forge_script/

recovery.rs

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

#[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,
    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) fn create(mut data: SequenceData<N>, batch: bool) -> 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()
            );
        }
        let generation = B256::random();
        data.set_recovery_generation(generation);
        let plan = RecoveryPlan::new(data, batch, generation)?;
        write_snapshot(&lock.path, &plan)?;
        Self::finish_open(lock, plan)
    }

    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,
    ) -> 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)?;
        if let Some(existing) = self.signed_payload(sequence, index) {
            if existing != &signed {
                bail!("refusing to replace an existing signed payload");
            }
            return Ok(existing.hash);
        }
        let id = operation.id;
        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,
            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,
                            )?
                        } 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()))
}

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,
) -> 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),
    };
    if transaction.from() != Some(signer)
        || !chain_matches
        || transaction.nonce() != Some(envelope.nonce())
        || 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(())
}

#[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::{TempoSignature, TempoTxEnvelope, transaction::Call};

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

    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(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(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,
        }
    }

    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).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).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).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).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).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).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).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).unwrap();
            let hash = store.persist_signed_payload(0, 0, SIGNED_TX.into()).unwrap();
            assert!(store.persist_signed_payload(0, 0, OTHER_SIGNED_TX.into()).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).unwrap();

        assert!(store.persist_signed_payload(1, 0, SIGNED_TX.into()).is_err());
        assert!(store.persist_signed_payload(0, 1, SIGNED_TX.into()).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).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).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).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()).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).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).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());
    }
}