CORE-299 Adding EVM transaction lanes

executor/evm/tests/executor.rs

@@ -116,6 +116,7 @@ fn executor(spec: EvmSpec) -> EvmExecutor {
         block_gas_limit: 30_000_000,
         base_fee: 0,
         wei_per_mote: DEFAULT_WEI_PER_MOTE,
+        transaction_lanes: Vec::new(),
     })
 }
 
@@ -1465,6 +1466,7 @@ fn whole_mote_value_executes_in_wei_and_persists_without_dust() {
         block_gas_limit: 30_000_000,
         base_fee: 0,
         wei_per_mote: DEFAULT_WEI_PER_MOTE,
+        transaction_lanes: Vec::new(),
     });
     let sender = evm::Address::new([0x31; 20]);
     let recipient = evm::Address::new([0x32; 20]);
@@ -2174,6 +2176,7 @@ fn unchecked_call_with_calldata_does_not_underflow_unfunded_sender() {
         block_gas_limit: 30_000_000,
         base_fee: 1_000_000,
         wei_per_mote: DEFAULT_WEI_PER_MOTE,
+        transaction_lanes: Vec::new(),
     };
     let gas_price = evm_config.base_fee_wei();
     let executor = EvmExecutor::new(evm_config);
@@ -2359,6 +2362,7 @@ fn signed_transactions_require_configured_chain_id() {
         block_gas_limit: 30_000_000,
         base_fee: 0,
         wei_per_mote: DEFAULT_WEI_PER_MOTE,
+        transaction_lanes: Vec::new(),
     });
     let transaction = legacy_transaction(Some(7));
     let request = ExecuteRequest {

node/src/components/block_accumulator/tests.rs

@@ -16,8 +16,8 @@ use tokio::time;
 
 use casper_types::{
     generate_ed25519_keypair, testing::TestRng, ActivationPoint, BlockV2, ChainNameDigest,
-    Chainspec, ChainspecRawBytes, FinalitySignature, FinalitySignatureV2, ProtocolVersion,
-    PublicKey, SecretKey, Signature, TestBlockBuilder, TransactionConfig, U512,
+    Chainspec, ChainspecRawBytes, EvmConfig, FinalitySignature, FinalitySignatureV2,
+    ProtocolVersion, PublicKey, SecretKey, Signature, TestBlockBuilder, TransactionConfig, U512,
 };
 use reactor::ReactorEvent;
 
@@ -208,6 +208,7 @@ impl Reactor for MockReactor {
             Some(registry),
             false,
             TransactionConfig::default(),
+            EvmConfig::default(),
         )
         .unwrap();
         storage.initialize_for_test();

node/src/components/block_validator/state.rs

@@ -8,8 +8,8 @@ use datasize::DataSize;
 use tracing::{debug, error, warn};
 
 use casper_types::{
-    Approval, ApprovalsHash, Chainspec, FinalitySignatureId, Timestamp, TransactionConfig,
-    TransactionHash,
+    Approval, ApprovalsHash, Chainspec, EvmConfig, FinalitySignatureId, Timestamp,
+    TransactionConfig, TransactionHash,
 };
 
 use crate::{
@@ -136,9 +136,11 @@ impl BlockValidationState {
 
         // this is an optimization, rejects proposal that exceeds lane limits OR
         // proposes a transaction in an unsupported lane
-        if let Err(err) =
-            Self::validate_transaction_lane_counts(proposed_block, &chainspec.transaction_config)
-        {
+        if let Err(err) = Self::validate_transaction_lane_counts(
+            proposed_block,
+            &chainspec.transaction_config,
+            &chainspec.evm_config,
+        ) {
             let state = BlockValidationState::Invalid {
                 timestamp: proposed_block.timestamp(),
                 error: err,
@@ -196,6 +198,7 @@ impl BlockValidationState {
         let state = BlockValidationState::InProgress {
             appendable_block: AppendableBlock::new(
                 chainspec.transaction_config.clone(),
+                chainspec.evm_config.clone(),
                 current_gas_price,
                 proposed_block.timestamp(),
             ),
@@ -211,16 +214,22 @@ impl BlockValidationState {
     fn validate_transaction_lane_counts(
         block: &ProposedBlock<ClContext>,
         config: &TransactionConfig,
+        evm_config: &EvmConfig,
     ) -> Result<(), Box<InvalidProposalError>> {
-        let lanes = config.transaction_v1_config.get_supported_lanes();
+        let mut lanes = config.transaction_v1_config.get_supported_lanes();
+        lanes.extend(evm_config.get_supported_lanes());
         if block.value().has_transaction_in_unsupported_lane(&lanes) {
             return Err(Box::new(InvalidProposalError::UnsupportedLane));
         }
         for supported_lane in lanes {
             let transactions = block.value().count(Some(supported_lane));
-            let lane_count_limit = config
-                .transaction_v1_config
-                .get_max_transaction_count(supported_lane);
+            let lane_count_limit = if evm_config.is_supported(supported_lane) {
+                evm_config.get_max_transaction_count(supported_lane)
+            } else {
+                config
+                    .transaction_v1_config
+                    .get_max_transaction_count(supported_lane)
+            };
             if lane_count_limit < transactions as u64 {
                 warn!(
                     supported_lane,

node/src/components/contract_runtime/operations.rs

@@ -686,6 +686,7 @@ pub fn execute_finalized_block(
             &stored_transaction,
             chainspec.core_config.pricing_handling,
             transaction_config,
+            &chainspec.evm_config,
         )
         .map_err(|err| BlockExecutionError::TransactionConversion(err.to_string()))?;
 
@@ -1198,7 +1199,7 @@ pub fn execute_finalized_block(
                         )?;
                     }
                     apply_evm_proposer_identity(&mut tracking_copy, protocol_version, &proposer)?;
-                    let outcome = EvmExecutor::new(chainspec.evm_config)
+                    let outcome = EvmExecutor::new(chainspec.evm_config.clone())
                         .execute(data_access_layer, &mut tracking_copy, request)
                         .map_err(|error| {
                             BlockExecutionError::TransactionConversion(error.to_string())
@@ -1982,6 +1983,7 @@ where
         &input_transaction,
         chainspec.core_config.pricing_handling,
         transaction_config,
+        &chainspec.evm_config,
     );
     if let Err(error) = maybe_transaction {
         return SpeculativeExecutionResult::invalid_transaction(error);
@@ -2210,7 +2212,7 @@ where
         block: block_context,
         kind,
     };
-    let outcome = match EvmExecutor::new(chainspec.evm_config).execute(
+    let outcome = match EvmExecutor::new(chainspec.evm_config.clone()).execute(
         data_access_layer,
         &mut tracking_copy,
         execute_request,
@@ -2426,6 +2428,7 @@ mod tests {
                 block_gas_limit: 30_000_000,
                 base_fee: 3,
                 wei_per_mote: DEFAULT_WEI_PER_MOTE,
+                transaction_lanes: Vec::new(),
             },
             ..Default::default()
         };

node/src/components/contract_runtime/tests.rs

@@ -13,7 +13,7 @@ use tempfile::TempDir;
 
 use casper_types::{
     bytesrepr::Bytes, contracts::ProtocolVersionMajor, evm, runtime_args, BlockHash, BlockHeader,
-    Chainspec, ChainspecRawBytes, Deploy, Digest, EntityVersion, EraId, EvmTransaction,
+    Chainspec, ChainspecRawBytes, Deploy, Digest, EntityVersion, EraId, EvmConfig, EvmTransaction,
     ExecutableDeployItem, PackageHash, PricingMode, PublicKey, RuntimeArgs, SecretKey,
     TestBlockBuilder, TimeDiff, Timestamp, Transaction, TransactionConfig,
     TransactionRuntimeParams, MINT_LANE_ID, U256, U512,
@@ -149,6 +149,7 @@ impl reactor::Reactor for Reactor {
             Some(registry),
             false,
             TransactionConfig::default(),
+            EvmConfig::default(),
         )
         .unwrap();
         storage.initialize_for_test();

node/src/components/fetcher/tests.rs

@@ -12,8 +12,8 @@ use tempfile::TempDir;
 use thiserror::Error;
 
 use casper_types::{
-    testing::TestRng, BlockV2, Chainspec, ChainspecRawBytes, FinalitySignatureV2, Transaction,
-    TransactionConfig, TransactionHash, TransactionId,
+    testing::TestRng, BlockV2, Chainspec, ChainspecRawBytes, EvmConfig, FinalitySignatureV2,
+    Transaction, TransactionConfig, TransactionHash, TransactionId,
 };
 
 use super::*;
@@ -304,6 +304,7 @@ impl ReactorTrait for Reactor {
             Some(registry),
             false,
             TransactionConfig::default(),
+            EvmConfig::default(),
         )
         .unwrap();
         storage.initialize_for_test();

node/src/components/gossiper/tests.rs

@@ -18,7 +18,7 @@ use tokio::time;
 use tracing::debug;
 
 use casper_types::{
-    testing::TestRng, BlockV2, Chainspec, ChainspecRawBytes, EraId, FinalitySignatureV2,
+    testing::TestRng, BlockV2, Chainspec, ChainspecRawBytes, EraId, EvmConfig, FinalitySignatureV2,
     ProtocolVersion, TimeDiff, Transaction, TransactionConfig,
 };
 
@@ -180,6 +180,7 @@ impl reactor::Reactor for Reactor {
             Some(registry),
             false,
             TransactionConfig::default(),
+            EvmConfig::default(),
         )
         .unwrap();
         storage.initialize_for_test();

node/src/components/storage.rs

@@ -67,8 +67,9 @@ use casper_types::{
     execution::{execution_result_v1, ExecutionResult, ExecutionResultV1},
     Approval, ApprovalsHash, AvailableBlockRange, Block, BlockBody, BlockHash, BlockHeader,
     BlockHeaderWithSignatures, BlockSignatures, BlockSignaturesV1, BlockSignaturesV2, BlockV2,
-    ChainNameDigest, DeployHash, Digest, EraId, ExecutionInfo, FinalitySignature, ProtocolVersion,
-    Timestamp, Transaction, TransactionConfig, TransactionHash, TransactionId, Transfer, U512,
+    ChainNameDigest, DeployHash, Digest, EraId, EvmConfig, ExecutionInfo, FinalitySignature,
+    ProtocolVersion, Timestamp, Transaction, TransactionConfig, TransactionHash, TransactionId,
+    Transfer, U512,
 };
 use datasize::DataSize;
 use num_rational::Ratio;
@@ -150,6 +151,8 @@ pub struct Storage {
     chain_name_hash: ChainNameDigest,
     /// The transaction config as specified by the chainspec.
     transaction_config: TransactionConfig,
+    /// The EVM config as specified by the chainspec.
+    evm_config: EvmConfig,
     /// The utilization of blocks.
     utilization_tracker: BTreeMap<EraId, BTreeMap<u64, u64>>,
     /// Component initialization state.
@@ -446,6 +449,7 @@ impl Storage {
         registry: Option<&Registry>,
         force_resync: bool,
         transaction_config: TransactionConfig,
+        evm_config: EvmConfig,
     ) -> Result<Self, FatalStorageError> {
         let config = cfg.value();
         let metrics = registry.map(Metrics::new).transpose()?;
@@ -464,6 +468,7 @@ impl Storage {
             metrics,
             chain_name_hash: ChainNameDigest::from_chain_name(network_name),
             transaction_config,
+            evm_config,
             state: ComponentState::Uninitialized,
             protocol_version,
             force_resync,
@@ -624,6 +629,7 @@ impl Storage {
                         }
                         let utilization = Self::calculate_block_utilization(
                             &self.transaction_config,
+                            &self.evm_config,
                             &block,
                             &map,
                         );
@@ -1028,6 +1034,7 @@ impl Storage {
                 if let Some(block) = maybe_block {
                     let utilization = Self::calculate_block_utilization(
                         &self.transaction_config,
+                        &self.evm_config,
                         &block,
                         &execution_results,
                     );
@@ -1340,8 +1347,12 @@ impl Storage {
         let era_id = block.era_id();
         let block_hash = txn.write_block(block)?;
         let _ = txn.write_approvals_hashes(approvals_hashes)?;
-        let utilization =
-            Self::calculate_block_utilization(&self.transaction_config, block, &execution_results);
+        let utilization = Self::calculate_block_utilization(
+            &self.transaction_config,
+            &self.evm_config,
+            block,
+            &execution_results,
+        );
 
         let block_info = BlockHashHeightAndEra::new(block_hash, block.height(), block.era_id());
         debug!("Utilization for block is {utilization}");
@@ -2307,12 +2318,14 @@ impl Storage {
 
     fn calculate_block_utilization(
         transaction_config_input: impl Borrow<TransactionConfig>,
+        evm_config_input: impl Borrow<EvmConfig>,
         block: &Block,
         execution_results: &HashMap<TransactionHash, ExecutionResult>,
     ) -> u64 {
         let transaction_config = transaction_config_input.borrow();
-        let block_utilization_score = block.block_utilization(transaction_config);
-        let has_hit_slot_limit = block.has_hit_slot_capacity(transaction_config);
+        let evm_config = evm_config_input.borrow();
+        let block_utilization_score = block.block_utilization(transaction_config, evm_config);
+        let has_hit_slot_limit = block.has_hit_slot_capacity(transaction_config, evm_config);
 
         let utilization = if has_hit_slot_limit {
             debug!("Block is at slot capacity, using slot utilization score");

node/src/components/storage/tests.rs

@@ -25,10 +25,10 @@ use casper_types::{
     testing::TestRng,
     ApprovalsHash, AvailableBlockRange, Block, BlockHash, BlockHeader, BlockHeaderWithSignatures,
     BlockSignatures, BlockSignaturesV2, BlockV2, ChainNameDigest, Chainspec, ChainspecRawBytes,
-    Deploy, DeployHash, Digest, EraId, ExecutionInfo, FinalitySignature, FinalitySignatureV2, Gas,
-    InitiatorAddr, ProtocolVersion, PublicKey, SecretKey, TestBlockBuilder, TestBlockV1Builder,
-    TimeDiff, Timestamp, Transaction, TransactionConfig, TransactionHash, TransactionV1Hash,
-    Transfer, TransferV2, U512,
+    Deploy, DeployHash, Digest, EraId, EvmConfig, ExecutionInfo, FinalitySignature,
+    FinalitySignatureV2, Gas, InitiatorAddr, ProtocolVersion, PublicKey, SecretKey,
+    TestBlockBuilder, TestBlockV1Builder, TimeDiff, Timestamp, Transaction, TransactionConfig,
+    TransactionHash, TransactionV1Hash, Transfer, TransferV2, U512,
 };
 use tempfile::tempdir;
 
@@ -205,6 +205,7 @@ fn storage_fixture(harness: &ComponentHarness<UnitTestEvent>) -> Storage {
         None,
         false,
         TransactionConfig::default(),
+        EvmConfig::default(),
     )
     .expect("could not create storage component fixture");
     storage.initialize_for_test();
@@ -250,6 +251,7 @@ fn storage_fixture_from_parts(
         None,
         false,
         TransactionConfig::default(),
+        EvmConfig::default(),
     )
     .expect("could not create storage component fixture from parts");
     storage.initialize_for_test();
@@ -281,6 +283,7 @@ fn storage_fixture_with_force_resync(cfg: &WithDir<Config>) -> Storage {
         None,
         true,
         TransactionConfig::default(),
+        EvmConfig::default(),
     )
     .expect("could not create storage component fixture");
     storage.initialize_for_test();
@@ -1827,6 +1830,7 @@ fn should_create_subdir_named_after_network() {
         None,
         false,
         TransactionConfig::default(),
+        EvmConfig::default(),
     )
     .unwrap();
 

node/src/components/transaction_acceptor.rs

@@ -187,6 +187,7 @@ impl TransactionAcceptor {
             &input_transaction,
             self.chainspec.as_ref().core_config.pricing_handling,
             transaction_config,
+            &self.chainspec.as_ref().evm_config,
         );
         let meta_transaction = match maybe_meta_transaction {
             Ok(transaction) => transaction,

node/src/components/transaction_acceptor/tests.rs

@@ -44,11 +44,11 @@ use casper_types::{
     evm,
     global_state::TrieMerkleProof,
     testing::TestRng,
-    Block, BlockV2, CLValue, Chainspec, ChainspecRawBytes, Contract, Deploy, EraId, EvmTransaction,
-    EvmTransactionError, Groups, HashAddr, InvalidDeploy, InvalidTransaction, InvalidTransactionV1,
-    Key, PackageAddr, PricingHandling, PricingMode, ProtocolVersion, PublicKey, SecretKey,
-    StoredValue, TestBlockBuilder, TimeDiff, Timestamp, Transaction, TransactionArgs,
-    TransactionConfig, TransactionRuntimeParams, TransactionV1, URef,
+    Block, BlockV2, CLValue, Chainspec, ChainspecRawBytes, Contract, Deploy, EraId, EvmConfig,
+    EvmTransaction, EvmTransactionError, Groups, HashAddr, InvalidDeploy, InvalidTransaction,
+    InvalidTransactionV1, Key, PackageAddr, PricingHandling, PricingMode, ProtocolVersion,
+    PublicKey, SecretKey, StoredValue, TestBlockBuilder, TimeDiff, Timestamp, Transaction,
+    TransactionArgs, TransactionConfig, TransactionRuntimeParams, TransactionV1, URef,
     DEFAULT_BASELINE_MOTES_AMOUNT,
 };
 
@@ -1443,6 +1443,7 @@ impl reactor::Reactor for Reactor {
             Some(registry),
             false,
             TransactionConfig::default(),
+            EvmConfig::default(),
         )
         .unwrap();
         storage.initialize_for_test();
@@ -1530,6 +1531,7 @@ fn inject_balance_check_for_peer(
         &txn,
         chainspec.core_config.pricing_handling,
         &chainspec.transaction_config,
+        &chainspec.evm_config,
     )
     .unwrap();
     |effect_builder: EffectBuilder<Event>| {