@flowtyio/flow-contracts 0.1.0-beta.9 → 0.1.1

package/contracts/flow-utils/ScopedFTProviders.cdc

@@ -57,6 +57,10 @@ access(all) contract ScopedFTProviders {
             self.expiration = expiration
         }
 
+        access(all) fun getProviderType(): Type {
+            return self.provider.borrow()!.getType()
+        }
+
         access(all) fun check(): Bool {
             return self.provider.check()
         }
@@ -86,7 +90,7 @@ access(all) contract ScopedFTProviders {
             return self.canWithdraw(amount)
         }
 
-        access(FungibleToken.Withdraw | FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
+        access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
             pre {
                 !self.isExpired(): "provider has expired"
             }
@@ -122,4 +126,3 @@ access(all) contract ScopedFTProviders {
         return <- create ScopedFTProvider(provider: provider, filters: filters, expiration: expiration)
     }
 }
-

package/contracts/flow-utils/ScopedNFTProviders.cdc

@@ -102,7 +102,11 @@ access(all) contract ScopedNFTProviders {
                 return false
             }
 
-            let nft = self.provider.borrow()!.borrowNFT(id)
+            if !self.provider.check() {
+                return false
+            }
+
+            let nft: &{NonFungibleToken.NFT}? = self.provider.borrow()!.borrowNFT(id)
             if nft == nil {
                 return false
             }
@@ -121,7 +125,7 @@ access(all) contract ScopedNFTProviders {
             return self.provider.check()
         }
 
-        access(NonFungibleToken.Withdraw | NonFungibleToken.Owner) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
+        access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
             pre {
                 !self.isExpired(): "provider has expired"
             }

package/contracts/flowty-drops/ContractManager.cdc

@@ -0,0 +1,73 @@
+import "FlowToken"
+import "FungibleToken"
+import "FungibleTokenRouter"
+
+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(self) let routerCap: Capability<auth(FungibleTokenRouter.Owner) &FungibleTokenRouter.Router>
+
+        access(all) let data: {String: AnyStruct}
+        access(all) let resources: @{String: AnyResource}
+
+        access(Manage) fun borrowContractAccount(): auth(Contracts) &Account {
+            return self.acct.borrow()!
+        }
+
+        access(Manage) fun addOverride(type: Type, addr: Address) {
+            let router = self.routerCap.borrow() ?? panic("fungible token router is not valid")
+            router.addOverride(type: type, addr: addr)
+        }
+
+        access(Manage) fun getSwitchboard(): auth(FungibleTokenRouter.Owner) &FungibleTokenRouter.Router {
+            return self.routerCap.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, defaultRouterAddress: Address) {
+            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)
+
+            let router <- FungibleTokenRouter.createRouter(defaultAddress: defaultRouterAddress)
+            acct.storage.save(<-router, to: FungibleTokenRouter.StoragePath)
+
+            let receiver = acct.capabilities.storage.issue<&{FungibleToken.Receiver}>(FungibleTokenRouter.StoragePath)
+            assert(receiver.check(), message: "invalid switchboard receiver capability")
+            acct.capabilities.publish(receiver, at: FungibleTokenRouter.PublicPath)
+
+            self.routerCap = acct.capabilities.storage.issue<auth(FungibleTokenRouter.Owner) &FungibleTokenRouter.Router>(FungibleTokenRouter.StoragePath)
+
+            self.data = {}
+            self.resources <- {}
+        }
+    }
+
+    access(all) fun createManager(tokens: @FlowToken.Vault, defaultRouterAddress: Address): @Manager {
+        return <- create Manager(tokens: <- tokens, defaultRouterAddress: defaultRouterAddress)
+    }
+
+    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 "FlowtyActiveCheckers"
+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 activeChecker = FlowtyActiveCheckers.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(activeChecker: activeChecker, 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 ActiveChecker turns on at a set unix timestamp (or is on by default if nil), and ends at the specified end date if provided
+        let activeChecker = FlowtyActiveCheckers.TimestampChecker(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(activeChecker: activeChecker, 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,282 @@
+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 activeCheckerType: 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: FlowtyDrops.PhaseDetails = phase.getDetails()
+            self.activeCheckerType = d.activeChecker.getType().identifier
+            self.pricerType = d.pricer.getType().identifier
+            self.addressVerifierType = d.addressVerifier.getType().identifier
+
+            self.hasStarted = d.activeChecker.hasStarted()
+            self.hasEnded = d.activeChecker.hasEnded()
+            self.start = d.activeChecker.getStart()
+            self.end = d.activeChecker.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)
+            }
+
+            if CompositeType(dropDetails.nftType) == nil {
+                continue
+            }
+
+            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/FlowtyActiveCheckers.cdc

@@ -0,0 +1,113 @@
+import "FlowtyDrops"
+
+/*
+This contract contains implementations for the FlowtyDrops.ActiveChecker struct interface.
+You can use these implementations, or your own, to configure when a phase in a drop is active
+*/
+access(all) contract FlowtyActiveCheckers {
+    /*
+    The AlwaysOn ActiveChecker is always on and never ends.
+    */
+    access(all) struct AlwaysOn: FlowtyDrops.ActiveChecker {
+        access(all) view fun hasStarted(): Bool {
+            return true
+        }
+
+        access(all) view fun hasEnded(): Bool {
+            return false
+        }
+
+        access(all) view fun getStart(): UInt64? {
+            return nil
+        }
+
+        access(all) view fun getEnd(): UInt64? {
+            return nil
+        }
+    }
+
+    /*
+    The manual checker is used to explicitly toggle a drop.
+    This version of checker allows a creator to turn on or off a drop at will
+    */
+    access(all) struct ManualChecker: FlowtyDrops.ActiveChecker {
+        access(self) var started: Bool
+        access(self) var ended: Bool
+
+        access(all) view fun hasStarted(): Bool {
+            return self.started
+        }
+
+        access(all) view fun hasEnded(): Bool {
+            return self.ended
+        }
+
+        access(all) view fun getStart(): UInt64? {
+            return nil
+        }
+
+        access(all) view fun getEnd(): UInt64? {
+            return nil
+        }
+
+        access(Mutate) fun setStarted(_ b: Bool) {
+            self.started = b
+        }
+
+        access(Mutate) fun setEnded(_ b: Bool) {
+            self.ended = b
+        }
+
+        init() {
+            self.started = false
+            self.ended = false
+        }
+    }
+
+    /*
+    TimestampChecker uses block timestamps to determine if a phase or drop is live or not.
+    A timestamp checker has a start and an end time.
+    */
+    access(all) struct TimestampChecker: FlowtyDrops.ActiveChecker {
+        access(all) var start: UInt64?
+        access(all) var end: UInt64?
+
+
+        access(all) view fun hasStarted(): Bool {
+            return self.start == nil || UInt64(getCurrentBlock().timestamp) >= self.start!
+        }
+
+        access(all) view fun hasEnded(): Bool {
+            if self.end == nil {
+                return false
+            }
+
+            return UInt64(getCurrentBlock().timestamp) > self.end!
+        }
+
+        access(all) view fun getStart(): UInt64? {
+            return self.start
+        }
+
+        access(all) view fun getEnd(): UInt64? {
+            return self.end
+        }
+
+        access(Mutate) fun setStart(start: UInt64?) {
+            self.start = start
+        }
+
+        access(Mutate) fun setEnd(end: UInt64?) {
+            self.end = end
+        }
+
+        init(start: UInt64?, end: UInt64?) {
+            pre {
+                start == nil || end == nil || start! < end!: "start must be less than end"
+            }
+
+            self.start = start
+            self.end = end
+        }
+    }
+}

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
+        }
+    }
+}