feat(forge): replace TypedTransaction with TransactionWithMetadata on ScriptSequence (#1891)

* replace TypedTransaction with TransactionWithMetadata

* move ScriptSequence into its own module

* remove create2_contracts from ScriptSequence

* use function signature instead for tx metadata

* feed tx hash to tx metadata when adding to pending

* remove unused branch

* update progress bar after adding to pending

* use decoder to decode transaction metadata

* add test for new log format

* dont skip vec serialization on sequence

* make arguments an Option

* return err when you can

* use flat_map on add_libraries

* remove duplicate unwrap of path

* nits 🛠️ 🛠️

Author: joshieDo

cli/src/cmd/forge/script/broadcast.rs

@@ -1,8 +1,9 @@
+use super::{
+    sequence::{ScriptSequence, TransactionWithMetadata},
+    *,
+};
 use crate::{
-    cmd::{
-        forge::script::receipts::wait_for_receipts, has_different_gas_calc, ScriptSequence,
-        VerifyBundle,
-    },
+    cmd::{forge::script::receipts::wait_for_receipts, has_different_gas_calc},
     init_progress,
     opts::WalletType,
     update_progress,
@@ -11,15 +12,14 @@ use crate::{
 use ethers::{
     prelude::{Http, Provider, RetryClient, Signer, SignerMiddleware, TxHash},
     providers::Middleware,
-    types::{transaction::eip2718::TypedTransaction, Chain},
+    types::transaction::eip2718::TypedTransaction,
     utils::format_units,
 };
+use foundry_config::Chain;
 use futures::StreamExt;
 use indicatif::{ProgressBar, ProgressStyle};
 use std::{cmp::min, fmt, sync::Arc};
 
-use super::*;
-
 impl ScriptArgs {
     /// Sends the transactions which haven't been broadcasted yet.
     pub async fn send_transactions(
@@ -32,8 +32,8 @@ impl ScriptArgs {
 
         if already_broadcasted < deployment_sequence.transactions.len() {
             let required_addresses = deployment_sequence
-                .transactions
-                .iter()
+                .typed_transactions()
+                .into_iter()
                 .skip(already_broadcasted)
                 .map(|tx| *tx.from().expect("No sender for onchain transaction!"))
                 .collect();
@@ -50,7 +50,7 @@ impl ScriptArgs {
 
             // Make a one-time gas price estimation
             let (gas_price, eip1559_fees) = {
-                match deployment_sequence.transactions.front().unwrap() {
+                match deployment_sequence.transactions.front().unwrap().typed_tx() {
                     TypedTransaction::Legacy(_) | TypedTransaction::Eip2930(_) => {
                         (provider.get_gas_price().await.ok(), None)
                     }
@@ -63,8 +63,8 @@ impl ScriptArgs {
             // Iterate through transactions, matching the `from` field with the associated
             // wallet. Then send the transaction. Panics if we find a unknown `from`
             let sequence = deployment_sequence
-                .transactions
-                .iter()
+                .typed_transactions()
+                .into_iter()
                 .skip(already_broadcasted)
                 .map(|tx| {
                     let from = *tx.from().expect("No sender for onchain transaction!");
@@ -115,15 +115,14 @@ impl ScriptArgs {
                     let tx_hash = self.send_transaction(tx, signer, sequential_broadcast, fork_url);
 
                     if sequential_broadcast {
+                        let tx_hash = tx_hash.await?;
+                        deployment_sequence.add_pending(index, tx_hash);
+
                         update_progress!(pb, (index + already_broadcasted));
                         index += 1;
 
-                        wait_for_receipts(
-                            vec![tx_hash.await?],
-                            deployment_sequence,
-                            provider.clone(),
-                        )
-                        .await?;
+                        wait_for_receipts(vec![tx_hash], deployment_sequence, provider.clone())
+                            .await?;
                     } else {
                         pending_transactions.push(tx_hash);
                     }
@@ -135,11 +134,12 @@ impl ScriptArgs {
                     let mut tx_hashes = vec![];
 
                     while let Some(tx_hash) = buffer.next().await {
-                        update_progress!(pb, (index + already_broadcasted));
-                        index += 1;
                         let tx_hash = tx_hash?;
-                        deployment_sequence.add_pending(tx_hash);
+                        deployment_sequence.add_pending(index, tx_hash);
                         tx_hashes.push(tx_hash);
+
+                        update_progress!(pb, (index + already_broadcasted));
+                        index += 1;
                     }
 
                     // Checkpoint save
@@ -207,8 +207,10 @@ impl ScriptArgs {
     ) -> eyre::Result<()> {
         if let Some(txs) = transactions {
             if script_config.evm_opts.fork_url.is_some() {
-                let (gas_filled_txs, create2_contracts) =
-                    self.execute_transactions(txs, script_config, decoder).await.map_err(|_| {
+                let gas_filled_txs = self
+                    .execute_transactions(txs, script_config, decoder, &verify.known_contracts)
+                    .await
+                    .map_err(|_| {
                         eyre::eyre!(
                             "One or more transactions failed when simulating the
                 on-chain version. Check the trace by re-running with `-vvv`"
@@ -230,10 +232,6 @@ impl ScriptArgs {
 
                 deployment_sequence.add_libraries(libraries);
 
-                create2_contracts
-                    .into_iter()
-                    .for_each(|addr| deployment_sequence.add_create2(addr));
-
                 if self.broadcast {
                     self.send_transactions(&mut deployment_sequence, &fork_url).await?;
                     if self.verify {
@@ -255,35 +253,35 @@ impl ScriptArgs {
     /// and/or gas calculations).
     async fn handle_chain_requirements(
         &self,
-        txes: VecDeque<TypedTransaction>,
+        txes: VecDeque<TransactionWithMetadata>,
         provider: Arc<Provider<RetryClient<Http>>>,
         chain: u64,
-    ) -> eyre::Result<VecDeque<TypedTransaction>> {
-        let is_legacy =
-            self.legacy || Chain::try_from(chain).map(|x| Chain::is_legacy(&x)).unwrap_or_default();
+    ) -> eyre::Result<VecDeque<TransactionWithMetadata>> {
+        let mut is_legacy = self.legacy;
+        if let Chain::Named(chain) = Chain::from(chain) {
+            is_legacy |= chain.is_legacy();
+        };
 
-        let mut new_txes: VecDeque<TypedTransaction> = VecDeque::new();
+        let mut new_txes = VecDeque::new();
         let mut total_gas = U256::zero();
-        for tx in txes.into_iter() {
-            let mut tx = if is_legacy {
-                TypedTransaction::Legacy(tx.into())
-            } else {
-                TypedTransaction::Eip1559(tx.into())
-            };
+        for mut tx in txes.into_iter() {
+            tx.change_type(is_legacy);
+
+            let typed_tx = tx.typed_tx_mut();
 
             if has_different_gas_calc(chain) {
-                tx.set_gas(provider.estimate_gas(&tx).await?);
+                typed_tx.set_gas(provider.estimate_gas(typed_tx).await?);
             }
 
-            total_gas += *tx.gas().expect("");
+            total_gas += *typed_tx.gas().expect("gas is set");
 
             new_txes.push_back(tx);
         }
 
         // We don't store it in the transactions, since we want the most updated value. Right before
         // broadcasting.
         let per_gas = {
-            match new_txes.front().unwrap() {
+            match new_txes.front().unwrap().typed_tx() {
                 TypedTransaction::Legacy(_) | TypedTransaction::Eip2930(_) => {
                     provider.get_gas_price().await?
                 }

cli/src/cmd/forge/script/build.rs

@@ -1,5 +1,5 @@
 use crate::{
-    cmd::{get_cached_entry_by_name, unwrap_contracts, VerifyBundle},
+    cmd::{get_cached_entry_by_name, unwrap_contracts},
     compile,
     opts::forge::ContractInfo,
 };

cli/src/cmd/forge/script/cmd.rs

@@ -1,7 +1,4 @@
-use crate::{
-    cmd::{unwrap_contracts, ScriptSequence},
-    utils::get_http_provider,
-};
+use crate::{cmd::unwrap_contracts, utils::get_http_provider};
 
 use ethers::{
     prelude::{artifacts::CompactContractBytecode, ArtifactId, Middleware, Signer},
@@ -10,7 +7,7 @@ use ethers::{
 use forge::executor::opts::EvmOpts;
 use foundry_config::{figment::Figment, Config};
 
-use super::*;
+use super::{sequence::ScriptSequence, *};
 
 impl ScriptArgs {
     pub async fn run_script(mut self) -> eyre::Result<()> {

cli/src/cmd/forge/script/executor.rs

@@ -1,8 +1,6 @@
 use crate::{cmd::needs_setup, utils};
 
-use cast::executor::inspector::DEFAULT_CREATE2_DEPLOYER;
 use ethers::{
-    prelude::NameOrAddress,
     solc::artifacts::CompactContractBytecode,
     types::{transaction::eip2718::TypedTransaction, Address, U256},
 };
@@ -13,7 +11,7 @@ use forge::{
 
 use std::collections::VecDeque;
 
-use crate::cmd::forge::script::*;
+use crate::cmd::forge::script::{sequence::TransactionWithMetadata, *};
 
 impl ScriptArgs {
     /// Locally deploys and executes the contract method that will collect all broadcastable
@@ -73,69 +71,72 @@ impl ScriptArgs {
         transactions: VecDeque<TypedTransaction>,
         script_config: &ScriptConfig,
         decoder: &mut CallTraceDecoder,
-    ) -> eyre::Result<(VecDeque<TypedTransaction>, Vec<Address>)> {
+        contracts: &BTreeMap<ArtifactId, (Abi, Vec<u8>)>,
+    ) -> eyre::Result<VecDeque<TransactionWithMetadata>> {
         let mut runner = self.prepare_runner(script_config, script_config.evm_opts.sender).await;
-
         let mut failed = false;
         let mut sum_gas = 0;
-        let mut final_txs = transactions.clone();
-        let mut create2_contracts = vec![];
 
         if script_config.evm_opts.verbosity > 3 {
             println!("==========================");
             println!("Simulated On-chain Traces:\n");
         }
 
-        transactions
+        let address_to_abi: BTreeMap<Address, (String, &Abi)> = decoder
+            .contracts
+            .iter()
+            .filter_map(|(addr, contract_name)| {
+                if let Some((_, (abi, _))) =
+                    contracts.iter().find(|(artifact, _)| artifact.name == *contract_name)
+                {
+                    return Some((*addr, (contract_name.clone(), abi)))
+                }
+                None
+            })
+            .collect();
+
+        let final_txs: VecDeque<TransactionWithMetadata> = transactions
             .into_iter()
             .map(|tx| match tx {
-                TypedTransaction::Legacy(tx) => (tx.from, tx.to, tx.data, tx.value),
-                _ => unreachable!(),
-            })
-            .map(|(from, to, data, value)| {
-                runner
-                    .simulate(
-                        from.expect("Transaction doesn't have a `from` address at execution time"),
-                        to,
-                        data,
-                        value,
-                    )
-                    .expect("Internal EVM error")
-            })
-            .enumerate()
-            .for_each(|(i, mut result)| {
-                match &mut final_txs[i] {
-                    TypedTransaction::Legacy(tx) => {
-                        // We store the CREATE2 address, since it's hard to get it otherwise
-                        if let Some(NameOrAddress::Address(to)) = tx.to {
-                            if to == DEFAULT_CREATE2_DEPLOYER {
-                                create2_contracts.push(Address::from_slice(&result.returned));
-                            }
-                        }
-                        // We inflate the gas used by the transaction by x1.3 since the estimation
-                        // might be off
-                        tx.gas = Some(U256::from(result.gas * 13 / 10))
+                TypedTransaction::Legacy(mut tx) => {
+                    let mut result = runner
+                        .simulate(
+                            tx.from.expect(
+                                "Transaction doesn't have a `from` address at execution time",
+                            ),
+                            tx.to.clone(),
+                            tx.data.clone(),
+                            tx.value,
+                        )
+                        .expect("Internal EVM error");
+
+                    // We inflate the gas used by the transaction by x1.3 since the estimation
+                    // might be off
+                    tx.gas = Some(U256::from(result.gas * 13 / 10));
+
+                    sum_gas += result.gas;
+                    if !result.success {
+                        failed = true;
                     }
-                    _ => unreachable!(),
-                }
-
-                sum_gas += result.gas;
-                if !result.success {
-                    failed = true;
-                }
 
-                if script_config.evm_opts.verbosity > 3 {
-                    for (_kind, trace) in &mut result.traces {
-                        decoder.decode(trace);
-                        println!("{}", trace);
+                    if script_config.evm_opts.verbosity > 3 {
+                        for (_kind, trace) in &mut result.traces {
+                            decoder.decode(trace);
+                            println!("{}", trace);
+                        }
                     }
+
+                    TransactionWithMetadata::new(tx.into(), &result, &address_to_abi, decoder)
+                        .unwrap()
                 }
-            });
+                _ => unreachable!(),
+            })
+            .collect();
 
         if failed {
             Err(eyre::Report::msg("Simulated execution failed"))
         } else {
-            Ok((final_txs, create2_contracts))
+            Ok(final_txs)
         }
     }