@flowtyio/flow-contracts 0.1.0-beta.11 → 0.1.0-beta.13

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

@@ -1,10 +1,22 @@
 import "CapabilityFactory"
 import "FungibleToken"
 
-pub contract FTAllFactory {
-    pub struct Factory: CapabilityFactory.Factory {
-        pub fun getCapability(acct: &AuthAccount, path: CapabilityPath): Capability {
-            return acct.getCapability<&{FungibleToken.Provider, FungibleToken.Balance, FungibleToken.Receiver}>(path)
+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}>() {
+                    return nil
+                }
+                
+                return con.capability as! Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Balance, FungibleToken.Receiver}>
+            }
+
+            return nil
+        }
+
+        access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
+            return nil
         }
     }
 }

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

@@ -1,10 +1,22 @@
 import "CapabilityFactory"
 import "FungibleToken"
 
-pub contract FTBalanceFactory {
-    pub struct Factory: CapabilityFactory.Factory {
-        pub fun getCapability(acct: &AuthAccount, path: CapabilityPath): Capability {
-            return acct.getCapability<&{FungibleToken.Balance}>(path)
+access(all) contract FTBalanceFactory {
+    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.Balance}>() {
+                    return nil
+                }
+
+                return con.capability as! Capability<&{FungibleToken.Balance}>
+            }
+
+            return nil
+        }
+
+        access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
+            return acct.capabilities.get<&{FungibleToken.Balance}>(path)
         }
     }
 }

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

@@ -1,10 +1,22 @@
 import "CapabilityFactory"
 import "FungibleToken"
 
-pub contract FTProviderFactory {
-    pub struct Factory: CapabilityFactory.Factory {
-        pub fun getCapability(acct: &AuthAccount, path: CapabilityPath): Capability {
-            return acct.getCapability<&{FungibleToken.Provider}>(path)
+access(all) contract FTProviderFactory {
+    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}>() {
+                    return nil
+                }
+
+                return con.capability as! Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>
+            }
+
+            return nil
+        }
+
+        access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
+            return nil
         }
     }
-}
+}

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

@@ -1,10 +1,22 @@
 import "CapabilityFactory"
 import "FungibleToken"
 
-pub contract FTReceiverBalanceFactory {
-    pub struct Factory: CapabilityFactory.Factory {
-        pub fun getCapability(acct: &AuthAccount, path: CapabilityPath): Capability {
-            return acct.getCapability<&{FungibleToken.Receiver, FungibleToken.Balance}>(path)
+access(all) contract FTReceiverBalanceFactory {
+    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.Receiver, FungibleToken.Balance}>() {
+                    return nil
+                }
+
+                return con.capability as! Capability<&{FungibleToken.Receiver, FungibleToken.Balance}>
+            }
+
+            return nil
+        }
+
+        access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
+            return acct.capabilities.get<&{FungibleToken.Receiver, FungibleToken.Balance}>(path)
         }
     }
 }

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

@@ -1,10 +1,22 @@
 import "CapabilityFactory"
 import "FungibleToken"
 
-pub contract FTReceiverFactory {
-    pub struct Factory: CapabilityFactory.Factory {
-        pub fun getCapability(acct: &AuthAccount, path: CapabilityPath): Capability {
-            return acct.getCapability<&{FungibleToken.Receiver}>(path)
+access(all) contract FTReceiverFactory {
+    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.Receiver}>() {
+                    return nil
+                }
+
+                return con.capability as! Capability<&{FungibleToken.Receiver}>
+            }
+
+            return nil
+        }
+
+        access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
+            return acct.capabilities.get<&{FungibleToken.Receiver}>(path)
         }
     }
 }

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

@@ -1,10 +1,22 @@
 import "CapabilityFactory"
 import "NonFungibleToken"
 
-pub contract NFTCollectionPublicFactory {
-    pub struct Factory: CapabilityFactory.Factory {
-        pub fun getCapability(acct: &AuthAccount, path: CapabilityPath): Capability {
-            return acct.getCapability<&{NonFungibleToken.CollectionPublic}>(path)
+access(all) contract NFTCollectionPublicFactory {
+    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.CollectionPublic}>() {
+                    return nil
+                }
+
+                return con.capability as! Capability<&{NonFungibleToken.CollectionPublic}>
+            }
+
+            return nil
+        }
+
+        access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
+            return acct.capabilities.get<&{NonFungibleToken.CollectionPublic}>(path)
         }
     }
 }

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

@@ -0,0 +1,22 @@
+import "CapabilityFactory"
+import "NonFungibleToken"
+
+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}>() {
+                    return nil
+                }
+
+                return con.capability as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>
+            }
+
+            return nil
+        }
+
+        access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
+            return nil
+        }
+    }
+}

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

@@ -1,10 +1,22 @@
 import "CapabilityFactory"
 import "NonFungibleToken"
 
-pub contract NFTProviderFactory {
-    pub struct Factory: CapabilityFactory.Factory {
-        pub fun getCapability(acct: &AuthAccount, path: CapabilityPath): Capability {
-            return acct.getCapability<&{NonFungibleToken.Provider}>(path)
+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}>() {
+                    return nil
+                }
+
+                return con.capability as! Capability<auth(NonFungibleToken.Withdraw) &{NonFungibleToken.Provider}>
+            }
+
+            return nil
+        }
+
+        access(all) view fun getPublicCapability(acct: &Account, path: PublicPath): Capability? {
+            return nil
         }
     }
 }

package/package.json

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

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

@@ -1,10 +0,0 @@
-import "CapabilityFactory"
-import "NonFungibleToken"
-
-pub contract NFTProviderAndCollectionFactory {
-    pub struct Factory: CapabilityFactory.Factory {
-        pub fun getCapability(acct: &AuthAccount, path: CapabilityPath): Capability {
-            return acct.getCapability<&{NonFungibleToken.Provider, NonFungibleToken.CollectionPublic}>(path)
-        }
-    }
-}