@flowtyio/flow-contracts 0.1.1 → 0.1.2

package/contracts/flowty-drops/DropTypes.cdc

@@ -42,6 +42,7 @@ access(all) contract DropTypes {
 
         access(all) let blockTimestamp: UInt64
         access(all) let blockHeight: UInt64
+        access(all) let royaltyRate: UFix64
 
         init(
             id: UInt64,
@@ -53,7 +54,8 @@ access(all) contract DropTypes {
             commissionRate: UFix64,
             nftType: Type,
             address: Address?,
-            phases: [PhaseSummary]
+            phases: [PhaseSummary],
+            royaltyRate: UFix64
         ) {
             self.id = id
             self.display = Display(display)
@@ -75,6 +77,7 @@ access(all) contract DropTypes {
             let b = getCurrentBlock()
             self.blockHeight = b.height
             self.blockTimestamp = UInt64(b.timestamp)
+            self.royaltyRate = royaltyRate
         }
     }
 
@@ -109,6 +112,7 @@ access(all) contract DropTypes {
         
         access(all) let address: Address?
         access(all) let remainingForAddress: Int?
+        access(all) let maxPerMint: Int?
 
         access(all) let quote: Quote?
 
@@ -147,6 +151,8 @@ access(all) contract DropTypes {
                 self.remainingForAddress = nil
             }
 
+            self.maxPerMint = d.addressVerifier.getMaxPerMint(addr: self.address, totalMinted: totalMinted ?? 0, data: {} as {String: AnyStruct})
+
             if paymentIdentifier != nil && quantity != nil {
                 let price = d.pricer.getPrice(num: quantity!, paymentTokenType: CompositeType(paymentIdentifier!)!, minter: minter)
 
@@ -199,6 +205,14 @@ access(all) contract DropTypes {
             phaseSummaries.append(summary)
         }
 
+        var royaltyRate = 0.0
+        if let tmpRoyalties = resolver!.resolveContractView(resourceType: nftType, viewType: Type<MetadataViews.Royalties>()) {
+            let royalties = tmpRoyalties as! MetadataViews.Royalties
+            for r in royalties.getRoyalties() {
+                royaltyRate = royaltyRate + r.cut
+            }
+        }
+
         let dropSummary = DropSummary(
             id: drop!.uuid,
             display: dropDetails.display,
@@ -209,7 +223,8 @@ access(all) contract DropTypes {
             commissionRate: dropDetails.commissionRate,
             nftType: CompositeType(dropDetails.nftType)!,
             address: minter,
-            phases: phaseSummaries
+            phases: phaseSummaries,
+            royaltyRate: royaltyRate
         )
 
         return dropSummary
@@ -263,6 +278,14 @@ access(all) contract DropTypes {
                 continue
             }
 
+            var royaltyRate = 0.0
+            if let tmpRoyalties = resolver!.resolveContractView(resourceType: nftType, viewType: Type<MetadataViews.Royalties>()) {
+                let royalties = tmpRoyalties as! MetadataViews.Royalties
+                for r in royalties.getRoyalties() {
+                    royaltyRate = royaltyRate + r.cut
+                }
+            }
+
             summaries.append(DropSummary(
                 id: drop!.uuid,
                 display: dropDetails.display,
@@ -273,7 +296,8 @@ access(all) contract DropTypes {
                 commissionRate: dropDetails.commissionRate,
                 nftType: CompositeType(dropDetails.nftType)!,
                 address: minter,
-                phases: phaseSummaries
+                phases: phaseSummaries,
+                royaltyRate: royaltyRate
             ))
         }
 

package/contracts/flowty-drops/FlowtyAddressVerifiers.cdc

@@ -14,6 +14,10 @@ access(all) contract FlowtyAddressVerifiers {
             return num <= self.maxPerMint
         }
 
+        access(all) view fun getMaxPerMint(addr: Address?, totalMinted: Int, data: {String: AnyStruct}): Int? {
+            return self.maxPerMint
+        }
+
         access(Mutate) fun setMaxPerMint(_ value: Int) {
             self.maxPerMint = value
         }
@@ -49,6 +53,10 @@ access(all) contract FlowtyAddressVerifiers {
             return nil
         }
 
+        access(all) view fun getMaxPerMint(addr: Address?, totalMinted: Int, data: {String: AnyStruct}): Int? {
+            return addr != nil ? self.remainingForAddress(addr: addr!, totalMinted: totalMinted) : nil
+        }
+
         access(Mutate) fun setAddress(addr: Address, value: Int) {
             self.allowedAddresses[addr] = value
         }

package/contracts/flowty-drops/FlowtyDrops.cdc

@@ -327,6 +327,10 @@ access(all) contract FlowtyDrops {
         access(all) fun remainingForAddress(addr: Address, totalMinted: Int): Int? {
             return nil
         }
+
+        access(all) view fun getMaxPerMint(addr: Address?, totalMinted: Int, data: {String: AnyStruct}): Int? {
+            return nil
+        }
     }
 
     access(all) struct interface Pricer {

package/contracts/flowty-drops/initializers/OpenEditionInitializer.cdc

@@ -52,6 +52,9 @@ access(all) contract OpenEditionInitializer: ContractInitializer {
             container.addDrop(<- drop)
         }
         
-        return NFTMetadata.initialize(acct: contractAcct, collectionInfo: collectionInfo, nftType: nftType)
+        let caps = NFTMetadata.initialize(acct: contractAcct, collectionInfo: collectionInfo, nftType: nftType)
+        caps.ownerCap.borrow()!.addMetadata(id: 0, data: data)
+
+        return caps
     }
 }

package/contracts/flowty-drops/nft/BaseCollection.cdc

@@ -23,7 +23,7 @@ access(all) contract interface BaseCollection: ViewResolver {
                 token.getType() == self.nftType: "unexpected nft type being deposited"
             }
 
-            destroy self.ownedNFTs.insert(key: token.uuid, <-token)
+            destroy self.ownedNFTs.insert(key: token.id, <-token)
         }
 
         access(all) view fun borrowNFT(_ id: UInt64): &{NonFungibleToken.NFT}? {
@@ -80,18 +80,29 @@ access(all) contract interface BaseCollection: ViewResolver {
                         return <- c.createEmptyCollection(nftType: rt)
                     }
                 )
-            case Type<MetadataViews.NFTCollectionDisplay>():
-                let c = getAccount(addr).contracts.borrow<&{BaseCollection}>(name: segments[2])!
-                let tmp = c.MetadataCap.borrow()
-                if tmp == nil {
-                    return nil
-                }
-
-                return tmp!.collectionInfo.getDisplay()
             case Type<FlowtyDrops.DropResolver>():
                 return FlowtyDrops.DropResolver(cap: acct.capabilities.get<&{FlowtyDrops.ContainerPublic}>(FlowtyDrops.ContainerPublicPath))
         }
 
+        // These views require the {BaseCollection} interface
+        if let c = getAccount(addr).contracts.borrow<&{BaseCollection}>(name: segments[2]) {
+            let tmp = c.MetadataCap.borrow()
+            if tmp == nil {
+                return nil
+            }
+
+            switch viewType {
+                case Type<MetadataViews.NFTCollectionDisplay>():
+                    return tmp!.collectionInfo.getDisplay()
+                case Type<MetadataViews.Royalties>():
+                    let keys = tmp!.metadata.keys
+                    if keys.length == 0 || keys.length > 1 {
+                        return nil
+                    }
+                    return tmp!.borrowMetadata(id: keys[0])!.getRoyalties()
+            }
+        }
+
         return nil
     }
 }

package/contracts/flowty-drops/nft/BaseNFT.cdc

@@ -42,7 +42,7 @@ access(all) contract interface BaseNFT: ViewResolver {
 
         access(all) fun resolveView(_ view: Type): AnyStruct? {
             if view == Type<MetadataViews.Serial>() {
-                return self.id
+                return MetadataViews.Serial(self.id)
             }
 
             let rt = self.getType()
@@ -75,25 +75,27 @@ access(all) contract interface BaseNFT: ViewResolver {
                         }
                     )
                 case Type<MetadataViews.NFTCollectionDisplay>():
-                    return md.collectionInfo.collectionDisplay
+                    return md.collectionInfo.getDisplay()
             }
 
             if let entry = md.borrowMetadata(id: self.metadataID) {
                 switch view {
                     case Type<MetadataViews.Traits>():
-                        return entry.traits
+                        return entry.getTraits()
                     case Type<MetadataViews.Editions>():
-                        return entry.editions
+                        return entry.getEditions()
                     case Type<MetadataViews.Display>():
                         let num = (entry.editions?.infoList?.length ?? 0) > 0 ? entry.editions!.infoList[0].number : self.id
 
                         return MetadataViews.Display(
                             name: entry.name.concat(" #").concat(num.toString()),
                             description: entry.description,
-                            thumbnail: NFTMetadata.UriFile(entry.thumbnail.uri())
+                            thumbnail: entry.getThumbnail()
                         )
                     case Type<MetadataViews.ExternalURL>():
-                        return entry.externalURL
+                        return entry.getExternalURL()
+                    case Type<MetadataViews.Royalties>():
+                        return entry.getRoyalties()
                 }
             }
 

package/contracts/flowty-drops/nft/NFTMetadata.cdc

@@ -36,6 +36,26 @@ access(all) contract NFTMetadata {
 
         access(all) let data: {String: AnyStruct}
 
+        access(all) fun getThumbnail(): {MetadataViews.File} {
+            return self.thumbnail
+        }
+
+        access(all) fun getTraits(): MetadataViews.Traits? {
+            return self.traits
+        }
+
+        access(all) fun getEditions(): MetadataViews.Editions? {
+            return self.editions
+        }
+
+        access(all) fun getExternalURL(): MetadataViews.ExternalURL? {
+            return self.externalURL
+        }
+
+        access(all) fun getRoyalties(): MetadataViews.Royalties? {
+            return self.royalties
+        }
+
         init(
             name: String,
             description: String,

package/contracts/flowty-drops/nft/UniversalCollection.cdc

@@ -14,6 +14,22 @@ access(all) contract UniversalCollection {
             return <- create Collection(nftType: self.nftType)
         }
 
+        access(all) fun deposit(token: @{NonFungibleToken.NFT}) {
+            pre {
+                token.getType() == self.nftType: "unexpected nft type being deposited"
+            }
+
+            destroy self.ownedNFTs.insert(key: token.id, <-token)
+        }
+
+        access(all) view fun borrowNFT(_ id: UInt64): &{NonFungibleToken.NFT}? {
+            return &self.ownedNFTs[id]
+        }
+
+        access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
+            return <- self.ownedNFTs.remove(key: withdrawID)!
+        }
+
         init (nftType: Type) {
             self.ownedNFTs <- {}
             self.nftType = nftType

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flowtyio/flow-contracts",
-    "version": "0.1.1",
+    "version": "0.1.2",
     "main": "index.json",
     "description": "An NPM package for common flow contracts",
     "author": "flowtyio",