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

package/contracts/example/ExampleToken.cdc

@@ -0,0 +1,302 @@
+import "FungibleToken"
+import "FungibleTokenMetadataViews"
+import "MetadataViews"
+
+
+// THIS CONTRACT IS FOR TESTING PURPOSES ONLY!
+access(all) contract ExampleToken {
+
+    /// Total supply of ExampleTokens in existence
+    access(all) var totalSupply: UFix64
+
+    /// TokensInitialized
+    ///
+    /// The event that is emitted when the contract is created
+    access(all) event TokensInitialized(initialSupply: UFix64)
+
+    /// TokensWithdrawn
+    ///
+    /// The event that is emitted when tokens are withdrawn from a Vault
+    access(all) event TokensWithdrawn(amount: UFix64, from: Address?)
+
+    /// TokensDeposited
+    ///
+    /// The event that is emitted when tokens are deposited to a Vault
+    access(all) event TokensDeposited(amount: UFix64, to: Address?)
+
+    /// TokensMinted
+    ///
+    /// The event that is emitted when new tokens are minted
+    access(all) event TokensMinted(amount: UFix64)
+
+    /// TokensBurned
+    ///
+    /// The event that is emitted when tokens are destroyed
+    access(all) event TokensBurned(amount: UFix64)
+
+    /// MinterCreated
+    ///
+    /// The event that is emitted when a new minter resource is created
+    access(all) event MinterCreated(allowedAmount: UFix64)
+
+    /// BurnerCreated
+    ///
+    /// The event that is emitted when a new burner resource is created
+    access(all) event BurnerCreated()
+
+    /// Vault
+    ///
+    /// Each user stores an instance of only the Vault in their storage
+    /// The functions in the Vault and governed by the pre and post conditions
+    /// in FungibleToken when they are called.
+    /// The checks happen at runtime whenever a function is called.
+    ///
+    /// Resources can only be created in the context of the contract that they
+    /// are defined in, so there is no way for a malicious user to create Vaults
+    /// out of thin air. A special Minter resource needs to be defined to mint
+    /// new tokens.
+    ///
+    access(all) resource Vault: FungibleToken.Vault {
+
+        /// The total balance of this vault
+        access(all) var balance: UFix64
+
+        // initialize the balance at resource creation time
+        init(balance: UFix64) {
+            self.balance = balance
+        }
+
+        access(all) view fun getBalance(): UFix64 {
+            return self.balance
+        }
+
+        access(all) view fun getDefaultStoragePath(): StoragePath? {
+            return /storage/exampleTokenVault
+        }
+
+        access(all) view fun getDefaultPublicPath(): PublicPath? {
+            return /public/exampleTokenPublic
+        }
+
+        access(all) view fun getDefaultReceiverPath(): PublicPath? {
+            return /public/exampleTokenPublic
+        }
+
+        access(all) view fun isAvailableToWithdraw(amount: UFix64): Bool {
+            return self.balance >= amount
+        }
+
+        /// Same as getViews above, but on a specific NFT instead of a contract
+        access(all) view fun getViews(): [Type] {
+            return ExampleToken.getContractViews(resourceType: nil)
+        }
+
+        /// Same as resolveView above, but on a specific NFT instead of a contract
+        access(all) fun resolveView(_ view: Type): AnyStruct? {
+            return ExampleToken.resolveContractView(resourceType: nil, viewType: view)
+        }
+
+        /// withdraw
+        ///
+        /// Function that takes an amount as an argument
+        /// and withdraws that amount from the Vault.
+        ///
+        /// It creates a new temporary Vault that is used to hold
+        /// the money that is being transferred. It returns the newly
+        /// created Vault to the context that called so it can be deposited
+        /// elsewhere.
+        ///
+        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)
+        }
+
+        access(all) view fun getSupportedVaultTypes(): {Type: Bool} {
+            return {
+                Type<@ExampleToken.Vault>(): true
+            }
+        }
+
+        access(all) view fun isSupportedVaultType(type: Type): Bool {
+            return type == Type<@ExampleToken.Vault>()
+        }
+
+        /// deposit
+        ///
+        /// Function that takes a Vault object as an argument and adds
+        /// its balance to the balance of the owners Vault.
+        ///
+        /// 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.
+        ///
+        access(all) fun deposit(from: @{FungibleToken.Vault}) {
+            let vault <- from as! @ExampleToken.Vault
+            self.balance = self.balance + vault.balance
+            emit TokensDeposited(amount: vault.balance, to: self.owner?.address)
+            vault.balance = 0.0
+            destroy vault
+        }
+
+        access(all) fun createEmptyVault(): @Vault {
+            return <- ExampleToken.createEmptyVault()
+        }
+    }
+
+    /// createEmptyVault
+    ///
+    /// Function that creates a new Vault with a balance of zero
+    /// and returns it to the calling context. A user must call this function
+    /// and store the returned Vault in their storage in order to allow their
+    /// account to be able to receive deposits of this token type.
+    ///
+    access(all) fun createEmptyVault(): @Vault {
+        return <-create Vault(balance: 0.0)
+    }
+
+    access(all) resource Administrator {
+
+        /// createNewMinter
+        ///
+        /// Function that creates and returns a new minter resource
+        ///
+        access(all) fun createNewMinter(allowedAmount: UFix64): @Minter {
+            emit MinterCreated(allowedAmount: allowedAmount)
+            return <-create Minter(allowedAmount: allowedAmount)
+        }
+
+        /// createNewBurner
+        ///
+        /// Function that creates and returns a new burner resource
+        ///
+        access(all) fun createNewBurner(): @Burner {
+            emit BurnerCreated()
+            return <-create Burner()
+        }
+    }
+
+    /// Minter
+    ///
+    /// Resource object that token admin accounts can hold to mint new tokens.
+    ///
+    access(all) resource Minter {
+
+        /// The amount of tokens that the minter is allowed to mint
+        access(all) var allowedAmount: UFix64
+
+        /// mintTokens
+        ///
+        /// Function that mints new tokens, adds them to the total supply,
+        /// and returns them to the calling context.
+        ///
+        access(all) fun mintTokens(amount: UFix64): @ExampleToken.Vault {
+            pre {
+                amount > 0.0: "Amount minted must be greater than zero"
+                amount <= self.allowedAmount: "Amount minted must be less than the allowed amount"
+            }
+            ExampleToken.totalSupply = ExampleToken.totalSupply + amount
+            self.allowedAmount = self.allowedAmount - amount
+            emit TokensMinted(amount: amount)
+            return <-create Vault(balance: amount)
+        }
+
+        init(allowedAmount: UFix64) {
+            self.allowedAmount = allowedAmount
+        }
+    }
+
+    /// Burner
+    ///
+    /// Resource object that token admin accounts can hold to burn tokens.
+    ///
+    access(all) resource Burner {
+
+        /// burnTokens
+        ///
+        /// Function that destroys a Vault instance, effectively burning the tokens.
+        ///
+        /// Note: the burned tokens are automatically subtracted from the
+        /// total supply in the Vault destructor.
+        ///
+        access(all) fun burnTokens(from: @{FungibleToken.Vault}) {
+            let vault <- from as! @ExampleToken.Vault
+            let amount = vault.balance
+            destroy vault
+            emit TokensBurned(amount: amount)
+        }
+    }
+
+    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://example.com"
+                    ),
+                    mediaType: "image/svg+xml"
+                )
+                let medias = MetadataViews.Medias([media])
+                return FungibleTokenMetadataViews.FTDisplay(
+                    name: "Example Token",
+                    symbol: "EXAMPLE",
+                    description: "",
+                    externalURL: MetadataViews.ExternalURL("https://flow.com"),
+                    logos: medias,
+                    socials: {
+                        "twitter": MetadataViews.ExternalURL("https://twitter.com/flow_blockchain")
+                    }
+                )
+            case Type<FungibleTokenMetadataViews.FTVaultData>():
+                let vaultRef = ExampleToken.account.storage.borrow<auth(FungibleToken.Withdraw) &ExampleToken.Vault>(from: /storage/exampleTokenVault)
+			        ?? panic("Could not borrow reference to the contract's Vault!")
+                return FungibleTokenMetadataViews.FTVaultData(
+                    storagePath: /storage/exampleTokenVault,
+                    receiverPath: /public/exampleTokenReceiver,
+                    metadataPath: /public/exampleTokenBalance,
+                    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: ExampleToken.totalSupply)
+        }
+        return nil
+    }
+
+    init() {
+        self.totalSupply = 1000.0
+
+        // Create the Vault with the total supply of tokens and save it in storage
+        //
+        let vault <- create Vault(balance: self.totalSupply)
+        self.account.storage.save(<-vault, to: /storage/exampleTokenVault)
+
+        // Create a public capability to the stored Vault that only exposes
+        // the `deposit` method through the `Receiver` interface
+        //
+        let publicCap = self.account.capabilities.storage.issue<&ExampleToken.Vault>(/storage/exampleTokenVault)
+        self.account.capabilities.publish(publicCap, at: /public/exampleTokenPublic)
+
+        let admin <- create Administrator()
+        self.account.storage.save(<-admin, to: /storage/exampleTokenAdmin)
+
+        // Emit an event that shows that the contract was initialized
+        //
+        emit TokensInitialized(initialSupply: self.totalSupply)
+    }
+}

package/contracts/flow-utils/AddressUtils.cdc

@@ -1,8 +1,5 @@
-import "StringUtils"
-
-pub contract AddressUtils {
-
-    pub fun withoutPrefix(_ input: String): String {
+access(all) contract AddressUtils {
+    access(all) fun withoutPrefix(_ input: String): String {
         var address = input
 
         // get rid of 0x
@@ -17,7 +14,7 @@ pub contract AddressUtils {
         return address
     }
 
-    pub fun parseUInt64(_ input: AnyStruct): UInt64? {
+    access(all) fun parseUInt64(_ input: AnyStruct): UInt64? {
         var stringValue = ""
 
         if let string = input as? String {
@@ -25,7 +22,7 @@ pub contract AddressUtils {
         } else if let address = input as? Address {
             stringValue = address.toString()
         } else if let type = input as? Type {
-            let parts = StringUtils.split(type.identifier, ".")
+            let parts = type.identifier.split(separator: ".")
             if parts.length == 1 {
                 return nil
             }
@@ -45,14 +42,14 @@ pub contract AddressUtils {
         return r
     }
 
-    pub fun parseAddress(_ input: AnyStruct): Address? {
+    access(all) fun parseAddress(_ input: AnyStruct): Address? {
         if let parsed = self.parseUInt64(input) {
             return Address(parsed)
         }
         return nil
     }
 
-    pub fun isValidAddress(_ input: AnyStruct, forNetwork: String): Bool {
+    access(all) fun isValidAddress(_ input: AnyStruct, forNetwork: String): Bool {
         let address = self.parseUInt64(input)
         if address == nil {
             return false
@@ -61,18 +58,19 @@ pub contract AddressUtils {
         let codeWords: {String: UInt64} = {
             "MAINNET" : 0,
             "TESTNET" : 0x6834ba37b3980209,
+            "CRESCENDO" : 0x6834ba37b3980209,
             "EMULATOR": 0x1cb159857af02018
         }
 
         let parityCheckMatrixColumns: [UInt64] = [
-            0x00001, 0x00002, 0x00004, 0x00008, 0x00010, 0x00020, 0x00040, 0x00080,
-            0x00100, 0x00200, 0x00400, 0x00800, 0x01000, 0x02000, 0x04000, 0x08000,
-            0x10000, 0x20000, 0x40000, 0x7328d, 0x6689a, 0x6112f, 0x6084b, 0x433fd,
-            0x42aab, 0x41951, 0x233ce, 0x22a81, 0x21948, 0x1ef60, 0x1deca, 0x1c639,
-            0x1bdd8, 0x1a535, 0x194ac, 0x18c46, 0x1632b, 0x1529b, 0x14a43, 0x13184,
-            0x12942, 0x118c1, 0x0f812, 0x0e027, 0x0d00e, 0x0c83c, 0x0b01d, 0x0a831,
-            0x0982b, 0x07034, 0x0682a, 0x05819, 0x03807, 0x007d2, 0x00727, 0x0068e,
-            0x0067c, 0x0059d, 0x004eb, 0x003b4, 0x0036a, 0x002d9, 0x001c7, 0x0003f
+        0x00001, 0x00002, 0x00004, 0x00008, 0x00010, 0x00020, 0x00040, 0x00080,
+        0x00100, 0x00200, 0x00400, 0x00800, 0x01000, 0x02000, 0x04000, 0x08000,
+        0x10000, 0x20000, 0x40000, 0x7328d, 0x6689a, 0x6112f, 0x6084b, 0x433fd,
+        0x42aab, 0x41951, 0x233ce, 0x22a81, 0x21948, 0x1ef60, 0x1deca, 0x1c639,
+        0x1bdd8, 0x1a535, 0x194ac, 0x18c46, 0x1632b, 0x1529b, 0x14a43, 0x13184,
+        0x12942, 0x118c1, 0x0f812, 0x0e027, 0x0d00e, 0x0c83c, 0x0b01d, 0x0a831,
+        0x0982b, 0x07034, 0x0682a, 0x05819, 0x03807, 0x007d2, 0x00727, 0x0068e,
+        0x0067c, 0x0059d, 0x004eb, 0x003b4, 0x0036a, 0x002d9, 0x001c7, 0x0003f
         ]
 
         var parity: UInt64 = 0
@@ -93,8 +91,8 @@ pub contract AddressUtils {
         return parity == 0 && codeWord == 0
     }
 
-    pub fun getNetworkFromAddress(_ input: AnyStruct): String? {
-        for network in ["MAINNET", "TESTNET", "EMULATOR"]{
+    access(all) fun getNetworkFromAddress(_ input: AnyStruct): String? {
+        for network in ["MAINNET", "TESTNET", "EMULATOR"] {
             if self.isValidAddress(input, forNetwork: network){
                 return network
             }
@@ -102,8 +100,7 @@ pub contract AddressUtils {
         return nil
     }
 
-    pub fun currentNetwork(): String {
-        return self.getNetworkFromAddress(self.account.address)!
+    access(all) fun currentNetwork(): String {
+        return  self.getNetworkFromAddress(self.account.address) ?? panic("unknown network!")
     }
-
-}
+}

package/contracts/flow-utils/ArrayUtils.cdc

@@ -1,8 +1,7 @@
 // Copied from https://github.com/bluesign/flow-utils/blob/dnz/cadence/contracts/ArrayUtils.cdc with minor adjustments
 
-pub contract ArrayUtils {
-
-    pub fun rangeFunc(_ start: Int, _ end: Int, _ f: ((Int): Void)) {
+access(all) contract ArrayUtils {
+    access(all) fun rangeFunc(_ start: Int, _ end: Int, _ f: fun (Int): Void) {
         var current = start
         while current < end {
             f(current)
@@ -10,7 +9,7 @@ pub contract ArrayUtils {
         }
     }
 
-    pub fun range(_ start: Int, _ end: Int): [Int] {
+    access(all) fun range(_ start: Int, _ end: Int): [Int] {
         var res: [Int] = []
         self.rangeFunc(start, end, fun (i: Int) {
             res.append(i)
@@ -18,7 +17,7 @@ pub contract ArrayUtils {
         return res
     }
 
-    pub fun reverse(_ array: [Int]): [Int] {
+    access(all) fun reverse(_ array: [Int]): [Int] {
         var res: [Int] = []
         var i: Int = array.length - 1
         while i >= 0 {
@@ -28,13 +27,13 @@ pub contract ArrayUtils {
         return res
     }
 
-    pub fun transform(_ array: &[AnyStruct], _ f : ((AnyStruct): AnyStruct)){
+    access(all) fun transform(_ array: auth(Mutate) &[AnyStruct], _ f : fun (&AnyStruct, auth(Mutate) &[AnyStruct], Int)){
         for i in self.range(0, array.length){
-            array[i] = f(array[i])
+            f(array[i], array, i)
         }
     }
 
-    pub fun iterate(_ array: [AnyStruct], _ f : ((AnyStruct): Bool)){
+    access(all) fun iterate(_ array: [AnyStruct], _ f : fun (AnyStruct): Bool) {
         for item in array{
             if !f(item){
                 break
@@ -42,7 +41,7 @@ pub contract ArrayUtils {
         }
     }
 
-    pub fun map(_ array: [AnyStruct], _ f : ((AnyStruct): AnyStruct)) : [AnyStruct] {
+    access(all) fun map(_ array: [AnyStruct], _ f : fun (AnyStruct): AnyStruct) : [AnyStruct] {
         var res : [AnyStruct] = []
         for item in array{
             res.append(f(item))
@@ -50,7 +49,7 @@ pub contract ArrayUtils {
         return res
     }
 
-    pub fun mapStrings(_ array: [String], _ f: ((String) : String) ) : [String] {
+    access(all) fun mapStrings(_ array: [String], _ f: fun (String) : String) : [String] {
         var res : [String] = []
         for item in array{
             res.append(f(item))
@@ -58,7 +57,7 @@ pub contract ArrayUtils {
         return res
     }
 
-    pub fun reduce(_ array: [AnyStruct], _ initial: AnyStruct, _ f : ((AnyStruct, AnyStruct): AnyStruct)) : AnyStruct{
+    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])

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)
     }
 }
+