1use crate::transaction::TransactionWithMetadata;
2use alloy_network::{Network, ReceiptResponse};
3use alloy_primitives::{Address, B256, Bytes, TxHash, hex, map::HashMap};
4use eyre::{ContextCompat, Result, WrapErr};
5use foundry_common::{
6 SELECTOR_LEN, TransactionMaybeSigned, fs, shell, tempo::configurable_account::ConfigJson,
7};
8use foundry_compilers::ArtifactId;
9use foundry_config::Config;
10use serde::{Deserialize, Serialize};
11use std::{
12 collections::VecDeque,
13 path::PathBuf,
14 time::{Duration, SystemTime, UNIX_EPOCH},
15};
16
17pub const DRY_RUN_DIR: &str = "dry-run";
18
19#[derive(Clone, Serialize, Deserialize)]
20pub struct NestedValue {
21 pub internal_type: String,
22 pub value: String,
23}
24
25#[derive(Clone, Default, Serialize, Deserialize)]
27pub struct SensitiveTransactionMetadata {
28 pub rpc: String,
29}
30
31#[derive(Clone, Default, Serialize, Deserialize)]
33pub struct SensitiveScriptSequence {
34 pub transactions: VecDeque<SensitiveTransactionMetadata>,
35 #[serde(default, skip_serializing_if = "Option::is_none")]
36 pub recovery_generation: Option<TxHash>,
37}
38
39#[derive(Clone, Serialize, Deserialize)]
42#[serde(bound(
43 serialize = "N::TransactionRequest: Serialize, N::TxEnvelope: Serialize",
44 deserialize = "N::TransactionRequest: for<'de2> Deserialize<'de2>, N::TxEnvelope: for<'de2> Deserialize<'de2>"
45))]
46pub struct ScriptSequence<N: Network> {
47 pub transactions: VecDeque<TransactionWithMetadata<N>>,
48 pub receipts: Vec<N::ReceiptResponse>,
49 pub libraries: Vec<String>,
50 pub pending: Vec<TxHash>,
51 #[serde(skip)]
52 pub paths: Option<(PathBuf, PathBuf)>,
55 pub returns: HashMap<String, NestedValue>,
56 pub timestamp: u128,
57 pub chain: u64,
58 pub commit: Option<String>,
59 #[serde(default, skip_serializing_if = "Option::is_none")]
60 pub recovery_generation: Option<TxHash>,
61 #[serde(default, skip_serializing_if = "Vec::is_empty")]
64 pub reverted: Vec<TxHash>,
65 #[serde(default, skip_serializing_if = "Vec::is_empty")]
68 pub awaiting_owners: Vec<AwaitingOwners>,
69}
70
71#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
74#[serde(rename_all = "camelCase")]
75pub struct AwaitingOwners {
76 pub index: usize,
78 pub account: Address,
80 pub config: ConfigJson,
82 pub unsigned_tx: Bytes,
84 pub digest: B256,
86 #[serde(default)]
90 pub approvals: Vec<Bytes>,
91}
92
93impl<N: Network> Default for ScriptSequence<N> {
94 fn default() -> Self {
95 Self {
96 transactions: Default::default(),
97 receipts: Default::default(),
98 libraries: Default::default(),
99 pending: Default::default(),
100 paths: Default::default(),
101 returns: Default::default(),
102 timestamp: Default::default(),
103 chain: Default::default(),
104 commit: Default::default(),
105 recovery_generation: Default::default(),
106 reverted: Default::default(),
107 awaiting_owners: Default::default(),
108 }
109 }
110}
111
112impl<N: Network> From<&ScriptSequence<N>> for SensitiveScriptSequence {
113 fn from(sequence: &ScriptSequence<N>) -> Self {
114 Self {
115 transactions: sequence
116 .transactions
117 .iter()
118 .map(|tx| SensitiveTransactionMetadata { rpc: tx.rpc.clone() })
119 .collect(),
120 recovery_generation: sequence.recovery_generation,
121 }
122 }
123}
124
125impl<N: Network> ScriptSequence<N> {
126 pub fn load(
128 config: &Config,
129 sig: &str,
130 target: &ArtifactId,
131 chain_id: u64,
132 dry_run: bool,
133 ) -> Result<Self>
134 where
135 N::TxEnvelope: for<'d> Deserialize<'d>,
136 {
137 let (path, sensitive_path) = Self::get_paths(config, sig, target, chain_id, dry_run)?;
138
139 let mut script_sequence: Self = fs::read_json_file(&path)
140 .wrap_err(format!("Deployment not found for chain `{chain_id}`."))?;
141
142 let sensitive_script_sequence: SensitiveScriptSequence = fs::read_json_file(
143 &sensitive_path,
144 )
145 .wrap_err(format!("Deployment's sensitive details not found for chain `{chain_id}`."))?;
146
147 script_sequence.fill_sensitive(&sensitive_script_sequence).wrap_err(format!(
148 "Deployment's sensitive details are out of sync with the broadcast file for chain `{chain_id}`; restore matching broadcast and sensitive-cache files before resuming."
149 ))?;
150
151 script_sequence.paths = Some((path, sensitive_path));
152
153 Ok(script_sequence)
154 }
155
156 pub fn save(&mut self, silent: bool, save_ts: bool) -> Result<()>
160 where
161 N::TxEnvelope: Serialize,
162 {
163 self.sort_receipts();
164
165 if self.transactions.is_empty() {
166 return Ok(());
167 }
168
169 self.timestamp = now().as_millis();
170 let ts_name = format!("run-{}.json", self.timestamp);
171
172 let sensitive_script_sequence = SensitiveScriptSequence::from(&*self);
173
174 let Some((path, sensitive_path)) = self.paths.as_ref() else { return Ok(()) };
175
176 fs::write_pretty_json_file(path, &self)?;
179 if save_ts {
180 fs::copy(path, path.with_file_name(&ts_name))?;
182 }
183
184 fs::write_sensitive_json_file(sensitive_path, &sensitive_script_sequence)?;
187 if save_ts {
188 fs::copy(sensitive_path, sensitive_path.with_file_name(&ts_name))?;
190 }
191
192 if !silent {
193 if shell::is_json() {
194 sh_println!(
195 "{}",
196 serde_json::json!({
197 "status": "success",
198 "transactions": path.display().to_string(),
199 "sensitive": sensitive_path.display().to_string(),
200 })
201 )?;
202 } else {
203 sh_println!("\nTransactions saved to: {}\n", path.display())?;
204 sh_println!("Sensitive values saved to: {}\n", sensitive_path.display())?;
205 }
206 }
207
208 Ok(())
209 }
210
211 pub fn add_receipt(&mut self, receipt: N::ReceiptResponse) {
212 self.receipts.push(receipt);
213 }
214
215 pub fn sort_receipts(&mut self) {
217 self.receipts.sort_by_key(|r| (r.block_number(), r.transaction_index()));
218 }
219
220 pub fn add_pending(&mut self, index: usize, tx_hash: TxHash) {
221 if !self.pending.contains(&tx_hash) {
222 self.transactions[index].hash = Some(tx_hash);
223 self.pending.push(tx_hash);
224 }
225 }
226
227 pub fn remove_pending(&mut self, tx_hash: TxHash) {
228 self.pending.retain(|element| element != &tx_hash);
229 }
230
231 pub fn get_paths(
235 config: &Config,
236 sig: &str,
237 target: &ArtifactId,
238 chain_id: u64,
239 dry_run: bool,
240 ) -> Result<(PathBuf, PathBuf)> {
241 let mut broadcast = config.broadcast.clone();
242 let mut cache = config.cache_path.clone();
243 let mut common = PathBuf::new();
244
245 let target_fname = target.source.file_name().wrap_err("No filename.")?;
246 common.push(target_fname);
247 common.push(chain_id.to_string());
248 if dry_run {
249 common.push(DRY_RUN_DIR);
250 }
251
252 broadcast.push(common.clone());
253 cache.push(common);
254
255 fs::create_dir_all(&broadcast)?;
256 fs::create_dir_all(&cache)?;
257
258 let filename = sig_to_file_name(sig);
260 let filename_with_ext = format!("{filename}-latest.json");
261
262 broadcast.push(&filename_with_ext);
263 cache.push(&filename_with_ext);
264
265 Ok((broadcast, cache))
266 }
267
268 pub fn rpc_url(&self) -> &str {
270 self.transactions.front().expect("empty sequence").rpc.as_str()
271 }
272
273 pub fn transactions(&self) -> impl Iterator<Item = &TransactionMaybeSigned<N>> {
275 self.transactions.iter().map(|tx| tx.tx())
276 }
277
278 pub fn fill_sensitive(&mut self, sensitive: &SensitiveScriptSequence) -> Result<()> {
280 if self.recovery_generation != sensitive.recovery_generation {
281 eyre::bail!(
282 "the broadcast file and its sensitive-cache counterpart belong to different recovery generations"
283 );
284 }
285 let transactions_len = self.transactions.len();
286 let sensitive_len = sensitive.transactions.len();
287 if transactions_len != sensitive_len {
288 eyre::bail!(
289 "sensitive-cache entry count ({sensitive_len}) does not match transaction count \
290 ({transactions_len}); the broadcast file and its sensitive-cache counterpart are \
291 out of sync"
292 );
293 }
294 for (i, tx) in self.transactions.iter_mut().enumerate() {
295 tx.rpc.clone_from(&sensitive.transactions[i].rpc);
296 }
297 Ok(())
298 }
299}
300
301pub fn sig_to_file_name(sig: &str) -> String {
305 if let Some((name, _)) = sig.split_once('(') {
306 return name.to_string();
308 }
309 if let Ok(calldata) = hex::decode(sig) {
311 if let Some(selector) = calldata.get(..SELECTOR_LEN) {
313 return hex::encode(selector);
314 }
315 return sig.to_string();
317 }
318
319 sig.to_string()
320}
321
322pub fn now() -> Duration {
323 SystemTime::now().duration_since(UNIX_EPOCH).expect("time went backwards")
324}
325
326#[cfg(test)]
327mod tests {
328 use super::*;
329 use alloy_network::Ethereum;
330
331 fn sequence_with_two_transactions() -> ScriptSequence<Ethereum> {
332 let mut sequence = ScriptSequence::default();
333 for rpc in ["first", "second"] {
334 let mut tx = TransactionWithMetadata::from_tx_request(
335 TransactionMaybeSigned::Unsigned(Default::default()),
336 );
337 tx.rpc = rpc.to_string();
338 sequence.transactions.push_back(tx);
339 }
340 sequence
341 }
342
343 #[test]
344 fn fill_sensitive_rejects_mismatched_counts_without_mutation() {
345 for count in [1, 3] {
346 let mut sequence = sequence_with_two_transactions();
347 let sensitive = SensitiveScriptSequence {
348 transactions: (0..count)
349 .map(|_| SensitiveTransactionMetadata { rpc: "replacement".to_string() })
350 .collect(),
351 recovery_generation: None,
352 };
353 assert_eq!(
354 sequence.fill_sensitive(&sensitive).unwrap_err().to_string(),
355 format!(
356 "sensitive-cache entry count ({count}) does not match transaction count (2); \
357 the broadcast file and its sensitive-cache counterpart are out of sync"
358 )
359 );
360 assert_eq!(
361 sequence.transactions.iter().map(|tx| tx.rpc.as_str()).collect::<Vec<_>>(),
362 ["first", "second"]
363 );
364 }
365 }
366
367 #[test]
368 fn fill_sensitive_restores_matching_cache() {
369 let mut sequence = sequence_with_two_transactions();
370 let sensitive = SensitiveScriptSequence {
371 transactions: ["restored-first", "restored-second"]
372 .into_iter()
373 .map(|rpc| SensitiveTransactionMetadata { rpc: rpc.to_string() })
374 .collect(),
375 recovery_generation: None,
376 };
377 sequence.fill_sensitive(&sensitive).unwrap();
378 assert_eq!(
379 sequence.transactions.iter().map(|tx| tx.rpc.as_str()).collect::<Vec<_>>(),
380 ["restored-first", "restored-second"]
381 );
382 }
383
384 #[test]
385 fn fill_sensitive_rejects_a_different_recovery_generation() {
386 let mut sequence = sequence_with_two_transactions();
387 sequence.recovery_generation = Some(TxHash::ZERO);
388 let sensitive = SensitiveScriptSequence {
389 transactions: Default::default(),
390 recovery_generation: Some(TxHash::with_last_byte(1)),
391 };
392
393 assert_eq!(
394 sequence.fill_sensitive(&sensitive).unwrap_err().to_string(),
395 "the broadcast file and its sensitive-cache counterpart belong to different recovery generations"
396 );
397 }
398
399 #[test]
400 fn can_convert_sig() {
401 assert_eq!(sig_to_file_name("run()").as_str(), "run");
402 assert_eq!(
403 sig_to_file_name(
404 "522bb704000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfFFb92266"
405 )
406 .as_str(),
407 "522bb704"
408 );
409 assert_eq!(
411 sig_to_file_name(
412 "0x522bb704000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfFFb92266"
413 )
414 .as_str(),
415 "522bb704"
416 );
417 assert_eq!(sig_to_file_name("0x1234").as_str(), "0x1234");
419 assert_eq!(sig_to_file_name("123").as_str(), "123");
420 assert_eq!(sig_to_file_name("0xnotahex").as_str(), "0xnotahex");
422 assert_eq!(sig_to_file_name("not_a_sig_or_hex").as_str(), "not_a_sig_or_hex");
424 }
425}