@flowtyio/flow-contracts 0.0.11 → 0.0.14

package/contracts/FungibleTokenMetadataViews.cdc

@@ -0,0 +1,183 @@
+import "FungibleToken"
+import "MetadataViews"
+
+/// This contract implements the metadata standard proposed
+/// in FLIP-1087.
+/// 
+/// Ref: https://github.com/onflow/flow/blob/master/flips/20220811-fungible-tokens-metadata.md
+/// 
+/// Structs and resources can implement one or more
+/// metadata types, called views. Each view type represents
+/// a different kind of metadata.
+///
+pub contract FungibleTokenMetadataViews {
+    /// FTView wraps FTDisplay and FTVaultData, and is used to give a complete 
+    /// picture of a Fungible Token. Most Fungible Token contracts should 
+    /// implement this view.
+    ///
+    pub struct FTView {
+        pub let ftDisplay: FTDisplay?     
+        pub let ftVaultData: FTVaultData?
+        init(
+            ftDisplay: FTDisplay?,
+            ftVaultData: FTVaultData?
+        ) {
+            self.ftDisplay = ftDisplay
+            self.ftVaultData = ftVaultData
+        }
+    }
+
+    /// Helper to get a FT view.
+    ///
+    /// @param viewResolver: A reference to the resolver resource
+    /// @return A FTView struct
+    ///
+    pub fun getFTView(viewResolver: &{MetadataViews.Resolver}): FTView {
+        let maybeFTView = viewResolver.resolveView(Type<FTView>())
+        if let ftView = maybeFTView {
+            return ftView as! FTView
+        }
+        return FTView(
+            ftDisplay: self.getFTDisplay(viewResolver),
+            ftVaultData: self.getFTVaultData(viewResolver)
+        )
+    }
+
+    /// View to expose the information needed to showcase this FT. 
+    /// This can be used by applications to give an overview and 
+    /// graphics of the FT.
+    ///
+    pub struct FTDisplay {
+        /// The display name for this token.
+        ///
+        /// Example: "Flow"
+        ///
+        pub let name: String
+
+        /// The abbreviated symbol for this token.
+        ///
+        /// Example: "FLOW"
+        pub let symbol: String
+
+        /// A description the provides an overview of this token.
+        ///
+        /// Example: "The FLOW token is the native currency of the Flow network."
+        pub let description: String
+
+        /// External link to a URL to view more information about the fungible token.
+        pub let externalURL: MetadataViews.ExternalURL
+
+        /// One or more versions of the fungible token logo.
+        pub let logos: MetadataViews.Medias
+
+        /// Social links to reach the fungible token's social homepages.
+        /// Possible keys may be "instagram", "twitter", "discord", etc.
+        pub let socials: {String: MetadataViews.ExternalURL}
+
+        init(
+            name: String,
+            symbol: String,
+            description: String,
+            externalURL: MetadataViews.ExternalURL,
+            logos: MetadataViews.Medias,
+            socials: {String: MetadataViews.ExternalURL}
+        ) {
+            self.name = name
+            self.symbol = symbol
+            self.description = description
+            self.externalURL = externalURL
+            self.logos = logos
+            self.socials = socials
+        }
+    }
+
+    /// Helper to get FTDisplay in a way that will return a typed optional.
+    /// 
+    /// @param viewResolver: A reference to the resolver resource
+    /// @return An optional FTDisplay struct
+    ///
+    pub fun getFTDisplay(_ viewResolver: &{MetadataViews.Resolver}): FTDisplay? {
+        if let maybeDisplayView = viewResolver.resolveView(Type<FTDisplay>()) {
+            if let displayView = maybeDisplayView as? FTDisplay {
+                return displayView
+            }
+        }
+        return nil
+    }
+
+    /// View to expose the information needed store and interact with a FT vault.
+    /// This can be used by applications to setup a FT vault with proper 
+    /// storage and public capabilities.
+    ///
+    pub struct FTVaultData {
+        /// Path in storage where this FT vault is recommended to be stored.
+        pub let storagePath: StoragePath
+
+        /// Public path which must be linked to expose the public receiver capability.
+        pub let receiverPath: PublicPath
+
+        /// Public path which must be linked to expose the balance and resolver public capabilities.
+        pub let metadataPath: PublicPath
+
+        /// Private path which should be linked to expose the provider capability to withdraw funds 
+        /// from the vault.
+        pub let providerPath: PrivatePath
+
+        /// Type that should be linked at the `receiverPath`. This is a restricted type requiring 
+        /// the `FungibleToken.Receiver` interface.
+        pub let receiverLinkedType: Type
+
+        /// Type that should be linked at the `receiverPath`. This is a restricted type requiring 
+        /// the `FungibleToken.Balance` and `MetadataViews.Resolver` interfaces.
+        pub let metadataLinkedType: Type
+
+        /// Type that should be linked at the aforementioned private path. This 
+        /// is normally a restricted type with at a minimum the `FungibleToken.Provider` interface.
+        pub let providerLinkedType: Type
+
+        /// Function that allows creation of an empty FT vault that is intended
+        /// to store the funds.
+        pub let createEmptyVault: ((): @FungibleToken.Vault)
+
+        init(
+            storagePath: StoragePath,
+            receiverPath: PublicPath,
+            metadataPath: PublicPath,
+            providerPath: PrivatePath,
+            receiverLinkedType: Type,
+            metadataLinkedType: Type,
+            providerLinkedType: Type,
+            createEmptyVaultFunction: ((): @FungibleToken.Vault)
+        ) {
+            pre {
+                receiverLinkedType.isSubtype(of: Type<&{FungibleToken.Receiver}>()): "Receiver public type must include FungibleToken.Receiver."
+                metadataLinkedType.isSubtype(of: Type<&{FungibleToken.Balance, MetadataViews.Resolver}>()): "Metadata public type must include FungibleToken.Balance and MetadataViews.Resolver interfaces."
+                providerLinkedType.isSubtype(of: Type<&{FungibleToken.Provider}>()): "Provider type must include FungibleToken.Provider interface."
+            }
+            self.storagePath = storagePath
+            self.receiverPath = receiverPath
+            self.metadataPath = metadataPath
+            self.providerPath = providerPath
+            self.receiverLinkedType = receiverLinkedType
+            self.metadataLinkedType = metadataLinkedType
+            self.providerLinkedType = providerLinkedType
+            self.createEmptyVault = createEmptyVaultFunction
+        }
+    }
+
+    /// Helper to get FTVaultData in a way that will return a typed Optional.
+    ///
+    /// @param viewResolver: A reference to the resolver resource
+    /// @return A optional FTVaultData struct
+    ///
+    pub fun getFTVaultData(_ viewResolver: &{MetadataViews.Resolver}): FTVaultData? {
+        if let view = viewResolver.resolveView(Type<FTVaultData>()) {
+            if let v = view as? FTVaultData {
+                return v
+            }
+        }
+        return nil
+    }
+
+}
+ 

package/contracts/TokenForwarding.cdc

@@ -0,0 +1,82 @@
+/**
+
+# Fungible Token Forwarding Contract
+
+This contract shows how an account could set up a custom FungibleToken Receiver
+to allow them to forward tokens to a different account whenever they receive tokens.
+
+They can publish this Forwarder resource as a Receiver capability just like a Vault,
+and the sender doesn't even need to know it is different.
+
+When an account wants to create a Forwarder, they call the createNewForwarder
+function and provide it with the Receiver reference that they want to forward
+their tokens to.
+
+*/
+
+import "FungibleToken"
+
+pub contract TokenForwarding {
+
+    // Event that is emitted when tokens are deposited to the target receiver
+    pub event ForwardedDeposit(amount: UFix64, from: Address?)
+
+    pub resource interface ForwarderPublic {
+        pub fun check(): Bool
+        pub fun safeBorrow(): &{FungibleToken.Receiver}?
+    }
+
+    pub resource Forwarder: FungibleToken.Receiver, ForwarderPublic {
+
+        // This is where the deposited tokens will be sent.
+        // The type indicates that it is a reference to a receiver
+        //
+        access(self) var recipient: Capability
+
+        // deposit
+        //
+        // Function that takes a Vault object as an argument and forwards
+        // it to the recipient's Vault using the stored reference
+        //
+        pub fun deposit(from: @FungibleToken.Vault) {
+            let receiverRef = self.recipient.borrow<&{FungibleToken.Receiver}>()!
+
+            let balance = from.balance
+
+            receiverRef.deposit(from: <-from)
+
+            emit ForwardedDeposit(amount: balance, from: self.owner?.address)
+        }
+
+        pub fun check(): Bool {
+            return self.recipient.check<&{FungibleToken.Receiver}>()
+        }
+
+        pub fun safeBorrow(): &{FungibleToken.Receiver}? {
+            return self.recipient.borrow<&{FungibleToken.Receiver}>()
+        }
+
+        // changeRecipient changes the recipient of the forwarder to the provided recipient
+        //
+        pub fun changeRecipient(_ newRecipient: Capability) {
+            pre {
+                newRecipient.borrow<&{FungibleToken.Receiver}>() != nil: "Could not borrow Receiver reference from the Capability"
+            }
+            self.recipient = newRecipient
+        }
+
+        init(recipient: Capability) {
+            pre {
+                recipient.borrow<&{FungibleToken.Receiver}>() != nil: "Could not borrow Receiver reference from the Capability"
+            }
+            self.recipient = recipient
+        }
+    }
+
+    // createNewForwarder creates a new Forwarder reference with the provided recipient
+    //
+    pub fun createNewForwarder(recipient: Capability): @Forwarder {
+        return <-create Forwarder(recipient: recipient)
+    }
+}
+ 

package/contracts/dapper/DapperUtilityCoin.cdc

@@ -0,0 +1,199 @@
+import "FungibleToken"
+
+pub contract DapperUtilityCoin: FungibleToken {
+
+    // Total supply of DapperUtilityCoins in existence
+    pub var totalSupply: UFix64
+
+    // Event that is emitted when the contract is created
+    pub event TokensInitialized(initialSupply: UFix64)
+
+    // Event that is emitted when tokens are withdrawn from a Vault
+    pub event TokensWithdrawn(amount: UFix64, from: Address?)
+
+    // Event that is emitted when tokens are deposited to a Vault
+    pub event TokensDeposited(amount: UFix64, to: Address?)
+
+    // Event that is emitted when new tokens are minted
+    pub event TokensMinted(amount: UFix64)
+
+    // Event that is emitted when tokens are destroyed
+    pub event TokensBurned(amount: UFix64)
+
+    // Event that is emitted when a new minter resource is created
+    pub event MinterCreated(allowedAmount: UFix64)
+
+    // Event that is emitted when a new burner resource is created
+    pub 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.
+    //
+    pub resource Vault: FungibleToken.Provider, FungibleToken.Receiver, FungibleToken.Balance {
+
+        // holds the balance of a users tokens
+        pub var balance: UFix64
+
+        // initialize the balance at resource creation time
+        init(balance: UFix64) {
+            self.balance = balance
+        }
+
+        // withdraw
+        //
+        // Function that takes an integer 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.
+        //
+        pub fun withdraw(amount: UFix64): @FungibleToken.Vault {
+            self.balance = self.balance - amount
+            emit TokensWithdrawn(amount: amount, from: self.owner?.address)
+            return <-create Vault(balance: amount)
+        }
+
+        // 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.
+        pub 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)
+            vault.balance = 0.0
+            destroy vault
+        }
+
+        destroy() {
+            DapperUtilityCoin.totalSupply = DapperUtilityCoin.totalSupply - self.balance
+        }
+    }
+
+    // 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.
+    //
+    pub fun createEmptyVault(): @FungibleToken.Vault {
+        return <-create Vault(balance: 0.0)
+    }
+
+    pub resource Administrator {
+        // createNewMinter
+        //
+        // Function that creates and returns a new minter resource
+        //
+        pub fun createNewMinter(allowedAmount: UFix64): @Minter {
+            emit MinterCreated(allowedAmount: allowedAmount)
+            return <-create Minter(allowedAmount: allowedAmount)
+        }
+
+        // createNewBurner
+        //
+        // Function that creates and returns a new burner resource
+        //
+        pub fun createNewBurner(): @Burner {
+            emit BurnerCreated()
+            return <-create Burner()
+        }
+    }
+
+    // Minter
+    //
+    // Resource object that token admin accounts can hold to mint new tokens.
+    //
+    pub resource Minter {
+
+        // the amount of tokens that the minter is allowed to mint
+        pub 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 {
+            pre {
+                amount > UFix64(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
+            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.
+    //
+    pub 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.
+        //
+        pub fun burnTokens(from: @FungibleToken.Vault) {
+            let vault <- from as! @DapperUtilityCoin.Vault
+            let amount = vault.balance
+            destroy vault
+            emit TokensBurned(amount: amount)
+        }
+    }
+
+    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
+        self.totalSupply = 999999999.0
+
+        let admin <- create Administrator()
+        let minter <- admin.createNewMinter(allowedAmount: self.totalSupply)
+        self.account.save(<-admin, to: /storage/dapperUtilityCoinAdmin)
+
+        // mint tokens
+        let tokenVault <- minter.mintTokens(amount: self.totalSupply)
+        self.account.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
+        )
+
+        // Emit an event that shows that the contract was initialized
+        emit TokensInitialized(initialSupply: self.totalSupply)
+    }
+}

package/contracts/dapper/FlowUtilityToken.cdc

@@ -0,0 +1,199 @@
+import "FungibleToken"
+
+pub contract FlowUtilityToken: FungibleToken {
+
+    // Total supply of DapperUtilityCoins in existence
+    pub var totalSupply: UFix64
+
+    // Event that is emitted when the contract is created
+    pub event TokensInitialized(initialSupply: UFix64)
+
+    // Event that is emitted when tokens are withdrawn from a Vault
+    pub event TokensWithdrawn(amount: UFix64, from: Address?)
+
+    // Event that is emitted when tokens are deposited to a Vault
+    pub event TokensDeposited(amount: UFix64, to: Address?)
+
+    // Event that is emitted when new tokens are minted
+    pub event TokensMinted(amount: UFix64)
+
+    // Event that is emitted when tokens are destroyed
+    pub event TokensBurned(amount: UFix64)
+
+    // Event that is emitted when a new minter resource is created
+    pub event MinterCreated(allowedAmount: UFix64)
+
+    // Event that is emitted when a new burner resource is created
+    pub 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.
+    //
+    pub resource Vault: FungibleToken.Provider, FungibleToken.Receiver, FungibleToken.Balance {
+
+        // holds the balance of a users tokens
+        pub var balance: UFix64
+
+        // initialize the balance at resource creation time
+        init(balance: UFix64) {
+            self.balance = balance
+        }
+
+        // withdraw
+        //
+        // Function that takes an integer 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.
+        //
+        pub fun withdraw(amount: UFix64): @FungibleToken.Vault {
+            self.balance = self.balance - amount
+            emit TokensWithdrawn(amount: amount, from: self.owner?.address)
+            return <-create Vault(balance: amount)
+        }
+
+        // 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.
+        pub 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
+        }
+
+        destroy() {
+            FlowUtilityToken.totalSupply = FlowUtilityToken.totalSupply - self.balance
+        }
+    }
+
+    // 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.
+    //
+    pub fun createEmptyVault(): @FungibleToken.Vault {
+        return <-create Vault(balance: 0.0)
+    }
+
+    pub resource Administrator {
+        // createNewMinter
+        //
+        // Function that creates and returns a new minter resource
+        //
+        pub fun createNewMinter(allowedAmount: UFix64): @Minter {
+            emit MinterCreated(allowedAmount: allowedAmount)
+            return <-create Minter(allowedAmount: allowedAmount)
+        }
+
+        // createNewBurner
+        //
+        // Function that creates and returns a new burner resource
+        //
+        pub fun createNewBurner(): @Burner {
+            emit BurnerCreated()
+            return <-create Burner()
+        }
+    }
+
+    // Minter
+    //
+    // Resource object that token admin accounts can hold to mint new tokens.
+    //
+    pub resource Minter {
+
+        // the amount of tokens that the minter is allowed to mint
+        pub 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 {
+            pre {
+                amount > UFix64(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
+            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.
+    //
+    pub 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.
+        //
+        pub fun burnTokens(from: @FungibleToken.Vault) {
+            let vault <- from as! @FlowUtilityToken.Vault
+            let amount = vault.balance
+            destroy vault
+            emit TokensBurned(amount: amount)
+        }
+    }
+
+    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
+        self.totalSupply = 999999999.0
+
+        let admin <- create Administrator()
+        let minter <- admin.createNewMinter(allowedAmount: self.totalSupply)
+        self.account.save(<-admin, to: /storage/flowUtilityTokenAdmin)
+
+        // mint tokens
+        let tokenVault <- minter.mintTokens(amount: self.totalSupply)
+        self.account.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
+        )
+
+        // Emit an event that shows that the contract was initialized
+        emit TokensInitialized(initialSupply: self.totalSupply)
+    }
+}