@flowtyio/flow-contracts 0.0.14 → 0.0.16

package/contracts/dapper/TopShotLocking.cdc

@@ -0,0 +1,165 @@
+import "NonFungibleToken"
+
+pub contract TopShotLocking {
+
+    // -----------------------------------------------------------------------
+    // TopShotLocking contract Events
+    // -----------------------------------------------------------------------
+
+    // Emitted when a Moment is locked
+    pub event MomentLocked(id: UInt64, duration: UFix64, expiryTimestamp: UFix64)
+
+    // Emitted when a Moment is unlocked
+    pub event MomentUnlocked(id: UInt64)
+
+    // Dictionary of locked NFTs
+    // TopShot nft resource id is the key
+    // locked until timestamp is the value
+    access(self) var lockedNFTs: {UInt64: UFix64}
+
+    // Dictionary of NFTs overridden to be unlocked
+    access(self) var unlockableNFTs: {UInt64: Bool} // nft resource id is the key
+
+    // isLocked Returns a boolean indicating if an nft exists in the lockedNFTs dictionary
+    //
+    // Parameters: nftRef: A reference to the NFT resource
+    //
+    // Returns: true if NFT is locked
+    pub fun isLocked(nftRef: &NonFungibleToken.NFT): Bool {
+        return self.lockedNFTs.containsKey(nftRef.id)
+    }
+
+    // getLockExpiry Returns the unix timestamp when an nft is unlockable
+    //
+    // Parameters: nftRef: A reference to the NFT resource
+    //
+    // Returns: unix timestamp
+    pub fun getLockExpiry(nftRef: &NonFungibleToken.NFT): UFix64 {
+        if !self.lockedNFTs.containsKey(nftRef.id) {
+            panic("NFT is not locked")
+        }
+        return self.lockedNFTs[nftRef.id]!
+    }
+
+    // lockNFT Takes an NFT resource and adds its unique identifier to the lockedNFTs dictionary
+    //
+    // Parameters: nft: NFT resource
+    //             duration: number of seconds the NFT will be locked for
+    //
+    // Returns: the NFT resource
+    pub fun lockNFT(nft: @NonFungibleToken.NFT, duration: UFix64): @NonFungibleToken.NFT {
+        let TopShotNFTType: Type = CompositeType("A.TOPSHOTADDRESS.TopShot.NFT")!
+        if !nft.isInstance(TopShotNFTType) {
+            panic("NFT is not a TopShot NFT")
+        }
+
+        if self.lockedNFTs.containsKey(nft.id) {
+            // already locked - short circuit and return the nft
+            return <- nft
+        }
+
+        let expiryTimestamp = getCurrentBlock().timestamp + duration
+
+        self.lockedNFTs[nft.id] = expiryTimestamp
+
+        emit MomentLocked(id: nft.id, duration: duration, expiryTimestamp: expiryTimestamp)
+
+        return <- nft
+    }
+
+    // unlockNFT Takes an NFT resource and removes it from the lockedNFTs dictionary
+    //
+    // Parameters: nft: NFT resource
+    //
+    // Returns: the NFT resource
+    //
+    // NFT must be eligible for unlocking by an admin
+    pub fun unlockNFT(nft: @NonFungibleToken.NFT): @NonFungibleToken.NFT {
+        if !self.lockedNFTs.containsKey(nft.id) {
+            // nft is not locked, short circuit and return the nft
+            return <- nft
+        }
+
+        let lockExpiryTimestamp: UFix64 = self.lockedNFTs[nft.id]!
+        let isPastExpiry: Bool = getCurrentBlock().timestamp >= lockExpiryTimestamp
+
+        let isUnlockableOverridden: Bool = self.unlockableNFTs.containsKey(nft.id)
+
+        if !(isPastExpiry || isUnlockableOverridden) {
+            panic("NFT is not eligible to be unlocked, expires at ".concat(lockExpiryTimestamp.toString()))
+        }
+
+        self.unlockableNFTs.remove(key: nft.id)
+        self.lockedNFTs.remove(key: nft.id)
+
+        emit MomentUnlocked(id: nft.id)
+
+        return <- nft
+    }
+
+    // getIDs Returns the ids of all locked Top Shot NFT tokens
+    //
+    // Returns: array of ids
+    //
+    pub fun getIDs(): [UInt64] {
+        return self.lockedNFTs.keys
+    }
+
+    // getExpiry Returns the timestamp when a locked token is eligible for unlock
+    //
+    // Parameters: tokenID: the nft id of the locked token
+    //
+    // Returns: a unix timestamp in seconds
+    //
+    pub fun getExpiry(tokenID: UInt64): UFix64? {
+        return self.lockedNFTs[tokenID]
+    }
+
+    // getLockedNFTsLength Returns the count of locked tokens
+    //
+    // Returns: an integer containing the number of locked tokens
+    //
+    pub fun getLockedNFTsLength(): Int {
+        return self.lockedNFTs.length
+    }
+
+    // Admin is a special authorization resource that 
+    // allows the owner to override the lock on a moment
+    //
+    pub resource Admin {
+        // createNewAdmin creates a new Admin resource
+        //
+        pub fun createNewAdmin(): @Admin {
+            return <-create Admin()
+        }
+
+        // markNFTUnlockable marks a given nft as being
+        // unlockable, overridding the expiry timestamp
+        // the nft owner will still need to send an unlock transaction to unlock
+        //
+        pub fun markNFTUnlockable(nftRef: &NonFungibleToken.NFT) {
+            TopShotLocking.unlockableNFTs[nftRef.id] = true
+        }
+
+        // unlocks all NFTs
+        pub fun unlockAll() {
+            TopShotLocking.lockedNFTs = {}
+            TopShotLocking.unlockableNFTs = {}
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // TopShotLocking initialization function
+    // -----------------------------------------------------------------------
+    //
+    init() {
+        self.lockedNFTs = {}
+        self.unlockableNFTs = {}
+
+        // Create a single admin resource
+        let admin <- create Admin()
+
+        // Store it in private account storage in `init` so only the admin can use it
+        self.account.save(<-admin, to: /storage/TopShotLockingAdmin)
+    }
+}

package/contracts/dapper/offers/DapperOffersV2.cdc

@@ -0,0 +1,238 @@
+import "OffersV2"
+import "FungibleToken"
+import "NonFungibleToken"
+import "Resolver"
+
+// DapperOffersV2
+//
+// Each account that wants to create offers for NFTs installs an DapperOffer
+// resource and creates individual Offers for NFTs within it.
+//
+// The DapperOffer resource contains the methods to add, remove, borrow and
+// get details on Offers contained within it.
+//
+pub contract DapperOffersV2 {
+    // DapperOffersV2
+    // This contract has been deployed.
+    // Event consumers can now expect events from this contract.
+    //
+    pub event DapperOffersInitialized()
+
+    /// DapperOfferInitialized
+    // A DapperOffer resource has been created.
+    //
+    pub event DapperOfferInitialized(DapperOfferResourceId: UInt64)
+
+    // DapperOfferDestroyed
+    // A DapperOffer resource has been destroyed.
+    // Event consumers can now stop processing events from this resource.
+    //
+    pub event DapperOfferDestroyed(DapperOfferResourceId: UInt64)
+
+
+    // DapperOfferPublic
+    // An interface providing a useful public interface to a Offer.
+    //
+    pub resource interface DapperOfferPublic {
+        // getOfferIds
+        // Get a list of Offer ids created by the resource.
+        //
+        pub fun getOfferIds(): [UInt64]
+        // borrowOffer
+        // Borrow an Offer to either accept the Offer or get details on the Offer.
+        //
+        pub fun borrowOffer(offerId: UInt64): &OffersV2.Offer{OffersV2.OfferPublic}?
+        // cleanup
+        // Remove an Offer
+        //
+        pub fun cleanup(offerId: UInt64)
+        // addProxyCapability
+        // Assign proxy capabilities (DapperOfferProxyManager) to an DapperOffer resource.
+        //
+        pub fun addProxyCapability(
+            account: Address,
+            cap: Capability<&DapperOffer{DapperOffersV2.DapperOfferProxyManager}>
+        )
+    }
+
+    // DapperOfferManager
+    // An interface providing a management interface for an DapperOffer resource.
+    //
+    pub resource interface DapperOfferManager {
+        // createOffer
+        // Allows the DapperOffer owner to create Offers.
+        //
+        pub fun createOffer(
+            vaultRefCapability: Capability<&{FungibleToken.Provider, FungibleToken.Balance}>,
+            nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
+            nftType: Type,
+            amount: UFix64,
+            royalties: [OffersV2.Royalty],
+            offerParamsString: {String:String},
+            offerParamsUFix64: {String:UFix64},
+            offerParamsUInt64: {String:UInt64},
+            resolverCapability: Capability<&{Resolver.ResolverPublic}>,
+        ): UInt64
+        // removeOffer
+        // Allows the DapperOffer owner to remove offers
+        //
+        pub fun removeOffer(offerId: UInt64)
+    }
+
+    // DapperOfferProxyManager
+    // An interface providing removeOffer on behalf of an DapperOffer owner.
+    //
+    pub resource interface DapperOfferProxyManager {
+        // removeOffer
+        // Allows the DapperOffer owner to remove offers
+        //
+        pub fun removeOffer(offerId: UInt64)
+        // removeOfferFromProxy
+        // Allows the DapperOffer proxy owner to remove offers
+        //
+        pub fun removeOfferFromProxy(account: Address, offerId: UInt64)
+    }
+
+
+    // DapperOffer
+    // A resource that allows its owner to manage a list of Offers, and anyone to interact with them
+    // in order to query their details and accept the Offers for NFTs that they represent.
+    //
+    pub resource DapperOffer : DapperOfferManager, DapperOfferPublic, DapperOfferProxyManager {
+        // The dictionary of Address to DapperOfferProxyManager capabilities.
+        access(self) var removeOfferCapability: {Address:Capability<&DapperOffer{DapperOffersV2.DapperOfferProxyManager}>}
+        // The dictionary of Offer uuids to Offer resources.
+        access(self) var offers: @{UInt64:OffersV2.Offer}
+
+        // addProxyCapability
+        // Assign proxy capabilities (DapperOfferProxyManager) to an DapperOffer resource.
+        //
+        pub fun addProxyCapability(account: Address, cap: Capability<&DapperOffer{DapperOffersV2.DapperOfferProxyManager}>) {
+            pre {
+                cap.borrow() != nil: "Invalid admin capability"
+            }
+            self.removeOfferCapability[account] = cap
+        }
+
+        // removeOfferFromProxy
+        // Allows the DapperOffer proxy owner to remove offers
+        //
+        pub fun removeOfferFromProxy(account: Address, offerId: UInt64) {
+            pre {
+                self.removeOfferCapability[account] != nil:
+                    "Cannot remove offers until the token admin has deposited the account registration capability"
+            }
+
+            let adminRef = self.removeOfferCapability[account]!.borrow()!
+
+            adminRef.removeOffer(offerId: offerId)
+        }
+
+
+        // createOffer
+        // Allows the DapperOffer owner to create Offers.
+        //
+        pub fun createOffer(
+            vaultRefCapability: Capability<&{FungibleToken.Provider, FungibleToken.Balance}>,
+            nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
+            nftType: Type,
+            amount: UFix64,
+            royalties: [OffersV2.Royalty],
+            offerParamsString: {String:String},
+            offerParamsUFix64: {String:UFix64},
+            offerParamsUInt64: {String:UInt64},
+            resolverCapability: Capability<&{Resolver.ResolverPublic}>,
+        ): UInt64 {
+            let offer <- OffersV2.makeOffer(
+                vaultRefCapability: vaultRefCapability,
+                nftReceiverCapability: nftReceiverCapability,
+                nftType: nftType,
+                amount: amount,
+                royalties: royalties,
+                offerParamsString: offerParamsString,
+                offerParamsUFix64: offerParamsUFix64,
+                offerParamsUInt64: offerParamsUInt64,
+                resolverCapability: resolverCapability,
+            )
+
+            let offerId = offer.uuid
+            let dummy <- self.offers[offerId] <- offer
+            destroy dummy
+
+            return offerId
+        }
+
+        // removeOffer
+        // Remove an Offer that has not yet been accepted from the collection and destroy it.
+        //
+        pub fun removeOffer(offerId: UInt64) {
+            destroy self.offers.remove(key: offerId) ?? panic("missing offer")
+        }
+
+        // getOfferIds
+        // Returns an array of the Offer resource IDs that are in the collection
+        //
+        pub fun getOfferIds(): [UInt64] {
+            return self.offers.keys
+        }
+
+        // borrowOffer
+        // Returns a read-only view of the Offer for the given OfferID if it is contained by this collection.
+        //
+        pub fun borrowOffer(offerId: UInt64): &OffersV2.Offer{OffersV2.OfferPublic}? {
+            if self.offers[offerId] != nil {
+                return (&self.offers[offerId] as &OffersV2.Offer{OffersV2.OfferPublic}?)!
+            } else {
+                return nil
+            }
+        }
+
+        // cleanup
+        // Remove an Offer *if* it has been accepted.
+        // Anyone can call, but at present it only benefits the account owner to do so.
+        // Kind purchasers can however call it if they like.
+        //
+        pub fun cleanup(offerId: UInt64) {
+            pre {
+                self.offers[offerId] != nil: "could not find Offer with given id"
+            }
+            let offer <- self.offers.remove(key: offerId)!
+            assert(offer.getDetails().purchased == true, message: "Offer is not purchased, only admin can remove")
+            destroy offer
+        }
+
+        // constructor
+        //
+        init() {
+            self.removeOfferCapability = {}
+            self.offers <- {}
+            // Let event consumers know that this storefront will no longer exist.
+            emit DapperOfferInitialized(DapperOfferResourceId: self.uuid)
+        }
+
+        // destructor
+        //
+        destroy() {
+            destroy self.offers
+            // Let event consumers know that this storefront exists.
+            emit DapperOfferDestroyed(DapperOfferResourceId: self.uuid)
+        }
+    }
+
+    // createDapperOffer
+    // Make creating an DapperOffer publicly accessible.
+    //
+    pub fun createDapperOffer(): @DapperOffer {
+        return <-create DapperOffer()
+    }
+
+    pub let DapperOffersStoragePath: StoragePath
+    pub let DapperOffersPublicPath: PublicPath
+
+    init () {
+        self.DapperOffersStoragePath = /storage/DapperOffersV2
+        self.DapperOffersPublicPath = /public/DapperOffersV2
+
+        emit DapperOffersInitialized()
+    }
+}