Pass all Shanghai and Cancun tests (#378)

* Several fixes for create initcode limit

* Move initcode check earlier to the call

* Pass all Shanghai tests

* Run cargo fmt

* Add missing ExpectException type

* EIP-7516 blob base fee

* EIP-4844 initial support

* Add KZGPointEvaluation precompile

* Pass all Cancun tests

* Add all static config pointers

* Cargo fmt

Author: sorpaas

future/tests/usability.rs

@@ -61,6 +61,12 @@ impl RuntimeEnvironment for UnimplementedHandler {
 	fn block_base_fee_per_gas(&self) -> U256 {
 		unimplemented!()
 	}
+	fn blob_base_fee_per_gas(&self) -> U256 {
+		unimplemented!()
+	}
+	fn blob_versioned_hash(&self, _index: U256) -> H256 {
+		unimplemented!()
+	}
 	fn chain_id(&self) -> U256 {
 		unimplemented!()
 	}

fuzz/src/backend.rs

@@ -104,6 +104,14 @@ impl RuntimeEnvironment for MockBackend {
 		Default::default()
 	}
 
+	fn blob_base_fee_per_gas(&self) -> U256 {
+		Default::default()
+	}
+
+	fn blob_versioned_hash(&self, _index: U256) -> H256 {
+		Default::default()
+	}
+
 	fn chain_id(&self) -> U256 {
 		Default::default()
 	}

interpreter/src/etable.rs

@@ -432,6 +432,8 @@ where
 		table.0[Opcode::CHAINID.as_usize()] = eval_chainid as _;
 		table.0[Opcode::SELFBALANCE.as_usize()] = eval_selfbalance as _;
 		table.0[Opcode::BASEFEE.as_usize()] = eval_basefee as _;
+		table.0[Opcode::BLOBHASH.as_usize()] = eval_blobhash as _;
+		table.0[Opcode::BLOBBASEFEE.as_usize()] = eval_blobbasefee as _;
 
 		table.0[Opcode::SLOAD.as_usize()] = eval_sload as _;
 		table.0[Opcode::SSTORE.as_usize()] = eval_sstore as _;

interpreter/src/eval/mod.rs

@@ -660,6 +660,24 @@ pub fn eval_gaslimit<S: AsRef<RuntimeState>, H: RuntimeEnvironment + RuntimeBack
 	self::system::gaslimit(machine, handle)
 }
 
+/// `BLOBHASH`
+pub fn eval_blobhash<S: AsRef<RuntimeState>, H: RuntimeEnvironment + RuntimeBackend, Tr>(
+	machine: &mut Machine<S>,
+	handle: &mut H,
+	_position: usize,
+) -> Control<Tr> {
+	self::system::blobhash(machine, handle)
+}
+
+/// `BLOBBASEFEE`
+pub fn eval_blobbasefee<S: AsRef<RuntimeState>, H: RuntimeEnvironment + RuntimeBackend, Tr>(
+	machine: &mut Machine<S>,
+	handle: &mut H,
+	_position: usize,
+) -> Control<Tr> {
+	self::system::blobbasefee(machine, handle)
+}
+
 /// `SLOAD`
 pub fn eval_sload<S: AsRef<RuntimeState>, H: RuntimeEnvironment + RuntimeBackend, Tr>(
 	machine: &mut Machine<S>,
@@ -935,6 +953,8 @@ where
 		Opcode::CHAINID => eval_chainid(machine, handle, position),
 		Opcode::SELFBALANCE => eval_selfbalance(machine, handle, position),
 		Opcode::BASEFEE => eval_basefee(machine, handle, position),
+		Opcode::BLOBHASH => eval_blobhash(machine, handle, position),
+		Opcode::BLOBBASEFEE => eval_blobbasefee(machine, handle, position),
 
 		Opcode::SLOAD => eval_sload(machine, handle, position),
 		Opcode::SSTORE => eval_sstore(machine, handle, position),

interpreter/src/eval/system.rs

@@ -124,6 +124,27 @@ pub fn basefee<S: AsRef<RuntimeState>, H: RuntimeEnvironment + RuntimeBackend, T
 	Control::Continue(1)
 }
 
+pub fn blobhash<S: AsRef<RuntimeState>, H: RuntimeEnvironment + RuntimeBackend, Tr>(
+	machine: &mut Machine<S>,
+	handler: &H,
+) -> Control<Tr> {
+	pop_u256!(machine, index);
+	let hash = handler.blob_versioned_hash(index);
+	push_h256!(machine, hash);
+
+	Control::Continue(1)
+}
+
+pub fn blobbasefee<S: AsRef<RuntimeState>, H: RuntimeEnvironment + RuntimeBackend, Tr>(
+	machine: &mut Machine<S>,
+	handler: &H,
+) -> Control<Tr> {
+	let blob_basefee = handler.blob_base_fee_per_gas();
+	push_u256!(machine, blob_basefee);
+
+	Control::Continue(1)
+}
+
 pub fn extcodesize<S: AsRef<RuntimeState>, H: RuntimeEnvironment + RuntimeBackend, Tr>(
 	machine: &mut Machine<S>,
 	handler: &mut H,

interpreter/src/opcode.rs

@@ -291,6 +291,10 @@ impl Opcode {
 	pub const SELFBALANCE: Opcode = Opcode(0x47);
 	/// `BASEFEE`
 	pub const BASEFEE: Opcode = Opcode(0x48);
+	/// `BLOBHASH`
+	pub const BLOBHASH: Opcode = Opcode(0x49);
+	/// `BLOBBASEFEE`
+	pub const BLOBBASEFEE: Opcode = Opcode(0x4a);
 
 	/// `SLOAD`
 	pub const SLOAD: Opcode = Opcode(0x54);

interpreter/src/runtime.rs

@@ -199,6 +199,10 @@ pub trait RuntimeEnvironment {
 	fn block_gas_limit(&self) -> U256;
 	/// Environmental block base fee.
 	fn block_base_fee_per_gas(&self) -> U256;
+	/// Blob hash.
+	fn blob_versioned_hash(&self, index: U256) -> H256;
+	/// Blob base fee per gas.
+	fn blob_base_fee_per_gas(&self) -> U256;
 	/// Get environmental chain ID.
 	fn chain_id(&self) -> U256;
 }

interpreter/tests/usability.rs

@@ -92,6 +92,12 @@ impl RuntimeEnvironment for UnimplementedHandler {
 	fn block_base_fee_per_gas(&self) -> U256 {
 		unimplemented!()
 	}
+	fn blob_base_fee_per_gas(&self) -> U256 {
+		unimplemented!()
+	}
+	fn blob_versioned_hash(&self, _index: U256) -> H256 {
+		unimplemented!()
+	}
 	fn chain_id(&self) -> U256 {
 		unimplemented!()
 	}

jsontests/src/error.rs

@@ -1,10 +1,12 @@
+use crate::types::TestExpectException;
+
 #[derive(Debug, thiserror::Error)]
 #[allow(dead_code)]
 pub enum TestError {
 	#[error("state root is different")]
 	StateMismatch,
 	#[error("expect error, but got okay")]
-	ExpectException,
+	ExpectException(TestExpectException),
 	#[error("unexpected decoding error")]
 	UnexpectedDecoding,
 }

jsontests/src/run.rs

@@ -188,6 +188,8 @@ pub fn run_test(
 		Fork::Istanbul => Config::istanbul(),
 		Fork::Berlin => Config::berlin(),
 		Fork::London => Config::london(),
+		Fork::Shanghai => Config::shanghai(),
+		Fork::Cancun => Config::cancun(),
 		_ => return Err(Error::UnsupportedFork),
 	};
 	config_change(&mut config);
@@ -206,10 +208,21 @@ pub fn run_test(
 		Some(TestExpectException::TR_NoFunds) => return Ok(()),
 		Some(TestExpectException::TR_GasLimitReached) => return Ok(()),
 		Some(TestExpectException::TR_TipGtFeeCap) => return Ok(()),
+		Some(TestExpectException::TE_TYPE_3_TX_PRE_FORK) => return Ok(()),
+		Some(TestExpectException::TE_TYPE_3_TX_PRE_FORK_OR_TX_ZERO_BLOBS) => return Ok(()),
+		Some(TestExpectException::TE_TYPE_3_TX_BLOB_COUNT_EXCEEDED) => return Ok(()),
+		Some(TestExpectException::TE_INSUFFICIENT_ACCOUNT_FUNDS) => return Ok(()),
 
 		_ => (),
 	}
 
+	if test.transaction.blob_versioned_hashes.is_some() {
+		// Rust EVM doesn't deal directly with transactions. Currently we expect
+		// users of Rust EVM to deduct blob costs themselves for TYPE 3
+		// transactions, but this may change in the future.
+		return Ok(());
+	}
+
 	let env = InMemoryEnvironment {
 		block_hashes: {
 			let mut block_hashes = BTreeMap::new();
@@ -229,6 +242,12 @@ pub fn run_test(
 		block_randomness: test.env.current_random,
 		block_gas_limit: test.env.current_gas_limit,
 		block_base_fee_per_gas: test.env.current_base_fee.unwrap_or_default(),
+		blob_base_fee_per_gas: U256::zero(),
+		blob_versioned_hashes: test
+			.transaction
+			.blob_versioned_hashes
+			.clone()
+			.unwrap_or_default(),
 		chain_id: U256::one(),
 	};
 
@@ -366,11 +385,11 @@ pub fn run_test(
 
 	let state_root = crate::hash::state_root(&run_backend);
 
-	if test.post.expect_exception.is_some() {
+	if let Some(expect_exception) = test.post.expect_exception {
 		if run_result.is_err() {
 			return Ok(());
 		} else {
-			return Err(TestError::ExpectException.into());
+			return Err(TestError::ExpectException(expect_exception).into());
 		}
 	}
 
@@ -421,6 +440,7 @@ pub fn run_test(
 							to: test.transaction.to,
 							value: vec![test.transaction.value],
 							access_lists: Some(vec![Some(test.transaction.access_list)]),
+							blob_versioned_hashes: test.transaction.blob_versioned_hashes,
 						},
 					},
 				);