Remove non permit flashtestation calls (#302)

Author: avalonche

crates/builder/op-rbuilder/src/builders/flashblocks/service.rs

@@ -92,7 +92,7 @@ where
         let flashtestations_builder_tx = if let Some(builder_key) = signer
             && self.0.flashtestations_config.flashtestations_enabled
         {
-            match bootstrap_flashtestations(self.0.flashtestations_config.clone(), builder_key, ctx)
+            match bootstrap_flashtestations(self.0.flashtestations_config.clone(), builder_key)
                 .await
             {
                 Ok(builder_tx) => Some(builder_tx),

crates/builder/op-rbuilder/src/builders/standard/service.rs

@@ -75,7 +75,7 @@ where
         let flashtestations_builder_tx = if let Some(builder_key) = signer
             && self.0.flashtestations_config.flashtestations_enabled
         {
-            match bootstrap_flashtestations(self.0.flashtestations_config.clone(), builder_key, ctx)
+            match bootstrap_flashtestations(self.0.flashtestations_config.clone(), builder_key)
                 .await
             {
                 Ok(builder_tx) => Some(builder_tx),

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

@@ -1,8 +1,8 @@
-use alloy_primitives::{Address, U256, utils::parse_ether};
+use alloy_primitives::Address;
 use clap::Parser;
 use reth_optimism_cli::commands::Commands;
 
-use crate::{args::Cli, tx_signer::Signer};
+use crate::args::Cli;
 
 /// Parameters for Flashtestations configuration
 /// The names in the struct are prefixed with `flashtestations`
@@ -52,23 +52,6 @@ pub struct FlashtestationsArgs {
     #[arg(long = "flashtestations.rpc-url", env = "FLASHTESTATIONS_RPC_URL")]
     pub rpc_url: Option<String>,
 
-    /// Funding key for the TEE key
-    #[arg(
-        long = "flashtestations.funding-key",
-        env = "FLASHTESTATIONS_FUNDING_KEY",
-        required_if_eq("flashtestations_enabled", "true")
-    )]
-    pub funding_key: Option<Signer>,
-
-    /// Funding amount for the generated signer
-    #[arg(
-        long = "flashtestations.funding-amount",
-        env = "FLASHTESTATIONS_FUNDING_AMOUNT",
-        default_value = "1",
-        value_parser = parse_ether
-    )]
-    pub funding_amount: U256,
-
     /// Enable end of block TEE proof
     #[arg(
         long = "flashtestations.enable-block-proofs",
@@ -100,14 +83,6 @@ pub struct FlashtestationsArgs {
         default_value = "1"
     )]
     pub builder_proof_version: u8,
-
-    /// Use permit for the flashtestation builder tx
-    #[arg(
-        long = "flashtestations.use-permit",
-        env = "FLASHTESTATIONS_USE_PERMIT",
-        default_value = "false"
-    )]
-    pub flashtestations_use_permit: bool,
 }
 
 impl Default for FlashtestationsArgs {

crates/builder/op-rbuilder/src/flashtestations/builder_tx.rs

@@ -1,27 +1,23 @@
-use alloy_consensus::TxEip1559;
 use alloy_eips::Encodable2718;
 use alloy_evm::Database;
 use alloy_op_evm::OpEvm;
-use alloy_primitives::{Address, B256, Bytes, Signature, TxKind, U256, keccak256};
+use alloy_primitives::{Address, B256, Bytes, Signature, U256, keccak256};
 use alloy_rpc_types_eth::TransactionInput;
 use alloy_sol_types::{SolCall, SolEvent, SolValue};
 use core::fmt::Debug;
-use op_alloy_consensus::OpTypedTransaction;
 use op_alloy_rpc_types::OpTransactionRequest;
-use reth_evm::{ConfigureEvm, Evm, EvmError, precompiles::PrecompilesMap};
+use reth_evm::{ConfigureEvm, Evm, precompiles::PrecompilesMap};
 use reth_optimism_primitives::OpTransactionSigned;
 use reth_provider::StateProvider;
 use reth_revm::{State, database::StateProviderDatabase};
-use revm::{
-    DatabaseCommit, DatabaseRef, context::result::ResultAndState, inspector::NoOpInspector,
-};
+use revm::{DatabaseCommit, DatabaseRef, inspector::NoOpInspector};
 use std::sync::{Arc, atomic::AtomicBool};
 use tracing::{debug, info, warn};
 
 use crate::{
     builders::{
         BuilderTransactionCtx, BuilderTransactionError, BuilderTransactions, OpPayloadBuilderCtx,
-        SimulationSuccessResult, get_balance, get_nonce,
+        SimulationSuccessResult, get_nonce,
     },
     flashtestations::{
         BlockData,
@@ -37,14 +33,11 @@ pub struct FlashtestationsBuilderTxArgs {
     pub attestation: Vec<u8>,
     pub extra_registration_data: Bytes,
     pub tee_service_signer: Signer,
-    pub funding_key: Signer,
-    pub funding_amount: U256,
     pub registry_address: Address,
     pub builder_policy_address: Address,
     pub builder_proof_version: u8,
     pub enable_block_proofs: bool,
     pub registered: bool,
-    pub use_permit: bool,
     pub builder_key: Signer,
 }
 
@@ -60,10 +53,6 @@ where
     extra_registration_data: Bytes,
     // TEE service generated key
     tee_service_signer: Signer,
-    // Funding key for the TEE signer
-    funding_key: Signer,
-    // Funding amount for the TEE signer
-    funding_amount: U256,
     // Registry address for the attestation
     registry_address: Address,
     // Builder policy address for the block builder proof
@@ -74,8 +63,6 @@ where
     registered: Arc<AtomicBool>,
     // Whether block proofs are enabled
     enable_block_proofs: bool,
-    // Whether to use permit for the flashtestation builder tx
-    use_permit: bool,
     // Builder key for the flashtestation permit tx
     builder_signer: Signer,
     // Extra context and data
@@ -92,14 +79,11 @@ where
             attestation: args.attestation,
             extra_registration_data: args.extra_registration_data,
             tee_service_signer: args.tee_service_signer,
-            funding_key: args.funding_key,
-            funding_amount: args.funding_amount,
             registry_address: args.registry_address,
             builder_policy_address: args.builder_policy_address,
             builder_proof_version: args.builder_proof_version,
             registered: Arc::new(AtomicBool::new(args.registered)),
             enable_block_proofs: args.enable_block_proofs,
-            use_permit: args.use_permit,
             builder_signer: args.builder_key,
             _marker: std::marker::PhantomData,
         }
@@ -137,136 +121,6 @@ where
         keccak256(&encoded)
     }
 
-    // TODO: deprecate in favour of permit calls
-    fn fund_tee_service_tx(
-        &self,
-        ctx: &OpPayloadBuilderCtx<ExtraCtx>,
-        evm: &mut OpEvm<&mut State<impl Database + DatabaseRef>, NoOpInspector, PrecompilesMap>,
-    ) -> Result<Option<BuilderTransactionCtx>, BuilderTransactionError> {
-        let balance = get_balance(evm.db(), self.tee_service_signer.address)?;
-        if balance.is_zero() {
-            let funding_nonce = get_nonce(evm.db(), self.funding_key.address)?;
-            let tx = OpTypedTransaction::Eip1559(TxEip1559 {
-                chain_id: ctx.chain_id(),
-                nonce: funding_nonce,
-                gas_limit: 21000,
-                max_fee_per_gas: ctx.base_fee().into(),
-                to: TxKind::Call(self.tee_service_signer.address),
-                value: self.funding_amount,
-                ..Default::default()
-            });
-            let funding_tx = self.funding_key.sign_tx(tx)?;
-            let da_size =
-                op_alloy_flz::tx_estimated_size_fjord_bytes(funding_tx.encoded_2718().as_slice());
-            let ResultAndState { state, .. } = match evm.transact(&funding_tx) {
-                Ok(res) => res,
-                Err(err) => {
-                    if err.is_invalid_tx_err() {
-                        return Err(BuilderTransactionError::InvalidTransactionError(Box::new(
-                            err,
-                        )));
-                    } else {
-                        return Err(BuilderTransactionError::EvmExecutionError(Box::new(err)));
-                    }
-                }
-            };
-            info!(target: "flashtestations", block_number = ctx.block_number(), tx_hash = ?funding_tx.tx_hash(), "adding funding tx to builder txs");
-            evm.db_mut().commit(state);
-            Ok(Some(BuilderTransactionCtx {
-                gas_used: 21000,
-                da_size,
-                signed_tx: funding_tx,
-                is_top_of_block: false,
-            }))
-        } else {
-            Ok(None)
-        }
-    }
-
-    // TODO: deprecate in favour of permit calls
-    fn register_tee_service_tx(
-        &self,
-        ctx: &OpPayloadBuilderCtx<ExtraCtx>,
-        evm: &mut OpEvm<&mut State<impl Database + DatabaseRef>, NoOpInspector, PrecompilesMap>,
-    ) -> Result<BuilderTransactionCtx, BuilderTransactionError> {
-        let calldata = IFlashtestationRegistry::registerTEEServiceCall {
-            rawQuote: self.attestation.clone().into(),
-            extendedRegistrationData: self.extra_registration_data.clone(),
-        };
-        let SimulationSuccessResult {
-            gas_used,
-            state_changes,
-            ..
-        } = self.flashtestation_call(
-            self.registry_address,
-            calldata.clone(),
-            vec![TEEServiceRegistered::SIGNATURE_HASH],
-            ctx,
-            evm,
-        )?;
-        let signed_tx = self.sign_tx(
-            self.registry_address,
-            self.tee_service_signer,
-            gas_used,
-            calldata.abi_encode().into(),
-            ctx,
-            evm.db(),
-        )?;
-        let da_size =
-            op_alloy_flz::tx_estimated_size_fjord_bytes(signed_tx.encoded_2718().as_slice());
-        // commit the register transaction state so the block proof transaction can succeed
-        evm.db_mut().commit(state_changes);
-        Ok(BuilderTransactionCtx {
-            gas_used,
-            da_size,
-            signed_tx,
-            is_top_of_block: false,
-        })
-    }
-
-    // TODO: remove in favour of permit calls
-    fn verify_block_proof_tx(
-        &self,
-        transactions: Vec<OpTransactionSigned>,
-        ctx: &OpPayloadBuilderCtx<ExtraCtx>,
-        evm: &mut OpEvm<impl Database + DatabaseRef, NoOpInspector, PrecompilesMap>,
-    ) -> Result<BuilderTransactionCtx, BuilderTransactionError> {
-        let block_content_hash = Self::compute_block_content_hash(
-            &transactions,
-            ctx.parent_hash(),
-            ctx.block_number(),
-            ctx.timestamp(),
-        );
-
-        let calldata = IBlockBuilderPolicy::verifyBlockBuilderProofCall {
-            blockContentHash: block_content_hash,
-            version: self.builder_proof_version,
-        };
-        let SimulationSuccessResult { gas_used, .. } = self.flashtestation_call(
-            self.builder_policy_address,
-            calldata.clone(),
-            vec![BlockBuilderProofVerified::SIGNATURE_HASH],
-            ctx,
-            evm,
-        )?;
-        let signed_tx = self.sign_tx(
-            self.builder_policy_address,
-            self.tee_service_signer,
-            gas_used,
-            calldata.abi_encode().into(),
-            ctx,
-            evm.db(),
-        )?;
-        let da_size =
-            op_alloy_flz::tx_estimated_size_fjord_bytes(signed_tx.encoded_2718().as_slice());
-        Ok(BuilderTransactionCtx {
-            gas_used,
-            da_size,
-            signed_tx,
-            is_top_of_block: false,
-        })
-    }
-
     fn set_registered(
         &self,
         state_provider: impl StateProvider + Clone,
@@ -534,35 +388,18 @@ where
 
         if !self.registered.load(std::sync::atomic::Ordering::SeqCst) {
             info!(target: "flashtestations", "tee service not registered yet, attempting to register");
-            let register_tx = if self.use_permit {
-                self.signed_registration_permit_tx(ctx, &mut evm)?
-            } else {
-                builder_txs.extend(self.fund_tee_service_tx(ctx, &mut evm)?);
-                self.register_tee_service_tx(ctx, &mut evm)?
-            };
+            let register_tx = self.signed_registration_permit_tx(ctx, &mut evm)?;
             builder_txs.push(register_tx);
         }
 
         // don't return on error for block proof as previous txs in builder_txs will not be returned
         if self.enable_block_proofs {
-            if self.use_permit {
-                debug!(target: "flashtestations", "adding permit verify block proof tx");
-                match self.signed_block_proof_permit_tx(&info.executed_transactions, ctx, &mut evm)
-                {
-                    Ok(block_proof_tx) => builder_txs.push(block_proof_tx),
-                    Err(e) => {
-                        warn!(target: "flashtestations", error = ?e, "failed to add permit block proof transaction")
-                    }
+            debug!(target: "flashtestations", "adding permit verify block proof tx");
+            match self.signed_block_proof_permit_tx(&info.executed_transactions, ctx, &mut evm) {
+                Ok(block_proof_tx) => builder_txs.push(block_proof_tx),
+                Err(e) => {
+                    warn!(target: "flashtestations", error = ?e, "failed to add permit block proof transaction")
                 }
-            } else {
-                // add verify block proof tx
-                match self.verify_block_proof_tx(info.executed_transactions.clone(), ctx, &mut evm)
-                {
-                    Ok(block_proof_tx) => builder_txs.push(block_proof_tx),
-                    Err(e) => {
-                        warn!(target: "flashtestations", error = ?e, "failed to add block proof transaction")
-                    }
-                };
             }
         }
         Ok(builder_txs)