Merge pull request #24 from ddimaria/features/implement-basic-erc20-functionality

Features/implement basic erc20 functionality

Author: eiri0k

README.md

@@ -60,6 +60,7 @@ This repo is designed to train Rust developers on intermediate and advanced Rust
   - [Contracts](#contracts)
     - [WIT](#wit)
     - [Sample Contract - Erc20](#sample-contract---erc20)
+    - [Invoking a Contract Function](#invoking-a-contract-function)
   - [Web3](#web3)
     - [Sample Usage](#sample-usage)
   - [Types](#types)
@@ -735,8 +736,17 @@ fn process_transaction<'a>(
                 contract_address = self.accounts.add_contract_account(&from, data).ok();
                 Ok(())
             }
-            TransactionKind::ContractExecution(_from, _to, _data) => {
-                unimplemented!()
+            TransactionKind::ContractExecution(_from, to, data) => {
+                let code = self
+                    .accounts
+                    .get_account(&to)?
+                    .code_hash
+                    .ok_or_else(|| ChainError::NotAContractAccount(to.to_string()))?;
+                let (function, params): (&str, Vec<&str>) = bincode::deserialize(&data)?;
+
+                // call the function in the contract
+                runtime::contract::call_function(&code, function, &params)
+                    .map_err(|e| ChainError::RuntimeError(to.to_string(), e.to_string()))
             }
         }?;
 
@@ -777,9 +787,43 @@ pub fn add_contract_account(&mut self, key: &Account, data: Bytes) -> Result<Acc
 
 Code received gets added to the `to` account's `code_hash` attribute.
 
-_TODO: document processing a contract execution_
+Contract execution involves calling a function in the contract in a WASM virtual machine (Wasmtime).  This sandboxing isolates contract execution from the rest of the blockchain.  We first must get the executable code from account storage:
 
-After the transaction is processed, the `from` account's `nonce` is updated.  A `transaction receipt` is created and returned from the function.
+```rust
+let code = self
+    .accounts
+    .get_account(&to)?
+    .code_hash
+    .ok_or_else(|| ChainError::NotAContractAccount(to.to_string()))?;
+```
+
+Now we just extract the function name and the function parameters from the `data` node in the transaction request:
+
+```rust 
+let (function, params): (&str, Vec<&str>) = bincode::deserialize(&data)?;
+```
+
+For example, let's say we want to invoke the `construct` function.  The function signature of `construct` contract function is:
+
+```rust
+fn construct(name: String, symbol: String) {}
+```
+
+We serialize the parameter types and values:
+
+
+```rust
+// ["Param 1 Type", "Param 1 Value", "Param 2 Type", "Param 2 Value"]
+let params = ["String", "Rust Coin", "String", "RustCoin"];
+```
+
+We can now invoke the `construct` function:
+
+```rust
+runtime::contract::call_function(&code, "construct", &params)?;
+```
+
+After we've handled one of the 3 transaction types, the `from` account's `nonce` is updated.  A `transaction receipt` is created and returned from the function.
 
 ## Organization
 
@@ -849,7 +893,7 @@ use wit_bindgen_guest_rust::*;
 
 wit_bindgen_guest_rust::generate!({path: "../erc20/erc20.wit", world: "erc20"});
 
-struct Erc20 {}
+struct Erc20;
 
 export_contract!(Erc20);
 
@@ -868,6 +912,19 @@ impl erc20::Erc20 for Erc20 {
 }
 ```
 
+#### Invoking a Contract Function
+
+This code can convert the textual representation of a contract function call to a function call within the wasmtime runtime.
+Parameters are listed in pairs of parameter type and paramater value.
+
+```rust
+let bytes = include_bytes!("./../../target/wasm32-unknown-unknown/release/erc20_wit.wasm");
+let function_name = "construct";
+let params = &["String", "Rust Coin", "String", "RustCoin"];
+
+call_function(bytes, function_name, params)?;
+```
+
 ### Web3
 
 The [web3](web3) crate is a naive implementation of a Web3 interface.
@@ -887,7 +944,7 @@ let block_number = web3.get_block_number().await?;
 let block = web3.get_block(*block_number).await?;
 
 let contract =
-    include_bytes!("./../../contracts/artifacts/contracts/ERC20.sol/RustCoinToken.json").to_vec();
+    include_bytes!("./../../target/wasm32-unknown-unknown/release/erc20_wit.wasm").to_vec();
 let tx_hash = web3.deploy(all_accounts[0], &contract).await?;
 let receipt = web3.transaction_receipt(tx_hash).await?;
 let code = web3.code(receipt.contract_address.unwrap(), None).await?;

chain/Cargo.toml

@@ -17,6 +17,7 @@ lazy_static = "1.4.0"
 proc_macros = { path = "../proc_macros" }
 rayon = "1.5.3"
 rocksdb = "0.19.0"
+runtime = { path = "../runtime" }
 serde_json = { version = "1.0", features = ["raw_value"] }
 serde = "1"
 thiserror = "1.0"

chain/src/blockchain.rs

@@ -232,8 +232,17 @@ impl BlockChain {
                     contract_address = self.accounts.add_contract_account(&from, data).ok();
                     Ok(())
                 }
-                TransactionKind::ContractExecution(_from, _to, _data) => {
-                    unimplemented!()
+                TransactionKind::ContractExecution(_from, to, data) => {
+                    let code = self
+                        .accounts
+                        .get_account(&to)?
+                        .code_hash
+                        .ok_or_else(|| ChainError::NotAContractAccount(to.to_string()))?;
+                    let (function, params): (&str, Vec<&str>) = bincode::deserialize(&data)?;
+
+                    // call the function in the contract
+                    runtime::contract::call_function(&code, function, &params)
+                        .map_err(|e| ChainError::RuntimeError(to.to_string(), e.to_string()))
                 }
             }?;
 

chain/src/error.rs

@@ -57,6 +57,12 @@ pub enum ChainError {
     #[error("Nonce {0} too low for account {1}")]
     NonceTooLow(String, String),
 
+    #[error("Account {0} is not a contract account")]
+    NotAContractAccount(String),
+
+    #[error("Error executing contract at address {0}: {1}")]
+    RuntimeError(String, String),
+
     #[error("Could not serialize: {0}")]
     SerializeError(String),
 

contracts/erc20/Cargo.toml

@@ -7,4 +7,4 @@ edition = "2021"
 crate-type = ["cdylib"]
 
 [dependencies]
-wit-bindgen-guest-rust = { git = "https://github.com/bytecodealliance/wit-bindgen" }
+wit-bindgen = { version = "0.4.0" }

contracts/erc20/README.md

@@ -3,6 +3,7 @@
 The [contracts](contracts) directory holds the WASM source code.
 Using [wit-bindgen](https://github.com/bytecodealliance/wit-bindgen), we can greatly simplify dealing with complex types.
 The [WIT format](https://github.com/WebAssembly/component-model/blob/main/design/mvp/WIT.md) specifies a language for generating WASM code. 
+
 ## Contracts
 
 ### WIT

contracts/erc20/erc20.wit

@@ -1,13 +1,19 @@
 #![allow(unused)]
-use wit_bindgen_guest_rust::*;
+use std::collections::HashMap;
 
-wit_bindgen_guest_rust::generate!({path: "../erc20/erc20.wit", world: "erc20"});
+wit_bindgen::generate!("erc20");
 
-struct Erc20 {}
+pub struct Erc20;
+
+pub struct State {
+    name: String,
+    symbol: String,
+    balances: HashMap<String, u64>,
+}
 
 export_contract!(Erc20);
 
-impl erc20::Erc20 for Erc20 {
+impl Contract for Erc20 {
     fn construct(name: String, symbol: String) {
         println!("name {}, symbol", symbol);
     }

contracts/erc20/src/lib.rs

@@ -0,0 +1,5 @@
+default world contract {
+  export construct: func(name: string, symbol: string)
+  export mint: func(account: string, amount: u64)
+  export transfer: func(to: string, amount: u64)
+}

contracts/erc20/wit/erc20.wit

@@ -7,15 +7,15 @@ edition = "2021"
 [dependencies]
 anyhow = "1.0.68"
 env_logger = "0.10.0"
+paste = "1.0.12"
 thiserror = "1.0.38"
 tracing = "0.1.34"
 tracing-subscriber = { version = "0.3.15", features = ["env-filter"] }
-types = { path = "../types" }
-wasmtime = { git = "https://github.com/bytecodealliance/wasmtime", features = [
-  "component-model",
-] }
-wit-component = "*"
+wasmtime = { version = "6.0.1", features = ["component-model"] }
+wit-component = "0.7.3"
+wit-bindgen = { version = "0.4.0" }
 
 
 [dev-dependencies]
 test-log = { version = "0.2.11", features = ["trace"] }
+types = { path = "../types" }