refactor(examples): Rename CustomTxEnv => PaymentTxEnv and CustomEvmTransaction => CustomTxEnv (#16443)

RomanHodulak · web-flow · commit 2b33b59ed8db · 2025-05-23T16:04:32.000Z
diff --git a/examples/custom-node/src/evm/alloy.rs b/examples/custom-node/src/evm/alloy.rs
@@ -1,4 +1,4 @@
-use crate::evm::{CustomEvmTransaction, CustomTxEnv};
+use crate::evm::{CustomTxEnv, PaymentTxEnv};
 use alloy_evm::{precompiles::PrecompilesMap, Database, Evm, EvmEnv, EvmFactory};
 use alloy_op_evm::{OpEvm, OpEvmFactory};
 use alloy_primitives::{Address, Bytes};
@@ -15,9 +15,9 @@ use reth_ethereum::evm::revm::{
 use revm::{context_interface::result::EVMError, inspector::NoOpInspector};
 use std::error::Error;
 
-/// EVM context contains data that EVM needs for execution of [`CustomEvmTransaction`].
+/// EVM context contains data that EVM needs for execution of [`CustomTxEnv`].
 pub type CustomContext<DB> =
-    Context<BlockEnv, OpTransaction<CustomTxEnv>, CfgEnv<OpSpecId>, DB, Journal<DB>, L1BlockInfo>;
+    Context<BlockEnv, OpTransaction<PaymentTxEnv>, CfgEnv<OpSpecId>, DB, Journal<DB>, L1BlockInfo>;
 
 pub struct CustomEvm<DB: Database, I, P = OpPrecompiles> {
     inner: OpEvm<DB, I, P>,
@@ -36,7 +36,7 @@ where
     P: PrecompileProvider<OpContext<DB>, Output = InterpreterResult>,
 {
     type DB = DB;
-    type Tx = CustomEvmTransaction;
+    type Tx = CustomTxEnv;
     type Error = EVMError<DB::Error, OpTransactionError>;
     type HaltReason = OpHaltReason;
     type Spec = OpSpecId;
@@ -56,8 +56,8 @@ where
         tx: Self::Tx,
     ) -> Result<ResultAndState<Self::HaltReason>, Self::Error> {
         match tx {
-            CustomEvmTransaction::Op(tx) => self.inner.transact_raw(tx),
-            CustomEvmTransaction::Payment(..) => todo!(),
+            CustomTxEnv::Op(tx) => self.inner.transact_raw(tx),
+            CustomTxEnv::Payment(..) => todo!(),
         }
     }
 
@@ -105,7 +105,7 @@ pub struct CustomEvmFactory(pub OpEvmFactory);
 impl EvmFactory for CustomEvmFactory {
     type Evm<DB: Database, I: Inspector<OpContext<DB>>> = CustomEvm<DB, I, Self::Precompiles>;
     type Context<DB: Database> = OpContext<DB>;
-    type Tx = CustomEvmTransaction;
+    type Tx = CustomTxEnv;
     type Error<DBError: Error + Send + Sync + 'static> = EVMError<DBError, OpTransactionError>;
     type HaltReason = OpHaltReason;
     type Spec = OpSpecId;
diff --git a/examples/custom-node/src/evm/env.rs b/examples/custom-node/src/evm/env.rs
@@ -6,24 +6,23 @@ use op_alloy_consensus::OpTxEnvelope;
 use op_revm::OpTransaction;
 use reth_ethereum::evm::{primitives::TransactionEnv, revm::context::TxEnv};
 
-/// An Optimism extended Ethereum transaction that can be fed to [`Evm`] because it contains
-/// [`CustomTxEnv`].
+/// An Optimism transaction extended by [`PaymentTxEnv`] that can be fed to [`Evm`].
 ///
 /// [`Evm`]: alloy_evm::Evm
 #[derive(Clone, Debug)]
-pub enum CustomEvmTransaction {
+pub enum CustomTxEnv {
     Op(OpTransaction<TxEnv>),
-    Payment(CustomTxEnv),
+    Payment(PaymentTxEnv),
 }
 
 /// A transaction environment is a set of information related to an Ethereum transaction that can be
 /// fed to [`Evm`] for execution.
 ///
 /// [`Evm`]: alloy_evm::Evm
 #[derive(Clone, Debug, Default)]
-pub struct CustomTxEnv(pub TxEnv);
+pub struct PaymentTxEnv(pub TxEnv);
 
-impl revm::context::Transaction for CustomEvmTransaction {
+impl revm::context::Transaction for CustomTxEnv {
     type AccessListItem<'a>
         = <TxEnv as revm::context::Transaction>::AccessListItem<'a>
     where
@@ -35,111 +34,111 @@ impl revm::context::Transaction for CustomEvmTransaction {
 
     fn tx_type(&self) -> u8 {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.tx_type(),
-            CustomEvmTransaction::Payment(tx) => tx.tx_type(),
+            Self::Op(tx) => tx.tx_type(),
+            Self::Payment(tx) => tx.tx_type(),
         }
     }
 
     fn caller(&self) -> Address {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.caller(),
-            CustomEvmTransaction::Payment(tx) => tx.caller(),
+            Self::Op(tx) => tx.caller(),
+            Self::Payment(tx) => tx.caller(),
         }
     }
 
     fn gas_limit(&self) -> u64 {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.gas_limit(),
-            CustomEvmTransaction::Payment(tx) => tx.gas_limit(),
+            Self::Op(tx) => tx.gas_limit(),
+            Self::Payment(tx) => tx.gas_limit(),
         }
     }
 
     fn value(&self) -> U256 {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.value(),
-            CustomEvmTransaction::Payment(tx) => tx.value(),
+            Self::Op(tx) => tx.value(),
+            Self::Payment(tx) => tx.value(),
         }
     }
 
     fn input(&self) -> &Bytes {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.input(),
-            CustomEvmTransaction::Payment(tx) => tx.input(),
+            Self::Op(tx) => tx.input(),
+            Self::Payment(tx) => tx.input(),
         }
     }
 
     fn nonce(&self) -> u64 {
         match self {
-            CustomEvmTransaction::Op(tx) => revm::context::Transaction::nonce(tx),
-            CustomEvmTransaction::Payment(tx) => revm::context::Transaction::nonce(tx),
+            Self::Op(tx) => revm::context::Transaction::nonce(tx),
+            Self::Payment(tx) => revm::context::Transaction::nonce(tx),
         }
     }
 
     fn kind(&self) -> TxKind {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.kind(),
-            CustomEvmTransaction::Payment(tx) => tx.kind(),
+            Self::Op(tx) => tx.kind(),
+            Self::Payment(tx) => tx.kind(),
         }
     }
 
     fn chain_id(&self) -> Option<u64> {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.chain_id(),
-            CustomEvmTransaction::Payment(tx) => tx.chain_id(),
+            Self::Op(tx) => tx.chain_id(),
+            Self::Payment(tx) => tx.chain_id(),
         }
     }
 
     fn gas_price(&self) -> u128 {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.gas_price(),
-            CustomEvmTransaction::Payment(tx) => tx.gas_price(),
+            Self::Op(tx) => tx.gas_price(),
+            Self::Payment(tx) => tx.gas_price(),
         }
     }
 
     fn access_list(&self) -> Option<impl Iterator<Item = Self::AccessListItem<'_>>> {
         Some(match self {
-            CustomEvmTransaction::Op(tx) => tx.base.access_list.iter(),
-            CustomEvmTransaction::Payment(tx) => tx.0.access_list.iter(),
+            Self::Op(tx) => tx.base.access_list.iter(),
+            Self::Payment(tx) => tx.0.access_list.iter(),
         })
     }
 
     fn blob_versioned_hashes(&self) -> &[B256] {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.blob_versioned_hashes(),
-            CustomEvmTransaction::Payment(tx) => tx.blob_versioned_hashes(),
+            Self::Op(tx) => tx.blob_versioned_hashes(),
+            Self::Payment(tx) => tx.blob_versioned_hashes(),
         }
     }
 
     fn max_fee_per_blob_gas(&self) -> u128 {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.max_fee_per_blob_gas(),
-            CustomEvmTransaction::Payment(tx) => tx.max_fee_per_blob_gas(),
+            Self::Op(tx) => tx.max_fee_per_blob_gas(),
+            Self::Payment(tx) => tx.max_fee_per_blob_gas(),
         }
     }
 
     fn authorization_list_len(&self) -> usize {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.authorization_list_len(),
-            CustomEvmTransaction::Payment(tx) => tx.authorization_list_len(),
+            Self::Op(tx) => tx.authorization_list_len(),
+            Self::Payment(tx) => tx.authorization_list_len(),
         }
     }
 
     fn authorization_list(&self) -> impl Iterator<Item = Self::Authorization<'_>> {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.base.authorization_list.iter(),
-            CustomEvmTransaction::Payment(tx) => tx.0.authorization_list.iter(),
+            Self::Op(tx) => tx.base.authorization_list.iter(),
+            Self::Payment(tx) => tx.0.authorization_list.iter(),
         }
     }
 
     fn max_priority_fee_per_gas(&self) -> Option<u128> {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.max_priority_fee_per_gas(),
-            CustomEvmTransaction::Payment(tx) => tx.max_priority_fee_per_gas(),
+            Self::Op(tx) => tx.max_priority_fee_per_gas(),
+            Self::Payment(tx) => tx.max_priority_fee_per_gas(),
         }
     }
 }
 
-impl revm::context::Transaction for CustomTxEnv {
+impl revm::context::Transaction for PaymentTxEnv {
     type AccessListItem<'a>
         = <TxEnv as revm::context::Transaction>::AccessListItem<'a>
     where
@@ -210,7 +209,7 @@ impl revm::context::Transaction for CustomTxEnv {
     }
 }
 
-impl TransactionEnv for CustomTxEnv {
+impl TransactionEnv for PaymentTxEnv {
     fn set_gas_limit(&mut self, gas_limit: u64) {
         self.0.set_gas_limit(gas_limit);
     }
@@ -228,39 +227,39 @@ impl TransactionEnv for CustomTxEnv {
     }
 }
 
-impl TransactionEnv for CustomEvmTransaction {
+impl TransactionEnv for CustomTxEnv {
     fn set_gas_limit(&mut self, gas_limit: u64) {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.set_gas_limit(gas_limit),
-            CustomEvmTransaction::Payment(tx) => tx.set_gas_limit(gas_limit),
+            Self::Op(tx) => tx.set_gas_limit(gas_limit),
+            Self::Payment(tx) => tx.set_gas_limit(gas_limit),
         }
     }
 
     fn nonce(&self) -> u64 {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.nonce(),
-            CustomEvmTransaction::Payment(tx) => tx.nonce(),
+            Self::Op(tx) => tx.nonce(),
+            Self::Payment(tx) => tx.nonce(),
         }
     }
 
     fn set_nonce(&mut self, nonce: u64) {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.set_nonce(nonce),
-            CustomEvmTransaction::Payment(tx) => tx.set_nonce(nonce),
+            Self::Op(tx) => tx.set_nonce(nonce),
+            Self::Payment(tx) => tx.set_nonce(nonce),
         }
     }
 
     fn set_access_list(&mut self, access_list: AccessList) {
         match self {
-            CustomEvmTransaction::Op(tx) => tx.set_access_list(access_list),
-            CustomEvmTransaction::Payment(tx) => tx.set_access_list(access_list),
+            Self::Op(tx) => tx.set_access_list(access_list),
+            Self::Payment(tx) => tx.set_access_list(access_list),
         }
     }
 }
 
-impl FromRecoveredTx<CustomTransaction> for CustomTxEnv {
+impl FromRecoveredTx<CustomTransaction> for PaymentTxEnv {
     fn from_recovered_tx(tx: &CustomTransaction, sender: Address) -> Self {
-        CustomTxEnv(match tx {
+        PaymentTxEnv(match tx {
             CustomTransaction::BuiltIn(tx) => {
                 OpTransaction::<TxEnv>::from_recovered_tx(tx, sender).base
             }
@@ -269,9 +268,9 @@ impl FromRecoveredTx<CustomTransaction> for CustomTxEnv {
     }
 }
 
-impl FromTxWithEncoded<CustomTransaction> for CustomTxEnv {
+impl FromTxWithEncoded<CustomTransaction> for PaymentTxEnv {
     fn from_encoded_tx(tx: &CustomTransaction, sender: Address, encoded: Bytes) -> Self {
-        CustomTxEnv(match tx {
+        PaymentTxEnv(match tx {
             CustomTransaction::BuiltIn(tx) => {
                 OpTransaction::<TxEnv>::from_encoded_tx(tx, sender, encoded).base
             }
@@ -318,41 +317,41 @@ impl FromTxWithEncoded<CustomTransactionEnvelope> for TxEnv {
     }
 }
 
-impl FromRecoveredTx<OpTxEnvelope> for CustomEvmTransaction {
+impl FromRecoveredTx<OpTxEnvelope> for CustomTxEnv {
     fn from_recovered_tx(tx: &OpTxEnvelope, sender: Address) -> Self {
         Self::Op(OpTransaction::from_recovered_tx(tx, sender))
     }
 }
 
-impl FromTxWithEncoded<OpTxEnvelope> for CustomEvmTransaction {
+impl FromTxWithEncoded<OpTxEnvelope> for CustomTxEnv {
     fn from_encoded_tx(tx: &OpTxEnvelope, sender: Address, encoded: Bytes) -> Self {
         Self::Op(OpTransaction::from_encoded_tx(tx, sender, encoded))
     }
 }
 
-impl FromRecoveredTx<CustomTransaction> for CustomEvmTransaction {
+impl FromRecoveredTx<CustomTransaction> for CustomTxEnv {
     fn from_recovered_tx(tx: &CustomTransaction, sender: Address) -> Self {
         match tx {
             CustomTransaction::BuiltIn(tx) => Self::from_recovered_tx(tx, sender),
             CustomTransaction::Other(tx) => {
-                Self::Payment(CustomTxEnv(TxEnv::from_recovered_tx(tx, sender)))
+                Self::Payment(PaymentTxEnv(TxEnv::from_recovered_tx(tx, sender)))
             }
         }
     }
 }
 
-impl FromTxWithEncoded<CustomTransaction> for CustomEvmTransaction {
+impl FromTxWithEncoded<CustomTransaction> for CustomTxEnv {
     fn from_encoded_tx(tx: &CustomTransaction, sender: Address, encoded: Bytes) -> Self {
         match tx {
             CustomTransaction::BuiltIn(tx) => Self::from_encoded_tx(tx, sender, encoded),
             CustomTransaction::Other(tx) => {
-                Self::Payment(CustomTxEnv(TxEnv::from_encoded_tx(tx, sender, encoded)))
+                Self::Payment(PaymentTxEnv(TxEnv::from_encoded_tx(tx, sender, encoded)))
             }
         }
     }
 }
 
-impl IntoTxEnv<Self> for CustomEvmTransaction {
+impl IntoTxEnv<Self> for CustomTxEnv {
     fn into_tx_env(self) -> Self {
         self
     }
diff --git a/examples/custom-node/src/evm/executor.rs b/examples/custom-node/src/evm/executor.rs
@@ -1,7 +1,7 @@
 use crate::{
     evm::{
         alloy::{CustomEvm, CustomEvmFactory},
-        CustomEvmConfig, CustomEvmTransaction,
+        CustomEvmConfig, CustomTxEnv,
     },
     primitives::CustomTransaction,
 };
@@ -27,7 +27,7 @@ pub struct CustomBlockExecutor<Evm> {
 impl<'db, DB, E> BlockExecutor for CustomBlockExecutor<E>
 where
     DB: Database + 'db,
-    E: Evm<DB = &'db mut State<DB>, Tx = CustomEvmTransaction>,
+    E: Evm<DB = &'db mut State<DB>, Tx = CustomTxEnv>,
 {
     type Transaction = CustomTransaction;
     type Receipt = OpReceipt;
diff --git a/examples/custom-node/src/evm/mod.rs b/examples/custom-node/src/evm/mod.rs
@@ -7,5 +7,5 @@ mod executor;
 pub use alloy::{CustomContext, CustomEvm};
 pub use assembler::CustomBlockAssembler;
 pub use config::CustomEvmConfig;
-pub use env::{CustomEvmTransaction, CustomTxEnv};
+pub use env::{CustomTxEnv, PaymentTxEnv};
 pub use executor::CustomBlockExecutor;

Original file line number	Diff line number	Diff line change
`@@ -6,24 +6,23 @@ use op_alloy_consensus::OpTxEnvelope;`
`6`	`6`	`use op_revm::OpTransaction;`
`7`	`7`	`use reth_ethereum::evm::{primitives::TransactionEnv, revm::context::TxEnv};`
`8`	`8`
`9`		-/// An Optimism extended Ethereum transaction that can be fed to [`Evm`] because it contains
`10`		-/// [`CustomTxEnv`].
	`9`	+/// An Optimism transaction extended by [`PaymentTxEnv`] that can be fed to [`Evm`].
`11`	`10`	`///`
`12`	`11`	/// [`Evm`]: alloy_evm::Evm
`13`	`12`	`#[derive(Clone, Debug)]`
`14`		`-pub enum CustomEvmTransaction {`
	`13`	`+pub enum CustomTxEnv {`
`15`	`14`	`Op(OpTransaction<TxEnv>),`
`16`		`- Payment(CustomTxEnv),`
	`15`	`+ Payment(PaymentTxEnv),`
`17`	`16`	`}`
`18`	`17`
`19`	`18`	`/// A transaction environment is a set of information related to an Ethereum transaction that can be`
`20`	`19`	/// fed to [`Evm`] for execution.
`21`	`20`	`///`
`22`	`21`	/// [`Evm`]: alloy_evm::Evm
`23`	`22`	`#[derive(Clone, Debug, Default)]`
`24`		`-pub struct CustomTxEnv(pub TxEnv);`
	`23`	`+pub struct PaymentTxEnv(pub TxEnv);`
`25`	`24`
`26`		`-impl revm::context::Transaction for CustomEvmTransaction {`
	`25`	`+impl revm::context::Transaction for CustomTxEnv {`
`27`	`26`	`type AccessListItem<'a>`
`28`	`27`	`= <TxEnv as revm::context::Transaction>::AccessListItem<'a>`
`29`	`28`	`where`
`@@ -35,111 +34,111 @@ impl revm::context::Transaction for CustomEvmTransaction {`
`35`	`34`
`36`	`35`	`fn tx_type(&self) -> u8 {`
`37`	`36`	`match self {`
`38`		`- CustomEvmTransaction::Op(tx) => tx.tx_type(),`
`39`		`- CustomEvmTransaction::Payment(tx) => tx.tx_type(),`
	`37`	`+ Self::Op(tx) => tx.tx_type(),`
	`38`	`+ Self::Payment(tx) => tx.tx_type(),`
`40`	`39`	`}`
`41`	`40`	`}`
`42`	`41`
`43`	`42`	`fn caller(&self) -> Address {`
`44`	`43`	`match self {`
`45`		`- CustomEvmTransaction::Op(tx) => tx.caller(),`
`46`		`- CustomEvmTransaction::Payment(tx) => tx.caller(),`
	`44`	`+ Self::Op(tx) => tx.caller(),`
	`45`	`+ Self::Payment(tx) => tx.caller(),`
`47`	`46`	`}`
`48`	`47`	`}`
`49`	`48`
`50`	`49`	`fn gas_limit(&self) -> u64 {`
`51`	`50`	`match self {`
`52`		`- CustomEvmTransaction::Op(tx) => tx.gas_limit(),`
`53`		`- CustomEvmTransaction::Payment(tx) => tx.gas_limit(),`
	`51`	`+ Self::Op(tx) => tx.gas_limit(),`
	`52`	`+ Self::Payment(tx) => tx.gas_limit(),`
`54`	`53`	`}`
`55`	`54`	`}`
`56`	`55`
`57`	`56`	`fn value(&self) -> U256 {`
`58`	`57`	`match self {`
`59`		`- CustomEvmTransaction::Op(tx) => tx.value(),`
`60`		`- CustomEvmTransaction::Payment(tx) => tx.value(),`
	`58`	`+ Self::Op(tx) => tx.value(),`
	`59`	`+ Self::Payment(tx) => tx.value(),`
`61`	`60`	`}`
`62`	`61`	`}`
`63`	`62`
`64`	`63`	`fn input(&self) -> &Bytes {`
`65`	`64`	`match self {`
`66`		`- CustomEvmTransaction::Op(tx) => tx.input(),`
`67`		`- CustomEvmTransaction::Payment(tx) => tx.input(),`
	`65`	`+ Self::Op(tx) => tx.input(),`
	`66`	`+ Self::Payment(tx) => tx.input(),`
`68`	`67`	`}`
`69`	`68`	`}`
`70`	`69`
`71`	`70`	`fn nonce(&self) -> u64 {`
`72`	`71`	`match self {`
`73`		`- CustomEvmTransaction::Op(tx) => revm::context::Transaction::nonce(tx),`
`74`		`- CustomEvmTransaction::Payment(tx) => revm::context::Transaction::nonce(tx),`
	`72`	`+ Self::Op(tx) => revm::context::Transaction::nonce(tx),`
	`73`	`+ Self::Payment(tx) => revm::context::Transaction::nonce(tx),`
`75`	`74`	`}`
`76`	`75`	`}`
`77`	`76`
`78`	`77`	`fn kind(&self) -> TxKind {`
`79`	`78`	`match self {`
`80`		`- CustomEvmTransaction::Op(tx) => tx.kind(),`
`81`		`- CustomEvmTransaction::Payment(tx) => tx.kind(),`
	`79`	`+ Self::Op(tx) => tx.kind(),`
	`80`	`+ Self::Payment(tx) => tx.kind(),`
`82`	`81`	`}`
`83`	`82`	`}`
`84`	`83`
`85`	`84`	`fn chain_id(&self) -> Option<u64> {`
`86`	`85`	`match self {`
`87`		`- CustomEvmTransaction::Op(tx) => tx.chain_id(),`
`88`		`- CustomEvmTransaction::Payment(tx) => tx.chain_id(),`
	`86`	`+ Self::Op(tx) => tx.chain_id(),`
	`87`	`+ Self::Payment(tx) => tx.chain_id(),`
`89`	`88`	`}`
`90`	`89`	`}`
`91`	`90`
`92`	`91`	`fn gas_price(&self) -> u128 {`
`93`	`92`	`match self {`
`94`		`- CustomEvmTransaction::Op(tx) => tx.gas_price(),`
`95`		`- CustomEvmTransaction::Payment(tx) => tx.gas_price(),`
	`93`	`+ Self::Op(tx) => tx.gas_price(),`
	`94`	`+ Self::Payment(tx) => tx.gas_price(),`
`96`	`95`	`}`
`97`	`96`	`}`
`98`	`97`
`99`	`98`	`fn access_list(&self) -> Option<impl Iterator<Item = Self::AccessListItem<'_>>> {`
`100`	`99`	`Some(match self {`
`101`		`- CustomEvmTransaction::Op(tx) => tx.base.access_list.iter(),`
`102`		`- CustomEvmTransaction::Payment(tx) => tx.0.access_list.iter(),`
	`100`	`+ Self::Op(tx) => tx.base.access_list.iter(),`
	`101`	`+ Self::Payment(tx) => tx.0.access_list.iter(),`
`103`	`102`	`})`
`104`	`103`	`}`
`105`	`104`
`106`	`105`	`fn blob_versioned_hashes(&self) -> &[B256] {`
`107`	`106`	`match self {`
`108`		`- CustomEvmTransaction::Op(tx) => tx.blob_versioned_hashes(),`
`109`		`- CustomEvmTransaction::Payment(tx) => tx.blob_versioned_hashes(),`
	`107`	`+ Self::Op(tx) => tx.blob_versioned_hashes(),`
	`108`	`+ Self::Payment(tx) => tx.blob_versioned_hashes(),`
`110`	`109`	`}`
`111`	`110`	`}`
`112`	`111`
`113`	`112`	`fn max_fee_per_blob_gas(&self) -> u128 {`
`114`	`113`	`match self {`
`115`		`- CustomEvmTransaction::Op(tx) => tx.max_fee_per_blob_gas(),`
`116`		`- CustomEvmTransaction::Payment(tx) => tx.max_fee_per_blob_gas(),`
	`114`	`+ Self::Op(tx) => tx.max_fee_per_blob_gas(),`
	`115`	`+ Self::Payment(tx) => tx.max_fee_per_blob_gas(),`
`117`	`116`	`}`
`118`	`117`	`}`
`119`	`118`
`120`	`119`	`fn authorization_list_len(&self) -> usize {`
`121`	`120`	`match self {`
`122`		`- CustomEvmTransaction::Op(tx) => tx.authorization_list_len(),`
`123`		`- CustomEvmTransaction::Payment(tx) => tx.authorization_list_len(),`
	`121`	`+ Self::Op(tx) => tx.authorization_list_len(),`
	`122`	`+ Self::Payment(tx) => tx.authorization_list_len(),`
`124`	`123`	`}`
`125`	`124`	`}`
`126`	`125`
`127`	`126`	`fn authorization_list(&self) -> impl Iterator<Item = Self::Authorization<'_>> {`
`128`	`127`	`match self {`
`129`		`- CustomEvmTransaction::Op(tx) => tx.base.authorization_list.iter(),`
`130`		`- CustomEvmTransaction::Payment(tx) => tx.0.authorization_list.iter(),`
	`128`	`+ Self::Op(tx) => tx.base.authorization_list.iter(),`
	`129`	`+ Self::Payment(tx) => tx.0.authorization_list.iter(),`
`131`	`130`	`}`
`132`	`131`	`}`
`133`	`132`
`134`	`133`	`fn max_priority_fee_per_gas(&self) -> Option<u128> {`
`135`	`134`	`match self {`
`136`		`- CustomEvmTransaction::Op(tx) => tx.max_priority_fee_per_gas(),`
`137`		`- CustomEvmTransaction::Payment(tx) => tx.max_priority_fee_per_gas(),`
	`135`	`+ Self::Op(tx) => tx.max_priority_fee_per_gas(),`
	`136`	`+ Self::Payment(tx) => tx.max_priority_fee_per_gas(),`
`138`	`137`	`}`
`139`	`138`	`}`
`140`	`139`	`}`
`141`	`140`
`142`		`-impl revm::context::Transaction for CustomTxEnv {`
	`141`	`+impl revm::context::Transaction for PaymentTxEnv {`
`143`	`142`	`type AccessListItem<'a>`
`144`	`143`	`= <TxEnv as revm::context::Transaction>::AccessListItem<'a>`
`145`	`144`	`where`
`@@ -210,7 +209,7 @@ impl revm::context::Transaction for CustomTxEnv {`
`210`	`209`	`}`
`211`	`210`	`}`
`212`	`211`
`213`		`-impl TransactionEnv for CustomTxEnv {`
	`212`	`+impl TransactionEnv for PaymentTxEnv {`
`214`	`213`	`fn set_gas_limit(&mut self, gas_limit: u64) {`
`215`	`214`	`self.0.set_gas_limit(gas_limit);`
`216`	`215`	`}`
`@@ -228,39 +227,39 @@ impl TransactionEnv for CustomTxEnv {`
`228`	`227`	`}`
`229`	`228`	`}`
`230`	`229`
`231`		`-impl TransactionEnv for CustomEvmTransaction {`
	`230`	`+impl TransactionEnv for CustomTxEnv {`
`232`	`231`	`fn set_gas_limit(&mut self, gas_limit: u64) {`
`233`	`232`	`match self {`
`234`		`- CustomEvmTransaction::Op(tx) => tx.set_gas_limit(gas_limit),`
`235`		`- CustomEvmTransaction::Payment(tx) => tx.set_gas_limit(gas_limit),`
	`233`	`+ Self::Op(tx) => tx.set_gas_limit(gas_limit),`
	`234`	`+ Self::Payment(tx) => tx.set_gas_limit(gas_limit),`
`236`	`235`	`}`
`237`	`236`	`}`
`238`	`237`
`239`	`238`	`fn nonce(&self) -> u64 {`
`240`	`239`	`match self {`
`241`		`- CustomEvmTransaction::Op(tx) => tx.nonce(),`
`242`		`- CustomEvmTransaction::Payment(tx) => tx.nonce(),`
	`240`	`+ Self::Op(tx) => tx.nonce(),`
	`241`	`+ Self::Payment(tx) => tx.nonce(),`
`243`	`242`	`}`
`244`	`243`	`}`
`245`	`244`
`246`	`245`	`fn set_nonce(&mut self, nonce: u64) {`
`247`	`246`	`match self {`
`248`		`- CustomEvmTransaction::Op(tx) => tx.set_nonce(nonce),`
`249`		`- CustomEvmTransaction::Payment(tx) => tx.set_nonce(nonce),`
	`247`	`+ Self::Op(tx) => tx.set_nonce(nonce),`
	`248`	`+ Self::Payment(tx) => tx.set_nonce(nonce),`
`250`	`249`	`}`
`251`	`250`	`}`
`252`	`251`
`253`	`252`	`fn set_access_list(&mut self, access_list: AccessList) {`
`254`	`253`	`match self {`
`255`		`- CustomEvmTransaction::Op(tx) => tx.set_access_list(access_list),`
`256`		`- CustomEvmTransaction::Payment(tx) => tx.set_access_list(access_list),`
	`254`	`+ Self::Op(tx) => tx.set_access_list(access_list),`
	`255`	`+ Self::Payment(tx) => tx.set_access_list(access_list),`
`257`	`256`	`}`
`258`	`257`	`}`
`259`	`258`	`}`
`260`	`259`
`261`		`-impl FromRecoveredTx<CustomTransaction> for CustomTxEnv {`
	`260`	`+impl FromRecoveredTx<CustomTransaction> for PaymentTxEnv {`
`262`	`261`	`fn from_recovered_tx(tx: &CustomTransaction, sender: Address) -> Self {`
`263`		`- CustomTxEnv(match tx {`
	`262`	`+ PaymentTxEnv(match tx {`
`264`	`263`	`CustomTransaction::BuiltIn(tx) => {`
`265`	`264`	`OpTransaction::<TxEnv>::from_recovered_tx(tx, sender).base`
`266`	`265`	`}`
`@@ -269,9 +268,9 @@ impl FromRecoveredTx<CustomTransaction> for CustomTxEnv {`
`269`	`268`	`}`
`270`	`269`	`}`
`271`	`270`
`272`		`-impl FromTxWithEncoded<CustomTransaction> for CustomTxEnv {`
	`271`	`+impl FromTxWithEncoded<CustomTransaction> for PaymentTxEnv {`
`273`	`272`	`fn from_encoded_tx(tx: &CustomTransaction, sender: Address, encoded: Bytes) -> Self {`
`274`		`- CustomTxEnv(match tx {`
	`273`	`+ PaymentTxEnv(match tx {`
`275`	`274`	`CustomTransaction::BuiltIn(tx) => {`
`276`	`275`	`OpTransaction::<TxEnv>::from_encoded_tx(tx, sender, encoded).base`
`277`	`276`	`}`
`@@ -318,41 +317,41 @@ impl FromTxWithEncoded<CustomTransactionEnvelope> for TxEnv {`
`318`	`317`	`}`
`319`	`318`	`}`
`320`	`319`
`321`		`-impl FromRecoveredTx<OpTxEnvelope> for CustomEvmTransaction {`
	`320`	`+impl FromRecoveredTx<OpTxEnvelope> for CustomTxEnv {`
`322`	`321`	`fn from_recovered_tx(tx: &OpTxEnvelope, sender: Address) -> Self {`
`323`	`322`	`Self::Op(OpTransaction::from_recovered_tx(tx, sender))`
`324`	`323`	`}`
`325`	`324`	`}`
`326`	`325`
`327`		`-impl FromTxWithEncoded<OpTxEnvelope> for CustomEvmTransaction {`
	`326`	`+impl FromTxWithEncoded<OpTxEnvelope> for CustomTxEnv {`
`328`	`327`	`fn from_encoded_tx(tx: &OpTxEnvelope, sender: Address, encoded: Bytes) -> Self {`
`329`	`328`	`Self::Op(OpTransaction::from_encoded_tx(tx, sender, encoded))`
`330`	`329`	`}`
`331`	`330`	`}`
`332`	`331`
`333`		`-impl FromRecoveredTx<CustomTransaction> for CustomEvmTransaction {`
	`332`	`+impl FromRecoveredTx<CustomTransaction> for CustomTxEnv {`
`334`	`333`	`fn from_recovered_tx(tx: &CustomTransaction, sender: Address) -> Self {`
`335`	`334`	`match tx {`
`336`	`335`	`CustomTransaction::BuiltIn(tx) => Self::from_recovered_tx(tx, sender),`
`337`	`336`	`CustomTransaction::Other(tx) => {`
`338`		`- Self::Payment(CustomTxEnv(TxEnv::from_recovered_tx(tx, sender)))`
	`337`	`+ Self::Payment(PaymentTxEnv(TxEnv::from_recovered_tx(tx, sender)))`
`339`	`338`	`}`
`340`	`339`	`}`
`341`	`340`	`}`
`342`	`341`	`}`
`343`	`342`
`344`		`-impl FromTxWithEncoded<CustomTransaction> for CustomEvmTransaction {`
	`343`	`+impl FromTxWithEncoded<CustomTransaction> for CustomTxEnv {`
`345`	`344`	`fn from_encoded_tx(tx: &CustomTransaction, sender: Address, encoded: Bytes) -> Self {`
`346`	`345`	`match tx {`
`347`	`346`	`CustomTransaction::BuiltIn(tx) => Self::from_encoded_tx(tx, sender, encoded),`
`348`	`347`	`CustomTransaction::Other(tx) => {`
`349`		`- Self::Payment(CustomTxEnv(TxEnv::from_encoded_tx(tx, sender, encoded)))`
	`348`	`+ Self::Payment(PaymentTxEnv(TxEnv::from_encoded_tx(tx, sender, encoded)))`
`350`	`349`	`}`
`351`	`350`	`}`
`352`	`351`	`}`
`353`	`352`	`}`
`354`	`353`
`355`		`-impl IntoTxEnv<Self> for CustomEvmTransaction {`
	`354`	`+impl IntoTxEnv<Self> for CustomTxEnv {`
`356`	`355`	`fn into_tx_env(self) -> Self {`
`357`	`356`	`self`
`358`	`357`	`}`