@flowtyio/flow-contracts 0.1.0-beta.14 → 0.1.0-beta.16

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.Collection}>
+        access(self) let provider: Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{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.Collection}>, filters: [{NFTFilter}], expiration: UFix64?) {
+        access(all) init(provider: Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>, filters: [{NFTFilter}], expiration: UFix64?) {
             self.provider = provider
             self.expiration = expiration
             self.filters = filters
@@ -102,7 +102,11 @@ access(all) contract ScopedNFTProviders {
                 return false
             }
 
-            let nft = self.provider.borrow()!.borrowNFT(id)
+            if !self.provider.check() {
+                return false
+            }
+
+            let nft: &{NonFungibleToken.NFT}? = self.provider.borrow()!.borrowNFT(id)
             if nft == nil {
                 return false
             }
@@ -153,11 +157,10 @@ access(all) contract ScopedNFTProviders {
     }
 
     access(all) fun createScopedNFTProvider(
-        provider: Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Collection}>,
+        provider: Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>,
         filters: [{NFTFilter}],
         expiration: UFix64?
     ): @ScopedNFTProvider {
         return <- create ScopedNFTProvider(provider: provider, filters: filters, expiration: expiration)
     }
-}
-
+}

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,48 @@
+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? {
+            if let cap = acct.capabilities.get<&{FungibleToken.Vault}>(path) {
+                if !cap.check() {
+                    return nil
+                }
+                
+                return cap
+            }
+
+            return nil
+        }
+    }
+}

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

@@ -0,0 +1,48 @@
+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.Owner) &{NonFungibleToken.Collection}>() {
+                    return nil
+                }
+
+                return con.capability as! Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{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? {
+            if let cap = acct.capabilities.get<&{NonFungibleToken.Collection}>(path) {
+                if !cap.check() {
+                    return nil
+                }
+                
+                return cap
+            }
+
+            return nil
+        }
+    }
+}

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

@@ -5,11 +5,11 @@ 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) {
-                if !con.capability.check<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>() {
+                if !con.capability.check<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>() {
                     return nil
                 }
 
-                return con.capability as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>
+                return con.capability as! Capability<auth(NonFungibleToken.Withdraw, NonFungibleToken.Owner) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>
             }
 
             return nil

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

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

package/flow.json

@@ -33,8 +33,8 @@
       "source": "./contracts/Burner.cdc",
       "aliases": {
         "emulator": "0xf8d6e0586b0a20c7",
-        "testnet": "0x631e88ae7f1d7c20",
-        "mainnet": "0x1d7e57aa55817448"
+        "testnet": "0x9a0766d93b6608b7",
+        "mainnet": "0xf233dcee88fe0abe"
       }
     },
     "MetadataViews": {

package/package.json

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