Fix multichain scripts resume functionality

crates/forge/bin/cmd/script/broadcast.rs

@@ -296,7 +296,7 @@ impl ScriptArgs {
  deployments.clone(),
  &self.sig,
  script_config.target_contract(),
- &script_config.config.broadcast,
+ &script_config.config,
  self.broadcast,
  )?;
 

crates/forge/bin/cmd/script/cmd.rs

@@ -192,7 +192,7 @@ impl ScriptArgs {
  return self
  .multi_chain_deployment(
  MultiChainSequence::load(
- &script_config.config.broadcast,
+ &script_config.config,
  &self.sig,
  script_config.target_contract(),
  )?,

crates/forge/bin/cmd/script/multi.rs

@@ -1,6 +1,6 @@
 use super::{
  receipts,
- sequence::{ScriptSequence, DRY_RUN_DIR},
+ sequence::{sig_to_file_name, ScriptSequence, SensitiveScriptSequence, DRY_RUN_DIR},
  verify::VerifyBundle,
  ScriptArgs,
 };
@@ -22,10 +22,25 @@ use std::{
 #[derive(Deserialize, Serialize, Clone, Default)]
 pub struct MultiChainSequence {
  pub deployments: Vec<ScriptSequence>,
+ #[serde(skip)]
  pub path: PathBuf,
+ #[serde(skip)]
+ pub sensitive_path: PathBuf,
  pub timestamp: u64,
 }
 
+/// Sensitive values from script sequences.
+#[derive(Deserialize, Serialize, Clone, Default)]
+pub struct SensitiveMultiChainSequence {
+ pub deployments: Vec<SensitiveScriptSequence>,
+}
+
+fn to_sensitive(sequence: &mut MultiChainSequence) -> SensitiveMultiChainSequence {
+ SensitiveMultiChainSequence {
+ deployments: sequence.deployments.iter_mut().map(|sequence| sequence.into()).collect(),
+ }
+}
+
 impl Drop for MultiChainSequence {
  fn drop(&mut self) {
  self.deployments.iter_mut().for_each(|sequence| sequence.sort_receipts());
@@ -38,56 +53,94 @@ impl MultiChainSequence {
  deployments: Vec<ScriptSequence>,
  sig: &str,
  target: &ArtifactId,
- log_folder: &Path,
+ config: &Config,
  broadcasted: bool,
  ) -> Result<Self> {
- let path =
- MultiChainSequence::get_path(&log_folder.join("multi"), sig, target, broadcasted)?;
-
- Ok(MultiChainSequence { deployments, path, timestamp: now().as_secs() })
+ let (path, sensitive_path) = MultiChainSequence::get_paths(
+ &config.broadcast,
+ &config.cache_path,
+ sig,
+ target,
+ broadcasted,
+ )?;
+
+ Ok(MultiChainSequence { deployments, path, sensitive_path, timestamp: now().as_secs() })
  }
 
- /// Saves to ./broadcast/multi/contract_filename[-timestamp]/sig.json
- pub fn get_path(
- out: &Path,
+ /// Gets paths in the formats
+ /// ./broadcast/multi/contract_filename[-timestamp]/sig.json and
+ /// ./cache/multi/contract_filename[-timestamp]/sig.json
+ pub fn get_paths(
+ broadcast: &Path,
+ cache: &Path,
  sig: &str,
  target: &ArtifactId,
  broadcasted: bool,
- ) -> Result<PathBuf> {
- let mut out = out.to_path_buf();
+ ) -> Result<(PathBuf, PathBuf)> {
+ let mut broadcast = broadcast.to_path_buf();
+ let mut cache = cache.to_path_buf();
+ let mut common = PathBuf::new();
+
+ common.push("multi");
 
  if !broadcasted {
- out.push(DRY_RUN_DIR);
+ common.push(DRY_RUN_DIR);
  }
 
  let target_fname = target
  .source
  .file_name()
  .wrap_err_with(|| format!("No filename for {:?}", target.source))?
  .to_string_lossy();
- out.push(format!("{target_fname}-latest"));
 
- fs::create_dir_all(&out)?;
+ common.push(format!("{target_fname}-latest"));
+
+ broadcast.push(common.clone());
+ cache.push(common);
 
- let filename = sig
- .split_once('(')
- .wrap_err_with(|| format!("Failed to compute file name: Signature {sig} is invalid."))?
- .0;
- out.push(format!("{filename}.json"));
+ fs::create_dir_all(&broadcast)?;
+ fs::create_dir_all(&cache)?;
 
- Ok(out)
+ let filename = format!("{}.json", sig_to_file_name(sig));
+
+ broadcast.push(filename.clone());
+ cache.push(filename);
+
+ Ok((broadcast, cache))
  }
 
  /// Loads the sequences for the multi chain deployment.
- pub fn load(log_folder: &Path, sig: &str, target: &ArtifactId) -> Result<Self> {
- let path = MultiChainSequence::get_path(&log_folder.join("multi"), sig, target, true)?;
- foundry_compilers::utils::read_json_file(path).wrap_err("Multi-chain deployment not found.")
+ pub fn load(config: &Config, sig: &str, target: &ArtifactId) -> Result<Self> {
+ let (path, sensitive_path) = MultiChainSequence::get_paths(
+ &config.broadcast,
+ &config.cache_path,
+ sig,
+ target,
+ true,
+ )?;
+ let mut sequence: MultiChainSequence = foundry_compilers::utils::read_json_file(&path)
+ .wrap_err("Multi-chain deployment not found.")?;
+ let sensitive_sequence: SensitiveMultiChainSequence =
+ foundry_compilers::utils::read_json_file(&sensitive_path)
+ .wrap_err("Multi-chain deployment sensitive details not found.")?;
+
+ sequence.deployments.iter_mut().enumerate().for_each(|(i, sequence)| {
+ sequence.fill_sensitive(&sensitive_sequence.deployments[i]);
+ });
+
+ sequence.path = path;
+ sequence.sensitive_path = sensitive_path;
+
+ Ok(sequence)
  }
 
  /// Saves the transactions as file if it's a standalone deployment.
  pub fn save(&mut self) -> Result<()> {
  self.timestamp = now().as_secs();
 
+ let sensitive_sequence: SensitiveMultiChainSequence = to_sensitive(self);
+
+ // broadcast writes
  //../Contract-latest/run.json
  let mut writer = BufWriter::new(fs::create_file(&self.path)?);
  serde_json::to_writer_pretty(&mut writer, &self)?;
@@ -99,7 +152,20 @@ impl MultiChainSequence {
  fs::create_dir_all(file.parent().unwrap())?;
  fs::copy(&self.path, &file)?;
 
+ // cache writes
+ //../Contract-latest/run.json
+ let mut writer = BufWriter::new(fs::create_file(&self.sensitive_path)?);
+ serde_json::to_writer_pretty(&mut writer, &sensitive_sequence)?;
+ writer.flush()?;
+
+ //../Contract-[timestamp]/run.json
+ let path = self.sensitive_path.to_string_lossy();
+ let file = PathBuf::from(&path.replace("-latest", &format!("-{}", self.timestamp)));
+ fs::create_dir_all(file.parent().unwrap())?;
+ fs::copy(&self.sensitive_path, &file)?;
+
  println!("\nTransactions saved to: {}\n", self.path.display());
+ println!("Sensitive details saved to: {}\n", self.sensitive_path.display());
 
  Ok(())
  }

crates/forge/bin/cmd/script/sequence.rs

@@ -136,11 +136,7 @@ impl ScriptSequence {
  "Deployment's sensitive details not found for chain `{chain_id}`."
  ))?;
 
- script_sequence
- .transactions
- .iter_mut()
- .enumerate()
- .for_each(|(i, tx)| tx.rpc = sensitive_script_sequence.transactions[i].rpc.clone());
+ script_sequence.fill_sensitive(&sensitive_script_sequence);
 
  script_sequence.path = path;
  script_sequence.sensitive_path = sensitive_path;
@@ -366,6 +362,13 @@ impl ScriptSequence {
  })
  .collect()
  }
+
+ pub fn fill_sensitive(&mut self, sensitive: &SensitiveScriptSequence) {
+ self.transactions
+ .iter_mut()
+ .enumerate()
+ .for_each(|(i, tx)| tx.rpc = sensitive.transactions[i].rpc.clone());
+ }
 }
 
 impl Drop for ScriptSequence {
@@ -379,7 +382,7 @@ impl Drop for ScriptSequence {
 ///
 /// This accepts either the signature of the function or the raw calldata
 
-fn sig_to_file_name(sig: &str) -> String {
+pub fn sig_to_file_name(sig: &str) -> String {
  if let Some((name, _)) = sig.split_once('(') {
  // strip until call argument parenthesis
  return name.to_string()

crates/forge/tests/cli/multi_script.rs

@@ -61,3 +61,18 @@ forgetest_async!(can_not_change_fork_during_broadcast, |prj, cmd| {
  .args(&[&handle1.http_endpoint(), &handle2.http_endpoint()])
  .broadcast(ScriptOutcome::ErrorSelectForkOnBroadcast);
 });
+
+forgetest_async!(can_resume_multi_chain_script, |prj, cmd| {
+ let (_, handle1) = spawn(NodeConfig::test()).await;
+ let (_, handle2) = spawn(NodeConfig::test()).await;
+ let mut tester = ScriptTester::new_broadcast_without_endpoint(cmd, prj.root());
+
+ tester
+ .add_sig("MultiChainBroadcastNoLink", "deploy(string memory,string memory)")
+ .args(&[&handle1.http_endpoint(), &handle2.http_endpoint()])
+ .broadcast(ScriptOutcome::MissingWallet)
+ .load_private_keys(&[0, 1])
+ .await
+ .arg("--multi")
+ .resume(ScriptOutcome::OkBroadcast);
+});