Merge pull request #173 from onflow/license-view

License View with medias

.github/workflows/ci.yml

@@ -18,19 +18,12 @@ jobs:
           key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
           restore-keys: |
             ${{ runner.os }}-go-
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-          cache: 'npm'
-          cache-dependency-path: lib/js/test/package-lock.json
       - name: Install Flow CLI
         run: sh -ci "$(curl -fsSL https://raw.githubusercontent.com/onflow/flow-cli/master/install.sh)" -- v1.3.1
       - name: Flow CLI Version
         run: flow version
       - name: Update PATH
         run: echo "/root/.local/bin" >> $GITHUB_PATH
-      - name: Install dependencies
-        run: cd lib/js/test && npm ci
       - name: Run tests
         run: make ci
 

.github/workflows/release.yml

@@ -13,19 +13,4 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: 📚 checkout
-        uses: actions/checkout@v2.4.2
-      - name: 🟢 node
-        uses: actions/setup-node@v3.2.0
-        with:
-          node-version: 15
-          registry-url: https://registry.npmjs.org
-      - name: Install Dependencies
-        run: npm i
-      - name: Create Release Pull Request or Publish to npm
-        id: changesets
-        uses: changesets/action@v1
-        with:
-          publish: npm run release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        uses: actions/checkout@v2.4.2

Makefile

@@ -2,11 +2,9 @@
 test:
 	$(MAKE) generate -C lib/go
 	$(MAKE) test -C lib/go
-	$(MAKE) test -C lib/js/test
 	flow test --cover tests/test_example_nft.cdc
 
 .PHONY: ci
 ci:
 	$(MAKE) ci -C lib/go
-	$(MAKE) ci -C lib/js/test
 	flow test --cover tests/test_example_nft.cdc

contracts/ExampleNFT.cdc

@@ -78,7 +78,8 @@ pub contract ExampleNFT: NonFungibleToken, ViewResolver {
                 Type<MetadataViews.NFTCollectionData>(),
                 Type<MetadataViews.NFTCollectionDisplay>(),
                 Type<MetadataViews.Serial>(),
-                Type<MetadataViews.Traits>()
+                Type<MetadataViews.Traits>(),
+                Type<MetadataViews.NFTLicense>()
             ]
         }
 
@@ -159,7 +160,8 @@ pub contract ExampleNFT: NonFungibleToken, ViewResolver {
                     traitsView.addTrait(fooTrait)
 
                     return traitsView
-
+                case Type<MetadataViews.NFTLicense>():
+                    return MetadataViews.nlpUtil()
             }
             return nil
         }

contracts/MetadataViews.cdc

@@ -737,4 +737,194 @@ pub contract MetadataViews {
         return Traits(traits)
     }
 
+    /// A struct to expose license information according to https://forum.onflow.org/t/flow-nft-license-project/4716
+    /// By default, there are only 12 possible license combinations,
+    /// so these are enabled by the 12 utility methods below the struct definition
+    /// to allow easy construction of each possible combination
+    /// For a given NFT, returning a license view is as simple as
+    /// calling the method for the desired view, like so:
+    ///
+    /*   pub fun resolveView(_ view: Type): AnyStruct? {
+            switch view {
+                case Type<MetadataViews.NFTLicense>():
+                    return MetadataViews.nlpVoteCom()
+                case ...
+    */
+    ///
+    /// The first version of the NFT license standard is only deployed
+    /// with the license names and text descriptions. Projects must refer
+    /// to the proposal and license documentation for specific descriptions of
+    /// the rights that each license grants.
+    ///
+    pub struct NFTLicense {
+        /// Array of the specific license identifiers
+        pub let licenses: [String]
+
+        /// Link to a badge image that can be displayed alongside
+        /// the asset on a webpage for a visual representation of the license
+        pub var badgeLink: Media?
+
+        /// Link to a description of the specific rights that the license offers
+        pub var descriptionLink: Media?
+
+        /// Plain text description of the license
+        pub var description: String?
+
+        init() {
+            self.licenses = []
+            self.badgeLink = nil
+            self.descriptionLink = nil
+            self.description = nil
+        }
+
+        access(contract) fun setBadgeLink(link: Media) {
+            self.badgeLink = link
+        }
+
+        access(contract) fun setDescriptionLink(link: Media) {
+            self.descriptionLink = link
+        }
+
+        access(contract) fun setDescription(_ description: String) {
+            self.description = description
+        }
+
+        access(contract) fun personalUse(): NFTLicense {
+            self.licenses.append("NLP-PER")
+            return self
+        }
+
+        access(contract) fun votingRights(): NFTLicense {
+            self.licenses.append("NFL-VOTE")
+            return self
+        }
+
+        access(contract) fun commercialRights(): NFTLicense {
+            self.licenses.append("NFL-COM")
+            return self
+        }
+
+        access(contract) fun additionalContentExperienceRights(): NFTLicense {
+            self.licenses.append("NLP-ALP")
+            return self
+        }
+
+        access(contract) fun merchandisingRights(): NFTLicense {
+            self.licenses.append("NLP-MERCH")
+            return self
+        }
+
+        access(all) fun equals(_ otherLicense: NFTLicense): Bool {
+            if self.licenses == otherLicense.licenses {
+                return true
+            }
+            return false
+        }
+
+    }
+
+    pub fun nlpUtil(): NFTLicense {
+        let license = NFTLicense().personalUse().votingRights().additionalContentExperienceRights()
+        // license.setBadgeLink(link: Media(file: , mediaType: ))
+        // license.setDescriptionLink(link: Media(file: , mediaType: ))
+        license.setDescription("This license gives the buyer Personal Use Rights, Voting Rights, and ACE Rights")
+        return license
+    }
+
+    pub fun nlpVoteMerch(): NFTLicense {
+        let license = NFTLicense().personalUse().votingRights().merchandisingRights()
+        // license.setBadgeLink(link: Media(file: , mediaType: ))
+        // license.setDescriptionLink(link: Media(file: , mediaType: ))
+        license.setDescription("This license gives the buyer Personal Use Rights, Voting Rights, and Merch Rights")
+        return license
+    }
+
+    pub fun nlpVoteCom(): NFTLicense {
+        let license = NFTLicense().personalUse().votingRights().commercialRights()
+        // license.setBadgeLink(link: Media(file: , mediaType: ))
+        // license.setDescriptionLink(link: Media(file: , mediaType: ))
+        license.setDescription("This license gives the buyer Personal Use Rights, Voting Rights, and Comm Rights")
+        return license
+    }
+
+    pub fun nlpAceMerch(): NFTLicense {
+        let license = NFTLicense().personalUse().additionalContentExperienceRights().merchandisingRights()
+        // license.setBadgeLink(link: Media(file: , mediaType: ))
+        // license.setDescriptionLink(link: Media(file: , mediaType: ))
+        license.setDescription("This license gives the buyer Personal Use Rights, ACE Rights, and Merch Rights")
+        return license
+    }
+
+    pub fun nlpAceCom(): NFTLicense {
+        let license = NFTLicense().personalUse().additionalContentExperienceRights().commercialRights()
+        // license.setBadgeLink(link: Media(file: , mediaType: ))
+        // license.setDescriptionLink(link: Media(file: , mediaType: ))
+        license.setDescription("This license gives the buyer Personal Use Rights, ACE Rights, and Comm Rights")
+        return license
+    }
+
+    pub fun nlpUtilMerch(): NFTLicense {
+        let license = NFTLicense().personalUse().votingRights().additionalContentExperienceRights().merchandisingRights()
+        // license.setBadgeLink(link: Media(file: , mediaType: ))
+        // license.setDescriptionLink(link: Media(file: , mediaType: ))
+        license.setDescription("This license gives the buyer Personal Use Rights, Voting Rights, ACE Rights, and Merch Rights")
+        return license
+    }
+
+    pub fun nlpUtilCom(): NFTLicense {
+        let license = NFTLicense().personalUse().votingRights().additionalContentExperienceRights().commercialRights()
+        // license.setBadgeLink(link: Media(file: , mediaType: ))
+        // license.setDescriptionLink(link: Media(file: , mediaType: ))
+        license.setDescription("This license gives the buyer Personal Use Rights, Voting Rights, ACE Rights, and Comm Rights")
+        return license
+    }
+
+    pub fun nlpAce(): NFTLicense {
+        let license = NFTLicense().additionalContentExperienceRights()
+        // license.setBadgeLink(link: Media(file: , mediaType: ))
+        // license.setDescriptionLink(link: Media(file: , mediaType: ))
+        license.setDescription("This license gives the buyer ACE Rights")
+        return license
+    }
+
+    pub fun nlpPer(): NFTLicense {
+        let license = NFTLicense().personalUse()
+        // license.setBadgeLink(link: Media(file: , mediaType: ))
+        // license.setDescriptionLink(link: Media(file: , mediaType: ))
+        license.setDescription("This license gives the buyer Personal Use Rights")
+        return license
+    }
+
+    pub fun nlpVote(): NFTLicense {
+        let license = NFTLicense().votingRights()
+        // license.setBadgeLink(link: Media(file: , mediaType: ))
+        // license.setDescriptionLink(link: Media(file: , mediaType: ))
+        license.setDescription("This license gives the buyer Voting Rights")
+        return license
+    }
+
+    pub fun nlpCom(): NFTLicense {
+        let license = NFTLicense().commercialRights()
+        // license.setBadgeLink(link: Media(file: , mediaType: ))
+        // license.setDescriptionLink(link: Media(file: , mediaType: ))
+        license.setDescription("This license gives the buyer Comm Rights")
+        return license
+    }
+
+    pub fun nlpMerch(): NFTLicense {
+        let license = NFTLicense().merchandisingRights()
+        // license.setBadgeLink(link: Media(file: , mediaType: ))
+        // license.setDescriptionLink(link: Media(file: , mediaType: ))
+        license.setDescription("This license gives the buyer Merch Rights")
+        return license
+    }
+
+    pub fun getNFTLicense(_ viewResolver: &{Resolver}) : NFTLicense? {
+        if let view = viewResolver.resolveView(Type<NFTLicense>()) {
+            if let v = view as? NFTLicense {
+                return v
+            }
+        }
+        return nil
+    }
 }