diff --git a/substrate/Cargo.lock b/substrate/Cargo.lock index 41c2d747f5..595ca2ff32 100644 --- a/substrate/Cargo.lock +++ b/substrate/Cargo.lock @@ -1044,6 +1044,25 @@ dependencies = [ "substrate-state-machine 0.1.0", ] +[[package]] +name = "polkadot-primitives" +version = "0.1.0" +dependencies = [ + "blake2-rfc 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)", + "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)", + "crunchy 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)", + "fixed-hash 0.1.3 (git+https://github.com/rphmeier/primitives.git?branch=compile-for-wasm)", + "pretty_assertions 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)", + "rustc-hex 2.0.0 (git+https://github.com/rphmeier/rustc-hex.git)", + "serde 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)", + "serde_derive 1.0.27 (registry+https://github.com/rust-lang/crates.io-index)", + "substrate-codec 0.1.0", + "substrate-primitives 0.1.0", + "substrate-serializer 0.1.0", + "twox-hash 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)", + "uint 0.1.2 (git+https://github.com/rphmeier/primitives.git?branch=compile-for-wasm)", +] + [[package]] name = "polkadot-rpc" version = "0.1.0" diff --git a/substrate/Cargo.toml b/substrate/Cargo.toml index 04b654bfce..ce8281310a 100644 --- a/substrate/Cargo.toml +++ b/substrate/Cargo.toml @@ -21,6 +21,7 @@ members = [ "rpc-servers", "rpc", "codec", + "polkadot-primitives", "runtime-std", "serializer", "state-machine", diff --git a/substrate/client/src/genesis.rs b/substrate/client/src/genesis.rs index 1e2020b9a7..6815f6b2b5 100644 --- a/substrate/client/src/genesis.rs +++ b/substrate/client/src/genesis.rs @@ -48,7 +48,6 @@ mod tests { use substrate_executor::executor; use primitives::relay::{AccountId, Hash, BlockNumber, Header, Digest, UncheckedTransaction, Transaction, Function}; - use primitives::contract::CallData; use ed25519::Pair; fn secret_for(who: &AccountId) -> Option { @@ -88,7 +87,7 @@ mod tests { &mut overlay, &executor(), "execute_transaction", - &CallData(vec![].join(&header).join(tx)) + &vec![].join(&header).join(tx) ).unwrap(); header = Header::from_slice(&mut &ret_data[..]).unwrap(); } @@ -98,7 +97,7 @@ mod tests { &mut overlay, &executor(), "finalise_block", - &CallData(vec![].join(&header)) + &vec![].join(&header) ).unwrap(); header = Header::from_slice(&mut &ret_data[..]).unwrap(); @@ -137,7 +136,7 @@ mod tests { &mut overlay, &executor(), "execute_block", - &CallData(b1data) + &b1data ).unwrap(); } } diff --git a/substrate/client/src/lib.rs b/substrate/client/src/lib.rs index 44c2aaa2bf..edf4d22c3e 100644 --- a/substrate/client/src/lib.rs +++ b/substrate/client/src/lib.rs @@ -48,7 +48,7 @@ pub use blockchain::Info as ChainInfo; pub use blockchain::BlockId; use primitives::relay::block; -use primitives::contract::{CallData, StorageKey, StorageData}; +use primitives::contract::{StorageKey, StorageData}; use blockchain::Backend as BlockchainBackend; use backend::BlockImportOperation; @@ -156,7 +156,7 @@ impl Client where /// Execute a call to a contract on top of state in a block of given hash. /// /// No changes are made. - pub fn call(&self, hash: &block::HeaderHash, method: &str, call_data: &CallData) -> error::Result { + pub fn call(&self, hash: &block::HeaderHash, method: &str, call_data: &[u8]) -> error::Result { let state = self.state_at(hash)?; let mut changes = state_machine::OverlayedChanges::default(); diff --git a/substrate/executor/src/native_executor.rs b/substrate/executor/src/native_executor.rs index d52b0daed1..64aa7b4986 100644 --- a/substrate/executor/src/native_executor.rs +++ b/substrate/executor/src/native_executor.rs @@ -16,7 +16,6 @@ use error::{Error, ErrorKind, Result}; use native_runtime as runtime; -use primitives::contract::CallData; use runtime_std; use state_machine::{Externalities, CodeExecutor}; use wasm_executor::WasmExecutor; @@ -37,16 +36,16 @@ impl CodeExecutor for NativeExecutor { ext: &mut E, code: &[u8], method: &str, - data: &CallData, + data: &[u8], ) -> Result> { // WARNING!!! This assumes that the runtime was built *before* the main project. Until we // get a proper build script, this must be strictly adhered to or things will go wrong. let native_equivalent = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.compact.wasm"); if code == &native_equivalent[..] { runtime_std::with_externalities(ext, || match method { - "execute_block" => safe_call(|| runtime::execute_block(&data.0)), - "execute_transaction" => safe_call(|| runtime::execute_transaction(&data.0)), - "finalise_block" => safe_call(|| runtime::finalise_block(&data.0)), + "execute_block" => safe_call(|| runtime::execute_block(data)), + "execute_transaction" => safe_call(|| runtime::execute_transaction(data)), + "finalise_block" => safe_call(|| runtime::finalise_block(data)), _ => Err(ErrorKind::MethodNotFound(method.to_owned()).into()), }) } else { @@ -90,7 +89,7 @@ mod tests { twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0] ], }; - let r = NativeExecutor.call(&mut t, BLOATY_CODE, "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx()))); + let r = NativeExecutor.call(&mut t, BLOATY_CODE, "execute_transaction", &vec![].join(&Header::from_block_number(1u64)).join(&tx())); assert!(r.is_err()); } @@ -101,7 +100,7 @@ mod tests { twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![68u8, 0, 0, 0, 0, 0, 0, 0] ], }; - let r = NativeExecutor.call(&mut t, COMPACT_CODE, "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx()))); + let r = NativeExecutor.call(&mut t, COMPACT_CODE, "execute_transaction", &vec![].join(&Header::from_block_number(1u64)).join(&tx())); assert!(r.is_err()); } @@ -114,7 +113,7 @@ mod tests { twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0] ], }; - let r = NativeExecutor.call(&mut t, COMPACT_CODE, "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx()))); + let r = NativeExecutor.call(&mut t, COMPACT_CODE, "execute_transaction", &vec![].join(&Header::from_block_number(1u64)).join(&tx())); assert!(r.is_ok()); runtime_std::with_externalities(&mut t, || { @@ -132,7 +131,7 @@ mod tests { twox_128(&one.to_keyed_vec(b"sta:bal:")).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0] ], }; - let r = NativeExecutor.call(&mut t, BLOATY_CODE, "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx()))); + let r = NativeExecutor.call(&mut t, BLOATY_CODE, "execute_transaction", &vec![].join(&Header::from_block_number(1u64)).join(&tx())); assert!(r.is_ok()); runtime_std::with_externalities(&mut t, || { @@ -234,7 +233,7 @@ mod tests { fn test_execution_works() { let mut t = new_test_ext(); println!("Testing Wasm..."); - let r = WasmExecutor.call(&mut t, COMPACT_CODE, "run_tests", &CallData(block2().0)); + let r = WasmExecutor.call(&mut t, COMPACT_CODE, "run_tests", &block2().0); assert!(r.is_ok()); } @@ -242,14 +241,14 @@ mod tests { fn full_native_block_import_works() { let mut t = new_test_ext(); - NativeExecutor.call(&mut t, COMPACT_CODE, "execute_block", &CallData(block1().0)).unwrap(); + NativeExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block1().0).unwrap(); runtime_std::with_externalities(&mut t, || { assert_eq!(balance(&one()), 42); assert_eq!(balance(&two()), 69); }); - NativeExecutor.call(&mut t, COMPACT_CODE, "execute_block", &CallData(block2().0)).unwrap(); + NativeExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block2().0).unwrap(); runtime_std::with_externalities(&mut t, || { assert_eq!(balance(&one()), 32); @@ -261,14 +260,14 @@ mod tests { fn full_wasm_block_import_works() { let mut t = new_test_ext(); - WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &CallData(block1().0)).unwrap(); + WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block1().0).unwrap(); runtime_std::with_externalities(&mut t, || { assert_eq!(balance(&one()), 42); assert_eq!(balance(&two()), 69); }); - WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &CallData(block2().0)).unwrap(); + WasmExecutor.call(&mut t, COMPACT_CODE, "execute_block", &block2().0).unwrap(); runtime_std::with_externalities(&mut t, || { assert_eq!(balance(&one()), 32); diff --git a/substrate/executor/src/wasm_executor.rs b/substrate/executor/src/wasm_executor.rs index 00eb9e67d7..b8a3367f03 100644 --- a/substrate/executor/src/wasm_executor.rs +++ b/substrate/executor/src/wasm_executor.rs @@ -22,7 +22,6 @@ use std::collections::HashMap; use parity_wasm::{deserialize_buffer, ModuleInstanceInterface, ProgramInstance}; use parity_wasm::interpreter::{ItemIndex, DummyUserError}; use parity_wasm::RuntimeValue::{I32, I64}; -use primitives::contract::CallData; use state_machine::{Externalities, CodeExecutor}; use error::{Error, ErrorKind, Result}; use wasm_utils::{MemoryInstance, UserDefinedElements, @@ -250,7 +249,7 @@ impl CodeExecutor for WasmExecutor { ext: &mut E, code: &[u8], method: &str, - data: &CallData, + data: &[u8], ) -> Result> { // TODO: handle all expects as errors to be returned. @@ -262,9 +261,9 @@ impl CodeExecutor for WasmExecutor { let memory = module.memory(ItemIndex::Internal(0)).expect("all modules compiled with rustc include memory segments; qed"); let mut fec = FunctionExecutor::new(&memory, ext); - let size = data.0.len() as u32; + let size = data.len() as u32; let offset = fec.heap.allocate(size); - memory.set(offset, &data.0).expect("heap always gives a sensible offset to write"); + memory.set(offset, &data).expect("heap always gives a sensible offset to write"); let returned = program .params_with_external("env", &mut fec) @@ -323,7 +322,7 @@ mod tests { let mut ext = TestExternalities::default(); let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm"); - let output = WasmExecutor.call(&mut ext, &test_code[..], "test_empty_return", &CallData(vec![])).unwrap(); + let output = WasmExecutor.call(&mut ext, &test_code[..], "test_empty_return", &[]).unwrap(); assert_eq!(output, vec![0u8; 0]); } @@ -332,10 +331,10 @@ mod tests { let mut ext = TestExternalities::default(); let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm"); - let output = WasmExecutor.call(&mut ext, &test_code[..], "test_panic", &CallData(vec![])); + let output = WasmExecutor.call(&mut ext, &test_code[..], "test_panic", &[]); assert!(output.is_err()); - let output = WasmExecutor.call(&mut ext, &test_code[..], "test_conditional_panic", &CallData(vec![2])); + let output = WasmExecutor.call(&mut ext, &test_code[..], "test_conditional_panic", &[2]); assert!(output.is_err()); } @@ -345,7 +344,7 @@ mod tests { ext.set_storage(b"foo".to_vec(), b"bar".to_vec()); let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm"); - let output = WasmExecutor.call(&mut ext, &test_code[..], "test_data_in", &CallData(b"Hello world".to_vec())).unwrap(); + let output = WasmExecutor.call(&mut ext, &test_code[..], "test_data_in", b"Hello world").unwrap(); assert_eq!(output, b"all ok!".to_vec()); @@ -362,11 +361,11 @@ mod tests { let mut ext = TestExternalities::default(); let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm"); assert_eq!( - WasmExecutor.call(&mut ext, &test_code[..], "test_blake2_256", &CallData(b"".to_vec())).unwrap(), + WasmExecutor.call(&mut ext, &test_code[..], "test_blake2_256", &[]).unwrap(), blake2_256(&b""[..]).to_vec() ); assert_eq!( - WasmExecutor.call(&mut ext, &test_code[..], "test_blake2_256", &CallData(b"Hello world!".to_vec())).unwrap(), + WasmExecutor.call(&mut ext, &test_code[..], "test_blake2_256", b"Hello world!").unwrap(), blake2_256(&b"Hello world!"[..]).to_vec() ); } @@ -376,11 +375,11 @@ mod tests { let mut ext = TestExternalities::default(); let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm"); assert_eq!( - WasmExecutor.call(&mut ext, &test_code[..], "test_twox_256", &CallData(b"".to_vec())).unwrap(), + WasmExecutor.call(&mut ext, &test_code[..], "test_twox_256", &[]).unwrap(), FromHex::from_hex("99e9d85137db46ef4bbea33613baafd56f963c64b1f3685a4eb4abd67ff6203a").unwrap() ); assert_eq!( - WasmExecutor.call(&mut ext, &test_code[..], "test_twox_256", &CallData(b"Hello world!".to_vec())).unwrap(), + WasmExecutor.call(&mut ext, &test_code[..], "test_twox_256", b"Hello world!").unwrap(), FromHex::from_hex("b27dfd7f223f177f2a13647b533599af0c07f68bda23d96d059da2b451a35a74").unwrap() ); } @@ -390,11 +389,11 @@ mod tests { let mut ext = TestExternalities::default(); let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm"); assert_eq!( - WasmExecutor.call(&mut ext, &test_code[..], "test_twox_128", &CallData(b"".to_vec())).unwrap(), + WasmExecutor.call(&mut ext, &test_code[..], "test_twox_128", &[]).unwrap(), FromHex::from_hex("99e9d85137db46ef4bbea33613baafd5").unwrap() ); assert_eq!( - WasmExecutor.call(&mut ext, &test_code[..], "test_twox_128", &CallData(b"Hello world!".to_vec())).unwrap(), + WasmExecutor.call(&mut ext, &test_code[..], "test_twox_128", b"Hello world!").unwrap(), FromHex::from_hex("b27dfd7f223f177f2a13647b533599af").unwrap() ); } @@ -409,7 +408,7 @@ mod tests { calldata.extend_from_slice(key.public().as_ref()); calldata.extend_from_slice(sig.as_ref()); assert_eq!( - WasmExecutor.call(&mut ext, &test_code[..], "test_ed25519_verify", &CallData(calldata)).unwrap(), + WasmExecutor.call(&mut ext, &test_code[..], "test_ed25519_verify", &calldata).unwrap(), vec![0] ); } @@ -419,7 +418,7 @@ mod tests { let mut ext = TestExternalities::default(); let test_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm"); assert_eq!( - WasmExecutor.call(&mut ext, &test_code[..], "test_enumerated_trie_root", &CallData(vec![])).unwrap(), + WasmExecutor.call(&mut ext, &test_code[..], "test_enumerated_trie_root", &[]).unwrap(), ordered_trie_root(vec![b"zero".to_vec(), b"one".to_vec(), b"two".to_vec()]).0.to_vec() ); } @@ -432,7 +431,7 @@ mod tests { ], }; let foreign_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.wasm"); - let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx()))); + let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &vec![].join(&Header::from_block_number(1u64)).join(&tx())); assert!(r.is_err()); } @@ -446,7 +445,7 @@ mod tests { ], }; let foreign_code = include_bytes!("../../wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.compact.wasm"); - let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &CallData(vec![].join(&Header::from_block_number(1u64)).join(&tx()))); + let r = WasmExecutor.call(&mut t, &foreign_code[..], "execute_transaction", &vec![].join(&Header::from_block_number(1u64)).join(&tx())); assert!(r.is_ok()); runtime_std::with_externalities(&mut t, || { diff --git a/substrate/polkadot-primitives/Cargo.toml b/substrate/polkadot-primitives/Cargo.toml new file mode 100644 index 0000000000..c81bd3a1a6 --- /dev/null +++ b/substrate/polkadot-primitives/Cargo.toml @@ -0,0 +1,35 @@ +[package] +name = "polkadot-primitives" +version = "0.1.0" +authors = ["Parity Technologies "] + +[dependencies] +crunchy = "0.1" +fixed-hash = { git = "https://github.com/rphmeier/primitives.git", branch = "compile-for-wasm", default_features = false } +rustc-hex = { git = "https://github.com/rphmeier/rustc-hex.git", version = "2.0", default_features = false } +serde = { version = "1.0", default_features = false } +serde_derive = { version = "1.0", optional = true } +uint = { git = "https://github.com/rphmeier/primitives.git", branch = "compile-for-wasm" } +twox-hash = { version = "1.1.0", optional = true } +byteorder = { version = "1.1", default_features = false } +blake2-rfc = { version = "0.2.18", optional = true } +substrate-codec = { path = "../codec", default_features = false } +substrate-primitives = { path = "../primitives", default_features = false } + +[dev-dependencies] +substrate-serializer = { path = "../serializer" } +pretty_assertions = "0.4" + +[features] +default = ["std"] +std = [ + "uint/std", + "fixed-hash/std", + "substrate-codec/std", + "serde/std", + "rustc-hex/std", + "twox-hash", + "blake2-rfc", + "serde_derive", + "byteorder/std" +] diff --git a/substrate/polkadot-primitives/src/lib.rs b/substrate/polkadot-primitives/src/lib.rs new file mode 100644 index 0000000000..196ef89fd3 --- /dev/null +++ b/substrate/polkadot-primitives/src/lib.rs @@ -0,0 +1,56 @@ +// Copyright 2017 Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// Polkadot is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with Polkadot. If not, see . + +//! Shareable Polkadot types. + +#![warn(missing_docs)] + +#![cfg_attr(not(feature = "std"), no_std)] +#![cfg_attr(not(feature = "std"), feature(alloc))] + +extern crate rustc_hex; + +extern crate serde; +extern crate byteorder; + +#[cfg(feature = "std")] +extern crate twox_hash; +#[cfg(feature = "std")] +extern crate blake2_rfc; + +#[macro_use] +extern crate crunchy; +#[macro_use] +extern crate fixed_hash; +#[cfg(feature = "std")] +#[macro_use] +extern crate serde_derive; +#[macro_use] +extern crate uint as uint_crate; + +#[cfg(feature = "std")] +extern crate core; +extern crate substrate_codec as codec; +extern crate substrate_primitives as primitives; +#[cfg(test)] +extern crate substrate_serializer; +#[cfg(test)] +#[macro_use] +extern crate pretty_assertions; + +#[cfg(not(feature = "std"))] +#[macro_use] +extern crate alloc; diff --git a/substrate/primitives/src/contract.rs b/substrate/primitives/src/contract.rs index 771381b85b..e8e22fc3f7 100644 --- a/substrate/primitives/src/contract.rs +++ b/substrate/primitives/src/contract.rs @@ -20,16 +20,6 @@ use bytes; use bytes::Vec; -/// Contract call data. -#[derive(Debug, PartialEq, Eq)] -#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] -pub struct CallData(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec); - -/// Contract output data. -#[derive(Debug, PartialEq, Eq)] -#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] -pub struct OutData(#[cfg_attr(feature = "std", serde(with="bytes"))] pub Vec); - /// Contract storage key. #[derive(Debug, PartialEq, Eq)] #[cfg_attr(feature = "std", derive(Serialize, Deserialize))] diff --git a/substrate/rpc/src/state/mod.rs b/substrate/rpc/src/state/mod.rs index 07b78a97c8..dd5ba7d7cb 100644 --- a/substrate/rpc/src/state/mod.rs +++ b/substrate/rpc/src/state/mod.rs @@ -23,7 +23,7 @@ mod tests; use client::{self, Client}; use primitives::relay::block; -use primitives::contract::{CallData, StorageKey, StorageData}; +use primitives::contract::{StorageKey, StorageData}; use state_machine; use self::error::Result; @@ -37,7 +37,7 @@ build_rpc_trait! { /// Call a contract. #[rpc(name = "state_call")] - fn call(&self, String, CallData, block::HeaderHash) -> Result>; + fn call(&self, String, Vec, block::HeaderHash) -> Result>; } } @@ -50,7 +50,7 @@ impl StateApi for Client where Ok(self.storage(&block, &key)?) } - fn call(&self, method: String, data: CallData, block: block::HeaderHash) -> Result> { + fn call(&self, method: String, data: Vec, block: block::HeaderHash) -> Result> { Ok(self.call(&block, &method, &data)?.return_data) } } diff --git a/substrate/rpc/src/state/tests.rs b/substrate/rpc/src/state/tests.rs index 2360ce9e45..8bc0d6ec5f 100644 --- a/substrate/rpc/src/state/tests.rs +++ b/substrate/rpc/src/state/tests.rs @@ -39,7 +39,7 @@ fn should_call_contract() { let genesis_hash = "af65e54217fb213853703d57b80fc5b2bb834bf923046294d7a49bff62f0a8b2".into(); assert_matches!( - StateApi::call(&client, "balanceOf".into(), CallData(vec![1,2,3]), genesis_hash), + StateApi::call(&client, "balanceOf".into(), vec![1,2,3], genesis_hash), Err(Error(ErrorKind::Client(client::error::ErrorKind::Execution(_)), _)) ) } diff --git a/substrate/runtime-std/src/lib.rs b/substrate/runtime-std/src/lib.rs index 0c080a743b..357fa7313b 100644 --- a/substrate/runtime-std/src/lib.rs +++ b/substrate/runtime-std/src/lib.rs @@ -24,8 +24,6 @@ #![cfg_attr(feature = "std", doc = "Polkadot runtime standard library as compiled when linked with Rust's standard library.")] #![cfg_attr(not(feature = "std"), doc = "Polkadot's runtime standard library as compiled without Rust's standard library.")] -extern crate substrate_codec as codec; - #[cfg(feature = "std")] include!("../with_std.rs"); @@ -39,47 +37,3 @@ pub mod prelude { pub use ::vec::Vec; pub use ::boxed::Box; } - -/// Type definitions and helpers for transactions. -pub mod transaction { - pub use primitives::relay::{Transaction, UncheckedTransaction}; - use primitives::relay::Signature; - - #[cfg(feature = "std")] - use std::ops; - - #[cfg(not(feature = "std"))] - use core::ops; - - /// A type-safe indicator that a transaction has been checked. - #[derive(PartialEq, Eq, Clone)] - #[cfg_attr(feature = "std", derive(Debug))] - pub struct CheckedTransaction(UncheckedTransaction); - - impl CheckedTransaction { - /// Get a reference to the checked signature. - pub fn signature(&self) -> &Signature { - &self.0.signature - } - } - - impl ops::Deref for CheckedTransaction { - type Target = Transaction; - - fn deref(&self) -> &Transaction { - &self.0.transaction - } - } - - /// Check the signature on a transaction. - /// - /// On failure, return the transaction back. - pub fn check(tx: UncheckedTransaction) -> Result { - let msg = ::codec::Slicable::to_vec(&tx.transaction); - if ::ed25519_verify(&tx.signature.0, &msg, &tx.transaction.signed) { - Ok(CheckedTransaction(tx)) - } else { - Err(tx) - } - } -} diff --git a/substrate/state-machine/src/lib.rs b/substrate/state-machine/src/lib.rs index 8a7af31a05..db1f0ef533 100644 --- a/substrate/state-machine/src/lib.rs +++ b/substrate/state-machine/src/lib.rs @@ -34,8 +34,6 @@ extern crate byteorder; use std::collections::HashMap; use std::fmt; -use primitives::contract::CallData; - pub mod backend; mod ext; mod testing; @@ -177,7 +175,7 @@ pub trait CodeExecutor: Sized + Send + Sync { ext: &mut E, code: &[u8], method: &str, - data: &CallData, + data: &[u8], ) -> Result, Self::Error>; } @@ -192,7 +190,7 @@ pub fn execute( overlay: &mut OverlayedChanges, exec: &Exec, method: &str, - call_data: &CallData, + call_data: &[u8], ) -> Result, Box> { let result = { diff --git a/substrate/wasm-runtime/polkadot/src/lib.rs b/substrate/wasm-runtime/polkadot/src/lib.rs index 81b0e0c032..656a8a7b2f 100644 --- a/substrate/wasm-runtime/polkadot/src/lib.rs +++ b/substrate/wasm-runtime/polkadot/src/lib.rs @@ -42,6 +42,50 @@ use runtime_std::prelude::*; use codec::Slicable; use primitives::relay::{Header, Block, UncheckedTransaction}; +/// Type definitions and helpers for transactions. +pub mod transaction { + pub use primitives::relay::{Transaction, UncheckedTransaction}; + use primitives::relay::Signature; + + #[cfg(feature = "std")] + use std::ops; + + #[cfg(not(feature = "std"))] + use core::ops; + + /// A type-safe indicator that a transaction has been checked. + #[derive(PartialEq, Eq, Clone)] + #[cfg_attr(feature = "std", derive(Debug))] + pub struct CheckedTransaction(UncheckedTransaction); + + impl CheckedTransaction { + /// Get a reference to the checked signature. + pub fn signature(&self) -> &Signature { + &self.0.signature + } + } + + impl ops::Deref for CheckedTransaction { + type Target = Transaction; + + fn deref(&self) -> &Transaction { + &self.0.transaction + } + } + + /// Check the signature on a transaction. + /// + /// On failure, return the transaction back. + pub fn check(tx: UncheckedTransaction) -> Result { + let msg = ::codec::Slicable::to_vec(&tx.transaction); + if ::runtime_std::ed25519_verify(&tx.signature.0, &msg, &tx.transaction.signed) { + Ok(CheckedTransaction(tx)) + } else { + Err(tx) + } + } +} + /// Execute a block, with `input` being the canonical serialisation of the block. Returns the /// empty vector. pub fn execute_block(mut input: &[u8]) -> Vec { diff --git a/substrate/wasm-runtime/polkadot/src/runtime/system.rs b/substrate/wasm-runtime/polkadot/src/runtime/system.rs index 9f8edbb92e..5f40feccf5 100644 --- a/substrate/wasm-runtime/polkadot/src/runtime/system.rs +++ b/substrate/wasm-runtime/polkadot/src/runtime/system.rs @@ -145,7 +145,7 @@ pub mod internal { } fn execute_transaction(utx: UncheckedTransaction) { - use runtime_std::transaction; + use ::transaction; // Verify the signature is good. let tx = match transaction::check(utx) { diff --git a/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.compact.wasm b/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.compact.wasm index 8772bd974e..ce296a5814 100644 Binary files a/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.compact.wasm and b/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.compact.wasm differ diff --git a/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.wasm b/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.wasm index 07e49ec59d..a6831997d4 100644 Binary files a/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.wasm and b/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_polkadot.wasm differ diff --git a/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm b/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm index 3c4e94098f..d317445bea 100644 Binary files a/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm and b/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.compact.wasm differ diff --git a/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.wasm b/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.wasm index 6a79823c53..0c77df8679 100644 Binary files a/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.wasm and b/substrate/wasm-runtime/target/wasm32-unknown-unknown/release/runtime_test.wasm differ