@flowtyio/flow-contracts 0.1.0-beta.10 → 0.1.0-beta.12

package/contracts/flow-utils/ScopedFTProviders.cdc

@@ -57,6 +57,10 @@ access(all) contract ScopedFTProviders {
             self.expiration = expiration
         }
 
+        access(all) fun getProviderType(): Type {
+            return self.provider.borrow()!.getType()
+        }
+
         access(all) fun check(): Bool {
             return self.provider.check()
         }

package/contracts/hybrid-custody/CapabilityDelegator.cdc

@@ -7,48 +7,48 @@
 /// private `Delegator` can only be borrowed from the child account when you have access to the full `ChildAccount` 
 /// resource.
 ///
-pub contract CapabilityDelegator {
+access(all) contract CapabilityDelegator {
 
     /* --- Canonical Paths --- */
     //
-    pub let StoragePath: StoragePath
-    pub let PrivatePath: PrivatePath
-    pub let PublicPath: PublicPath
+    access(all) let StoragePath: StoragePath
+    access(all) let PrivatePath: PrivatePath
+    access(all) let PublicPath: PublicPath
     
     /* --- Events --- */
     //
-    pub event DelegatorCreated(id: UInt64)
-    pub event DelegatorUpdated(id: UInt64, capabilityType: Type, isPublic: Bool, active: Bool)
+    access(all) event DelegatorCreated(id: UInt64)
+    access(all) event DelegatorUpdated(id: UInt64, capabilityType: Type, isPublic: Bool, active: Bool)
 
     /// Private interface for Capability retrieval
     ///
-    pub resource interface GetterPrivate {
-        pub fun getPrivateCapability(_ type: Type): Capability? {
+    access(all) resource interface GetterPrivate {
+        access(Capabilities) view fun getPrivateCapability(_ type: Type): Capability? {
             post {
                 result == nil || type.isSubtype(of: result.getType()): "incorrect returned capability type"
             }
         }
-        pub fun findFirstPrivateType(_ type: Type): Type?
-        pub fun getAllPrivate(): [Capability]
+        access(all) view fun findFirstPrivateType(_ type: Type): Type?
+        access(Capabilities) fun getAllPrivate(): [Capability]
     }
 
     /// Exposes public Capability retrieval
     ///
-    pub resource interface GetterPublic {
-        pub fun getPublicCapability(_ type: Type): Capability? {
+    access(all) resource interface GetterPublic {
+        access(all) view fun getPublicCapability(_ type: Type): Capability? {
             post {
-                result == nil || type.isSubtype(of: result.getType()): "incorrect returned capability type "
+                result == nil || type.isSubtype(of: result.getType()): "incorrect returned capability type"
             }
         }
 
-        pub fun findFirstPublicType(_ type: Type): Type?
-        pub fun getAllPublic(): [Capability]
+        access(all) view fun findFirstPublicType(_ type: Type): Type?
+        access(all) view fun getAllPublic(): [Capability]
     }
 
     /// This Delegator is used to store Capabilities, partitioned by public and private access with corresponding
     /// GetterPublic and GetterPrivate conformances.AccountCapabilityController
     ///
-    pub resource Delegator: GetterPublic, GetterPrivate {
+    access(all) resource Delegator: GetterPublic, GetterPrivate {
         access(self) let privateCapabilities: {Type: Capability}
         access(self) let publicCapabilities: {Type: Capability}
 
@@ -56,7 +56,7 @@ pub contract CapabilityDelegator {
         //
         /// Returns the public Capability of the given Type if it exists
         ///
-        pub fun getPublicCapability(_ type: Type): Capability? {
+        access(all) view fun getPublicCapability(_ type: Type): Capability? {
             return self.publicCapabilities[type]
         }
 
@@ -66,7 +66,7 @@ pub contract CapabilityDelegator {
         /// @param type: Type of the Capability to retrieve
         /// @return Capability of the given Type if it exists, nil otherwise
         ///
-        pub fun getPrivateCapability(_ type: Type): Capability? {
+        access(Capabilities) view fun getPrivateCapability(_ type: Type): Capability? {
             return self.privateCapabilities[type]
         }
 
@@ -74,7 +74,7 @@ pub contract CapabilityDelegator {
         ///
         /// @return List of all public Capabilities
         ///
-        pub fun getAllPublic(): [Capability] {
+        access(all) view fun getAllPublic(): [Capability] {
             return self.publicCapabilities.values
         }
 
@@ -82,7 +82,7 @@ pub contract CapabilityDelegator {
         ///
         /// @return List of all private Capabilities
         ///
-        pub fun getAllPrivate(): [Capability] {
+        access(Capabilities) fun getAllPrivate(): [Capability] {
             return self.privateCapabilities.values
         }
 
@@ -91,7 +91,7 @@ pub contract CapabilityDelegator {
         /// @param type: Type to check for subtypes
         /// @return First public Type that is a subtype of the given Type, nil otherwise
         ///
-        pub fun findFirstPublicType(_ type: Type): Type? {
+        access(all) view fun findFirstPublicType(_ type: Type): Type? {
             for t in self.publicCapabilities.keys {
                 if t.isSubtype(of: type) {
                     return t
@@ -106,7 +106,7 @@ pub contract CapabilityDelegator {
         /// @param type: Type to check for subtypes
         /// @return First private Type that is a subtype of the given Type, nil otherwise
         ///
-        pub fun findFirstPrivateType(_ type: Type): Type? {
+        access(all) view fun findFirstPrivateType(_ type: Type): Type? {
             for t in self.privateCapabilities.keys {
                 if t.isSubtype(of: type) {
                     return t
@@ -122,7 +122,7 @@ pub contract CapabilityDelegator {
         /// @param cap: Capability to add
         /// @param isPublic: Whether the Capability should be public or private
         ///
-        pub fun addCapability(cap: Capability, isPublic: Bool) {
+        access(Mutate) fun addCapability(cap: Capability, isPublic: Bool) {
             pre {
                 cap.check<&AnyResource>(): "Invalid Capability provided"
             }
@@ -138,7 +138,7 @@ pub contract CapabilityDelegator {
         ///
         /// @param cap: Capability to remove
         ///
-        pub fun removeCapability(cap: Capability) {
+        access(Mutate) 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)
             }
@@ -158,7 +158,7 @@ pub contract CapabilityDelegator {
     /// 
     /// @return Newly created Delegator
     ///
-    pub fun createDelegator(): @Delegator {
+    access(all) fun createDelegator(): @Delegator {
         let delegator <- create Delegator()
         emit DelegatorCreated(id: delegator.uuid)
         return <- delegator

package/contracts/hybrid-custody/CapabilityFactory.cdc

@@ -13,37 +13,38 @@
 /// Capabilities is critical to the use case of Hybrid Custody. It's advised to use Factories sparingly and only for
 /// cases where Capabilities must be castable by the caller.
 ///
-pub contract CapabilityFactory {
+access(all) contract CapabilityFactory {
     
-    pub let StoragePath: StoragePath
-    pub let PrivatePath: PrivatePath
-    pub let PublicPath: PublicPath
+    access(all) let StoragePath: StoragePath
+    access(all) let PrivatePath: PrivatePath
+    access(all) let PublicPath: PublicPath
     
     /// Factory structures a common interface for Capability retrieval from a given account at a specified path
     ///
-    pub struct interface Factory {
-        pub fun getCapability(acct: &AuthAccount, path: CapabilityPath): Capability
+    access(all) struct interface Factory {
+        access(Capabilities) view fun getCapability(acct: auth(Capabilities) &Account, controllerID: UInt64): Capability?
+        access(all) view fun getPublicCapability(acct: auth(Capabilities) &Account, path: PublicPath): Capability?
     }
 
     /// Getter defines an interface for retrieval of a Factory if contained within the implementing resource
     ///
-    pub resource interface Getter {
-        pub fun getSupportedTypes(): [Type]
-        pub fun getFactory(_ t: Type): {CapabilityFactory.Factory}?
+    access(all) resource interface Getter {
+        access(all) view fun getSupportedTypes(): [Type]
+        access(all) view fun getFactory(_ t: Type): {CapabilityFactory.Factory}?
     }
 
     /// Manager is a resource that contains Factories and implements the Getter interface for retrieval of contained
     /// Factories
     ///
-    pub resource Manager: Getter {
+    access(all) resource Manager: Getter {
         /// Mapping of Factories indexed on Type of Capability they retrieve
-        pub let factories: {Type: {CapabilityFactory.Factory}}
+        access(all) let factories: {Type: {CapabilityFactory.Factory}}
 
         /// Retrieves a list of Types supported by contained Factories
         ///
         /// @return List of Types supported by the Manager
         ///
-        pub fun getSupportedTypes(): [Type] {
+        access(all) view fun getSupportedTypes(): [Type] {
             return self.factories.keys
         }
 
@@ -51,7 +52,7 @@ pub contract CapabilityFactory {
         ///
         /// @param t: Type the Factory is indexed on
         ///
-        pub fun getFactory(_ t: Type): {CapabilityFactory.Factory}? {
+        access(all) view fun getFactory(_ t: Type): {CapabilityFactory.Factory}? {
             return self.factories[t]
         }
 
@@ -60,7 +61,7 @@ pub contract CapabilityFactory {
         /// @param t: Type of Capability the Factory retrieves
         /// @param f: Factory to add
         ///
-        pub fun addFactory(_ t: Type, _ f: {CapabilityFactory.Factory}) {
+        access(Mutate) fun addFactory(_ t: Type, _ f: {CapabilityFactory.Factory}) {
             pre {
                 !self.factories.containsKey(t): "Factory of given type already exists"
             }
@@ -72,7 +73,7 @@ pub contract CapabilityFactory {
         /// @param t: Type of Capability the Factory retrieves
         /// @param f: Factory to replace existing Factory
         ///
-        pub fun updateFactory(_ t: Type, _ f: {CapabilityFactory.Factory}) {
+        access(Mutate) fun updateFactory(_ t: Type, _ f: {CapabilityFactory.Factory}) {
             self.factories[t] = f
         }
 
@@ -80,7 +81,7 @@ pub contract CapabilityFactory {
         ///
         /// @param t: Type the Factory is indexed on
         ///
-        pub fun removeFactory(_ t: Type): {CapabilityFactory.Factory}? {
+        access(Mutate) fun removeFactory(_ t: Type): {CapabilityFactory.Factory}? {
             return self.factories.remove(key: t)
         }
 
@@ -92,7 +93,7 @@ pub contract CapabilityFactory {
     /// Creates a Manager resource
     ///
     /// @return Manager resource
-    pub fun createFactoryManager(): @Manager {
+    access(all) fun createFactoryManager(): @Manager {
         return <- create Manager()
     }
 

package/contracts/hybrid-custody/CapabilityFilter.cdc

@@ -6,29 +6,29 @@
 /// - `AllowlistFilter` - A filter which contains a mapping of allowed Types
 /// - `AllowAllFilter`  - A passthrough, all requested capabilities are allowed
 /// 
-pub contract CapabilityFilter {
+access(all) contract CapabilityFilter {
     
     /* --- Canonical Paths --- */
     //
-    pub let StoragePath: StoragePath
-    pub let PublicPath: PublicPath
-    pub let PrivatePath: PrivatePath
+    access(all) let StoragePath: StoragePath
+    access(all) let PublicPath: PublicPath
+    access(all) let PrivatePath: PrivatePath
 
     /* --- Events --- */
     //
-    pub event FilterUpdated(id: UInt64, filterType: Type, type: Type, active: Bool)
+    access(all) event FilterUpdated(id: UInt64, filterType: Type, type: Type, active: Bool)
 
     /// `Filter` is a simple interface with methods to determine if a Capability is allowed and retrieve details about
     /// the Filter itself
     ///
-    pub resource interface Filter {
-        pub fun allowed(cap: Capability): Bool
-        pub fun getDetails(): AnyStruct
+    access(all) resource interface Filter {
+        access(all) view fun allowed(cap: Capability): Bool
+        access(all) view fun getDetails(): AnyStruct
     }
 
     /// `DenylistFilter` is a `Filter` which contains a mapping of denied Types
     ///
-    pub resource DenylistFilter: Filter {
+    access(all) resource DenylistFilter: Filter {
 
         /// Represents the underlying types which should not ever be returned by a RestrictedChildAccount. The filter
         /// will borrow a requested capability, and make sure that the type it gets back is not in the list of denied
@@ -39,7 +39,7 @@ pub contract CapabilityFilter {
         /// 
         /// @param type: The type to add to the denied types mapping
         ///
-        pub fun addType(_ type: Type) {
+        access(Mutate) fun addType(_ type: Type) {
             self.deniedTypes.insert(key: type, true)
             emit FilterUpdated(id: self.uuid, filterType: self.getType(), type: type, active: true)
         }
@@ -48,18 +48,26 @@ pub contract CapabilityFilter {
         ///
         /// @param type: The type to remove from the denied types mapping
         ///
-        pub fun removeType(_ type: Type) {
+        access(Mutate) fun removeType(_ type: Type) {
             if let removed = self.deniedTypes.remove(key: type) {
                 emit FilterUpdated(id: self.uuid, filterType: self.getType(), type: type, active: false)
             }
         }
 
+        /// Removes all types from the mapping of denied types
+        ///
+        access(Mutate) fun removeAllTypes() {
+            for type in self.deniedTypes.keys {
+                self.removeType(type)
+            }
+        }
+
         /// Determines if a requested capability is allowed by this `Filter`
         ///
         /// @param cap: The capability to check
         /// @return: true if the capability is allowed, false otherwise
         ///
-        pub fun allowed(cap: Capability): Bool {
+        access(all) view fun allowed(cap: Capability): Bool {
             if let item = cap.borrow<&AnyResource>() {
                 return !self.deniedTypes.containsKey(item.getType())
             }
@@ -72,7 +80,7 @@ pub contract CapabilityFilter {
         /// @return A struct containing details about this filter including this Filter's Type indexed on the `type`
         ///         key as well as types denied indexed on the `deniedTypes` key
         ///
-        pub fun getDetails(): AnyStruct {
+        access(all) view fun getDetails(): AnyStruct {
             return {
                 "type": self.getType(),
                 "deniedTypes": self.deniedTypes.keys
@@ -86,7 +94,7 @@ pub contract CapabilityFilter {
 
     /// `AllowlistFilter` is a `Filter` which contains a mapping of allowed Types
     ///
-    pub resource AllowlistFilter: Filter {
+    access(all) resource AllowlistFilter: Filter {
         // allowedTypes
         // Represents the set of underlying types which are allowed to be 
         // returned by a RestrictedChildAccount. The filter will borrow
@@ -98,7 +106,7 @@ pub contract CapabilityFilter {
         /// 
         /// @param type: The type to add to the allowed types mapping
         ///
-        pub fun addType(_ type: Type) {
+        access(Mutate) fun addType(_ type: Type) {
             self.allowedTypes.insert(key: type, true)
             emit FilterUpdated(id: self.uuid, filterType: self.getType(), type: type, active: true)
         }
@@ -107,18 +115,26 @@ pub contract CapabilityFilter {
         ///
         /// @param type: The type to remove from the denied types mapping
         ///
-        pub fun removeType(_ type: Type) {
+        access(Mutate) fun removeType(_ type: Type) {
             if let removed = self.allowedTypes.remove(key: type) {
                 emit FilterUpdated(id: self.uuid, filterType: self.getType(), type: type, active: false)
             }
         }
+
+        /// Removes all types from the mapping of denied types
+        ///
+        access(Mutate) fun removeAllTypes() {
+            for type in self.allowedTypes.keys {
+                self.removeType(type)
+            }
+        }
         
         /// Determines if a requested capability is allowed by this `Filter`
         ///
         /// @param cap: The capability to check
         /// @return: true if the capability is allowed, false otherwise
         ///
-        pub fun allowed(cap: Capability): Bool {
+        access(all) view fun allowed(cap: Capability): Bool {
             if let item = cap.borrow<&AnyResource>() {
                 return self.allowedTypes.containsKey(item.getType())
             }
@@ -131,7 +147,7 @@ pub contract CapabilityFilter {
         /// @return A struct containing details about this filter including this Filter's Type indexed on the `type`
         ///         key as well as types allowed indexed on the `allowedTypes` key
         ///
-        pub fun getDetails(): AnyStruct {
+        access(all) view fun getDetails(): AnyStruct {
             return {
                 "type": self.getType(),
                 "allowedTypes": self.allowedTypes.keys
@@ -145,13 +161,13 @@ pub contract CapabilityFilter {
 
     /// AllowAllFilter is a passthrough, all requested capabilities are allowed
     ///
-    pub resource AllowAllFilter: Filter {
+    access(all) resource AllowAllFilter: Filter {
         /// Determines if a requested capability is allowed by this `Filter`
         ///
         /// @param cap: The capability to check
         /// @return: true since this filter is a passthrough
         ///
-        pub fun allowed(cap: Capability): Bool {
+        access(all) view fun allowed(cap: Capability): Bool {
             return true
         }
         
@@ -160,7 +176,7 @@ pub contract CapabilityFilter {
         /// @return A struct containing details about this filter including this Filter's Type indexed on the `type`
         ///         key
         ///
-        pub fun getDetails(): AnyStruct {
+        access(all) view fun getDetails(): AnyStruct {
             return {
                 "type": self.getType()
             }
@@ -172,7 +188,7 @@ pub contract CapabilityFilter {
     /// @param t: The type of `Filter` to create
     /// @return: A new instance of the given `Filter` type
     ///
-    pub fun create(_ t: Type): @AnyResource{Filter} {
+    access(all) fun createFilter(_ t: Type): @{Filter} {
         post {
             result.getType() == t
         }