@flowtyio/flow-contracts 0.1.3 → 0.1.5

package/contracts/flowty-drops/ContractManager.cdc

@@ -6,8 +6,13 @@ access(all) contract ContractManager {
     access(all) let StoragePath: StoragePath
     access(all) let PublicPath: PublicPath
 
+    access(all) let OwnerStoragePath: StoragePath
+    access(all) let OwnerPublicPath: PublicPath
+
     access(all) entitlement Manage
 
+    access(all) event ManagerSaved(uuid: UInt64, contractAddress: Address, ownerAddress: Address)
+
     access(all) resource Manager {
         access(self) let acct: Capability<auth(Storage, Contracts, Keys, Inbox, Capabilities) &Account>
         access(self) let routerCap: Capability<auth(FungibleTokenRouter.Owner) &FungibleTokenRouter.Router>
@@ -36,6 +41,26 @@ access(all) contract ContractManager {
             return getAccount(self.acct.address)
         }
 
+        // Should be called after saving a ContractManager resource to signal that a new address stores (and therefore "owns")
+        // this manager resource's acct capability. Without this, it is not possible to track the original creator of a contract
+        // when using the ContractManager
+        access(Manage) fun onSave() {
+            let acct = self.acct.borrow()!
+
+            acct.storage.load<Address>(from: ContractManager.OwnerStoragePath)
+            acct.storage.save(self.owner!.address, to: ContractManager.OwnerStoragePath)
+
+            if !acct.capabilities.get<&Address>(ContractManager.OwnerPublicPath).check() {
+                acct.capabilities.unpublish(ContractManager.OwnerPublicPath)
+                acct.capabilities.publish(
+                    acct.capabilities.storage.issue<&Address>(ContractManager.OwnerStoragePath),
+                    at: ContractManager.OwnerPublicPath
+                )
+            }
+
+            emit ManagerSaved(uuid: self.uuid, contractAddress: self.acct.address, ownerAddress: self.owner!.address)
+        }
+
         init(tokens: @FlowToken.Vault, defaultRouterAddress: Address) {
             pre {
                 tokens.balance >= 0.001: "minimum balance of 0.001 required for initialization"
@@ -69,5 +94,9 @@ access(all) contract ContractManager {
         let identifier = "ContractManager_".concat(self.account.address.toString())
         self.StoragePath = StoragePath(identifier: identifier)!
         self.PublicPath = PublicPath(identifier: identifier)!
+
+        let ownerIdentifier = "ContractManager_Owner_".concat(self.account.address.toString())
+        self.OwnerStoragePath = StoragePath(identifier: ownerIdentifier)!
+        self.OwnerPublicPath = PublicPath(identifier: ownerIdentifier)!
     }
 }

package/contracts/flowty-drops/DropFactory.cdc

@@ -35,7 +35,7 @@ access(all) contract DropFactory {
 
 
         let nftType = CompositeType(nftTypeIdentifier) ?? panic("invalid nft type identifier")
-        let dropDetails = FlowtyDrops.DropDetails(display: dropDisplay, medias: nil, commissionRate: 0.05, nftType: nftTypeIdentifier)
+        let dropDetails = FlowtyDrops.DropDetails(display: dropDisplay, medias: nil, commissionRate: 0.05, nftType: nftTypeIdentifier, paymentTokenTypes: {paymentTokenType.identifier: true})
         let drop <- FlowtyDrops.createDrop(details: dropDetails, minterCap: minterCap, phases: <- [<-phase])
 
         return <- drop
@@ -67,7 +67,7 @@ access(all) contract DropFactory {
         let phase <- FlowtyDrops.createPhase(details: phaseDetails)
 
         let nftType = CompositeType(nftTypeIdentifier) ?? panic("invalid nft type identifier")
-        let dropDetails = FlowtyDrops.DropDetails(display: dropDisplay, medias: nil, commissionRate: 0.05, nftType: nftTypeIdentifier)
+        let dropDetails = FlowtyDrops.DropDetails(display: dropDisplay, medias: nil, commissionRate: 0.05, nftType: nftTypeIdentifier, paymentTokenTypes: {paymentTokenType.identifier: true})
         let drop <- FlowtyDrops.createDrop(details: dropDetails, minterCap: minterCap, phases: <- [<-phase])
 
         return <- drop

package/contracts/flowty-drops/DropTypes.cdc

@@ -2,6 +2,7 @@ import "FlowtyDrops"
 import "MetadataViews"
 import "ViewResolver"
 import "AddressUtils"
+import "ContractManager"
 
 access(all) contract DropTypes {
     access(all) struct Display {
@@ -34,6 +35,8 @@ access(all) contract DropTypes {
         access(all) let minterCount: Int
         access(all) let commissionRate: UFix64
         access(all) let nftType: String
+        access(all) let creator: Address?
+        access(all) let paymentTokenTypes: {String: Bool}
 
         access(all) let address: Address?
         access(all) let mintedByAddress: Int?
@@ -55,10 +58,13 @@ access(all) contract DropTypes {
             nftType: Type,
             address: Address?,
             phases: [PhaseSummary],
-            royaltyRate: UFix64
+            royaltyRate: UFix64,
+            creator: Address?,
+            paymentTokenTypes: {String: Bool}
         ) {
             self.id = id
             self.display = Display(display)
+            self.creator = creator
             
             self.medias = []
             for m in medias?.items ?? [] {
@@ -78,6 +84,7 @@ access(all) contract DropTypes {
             self.blockHeight = b.height
             self.blockTimestamp = UInt64(b.timestamp)
             self.royaltyRate = royaltyRate
+            self.paymentTokenTypes = paymentTokenTypes
         }
     }
 
@@ -114,7 +121,7 @@ access(all) contract DropTypes {
         access(all) let remainingForAddress: Int?
         access(all) let maxPerMint: Int?
 
-        access(all) let quote: Quote?
+        access(all) let quotes: {String: Quote}
 
         init(
             index: Int,
@@ -123,7 +130,7 @@ access(all) contract DropTypes {
             totalMinted: Int?,
             minter: Address?,
             quantity: Int?,
-            paymentIdentifier: String?
+            paymentIdentifiers: [String]
         ) {
             self.index = index
             self.id = phase.uuid
@@ -151,24 +158,24 @@ access(all) contract DropTypes {
                 self.remainingForAddress = nil
             }
 
-            self.maxPerMint = d.addressVerifier.getMaxPerMint(addr: self.address, totalMinted: totalMinted ?? 0, data: {} as {String: AnyStruct})
+            self.maxPerMint = d.addressVerifier.getMaxPerMint(addr: self.address, totalMinted: totalMinted ?? 0, data: {})
+            self.quotes = {}
 
-            if paymentIdentifier != nil && quantity != nil {
-                let price = d.pricer.getPrice(num: quantity!, paymentTokenType: CompositeType(paymentIdentifier!)!, minter: minter)
-
-                self.quote = Quote(price: price, quantity: quantity!, paymentIdentifier: paymentIdentifier!, minter: minter)
-            } else {
-                self.quote = nil
+            for paymentIdentifier in paymentIdentifiers {
+                let price = d.pricer.getPrice(num: quantity!, paymentTokenType: CompositeType(paymentIdentifier)!, minter: minter)
+                self.quotes[paymentIdentifier] = Quote(price: price, quantity: quantity!, paymentIdentifier: paymentIdentifier, minter: minter)
             }
         }
     }
 
-    access(all) fun getDropSummary(nftTypeIdentifier: String, dropID: UInt64, minter: Address?, quantity: Int?, paymentIdentifier: String?): DropSummary? {
+    access(all) fun getDropSummary(nftTypeIdentifier: String, dropID: UInt64, minter: Address?, quantity: Int?, paymentIdentifiers: [String]): DropSummary? {
         let nftType = CompositeType(nftTypeIdentifier) ?? panic("invalid nft type identifier")
         let segments = nftTypeIdentifier.split(separator: ".")
         let contractAddress = AddressUtils.parseAddress(nftType)!
         let contractName = segments[2]
 
+        let creator = self.getCreatorAddress(contractAddress)
+
         let resolver = getAccount(contractAddress).contracts.borrow<&{ViewResolver}>(name: contractName)
         if resolver == nil {
             return nil
@@ -200,7 +207,7 @@ access(all) contract DropTypes {
                 totalMinted: minter != nil ? dropDetails.minters[minter!] : nil,
                 minter: minter,
                 quantity: quantity,
-                paymentIdentifier: paymentIdentifier
+                paymentIdentifiers: paymentIdentifiers.length > 0 ? paymentIdentifiers : dropDetails.paymentTokenTypes.keys
             )
             phaseSummaries.append(summary)
         }
@@ -224,17 +231,21 @@ access(all) contract DropTypes {
             nftType: CompositeType(dropDetails.nftType)!,
             address: minter,
             phases: phaseSummaries,
-            royaltyRate: royaltyRate
+            royaltyRate: royaltyRate,
+            creator: creator,
+            paymentTokenTypes: dropDetails.paymentTokenTypes
         )
 
         return dropSummary
     }
 
-    access(all) fun getAllDropSummaries(nftTypeIdentifier: String, minter: Address?, quantity: Int?, paymentIdentifier: String?): [DropSummary] {
+    access(all) fun getAllDropSummaries(nftTypeIdentifier: String, minter: Address?, quantity: Int?, paymentIdentifiers: [String]): [DropSummary] {
         let nftType = CompositeType(nftTypeIdentifier) ?? panic("invalid nft type identifier")
         let segments = nftTypeIdentifier.split(separator: ".")
         let contractAddress = AddressUtils.parseAddress(nftType)!
         let contractName = segments[2]
+
+        let creator = self.getCreatorAddress(contractAddress)
         
         let resolver = getAccount(contractAddress).contracts.borrow<&{ViewResolver}>(name: contractName)
         if resolver == nil {
@@ -269,7 +280,7 @@ access(all) contract DropTypes {
                     totalMinted: minter != nil ? dropDetails.minters[minter!] : nil,
                     minter: minter,
                     quantity: quantity,
-                    paymentIdentifier: paymentIdentifier
+                    paymentIdentifiers: paymentIdentifiers.length > 0 ? paymentIdentifiers : dropDetails.paymentTokenTypes.keys
                 )
                 phaseSummaries.append(summary)
             }
@@ -297,10 +308,38 @@ access(all) contract DropTypes {
                 nftType: CompositeType(dropDetails.nftType)!,
                 address: minter,
                 phases: phaseSummaries,
-                royaltyRate: royaltyRate
+                royaltyRate: royaltyRate,
+                creator: creator,
+                paymentTokenTypes: dropDetails.paymentTokenTypes
             ))
         }
 
         return summaries
     }
+
+    access(all) fun getCreatorAddress(_ contractAddress: Address): Address? {
+        // We look for a two-way relationship between creator and collection. A contract can expose an address at ContractManager.OwnerPublicPath
+        // specifying the owning account. If found, we will check that same account for a &ContractManager.Manager resource at ContractManager.PublicPath,
+        // which, when borrowed, can return its underlying account address using &Manager.getAccount().
+        //
+        // If the addresses match, we consider this account to be the creator of a drop
+        let tmp = getAccount(contractAddress).capabilities.borrow<&Address>(ContractManager.OwnerPublicPath)
+        if tmp == nil {
+            return nil
+        }
+
+        let creator = *(tmp!)
+        let manager = getAccount(creator).capabilities.borrow<&ContractManager.Manager>(ContractManager.PublicPath)
+        if manager == nil {
+            return nil
+        }
+
+        let contractManagerAccount = manager!.getAccount()
+
+        if contractManagerAccount.address != contractAddress {
+            return nil
+        }
+ 
+        return creator
+    }
 }

package/contracts/flowty-drops/FlowtyDrops.cdc

@@ -5,12 +5,19 @@ import "AddressUtils"
 import "FungibleTokenMetadataViews"
 import "FungibleTokenRouter"
 
+// FlowtyDrops is a contract to help collections manage their primary sale needs on flow.
+// Multiple drops can be made for a single contract (like how TopShot has had lots of pack drops),
+// and can be split into phases to represent different behaviors over the course of a drop
 access(all) contract FlowtyDrops {
+    // The total number of nfts minted by this contract
+    access(all) var TotalMinted: UInt64
+
     access(all) let ContainerStoragePath: StoragePath
     access(all) let ContainerPublicPath: PublicPath
 
     access(all) event DropAdded(address: Address, id: UInt64, name: String, description: String, imageUrl: String, start: UInt64?, end: UInt64?, nftType: String)
-    access(all) event Minted(address: Address, dropID: UInt64, phaseID: UInt64, nftID: UInt64, nftType: String)
+    access(all) event DropRemoved(address: Address, id: UInt64)
+    access(all) event Minted(address: Address, dropID: UInt64, phaseID: UInt64, nftID: UInt64, nftType: String, totalMinted: UInt64)
     access(all) event PhaseAdded(dropID: UInt64, dropAddress: Address, id: UInt64, index: Int, activeCheckerType: String, pricerType: String, addressVerifierType: String)
     access(all) event PhaseRemoved(dropID: UInt64, dropAddress: Address, id: UInt64)
 
@@ -20,9 +27,9 @@ access(all) contract FlowtyDrops {
     // Interface to expose all the components necessary to participate in a drop
     // and to ask questions about a drop.
     access(all) resource interface DropPublic {
-        access(all) fun borrowPhasePublic(index: Int): &{PhasePublic}
-        access(all) fun borrowActivePhases(): [&{PhasePublic}]
-        access(all) fun borrowAllPhases(): [&{PhasePublic}]
+        access(all) view fun borrowPhasePublic(index: Int): &{PhasePublic}
+        access(all) view fun borrowActivePhases(): [&{PhasePublic}]
+        access(all) view fun borrowAllPhases(): [&{PhasePublic}]
         access(all) fun mint(
             payment: @{FungibleToken.Vault},
             amount: Int,
@@ -31,8 +38,18 @@ access(all) contract FlowtyDrops {
             receiverCap: Capability<&{NonFungibleToken.CollectionPublic}>,
             commissionReceiver: Capability<&{FungibleToken.Receiver}>?,
             data: {String: AnyStruct}
-        ): @{FungibleToken.Vault}
-        access(all) fun getDetails(): DropDetails
+        ): @{FungibleToken.Vault} {
+            pre {
+                self.getDetails().paymentTokenTypes[payment.getType().identifier] == true: "unsupported payment token type"
+                receiverCap.check(): "unvalid nft receiver capability"
+                commissionReceiver == nil || commissionReceiver!.check(): "commission receiver must be nil or a valid capability"
+                self.getType() == Type<@Drop>(): "unsupported type implementing DropPublic"
+                expectedType.isSubtype(of: Type<@{NonFungibleToken.NFT}>()): "expected type must be an NFT"
+                expectedType.identifier == self.getDetails().nftType: "expected type does not match drop details type"
+                receiverCap.check(): "receiver capability is not valid"
+            }
+        }
+        access(all) view fun getDetails(): DropDetails
     }
 
     // A phase represents a stage of a drop. Some drops will only have one
@@ -47,23 +64,23 @@ access(all) contract FlowtyDrops {
         access(all) let resources: @{String: AnyResource}
 
         // returns whether this phase of a drop has started.
-        access(all) fun isActive(): Bool {
+        access(all) view fun isActive(): Bool {
             return self.details.activeChecker.hasStarted() && !self.details.activeChecker.hasEnded()
         }
 
-        access(all) fun getDetails(): PhaseDetails {
+        access(all) view fun getDetails(): PhaseDetails {
             return self.details
         }
 
-        access(EditPhase) fun borrowActiveCheckerAuth(): auth(Mutate) &{ActiveChecker} {
+        access(EditPhase) view fun borrowActiveCheckerAuth(): auth(Mutate) &{ActiveChecker} {
             return &self.details.activeChecker
         }
 
-        access(EditPhase) fun borrowPricerAuth(): auth(Mutate) &{Pricer} {
+        access(EditPhase) view fun borrowPricerAuth(): auth(Mutate) &{Pricer} {
             return &self.details.pricer
         }
 
-        access(EditPhase) fun borrowAddressVerifierAuth(): auth(Mutate) &{AddressVerifier} {
+        access(EditPhase) view fun borrowAddressVerifierAuth(): auth(Mutate) &{AddressVerifier} {
             return &self.details.addressVerifier
         }
 
@@ -75,6 +92,8 @@ access(all) contract FlowtyDrops {
         }
     }
 
+    // The primary resource of this contract. A drop has some top-level details, and some phase-specific details which are encapsulated
+    // by each phase.
     access(all) resource Drop: DropPublic {
         access(all) event ResourceDestroyed(
             uuid: UInt64 = self.uuid,
@@ -87,8 +106,11 @@ access(all) contract FlowtyDrops {
         access(self) let phases: @[Phase]
         // the details of a drop. This includes things like display information and total number of mints
         access(self) let details: DropDetails
+        // capability to mint nfts with. Regardless of where a drop is hosted, the minter itself is what is responsible for creating nfts
+        // and is used by the drop's mint method.
         access(self) let minterCap: Capability<&{Minter}>
 
+        // general-purpose property bags which are needed to ensure extensibility of this resource
         access(all) let data: {String: AnyStruct}
         access(all) let resources: @{String: AnyResource}
 
@@ -102,10 +124,7 @@ access(all) contract FlowtyDrops {
             data: {String: AnyStruct}
         ): @{FungibleToken.Vault} {
             pre {
-                expectedType.isSubtype(of: Type<@{NonFungibleToken.NFT}>()): "expected type must be an NFT"
-                expectedType.identifier == self.details.nftType: "expected type does not match drop details type"
                 self.phases.length > phaseIndex: "phase index is too high"
-                receiverCap.check(): "receiver capability is not valid"
             }
 
             // validate the payment vault amount and type
@@ -116,6 +135,7 @@ access(all) contract FlowtyDrops {
             )
 
             let paymentAmount = phase.details.pricer.getPrice(num: amount, paymentTokenType: payment.getType(), minter: receiverCap.address)
+            assert(payment.balance >= paymentAmount, message: "payment balance is lower than payment amount")
             let withdrawn <- payment.withdraw(amount: paymentAmount) // make sure that we have a fresh vault resource
 
             // take commission
@@ -124,13 +144,14 @@ access(all) contract FlowtyDrops {
                 commissionReceiver!.borrow()!.deposit(from: <-commission)
             }
 
-            assert(phase.details.pricer.getPrice(num: amount, paymentTokenType: withdrawn.getType(), minter: receiverCap.address) * (1.0 - self.details.commissionRate) == withdrawn.balance, message: "incorrect payment amount")
+            // The balance of the payment sent to the creator is equal to the paymentAmount - fees
+            assert(paymentAmount * (1.0 - self.details.commissionRate) == withdrawn.balance, message: "incorrect payment amount")
             assert(phase.details.pricer.getPaymentTypes().contains(withdrawn.getType()), message: "unsupported payment type")
+            assert(phase.details.activeChecker.hasStarted() && !phase.details.activeChecker.hasEnded(), message: "phase is not active")
 
             // mint the nfts
             let minter = self.minterCap.borrow() ?? panic("minter capability could not be borrowed")
             let mintedNFTs: @[{NonFungibleToken.NFT}] <- minter.mint(payment: <-withdrawn, amount: amount, phase: phase, data: data)
-            assert(phase.details.activeChecker.hasStarted() && !phase.details.activeChecker.hasEnded(), message: "phase is not active")
             assert(mintedNFTs.length == amount, message: "incorrect number of items returned")
 
             // distribute to receiver
@@ -141,7 +162,8 @@ access(all) contract FlowtyDrops {
                 let nft <- mintedNFTs.removeFirst()
 
                 let nftType = nft.getType()
-                emit Minted(address: receiverCap.address, dropID: self.uuid, phaseID: phase.uuid, nftID: nft.id, nftType: nftType.identifier)
+                FlowtyDrops.TotalMinted = FlowtyDrops.TotalMinted + 1
+                emit Minted(address: receiverCap.address, dropID: self.uuid, phaseID: phase.uuid, nftID: nft.id, nftType: nftType.identifier, totalMinted: FlowtyDrops.TotalMinted)
 
                 // validate that every nft is the right type
                 assert(nftType == expectedType, message: "unexpected nft type was minted")
@@ -156,23 +178,23 @@ access(all) contract FlowtyDrops {
             return <- payment
         }
 
-        access(Owner) fun borrowPhase(index: Int): auth(EditPhase) &Phase {
+        access(Owner) view fun borrowPhase(index: Int): auth(EditPhase) &Phase {
             return &self.phases[index]
         }
 
 
-        access(all) fun borrowPhasePublic(index: Int): &{PhasePublic} {
+        access(all) view fun borrowPhasePublic(index: Int): &{PhasePublic} {
             return &self.phases[index]
         }
 
-        access(all) fun borrowActivePhases(): [&{PhasePublic}] {
-            let arr: [&{PhasePublic}] = []
+        access(all) view fun borrowActivePhases(): [&{PhasePublic}] {
+            var arr: [&{PhasePublic}] = []
             var count = 0
             while count < self.phases.length {
                 let ref = self.borrowPhasePublic(index: count)
                 let activeChecker = ref.getDetails().activeChecker
                 if activeChecker.hasStarted() && !activeChecker.hasEnded() {
-                    arr.append(ref)
+                    arr = arr.concat([ref])
                 }
 
                 count = count + 1
@@ -181,12 +203,12 @@ access(all) contract FlowtyDrops {
             return arr
         }
 
-        access(all) fun borrowAllPhases(): [&{PhasePublic}] {
-            let arr: [&{PhasePublic}] = []
+        access(all) view fun borrowAllPhases(): [&{PhasePublic}] {
+            var arr: [&{PhasePublic}] = []
             var index = 0
             while index < self.phases.length {
                 let ref = self.borrowPhasePublic(index: index)
-                arr.append(ref)
+                arr = arr.concat([ref])
                 index = index + 1
             }
 
@@ -217,7 +239,7 @@ access(all) contract FlowtyDrops {
             return <- phase
         }
 
-        access(all) fun getDetails(): DropDetails {
+        access(all) view fun getDetails(): DropDetails {
             return self.details
         }
 
@@ -242,6 +264,7 @@ access(all) contract FlowtyDrops {
         access(all) var minters: {Address: Int}
         access(all) let commissionRate: UFix64
         access(all) let nftType: String
+        access(all) let paymentTokenTypes: {String: Bool}
 
         access(all) let data: {String: AnyStruct}
 
@@ -254,7 +277,7 @@ access(all) contract FlowtyDrops {
             self.minters[addr] = self.minters[addr]! + num
         }
 
-        init(display: MetadataViews.Display, medias: MetadataViews.Medias?, commissionRate: UFix64, nftType: String) {
+        init(display: MetadataViews.Display, medias: MetadataViews.Medias?, commissionRate: UFix64, nftType: String, paymentTokenTypes: {String: Bool}) {
             pre {
                 nftType != "": "nftType should be a composite type identifier"
             }
@@ -265,6 +288,8 @@ access(all) contract FlowtyDrops {
             self.commissionRate = commissionRate
             self.minters = {}
             self.nftType = nftType
+            self.paymentTokenTypes = paymentTokenTypes
+
             self.data = {}
         }
     }
@@ -289,8 +314,8 @@ access(all) contract FlowtyDrops {
         // - How many items are left in the current phase?
         // - Can Address x mint on a phase?
         // - What is the cost to mint for the phase I am interested in (for address x)?
-        access(all) fun getDetails(): PhaseDetails
-        access(all) fun isActive(): Bool
+        access(all) view fun getDetails(): PhaseDetails
+        access(all) view fun isActive(): Bool
     }
 
     access(all) struct PhaseDetails {
@@ -319,6 +344,7 @@ access(all) contract FlowtyDrops {
         }
     }
 
+    // The AddressVerifier interface is responsible for determining whether an address is permitted to mint or not
     access(all) struct interface AddressVerifier {
         access(all) fun canMint(addr: Address, num: Int, totalMinted: Int, data: {String: AnyStruct}): Bool {
             return true
@@ -333,12 +359,15 @@ access(all) contract FlowtyDrops {
         }
     }
 
+    // The pricer interface is responsible for the cost of a mint. It can vary by phase
     access(all) struct interface Pricer {
         access(all) fun getPrice(num: Int, paymentTokenType: Type, minter: Address?): UFix64
         access(all) fun getPaymentTypes(): [Type]
     }
 
     access(all) resource interface Minter {
+        // mint is only able to be called either by this contract (FlowtyDrops) or the implementing contract.
+        // In its default implementation, it is assumed that the receiver capability for payment is the FungibleTokenRouter
         access(contract) fun mint(payment: @{FungibleToken.Vault}, amount: Int, phase: &FlowtyDrops.Phase, data: {String: AnyStruct}): @[{NonFungibleToken.NFT}] {
             let resourceAddress = AddressUtils.parseAddress(self.getType())!
             let receiver = getAccount(resourceAddress).capabilities.get<&{FungibleToken.Receiver}>(FungibleTokenRouter.PublicPath).borrow()
@@ -356,9 +385,11 @@ access(all) contract FlowtyDrops {
             return <- nfts
         }
 
+        // required so that the minter interface has a way to create NFTs on its implementing resource
         access(contract) fun createNextNFT(): @{NonFungibleToken.NFT}
     }
     
+    // Struct to wrap obtaining a Drop container. Intended for use with the ViewResolver contract interface
     access(all) struct DropResolver {
         access(self) let cap: Capability<&{ContainerPublic}>
 
@@ -380,7 +411,7 @@ access(all) contract FlowtyDrops {
         access(all) fun getIDs(): [UInt64]
     }
 
-    // Contains drops. 
+    // Container holds drops so that one address can host more than one drop at once
     access(all) resource Container: ContainerPublic {
         access(self) let drops: @{UInt64: Drop}
 
@@ -413,6 +444,7 @@ access(all) contract FlowtyDrops {
                 self.drops.containsKey(id): "drop was not found"
             }
 
+            emit DropRemoved(address: self.owner!.address, id: id)
             return <- self.drops.remove(key: id)!
         }
 
@@ -461,5 +493,7 @@ access(all) contract FlowtyDrops {
 
         self.ContainerStoragePath = StoragePath(identifier: containerIdentifier)!
         self.ContainerPublicPath = PublicPath(identifier: containerIdentifier)!
+
+        self.TotalMinted = 0
     }
 }

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

@@ -40,7 +40,14 @@ access(all) contract interface BaseNFT: ViewResolver {
             ]
         }
 
+        // In case the implementor of `NFT` wants to override resolved views,
+        // the actual logic to perform view resolution is done in another method,
+        // with this one calling directly into it.
         access(all) fun resolveView(_ view: Type): AnyStruct? {
+            return self._resolveView(view)
+        }
+
+        access(all) fun _resolveView(_ view: Type): AnyStruct? {
             if view == Type<MetadataViews.Serial>() {
                 return MetadataViews.Serial(self.id)
             }

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

@@ -94,6 +94,7 @@ access(all) contract NFTMetadata {
         access(Owner) fun addMetadata(id: UInt64, data: Metadata) {
             pre {
                 self.metadata[id] == nil: "id already has metadata assigned"
+                !self.frozen: "metadata is frozen and cannot be updated"
             }
 
             self.metadata[id] = data

package/flow.json

@@ -359,7 +359,7 @@
       "source": "./contracts/flowty-drops/ContractManager.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -367,7 +367,7 @@
       "source": "./contracts/flowty-drops/initializers/ContractInitializer.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -375,7 +375,7 @@
       "source": "./contracts/flowty-drops/initializers/ContractBorrower.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -383,7 +383,7 @@
       "source": "./contracts/flowty-drops/initializers/OpenEditionInitializer.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -391,7 +391,7 @@
       "source": "./contracts/flowty-drops/nft/BaseCollection.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -399,7 +399,7 @@
       "source": "./contracts/flowty-drops/nft/ContractFactoryTemplate.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -407,7 +407,7 @@
       "source": "./contracts/flowty-drops/nft/ContractFactory.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -415,7 +415,7 @@
       "source": "./contracts/flowty-drops/nft/OpenEditionTemplate.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -423,7 +423,7 @@
       "source": "./contracts/flowty-drops/nft/UniversalCollection.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -431,7 +431,7 @@
       "source": "./contracts/flowty-drops/nft/BaseNFT.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -439,7 +439,7 @@
       "source": "./contracts/flowty-drops/nft/NFTMetadata.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -447,7 +447,7 @@
       "source": "./contracts/flowty-drops/FlowtyDrops.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -455,7 +455,7 @@
       "source": "./contracts/flowty-drops/DropFactory.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -463,7 +463,7 @@
       "source": "./contracts/flowty-drops/FlowtyActiveCheckers.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -471,7 +471,7 @@
       "source": "./contracts/flowty-drops/FlowtyPricers.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -479,7 +479,7 @@
       "source": "./contracts/flowty-drops/FlowtyAddressVerifiers.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x772a10c786851a1b",
+        "testnet": "0x5d06d5357cdf8063",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },
@@ -487,7 +487,7 @@
       "source": "./contracts/flowty-drops/DropTypes.cdc",
       "aliases": {
         "testing": "0x0000000000000006",
-        "testnet": "0x22f23883bf122007",
+        "testnet": "0xa8d83f18fd8ba80a",
         "emulator": "0xf8d6e0586b0a20c7"
       }
     },

package/package.json

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