Merge branch 'master' of github.com:FuelLabs/sway into vaivaswatha/ir2_pr3

Author: vaivaswatha

Cargo.lock

@@ -31,7 +31,6 @@ use fuels::{
 use fuels_core::types::{transaction::TxPolicies, AssetId, ContractId};
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, str::FromStr};
-use sway_core;
 
 /// Response returned from a contract call operation
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]
@@ -264,17 +263,18 @@ pub(crate) fn process_transaction_output(
                         data: Some(data),
                         ..
                     } => {
+                        let default_program_abi = ProgramABI::default();
                         let program_abi = abis
                             .get(contract_id)
-                            .map(|abi| {
-                                sway_core::asm_generation::ProgramABI::Fuel(abi.program.clone())
-                            })
-                            .unwrap_or(sway_core::asm_generation::ProgramABI::Fuel(
-                                ProgramABI::default(),
-                            ));
-                        forc_util::tx_utils::decode_log_data(&rb.to_string(), data, &program_abi)
-                            .ok()
-                            .map(|decoded| decoded.value)
+                            .map(|abi| &abi.program)
+                            .unwrap_or(&default_program_abi);
+                        forc_util::tx_utils::decode_fuel_vm_log_data(
+                            &rb.to_string(),
+                            data,
+                            program_abi,
+                        )
+                        .ok()
+                        .map(|decoded| decoded.value)
                     }
                     _ => None,
                 })

forc-plugins/forc-client/src/op/call/mod.rs

@@ -263,19 +263,14 @@ impl Node<'_> {
                     Some(data) => {
                         let hex_str = format!("0x{}", hex::encode(data));
                         match self.abis.get(id) {
-                            Some(abi) => {
-                                let program_abi = sway_core::asm_generation::ProgramABI::Fuel(
-                                    abi.program.clone(),
-                                );
-                                forc_util::tx_utils::decode_log_data(
-                                    &rb.to_string(),
-                                    data,
-                                    &program_abi,
-                                )
-                                .ok()
-                                .map(|decoded| decoded.value)
-                                .unwrap_or(hex_str)
-                            }
+                            Some(abi) => forc_util::tx_utils::decode_fuel_vm_log_data(
+                                &rb.to_string(),
+                                data,
+                                &abi.program,
+                            )
+                            .ok()
+                            .map(|decoded| decoded.value)
+                            .unwrap_or(hex_str),
                             None => hex_str,
                         }
                     }

forc-plugins/forc-client/src/op/call/transaction_trace.rs

@@ -11,6 +11,7 @@ repository.workspace = true
 [dependencies]
 anyhow.workspace = true
 forc-pkg.workspace = true
+forc-util.workspace = true
 fuel-abi-types.workspace = true
 fuel-tx = { workspace = true, features = ["test-helpers"] }
 fuel-vm = { workspace = true, features = ["random", "test-helpers"] }

forc-test/Cargo.toml

@@ -25,14 +25,14 @@ impl Syscall {
                 let mut f = unsafe { std::fs::File::from_raw_fd(*fd as i32) };
                 write!(&mut f, "{}", s).unwrap();
 
-                // Dont close the fd
+                // Don't close the fd
                 std::mem::forget(f);
             }
             Syscall::Fflush { fd } => {
                 let mut f = unsafe { std::fs::File::from_raw_fd(*fd as i32) };
                 let _ = f.flush();
 
-                // Dont close the fd
+                // Don't close the fd
                 std::mem::forget(f);
             }
             Syscall::Unknown { ra, rb, rc, rd } => {

forc-test/src/ecal.rs

@@ -8,7 +8,8 @@ use crate::setup::{
 };
 use ecal::EcalSyscallHandler;
 use forc_pkg::{self as pkg, BuildOpts};
-use fuel_abi_types::error_codes::ErrorSignal;
+use forc_util::tx_utils::RevertInfo;
+use fuel_abi_types::abi::program::ProgramABI;
 use fuel_tx as tx;
 use fuel_vm::checked_transaction::builder::TransactionBuilderExt;
 use fuel_vm::{self as vm};
@@ -516,12 +517,13 @@ impl TestResult {
         }
     }
 
-    /// Return an [ErrorSignal] for this [TestResult] if the test is failed to pass.
-    pub fn error_signal(&self) -> anyhow::Result<ErrorSignal> {
-        let revert_code = self.revert_code().ok_or_else(|| {
-            anyhow::anyhow!("there is no revert code to convert to `ErrorSignal`")
-        })?;
-        ErrorSignal::try_from_revert_code(revert_code).map_err(|e| anyhow::anyhow!(e))
+    pub fn revert_info(
+        &self,
+        program_abi: Option<&ProgramABI>,
+        logs: &[fuel_tx::Receipt],
+    ) -> Option<RevertInfo> {
+        self.revert_code()
+            .map(|revert_code| RevertInfo::new(revert_code, program_abi, logs))
     }
 
     /// Return [TestDetails] from the span of the function declaring this test.

forc-test/src/lib.rs

@@ -26,6 +26,8 @@ use sway_utils::constants;
 pub mod bytecode;
 pub mod fs_locking;
 pub mod restricted;
+#[cfg(feature = "tx")]
+pub mod tx_utils;
 
 #[macro_use]
 pub mod cli;
@@ -141,111 +143,6 @@ macro_rules! forc_result_bail {
     };
 }
 
-#[cfg(feature = "tx")]
-pub mod tx_utils {
-
-    use anyhow::Result;
-    use clap::Args;
-    use fuels_core::{codec::ABIDecoder, types::param_types::ParamType};
-    use serde::{Deserialize, Serialize};
-    use std::collections::HashMap;
-    use sway_core::{asm_generation::ProgramABI, fuel_prelude::fuel_tx};
-
-    /// Added salt used to derive the contract ID.
-    #[derive(Debug, Args, Default, Deserialize, Serialize)]
-    pub struct Salt {
-        /// Added salt used to derive the contract ID.
-        ///
-        /// By default, this is
-        /// `0x0000000000000000000000000000000000000000000000000000000000000000`.
-        #[clap(long = "salt")]
-        pub salt: Option<fuel_tx::Salt>,
-    }
-
-    /// Format `Log` and `LogData` receipts.
-    pub fn format_log_receipts(
-        receipts: &[fuel_tx::Receipt],
-        pretty_print: bool,
-    ) -> Result<String> {
-        let mut receipt_to_json_array = serde_json::to_value(receipts)?;
-        for (rec_index, receipt) in receipts.iter().enumerate() {
-            let rec_value = receipt_to_json_array.get_mut(rec_index).ok_or_else(|| {
-                anyhow::anyhow!(
-                    "Serialized receipts does not contain {} th index",
-                    rec_index
-                )
-            })?;
-            match receipt {
-                fuel_tx::Receipt::LogData {
-                    data: Some(data), ..
-                } => {
-                    if let Some(v) = rec_value.pointer_mut("/LogData/data") {
-                        *v = hex::encode(data).into();
-                    }
-                }
-                fuel_tx::Receipt::ReturnData {
-                    data: Some(data), ..
-                } => {
-                    if let Some(v) = rec_value.pointer_mut("/ReturnData/data") {
-                        *v = hex::encode(data).into();
-                    }
-                }
-                _ => {}
-            }
-        }
-        if pretty_print {
-            Ok(serde_json::to_string_pretty(&receipt_to_json_array)?)
-        } else {
-            Ok(serde_json::to_string(&receipt_to_json_array)?)
-        }
-    }
-
-    /// A `LogData` decoded into a human readable format with its type information.
-    pub struct DecodedLog {
-        pub value: String,
-    }
-
-    pub fn decode_log_data(
-        log_id: &str,
-        log_data: &[u8],
-        program_abi: &ProgramABI,
-    ) -> anyhow::Result<DecodedLog> {
-        let program_abi = match program_abi {
-            ProgramABI::Fuel(fuel_abi) => Some(
-                fuel_abi_types::abi::unified_program::UnifiedProgramABI::from_counterpart(
-                    fuel_abi,
-                )?,
-            ),
-            _ => None,
-        }
-        .ok_or_else(|| anyhow::anyhow!("only fuelvm is supported for log decoding"))?;
-        // Create type lookup (id, TypeDeclaration)
-        let type_lookup = program_abi
-            .types
-            .iter()
-            .map(|decl| (decl.type_id, decl.clone()))
-            .collect::<HashMap<_, _>>();
-
-        let logged_type_lookup: HashMap<_, _> = program_abi
-            .logged_types
-            .iter()
-            .flatten()
-            .map(|logged_type| (logged_type.log_id.as_str(), logged_type.application.clone()))
-            .collect();
-
-        let type_application = logged_type_lookup
-            .get(&log_id)
-            .ok_or_else(|| anyhow::anyhow!("log id is missing"))?;
-
-        let abi_decoder = ABIDecoder::default();
-        let param_type = ParamType::try_from_type_application(type_application, &type_lookup)?;
-        let decoded_str = abi_decoder.decode_as_debug_str(&param_type, log_data)?;
-        let decoded_log = DecodedLog { value: decoded_str };
-
-        Ok(decoded_log)
-    }
-}
-
 pub fn find_file_name<'sc>(manifest_dir: &Path, entry_path: &'sc Path) -> Result<&'sc Path> {
     let mut file_path = manifest_dir.to_path_buf();
     file_path.pop();