@flowtyio/flow-contracts 0.1.0-beta.2 → 0.1.0-beta.21

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.Receiver, FungibleToken.Balance}>() {
+                    return nil
+                }
+                
+                return con.capability as! Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider, FungibleToken.Receiver, FungibleToken.Balance}>
+            }
+
+            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/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/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/NFTProviderAndCollectionPublicFactory.cdc

@@ -1,10 +1,22 @@
 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)
+access(all) contract NFTProviderAndCollectionPublicFactory {
+    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/contracts/lost-and-found/LostAndFound.cdc

@@ -125,7 +125,7 @@ access(all) contract LostAndFound {
             if self.type.isSubtype(of: Type<@{NonFungibleToken.NFT}>()) {
                 let ref = (&self.item as &AnyResource?)!
                 let nft = ref as! &{NonFungibleToken.NFT}
-                return nft.getID()
+                return nft.id
             }
             return nil
         }
@@ -135,7 +135,7 @@ access(all) contract LostAndFound {
             if self.type.isSubtype(of: Type<@{FungibleToken.Vault}>()) {
                 let ref = (&self.item as &AnyResource?)!
                 let ft = ref as! &{FungibleToken.Vault}
-                return ft.getBalance()
+                return ft.balance
             }
             return nil
         }
@@ -149,8 +149,8 @@ access(all) contract LostAndFound {
             var redeemableItem <- self.item <- nil
             let cap = receiver.borrow<&AnyResource>()!
 
-            if cap.isInstance(Type<@{NonFungibleToken.Collection}>()) {
-                let target = receiver.borrow<&{NonFungibleToken.Collection}>()!
+            if cap.isInstance(Type<@{NonFungibleToken.CollectionPublic}>()) {
+                let target = receiver.borrow<&{NonFungibleToken.CollectionPublic}>()!
                 let token <- redeemableItem  as! @{NonFungibleToken.NFT}?
                 self.redeemed = true
                 emit TicketRedeemed(redeemer: self.redeemer, ticketID: self.uuid, type: token.getType())
@@ -391,8 +391,8 @@ access(all) contract LostAndFound {
         }
     }
 
-    access(contract) fun getFlowProvider(): auth(FungibleToken.Withdrawable) &FlowToken.Vault {
-        return self.account.storage.borrow<auth(FungibleToken.Withdrawable) &FlowToken.Vault>(from: /storage/flowTokenVault)!
+    access(contract) fun getFlowProvider(): auth(FungibleToken.Withdraw) &FlowToken.Vault {
+        return self.account.storage.borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(from: /storage/flowTokenVault)!
     }
 
     // ShelfManager is a light-weight wrapper to get our shelves into storage.
@@ -422,7 +422,7 @@ access(all) contract LostAndFound {
             item: @AnyResource,
             memo: String?,
             display: MetadataViews.Display?,
-            storagePayment: auth(FungibleToken.Withdrawable) &{FungibleToken.Vault},
+            storagePayment: auth(FungibleToken.Withdraw) &{FungibleToken.Vault},
             flowTokenRepayment: Capability<&FlowToken.Vault>?
         ) : UInt64 {
             pre {
@@ -566,9 +566,9 @@ access(all) contract LostAndFound {
             memo: String?,
             display: MetadataViews.Display?
         ) {
-            if cap.check<&{NonFungibleToken.Collection}>() {
+            if cap.check<&{NonFungibleToken.CollectionPublic}>() {
                 let nft <- item as! @{NonFungibleToken.NFT}
-                cap.borrow<&{NonFungibleToken.Collection}>()!.deposit(token: <-nft)
+                cap.borrow<&{NonFungibleToken.CollectionPublic}>()!.deposit(token: <-nft)
             } else if cap.check<&{FungibleToken.Receiver}>() {
                 let vault <- item as! @{FungibleToken.Vault}
                 cap.borrow<&{FungibleToken.Receiver}>()!.deposit(from: <-vault)
@@ -598,7 +598,7 @@ access(all) contract LostAndFound {
         init(_ flowTokenRepayment: Capability<&FlowToken.Vault>, lowBalanceThreshold: UFix64?) {
             self.flowTokenRepayment = flowTokenRepayment
 
-            let vault <- FlowToken.createEmptyVault()
+            let vault <- FlowToken.createEmptyVault(vaultType: Type<@FlowToken.Vault>())
             self.flowTokenVault <- vault
             self.lowBalanceThreshold = lowBalanceThreshold 
         }
@@ -713,7 +713,7 @@ access(all) contract LostAndFound {
         item: @AnyResource,
         memo: String?,
         display: MetadataViews.Display?,
-        storagePayment: auth(FungibleToken.Withdrawable) &{FungibleToken.Vault},
+        storagePayment: auth(FungibleToken.Withdraw) &{FungibleToken.Vault},
         flowTokenRepayment: Capability<&FlowToken.Vault>?
     ) : UInt64 {
         pre {
@@ -730,12 +730,12 @@ access(all) contract LostAndFound {
         cap: Capability,
         memo: String?,
         display: MetadataViews.Display?,
-        storagePayment: auth(FungibleToken.Withdrawable) &{FungibleToken.Vault},
+        storagePayment: auth(FungibleToken.Withdraw) &{FungibleToken.Vault},
         flowTokenRepayment: Capability<&FlowToken.Vault>
     ) {
-        if cap.check<&{NonFungibleToken.Collection}>() {
+        if cap.check<&{NonFungibleToken.CollectionPublic}>() {
             let nft <- item as! @{NonFungibleToken.NFT}
-            cap.borrow<&{NonFungibleToken.Collection}>()!.deposit(token: <-nft)
+            cap.borrow<&{NonFungibleToken.CollectionPublic}>()!.deposit(token: <-nft)
         } else if cap.check<&{FungibleToken.Receiver}>() {
             let vault <- item as! @{FungibleToken.Vault}
             cap.borrow<&{FungibleToken.Receiver}>()!.deposit(from: <-vault)