forge_script/

recovery.rs

use crate::{
    multi_sequence::MultiChainSequence,
    sequence::{SequenceData, completed_transaction_prefix, operation_ordinal},
};
use alloy_consensus::{Transaction, transaction::SignerRecoverable};
use alloy_eips::eip2718::{Decodable2718, Encodable2718};
use alloy_network::{Network, ReceiptResponse, TransactionBuilder, TransactionResponse};
use alloy_primitives::{Address, B256, Bytes, TxKind, keccak256};
use eyre::{ContextCompat, Result, WrapErr, bail};
use forge_script_sequence::{ScriptSequence, TransactionWithMetadata, now};
use foundry_common::{FoundryTransactionBuilder, TransactionMaybeSigned};
use serde::{Deserialize, Serialize};
use std::{
    fs::{File, OpenOptions},
    io::{BufWriter, Write},
    path::{Path, PathBuf},
};
use tempfile::NamedTempFile;
use tempo_primitives::transaction::{TEMPO_EXPIRING_NONCE_KEY, TempoTxEnvelope};

#[cfg(unix)]
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};

const RECOVERY_VERSION: u32 = 1;

#[derive(Clone, Serialize, Deserialize)]
#[serde(bound(
    serialize = "N::TxEnvelope: Serialize",
    deserialize = "N::TxEnvelope: for<'de2> Deserialize<'de2>"
))]
struct RecoveryPlan<N: Network> {
    version: u32,
    generation: B256,
    multi: bool,
    batch: bool,
    /// Tempo sponsor of the run that created the snapshot. Resume must not prepare new
    /// transactions without it.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    sponsor: Option<Address>,
    deployments: Vec<RecoveryDeployment<N>>,
    data: SequenceData<N>,
}

#[derive(Clone, Serialize, Deserialize)]
#[serde(bound = "")]
struct RecoveryDeployment<N: Network> {
    chain: u64,
    batch_id: Option<u32>,
    operations: Vec<RecoveryOperation>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    attempts: Vec<SubmissionAttempt<N::TransactionRequest>>,
}

#[derive(Clone, Serialize, Deserialize)]
struct RecoveryOperation {
    id: OperationId,
    fingerprint: B256,
    rpc: String,
}

#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
struct OperationId {
    sequence: u32,
    index: u32,
}

#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
pub(crate) struct SignedPayload {
    pub(crate) payload: Bytes,
    pub(crate) hash: B256,
}

#[derive(Clone, Serialize, Deserialize)]
struct SubmissionAttempt<T> {
    id: B256,
    members: Vec<OperationId>,
    kind: AttemptKind<T>,
}

#[derive(Clone, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "camelCase")]
pub(crate) enum AttemptKind<T> {
    Signed { request: Option<T>, payload: SignedPayload },
    Delegated { request: T, status: DelegatedStatus },
    Legacy { hash: B256 },
}

#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "status", rename_all = "camelCase")]
pub(crate) enum DelegatedStatus {
    Prepared,
    Pending { hash: B256 },
    OutcomeUnknown,
}

/// Owns the authoritative recovery snapshot and its process-lifetime writer lock.
pub(crate) struct RecoveryStore<N: Network> {
    path: PathBuf,
    _lock: RecoveryLock,
    plan: RecoveryPlan<N>,
}

pub(crate) struct RecoveryLock {
    path: PathBuf,
    _files: Vec<File>,
}

pub(crate) struct RecoveryRelocation {
    lock: RecoveryLock,
}

impl<N: Network> RecoveryStore<N>
where
    N::TxEnvelope: for<'de> Deserialize<'de> + Serialize,
{
    pub(crate) const fn data(&self) -> &SequenceData<N> {
        &self.plan.data
    }

    pub(crate) const fn data_mut(&mut self) -> &mut SequenceData<N> {
        &mut self.plan.data
    }

    pub(crate) const fn is_batch(&self) -> bool {
        self.plan.batch
    }

    pub(crate) const fn sponsor(&self) -> Option<Address> {
        self.plan.sponsor
    }

    pub(crate) fn create(
        mut data: SequenceData<N>,
        batch: bool,
        sponsor: Option<Address>,
    ) -> Result<Self> {
        let paths = data.paths();
        let lock = RecoveryLock::acquire(&paths)?;
        let pending = pending_path(&lock.path);
        if pending.exists() {
            bail!(
                "uncommitted recovery snapshot `{}` already exists; resume it before starting a new execution",
                pending.display()
            );
        }
        if previous_unfinished::<N>(&lock.path, &paths, data.is_multi()) {
            bail!(
                "the previous broadcast `{}` has unfinished operations; finish it with `{}`, or pass `--start-fresh` to archive it and broadcast anew",
                paths.0.display(),
                if data.is_multi() { "--multi --resume" } else { "--resume" }
            );
        }
        let generation = B256::random();
        data.set_recovery_generation(generation);
        let plan = RecoveryPlan { sponsor, ..RecoveryPlan::new(data, batch, generation)? };
        write_snapshot(&lock.path, &plan)?;
        Self::finish_open(lock, plan)
    }

    /// Moves the unfinished progress of a previous execution of `data` to timestamped names, so
    /// that a new execution can replace it.
    pub(crate) fn archive_unfinished(data: &SequenceData<N>) -> Result<()> {
        let paths = &data.paths();
        let lock = RecoveryLock::acquire(paths)?;
        // A crash mid-commit leaves the newest complete snapshot pending, as resume would find it.
        let pending = pending_path(&lock.path);
        if pending.exists() {
            commit_pending_plan(&pending, &lock.path)?;
        }
        if !previous_unfinished::<N>(&lock.path, paths, data.is_multi()) {
            return Ok(());
        }
        let timestamp = now().as_millis();
        for path in [&lock.path, &paths.0, &paths.1] {
            if path.exists() {
                let archive = path.with_extension(format!("{timestamp}.json"));
                std::fs::rename(path, &archive)?;
                sh_status!("Archived `{}` to `{}`", path.display(), archive.display())?;
            }
        }
        Ok(())
    }

    pub(crate) fn load(
        paths: &(PathBuf, PathBuf),
        batch: bool,
        lock: RecoveryLock,
    ) -> Result<Option<Self>>
    where
        N::TxEnvelope: SignerRecoverable,
        N::TransactionRequest: FoundryTransactionBuilder<N>,
    {
        let pending = pending_path(&lock.path);
        let (mut plan, recover_pending) = if pending.exists() {
            (load_plan(&pending)?, true)
        } else if lock.path.exists() {
            (load_plan(&lock.path)?, false)
        } else {
            return Ok(None);
        };
        plan.restore_sensitive();
        plan.data.set_paths(paths.clone());
        plan.validate(batch)?;
        plan.validate_signed_payloads()?;
        if recover_pending {
            commit_pending_plan(&pending, &lock.path)?;
        }
        Self::finish_open(lock, plan).map(Some)
    }

    pub(crate) fn import(mut data: SequenceData<N>, batch: bool, lock: RecoveryLock) -> Result<Self>
    where
        N::TxEnvelope: SignerRecoverable,
        N::TransactionRequest: FoundryTransactionBuilder<N>,
    {
        let generation = B256::random();
        data.set_recovery_generation(generation);
        let mut plan = RecoveryPlan::new(data, batch, generation)?;
        if batch {
            plan.import_legacy_batch_attempts()?;
        }
        plan.validate_signed_payloads()?;
        write_snapshot(&lock.path, &plan)?;
        Self::finish_open(lock, plan)
    }

    fn finish_open(lock: RecoveryLock, plan: RecoveryPlan<N>) -> Result<Self> {
        #[cfg(unix)]
        for path in [&lock.path, &pending_path(&lock.path)] {
            if path.exists() {
                std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600))?;
            }
        }
        Ok(Self { path: lock.path.clone(), _lock: lock, plan })
    }

    pub(crate) fn save(&self) -> Result<()> {
        self.plan.validate(self.plan.batch)?;
        write_snapshot(&self.path, &self.plan)
    }

    fn submission_attempts(
        &self,
        sequence: usize,
        index: usize,
    ) -> impl Iterator<Item = &SubmissionAttempt<N::TransactionRequest>> {
        let operation = self
            .plan
            .deployments
            .get(sequence)
            .and_then(|deployment| deployment.operations.get(index))
            .map(|operation| operation.id);
        self.plan
            .deployments
            .get(sequence)
            .into_iter()
            .flat_map(|deployment| &deployment.attempts)
            .filter(move |attempt| operation.is_some_and(|id| attempt.members.contains(&id)))
    }

    pub(crate) fn signed_payload(&self, sequence: usize, index: usize) -> Option<&SignedPayload> {
        self.submission_attempts(sequence, index).find_map(|attempt| match &attempt.kind {
            AttemptKind::Signed { payload, .. } => Some(payload),
            AttemptKind::Delegated { .. } | AttemptKind::Legacy { .. } => None,
        })
    }

    pub(crate) fn delegated_status(
        &self,
        sequence: usize,
        index: usize,
    ) -> Option<DelegatedStatus> {
        self.submission_attempts(sequence, index).find_map(|attempt| match &attempt.kind {
            AttemptKind::Delegated { status, .. } => Some(*status),
            AttemptKind::Signed { .. } | AttemptKind::Legacy { .. } => None,
        })
    }

    pub(crate) fn submission_hashes(&self, sequence: usize) -> (Vec<B256>, Vec<B256>) {
        let mut durable = Vec::new();
        let mut replayable = Vec::new();
        for attempt in self
            .plan
            .deployments
            .get(sequence)
            .into_iter()
            .flat_map(|deployment| &deployment.attempts)
        {
            match &attempt.kind {
                AttemptKind::Signed { payload, .. } => {
                    durable.push(payload.hash);
                    replayable.push(payload.hash);
                }
                AttemptKind::Delegated { status: DelegatedStatus::Pending { hash }, .. } => {
                    durable.push(*hash);
                }
                AttemptKind::Legacy { hash } => durable.push(*hash),
                AttemptKind::Delegated { .. } => {}
            }
        }
        (durable, replayable)
    }

    pub(crate) fn batch_attempt(
        &self,
        sequence: usize,
    ) -> Option<(usize, B256, &AttemptKind<N::TransactionRequest>)> {
        if !self.plan.batch {
            return None;
        }
        let attempt = self.plan.deployments.get(sequence)?.attempts.first()?;
        Some((attempt.members.first()?.index as usize, attempt.id, &attempt.kind))
    }

    pub(crate) fn persist_signed_payload(
        &mut self,
        sequence: usize,
        index: usize,
        payload: Bytes,
        sender_scoped_replay: bool,
    ) -> Result<B256>
    where
        N::TxEnvelope: SignerRecoverable,
        N::TransactionRequest: FoundryTransactionBuilder<N>,
    {
        let deployment = self
            .plan
            .deployments
            .get(sequence)
            .context("signed payload deployment is not in the recovery snapshot")?;
        let operation = deployment
            .operations
            .get(index)
            .context("signed payload operation is not in the recovery snapshot")?;
        let transaction = &self.plan.data.sequences()[sequence].transactions[index];
        let signed = validate_signed_payload::<N>(
            payload,
            transaction,
            deployment.chain,
            index,
            operation_ordinal(self.plan.data.sequences(), sequence, index),
        )?;
        let id = operation.id;
        // From T1B, expiring replay identities exclude sponsor signatures, so different envelopes
        // can still be replays. Compare identities across all sequences of the same chain before
        // recording an attempt the node would reject. Keep envelope hashes for receipt tracking.
        let replay_hash = expiring_replay_hash(&signed.payload, sender_scoped_replay)?;
        for attempt in self
            .plan
            .deployments
            .iter()
            .enumerate()
            .filter(|(i, other)| {
                *i == sequence || (replay_hash.is_some() && other.chain == deployment.chain)
            })
            .flat_map(|(_, other)| &other.attempts)
        {
            if !attempt.members.contains(&id)
                && let AttemptKind::Signed { payload, .. } = &attempt.kind
                && match replay_hash {
                    Some(hash) => {
                        expiring_replay_hash(&payload.payload, sender_scoped_replay)? == Some(hash)
                    }
                    None => payload.hash == signed.hash,
                }
            {
                bail!(
                    "transaction {index} is identical to an earlier transaction of this script ({}) and would be rejected as a replay; identical Tempo expiring nonce transactions are only distinct from the T12 hardfork (TIP-1106)",
                    signed.hash
                );
            }
        }
        if let Some(existing) = self.signed_payload(sequence, index) {
            if existing != &signed {
                bail!("refusing to replace an existing signed payload");
            }
            return Ok(existing.hash);
        }
        if deployment.attempts.iter().any(|attempt| attempt.members.contains(&id)) {
            bail!("refusing to replace an existing submission attempt");
        }
        let hash = signed.hash;
        self.persist_attempt(
            sequence,
            SubmissionAttempt {
                id: B256::random(),
                members: vec![id],
                kind: AttemptKind::Signed { request: None, payload: signed },
            },
        )?;
        Ok(hash)
    }

    pub(crate) fn persist_delegated_request(
        &mut self,
        sequence: usize,
        index: usize,
        request: N::TransactionRequest,
    ) -> Result<()> {
        let deployment = self
            .plan
            .deployments
            .get(sequence)
            .context("delegated operation is not in the recovery snapshot")?;
        let id = deployment
            .operations
            .get(index)
            .context("delegated operation is not in the recovery snapshot")?
            .id;
        if deployment.attempts.iter().any(|attempt| attempt.members.contains(&id)) {
            bail!("refusing to replace an existing submission attempt");
        }
        self.persist_attempt(
            sequence,
            SubmissionAttempt {
                id: B256::random(),
                members: vec![id],
                kind: AttemptKind::Delegated { request, status: DelegatedStatus::Prepared },
            },
        )
    }

    pub(crate) fn persist_delegated_status(
        &mut self,
        sequence: usize,
        index: usize,
        status: DelegatedStatus,
    ) -> Result<()> {
        let deployment = self
            .plan
            .deployments
            .get_mut(sequence)
            .context("delegated operation is not in the recovery snapshot")?;
        let id = deployment
            .operations
            .get(index)
            .context("delegated operation is not in the recovery snapshot")?
            .id;
        let attempt = deployment
            .attempts
            .iter_mut()
            .find(|attempt| attempt.members.contains(&id))
            .context("delegated operation has no submission attempt")?;
        let AttemptKind::Delegated { status: current, .. } = &mut attempt.kind else {
            bail!("operation has no delegated submission attempt");
        };
        let previous = *current;
        if previous == status {
            return Ok(());
        }
        *current = status;
        if let Err(error) = write_snapshot(&self.path, &self.plan) {
            let AttemptKind::Delegated { status, .. } = &mut self.plan.deployments[sequence]
                .attempts
                .iter_mut()
                .find(|attempt| attempt.members.contains(&id))
                .unwrap()
                .kind
            else {
                unreachable!()
            };
            *status = previous;
            return Err(error);
        }
        Ok(())
    }

    pub(crate) fn clear_delegated_request(&mut self, sequence: usize, index: usize) -> Result<()> {
        let deployment = self
            .plan
            .deployments
            .get_mut(sequence)
            .context("delegated operation is not in the recovery snapshot")?;
        let id = deployment
            .operations
            .get(index)
            .context("delegated operation is not in the recovery snapshot")?
            .id;
        let position = deployment
            .attempts
            .iter()
            .position(|attempt| {
                attempt.members.contains(&id)
                    && matches!(&attempt.kind, AttemptKind::Delegated { .. })
            })
            .context("delegated operation has no submission attempt")?;
        let attempt = deployment.attempts.remove(position);
        if let Err(error) = write_snapshot(&self.path, &self.plan) {
            self.plan.deployments[sequence].attempts.insert(position, attempt);
            return Err(error);
        }
        Ok(())
    }

    pub(crate) fn delegated_attempt_location(&self, id: B256) -> Option<(usize, usize)> {
        self.plan.deployments.iter().enumerate().find_map(|(sequence, deployment)| {
            let attempt = deployment.attempts.iter().find(|attempt| {
                attempt.id == id && matches!(attempt.kind, AttemptKind::Delegated { .. })
            })?;
            let operation = attempt.members.first()?;
            Some((sequence, operation.index as usize))
        })
    }

    pub(crate) fn delegated_attempts(&self) -> Vec<(usize, usize, B256, DelegatedStatus)> {
        self.plan
            .deployments
            .iter()
            .enumerate()
            .flat_map(|(sequence, deployment)| {
                deployment.attempts.iter().filter_map(move |attempt| {
                    let AttemptKind::Delegated { status, .. } = &attempt.kind else { return None };
                    Some((sequence, attempt.members.first()?.index as usize, attempt.id, *status))
                })
            })
            .collect()
    }

    pub(crate) fn resolve_delegated_hash(
        &mut self,
        attempt_id: B256,
        hash: B256,
        transaction: &N::TransactionResponse,
    ) -> Result<(usize, usize)>
    where
        N::TransactionRequest: FoundryTransactionBuilder<N>,
    {
        let (sequence, index) = self
            .delegated_attempt_location(attempt_id)
            .context("no interrupted delegated submission matches --resume-attempt")?;
        let deployment = &self.plan.deployments[sequence];
        let attempt = deployment.attempts.iter().find(|attempt| attempt.id == attempt_id).unwrap();
        let AttemptKind::Delegated { request, status } = &attempt.kind else { unreachable!() };
        if !matches!(status, DelegatedStatus::Prepared | DelegatedStatus::OutcomeUnknown) {
            bail!("delegated submission attempt {attempt_id} does not require resolution");
        }
        validate_delegated_transaction::<N>(transaction, request, deployment.chain, hash)?;
        self.persist_delegated_status(sequence, index, DelegatedStatus::Pending { hash })?;
        Ok((sequence, index))
    }

    pub(crate) fn persist_batch_signed_payload(
        &mut self,
        sequence: usize,
        first_operation: usize,
        request: N::TransactionRequest,
        payload: Bytes,
    ) -> Result<B256>
    where
        N::TxEnvelope: Decodable2718 + Encodable2718,
    {
        let signed = SignedPayload { hash: signed_payload_hash::<N>(&payload)?, payload };
        let hash = signed.hash;
        self.persist_batch_attempt(
            sequence,
            first_operation,
            AttemptKind::Signed { request: Some(request), payload: signed },
        )?;
        Ok(hash)
    }

    pub(crate) fn persist_batch_delegated_request(
        &mut self,
        sequence: usize,
        first_operation: usize,
        request: N::TransactionRequest,
    ) -> Result<()> {
        self.persist_batch_attempt(
            sequence,
            first_operation,
            AttemptKind::Delegated { request, status: DelegatedStatus::Prepared },
        )
    }

    fn persist_batch_attempt(
        &mut self,
        sequence: usize,
        first_operation: usize,
        kind: AttemptKind<N::TransactionRequest>,
    ) -> Result<()> {
        if self.batch_attempt(sequence).is_some() {
            bail!("refusing to replace an existing batch submission attempt");
        }
        let members = self
            .plan
            .deployments
            .get(sequence)
            .context("batch deployment is not in the recovery snapshot")?
            .operations
            .get(first_operation..)
            .context("batch operation is not in the recovery snapshot")?
            .iter()
            .map(|operation| operation.id)
            .collect::<Vec<_>>();
        if members.is_empty() {
            bail!("batch submission has no operations");
        }
        self.persist_attempt(sequence, SubmissionAttempt { id: B256::random(), members, kind })
    }

    fn persist_attempt(
        &mut self,
        sequence: usize,
        attempt: SubmissionAttempt<N::TransactionRequest>,
    ) -> Result<()> {
        self.plan
            .deployments
            .get_mut(sequence)
            .context("submission deployment is not in the recovery snapshot")?
            .attempts
            .push(attempt);
        if let Err(error) = write_snapshot(&self.path, &self.plan) {
            self.plan.deployments[sequence].attempts.pop();
            return Err(error);
        }
        Ok(())
    }

    pub(crate) fn prepare_relocation(
        &self,
        paths: &(PathBuf, PathBuf),
    ) -> Result<RecoveryRelocation> {
        let lock = RecoveryLock::acquire(paths)?;
        let path = &lock.path;
        if paths.0.exists() {
            bail!(
                "broadcast progress `{}` already exists; refusing to replace it",
                paths.0.display()
            );
        }
        if path.exists() {
            let existing: RecoveryPlan<N> = foundry_common::fs::read_json_file(path)
                .wrap_err_with(|| format!("recovery snapshot `{}` is corrupt", path.display()))?;
            existing.validate(self.plan.batch)?;
            self.plan.validate(self.plan.batch)?;
            if serde_json::to_value(existing.deployments)?
                != serde_json::to_value(&self.plan.deployments)?
            {
                bail!("destination recovery snapshot does not match the script operations");
            }
        }
        write_snapshot(path, &self.plan)?;
        Ok(RecoveryRelocation { lock })
    }

    pub(crate) fn commit_relocation(&mut self, relocation: RecoveryRelocation) -> Result<()> {
        let RecoveryRelocation { lock } = relocation;
        let path = &lock.path;
        #[cfg(unix)]
        std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600))?;
        self.path.clone_from(path);
        self._lock = lock;
        Ok(())
    }
}

impl RecoveryLock {
    pub(crate) fn acquire(paths: &(PathBuf, PathBuf)) -> Result<Self> {
        let path = recovery_path_from_sensitive(&paths.1)?;
        let mut lock_paths =
            vec![path.with_extension("lock"), paths.0.with_extension("recovery.lock")];
        lock_paths.sort();
        lock_paths.dedup();
        let mut files = Vec::with_capacity(lock_paths.len());
        for lock_path in lock_paths {
            if let Some(parent) = lock_path.parent() {
                std::fs::create_dir_all(parent)?;
            }
            let mut options = OpenOptions::new();
            options.read(true).write(true).create(true);
            #[cfg(unix)]
            options.mode(0o600);
            let file = options.open(&lock_path)?;
            #[cfg(unix)]
            file.set_permissions(std::fs::Permissions::from_mode(0o600))?;
            file.try_lock().wrap_err_with(|| {
                format!("another process is already modifying recovery state `{}`", path.display())
            })?;
            files.push(file);
        }
        Ok(Self { path, _files: files })
    }
}

impl<N: Network> RecoveryPlan<N>
where
    N::TxEnvelope: for<'de> Deserialize<'de> + Serialize,
{
    fn new(data: SequenceData<N>, batch: bool, generation: B256) -> Result<Self> {
        let deployments = data
            .sequences()
            .iter()
            .enumerate()
            .map(|(sequence, deployment)| {
                Ok(RecoveryDeployment {
                    chain: deployment.chain,
                    batch_id: batch.then(|| u32::try_from(sequence).expect("too many sequences")),
                    attempts: Vec::new(),
                    operations: deployment
                        .transactions
                        .iter()
                        .enumerate()
                        .map(|(index, transaction)| {
                            Ok(RecoveryOperation {
                                id: OperationId {
                                    sequence: u32::try_from(sequence).expect("too many sequences"),
                                    index: u32::try_from(index).expect("too many operations"),
                                },
                                fingerprint: operation_fingerprint(transaction)?,
                                rpc: transaction.rpc.clone(),
                            })
                        })
                        .collect::<Result<Vec<_>>>()?,
                })
            })
            .collect::<Result<Vec<_>>>()?;
        Ok(Self {
            version: RECOVERY_VERSION,
            generation,
            multi: data.is_multi(),
            batch,
            sponsor: None,
            deployments,
            data,
        })
    }

    fn import_legacy_batch_attempts(&mut self) -> Result<()> {
        for (deployment, data) in self.deployments.iter_mut().zip(self.data.sequences().iter()) {
            let completed = completed_transaction_prefix(data)?;
            if data.pending.is_empty() {
                if data
                    .transactions
                    .iter()
                    .skip(completed)
                    .any(|transaction| transaction.hash.is_some())
                {
                    bail!("legacy batch progress has operation hashes without a pending hash");
                }
                continue;
            }
            let [hash] = data.pending.as_slice() else {
                bail!("cannot import legacy batch progress with multiple pending hashes");
            };
            let first = data
                .transactions
                .iter()
                .position(|transaction| transaction.hash == Some(*hash))
                .context("legacy batch hash is not bound to a recovery operation")?;
            if completed != first {
                bail!("legacy batch progress omits an incomplete operation");
            }
            if data
                .transactions
                .iter()
                .skip(first)
                .any(|transaction| transaction.hash != Some(*hash))
            {
                bail!("cannot import inconsistent legacy batch operation hashes");
            }
            deployment.attempts.push(SubmissionAttempt {
                id: B256::random(),
                members: deployment.operations[first..]
                    .iter()
                    .map(|operation| operation.id)
                    .collect(),
                kind: AttemptKind::Legacy { hash: *hash },
            });
        }
        Ok(())
    }

    fn validate(&self, batch: bool) -> Result<()> {
        if self.version != RECOVERY_VERSION {
            bail!(
                "unsupported recovery snapshot version {}; expected version {}",
                self.version,
                RECOVERY_VERSION
            );
        }
        if self.batch != batch || self.multi != self.data.is_multi() {
            bail!("recovery snapshot does not match the requested script mode");
        }
        if self
            .data
            .sequences()
            .iter()
            .any(|sequence| sequence.recovery_generation != Some(self.generation))
        {
            bail!("recovery snapshot contains inconsistent generations");
        }
        let mut saved = self.deployments.clone();
        for deployment in &mut saved {
            deployment.attempts.clear();
        }
        let expected = Self::new(self.data.clone(), self.batch, self.generation)?;
        if serde_json::to_value(saved)? != serde_json::to_value(&expected.deployments)? {
            bail!("recovery snapshot does not match the script operations; refusing to resume");
        }
        Ok(())
    }

    fn validate_signed_payloads(&self) -> Result<()>
    where
        N::TxEnvelope: SignerRecoverable,
        N::TransactionRequest: FoundryTransactionBuilder<N>,
    {
        for (sequence, deployment) in self.deployments.iter().enumerate() {
            let data = &self.data.sequences()[sequence];
            if self.batch && deployment.attempts.is_empty() {
                let completed = completed_transaction_prefix(data)?;
                if !data.pending.is_empty()
                    || data
                        .transactions
                        .iter()
                        .skip(completed)
                        .any(|transaction| transaction.hash.is_some())
                {
                    bail!("batch progress exists without a durable submission attempt");
                }
            }
            if self.batch && deployment.attempts.len() > 1 {
                bail!("recovery snapshot contains multiple batch submission attempts");
            }
            let mut claimed = vec![false; deployment.operations.len()];
            for attempt in &deployment.attempts {
                let Some(first) = attempt.members.first() else {
                    bail!("recovery snapshot attempt has invalid operation membership");
                };
                if first.sequence as usize != sequence {
                    bail!("recovery snapshot attempt has invalid operation membership");
                }
                let start = first.index as usize;
                let end = start
                    .checked_add(attempt.members.len())
                    .context("recovery snapshot attempt has invalid operation membership")?;
                let operations = deployment
                    .operations
                    .get(start..end)
                    .context("recovery snapshot attempt has invalid operation membership")?;
                if operations
                    .iter()
                    .map(|operation| operation.id)
                    .ne(attempt.members.iter().copied())
                    || claimed[start..end].iter().any(|claimed| *claimed)
                    || if self.batch {
                        end != deployment.operations.len()
                    } else {
                        attempt.members.len() != 1
                    }
                {
                    bail!("recovery snapshot attempt has invalid operation membership");
                }
                if self.batch {
                    let completed = completed_transaction_prefix(data)?;
                    if completed != start && completed != deployment.operations.len() {
                        bail!("batch submission attempt omits an incomplete operation");
                    }
                    let expected_hash = match &attempt.kind {
                        AttemptKind::Signed { payload, .. } => Some(payload.hash),
                        AttemptKind::Delegated {
                            status: DelegatedStatus::Pending { hash },
                            ..
                        }
                        | AttemptKind::Legacy { hash } => Some(*hash),
                        AttemptKind::Delegated { .. } => None,
                    };
                    if data.pending.len() > 1
                        || data.pending.iter().any(|hash| Some(*hash) != expected_hash)
                        || data
                            .transactions
                            .iter()
                            .skip(start)
                            .filter_map(|transaction| transaction.hash)
                            .any(|hash| Some(hash) != expected_hash)
                    {
                        bail!("batch submission attempt conflicts with script progress");
                    }
                }
                claimed[start..end].fill(true);
                match &attempt.kind {
                    AttemptKind::Signed { request, payload } => {
                        if request.is_some() != self.batch {
                            bail!("recovery snapshot signed attempt has an invalid request");
                        }
                        let validated = if let [operation] = operations
                            && !self.batch
                        {
                            validate_signed_payload::<N>(
                                payload.payload.clone(),
                                &data.transactions[operation.id.index as usize],
                                deployment.chain,
                                operation.id.index as usize,
                                operation_ordinal(
                                    self.data.sequences(),
                                    sequence,
                                    operation.id.index as usize,
                                ),
                            )?
                        } else {
                            SignedPayload {
                                hash: signed_payload_hash::<N>(&payload.payload)?,
                                payload: payload.payload.clone(),
                            }
                        };
                        if validated != *payload {
                            bail!("recovery snapshot signed payload does not match its hash");
                        }
                    }
                    AttemptKind::Legacy { .. } if !self.batch => {
                        bail!("ordinary recovery snapshot contains a legacy batch attempt");
                    }
                    AttemptKind::Delegated { .. } | AttemptKind::Legacy { .. } => {}
                }
            }
        }
        Ok(())
    }

    fn restore_sensitive(&mut self) {
        for (deployment, data) in self.deployments.iter().zip(self.data.sequences_mut().iter_mut())
        {
            for (operation, transaction) in
                deployment.operations.iter().zip(data.transactions.iter_mut())
            {
                transaction.rpc.clone_from(&operation.rpc);
            }
        }
    }
}

fn operation_fingerprint<N: Network>(transaction: &TransactionWithMetadata<N>) -> Result<B256>
where
    N::TxEnvelope: for<'de> Deserialize<'de> + Serialize,
{
    let mut transaction = transaction.clone();
    transaction.hash = None;
    transaction.rpc.clear();
    let transaction =
        serde_json::from_value::<TransactionWithMetadata<N>>(serde_json::to_value(transaction)?)?;
    let mut value = serde_json::to_value(transaction)?;
    value.sort_all_objects();
    Ok(keccak256(serde_json::to_vec(&value)?))
}

fn load_plan<N: Network>(path: &Path) -> Result<RecoveryPlan<N>>
where
    N::TxEnvelope: for<'de> Deserialize<'de>,
{
    foundry_common::fs::read_json_file(path)
        .wrap_err_with(|| format!("recovery snapshot `{}` is corrupt", path.display()))
}

/// Returns whether the previous execution at `paths` submitted anything and left an operation, on
/// any chain, with neither a receipt nor a recorded revert. Without a recovery snapshot, progress
/// saved before snapshots existed is read from the broadcast export. An unreadable snapshot counts
/// as unfinished, as resume would refuse it too; an unreadable export counts as finished.
fn previous_unfinished<N: Network>(snapshot: &Path, paths: &(PathBuf, PathBuf), multi: bool) -> bool
where
    N::TxEnvelope: for<'de> Deserialize<'de> + Serialize,
{
    let (data, attempted) = if snapshot.exists() {
        let Ok(plan) = load_plan::<N>(snapshot) else { return true };
        let attempted = plan.deployments.iter().any(|deployment| !deployment.attempts.is_empty());
        (plan.data, attempted)
    } else {
        let data = if multi {
            foundry_common::fs::read_json_file::<MultiChainSequence<N>>(&paths.0)
                .map(SequenceData::Multi)
        } else {
            foundry_common::fs::read_json_file::<ScriptSequence<N>>(&paths.0)
                .map(|sequence| SequenceData::Single(Box::new(sequence)))
        };
        let Ok(data) = data else { return false };
        (data, false)
    };
    let sequences = data.sequences();
    let submitted = attempted
        || sequences.iter().flat_map(|sequence| &sequence.transactions).any(|tx| tx.hash.is_some());
    submitted
        && sequences.iter().any(|sequence| {
            sequence.transactions.iter().any(|tx| {
                !tx.hash.is_some_and(|hash| {
                    sequence.reverted.contains(&hash)
                        || sequence
                            .receipts
                            .iter()
                            .any(|receipt| receipt.transaction_hash() == hash)
                })
            })
        })
}

fn pending_path(path: &Path) -> PathBuf {
    path.with_extension("pending")
}

pub(crate) fn recovery_exists(paths: &(PathBuf, PathBuf)) -> Result<bool> {
    let path = recovery_path_from_sensitive(&paths.1)?;
    Ok(path.exists() || pending_path(&path).exists())
}

fn commit_pending_plan(pending: &Path, path: &Path) -> Result<()> {
    #[cfg(windows)]
    if path.exists() {
        std::fs::remove_file(path)?;
    }
    std::fs::rename(pending, path)?;
    #[cfg(unix)]
    std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o600))?;
    #[cfg(unix)]
    File::open(path.parent().context("recovery plan has no parent directory")?)?.sync_all()?;
    Ok(())
}

fn recovery_path_from_sensitive(sensitive_path: &Path) -> Result<PathBuf> {
    let filename = sensitive_path.file_name().context("sensitive cache path has no filename")?;
    Ok(sensitive_path.with_file_name(format!("{}.recovery.json", filename.to_string_lossy())))
}

fn signed_payload_hash<N: Network>(payload: &Bytes) -> Result<B256>
where
    N::TxEnvelope: Decodable2718 + Encodable2718,
{
    Ok(N::TxEnvelope::decode_2718_exact(payload)
        .wrap_err("recovery snapshot contains an invalid signed payload")?
        .trie_hash())
}

fn validate_signed_payload<N: Network>(
    payload: Bytes,
    planned: &TransactionWithMetadata<N>,
    chain: u64,
    index: usize,
    ordinal: usize,
) -> Result<SignedPayload>
where
    N::TxEnvelope: SignerRecoverable,
    N::TransactionRequest: FoundryTransactionBuilder<N>,
{
    let envelope = N::TxEnvelope::decode_2718_exact(&payload)
        .wrap_err("recovery snapshot contains an invalid signed payload")?;
    let signer = envelope
        .recover_signer()
        .wrap_err("recovery snapshot signed payload has an invalid signature")?;
    let transaction = planned.tx();
    let chain_matches = match transaction {
        TransactionMaybeSigned::Signed { tx, .. } => {
            envelope.trie_hash() == tx.trie_hash() && tx.chain_id().is_none_or(|id| id == chain)
        }
        TransactionMaybeSigned::Unsigned(_) => envelope.chain_id() == Some(chain),
    };
    // The planned nonce is the sender's sequential nonce. A Tempo expiring nonce transaction
    // never reads nonce state and is signed with 0 or, from T12, with its complete-plan ordinal as
    // the TIP-1106 discriminator. Accept sequence-local indices from older recovery snapshots
    // too.
    let nonce = envelope.nonce();
    let nonce_matches = transaction.nonce() == Some(nonce)
        || ((nonce == 0 || nonce == ordinal as u64 || nonce == index as u64)
            && <N::TransactionRequest as From<N::TxEnvelope>>::from(envelope.clone()).nonce_key()
                == Some(TEMPO_EXPIRING_NONCE_KEY));
    if transaction.from() != Some(signer)
        || !chain_matches
        || !nonce_matches
        || transaction.to() != envelope.to()
        || transaction.value().unwrap_or_default() != envelope.value()
        || transaction.input().cloned().unwrap_or_default() != *envelope.input()
        || transaction.authorization_list().as_deref().unwrap_or_default()
            != envelope.authorization_list().unwrap_or_default()
    {
        bail!("signed payload does not match its planned transaction");
    }
    Ok(SignedPayload { hash: envelope.trie_hash(), payload })
}

fn validate_delegated_transaction<N: Network>(
    transaction: &N::TransactionResponse,
    planned: &N::TransactionRequest,
    chain: u64,
    hash: B256,
) -> Result<()>
where
    N::TransactionRequest: FoundryTransactionBuilder<N>,
{
    // Preserve network-specific execution fields while allowing the signer to choose gas and fees.
    let resolved =
        <N::TransactionRequest as From<N::TransactionResponse>>::from(transaction.clone());
    let sender = planned.from().context("delegated request has no sender")?;
    let planned_tempo_aa = planned.is_tempo_aa();
    let resolved_tempo_aa = resolved.is_tempo_aa();
    let planned_fields = serde_json::to_value(planned)?;
    let resolved_fields = serde_json::to_value(&resolved)?;
    let same = |field: &str| planned_fields.get(field) == resolved_fields.get(field);
    let same_list = |field: &str| {
        let empty = serde_json::Value::Array(Vec::new());
        planned_fields.get(field).filter(|value| !value.is_null()).unwrap_or(&empty)
            == resolved_fields.get(field).filter(|value| !value.is_null()).unwrap_or(&empty)
    };
    if transaction.tx_hash() != hash
        || transaction.from() != sender
        || transaction.chain_id() != Some(chain)
        || planned.chain_id() != Some(chain)
        || transaction.nonce() != planned.nonce().context("delegated request has no nonce")?
        || planned_tempo_aa != resolved_tempo_aa
        // A missing `to` and `TxKind::Create` both describe a contract creation.
        || (!planned_tempo_aa
            && (resolved.kind().unwrap_or(TxKind::Create)
                != planned.kind().unwrap_or(TxKind::Create)
                || resolved.value().unwrap_or_default() != planned.value().unwrap_or_default()
                || resolved.input().unwrap_or_default() != planned.input().unwrap_or_default()))
        || transaction.authorization_list().unwrap_or_default()
            != planned.authorization_list().map(Vec::as_slice).unwrap_or_default()
        || planned.access_list().filter(|list| !list.is_empty())
            != resolved.access_list().filter(|list| !list.is_empty())
        || planned.blob_versioned_hashes().filter(|hashes| !hashes.is_empty())
            != resolved.blob_versioned_hashes().filter(|hashes| !hashes.is_empty())
        || (planned_tempo_aa
            && canonical_tempo_calls::<N>(planned, &planned_fields)?
                != canonical_tempo_calls::<N>(&resolved, &resolved_fields)?)
        || !same_list("aaAuthorizationList")
        || planned.nonce_key().unwrap_or_default() != resolved.nonce_key().unwrap_or_default()
        || planned.fee_token() != resolved.fee_token()
        || planned.valid_before() != resolved.valid_before()
        || planned.valid_after() != resolved.valid_after()
        || !same("keyAuthorization")
        || delegated_fee_payer::<N>(planned, sender)?
            != delegated_fee_payer::<N>(&resolved, sender)?
    {
        bail!("resolved transaction does not match its delegated submission attempt");
    }
    Ok(())
}

fn canonical_tempo_calls<N: Network>(
    request: &N::TransactionRequest,
    fields: &serde_json::Value,
) -> Result<Vec<serde_json::Value>> {
    let mut calls =
        fields.get("calls").and_then(serde_json::Value::as_array).cloned().unwrap_or_default();
    if let Some(to) = request.kind() {
        calls.push(serde_json::to_value(tempo_primitives::transaction::Call {
            to,
            value: request.value().unwrap_or_default(),
            input: request.input().cloned().unwrap_or_default(),
        })?);
    }
    Ok(calls)
}

fn delegated_fee_payer<N: Network>(
    request: &N::TransactionRequest,
    sender: Address,
) -> Result<Option<Address>>
where
    N::TransactionRequest: FoundryTransactionBuilder<N>,
{
    let Some(signature) = request.fee_payer_signature() else { return Ok(None) };
    let hash = request
        .compute_sponsor_hash(sender)
        .context("failed to compute delegated Tempo sponsor hash")?;
    Ok(Some(
        signature
            .recover_address_from_prehash(&hash)
            .wrap_err("failed to recover delegated Tempo sponsor")?,
    ))
}

fn write_snapshot<N: Network>(path: &Path, plan: &RecoveryPlan<N>) -> Result<()>
where
    N::TxEnvelope: Serialize,
{
    let pending = pending_path(path);
    write_plan(&pending, plan)?;
    commit_pending_plan(&pending, path)
}

fn write_plan<N: Network>(path: &Path, plan: &RecoveryPlan<N>) -> Result<()>
where
    N::TxEnvelope: Serialize,
{
    let parent = path.parent().context("recovery plan has no parent directory")?;
    std::fs::create_dir_all(parent)?;
    let mut tmp = NamedTempFile::new_in(parent)?;
    #[cfg(unix)]
    tmp.as_file().set_permissions(std::fs::Permissions::from_mode(0o600))?;
    {
        let mut writer = BufWriter::new(tmp.as_file_mut());
        serde_json::to_writer_pretty(&mut writer, plan)?;
        writer.flush()?;
    }
    tmp.as_file().sync_all()?;
    tmp.persist(path).map_err(|error| error.error)?;
    #[cfg(unix)]
    File::open(parent)?.sync_all()?;
    Ok(())
}

/// Tempo replay protection excludes sponsor signatures from T1B onward.
fn expiring_replay_hash(payload: &[u8], sender_scoped_replay: bool) -> Result<Option<B256>> {
    if let Ok(TempoTxEnvelope::AA(tx)) = TempoTxEnvelope::decode_2718_exact(payload)
        && tx.tx().is_expiring_nonce_tx()
    {
        return Ok(Some(if sender_scoped_replay {
            tx.expiring_nonce_hash(tx.recover_signer()?)
        } else {
            *tx.hash()
        }));
    }
    Ok(None)
}

#[cfg(test)]
mod tests {
    use super::*;
    use alloy_consensus::{
        Eip658Value, Receipt, ReceiptEnvelope, ReceiptWithBloom, SignableTransaction, TxEip1559,
        TxEnvelope, transaction::Recovered,
    };
    use alloy_network::Ethereum;
    use alloy_primitives::{Bloom, Signature, U256, hex};
    use alloy_rpc_types::{Transaction as RpcTransaction, TransactionReceipt, TransactionRequest};
    use alloy_signer::SignerSync;
    use tempo_alloy::{TempoNetwork, rpc::TempoTransactionRequest};
    use tempo_primitives::{
        AASigned, TempoSignature,
        transaction::{Call, PrimitiveSignature},
    };

    const SIGNED_TX: &[u8] = &hex!(
        "02f86b0180843b9aca008502540be4008252089400000000000000000000000000000000000000016480c001a070d55e79ed3ac9fc8f51e78eb91fd054720d943d66633f2eb1bc960f0126b0eca052eda05a792680de3181e49bab4093541f75b49d1ecbe443077b3660c836016a"
    );
    const OTHER_SIGNED_TX: &[u8] = &hex!(
        "02f86b0180843b9aca008502540be4008252089400000000000000000000000000000000000000018080c001a0cce9a61187b5d18a89ecd27ec675e3b3f10d37f165627ef89a15a7fe76395ce8a07537f5bffb358ffbef22cda84b1c92f7211723f9e09ae037e81686805d3e5505"
    );

    const ROOT_PRIVATE_KEY: &str =
        "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";

    fn sequence(dir: &Path) -> SequenceData<Ethereum> {
        let mut transaction = TransactionWithMetadata::from_tx_request(
            TransactionMaybeSigned::Unsigned(Default::default()),
        );
        transaction.rpc = "http://localhost:8545".to_string();
        let mut sequence = forge_script_sequence::ScriptSequence::default();
        sequence.transactions.push_back(transaction);
        sequence.paths = Some((dir.join("broadcast.json"), dir.join("cache.json")));
        SequenceData::Single(Box::new(sequence))
    }

    fn signed_sequence(dir: &Path) -> SequenceData<Ethereum> {
        let transactions = [SIGNED_TX, OTHER_SIGNED_TX].map(|payload| {
            let envelope = TxEnvelope::decode_2718_exact(payload).unwrap();
            let from = envelope.recover_signer().unwrap();
            let mut request: TransactionRequest = envelope.into();
            request.from = Some(from);
            TransactionWithMetadata::from_tx_request(TransactionMaybeSigned::new(request))
        });
        let mut sequence = forge_script_sequence::ScriptSequence {
            chain: 1,
            transactions: transactions.into(),
            ..Default::default()
        };
        sequence.paths = Some((dir.join("broadcast.json"), dir.join("cache.json")));
        SequenceData::Single(Box::new(sequence))
    }

    fn delegated_transaction(payload: &[u8]) -> (TransactionRequest, RpcTransaction) {
        let envelope = TxEnvelope::decode_2718_exact(payload).unwrap();
        let from = envelope.recover_signer().unwrap();
        let mut request: TransactionRequest = envelope.clone().into();
        request.from = Some(from);
        let transaction = RpcTransaction {
            inner: Recovered::new_unchecked(envelope, from),
            block_hash: None,
            block_number: None,
            transaction_index: None,
            effective_gas_price: None,
            block_timestamp: None,
        };
        (request, transaction)
    }

    fn tempo_transaction(
        request: TempoTransactionRequest,
        from: Address,
    ) -> RpcTransaction<TempoTxEnvelope> {
        let envelope =
            TempoTxEnvelope::AA(request.build_aa().unwrap().into_signed(TempoSignature::default()));
        RpcTransaction {
            inner: Recovered::new_unchecked(envelope, from),
            block_hash: None,
            block_number: None,
            transaction_index: None,
            effective_gas_price: None,
            block_timestamp: None,
        }
    }

    #[test]
    fn expiring_signed_payload_accepts_complete_plan_ordinal_and_legacy_index() {
        let signer = foundry_wallets::utils::create_local_signer(ROOT_PRIVATE_KEY).unwrap();
        let request = expiring_request(signer.address(), 4217, 8);
        let planned =
            TransactionWithMetadata::from_tx_request(TransactionMaybeSigned::new(request.clone()));
        for nonce in [0, 1, 3, 4] {
            let mut request = request.clone();
            request.inner.nonce = Some(nonce);
            let payload = sign_tempo_payload(request, &signer);
            assert_eq!(
                validate_signed_payload::<TempoNetwork>(payload, &planned, 4217, 1, 3).is_ok(),
                nonce != 4
            );
        }
    }

    #[test]
    fn identical_expiring_payload_is_rejected_across_same_chain_sequences() {
        let dir = tempfile::tempdir().unwrap();
        let signer = foundry_wallets::utils::create_local_signer(ROOT_PRIVATE_KEY).unwrap();
        // A -> B -> A: the planned nonce on A advances, the signed expiring nonce stays 0.
        let deployments = [(4217, 0), (4218, 0), (4217, 1)]
            .map(|(chain, nonce)| ScriptSequence::<TempoNetwork> {
                chain,
                transactions: [TransactionWithMetadata::from_tx_request(
                    TransactionMaybeSigned::new(expiring_request(signer.address(), chain, nonce)),
                )]
                .into(),
                ..Default::default()
            })
            .into();
        let data = SequenceData::Multi(MultiChainSequence {
            deployments,
            path: dir.path().join("broadcast.json"),
            sensitive_path: dir.path().join("cache.json"),
            timestamp: 0,
        });
        let payload = sign_tempo_payload(expiring_request(signer.address(), 4217, 0), &signer);

        let mut store = RecoveryStore::create(data, false, None).unwrap();
        let hash = store.persist_signed_payload(0, 0, payload.clone(), true).unwrap();
        assert_eq!(
            store.persist_signed_payload(2, 0, payload, true).unwrap_err().to_string(),
            format!(
                "transaction 0 is identical to an earlier transaction of this script ({hash}) and would be rejected as a replay; identical Tempo expiring nonce transactions are only distinct from the T12 hardfork (TIP-1106)"
            )
        );
    }

    fn sign_tempo_sponsor(
        request: &mut TempoTransactionRequest,
        from: Address,
        sponsor: &impl SignerSync,
    ) {
        request.fee_payer_signature = None;
        let hash = request.compute_sponsor_hash(from).unwrap();
        request.fee_payer_signature = Some(sponsor.sign_hash_sync(&hash).unwrap());
    }

    fn load(paths: &(PathBuf, PathBuf), batch: bool) -> Result<RecoveryStore<Ethereum>> {
        let lock = RecoveryLock::acquire(paths)?;
        RecoveryStore::load(paths, batch, lock)?.context("missing recovery snapshot")
    }

    #[test]
    fn snapshot_is_versioned_private_and_locks_writers() {
        let dir = tempfile::tempdir().unwrap();
        let data = sequence(dir.path());
        let paths = data.paths();
        let store = RecoveryStore::create(data, false, None).unwrap();
        let value: serde_json::Value = foundry_common::fs::read_json_file(&store.path).unwrap();
        assert_eq!(value["version"], RECOVERY_VERSION);
        assert_eq!(value["deployments"][0]["operations"][0]["id"]["sequence"], 0);
        assert_eq!(value["deployments"][0]["operations"][0]["id"]["index"], 0);
        assert!(value["deployments"][0]["operations"][0]["fingerprint"].is_string());
        assert!(value["deployments"][0]["operations"][0].get("transaction").is_none());
        assert!(RecoveryLock::acquire(&paths).is_err());
        #[cfg(unix)]
        assert_eq!(store.path.metadata().unwrap().permissions().mode() & 0o777, 0o600);
    }

    #[test]
    fn snapshot_recovers_without_compatibility_exports() {
        let dir = tempfile::tempdir().unwrap();
        let data = sequence(dir.path());
        let paths = data.paths();
        let hash = B256::repeat_byte(0x11);
        {
            let mut store = RecoveryStore::create(data, false, None).unwrap();
            let deployment = &mut store.data_mut().sequences_mut()[0];
            deployment.transactions[0].hash = Some(hash);
            deployment.pending.push(hash);
            store.save().unwrap();
        }
        for path in [&paths.0, &paths.1] {
            assert!(!path.exists());
        }

        let store = load(&paths, false).unwrap();
        let deployment = &store.data().sequences()[0];
        assert_eq!(deployment.transactions[0].hash, Some(hash));
        assert_eq!(deployment.pending, [hash]);
        store.data().publish(&paths).unwrap();
        assert!(paths.0.exists());
        assert!(paths.1.exists());
    }

    #[test]
    fn snapshot_ignores_stale_compatibility_exports() {
        let dir = tempfile::tempdir().unwrap();
        let data = sequence(dir.path());
        let paths = data.paths();
        let hash = B256::repeat_byte(0x22);
        {
            let mut store = RecoveryStore::create(data.clone(), false, None).unwrap();
            store.data_mut().sequences_mut()[0].transactions[0].hash = Some(hash);
            store.save().unwrap();
        }
        data.publish(&paths).unwrap();

        let store = load(&paths, false).unwrap();
        assert_eq!(store.data().sequences()[0].transactions[0].hash, Some(hash));
    }

    #[test]
    fn corrupt_snapshot_fails_closed_even_with_valid_exports() {
        let dir = tempfile::tempdir().unwrap();
        let data = sequence(dir.path());
        let paths = data.paths();
        data.publish(&paths).unwrap();
        let snapshot = {
            let store = RecoveryStore::create(data, false, None).unwrap();
            store.path
        };
        std::fs::write(snapshot, b"{").unwrap();

        assert!(load(&paths, false).err().unwrap().to_string().contains("is corrupt"));
    }

    #[test]
    fn interrupted_snapshot_replacement_is_recovered() {
        let dir = tempfile::tempdir().unwrap();
        let data = sequence(dir.path());
        let paths = data.paths();
        let hash = B256::repeat_byte(0x33);
        let snapshot = {
            let mut store = RecoveryStore::create(data, false, None).unwrap();
            store.data_mut().sequences_mut()[0].pending.push(hash);
            write_plan(&pending_path(&store.path), &store.plan).unwrap();
            store.path.clone()
        };

        let store = load(&paths, false).unwrap();
        assert_eq!(store.data().sequences()[0].pending, [hash]);
        assert!(snapshot.exists());
        assert!(!pending_path(&snapshot).exists());
    }

    #[test]
    fn changed_operations_fail_closed() {
        let dir = tempfile::tempdir().unwrap();
        let mut store = RecoveryStore::create(sequence(dir.path()), false, None).unwrap();
        store.data_mut().sequences_mut()[0].transactions.clear();
        assert!(store.save().unwrap_err().to_string().contains("does not match"));
    }

    #[test]
    fn relocation_preserves_the_authoritative_snapshot() {
        let dir = tempfile::tempdir().unwrap();
        let data = sequence(dir.path());
        let source_paths = data.paths();
        let mut store = RecoveryStore::create(data, false, None).unwrap();
        let destination = dir.path().join("broadcast-cache.json");
        let destination_snapshot = recovery_path_from_sensitive(&destination).unwrap();
        let paths = (dir.path().join("broadcasted.json"), destination);
        let relocation = store.prepare_relocation(&paths).unwrap();
        assert!(RecoveryLock::acquire(&source_paths).is_err());
        store.commit_relocation(relocation).unwrap();
        assert_eq!(store.path, destination_snapshot);
        assert!(destination_snapshot.exists());
        RecoveryLock::acquire(&source_paths).unwrap();
    }

    #[test]
    fn signed_payload_is_immutable_and_survives_reload() {
        let dir = tempfile::tempdir().unwrap();
        let data = signed_sequence(dir.path());
        let paths = data.paths();
        let expected_hash = {
            let mut store = RecoveryStore::create(data, false, None).unwrap();
            let hash = store.persist_signed_payload(0, 0, SIGNED_TX.into(), true).unwrap();
            assert!(store.persist_signed_payload(0, 0, OTHER_SIGNED_TX.into(), true).is_err());
            hash
        };

        let store = load(&paths, false).unwrap();
        let signed = store.signed_payload(0, 0).unwrap();
        assert_eq!(signed.payload.as_ref(), SIGNED_TX);
        assert_eq!(signed.hash, expected_hash);
    }

    #[test]
    fn signed_payload_is_bound_to_its_planned_operation() {
        let dir = tempfile::tempdir().unwrap();
        let mut store = RecoveryStore::create(signed_sequence(dir.path()), false, None).unwrap();

        assert!(store.persist_signed_payload(1, 0, SIGNED_TX.into(), true).is_err());
        assert!(store.persist_signed_payload(0, 1, SIGNED_TX.into(), true).is_err());
    }

    #[test]
    fn delegated_submission_is_immutable_and_survives_reload() {
        let dir = tempfile::tempdir().unwrap();
        let data = sequence(dir.path());
        let paths = data.paths();
        let request = TransactionRequest::default();
        let hash = B256::repeat_byte(0x42);
        {
            let mut store = RecoveryStore::create(data, false, None).unwrap();
            store.persist_delegated_request(0, 0, request).unwrap();
            store.persist_delegated_status(0, 0, DelegatedStatus::Pending { hash }).unwrap();
            assert!(store.persist_delegated_request(0, 0, Default::default()).is_err());
        }

        let store = load(&paths, false).unwrap();
        assert!(
            matches!(store.delegated_status(0, 0), Some(DelegatedStatus::Pending { hash: value }) if value == hash)
        );
    }

    #[test]
    fn delegated_resolution_is_bound_to_its_planned_transaction() {
        let (mut request, transaction) = delegated_transaction(SIGNED_TX);
        let hash = transaction.tx_hash();
        validate_delegated_transaction::<Ethereum>(&transaction, &request, 1, hash).unwrap();

        request.gas = Some(100_000);
        request.max_fee_per_gas = Some(10_000);
        validate_delegated_transaction::<Ethereum>(&transaction, &request, 1, hash).unwrap();

        request.blob_versioned_hashes = Some(vec![B256::repeat_byte(0x42)]);
        assert!(
            validate_delegated_transaction::<Ethereum>(&transaction, &request, 1, hash).is_err()
        );

        let (other, _) = delegated_transaction(OTHER_SIGNED_TX);
        assert!(validate_delegated_transaction::<Ethereum>(&transaction, &other, 1, hash).is_err());
    }

    #[test]
    fn delegated_resolution_matches_creations_by_kind() {
        let from = Address::repeat_byte(0x11);
        let transaction = |to: TxKind| {
            let envelope = TxEnvelope::Eip1559(
                TxEip1559 {
                    chain_id: 1,
                    gas_limit: 100_000,
                    max_fee_per_gas: 1,
                    max_priority_fee_per_gas: 1,
                    to,
                    input: Bytes::from_static(&[0x60, 0x00]),
                    ..Default::default()
                }
                .into_signed(Signature::test_signature()),
            );
            RpcTransaction {
                inner: Recovered::new_unchecked(envelope, from),
                block_hash: None,
                block_number: None,
                transaction_index: None,
                effective_gas_price: None,
                block_timestamp: None,
            }
        };
        // Serialize the planned request the same way the recovery snapshot stores it.
        let planned = |to: TxKind| {
            let mut request: TransactionRequest = transaction(to).inner.into_inner().into();
            request.from = Some(from);
            serde_json::from_value::<TransactionRequest>(serde_json::to_value(request).unwrap())
                .unwrap()
        };
        let validate = |transaction: &RpcTransaction, planned: &TransactionRequest| {
            validate_delegated_transaction::<Ethereum>(
                transaction,
                planned,
                1,
                transaction.tx_hash(),
            )
        };
        let create = transaction(TxKind::Create);
        let call = transaction(TxKind::Call(Address::repeat_byte(0x22)));
        assert_eq!(planned(TxKind::Create).to, None);

        validate(&create, &planned(TxKind::Create)).unwrap();
        validate(&call, &planned(TxKind::Call(Address::repeat_byte(0x22)))).unwrap();
        assert!(validate(&create, &planned(TxKind::Call(Address::repeat_byte(0x22)))).is_err());
        assert!(validate(&call, &planned(TxKind::Create)).is_err());
        assert!(validate(&call, &planned(TxKind::Call(Address::repeat_byte(0x33)))).is_err());
    }

    #[test]
    fn delegated_tempo_resolution_matches_creations_by_kind() {
        let from = Address::repeat_byte(0x11);
        let transaction = |to: TxKind| {
            let envelope = TempoTxEnvelope::Eip1559(
                TxEip1559 {
                    chain_id: 4217,
                    gas_limit: 100_000,
                    max_fee_per_gas: 1,
                    max_priority_fee_per_gas: 1,
                    to,
                    input: Bytes::from_static(&[0x60, 0x00]),
                    ..Default::default()
                }
                .into_signed(Signature::test_signature()),
            );
            RpcTransaction {
                inner: Recovered::new_unchecked(envelope, from),
                block_hash: None,
                block_number: None,
                transaction_index: None,
                effective_gas_price: None,
                block_timestamp: None,
            }
        };
        // Serialize the planned request the same way the recovery snapshot stores it.
        let planned = |to: TxKind| {
            let mut request = <TempoTransactionRequest as From<_>>::from(transaction(to));
            request.inner.from = Some(from);
            serde_json::from_value::<TempoTransactionRequest>(
                serde_json::to_value(request).unwrap(),
            )
            .unwrap()
        };
        let validate = |transaction: &RpcTransaction<TempoTxEnvelope>,
                        planned: &TempoTransactionRequest| {
            validate_delegated_transaction::<TempoNetwork>(
                transaction,
                planned,
                4217,
                transaction.tx_hash(),
            )
        };
        let create = transaction(TxKind::Create);
        let call = transaction(TxKind::Call(Address::repeat_byte(0x22)));
        assert_eq!(planned(TxKind::Create).inner.to, None);
        assert!(!planned(TxKind::Create).is_tempo_aa());

        validate(&create, &planned(TxKind::Create)).unwrap();
        validate(&call, &planned(TxKind::Call(Address::repeat_byte(0x22)))).unwrap();
        assert!(validate(&create, &planned(TxKind::Call(Address::repeat_byte(0x22)))).is_err());
        assert!(validate(&call, &planned(TxKind::Create)).is_err());
    }

    #[test]
    fn delegated_tempo_resolution_checks_nonce_domain_and_calls() {
        let from = Address::repeat_byte(0x11);
        let resolved = TempoTransactionRequest {
            inner: TransactionRequest {
                from: Some(from),
                gas: Some(0),
                max_fee_per_gas: Some(0),
                max_priority_fee_per_gas: Some(0),
                nonce: Some(0),
                chain_id: Some(4217),
                ..Default::default()
            },
            nonce_key: Some(U256::from(7)),
            calls: vec![
                Call {
                    to: TxKind::Call(Address::repeat_byte(0x22)),
                    value: U256::ONE,
                    input: Bytes::from_static(&[0x12]),
                },
                Call {
                    to: TxKind::Call(Address::repeat_byte(0x33)),
                    value: U256::from(2),
                    input: Bytes::from_static(&[0x34]),
                },
            ],
            ..Default::default()
        };
        let transaction = tempo_transaction(resolved, from);
        let mut request = <TempoTransactionRequest as From<_>>::from(transaction.clone());
        request.from = Some(from);
        let hash = transaction.tx_hash();
        validate_delegated_transaction::<TempoNetwork>(&transaction, &request, 4217, hash).unwrap();
        assert!(
            validate_delegated_transaction::<TempoNetwork>(
                &transaction,
                &request,
                4217,
                B256::ZERO,
            )
            .is_err()
        );

        request.valid_before = std::num::NonZeroU64::new(1);
        assert!(
            validate_delegated_transaction::<TempoNetwork>(&transaction, &request, 4217, hash)
                .is_err()
        );
        request.valid_before = None;
        request.fee_token = Some(Address::repeat_byte(0x44));
        assert!(
            validate_delegated_transaction::<TempoNetwork>(&transaction, &request, 4217, hash)
                .is_err()
        );
        request.fee_token = None;

        let top_level = request.calls.pop().unwrap();
        request.inner.to = Some(top_level.to);
        request.inner.value = Some(top_level.value);
        request.inner.input = top_level.input.into();
        validate_delegated_transaction::<TempoNetwork>(&transaction, &request, 4217, hash).unwrap();

        request.nonce_key = Some(U256::from(8));
        assert!(
            validate_delegated_transaction::<TempoNetwork>(&transaction, &request, 4217, hash)
                .is_err()
        );
        request.nonce_key = Some(U256::from(7));
        request.calls.push(Call {
            to: request.inner.to.take().unwrap(),
            value: request.inner.value.take().unwrap(),
            input: request.inner.input.input.take().unwrap(),
        });
        request.calls.swap(0, 1);
        assert!(
            validate_delegated_transaction::<TempoNetwork>(&transaction, &request, 4217, hash)
                .is_err()
        );
    }

    #[test]
    fn delegated_tempo_resolution_checks_sponsor_identity() {
        let from = Address::repeat_byte(0x11);
        let sponsor = foundry_wallets::utils::create_local_signer(
            "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
        )
        .unwrap();
        let other_sponsor = foundry_wallets::utils::create_local_signer(
            "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d",
        )
        .unwrap();
        assert_ne!(sponsor.address(), other_sponsor.address());

        let mut planned = TempoTransactionRequest {
            inner: TransactionRequest {
                from: Some(from),
                to: Some(TxKind::Call(Address::repeat_byte(0x22))),
                gas: Some(100_000),
                max_fee_per_gas: Some(10),
                max_priority_fee_per_gas: Some(1),
                nonce: Some(0),
                chain_id: Some(4217),
                ..Default::default()
            },
            nonce_key: Some(U256::from(7)),
            ..Default::default()
        };
        sign_tempo_sponsor(&mut planned, from, &sponsor);

        let mut resolved = planned.clone();
        resolved.inner.gas = Some(120_000);
        resolved.inner.max_fee_per_gas = Some(12);
        sign_tempo_sponsor(&mut resolved, from, &sponsor);
        let transaction = tempo_transaction(resolved.clone(), from);
        validate_delegated_transaction::<TempoNetwork>(
            &transaction,
            &planned,
            4217,
            transaction.tx_hash(),
        )
        .unwrap();

        resolved.fee_payer_signature = None;
        let transaction = tempo_transaction(resolved.clone(), from);
        assert!(
            validate_delegated_transaction::<TempoNetwork>(
                &transaction,
                &planned,
                4217,
                transaction.tx_hash(),
            )
            .is_err()
        );

        sign_tempo_sponsor(&mut resolved, from, &other_sponsor);
        let transaction = tempo_transaction(resolved, from);
        assert!(
            validate_delegated_transaction::<TempoNetwork>(
                &transaction,
                &planned,
                4217,
                transaction.tx_hash(),
            )
            .is_err()
        );
    }

    #[test]
    fn definite_non_submission_clears_delegated_request() {
        let dir = tempfile::tempdir().unwrap();
        let data = sequence(dir.path());
        let paths = data.paths();
        let mut store = RecoveryStore::create(data, false, None).unwrap();
        store.persist_delegated_request(0, 0, Default::default()).unwrap();
        store.clear_delegated_request(0, 0).unwrap();
        assert!(store.delegated_status(0, 0).is_none());
        drop(store);

        assert!(load(&paths, false).unwrap().delegated_status(0, 0).is_none());
    }

    #[test]
    fn batch_attempt_uses_shared_membership_and_survives_reload() {
        let dir = tempfile::tempdir().unwrap();
        let data = signed_sequence(dir.path());
        let paths = data.paths();
        let request = TransactionRequest::default();
        {
            let mut store = RecoveryStore::create(data, true, None).unwrap();
            store.persist_batch_signed_payload(0, 0, request.clone(), SIGNED_TX.into()).unwrap();
            assert!(store.persist_signed_payload(0, 1, OTHER_SIGNED_TX.into(), true).is_err());
        }

        let store = load(&paths, true).unwrap();
        let Some((0, _, AttemptKind::Signed { request: Some(saved), .. })) = store.batch_attempt(0)
        else {
            panic!("expected signed batch attempt");
        };
        assert_eq!(saved, &request);
    }

    #[test]
    fn batch_attempt_rejects_conflicting_progress() {
        let foreign = B256::repeat_byte(0x66);
        for (transaction_hash, pending) in [(Some(foreign), vec![]), (None, vec![foreign])] {
            let dir = tempfile::tempdir().unwrap();
            let data = signed_sequence(dir.path());
            let paths = data.paths();
            {
                let mut store = RecoveryStore::create(data, true, None).unwrap();
                store
                    .persist_batch_signed_payload(
                        0,
                        0,
                        TransactionRequest::default(),
                        SIGNED_TX.into(),
                    )
                    .unwrap();
                let deployment = &mut store.data_mut().sequences_mut()[0];
                deployment.transactions[0].hash = transaction_hash;
                deployment.pending = pending;
                write_snapshot(&store.path, &store.plan).unwrap();
            }

            assert!(load(&paths, true).is_err());
        }
    }

    #[test]
    fn batch_progress_without_an_attempt_fails_closed() {
        let dir = tempfile::tempdir().unwrap();
        let data = signed_sequence(dir.path());
        let paths = data.paths();
        {
            let mut store = RecoveryStore::create(data, true, None).unwrap();
            store.data_mut().sequences_mut()[0].pending.push(B256::repeat_byte(0x77));
            write_snapshot(&store.path, &store.plan).unwrap();
        }

        assert!(load(&paths, true).is_err());
    }

    #[test]
    fn legacy_batch_import_requires_one_consistent_pending_hash() {
        let dir = tempfile::tempdir().unwrap();
        let mut data = signed_sequence(dir.path());
        let paths = data.paths();
        let hash = B256::repeat_byte(0x55);
        let deployment = &mut data.sequences_mut()[0];
        for transaction in &mut deployment.transactions {
            transaction.hash = Some(hash);
        }
        deployment.pending.push(hash);
        let store =
            RecoveryStore::import(data, true, RecoveryLock::acquire(&paths).unwrap()).unwrap();
        assert!(
            matches!(store.batch_attempt(0), Some((0, _, AttemptKind::Legacy { hash: saved })) if *saved == hash)
        );
        drop(store);

        let other = tempfile::tempdir().unwrap();
        let mut data = signed_sequence(other.path());
        let paths = data.paths();
        let deployment = &mut data.sequences_mut()[0];
        deployment.transactions[1].hash = Some(hash);
        deployment.pending.push(hash);
        assert!(RecoveryStore::import(data, true, RecoveryLock::acquire(&paths).unwrap()).is_err());
    }

    #[test]
    fn legacy_batch_import_accepts_a_receipted_prefix() {
        let dir = tempfile::tempdir().unwrap();
        let mut data = signed_sequence(dir.path());
        let paths = data.paths();
        let completed = B256::repeat_byte(0x44);
        let pending = B256::repeat_byte(0x55);
        let deployment = &mut data.sequences_mut()[0];
        deployment.transactions[0].hash = Some(completed);
        deployment.transactions[1].hash = Some(pending);
        let completed_receipt = TransactionReceipt {
            inner: ReceiptEnvelope::Legacy(ReceiptWithBloom {
                receipt: Receipt {
                    status: Eip658Value::success(),
                    cumulative_gas_used: 0,
                    logs: Vec::new(),
                },
                logs_bloom: Bloom::ZERO,
            }),
            transaction_hash: completed,
            transaction_index: None,
            block_hash: None,
            block_number: None,
            gas_used: 0,
            effective_gas_price: 0,
            blob_gas_used: None,
            blob_gas_price: None,
            from: Address::ZERO,
            to: None,
            contract_address: None,
        };
        deployment.receipts.push(completed_receipt);
        deployment.pending.push(pending);

        let store =
            RecoveryStore::import(data, true, RecoveryLock::acquire(&paths).unwrap()).unwrap();
        assert!(
            matches!(store.batch_attempt(0), Some((1, _, AttemptKind::Legacy { hash })) if *hash == pending)
        );
    }

    #[test]
    fn rejected_legacy_batch_import_does_not_publish_a_snapshot() {
        let dir = tempfile::tempdir().unwrap();
        let mut data = signed_sequence(dir.path());
        let paths = data.paths();
        data.sequences_mut()[0].transactions[0].hash = Some(B256::repeat_byte(0x55));
        let snapshot = recovery_path_from_sensitive(&paths.1).unwrap();

        assert!(RecoveryStore::import(data, true, RecoveryLock::acquire(&paths).unwrap()).is_err());
        assert!(!snapshot.exists());
    }

    #[test]
    fn expiring_replay_guard_ignores_sponsor_changes_and_keeps_discriminators() {
        let dir = tempfile::tempdir().unwrap();
        let sender = foundry_wallets::utils::create_local_signer(ROOT_PRIVATE_KEY).unwrap();
        let sponsor = foundry_wallets::utils::create_local_signer(
            "0x59c6995e998f97a5a004497e5da3b5d2b2b66a87f064d39c44da0b6d6e4f8ff0",
        )
        .unwrap();
        let request = |nonce| expiring_request(sender.address(), 4217, nonce);
        let data = SequenceData::Multi(MultiChainSequence {
            deployments: [0, 1]
                .map(|nonce| ScriptSequence::<TempoNetwork> {
                    chain: 4217,
                    transactions: [TransactionWithMetadata::from_tx_request(
                        TransactionMaybeSigned::new(request(nonce)),
                    )]
                    .into(),
                    ..Default::default()
                })
                .into(),
            path: dir.path().join("broadcast.json"),
            sensitive_path: dir.path().join("cache.json"),
            timestamp: 0,
        });
        let payload = |nonce, sponsor: &_| {
            let mut request = request(nonce);
            sign_tempo_sponsor(&mut request, sender.address(), sponsor);
            sign_tempo_payload(request, &sender)
        };
        let first = payload(0, &sender);
        let duplicate = payload(0, &sponsor);
        assert_ne!(
            signed_payload_hash::<TempoNetwork>(&first).unwrap(),
            signed_payload_hash::<TempoNetwork>(&duplicate).unwrap()
        );
        assert_eq!(
            expiring_replay_hash(&first, true).unwrap(),
            expiring_replay_hash(&duplicate, true).unwrap()
        );
        let mut store = RecoveryStore::create(data, false, None).unwrap();
        let first_hash = store.persist_signed_payload(0, 0, first, true).unwrap();
        assert_eq!(store.signed_payload(0, 0).unwrap().hash, first_hash);
        let snapshot = std::fs::read(&store.path).unwrap();
        let duplicate_hash = signed_payload_hash::<TempoNetwork>(&duplicate).unwrap();
        assert_eq!(
            store.persist_signed_payload(1, 0, duplicate.clone(), true).unwrap_err().to_string(),
            format!(
                "transaction 0 is identical to an earlier transaction of this script ({duplicate_hash}) and would be rejected as a replay; identical Tempo expiring nonce transactions are only distinct from the T12 hardfork (TIP-1106)"
            )
        );
        assert!(store.signed_payload(1, 0).is_none());
        assert_eq!(std::fs::read(&store.path).unwrap(), snapshot);
        // Older snapshots may already contain a conflicting durable attempt.
        let id = store.plan.deployments[1].operations[0].id;
        store.plan.deployments[1].attempts.push(SubmissionAttempt {
            id: B256::random(),
            members: vec![id],
            kind: AttemptKind::Signed {
                request: None,
                payload: SignedPayload { payload: duplicate.clone(), hash: duplicate_hash },
            },
        });
        assert!(store.persist_signed_payload(1, 0, duplicate.clone(), true).is_err());
        store.plan.deployments[1].attempts.clear();
        // T1/T1A use envelope hashes, so the differently sponsored payload is executable.
        assert_eq!(store.persist_signed_payload(1, 0, duplicate, false).unwrap(), duplicate_hash);
        store.plan.deployments[1].attempts.clear();
        // T12 discriminators distinguish the second operation despite the sponsor change.
        let distinct = payload(1, &sponsor);
        let distinct_hash = signed_payload_hash::<TempoNetwork>(&distinct).unwrap();
        assert_eq!(store.persist_signed_payload(1, 0, distinct, true).unwrap(), distinct_hash);
        assert_eq!(store.signed_payload(1, 0).unwrap().hash, distinct_hash);
    }

    fn expiring_request(from: Address, chain_id: u64, nonce: u64) -> TempoTransactionRequest {
        TempoTransactionRequest {
            inner: TransactionRequest {
                from: Some(from),
                to: Some(TxKind::Call(Address::with_last_byte(2))),
                chain_id: Some(chain_id),
                nonce: Some(nonce),
                gas: Some(100_000),
                max_fee_per_gas: Some(10),
                max_priority_fee_per_gas: Some(1),
                ..Default::default()
            },
            nonce_key: Some(TEMPO_EXPIRING_NONCE_KEY),
            valid_before: std::num::NonZeroU64::new(100),
            ..Default::default()
        }
    }

    fn sign_tempo_payload(request: TempoTransactionRequest, signer: &impl SignerSync) -> Bytes {
        let tx = request.build_aa().unwrap();
        let signature = signer.sign_hash_sync(&tx.signature_hash()).unwrap();
        Bytes::from(
            TempoTxEnvelope::AA(AASigned::new_unhashed(
                tx,
                TempoSignature::Primitive(PrimitiveSignature::Secp256k1(signature)),
            ))
            .encoded_2718(),
        )
    }

    #[test]
    fn sponsor_survives_reload_and_defaults_to_none() {
        let dir = tempfile::tempdir().unwrap();
        let data = sequence(dir.path());
        let paths = data.paths();
        let sponsor = Address::repeat_byte(0x55);
        let snapshot = RecoveryStore::create(data, false, Some(sponsor)).unwrap().path;
        let store = load(&paths, false).unwrap();
        assert_eq!(store.sponsor(), Some(sponsor));
        drop(store);

        // Snapshots written before the sponsor was recorded load without one.
        let mut value: serde_json::Value = foundry_common::fs::read_json_file(&snapshot).unwrap();
        assert_eq!(value["sponsor"], serde_json::json!(sponsor));
        value.as_object_mut().unwrap().remove("sponsor");
        std::fs::write(&snapshot, serde_json::to_vec(&value).unwrap()).unwrap();
        assert_eq!(load(&paths, false).unwrap().sponsor(), None);
    }

    #[test]
    fn new_execution_refuses_unfinished_progress() {
        let dir = tempfile::tempdir().unwrap();
        let paths = sequence(dir.path()).paths();
        let refused = format!(
            "the previous broadcast `{}` has unfinished operations; finish it with `--resume`, or pass `--start-fresh` to archive it and broadcast anew",
            paths.0.display()
        );
        let create = || RecoveryStore::create(sequence(dir.path()), false, None).map(|_| ());

        // Progress without any submission is replaced.
        create().unwrap();
        create().unwrap();

        // A submission attempt makes it unfinished, also when its commit was interrupted.
        let mut store = RecoveryStore::create(sequence(dir.path()), false, None).unwrap();
        store.persist_delegated_request(0, 0, Default::default()).unwrap();
        let snapshot = store.path.clone();
        drop(store);
        assert_eq!(create().unwrap_err().to_string(), refused);
        std::fs::rename(&snapshot, pending_path(&snapshot)).unwrap();
        RecoveryStore::<Ethereum>::archive_unfinished(&sequence(dir.path())).unwrap();
        assert!(!snapshot.exists() && !pending_path(&snapshot).exists());
        create().unwrap();

        // An unreadable snapshot is never silently replaced.
        std::fs::write(&snapshot, "garbage").unwrap();
        assert_eq!(create().unwrap_err().to_string(), refused);
        RecoveryStore::<Ethereum>::archive_unfinished(&sequence(dir.path())).unwrap();
        create().unwrap();

        // Without a snapshot, progress saved before snapshots existed is checked.
        std::fs::remove_file(&snapshot).unwrap();
        let mut legacy = sequence(dir.path());
        legacy.sequences_mut()[0].transactions[0].hash = Some(B256::ZERO);
        foundry_common::fs::write_json_file(&paths.0, &legacy.sequences()[0]).unwrap();
        assert_eq!(create().unwrap_err().to_string(), refused);
        RecoveryStore::<Ethereum>::archive_unfinished(&sequence(dir.path())).unwrap();
        assert!(!paths.0.exists());
        create().unwrap();
    }
}