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

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

@@ -2,6 +2,8 @@ import "OffersV2"
 import "FungibleToken"
 import "NonFungibleToken"
 import "Resolver"
+import "ViewResolver"
+
 
 // DapperOffersV2
 //
@@ -11,59 +13,62 @@ 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 {
+
+    access(all) entitlement Manager
+    access(all) entitlement ProxyManager
     // 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<auth(ProxyManager) &DapperOffer>
         )
     }
 
     // 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(Manager) fun createOffer(
+            vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>,
             nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
             nftType: Type,
             amount: UFix64,
@@ -76,21 +81,21 @@ pub contract DapperOffersV2 {
         // removeOffer
         // Allows the DapperOffer owner to remove offers
         //
-        pub fun removeOffer(offerId: UInt64)
+        access(Manager | ProxyManager) 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(Manager | ProxyManager) fun removeOffer(offerId: UInt64)
         // removeOfferFromProxy
         // Allows the DapperOffer proxy owner to remove offers
         //
-        pub fun removeOfferFromProxy(account: Address, offerId: UInt64)
+        access(ProxyManager) fun removeOfferFromProxy(account: Address, offerId: UInt64)
     }
 
 
@@ -98,18 +103,18 @@ 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<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.
         //
-        pub fun addProxyCapability(account: Address, cap: Capability<&DapperOffer{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 @@ pub contract DapperOffersV2 {
         // removeOfferFromProxy
         // Allows the DapperOffer proxy owner to remove offers
         //
-        pub 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.
         //
-        pub fun createOffer(
-            vaultRefCapability: Capability<&{FungibleToken.Provider, FungibleToken.Balance}>,
+        access(Manager) fun createOffer(
+            vaultRefCapability: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>,
             nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
             nftType: Type,
             amount: UFix64,
@@ -165,23 +170,25 @@ pub contract DapperOffersV2 {
         // 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")
+        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
         //
-        pub 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.
         //
-        pub fun borrowOffer(offerId: UInt64): &OffersV2.Offer{OffersV2.OfferPublic}? {
+        access(all) view fun borrowOffer(offerId: UInt64): &{OffersV2.OfferPublic}? {
             if self.offers[offerId] != nil {
-                return (&self.offers[offerId] as &OffersV2.Offer{OffersV2.OfferPublic}?)!
+                return (&self.offers[offerId] as &{OffersV2.OfferPublic}?)!
             } else {
                 return nil
             }
@@ -192,7 +199,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"
             }
@@ -210,24 +217,20 @@ pub 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
     // 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
@@ -235,4 +238,4 @@ pub contract DapperOffersV2 {
 
         emit DapperOffersInitialized()
     }
-}
+}

package/contracts/dapper/offers/OffersV2.cdc

@@ -2,9 +2,10 @@ import "FungibleToken"
 import "NonFungibleToken"
 import "DapperUtilityCoin"
 import "MetadataViews"
+import "ViewResolver"
 import "Resolver"
 
-// OffersV2
+/// OffersV2
 //
 // Contract holds the Offer resource and a public method to create them.
 //
@@ -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,37 @@ 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 {
+
+        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.
-        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.Vault}>,
             nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
             nftType: Type,
             amount: UFix64,
@@ -208,8 +213,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 +225,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 +236,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,8 +256,8 @@ 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<&DapperUtilityCoin.Vault>>()
+            ) // todo: check if this is correct
 
             if isDucVault {
                 assert(self.vaultRefCapability.borrow()!.balance == initalDucSupply, message: "DUC is leaking")
@@ -278,14 +283,14 @@ pub contract OffersV2 {
         // getDetails
         // Return Offer details
         //
-        pub fun getDetails(): OfferDetails {
+        access(all) view fun getDetails(): OfferDetails {
             return self.details
         }
 
         // getRoyaltyInfo
         // Return royalty details
         //
-        pub fun getRoyaltyInfo(): {Address:UFix64} {
+        access(all) view fun getRoyaltyInfo(): {Address:UFix64} {
             let royaltyInfo: {Address:UFix64} = {}
 
             for royalty in self.details.royalties {
@@ -293,31 +298,11 @@ 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,
-                )
-            }
-        }
     }
 
     // makeOffer
-    pub fun makeOffer(
-        vaultRefCapability: Capability<&{FungibleToken.Provider, FungibleToken.Balance}>,
+    access(all) fun makeOffer(
+        vaultRefCapability:  Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>,
         nftReceiverCapability: Capability<&{NonFungibleToken.CollectionPublic}>,
         nftType: Type,
         amount: UFix64,
@@ -340,5 +325,4 @@ pub contract OffersV2 {
         )
         return <-newOfferResource
     }
-}
- 
+}

package/contracts/dapper/offers/Resolver.cdc

@@ -1,20 +1,27 @@
 import "NonFungibleToken"
 import "MetadataViews"
 import "TopShot"
+import "ViewResolver"
 
-pub contract Resolver {
+// 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.
-    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,19 +29,19 @@ 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 {
             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
@@ -64,7 +71,7 @@ pub contract Resolver {
 
     }
 
-    pub fun createResolver(): @OfferResolver {
+    access(all) fun createResolver(): @OfferResolver {
         return <-create OfferResolver()
     }
 }