Start fee distribution changes

crates/revm/Cargo.toml

@@ -15,6 +15,8 @@ revm-interpreter = { path = "../interpreter", version = "1.1.2", default-feature
 
 #misc
 auto_impl = { version = "1.1", default-features = false }
+once_cell = "1.18.0"
+bytes = "1.4.0"
 
 # Optional
 serde = { version = "1.0", features = ["derive", "rc"], optional = true }

crates/revm/src/evm_impl.rs

@@ -19,6 +19,11 @@ use revm_interpreter::gas::initial_tx_gas;
 use revm_interpreter::MAX_CODE_SIZE;
 use revm_precompile::{Precompile, Precompiles};
 
+#[cfg(feature = "optimism")]
+use crate::optimism;
+#[cfg(feature = "optimism")]
+use core::ops::Mul;
+
 pub struct EVMData<'a, DB: Database> {
     pub env: &'a mut Env,
     pub journaled_state: JournaledState,
@@ -319,7 +324,16 @@ impl<'a, GSPEC: Spec, DB: Database, const INSPECT: bool> EVMImpl<'a, GSPEC, DB,
                 let effective_gas_price = self.data.env.effective_gas_price();
                 let basefee = self.data.env.block.basefee;
 
-                let gas_refunded = if self.env().cfg.is_gas_refund_disabled() {
+                let is_gas_refund_disabled = self.data.env.cfg.is_gas_refund_disabled();
+
+                #[cfg(feature = "optimism")]
+                let is_deposit = self.data.env.tx.source_hash.is_some();
+
+                #[cfg(feature = "optimism")]
+                let is_gas_refund_disabled =
+                    is_gas_refund_disabled && is_deposit && !SPEC::enabled(SpecId::REGOLITH);
+
+                let gas_refunded = if is_gas_refund_disabled {
                     0
                 } else {
                     // EIP-3529: Reduction in refunds
@@ -338,12 +352,10 @@ impl<'a, GSPEC: Spec, DB: Database, const INSPECT: bool> EVMImpl<'a, GSPEC, DB,
                     effective_gas_price * U256::from(gas.remaining() + gas_refunded),
                 );
 
-                #[cfg(not(feature = "optimism"))]
                 let disable_coinbase_tip = self.data.env.cfg.disable_coinbase_tip;
 
                 #[cfg(feature = "optimism")]
-                let disable_coinbase_tip = self.data.env.cfg.disable_coinbase_tip
-                    || self.data.env.tx.source_hash.is_some();
+                let disable_coinbase_tip = disable_coinbase_tip || is_deposit;
 
                 // transfer fee to coinbase/beneficiary.
                 if !disable_coinbase_tip {
@@ -368,12 +380,42 @@ impl<'a, GSPEC: Spec, DB: Database, const INSPECT: bool> EVMImpl<'a, GSPEC, DB,
                 }
 
                 #[cfg(feature = "optimism")]
-                if self.data.env.cfg.optimism && self.data.env.tx.source_hash.is_none() {
+                if self.data.env.cfg.optimism && !is_deposit {
                     // If the transaction is not a deposit transaction, fees are paid out
-                    // to both the Base Fee Vault as well as the Sequencer Fee Vault.
-                    // TODO(clabby): Need to load the L1 fee information from the L1 block contract
-                    //               and pay out fees to the vaults.
-                    todo!()
+                    // to both the Base Fee Vault as well as the L1 Fee Vault.
+
+                    // Fetch the L1 block information from account storage.
+                    let Ok(l1_block_info) = optimism::fetch_l1_block_info(&mut self.data.db) else {
+                        panic!("Failed to fetch L1 block info from account storage.");
+                    };
+
+                    // Calculate the L1 cost of the transaction based on the L1 block info.
+                    // TODO(clabby): This is incorrect. The L1 cost is computed with the full
+                    // enveloped encoding of the transaction, not its input. How do we get the full
+                    // encoded tx here? We may pass it through the `TxEnv`, but that feels hacky.
+                    let l1_cost =
+                        l1_block_info.calculate_tx_l1_cost::<SPEC>(&self.data.env.tx.data, true);
+
+                    // Send the L1 cost of the transaction to the L1 Fee Vault.
+                    let Ok((l1_fee_vault_account, _)) = self
+                        .data
+                        .journaled_state
+                        .load_account(*optimism::L1_FEE_RECIPIENT, self.data.db)
+                    else {
+                        panic!("L1 Fee Vault account not found");
+                    };
+                    l1_fee_vault_account.info.balance += l1_cost;
+
+                    // Send the base fee of the transaction to the Base Fee Vault.
+                    let Ok((base_fee_vault_account, _)) = self
+                        .data
+                        .journaled_state
+                        .load_account(*optimism::BASE_FEE_RECIPIENT, self.data.db)
+                    else {
+                        panic!("Base Fee Vault account not found");
+                    };
+                    base_fee_vault_account.info.balance +=
+                        l1_block_info.l1_base_fee.mul(U256::from(gas.spend()));
                 }
 
                 (gas.spend() - gas_refunded, gas_refunded)

crates/revm/src/lib.rs

@@ -10,6 +10,9 @@ mod evm_impl;
 mod inspector;
 mod journaled_state;
 
+#[cfg(feature = "optimism")]
+pub mod optimism;
+
 #[cfg(all(feature = "with-serde", not(feature = "serde")))]
 compile_error!("`with-serde` feature has been renamed to `serde`.");
 
@@ -39,3 +42,7 @@ pub use revm_interpreter::primitives;
 // reexport inspector implementations
 pub use inspector::inspectors;
 pub use inspector::Inspector;
+
+// export Optimism types, helpers, and constants
+#[cfg(feature = "optimism")]
+pub use optimism::*;

crates/revm/src/optimism.rs

@@ -0,0 +1,100 @@
+//! Optimism-specific constants, types, and helpers.
+
+use core::ops::Mul;
+
+use bytes::Bytes;
+use once_cell::sync::Lazy;
+use revm_interpreter::primitives::{db::Database, hex_literal::hex, Address, Spec, SpecId, U256};
+
+const ZERO_BYTE_COST: u64 = 4;
+const NON_ZERO_BYTE_COST: u64 = 16;
+
+static L1_BASE_FEE_SLOT: Lazy<U256> = Lazy::new(|| U256::from(1));
+static L1_OVERHEAD_SLOT: Lazy<U256> = Lazy::new(|| U256::from(5));
+static L1_SCALAR_SLOT: Lazy<U256> = Lazy::new(|| U256::from(6));
+
+/// The address of L1 fee recipient.
+pub static L1_FEE_RECIPIENT: Lazy<Address> =
+    Lazy::new(|| Address::from_slice(&hex!("420000000000000000000000000000000000001A")));
+
+/// The address of the base fee recipient.
+pub static BASE_FEE_RECIPIENT: Lazy<Address> =
+    Lazy::new(|| Address::from_slice(&hex!("4200000000000000000000000000000000000019")));
+
+/// The address of the L1Block contract.
+pub static L1_BLOCK_CONTRACT: Lazy<Address> =
+    Lazy::new(|| Address::from_slice(&hex!("4200000000000000000000000000000000000015")));
+
+/// L1 block info
+///
+/// We can extract L1 epoch data from each L2 block, by looking at the `setL1BlockValues`
+/// transaction data. This data is then used to calculate the L1 cost of a transaction.
+///
+/// Here is the format of the `setL1BlockValues` transaction data:
+///
+/// setL1BlockValues(uint64 _number, uint64 _timestamp, uint256 _basefee, bytes32 _hash,
+/// uint64 _sequenceNumber, bytes32 _batcherHash, uint256 _l1FeeOverhead, uint256 _l1FeeScalar)
+///
+/// For now, we only care about the fields necessary for L1 cost calculation.
+#[derive(Clone, Debug)]
+pub struct L1BlockInfo {
+    /// The base fee of the L1 origin block.
+    pub l1_base_fee: U256,
+    /// The current L1 fee overhead.
+    pub l1_fee_overhead: U256,
+    /// The current L1 fee scalar.
+    pub l1_fee_scalar: U256,
+}
+
+impl L1BlockInfo {
+    /// Calculate the data gas for posting the transaction on L1. Calldata costs 16 gas per non-zero
+    /// byte and 4 gas per zero byte.
+    ///
+    /// Prior to regolith, an extra 68 non-zero bytes were included in the rollup data costs to
+    /// account for the empty signature.
+    pub fn data_gas<SPEC: Spec>(&self, input: &Bytes) -> U256 {
+        let mut rollup_data_gas_cost = U256::from(input.iter().fold(0, |acc, byte| {
+            acc + if *byte == 0x00 {
+                ZERO_BYTE_COST
+            } else {
+                NON_ZERO_BYTE_COST
+            }
+        }));
+
+        // Prior to regolith, an extra 68 non zero bytes were included in the rollup data costs.
+        if !SPEC::enabled(SpecId::REGOLITH) {
+            rollup_data_gas_cost += U256::from(NON_ZERO_BYTE_COST).mul(U256::from(68));
+        }
+
+        rollup_data_gas_cost
+    }
+
+    /// Calculate the gas cost of a transaction based on L1 block data posted on L2
+    pub fn calculate_tx_l1_cost<SPEC: Spec>(&self, input: &Bytes, is_deposit: bool) -> U256 {
+        let rollup_data_gas_cost = self.data_gas::<SPEC>(input);
+
+        if is_deposit || rollup_data_gas_cost == U256::ZERO {
+            return U256::ZERO;
+        }
+
+        rollup_data_gas_cost
+            .saturating_add(self.l1_fee_overhead)
+            .saturating_mul(self.l1_base_fee)
+            .saturating_mul(self.l1_fee_scalar)
+            .checked_div(U256::from(1_000_000))
+            .unwrap_or_default()
+    }
+}
+
+/// Fetches the L1 block info from the `L1Block` contract in the database.
+pub fn fetch_l1_block_info<DB: Database>(db: &mut DB) -> Result<L1BlockInfo, DB::Error> {
+    let l1_base_fee = db.storage(*L1_BLOCK_CONTRACT, *L1_BASE_FEE_SLOT)?;
+    let l1_fee_overhead = db.storage(*L1_BLOCK_CONTRACT, *L1_OVERHEAD_SLOT)?;
+    let l1_fee_scalar = db.storage(*L1_BLOCK_CONTRACT, *L1_SCALAR_SLOT)?;
+
+    Ok(L1BlockInfo {
+        l1_base_fee,
+        l1_fee_overhead,
+        l1_fee_scalar,
+    })
+}