fix registration retries

Author: avalonche

Cargo.lock

@@ -122,6 +122,7 @@ http = "1.0"
 sha3 = "0.10"
 hex = "0.4"
 ureq = "2.10"
+k256 = "0.13.4"
 
 rollup-boost = { git = "http://github.com/flashbots/rollup-boost", branch = "main" }
 

crates/op-rbuilder/Cargo.toml

@@ -73,15 +73,15 @@ impl From<BuilderTransactionError> for PayloadBuilderError {
 pub trait BuilderTransactions: Debug {
     fn simulate_builder_txs<Extra: Debug + Default>(
         &self,
-        state_provider: impl StateProvider,
+        state_provider: impl StateProvider + Clone,
         info: &mut ExecutionInfo<Extra>,
         ctx: &OpPayloadBuilderCtx,
         db: &mut State<impl Database>,
     ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError>;
 
     fn add_builder_txs<Extra: Debug + Default>(
         &self,
-        state_provider: impl StateProvider,
+        state_provider: impl StateProvider + Clone,
         info: &mut ExecutionInfo<Extra>,
         builder_ctx: &OpPayloadBuilderCtx,
         db: &mut State<impl Database>,
@@ -235,7 +235,7 @@ impl StandardBuilderTx {
 impl BuilderTransactions for StandardBuilderTx {
     fn simulate_builder_txs<Extra: Debug + Default>(
         &self,
-        _state_provider: impl StateProvider,
+        _state_provider: impl StateProvider + Clone,
         _info: &mut ExecutionInfo<Extra>,
         ctx: &OpPayloadBuilderCtx,
         db: &mut State<impl Database>,

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

@@ -1,9 +1,9 @@
-use alloy::sol_types::{SolCall, SolEvent, SolValue};
 use alloy_consensus::TxEip1559;
 use alloy_eips::Encodable2718;
 use alloy_evm::Database;
 use alloy_op_evm::OpEvm;
 use alloy_primitives::{keccak256, map::foldhash::HashMap, Address, Bytes, TxKind, B256, U256};
+use alloy_sol_types::{SolCall, SolEvent, SolValue};
 use core::fmt::Debug;
 use op_alloy_consensus::OpTypedTransaction;
 use reth_evm::{precompiles::PrecompilesMap, ConfigureEvm, Evm, EvmError};
@@ -385,7 +385,7 @@ impl FlashtestationsBuilderTx {
                     }
                 }
             };
-            info!(target: "flashtestations", "adding funding tx to builder txs");
+            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,
@@ -431,7 +431,7 @@ impl FlashtestationsBuilderTx {
                 let da_size = op_alloy_flz::tx_estimated_size_fjord_bytes(
                     register_tx.encoded_2718().as_slice(),
                 );
-                info!(target: "flashtestations", "adding register tee tx to builder txs");
+                info!(target: "flashtestations", block_number = ctx.block_number(), tx_hash = ?register_tx.tx_hash(), "adding register tee tx to builder txs");
                 evm.db_mut().commit(state_changes);
                 Ok((
                     Some(BuilderTransactionCtx {
@@ -494,7 +494,7 @@ impl FlashtestationsBuilderTx {
                 let da_size = op_alloy_flz::tx_estimated_size_fjord_bytes(
                     verify_block_proof_tx.encoded_2718().as_slice(),
                 );
-                debug!(target: "flashtestations", "adding verify block proof tx to builder txs");
+                debug!(target: "flashtestations", block_number = ctx.block_number(), tx_hash = ?verify_block_proof_tx.tx_hash(), "adding verify block proof tx to builder txs");
                 Ok(Some(BuilderTransactionCtx {
                     gas_used,
                     da_size,
@@ -507,21 +507,47 @@ impl FlashtestationsBuilderTx {
                 .simulate_builder_tx(ctx, evm.db_mut())
         }
     }
+
+    fn set_registered(
+        &self,
+        state_provider: impl StateProvider + Clone,
+        ctx: &OpPayloadBuilderCtx,
+    ) {
+        let state = StateProviderDatabase::new(state_provider.clone());
+        let mut simulation_state = State::builder()
+            .with_database(state)
+            .with_bundle_update()
+            .build();
+        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;
+        });
+        match self.register_tee_service_tx(ctx, &mut evm) {
+            Ok((_, registered)) => {
+                self.registered.store(registered, Ordering::Relaxed);
+            }
+            Err(e) => {
+                debug!(target: "flashtestations", error = ?e, "simulation error when checking if registered");
+            }
+        }
+    }
 }
 
 impl BuilderTransactions for FlashtestationsBuilderTx {
     fn simulate_builder_txs<Extra: Debug + Default>(
         &self,
-        state_provider: impl StateProvider,
+        state_provider: impl StateProvider + Clone,
         info: &mut ExecutionInfo<Extra>,
         ctx: &OpPayloadBuilderCtx,
         db: &mut State<impl Database>,
     ) -> Result<Vec<BuilderTransactionCtx>, BuilderTransactionError> {
-        let state = StateProviderDatabase::new(state_provider);
+        let state = StateProviderDatabase::new(state_provider.clone());
         let mut simulation_state = State::builder()
             .with_database(state)
-            .with_bundle_prestate(db.bundle_state.clone())
             .with_cached_prestate(db.cache.clone())
+            .with_bundle_prestate(db.bundle_state.clone())
             .with_bundle_update()
             .build();
 
@@ -535,11 +561,10 @@ impl BuilderTransactions for FlashtestationsBuilderTx {
         let mut builder_txs = Vec::<BuilderTransactionCtx>::new();
 
         if !self.registered.load(Ordering::Relaxed) {
+            info!(target: "flashtestations", "tee service not registered yet, attempting to add registration tx");
+            self.set_registered(state_provider, ctx);
             builder_txs.extend(self.fund_tee_service_tx(ctx, &mut evm)?);
-            let (register_tx, registered) = self.register_tee_service_tx(ctx, &mut evm)?;
-            if registered {
-                self.registered.store(true, Ordering::Relaxed);
-            }
+            let (register_tx, _) = self.register_tee_service_tx(ctx, &mut evm)?;
             builder_txs.extend(register_tx);
         }
 

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

@@ -1,5 +1,5 @@
-use alloy::{sol, sol_types::SolError};
 use alloy_primitives::{Address, Bytes, FixedBytes, B256, U256};
+use alloy_sol_types::{sol, SolError};
 
 sol!(
     #[sol(rpc, abi)]

crates/op-rbuilder/src/flashtestations/mod.rs

@@ -1,13 +1,16 @@
 use alloy_json_rpc::RpcError;
 use alloy_network::ReceiptResponse;
-use alloy_primitives::{keccak256, Address, Bytes, TxHash, TxKind, B256, U256};
+use alloy_primitives::{Address, Bytes, TxHash, TxKind, U256};
 use alloy_rpc_types_eth::TransactionRequest;
-use alloy_transport::TransportResult;
+use alloy_sol_types::SolCall;
+use alloy_transport::{TransportError, TransportErrorKind, TransportResult};
+use k256::ecdsa;
 use std::time::Duration;
 
-use alloy_provider::{PendingTransactionBuilder, Provider, ProviderBuilder};
+use alloy_provider::{
+    PendingTransactionBuilder, PendingTransactionError, Provider, ProviderBuilder,
+};
 use alloy_signer_local::PrivateKeySigner;
-use alloy_sol_types::{sol, SolCall, SolValue};
 use op_alloy_network::Optimism;
 use tracing::{debug, error, info, warn};
 

crates/op-rbuilder/src/flashtestations/tx_manager.rs

@@ -1,8 +1,8 @@
 use std::str::FromStr;
 
-use alloy::signers::k256::sha2::Sha256;
 use alloy_consensus::SignableTransaction;
 use alloy_primitives::{Address, Signature, B256, U256};
+use k256::sha2::Sha256;
 use op_alloy_consensus::OpTypedTransaction;
 use reth_optimism_primitives::OpTransactionSigned;
 use reth_primitives::Recovered;