@flowtyio/flow-contracts 0.1.0-beta.22 → 0.1.0-beta.23

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.23",
     "main": "index.json",
     "description": "An NPM package for common flow contracts",
     "author": "flowtyio",