@flowtyio/flow-contracts 0.1.0-beta.24 → 0.1.0-beta.26

package/README.md

@@ -49,7 +49,7 @@ Currently, the list includes:
 | FTProviderFactory | 0x294e44e1ec6993c6 | 0xd8a7e05a7ac670c0 |
 | FTReceiverFactory | 0x294e44e1ec6993c6 | 0xd8a7e05a7ac670c0 |
 | NFTCollectionPublicFactory | 0x294e44e1ec6993c6 | 0xd8a7e05a7ac670c0 |
-| NFTProviderAndCollectionPublicFactory | 0x294e44e1ec6993c6 | 0xd8a7e05a7ac670c0 |
+| NFTProviderAndCollectionFactory | 0x294e44e1ec6993c6 | 0xd8a7e05a7ac670c0 |
 | NFTProviderFactory | 0x294e44e1ec6993c6 | 0xd8a7e05a7ac670c0 |
 | NFTCatalog | 0x49a7cda3a1eecc29 | 0x324c34e1c517e4db |
 | NFTCatalogAdmin | 0x49a7cda3a1eecc29 | 0x324c34e1c517e4db |

package/contracts/capability-cache/CapabilityCache.cdc

@@ -0,0 +1,97 @@
+/*
+https://github.com/Flowtyio/capability-cache
+
+CapabilityCache helps manage capabilities which are issued but are not in public paths.
+Rather than looping through all capabilities under a storage path and finding one that 
+matches the Capability type you want, the cache can be used to retrieve them
+*/
+access(all) contract CapabilityCache {
+
+    access(all) let basePathIdentifier: String
+
+    access(all) event CapabilityAdded(owner: Address?, cacheUuid: UInt64, namespace: String, resourceType: Type, capabilityType: Type, capabilityID: UInt64)
+    access(all) event CapabilityRemoved(owner: Address?, cacheUuid: UInt64, namespace: String, resourceType: Type, capabilityType: Type, capabilityID: UInt64)
+
+    // Add to a namespace
+    access(all) entitlement Add
+
+    // Remove from a namespace
+    access(all) entitlement Delete
+
+    // Retrieve a cap from the namespace
+    access(all) entitlement Get
+
+    // Resource that manages capabilities for a provided namespace. Only one capability is permitted per type.
+    access(all) resource Cache {
+        // A dictionary of resourceType -> CapabilityType -> Capability
+        // For example, one might store a Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}> for the @TopShot.NFT resource.
+        // Note that the resource type is not necessarily the type that the borrowed capability is an instance of. This is because some resource definitions
+        // might be reused.
+        access(self) let caps: {Type: {Type: Capability}}
+
+        // who is this capability cache maintained by? e.g. flowty, dapper, find? 
+        access(all) let namespace: String
+
+        // Remove a capability, if it exists, 
+        access(Delete) fun removeCapabilityByType(resourceType: Type, capabilityType: Type): Capability? {
+            if let ref = &self.caps[resourceType] as auth(Mutate) &{Type: Capability}? {
+                let cap = ref.remove(key: capabilityType)
+                if cap != nil {
+                    emit CapabilityRemoved(owner: self.owner?.address, cacheUuid: self.uuid, namespace: self.namespace, resourceType: resourceType, capabilityType: capabilityType, capabilityID: cap!.id)
+                }
+            }
+
+            return nil
+        }
+
+        // Adds a capability to the cache. If there is already an entry for the given type,
+        // it will be returned
+        access(Add) fun addCapability(resourceType: Type, cap: Capability): Capability? {
+            pre {
+                cap.id != 0: "cannot add a capability with id 0"
+            }
+
+            let capType = cap.getType()
+            emit CapabilityAdded(owner: self.owner?.address, cacheUuid: self.uuid, namespace: self.namespace, resourceType: resourceType, capabilityType: capType, capabilityID: cap.id)
+            if let ref = &self.caps[resourceType] as auth(Mutate) &{Type: Capability}? {
+                return ref.insert(key: capType, cap)
+            }
+
+            self.caps[resourceType] = {
+                capType: cap
+            }
+
+            return nil
+        }
+
+        // Retrieve a capability key'd by a given type.
+        access(Get) fun getCapabilityByType(resourceType: Type, capabilityType: Type): Capability? {
+            if let tmp = self.caps[resourceType] {
+                return tmp[capabilityType]
+            }
+
+            return nil
+        }
+
+        init(namespace: String) {
+            self.caps = {}
+
+            self.namespace = namespace
+        }
+    }
+
+    // There is no uniform storage path for the Capability Cache. Instead, each platform which issues capabilities
+    // should manage their own cache, and can generate the storage path to store it in with this helper method
+    access(all) fun getPathForCache(_ namespace: String): StoragePath {
+        return StoragePath(identifier: self.basePathIdentifier.concat(namespace))
+            ?? panic("invalid namespace value")
+    }
+
+    access(all) fun createCache(namespace: String): @Cache {
+        return <- create Cache(namespace: namespace)
+    }
+
+    init() {
+        self.basePathIdentifier = "CapabilityCache_".concat(self.account.address.toString()).concat("_")
+    }
+}

package/contracts/flowty-drops/ContractManager.cdc

@@ -0,0 +1,47 @@
+import "FlowToken"
+import "FungibleToken"
+
+access(all) contract ContractManager {
+    access(all) let StoragePath: StoragePath
+    access(all) let PublicPath: PublicPath
+
+    access(all) entitlement Manage
+
+    access(all) resource Manager {
+        access(self) let acct: Capability<auth(Storage, Contracts, Keys, Inbox, Capabilities) &Account>
+
+        access(Manage) fun borrowContractAccount(): auth(Contracts) &Account {
+            return self.acct.borrow()!
+        }
+
+        access(all) fun addFlowTokensToAccount(_ tokens: @FlowToken.Vault) {
+            self.acct.borrow()!.storage.borrow<&{FungibleToken.Receiver}>(from: /storage/flowTokenVault)!.deposit(from: <-tokens)
+        }
+
+        access(all) fun getAccount(): &Account {
+            return getAccount(self.acct.address)
+        }
+
+        init(tokens: @FlowToken.Vault) {
+            pre {
+                tokens.balance >= 0.001: "minimum balance of 0.001 required for initialization"
+            }
+
+            let acct = Account(payer: ContractManager.account)
+            self.acct = acct.capabilities.account.issue<auth(Storage, Contracts, Keys, Inbox, Capabilities) &Account>()
+            assert(self.acct.check(), message: "failed to setup account capability")
+
+            acct.storage.borrow<&{FungibleToken.Receiver}>(from: /storage/flowTokenVault)!.deposit(from: <-tokens)
+        }
+    }
+
+    access(all) fun createManager(tokens: @FlowToken.Vault): @Manager {
+        return <- create Manager(tokens: <- tokens)
+    }
+
+    init() {
+        let identifier = "ContractManager_".concat(self.account.address.toString())
+        self.StoragePath = StoragePath(identifier: identifier)!
+        self.PublicPath = PublicPath(identifier: identifier)!
+    }
+}

package/contracts/flowty-drops/DropFactory.cdc

@@ -0,0 +1,75 @@
+import "FungibleToken"
+import "MetadataViews"
+
+import "FlowtyDrops"
+import "FlowtySwitchers"
+import "FlowtyAddressVerifiers"
+import "FlowtyPricers"
+
+/*
+The DropFactory is a contract that helps create common types of drops
+*/
+access(all) contract DropFactory {
+    access(all) fun createEndlessOpenEditionDrop(
+        price: UFix64,
+        paymentTokenType: Type,
+        dropDisplay: MetadataViews.Display,
+        minterCap: Capability<&{FlowtyDrops.Minter}>,
+        nftTypeIdentifier: String
+    ): @FlowtyDrops.Drop {
+        pre {
+            paymentTokenType.isSubtype(of: Type<@{FungibleToken.Vault}>()): "paymentTokenType must be a FungibleToken"
+        }
+
+        // This drop is always on and never ends.
+        let switcher = FlowtySwitchers.AlwaysOn()
+
+        // All addresses are allowed to participate
+        let addressVerifier = FlowtyAddressVerifiers.AllowAll(maxPerMint: 10)
+
+        // The cost of each mint is the same, and only permits one token type as payment
+        let pricer = FlowtyPricers.FlatPrice(price: price, paymentTokenType: paymentTokenType)
+        
+        let phaseDetails = FlowtyDrops.PhaseDetails(switcher: switcher, display: nil, pricer: pricer, addressVerifier: addressVerifier)
+        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 drop <- FlowtyDrops.createDrop(details: dropDetails, minterCap: minterCap, phases: <- [<-phase])
+
+        return <- drop
+    }
+
+    access(all) fun createTimeBasedOpenEditionDrop(
+        price: UFix64,
+        paymentTokenType: Type,
+        dropDisplay: MetadataViews.Display,
+        minterCap: Capability<&{FlowtyDrops.Minter}>,
+        startUnix: UInt64?,
+        endUnix: UInt64?,
+        nftTypeIdentifier: String
+    ): @FlowtyDrops.Drop {
+        pre {
+            paymentTokenType.isSubtype(of: Type<@{FungibleToken.Vault}>()): "paymentTokenType must be a FungibleToken"
+        }
+
+        // This switcher turns on at a set unix timestamp (or is on by default if nil), and ends at the specified end date if provided
+        let switcher = FlowtySwitchers.TimestampSwitch(start: startUnix, end: endUnix)
+
+        // All addresses are allowed to participate
+        let addressVerifier = FlowtyAddressVerifiers.AllowAll(maxPerMint: 10)
+
+        // The cost of each mint is the same, and only permits one token type as payment
+        let pricer = FlowtyPricers.FlatPrice(price: price, paymentTokenType: paymentTokenType)
+        
+        let phaseDetails = FlowtyDrops.PhaseDetails(switcher: switcher, display: nil, pricer: pricer, addressVerifier: addressVerifier)
+        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 drop <- FlowtyDrops.createDrop(details: dropDetails, minterCap: minterCap, phases: <- [<-phase])
+
+        return <- drop
+    }
+}

package/contracts/flowty-drops/DropTypes.cdc

@@ -0,0 +1,278 @@
+import "FlowtyDrops"
+import "MetadataViews"
+import "ViewResolver"
+import "AddressUtils"
+
+access(all) contract DropTypes {
+    access(all) struct Display {
+        access(all) let name: String
+        access(all) let description: String
+        access(all) let url: String
+
+        init(_ display: MetadataViews.Display) {
+            self.name = display.name
+            self.description = display.description
+            self.url = display.thumbnail.uri()
+        }
+    }
+
+    access(all) struct Media {
+        access(all) let url: String
+        access(all) let mediaType: String
+
+        init(_ media: MetadataViews.Media) {
+            self.url = media.file.uri()
+            self.mediaType = media.mediaType
+        }
+    }
+
+    access(all) struct DropSummary {
+        access(all) let id: UInt64
+        access(all) let display: Display
+        access(all) let medias: [Media]
+        access(all) let totalMinted: Int
+        access(all) let minterCount: Int
+        access(all) let commissionRate: UFix64
+        access(all) let nftType: String
+
+        access(all) let address: Address?
+        access(all) let mintedByAddress: Int?
+
+        access(all) let phases: [PhaseSummary]
+
+        access(all) let blockTimestamp: UInt64
+        access(all) let blockHeight: UInt64
+
+        init(
+            id: UInt64,
+            display: MetadataViews.Display,
+            medias: MetadataViews.Medias?,
+            totalMinted: Int,
+            minterCount: Int,
+            mintedByAddress: Int?,
+            commissionRate: UFix64,
+            nftType: Type,
+            address: Address?,
+            phases: [PhaseSummary]
+        ) {
+            self.id = id
+            self.display = Display(display)
+            
+            self.medias = []
+            for m in medias?.items ?? [] {
+                self.medias.append(Media(m))
+            }
+
+
+            self.totalMinted = totalMinted
+            self.commissionRate = commissionRate
+            self.minterCount = minterCount
+            self.mintedByAddress = mintedByAddress
+            self.nftType = nftType.identifier
+            self.address = address
+            self.phases = phases
+
+            let b = getCurrentBlock()
+            self.blockHeight = b.height
+            self.blockTimestamp = UInt64(b.timestamp)
+        }
+    }
+
+    access(all) struct Quote {
+        access(all) let price: UFix64
+        access(all) let quantity: Int
+        access(all) let paymentIdentifier: String
+        access(all) let minter: Address?
+
+        init(price: UFix64, quantity: Int, paymentIdentifier: String, minter: Address?) {
+            self.price = price
+            self.quantity = quantity
+            self.paymentIdentifier = paymentIdentifier
+            self.minter = minter
+        }
+    }
+
+    access(all) struct PhaseSummary {
+        access(all) let id: UInt64
+        access(all) let index: Int
+
+        access(all) let switcherType: String
+        access(all) let pricerType: String
+        access(all) let addressVerifierType: String
+
+        access(all) let hasStarted: Bool
+        access(all) let hasEnded: Bool
+        access(all) let start: UInt64?
+        access(all) let end: UInt64?
+
+        access(all) let paymentTypes: [String]
+        
+        access(all) let address: Address?
+        access(all) let remainingForAddress: Int?
+
+        access(all) let quote: Quote?
+
+        init(
+            index: Int,
+            phase: &{FlowtyDrops.PhasePublic},
+            address: Address?,
+            totalMinted: Int?,
+            minter: Address?,
+            quantity: Int?,
+            paymentIdentifier: String?
+        ) {
+            self.index = index
+            self.id = phase.uuid
+
+            let d = phase.getDetails()
+            self.switcherType = d.switcher.getType().identifier
+            self.pricerType = d.pricer.getType().identifier
+            self.addressVerifierType = d.addressVerifier.getType().identifier
+
+            self.hasStarted = d.switcher.hasStarted()
+            self.hasEnded = d.switcher.hasEnded()
+            self.start = d.switcher.getStart()
+            self.end = d.switcher.getEnd()
+
+            self.paymentTypes = []
+            for pt in d.pricer.getPaymentTypes() {
+                self.paymentTypes.append(pt.identifier)
+            }
+
+            if let addr = address {
+                self.address = address
+                self.remainingForAddress = d.addressVerifier.remainingForAddress(addr: addr, totalMinted: totalMinted ?? 0)
+            } else {
+                self.address = nil
+                self.remainingForAddress = nil
+            }
+
+            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
+            }
+        }
+    }
+
+    access(all) fun getDropSummary(nftTypeIdentifier: String, dropID: UInt64, minter: Address?, quantity: Int?, paymentIdentifier: 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 resolver = getAccount(contractAddress).contracts.borrow<&{ViewResolver}>(name: contractName)
+        if resolver == nil {
+            return nil
+        }
+
+        let dropResolver = resolver!.resolveContractView(resourceType: nftType, viewType: Type<FlowtyDrops.DropResolver>()) as! FlowtyDrops.DropResolver?
+        if dropResolver == nil {
+            return nil
+        }
+
+        let container = dropResolver!.borrowContainer()
+        if container == nil {
+            return nil
+        }
+
+        let drop = container!.borrowDropPublic(id: dropID)
+        if drop == nil {
+            return nil
+        }
+
+        let dropDetails = drop!.getDetails()
+
+        let phaseSummaries: [PhaseSummary] = []
+        for index, phase in drop!.borrowAllPhases() {
+            let summary = PhaseSummary(
+                index: index,
+                phase: phase,
+                address: minter,
+                totalMinted: minter != nil ? dropDetails.minters[minter!] : nil,
+                minter: minter,
+                quantity: quantity,
+                paymentIdentifier: paymentIdentifier
+            )
+            phaseSummaries.append(summary)
+        }
+
+        let dropSummary = DropSummary(
+            id: drop!.uuid,
+            display: dropDetails.display,
+            medias: dropDetails.medias,
+            totalMinted: dropDetails.totalMinted,
+            minterCount: dropDetails.minters.keys.length,
+            mintedByAddress: minter != nil ? dropDetails.minters[minter!] : nil,
+            commissionRate: dropDetails.commissionRate,
+            nftType: CompositeType(dropDetails.nftType)!,
+            address: minter,
+            phases: phaseSummaries
+        )
+
+        return dropSummary
+    }
+
+    access(all) fun getAllDropSummaries(nftTypeIdentifier: String, minter: Address?, quantity: Int?, paymentIdentifier: 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 resolver = getAccount(contractAddress).contracts.borrow<&{ViewResolver}>(name: contractName)
+        if resolver == nil {
+            return []
+        }
+
+        let dropResolver = resolver!.resolveContractView(resourceType: nftType, viewType: Type<FlowtyDrops.DropResolver>()) as! FlowtyDrops.DropResolver?
+        if dropResolver == nil {
+            return []
+        }
+
+        let container = dropResolver!.borrowContainer()
+        if container == nil {
+            return []
+        }
+
+        let summaries: [DropSummary] = []
+        for id in container!.getIDs() {
+            let drop = container!.borrowDropPublic(id: id)
+            if drop == nil {
+                continue
+            }
+
+            let dropDetails = drop!.getDetails()
+
+            let phaseSummaries: [PhaseSummary] = []
+            for index, phase in drop!.borrowAllPhases() {
+                let summary = PhaseSummary(
+                    index: index,
+                    phase: phase,
+                    address: minter,
+                    totalMinted: minter != nil ? dropDetails.minters[minter!] : nil,
+                    minter: minter,
+                    quantity: quantity,
+                    paymentIdentifier: paymentIdentifier
+                )
+                phaseSummaries.append(summary)
+            }
+
+            summaries.append(DropSummary(
+                id: drop!.uuid,
+                display: dropDetails.display,
+                medias: dropDetails.medias,
+                totalMinted: dropDetails.totalMinted,
+                minterCount: dropDetails.minters.keys.length,
+                mintedByAddress: minter != nil ? dropDetails.minters[minter!] : nil,
+                commissionRate: dropDetails.commissionRate,
+                nftType: CompositeType(dropDetails.nftType)!,
+                address: minter,
+                phases: phaseSummaries
+            ))
+        }
+
+        return summaries
+    }
+}

package/contracts/flowty-drops/FlowtyAddressVerifiers.cdc

@@ -0,0 +1,64 @@
+import "FlowtyDrops"
+
+/*
+This contract contains implementations of the FlowtyDrops.AddressVerifier struct interface
+*/
+access(all) contract FlowtyAddressVerifiers {
+    /*
+    The AllowAll AddressVerifier allows any address to mint without any verification
+    */
+    access(all) struct AllowAll: FlowtyDrops.AddressVerifier {
+        access(all) var maxPerMint: Int
+
+        access(all) view fun canMint(addr: Address, num: Int, totalMinted: Int, data: {String: AnyStruct}): Bool {
+            return num <= self.maxPerMint
+        }
+
+        access(Mutate) fun setMaxPerMint(_ value: Int) {
+            self.maxPerMint = value
+        }
+
+        init(maxPerMint: Int) {
+            pre {
+                maxPerMint > 0: "maxPerMint must be greater than 0"
+            }
+
+            self.maxPerMint = maxPerMint
+        }
+    }
+
+    /*
+    The AllowList Verifier only lets a configured set of addresses participate in a drop phase. The number
+    of mints per address is specified to allow more granular control of what each address is permitted to do.
+    */
+    access(all) struct AllowList: FlowtyDrops.AddressVerifier {
+        access(self) let allowedAddresses: {Address: Int}
+
+        access(all) view fun canMint(addr: Address, num: Int, totalMinted: Int, data: {String: AnyStruct}): Bool {
+            if let allowedMints = self.allowedAddresses[addr] {
+                return allowedMints >= num + totalMinted
+            }
+
+            return false
+        }
+
+        access(all) view fun remainingForAddress(addr: Address, totalMinted: Int): Int? {
+            if let allowedMints = self.allowedAddresses[addr] {
+                return allowedMints - totalMinted
+            }
+            return nil
+        }
+
+        access(Mutate) fun setAddress(addr: Address, value: Int) {
+            self.allowedAddresses[addr] = value
+        }
+
+        access(Mutate) fun removeAddress(addr: Address) {
+            self.allowedAddresses.remove(key: addr)
+        }
+
+        init(allowedAddresses: {Address: Int}) {
+            self.allowedAddresses = allowedAddresses
+        }
+    }
+}