@flowtyio/flow-contracts 0.1.0-beta.8 → 0.1.0

package/contracts/flowty-drops/FlowtyDrops.cdc

@@ -0,0 +1,461 @@
+import "NonFungibleToken"
+import "FungibleToken"
+import "MetadataViews"
+import "AddressUtils"
+import "FungibleTokenMetadataViews"
+import "FungibleTokenRouter"
+
+access(all) contract FlowtyDrops {
+    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 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)
+
+    access(all) entitlement Owner
+    access(all) entitlement EditPhase
+
+    // 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) fun mint(
+            payment: @{FungibleToken.Vault},
+            amount: Int,
+            phaseIndex: Int,
+            expectedType: Type,
+            receiverCap: Capability<&{NonFungibleToken.CollectionPublic}>,
+            commissionReceiver: Capability<&{FungibleToken.Receiver}>?,
+            data: {String: AnyStruct}
+        ): @{FungibleToken.Vault}
+        access(all) fun getDetails(): DropDetails
+    }
+
+    // A phase represents a stage of a drop. Some drops will only have one
+    // phase, while others could have many. For example, a drop with an allow list
+    // and a public mint would likely have two phases.
+    access(all) resource Phase: PhasePublic {
+        access(all) event ResourceDestroyed(uuid: UInt64 = self.uuid)
+
+        access(all) let details: PhaseDetails
+
+        access(all) let data: {String: AnyStruct}
+        access(all) let resources: @{String: AnyResource}
+
+        // returns whether this phase of a drop has started.
+        access(all) fun isActive(): Bool {
+            return self.details.activeChecker.hasStarted() && !self.details.activeChecker.hasEnded()
+        }
+
+        access(all) fun getDetails(): PhaseDetails {
+            return self.details
+        }
+
+        access(EditPhase) fun borrowActiveCheckerAuth(): auth(Mutate) &{ActiveChecker} {
+            return &self.details.activeChecker
+        }
+
+        access(EditPhase) fun borrowPricerAuth(): auth(Mutate) &{Pricer} {
+            return &self.details.pricer
+        }
+
+        access(EditPhase) fun borrowAddressVerifierAuth(): auth(Mutate) &{AddressVerifier} {
+            return &self.details.addressVerifier
+        }
+
+        init(details: PhaseDetails) {
+            self.details = details
+
+            self.data = {}
+            self.resources <- {}
+        }
+    }
+
+    access(all) resource Drop: DropPublic {
+        access(all) event ResourceDestroyed(
+            uuid: UInt64 = self.uuid,
+            minterAddress: Address = self.minterCap.address,
+            nftType: String = self.details.nftType,
+            totalMinted: Int = self.details.totalMinted
+        )
+
+        // phases represent the stages of a drop. For example, a drop might have an allowlist and a public mint phase.
+        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
+        access(self) let minterCap: Capability<&{Minter}>
+
+        access(all) let data: {String: AnyStruct}
+        access(all) let resources: @{String: AnyResource}
+
+        access(all) fun mint(
+            payment: @{FungibleToken.Vault},
+            amount: Int,
+            phaseIndex: Int,
+            expectedType: Type,
+            receiverCap: Capability<&{NonFungibleToken.CollectionPublic}>,
+            commissionReceiver: Capability<&{FungibleToken.Receiver}>?,
+            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
+            let phase: &Phase = &self.phases[phaseIndex]
+            assert(
+                phase.details.addressVerifier.canMint(addr: receiverCap.address, num: amount, totalMinted: self.details.minters[receiverCap.address] ?? 0, data: {}),
+                message: "receiver address has exceeded their mint capacity"
+            )
+
+            let paymentAmount = phase.details.pricer.getPrice(num: amount, paymentTokenType: payment.getType(), minter: receiverCap.address)
+            let withdrawn <- payment.withdraw(amount: paymentAmount) // make sure that we have a fresh vault resource
+
+            // take commission
+            if commissionReceiver != nil && commissionReceiver!.check() {
+                let commission <- withdrawn.withdraw(amount: self.details.commissionRate * withdrawn.balance)
+                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")
+            assert(phase.details.pricer.getPaymentTypes().contains(withdrawn.getType()), message: "unsupported payment type")
+
+            // 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
+            let receiver = receiverCap.borrow() ?? panic("could not borrow receiver capability")
+            self.details.addMinted(num: mintedNFTs.length, addr: receiverCap.address)
+
+            while mintedNFTs.length > 0 {
+                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)
+
+                // validate that every nft is the right type
+                assert(nftType == expectedType, message: "unexpected nft type was minted")
+    
+                receiver.deposit(token: <-nft)
+            }
+
+            // cleanup
+            destroy mintedNFTs
+
+            // return excess payment
+            return <- payment
+        }
+
+        access(Owner) fun borrowPhase(index: Int): auth(EditPhase) &Phase {
+            return &self.phases[index]
+        }
+
+
+        access(all) fun borrowPhasePublic(index: Int): &{PhasePublic} {
+            return &self.phases[index]
+        }
+
+        access(all) fun borrowActivePhases(): [&{PhasePublic}] {
+            let 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)
+                }
+
+                count = count + 1
+            }
+
+            return arr
+        }
+
+        access(all) fun borrowAllPhases(): [&{PhasePublic}] {
+            let arr: [&{PhasePublic}] = []
+            var index = 0
+            while index < self.phases.length {
+                let ref = self.borrowPhasePublic(index: index)
+                arr.append(ref)
+                index = index + 1
+            }
+
+            return arr
+        }
+
+        access(Owner) fun addPhase(_ phase: @Phase) {
+            emit PhaseAdded(
+                dropID: self.uuid,
+                dropAddress: self.owner!.address,
+                id: phase.uuid,
+                index: self.phases.length,
+                activeCheckerType: phase.details.activeChecker.getType().identifier,
+                pricerType: phase.details.pricer.getType().identifier,
+                addressVerifierType: phase.details.addressVerifier.getType().identifier
+            )
+            self.phases.append(<-phase)
+        }
+
+        access(Owner) fun removePhase(index: Int): @Phase {
+            pre {
+                self.phases.length > index: "index is greater than length of phases"
+            }
+
+            let phase <- self.phases.remove(at: index)
+            emit PhaseRemoved(dropID: self.uuid, dropAddress: self.owner!.address, id: phase.uuid)
+
+            return <- phase
+        }
+
+        access(all) fun getDetails(): DropDetails {
+            return self.details
+        }
+
+        init(details: DropDetails, minterCap: Capability<&{Minter}>, phases: @[Phase]) {
+            pre {
+                minterCap.check(): "minter capability is not valid"
+            }
+
+            self.phases <- phases
+            self.details = details
+            self.minterCap = minterCap
+
+            self.data = {}
+            self.resources <- {}
+        }
+    }
+
+    access(all) struct DropDetails {
+        access(all) let display: MetadataViews.Display
+        access(all) let medias: MetadataViews.Medias?
+        access(all) var totalMinted: Int
+        access(all) var minters: {Address: Int}
+        access(all) let commissionRate: UFix64
+        access(all) let nftType: String
+
+        access(all) let data: {String: AnyStruct}
+
+        access(contract) fun addMinted(num: Int, addr: Address) {
+            self.totalMinted = self.totalMinted + num
+            if self.minters[addr] == nil {
+                self.minters[addr] = 0
+            }
+
+            self.minters[addr] = self.minters[addr]! + num
+        }
+
+        init(display: MetadataViews.Display, medias: MetadataViews.Medias?, commissionRate: UFix64, nftType: String) {
+            pre {
+                nftType != "": "nftType should be a composite type identifier"
+            }
+
+            self.display = display
+            self.medias = medias
+            self.totalMinted = 0
+            self.commissionRate = commissionRate
+            self.minters = {}
+            self.nftType = nftType
+            self.data = {}
+        }
+    }
+
+    // An ActiveChecker represents a phase being on or off, and holds information
+    // about whether a phase has started or not.
+    access(all) struct interface ActiveChecker {
+        // Signal that a phase has started. If the phase has not ended, it means that this activeChecker's phase
+        // is active
+        access(all) view fun hasStarted(): Bool
+        // Signal that a phase has ended. If an ActiveChecker has ended, minting will not work. That could mean
+        // the drop is over, or it could mean another phase has begun.
+        access(all) view fun hasEnded(): Bool
+
+        access(all) view fun getStart(): UInt64?
+        access(all) view fun getEnd(): UInt64?
+    }
+
+    access(all) resource interface PhasePublic {
+        // What does a phase need to be able to answer/manage?
+        // - What are the details of the phase being interactive with?
+        // - 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) struct PhaseDetails {
+        // handles whether a phase is on or not
+        access(all) let activeChecker: {ActiveChecker}
+
+        // display information about a phase
+        access(all) let display: MetadataViews.Display?
+
+        // handles the pricing of a phase
+        access(all) let pricer: {Pricer}
+
+        // verifies whether an address is able to mint
+        access(all) let addressVerifier: {AddressVerifier}
+
+        // placecholder data dictionary to allow new fields to be accessed
+        access(all) let data: {String: AnyStruct}
+
+        init(activeChecker: {ActiveChecker}, display: MetadataViews.Display?, pricer: {Pricer}, addressVerifier: {AddressVerifier}) {
+            self.activeChecker = activeChecker
+            self.display = display
+            self.pricer = pricer
+            self.addressVerifier = addressVerifier
+
+            self.data = {}
+        }
+    }
+
+    access(all) struct interface AddressVerifier {
+        access(all) fun canMint(addr: Address, num: Int, totalMinted: Int, data: {String: AnyStruct}): Bool {
+            return true
+        }
+
+        access(all) fun remainingForAddress(addr: Address, totalMinted: Int): Int? {
+            return nil
+        }
+    }
+
+    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 {
+        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()
+                ?? panic("missing receiver at fungible token router path")
+            receiver.deposit(from: <-payment)
+
+            let nfts: @[{NonFungibleToken.NFT}] <- []
+
+            var count = 0
+            while count < amount {
+                count = count + 1
+                nfts.append(<- self.createNextNFT())
+            }
+
+            return <- nfts
+        }
+
+        access(contract) fun createNextNFT(): @{NonFungibleToken.NFT}
+    }
+    
+    access(all) struct DropResolver {
+        access(self) let cap: Capability<&{ContainerPublic}>
+
+        access(all) fun borrowContainer(): &{ContainerPublic}? {
+            return self.cap.borrow()
+        }
+
+        init(cap: Capability<&{ContainerPublic}>) {
+            pre {
+                cap.check(): "container capability is not valid"
+            }
+
+            self.cap = cap
+        }
+    }
+
+    access(all) resource interface ContainerPublic {
+        access(all) fun borrowDropPublic(id: UInt64): &{DropPublic}?
+        access(all) fun getIDs(): [UInt64]
+    }
+
+    // Contains drops. 
+    access(all) resource Container: ContainerPublic {
+        access(self) let drops: @{UInt64: Drop}
+
+        access(all) let data: {String: AnyStruct}
+        access(all) let resources: @{String: AnyResource}
+
+        access(Owner) fun addDrop(_ drop: @Drop) {
+            let details = drop.getDetails()
+
+            let phases = drop.borrowAllPhases()
+            assert(phases.length > 0, message: "drops must have at least one phase to be added to a container")
+
+            let firstPhaseDetails = phases[0].getDetails()
+
+            emit DropAdded(
+                address: self.owner!.address,
+                id: drop.uuid,
+                name: details.display.name,
+                description: details.display.description,
+                imageUrl: details.display.thumbnail.uri(),
+                start: firstPhaseDetails.activeChecker.getStart(),
+                end: firstPhaseDetails.activeChecker.getEnd(),
+                nftType: details.nftType
+            )
+            destroy self.drops.insert(key: drop.uuid, <-drop)
+        }
+
+        access(Owner) fun removeDrop(id: UInt64): @Drop {
+            pre {
+                self.drops.containsKey(id): "drop was not found"
+            }
+
+            return <- self.drops.remove(key: id)!
+        }
+
+        access(Owner) fun borrowDrop(id: UInt64): auth(Owner) &Drop? {
+            return &self.drops[id]
+        }
+
+        access(all) fun borrowDropPublic(id: UInt64): &{DropPublic}? {
+            return &self.drops[id]
+        }
+
+        access(all) fun getIDs(): [UInt64] {
+            return self.drops.keys
+        }
+
+        init() {
+            self.drops <- {}
+
+            self.data = {}
+            self.resources <- {}
+        }
+    }
+
+    access(all) fun createPhase(details: PhaseDetails): @Phase {
+        return <- create Phase(details: details)
+    }
+
+    access(all) fun createDrop(details: DropDetails, minterCap: Capability<&{Minter}>, phases: @[Phase]): @Drop {
+        return <- create Drop(details: details, minterCap: minterCap, phases: <- phases)
+    }
+
+    access(all) fun createContainer(): @Container {
+        return <- create Container()
+    }
+
+    access(all) fun getMinterStoragePath(type: Type): StoragePath {
+        let segments = type.identifier.split(separator: ".")
+        let identifier = "FlowtyDrops_Minter_".concat(segments[1]).concat("_").concat(segments[2])
+        return StoragePath(identifier: identifier)!
+    }
+
+    init() {
+        let identifier = "FlowtyDrops_".concat(self.account.address.toString())
+        let containerIdentifier = identifier.concat("_Container")
+        let minterIdentifier = identifier.concat("_Minter")
+
+        self.ContainerStoragePath = StoragePath(identifier: containerIdentifier)!
+        self.ContainerPublicPath = PublicPath(identifier: containerIdentifier)!
+    }
+}

package/contracts/flowty-drops/FlowtyPricers.cdc

@@ -0,0 +1,48 @@
+import "FlowtyDrops"
+import "FlowToken"
+
+/*
+This contract contains implementations of the FlowtyDrops.Pricer interface.
+You can use these, or any custom implementation for the phases of your drop.
+*/
+access(all) contract FlowtyPricers {
+
+    /*
+    The FlatPrice Pricer implementation has a set price and token type. Every mint is the same cost regardless of
+    the number minter, or what address is minting
+    */
+    access(all) struct FlatPrice: FlowtyDrops.Pricer {
+        access(all) var price: UFix64
+        access(all) let paymentTokenType: String
+
+        access(all) view fun getPrice(num: Int, paymentTokenType: Type, minter: Address?): UFix64 {
+            return self.price * UFix64(num)
+        }
+
+        access(all) view fun getPaymentTypes(): [Type] {
+            return [CompositeType(self.paymentTokenType)!]
+        }
+
+        access(Mutate) fun setPrice(price: UFix64) {
+            self.price = price
+        }
+
+        init(price: UFix64, paymentTokenType: Type) {
+            self.price = price
+            self.paymentTokenType = paymentTokenType.identifier
+        }
+    }
+
+    /*
+    The Free Pricer can be used for a free mint, it has no price and always marks its payment type as @FlowToken.Vault
+    */
+    access(all) struct Free: FlowtyDrops.Pricer {
+        access(all) fun getPrice(num: Int, paymentTokenType: Type, minter: Address?): UFix64 {
+            return 0.0
+        }
+
+        access(all) fun getPaymentTypes(): [Type] {
+            return [Type<@FlowToken.Vault>()]
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import "FlowtyDrops"
+import "NFTMetadata"
+import "AddressUtils"
+import "ContractInitializer"
+
+access(all) contract ContractBorrower {
+    access(all) fun borrowInitializer(typeIdentifier: String): &{ContractInitializer} {
+        let type = CompositeType(typeIdentifier) ?? panic("invalid type identifier")
+        let addr = AddressUtils.parseAddress(type)!
+
+        let contractName = type.identifier.split(separator: ".")[2]
+        return getAccount(addr).contracts.borrow<&{ContractInitializer}>(name: contractName)!
+    }
+}

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

@@ -0,0 +1,7 @@
+import "FlowtyDrops"
+import "NFTMetadata"
+import "AddressUtils"
+
+access(all) contract interface ContractInitializer {
+    access(all) fun initialize(contractAcct: auth(Storage, Contracts, Keys, Inbox, Capabilities) &Account, params: {String: AnyStruct}): NFTMetadata.InitializedCaps
+}

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

@@ -0,0 +1,57 @@
+import "ContractInitializer"
+import "NFTMetadata"
+import "FlowtyDrops"
+import "NonFungibleToken"
+import "UniversalCollection"
+
+access(all) contract OpenEditionInitializer: ContractInitializer {
+    access(all) fun initialize(contractAcct: auth(Storage, Contracts, Keys, Inbox, Capabilities) &Account, params: {String: AnyStruct}): NFTMetadata.InitializedCaps {
+        pre {
+            params["data"] != nil: "missing param data"
+            params["data"]!.getType() == Type<NFTMetadata.Metadata>(): "data param must be of type NFTMetadata.Metadata"
+            params["collectionInfo"] != nil: "missing param collectionInfo"
+            params["collectionInfo"]!.getType() == Type<NFTMetadata.CollectionInfo>(): "collectionInfo param must be of type NFTMetadata.CollectionInfo"
+            params["type"] != nil: "missing param type"
+            params["type"]!.getType() == Type<Type>(): "type param must be of type Type"
+        }
+
+        let data = params["data"]! as! NFTMetadata.Metadata
+        let collectionInfo = params["collectionInfo"]! as! NFTMetadata.CollectionInfo
+
+        let nftType = params["type"]! as! Type
+        let contractName = nftType.identifier.split(separator: ".")[2]
+
+        // do we have information to setup a drop as well?
+        if params.containsKey("dropDetails") && params.containsKey("phaseDetails") && params.containsKey("minterController") {
+            // extract expected keys
+            let minterCap = params["minterController"]! as! Capability<&{FlowtyDrops.Minter}>
+            let dropDetails = params["dropDetails"]! as! FlowtyDrops.DropDetails
+            let phaseDetails = params["phaseDetails"]! as! [FlowtyDrops.PhaseDetails]
+
+            assert(minterCap.check(), message: "invalid minter capability")
+            assert(CompositeType(dropDetails.nftType) != nil, message: "dropDetails.nftType must be a valid CompositeType")
+
+            let phases: @[FlowtyDrops.Phase] <- []
+            for p in phaseDetails {
+                phases.append(<- FlowtyDrops.createPhase(details: p))
+            }
+
+            let drop <- FlowtyDrops.createDrop(details: dropDetails, minterCap: minterCap, phases: <- phases)
+            if contractAcct.storage.borrow<&AnyResource>(from: FlowtyDrops.ContainerStoragePath) == nil {
+                contractAcct.storage.save(<- FlowtyDrops.createContainer(), to: FlowtyDrops.ContainerStoragePath)
+
+                contractAcct.capabilities.unpublish(FlowtyDrops.ContainerPublicPath)
+                contractAcct.capabilities.publish(
+                    contractAcct.capabilities.storage.issue<&{FlowtyDrops.ContainerPublic}>(FlowtyDrops.ContainerStoragePath),
+                    at: FlowtyDrops.ContainerPublicPath
+                )
+            }
+
+            let container = contractAcct.storage.borrow<auth(FlowtyDrops.Owner) &FlowtyDrops.Container>(from: FlowtyDrops.ContainerStoragePath)
+                ?? panic("drops container not found")
+            container.addDrop(<- drop)
+        }
+        
+        return NFTMetadata.initialize(acct: contractAcct, collectionInfo: collectionInfo, nftType: nftType)
+    }
+}

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

@@ -0,0 +1,97 @@
+import "NonFungibleToken"
+import "ViewResolver"
+import "MetadataViews"
+import "NFTMetadata"
+import "FlowtyDrops"
+import "AddressUtils"
+import "StringUtils"
+
+access(all) contract interface BaseCollection: ViewResolver {
+    access(all) var MetadataCap: Capability<&NFTMetadata.Container>
+    access(all) var totalSupply: UInt64
+
+    access(all) fun createEmptyCollection(nftType: Type): @{NonFungibleToken.Collection}
+
+    // The base collection is an interface that attmepts to take more boilerplate
+    // off of NFT-standard compliant definitions.
+    access(all) resource interface Collection: NonFungibleToken.Collection {
+        access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
+        access(all) var nftType: Type
+
+        access(all) fun deposit(token: @{NonFungibleToken.NFT}) {
+            pre {
+                token.getType() == self.nftType: "unexpected nft type being deposited"
+            }
+
+            destroy self.ownedNFTs.insert(key: token.uuid, <-token)
+        }
+
+        access(all) view fun borrowNFT(_ id: UInt64): &{NonFungibleToken.NFT}? {
+            return &self.ownedNFTs[id]
+        }
+
+        access(all) view fun getSupportedNFTTypes(): {Type: Bool} {
+            return {
+                self.nftType: true
+            }
+        }
+
+        access(all) view fun isSupportedNFTType(type: Type): Bool {
+            return type == self.nftType
+        }
+
+        access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
+            return <- self.ownedNFTs.remove(key: withdrawID)!
+        }
+    }
+
+    access(all) view fun getContractViews(resourceType: Type?): [Type] {
+        return [
+            Type<MetadataViews.NFTCollectionData>(),
+            Type<MetadataViews.NFTCollectionDisplay>()
+        ]
+    }
+
+    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
+        if resourceType == nil {
+            return nil
+        }
+
+        let rt = resourceType!
+        let segments = rt.identifier.split(separator: ".") 
+        let pathIdentifier = StringUtils.join([segments[2], segments[1]], "_")
+
+        let addr = AddressUtils.parseAddress(rt)!
+        let acct = getAccount(addr)
+        
+        switch viewType {
+            case Type<MetadataViews.NFTCollectionData>():
+                let segments = rt.identifier.split(separator: ".") 
+                let pathIdentifier = StringUtils.join([segments[2], segments[1]], "_")
+
+                return MetadataViews.NFTCollectionData(
+                    storagePath: StoragePath(identifier: pathIdentifier)!,
+                    publicPath: PublicPath(identifier: pathIdentifier)!,
+                    publicCollection: Type<&{NonFungibleToken.Collection}>(),
+                    publicLinkedType: Type<&{NonFungibleToken.Collection}>(),
+                    createEmptyCollectionFunction: fun(): @{NonFungibleToken.Collection} {
+                        let addr = AddressUtils.parseAddress(rt)!
+                        let c = getAccount(addr).contracts.borrow<&{BaseCollection}>(name: segments[2])!
+                        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))
+        }
+
+        return nil
+    }
+}