Skip to main content

forge_script/
sequence.rs

1use crate::{
2    multi_sequence::MultiChainSequence,
3    recovery::{AttemptKind, DelegatedStatus, RecoveryLock, RecoveryStore, SignedPayload},
4};
5use alloy_consensus::transaction::SignerRecoverable;
6use alloy_eips::eip2718::{Decodable2718, Encodable2718};
7use alloy_network::{Network, ReceiptResponse};
8use alloy_primitives::{Address, B256, Bytes};
9use eyre::{ContextCompat, Report, Result, bail, eyre};
10use forge_script_sequence::{ScriptSequence, TransactionWithMetadata};
11use foundry_cli::utils::Git;
12use foundry_common::{FoundryTransactionBuilder, fmt::UIfmt};
13use foundry_compilers::ArtifactId;
14use foundry_config::Config;
15use serde::{Deserialize, Serialize};
16use std::{
17    collections::HashMap,
18    fmt::{Error, Write},
19    path::{Path, PathBuf},
20};
21
22pub(crate) fn completed_transaction_prefix<N: Network>(
23    sequence: &ScriptSequence<N>,
24) -> Result<usize> {
25    let mut receipts = HashMap::<_, usize>::new();
26    for receipt in &sequence.receipts {
27        *receipts.entry(receipt.transaction_hash()).or_default() += 1;
28    }
29
30    let mut prefix = 0;
31    let mut incomplete = false;
32    for transaction in &sequence.transactions {
33        let complete = transaction.hash.is_some_and(|hash| {
34            receipts.get_mut(&hash).is_some_and(|count| {
35                if *count == 0 {
36                    false
37                } else {
38                    *count -= 1;
39                    true
40                }
41            })
42        });
43        if complete {
44            if incomplete {
45                bail!("script progress contains a receipt after an incomplete operation");
46            }
47            prefix += 1;
48        } else {
49            incomplete = true;
50        }
51    }
52    if receipts.values().any(|count| *count != 0) {
53        bail!("script progress contains a receipt without a matching operation");
54    }
55    Ok(prefix)
56}
57
58#[derive(Clone, Serialize, Deserialize)]
59#[serde(
60    tag = "kind",
61    content = "sequence",
62    rename_all = "camelCase",
63    bound(
64        serialize = "N::TxEnvelope: Serialize",
65        deserialize = "N::TxEnvelope: for<'de2> Deserialize<'de2>"
66    )
67)]
68pub(crate) enum SequenceData<N: Network> {
69    Single(Box<ScriptSequence<N>>),
70    Multi(MultiChainSequence<N>),
71}
72
73impl<N: Network> SequenceData<N>
74where
75    N::TxEnvelope: Serialize,
76{
77    fn save(&mut self, silent: bool, save_ts: bool) -> Result<()> {
78        match self {
79            Self::Single(sequence) => sequence.save(silent, save_ts),
80            Self::Multi(sequence) => sequence.save(silent, save_ts),
81        }
82    }
83
84    pub fn sequences(&self) -> &[ScriptSequence<N>] {
85        match self {
86            Self::Single(sequence) => std::slice::from_ref(&**sequence),
87            Self::Multi(sequence) => &sequence.deployments,
88        }
89    }
90
91    pub fn sequences_mut(&mut self) -> &mut [ScriptSequence<N>] {
92        match self {
93            Self::Single(sequence) => std::slice::from_mut(&mut **sequence),
94            Self::Multi(sequence) => &mut sequence.deployments,
95        }
96    }
97
98    pub const fn is_multi(&self) -> bool {
99        matches!(self, Self::Multi(_))
100    }
101
102    pub fn paths(&self) -> (std::path::PathBuf, std::path::PathBuf) {
103        match self {
104            Self::Single(sequence) => sequence.paths.clone().expect("sequence paths not set"),
105            Self::Multi(sequence) => (sequence.path.clone(), sequence.sensitive_path.clone()),
106        }
107    }
108
109    pub(crate) fn set_paths(&mut self, paths: (PathBuf, PathBuf)) {
110        match self {
111            Self::Single(sequence) => sequence.paths = Some(paths),
112            Self::Multi(sequence) => {
113                sequence.path = paths.0;
114                sequence.sensitive_path = paths.1;
115            }
116        }
117    }
118
119    pub(crate) fn has_recovery_generation(&self) -> bool {
120        self.sequences().iter().any(|sequence| sequence.recovery_generation.is_some())
121    }
122
123    pub(crate) fn set_recovery_generation(&mut self, generation: B256) {
124        for sequence in self.sequences_mut() {
125            sequence.recovery_generation = Some(generation);
126        }
127    }
128
129    pub(crate) fn publish(&self, paths: &(PathBuf, PathBuf)) -> Result<()> {
130        let mut export = self.clone();
131        export.set_paths(paths.clone());
132        export.save(true, false)
133    }
134
135    fn save_timestamped(&self, paths: &(PathBuf, PathBuf)) -> Result<()> {
136        match self {
137            Self::Single(sequence) => {
138                let filename = format!("run-{}.json", sequence.timestamp);
139                std::fs::copy(&paths.0, paths.0.with_file_name(&filename))?;
140                std::fs::copy(&paths.1, paths.1.with_file_name(filename))?;
141            }
142            Self::Multi(sequence) => {
143                let timestamp = sequence.timestamp;
144                for path in [&paths.0, &paths.1] {
145                    let timestamped = PathBuf::from(
146                        path.to_string_lossy().replace("-latest", &format!("-{timestamp}")),
147                    );
148                    std::fs::create_dir_all(timestamped.parent().unwrap())?;
149                    std::fs::copy(path, timestamped)?;
150                }
151            }
152        }
153        Ok(())
154    }
155}
156
157/// How `--resume` resolves an interrupted delegated submission whose outcome is unknown.
158#[derive(Clone, Copy, Debug, PartialEq, Eq)]
159pub(crate) enum DelegatedResolution {
160    /// No attempt is selected, so every unknown outcome blocks the resume.
161    None,
162    /// `--resume-attempt` selects the attempt to resolve with `action`.
163    Attempt {
164        attempt: B256,
165        /// `None` when neither `--resume-tx-hash` nor `--resume-retry` was given, which is
166        /// rejected once the attempt is found to need resolution.
167        action: Option<DelegatedAction>,
168    },
169}
170
171/// The operator's resolution of a delegated submission whose outcome is unknown.
172#[derive(Clone, Copy, Debug, PartialEq, Eq)]
173pub(crate) enum DelegatedAction {
174    /// `--resume-tx-hash`: the submission was found on chain under this hash.
175    RecordHash(B256),
176    /// `--resume-retry`: the submission was proven not to have been sent, so it is prepared anew.
177    Retry,
178}
179
180impl DelegatedResolution {
181    /// Builds the resolution from the `--resume-attempt`, `--resume-tx-hash` and
182    /// `--resume-retry` flags, preferring a retry over a hash.
183    pub(crate) fn new(
184        attempt: Option<B256>,
185        resolved_hash: Option<B256>,
186        retry_unknown: bool,
187    ) -> Result<Self> {
188        let action = if retry_unknown {
189            Some(DelegatedAction::Retry)
190        } else {
191            resolved_hash.map(DelegatedAction::RecordHash)
192        };
193        match (attempt, action) {
194            (Some(attempt), action) => Ok(Self::Attempt { attempt, action }),
195            (None, None) => Ok(Self::None),
196            (None, Some(_)) => {
197                bail!("--resume-attempt is required to resolve an interrupted submission")
198            }
199        }
200    }
201}
202
203pub struct ScriptSequenceKind<N: Network>
204where
205    N::TxEnvelope: for<'d> Deserialize<'d> + Serialize,
206{
207    recovery: RecoveryStore<N>,
208    /// Endpoint that replaces the saved one for this run, never persisted.
209    rpc_override: Option<String>,
210}
211
212impl<N: Network> ScriptSequenceKind<N>
213where
214    N::TxEnvelope: for<'d> Deserialize<'d> + Serialize,
215{
216    #[cfg(test)]
217    pub fn new_single(
218        sequence: ScriptSequence<N>,
219        batch: bool,
220        sponsor: Option<Address>,
221    ) -> Result<Self> {
222        Self::create(SequenceData::Single(Box::new(sequence)), batch, sponsor)
223    }
224
225    pub fn load_single(
226        config: &Config,
227        sig: &str,
228        target: &ArtifactId,
229        chain: u64,
230        dry_run: bool,
231        batch: bool,
232    ) -> Result<Self>
233    where
234        N::TxEnvelope: SignerRecoverable,
235        N::TransactionRequest: FoundryTransactionBuilder<N>,
236    {
237        let paths = ScriptSequence::<N>::get_paths(config, sig, target, chain, dry_run)?;
238        Self::load(paths, batch, || {
239            ScriptSequence::load(config, sig, target, chain, dry_run)
240                .map(|sequence| SequenceData::Single(Box::new(sequence)))
241        })
242    }
243
244    pub fn load_multi(
245        config: &Config,
246        sig: &str,
247        target: &ArtifactId,
248        dry_run: bool,
249        batch: bool,
250    ) -> Result<Self>
251    where
252        N::TxEnvelope: SignerRecoverable,
253        N::TransactionRequest: FoundryTransactionBuilder<N>,
254    {
255        let paths = MultiChainSequence::<N>::get_paths(config, sig, target, dry_run)?;
256        Self::load(paths, batch, || {
257            MultiChainSequence::load(config, sig, target, dry_run).map(SequenceData::Multi)
258        })
259    }
260
261    fn load(
262        paths: (PathBuf, PathBuf),
263        batch: bool,
264        load_legacy: impl FnOnce() -> Result<SequenceData<N>>,
265    ) -> Result<Self>
266    where
267        N::TxEnvelope: SignerRecoverable,
268        N::TransactionRequest: FoundryTransactionBuilder<N>,
269    {
270        let lock = RecoveryLock::acquire(&paths)?;
271        let recovery = if let Some(recovery) = RecoveryStore::load(&paths, batch, lock)? {
272            recovery
273        } else {
274            let lock = RecoveryLock::acquire(&paths)?;
275            let data = load_legacy()?;
276            if data.has_recovery_generation() {
277                bail!("recovery exports reference a missing authoritative snapshot");
278            }
279            RecoveryStore::import(data, batch, lock)?
280        };
281        let sequence = Self { recovery, rpc_override: None };
282        sequence.recovery.data().publish(&paths)?;
283        Ok(sequence)
284    }
285
286    pub(crate) fn create(
287        data: SequenceData<N>,
288        batch: bool,
289        sponsor: Option<Address>,
290    ) -> Result<Self> {
291        let paths = data.paths();
292        let recovery = RecoveryStore::create(data, batch, sponsor)?;
293        let sequence = Self { recovery, rpc_override: None };
294        sequence.recovery.data().publish(&paths)?;
295        Ok(sequence)
296    }
297
298    pub fn save(&mut self, silent: bool, save_ts: bool) -> Result<()> {
299        self.recovery.save()?;
300        let paths = self.recovery.data().paths();
301        self.recovery.data().publish(&paths)?;
302        if save_ts {
303            self.recovery.data().save_timestamped(&paths)?;
304        }
305        if !silent {
306            if foundry_common::shell::is_json() {
307                sh_println!(
308                    "{}",
309                    serde_json::json!({
310                        "status": "success",
311                        "transactions": paths.0.display().to_string(),
312                        "sensitive": paths.1.display().to_string(),
313                    })
314                )?;
315            } else {
316                sh_println!("\nTransactions saved to: {}\n", paths.0.display())?;
317                sh_println!("Sensitive values saved to: {}\n", paths.1.display())?;
318            }
319        }
320        Ok(())
321    }
322
323    pub fn sequences(&self) -> &[ScriptSequence<N>] {
324        self.recovery.data().sequences()
325    }
326
327    pub fn sequences_mut(&mut self) -> &mut [ScriptSequence<N>] {
328        self.recovery.data_mut().sequences_mut()
329    }
330
331    /// Uses `rpc` instead of the saved endpoint for the rest of this run.
332    pub(crate) fn set_rpc_override(&mut self, rpc: String) {
333        self.rpc_override = Some(rpc);
334    }
335
336    /// Returns the endpoint used to reach the sequence at `index`.
337    pub(crate) fn rpc_url(&self, index: usize) -> &str {
338        self.rpc_override.as_deref().unwrap_or_else(|| self.sequences()[index].rpc_url())
339    }
340
341    pub(crate) fn signed_payload(&self, sequence: usize, index: usize) -> Option<&SignedPayload> {
342        self.recovery.signed_payload(sequence, index)
343    }
344
345    pub(crate) fn submission_hashes(&self, sequence: usize) -> (Vec<B256>, Vec<B256>) {
346        self.recovery.submission_hashes(sequence)
347    }
348
349    pub(crate) fn persist_signed_payload(
350        &mut self,
351        sequence: usize,
352        index: usize,
353        payload: Bytes,
354        sender_scoped_replay: bool,
355    ) -> Result<B256>
356    where
357        N::TxEnvelope: SignerRecoverable,
358        N::TransactionRequest: FoundryTransactionBuilder<N>,
359    {
360        self.recovery.persist_signed_payload(sequence, index, payload, sender_scoped_replay)
361    }
362
363    pub(crate) fn delegated_status(
364        &self,
365        sequence: usize,
366        index: usize,
367    ) -> Option<DelegatedStatus> {
368        self.recovery.delegated_status(sequence, index)
369    }
370
371    pub(crate) fn persist_delegated_request(
372        &mut self,
373        sequence: usize,
374        index: usize,
375        request: N::TransactionRequest,
376    ) -> Result<()> {
377        self.recovery.persist_delegated_request(sequence, index, request)
378    }
379
380    pub(crate) fn persist_delegated_status(
381        &mut self,
382        sequence: usize,
383        index: usize,
384        status: DelegatedStatus,
385    ) -> Result<()> {
386        self.recovery.persist_delegated_status(sequence, index, status)
387    }
388
389    pub(crate) fn clear_delegated_request(&mut self, sequence: usize, index: usize) -> Result<()> {
390        self.recovery.clear_delegated_request(sequence, index)
391    }
392
393    pub(crate) fn resolve_delegated_hash(
394        &mut self,
395        attempt_id: B256,
396        hash: B256,
397        transaction: &N::TransactionResponse,
398    ) -> Result<()>
399    where
400        N::TransactionRequest: FoundryTransactionBuilder<N>,
401    {
402        let (sequence, index) =
403            self.recovery.resolve_delegated_hash(attempt_id, hash, transaction)?;
404        if !self.recovery.is_batch() {
405            self.sequences_mut()[sequence].add_pending(index, hash);
406        }
407        Ok(())
408    }
409
410    pub(crate) fn batch_attempt(
411        &self,
412        sequence: usize,
413    ) -> Option<(usize, B256, &AttemptKind<N::TransactionRequest>)> {
414        self.recovery.batch_attempt(sequence)
415    }
416
417    pub(crate) fn persist_batch_signed_payload(
418        &mut self,
419        sequence: usize,
420        first_operation: usize,
421        request: N::TransactionRequest,
422        payload: Bytes,
423    ) -> Result<B256>
424    where
425        N::TxEnvelope: Decodable2718 + Encodable2718,
426    {
427        self.recovery.persist_batch_signed_payload(sequence, first_operation, request, payload)
428    }
429
430    pub(crate) fn persist_batch_delegated_request(
431        &mut self,
432        sequence: usize,
433        first_operation: usize,
434        request: N::TransactionRequest,
435    ) -> Result<()> {
436        self.recovery.persist_batch_delegated_request(sequence, first_operation, request)
437    }
438
439    pub(crate) fn restore_delegated_pending(
440        &mut self,
441        resolution: DelegatedResolution,
442    ) -> Result<Option<(usize, usize, B256, B256)>> {
443        for (sequence, index, _, status) in self.recovery.delegated_attempts() {
444            if status == DelegatedStatus::Prepared {
445                self.recovery.persist_delegated_status(
446                    sequence,
447                    index,
448                    DelegatedStatus::OutcomeUnknown,
449                )?;
450            }
451        }
452
453        let mut pending_resolution = None;
454        if let DelegatedResolution::Attempt { attempt: attempt_id, action } = resolution {
455            let (sequence, index) = self
456                .recovery
457                .delegated_attempt_location(attempt_id)
458                .context("no interrupted delegated submission matches --resume-attempt")?;
459            if !matches!(
460                self.recovery.delegated_status(sequence, index),
461                Some(DelegatedStatus::OutcomeUnknown)
462            ) {
463                bail!("delegated submission attempt {attempt_id} does not require resolution");
464            }
465            match action {
466                Some(DelegatedAction::Retry) => {
467                    self.recovery.clear_delegated_request(sequence, index)?;
468                }
469                Some(DelegatedAction::RecordHash(hash)) => {
470                    pending_resolution = Some((sequence, index, attempt_id, hash));
471                }
472                None => bail!("--resume-attempt requires --resume-tx-hash or --resume-retry"),
473            }
474        }
475
476        let batch = self.recovery.is_batch();
477        for (sequence, index, attempt, status) in self.recovery.delegated_attempts() {
478            match status {
479                DelegatedStatus::OutcomeUnknown => {
480                    if pending_resolution.is_some_and(|(_, _, target, _)| target == attempt) {
481                        continue;
482                    }
483                    bail!(
484                        "submission outcome for delegated attempt {attempt} on chain {} is unknown; target it with --resume-attempt and provide --resume-tx-hash, or use --resume-retry only after proving it was not submitted",
485                        self.sequences()[sequence].chain
486                    );
487                }
488                DelegatedStatus::Pending { hash } if !batch => {
489                    let deployment = &mut self.sequences_mut()[sequence];
490                    if !deployment.reverted.contains(&hash)
491                        && !deployment
492                            .receipts
493                            .iter()
494                            .any(|receipt| receipt.transaction_hash() == hash)
495                    {
496                        deployment.add_pending(index, hash);
497                    }
498                }
499                DelegatedStatus::Prepared | DelegatedStatus::Pending { .. } => {}
500            }
501        }
502        Ok(pending_resolution)
503    }
504
505    pub(crate) fn ensure_delegated_outcomes_known(&mut self, sequence: usize) -> Result<()> {
506        for index in 0..self.sequences()[sequence].transactions.len() {
507            let Some(DelegatedStatus::Pending { hash }) =
508                self.recovery.delegated_status(sequence, index)
509            else {
510                continue;
511            };
512            let deployment = &self.sequences()[sequence];
513            if deployment.pending.contains(&hash)
514                || deployment.reverted.contains(&hash)
515                || deployment.receipts.iter().any(|receipt| receipt.transaction_hash() == hash)
516            {
517                continue;
518            }
519            let chain = deployment.chain;
520            bail!(
521                "delegated submission {hash} for operation {index} on chain {chain} is not currently visible; its recovery identity remains pending"
522            );
523        }
524        Ok(())
525    }
526
527    pub const fn is_multi(&self) -> bool {
528        self.recovery.data().is_multi()
529    }
530
531    /// Returns the Tempo sponsor recorded when the deployment was created.
532    pub(crate) const fn sponsor(&self) -> Option<Address> {
533        self.recovery.sponsor()
534    }
535
536    /// Atomically promotes a dry-run sequence to the broadcast paths.
537    pub fn promote_to_broadcasted(
538        &mut self,
539        config: &Config,
540        sig: &str,
541        target: &ArtifactId,
542    ) -> Result<()> {
543        let paths = match self.recovery.data() {
544            SequenceData::Single(sequence) => {
545                ScriptSequence::<N>::get_paths(config, sig, target, sequence.chain, false)?
546            }
547            SequenceData::Multi(_) => {
548                MultiChainSequence::<N>::get_paths(config, sig, target, false)?
549            }
550        };
551        let relocation = self.recovery.prepare_relocation(&paths)?;
552        self.recovery.commit_relocation(relocation)?;
553        self.recovery.data_mut().set_paths(paths.clone());
554        self.recovery.save()?;
555        self.recovery.data().publish(&paths)?;
556        self.recovery.data().save_timestamped(&paths)?;
557        Ok(())
558    }
559
560    pub fn show_transactions(&self) -> Result<()>
561    where
562        N::TxEnvelope: UIfmt,
563        N::TransactionRequest: FoundryTransactionBuilder<N>,
564    {
565        for sequence in self.sequences() {
566            if !sequence.transactions.is_empty() {
567                sh_println!("\nChain {}\n", sequence.chain)?;
568
569                for (i, tx) in sequence.transactions.iter().enumerate() {
570                    sh_print!("{}", format_transaction(i + 1, tx)?)?;
571                }
572            }
573        }
574
575        Ok(())
576    }
577
578    /// Prefixes a multichain error with the chain of the sequence at `index`, adding the sequence
579    /// number when another sequence is on the same chain.
580    pub(crate) fn label_error(&self, index: usize, err: Report) -> Report {
581        if !self.is_multi() {
582            return err;
583        }
584        let chain = self.sequences()[index].chain;
585        if self.sequences().iter().filter(|sequence| sequence.chain == chain).count() > 1 {
586            eyre!("chain {chain} (sequence #{}): {err}", index + 1)
587        } else {
588            eyre!("chain {chain}: {err}")
589        }
590    }
591}
592
593impl<N: Network> Drop for ScriptSequenceKind<N>
594where
595    N::TxEnvelope: for<'d> Deserialize<'d> + Serialize,
596{
597    fn drop(&mut self) {
598        if let Err(err) = self.save(false, true) {
599            error!(?err, "could not save deployment sequence");
600        }
601    }
602}
603
604/// Format transaction details for display
605fn format_transaction<N: Network>(
606    index: usize,
607    tx: &TransactionWithMetadata<N>,
608) -> Result<String, Error>
609where
610    N::TxEnvelope: UIfmt,
611    N::TransactionRequest: FoundryTransactionBuilder<N>,
612{
613    let mut output = String::new();
614    writeln!(output, "### Transaction {index} ###")?;
615    writeln!(output, "{}", tx.tx().pretty())?;
616
617    // Show contract name and address if available
618    if !tx.call_kind.is_any_create()
619        && let (Some(name), Some(addr)) = (&tx.contract_name, &tx.contract_address)
620    {
621        writeln!(output, "contract: {name}({addr})")?;
622    }
623
624    // Show decoded function if available
625    if let (Some(func), Some(args)) = (&tx.display_function, &tx.arguments) {
626        if args.is_empty() {
627            writeln!(output, "data (decoded): {func}()")?;
628        } else {
629            writeln!(output, "data (decoded): {func}(")?;
630            for (i, arg) in args.iter().enumerate() {
631                writeln!(&mut output, "  {}{}", arg, if i + 1 < args.len() { "," } else { "" })?;
632            }
633            writeln!(output, ")")?;
634        }
635    }
636
637    writeln!(output)?;
638    Ok(output)
639}
640
641/// Returns the commit hash of the project if it exists
642pub fn get_commit_hash(root: &Path) -> Option<String> {
643    Git::new(root).commit_hash(true, "HEAD").ok()
644}
645
646/// Returns a stable transaction ordinal across the complete script plan, including completed
647/// transactions so that resuming does not change expiring nonce discriminators.
648pub(crate) fn operation_ordinal<N: Network>(
649    sequences: &[ScriptSequence<N>],
650    sequence: usize,
651    index: usize,
652) -> usize {
653    sequences[..sequence].iter().map(|sequence| sequence.transactions.len()).sum::<usize>() + index
654}
655
656/// Returns the pending hashes of `sequence` that cannot be mined yet, because an earlier
657/// transaction on the same chain from the same sender has no receipt, recorded revert, or pending
658/// hash.
659pub(crate) fn blocked_pending<N: Network>(
660    sequences: &[ScriptSequence<N>],
661    sequence: usize,
662) -> Vec<B256> {
663    let chain = sequences[sequence].chain;
664    let mut gap_senders = Vec::new();
665    let mut blocked = Vec::new();
666    for (index, deployment) in sequences[..=sequence].iter().enumerate() {
667        if deployment.chain != chain {
668            continue;
669        }
670        for tx in &deployment.transactions {
671            let sender = tx.tx().from();
672            match tx.hash {
673                Some(hash) if deployment.pending.contains(&hash) => {
674                    if index == sequence && gap_senders.contains(&sender) {
675                        blocked.push(hash);
676                    }
677                }
678                Some(hash)
679                    if deployment.reverted.contains(&hash)
680                        || deployment.receipts.iter().any(|r| r.transaction_hash() == hash) => {}
681                _ => gap_senders.push(sender),
682            }
683        }
684    }
685    blocked
686}
687
688#[cfg(test)]
689mod tests {
690    use super::*;
691    use alloy_network::Ethereum;
692    use alloy_rpc_types::TransactionRequest;
693    use foundry_common::TransactionMaybeSigned;
694
695    #[test]
696    fn operation_ordinals_include_earlier_sequences_and_completed_transactions() {
697        let transaction =
698            TransactionWithMetadata::from_tx_request(TransactionMaybeSigned::<Ethereum>::Unsigned(
699                Default::default(),
700            ));
701        let mut sequences = [
702            ScriptSequence {
703                chain: 4217,
704                transactions: [transaction.clone()].into(),
705                ..Default::default()
706            },
707            ScriptSequence {
708                chain: 4218,
709                transactions: [transaction.clone(), transaction.clone()].into(),
710                ..Default::default()
711            },
712            ScriptSequence {
713                chain: 4217,
714                transactions: [transaction].into(),
715                ..Default::default()
716            },
717        ];
718        assert_eq!(operation_ordinal(&sequences, 0, 0), 0);
719        assert_eq!(operation_ordinal(&sequences, 1, 1), 2);
720        assert_eq!(operation_ordinal(&sequences, 2, 0), 3);
721        sequences[0].transactions[0].hash = Some(B256::repeat_byte(1));
722        assert_eq!(operation_ordinal(&sequences, 2, 0), 3);
723    }
724
725    #[test]
726    fn pending_behind_a_missing_transaction_is_blocked_only_on_its_chain_and_sender() {
727        let (sender, other) = (Address::repeat_byte(1), Address::repeat_byte(2));
728        let tx = |from, hash| {
729            let mut tx = TransactionWithMetadata::from_tx_request(
730                TransactionMaybeSigned::<Ethereum>::Unsigned(
731                    TransactionRequest::default().from(from),
732                ),
733            );
734            tx.hash = Some(B256::repeat_byte(hash));
735            tx
736        };
737        let sequence = |chain, transactions: Vec<_>, pending: &[u8]| ScriptSequence {
738            chain,
739            transactions: transactions.into(),
740            pending: pending.iter().copied().map(B256::repeat_byte).collect(),
741            ..Default::default()
742        };
743        // The first transaction is neither pending nor confirmed.
744        let sequences = [
745            sequence(1, vec![tx(sender, 1), tx(sender, 2)], &[2]),
746            sequence(2, vec![tx(sender, 3)], &[3]),
747            sequence(1, vec![tx(other, 4), tx(sender, 5)], &[4, 5]),
748        ];
749        assert_eq!(blocked_pending(&sequences, 0), [B256::repeat_byte(2)]);
750        assert!(blocked_pending(&sequences, 1).is_empty());
751        assert_eq!(blocked_pending(&sequences, 2), [B256::repeat_byte(5)]);
752    }
753
754    fn unknown_delegated_sequence() -> (tempfile::TempDir, ScriptSequenceKind<Ethereum>, B256) {
755        let dir = tempfile::tempdir().unwrap();
756        let mut deployment = ScriptSequence::<Ethereum> {
757            chain: 1,
758            paths: Some((dir.path().join("broadcast.json"), dir.path().join("cache.json"))),
759            ..Default::default()
760        };
761        deployment.transactions.push_back(TransactionWithMetadata::from_tx_request(
762            TransactionMaybeSigned::Unsigned(Default::default()),
763        ));
764        let mut sequence = ScriptSequenceKind::new_single(deployment, false, None).unwrap();
765        sequence.persist_delegated_request(0, 0, Default::default()).unwrap();
766        sequence.persist_delegated_status(0, 0, DelegatedStatus::OutcomeUnknown).unwrap();
767        let attempt = sequence.recovery.delegated_attempts()[0].2;
768        (dir, sequence, attempt)
769    }
770
771    #[test]
772    fn publish_keeps_source_paths() {
773        let dir = tempfile::tempdir().unwrap();
774        let source_paths = (dir.path().join("dry-run.json"), dir.path().join("dry-run-cache.json"));
775        let mut sequence =
776            ScriptSequence::<Ethereum> { paths: Some(source_paths.clone()), ..Default::default() };
777        sequence.transactions.push_back(TransactionWithMetadata::from_tx_request(
778            TransactionMaybeSigned::Unsigned(Default::default()),
779        ));
780        let data = SequenceData::Single(Box::new(sequence));
781
782        let public = dir.path().join("broadcast.json");
783        let sensitive = dir.path().join("broadcast-cache.json");
784        let paths = (public, sensitive.clone());
785        data.publish(&paths).unwrap();
786
787        assert_eq!(data.paths(), source_paths);
788        let value: serde_json::Value = foundry_common::fs::read_json_file(&sensitive).unwrap();
789        assert_eq!(value["transactions"].as_array().unwrap().len(), 1);
790    }
791
792    #[test]
793    fn any_deployment_generation_blocks_legacy_import() {
794        let mut data = SequenceData::<Ethereum>::Multi(MultiChainSequence {
795            deployments: vec![ScriptSequence::default(), ScriptSequence::default()],
796            path: PathBuf::new(),
797            sensitive_path: PathBuf::new(),
798            timestamp: 0,
799        });
800        data.sequences_mut()[1].recovery_generation = Some(B256::repeat_byte(0x11));
801
802        assert!(data.has_recovery_generation());
803    }
804
805    #[test]
806    fn delegated_outcome_requires_explicit_operator_resolution() {
807        let (_dir, mut sequence, attempt) = unknown_delegated_sequence();
808        let hash = B256::repeat_byte(0x42);
809
810        assert_eq!(
811            sequence
812                .restore_delegated_pending(DelegatedResolution::Attempt {
813                    attempt,
814                    action: Some(DelegatedAction::RecordHash(hash)),
815                })
816                .unwrap(),
817            Some((0, 0, attempt, hash))
818        );
819
820        assert!(matches!(sequence.delegated_status(0, 0), Some(DelegatedStatus::OutcomeUnknown)));
821        assert!(sequence.sequences()[0].pending.is_empty());
822
823        let (_dir, mut sequence, attempt) = unknown_delegated_sequence();
824
825        sequence
826            .restore_delegated_pending(DelegatedResolution::Attempt {
827                attempt,
828                action: Some(DelegatedAction::Retry),
829            })
830            .unwrap();
831
832        assert!(sequence.delegated_status(0, 0).is_none());
833    }
834
835    #[test]
836    fn authoritative_load_does_not_read_legacy_exports() {
837        let (_dir, sequence, attempt) = unknown_delegated_sequence();
838        let paths = sequence.recovery.data().paths();
839        drop(sequence);
840        std::fs::remove_file(&paths.0).unwrap();
841        std::fs::remove_file(&paths.1).unwrap();
842
843        let loaded = ScriptSequenceKind::<Ethereum>::load(paths.clone(), false, || {
844            panic!("authoritative recovery must not load compatibility exports");
845        })
846        .unwrap();
847        assert_eq!(loaded.recovery.delegated_attempts()[0].2, attempt);
848        assert!(paths.0.exists());
849        assert!(paths.1.exists());
850    }
851}