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#[derive(Clone, Copy, Debug, PartialEq, Eq)]
159pub(crate) enum DelegatedResolution {
160 None,
162 Attempt {
164 attempt: B256,
165 action: Option<DelegatedAction>,
168 },
169}
170
171#[derive(Clone, Copy, Debug, PartialEq, Eq)]
173pub(crate) enum DelegatedAction {
174 RecordHash(B256),
176 Retry,
178}
179
180impl DelegatedResolution {
181 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 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 pub(crate) fn set_rpc_override(&mut self, rpc: String) {
333 self.rpc_override = Some(rpc);
334 }
335
336 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 pub(crate) const fn sponsor(&self) -> Option<Address> {
533 self.recovery.sponsor()
534 }
535
536 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 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
604fn 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 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 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
641pub fn get_commit_hash(root: &Path) -> Option<String> {
643 Git::new(root).commit_hash(true, "HEAD").ok()
644}
645
646pub(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
656pub(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 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}