EIP2930: Tx envelop and AccessList tx support (#140)

 EIP2930: Tx envelop and AccessList transaction support
- Uses individual structs for Transactions
- Adds tests for different structure of access list
- Changes Transaction core type and it's usage everywhere

evm_loader/cli/src/main.rs

@@ -12,7 +12,8 @@ use neon_lib::{
         get_ether_account_data, get_neon_elf, get_neon_elf::CachedElfParams, get_storage_at,
         init_environment, trace,
     },
-    errors, rpc, types,
+    errors, rpc,
+    types::{self, AccessListItem},
 };
 
 use clap::ArgMatches;
@@ -319,16 +320,21 @@ fn parse_tx(params: &ArgMatches) -> (TxParams, TraceCallConfig) {
             )
         })
         .unwrap_or_default();
+
     let value = u256_of(params, "value");
+
     let gas_limit = u256_of(params, "gas_limit");
 
+    let access_list = access_list_of(params, "access_list");
+
     let tx_params = TxParams {
         nonce: None,
         from,
         to,
         data,
         value,
         gas_limit,
+        access_list,
     };
 
     (tx_params, trace_config)
@@ -403,6 +409,18 @@ fn address_of(matches: &ArgMatches<'_>, name: &str) -> Option<Address> {
         .map(|value| Address::from_hex(value).unwrap())
 }
 
+fn access_list_of(matches: &ArgMatches<'_>, name: &str) -> Option<Vec<AccessListItem>> {
+    matches.value_of(name).map(|value| {
+        let address = Address::from_hex(value).unwrap();
+        let keys = vec![];
+        let item = AccessListItem {
+            address,
+            storage_keys: keys,
+        };
+        vec![item]
+    })
+}
+
 fn u256_of(matches: &ArgMatches<'_>, name: &str) -> Option<U256> {
     matches.value_of(name).map(|value| {
         if value.is_empty() {

evm_loader/cli/src/program_options.rs

@@ -151,6 +151,14 @@ fn trx_params<'a, 'b>(cmd: &'static str, desc: &'static str) -> App<'a, 'b> {
                 .validator(is_valid_u256)
                 .help("Gas limit"),
         )
+        .arg(
+            Arg::with_name("access_list")
+                .long("access-list")
+                .takes_value(true)
+                .required(false)
+                .multiple(true)
+                .value_name("ADDRESS [STORAGE_KEYS ...]"),
+        )
         .arg(
             Arg::with_name("cached_accounts")
                 .value_name("CACHED_ACCOUNTS")

evm_loader/lib/src/commands/emulate.rs

@@ -202,19 +202,65 @@ pub(crate) async fn emulate_trx<'a>(
 ) -> Result<evm_loader::evm::tracing::EmulationResult, NeonError> {
     let (exit_status, actions, steps_executed) = {
         let mut backend = ExecutorState::new(storage);
-        let trx = Transaction {
-            nonce: tx_params
-                .nonce
-                .unwrap_or_else(|| storage.nonce(&tx_params.from)),
-            gas_price: U256::ZERO,
-            gas_limit: tx_params.gas_limit.unwrap_or(U256::MAX),
-            target: tx_params.to,
-            value: tx_params.value.unwrap_or_default(),
-            call_data: evm_loader::evm::Buffer::from_slice(&tx_params.data.unwrap_or_default()),
-            chain_id: Some(chain_id.into()),
-            ..Transaction::default()
+        let trx_payload = if tx_params.access_list.is_some() {
+            let access_list = tx_params
+                .access_list
+                .expect("access_list is present")
+                .into_iter()
+                .map(|item| {
+                    (
+                        item.address,
+                        item.storage_keys
+                            .into_iter()
+                            .map(|k| {
+                                evm_loader::types::StorageKey::try_from(k)
+                                    .expect("key to be correct")
+                            })
+                            .collect(),
+                    )
+                })
+                .collect();
+            evm_loader::types::TransactionPayload::AccessList(evm_loader::types::AccessListTx {
+                nonce: tx_params
+                    .nonce
+                    .unwrap_or_else(|| storage.nonce(&tx_params.from)),
+                gas_price: U256::ZERO,
+                gas_limit: tx_params.gas_limit.unwrap_or(U256::MAX),
+                target: tx_params.to,
+                value: tx_params.value.unwrap_or_default(),
+                call_data: evm_loader::evm::Buffer::from_slice(&tx_params.data.unwrap_or_default()),
+                r: U256::default(),
+                s: U256::default(),
+                chain_id: chain_id.into(),
+                recovery_id: u8::default(),
+                access_list,
+            })
+        } else {
+            evm_loader::types::TransactionPayload::Legacy(evm_loader::types::LegacyTx {
+                nonce: tx_params
+                    .nonce
+                    .unwrap_or_else(|| storage.nonce(&tx_params.from)),
+                gas_price: U256::ZERO,
+                gas_limit: tx_params.gas_limit.unwrap_or(U256::MAX),
+                target: tx_params.to,
+                value: tx_params.value.unwrap_or_default(),
+                call_data: evm_loader::evm::Buffer::from_slice(&tx_params.data.unwrap_or_default()),
+                v: U256::default(),
+                r: U256::default(),
+                s: U256::default(),
+                chain_id: Some(chain_id.into()),
+                recovery_id: u8::default(),
+            })
         };
-        let mut evm = Machine::new(trx, tx_params.from, &mut backend, tracer)?;
+
+        let mut trx = Transaction {
+            transaction: trx_payload,
+            byte_len: usize::default(),
+            hash: <[u8; 32]>::default(),
+            signed_hash: <[u8; 32]>::default(),
+        };
+
+        let mut evm = Machine::new(&mut trx, tx_params.from, &mut backend, tracer)?;
 
         let (result, steps_executed) = evm.execute(step_limit, &mut backend)?;
         if result == ExitStatus::StepLimit {

evm_loader/lib/src/types/indexer_db.rs

@@ -170,6 +170,7 @@ impl IndexerDb {
             data: Some(data),
             value: Some(value),
             gas_limit: Some(gas_limit),
+            access_list: None,
         })
     }
 }

evm_loader/lib/src/types/mod.rs

@@ -33,6 +33,12 @@ pub struct ChDbConfig {
     pub indexer_password: String,
 }
 
+#[derive(Clone, Serialize, Deserialize, Debug)]
+pub struct AccessListItem {
+    pub address: Address,
+    pub storage_keys: Vec<HexBytes>,
+}
+
 #[derive(Clone, Serialize, Deserialize, Debug)]
 pub struct TxParams {
     pub nonce: Option<u64>,
@@ -41,6 +47,7 @@ pub struct TxParams {
     pub data: Option<Vec<u8>>,
     pub value: Option<U256>,
     pub gas_limit: Option<U256>,
+    pub access_list: Option<Vec<AccessListItem>>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

evm_loader/lib/src/types/request_models.rs

@@ -5,6 +5,8 @@ use evm_loader::types::Address;
 use serde::{Deserialize, Serialize};
 use solana_sdk::pubkey::Pubkey;
 
+use super::AccessListItem;
+
 #[derive(Deserialize, Serialize, Debug, Default)]
 pub struct GetEtherRequest {
     pub ether: Address,
@@ -25,6 +27,7 @@ pub struct TxParamsRequestModel {
     pub data: Option<Vec<u8>>,
     pub value: Option<U256>,
     pub gas_limit: Option<U256>,
+    pub access_list: Option<Vec<AccessListItem>>,
 }
 
 impl From<TxParamsRequestModel> for TxParams {
@@ -36,6 +39,7 @@ impl From<TxParamsRequestModel> for TxParams {
             data: model.data,
             value: model.value,
             gas_limit: model.gas_limit,
+            access_list: model.access_list,
         }
     }
 }

evm_loader/program/src/account/holder.rs

@@ -93,8 +93,8 @@ impl<'a> Holder<'a> {
     }
 
     pub fn validate_transaction(&self, trx: &Transaction) -> Result<()> {
-        if self.transaction_hash != trx.hash {
-            return Err(Error::HolderInvalidHash(self.transaction_hash, trx.hash));
+        if self.transaction_hash != trx.hash() {
+            return Err(Error::HolderInvalidHash(self.transaction_hash, trx.hash()));
         }
 
         Ok(())

evm_loader/program/src/evm/mod.rs

@@ -192,7 +192,7 @@ impl<B: Database> Machine<B> {
     }
 
     pub fn new(
-        trx: Transaction,
+        trx: &mut Transaction,
         origin: Address,
         backend: &mut B,
         #[cfg(feature = "tracing")] tracer: TracerTypeOpt,
@@ -203,29 +203,29 @@ impl<B: Database> Machine<B> {
             return Err(Error::NonceOverflow(origin));
         }
 
-        if origin_nonce != trx.nonce {
+        if origin_nonce != trx.nonce() {
             return Err(Error::InvalidTransactionNonce(
                 origin,
                 origin_nonce,
-                trx.nonce,
+                trx.nonce(),
             ));
         }
 
-        if let Some(chain_id) = trx.chain_id {
+        if let Some(chain_id) = trx.chain_id() {
             if backend.chain_id() != chain_id {
                 return Err(Error::InvalidChainId(chain_id));
             }
         }
 
-        if backend.balance(&origin)? < trx.value {
-            return Err(Error::InsufficientBalance(origin, trx.value));
+        if backend.balance(&origin)? < trx.value() {
+            return Err(Error::InsufficientBalance(origin, trx.value()));
         }
 
         if backend.code_size(&origin)? != 0 {
             return Err(Error::SenderHasDeployedCode(origin));
         }
 
-        if trx.target.is_some() {
+        if trx.target().is_some() {
             Self::new_call(
                 trx,
                 origin,
@@ -245,20 +245,20 @@ impl<B: Database> Machine<B> {
     }
 
     fn new_call(
-        trx: Transaction,
+        trx: &mut Transaction,
         origin: Address,
         backend: &mut B,
         #[cfg(feature = "tracing")] tracer: TracerTypeOpt,
     ) -> Result<Self> {
-        assert!(trx.target.is_some());
+        assert!(trx.target().is_some());
 
-        let target = trx.target.unwrap();
+        let target = trx.target().unwrap();
         sol_log_data(&[b"ENTER", b"CALL", target.as_bytes()]);
 
         backend.increment_nonce(origin)?;
         backend.snapshot();
 
-        backend.transfer(origin, target, trx.value)?;
+        backend.transfer(origin, target, trx.value())?;
 
         let execution_code = backend.code(&target)?;
 
@@ -267,13 +267,13 @@ impl<B: Database> Machine<B> {
             context: Context {
                 caller: origin,
                 contract: target,
-                value: trx.value,
+                value: trx.value(),
                 code_address: Some(target),
             },
-            gas_price: trx.gas_price,
-            gas_limit: trx.gas_limit,
+            gas_price: trx.gas_price(),
+            gas_limit: trx.gas_limit(),
             execution_code,
-            call_data: trx.call_data,
+            call_data: trx.extract_call_data(),
             return_data: Buffer::empty(),
             return_range: 0..0,
             stack: Stack::new(
@@ -295,14 +295,14 @@ impl<B: Database> Machine<B> {
     }
 
     fn new_create(
-        trx: Transaction,
+        trx: &mut Transaction,
         origin: Address,
         backend: &mut B,
         #[cfg(feature = "tracing")] tracer: TracerTypeOpt,
     ) -> Result<Self> {
-        assert!(trx.target.is_none());
+        assert!(trx.target().is_none());
 
-        let target = Address::from_create(&origin, trx.nonce);
+        let target = Address::from_create(&origin, trx.nonce());
         sol_log_data(&[b"ENTER", b"CREATE", target.as_bytes()]);
 
         if (backend.nonce(&target)? != 0) || (backend.code_size(&target)? != 0) {
@@ -313,18 +313,18 @@ impl<B: Database> Machine<B> {
         backend.snapshot();
 
         backend.increment_nonce(target)?;
-        backend.transfer(origin, target, trx.value)?;
+        backend.transfer(origin, target, trx.value())?;
 
         Ok(Self {
             origin,
             context: Context {
                 caller: origin,
                 contract: target,
-                value: trx.value,
+                value: trx.value(),
                 code_address: None,
             },
-            gas_price: trx.gas_price,
-            gas_limit: trx.gas_limit,
+            gas_price: trx.gas_price(),
+            gas_limit: trx.gas_limit(),
             return_data: Buffer::empty(),
             return_range: 0..0,
             stack: Stack::new(
@@ -338,7 +338,7 @@ impl<B: Database> Machine<B> {
             pc: 0_usize,
             is_static: false,
             reason: Reason::Create,
-            execution_code: trx.call_data,
+            execution_code: trx.extract_call_data(),
             call_data: Buffer::empty(),
             parent: None,
             phantom: PhantomData,

evm_loader/program/src/gasometer.rs

@@ -57,7 +57,7 @@ impl Gasometer {
     }
 
     pub fn record_write_to_holder(&mut self, trx: &Transaction) {
-        let size: u64 = trx.rlp_len.try_into().expect("usize is 8 bytes");
+        let size: u64 = trx.rlp_len().try_into().expect("usize is 8 bytes");
         let cost: u64 = ((size + (HOLDER_MSG_SIZE - 1)) / HOLDER_MSG_SIZE)
             .saturating_mul(WRITE_TO_HOLDER_TRX_COST);
 

evm_loader/program/src/instruction/transaction_execute.rs

@@ -26,8 +26,8 @@ pub fn validate(
     trx: &Transaction,
     _caller_address: &Address,
 ) -> Result<()> {
-    if trx.chain_id != Some(CHAIN_ID.into()) {
-        return Err(Error::InvalidChainId(trx.chain_id.unwrap_or(U256::ZERO)));
+    if trx.chain_id() != Some(CHAIN_ID.into()) {
+        return Err(Error::InvalidChainId(trx.chain_id().unwrap_or(U256::ZERO)));
     }
 
     account_storage.check_for_blocked_accounts()?;
@@ -39,7 +39,7 @@ pub fn execute<'a>(
     accounts: Accounts<'a>,
     account_storage: &mut ProgramAccountStorage<'a>,
     mut gasometer: Gasometer,
-    trx: Transaction,
+    trx: &mut Transaction,
     caller_address: Address,
 ) -> Result<()> {
     accounts.system_program.transfer(
@@ -48,8 +48,8 @@ pub fn execute<'a>(
         crate::config::PAYMENT_TO_TREASURE,
     )?;
 
-    let gas_limit = trx.gas_limit;
-    let gas_price = trx.gas_price;
+    let gas_limit = trx.gas_limit();
+    let gas_price = trx.gas_price();
 
     let (exit_reason, apply_state) = {
         let mut backend = ExecutorState::new(account_storage);