Copy OP execution outcome tests

[emhane]

Describe the feature

Copy all tests that have an optimism feature gate inside, into optimism evm crate. For the copies, remove the optimism feature gate. For the originals, remove the optimism feature gated code completely.

reth/crates/evm/execution-types/src/execution_outcome.rs

Lines 365 to 891 in 6a1ec0d

	#[cfg(test)]
	mod tests {
	use super::*;
	use alloy_eips::{eip6110::DepositRequest, eip7002::WithdrawalRequest};
	use alloy_primitives::{Address, FixedBytes, LogData, B256};
	use reth_primitives::{Receipts, Request, Requests, TxType};
	use std::collections::HashMap;
	#[test]
	fn test_initialisation() {
	// Create a new BundleState object with initial data
	let bundle = BundleState::new(
	vec![(Address::new([2; 20]), None, Some(AccountInfo::default()), HashMap::default())],
	vec![vec![(Address::new([2; 20]), None, vec![])]],
	vec![],
	);
	// Create a Receipts object with a vector of receipt vectors
	let receipts = Receipts {
	receipt_vec: vec![vec![Some(Receipt {
	tx_type: TxType::Legacy,
	cumulative_gas_used: 46913,
	logs: vec![],
	success: true,
	#[cfg(feature = "optimism")]
	deposit_nonce: Some(18),
	#[cfg(feature = "optimism")]
	deposit_receipt_version: Some(34),
	})]],
	};
	// Create a Requests object with a vector of requests, including DepositRequest and
	// WithdrawalRequest
	let requests = vec![Requests(vec![
	Request::DepositRequest(DepositRequest {
	pubkey: FixedBytes::<48>::from([1; 48]),
	withdrawal_credentials: B256::from([0; 32]),
	amount: 1111,
	signature: FixedBytes::<96>::from([2; 96]),
	index: 222,
	}),
	Request::DepositRequest(DepositRequest {
	pubkey: FixedBytes::<48>::from([23; 48]),
	withdrawal_credentials: B256::from([0; 32]),
	amount: 34343,
	signature: FixedBytes::<96>::from([43; 96]),
	index: 1212,
	}),
	Request::WithdrawalRequest(WithdrawalRequest {
	source_address: Address::from([1; 20]),
	validator_pubkey: FixedBytes::<48>::from([10; 48]),
	amount: 72,
	}),
	])];
	// Define the first block number
	let first_block = 123;
	// Create a ExecutionOutcome object with the created bundle, receipts, requests, and
	// first_block
	let exec_res = ExecutionOutcome {
	bundle: bundle.clone(),
	receipts: receipts.clone(),
	requests: requests.clone(),
	first_block,
	};
	// Assert that creating a new ExecutionOutcome using the constructor matches exec_res
	assert_eq!(
	ExecutionOutcome::new(bundle, receipts.clone(), first_block, requests.clone()),
	exec_res
	);
	// Create a BundleStateInit object and insert initial data
	let mut state_init: BundleStateInit = HashMap::default();
	state_init
	.insert(Address::new([2; 20]), (None, Some(Account::default()), HashMap::default()));
	// Create a HashMap for account reverts and insert initial data
	let mut revert_inner: HashMap<Address, AccountRevertInit> = HashMap::default();
	revert_inner.insert(Address::new([2; 20]), (None, vec![]));
	// Create a RevertsInit object and insert the revert_inner data
	let mut revert_init: RevertsInit = HashMap::default();
	revert_init.insert(123, revert_inner);
	// Assert that creating a new ExecutionOutcome using the new_init method matches
	// exec_res
	assert_eq!(
	ExecutionOutcome::new_init(
	state_init,
	revert_init,
	vec![],
	receipts,
	first_block,
	requests,
	),
	exec_res
	);
	}
	#[test]
	fn test_block_number_to_index() {
	// Create a Receipts object with a vector of receipt vectors
	let receipts = Receipts {
	receipt_vec: vec![vec![Some(Receipt {
	tx_type: TxType::Legacy,
	cumulative_gas_used: 46913,
	logs: vec![],
	success: true,
	#[cfg(feature = "optimism")]
	deposit_nonce: Some(18),
	#[cfg(feature = "optimism")]
	deposit_receipt_version: Some(34),
	})]],
	};
	// Define the first block number
	let first_block = 123;
	// Create a ExecutionOutcome object with the created bundle, receipts, requests, and
	// first_block
	let exec_res = ExecutionOutcome {
	bundle: Default::default(),
	receipts,
	requests: vec![],
	first_block,
	};
	// Test before the first block
	assert_eq!(exec_res.block_number_to_index(12), None);
	// Test after after the first block but index larger than receipts length
	assert_eq!(exec_res.block_number_to_index(133), None);
	// Test after the first block
	assert_eq!(exec_res.block_number_to_index(123), Some(0));
	}
	#[test]
	fn test_get_logs() {
	// Create a Receipts object with a vector of receipt vectors
	let receipts = Receipts {
	receipt_vec: vec![vec![Some(Receipt {
	tx_type: TxType::Legacy,
	cumulative_gas_used: 46913,
	logs: vec![Log::<LogData>::default()],
	success: true,
	#[cfg(feature = "optimism")]
	deposit_nonce: Some(18),
	#[cfg(feature = "optimism")]
	deposit_receipt_version: Some(34),
	})]],
	};
	// Define the first block number
	let first_block = 123;
	// Create a ExecutionOutcome object with the created bundle, receipts, requests, and
	// first_block
	let exec_res = ExecutionOutcome {
	bundle: Default::default(),
	receipts,
	requests: vec![],
	first_block,
	};
	// Get logs for block number 123
	let logs: Vec<&Log> = exec_res.logs(123).unwrap().collect();
	// Assert that the logs match the expected logs
	assert_eq!(logs, vec![&Log::<LogData>::default()]);
	}
	#[test]
	fn test_receipts_by_block() {
	// Create a Receipts object with a vector of receipt vectors
	let receipts = Receipts {
	receipt_vec: vec![vec![Some(Receipt {
	tx_type: TxType::Legacy,
	cumulative_gas_used: 46913,
	logs: vec![Log::<LogData>::default()],
	success: true,
	#[cfg(feature = "optimism")]
	deposit_nonce: Some(18),
	#[cfg(feature = "optimism")]
	deposit_receipt_version: Some(34),
	})]],
	};
	// Define the first block number
	let first_block = 123;
	// Create a ExecutionOutcome object with the created bundle, receipts, requests, and
	// first_block
	let exec_res = ExecutionOutcome {
	bundle: Default::default(), // Default value for bundle
	receipts, // Include the created receipts
	requests: vec![], // Empty vector for requests
	first_block, // Set the first block number
	};
	// Get receipts for block number 123 and convert the result into a vector
	let receipts_by_block: Vec<_> = exec_res.receipts_by_block(123).iter().collect();
	// Assert that the receipts for block number 123 match the expected receipts
	assert_eq!(
	receipts_by_block,
	vec![&Some(Receipt {
	tx_type: TxType::Legacy,
	cumulative_gas_used: 46913,
	logs: vec![Log::<LogData>::default()],
	success: true,
	#[cfg(feature = "optimism")]
	deposit_nonce: Some(18),
	#[cfg(feature = "optimism")]
	deposit_receipt_version: Some(34),
	})]
	);
	}
	#[test]
	fn test_receipts_len() {
	// Create a Receipts object with a vector of receipt vectors
	let receipts = Receipts {
	receipt_vec: vec![vec![Some(Receipt {
	tx_type: TxType::Legacy,
	cumulative_gas_used: 46913,
	logs: vec![Log::<LogData>::default()],
	success: true,
	#[cfg(feature = "optimism")]
	deposit_nonce: Some(18),
	#[cfg(feature = "optimism")]
	deposit_receipt_version: Some(34),
	})]],
	};
	// Create an empty Receipts object
	let receipts_empty = Receipts { receipt_vec: vec![] };
	// Define the first block number
	let first_block = 123;
	// Create a ExecutionOutcome object with the created bundle, receipts, requests, and
	// first_block
	let exec_res = ExecutionOutcome {
	bundle: Default::default(), // Default value for bundle
	receipts, // Include the created receipts
	requests: vec![], // Empty vector for requests
	first_block, // Set the first block number
	};
	// Assert that the length of receipts in exec_res is 1
	assert_eq!(exec_res.len(), 1);
	// Assert that exec_res is not empty
	assert!(!exec_res.is_empty());
	// Create a ExecutionOutcome object with an empty Receipts object
	let exec_res_empty_receipts = ExecutionOutcome {
	bundle: Default::default(), // Default value for bundle
	receipts: receipts_empty, // Include the empty receipts
	requests: vec![], // Empty vector for requests
	first_block, // Set the first block number
	};
	// Assert that the length of receipts in exec_res_empty_receipts is 0
	assert_eq!(exec_res_empty_receipts.len(), 0);
	// Assert that exec_res_empty_receipts is empty
	assert!(exec_res_empty_receipts.is_empty());
	}
	#[test]
	fn test_revert_to() {
	// Create a random receipt object
	let receipt = Receipt {
	tx_type: TxType::Legacy,
	cumulative_gas_used: 46913,
	logs: vec![],
	success: true,
	#[cfg(feature = "optimism")]
	deposit_nonce: Some(18),
	#[cfg(feature = "optimism")]
	deposit_receipt_version: Some(34),
	};
	// Create a Receipts object with a vector of receipt vectors
	let receipts = Receipts {
	receipt_vec: vec![vec![Some(receipt.clone())], vec![Some(receipt.clone())]],
	};
	// Define the first block number
	let first_block = 123;
	// Create a DepositRequest object with specific attributes.
	let request = Request::DepositRequest(DepositRequest {
	pubkey: FixedBytes::<48>::from([1; 48]),
	withdrawal_credentials: B256::from([0; 32]),
	amount: 1111,
	signature: FixedBytes::<96>::from([2; 96]),
	index: 222,
	});
	// Create a vector of Requests containing the request.
	let requests = vec![Requests(vec![request]), Requests(vec![request])];
	// Create a ExecutionOutcome object with the created bundle, receipts, requests, and
	// first_block
	let mut exec_res =
	ExecutionOutcome { bundle: Default::default(), receipts, requests, first_block };
	// Assert that the revert_to method returns true when reverting to the initial block number.
	assert!(exec_res.revert_to(123));
	// Assert that the receipts are properly cut after reverting to the initial block number.
	assert_eq!(exec_res.receipts, Receipts { receipt_vec: vec![vec![Some(receipt)]] });
	// Assert that the requests are properly cut after reverting to the initial block number.
	assert_eq!(exec_res.requests, vec![Requests(vec![request])]);
	// Assert that the revert_to method returns false when attempting to revert to a block
	// number greater than the initial block number.
	assert!(!exec_res.revert_to(133));
	// Assert that the revert_to method returns false when attempting to revert to a block
	// number less than the initial block number.
	assert!(!exec_res.revert_to(10));
	}
	#[test]
	fn test_extend_execution_outcome() {
	// Create a Receipt object with specific attributes.
	let receipt = Receipt {
	tx_type: TxType::Legacy,
	cumulative_gas_used: 46913,
	logs: vec![],
	success: true,
	#[cfg(feature = "optimism")]
	deposit_nonce: Some(18),
	#[cfg(feature = "optimism")]
	deposit_receipt_version: Some(34),
	};
	// Create a Receipts object containing the receipt.
	let receipts = Receipts { receipt_vec: vec![vec![Some(receipt.clone())]] };
	// Create a DepositRequest object with specific attributes.
	let request = Request::DepositRequest(DepositRequest {
	pubkey: FixedBytes::<48>::from([1; 48]),
	withdrawal_credentials: B256::from([0; 32]),
	amount: 1111,
	signature: FixedBytes::<96>::from([2; 96]),
	index: 222,
	});
	// Create a vector of Requests containing the request.
	let requests = vec![Requests(vec![request])];
	// Define the initial block number.
	let first_block = 123;
	// Create an ExecutionOutcome object.
	let mut exec_res =
	ExecutionOutcome { bundle: Default::default(), receipts, requests, first_block };
	// Extend the ExecutionOutcome object by itself.
	exec_res.extend(exec_res.clone());
	// Assert the extended ExecutionOutcome matches the expected outcome.
	assert_eq!(
	exec_res,
	ExecutionOutcome {
	bundle: Default::default(),
	receipts: Receipts {
	receipt_vec: vec![vec![Some(receipt.clone())], vec![Some(receipt)]]
	},
	requests: vec![Requests(vec![request]), Requests(vec![request])],
	first_block: 123,
	}
	);
	}
	#[test]
	fn test_split_at_execution_outcome() {
	// Create a random receipt object
	let receipt = Receipt {
	tx_type: TxType::Legacy,
	cumulative_gas_used: 46913,
	logs: vec![],
	success: true,
	#[cfg(feature = "optimism")]
	deposit_nonce: Some(18),
	#[cfg(feature = "optimism")]
	deposit_receipt_version: Some(34),
	};
	// Create a Receipts object with a vector of receipt vectors
	let receipts = Receipts {
	receipt_vec: vec![
	vec![Some(receipt.clone())],
	vec![Some(receipt.clone())],
	vec![Some(receipt.clone())],
	],
	};
	// Define the first block number
	let first_block = 123;
	// Create a DepositRequest object with specific attributes.
	let request = Request::DepositRequest(DepositRequest {
	pubkey: FixedBytes::<48>::from([1; 48]),
	withdrawal_credentials: B256::from([0; 32]),
	amount: 1111,
	signature: FixedBytes::<96>::from([2; 96]),
	index: 222,
	});
	// Create a vector of Requests containing the request.
	let requests =
	vec![Requests(vec![request]), Requests(vec![request]), Requests(vec![request])];
	// Create a ExecutionOutcome object with the created bundle, receipts, requests, and
	// first_block
	let exec_res =
	ExecutionOutcome { bundle: Default::default(), receipts, requests, first_block };
	// Split the ExecutionOutcome at block number 124
	let result = exec_res.clone().split_at(124);
	// Define the expected lower ExecutionOutcome after splitting
	let lower_execution_outcome = ExecutionOutcome {
	bundle: Default::default(),
	receipts: Receipts { receipt_vec: vec![vec![Some(receipt.clone())]] },
	requests: vec![Requests(vec![request])],
	first_block,
	};
	// Define the expected higher ExecutionOutcome after splitting
	let higher_execution_outcome = ExecutionOutcome {
	bundle: Default::default(),
	receipts: Receipts {
	receipt_vec: vec![vec![Some(receipt.clone())], vec![Some(receipt)]],
	},
	requests: vec![Requests(vec![request]), Requests(vec![request])],
	first_block: 124,
	};
	// Assert that the split result matches the expected lower and higher outcomes
	assert_eq!(result.0, Some(lower_execution_outcome));
	assert_eq!(result.1, higher_execution_outcome);
	// Assert that splitting at the first block number returns None for the lower outcome
	assert_eq!(exec_res.clone().split_at(123), (None, exec_res));
	}
	#[test]
	fn test_changed_accounts() {
	// Set up some sample accounts
	let address1 = Address::random();
	let address2 = Address::random();
	let address3 = Address::random();
	// Set up account info with some changes
	let account_info1 =
	AccountInfo { nonce: 1, balance: U256::from(100), code_hash: B256::ZERO, code: None };
	let account_info2 =
	AccountInfo { nonce: 2, balance: U256::from(200), code_hash: B256::ZERO, code: None };
	// Set up the bundle state with these accounts
	let mut bundle_state = BundleState::default();
	bundle_state.state.insert(
	address1,
	BundleAccount {
	info: Some(account_info1),
	storage: Default::default(),
	original_info: Default::default(),
	status: Default::default(),
	},
	);
	bundle_state.state.insert(
	address2,
	BundleAccount {
	info: Some(account_info2),
	storage: Default::default(),
	original_info: Default::default(),
	status: Default::default(),
	},
	);
	// Unchanged account
	bundle_state.state.insert(
	address3,
	BundleAccount {
	info: None,
	storage: Default::default(),
	original_info: Default::default(),
	status: Default::default(),
	},
	);
	let execution_outcome = ExecutionOutcome {
	bundle: bundle_state,
	receipts: Receipts::default(),
	first_block: 0,
	requests: vec![],
	};
	// Get the changed accounts
	let changed_accounts: Vec<ChangedAccount> = execution_outcome.changed_accounts().collect();
	// Assert that the changed accounts match the expected ones
	assert_eq!(changed_accounts.len(), 2);
	assert!(changed_accounts.contains(&ChangedAccount {
	address: address1,
	nonce: 1,
	balance: U256::from(100)
	}));
	assert!(changed_accounts.contains(&ChangedAccount {
	address: address2,
	nonce: 2,
	balance: U256::from(200)
	}));
	}
	}

Additional context

No response

[Parikalp-Bhardwaj]

hi @emhane, assign me