feat(op-revm): add SGT fee burning via collect_native_balance

When SGT is enabled and not native-backed, fee recipients should only
receive the native portion of fees — the SGT portion is burned. This
matches op-geth's collectNativeBalance behavior.

- Add collect_native_balance to sgt.rs that splits fees between SGT
  (burned) and native (paid) pools
- Change reward_beneficiary return type to Result<U256> so the OP
  handler can capture the coinbase fee amount
- Apply collect_native_balance to coinbase fee and all OP-specific
  fees (L1, base fee, operator fee)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: blockchaindevsh

crates/handler/src/handler.rs

@@ -451,7 +451,8 @@ pub trait Handler {
         evm: &mut Self::Evm,
         exec_result: &mut <<Self::Evm as EvmTr>::Frame as FrameTr>::FrameResult,
     ) -> Result<(), Self::Error> {
-        post_execution::reward_beneficiary(evm.ctx(), exec_result.gas()).map_err(From::from)
+        post_execution::reward_beneficiary(evm.ctx(), exec_result.gas())?;
+        Ok(())
     }
 
     /// Processes the final execution output.

crates/handler/src/post_execution.rs

@@ -54,11 +54,13 @@ pub fn reimburse_caller<CTX: ContextTr>(
 }
 
 /// Rewards the beneficiary with transaction fees.
+///
+/// Returns the coinbase fee amount that was credited to the beneficiary.
 #[inline]
 pub fn reward_beneficiary<CTX: ContextTr>(
     context: &mut CTX,
     gas: &Gas,
-) -> Result<(), <CTX::Db as Database>::Error> {
+) -> Result<U256, <CTX::Db as Database>::Error> {
     let (block, tx, cfg, journal, _, _) = context.all_mut();
     let basefee = block.basefee() as u128;
     let effective_gas_price = tx.effective_gas_price(basefee);
@@ -71,12 +73,14 @@ pub fn reward_beneficiary<CTX: ContextTr>(
         effective_gas_price
     };
 
+    let coinbase_fee = U256::from(coinbase_gas_price * gas.used() as u128);
+
     // reward beneficiary
     journal
         .load_account_mut(block.beneficiary())?
-        .incr_balance(U256::from(coinbase_gas_price * gas.used() as u128));
+        .incr_balance(coinbase_fee);
 
-    Ok(())
+    Ok(coinbase_fee)
 }
 
 /// Calculate last gas spent and transform internal reason to external.

crates/op-revm/src/handler.rs

@@ -2,7 +2,7 @@
 use crate::{
     api::exec::OpContextTr,
     constants::{BASE_FEE_RECIPIENT, L1_FEE_RECIPIENT, OPERATOR_FEE_RECIPIENT},
-    sgt::{add_sgt_balance, deduct_sgt_balance, read_sgt_balance},
+    sgt::{add_sgt_balance, collect_native_balance, deduct_sgt_balance, read_sgt_balance},
     transaction::{deposit::DEPOSIT_TRANSACTION_TYPE, OpTransactionError, OpTxTr},
     L1BlockInfo, OpHaltReason, OpSpecId,
 };
@@ -430,7 +430,32 @@ where
             return Ok(());
         }
 
-        self.mainnet.reward_beneficiary(evm, frame_result)?;
+        // Call post_execution::reward_beneficiary directly to get the coinbase fee amount
+        let coinbase_fee = post_execution::reward_beneficiary(evm.ctx(), frame_result.gas())
+            .map_err(|e| ERROR::from(ContextError::Db(e)))?;
+
+        let is_sgt = evm.ctx().cfg().is_sgt_enabled();
+        let is_native_backed = evm.ctx().cfg().is_sgt_native_backed();
+
+        // SGT: burn the non-native portion of the coinbase fee
+        if is_sgt {
+            let chain = evm.ctx().chain_mut();
+            let actual = collect_native_balance(
+                coinbase_fee,
+                is_native_backed,
+                &mut chain.sgt_amount_deducted,
+                &mut chain.sgt_native_deducted,
+            );
+            let burned = coinbase_fee.saturating_sub(actual);
+            if !burned.is_zero() {
+                let beneficiary = evm.ctx().block().beneficiary();
+                evm.ctx()
+                    .journal_mut()
+                    .load_account_mut(beneficiary)?
+                    .decr_balance(burned);
+            }
+        }
+
         let basefee = evm.ctx().block().basefee() as u128;
 
         // If the transaction is not a deposit transaction, fees are paid out
@@ -458,13 +483,24 @@ where
         };
         let base_fee_amount = U256::from(basefee.saturating_mul(frame_result.gas().used() as u128));
 
-        // Send fees to their respective recipients
+        // Send fees to their respective recipients, applying SGT burning if enabled
         for (recipient, amount) in [
             (L1_FEE_RECIPIENT, l1_cost),
             (BASE_FEE_RECIPIENT, base_fee_amount),
             (OPERATOR_FEE_RECIPIENT, operator_fee_cost),
         ] {
-            ctx.journal_mut().balance_incr(recipient, amount)?;
+            let actual = if is_sgt {
+                let chain = ctx.chain_mut();
+                collect_native_balance(
+                    amount,
+                    is_native_backed,
+                    &mut chain.sgt_amount_deducted,
+                    &mut chain.sgt_native_deducted,
+                )
+            } else {
+                amount
+            };
+            ctx.journal_mut().balance_incr(recipient, actual)?;
         }
 
         Ok(())

crates/op-revm/src/sgt.rs

@@ -67,6 +67,37 @@ where
     Ok(())
 }
 
+/// Collect native balance from a fee amount, burning the SGT portion.
+///
+/// When SGT is enabled and not native-backed, fees are split between SGT and native pools.
+/// The SGT portion is burned (not paid to recipient), while the native portion goes to the
+/// recipient. This matches op-geth's `collectNativeBalance`.
+///
+/// Deducts from `sgt_remaining` first (burned), then from `native_remaining` (to recipient).
+/// Both pools are mutated in place. Returns the native amount that should be paid to the recipient.
+///
+/// Returns `amount` unchanged when `sgt_remaining == 0` or `is_native_backed`.
+pub fn collect_native_balance(
+    amount: U256,
+    is_native_backed: bool,
+    sgt_remaining: &mut U256,
+    native_remaining: &mut U256,
+) -> U256 {
+    if is_native_backed || sgt_remaining.is_zero() {
+        return amount;
+    }
+
+    // Burn from SGT pool first
+    let sgt_burn = amount.min(*sgt_remaining);
+    *sgt_remaining = sgt_remaining.saturating_sub(sgt_burn);
+
+    // Remainder comes from native pool
+    let native_part = amount.saturating_sub(sgt_burn).min(*native_remaining);
+    *native_remaining = native_remaining.saturating_sub(native_part);
+
+    native_part
+}
+
 /// Add amount to SGT balance in contract storage.
 ///
 /// This performs: `balance[account] += amount` in SGT contract storage.