Merge pull request #4 from flow-hydraulics/store-resource-in-payload

Store resource in payload

contracts/FungibleToken.cdc

@@ -0,0 +1,205 @@
+/**
+
+# The Flow Fungible Token standard
+
+## `FungibleToken` contract interface
+
+The interface that all fungible token contracts would have to conform to.
+If a users wants to deploy a new token contract, their contract
+would need to implement the FungibleToken interface.
+
+Their contract would have to follow all the rules and naming
+that the interface specifies.
+
+## `Vault` resource
+
+Each account that owns tokens would need to have an instance
+of the Vault resource stored in their account storage.
+
+The Vault resource has methods that the owner and other users can call.
+
+## `Provider`, `Receiver`, and `Balance` resource interfaces
+
+These interfaces declare pre-conditions and post-conditions that restrict
+the execution of the functions in the Vault.
+
+They are separate because it gives the user the ability to share
+a reference to their Vault that only exposes the fields functions
+in one or more of the interfaces.
+
+It also gives users the ability to make custom resources that implement
+these interfaces to do various things with the tokens.
+For example, a faucet can be implemented by conforming
+to the Provider interface.
+
+By using resources and interfaces, users of FungibleToken contracts
+can send and receive tokens peer-to-peer, without having to interact
+with a central ledger smart contract. To send tokens to another user,
+a user would simply withdraw the tokens from their Vault, then call
+the deposit function on another user's Vault to complete the transfer.
+
+*/
+
+/// FungibleToken
+///
+/// The interface that fungible token contracts implement.
+///
+pub contract interface FungibleToken {
+
+    /// The total number of tokens in existence.
+    /// It is up to the implementer to ensure that the total supply
+    /// stays accurate and up to date
+    ///
+    pub var totalSupply: UFix64
+
+    /// TokensInitialized
+    ///
+    /// The event that is emitted when the contract is created
+    ///
+    pub event TokensInitialized(initialSupply: UFix64)
+
+    /// TokensWithdrawn
+    ///
+    /// The event that is emitted when tokens are withdrawn from a Vault
+    ///
+    pub event TokensWithdrawn(amount: UFix64, from: Address?)
+
+    /// TokensDeposited
+    ///
+    /// The event that is emitted when tokens are deposited into a Vault
+    ///
+    pub event TokensDeposited(amount: UFix64, to: Address?)
+
+    /// Provider
+    ///
+    /// The interface that enforces the requirements for withdrawing
+    /// tokens from the implementing type.
+    ///
+    /// It does not enforce requirements on `balance` here,
+    /// because it leaves open the possibility of creating custom providers
+    /// that do not necessarily need their own balance.
+    ///
+    pub resource interface Provider {
+
+        /// withdraw subtracts tokens from the owner's Vault
+        /// and returns a Vault with the removed tokens.
+        ///
+        /// The function's access level is public, but this is not a problem
+        /// because only the owner storing the resource in their account
+        /// can initially call this function.
+        ///
+        /// The owner may grant other accounts access by creating a private
+        /// capability that allows specific other users to access
+        /// the provider resource through a reference.
+        ///
+        /// The owner may also grant all accounts access by creating a public
+        /// capability that allows all users to access the provider
+        /// resource through a reference.
+        ///
+        pub fun withdraw(amount: UFix64): @Vault {
+            post {
+                // `result` refers to the return value
+                result.balance == amount:
+                    "Withdrawal amount must be the same as the balance of the withdrawn Vault"
+            }
+        }
+    }
+
+    /// Receiver
+    ///
+    /// The interface that enforces the requirements for depositing
+    /// tokens into the implementing type.
+    ///
+    /// We do not include a condition that checks the balance because
+    /// we want to give users the ability to make custom receivers that
+    /// can do custom things with the tokens, like split them up and
+    /// send them to different places.
+    ///
+    pub resource interface Receiver {
+
+        /// deposit takes a Vault and deposits it into the implementing resource type
+        ///
+        pub fun deposit(from: @Vault)
+    }
+
+    /// Balance
+    ///
+    /// The interface that contains the `balance` field of the Vault
+    /// and enforces that when new Vaults are created, the balance
+    /// is initialized correctly.
+    ///
+    pub resource interface Balance {
+
+        /// The total balance of a vault
+        ///
+        pub var balance: UFix64
+
+        init(balance: UFix64) {
+            post {
+                self.balance == balance:
+                    "Balance must be initialized to the initial balance"
+            }
+        }
+    }
+
+    /// Vault
+    ///
+    /// The resource that contains the functions to send and receive tokens.
+    ///
+    pub resource Vault: Provider, Receiver, Balance {
+
+        // The declaration of a concrete type in a contract interface means that
+        // every Fungible Token contract that implements the FungibleToken interface
+        // must define a concrete `Vault` resource that conforms to the `Provider`, `Receiver`,
+        // and `Balance` interfaces, and declares their required fields and functions
+
+        /// The total balance of the vault
+        ///
+        pub var balance: UFix64
+
+        // The conforming type must declare an initializer
+        // that allows prioviding the initial balance of the Vault
+        //
+        init(balance: UFix64)
+
+        /// withdraw subtracts `amount` from the Vault's balance
+        /// and returns a new Vault with the subtracted balance
+        ///
+        pub fun withdraw(amount: UFix64): @Vault {
+            pre {
+                self.balance >= amount:
+                    "Amount withdrawn must be less than or equal than the balance of the Vault"
+            }
+            post {
+                // use the special function `before` to get the value of the `balance` field
+                // at the beginning of the function execution
+                //
+                self.balance == before(self.balance) - amount:
+                    "New Vault balance must be the difference of the previous balance and the withdrawn Vault"
+            }
+        }
+
+        /// deposit takes a Vault and adds its balance to the balance of this Vault
+        ///
+        pub fun deposit(from: @Vault) {
+            // Assert that the concrete type of the deposited vault is the same
+            // as the vault that is accepting the deposit
+            pre {
+                from.isInstance(self.getType()): 
+                    "Cannot deposit an incompatible token type"
+            }
+            post {
+                self.balance == before(self.balance) + before(from.balance):
+                    "New Vault balance must be the sum of the previous balance and the deposited Vault"
+            }
+        }
+    }
+
+    /// createEmptyVault allows any user to create a new Vault that has a zero balance
+    ///
+    pub fun createEmptyVault(): @Vault {
+        post {
+            result.balance == 0.0: "The newly created Vault must have zero balance"
+        }
+    }
+}

contracts/MultiSigFlowToken.cdc

@@ -63,8 +63,8 @@ pub contract MultiSigFlowToken: FungibleToken {
         access(self) let multiSigManager: @OnChainMultiSig.Manager;
 
         /// To submit a new paylaod, i.e. starting a new tx requiring, potentially requiring more signatures
-        pub fun addNewPayload(payload: OnChainMultiSig.PayloadDetails, publicKey: String, sig: [UInt8]) {
-            self.multiSigManager.addNewPayload(resourceId: self.uuid, payload: payload, publicKey: publicKey, sig: sig);
+        pub fun addNewPayload(payload: @OnChainMultiSig.PayloadDetails, publicKey: String, sig: [UInt8]) {
+            self.multiSigManager.addNewPayload(resourceId: self.uuid, payload: <-payload, publicKey: publicKey, sig: sig);
         }
 
         /// To submit a new signature for a pre-exising payload, i.e. adding another signature
@@ -75,27 +75,47 @@ pub contract MultiSigFlowToken: FungibleToken {
         /// `configureKey` and `removeKey` functions can be used for all resources if see fit
         /// other methods must be implemented to suit the particular resource
         pub fun executeTx(txIndex: UInt64): @AnyResource? {
-            let p = self.multiSigManager.readyForExecution(txIndex: txIndex) ?? panic ("no transactable payload at given txIndex")
+            let p <- self.multiSigManager.readyForExecution(txIndex: txIndex) ?? panic ("no transactable payload at given txIndex")
             switch p.method {
                 case "configureKey":
-                    let pubKey = p.args[0] as? String ?? panic ("cannot downcast public key");
-                    let weight = p.args[1] as? UFix64 ?? panic ("cannot downcast weight");
+                    let pubKey = p.getArg(i: 0)! as? String ?? panic ("cannot downcast public key");
+                    let weight = p.getArg(i: 1)! as? UFix64 ?? panic ("cannot downcast weight");
+                    destroy(p)
                     self.multiSigManager.configureKeys(pks: [pubKey], kws: [weight])
                 case "removeKey":
-                    let pubKey = p.args[0] as? String ?? panic ("cannot downcast public key");
+                    let pubKey = p.getArg(i: 0)! as? String ?? panic ("cannot downcast public key");
+                    destroy(p)
                     self.multiSigManager.removeKeys(pks: [pubKey])
+                case "removePayload":
+                    let txIndex = p.getArg(i: 0)! as? UInt64 ?? panic ("cannot downcast txIndex");
+                    let payloadToRemove <- self.multiSigManager.removePayload(txIndex: txIndex)
+                    // creating a `temp` resource to replace the existing `@[AnyResource]`
+                    // https://docs.onflow.org/cadence/language/composite-types/#resources-in-arrays-and-dictionaries
+                    var temp: @AnyResource? <- nil 
+                    payloadToRemove.rsc <-> temp
+                    destroy(p)
+                    destroy(payloadToRemove)
+                    return <- temp 
                 case "withdraw":
-                    let amount  = p.args[0] as? UFix64 ?? panic ("cannot downcast amount");
+                    let amount = p.getArg(i: 0)! as? UFix64 ?? panic ("cannot downcast amount");
+                    destroy(p)
                     return <- self.withdraw(amount: amount);
+                case "deposit":
+                    var temp: @AnyResource? <- nil 
+                    p.rsc <-> temp
+                    destroy(p)
+                    let vault <- temp! as! @FungibleToken.Vault
+                    self.deposit(from: <- vault );
                 case "transfer":
-                    let amount = p.args[0] as? UFix64 ?? panic ("cannot downcast amount");
-                    let to = p.args[1] as? Address ?? panic ("cannot downcast address");
+                    let amount = p.getArg(i: 0)! as? UFix64 ?? panic ("cannot downcast amount");
+                    let to = p.getArg(i: 1)! as? Address ?? panic ("cannot downcast address");
                     let toAcct = getAccount(to);
                     let receiver = toAcct.getCapability(MultiSigFlowToken.VaultReceiverPubPath)!
                         .borrow<&{FungibleToken.Receiver}>()
                         ?? panic("Unable to borrow receiver reference for recipient")
 
                     let v <- self.withdraw(amount: amount);
+                    destroy(p)
                     receiver.deposit(from: <- v)
             }
             return nil;