From eab8410402a1e307d24aa4e13aeb6d447c07c25d Mon Sep 17 00:00:00 2001 From: debris Date: Thu, 4 Feb 2016 23:48:29 +0100 Subject: [PATCH] finishe signed transactions --- ethcore/src/engine.rs | 2 +- ethcore/src/ethereum/ethash.rs | 2 +- ethcore/src/executive.rs | 57 +++-- ethcore/src/json_tests/state.rs | 2 +- ethcore/src/json_tests/transaction.rs | 8 +- ethcore/src/state.rs | 2 +- ethcore/src/tests/helpers.rs | 4 +- ethcore/src/transaction.rs | 291 ++++++++------------------ ethcore/src/verification.rs | 25 ++- 9 files changed, 164 insertions(+), 229 deletions(-) diff --git a/ethcore/src/engine.rs b/ethcore/src/engine.rs index 27e50bb84..a5a83c9cf 100644 --- a/ethcore/src/engine.rs +++ b/ethcore/src/engine.rs @@ -56,7 +56,7 @@ pub trait Engine : Sync + Send { /// Additional verification for transactions in blocks. // TODO: Add flags for which bits of the transaction to check. // TODO: consider including State in the params. - fn verify_transaction_basic(&self, _t: &Transaction, _header: &Header) -> Result<(), Error> { Ok(()) } + fn verify_transaction_basic(&self, _t: &SignedTransaction, _header: &Header) -> Result<(), Error> { Ok(()) } /// Verify a particular transaction is valid. fn verify_transaction(&self, _t: &SignedTransaction, _header: &Header) -> Result<(), Error> { Ok(()) } diff --git a/ethcore/src/ethereum/ethash.rs b/ethcore/src/ethereum/ethash.rs index a8cc92484..7645a9458 100644 --- a/ethcore/src/ethereum/ethash.rs +++ b/ethcore/src/ethereum/ethash.rs @@ -154,7 +154,7 @@ impl Engine for Ethash { Ok(()) } - fn verify_transaction_basic(&self, t: &Transaction, header: &Header) -> result::Result<(), Error> { + fn verify_transaction_basic(&self, t: &SignedTransaction, header: &Header) -> result::Result<(), Error> { if header.number() >= self.u64_param("frontierCompatibilityModeLimit") { try!(t.check_low_s()); } diff --git a/ethcore/src/executive.rs b/ethcore/src/executive.rs index b67b71306..3a16ea8c7 100644 --- a/ethcore/src/executive.rs +++ b/ethcore/src/executive.rs @@ -86,7 +86,7 @@ impl<'a> Executive<'a> { } /// This funtion should be used to execute transaction. - pub fn transact(&'a mut self, t: &Transaction) -> Result { + pub fn transact(&'a mut self, t: &SignedTransaction) -> Result { let sender = try!(t.sender()); let nonce = self.state.nonce(&sender); @@ -268,7 +268,7 @@ impl<'a> Executive<'a> { } /// Finalizes the transaction (does refunds and suicides). - fn finalize(&mut self, t: &Transaction, substate: Substate, result: evm::Result) -> ExecutionResult { + fn finalize(&mut self, t: &SignedTransaction, substate: Substate, result: evm::Result) -> ExecutionResult { let schedule = self.engine.schedule(self.info); // refunds from SSTORE nonzero -> zero @@ -685,9 +685,15 @@ mod tests { // test is incorrect, mk evm_test_ignore!{test_transact_simple: test_transact_simple_jit, test_transact_simple_int} fn test_transact_simple(factory: Factory) { - let mut t = Transaction::new_create(U256::from(17), "3331600055".from_hex().unwrap(), U256::from(100_000), U256::zero(), U256::zero()); let keypair = KeyPair::create().unwrap(); - t.sign(&keypair.secret()); + let t = Transaction { + action: Action::Create, + value: U256::from(17), + data: "3331600055".from_hex().unwrap(), + gas: U256::from(100_000), + gas_price: U256::zero(), + nonce: U256::zero() + }.sign(&keypair.secret()); let sender = t.sender().unwrap(); let contract = contract_address(&sender, &U256::zero()); @@ -717,8 +723,14 @@ mod tests { evm_test!{test_transact_invalid_sender: test_transact_invalid_sender_jit, test_transact_invalid_sender_int} fn test_transact_invalid_sender(factory: Factory) { - let t = Transaction::new_create(U256::from(17), "3331600055".from_hex().unwrap(), U256::from(100_000), U256::zero(), U256::zero()); - + let t = Transaction { + action: Action::Create, + value: U256::from(17), + data: "3331600055".from_hex().unwrap(), + gas: U256::from(100_000), + gas_price: U256::zero(), + nonce: U256::zero() + }.fake_sign(); let mut state_result = get_temp_state(); let mut state = state_result.reference_mut(); let mut info = EnvInfo::default(); @@ -738,11 +750,17 @@ mod tests { evm_test!{test_transact_invalid_nonce: test_transact_invalid_nonce_jit, test_transact_invalid_nonce_int} fn test_transact_invalid_nonce(factory: Factory) { - let mut t = Transaction::new_create(U256::from(17), "3331600055".from_hex().unwrap(), U256::from(100_000), U256::zero(), U256::one()); let keypair = KeyPair::create().unwrap(); - t.sign(&keypair.secret()); + let t = Transaction { + action: Action::Create, + value: U256::from(17), + data: "3331600055".from_hex().unwrap(), + gas: U256::from(100_000), + gas_price: U256::zero(), + nonce: U256::one() + }.sign(&keypair.secret()); let sender = t.sender().unwrap(); - + let mut state_result = get_temp_state(); let mut state = state_result.reference_mut(); state.add_balance(&sender, &U256::from(17)); @@ -764,9 +782,15 @@ mod tests { evm_test!{test_transact_gas_limit_reached: test_transact_gas_limit_reached_jit, test_transact_gas_limit_reached_int} fn test_transact_gas_limit_reached(factory: Factory) { - let mut t = Transaction::new_create(U256::from(17), "3331600055".from_hex().unwrap(), U256::from(80_001), U256::zero(), U256::zero()); let keypair = KeyPair::create().unwrap(); - t.sign(&keypair.secret()); + let t = Transaction { + action: Action::Create, + value: U256::from(17), + data: "3331600055".from_hex().unwrap(), + gas: U256::from(80_001), + gas_price: U256::zero(), + nonce: U256::zero() + }.sign(&keypair.secret()); let sender = t.sender().unwrap(); let mut state_result = get_temp_state(); @@ -791,9 +815,16 @@ mod tests { evm_test!{test_not_enough_cash: test_not_enough_cash_jit, test_not_enough_cash_int} fn test_not_enough_cash(factory: Factory) { - let mut t = Transaction::new_create(U256::from(18), "3331600055".from_hex().unwrap(), U256::from(100_000), U256::one(), U256::zero()); + let keypair = KeyPair::create().unwrap(); - t.sign(&keypair.secret()); + let t = Transaction { + action: Action::Create, + value: U256::from(18), + data: "3331600055".from_hex().unwrap(), + gas: U256::from(100_000), + gas_price: U256::one(), + nonce: U256::zero() + }.sign(&keypair.secret()); let sender = t.sender().unwrap(); let mut state_result = get_temp_state(); diff --git a/ethcore/src/json_tests/state.rs b/ethcore/src/json_tests/state.rs index fa8da9329..304d423dd 100644 --- a/ethcore/src/json_tests/state.rs +++ b/ethcore/src/json_tests/state.rs @@ -33,7 +33,7 @@ pub fn json_chain_test(json_data: &[u8], era: ChainEra) -> Vec { flush!(" - {}...", name); - let t = Transaction::from_json(&test["transaction"]); + let t = SignedTransaction::from_json(&test["transaction"]); let env = EnvInfo::from_json(&test["env"]); let _out = Bytes::from_json(&test["out"]); let post_state_root = xjson!(&test["postStateRoot"]); diff --git a/ethcore/src/json_tests/transaction.rs b/ethcore/src/json_tests/transaction.rs index 91f7d96e5..99e5e07c9 100644 --- a/ethcore/src/json_tests/transaction.rs +++ b/ethcore/src/json_tests/transaction.rs @@ -6,7 +6,7 @@ fn do_json_test(json_data: &[u8]) -> Vec { let mut failed = Vec::new(); let old_schedule = evm::Schedule::new_frontier(); let new_schedule = evm::Schedule::new_homestead(); - let ot = RefCell::new(Transaction::new()); + let ot = RefCell::new(None); for (name, test) in json.as_object().unwrap() { let mut fail = false; let mut fail_unless = |cond: bool| if !cond && !fail { failed.push(name.clone()); println!("Transaction: {:?}", ot.borrow()); fail = true }; @@ -15,7 +15,7 @@ fn do_json_test(json_data: &[u8]) -> Vec { .and_then(|s| BlockNumber::from_str(s).ok()) .unwrap_or(0) { x if x < 1_000_000 => &old_schedule, _ => &new_schedule }; let rlp = Bytes::from_json(&test["rlp"]); - let res = UntrustedRlp::new(&rlp).as_val().map_err(From::from).and_then(|t: Transaction| t.validate(schedule, schedule.have_delegate_call)); + let res = UntrustedRlp::new(&rlp).as_val().map_err(From::from).and_then(|t: SignedTransaction| t.validate(schedule, schedule.have_delegate_call)); fail_unless(test.find("transaction").is_none() == res.is_err()); if let (Some(&Json::Object(ref tx)), Some(&Json::String(ref expect_sender))) = (test.find("transaction"), test.find("sender")) { let t = res.unwrap(); @@ -26,10 +26,10 @@ fn do_json_test(json_data: &[u8]) -> Vec { fail_unless(t.nonce == xjson!(&tx["nonce"])); fail_unless(t.value == xjson!(&tx["value"])); if let Action::Call(ref to) = t.action { - *ot.borrow_mut() = t.clone(); + *ot.borrow_mut() = Some(t.clone()); fail_unless(to == &xjson!(&tx["to"])); } else { - *ot.borrow_mut() = t.clone(); + *ot.borrow_mut() = Some(t.clone()); fail_unless(Bytes::from_json(&tx["to"]).is_empty()); } } diff --git a/ethcore/src/state.rs b/ethcore/src/state.rs index ed7d29813..6f723952a 100644 --- a/ethcore/src/state.rs +++ b/ethcore/src/state.rs @@ -139,7 +139,7 @@ impl State { /// Execute a given transaction. /// This will change the state accordingly. - pub fn apply(&mut self, env_info: &EnvInfo, engine: &Engine, t: &Transaction) -> ApplyResult { + pub fn apply(&mut self, env_info: &EnvInfo, engine: &Engine, t: &SignedTransaction) -> ApplyResult { // let old = self.to_pod(); let e = try!(Executive::new(self, env_info, engine).transact(t)); diff --git a/ethcore/src/tests/helpers.rs b/ethcore/src/tests/helpers.rs index 04d47cbd3..c69f62617 100644 --- a/ethcore/src/tests/helpers.rs +++ b/ethcore/src/tests/helpers.rs @@ -103,12 +103,12 @@ fn create_unverifiable_block(order: u32, parent_hash: H256) -> Bytes { create_test_block(&create_unverifiable_block_header(order, parent_hash)) } -pub fn create_test_block_with_data(header: &Header, transactions: &[&Transaction], uncles: &[Header]) -> Bytes { +pub fn create_test_block_with_data(header: &Header, transactions: &[&SignedTransaction], uncles: &[Header]) -> Bytes { let mut rlp = RlpStream::new_list(3); rlp.append(header); rlp.begin_list(transactions.len()); for t in transactions { - rlp.append_raw(&t.rlp_bytes_opt(Seal::With), 1); + rlp.append_raw(&encode::(t).to_vec(), 1); } rlp.append(&uncles); rlp.out() diff --git a/ethcore/src/transaction.rs b/ethcore/src/transaction.rs index 0eed2dedd..355d01e0a 100644 --- a/ethcore/src/transaction.rs +++ b/ethcore/src/transaction.rs @@ -1,7 +1,6 @@ //! Transaction data structure. use util::*; -use basic_types::*; use error::*; use evm::Schedule; @@ -18,6 +17,16 @@ impl Default for Action { fn default() -> Action { Action::Create } } +impl Decodable for Action { + fn decode(decoder: &D) -> Result where D: Decoder { + let rlp = decoder.as_rlp(); + match rlp.is_empty() { + true => Ok(Action::Create), + false => Ok(Action::Call(try!(rlp.as_val()))) + } + } +} + /// A set of information describing an externally-originating message call /// or contract creation operation. #[derive(Default, Debug, Clone)] @@ -34,18 +43,6 @@ pub struct Transaction { pub value: U256, /// Transaction data. pub data: Bytes, - - - //// signature - ///// The V field of the signature, either 27 or 28; helps describe the point on the curve. - //pub v: u8, - ///// The R field of the signature; helps describe the point on the curve. - //pub r: U256, - ///// The S field of the signature; helps describe the point on the curve. - //pub s: U256, - - //hash: RefCell>, - //sender: RefCell>, } impl Transaction { @@ -62,90 +59,11 @@ impl Transaction { s.append(&self.value); s.append(&self.data); } - - /// Create a new transaction. - #[cfg(test)] - #[cfg(feature = "json-tests")] - pub fn new() -> Self { - Transaction { - nonce: x!(0), - gas_price: x!(0), - gas: x!(0), - action: Action::Create, - value: x!(0), - data: vec![], - //v: 0, - //r: x!(0), - //s: x!(0), - //hash: RefCell::new(None), - //sender: RefCell::new(None), - } - } - - /// Create a new message-call transaction. - #[allow(dead_code)] - pub fn new_call(to: Address, value: U256, data: Bytes, gas: U256, gas_price: U256, nonce: U256) -> Transaction { - Transaction { - nonce: nonce, - gas_price: gas_price, - gas: gas, - action: Action::Call(to), - value: value, - data: data, - //v: 0, - //r: x!(0), - //s: x!(0), - //hash: RefCell::new(None), - //sender: RefCell::new(None), - } - } - - /// Create a new contract-creation transaction. - #[cfg(test)] - pub fn new_create(value: U256, data: Bytes, gas: U256, gas_price: U256, nonce: U256) -> Transaction { - Transaction { - nonce: nonce, - gas_price: gas_price, - gas: gas, - action: Action::Create, - value: value, - data: data, - //v: 0, - //r: x!(0), - //s: x!(0), - //hash: RefCell::new(None), - //sender: RefCell::new(None), - } - } - - ///// Append object into RLP stream, optionally with or without the signature. - //pub fn rlp_append_opt(&self, s: &mut RlpStream, with_seal: Seal) { - //s.begin_list(6 + match with_seal { Seal::With => 3, _ => 0 }); - //s.append(&self.nonce); - //s.append(&self.gas_price); - //s.append(&self.gas); - //match self.action { - //Action::Create => s.append_empty_data(), - //Action::Call(ref to) => s.append(to), - //}; - //s.append(&self.value); - //s.append(&self.data); - //if let Seal::With = with_seal { - //s.append(&(self.v as u16)).append(&self.r).append(&self.s); - //} - //} - - ///// Get the RLP serialisation of the object, optionally with or without the signature. - //pub fn rlp_bytes_opt(&self, with_seal: Seal) -> Bytes { - //let mut s = RlpStream::new(); - //self.rlp_append_opt(&mut s, with_seal); - //s.out() - //} } -impl FromJson for Transaction { - fn from_json(json: &Json) -> Transaction { - let mut r = Transaction { +impl FromJson for SignedTransaction { + fn from_json(json: &Json) -> SignedTransaction { + let t = Transaction { nonce: xjson!(&json["nonce"]), gas_price: xjson!(&json["gasPrice"]), gas: xjson!(&json["gasLimit"]), @@ -155,41 +73,58 @@ impl FromJson for Transaction { }, value: xjson!(&json["value"]), data: xjson!(&json["data"]), - //v: match json.find("v") { Some(ref j) => u16::from_json(j) as u8, None => 0 }, - //r: match json.find("r") { Some(j) => xjson!(j), None => x!(0) }, - //s: match json.find("s") { Some(j) => xjson!(j), None => x!(0) }, - //hash: RefCell::new(None), - //sender: match json.find("sender") { - //Some(&Json::String(ref sender)) => RefCell::new(Some(address_from_hex(clean(sender)))), - //_ => RefCell::new(None), - //}, }; - //if let Some(&Json::String(ref secret_key)) = json.find("secretKey") { - //r.sign(&h256_from_hex(clean(secret_key))); - //} - r + match json.find("secretKey") { + Some(&Json::String(ref secret_key)) => t.sign(&h256_from_hex(clean(secret_key))), + _ => SignedTransaction { + transaction: t, + v: match json.find("v") { Some(ref j) => u16::from_json(j) as u8, None => 0 }, + r: match json.find("r") { Some(j) => xjson!(j), None => x!(0) }, + s: match json.find("s") { Some(j) => xjson!(j), None => x!(0) }, + hash: RefCell::new(None), + sender: match json.find("sender") { + Some(&Json::String(ref sender)) => RefCell::new(Some(address_from_hex(clean(sender)))), + _ => RefCell::new(None), + } + } + } } } -//impl Encodable for Transaction { - //fn rlp_append(&self, s: &mut RlpStream) { self.rlp_append_opt(s, Seal::With) } -//} - impl Transaction { + /// The message hash of the transaction. + pub fn message_hash(&self) -> H256 { + let mut stream = RlpStream::new(); + self.rlp_append_unsigned_transaction(&mut stream); + stream.out().sha3() + } /// Signs the transaction as coming from `sender`. - //pub fn sign(&mut self, secret: &Secret) { - // TODO: make always low. - //let sig = ec::sign(secret, &self.message_hash()); - //let (r, s, v) = sig.unwrap().to_rsv(); - //self.r = r; - //self.s = s; - //self.v = v + 27; - //} + pub fn sign(self, secret: &Secret) -> SignedTransaction { + let sig = ec::sign(secret, &self.message_hash()); + let (r, s, v) = sig.unwrap().to_rsv(); + SignedTransaction { + transaction: self, + r: r, + s: s, + v: v + 27, + hash: RefCell::new(None), + sender: RefCell::new(None) + } + } - /// Signs the transaction as coming from `sender`. - //#[cfg(test)] - //pub fn signed(self, secret: &Secret) -> Transaction { let mut r = self; r.sign(secret); r } + /// Useful for test incorrectly signed transactions. + #[cfg(test)] + pub fn fake_sign(self) -> SignedTransaction { + SignedTransaction { + transaction: self, + r: U256::zero(), + s: U256::zero(), + v: 0, + hash: RefCell::new(None), + sender: RefCell::new(None) + } + } /// Get the transaction cost in gas for the given params. pub fn gas_required_for(is_create: bool, data: &[u8], schedule: &Schedule) -> u64 { @@ -199,91 +134,27 @@ impl Transaction { ) } - /// The message hash of the transaction. - pub fn message_hash(&self) -> H256 { - let mut stream = RlpStream::new(); - self.rlp_append_unsigned_transaction(&mut stream); - stream.out().sha3() - } - - pub fn sign(self, secret: &Secret) -> SignedTransaction { - let sig = ec::sign(secret, &self.message_hash()); - let (r, s, v) = sig.unwrap().to_rsv(); - SignedTransaction { - transaction: self, - r: r, - s: s, - v: v, - hash: RefCell::new(None), - sender: RefCell::new(None) - } - } - /// Get the transaction cost in gas for this transaction. pub fn gas_required(&self, schedule: &Schedule) -> u64 { Self::gas_required_for(match self.action{Action::Create=>true, Action::Call(_)=>false}, &self.data, schedule) } - - - - /// Do basic validation, checking for valid signature and minimum gas, - // TODO: consider use in block validation. - #[cfg(test)] - #[cfg(feature = "json-tests")] - pub fn validate(self, schedule: &Schedule, require_low: bool) -> Result { - if require_low && !ec::is_low_s(&self.s) { - return Err(Error::Util(UtilError::Crypto(CryptoError::InvalidSignature))); - } - try!(self.sender()); - if self.gas < U256::from(self.gas_required(&schedule)) { - Err(From::from(TransactionError::InvalidGasLimit(OutOfBounds{min: Some(U256::from(self.gas_required(&schedule))), max: None, found: self.gas}))) - } else { - Ok(self) - } - } } -impl Decodable for Action { - fn decode(decoder: &D) -> Result where D: Decoder { - let rlp = decoder.as_rlp(); - if rlp.is_empty() { - Ok(Action::Create) - } else { - Ok(Action::Call(try!(rlp.as_val()))) - } - } -} -//impl Decodable for Transaction { - //fn decode(decoder: &D) -> Result where D: Decoder { - //let d = decoder.as_rlp(); - //if d.item_count() != 9 { - //return Err(DecoderError::RlpIncorrectListLen); - //} - //Ok(Transaction { - //nonce: try!(d.val_at(0)), - //gas_price: try!(d.val_at(1)), - //gas: try!(d.val_at(2)), - //action: try!(d.val_at(3)), - //value: try!(d.val_at(4)), - //data: try!(d.val_at(5)), - //v: try!(d.val_at(6)), - //r: try!(d.val_at(7)), - //s: try!(d.val_at(8)), - //hash: RefCell::new(None), - //sender: RefCell::new(None), - //}) - //} -//} #[derive(Debug, Clone)] pub struct SignedTransaction { + /// Plain Transaction. transaction: Transaction, + /// The V field of the signature, either 27 or 28; helps describe the point on the curve. v: u8, + /// The R field of the signature; helps describe the point on the curve. r: U256, + /// The S field of the signature; helps describe the point on the curve. s: U256, - + /// Cached hash. hash: RefCell>, + /// Cached sender. sender: RefCell> } @@ -309,13 +180,6 @@ impl Decodable for SignedTransaction { action: try!(d.val_at(3)), value: try!(d.val_at(4)), data: try!(d.val_at(5)), - - // to remove - v: 0, - r: From::from(0), - s: From::from(0), - hash: RefCell::new(None), - sender: RefCell::new(None) }, v: try!(d.val_at(6)), r: try!(d.val_at(7)), @@ -335,7 +199,7 @@ impl SignedTransaction { pub fn rlp_append_sealed_transaction(&self, s: &mut RlpStream) { s.begin_list(9); s.append(&self.nonce); - s.appned(&self.gas_price); + s.append(&self.gas_price); s.append(&self.gas); match self.action { Action::Create => s.append_empty_data(), @@ -386,11 +250,27 @@ impl SignedTransaction { } } } + + /// Do basic validation, checking for valid signature and minimum gas, + // TODO: consider use in block validation. + #[cfg(test)] + #[cfg(feature = "json-tests")] + pub fn validate(self, schedule: &Schedule, require_low: bool) -> Result { + if require_low && !ec::is_low_s(&self.s) { + return Err(Error::Util(UtilError::Crypto(CryptoError::InvalidSignature))); + } + try!(self.sender()); + if self.gas < U256::from(self.gas_required(&schedule)) { + Err(From::from(TransactionError::InvalidGasLimit(OutOfBounds{min: Some(U256::from(self.gas_required(&schedule))), max: None, found: self.gas}))) + } else { + Ok(self) + } + } } #[test] fn sender_test() { - let t: Transaction = decode(&FromHex::from_hex("f85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap()); + let t: SignedTransaction = decode(&FromHex::from_hex("f85f800182520894095e7baea6a6c7c4c2dfeb977efac326af552d870a801ba048b55bfa915ac795c431978d8a6a992b628d557da5ff759b307d495a36649353a0efffd310ac743f371de3b9f7f9cb56c0b28ad43601b4ab949f53faa07bd2c804").unwrap()); assert_eq!(t.data, b""); assert_eq!(t.gas, U256::from(0x5208u64)); assert_eq!(t.gas_price, U256::from(0x01u64)); @@ -405,6 +285,13 @@ fn sender_test() { #[test] fn signing() { let key = KeyPair::create().unwrap(); - let t = Transaction::new_create(U256::from(42u64), b"Hello!".to_vec(), U256::from(3000u64), U256::from(50_000u64), U256::from(1u64)).signed(&key.secret()); + let t = Transaction { + action: Action::Create, + nonce: U256::from(42), + gas_price: U256::from(3000), + gas: U256::from(50_000), + value: U256::from(1), + data: b"Hello!".to_vec() + }.sign(&key.secret()); assert_eq!(Address::from(key.public().sha3()), t.sender().unwrap()); } diff --git a/ethcore/src/verification.rs b/ethcore/src/verification.rs index db7faa074..51f81dd81 100644 --- a/ethcore/src/verification.rs +++ b/ethcore/src/verification.rs @@ -220,7 +220,6 @@ mod tests { use engine::*; use spec::*; use transaction::*; - use basic_types::*; use tests::helpers::*; fn check_ok(result: Result<(), Error>) { @@ -309,8 +308,26 @@ mod tests { good.timestamp = 40; good.number = 10; - let tr1 = Transaction::new_create(x!(0), Bytes::new(), x!(30000), x!(40000), x!(1)); - let tr2 = Transaction::new_create(x!(0), Bytes::new(), x!(30000), x!(40000), x!(2)); + let keypair = KeyPair::create().unwrap(); + + let tr1 = Transaction { + action: Action::Create, + value: U256::from(0), + data: Bytes::new(), + gas: U256::from(30_000), + gas_price: U256::from(40_000), + nonce: U256::one() + }.sign(&keypair.secret()); + + let tr2 = Transaction { + action: Action::Create, + value: U256::from(0), + data: Bytes::new(), + gas: U256::from(30_000), + gas_price: U256::from(40_000), + nonce: U256::from(2) + }.sign(&keypair.secret()); + let good_transactions = [ &tr1, &tr2 ]; let diff_inc = U256::from(0x40); @@ -346,7 +363,7 @@ mod tests { let mut uncles_rlp = RlpStream::new(); uncles_rlp.append(&good_uncles); let good_uncles_hash = uncles_rlp.as_raw().sha3(); - let good_transactions_root = ordered_trie_root(good_transactions.iter().map(|t| t.rlp_bytes_opt(Seal::With)).collect()); + let good_transactions_root = ordered_trie_root(good_transactions.iter().map(|t| encode::(t).to_vec()).collect()); let mut parent = good.clone(); parent.number = 9;