I26 wasm add async

.gitignore

@@ -3,4 +3,9 @@ Cargo.lock
 .idea/
 /test-helper/target
 /test-helper/Cargo.lock
-.env
+www/
+.env
+
+node_modules
+dist
+package-lock.json

Cargo.toml

@@ -2,13 +2,15 @@
 members = [
 	"ethane",
 	"ethane-abi",
+	"ethane-types",
+	"ethane-wasm",
 ]
 
 [profile.dev]
 opt-level = 3
 
 [profile.release]
-opt-level = 3
+opt-level = 3 
 
 [profile.test]
-opt-level = 3
+opt-level = 3

README.md

@@ -9,25 +9,34 @@
 ## Story
 
 Package originally created by [thojest](https://github.com/thojest) and later maintained by ZGEN DAO.
-Created on purpose to make the web3 connection much simpler when using Rust.
-This creates a simple alternative to other web3 packages in Rust.
+Created with the purpose to provide a simple alternative for `Web3` packages written in Rust.
 
 ## Description
 
-Ethane is an alternative web3 implementation with the aim of being slim and simple.
-It does not depend on futures or any executors. It currently supports http and
+Ethane is an alternative `Web3` implementation with the aim of being slim and
+simple. It has two features `blocking` and `non-blocking` that determines the
+http connection type it should use.
+
+A blocking http client does not depend on futures or any executors. Furthermore, it currently supports
 websockets (both plain and TLS) and inter process communication via Unix domain sockets (Unix only). For
 http and websockets it also supports Http Basic and Bearer Authentication. It also has a built-in ABI parser library.
 It's hidden under the contract functionalities, but it can be used alongside with the main crate.
 
+If you still need a non-blocking http client (e.g. for `wasm` compatibility),
+you may compile `Ethane` with the `non-blocking` feature flag to enable an
+`async` http client.
+
 Please also take a look at the [documentation](https://docs.rs/ethane).
 If you just want to use this crate, it is also available on crates.io.
 ([Ethane](https://crates.io/crates/ethane)). If you find any bugs please
 do not hesitate to open an issue.
 
 ## Usage
 
-Guidelines to use the Ethane library.
+Guidelines to use the Ethane library. The examples were worked out for the
+blocking client, however the non-blocking version is quite similar. The main
+difference is that an `AsyncConnection` can only wrap an `AsyncHttp` client without any
+type generics, so there is currently no implementation for a non-blocking websocket.
 
 ### Connection
 
@@ -55,7 +64,7 @@ use ethane::types::Address;
 fn main() {
     let conn = Connection::new(Http::new("http://localhost:8545", None));
 
-    match conn.call(rpc::eth_get_balance(Address::from_str(ADDRESS1).unwrap(), None)) {
+    match conn.call(rpc::eth_get_balance(Address::try_from_str(ADDRESS1).unwrap(), None)) {
         Ok(res) => res,
         Err(err) => println!("{:?}", err),
     }
@@ -78,31 +87,33 @@ fn main() {
     let mut caller = Caller::new_from_path(
         conn,
         "path/to/contract.abi",
-        Address::from_str("0x141770c471a64bcde74c587e55a1ffd9a1bffd31").unwrap(),
+        Address::try_from_str("0x141770c471a64bcde74c587e55a1ffd9a1bffd31").unwrap(),
     );
 
     // The call function determine the call_type based on the state_mutability.
     // This calls to function from an ERC-20 compliant token
     // eth_call
+    let address = Address::try_from_str("0x141770c471a64bcde74c587e55a1ffd9a1bffd31").uwnrap();
     let result = caller.call(
         "balanceOf",
-        vec![Parameter::from(Address::from(address))],
+        vec![Parameter::from(address)],
         None,
     );
     match result {
         CallResult::Transaction(_) => panic!("Should be eth_call"),
         CallResult::Call(r) => match r[0] {
-            Parameter::Uint(data, 256) => assert_eq!(data, H256::from_low_u64_be(1000000000_u64)),
+            Parameter::Uint(data, 256) => assert_eq!(data, H256::from_int_unchecked(1000000000_u64)),
             _ => panic!("Invalid data received!"),
         },
     }
 
     // eth_sendTransaction
+    let to_address = Address::try_from_str("0x...").unwrap();
     let result = caller.call(
         "transfer",
         vec![
-            Parameter::from(Address::from(to_address)),
-            Parameter::from(U256::from(1000)),
+            Parameter::from(to_address),
+            Parameter::from(U256::try_from_int(1000_u128).unwrap()),
         ],
         Some(CallOpts {
             force_call_type: None, // NOTE: the call_type can be forced

ethane-abi/Cargo.toml

@@ -11,11 +11,9 @@ categories = ["cryptography::cryptocurrencies", "web-programming"]
 readme = "../README.md"
 
 [dependencies]
-byteorder = "1.4.3"
-ethereum-types = "0.11"
+ethane-types = { path = "../ethane-types" }
 serde_json = "1.0"
-sha3 = "0.9.1"
-thiserror = "1.0"
+tiny-keccak = { version = "2.0", features = ["keccak"] }
 
 [dev-dependencies]
 hex-literal = "0.3"

ethane-abi/src/lib.rs

@@ -1,10 +1,8 @@
 use std::collections::HashMap;
 use std::fs::File;
-use std::io::BufReader;
 use std::path::Path;
 
-use sha3::{Digest, Keccak256};
-use thiserror::Error;
+use tiny_keccak::{Hasher, Keccak};
 
 mod function;
 mod parameter;
@@ -59,9 +57,10 @@ impl Abi {
 
     /// Parses an ABI `.json` file into the `Abi` instance.
     pub fn parse_file(&mut self, path_to_abi: &Path) -> Result<(), AbiParserError> {
-        let file = File::open(path_to_abi)?;
-        let reader = BufReader::new(file);
-        let abi: serde_json::Value = serde_json::from_reader(reader)?;
+        let reader =
+            File::open(path_to_abi).map_err(|e| AbiParserError::FileIoError(e.to_string()))?;
+        let abi: serde_json::Value =
+            serde_json::from_reader(reader).map_err(|e| AbiParserError::Serde(e.to_string()))?;
 
         self.parse_json(abi)
     }
@@ -98,10 +97,12 @@ impl Abi {
                 }
             }
             let signature = format!("{}({})", function_name, abi_arguments.join(","));
-            let mut hasher = Keccak256::new();
-            hasher.update(signature);
+            let mut hasher = Keccak::v256();
+            hasher.update(signature.as_bytes());
             // Take first 4 bytes of the Keccak hash
-            let mut hash = hasher.finalize()[0..4].to_vec();
+            let mut out = [0_u8; 32];
+            hasher.finalize(&mut out);
+            let mut hash = out[0..4].to_vec();
             // Append the encoded parameters to the hash
             parameter::encode_into(&mut hash, parameters);
             Ok(hash)
@@ -140,16 +141,11 @@ impl Abi {
     }
 }
 
-#[derive(Error, Debug)]
+#[derive(Debug)]
 pub enum AbiParserError {
-    #[error("Couldn't open ABI file: {0}")]
-    FileIoError(#[from] std::io::Error),
-    #[error("De-/Serialization error: {0}")]
-    Serde(#[from] serde_json::Error),
-    #[error("Missing data error: {0}")]
+    FileIoError(String),
+    Serde(String),
     MissingData(String),
-    #[error("Invalid ABI encoding error: {0}")]
     InvalidAbiEncoding(String),
-    #[error("Parameter type doesn't match the internal data type")]
     TypeError,
 }