Merge pull request #59 from onflow/nialexsan/usdc

usdc contract

Author: nialexsan

cadence/transactions/usdc/mint_tokens.cdc

@@ -0,0 +1,52 @@
+import "FungibleToken"
+import "USDCFlow"
+import "FungibleTokenMetadataViews"
+
+import "FlowEVMBridgeHandlerInterfaces"
+
+/// This transaction is what the minter Account uses to mint new ExampleTokens
+/// They provide the recipient address and amount to mint, and the tokens
+/// are transferred to the address after minting
+
+transaction(recipient: Address, amount: UFix64) {
+
+    /// Reference to the Example Token Minter Resource object
+    let tokenMinter: auth(FlowEVMBridgeHandlerInterfaces.Mint) &USDCFlow.Minter
+
+    /// Reference to the Fungible Token Receiver of the recipient
+    let tokenReceiver: &{FungibleToken.Receiver}
+
+    /// The total supply of tokens before the burn
+    let supplyBefore: UFix64
+
+    prepare(signer: auth(BorrowValue) &Account) {
+        self.supplyBefore = USDCFlow.totalSupply
+
+        // Borrow a reference to the admin object
+        self.tokenMinter = signer.storage.borrow<auth(FlowEVMBridgeHandlerInterfaces.Mint) &USDCFlow.Minter>(
+                from: /storage/usdcFlowMinter
+            ) ?? panic("Signer is not the token admin")
+
+        let vaultData = USDCFlow.resolveContractView(
+                resourceType: nil,
+                viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
+            ) as! FungibleTokenMetadataViews.FTVaultData?
+            ?? panic("Could not get vault data view for the contract")
+    
+        self.tokenReceiver = getAccount(recipient).capabilities.borrow<&{FungibleToken.Receiver}>(vaultData.receiverPath)
+            ?? panic("Could not borrow receiver reference to the Vault")
+    }
+
+    execute {
+
+        // Create mint tokens
+        let mintedVault <- self.tokenMinter.mint(amount: amount)
+
+        // Deposit them to the receiever
+        self.tokenReceiver.deposit(from: <-mintedVault)
+    }
+
+    post {
+        USDCFlow.totalSupply == self.supplyBefore + amount: "The total supply must be increased by the amount"
+    }
+}

cadence/transactions/usdc/setup_vault.cdc

@@ -0,0 +1,42 @@
+// This transaction is a template for a transaction to allow
+// anyone to add a Vault resource to their account so that
+// they can use the exampleToken
+
+import "FungibleToken"
+import "USDCFlow"
+import "ViewResolver"
+import "FungibleTokenMetadataViews"
+
+transaction () {
+
+    prepare(signer: auth(BorrowValue, IssueStorageCapabilityController, PublishCapability, SaveValue) &Account) {
+
+        let vaultData = USDCFlow.resolveContractView(
+                resourceType: nil,
+                viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
+            ) as! FungibleTokenMetadataViews.FTVaultData?
+            ?? panic("ViewResolver does not resolve FTVaultData view")
+
+        // Return early if the account already stores a ExampleToken Vault
+        if signer.storage.borrow<&USDCFlow.Vault>(from: vaultData.storagePath) != nil {
+            return
+        }
+
+        let vault <- USDCFlow.createEmptyVault(vaultType: Type<@USDCFlow.Vault>())
+
+        // Create a new ExampleToken Vault and put it in storage
+        signer.storage.save(<-vault, to: vaultData.storagePath)
+
+        // Create a public capability to the Vault that exposes the Vault interfaces
+        let vaultCap = signer.capabilities.storage.issue<&USDCFlow.Vault>(
+            vaultData.storagePath
+        )
+        signer.capabilities.publish(vaultCap, at: vaultData.metadataPath)
+
+        // Create a public Capability to the Vault's Receiver functionality
+        let receiverCap = signer.capabilities.storage.issue<&USDCFlow.Vault>(
+            vaultData.storagePath
+        )
+        signer.capabilities.publish(receiverCap, at: vaultData.receiverPath)
+    }
+}

cadence/transactions/usdc/transfer_tokens.cdc

@@ -0,0 +1,48 @@
+// This transaction is a template for a transaction that
+// could be used by anyone to send USDCFlows to another 
+// account that has been set up to receive tokens.
+//
+// The withdraw amount and the account from getAccount
+// would be the parameters to the transaction
+
+import "FungibleToken"
+import "USDCFlow"
+import "FungibleTokenMetadataViews"
+
+transaction(amount: UFix64, to: Address) {
+
+    /// FTVaultData metadata view for the token being used
+    let vaultData: FungibleTokenMetadataViews.FTVaultData
+
+    // The Vault resource that holds the tokens that are being transferred
+    let sentVault: @{FungibleToken.Vault}
+
+    prepare(signer: auth(BorrowValue) &Account) {
+
+        self.vaultData = USDCFlow.resolveContractView(
+                resourceType: nil,
+                viewType: Type<FungibleTokenMetadataViews.FTVaultData>()
+            ) as! FungibleTokenMetadataViews.FTVaultData?
+            ?? panic("ViewResolver does not resolve FTVaultData view")
+
+        // Get a reference to the signer's stored vault
+        let vaultRef = signer.storage.borrow<auth(FungibleToken.Withdraw) &USDCFlow.Vault>(from: self.vaultData.storagePath)
+            ?? panic("Could not borrow reference to the owner's Vault!")
+
+        // Withdraw tokens from the signer's stored vault
+        self.sentVault <- vaultRef.withdraw(amount: amount)
+    }
+
+    execute {
+
+        // Get the recipient's public account object
+        let recipient = getAccount(to)
+
+        // Get a reference to the recipient's Receiver
+        let receiverRef = recipient.capabilities.borrow<&{FungibleToken.Receiver}>(self.vaultData.receiverPath)
+            ?? panic("Could not borrow receiver reference to the recipient's Vault")
+
+        // Deposit the withdrawn tokens in the recipient's receiver
+        receiverRef.deposit(from: <-self.sentVault)
+    }
+}

flow.json

@@ -156,6 +156,14 @@
 				"testnet": "8c5303eaa26202d6"
 			}
 		},
+		"FlowEVMBridgeHandlerInterfaces": {
+			"source": "mainnet://1e4aa0b87d10b141.FlowEVMBridgeHandlerInterfaces",
+			"hash": "7e0e28eb8fb30595249384cb8c7a44eae3884700d0a6c3139240c0d19e4dc173",
+			"aliases": {
+				"emulator": "f8d6e0586b0a20c7",
+				"mainnet": "1e4aa0b87d10b141"
+			}
+		},
 		"FlowStorageFees": {
 			"source": "mainnet://e467b9dd11fa00df.FlowStorageFees",
 			"hash": "e38d8a95f6518b8ff46ce57dfa37b4b850b3638f33d16333096bc625b6d9b51a",
@@ -258,6 +266,14 @@
 				"mainnet": "a6850776a94e6551"
 			}
 		},
+		"USDCFlow": {
+			"source": "mainnet://f1ab99c82dee3526.USDCFlow",
+			"hash": "221e4f6b0d3cfc61d6baab6c968d962ff019a58e1eff43835daa7e62258c8fc5",
+			"aliases": {
+				"emulator": "f8d6e0586b0a20c7",
+				"mainnet": "f1ab99c82dee3526"
+			}
+		},
 		"ViewResolver": {
 			"source": "mainnet://1d7e57aa55817448.ViewResolver",
 			"hash": "374a1994046bac9f6228b4843cb32393ef40554df9bd9907a702d098a2987bde",
@@ -315,6 +331,8 @@
 	"deployments": {
 		"emulator": {
 			"emulator-account": [
+				"FlowEVMBridgeHandlerInterfaces",
+				"USDCFlow",
 				"DeFiActionsMathUtils",
 				"DeFiActionsUtils",
 				"DeFiActions",