rewritten eng_wasm_derive::pub_interface

* Enabled usage of the \#[pub_interface] annotation on `impl Struct` items
  as well as on trait items. When using the trait version the name of the
  struct/enum implementing the methods was (and still is) hardcoded as
  `Contract`. When using the new form, the user may use whatever name they want
  for the struct. It has no side-effects.
  (They can theoretically use any type they want now)
* Added the following diagnostics to the macro invocation:
  (when any of these is detected, the user will see a useful error message)
    * The attribute was placed on an item which is not a trait or inherent impl
    * The trait or impl methods use the `self` receiver
    * Trait methods provided a default implementation (i understand that we
      wanted the users to define the implementations on the `Contract` struct)
    * Trait method with any additional attribute
    * Impl method with a \#[no_mangle] attribute
    * Impl method with visibility which isn't private or `pub`
      (we don't want them defining `pub(crate)` or `pub(in something)` because
      that can be misleading in this context)
* Fixed issue around parsing return values from contract methods where their
  amount was incorrectly calculated
* When parsing of method inputs fails at runtime, the panic message now
  mentions the type and argument that caused the failure.
* If an unknown method is called, the panic message mentions the name of
  that method.
* Using the contract no longer requires writing `use eng_wasm::*;` in the using
  module
* restructured the module layout to make it easier to follow.
* added unittests
* documented a lot of things

The ERC20 example now generates the following code:
https://gist.github.com/rust-play/d9e375f7a587725be238ced968630d28

Author: reuvenpo

eng-wasm/Cargo.toml

@@ -11,4 +11,4 @@ categories = ["wasm"]
 [dependencies]
 serde_json = "1.0"
 serde = { version = "1.0", default-features = false }
-eng-pwasm-abi = "0.3"
+eng-pwasm-abi = "0.3"

eng-wasm/derive/.rustfmt.toml

@@ -0,0 +1 @@
+# override global formatting. i want clean and standard runstfmt.

eng-wasm/derive/Cargo.toml

@@ -1,22 +1,24 @@
 [package]
 name = "eng-wasm-derive"
 version = "0.1.3"
-authors = ["moria <[email protected]>"]
+authors = ["moria <[email protected]>", "Reuven Podmazo <[email protected]>"]
+edition = "2018"
 license = "AGPL-3.0"
 description = "Enigma library for creating Secret Contracts"
 keywords = ["wasm", "webassembly", "blockchain", "sgx", "enigma"]
 categories = ["wasm"]
 
+[lib]
+proc-macro = true
+
 [dependencies]
-eng-wasm = { version = "0.1.3", path = "../" }
-proc-macro2 = "0.4"
-quote = "0.6"
-syn = { version = "0.15", features = ["full"] }
-#syn = { version = "0.15", features = ["full", "extra-traits"] } # for debug purposes
-failure = { version = "0.1.5", default-features = false, features = ["derive"] }
+proc-macro2 = "1.0"
+syn = { version = "1.0", features = ["full"] }
+quote = "1.0"
+failure = "0.1"
 ethabi = "6.1"
 serde_json = "1.0"
 tiny-keccak = "1.4"
 
-[lib]
-proc-macro = true
+[dev-dependencies]
+syn = { version = "1.0", features = ["full", "extra-traits"] }

eng-wasm/derive/src/eth_contract.rs

@@ -0,0 +1,154 @@
+use std::fs::File;
+
+use quote::quote;
+
+use ethabi::{Contract, ParamType};
+
+mod errors;
+mod ethereum;
+
+use errors::EngWasmError;
+use ethereum::short_signature;
+
+trait Write {
+    fn write(&self) -> String;
+    fn error(&self) -> String;
+}
+
+impl Write for ParamType {
+    /// Returns string which is a formatted representation of param.
+    fn write(&self) -> String {
+        match *self {
+            ParamType::Address => "Address".to_owned(),
+            ParamType::Bytes => "Vec<u8>".to_owned(),
+            ParamType::FixedBytes(len) => format!("u8[{}]", len),
+            ParamType::Int(len) => match len {
+                32 | 64 => format!("i{}", len),
+                _ => panic!("{}", self.error()),
+            },
+            ParamType::Uint(len) => match len {
+                32 | 64 => format!("u{}", len),
+                256 => "U256".to_owned(),
+                _ => panic!("{}", self.error()),
+            },
+            ParamType::Bool => "bool".to_owned(),
+            ParamType::String => "String".to_owned(),
+            ParamType::FixedArray(ref param, len) => format!("{}[{}]", param.write(), len),
+            ParamType::Array(ref param) => format!("Vec<{}>", param.write()),
+        }
+    }
+    fn error(&self) -> String {
+        format!("The type {} is not supported", self.to_string())
+    }
+}
+
+struct FunctionAst {
+    name: syn::Ident,
+    args_ast_types: Vec<syn::Type>,
+    args_types: Vec<ParamType>,
+}
+
+fn read_contract_file(file_path: String) -> Result<Box<File>, EngWasmError> {
+    let file = File::open(file_path)?;
+    let contents = Box::new(file);
+    Ok(contents)
+}
+
+fn generate_eth_functions(
+    contract: &Contract,
+) -> Result<Vec<proc_macro2::TokenStream>, EngWasmError> {
+    let mut functions: Vec<FunctionAst> = Vec::new();
+    for function in &contract.functions {
+        let mut args_ast_types = Vec::new();
+        for input in &function.1.inputs {
+            let arg_type: syn::Type = syn::parse_str(&input.kind.clone().write())?;
+            args_ast_types.push(arg_type);
+        }
+        let args_types = function
+            .1
+            .inputs
+            .iter()
+            .map(|input| input.kind.clone())
+            .collect();
+
+        let name = syn::Ident::new(&function.1.name, proc_macro2::Span::call_site());
+        functions.push(FunctionAst {
+            name,
+            args_types,
+            args_ast_types,
+        })
+    }
+
+    let result: Vec<proc_macro2::TokenStream> = functions
+        .iter()
+        .map(|function| {
+            let function_name = &function.name;
+            let args_ast_types = function.args_ast_types.clone();
+            let sig_u32 = short_signature(&function_name.to_string(), &function.args_types);
+            let sig = syn::Lit::Int(syn::LitInt::new(
+                &format!("{}_u32", sig_u32 as u32),
+                proc_macro2::Span::call_site(),
+            ));
+            let args_number = syn::Lit::Int(syn::LitInt::new(
+                &format!("{}_usize", args_ast_types.len() as usize),
+                proc_macro2::Span::call_site(),
+            ));
+            let args_names: Vec<syn::Ident> = function
+                .args_ast_types
+                .iter()
+                .enumerate()
+                .map(|item| {
+                    let mut arg = String::from("arg");
+                    arg.push_str(item.0.to_string().as_str());
+                    syn::Ident::new(&arg, proc_macro2::Span::call_site())
+                })
+                .collect();
+            let args_names_copy = args_names.clone();
+            quote! {
+                fn #function_name(&self, #(#args_names: #args_ast_types),*){
+                    #![allow(unused_mut)]
+                    #![allow(unused_variables)]
+                    let mut payload = Vec::with_capacity(4 + #args_number * 32);
+                    payload.push((#sig >> 24) as u8);
+                    payload.push((#sig >> 16) as u8);
+                    payload.push((#sig >> 8) as u8);
+                    payload.push(#sig as u8);
+
+                    let mut sink = eng_pwasm_abi::eth::Sink::new(#args_number);
+                    #(sink.push(#args_names_copy);)*
+                    sink.drain_to(&mut payload);
+                    write_ethereum_bridge(&payload, &self.addr);
+                }
+            }
+        })
+        .collect();
+
+    Ok(result)
+}
+
+pub fn impl_eth_contract(
+    args: proc_macro2::TokenStream,
+    input: proc_macro2::TokenStream,
+) -> proc_macro2::TokenStream {
+    let input_tokens = parse_macro_input2!(input as syn::ItemStruct);
+    let struct_name = input_tokens.ident;
+    let file_path = parse_macro_input2!(args as syn::LitStr);
+    let contents: Box<File> = read_contract_file(file_path.value()).expect("Bad contract file");
+    let contract = Contract::load(contents).unwrap();
+    let it: Vec<proc_macro2::TokenStream> = generate_eth_functions(&contract).unwrap();
+
+    quote! {
+        struct #struct_name {
+            addr: Address,
+        }
+        impl EthContract{
+            fn new(addr_str: /*Address*/&str) -> Self {
+                use core::str::FromStr;
+        // Ethereum Addresses need to start with `0x` so we remove the first two characters
+                let addr = Address::from_str(&addr_str[2..]).expect("Failed converting the address from hex");
+                EthContract{ addr }
+            }
+             #(#it)*
+        }
+    }
+}

eng-wasm/derive/src/errors.rs renamed to eng-wasm/derive/src/eth_contract/errors.rs

@@ -14,24 +14,24 @@ pub enum EngWasmError {
 
 impl From<io::Error> for EngWasmError {
     fn from(error: io::Error) -> Self {
-        match error {
-            _ => EngWasmError::IoError { error: error.to_string() },
+        EngWasmError::IoError {
+            error: error.to_string(),
         }
     }
 }
 
 impl From<serde_json::Error> for EngWasmError {
     fn from(err: serde_json::Error) -> Self {
-        match err {
-            _ => EngWasmError::JsonError { error: err.to_string() },
+        EngWasmError::JsonError {
+            error: err.to_string(),
         }
     }
 }
 
 impl From<syn::parse::Error> for EngWasmError {
     fn from(err: syn::parse::Error) -> Self {
-        match err {
-            _ => EngWasmError::TokenParseError { error: err.to_string() },
+        EngWasmError::TokenParseError {
+            error: err.to_string(),
         }
     }
 }

eng-wasm/derive/src/ethereum.rs renamed to eng-wasm/derive/src/eth_contract/ethereum.rs

@@ -9,7 +9,11 @@ pub fn short_signature(name: &str, params: &[ParamType]) -> u32 /*[u8; 4] */ {
 }
 
 fn fill_signature(name: &str, params: &[ParamType], result: &mut [u8]) {
-    let types = params.iter().map(Writer::write).collect::<Vec<String>>().join(",");
+    let types = params
+        .iter()
+        .map(Writer::write)
+        .collect::<Vec<String>>()
+        .join(",");
 
     let data: Vec<u8> = From::from(format!("{}({})", name, types).as_str());
 

eng-wasm/derive/src/into_ident.rs

@@ -0,0 +1,9 @@
+pub trait IntoIdent {
+    fn into_ident(self) -> syn::Ident;
+}
+
+impl IntoIdent for &str {
+    fn into_ident(self) -> syn::Ident {
+        quote::format_ident!("{}", self)
+    }
+}