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

package/contracts/dapper/offers/DapperOffersV2.cdc

@@ -2,6 +2,8 @@ import "OffersV2"
 import "FungibleToken"
 import "NonFungibleToken"
 import "Resolver"
+import "ViewResolver"
+
 
 // DapperOffersV2
 //
@@ -12,6 +14,9 @@ import "Resolver"
 // get details on Offers contained within it.
 //
 access(all) contract DapperOffersV2 {
+
+    access(all) entitlement Manager
+    access(all) entitlement ProxyManager
     // DapperOffersV2
     // This contract has been deployed.
     // Event consumers can now expect events from this contract.
@@ -51,7 +56,7 @@ access(all) contract DapperOffersV2 {
         //
         access(all) fun addProxyCapability(
             account: Address,
-            cap: Capability<&{DapperOffersV2.DapperOfferProxyManager}>
+            cap: Capability<auth(ProxyManager) &DapperOffer>
         )
     }
 
@@ -62,8 +67,8 @@ access(all) contract DapperOffersV2 {
         // createOffer
         // Allows the DapperOffer owner to create Offers.
         //
-        access(all) fun createOffer(
-            vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Balance}>,
+        access(Manager) fun createOffer(
+            vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>,
             nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
             nftType: Type,
             amount: UFix64,
@@ -76,7 +81,7 @@ access(all) contract DapperOffersV2 {
         // removeOffer
         // Allows the DapperOffer owner to remove offers
         //
-        access(all) fun removeOffer(offerId: UInt64)
+        access(Manager | ProxyManager) fun removeOffer(offerId: UInt64)
     }
 
     // DapperOfferProxyManager
@@ -86,11 +91,11 @@ access(all) contract DapperOffersV2 {
         // removeOffer
         // Allows the DapperOffer owner to remove offers
         //
-        access(all) fun removeOffer(offerId: UInt64)
+        access(Manager | ProxyManager) fun removeOffer(offerId: UInt64)
         // removeOfferFromProxy
         // Allows the DapperOffer proxy owner to remove offers
         //
-        access(all) fun removeOfferFromProxy(account: Address, offerId: UInt64)
+        access(ProxyManager) fun removeOfferFromProxy(account: Address, offerId: UInt64)
     }
 
 
@@ -98,18 +103,18 @@ access(all) contract DapperOffersV2 {
     // 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.
     //
-    access(all) resource DapperOffer : DapperOfferManager, DapperOfferPublic, DapperOfferProxyManager {
+    access(all) resource DapperOffer :DapperOfferManager, DapperOfferPublic, DapperOfferProxyManager {
         // The dictionary of Address to DapperOfferProxyManager capabilities.
-        access(self) var removeOfferCapability: {Address:Capability<&{DapperOffersV2.DapperOfferProxyManager}>}
+        access(self) var removeOfferCapability: {Address:Capability<auth(ProxyManager) &DapperOffer>}
         // The dictionary of Offer uuids to Offer resources.
         access(self) var offers: @{UInt64:OffersV2.Offer}
 
         // addProxyCapability
         // Assign proxy capabilities (DapperOfferProxyManager) to an DapperOffer resource.
         //
-        access(all) fun addProxyCapability(account: Address, cap: Capability<&{DapperOffersV2.DapperOfferProxyManager}>) {
+        access(all) fun addProxyCapability(account: Address, cap: Capability<auth(ProxyManager) &DapperOffer>) {
             pre {
-                cap.borrow() != nil: "Invalid admin capability"
+                cap != nil: "Invalid admin capability"
             }
             self.removeOfferCapability[account] = cap
         }
@@ -117,23 +122,23 @@ access(all) contract DapperOffersV2 {
         // removeOfferFromProxy
         // Allows the DapperOffer proxy owner to remove offers
         //
-        access(all) fun removeOfferFromProxy(account: Address, offerId: UInt64) {
+        access(ProxyManager) 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()!
+            let adminRef = self.removeOfferCapability[account]!
 
-            adminRef.removeOffer(offerId: offerId)
+            adminRef.borrow()!.removeOffer(offerId: offerId)
         }
 
 
         // createOffer
         // Allows the DapperOffer owner to create Offers.
         //
-        access(all) fun createOffer(
-            vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Balance}>,
+        access(Manager) fun createOffer(
+            vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>,
             nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
             nftType: Type,
             amount: UFix64,
@@ -165,22 +170,28 @@ access(all) contract DapperOffersV2 {
         // removeOffer
         // Remove an Offer that has not yet been accepted from the collection and destroy it.
         //
-        access(all) fun removeOffer(offerId: UInt64) {
-            destroy self.offers.remove(key: offerId) ?? panic("missing offer")
+        access(Manager | ProxyManager) fun removeOffer(offerId: UInt64) {
+            let offer <- self.offers.remove(key: offerId) ?? panic("missing offer")
+            // offer.customDestroy()
+            destroy offer
         }
 
         // getOfferIds
         // Returns an array of the Offer resource IDs that are in the collection
         //
-        access(all) fun getOfferIds(): [UInt64] {
+        access(all) view 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.
         //
-        access(all) fun borrowOffer(offerId: UInt64): &{OffersV2.OfferPublic}? {
-            return &self.offers[offerId]
+        access(all) view fun borrowOffer(offerId: UInt64): &{OffersV2.OfferPublic}? {
+            if self.offers[offerId] != nil {
+                return (&self.offers[offerId] as &{OffersV2.OfferPublic}?)!
+            } else {
+                return nil
+            }
         }
 
         // cleanup
@@ -206,13 +217,9 @@ access(all) contract DapperOffersV2 {
             emit DapperOfferInitialized(DapperOfferResourceId: self.uuid)
         }
 
-        // destructor
-        //
-        // destroy() {
-        //     destroy self.offers
-        //     // Let event consumers know that this storefront exists.
-        //     emit DapperOfferDestroyed(DapperOfferResourceId: self.uuid)
-        // }
+        access(all) event ResourceDestroyed(
+            id: UInt64 = self.uuid
+        )
     }
 
     // createDapperOffer
@@ -231,4 +238,4 @@ access(all) contract DapperOffersV2 {
 
         emit DapperOffersInitialized()
     }
-}
+}

package/contracts/dapper/offers/OffersV2.cdc

@@ -2,10 +2,10 @@ import "FungibleToken"
 import "NonFungibleToken"
 import "DapperUtilityCoin"
 import "MetadataViews"
-import "Resolver"
 import "ViewResolver"
+import "Resolver"
 
-// OffersV2
+/// OffersV2
 //
 // Contract holds the Offer resource and a public method to create them.
 //
@@ -141,6 +141,10 @@ access(all) contract OffersV2 {
 
 
     access(all) resource Offer: OfferPublic {
+
+        access(all)  event ResourceDestroyed(purchased: Bool = self.details.purchased, offerId: UInt64 = self.details.offerId)
+
+
         // The OfferDetails struct of the Offer
         access(self) let details: OfferDetails
         // The vault which will handle the payment if the Offer is accepted.
@@ -151,7 +155,7 @@ access(all) contract OffersV2 {
         access(contract) let resolverCapability: Capability<&{Resolver.ResolverPublic}>
 
         init(
-            vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Balance}>,
+            vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>,
             nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
             nftType: Type,
             amount: UFix64,
@@ -252,8 +256,8 @@ access(all) contract OffersV2 {
 
             // If a DUC vault is being used for payment we must assert that no DUC is leaking from the transactions.
             let isDucVault = self.vaultRefCapability.isInstance(
-                Type<Capability<&{FungibleToken.Provider, FungibleToken.Balance}>>()
-            )
+                Type<Capability<&DapperUtilityCoin.Vault>>()
+            ) // todo: check if this is correct
 
             if isDucVault {
                 assert(self.vaultRefCapability.borrow()!.balance == initalDucSupply, message: "DUC is leaking")
@@ -279,14 +283,14 @@ access(all) contract OffersV2 {
         // getDetails
         // Return Offer details
         //
-        access(all) fun getDetails(): OfferDetails {
+        access(all) view fun getDetails(): OfferDetails {
             return self.details
         }
 
         // getRoyaltyInfo
         // Return royalty details
         //
-        access(all) fun getRoyaltyInfo(): {Address:UFix64} {
+        access(all) view fun getRoyaltyInfo(): {Address:UFix64} {
             let royaltyInfo: {Address:UFix64} = {}
 
             for royalty in self.details.royalties {
@@ -294,31 +298,11 @@ access(all) contract OffersV2 {
             }
             return royaltyInfo;
         }
-
-        // destroy() {
-        //     if !self.details.purchased {
-        //         emit OfferCompleted(
-        //             purchased: self.details.purchased,
-        //             acceptingAddress: nil,
-        //             offerAddress: self.nftReceiverCapability.address,
-        //             offerId: self.details.offerId,
-        //             nftType: self.details.nftType,
-        //             offerAmount: self.details.offerAmount,
-        //             royalties: self.getRoyaltyInfo(),
-        //             offerType: self.details.offerParamsString["_type"] ?? "unknown",
-        //             offerParamsString: self.details.offerParamsString,
-        //             offerParamsUFix64: self.details.offerParamsUFix64,
-        //             offerParamsUInt64: self.details.offerParamsUInt64,
-        //             paymentVaultType: self.details.paymentVaultType,
-        //             nftId: nil,
-        //         )
-        //     }
-        // }
     }
 
     // makeOffer
     access(all) fun makeOffer(
-        vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Balance}>,
+        vaultRefCapability:  Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>,
         nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
         nftType: Type,
         amount: UFix64,
@@ -341,5 +325,4 @@ access(all) contract OffersV2 {
         )
         return <-newOfferResource
     }
-}
- 
+}

package/contracts/dapper/offers/Resolver.cdc

@@ -1,8 +1,14 @@
 import "NonFungibleToken"
 import "MetadataViews"
-import "ViewResolver"
 import "TopShot"
+import "ViewResolver"
 
+// Resolver
+//
+// Contract holds the Offer exchange resolution rules.
+//
+// When an Offer is created a ResolverType is included. The ResolverType is also
+// passed into checkOfferResolver() from the Offers contract on exchange validation
 access(all) contract Resolver {
     // Current list of supported resolution rules.
     access(all) enum ResolverType: UInt8 {
@@ -35,7 +41,7 @@ access(all) contract Resolver {
             if offerParamsString["resolver"] == ResolverType.NFT.rawValue.toString() {
                 assert(item.id.toString() == offerParamsString["nftId"], message: "item NFT does not have specified ID")
                 return true
-            } else if offerParamsString["resolver"] == ResolverType.TopShotEdition.rawValue.toString() {
+            }  else if offerParamsString["resolver"] == ResolverType.TopShotEdition.rawValue.toString() {
                 // // Get the Top Shot specific metadata for this NFT
                 let view = item.resolveView(Type<TopShot.TopShotMomentMetadataView>())!
                 let metadata = view as! TopShot.TopShotMomentMetadataView

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flowtyio/flow-contracts",
-    "version": "0.1.0-beta.23",
+    "version": "0.1.0-beta.24",
     "main": "index.json",
     "description": "An NPM package for common flow contracts",
     "author": "flowtyio",