I36 remove deps

.gitignore

@@ -3,4 +3,8 @@ Cargo.lock
 .idea/
 /test-helper/target
 /test-helper/Cargo.lock
-.env
+.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

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,
 }

ethane-abi/src/parameter/construction.rs

@@ -1,6 +1,6 @@
 use super::utils::*;
 use super::Parameter;
-use ethereum_types::{Address, H256, U128, U256, U64};
+use ethane_types::{Address, H256, U128, U256, U64};
 
 use std::convert::From;
 
@@ -31,103 +31,79 @@ impl Parameter {
 impl From<u8> for Parameter {
     #[inline]
     fn from(input: u8) -> Self {
-        Self::Uint(H256::from_slice(&left_pad_to_32_bytes(&[input])), 8)
+        Self::Uint(H256::from_int_unchecked(input), 8)
     }
 }
 
 impl From<u16> for Parameter {
     #[inline]
     fn from(input: u16) -> Self {
-        Self::Uint(
-            H256::from_slice(&left_pad_to_32_bytes(&input.to_be_bytes())),
-            16,
-        )
+        Self::Uint(H256::from_int_unchecked(input), 16)
     }
 }
 
 impl From<u32> for Parameter {
     #[inline]
     fn from(input: u32) -> Self {
-        Self::Uint(
-            H256::from_slice(&left_pad_to_32_bytes(&input.to_be_bytes())),
-            32,
-        )
+        Self::Uint(H256::from_int_unchecked(input), 32)
     }
 }
 
 impl From<u64> for Parameter {
     #[inline]
     fn from(input: u64) -> Self {
-        Self::Uint(
-            H256::from_slice(&left_pad_to_32_bytes(&input.to_be_bytes())),
-            64,
-        )
+        Self::Uint(H256::from_int_unchecked(input), 64)
     }
 }
 
 impl From<u128> for Parameter {
     #[inline]
     fn from(input: u128) -> Self {
-        Self::Uint(
-            H256::from_slice(&left_pad_to_32_bytes(&input.to_be_bytes())),
-            128,
-        )
+        Self::Uint(H256::from_int_unchecked(input), 128)
     }
 }
 
 // Signed elementary integer types
 impl From<i8> for Parameter {
     #[inline]
     fn from(input: i8) -> Self {
-        Self::Int(H256::from_slice(&left_pad_to_32_bytes(&[input as u8])), 8)
+        Self::Int(H256::from_int_unchecked(input), 8)
     }
 }
 
 impl From<i16> for Parameter {
     #[inline]
     fn from(input: i16) -> Self {
-        Self::Int(
-            H256::from_slice(&left_pad_to_32_bytes(&input.to_be_bytes())),
-            16,
-        )
+        Self::Int(H256::from_int_unchecked(input), 16)
     }
 }
 
 impl From<i32> for Parameter {
     #[inline]
     fn from(input: i32) -> Self {
-        Self::Int(
-            H256::from_slice(&left_pad_to_32_bytes(&input.to_be_bytes())),
-            32,
-        )
+        Self::Int(H256::from_int_unchecked(input), 32)
     }
 }
 
 impl From<i64> for Parameter {
     #[inline]
     fn from(input: i64) -> Self {
-        Self::Int(
-            H256::from_slice(&left_pad_to_32_bytes(&input.to_be_bytes())),
-            64,
-        )
+        Self::Int(H256::from_int_unchecked(input), 64)
     }
 }
 
 impl From<i128> for Parameter {
     #[inline]
     fn from(input: i128) -> Self {
-        Self::Int(
-            H256::from_slice(&left_pad_to_32_bytes(&input.to_be_bytes())),
-            128,
-        )
+        Self::Int(H256::from_int_unchecked(input), 128)
     }
 }
 
 // Boolean type
 impl From<bool> for Parameter {
     #[inline]
     fn from(input: bool) -> Self {
-        Self::Bool(H256::from_slice(&left_pad_to_32_bytes(&[u8::from(input)])))
+        Self::Bool(H256::from_int_unchecked(u8::from(input)))
     }
 }
 
@@ -143,42 +119,36 @@ impl From<&str> for Parameter {
 impl From<Address> for Parameter {
     #[inline]
     fn from(input: Address) -> Self {
-        Self::Address(H256::from_slice(&left_pad_to_32_bytes(&input.as_bytes())))
+        Self::Address(H256::from(&left_pad_to_32_bytes(input.as_bytes())))
     }
 }
 
 impl From<U64> for Parameter {
     #[inline]
     fn from(input: U64) -> Self {
-        let mut bytes = [0u8; 8];
-        input.to_big_endian(&mut bytes);
-        Self::Uint(H256::from_slice(&left_pad_to_32_bytes(&bytes)), 64)
+        Self::Uint(H256::from(&left_pad_to_32_bytes(input.as_bytes())), 64)
     }
 }
 
 impl From<U128> for Parameter {
     #[inline]
     fn from(input: U128) -> Self {
-        let mut bytes = [0u8; 16];
-        input.to_big_endian(&mut bytes);
-        Self::Uint(H256::from_slice(&left_pad_to_32_bytes(&bytes)), 128)
+        Self::Uint(H256::from(&left_pad_to_32_bytes(input.as_bytes())), 128)
     }
 }
 
 impl From<U256> for Parameter {
     #[inline]
     fn from(input: U256) -> Self {
-        let mut padded = [0u8; 32];
-        input.to_big_endian(&mut padded);
-        Self::Uint(H256::from_slice(&padded), 256)
+        Self::Uint(H256::from(input.into_bytes()), 256)
     }
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
     use hex_literal::hex;
-    use std::str::FromStr;
+    use std::convert::TryFrom;
 
     #[test]
     fn parameter_from_elementary_numeric_type() {
@@ -306,40 +276,40 @@ mod test {
         let param = Parameter::from(U64::zero());
         if let Parameter::Uint(value, len) = param {
             assert_eq!(len, 64);
-            assert_eq!(value.to_fixed_bytes(), [0u8; 32]);
+            assert_eq!(value.into_bytes(), [0u8; 32]);
         } else {
             panic!("From U64 test failed")
         }
 
         // from U128
-        let param = Parameter::from(U128::from_str("12345").unwrap());
+        let param = Parameter::from(U128::try_from("12345").unwrap());
         if let Parameter::Uint(value, len) = param {
             let mut expected = [0u8; 32];
             expected[28..].copy_from_slice(&0x12345u32.to_be_bytes());
             assert_eq!(len, 128);
-            assert_eq!(value.to_fixed_bytes(), expected);
+            assert_eq!(value.into_bytes(), expected);
         } else {
             panic!("From U128 test failed")
         }
 
         // from U256
-        let param = Parameter::from(U256::from_str("123456789").unwrap());
+        let param = Parameter::from(U256::try_from("123456789").unwrap());
         if let Parameter::Uint(value, len) = param {
             let mut expected = [0u8; 32];
             expected[24..].copy_from_slice(&0x123456789u64.to_be_bytes());
             assert_eq!(len, 256);
-            assert_eq!(value.to_fixed_bytes(), expected);
+            assert_eq!(value.into_bytes(), expected);
         } else {
             panic!("From U256 test failed")
         }
 
         // from Address
         let param = Parameter::from(
-            Address::from_str("0x95eDA452256C1190947f9ba1fD19422f0120858a").unwrap(),
+            Address::try_from("0x95eDA452256C1190947f9ba1fD19422f0120858a").unwrap(),
         );
         if let Parameter::Address(value) = param {
             let expected = hex!("00000000000000000000000095eDA452256C1190947f9ba1fD19422f0120858a");
-            assert_eq!(value.to_fixed_bytes(), expected);
+            assert_eq!(value.into_bytes(), expected);
         } else {
             panic!("From U256 test failed")
         }
@@ -389,7 +359,7 @@ mod test {
         let param = Parameter::new_int([14; 32], true); // signed = true
         if let Parameter::Int(value, len) = param {
             assert_eq!(len, 256);
-            assert_eq!(value.to_fixed_bytes(), [14u8; 32]);
+            assert_eq!(value.into_bytes(), [14u8; 32]);
         } else {
             panic!("Signed integer from fixed slice test failed");
         }
@@ -398,7 +368,7 @@ mod test {
         let param = Parameter::new_int([12; 32], false); // signed = false
         if let Parameter::Uint(value, len) = param {
             assert_eq!(len, 256);
-            assert_eq!(value.to_fixed_bytes(), [12u8; 32]);
+            assert_eq!(value.into_bytes(), [12u8; 32]);
         } else {
             panic!("Unsigned integer from fixed slice test failed");
         }