forge_script/

build.rs

use crate::{
    ScriptArgs, ScriptConfig,
    broadcast::{BundledState, remaining_unsigned_transactions_for_recovery},
    execute::LinkedState,
    multi_sequence::MultiChainSequence,
    progress::ScriptProgress,
    receipts::is_mined_receipt_for,
    recovery::recovery_exists,
    sequence::{ScriptSequenceKind, blocked_pending},
    session::{SignerScope, script_session_expected_sender_if_configured},
};
use alloy_network::{AnyNetwork, ReceiptResponse};
use alloy_primitives::{Address, B256, map::AddressHashSet};
use alloy_provider::Provider;
use eyre::{ContextCompat, OptionExt, Result};
use forge_script_sequence::ScriptSequence;
use foundry_cheatcodes::Wallets;
use foundry_cli::opts::TempoOpts;
use foundry_common::{
    ContractData, ContractsByArtifact, ContractsByArtifactBuilder, compile::ProjectCompiler,
    external_compiler::is_builtin_compiler_source, fs::canonicalize_path, namespaced_storage,
    provider::ProviderBuilder,
};
use foundry_compilers::{
    ArtifactId, ProjectCompileOutput,
    artifacts::{BytecodeObject, Libraries},
    compilers::{Language, multi::MultiCompilerLanguage},
    info::ContractInfo,
    utils::source_files_iter,
};
use foundry_evm::{
    core::evm::FoundryEvmNetwork,
    traces::{CallTraceDecoder, debug::ContractSources},
};
use foundry_linking::Linker;
use foundry_wallets::{MultiWalletOpts, wallet_browser::signer::BrowserSigner};
use itertools::Itertools;
use std::{
    path::{Path, PathBuf},
    str::FromStr,
    sync::Arc,
};

/// Container for the compiled contracts.
#[derive(Clone, Debug)]
pub struct BuildData {
    /// Root of the project.
    pub project_root: PathBuf,
    /// The compiler output.
    pub output: ProjectCompileOutput,
    /// ID of target contract artifact.
    pub target: ArtifactId,
}

impl BuildData {
    pub fn get_linker(&self) -> Linker<'_> {
        Linker::new(self.project_root.clone(), self.output.artifact_ids().collect())
    }

    /// Links contracts. Uses CREATE2 linking when possible, otherwise falls back to
    /// default linking with sender nonce and address.
    pub async fn link<FEN: FoundryEvmNetwork>(
        self,
        script_config: &ScriptConfig<FEN>,
    ) -> Result<LinkedBuildData> {
        let create2_deployer = script_config.evm_opts.create2_deployer;
        let can_use_create2 = script_config
            .backend
            .can_use_create2_deployer(script_config.evm_opts.create2_deployer)
            .await?;

        let known_libraries = script_config.config.libraries_with_remappings()?;

        let maybe_create2_link_output = can_use_create2
            .then(|| {
                self.get_linker()
                    .link_with_create2_detailed(
                        known_libraries.clone(),
                        create2_deployer,
                        script_config.config.create2_library_salt,
                        [&self.target],
                    )
                    .ok()
            })
            .flatten();

        let (libraries, predeploy_libs) = if let Some(output) = maybe_create2_link_output {
            (
                output.output.libraries,
                ScriptPredeployLibraries::Create2 {
                    onchain: output.linked_libraries,
                    salt: script_config.config.create2_library_salt,
                    local: Vec::new(),
                },
            )
        } else {
            let output = self.get_linker().link_with_nonce_or_address_detailed(
                known_libraries,
                script_config.evm_opts.sender,
                script_config.sender_nonce,
                [&self.target],
            )?;

            (
                output.output.libraries,
                ScriptPredeployLibraries::Default {
                    onchain: output.linked_libraries,
                    local: Vec::new(),
                },
            )
        };

        LinkedBuildData::new(libraries, predeploy_libs, self)
    }

    /// Links the build data with the given libraries. Expects supplied libraries set being enough
    /// to fully link target contract.
    pub fn link_with_libraries(self, libraries: Libraries) -> Result<LinkedBuildData> {
        LinkedBuildData::new(
            libraries,
            ScriptPredeployLibraries::Default { onchain: Vec::new(), local: Vec::new() },
            self,
        )
    }
}

#[derive(Clone, Debug)]
pub enum ScriptPredeployLibraries {
    Default {
        onchain: Vec<foundry_linking::LinkedLibrary>,
        local: Vec<foundry_linking::LinkedLibrary>,
    },
    Create2 {
        onchain: Vec<foundry_linking::LinkedLibrary>,
        salt: B256,
        local: Vec<foundry_linking::LinkedLibrary>,
    },
}

impl ScriptPredeployLibraries {
    pub const fn libraries_count(&self) -> usize {
        match self {
            Self::Default { onchain, .. } => onchain.len(),
            Self::Create2 { onchain, .. } => onchain.len(),
        }
    }
}

/// Container for the linked contracts and their dependencies
#[derive(Clone, Debug)]
pub struct LinkedBuildData {
    /// Original build data, might be used to relink this object with different libraries.
    pub build_data: BuildData,
    /// Known fully linked contracts.
    pub known_contracts: ContractsByArtifact,
    /// Libraries used to link the contracts.
    pub libraries: Libraries,
    /// Libraries that need to be deployed by sender before script execution.
    pub predeploy_libraries: ScriptPredeployLibraries,
    /// Source files of the contracts. Used by debugger.
    pub sources: ContractSources,
}

impl LinkedBuildData {
    pub fn new(
        libraries: Libraries,
        predeploy_libraries: ScriptPredeployLibraries,
        mut build_data: BuildData,
    ) -> Result<Self> {
        let sources = ContractSources::from_project_output(
            &build_data.output,
            &build_data.project_root,
            Some(&libraries),
        )?;

        let storage_layouts = namespaced_storage::project_storage_layouts(
            &mut build_data.output,
            &build_data.project_root,
        );
        let linked_contracts = build_data.get_linker().get_linked_artifacts(&libraries)?;
        let known_contracts = ContractsByArtifactBuilder::new(
            linked_contracts.iter().map(|(id, artifact)| (id.clone(), artifact.into())),
        )
        .with_storage_layouts(storage_layouts)
        .build();

        Ok(Self { build_data, known_contracts, libraries, predeploy_libraries, sources })
    }

    /// Fetches target bytecode from linked contracts.
    pub fn get_target_contract(&self) -> Result<&ContractData> {
        self.known_contracts
            .get(&self.build_data.target)
            .ok_or_eyre("target not found in linked artifacts")
    }
}

/// First state basically containing only inputs of the user.
pub struct PreprocessedState<FEN: FoundryEvmNetwork> {
    pub args: ScriptArgs,
    pub script_config: ScriptConfig<FEN>,
    pub script_wallets: Wallets,
    pub browser_wallet: Option<BrowserSigner<FEN::Network>>,
}

impl<FEN: FoundryEvmNetwork> PreprocessedState<FEN> {
    /// Parses user input and compiles the contracts depending on script target.
    /// After compilation, finds exact [ArtifactId] of the target contract.
    pub fn compile(self) -> Result<CompiledState<FEN>> {
        let Self { args, script_config, script_wallets, browser_wallet } = self;
        let project = script_config.config.project()?;

        let mut target_name = args.target_contract.clone();

        // If we've received correct path, use it as target_path
        // Otherwise, parse input as <path>:<name> and use the path from the contract info, if
        // present.
        let target_path = if let Ok(path) = canonicalize_path(&args.path) {
            path
        } else {
            let contract = ContractInfo::from_str(&args.path)?;
            target_name = Some(contract.name.clone());
            if let Some(path) = contract.path {
                canonicalize_path(path)?
            } else {
                project.find_contract_path(contract.name.as_str())?
            }
        };

        let sources_to_compile = source_files_iter(
            project.paths.sources.as_path(),
            MultiCompilerLanguage::FILE_EXTENSIONS,
        );

        let compiler = ProjectCompiler::new()
            .allow_linked_libraries(script_config.config.allow_linked_libraries)
            .external_compilers(&script_config.config)
            .files(sources_to_compile)
            .dynamic_test_linking(script_config.config.dynamic_test_linking);
        let compiler = if is_builtin_compiler_source(&target_path) {
            compiler.files([target_path.clone()])
        } else {
            compiler.target_files([target_path.clone()])
        };
        let output = compiler.compile(&project)?;

        let mut target_id: Option<ArtifactId> = None;

        // Find target artifact id by name and path in compilation artifacts.
        for (id, contract) in output.artifact_ids().filter(|(id, _)| id.source == target_path) {
            if let Some(name) = &target_name {
                if id.name != *name {
                    continue;
                }
            } else if contract.abi.as_ref().is_none_or(|abi| abi.is_empty())
                || contract.bytecode.as_ref().is_none_or(|b| match &b.object {
                    BytecodeObject::Bytecode(b) => b.is_empty(),
                    BytecodeObject::Unlinked(_) => false,
                })
            {
                // Ignore contracts with empty abi or linked bytecode of length 0 which are
                // interfaces/abstract contracts/libraries.
                continue;
            }

            if let Some(target) = target_id {
                // We might have multiple artifacts for the same contract but with different
                // solc versions. Their names will have form of {name}.0.X.Y, so we are
                // stripping versions off before comparing them.
                let target_name = target.name.split('.').next().unwrap();
                let id_name = id.name.split('.').next().unwrap();
                if target_name != id_name {
                    eyre::bail!(
                        "Multiple contracts in the target path. Please specify the contract name with `--tc ContractName`"
                    );
                }
            }
            target_id = Some(id);
        }

        let target = target_id.ok_or_eyre("Could not find target contract")?;

        Ok(CompiledState {
            args,
            script_config,
            script_wallets,
            browser_wallet,
            build_data: BuildData { output, target, project_root: project.root().to_path_buf() },
        })
    }
}

/// State after we have determined and compiled target contract to be executed.
pub struct CompiledState<FEN: FoundryEvmNetwork> {
    pub args: ScriptArgs,
    pub script_config: ScriptConfig<FEN>,
    pub script_wallets: Wallets,
    pub browser_wallet: Option<BrowserSigner<FEN::Network>>,
    pub build_data: BuildData,
}

impl<FEN: FoundryEvmNetwork> CompiledState<FEN> {
    /// Uses provided sender address to compute library addresses and link contracts with them.
    pub async fn link(self) -> Result<LinkedState<FEN>> {
        let Self { args, script_config, script_wallets, browser_wallet, build_data } = self;

        let build_data = build_data.link(&script_config).await?;

        Ok(LinkedState { args, script_config, script_wallets, browser_wallet, build_data })
    }

    /// Tries loading the resumed state from the cache files, skipping simulation stage.
    pub async fn resume(mut self) -> Result<BundledState<FEN>> {
        let endpoint = if self.args.multi {
            if self.args.evm.rpc.rpc_url.is_some() {
                sh_warn!(
                    "Multichain resume submits and checks transactions through the RPC endpoints saved by the original run; `--rpc-url` is not used for that."
                )?;
            }
            None
        } else {
            let fork_url = self.script_config.evm_opts.fork_url.clone().ok_or_eyre("Missing --fork-url field, if you were trying to broadcast a multi-chain sequence, please use --multi flag")?;
            let provider = Arc::new(ProviderBuilder::<AnyNetwork>::new(&fork_url).build()?);
            let chain = provider.get_chain_id().await?;
            Some((fork_url, chain))
        };
        let chain = endpoint.as_ref().map(|(_, chain)| *chain);

        let mut sequence = if self.sequence_exists(chain, false)? {
            self.try_load_sequence(chain, false)?
        } else {
            // If the script was simulated, but there was no attempt to broadcast yet,
            // read the script sequence from the `dry-run/` folder.
            let mut sequence = self.try_load_sequence(chain, true)?;

            // Promote the complete dry-run sequence before broadcasting it.
            sequence.promote_to_broadcasted(
                &self.script_config.config,
                &self.args.sig,
                &self.build_data.target,
            )?;
            sequence
        };

        // A single-chain resume reaches the chain through an explicit `--rpc-url` instead of the
        // saved endpoint. A configured RPC only selects the chain.
        if let Some((fork_url, chain)) = endpoint
            && self.args.evm.rpc.rpc_url.is_some()
        {
            let saved = sequence.sequences()[0].chain;
            if saved != chain {
                eyre::bail!(
                    "saved sequence is for chain {saved}, but `--rpc-url` is on chain {chain}"
                );
            }
            sequence.set_rpc_override(fork_url);
        }

        let resolution = sequence.restore_delegated_pending(
            self.args.resume_attempt,
            self.args.resume_tx_hash,
            self.args.resume_retry,
        )?;
        if !self.args.batch {
            if let Some((sequence_index, _, attempt_id, hash)) = resolution {
                let provider = ProviderBuilder::<FEN::Network>::from_config_with_url(
                    &self.script_config.config,
                    sequence.rpc_url(sequence_index),
                )?
                .build()?;
                let transaction = provider
                    .get_transaction_by_hash(hash)
                    .await?
                    .context("resolved transaction is not available from the recovery endpoint")?;
                sequence.resolve_delegated_hash(attempt_id, hash, &transaction)?;
            }
            let progress = ScriptProgress::default();
            // Every sequence is reconciled even after one fails, so a failing chain does not leave
            // the receipts of later chains unrecorded.
            let mut errors = Vec::new();
            for index in 0..sequence.sequences().len() {
                // Returns the result of waiting for receipts, if anything is pending.
                let waited = async {
                    let provider = ProviderBuilder::<FEN::Network>::from_config_with_url(
                        &self.script_config.config,
                        sequence.rpc_url(index),
                    )?
                    .build()?;
                    // A saved signed attempt whose response was lost before its hash was recorded
                    // is reconciled before requesting signers when its receipt shows it was mined.
                    for operation in 0..sequence.sequences()[index].transactions.len() {
                        let deployment = &sequence.sequences()[index];
                        if let Some(hash) =
                            sequence.signed_payload(index, operation).map(|s| s.hash)
                            && !deployment.pending.contains(&hash)
                            && !deployment.reverted.contains(&hash)
                            && !deployment.receipts.iter().any(|r| r.transaction_hash() == hash)
                            && let Some(receipt) = provider.get_transaction_receipt(hash).await?
                            && is_mined_receipt_for(&receipt, hash)
                        {
                            sequence.sequences_mut()[index].add_pending(operation, hash);
                        }
                    }
                    if sequence.sequences()[index].pending.is_empty() {
                        return Ok(None);
                    }
                    let (durable_hashes, replayable_hashes) = sequence.submission_hashes(index);
                    let blocked = blocked_pending(sequence.sequences(), index);
                    Ok::<_, eyre::Report>(Some(
                        progress
                            .wait_for_pending(
                                index,
                                &mut sequence.sequences_mut()[index],
                                &provider,
                                self.script_config.config.transaction_timeout,
                                self.args.confirmations,
                                (&durable_hashes, &replayable_hashes),
                                &blocked,
                            )
                            .await,
                    ))
                }
                .await;
                let result = match waited {
                    Ok(Some(result)) => {
                        sequence.save(true, false)?;
                        result.and_then(|()| sequence.ensure_delegated_outcomes_known(index))
                    }
                    Ok(None) => Ok(()),
                    Err(err) => Err(err),
                };
                if let Err(err) = result {
                    errors.push(sequence.label_error(index, err));
                }
            }
            match errors.len() {
                0 => {}
                1 => return Err(errors.remove(0)),
                _ => eyre::bail!("{}", errors.iter().format("\n")),
            }
        }
        for deployment in sequence.sequences() {
            for hash in &deployment.reverted {
                sh_warn!(
                    "Transaction {hash} on chain {} reverted; resume will not resubmit it.",
                    deployment.chain
                )?;
            }
        }

        if !self.args.unlocked
            && !remaining_unsigned_transactions_for_recovery(&sequence).is_empty()
        {
            self.script_wallets =
                Wallets::new(self.args.wallets.get_multi_wallet().await?, self.args.evm.sender);
            self.browser_wallet = self.args.wallets.browser_signer::<FEN::Network>().await?;

            if self.args.evm.sender.is_none() {
                let addresses = self.script_wallets.addresses();
                let sender = self
                    .args
                    .maybe_load_private_key()?
                    .or_else(|| (addresses.len() == 1).then(|| addresses[0]))
                    .or_else(|| self.browser_wallet.as_ref().map(|wallet| wallet.address()));
                if let Some(sender) = sender {
                    self.script_config.update_sender(sender).await?;
                }
            }
        }

        let (args, build_data, script_wallets, browser_wallet, script_config, resume_script_error) =
            if self.args.unlocked {
                (
                    self.args,
                    self.build_data,
                    self.script_wallets,
                    self.browser_wallet,
                    self.script_config,
                    None,
                )
            } else {
                let remaining_transactions =
                    remaining_unsigned_transactions_for_recovery(&sequence);
                let remaining_froms =
                    remaining_transactions.iter().map(|tx| tx.sender).collect::<AddressHashSet>();
                let expected_session_sender = script_session_expected_sender_if_configured(
                    &self.script_config.tempo,
                    &remaining_froms,
                )?;
                let has_available_signers = has_available_script_signers(
                    &self.script_config.tempo,
                    &self.args.wallets,
                    &self.script_wallets,
                    expected_session_sender,
                    &remaining_transactions,
                )?;

                if has_available_signers {
                    (
                        self.args,
                        self.build_data,
                        self.script_wallets,
                        self.browser_wallet,
                        self.script_config,
                        None,
                    )
                } else {
                    // IF we are missing required signers, execute script as we might need to
                    // collect private keys from the execution.
                    let mut state = self;
                    state
                        .script_config
                        .update_tempo_session_sender(&state.args.wallets, state.args.evm.sender)
                        .await?;
                    let executed = state.link().await?.prepare_execution().await?.execute().await?;
                    // A failed run may still have collected every signer, so broadcast decides
                    // whether this error is fatal.
                    let resume_script_error = (!executed.execution_result.success).then(|| {
                        CallTraceDecoder::new()
                            .revert_decoder
                            .clone()
                            .with_abis(executed.build_data.known_contracts.values().map(|c| &c.abi))
                            .decode(
                                &executed.execution_result.returned,
                                executed.execution_result.exit_reason,
                            )
                    });
                    (
                        executed.args,
                        executed.build_data.build_data,
                        executed.script_wallets,
                        executed.browser_wallet,
                        executed.script_config,
                        resume_script_error,
                    )
                }
            };

        // Collect libraries from sequence and link contracts with them.
        let libraries = if sequence.is_multi() {
            // Library linking is not supported for multi-chain sequences.
            Libraries::default()
        } else {
            Libraries::parse(&sequence.sequences()[0].libraries)?
        };

        let linked_build_data = build_data.link_with_libraries(libraries)?;

        Ok(BundledState {
            args,
            script_config,
            script_wallets,
            browser_wallet,
            build_data: linked_build_data,
            sequence,
            resume_script_error,
        })
    }

    fn try_load_sequence(
        &self,
        chain: Option<u64>,
        dry_run: bool,
    ) -> Result<ScriptSequenceKind<FEN::Network>> {
        if let Some(chain) = chain {
            ScriptSequenceKind::load_single(
                &self.script_config.config,
                &self.args.sig,
                &self.build_data.target,
                chain,
                dry_run,
                self.args.batch,
            )
        } else {
            ScriptSequenceKind::load_multi(
                &self.script_config.config,
                &self.args.sig,
                &self.build_data.target,
                dry_run,
                self.args.batch,
            )
        }
    }

    fn sequence_exists(&self, chain: Option<u64>, dry_run: bool) -> Result<bool> {
        let paths = if let Some(chain) = chain {
            ScriptSequence::<FEN::Network>::get_paths(
                &self.script_config.config,
                &self.args.sig,
                &self.build_data.target,
                chain,
                dry_run,
            )?
        } else {
            MultiChainSequence::<FEN::Network>::get_paths(
                &self.script_config.config,
                &self.args.sig,
                &self.build_data.target,
                dry_run,
            )?
        };
        Ok(compatibility_progress_exists(&paths) || recovery_exists(&paths)?)
    }
}

fn compatibility_progress_exists(paths: &(PathBuf, PathBuf)) -> bool {
    [&paths.0, &paths.1].into_iter().any(|path| progress_exists(path))
}

fn progress_exists(path: &Path) -> bool {
    path.exists() || path.with_extension("previous").exists()
}

/// Returns whether every scoped signer needed for resume is already available.
///
/// `Wallets` only tracks signers collected from CLI options and script cheatcodes. A Tempo
/// session signer lives in the Accounts store instead, so resume needs to treat the session
/// root account as available only on the chain covered by the session.
fn has_available_script_signers(
    tempo: &TempoOpts,
    wallets: &MultiWalletOpts,
    script_wallets: &Wallets,
    expected_sender: Option<Address>,
    remaining: &[SignerScope],
) -> Result<bool> {
    let signers = script_wallets
        .signers()
        .map_err(|e| eyre::eyre!("Failed to get available signers: {}", e))?;
    if remaining.is_empty() {
        return Ok(true);
    }

    let session_scope = tempo
        .session_signer_for_multi_wallet_any_chain(wallets, expected_sender)?
        .map(|s| SignerScope::new(s.session.chain_id, s.access_key.account()));

    Ok(remaining.iter().all(|tx| signers.contains(&tx.sender) || session_scope == Some(*tx)))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn backup_counts_as_recoverable_progress() {
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join("run-latest.json");
        std::fs::write(path.with_extension("previous"), b"{}").unwrap();

        assert!(progress_exists(&path));
    }

    #[test]
    fn sensitive_export_counts_as_recoverable_progress() {
        let dir = tempfile::tempdir().unwrap();
        let paths = (dir.path().join("run-latest.json"), dir.path().join("run-latest-cache.json"));
        std::fs::write(&paths.1, b"{}").unwrap();

        assert!(compatibility_progress_exists(&paths));
    }

    #[test]
    fn has_available_script_signers_skips_session_resolution_when_remaining_empty() {
        let has_available = has_available_script_signers(
            &TempoOpts { session: Some(B256::repeat_byte(0x99)), ..Default::default() },
            &MultiWalletOpts::default(),
            &Wallets::new(Default::default(), None),
            None,
            &[],
        )
        .unwrap();

        assert!(has_available);
    }
}