feat: use custom handlers to pay for gas with erc-20

Cargo.toml

@@ -32,6 +32,7 @@ members = [
     "examples/database_components",
     "examples/uniswap_get_reserves",
     "examples/uniswap_v2_usdc_swap",
+    "examples/erc20_gas",
     #"examples/custom_opcodes",
 ]
 resolver = "2"

examples/erc20_gas/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "example-erc20-gas"
+version = "0.0.0"
+publish = false
+authors.workspace = true
+edition.workspace = true
+keywords.workspace = true
+license.workspace = true
+repository.workspace = true
+readme.workspace = true
+
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[lints.rust]
+unreachable_pub = "warn"
+unused_must_use = "deny"
+rust_2018_idioms = "deny"
+
+[lints.rustdoc]
+all = "warn"
+
+[dependencies]
+revm.workspace = true
+database = { workspace = true, features = ["std", "alloydb"] }
+specification.workspace = true
+
+
+# tokio
+tokio = { version = "1.40", features = ["rt-multi-thread", "macros"] }
+
+# alloy
+alloy-sol-types = { version = "0.8.2", default-features = false, features = [
+    "std",
+] }
+alloy-eips = "0.6"
+alloy-transport-http = "0.6"
+alloy-provider = "0.6"
+reqwest = { version = "0.12" }
+anyhow = "1.0.89"
+
+
+

examples/erc20_gas/src/error.rs

@@ -0,0 +1,6 @@
+use revm::{
+    context_interface::{result::{EVMError, InvalidTransaction}, JournalStateGetterDBError},
+    Context,
+};
+
+pub type Erc20Error = EVMError<JournalStateGetterDBError<Context>, InvalidTransaction>; 

examples/erc20_gas/src/handlers/mod.rs

@@ -0,0 +1,7 @@
+pub mod pre_execution;
+pub mod post_execution;
+pub mod validation;
+
+pub use pre_execution::Erc20PreExecution;
+pub use post_execution::Erc20PostExecution;
+pub use validation::Erc20Validation; 

examples/erc20_gas/src/handlers/post_execution.rs

@@ -0,0 +1,94 @@
+use crate::error::Erc20Error;
+use crate::{token_operation, TREASURY};
+use revm::{
+    context::Cfg,
+    context_interface::{
+        result::{HaltReason, ResultAndState},
+        Block, Transaction, TransactionGetter,
+    },
+    handler::{EthPostExecution, FrameResult},
+    handler_interface::PostExecutionHandler,
+    primitives::U256,
+    specification::hardfork::SpecId,
+    Context,
+};
+
+pub struct Erc20PostExecution {
+    inner: EthPostExecution<Context, Erc20Error, HaltReason>,
+}
+
+impl Erc20PostExecution {
+    pub fn new() -> Self {
+        Self {
+            inner: EthPostExecution::new(),
+        }
+    }
+}
+
+impl PostExecutionHandler for Erc20PostExecution {
+    type Context = Context;
+    type Error = Erc20Error;
+    type ExecResult = FrameResult;
+    type Output = ResultAndState<HaltReason>;
+
+    fn refund(
+        &self,
+        context: &mut Self::Context,
+        exec_result: &mut Self::ExecResult,
+        eip7702_refund: i64,
+    ) {
+        self.inner.refund(context, exec_result, eip7702_refund)
+    }
+
+    fn reimburse_caller(
+        &self,
+        context: &mut Self::Context,
+        exec_result: &mut Self::ExecResult,
+    ) -> Result<(), Self::Error> {
+        let basefee = context.block.basefee();
+        let caller = context.tx().common_fields().caller();
+        let effective_gas_price = context.tx().effective_gas_price(*basefee);
+        let gas = exec_result.gas();
+
+        let reimbursement =
+            effective_gas_price * U256::from(gas.remaining() + gas.refunded() as u64);
+        token_operation(context, TREASURY, caller, reimbursement).unwrap();
+
+        Ok(())
+    }
+
+    fn reward_beneficiary(
+        &self,
+        context: &mut Self::Context,
+        exec_result: &mut Self::ExecResult,
+    ) -> Result<(), Self::Error> {
+        let tx = context.tx();
+        let beneficiary = context.block.beneficiary();
+        let basefee = context.block.basefee();
+        let effective_gas_price = tx.effective_gas_price(*basefee);
+        let gas = exec_result.gas();
+
+        let coinbase_gas_price = if context.cfg.spec().is_enabled_in(SpecId::LONDON) {
+            effective_gas_price.saturating_sub(*basefee)
+        } else {
+            effective_gas_price
+        };
+
+        let reward = coinbase_gas_price * U256::from(gas.spent() - gas.refunded() as u64);
+        token_operation(context, TREASURY, *beneficiary, reward).unwrap();
+
+        Ok(())
+    }
+
+    fn output(
+        &self,
+        context: &mut Self::Context,
+        result: Self::ExecResult,
+    ) -> Result<Self::Output, Self::Error> {
+        self.inner.output(context, result)
+    }
+
+    fn clear(&self, context: &mut Self::Context) {
+        self.inner.clear(context)
+    }
+}

examples/erc20_gas/src/handlers/pre_execution.rs

@@ -0,0 +1,52 @@
+use crate::error::Erc20Error;
+use crate::{token_operation, TREASURY};
+use revm::context_interface::transaction::Eip4844Tx;
+use revm::context_interface::{Block, Transaction, TransactionGetter};
+use revm::{
+    context_interface::TransactionType, handler::EthPreExecution,
+    handler_interface::PreExecutionHandler, primitives::U256, Context,
+};
+
+pub struct Erc20PreExecution {
+    inner: EthPreExecution<Context, Erc20Error>,
+}
+
+impl Erc20PreExecution {
+    pub fn new() -> Self {
+        Self {
+            inner: EthPreExecution::new(),
+        }
+    }
+}
+
+impl PreExecutionHandler for Erc20PreExecution {
+    type Context = Context;
+    type Error = Erc20Error;
+
+    fn load_accounts(&self, context: &mut Self::Context) -> Result<(), Self::Error> {
+        self.inner.load_accounts(context)
+    }
+
+    fn apply_eip7702_auth_list(&self, context: &mut Self::Context) -> Result<u64, Self::Error> {
+        self.inner.apply_eip7702_auth_list(context)
+    }
+
+    fn deduct_caller(&self, context: &mut Self::Context) -> Result<(), Self::Error> {
+        let basefee = context.block.basefee();
+        let blob_price = U256::from(context.block.blob_gasprice().unwrap_or_default());
+        let effective_gas_price = context.tx().effective_gas_price(*basefee);
+
+        let mut gas_cost = U256::from(context.tx().common_fields().gas_limit())
+            .saturating_mul(effective_gas_price);
+
+        if context.tx().tx_type() == TransactionType::Eip4844 {
+            let blob_gas = U256::from(context.tx().eip4844().total_blob_gas());
+            gas_cost = gas_cost.saturating_add(blob_price.saturating_mul(blob_gas));
+        }
+
+        let caller = context.tx().common_fields().caller();
+        token_operation(context, caller, TREASURY, gas_cost)?;
+
+        Ok(())
+    }
+}

examples/erc20_gas/src/handlers/validation.rs

@@ -0,0 +1,105 @@
+use crate::error::Erc20Error;
+use crate::keccak256;
+use crate::TOKEN;
+use alloy_sol_types::SolValue;
+use revm::context_interface::{Transaction, TransactionGetter};
+use revm::{
+    context::Cfg,
+    context_interface::{
+        result::{EVMError, InvalidTransaction},
+        transaction::Eip4844Tx,
+        JournalStateGetter, TransactionType,
+    },
+    handler::EthValidation,
+    handler_interface::ValidationHandler,
+    primitives::U256,
+    Context,
+};
+use std::cmp::Ordering;
+
+pub struct Erc20Validation {
+    inner: EthValidation<Context, Erc20Error>,
+}
+
+impl Erc20Validation {
+    pub fn new() -> Self {
+        Self {
+            inner: EthValidation::new(),
+        }
+    }
+}
+
+impl ValidationHandler for Erc20Validation {
+    type Context = Context;
+    type Error = Erc20Error;
+
+    fn validate_env(&self, context: &Self::Context) -> Result<(), Self::Error> {
+        self.inner.validate_env(context)
+    }
+
+    fn validate_tx_against_state(&self, context: &mut Self::Context) -> Result<(), Self::Error> {
+        let caller = context.tx().common_fields().caller();
+        let caller_nonce = context.journal().load_account(caller)?.data.info.nonce;
+        let token_account = context.journal().load_account(TOKEN)?.data.clone();
+
+        if !context.cfg.is_nonce_check_disabled() {
+            let tx_nonce = context.tx().common_fields().nonce();
+            let state_nonce = caller_nonce;
+            match tx_nonce.cmp(&state_nonce) {
+                Ordering::Less => {
+                    return Err(EVMError::Transaction(
+                        InvalidTransaction::NonceTooLow {
+                            tx: tx_nonce,
+                            state: state_nonce,
+                        }
+                        .into(),
+                    ))
+                }
+                Ordering::Greater => {
+                    return Err(EVMError::Transaction(
+                        InvalidTransaction::NonceTooHigh {
+                            tx: tx_nonce,
+                            state: state_nonce,
+                        }
+                        .into(),
+                    ))
+                }
+                _ => (),
+            }
+        }
+
+        let mut balance_check = U256::from(context.tx().common_fields().gas_limit())
+            .checked_mul(U256::from(context.tx().max_fee()))
+            .and_then(|gas_cost| gas_cost.checked_add(context.tx().common_fields().value()))
+            .ok_or(InvalidTransaction::OverflowPaymentInTransaction)?;
+
+        if context.tx().tx_type() == TransactionType::Eip4844 {
+            let tx = context.tx().eip4844();
+            let data_fee = tx.calc_max_data_fee();
+            balance_check = balance_check
+                .checked_add(data_fee)
+                .ok_or(InvalidTransaction::OverflowPaymentInTransaction)?;
+        }
+
+        let account_balance_slot: U256 = keccak256((caller, U256::from(3)).abi_encode()).into();
+        let account_balance = token_account
+            .storage
+            .get(&account_balance_slot)
+            .expect("Balance slot not found")
+            .present_value();
+
+        if account_balance < balance_check && !context.cfg.is_balance_check_disabled() {
+            return Err(InvalidTransaction::LackOfFundForMaxFee {
+                fee: Box::new(balance_check),
+                balance: Box::new(account_balance),
+            }
+            .into());
+        };
+
+        Ok(())
+    }
+
+    fn validate_initial_tx_gas(&self, context: &Self::Context) -> Result<u64, Self::Error> {
+        self.inner.validate_initial_tx_gas(context)
+    }
+}