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

package/contracts/dapper/DapperUtilityCoin.cdc

@@ -1,30 +1,32 @@
 import "FungibleToken"
+import "MetadataViews"
+import "FungibleTokenMetadataViews"
 
-pub contract DapperUtilityCoin: FungibleToken {
+access(all) contract DapperUtilityCoin: FungibleToken {
 
     // Total supply of DapperUtilityCoins in existence
-    pub var totalSupply: UFix64
+    access(all) var totalSupply: UFix64
 
     // Event that is emitted when the contract is created
-    pub event TokensInitialized(initialSupply: UFix64)
+    access(all) event TokensInitialized(initialSupply: UFix64)
 
     // Event that is emitted when tokens are withdrawn from a Vault
-    pub event TokensWithdrawn(amount: UFix64, from: Address?)
+    access(all) event TokensWithdrawn(amount: UFix64, from: Address?)
 
     // Event that is emitted when tokens are deposited to a Vault
-    pub event TokensDeposited(amount: UFix64, to: Address?)
+    access(all) event TokensDeposited(amount: UFix64, to: Address?)
 
     // Event that is emitted when new tokens are minted
-    pub event TokensMinted(amount: UFix64)
+    access(all) event TokensMinted(amount: UFix64)
 
     // Event that is emitted when tokens are destroyed
-    pub event TokensBurned(amount: UFix64)
+    access(all) event TokensBurned(amount: UFix64)
 
     // Event that is emitted when a new minter resource is created
-    pub event MinterCreated(allowedAmount: UFix64)
+    access(all) event MinterCreated(allowedAmount: UFix64)
 
     // Event that is emitted when a new burner resource is created
-    pub event BurnerCreated()
+    access(all) event BurnerCreated()
 
     // Vault
     //
@@ -38,10 +40,10 @@ pub contract DapperUtilityCoin: FungibleToken {
     // out of thin air. A special Minter resource needs to be defined to mint
     // new tokens.
     //
-    pub resource Vault: FungibleToken.Provider, FungibleToken.Receiver, FungibleToken.Balance {
+    access(all) resource Vault: FungibleToken.Vault {
 
         // holds the balance of a users tokens
-        pub var balance: UFix64
+        access(all) var balance: UFix64
 
         // initialize the balance at resource creation time
         init(balance: UFix64) {
@@ -57,7 +59,7 @@ pub contract DapperUtilityCoin: FungibleToken {
         // created Vault to the context that called so it can be deposited
         // elsewhere.
         //
-        pub fun withdraw(amount: UFix64): @FungibleToken.Vault {
+        access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
             self.balance = self.balance - amount
             emit TokensWithdrawn(amount: amount, from: self.owner?.address)
             return <-create Vault(balance: amount)
@@ -70,7 +72,7 @@ pub contract DapperUtilityCoin: FungibleToken {
         // It is allowed to destroy the sent Vault because the Vault
         // was a temporary holder of the tokens. The Vault's balance has
         // been consumed and therefore can be destroyed.
-        pub fun deposit(from: @FungibleToken.Vault) {
+        access(all) fun deposit(from: @{FungibleToken.Vault}) {
             let vault <- from as! @DapperUtilityCoin.Vault
             self.balance = self.balance + vault.balance
             emit TokensDeposited(amount: vault.balance, to: self.owner?.address)
@@ -78,9 +80,33 @@ pub contract DapperUtilityCoin: FungibleToken {
             destroy vault
         }
 
-        destroy() {
+        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
+            return self.balance >= amount
+        }
+
+        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
+            return {Type<@Vault>(): true}
+        }
+
+        access(all) view fun isSupportedVaultType(type: Type): Bool {
+            return type == Type<@Vault>()
+        }
+
+        access(contract) fun burnCallback() {
             DapperUtilityCoin.totalSupply = DapperUtilityCoin.totalSupply - self.balance
         }
+
+        access(all) fun createEmptyVault(): @{FungibleToken.Vault} {
+            return <- create Vault(balance: 0.0)
+        }
+
+        access(all) view fun getViews(): [Type]{
+            return DapperUtilityCoin.getContractViews(resourceType: nil)
+        }
+
+        access(all) fun resolveView(_ view: Type): AnyStruct? {
+            return DapperUtilityCoin.resolveContractView(resourceType: nil, viewType: view)
+        }
     }
 
     // createEmptyVault
@@ -90,16 +116,16 @@ pub contract DapperUtilityCoin: FungibleToken {
     // and store the returned Vault in their storage in order to allow their
     // account to be able to receive deposits of this token type.
     //
-    pub fun createEmptyVault(): @FungibleToken.Vault {
+    access(all) fun createEmptyVault(vaultType: Type): @{FungibleToken.Vault} {
         return <-create Vault(balance: 0.0)
     }
 
-    pub resource Administrator {
+    access(all) resource Administrator {
         // createNewMinter
         //
         // Function that creates and returns a new minter resource
         //
-        pub fun createNewMinter(allowedAmount: UFix64): @Minter {
+        access(all) fun createNewMinter(allowedAmount: UFix64): @Minter {
             emit MinterCreated(allowedAmount: allowedAmount)
             return <-create Minter(allowedAmount: allowedAmount)
         }
@@ -108,7 +134,7 @@ pub contract DapperUtilityCoin: FungibleToken {
         //
         // Function that creates and returns a new burner resource
         //
-        pub fun createNewBurner(): @Burner {
+        access(all) fun createNewBurner(): @Burner {
             emit BurnerCreated()
             return <-create Burner()
         }
@@ -118,19 +144,19 @@ pub contract DapperUtilityCoin: FungibleToken {
     //
     // Resource object that token admin accounts can hold to mint new tokens.
     //
-    pub resource Minter {
+    access(all) resource Minter {
 
         // the amount of tokens that the minter is allowed to mint
-        pub var allowedAmount: UFix64
+        access(all) var allowedAmount: UFix64
 
         // mintTokens
         //
         // Function that mints new tokens, adds them to the total supply,
         // and returns them to the calling context.
         //
-        pub fun mintTokens(amount: UFix64): @DapperUtilityCoin.Vault {
+        access(all) fun mintTokens(amount: UFix64): @DapperUtilityCoin.Vault {
             pre {
-                amount > UFix64(0): "Amount minted must be greater than zero"
+                amount > 0.0: "Amount minted must be greater than zero"
                 amount <= self.allowedAmount: "Amount minted must be less than the allowed amount"
             }
             DapperUtilityCoin.totalSupply = DapperUtilityCoin.totalSupply + amount
@@ -148,7 +174,7 @@ pub contract DapperUtilityCoin: FungibleToken {
     //
     // Resource object that token admin accounts can hold to burn tokens.
     //
-    pub resource Burner {
+    access(all) resource Burner {
 
         // burnTokens
         //
@@ -157,7 +183,7 @@ pub contract DapperUtilityCoin: FungibleToken {
         // Note: the burned tokens are automatically subtracted from the
         // total supply in the Vault destructor.
         //
-        pub fun burnTokens(from: @FungibleToken.Vault) {
+        access(all) fun burnTokens(from: @{FungibleToken.Vault}) {
             let vault <- from as! @DapperUtilityCoin.Vault
             let amount = vault.balance
             destroy vault
@@ -165,6 +191,57 @@ pub contract DapperUtilityCoin: FungibleToken {
         }
     }
 
+    access(all) view fun getContractViews(resourceType: Type?): [Type] {
+        return [Type<FungibleTokenMetadataViews.FTView>(),
+                Type<FungibleTokenMetadataViews.FTDisplay>(),
+                Type<FungibleTokenMetadataViews.FTVaultData>(),
+                Type<FungibleTokenMetadataViews.TotalSupply>()]
+    }
+
+    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
+        switch viewType {
+            case Type<FungibleTokenMetadataViews.FTView>():
+                return FungibleTokenMetadataViews.FTView(
+                    ftDisplay: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTDisplay>()) as! FungibleTokenMetadataViews.FTDisplay?,
+                    ftVaultData: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTVaultData>()) as! FungibleTokenMetadataViews.FTVaultData?
+                )
+            case Type<FungibleTokenMetadataViews.FTDisplay>():
+                let media = MetadataViews.Media(
+                        file: MetadataViews.HTTPFile(
+                        url: "https://meetdapper.com/"
+                    ),
+                    mediaType: "image/svg+xml"
+                )
+                let medias = MetadataViews.Medias([media])
+                return FungibleTokenMetadataViews.FTDisplay(
+                    name: "Dapper Utility Coin",
+                    symbol: "DUC",
+                    description: "",
+                    externalURL: MetadataViews.ExternalURL("https://meetdapper.com/"),
+                    logos: medias,
+                    socials: {
+                        "twitter": MetadataViews.ExternalURL("https://twitter.com/hellodapper")
+                    }
+                )
+            case Type<FungibleTokenMetadataViews.FTVaultData>():
+                let vaultRef = DapperUtilityCoin.account.storage.borrow<auth(FungibleToken.Withdraw) &DapperUtilityCoin.Vault>(from: /storage/dapperUtilityCoinVault)
+			        ?? panic("Could not borrow reference to the contract's Vault!")
+                return FungibleTokenMetadataViews.FTVaultData(
+                    storagePath: /storage/dapperUtilityCoinVault,
+                    receiverPath: /public/exampleTokenReceiver,
+                    metadataPath: /public/dapperUtilityCoinBalance,
+                    receiverLinkedType: Type<&{FungibleToken.Receiver, FungibleToken.Vault}>(),
+                    metadataLinkedType: Type<&{FungibleToken.Balance, FungibleToken.Vault}>(),
+                    createEmptyVaultFunction: (fun (): @{FungibleToken.Vault} {
+                        return <-vaultRef.createEmptyVault()
+                    })
+                )
+            case Type<FungibleTokenMetadataViews.TotalSupply>():
+                return FungibleTokenMetadataViews.TotalSupply(totalSupply: DapperUtilityCoin.totalSupply)
+        }
+        return nil
+    }
+
     init() {
         // we're using a high value as the balance here to make it look like we've got a ton of money,
         // just in case some contract manually checks that our balance is sufficient to pay for stuff
@@ -172,26 +249,16 @@ pub contract DapperUtilityCoin: FungibleToken {
 
         let admin <- create Administrator()
         let minter <- admin.createNewMinter(allowedAmount: self.totalSupply)
-        self.account.save(<-admin, to: /storage/dapperUtilityCoinAdmin)
+        self.account.storage.save(<-admin, to: /storage/dapperUtilityCoinAdmin)
 
         // mint tokens
         let tokenVault <- minter.mintTokens(amount: self.totalSupply)
-        self.account.save(<-tokenVault, to: /storage/dapperUtilityCoinVault)
+        self.account.storage.save(<-tokenVault, to: /storage/dapperUtilityCoinVault)
         destroy minter
 
-        // Create a public capability to the stored Vault that only exposes
-        // the balance field through the Balance interface
-        self.account.link<&DapperUtilityCoin.Vault{FungibleToken.Balance}>(
-            /public/dapperUtilityCoinBalance,
-            target: /storage/dapperUtilityCoinVault
-        )
-
-        // Create a public capability to the stored Vault that only exposes
-        // the deposit method through the Receiver interface
-        self.account.link<&{FungibleToken.Receiver}>(
-            /public/dapperUtilityCoinReceiver,
-            target: /storage/dapperUtilityCoinVault
-        )
+        let cap = self.account.capabilities.storage.issue<&DapperUtilityCoin.Vault>(/storage/dapperUtilityCoinVault)
+        self.account.capabilities.publish(cap, at: /public/dapperUtilityCoinBalance)
+        self.account.capabilities.publish(cap, at: /public/dapperUtilityCoinReceiver)
 
         // Emit an event that shows that the contract was initialized
         emit TokensInitialized(initialSupply: self.totalSupply)

package/contracts/dapper/FlowUtilityToken.cdc

@@ -1,30 +1,32 @@
 import "FungibleToken"
+import "MetadataViews"
+import "FungibleTokenMetadataViews"
 
-pub contract FlowUtilityToken: FungibleToken {
+access(all) contract FlowUtilityToken: FungibleToken {
 
-    // Total supply of DapperUtilityCoins in existence
-    pub var totalSupply: UFix64
+    // Total supply of FlowUtilityTokens in existence
+    access(all) var totalSupply: UFix64
 
     // Event that is emitted when the contract is created
-    pub event TokensInitialized(initialSupply: UFix64)
+    access(all) event TokensInitialized(initialSupply: UFix64)
 
     // Event that is emitted when tokens are withdrawn from a Vault
-    pub event TokensWithdrawn(amount: UFix64, from: Address?)
+    access(all) event TokensWithdrawn(amount: UFix64, from: Address?)
 
     // Event that is emitted when tokens are deposited to a Vault
-    pub event TokensDeposited(amount: UFix64, to: Address?)
+    access(all) event TokensDeposited(amount: UFix64, to: Address?)
 
     // Event that is emitted when new tokens are minted
-    pub event TokensMinted(amount: UFix64)
+    access(all) event TokensMinted(amount: UFix64)
 
     // Event that is emitted when tokens are destroyed
-    pub event TokensBurned(amount: UFix64)
+    access(all) event TokensBurned(amount: UFix64)
 
     // Event that is emitted when a new minter resource is created
-    pub event MinterCreated(allowedAmount: UFix64)
+    access(all) event MinterCreated(allowedAmount: UFix64)
 
     // Event that is emitted when a new burner resource is created
-    pub event BurnerCreated()
+    access(all) event BurnerCreated()
 
     // Vault
     //
@@ -38,10 +40,10 @@ pub contract FlowUtilityToken: FungibleToken {
     // out of thin air. A special Minter resource needs to be defined to mint
     // new tokens.
     //
-    pub resource Vault: FungibleToken.Provider, FungibleToken.Receiver, FungibleToken.Balance {
+    access(all) resource Vault: FungibleToken.Vault {
 
         // holds the balance of a users tokens
-        pub var balance: UFix64
+        access(all) var balance: UFix64
 
         // initialize the balance at resource creation time
         init(balance: UFix64) {
@@ -57,7 +59,7 @@ pub contract FlowUtilityToken: FungibleToken {
         // created Vault to the context that called so it can be deposited
         // elsewhere.
         //
-        pub fun withdraw(amount: UFix64): @FungibleToken.Vault {
+        access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
             self.balance = self.balance - amount
             emit TokensWithdrawn(amount: amount, from: self.owner?.address)
             return <-create Vault(balance: amount)
@@ -70,17 +72,41 @@ pub contract FlowUtilityToken: FungibleToken {
         // It is allowed to destroy the sent Vault because the Vault
         // was a temporary holder of the tokens. The Vault's balance has
         // been consumed and therefore can be destroyed.
-        pub fun deposit(from: @FungibleToken.Vault) {
+        access(all) fun deposit(from: @{FungibleToken.Vault}) {
             let vault <- from as! @FlowUtilityToken.Vault
             self.balance = self.balance + vault.balance
             emit TokensDeposited(amount: vault.balance, to: self.owner?.address)
             vault.balance = 0.0
             destroy vault
         }
+        
+        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
+            return self.balance >= amount
+        }
+
+        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
+            return {Type<@Vault>(): true}
+        }
+
+        access(all) view fun isSupportedVaultType(type: Type): Bool {
+            return type == Type<@Vault>()
+        }
 
-        destroy() {
+        access(contract) fun burnCallback() {
             FlowUtilityToken.totalSupply = FlowUtilityToken.totalSupply - self.balance
         }
+
+        access(all) fun createEmptyVault(): @{FungibleToken.Vault} {
+            return <- create Vault(balance: 0.0)
+        }
+
+        access(all) view fun getViews(): [Type]{
+            return FlowUtilityToken.getContractViews(resourceType: nil)
+        }
+
+        access(all) fun resolveView(_ view: Type): AnyStruct? {
+            return FlowUtilityToken.resolveContractView(resourceType: nil, viewType: view)
+        }
     }
 
     // createEmptyVault
@@ -90,16 +116,16 @@ pub contract FlowUtilityToken: FungibleToken {
     // and store the returned Vault in their storage in order to allow their
     // account to be able to receive deposits of this token type.
     //
-    pub fun createEmptyVault(): @FungibleToken.Vault {
+    access(all) fun createEmptyVault(vaultType: Type): @{FungibleToken.Vault} {
         return <-create Vault(balance: 0.0)
     }
 
-    pub resource Administrator {
+    access(all) resource Administrator {
         // createNewMinter
         //
         // Function that creates and returns a new minter resource
         //
-        pub fun createNewMinter(allowedAmount: UFix64): @Minter {
+        access(all) fun createNewMinter(allowedAmount: UFix64): @Minter {
             emit MinterCreated(allowedAmount: allowedAmount)
             return <-create Minter(allowedAmount: allowedAmount)
         }
@@ -108,7 +134,7 @@ pub contract FlowUtilityToken: FungibleToken {
         //
         // Function that creates and returns a new burner resource
         //
-        pub fun createNewBurner(): @Burner {
+        access(all) fun createNewBurner(): @Burner {
             emit BurnerCreated()
             return <-create Burner()
         }
@@ -118,19 +144,19 @@ pub contract FlowUtilityToken: FungibleToken {
     //
     // Resource object that token admin accounts can hold to mint new tokens.
     //
-    pub resource Minter {
+    access(all) resource Minter {
 
         // the amount of tokens that the minter is allowed to mint
-        pub var allowedAmount: UFix64
+        access(all) var allowedAmount: UFix64
 
         // mintTokens
         //
         // Function that mints new tokens, adds them to the total supply,
         // and returns them to the calling context.
         //
-        pub fun mintTokens(amount: UFix64): @FlowUtilityToken.Vault {
+        access(all) fun mintTokens(amount: UFix64): @FlowUtilityToken.Vault {
             pre {
-                amount > UFix64(0): "Amount minted must be greater than zero"
+                amount > 0.0: "Amount minted must be greater than zero"
                 amount <= self.allowedAmount: "Amount minted must be less than the allowed amount"
             }
             FlowUtilityToken.totalSupply = FlowUtilityToken.totalSupply + amount
@@ -148,7 +174,7 @@ pub contract FlowUtilityToken: FungibleToken {
     //
     // Resource object that token admin accounts can hold to burn tokens.
     //
-    pub resource Burner {
+    access(all) resource Burner {
 
         // burnTokens
         //
@@ -157,7 +183,7 @@ pub contract FlowUtilityToken: FungibleToken {
         // Note: the burned tokens are automatically subtracted from the
         // total supply in the Vault destructor.
         //
-        pub fun burnTokens(from: @FungibleToken.Vault) {
+        access(all) fun burnTokens(from: @{FungibleToken.Vault}) {
             let vault <- from as! @FlowUtilityToken.Vault
             let amount = vault.balance
             destroy vault
@@ -165,6 +191,57 @@ pub contract FlowUtilityToken: FungibleToken {
         }
     }
 
+    access(all) view fun getContractViews(resourceType: Type?): [Type] {
+        return [Type<FungibleTokenMetadataViews.FTView>(),
+                Type<FungibleTokenMetadataViews.FTDisplay>(),
+                Type<FungibleTokenMetadataViews.FTVaultData>(),
+                Type<FungibleTokenMetadataViews.TotalSupply>()]
+    }
+
+    access(all) fun resolveContractView(resourceType: Type?, viewType: Type): AnyStruct? {
+        switch viewType {
+            case Type<FungibleTokenMetadataViews.FTView>():
+                return FungibleTokenMetadataViews.FTView(
+                    ftDisplay: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTDisplay>()) as! FungibleTokenMetadataViews.FTDisplay?,
+                    ftVaultData: self.resolveContractView(resourceType: nil, viewType: Type<FungibleTokenMetadataViews.FTVaultData>()) as! FungibleTokenMetadataViews.FTVaultData?
+                )
+            case Type<FungibleTokenMetadataViews.FTDisplay>():
+                let media = MetadataViews.Media(
+                        file: MetadataViews.HTTPFile(
+                        url: "https://meetdapper.com/"
+                    ),
+                    mediaType: "image/svg+xml"
+                )
+                let medias = MetadataViews.Medias([media])
+                return FungibleTokenMetadataViews.FTDisplay(
+                    name: "Dapper Utility Coin",
+                    symbol: "DUC",
+                    description: "",
+                    externalURL: MetadataViews.ExternalURL("https://meetdapper.com/"),
+                    logos: medias,
+                    socials: {
+                        "twitter": MetadataViews.ExternalURL("https://twitter.com/hellodapper")
+                    }
+                )
+            case Type<FungibleTokenMetadataViews.FTVaultData>():
+                let vaultRef = FlowUtilityToken.account.storage.borrow<auth(FungibleToken.Withdraw) &FlowUtilityToken.Vault>(from: /storage/flowUtilityTokenVault)
+			        ?? panic("Could not borrow reference to the contract's Vault!")
+                return FungibleTokenMetadataViews.FTVaultData(
+                    storagePath: /storage/flowUtilityTokenVault,
+                    receiverPath: /public/exampleTokenReceiver,
+                    metadataPath: /public/flowUtilityTokenBalance,
+                    receiverLinkedType: Type<&{FungibleToken.Receiver, FungibleToken.Vault}>(),
+                    metadataLinkedType: Type<&{FungibleToken.Balance, FungibleToken.Vault}>(),
+                    createEmptyVaultFunction: (fun (): @{FungibleToken.Vault} {
+                        return <-vaultRef.createEmptyVault()
+                    })
+                )
+            case Type<FungibleTokenMetadataViews.TotalSupply>():
+                return FungibleTokenMetadataViews.TotalSupply(totalSupply: FlowUtilityToken.totalSupply)
+        }
+        return nil
+    }
+
     init() {
         // we're using a high value as the balance here to make it look like we've got a ton of money,
         // just in case some contract manually checks that our balance is sufficient to pay for stuff
@@ -172,26 +249,16 @@ pub contract FlowUtilityToken: FungibleToken {
 
         let admin <- create Administrator()
         let minter <- admin.createNewMinter(allowedAmount: self.totalSupply)
-        self.account.save(<-admin, to: /storage/flowUtilityTokenAdmin)
+        self.account.storage.save(<-admin, to: /storage/flowUtilityTokenAdmin)
 
         // mint tokens
         let tokenVault <- minter.mintTokens(amount: self.totalSupply)
-        self.account.save(<-tokenVault, to: /storage/flowUtilityTokenVault)
+        self.account.storage.save(<-tokenVault, to: /storage/flowUtilityTokenVault)
         destroy minter
 
-        // Create a public capability to the stored Vault that only exposes
-        // the balance field through the Balance interface
-        self.account.link<&FlowUtilityToken.Vault{FungibleToken.Balance}>(
-            /public/flowUtilityTokenBalance,
-            target: /storage/flowUtilityTokenVault
-        )
-
-        // Create a public capability to the stored Vault that only exposes
-        // the deposit method through the Receiver interface
-        self.account.link<&{FungibleToken.Receiver}>(
-            /public/flowUtilityTokenReceiver,
-            target: /storage/flowUtilityTokenVault
-        )
+        let cap = self.account.capabilities.storage.issue<&FlowUtilityToken.Vault>(/storage/flowUtilityTokenVault)
+        self.account.capabilities.publish(cap, at: /public/flowUtilityTokenBalance)
+        self.account.capabilities.publish(cap, at: /public/flowUtilityTokenReceiver)
 
         // Emit an event that shows that the contract was initialized
         emit TokensInitialized(initialSupply: self.totalSupply)

package/contracts/flow-utils/AddressUtils.cdc

@@ -103,4 +103,4 @@ access(all) contract AddressUtils {
     access(all) fun currentNetwork(): String {
         return  self.getNetworkFromAddress(self.account.address) ?? panic("unknown network!")
     }
-}
+}

package/contracts/flow-utils/ArrayUtils.cdc

@@ -1,120 +1,68 @@
-import "FungibleToken"
-import "StringUtils"
-
-// ScopedFTProviders
-//
-// TO AVOID RISK, PLEASE DEPLOY YOUR OWN VERSION OF THIS CONTRACT SO THAT
-// MALICIOUS UPDATES ARE NOT POSSIBLE
-//
-// ScopedProviders are meant to solve the issue of unbounded access FungibleToken vaults
-// when a provider is called for.
-access(all) contract ScopedFTProviders {
-    access(all) struct interface FTFilter {
-        access(all) fun canWithdrawAmount(_ amount: UFix64): Bool
-        access(FungibleToken.Withdraw) fun markAmountWithdrawn(_ amount: UFix64)
-        access(all) fun getDetails(): {String: AnyStruct}
-    }
-
-    access(all) struct AllowanceFilter: FTFilter {
-        access(self) let allowance: UFix64
-        access(self) var allowanceUsed: UFix64
-
-        init(_ allowance: UFix64) {
-            self.allowance = allowance
-            self.allowanceUsed = 0.0
-        }
-
-        access(all) fun canWithdrawAmount(_ amount: UFix64): Bool {
-            return amount + self.allowanceUsed <= self.allowance
-        }
-
-        access(FungibleToken.Withdraw) fun markAmountWithdrawn(_ amount: UFix64) {
-            self.allowanceUsed = self.allowanceUsed + amount
-        }
-
-        access(all) fun getDetails(): {String: AnyStruct} {
-            return {
-                "allowance": self.allowance,
-                "allowanceUsed": self.allowanceUsed
-            }
+// Copied from https://github.com/bluesign/flow-utils/blob/dnz/cadence/contracts/ArrayUtils.cdc with minor adjustments
+
+access(all) contract ArrayUtils {
+    access(all) fun rangeFunc(_ start: Int, _ end: Int, _ f: fun (Int): Void) {
+        var current = start
+        while current < end {
+            f(current)
+            current = current + 1
         }
     }
 
-    // ScopedFTProvider
-    //
-    // A ScopedFTProvider is a wrapped FungibleTokenProvider with
-    // filters that can be defined by anyone using the ScopedFTProvider.
-    access(all) resource ScopedFTProvider: FungibleToken.Provider {
-        access(self) let provider: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>
-        access(self) var filters: [{FTFilter}]
-
-        // block timestamp that this provider can no longer be used after
-        access(self) let expiration: UFix64?
+    access(all) fun range(_ start: Int, _ end: Int): [Int] {
+        var res: [Int] = []
+        self.rangeFunc(start, end, fun (i: Int) {
+            res.append(i)
+        })
+        return res
+    }
 
-        access(all) init(provider: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>, filters: [{FTFilter}], expiration: UFix64?) {
-            self.provider = provider
-            self.filters = filters
-            self.expiration = expiration
+    access(all) fun reverse(_ array: [Int]): [Int] {
+        var res: [Int] = []
+        var i: Int = array.length - 1
+        while i >= 0 {
+            res.append(array[i])
+            i = i - 1
         }
+        return res
+    }
 
-        access(all) fun check(): Bool {
-            return self.provider.check()
+    access(all) fun transform(_ array: auth(Mutate) &[AnyStruct], _ f : fun (&AnyStruct, auth(Mutate) &[AnyStruct], Int)){
+        for i in self.range(0, array.length){
+            f(array[i], array, i)
         }
+    }
 
-        access(all) view fun isExpired(): Bool {
-            if let expiration = self.expiration {
-                return getCurrentBlock().timestamp >= expiration
+    access(all) fun iterate(_ array: [AnyStruct], _ f : fun (AnyStruct): Bool) {
+        for item in array{
+            if !f(item){
+                break
             }
-            return false
         }
+    }
 
-        access(all) fun canWithdraw(_ amount: UFix64): Bool {
-            if self.isExpired() {
-                return false
-            }
-
-            for filter in self.filters {
-                if !filter.canWithdrawAmount(amount) {
-                    return false
-                }
-            }
-
-            return true
+    access(all) fun map(_ array: [AnyStruct], _ f : fun (AnyStruct): AnyStruct) : [AnyStruct] {
+        var res : [AnyStruct] = []
+        for item in array{
+            res.append(f(item))
         }
+        return res
+    }
 
-        access(FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
-            pre {
-                !self.isExpired(): "provider has expired"
-            }
-
-            var i = 0
-            while i < self.filters.length {
-                if !self.filters[i].canWithdrawAmount(amount) {
-                    panic(StringUtils.join(["cannot withdraw tokens. filter of type", self.filters[i].getType().identifier, "failed."], " "))
-                }
-
-                self.filters[i].markAmountWithdrawn(amount)
-                i = i + 1
-            }
-
-            return <-self.provider.borrow()!.withdraw(amount: amount)
+    access(all) fun mapStrings(_ array: [String], _ f: fun (String) : String) : [String] {
+        var res : [String] = []
+        for item in array{
+            res.append(f(item))
         }
+        return res
+    }
 
-        access(all) fun getDetails(): [{String: AnyStruct}] {
-            let details: [{String: AnyStruct}] = []
-            for filter in self.filters {
-                details.append(filter.getDetails())
-            }
-
-            return details
+    access(all) fun reduce(_ array: [AnyStruct], _ initial: AnyStruct, _ f : fun (AnyStruct, AnyStruct): AnyStruct) : AnyStruct{
+        var res: AnyStruct = f(initial, array[0])
+        for i in self.range(1, array.length){
+            res =  f(res, array[i])
         }
+        return res
     }
 
-    access(all) fun createScopedFTProvider(
-        provider: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>,
-        filters: [{FTFilter}],
-        expiration: UFix64?
-    ): @ScopedFTProvider {
-        return <- create ScopedFTProvider(provider: provider, filters: filters, expiration: expiration)
-    }
-}
+}

package/contracts/flow-utils/ScopedFTProviders.cdc

@@ -8,14 +8,14 @@ import "StringUtils"
 //
 // ScopedProviders are meant to solve the issue of unbounded access FungibleToken vaults
 // when a provider is called for.
-pub contract ScopedFTProviders {
-    pub struct interface FTFilter {
-        pub fun canWithdrawAmount(_ amount: UFix64): Bool
-        pub fun markAmountWithdrawn(_ amount: UFix64)
-        pub fun getDetails(): {String: AnyStruct}
+access(all) contract ScopedFTProviders {
+    access(all) struct interface FTFilter {
+        access(all) view fun canWithdrawAmount(_ amount: UFix64): Bool
+        access(FungibleToken.Withdraw) fun markAmountWithdrawn(_ amount: UFix64)
+        access(all) fun getDetails(): {String: AnyStruct}
     }
 
-    pub struct AllowanceFilter: FTFilter {
+    access(all) struct AllowanceFilter: FTFilter {
         access(self) let allowance: UFix64
         access(self) var allowanceUsed: UFix64
 
@@ -24,15 +24,15 @@ pub contract ScopedFTProviders {
             self.allowanceUsed = 0.0
         }
 
-        pub fun canWithdrawAmount(_ amount: UFix64): Bool {
+        access(all) view fun canWithdrawAmount(_ amount: UFix64): Bool {
             return amount + self.allowanceUsed <= self.allowance
         }
 
-        pub fun markAmountWithdrawn(_ amount: UFix64) {
+        access(FungibleToken.Withdraw) fun markAmountWithdrawn(_ amount: UFix64) {
             self.allowanceUsed = self.allowanceUsed + amount
         }
 
-        pub fun getDetails(): {String: AnyStruct} {
+        access(all) fun getDetails(): {String: AnyStruct} {
             return {
                 "allowance": self.allowance,
                 "allowanceUsed": self.allowanceUsed
@@ -44,31 +44,31 @@ pub contract ScopedFTProviders {
     //
     // A ScopedFTProvider is a wrapped FungibleTokenProvider with
     // filters that can be defined by anyone using the ScopedFTProvider.
-    pub resource ScopedFTProvider: FungibleToken.Provider {
-        access(self) let provider: Capability<&{FungibleToken.Provider}>
+    access(all) resource ScopedFTProvider: FungibleToken.Provider {
+        access(self) let provider: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>
         access(self) var filters: [{FTFilter}]
 
         // block timestamp that this provider can no longer be used after
         access(self) let expiration: UFix64?
 
-        pub init(provider: Capability<&{FungibleToken.Provider}>, filters: [{FTFilter}], expiration: UFix64?) {
+        access(all) init(provider: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>, filters: [{FTFilter}], expiration: UFix64?) {
             self.provider = provider
             self.filters = filters
             self.expiration = expiration
         }
 
-        pub fun check(): Bool {
+        access(all) fun check(): Bool {
             return self.provider.check()
         }
 
-        pub fun isExpired(): Bool {
+        access(all) view fun isExpired(): Bool {
             if let expiration = self.expiration {
                 return getCurrentBlock().timestamp >= expiration
             }
             return false
         }
 
-        pub fun canWithdraw(_ amount: UFix64): Bool {
+        access(all) view fun canWithdraw(_ amount: UFix64): Bool {
             if self.isExpired() {
                 return false
             }
@@ -82,7 +82,11 @@ pub contract ScopedFTProviders {
             return true
         }
 
-        pub fun withdraw(amount: UFix64): @FungibleToken.Vault {
+        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
+            return self.canWithdraw(amount)
+        }
+
+        access(FungibleToken.Withdraw | FungibleToken.Withdraw) fun withdraw(amount: UFix64): @{FungibleToken.Vault} {
             pre {
                 !self.isExpired(): "provider has expired"
             }
@@ -100,7 +104,7 @@ pub contract ScopedFTProviders {
             return <-self.provider.borrow()!.withdraw(amount: amount)
         }
 
-        pub fun getDetails(): [{String: AnyStruct}] {
+        access(all) fun getDetails(): [{String: AnyStruct}] {
             let details: [{String: AnyStruct}] = []
             for filter in self.filters {
                 details.append(filter.getDetails())
@@ -110,11 +114,12 @@ pub contract ScopedFTProviders {
         }
     }
 
-    pub fun createScopedFTProvider(
-        provider: Capability<&{FungibleToken.Provider}>,
+    access(all) fun createScopedFTProvider(
+        provider: Capability<auth(FungibleToken.Withdraw) &{FungibleToken.Provider}>,
         filters: [{FTFilter}],
         expiration: UFix64?
     ): @ScopedFTProvider {
         return <- create ScopedFTProvider(provider: provider, filters: filters, expiration: expiration)
     }
 }
+

package/contracts/flow-utils/ScopedNFTProviders.cdc

@@ -32,11 +32,11 @@ access(all) contract ScopedNFTProviders {
         }
 
         access(all) fun canWithdraw(_ nft: &{NonFungibleToken.NFT}): Bool {
-            return self.ids[nft.getID()] != nil && self.ids[nft.getID()] == true
+            return self.ids[nft.id] != nil && self.ids[nft.id] == true
         }
 
         access(NonFungibleToken.Withdraw) fun markWithdrawn(_ nft: &{NonFungibleToken.NFT}) {
-            self.ids[nft.getID()] = false
+            self.ids[nft.id] = false
         }
 
         access(all) fun getDetails(): {String: AnyStruct} {
@@ -121,7 +121,7 @@ access(all) contract ScopedNFTProviders {
             return self.provider.check()
         }
 
-        access(NonFungibleToken.Withdraw) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
+        access(NonFungibleToken.Withdraw | NonFungibleToken.Owner) fun withdraw(withdrawID: UInt64): @{NonFungibleToken.NFT} {
             pre {
                 !self.isExpired(): "provider has expired"
             }
@@ -160,3 +160,4 @@ access(all) contract ScopedNFTProviders {
         return <- create ScopedNFTProvider(provider: provider, filters: filters, expiration: expiration)
     }
 }
+

package/contracts/flow-utils/StringUtils.cdc

@@ -81,4 +81,4 @@ access(all) contract StringUtils {
     access(all) fun join(_ strs: [String], _ separator: String): String {
         return String.join(strs, separator: separator)
     }
-}
+}

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
         }
@@ -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 {
@@ -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,7 +730,7 @@ 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}>() {

package/package.json

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