@flowtyio/flow-contracts 0.1.0-beta.3 → 0.1.0-beta.30

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