@flowtyio/flow-contracts 0.1.0-beta.2 → 0.1.0-beta.21

package/contracts/dapper/TopShotLocking.cdc

@@ -1,16 +1,16 @@
 import "NonFungibleToken"
 
-pub contract TopShotLocking {
+access(all) contract TopShotLocking {
 
     // -----------------------------------------------------------------------
     // TopShotLocking contract Events
     // -----------------------------------------------------------------------
 
     // Emitted when a Moment is locked
-    pub event MomentLocked(id: UInt64, duration: UFix64, expiryTimestamp: UFix64)
+    access(all) event MomentLocked(id: UInt64, duration: UFix64, expiryTimestamp: UFix64)
 
     // Emitted when a Moment is unlocked
-    pub event MomentUnlocked(id: UInt64)
+    access(all) event MomentUnlocked(id: UInt64)
 
     // Dictionary of locked NFTs
     // TopShot nft resource id is the key
@@ -25,7 +25,7 @@ pub contract TopShotLocking {
     // Parameters: nftRef: A reference to the NFT resource
     //
     // Returns: true if NFT is locked
-    pub fun isLocked(nftRef: &NonFungibleToken.NFT): Bool {
+    access(all) view fun isLocked(nftRef: &{NonFungibleToken.NFT}): Bool {
         return self.lockedNFTs.containsKey(nftRef.id)
     }
 
@@ -34,7 +34,7 @@ pub contract TopShotLocking {
     // Parameters: nftRef: A reference to the NFT resource
     //
     // Returns: unix timestamp
-    pub fun getLockExpiry(nftRef: &NonFungibleToken.NFT): UFix64 {
+    access(all) view fun getLockExpiry(nftRef: &{NonFungibleToken.NFT}): UFix64 {
         if !self.lockedNFTs.containsKey(nftRef.id) {
             panic("NFT is not locked")
         }
@@ -47,7 +47,7 @@ pub contract TopShotLocking {
     //             duration: number of seconds the NFT will be locked for
     //
     // Returns: the NFT resource
-    pub fun lockNFT(nft: @NonFungibleToken.NFT, duration: UFix64): @NonFungibleToken.NFT {
+    access(all) 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")
@@ -74,7 +74,7 @@ pub contract TopShotLocking {
     // Returns: the NFT resource
     //
     // NFT must be eligible for unlocking by an admin
-    pub fun unlockNFT(nft: @NonFungibleToken.NFT): @NonFungibleToken.NFT {
+    access(all) 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
@@ -101,7 +101,7 @@ pub contract TopShotLocking {
     //
     // Returns: array of ids
     //
-    pub fun getIDs(): [UInt64] {
+    access(all) view fun getIDs(): [UInt64] {
         return self.lockedNFTs.keys
     }
 
@@ -111,7 +111,7 @@ pub contract TopShotLocking {
     //
     // Returns: a unix timestamp in seconds
     //
-    pub fun getExpiry(tokenID: UInt64): UFix64? {
+    access(all) view fun getExpiry(tokenID: UInt64): UFix64? {
         return self.lockedNFTs[tokenID]
     }
 
@@ -119,17 +119,21 @@ pub contract TopShotLocking {
     //
     // Returns: an integer containing the number of locked tokens
     //
-    pub fun getLockedNFTsLength(): Int {
+    access(all) view fun getLockedNFTsLength(): Int {
         return self.lockedNFTs.length
     }
 
+    // The path to the TopShotLocking Admin resource belonging to the Account
+    // which the contract is deployed on
+    access(all) view fun AdminStoragePath() : StoragePath { return /storage/TopShotLockingAdmin}
+
     // Admin is a special authorization resource that 
     // allows the owner to override the lock on a moment
     //
-    pub resource Admin {
+    access(all) resource Admin {
         // createNewAdmin creates a new Admin resource
         //
-        pub fun createNewAdmin(): @Admin {
+        access(all) fun createNewAdmin(): @Admin {
             return <-create Admin()
         }
 
@@ -137,12 +141,34 @@ pub contract TopShotLocking {
         // unlockable, overridding the expiry timestamp
         // the nft owner will still need to send an unlock transaction to unlock
         //
-        pub fun markNFTUnlockable(nftRef: &NonFungibleToken.NFT) {
+        access(all) fun markNFTUnlockable(nftRef: &{NonFungibleToken.NFT}) {
             TopShotLocking.unlockableNFTs[nftRef.id] = true
         }
 
+        access(all) fun unlockByID(id: UInt64) {
+            if !TopShotLocking.lockedNFTs.containsKey(id) {
+                // nft is not locked, do nothing
+                return
+            }
+            TopShotLocking.lockedNFTs.remove(key: id)
+            emit MomentUnlocked(id: id)
+        }
+
+        // admin may alter the expiry of a lock on an NFT
+        access(all) fun setLockExpiryByID(id: UInt64, expiryTimestamp: UFix64) {
+            if expiryTimestamp < getCurrentBlock().timestamp {
+                panic("cannot set expiry in the past")
+            }
+
+            let duration = expiryTimestamp - getCurrentBlock().timestamp
+
+            TopShotLocking.lockedNFTs[id] = expiryTimestamp
+
+            emit MomentLocked(id: id, duration: duration, expiryTimestamp: expiryTimestamp)
+        }
+
         // unlocks all NFTs
-        pub fun unlockAll() {
+        access(all) fun unlockAll() {
             TopShotLocking.lockedNFTs = {}
             TopShotLocking.unlockableNFTs = {}
         }
@@ -160,6 +186,6 @@ pub contract TopShotLocking {
         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)
+        self.account.storage.save(<-admin, to: TopShotLocking.AdminStoragePath())
     }
 }

package/contracts/dapper/offers/DapperOffersV2.cdc

@@ -11,59 +11,59 @@ import "Resolver"
 // The DapperOffer resource contains the methods to add, remove, borrow and
 // get details on Offers contained within it.
 //
-pub contract DapperOffersV2 {
+access(all) contract DapperOffersV2 {
     // DapperOffersV2
     // This contract has been deployed.
     // Event consumers can now expect events from this contract.
     //
-    pub event DapperOffersInitialized()
+    access(all) event DapperOffersInitialized()
 
     /// DapperOfferInitialized
     // A DapperOffer resource has been created.
     //
-    pub event DapperOfferInitialized(DapperOfferResourceId: UInt64)
+    access(all) 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)
+    access(all) event DapperOfferDestroyed(DapperOfferResourceId: UInt64)
 
 
     // DapperOfferPublic
     // An interface providing a useful public interface to a Offer.
     //
-    pub resource interface DapperOfferPublic {
+    access(all) resource interface DapperOfferPublic {
         // getOfferIds
         // Get a list of Offer ids created by the resource.
         //
-        pub fun getOfferIds(): [UInt64]
+        access(all) 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}?
+        access(all) fun borrowOffer(offerId: UInt64): &{OffersV2.OfferPublic}?
         // cleanup
         // Remove an Offer
         //
-        pub fun cleanup(offerId: UInt64)
+        access(all) fun cleanup(offerId: UInt64)
         // addProxyCapability
         // Assign proxy capabilities (DapperOfferProxyManager) to an DapperOffer resource.
         //
-        pub fun addProxyCapability(
+        access(all) fun addProxyCapability(
             account: Address,
-            cap: Capability<&DapperOffer{DapperOffersV2.DapperOfferProxyManager}>
+            cap: Capability<&{DapperOffersV2.DapperOfferProxyManager}>
         )
     }
 
     // DapperOfferManager
     // An interface providing a management interface for an DapperOffer resource.
     //
-    pub resource interface DapperOfferManager {
+    access(all) resource interface DapperOfferManager {
         // createOffer
         // Allows the DapperOffer owner to create Offers.
         //
-        pub fun createOffer(
-            vaultRefCapability: Capability<&{FungibleToken.Provider, FungibleToken.Balance}>,
+        access(all) fun createOffer(
+            vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Balance}>,
             nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
             nftType: Type,
             amount: UFix64,
@@ -76,21 +76,21 @@ pub contract DapperOffersV2 {
         // removeOffer
         // Allows the DapperOffer owner to remove offers
         //
-        pub fun removeOffer(offerId: UInt64)
+        access(all) fun removeOffer(offerId: UInt64)
     }
 
     // DapperOfferProxyManager
     // An interface providing removeOffer on behalf of an DapperOffer owner.
     //
-    pub resource interface DapperOfferProxyManager {
+    access(all) resource interface DapperOfferProxyManager {
         // removeOffer
         // Allows the DapperOffer owner to remove offers
         //
-        pub fun removeOffer(offerId: UInt64)
+        access(all) fun removeOffer(offerId: UInt64)
         // removeOfferFromProxy
         // Allows the DapperOffer proxy owner to remove offers
         //
-        pub fun removeOfferFromProxy(account: Address, offerId: UInt64)
+        access(all) fun removeOfferFromProxy(account: Address, offerId: UInt64)
     }
 
 
@@ -98,16 +98,16 @@ pub 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.
     //
-    pub 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<&DapperOffer{DapperOffersV2.DapperOfferProxyManager}>}
+        access(self) var removeOfferCapability: {Address:Capability<&{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}>) {
+        access(all) fun addProxyCapability(account: Address, cap: Capability<&{DapperOffersV2.DapperOfferProxyManager}>) {
             pre {
                 cap.borrow() != nil: "Invalid admin capability"
             }
@@ -117,7 +117,7 @@ pub contract DapperOffersV2 {
         // removeOfferFromProxy
         // Allows the DapperOffer proxy owner to remove offers
         //
-        pub fun removeOfferFromProxy(account: Address, offerId: UInt64) {
+        access(all) fun removeOfferFromProxy(account: Address, offerId: UInt64) {
             pre {
                 self.removeOfferCapability[account] != nil:
                     "Cannot remove offers until the token admin has deposited the account registration capability"
@@ -132,8 +132,8 @@ pub contract DapperOffersV2 {
         // createOffer
         // Allows the DapperOffer owner to create Offers.
         //
-        pub fun createOffer(
-            vaultRefCapability: Capability<&{FungibleToken.Provider, FungibleToken.Balance}>,
+        access(all) fun createOffer(
+            vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Balance}>,
             nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
             nftType: Type,
             amount: UFix64,
@@ -165,26 +165,22 @@ pub contract DapperOffersV2 {
         // removeOffer
         // Remove an Offer that has not yet been accepted from the collection and destroy it.
         //
-        pub fun removeOffer(offerId: UInt64) {
+        access(all) 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] {
+        access(all) 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
-            }
+        access(all) fun borrowOffer(offerId: UInt64): &{OffersV2.OfferPublic}? {
+            return &self.offers[offerId]
         }
 
         // cleanup
@@ -192,7 +188,7 @@ pub contract DapperOffersV2 {
         // 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) {
+        access(all) fun cleanup(offerId: UInt64) {
             pre {
                 self.offers[offerId] != nil: "could not find Offer with given id"
             }
@@ -212,22 +208,22 @@ pub contract DapperOffersV2 {
 
         // destructor
         //
-        destroy() {
-            destroy self.offers
-            // Let event consumers know that this storefront exists.
-            emit DapperOfferDestroyed(DapperOfferResourceId: self.uuid)
-        }
+        // 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 {
+    access(all) fun createDapperOffer(): @DapperOffer {
         return <-create DapperOffer()
     }
 
-    pub let DapperOffersStoragePath: StoragePath
-    pub let DapperOffersPublicPath: PublicPath
+    access(all) let DapperOffersStoragePath: StoragePath
+    access(all) let DapperOffersPublicPath: PublicPath
 
     init () {
         self.DapperOffersStoragePath = /storage/DapperOffersV2

package/contracts/dapper/offers/OffersV2.cdc

@@ -3,6 +3,7 @@ import "NonFungibleToken"
 import "DapperUtilityCoin"
 import "MetadataViews"
 import "Resolver"
+import "ViewResolver"
 
 // OffersV2
 //
@@ -17,12 +18,12 @@ import "Resolver"
 // Marketplaces and other aggregators can watch for OfferAvailable events
 // and list offers of interest to logged in users.
 //
-pub contract OffersV2 {
+access(all) contract OffersV2 {
     // OfferAvailable
     // An Offer has been created and added to the users DapperOffer resource.
     //
 
-    pub event OfferAvailable(
+    access(all) event OfferAvailable(
         offerAddress: Address,
         offerId: UInt64,
         nftType: Type,
@@ -39,7 +40,7 @@ pub contract OffersV2 {
     // The Offer has been resolved. The offer has either been accepted
     //  by the NFT owner, or the offer has been removed and destroyed.
     //
-    pub event OfferCompleted(
+    access(all) event OfferCompleted(
         purchased: Bool,
         acceptingAddress: Address?,
         offerAddress: Address,
@@ -59,9 +60,9 @@ pub contract OffersV2 {
     // A struct representing a recipient that must be sent a certain amount
     // of the payment when a NFT is sold.
     //
-    pub struct Royalty {
-        pub let receiver: Capability<&{FungibleToken.Receiver}>
-        pub let amount: UFix64
+    access(all) struct Royalty {
+        access(all) let receiver: Capability<&{FungibleToken.Receiver}>
+        access(all) let amount: UFix64
 
         init(receiver: Capability<&{FungibleToken.Receiver}>, amount: UFix64) {
             self.receiver = receiver
@@ -72,23 +73,23 @@ pub contract OffersV2 {
     // OfferDetails
     // A struct containing Offers' data.
     //
-    pub struct OfferDetails {
+    access(all) struct OfferDetails {
         // The ID of the offer
-        pub let offerId: UInt64
+        access(all) let offerId: UInt64
         // The Type of the NFT
-        pub let nftType: Type
+        access(all) let nftType: Type
         // The Type of the FungibleToken that payments must be made in.
-        pub let paymentVaultType: Type
+        access(all) let paymentVaultType: Type
         // The Offer amount for the NFT
-        pub let offerAmount: UFix64
+        access(all) let offerAmount: UFix64
         // Flag to tracked the purchase state
-        pub var purchased: Bool
+        access(all) var purchased: Bool
         // This specifies the division of payment between recipients.
-        pub let royalties: [Royalty]
+        access(all) let royalties: [Royalty]
         // Used to hold Offer metadata and offer type information
-        pub let offerParamsString: {String: String}
-        pub let offerParamsUFix64: {String:UFix64}
-        pub let offerParamsUInt64: {String:UInt64}
+        access(all) let offerParamsString: {String: String}
+        access(all) let offerParamsUFix64: {String:UFix64}
+        access(all) let offerParamsUInt64: {String:UInt64}
 
         // setToPurchased
         // Irreversibly set this offer as purchased.
@@ -124,33 +125,33 @@ pub contract OffersV2 {
     // OfferPublic
     // An interface providing a useful public interface to an Offer resource.
     //
-    pub resource interface OfferPublic {
+    access(all) resource interface OfferPublic {
         // accept
         // This will accept the offer if provided with the NFT id that matches the Offer
         //
-        pub fun accept(
-            item: @AnyResource{NonFungibleToken.INFT, MetadataViews.Resolver},
+        access(all) fun accept(
+            item: @{NonFungibleToken.NFT, ViewResolver.Resolver},
             receiverCapability: Capability<&{FungibleToken.Receiver}>,
         ): Void
         // getDetails
         // Return Offer details
         //
-        pub fun getDetails(): OfferDetails
+        access(all) fun getDetails(): OfferDetails
     }
 
 
-    pub resource Offer: OfferPublic {
+    access(all) resource Offer: OfferPublic {
         // The OfferDetails struct of the Offer
         access(self) let details: OfferDetails
         // The vault which will handle the payment if the Offer is accepted.
-        access(contract) let vaultRefCapability: Capability<&{FungibleToken.Provider, FungibleToken.Balance}>
+        access(contract) let vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Balance}>
         // Receiver address for the NFT when/if the Offer is accepted.
         access(contract) let nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>
         // Resolver capability for the offer type
         access(contract) let resolverCapability: Capability<&{Resolver.ResolverPublic}>
 
         init(
-            vaultRefCapability: Capability<&{FungibleToken.Provider, FungibleToken.Balance}>,
+            vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Balance}>,
             nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
             nftType: Type,
             amount: UFix64,
@@ -208,8 +209,8 @@ pub contract OffersV2 {
         // - Provided with a NFT matching the NFT id within the Offer details.
         // - Provided with a NFT matching the NFT Type within the Offer details.
         //
-        pub fun accept(
-                item: @AnyResource{NonFungibleToken.INFT, MetadataViews.Resolver},
+        access(all) fun accept(
+                item: @{NonFungibleToken.NFT, ViewResolver.Resolver},
                 receiverCapability: Capability<&{FungibleToken.Receiver}>,
             ): Void {
 
@@ -220,7 +221,7 @@ pub contract OffersV2 {
 
             let resolverCapability = self.resolverCapability.borrow() ?? panic("could not borrow resolver")
             let resolverResult = resolverCapability.checkOfferResolver(
-                item: &item as &AnyResource{NonFungibleToken.INFT, MetadataViews.Resolver},
+                item: &item as &{NonFungibleToken.NFT, ViewResolver.Resolver},
                 offerParamsString: self.details.offerParamsString,
                 offerParamsUInt64: self.details.offerParamsUInt64,
                 offerParamsUFix64: self.details.offerParamsUFix64,
@@ -231,7 +232,7 @@ pub contract OffersV2 {
             }
 
             self.details.setToPurchased()
-            let nft <- item as! @NonFungibleToken.NFT
+            let nft <- item as! @{NonFungibleToken.NFT}
             let nftId: UInt64 = nft.id
             self.nftReceiverCapability.borrow()!.deposit(token: <- nft)
 
@@ -251,7 +252,7 @@ pub 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<&DapperUtilityCoin.Vault{FungibleToken.Provider, FungibleToken.Balance}>>()
+                Type<Capability<&{FungibleToken.Provider, FungibleToken.Balance}>>()
             )
 
             if isDucVault {
@@ -278,14 +279,14 @@ pub contract OffersV2 {
         // getDetails
         // Return Offer details
         //
-        pub fun getDetails(): OfferDetails {
+        access(all) fun getDetails(): OfferDetails {
             return self.details
         }
 
         // getRoyaltyInfo
         // Return royalty details
         //
-        pub fun getRoyaltyInfo(): {Address:UFix64} {
+        access(all) fun getRoyaltyInfo(): {Address:UFix64} {
             let royaltyInfo: {Address:UFix64} = {}
 
             for royalty in self.details.royalties {
@@ -294,30 +295,30 @@ pub 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,
-                )
-            }
-        }
+        // 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
-    pub fun makeOffer(
-        vaultRefCapability: Capability<&{FungibleToken.Provider, FungibleToken.Balance}>,
+    access(all) fun makeOffer(
+        vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Balance}>,
         nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
         nftType: Type,
         amount: UFix64,

package/contracts/dapper/offers/Resolver.cdc

@@ -1,20 +1,21 @@
 import "NonFungibleToken"
 import "MetadataViews"
+import "ViewResolver"
 import "TopShot"
 
-pub contract Resolver {
+access(all) contract Resolver {
     // Current list of supported resolution rules.
-    pub enum ResolverType: UInt8 {
-        pub case NFT
-        pub case TopShotEdition
-        pub case MetadataViewsEditions
+    access(all) enum ResolverType: UInt8 {
+        access(all) case NFT
+        access(all) case TopShotEdition
+        access(all) case MetadataViewsEditions
     }
 
     // Public resource interface that defines a method signature for checkOfferResolver
     // which is used within the Resolver resource for offer acceptance validation
-    pub resource interface ResolverPublic {
-        pub fun checkOfferResolver(
-         item: &AnyResource{NonFungibleToken.INFT, MetadataViews.Resolver},
+    access(all) resource interface ResolverPublic {
+        access(all) fun checkOfferResolver(
+         item: &{NonFungibleToken.NFT, ViewResolver.Resolver},
          offerParamsString: {String:String},
          offerParamsUInt64: {String:UInt64},
          offerParamsUFix64: {String:UFix64}): Bool
@@ -22,12 +23,12 @@ pub contract Resolver {
 
 
     // Resolver resource holds the Offer exchange resolution rules.
-    pub resource OfferResolver: ResolverPublic {
+    access(all) resource OfferResolver: ResolverPublic {
         // checkOfferResolver
         // Holds the validation rules for resolver each type of supported ResolverType
         // Function returns TRUE if the provided nft item passes the criteria for exchange
-        pub fun checkOfferResolver(
-         item: &AnyResource{NonFungibleToken.INFT, MetadataViews.Resolver},
+        access(all) fun checkOfferResolver(
+         item: &{NonFungibleToken.NFT, ViewResolver.Resolver},
          offerParamsString: {String:String},
          offerParamsUInt64: {String:UInt64},
          offerParamsUFix64: {String:UFix64}): Bool {
@@ -64,7 +65,7 @@ pub contract Resolver {
 
     }
 
-    pub fun createResolver(): @OfferResolver {
+    access(all) fun createResolver(): @OfferResolver {
         return <-create OfferResolver()
     }
 }