feat(composer)!: Add chain_id check on executor build

crates/astria-composer/src/executor/mod.rs

@@ -40,16 +40,21 @@ use futures::{
 use pin_project_lite::pin_project;
 use prost::Message as _;
 use sequencer_client::{
-    tendermint_rpc::endpoint::broadcast::tx_sync,
+    tendermint_rpc::{
+        endpoint::broadcast::tx_sync,
+        Client as _,
+    },
     Address,
     SequencerClientExt as _,
 };
 use tendermint::crypto::Sha256;
 use tokio::{
     select,
     sync::{
-        mpsc,
-        mpsc::error::SendTimeoutError,
+        mpsc::{
+            self,
+            error::SendTimeoutError,
+        },
         watch,
     },
     time::{
@@ -94,7 +99,19 @@ pub(crate) use builder::Builder;
 const BUNDLE_DRAINING_DURATION: Duration = Duration::from_secs(16);
 
 type StdError = dyn std::error::Error;
-
+#[derive(Debug, thiserror::Error)]
+pub(crate) enum EnsureChainIdError {
+    // <other error variants from getting genesis, etc>
+    #[error("failed to obtain sequencer chain ID")]
+    FailedToGetChainId,
+    #[error("failed to obtain sequencer genesis")]
+    FailedToGetGenesis,
+    #[error("expected chain ID `{expected}`, but received `{actual}`")]
+    WrongChainId {
+        expected: String,
+        actual: tendermint::chain::Id,
+    },
+}
 /// The `Executor` interfaces with the sequencer. It handles account nonces, transaction signing,
 /// and transaction submission.
 /// The `Executor` receives `Vec<Action>` from the bundling logic, packages them with a nonce into
@@ -199,6 +216,17 @@ impl Executor {
     /// An error is returned if connecting to the sequencer fails.
     #[instrument(skip_all, fields(address = %self.address))]
     pub(super) async fn run_until_stopped(mut self) -> eyre::Result<()> {
+        select!(
+            biased;
+            () = self.shutdown_token.cancelled() => {
+                info!("received shutdown signal while running initialization routines; exiting");
+                return Ok(());
+            }
+
+            res = self.pre_run_checks() => {
+                res?;
+            }
+        );
         let mut submission_fut: Fuse<Instrumented<SubmitFut>> = Fuse::terminated();
         let mut nonce = get_latest_nonce(self.sequencer_client.clone(), self.address, self.metrics)
             .await
@@ -417,6 +445,56 @@ impl Executor {
 
         reason.map(|_| ())
     }
+
+    /// Performs initialization checks prior to running the executor
+    async fn pre_run_checks(&self) -> eyre::Result<()> {
+        self.ensure_chain_id_is_correct().await?;
+        Ok(())
+    }
+
+    /// Performs check to ensure the configured chain ID matches the remote chain ID
+    pub(crate) async fn ensure_chain_id_is_correct(&self) -> Result<(), EnsureChainIdError> {
+        let remote_chain_id = self
+            .get_sequencer_chain_id()
+            .await
+            .map_err(|_| EnsureChainIdError::FailedToGetChainId)?;
+        if remote_chain_id.as_str() != self.sequencer_chain_id {
+            return Err(EnsureChainIdError::WrongChainId {
+                expected: self.sequencer_chain_id.clone(),
+                actual: remote_chain_id,
+            });
+        }
+        Ok(())
+    }
+
+    /// Fetch chain id from the sequencer client
+    async fn get_sequencer_chain_id(&self) -> eyre::Result<tendermint::chain::Id> {
+        let retry_config = tryhard::RetryFutureConfig::new(u32::MAX)
+            .exponential_backoff(Duration::from_millis(100))
+            .max_delay(Duration::from_secs(20))
+            .on_retry(
+                |attempt: u32,
+                 next_delay: Option<Duration>,
+                 error: &sequencer_client::tendermint_rpc::Error| {
+                    let wait_duration = next_delay
+                        .map(humantime::format_duration)
+                        .map(tracing::field::display);
+                    warn!(
+                        attempt,
+                        wait_duration,
+                        error = error as &dyn std::error::Error,
+                        "attempt to fetch sequencer genesis info; retrying after backoff",
+                    );
+                    futures::future::ready(())
+                },
+            );
+        let client_genesis: tendermint::Genesis =
+            tryhard::retry_fn(|| self.sequencer_client.genesis())
+                .with_config(retry_config)
+                .await
+                .map_err(|_| EnsureChainIdError::FailedToGetGenesis)?;
+        Ok(client_genesis.chain_id)
+    }
 }
 
 /// Queries the sequencer for the latest nonce with an exponential backoff