@flowtyio/flow-contracts 0.1.0-beta.15 → 0.1.0-beta.17

package/contracts/NonFungibleToken.cdc

@@ -49,9 +49,6 @@ access(all) contract interface NonFungibleToken: ViewResolver {
     /// An entitlement for allowing updates and update events for an NFT
     access(all) entitlement Update
 
-    /// entitlement for owner that grants Withdraw and Update
-    access(all) entitlement Owner
-
     /// Event that contracts should emit when the metadata of an NFT is updated
     /// It can only be emitted by calling the `emitNFTUpdated` function
     /// with an `Updatable` entitled reference to the NFT that was updated
@@ -63,7 +60,7 @@ access(all) contract interface NonFungibleToken: ViewResolver {
     /// and query the updated metadata from the owners' collections.
     ///
     access(all) event Updated(type: String, id: UInt64, uuid: UInt64, owner: Address?)
-    access(contract) view fun emitNFTUpdated(_ nftRef: auth(Update | Owner) &{NonFungibleToken.NFT})
+    access(all) view fun emitNFTUpdated(_ nftRef: auth(Update) &{NonFungibleToken.NFT})
     {
         emit Updated(type: nftRef.getType().identifier, id: nftRef.id, uuid: nftRef.uuid, owner: nftRef.owner?.address)
     }
@@ -85,9 +82,6 @@ access(all) contract interface NonFungibleToken: ViewResolver {
     ///
     access(all) event Deposited(type: String, id: UInt64, uuid: UInt64, to: Address?, collectionUUID: UInt64)
 
-    /// Included for backwards-compatibility
-    access(all) resource interface INFT: NFT {}
-
     /// Interface that the NFTs must conform to
     ///
     access(all) resource interface NFT: ViewResolver.Resolver {
@@ -105,6 +99,7 @@ access(all) contract interface NonFungibleToken: ViewResolver {
         access(all) fun createEmptyCollection(): @{Collection} {
             post {
                 result.getLength() == 0: "The created collection must be empty!"
+                result.isSupportedNFTType(type: self.getType()): "The created collection must support this NFT type"
             }
         }
 
@@ -141,7 +136,7 @@ access(all) contract interface NonFungibleToken: ViewResolver {
         /// withdraw removes an NFT from the collection and moves it to the caller
         /// It does not specify whether the ID is UUID or not
         /// @param withdrawID: The id of the NFT to withdraw from the collection
-        access(Withdraw | Owner) fun withdraw(withdrawID: UInt64): @{NFT} {
+        access(Withdraw) fun withdraw(withdrawID: UInt64): @{NFT} {
             post {
                 result.id == withdrawID: "The ID of the withdrawn token must be the same as the requested ID"
                 emit Withdrawn(type: result.getType().identifier, id: result.id, uuid: result.uuid, from: self.owner?.address, providerUUID: self.uuid)
@@ -174,6 +169,7 @@ access(all) contract interface NonFungibleToken: ViewResolver {
         access(all) fun deposit(token: @{NFT})
         access(all) view fun getLength(): Int
         access(all) view fun getIDs(): [UInt64]
+        access(all) fun forEachID(_ f: fun (UInt64): Bool): Void
         access(all) view fun borrowNFT(_ id: UInt64): &{NFT}?
     }
 
@@ -182,6 +178,8 @@ access(all) contract interface NonFungibleToken: ViewResolver {
     ///
     access(all) resource interface Collection: Provider, Receiver, CollectionPublic, ViewResolver.ResolverCollection {
 
+        access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
+
         /// deposit takes a NFT as an argument and stores it in the collection
         /// @param token: The NFT to deposit into the collection
         access(all) fun deposit(token: @{NonFungibleToken.NFT}) {
@@ -196,7 +194,16 @@ access(all) contract interface NonFungibleToken: ViewResolver {
 
         /// Gets the amount of NFTs stored in the collection
         /// @return An integer indicating the size of the collection
-        access(all) view fun getLength(): Int
+        access(all) view fun getLength(): Int {
+            return self.ownedNFTs.length
+        }
+
+        /// Allows a given function to iterate through the list
+        /// of owned NFT IDs in a collection without first
+        /// having to load the entire list into memory
+        access(all) fun forEachID(_ f: fun (UInt64): Bool): Void {
+            self.ownedNFTs.forEachKey(f)
+        }
 
         /// Borrows a reference to an NFT stored in the collection
         /// If the NFT with the specified ID is not in the collection,
@@ -231,4 +238,4 @@ access(all) contract interface NonFungibleToken: ViewResolver {
             result.getIDs().length == 0: "The created collection must be empty!"
         }
     }
-}
+}

package/contracts/dapper/TopShot.cdc

@@ -1060,7 +1060,7 @@ access(all) contract TopShot: NonFungibleToken {
     access(all) resource Collection: MomentCollectionPublic, NonFungibleToken.Collection {
         // Dictionary of Moment conforming tokens
         // NFT is a resource type with a UInt64 ID field
-        access(contract) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
+        access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
 
         init() {
             self.ownedNFTs <- {}
@@ -1098,7 +1098,7 @@ access(all) contract TopShot: NonFungibleToken {
         // that is to be removed from the Collection
         //
         // returns: @NonFungibleToken.NFT the token that was withdrawn
-        access(NonFungibleToken.Withdraw | NonFungibleToken.Owner) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
+        access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
 
             // Borrow nft and check if locked
             let nft = self.borrowNFT(withdrawID)
@@ -1124,7 +1124,7 @@ access(all) contract TopShot: NonFungibleToken {
         // Returns: @NonFungibleToken.Collection: A collection that contains
         //                                        the withdrawn moments
         //
-        access(NonFungibleToken.Withdraw | NonFungibleToken.Owner) fun batchWithdraw(ids: [UInt64]): @{NonFungibleToken.Collection} {
+        access(NonFungibleToken.Withdraw) fun batchWithdraw(ids: [UInt64]): @{NonFungibleToken.Collection} {
             // Create a new empty Collection
             var batchCollection <- create Collection()
             
@@ -1181,7 +1181,7 @@ access(all) contract TopShot: NonFungibleToken {
 
         // lock takes a token id and a duration in seconds and locks
         // the moment for that duration
-        access(NonFungibleToken.Update | NonFungibleToken.Owner) fun lock(id: UInt64, duration: UFix64) {
+        access(NonFungibleToken.Update) fun lock(id: UInt64, duration: UFix64) {
             // Remove the nft from the Collection
             let token <- self.ownedNFTs.remove(key: id) 
                 ?? panic("Cannot lock: Moment does not exist in the collection")
@@ -1195,7 +1195,7 @@ access(all) contract TopShot: NonFungibleToken {
 
         // batchLock takes an array of token ids and a duration in seconds
         // it iterates through the ids and locks each for the specified duration
-        access(NonFungibleToken.Update | NonFungibleToken.Owner) fun batchLock(ids: [UInt64], duration: UFix64) {
+        access(NonFungibleToken.Update) fun batchLock(ids: [UInt64], duration: UFix64) {
             // Iterate through the ids and lock them
             for id in ids {
                 self.lock(id: id, duration: duration)
@@ -1204,7 +1204,7 @@ access(all) contract TopShot: NonFungibleToken {
 
         // unlock takes a token id and attempts to unlock it
         // TopShotLocking.unlockNFT contains business logic around unlock eligibility
-        access(NonFungibleToken.Update | NonFungibleToken.Owner) fun unlock(id: UInt64) {
+        access(NonFungibleToken.Update) fun unlock(id: UInt64) {
             // Remove the nft from the Collection
             let token <- self.ownedNFTs.remove(key: id) 
                 ?? panic("Cannot lock: Moment does not exist in the collection")
@@ -1218,7 +1218,7 @@ access(all) contract TopShot: NonFungibleToken {
 
         // batchUnlock takes an array of token ids
         // it iterates through the ids and unlocks each if they are eligible
-        access(NonFungibleToken.Update | NonFungibleToken.Owner) fun batchUnlock(ids: [UInt64]) {
+        access(NonFungibleToken.Update) fun batchUnlock(ids: [UInt64]) {
             // Iterate through the ids and unlocks them
             for id in ids {
                 self.unlock(id: id)
@@ -1230,7 +1230,7 @@ access(all) contract TopShot: NonFungibleToken {
         //
         // Parameters: ids: An array of NFT IDs
         // to be destroyed from the Collection
-        access(NonFungibleToken.Update | NonFungibleToken.Owner) fun destroyMoments(ids: [UInt64]) {
+        access(NonFungibleToken.Update) fun destroyMoments(ids: [UInt64]) {
             let topShotLockingAdmin = TopShot.account.storage.borrow<&TopShotLocking.Admin>(from: TopShotLocking.AdminStoragePath())
                 ?? panic("No TopShotLocking admin resource in storage")
 

package/contracts/dapper/offers/OffersV2.cdc

@@ -130,7 +130,7 @@ access(all) contract OffersV2 {
         // This will accept the offer if provided with the NFT id that matches the Offer
         //
         access(all) fun accept(
-            item: @{NonFungibleToken.INFT, ViewResolver.Resolver},
+            item: @{NonFungibleToken.NFT, ViewResolver.Resolver},
             receiverCapability: Capability<&{FungibleToken.Receiver}>,
         ): Void
         // getDetails
@@ -210,7 +210,7 @@ access(all) contract OffersV2 {
         // - Provided with a NFT matching the NFT Type within the Offer details.
         //
         access(all) fun accept(
-                item: @{NonFungibleToken.INFT, ViewResolver.Resolver},
+                item: @{NonFungibleToken.NFT, ViewResolver.Resolver},
                 receiverCapability: Capability<&{FungibleToken.Receiver}>,
             ): Void {
 
@@ -221,7 +221,7 @@ access(all) contract OffersV2 {
 
             let resolverCapability = self.resolverCapability.borrow() ?? panic("could not borrow resolver")
             let resolverResult = resolverCapability.checkOfferResolver(
-                item: &item as &{NonFungibleToken.INFT, ViewResolver.Resolver},
+                item: &item as &{NonFungibleToken.NFT, ViewResolver.Resolver},
                 offerParamsString: self.details.offerParamsString,
                 offerParamsUInt64: self.details.offerParamsUInt64,
                 offerParamsUFix64: self.details.offerParamsUFix64,

package/contracts/dapper/offers/Resolver.cdc

@@ -15,7 +15,7 @@ access(all) contract Resolver {
     // which is used within the Resolver resource for offer acceptance validation
     access(all) resource interface ResolverPublic {
         access(all) fun checkOfferResolver(
-         item: &{NonFungibleToken.INFT, ViewResolver.Resolver},
+         item: &{NonFungibleToken.NFT, ViewResolver.Resolver},
          offerParamsString: {String:String},
          offerParamsUInt64: {String:UInt64},
          offerParamsUFix64: {String:UFix64}): Bool
@@ -28,7 +28,7 @@ access(all) contract Resolver {
         // Holds the validation rules for resolver each type of supported ResolverType
         // Function returns TRUE if the provided nft item passes the criteria for exchange
         access(all) fun checkOfferResolver(
-         item: &{NonFungibleToken.INFT, ViewResolver.Resolver},
+         item: &{NonFungibleToken.NFT, ViewResolver.Resolver},
          offerParamsString: {String:String},
          offerParamsUInt64: {String:UInt64},
          offerParamsUFix64: {String:UFix64}): Bool {

package/contracts/example/ExampleNFT.cdc

@@ -164,7 +164,7 @@ access(all) contract ExampleNFT: ViewResolver {
 
         // dictionary of NFT conforming tokens
         // NFT is a resource type with an `UInt64` ID field
-        access(self) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
+        access(all) var ownedNFTs: @{UInt64: {NonFungibleToken.NFT}}
 
         init () {
             self.ownedNFTs <- {}
@@ -206,7 +206,7 @@ access(all) contract ExampleNFT: ViewResolver {
         }
 
         // withdraw removes an NFT from the collection and moves it to the caller
-        access(NonFungibleToken.Withdraw | NonFungibleToken.Owner) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
+        access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
             let token <- self.ownedNFTs.remove(key: withdrawID) ?? panic("missing NFT")
 
             emit Withdraw(id: token.id, from: self.owner?.address)

package/contracts/flow-utils/ScopedNFTProviders.cdc

@@ -78,7 +78,7 @@ access(all) contract ScopedNFTProviders {
     //
     // Wrapper around an NFT Provider that is restricted to specific ids.
     access(all) resource ScopedNFTProvider: NonFungibleToken.Provider {
-        access(self) let provider: Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>
+        access(self) let provider: Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>
         access(self) let filters: [{NFTFilter}]
 
         // block timestamp that this provider can no longer be used after
@@ -91,7 +91,7 @@ access(all) contract ScopedNFTProviders {
             return false
         }
 
-        access(all) init(provider: Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>, filters: [{NFTFilter}], expiration: UFix64?) {
+        access(all) init(provider: Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>, filters: [{NFTFilter}], expiration: UFix64?) {
             self.provider = provider
             self.expiration = expiration
             self.filters = filters
@@ -125,7 +125,7 @@ access(all) contract ScopedNFTProviders {
             return self.provider.check()
         }
 
-        access(NonFungibleToken.Withdraw | NonFungibleToken.Owner) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
+        access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
             pre {
                 !self.isExpired(): "provider has expired"
             }
@@ -157,7 +157,7 @@ access(all) contract ScopedNFTProviders {
     }
 
     access(all) fun createScopedNFTProvider(
-        provider: Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>,
+        provider: Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>,
         filters: [{NFTFilter}],
         expiration: UFix64?
     ): @ScopedNFTProvider {

package/contracts/hybrid-custody/CapabilityDelegator.cdc

@@ -15,6 +15,9 @@ 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
     
     /* --- Events --- */
     //
@@ -123,7 +126,7 @@ access(all) contract CapabilityDelegator {
         /// @param cap: Capability to add
         /// @param isPublic: Whether the Capability should be public or private
         ///
-        access(Mutate | Insert) fun addCapability(cap: Capability, isPublic: Bool) {
+        access(Owner | Add) fun addCapability(cap: Capability, isPublic: Bool) {
             pre {
                 cap.check<&AnyResource>(): "Invalid Capability provided"
             }
@@ -139,7 +142,7 @@ access(all) contract CapabilityDelegator {
         ///
         /// @param cap: Capability to remove
         ///
-        access(Mutate | Remove) fun removeCapability(cap: Capability) {
+        access(Owner | 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

@@ -17,6 +17,10 @@ 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
     
     /// Factory structures a common interface for Capability retrieval from a given account at a specified path
     ///
@@ -60,7 +64,7 @@ access(all) contract CapabilityFactory {
         /// @param t: Type of Capability the Factory retrieves
         /// @param f: Factory to add
         ///
-        access(Mutate | Insert) fun addFactory(_ t: Type, _ f: {CapabilityFactory.Factory}) {
+        access(Owner | Add) fun addFactory(_ t: Type, _ f: {CapabilityFactory.Factory}) {
             pre {
                 !self.factories.containsKey(t): "Factory of given type already exists"
             }
@@ -72,7 +76,7 @@ access(all) contract CapabilityFactory {
         /// @param t: Type of Capability the Factory retrieves
         /// @param f: Factory to replace existing Factory
         ///
-        access(Mutate | Insert) fun updateFactory(_ t: Type, _ f: {CapabilityFactory.Factory}) {
+        access(Owner | Add) fun updateFactory(_ t: Type, _ f: {CapabilityFactory.Factory}) {
             self.factories[t] = f
         }
 
@@ -80,7 +84,7 @@ access(all) contract CapabilityFactory {
         ///
         /// @param t: Type the Factory is indexed on
         ///
-        access(Mutate | Remove) fun removeFactory(_ t: Type): {CapabilityFactory.Factory}? {
+        access(Owner | Delete) fun removeFactory(_ t: Type): {CapabilityFactory.Factory}? {
             return self.factories.remove(key: t)
         }
 

package/contracts/hybrid-custody/CapabilityFilter.cdc

@@ -13,6 +13,10 @@ 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
+
     /* --- Events --- */
     //
     access(all) event FilterUpdated(id: UInt64, filterType: Type, type: Type, active: Bool)
@@ -38,7 +42,7 @@ access(all) contract CapabilityFilter {
         /// 
         /// @param type: The type to add to the denied types mapping
         ///
-        access(Mutate | Insert) fun addType(_ type: Type) {
+        access(Owner | Add) fun addType(_ type: Type) {
             self.deniedTypes.insert(key: type, true)
             emit FilterUpdated(id: self.uuid, filterType: self.getType(), type: type, active: true)
         }
@@ -47,7 +51,7 @@ access(all) contract CapabilityFilter {
         ///
         /// @param type: The type to remove from the denied types mapping
         ///
-        access(Mutate | Remove) fun removeType(_ type: Type) {
+        access(Owner | 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)
             }
@@ -55,7 +59,7 @@ access(all) contract CapabilityFilter {
 
         /// Removes all types from the mapping of denied types
         ///
-        access(Mutate | Remove) fun removeAllTypes() {
+        access(Owner | Delete) fun removeAllTypes() {
             for type in self.deniedTypes.keys {
                 self.removeType(type)
             }
@@ -105,7 +109,7 @@ access(all) contract CapabilityFilter {
         /// 
         /// @param type: The type to add to the allowed types mapping
         ///
-        access(Mutate | Insert) fun addType(_ type: Type) {
+        access(Owner | Add) fun addType(_ type: Type) {
             self.allowedTypes.insert(key: type, true)
             emit FilterUpdated(id: self.uuid, filterType: self.getType(), type: type, active: true)
         }
@@ -114,7 +118,7 @@ access(all) contract CapabilityFilter {
         ///
         /// @param type: The type to remove from the denied types mapping
         ///
-        access(Mutate | Remove) fun removeType(_ type: Type) {
+        access(Owner | 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)
             }
@@ -122,7 +126,7 @@ access(all) contract CapabilityFilter {
 
         /// Removes all types from the mapping of denied types
         ///
-        access(Mutate | Remove) fun removeAllTypes() {
+        access(Owner | Delete) fun removeAllTypes() {
             for type in self.allowedTypes.keys {
                 self.removeType(type)
             }

package/contracts/hybrid-custody/HybridCustody.cdc

@@ -234,13 +234,13 @@ access(all) contract HybridCustody {
     /// Entry point for a parent to obtain, maintain and access Capabilities or perform other actions on child accounts
     ///
     access(all) resource interface ManagerPrivate {
-        access(Manage | Insert) fun addAccount(cap: Capability<auth(Child) &{AccountPrivate, AccountPublic, ViewResolver.Resolver}>)
+        access(Manage) fun addAccount(cap: Capability<auth(Child) &{AccountPrivate, AccountPublic, ViewResolver.Resolver}>)
         access(Manage) fun borrowAccount(addr: Address): auth(Child) &{AccountPrivate, AccountPublic, ViewResolver.Resolver}?
-        access(Manage | Remove) fun removeChild(addr: Address)
-        access(Manage | Insert) fun addOwnedAccount(cap: Capability<auth(Owner) &{OwnedAccountPrivate, OwnedAccountPublic, ViewResolver.Resolver}>)
+        access(Manage) fun removeChild(addr: Address)
+        access(Manage) fun addOwnedAccount(cap: Capability<auth(Owner) &{OwnedAccountPrivate, OwnedAccountPublic, ViewResolver.Resolver}>)
         access(Manage) fun borrowOwnedAccount(addr: Address): auth(Owner) &{OwnedAccountPrivate, OwnedAccountPublic, ViewResolver.Resolver}?
-        access(Manage | Remove) fun removeOwned(addr: Address)
-        access(Manage | Mutate) fun setManagerCapabilityFilter(cap: Capability<&{CapabilityFilter.Filter}>?, childAddress: Address) {
+        access(Manage) fun removeOwned(addr: Address)
+        access(Manage) fun setManagerCapabilityFilter(cap: Capability<&{CapabilityFilter.Filter}>?, childAddress: Address) {
             pre {
                 cap == nil || cap!.check(): "Invalid Manager Capability Filter"
             }
@@ -282,7 +282,7 @@ access(all) contract HybridCustody {
 
         /// Sets the Display on the ChildAccount. If nil, the display is removed.
         ///
-        access(Manage | Mutate) fun setChildAccountDisplay(address: Address, _ d: MetadataViews.Display?) {
+        access(Manage) fun setChildAccountDisplay(address: Address, _ d: MetadataViews.Display?) {
             pre {
                 self.childAccounts[address] != nil: "There is no child account with this address"
             }
@@ -316,7 +316,7 @@ access(all) contract HybridCustody {
 
         /// Sets the default Filter Capability for this Manager. Does not propagate to child accounts.
         ///
-        access(Manage | Mutate) fun setDefaultManagerCapabilityFilter(cap: Capability<&{CapabilityFilter.Filter}>?) {
+        access(Manage) fun setDefaultManagerCapabilityFilter(cap: Capability<&{CapabilityFilter.Filter}>?) {
             pre {
                 cap == nil || cap!.check(): "supplied capability must be nil or check must pass"
             }
@@ -326,7 +326,7 @@ access(all) contract HybridCustody {
 
         /// Sets the Filter Capability for this Manager, propagating to the specified child account
         ///
-        access(Manage | Mutate) fun setManagerCapabilityFilter(cap: Capability<&{CapabilityFilter.Filter}>?, childAddress: Address) {
+        access(Manage) fun setManagerCapabilityFilter(cap: Capability<&{CapabilityFilter.Filter}>?, childAddress: Address) {
             let acct = self.borrowAccount(addr: childAddress) 
                 ?? panic("child account not found")
 
@@ -1100,9 +1100,9 @@ access(all) contract HybridCustody {
 
         /// Retrieves a reference to the ChildAccount associated with the given parent account if one exists.
         ///
-        access(Owner) fun borrowChildAccount(parent: Address): auth(Capabilities) &ChildAccount? {
+        access(Owner) fun borrowChildAccount(parent: Address): auth(Child) &ChildAccount? {
             let identifier = HybridCustody.getChildAccountIdentifier(parent)
-            return self.borrowAccount().storage.borrow<auth(Capabilities) &ChildAccount>(from: StoragePath(identifier: identifier)!)
+            return self.borrowAccount().storage.borrow<auth(Child) &ChildAccount>(from: StoragePath(identifier: identifier)!)
         }
 
         /// Sets the CapabilityFactory Manager for the specified parent in the associated ChildAccount.
@@ -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(Mutate) &CapabilityDelegator.Delegator? {
+        access(Owner) fun borrowCapabilityDelegatorForParent(parent: Address): auth(CapabilityDelegator.Owner) &CapabilityDelegator.Delegator? {
             let identifier = HybridCustody.getCapabilityDelegatorIdentifier(parent)
-            return self.borrowAccount().storage.borrow<auth(Mutate) &CapabilityDelegator.Delegator>(from: StoragePath(identifier: identifier)!)
+            return self.borrowAccount().storage.borrow<auth(CapabilityDelegator.Owner) &CapabilityDelegator.Delegator>(from: StoragePath(identifier: identifier)!)
         }
 
         /// Adds the provided Capability to the Delegator associated with the given parent account.

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

@@ -5,11 +5,11 @@ access(all) contract FTAllFactory {
     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) {
-                if !con.capability.check<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Balance, FungibleToken.Receiver}>() {
+                if !con.capability.check<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Receiver, FungibleToken.Balance}>() {
                     return nil
                 }
                 
-                return con.capability as! Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Balance, FungibleToken.Receiver}>
+                return con.capability as! Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Receiver, FungibleToken.Balance}>
             }
 
             return nil

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

@@ -0,0 +1,45 @@
+import "CapabilityFactory"
+import "FungibleToken"
+
+access(all) contract FTVaultFactory {
+    access(all) struct WithdrawFactory: CapabilityFactory.Factory {
+        access(all) view fun getCapability(acct: auth(Capabilities) &Account, controllerID: UInt64): Capability? {
+            if let con = acct.capabilities.storage.getController(byCapabilityID: controllerID) {
+                if !con.capability.check<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>() {
+                    return nil
+                }
+                
+                return con.capability as! Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Vault}>
+            }
+
+            return nil
+        }
+
+        access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
+            return nil
+        }
+    }
+
+    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) {
+                if !con.capability.check<&{FungibleToken.Vault}>() {
+                    return nil
+                }
+                
+                return con.capability as! Capability<&{FungibleToken.Vault}>
+            }
+
+            return nil
+        }
+
+        access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
+            let cap = acct.capabilities.get<&{FungibleToken.Vault}>(path)
+            if !cap.check() {
+                return nil
+            }
+            
+            return cap
+        }
+    }
+}

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

@@ -0,0 +1,45 @@
+import "CapabilityFactory"
+import "NonFungibleToken"
+
+access(all) contract NFTProviderAndCollectionFactory {
+    access(all) struct WithdrawFactory: CapabilityFactory.Factory {
+        access(all) view fun getCapability(acct: auth(Capabilities) &Account, controllerID: UInt64): Capability? {
+            if let con = acct.capabilities.storage.getController(byCapabilityID: controllerID) {
+                if !con.capability.check<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>() {
+                    return nil
+                }
+
+                return con.capability as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>
+            }
+
+            return nil
+        }
+
+        access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
+            return nil
+        }
+    }
+
+    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) {
+                if !con.capability.check<&{NonFungibleToken.Collection}>() {
+                    return nil
+                }
+
+                return con.capability as! Capability<&{NonFungibleToken.Collection}>
+            }
+
+            return nil
+        }
+
+        access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
+            let cap = acct.capabilities.get<&{NonFungibleToken.Collection}>(path)
+            if !cap.check() {
+                return nil
+            }
+            
+            return cap
+        }
+    }
+}

package/package.json

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