refactor: canonicalize load paths in load_from functions

Cargo.toml

@@ -56,6 +56,7 @@ fuel-abi-types = "0.7.0"
 futures = "0.3.29"
 hex = { version = "0.4.3", default-features = false }
 itertools = "0.12.0"
+path-clean = "1.0.1"
 portpicker = "0.1.1"
 pretty_assertions = { version = "1.4", default-features = false }
 proc-macro2 = "1.0.70"

e2e/tests/contracts.rs

@@ -1,3 +1,4 @@
+use std::fs;
 use std::time::Duration;
 
 use fuel_tx::{
@@ -1089,17 +1090,23 @@ async fn test_add_custom_assets() -> Result<()> {
 #[tokio::test]
 async fn contract_load_error_messages() {
     {
-        let binary_path = "sway/contracts/contract_test/out/release/no_file_on_path.bin";
-        let expected_error = format!("io: file \"{binary_path}\" does not exist");
+        let binary_path = "sway/../sway/contracts/contract_test/out/release/no_file_on_path.bin";
+        let manifest_dir = env!("CARGO_MANIFEST_DIR");
+        let expected_error = format!("io: file \"{manifest_dir}/sway/contracts/contract_test/out/release/no_file_on_path.bin\" does not exist");
 
         let error = Contract::load_from(binary_path, LoadConfiguration::default())
             .expect_err("should have failed");
 
         assert_eq!(error.to_string(), expected_error);
     }
     {
-        let binary_path = "sway/contracts/contract_test/out/release/contract_test-abi.json";
-        let expected_error = format!("expected \"{binary_path}\" to have '.bin' extension");
+        let binary_path =
+            fs::canonicalize("sway/contracts/contract_test/out/release/contract_test-abi.json")
+                .unwrap();
+        let expected_error = format!(
+            "expected \"{}\" to have '.bin' extension",
+            binary_path.display()
+        );
 
         let error = Contract::load_from(binary_path, LoadConfiguration::default())
             .expect_err("should have failed");

e2e/tests/storage.rs

@@ -87,8 +87,9 @@ async fn test_init_storage_automatically() -> Result<()> {
 #[tokio::test]
 async fn storage_load_error_messages() {
     {
-        let json_path = "sway/contracts/storage/out/release/no_file_on_path.json";
-        let expected_error = format!("io: file \"{json_path}\" does not exist");
+        let json_path = "sway/../sway/contracts/storage/out/release/no_file_on_path.json";
+        let manifest_dir = env!("CARGO_MANIFEST_DIR");
+        let expected_error = format!("io: file \"{manifest_dir}/sway/contracts/storage/out/release/no_file_on_path.json\" does not exist");
 
         let error = StorageConfiguration::default()
             .add_slot_overrides_from_file(json_path)
@@ -97,8 +98,9 @@ async fn storage_load_error_messages() {
         assert_eq!(error.to_string(), expected_error);
     }
     {
-        let json_path = "sway/contracts/storage/out/release/storage.bin";
-        let expected_error = format!("expected \"{json_path}\" to have '.json' extension");
+        let json_path = "sway/../sway/contracts/storage/out/release/storage.bin";
+        let manifest_dir = env!("CARGO_MANIFEST_DIR");
+        let expected_error = format!("expected \"{manifest_dir}/sway/contracts/storage/out/release/storage.bin\" to have '.json' extension");
 
         let error = StorageConfiguration::default()
             .add_slot_overrides_from_file(json_path)

packages/fuels-accounts/Cargo.toml

@@ -22,6 +22,7 @@ fuel-tx = { workspace = true }
 fuel-types = { workspace = true, features = ["random"] }
 fuels-core = { workspace = true, default-features = false }
 itertools = { workspace = true }
+path-clean = { workspace = true }
 rand = { workspace = true, default-features = false }
 semver = { workspace = true }
 tai64 = { workspace = true, features = ["serde"] }

packages/fuels-accounts/src/predicate.rs

@@ -1,4 +1,4 @@
-use std::{fmt::Debug, fs};
+use std::{fmt::Debug, fs, path};
 
 #[cfg(feature = "std")]
 use fuels_core::types::{coin_type_id::CoinTypeId, input::Input, AssetId};
@@ -41,10 +41,16 @@ impl Predicate {
 
     pub fn load_from(file_path: &str) -> Result<Self> {
         let code = fs::read(file_path).map_err(|e| {
-            error!(
-                IO,
-                "could not read predicate binary {file_path:?}. Reason: {e}"
-            )
+            match path::absolute(file_path).map(path_clean::clean) {
+                Ok(clean_file_path) => error!(
+                    IO,
+                    "could not read predicate binary {clean_file_path:?}. Reason: {e}",
+                ),
+                Err(e) => error!(
+                    IO,
+                    "failed to make path absolute: {file_path:?}. Reason: {e}"
+                ),
+            }
         })?;
         Ok(Self::from_code(code))
     }

packages/fuels-core/src/types/errors.rs

@@ -44,7 +44,7 @@ pub type Result<T> = std::result::Result<T, Error>;
 /// Those are: `IO`, `Codec`, `Provider`, `Other`.
 #[macro_export]
 macro_rules! error {
-   ($err_variant:ident, $fmt_str: literal $(,$arg: expr)*) => {
+   ($err_variant:ident, $fmt_str: literal $(,$arg: expr)* $(,)?) => {
     $crate::types::errors::Error::$err_variant(format!($fmt_str,$($arg),*))
    }
 }

packages/fuels-programs/Cargo.toml

@@ -18,6 +18,7 @@ fuel-types = { workspace = true, features = ["default"] }
 fuels-accounts = { workspace = true }
 fuels-core = { workspace = true }
 itertools = { workspace = true }
+path-clean = { workspace = true }
 rand = { workspace = true }
 serde_json = { workspace = true }
 tokio = { workspace = true }

packages/fuels-programs/src/contract/regular.rs

@@ -1,4 +1,8 @@
-use std::{default::Default, fmt::Debug, path::Path};
+use std::{
+    default::Default,
+    fmt::Debug,
+    path::{self, Path},
+};
 
 use fuel_tx::{Bytes32, ContractId, Salt, StorageSlot};
 use fuels_accounts::Account;
@@ -99,17 +103,20 @@ impl Contract<Regular> {
         binary_filepath: impl AsRef<Path>,
         config: LoadConfiguration,
     ) -> Result<Contract<Regular>> {
-        let binary_filepath = binary_filepath.as_ref();
-        validate_path_and_extension(binary_filepath, "bin")?;
+        let clean_file_path = path::absolute(&binary_filepath)
+            .map(path_clean::clean)
+            .unwrap_or_else(|_| binary_filepath.as_ref().to_path_buf());
+        validate_path_and_extension(&clean_file_path, "bin")?;
 
-        let binary = std::fs::read(binary_filepath).map_err(|e| {
+        let binary = std::fs::read(&binary_filepath).map_err(|e| {
             std::io::Error::new(
                 e.kind(),
-                format!("failed to read binary: {binary_filepath:?}: {e}"),
+                format!("failed to read binary: {clean_file_path:?}: {e}"),
             )
         })?;
 
-        let storage_slots = super::determine_storage_slots(config.storage, binary_filepath)?;
+        let storage_slots =
+            super::determine_storage_slots(config.storage, binary_filepath.as_ref())?;
 
         Ok(Contract {
             code: Regular::new(binary, config.configurables),

packages/fuels-programs/src/contract/storage.rs

@@ -3,7 +3,7 @@ use std::{
     default::Default,
     fmt::Debug,
     io,
-    path::{Path, PathBuf},
+    path::{self, Path, PathBuf},
 };
 
 use fuel_tx::{Bytes32, StorageSlot};
@@ -94,13 +94,15 @@ impl StorageSlots {
     }
 
     pub(crate) fn load_from_file(storage_path: impl AsRef<Path>) -> Result<Self> {
-        let storage_path = storage_path.as_ref();
-        validate_path_and_extension(storage_path, "json")?;
+        let clean_storage_path = path::absolute(&storage_path)
+            .map(path_clean::clean)
+            .unwrap_or_else(|_| storage_path.as_ref().to_path_buf());
+        validate_path_and_extension(&clean_storage_path, "json")?;
 
-        let storage_json_string = std::fs::read_to_string(storage_path).map_err(|e| {
+        let storage_json_string = std::fs::read_to_string(&storage_path).map_err(|e| {
             io::Error::new(
                 e.kind(),
-                format!("failed to read storage slots from: {storage_path:?}: {e}"),
+                format!("failed to read storage slots from: {clean_storage_path:?}: {e}"),
             )
         })?;