Sunce86/add support eip2930 ethereum tests runner (#288)

* added support for eip2930 tests

Co-authored-by: sunce86 <dusan.stanivukovic@gmail.pm>
This commit is contained in:
Dusan Stanivukovic 2021-03-03 15:57:25 +01:00 committed by GitHub
parent 63fdad8d86
commit 973a5a594b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 101 additions and 83 deletions

3
Cargo.lock generated
View File

@ -439,7 +439,6 @@ name = "common-types"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"ethereum-types 0.4.2", "ethereum-types 0.4.2",
"ethjson",
"ethkey", "ethkey",
"heapsize", "heapsize",
"keccak-hash", "keccak-hash",
@ -1375,7 +1374,9 @@ dependencies = [
name = "ethjson" name = "ethjson"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"common-types",
"ethereum-types 0.4.2", "ethereum-types 0.4.2",
"ethkey",
"macros", "macros",
"maplit", "maplit",
"rustc-hex 1.0.0", "rustc-hex 1.0.0",

View File

@ -204,7 +204,7 @@ fn run_state_test(args: Args) {
} }
for (idx, state) in states.into_iter().enumerate() { for (idx, state) in states.into_iter().enumerate() {
let post_root = state.hash.into(); let post_root = state.hash.into();
let transaction = multitransaction.select(&state.indexes).into(); let transaction = multitransaction.select(&state.indexes);
let trie_spec = if args.flag_std_dump_json { let trie_spec = if args.flag_std_dump_json {
TrieSpec::Fat TrieSpec::Fat

@ -1 +1 @@
Subproject commit 1508126ea04cd61495b60db2f036ac823de274b1 Subproject commit 31d663076b6678df18983d6da912d7cad4ad3416

View File

@ -184,7 +184,7 @@ impl TestRunner {
return Vec::new(); return Vec::new();
} }
} }
super::state::json_chain_test(&test, &path, &json, &mut |_, _| {}) super::state::json_state_test(&test, &path, &json, &mut |_, _| {})
}, },
) )
} }

View File

@ -20,7 +20,6 @@ use ethjson;
use pod_state::PodState; use pod_state::PodState;
use std::path::Path; use std::path::Path;
use trace; use trace;
use types::transaction::SignedTransaction;
use vm::EnvInfo; use vm::EnvInfo;
fn skip_test( fn skip_test(
@ -42,7 +41,7 @@ fn skip_test(
}) })
} }
pub fn json_chain_test<H: FnMut(&str, HookType)>( pub fn json_state_test<H: FnMut(&str, HookType)>(
state_test: &ethjson::test::StateTests, state_test: &ethjson::test::StateTests,
path: &Path, path: &Path,
json_data: &[u8], json_data: &[u8],
@ -91,8 +90,7 @@ pub fn json_chain_test<H: FnMut(&str, HookType)>(
} }
let post_root: H256 = state.hash.into(); let post_root: H256 = state.hash.into();
let transaction: SignedTransaction = let transaction = multitransaction.select(&state.indexes);
multitransaction.select(&state.indexes).into();
let result = || -> Result<_, EvmTestError> { let result = || -> Result<_, EvmTestError> {
Ok(EvmTestClient::from_pod_state(&spec, pre.clone())?.transact( Ok(EvmTestClient::from_pod_state(&spec, pre.clone())?.transact(

View File

@ -6,7 +6,6 @@ authors = ["Parity Technologies <admin@parity.io>"]
[dependencies] [dependencies]
ethereum-types = "0.4" ethereum-types = "0.4"
ethjson = { path = "../../ethjson" }
ethkey = { path = "../../accounts/ethkey" } ethkey = { path = "../../accounts/ethkey" }
heapsize = "0.4" heapsize = "0.4"
keccak-hash = "0.1" keccak-hash = "0.1"

View File

@ -35,7 +35,6 @@
#![warn(unused_extern_crates)] #![warn(unused_extern_crates)]
extern crate ethereum_types; extern crate ethereum_types;
extern crate ethjson;
extern crate ethkey; extern crate ethkey;
extern crate heapsize; extern crate heapsize;
extern crate keccak_hash as hash; extern crate keccak_hash as hash;

View File

@ -21,7 +21,6 @@ use ethereum_types::{Address, Bloom, BloomInput, H256};
use heapsize::HeapSizeOf; use heapsize::HeapSizeOf;
use std::ops::Deref; use std::ops::Deref;
use ethjson;
use BlockNumber; use BlockNumber;
/// A record of execution for a `LOG` operation. /// A record of execution for a `LOG` operation.
@ -53,16 +52,6 @@ impl LogEntry {
} }
} }
impl From<ethjson::state::Log> for LogEntry {
fn from(l: ethjson::state::Log) -> Self {
LogEntry {
address: l.address.into(),
topics: l.topics.into_iter().map(Into::into).collect(),
data: l.data.into(),
}
}
}
/// Log localized in a blockchain. /// Log localized in a blockchain.
#[derive(Default, Debug, PartialEq, Clone)] #[derive(Default, Debug, PartialEq, Clone)]
pub struct LocalizedLogEntry { pub struct LocalizedLogEntry {

View File

@ -17,7 +17,6 @@
//! Transaction data structure. //! Transaction data structure.
use ethereum_types::{Address, H160, H256, U256}; use ethereum_types::{Address, H160, H256, U256};
use ethjson;
use ethkey::{self, public_to_address, recover, Public, Secret, Signature}; use ethkey::{self, public_to_address, recover, Public, Secret, Signature};
use hash::keccak; use hash::keccak;
use heapsize::HeapSizeOf; use heapsize::HeapSizeOf;
@ -606,56 +605,6 @@ impl SignatureComponents {
} }
} }
#[cfg(any(test, feature = "test-helpers"))]
impl From<ethjson::state::Transaction> for SignedTransaction {
fn from(t: ethjson::state::Transaction) -> Self {
let to: Option<ethjson::hash::Address> = t.to.into();
let secret = t.secret.map(|s| Secret::from(s.0));
let tx = TypedTransaction::Legacy(Transaction {
nonce: t.nonce.into(),
gas_price: t.gas_price.into(),
gas: t.gas_limit.into(),
action: match to {
Some(to) => Action::Call(to.into()),
None => Action::Create,
},
value: t.value.into(),
data: t.data.into(),
});
match secret {
Some(s) => tx.sign(&s, None),
None => tx.null_sign(1),
}
}
}
impl From<ethjson::transaction::Transaction> for UnverifiedTransaction {
fn from(t: ethjson::transaction::Transaction) -> Self {
let to: Option<ethjson::hash::Address> = t.to.into();
UnverifiedTransaction {
unsigned: TypedTransaction::Legacy(Transaction {
nonce: t.nonce.into(),
gas_price: t.gas_price.into(),
gas: t.gas_limit.into(),
action: match to {
Some(to) => Action::Call(to.into()),
None => Action::Create,
},
value: t.value.into(),
data: t.data.into(),
}),
chain_id: signature::extract_chain_id_from_legacy_v(t.v.into()),
signature: SignatureComponents {
r: t.r.into(),
s: t.s.into(),
standard_v: signature::extract_standard_v(t.v.into()),
},
hash: 0.into(),
}
.compute_hash()
}
}
/// Signed transaction information without verified signature. /// Signed transaction information without verified signature.
#[derive(Debug, Clone, Eq, PartialEq)] #[derive(Debug, Clone, Eq, PartialEq)]
pub struct UnverifiedTransaction { pub struct UnverifiedTransaction {

View File

@ -5,6 +5,8 @@ version = "0.1.0"
authors = ["Parity Technologies <admin@parity.io>"] authors = ["Parity Technologies <admin@parity.io>"]
[dependencies] [dependencies]
common-types = { path = "../ethcore/types", features = ["test-helpers"] }
ethkey = { path = "../accounts/ethkey" }
ethereum-types = "0.4" ethereum-types = "0.4"
rustc-hex = "1.0" rustc-hex = "1.0"
serde = "1.0" serde = "1.0"

View File

@ -41,7 +41,7 @@ pub struct Transaction {
pub type AccessList = Vec<AccessListItem>; pub type AccessList = Vec<AccessListItem>;
#[derive(Debug, PartialEq, Deserialize)] #[derive(Debug, PartialEq, Deserialize, Clone)]
#[serde(rename_all = "camelCase")] #[serde(rename_all = "camelCase")]
pub struct AccessListItem { pub struct AccessListItem {
pub address: H160, pub address: H160,

View File

@ -14,7 +14,9 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with OpenEthereum. If not, see <http://www.gnu.org/licenses/>. // along with OpenEthereum. If not, see <http://www.gnu.org/licenses/>.
extern crate common_types as types;
extern crate ethereum_types; extern crate ethereum_types;
extern crate ethkey;
extern crate rustc_hex; extern crate rustc_hex;
extern crate serde; extern crate serde;
extern crate serde_json; extern crate serde_json;

View File

@ -17,14 +17,18 @@
//! General test deserialization. //! General test deserialization.
use bytes::Bytes; use bytes::Bytes;
use ethkey::Secret;
use hash::{Address, H256}; use hash::{Address, H256};
use maybe::MaybeEmpty; use maybe::MaybeEmpty;
use serde_json::{self, Error}; use serde_json::{self, Error};
use spec::ForkSpec; use spec::ForkSpec;
use state::{AccountState, Env, Transaction}; use state::{AccountState, Env};
use std::{collections::BTreeMap, io::Read}; use std::{collections::BTreeMap, io::Read};
use types::transaction::{AccessListTx, Action, SignedTransaction, Transaction, TypedTransaction};
use uint::Uint; use uint::Uint;
use crate::blockchain::transaction::AccessList;
/// State test deserializer. /// State test deserializer.
#[derive(Debug, PartialEq, Deserialize)] #[derive(Debug, PartialEq, Deserialize)]
pub struct Test(BTreeMap<String, State>); pub struct Test(BTreeMap<String, State>);
@ -69,6 +73,8 @@ pub struct State {
pub struct MultiTransaction { pub struct MultiTransaction {
/// Transaction data set. /// Transaction data set.
pub data: Vec<Bytes>, pub data: Vec<Bytes>,
/// Optional access list
pub access_lists: Option<Vec<Option<AccessList>>>,
/// Gas limit set. /// Gas limit set.
pub gas_limit: Vec<Uint>, pub gas_limit: Vec<Uint>,
/// Gas price. /// Gas price.
@ -84,21 +90,60 @@ pub struct MultiTransaction {
pub value: Vec<Uint>, pub value: Vec<Uint>,
} }
fn sign_with_secret(tx: TypedTransaction, secret: Option<Secret>) -> SignedTransaction {
match secret {
Some(s) => tx.sign(&s, None),
None => tx.null_sign(1),
}
}
impl MultiTransaction { impl MultiTransaction {
/// Build transaction with given indexes. /// Build transaction with given indexes.
pub fn select(&self, indexes: &PostStateIndexes) -> Transaction { pub fn select(&self, indexes: &PostStateIndexes) -> SignedTransaction {
Transaction { let secret = self.secret.clone().map(|s| Secret::from(s.0));
data: self.data[indexes.data as usize].clone(), let to: Option<Address> = self.to.clone().into();
gas_limit: self.gas_limit[indexes.gas as usize].clone(), let transaction = Transaction {
gas_price: self.gas_price.clone(), nonce: self.nonce.clone().into(),
nonce: self.nonce.clone(), gas_price: self.gas_price.clone().into(),
secret: self.secret.clone(), gas: self.gas_limit[indexes.gas as usize].clone().into(),
to: self.to.clone(), action: match to {
value: self.value[indexes.value as usize].clone(), Some(to) => Action::Call(to.into()),
None => Action::Create,
},
value: self.value[indexes.value as usize].clone().into(),
data: self.data[indexes.data as usize].clone().into(),
};
if let Some(access_lists) = self.access_lists.as_ref() {
if access_lists.len() > indexes.data as usize {
if let Some(access_list) = access_lists[indexes.data as usize].clone() {
//access list type of transaction
let access_list = access_list
.into_iter()
.map(|elem| {
(
elem.address.into(),
elem.storage_keys.into_iter().map(Into::into).collect(),
)
})
.collect();
let tx = TypedTransaction::AccessList(AccessListTx {
transaction,
access_list,
});
return sign_with_secret(tx, secret);
} }
} }
} }
let tx = TypedTransaction::Legacy(transaction);
sign_with_secret(tx, secret)
}
}
/// State test indexes deserialization. /// State test indexes deserialization.
#[derive(Debug, PartialEq, Deserialize)] #[derive(Debug, PartialEq, Deserialize)]
pub struct PostStateIndexes { pub struct PostStateIndexes {
@ -138,6 +183,39 @@ mod tests {
let _deserialized: MultiTransaction = serde_json::from_str(s).unwrap(); let _deserialized: MultiTransaction = serde_json::from_str(s).unwrap();
} }
#[test]
fn multi_transaction_deserialization_with_access_list() {
let s = r#"{
"data" : [ "" ],
"accessLists" : [
null,
[
],
[
{
"address" : "0x0000000000000000000000000000000000000102",
"storageKeys" : [
]
},
{
"address" : "0x0000000000000000000000000000000000000101",
"storageKeys" : [
"0x0000000000000000000000000000000000000000000000000000000000000000",
"0x0000000000000000000000000000000000000000000000000000000000000010"
]
}
]
],
"gasLimit" : [ "0x2dc6c0", "0x222222" ],
"gasPrice" : "0x01",
"nonce" : "0x00",
"secretKey" : "45a915e4d060149eb4365960e6a7a45f334393093061116b197e3240065ff2d8",
"to" : "1000000000000000000000000000000000000000",
"value" : [ "0x00", "0x01", "0x02" ]
}"#;
let _deserialized: MultiTransaction = serde_json::from_str(s).unwrap();
}
#[test] #[test]
fn state_deserialization() { fn state_deserialization() {
let s = r#"{ let s = r#"{

View File

@ -51,6 +51,7 @@ mod tests {
fn transaction_deserialization() { fn transaction_deserialization() {
let s = r#"{ let s = r#"{
"data" : "", "data" : "",
"accessLists": null,
"gasLimit" : "0x2dc6c0", "gasLimit" : "0x2dc6c0",
"gasPrice" : "0x01", "gasPrice" : "0x01",
"nonce" : "0x00", "nonce" : "0x00",