openethereum/src/transaction.rs

254 lines
7.9 KiB
Rust
Raw Normal View History

use util::*;
2016-01-11 20:36:29 +01:00
use basic_types::*;
use error::*;
2016-01-12 01:30:30 +01:00
use evm::Schedule;
2015-12-09 00:45:33 +01:00
2016-01-11 13:52:40 +01:00
pub enum Action {
Create,
Call(Address),
2016-01-07 19:05:44 +01:00
}
/// A set of information describing an externally-originating message call
/// or contract creation operation.
2015-12-09 00:45:33 +01:00
pub struct Transaction {
2016-01-07 19:05:44 +01:00
pub nonce: U256,
pub gas_price: U256,
pub gas: U256,
2016-01-11 15:23:27 +01:00
pub action: Action,
2016-01-07 19:05:44 +01:00
pub value: U256,
2016-01-11 15:23:27 +01:00
pub data: Bytes,
2016-01-11 21:57:22 +01:00
// signature
pub v: u8,
2016-01-12 01:30:30 +01:00
pub r: U256,
pub s: U256,
2015-12-09 00:45:33 +01:00
hash: RefCell<Option<H256>>, //TODO: make this private
2015-12-09 00:45:33 +01:00
}
2016-01-07 19:05:44 +01:00
2016-01-11 20:36:29 +01:00
impl Transaction {
2016-01-11 22:00:25 +01:00
/// Append object into RLP stream, optionally with or without the signature.
2016-01-11 20:36:29 +01:00
pub fn rlp_append_opt(&self, s: &mut RlpStream, with_seal: Seal) {
s.append_list(6 + match with_seal { Seal::With => 3, _ => 0 });
s.append(&self.nonce);
s.append(&self.gas_price);
s.append(&self.gas);
2016-01-11 13:52:40 +01:00
match self.action {
Action::Create => s.append_empty_data(),
Action::Call(ref to) => s.append(to),
};
s.append(&self.value);
s.append(&self.data);
2016-01-11 20:36:29 +01:00
match with_seal {
2016-01-11 21:57:22 +01:00
Seal::With => { s.append(&(self.v as u16)).append(&self.r).append(&self.s); },
2016-01-11 20:36:29 +01:00
_ => {}
}
2016-01-07 21:29:36 +01:00
}
2016-01-11 20:36:29 +01:00
2016-01-11 22:00:25 +01:00
/// Get the RLP serialisation of the object, optionally with or without the signature.
2016-01-11 20:36:29 +01:00
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 RlpStandard for Transaction {
fn rlp_append(&self, s: &mut RlpStream) { self.rlp_append_opt(s, Seal::With) }
}
2016-01-07 21:29:36 +01:00
impl Transaction {
/// Get the hash of this header (sha3 of the RLP).
pub fn hash(&self) -> H256 {
let mut hash = self.hash.borrow_mut();
match &mut *hash {
&mut Some(ref h) => h.clone(),
hash @ &mut None => {
*hash = Some(self.rlp_sha3());
hash.as_ref().unwrap().clone()
}
}
}
2016-01-07 19:05:44 +01:00
/// Note that some fields have changed. Resets the memoised hash.
pub fn note_dirty(&self) {
*self.hash.borrow_mut() = None;
2016-01-07 19:05:44 +01:00
}
/// Returns transaction type.
2016-01-11 13:52:40 +01:00
pub fn action(&self) -> &Action { &self.action }
2016-01-08 22:04:21 +01:00
2016-01-12 01:30:30 +01:00
/// 0 is `v` is 27, 1 if 28, and 4 otherwise.
pub fn standard_v(&self) -> u8 { match self.v { 27 => 0, 28 => 1, _ => 4 } }
2016-01-11 21:57:22 +01:00
/// Construct a signature object from the sig.
2016-01-12 01:30:30 +01:00
pub fn signature(&self) -> Signature { Signature::from_rsv(&From::from(&self.r), &From::from(&self.s), self.standard_v()) }
2016-01-11 21:57:22 +01:00
/// The message hash of the transaction.
2016-01-11 22:00:25 +01:00
pub fn message_hash(&self) -> H256 { self.rlp_bytes_opt(Seal::Without).sha3() }
2016-01-11 21:57:22 +01:00
2016-01-11 15:23:27 +01:00
/// Returns transaction sender.
2016-01-11 21:57:22 +01:00
pub fn sender(&self) -> Result<Address, Error> { Ok(From::from(try!(ec::recover(&self.signature(), &self.message_hash())).sha3())) }
2016-01-12 01:30:30 +01:00
/// Get the transaction cost in gas for the given params.
pub fn gas_required_for(is_create: bool, data: &[u8], schedule: &Schedule) -> U256 {
2016-01-12 01:30:30 +01:00
// CRITICAL TODO XXX FIX NEED BIGINT!!!!!
data.iter().fold(
U256::from(if is_create {schedule.tx_create_gas} else {schedule.tx_gas}),
2016-01-12 01:30:30 +01:00
|g, b| g + U256::from(match *b { 0 => schedule.tx_data_zero_gas, _ => schedule.tx_data_non_zero_gas})
)
}
/// Get the transaction cost in gas for this transaction.
pub fn gas_required(&self, schedule: &Schedule) -> U256 {
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,
pub fn validate(self, schedule: &Schedule) -> Result<Transaction, Error> {
try!(self.sender());
if self.gas < self.gas_required(&schedule) {
Err(From::from(TransactionError::InvalidGasLimit(OutOfBounds{min: Some(self.gas_required(&schedule)), max: None, found: self.gas})))
} else {
Ok(self)
}
2016-01-12 01:30:30 +01:00
}
}
2016-01-11 13:52:40 +01:00
impl Decodable for Action {
fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
let rlp = decoder.as_rlp();
if rlp.is_empty() {
Ok(Action::Create)
} else {
Ok(Action::Call(try!(rlp.as_val())))
}
2015-12-09 00:45:33 +01:00
}
}
impl Decodable for Transaction {
fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
2015-12-14 12:09:32 +01:00
let d = try!(decoder.as_list());
2016-01-12 01:30:30 +01:00
if d.len() != 9 {
return Err(DecoderError::RlpIncorrectListLen);
}
2016-01-11 20:36:29 +01:00
Ok(Transaction {
2015-12-14 12:09:32 +01:00
nonce: try!(Decodable::decode(&d[0])),
gas_price: try!(Decodable::decode(&d[1])),
gas: try!(Decodable::decode(&d[2])),
2016-01-11 13:52:40 +01:00
action: try!(Decodable::decode(&d[3])),
2015-12-14 12:09:32 +01:00
value: try!(Decodable::decode(&d[4])),
data: try!(Decodable::decode(&d[5])),
2016-01-11 21:57:22 +01:00
v: try!(u16::decode(&d[6])) as u8,
r: try!(Decodable::decode(&d[7])),
s: try!(Decodable::decode(&d[8])),
hash: RefCell::new(None)
2016-01-11 20:36:29 +01:00
})
2015-12-09 00:45:33 +01:00
}
}
2016-01-11 21:57:22 +01:00
2016-01-12 01:30:30 +01:00
pub fn clean(s: &str) -> &str {
if s.len() >= 2 && &s[0..2] == "0x" {
&s[2..]
} else {
s
}
}
pub fn bytes_from_json(json: &Json) -> Bytes {
let s = json.as_string().unwrap();
if s.len() % 2 == 1 {
FromHex::from_hex(&("0".to_string() + &(clean(s).to_string()))[..]).unwrap_or(vec![])
2016-01-12 01:30:30 +01:00
} else {
FromHex::from_hex(clean(s)).unwrap_or(vec![])
2016-01-12 01:30:30 +01:00
}
}
pub fn address_from_json(json: &Json) -> Address {
let s = json.as_string().unwrap();
if s.len() % 2 == 1 {
address_from_hex(&("0".to_string() + &(clean(s).to_string()))[..])
} else {
address_from_hex(clean(s))
}
}
pub fn u256_from_json(json: &Json) -> U256 {
let s = json.as_string().unwrap();
if s.len() >= 2 && &s[0..2] == "0x" {
// hex
U256::from_str(&s[2..]).unwrap()
}
else {
// dec
U256::from_dec_str(s).unwrap()
}
}
#[cfg(test)]
mod tests {
use util::*;
use evm::Schedule;
2016-01-12 01:30:30 +01:00
use header::BlockNumber;
use super::*;
#[test]
fn sender_test() {
let t: Transaction = 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));
assert_eq!(t.nonce, U256::from(0x00u64));
if let Action::Call(ref to) = t.action {
assert_eq!(*to, address_from_hex("095e7baea6a6c7c4c2dfeb977efac326af552d87"));
} else { panic!(); }
assert_eq!(t.value, U256::from(0x0au64));
assert_eq!(t.sender().unwrap(), address_from_hex("0f65fe9276bc9a24ae7083ae28e2660ef72df99e"));
}
fn do_json_test(json_data: &[u8]) -> Vec<String> {
let json = Json::from_str(::std::str::from_utf8(json_data).unwrap()).expect("Json is invalid");
let mut failed = Vec::new();
let schedule = Schedule::new_frontier();
for (name, test) in json.as_object().unwrap() {
let mut fail = false;
let mut fail_unless = |cond: bool| if !cond && fail { failed.push(name.to_string()); fail = true };
let _ = BlockNumber::from_str(test["blocknumber"].as_string().unwrap()).unwrap();
let rlp = bytes_from_json(&test["rlp"]);
let res = UntrustedRlp::new(&rlp).as_val().map_err(|e| From::from(e)).and_then(|t: Transaction| t.validate(&schedule));
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();
fail_unless(t.sender().unwrap() == address_from_hex(clean(expect_sender)));
fail_unless(t.data == bytes_from_json(&tx["data"]));
fail_unless(t.gas == u256_from_json(&tx["gasLimit"]));
fail_unless(t.gas_price == u256_from_json(&tx["gasPrice"]));
fail_unless(t.nonce == u256_from_json(&tx["nonce"]));
fail_unless(t.value == u256_from_json(&tx["value"]));
if let Action::Call(ref to) = t.action {
fail_unless(to == &address_from_json(&tx["to"]));
} else {
fail_unless(bytes_from_json(&tx["to"]).len() == 0);
}
2016-01-12 01:30:30 +01:00
}
}
for f in failed.iter() {
println!("FAILED: {:?}", f);
}
failed
2016-01-12 01:30:30 +01:00
}
macro_rules! declare_test {
($test_set_name: ident/$name: ident) => {
#[test]
#[allow(non_snake_case)]
fn $name() {
assert!(do_json_test(include_bytes!(concat!("../res/ethereum/tests/", stringify!($test_set_name), "/", stringify!($name), ".json"))).len() == 0);
}
}
2016-01-12 01:30:30 +01:00
}
declare_test!{TransactionTests/ttTransactionTest}
declare_test!{TransactionTests/tt10mbDataField}
declare_test!{TransactionTests/ttWrongRLPTransaction}
2016-01-11 21:57:22 +01:00
}