test: add option to run against live node

.github/workflows/ci.yml

@@ -21,7 +21,10 @@ env:
   FORC_VERSION: 0.46.0
   FORC_PATCH_BRANCH: "xunilrj/fix-implicit-std-env-vars"
   FORC_PATCH_REVISION: ""
-  FORC_IMPLICIT_STD_GIT_BRANCH: "xunilrj/fix-implicit-std-env-vars" 
+  FORC_IMPLICIT_STD_GIT_BRANCH: "xunilrj/fix-implicit-std-env-vars"
+  TEST_WALLET_SECRET_KEY_1: ${{ secrets.TEST_WALLET_SECRET_KEY_1 }}
+  TEST_WALLET_SECRET_KEY_2: ${{ secrets.TEST_WALLET_SECRET_KEY_2 }}
+  TEST_WALLET_SECRET_KEY_3: ${{ secrets.TEST_WALLET_SECRET_KEY_3 }}
 
 jobs:
   setup-test-projects:

examples/providers/src/lib.rs

@@ -14,7 +14,7 @@ mod tests {
         // Create a provider pointing to the testnet.
         // This example will not work as the testnet does not support the new version of fuel-core
         // yet
-        let provider = Provider::connect("beta-4.fuel.network").await.unwrap();
+        let provider = Provider::connect(TESTNET_NODE_URL).await.unwrap();
 
         // Setup a private key
         let secret =

packages/fuels-core/src/utils/constants.rs

@@ -11,3 +11,5 @@ pub const BASE_ASSET_ID: AssetId = AssetId::BASE;
 // ANCHOR_END: default_call_parameters
 
 pub const DEFAULT_GAS_ESTIMATION_TOLERANCE: f64 = 0.2;
+
+pub const TESTNET_NODE_URL: &str = "beta-4.fuel.network";

packages/fuels-macros/src/setup_program_test/code_gen.rs

@@ -25,7 +25,7 @@ pub(crate) fn generate_setup_program_test_code(
 
     let project_lookup = generate_project_lookup(&generate_bindings)?;
     let abigen_code = abigen_code(&project_lookup);
-    let wallet_code = wallet_initialization_code(initialize_wallets);
+    let wallet_code = wallet_initialization_code(initialize_wallets)?;
     let deploy_code = contract_deploying_code(&deploy_contract, &project_lookup);
     let script_code = script_loading_code(&load_scripts, &project_lookup);
 
@@ -66,21 +66,22 @@ fn generate_abigen_targets(project_lookup: &HashMap<String, Project>) -> Vec<Abi
         .collect()
 }
 
-fn wallet_initialization_code(maybe_command: Option<InitializeWalletCommand>) -> TokenStream {
+fn wallet_initialization_code(
+    maybe_command: Option<InitializeWalletCommand>,
+) -> syn::Result<TokenStream> {
     let command = if let Some(command) = maybe_command {
         command
     } else {
-        return Default::default();
+        return Ok(Default::default());
     };
 
     let wallet_names = extract_wallet_names(&command);
-
     if wallet_names.is_empty() {
-        return Default::default();
+        return Ok(Default::default());
     }
-
     let num_wallets = wallet_names.len();
-    quote! {
+
+    Ok(quote! {
         let [#(#wallet_names),*]: [_; #num_wallets] = launch_custom_provider_and_get_wallets(
             WalletsConfig::new(Some(#num_wallets as u64), None, None),
             None,
@@ -90,7 +91,7 @@ fn wallet_initialization_code(maybe_command: Option<InitializeWalletCommand>) ->
         .expect("Error while trying to fetch wallets from the custom provider")
         .try_into()
         .expect("Should have the exact number of wallets");
-    }
+    })
 }
 
 fn extract_wallet_names(command: &InitializeWalletCommand) -> Vec<Ident> {

packages/fuels-macros/src/setup_program_test/parsing/commands.rs

@@ -35,7 +35,7 @@ command_parser!(
     Wallets -> InitializeWalletCommand,
     Abigen -> AbigenCommand,
     Deploy -> DeployContractCommand,
-    LoadScript -> LoadScriptCommand
+    LoadScript -> LoadScriptCommand,
 );
 
 impl Parse for TestProgramCommands {

packages/fuels-test-helpers/Cargo.toml

@@ -34,3 +34,4 @@ which = { workspace = true, default-features = false }
 default = ["fuels-accounts", "std"]
 std = ["fuels-accounts?/std", "fuels-core/std"]
 fuel-core-lib = ["fuel-core"]
+test-against-live-node = []

packages/fuels-test-helpers/src/accounts.rs

@@ -1,6 +1,11 @@
 use std::mem::size_of;
+use std::str::FromStr;
 
-use fuels_accounts::{fuel_crypto::SecretKey, wallet::WalletUnlocked, ViewOnlyAccount};
+use fuels_accounts::{
+    fuel_crypto::SecretKey, provider::Provider, wallet::WalletUnlocked, ViewOnlyAccount,
+};
+use fuels_core::constants::TESTNET_NODE_URL;
+use fuels_core::error;
 use fuels_core::types::errors::Result;
 
 use crate::{
@@ -86,6 +91,44 @@ pub async fn launch_custom_provider_and_get_wallets(
     Ok(wallets)
 }
 
+pub async fn connect_to_testnet_node_and_get_wallets(
+    num_wallets: usize,
+) -> Result<Vec<WalletUnlocked>> {
+    if num_wallets > 3 {
+        error!(
+            InvalidData,
+            "Trying to get more than 3 wallets from beta node"
+        );
+    }
+    let provider = Provider::connect(TESTNET_NODE_URL)
+        .await
+        .expect("Should be able to connect to {TESTNET_NODE_URL}");
+    let wallets = (1..=num_wallets)
+        .map(|wallet_counter| {
+            let private_key_string =
+                std::env::var(format!("TEST_WALLET_SECRET_KEY_{wallet_counter}"))
+                    .expect("Should find private key in ENV");
+            let private_key = SecretKey::from_str(private_key_string.as_str())
+                .expect("Should be able to transform into private key");
+            WalletUnlocked::new_from_private_key(private_key, Some(provider.clone()))
+        })
+        .collect::<Vec<WalletUnlocked>>();
+    Ok(wallets)
+}
+
+pub async fn maybe_live_wallet(num_wallets: usize) -> Result<Vec<WalletUnlocked>> {
+    if cfg!(feature = "test-against-live-node") {
+        connect_to_testnet_node_and_get_wallets(num_wallets).await
+    } else {
+        launch_custom_provider_and_get_wallets(
+            WalletsConfig::new(Some(num_wallets as u64), None, None),
+            None,
+            None,
+        )
+        .await
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use fuels_accounts::{fuel_crypto::fuel_types::AssetId, Account, ViewOnlyAccount};

packages/fuels/Cargo.toml

@@ -53,5 +53,6 @@ std = [
 ]
 # TODO: To be removed once https://github.com/FuelLabs/fuels-rs/issues/881 is unblocked.
 test-type-paths = []
+test-against-live-node = []
 fuel-core-lib = ["fuels-test-helpers?/fuel-core-lib", "dep:fuel-core"]
 rocksdb = ["fuel-core?/rocksdb"]

packages/fuels/tests/contracts.rs

@@ -43,8 +43,11 @@ async fn test_multiple_args() -> Result<()> {
 #[tokio::test]
 async fn test_contract_calling_contract() -> Result<()> {
     // Tests a contract call that calls another contract (FooCaller calls FooContract underneath)
+    let [wallet]: [WalletUnlocked; 1] = maybe_live_wallet(1)
+        .await?
+        .try_into()
+        .expect("Vec can be converted to an array");
     setup_program_test!(
-        Wallets("wallet"),
         Abigen(
             Contract(
                 name = "LibContract",
@@ -1502,8 +1505,11 @@ async fn can_configure_decoding_of_contract_return() -> Result<()> {
 
 #[tokio::test]
 async fn test_contract_submit_and_response() -> Result<()> {
+    let [wallet]: [WalletUnlocked; 1] = maybe_live_wallet(1)
+        .await?
+        .try_into()
+        .expect("Vec can be converted to an array");
     setup_program_test!(
-        Wallets("wallet"),
         Abigen(Contract(
             name = "TestContract",
             project = "packages/fuels/tests/contracts/contract_test"

packages/fuels/tests/providers.rs

@@ -12,10 +12,12 @@ use fuels::{
     tx::Receipt,
     types::{block::Block, coin_type::CoinType, message::Message},
 };
-
-use fuels_core::types::{
-    transaction_builders::{ScriptTransactionBuilder, TransactionBuilder},
-    Bits256,
+use fuels_core::{
+    constants::TESTNET_NODE_URL,
+    types::{
+        transaction_builders::{ScriptTransactionBuilder, TransactionBuilder},
+        Bits256,
+    },
 };
 
 #[tokio::test]
@@ -634,7 +636,7 @@ async fn testnet_hello_world() -> Result<()> {
     ));
 
     // Create a provider pointing to the testnet.
-    let provider = Provider::connect("beta-4.fuel.network").await.unwrap();
+    let provider = Provider::connect(TESTNET_NODE_URL).await.unwrap();
 
     // Setup the private key.
     let secret =

packages/fuels/tests/scripts.rs

@@ -26,8 +26,11 @@ async fn test_transaction_script_workflow() -> Result<()> {
 
 #[tokio::test]
 async fn test_multi_call_script_workflow() -> Result<()> {
+    let [wallet]: [WalletUnlocked; 1] = maybe_live_wallet(1)
+        .await?
+        .try_into()
+        .expect("Vec can be converted to an array");
     setup_program_test!(
-        Wallets("wallet"),
         Abigen(Contract(
             name = "TestContract",
             project = "packages/fuels/tests/contracts/contract_test"
@@ -404,8 +407,11 @@ async fn can_configure_decoder_on_script_call() -> Result<()> {
 
 #[tokio::test]
 async fn test_script_submit_and_response() -> Result<()> {
+    let [wallet]: [WalletUnlocked; 1] = maybe_live_wallet(1)
+        .await?
+        .try_into()
+        .expect("Vec can be converted to an array");
     setup_program_test!(
-        Wallets("wallet"),
         Abigen(Script(
             name = "MyScript",
             project = "packages/fuels/tests/scripts/script_struct"