@flowtyio/flow-contracts 0.1.0-beta.22 → 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/contracts/hybrid-custody/CapabilityDelegator.cdc

@@ -15,7 +15,6 @@ access(all) contract CapabilityDelegator {
     access(all) let PublicPath: PublicPath
 
     access(all) entitlement Get
-    access(all) entitlement Owner
     access(all) entitlement Add
     access(all) entitlement Delete
     
@@ -126,7 +125,7 @@ access(all) contract CapabilityDelegator {
         /// @param cap: Capability to add
         /// @param isPublic: Whether the Capability should be public or private
         ///
-        access(Owner | Add) fun addCapability(cap: Capability, isPublic: Bool) {
+        access(Add) fun addCapability(cap: Capability, isPublic: Bool) {
             pre {
                 cap.check<&AnyResource>(): "Invalid Capability provided"
             }
@@ -142,7 +141,7 @@ access(all) contract CapabilityDelegator {
         ///
         /// @param cap: Capability to remove
         ///
-        access(Owner | Delete) fun removeCapability(cap: Capability) {
+        access(Delete) fun removeCapability(cap: Capability) {
             if let removedPublic = self.publicCapabilities.remove(key: cap.getType()) {
                 emit DelegatorUpdated(id: self.uuid, capabilityType: cap.getType(), isPublic: true, active: false)
             }

package/contracts/hybrid-custody/CapabilityFactory.cdc

@@ -18,7 +18,6 @@ access(all) contract CapabilityFactory {
     access(all) let StoragePath: StoragePath
     access(all) let PublicPath: PublicPath
 
-    access(all) entitlement Owner
     access(all) entitlement Add
     access(all) entitlement Delete
     
@@ -64,7 +63,7 @@ access(all) contract CapabilityFactory {
         /// @param t: Type of Capability the Factory retrieves
         /// @param f: Factory to add
         ///
-        access(Owner | Add) fun addFactory(_ t: Type, _ f: {CapabilityFactory.Factory}) {
+        access(Add) fun addFactory(_ t: Type, _ f: {CapabilityFactory.Factory}) {
             pre {
                 !self.factories.containsKey(t): "Factory of given type already exists"
             }
@@ -76,7 +75,7 @@ access(all) contract CapabilityFactory {
         /// @param t: Type of Capability the Factory retrieves
         /// @param f: Factory to replace existing Factory
         ///
-        access(Owner | Add) fun updateFactory(_ t: Type, _ f: {CapabilityFactory.Factory}) {
+        access(Add) fun updateFactory(_ t: Type, _ f: {CapabilityFactory.Factory}) {
             self.factories[t] = f
         }
 
@@ -84,7 +83,7 @@ access(all) contract CapabilityFactory {
         ///
         /// @param t: Type the Factory is indexed on
         ///
-        access(Owner | Delete) fun removeFactory(_ t: Type): {CapabilityFactory.Factory}? {
+        access(Delete) fun removeFactory(_ t: Type): {CapabilityFactory.Factory}? {
             return self.factories.remove(key: t)
         }
 

package/contracts/hybrid-custody/CapabilityFilter.cdc

@@ -13,7 +13,6 @@ access(all) contract CapabilityFilter {
     access(all) let StoragePath: StoragePath
     access(all) let PublicPath: PublicPath
 
-    access(all) entitlement Owner
     access(all) entitlement Add
     access(all) entitlement Delete
 
@@ -42,7 +41,7 @@ access(all) contract CapabilityFilter {
         /// 
         /// @param type: The type to add to the denied types mapping
         ///
-        access(Owner | Add) fun addType(_ type: Type) {
+        access(Add) fun addType(_ type: Type) {
             self.deniedTypes.insert(key: type, true)
             emit FilterUpdated(id: self.uuid, filterType: self.getType(), type: type, active: true)
         }
@@ -51,7 +50,7 @@ access(all) contract CapabilityFilter {
         ///
         /// @param type: The type to remove from the denied types mapping
         ///
-        access(Owner | Delete) fun removeType(_ type: Type) {
+        access(Delete) fun removeType(_ type: Type) {
             if let removed = self.deniedTypes.remove(key: type) {
                 emit FilterUpdated(id: self.uuid, filterType: self.getType(), type: type, active: false)
             }
@@ -59,7 +58,7 @@ access(all) contract CapabilityFilter {
 
         /// Removes all types from the mapping of denied types
         ///
-        access(Owner | Delete) fun removeAllTypes() {
+        access(Delete) fun removeAllTypes() {
             for type in self.deniedTypes.keys {
                 self.removeType(type)
             }
@@ -109,7 +108,7 @@ access(all) contract CapabilityFilter {
         /// 
         /// @param type: The type to add to the allowed types mapping
         ///
-        access(Owner | Add) fun addType(_ type: Type) {
+        access(Add) fun addType(_ type: Type) {
             self.allowedTypes.insert(key: type, true)
             emit FilterUpdated(id: self.uuid, filterType: self.getType(), type: type, active: true)
         }
@@ -118,7 +117,7 @@ access(all) contract CapabilityFilter {
         ///
         /// @param type: The type to remove from the denied types mapping
         ///
-        access(Owner | Delete) fun removeType(_ type: Type) {
+        access(Delete) fun removeType(_ type: Type) {
             if let removed = self.allowedTypes.remove(key: type) {
                 emit FilterUpdated(id: self.uuid, filterType: self.getType(), type: type, active: false)
             }
@@ -126,7 +125,7 @@ access(all) contract CapabilityFilter {
 
         /// Removes all types from the mapping of denied types
         ///
-        access(Owner | Delete) fun removeAllTypes() {
+        access(Delete) fun removeAllTypes() {
             for type in self.allowedTypes.keys {
                 self.removeType(type)
             }

package/contracts/hybrid-custody/HybridCustody.cdc

@@ -115,7 +115,7 @@ access(all) contract HybridCustody {
         /// access control are managed through the child account.
         access(Owner) fun publishToParent(
             parentAddress: Address,
-            factory: Capability<&{CapabilityFactory.Getter}>,
+            factory: Capability<&CapabilityFactory.Manager>,
             filter: Capability<&{CapabilityFilter.Filter}>
         ) {
             pre {
@@ -140,7 +140,7 @@ access(all) contract HybridCustody {
         // setCapabilityFactoryForParent
         // Override the existing CapabilityFactory Capability for a given parent. This will allow the owner of the
         // account to start managing their own factory of capabilities to be able to retrieve
-        access(Owner) fun setCapabilityFactoryForParent(parent: Address, cap: Capability<&{CapabilityFactory.Getter}>) {
+        access(Owner) fun setCapabilityFactoryForParent(parent: Address, cap: Capability<&CapabilityFactory.Manager>) {
             pre {
                 cap.check(): "Invalid CapabilityFactory.Getter Capability provided"
             }
@@ -529,7 +529,7 @@ access(all) contract HybridCustody {
         /// account. The CapabilityFactory returns Capabilities which can be casted to their appropriate types once
         /// obtained, but only if the child account has configured their factory to allow it. For instance, a
         /// ChildAccount might choose to expose NonFungibleToken.Provider, but not FungibleToken.Provider
-        access(self) var factory: Capability<&{CapabilityFactory.Getter}>
+        access(self) var factory: Capability<&CapabilityFactory.Manager>
 
         /// The CapabilityFilter is a restriction put at the front of obtaining any non-public Capability. Some wallets
         /// might want to give access to NonFungibleToken.Provider, but only to **some** of the collections it manages,
@@ -541,7 +541,7 @@ access(all) contract HybridCustody {
         /// certain type. When using the CapabilityDelegator, you do not have the ability to specify which path a
         /// capability came from. For instance, Dapper Wallet might choose to expose a Capability to their Full TopShot
         /// collection, but only to the path that the collection exists in.
-        access(self) let delegator: Capability<auth(CapabilityDelegator.Get) &{CapabilityDelegator.GetterPublic, CapabilityDelegator.GetterPrivate}>
+        access(self) let delegator: Capability<auth(CapabilityDelegator.Get) &CapabilityDelegator.Delegator>
 
         /// managerCapabilityFilter is a component optionally given to a child account when a manager redeems it. If
         /// this filter is not nil, any Capability returned through the `getCapability` function checks that the
@@ -580,7 +580,7 @@ access(all) contract HybridCustody {
 
         /// Sets the CapabiltyFactory.Manager Capability
         ///
-        access(contract) fun setCapabilityFactory(cap: Capability<&{CapabilityFactory.Getter}>) {
+        access(contract) fun setCapabilityFactory(cap: Capability<&CapabilityFactory.Manager>) {
             self.factory = cap
         }
  
@@ -730,9 +730,9 @@ access(all) contract HybridCustody {
 
         init(
             _ childCap: Capability<&{BorrowableAccount, OwnedAccountPublic, ViewResolver.Resolver}>,
-            _ factory: Capability<&{CapabilityFactory.Getter}>,
+            _ factory: Capability<&CapabilityFactory.Manager>,
             _ filter: Capability<&{CapabilityFilter.Filter}>,
-            _ delegator: Capability<auth(CapabilityDelegator.Get) &{CapabilityDelegator.GetterPublic, CapabilityDelegator.GetterPrivate}>,
+            _ delegator: Capability<auth(CapabilityDelegator.Get) &CapabilityDelegator.Delegator>,
             _ parent: Address
         ) {
             pre {
@@ -853,7 +853,7 @@ access(all) contract HybridCustody {
         ///
         access(Owner) fun publishToParent(
             parentAddress: Address,
-            factory: Capability<&{CapabilityFactory.Getter}>,
+            factory: Capability<&CapabilityFactory.Manager>,
             filter: Capability<&{CapabilityFilter.Filter}>
         ) {
             pre {
@@ -880,7 +880,7 @@ access(all) contract HybridCustody {
             let pubCap = acct.capabilities.storage.issue<&{CapabilityDelegator.GetterPublic}>(capDelegatorStorage)
             acct.capabilities.publish(pubCap, at: capDelegatorPublic)
 
-            let delegator = acct.capabilities.storage.issue<auth(CapabilityDelegator.Get) &{CapabilityDelegator.GetterPublic, CapabilityDelegator.GetterPrivate}>(capDelegatorStorage)
+            let delegator = acct.capabilities.storage.issue<auth(CapabilityDelegator.Get) &CapabilityDelegator.Delegator>(capDelegatorStorage)
             assert(delegator.check(), message: "failed to setup capability delegator for parent address")
 
             let borrowableCap = self.borrowAccount().capabilities.storage.issue<&{BorrowableAccount, OwnedAccountPublic, ViewResolver.Resolver}>(
@@ -1109,7 +1109,7 @@ access(all) contract HybridCustody {
         ///
         access(Owner) fun setCapabilityFactoryForParent(
             parent: Address,
-            cap: Capability<&{CapabilityFactory.Getter}>
+            cap: Capability<&CapabilityFactory.Manager>
         ) {
             let p = self.borrowChildAccount(parent: parent) ?? panic("could not find parent address")
             p.setCapabilityFactory(cap: cap)
@@ -1124,9 +1124,9 @@ access(all) contract HybridCustody {
 
         /// Retrieves a reference to the Delegator associated with the given parent account if one exists.
         ///
-        access(Owner) fun borrowCapabilityDelegatorForParent(parent: Address): auth(CapabilityDelegator.Owner) &CapabilityDelegator.Delegator? {
+        access(Owner) fun borrowCapabilityDelegatorForParent(parent: Address): auth(CapabilityDelegator.Get, CapabilityDelegator.Add, CapabilityDelegator.Delete) &CapabilityDelegator.Delegator? {
             let identifier = HybridCustody.getCapabilityDelegatorIdentifier(parent)
-            return self.borrowAccount().storage.borrow<auth(CapabilityDelegator.Owner) &CapabilityDelegator.Delegator>(from: StoragePath(identifier: identifier)!)
+            return self.borrowAccount().storage.borrow<auth(CapabilityDelegator.Get, CapabilityDelegator.Add, CapabilityDelegator.Delete) &CapabilityDelegator.Delegator>(from: StoragePath(identifier: identifier)!)
         }
 
         /// Adds the provided Capability to the Delegator associated with the given parent account.

package/contracts/hybrid-custody/factories/FTVaultFactory.cdc

@@ -38,8 +38,9 @@ access(all) contract FTVaultFactory {
             if !cap.check() {
                 return nil
             }
-            
+                
             return cap
+
         }
     }
 }

package/contracts/hybrid-custody/factories/{NFTProviderAndCollectionPublicFactory.cdc → NFTProviderAndCollectionFactory.cdc}

@@ -1,7 +1,7 @@
 import "CapabilityFactory"
 import "NonFungibleToken"
 
-access(all) contract NFTProviderAndCollectionPublicFactory {
+access(all) contract NFTProviderAndCollectionFactory {
     access(all) struct Factory: CapabilityFactory.Factory {
         access(all) view fun getCapability(acct: auth(Capabilities) &Account, controllerID: UInt64): Capability? {
             if let con = acct.capabilities.storage.getController(byCapabilityID: controllerID) {

package/package.json

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