Add permit functions for flashblocks number contract

Author: avalonche

crates/op-rbuilder/src/args/op.rs

@@ -167,6 +167,15 @@ pub struct FlashblocksArgs {
     )]
     pub flashblocks_number_contract_address: Option<Address>,
 
+    /// Use permit signatures if flashtestations is enabled with the flashtestation key
+    /// to increment the flashblocks number
+    #[arg(
+        long = "flashblocks.number-contract-use-permit",
+        env = "FLASHBLOCK_NUMBER_CONTRACT_USE_PERMIT",
+        default_value = "false"
+    )]
+    pub flashblocks_number_contract_use_permit: bool,
+
     /// Flashblocks p2p configuration
     #[command(flatten)]
     pub p2p: FlashblocksP2pArgs,

crates/op-rbuilder/src/builders/builder_tx.rs

@@ -126,7 +126,7 @@ impl From<BuilderTransactionError> for PayloadBuilderError {
             BuilderTransactionError::EvmExecutionError(e) => {
                 PayloadBuilderError::EvmExecutionError(e)
             }
-            _ => PayloadBuilderError::Other(Box::new(error)),
+            _ => PayloadBuilderError::other(error),
         }
     }
 }

crates/op-rbuilder/src/builders/flashblocks/builder_tx.rs

@@ -1,29 +1,20 @@
-use alloy_consensus::TxEip1559;
 use alloy_eips::Encodable2718;
 use alloy_evm::{Database, Evm};
 use alloy_op_evm::OpEvm;
-use alloy_primitives::{Address, TxKind};
-use alloy_sol_types::{Error, SolCall, SolEvent, SolInterface, sol};
+use alloy_primitives::{Address, B256, Bytes, Signature, U256};
+use alloy_sol_types::{SolCall, SolEvent, SolInterface, SolValue, sol};
 use core::fmt::Debug;
-use op_alloy_consensus::OpTypedTransaction;
-use op_revm::OpHaltReason;
 use reth_evm::{ConfigureEvm, precompiles::PrecompilesMap};
-use reth_optimism_primitives::OpTransactionSigned;
-use reth_primitives::Recovered;
 use reth_provider::StateProvider;
-use reth_revm::State;
-use revm::{
-    DatabaseRef,
-    context::result::{ExecutionResult, ResultAndState},
-    inspector::NoOpInspector,
-};
+use reth_revm::{State, database::StateProviderDatabase};
+use revm::inspector::NoOpInspector;
 use tracing::warn;
 
 use crate::{
     builders::{
         BuilderTransactionCtx, BuilderTransactionError, BuilderTransactions,
-        InvalidContractDataError,
-        builder_tx::{BuilderTxBase, get_nonce},
+        InvalidContractDataError, SimulationSuccessResult,
+        builder_tx::BuilderTxBase,
         context::OpPayloadBuilderCtx,
         flashblocks::payload::{FlashblocksExecutionInfo, FlashblocksExtraCtx},
     },
@@ -37,8 +28,17 @@ sol!(
     #[sol(rpc, abi)]
     #[derive(Debug)]
     interface IFlashblockNumber {
+        uint256 public flashblockNumber;
+
         function incrementFlashblockNumber() external;
 
+        function permitIncrementFlashblockNumber(uint256 currentFlashblockNumber, bytes memory signature) external;
+
+        function computeStructHash(uint256 currentFlashblockNumber) external pure returns (bytes32);
+
+        function hashTypedDataV4(bytes32 structHash) external view returns (bytes32);
+
+
         // @notice Emitted when flashblock index is incremented
         // @param newFlashblockIndex The new flashblock index (0-indexed within each L2 block)
         event FlashblockIncremented(uint256 newFlashblockIndex);
@@ -55,10 +55,8 @@ sol!(
 pub(super) enum FlashblockNumberError {
     #[error("flashblocks number contract tx reverted: {0:?}")]
     Revert(IFlashblockNumber::IFlashblockNumberErrors),
-    #[error("unknown revert: {0} err: {1}")]
-    Unknown(String, Error),
-    #[error("halt: {0:?}")]
-    Halt(OpHaltReason),
+    #[error("unknown revert: {0}")]
+    Unknown(String),
 }
 
 // This will be the end of block transaction of a regular block
@@ -133,25 +131,28 @@ impl BuilderTransactions<FlashblocksExtraCtx, FlashblocksExecutionInfo> for Flas
 // This will be the end of block transaction of a regular block
 #[derive(Debug, Clone)]
 pub(super) struct FlashblocksNumberBuilderTx {
-    pub signer: Option<Signer>,
+    pub signer: Signer,
     pub flashblock_number_address: Address,
+    pub use_permit: bool,
     pub base_builder_tx: BuilderTxBase<FlashblocksExtraCtx>,
     pub flashtestations_builder_tx:
         Option<FlashtestationsBuilderTx<FlashblocksExtraCtx, FlashblocksExecutionInfo>>,
 }
 
 impl FlashblocksNumberBuilderTx {
     pub(super) fn new(
-        signer: Option<Signer>,
+        signer: Signer,
         flashblock_number_address: Address,
+        use_permit: bool,
         flashtestations_builder_tx: Option<
             FlashtestationsBuilderTx<FlashblocksExtraCtx, FlashblocksExecutionInfo>,
         >,
     ) -> Self {
-        let base_builder_tx = BuilderTxBase::new(signer);
+        let base_builder_tx = BuilderTxBase::new(Some(signer));
         Self {
             signer,
             flashblock_number_address,
+            use_permit,
             base_builder_tx,
             flashtestations_builder_tx,
         }
@@ -200,27 +201,173 @@ impl FlashblocksNumberBuilderTx {
             )),
         }
     }
+    
+    fn current_flashblock_number(
+        &self,
+        ctx: &OpPayloadBuilderCtx<FlashblocksExtraCtx>,
+        evm: &mut OpEvm<
+            &mut State<StateProviderDatabase<impl StateProvider>>,
+            NoOpInspector,
+            PrecompilesMap,
+        >,
+    ) -> Result<U256, BuilderTransactionError> {
+        let current_flashblock_calldata = IFlashblockNumber::flashblockNumberCall {}.abi_encode();
+        let SimulationSuccessResult { output, .. } =
+            self.simulate_flashblocks_call(current_flashblock_calldata, None, ctx, evm)?;
+        IFlashblockNumber::flashblockNumberCall::abi_decode_returns(&output).map_err(|_| {
+            BuilderTransactionError::InvalidContract(
+                self.flashblock_number_address,
+                InvalidContractDataError::OutputAbiDecodeError,
+            )
+        })
+    }
 
-    fn signed_flashblock_number_tx(
+    fn signed_increment_flashblocks_tx(
         &self,
         ctx: &OpPayloadBuilderCtx<FlashblocksExtraCtx>,
-        gas_limit: u64,
-        nonce: u64,
-        signer: &Signer,
-    ) -> Result<Recovered<OpTransactionSigned>, secp256k1::Error> {
+        evm: &mut OpEvm<
+            &mut State<StateProviderDatabase<impl StateProvider>>,
+            NoOpInspector,
+            PrecompilesMap,
+        >,
+    ) -> Result<BuilderTransactionCtx, BuilderTransactionError> {
         let calldata = IFlashblockNumber::incrementFlashblockNumberCall {}.abi_encode();
-        // Create the EIP-1559 transaction
-        let tx = OpTypedTransaction::Eip1559(TxEip1559 {
-            chain_id: ctx.chain_id(),
-            nonce,
-            gas_limit,
-            max_fee_per_gas: ctx.base_fee().into(),
-            max_priority_fee_per_gas: 0,
-            to: TxKind::Call(self.flashblock_number_address),
-            input: calldata.into(),
-            ..Default::default()
-        });
-        signer.sign_tx(tx)
+        let SimulationSuccessResult { gas_used, .. } = self.simulate_flashblocks_call(
+            calldata.clone(),
+            Some(IFlashblockNumber::FlashblockIncremented::SIGNATURE_HASH),
+            ctx,
+            evm,
+        )?;
+        let signed_tx = self.sign_tx(
+            self.flashblock_number_address,
+            self.signer,
+            Some(gas_used),
+            calldata.into(),
+            ctx,
+            evm.db_mut(),
+        )?;
+        let da_size =
+            op_alloy_flz::tx_estimated_size_fjord_bytes(signed_tx.encoded_2718().as_slice());
+        Ok(BuilderTransactionCtx {
+            signed_tx,
+            gas_used,
+            da_size,
+            is_top_of_block: true,
+        })
+    }
+
+    fn increment_flashblocks_permit_signature(
+        &self,
+        flashtestations_signer: &Signer,
+        current_flashblock_number: U256,
+        ctx: &OpPayloadBuilderCtx<FlashblocksExtraCtx>,
+        evm: &mut OpEvm<
+            &mut State<StateProviderDatabase<impl StateProvider>>,
+            NoOpInspector,
+            PrecompilesMap,
+        >,
+    ) -> Result<Signature, BuilderTransactionError> {
+        let struct_hash_calldata = IFlashblockNumber::computeStructHashCall {
+            currentFlashblockNumber: current_flashblock_number,
+        }
+        .abi_encode();
+        let SimulationSuccessResult { output, .. } =
+            self.simulate_flashblocks_call(struct_hash_calldata, None, ctx, evm)?;
+        let struct_hash = B256::abi_decode(&output).map_err(|_| {
+            BuilderTransactionError::InvalidContract(
+                self.flashblock_number_address,
+                InvalidContractDataError::OutputAbiDecodeError,
+            )
+        })?;
+        let typed_data_hash_calldata = IFlashblockNumber::hashTypedDataV4Call {
+            structHash: struct_hash,
+        }
+        .abi_encode();
+        let SimulationSuccessResult { output, .. } =
+            self.simulate_flashblocks_call(typed_data_hash_calldata, None, ctx, evm)?;
+        let typed_data_hash = B256::abi_decode(&output).map_err(|_| {
+            BuilderTransactionError::InvalidContract(
+                self.flashblock_number_address,
+                InvalidContractDataError::OutputAbiDecodeError,
+            )
+        })?;
+        let signature = flashtestations_signer.sign_message(typed_data_hash)?;
+        Ok(signature)
+    }
+
+    fn signed_increment_flashblocks_permit_tx(
+        &self,
+        flashtestations_signer: &Signer,
+        ctx: &OpPayloadBuilderCtx<FlashblocksExtraCtx>,
+        evm: &mut OpEvm<
+            &mut State<StateProviderDatabase<impl StateProvider>>,
+            NoOpInspector,
+            PrecompilesMap,
+        >,
+    ) -> Result<BuilderTransactionCtx, BuilderTransactionError> {
+        let current_flashblock_number = self.current_flashblock_number(ctx, evm)?;
+        let signature = self.increment_flashblocks_permit_signature(
+            flashtestations_signer,
+            current_flashblock_number,
+            ctx,
+            evm,
+        )?;
+        let calldata = IFlashblockNumber::permitIncrementFlashblockNumberCall {
+            currentFlashblockNumber: current_flashblock_number,
+            signature: signature.as_bytes().into(),
+        }
+        .abi_encode();
+        let SimulationSuccessResult { gas_used, .. } = self.simulate_flashblocks_call(
+            calldata.clone(),
+            Some(IFlashblockNumber::FlashblockIncremented::SIGNATURE_HASH),
+            ctx,
+            evm,
+        )?;
+        let signed_tx = self.sign_tx(
+            self.flashblock_number_address,
+            self.signer,
+            Some(gas_used),
+            calldata.into(),
+            ctx,
+            evm.db_mut(),
+        )?;
+        let da_size =
+            op_alloy_flz::tx_estimated_size_fjord_bytes(signed_tx.encoded_2718().as_slice());
+        Ok(BuilderTransactionCtx {
+            signed_tx,
+            gas_used,
+            da_size,
+            is_top_of_block: true,
+        })
+    }
+
+    fn simulate_flashblocks_call(
+        &self,
+        calldata: Vec<u8>,
+        expected_topic: Option<B256>,
+        ctx: &OpPayloadBuilderCtx<FlashblocksExtraCtx>,
+        evm: &mut OpEvm<
+            &mut State<StateProviderDatabase<impl StateProvider>>,
+            NoOpInspector,
+            PrecompilesMap,
+        >,
+    ) -> Result<SimulationSuccessResult, BuilderTransactionError> {
+        let signed_tx = self.sign_tx(
+            self.flashblock_number_address,
+            self.signer,
+            None,
+            calldata.into(),
+            ctx,
+            evm.db_mut(),
+        )?;
+        self.simulate_call(signed_tx, expected_topic, Self::handle_revert, evm)
+    }
+
+    fn handle_revert(revert_output: Bytes) -> BuilderTransactionError {
+        let revert_reason = IFlashblockNumber::IFlashblockNumberErrors::abi_decode(&revert_output)
+            .map(FlashblockNumberError::Revert)
+            .unwrap_or_else(|_| FlashblockNumberError::Unknown(hex::encode(revert_output)));
+        BuilderTransactionError::TransactionReverted(Box::new(revert_reason))
     }
 }
 
@@ -242,46 +389,37 @@ impl BuilderTransactions<FlashblocksExtraCtx, FlashblocksExecutionInfo>
             builder_txs.extend(self.base_builder_tx.simulate_builder_tx(ctx, &mut *db)?);
         } else {
             // we increment the flashblock number for the next flashblock so we don't increment in the last flashblock
-            if let Some(signer) = &self.signer {
-                let mut evm = ctx.evm_config.evm_with_env(&mut *db, ctx.evm_env.clone());
-                evm.modify_cfg(|cfg| {
-                    cfg.disable_balance_check = true;
-                    cfg.disable_block_gas_limit = true;
-                });
-
-                let nonce = get_nonce(evm.db_mut(), signer.address)?;
-
-                let tx = match self.estimate_flashblock_number_tx_gas(ctx, &mut evm, signer, nonce)
-                {
-                    Ok(gas_used) => {
-                        // Due to EIP-150, 63/64 of available gas is forwarded to external calls so need to add a buffer
-                        let signed_tx = self.signed_flashblock_number_tx(
-                            ctx,
-                            gas_used * 64 / 63,
-                            nonce,
-                            signer,
-                        )?;
-
-                        let da_size = op_alloy_flz::tx_estimated_size_fjord_bytes(
-                            signed_tx.encoded_2718().as_slice(),
-                        );
-                        Some(BuilderTransactionCtx {
-                            gas_used,
-                            da_size,
-                            signed_tx,
-                            is_top_of_block: true, // number tx at top of flashblock
-                        })
-                    }
-                    Err(e) => {
-                        warn!(target: "builder_tx", error = ?e, "Flashblocks number contract tx simulation failed, defaulting to fallback builder tx");
-                        self.base_builder_tx
-                            .simulate_builder_tx(ctx, &mut *db)?
-                            .map(|tx| tx.set_top_of_block())
-                    }
-                };
+            let mut evm = ctx
+                .evm_config
+                .evm_with_env(&mut simulation_state, ctx.evm_env.clone());
+            evm.modify_cfg(|cfg| {
+                cfg.disable_balance_check = true;
+                cfg.disable_block_gas_limit = true;
+            });
 
-                builder_txs.extend(tx);
-            }
+            let flashblocks_num_tx = if let Some(flashtestations) = &self.flashtestations_builder_tx
+                && self.use_permit
+            {
+                self.signed_increment_flashblocks_permit_tx(
+                    flashtestations.tee_signer(),
+                    ctx,
+                    &mut evm,
+                )
+            } else {
+                self.signed_increment_flashblocks_tx(ctx, &mut evm)
+            };
+
+            let tx = match flashblocks_num_tx {
+                Ok(tx) => Some(tx),
+                Err(e) => {
+                    warn!(target: "builder_tx", error = ?e, "flashblocks number contract tx simulation failed, defaulting to fallback builder tx");
+                    self.base_builder_tx
+                        .simulate_builder_tx(ctx, db)?
+                        .map(|tx| tx.set_top_of_block())
+                }
+            };
+
+            builder_txs.extend(tx);
         }
 
         if ctx.is_last_flashblock() {