@flowtyio/flow-contracts 0.1.4 → 0.1.6

package/contracts/example/ExampleToken.cdc

@@ -1,10 +1,8 @@
 import "FungibleToken"
-import "FungibleTokenMetadataViews"
 import "MetadataViews"
+import "FungibleTokenMetadataViews"
 
-
-// THIS CONTRACT IS FOR TESTING PURPOSES ONLY!
-access(all) contract ExampleToken {
+access(all) contract ExampleToken: FungibleToken {
 
     /// Total supply of ExampleTokens in existence
     access(all) var totalSupply: UFix64
@@ -66,32 +64,36 @@ access(all) contract ExampleToken {
             self.balance = balance
         }
 
-        access(all) view fun getBalance(): UFix64 {
-            return self.balance
-        }
-
-        access(all) view fun getDefaultStoragePath(): StoragePath? {
-            return /storage/exampleTokenVault
+        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
+            return amount <= self.balance
         }
 
-        access(all) view fun getDefaultPublicPath(): PublicPath? {
-            return /public/exampleTokenPublic
+        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
+            return {self.getType(): true}
         }
 
-        access(all) view fun getDefaultReceiverPath(): PublicPath? {
-            return /public/exampleTokenPublic
+        access(all) view fun isSupportedVaultType(type: Type): Bool {
+            if (type == self.getType()) { return true } else { return false }
         }
 
-        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
-            return self.balance >= amount
+        access(all) fun createEmptyVault(): @{FungibleToken.Vault} {
+            return <-create Vault(balance: 0.0)
         }
 
-        /// Same as getViews above, but on a specific NFT instead of a contract
-        access(all) view fun getViews(): [Type] {
+        /// Get all the Metadata Views implemented by ExampleToken
+        ///
+        /// @return An array of Types defining the implemented views. This value will be used by
+        ///         developers to know which parameter to pass to the resolveView() method.
+        ///
+        access(all) view fun getViews(): [Type]{
             return ExampleToken.getContractViews(resourceType: nil)
         }
 
-        /// Same as resolveView above, but on a specific NFT instead of a contract
+        /// Get a Metadata View from ExampleToken
+        ///
+        /// @param view: The Type of the desired view.
+        /// @return A structure representing the requested view.
+        ///
         access(all) fun resolveView(_ view: Type): AnyStruct? {
             return ExampleToken.resolveContractView(resourceType: nil, viewType: view)
         }
@@ -112,16 +114,6 @@ access(all) contract ExampleToken {
             return <-create Vault(balance: amount)
         }
 
-        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
-            return {
-                Type<@ExampleToken.Vault>(): true
-            }
-        }
-
-        access(all) view fun isSupportedVaultType(type: Type): Bool {
-            return type == Type<@ExampleToken.Vault>()
-        }
-
         /// deposit
         ///
         /// Function that takes a Vault object as an argument and adds
@@ -139,8 +131,8 @@ access(all) contract ExampleToken {
             destroy vault
         }
 
-        access(all) fun createEmptyVault(): @Vault {
-            return <- ExampleToken.createEmptyVault()
+        access(contract) fun burnCallback() {
+            ExampleToken.totalSupply = ExampleToken.totalSupply - self.balance
         }
     }
 
@@ -151,7 +143,7 @@ access(all) contract ExampleToken {
     /// and store the returned Vault in their storage in order to allow their
     /// account to be able to receive deposits of this token type.
     ///
-    access(all) fun createEmptyVault(): @Vault {
+    access(all) fun createEmptyVault(vaultType: Type): @Vault {
         return <-create Vault(balance: 0.0)
     }
 
@@ -227,6 +219,7 @@ access(all) contract ExampleToken {
         }
     }
 
+    /// Gets a list of the metadata views that this contract supports
     access(all) view fun getContractViews(resourceType: Type?): [Type] {
         return [Type<FungibleTokenMetadataViews.FTView>(),
                 Type<FungibleTokenMetadataViews.FTDisplay>(),
@@ -234,6 +227,21 @@ access(all) contract ExampleToken {
                 Type<FungibleTokenMetadataViews.TotalSupply>()]
     }
 
+    access(all) fun mintTokens(amount: UFix64): @{FungibleToken.Vault} {
+        let admin = self.account.storage.borrow<&Administrator>(from: /storage/exampleTokenAdmin)!
+        let minter <- admin.createNewMinter(allowedAmount: amount)
+
+        let tokens <- minter.mintTokens(amount: amount)
+        destroy minter
+
+        return <- tokens
+    }
+
+    /// Get a Metadata View from ExampleToken
+    ///
+    /// @param view: The Type of the desired view.
+    /// @return A structure representing the requested view.
+    ///
     access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
         switch viewType {
             case Type<FungibleTokenMetadataViews.FTView>():
@@ -244,15 +252,15 @@ access(all) contract ExampleToken {
             case Type<FungibleTokenMetadataViews.FTDisplay>():
                 let media = MetadataViews.Media(
                         file: MetadataViews.HTTPFile(
-                        url: "https://example.com"
+                        url: "example.com"
                     ),
                     mediaType: "image/svg+xml"
                 )
                 let medias = MetadataViews.Medias([media])
                 return FungibleTokenMetadataViews.FTDisplay(
-                    name: "Example Token",
+                    name: "EXAMPLE Token",
                     symbol: "EXAMPLE",
-                    description: "",
+                    description: "This is an example token",
                     externalURL: MetadataViews.ExternalURL("https://flow.com"),
                     logos: medias,
                     socials: {
@@ -286,11 +294,10 @@ access(all) contract ExampleToken {
         let vault <- create Vault(balance: self.totalSupply)
         self.account.storage.save(<-vault, to: /storage/exampleTokenVault)
 
-        // Create a public capability to the stored Vault that only exposes
-        // the `deposit` method through the `Receiver` interface
-        //
-        let publicCap = self.account.capabilities.storage.issue<&ExampleToken.Vault>(/storage/exampleTokenVault)
-        self.account.capabilities.publish(publicCap, at: /public/exampleTokenPublic)
+        let cap = self.account.capabilities.storage.issue<&{FungibleToken.Vault}>(/storage/exampleTokenVault)
+        self.account.capabilities.publish(cap, at: /public/exampleTokenReceiver)
+        self.account.capabilities.publish(cap, at: /public/exampleTokenBalance)
+
 
         let admin <- create Administrator()
         self.account.storage.save(<-admin, to: /storage/exampleTokenAdmin)

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

@@ -36,6 +36,7 @@ access(all) contract DropTypes {
         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?
@@ -58,7 +59,8 @@ access(all) contract DropTypes {
             address: Address?,
             phases: [PhaseSummary],
             royaltyRate: UFix64,
-            creator: Address?
+            creator: Address?,
+            paymentTokenTypes: {String: Bool}
         ) {
             self.id = id
             self.display = Display(display)
@@ -82,6 +84,7 @@ access(all) contract DropTypes {
             self.blockHeight = b.height
             self.blockTimestamp = UInt64(b.timestamp)
             self.royaltyRate = royaltyRate
+            self.paymentTokenTypes = paymentTokenTypes
         }
     }
 
@@ -118,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,
@@ -127,7 +130,7 @@ access(all) contract DropTypes {
             totalMinted: Int?,
             minter: Address?,
             quantity: Int?,
-            paymentIdentifier: String?
+            paymentIdentifiers: [String]
         ) {
             self.index = index
             self.id = phase.uuid
@@ -155,19 +158,17 @@ 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)!
@@ -206,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)
         }
@@ -231,13 +232,14 @@ access(all) contract DropTypes {
             address: minter,
             phases: phaseSummaries,
             royaltyRate: royaltyRate,
-            creator: creator
+            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)!
@@ -278,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)
             }
@@ -307,7 +309,8 @@ access(all) contract DropTypes {
                 address: minter,
                 phases: phaseSummaries,
                 royaltyRate: royaltyRate,
-                creator: creator
+                creator: creator,
+                paymentTokenTypes: dropDetails.paymentTokenTypes
             ))
         }
 

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

package/package.json

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