MERGE: Merged develop into ptt

Author: elichai

eng_wasm/Cargo.toml

@@ -6,3 +6,10 @@ authors = ["moria <moria@enigma.co>"]
 [dependencies]
 serde_json = "1.0"
 serde = "1.0"
+pwasm-abi = { git = "https://github.com/enigmampc/pwasm-abi.git" }
+failure_derive="=0.1.1"
+failure = { version = "=0.1.1", default-features = false, features = ["derive"] }
+syn = { version = "0.15.12", features = ["full", "extra-traits"] }
+tiny-keccak = "1.4"
+ethabi = "6.1.0"
+byteorder = "1"

eng_wasm/dispatch/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "eng_wasm_dispatch"
+version = "0.1.0"
+
+[dependencies]
+eng_wasm = {path = "../../eng_wasm"}
+proc-macro2 = "0.4"
+quote = "0.6.8"
+syn = { version = "0.15.12", features = ["full", "extra-traits"] }
+serde_json = "1.0"
+ethabi = "6.1.0"
+
+[lib]
+proc-macro = true

eng_wasm/dispatch/src/lib.rs

@@ -0,0 +1,256 @@
+#![recursion_limit="128"]
+extern crate eng_wasm;
+extern crate proc_macro2;
+#[macro_use] extern crate quote;
+extern crate proc_macro;
+#[macro_use]
+extern crate syn;
+extern crate serde_json;
+extern crate ethabi;
+
+use eng_wasm::*;
+use std::fs::File;
+use std::string::ToString;
+//use std::io::prelude::*;
+use std::convert::*;
+use ethabi::{Contract, ParamType};
+
+fn generate_eng_wasm_aux_functions() -> proc_macro2::TokenStream{
+    quote!{
+        #[no_mangle]
+        pub fn function_name() -> String {
+
+            let length_result = unsafe { eng_wasm::external::fetch_function_name_length() };
+
+            match length_result {
+                0 => "".to_string(),
+                length => {
+                let mut data = Vec::with_capacity(length as usize);
+                for _ in 0..length{
+                    data.push(0);
+                }
+
+                unsafe {
+                    eng_wasm::external::fetch_function_name(data.as_mut_ptr());
+                }
+                from_utf8(&data).unwrap().to_string()
+                }
+            }
+        }
+        #[no_mangle]
+        pub fn args() -> String {
+            let length_result = unsafe { external::fetch_args_length() };
+
+            match length_result {
+                0 => "".to_string(),
+                length => {
+                    let mut data = Vec::with_capacity(length as usize);
+                    for _ in 0..length{
+                        data.push(0);
+                    }
+
+                    unsafe {
+                        external::fetch_args(data.as_mut_ptr());
+                    }
+                    from_utf8(&data).unwrap().to_string()
+                }
+            }
+        }
+
+    }
+}
+
+fn generate_dispatch(input: syn::Item) -> proc_macro2::TokenStream{
+    let v;
+    let functions= match input {
+        syn::Item::Trait(input) => {
+            v = input.items;
+            v.iter()
+        },
+        _ => panic!(),
+    };
+
+    let it: Vec<proc_macro2::TokenStream> = functions.filter_map(|item| {
+        match item {
+                syn::TraitItem::Method(item) => {
+                    let func = item.sig.ident.clone();
+                    let arg_types: Vec<proc_macro2::TokenStream> = item.sig.decl.inputs.iter().filter_map(|arg| match arg {
+                        // Argument captured by a name
+                        syn::FnArg::Captured(arg_captured) => {
+                            let ty = &arg_captured.ty;
+                            Some(quote!{#ty})
+                        },
+                        // Argument without a name
+                        syn::FnArg::Ignored(type_only) => {
+                            Some(quote!{#type_only})
+                        },
+                        _ => None,
+                    }).collect();
+
+                    let name = &func.to_string();
+                    //println!("METHOD {:#?} TYPES {:#?}", item, arg_types);
+                    Some(quote!{
+                        #name => {
+                            let mut stream = pwasm_abi::eth::Stream::new(args.as_bytes());
+
+                            Contract::#func(#(stream.pop::<#arg_types>().expect("argument decoding failed")),*);
+
+                        }
+                    })
+                },
+                _ => None,
+        }
+    }).collect();
+
+
+    quote! {
+        pub fn dispatch(name: &str, args: &str){
+            match name{
+            #(#it,)*
+            _=>panic!(),
+            }
+        }
+    }
+}
+
+#[proc_macro_attribute]
+#[allow(unused_variables, unused_mut)]
+pub fn dispatch(args: proc_macro::TokenStream, input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input_tokens = parse_macro_input!(input as syn::Item);
+    let disp = generate_dispatch(input_tokens.clone());
+    let eng_wasm_aux = generate_eng_wasm_aux_functions();
+    let result = quote! {
+        #eng_wasm_aux
+        #input_tokens
+        #disp
+
+        #[no_mangle]
+        pub fn call(){
+            dispatch(&function_name(), &args());
+        }
+    };
+    proc_macro::TokenStream::from(result)
+}
+
+//--------------------------------------------------------------------------------------------------
+
+trait Write{
+    fn write(&self) -> String;
+    fn error(&self) -> String;
+}
+
+impl Write for ParamType{
+    /// Returns string which is a formatted represenation 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!("i{}", 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())
+    }
+}
+
+#[derive(Debug)]
+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<Box<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(sig_u32 as u64, syn::IntSuffix::U32, proc_macro2::Span::call_site()));
+        let args_number = syn::Lit::Int(syn::LitInt::new(args_ast_types.len() as u64,
+                                                         syn::IntSuffix::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 = pwasm_abi::eth::Sink::new(#args_number);
+                #(sink.push(#args_names_copy);)*
+                sink.drain_to(&mut payload);
+                write_ethereum_payload(payload);
+                write_ethereum_contract_addr(&self.addr);
+            }
+        }
+    }).collect();
+
+    Ok(Box::new(result))
+}
+
+#[proc_macro_attribute]
+#[allow(unused_variables, unused_mut)]
+pub fn eth_contract(args: proc_macro::TokenStream, input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input_tokens = parse_macro_input!(input as syn::ItemStruct);
+    let struct_name = input_tokens.ident;
+    let file_path = parse_macro_input!(args as syn::LitStr);
+    let mut 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();
+
+    let result = quote! {
+        struct #struct_name{
+            addr: [u8;20],
+        }
+        impl EthContract{
+            fn new(addr_str: /*Address*/&str) -> Self {
+                EthContract{addr: From::from(Address::from(addr_str.as_bytes()))}
+            }
+             #(#it)*
+        }
+    };
+    proc_macro::TokenStream::from(result)
+}

eng_wasm/src/eng_wasm_errors.rs

@@ -0,0 +1,47 @@
+use super::failure::Fail;
+use internal_std::String;
+use internal_std::ToString;
+use internal_std::io;
+use syn;
+
+#[derive(Debug, Fail)]
+pub enum EngWasmError {
+    #[fail(display = "I/O error: {:?}", error)]
+    IoError{
+        error: String,
+    },
+    #[fail(display = "Json error: {}", error)]
+    JsonError {
+        error: String,
+    },
+    #[fail(display = "Token parse error: {}", error)]
+    TokenParseError {
+        error: String,
+    }
+}
+
+
+impl From<std::io::Error> for EngWasmError {
+    fn from(error: io::Error) -> Self {
+        match error {
+            _ => 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()},
+        }
+    }
+}
+
+impl From<syn::parse::Error> for EngWasmError {
+    fn from (err: syn::parse::Error) -> Self {
+        match err {
+            _ => EngWasmError::TokenParseError{error: err.to_string()}
+        }
+    }
+}

eng_wasm/src/ethereum.rs

@@ -0,0 +1,26 @@
+use internal_std::Vec;
+use internal_std::String;
+use internal_std::SliceConcatExt;
+use tiny_keccak::Keccak;
+use ethabi::param_type::{Writer, ParamType};
+use byteorder::{BigEndian, ByteOrder};
+
+
+pub fn short_signature(name: &str, params: &[ParamType]) -> u32/*[u8; 4] */{
+    let mut result = [0u8; 4];
+    fill_signature(name, params, &mut result);
+    BigEndian::read_u32(&result.as_ref()[0..4])
+}
+
+fn fill_signature(name: &str, params: &[ParamType], result: &mut [u8]) {
+    let types = params.iter()
+        .map(Writer::write)
+        .collect::<Vec<String>>()
+        .join(",");
+
+    let data: Vec<u8> = From::from(eformat!("{}({})", name, types).as_str());
+
+    let mut sponge = Keccak::new_keccak256();
+    sponge.update(&data);
+    sponge.finalize(result);
+}

eng_wasm/src/internal_std.rs

@@ -1,10 +1,13 @@
-extern crate std;
+pub extern crate std;
 
 pub use self::std::fmt;
 //pub use self::std::prelude::v1::*;
 pub use self::std::iter;
 pub use self::std::string::{ToString, String};
 pub use self::std::vec::Vec;
+pub use self::std::str::from_utf8;
+pub use self::std::io;
+pub use self::std::slice::SliceConcatExt;
 
 //pub fn zeroed_vec(s: usize) -> Vec<u8>  {
 //    vec![0u8; s]