@flowtyio/flow-contracts 0.1.0-beta.8 → 0.1.0

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,46 @@
+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/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/contracts/lost-and-found/LostAndFound.cdc

@@ -45,8 +45,12 @@ access(all) contract LostAndFound {
     access(all) event DepositorTokensAdded(uuid: UInt64, tokens: UFix64, balance: UFix64)
     access(all) event DepositorTokensWithdrawn(uuid: UInt64, tokens: UFix64, balance: UFix64)
 
+    // Used by the @Depositor resource and controls whether the depositor can be used 
+    // or not to send resources to the LostAndFound
     access(all) entitlement Deposit
-    access(all) entitlement Withdraw
+
+    // Used by the @Depositor resource to manage settings such as low token threshold
+    access(all) entitlement Owner
 
     // Placeholder receiver so that any resource can be supported, not just FT and NFT Receivers
     access(all) resource interface AnyResourceReceiver {
@@ -54,7 +58,7 @@ access(all) contract LostAndFound {
     }
 
     access(all) resource DepositEstimate {
-        access(Withdraw) var item: @AnyResource?
+        access(self) var item: @AnyResource?
         access(all) let storageFee: UFix64
 
         init(item: @AnyResource, storageFee: UFix64) {
@@ -62,7 +66,7 @@ access(all) contract LostAndFound {
             self.storageFee = storageFee
         }
 
-        access(Withdraw) fun withdraw(): @AnyResource {
+        access(all) fun withdraw(): @AnyResource {
             let item <- self.item <- nil
             return <-item!
         }
@@ -140,7 +144,7 @@ access(all) contract LostAndFound {
             return nil
         }
 
-        access(Withdraw) fun withdraw(receiver: Capability) {
+        access(contract) fun withdraw(receiver: Capability) {
             pre {
                 receiver.address == self.redeemer: "receiver address and redeemer must match"
                 !self.redeemed: "already redeemed"
@@ -149,8 +153,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())
@@ -344,7 +348,7 @@ access(all) contract LostAndFound {
         }
 
         // Redeem a specific ticket instead of all of a certain type.
-        access(Withdraw) fun redeem(type: Type, ticketID: UInt64, receiver: Capability) {
+        access(all) fun redeem(type: Type, ticketID: UInt64, receiver: Capability) {
             pre {
                 receiver.address == self.redeemer: "receiver must match the redeemer of this shelf"
                 self.bins.containsKey(type.identifier): "no bin for provided type"
@@ -430,7 +434,7 @@ access(all) contract LostAndFound {
                 storagePayment.getType() == Type<@FlowToken.Vault>(): "storage payment must be in flow tokens"
             }
             let receiver = LostAndFound.account
-                .capabilities.get<&FlowToken.Vault>(/public/flowTokenReceiver)!
+                .capabilities.get<&FlowToken.Vault>(/public/flowTokenReceiver)
                 .borrow()!
 
 
@@ -513,11 +517,11 @@ access(all) contract LostAndFound {
             return false
         }
 
-        access(Mutate) fun setLowBalanceThreshold(threshold: UFix64?) {
+        access(Owner) fun setLowBalanceThreshold(threshold: UFix64?) {
             self.lowBalanceThreshold = threshold
         }
 
-        access(Mutate) fun getLowBalanceThreshold(): UFix64? {
+        access(Owner) fun getLowBalanceThreshold(): UFix64? {
             return self.lowBalanceThreshold
         }
 
@@ -528,7 +532,7 @@ access(all) contract LostAndFound {
             display: MetadataViews.Display?
         ) : UInt64 {
             let receiver = LostAndFound.account
-                .capabilities.get<&FlowToken.Vault>(/public/flowTokenReceiver)!
+                .capabilities.get<&FlowToken.Vault>(/public/flowTokenReceiver)
                 .borrow()!
 
             let storageBeforeShelf = LostAndFound.account.storage.used
@@ -566,9 +570,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)
@@ -577,7 +581,7 @@ access(all) contract LostAndFound {
             }
         }
 
-        access(Mutate) fun withdrawTokens(amount: UFix64): @{FungibleToken.Vault} {
+        access(Owner) fun withdrawTokens(amount: UFix64): @{FungibleToken.Vault} {
             let tokens <-self.flowTokenVault.withdraw(amount: amount)
             emit DepositorTokensWithdrawn(uuid: self.uuid, tokens: amount, balance: self.flowTokenVault.balance)
             self.checkForLowBalance()
@@ -617,7 +621,7 @@ access(all) contract LostAndFound {
     }
 
     access(all) fun borrowShelfManager(): &LostAndFound.ShelfManager {
-        return self.account.capabilities.get<&LostAndFound.ShelfManager>(LostAndFound.LostAndFoundPublicPath)!.borrow()!
+        return self.account.capabilities.get<&LostAndFound.ShelfManager>(LostAndFound.LostAndFoundPublicPath).borrow()!
     }
 
     access(all) fun borrowAllTicketsByType(addr: Address, type: Type): [&LostAndFound.Ticket] {
@@ -733,9 +737,9 @@ access(all) contract LostAndFound {
         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)