@fuel-ts/account 0.89.2 → 0.91.0

package/dist/test-utils.mjs

@@ -20,14 +20,16 @@ var __privateMethod = (obj, member, method) => {
 
 // src/wallet/base-wallet-unlocked.ts
 import { hashMessage } from "@fuel-ts/hasher";
-import { hexlify as hexlify15 } from "@fuel-ts/utils";
+import { hexlify as hexlify16 } from "@fuel-ts/utils";
 
 // src/account.ts
+import { UTXO_ID_LEN as UTXO_ID_LEN3 } from "@fuel-ts/abi-coder";
 import { Address as Address3 } from "@fuel-ts/address";
+import { randomBytes as randomBytes2 } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode15, FuelError as FuelError15 } from "@fuel-ts/errors";
 import { AbstractAccount } from "@fuel-ts/interfaces";
 import { bn as bn19 } from "@fuel-ts/math";
-import { arrayify as arrayify14, isDefined as isDefined2 } from "@fuel-ts/utils";
+import { arrayify as arrayify14, hexlify as hexlify13, isDefined as isDefined2 } from "@fuel-ts/utils";
 import { clone as clone4 } from "ramda";
 
 // src/providers/coin-quantity.ts
@@ -302,6 +304,7 @@ var MessageProofFragmentDoc = gql`
     proofIndex
   }
   messageBlockHeader {
+    version
     id
     daHeight
     consensusParametersVersion
@@ -317,6 +320,7 @@ var MessageProofFragmentDoc = gql`
     applicationHash
   }
   commitBlockHeader {
+    version
     id
     daHeight
     consensusParametersVersion
@@ -503,6 +507,15 @@ var GasCostsFragmentDoc = gql`
   wqmm
   xor
   xori
+  alocDependentCost {
+    ...DependentCostFragment
+  }
+  cfe {
+    ...DependentCostFragment
+  }
+  cfeiDependentCost {
+    ...DependentCostFragment
+  }
   call {
     ...DependentCostFragment
   }
@@ -687,9 +700,13 @@ var GetTransactionsDocument = gql`
         ...transactionFragment
       }
     }
+    pageInfo {
+      ...pageInfoFragment
+    }
   }
 }
-    ${TransactionFragmentDoc}`;
+    ${TransactionFragmentDoc}
+${PageInfoFragmentDoc}`;
 var GetTransactionsByOwnerDocument = gql`
     query getTransactionsByOwner($owner: Address!, $after: String, $before: String, $first: Int, $last: Int) {
   transactionsByOwner(
@@ -881,8 +898,12 @@ var GetRelayedTransactionStatusDocument = gql`
 }
     ${RelayedTransactionStatusFragmentDoc}`;
 var DryRunDocument = gql`
-    mutation dryRun($encodedTransactions: [HexString!]!, $utxoValidation: Boolean) {
-  dryRun(txs: $encodedTransactions, utxoValidation: $utxoValidation) {
+    mutation dryRun($encodedTransactions: [HexString!]!, $utxoValidation: Boolean, $gasPrice: U64) {
+  dryRun(
+    txs: $encodedTransactions
+    utxoValidation: $utxoValidation
+    gasPrice: $gasPrice
+  ) {
     ...dryRunTransactionExecutionStatusFragment
   }
 }
@@ -1647,15 +1668,6 @@ function normalizeJSON(root) {
   return normalize(clone(root));
 }
 
-// src/providers/utils/sleep.ts
-function sleep(time) {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      resolve(true);
-    }, time);
-  });
-}
-
 // src/providers/utils/extract-tx-error.ts
 import { ErrorCode as ErrorCode7, FuelError as FuelError7 } from "@fuel-ts/errors";
 import { bn as bn6 } from "@fuel-ts/math";
@@ -1669,7 +1681,7 @@ import {
   PANIC_REASONS,
   PANIC_DOC_URL
 } from "@fuel-ts/transactions/configs";
-var assemblePanicError = (statusReason) => {
+var assemblePanicError = (statusReason, metadata) => {
   let errorMessage = `The transaction reverted with reason: "${statusReason}".`;
   if (PANIC_REASONS.includes(statusReason)) {
     errorMessage = `${errorMessage}
@@ -1678,10 +1690,13 @@ You can read more about this error at:
 
 ${PANIC_DOC_URL}#variant.${statusReason}`;
   }
-  return { errorMessage, reason: statusReason };
+  return new FuelError7(ErrorCode7.SCRIPT_REVERTED, errorMessage, {
+    ...metadata,
+    reason: statusReason
+  });
 };
 var stringify = (obj) => JSON.stringify(obj, null, 2);
-var assembleRevertError = (receipts, logs) => {
+var assembleRevertError = (receipts, logs, metadata) => {
   let errorMessage = "The transaction reverted with an unknown reason.";
   const revertReceipt = receipts.find(({ type }) => type === ReceiptType3.Revert);
   let reason = "";
@@ -1714,25 +1729,36 @@ var assembleRevertError = (receipts, logs) => {
         errorMessage = `The transaction reverted because it's missing an "OutputChange".`;
         break;
       default:
-        reason = "unknown";
-        errorMessage = `The transaction reverted with an unknown reason: ${revertReceipt.val}`;
+        throw new FuelError7(
+          ErrorCode7.UNKNOWN,
+          `The transaction reverted with an unknown reason: ${revertReceipt.val}`,
+          {
+            ...metadata,
+            reason: "unknown"
+          }
+        );
     }
   }
-  return { errorMessage, reason };
+  return new FuelError7(ErrorCode7.SCRIPT_REVERTED, errorMessage, {
+    ...metadata,
+    reason
+  });
 };
 var extractTxError = (params) => {
   const { receipts, statusReason, logs } = params;
   const isPanic = receipts.some(({ type }) => type === ReceiptType3.Panic);
   const isRevert = receipts.some(({ type }) => type === ReceiptType3.Revert);
-  const { errorMessage, reason } = isPanic ? assemblePanicError(statusReason) : assembleRevertError(receipts, logs);
   const metadata = {
     logs,
     receipts,
     panic: isPanic,
     revert: isRevert,
-    reason
+    reason: ""
   };
-  return new FuelError7(ErrorCode7.SCRIPT_REVERTED, errorMessage, metadata);
+  if (isPanic) {
+    return assemblePanicError(statusReason, metadata);
+  }
+  return assembleRevertError(receipts, logs, metadata);
 };
 
 // src/providers/transaction-request/errors.ts
@@ -3610,6 +3636,7 @@ var TransactionResponse = class {
 };
 
 // src/providers/utils/auto-retry-fetch.ts
+import { sleep } from "@fuel-ts/utils";
 function getWaitDelay(options, retryAttemptNum) {
   const duration = options.baseDelay ?? 150;
   switch (options.backoff) {
@@ -4036,7 +4063,7 @@ Supported fuel-core version: ${supportedVersion}.`
    * @param sendTransactionParams - The provider call parameters (optional).
    * @returns A promise that resolves to the call result object.
    */
-  async call(transactionRequestLike, { utxoValidation, estimateTxDependencies = true } = {}) {
+  async dryRun(transactionRequestLike, { utxoValidation, estimateTxDependencies = true } = {}) {
     const transactionRequest = transactionRequestify(transactionRequestLike);
     if (estimateTxDependencies) {
       return this.estimateTxDependencies(transactionRequest);
@@ -4575,6 +4602,21 @@ Supported fuel-core version: ${supportedVersion}.`
       0
     )?.[0];
   }
+  /**
+   * Retrieves transactions based on the provided pagination arguments.
+   * @param paginationArgs - The pagination arguments for retrieving transactions.
+   * @returns A promise that resolves to an object containing the retrieved transactions and pagination information.
+   */
+  async getTransactions(paginationArgs) {
+    const {
+      transactions: { edges, pageInfo }
+    } = await this.operations.getTransactions(paginationArgs);
+    const coder = new TransactionCoder5();
+    const transactions = edges.map(
+      ({ node: { rawPayload } }) => coder.decode(arrayify11(rawPayload), 0)[0]
+    );
+    return { transactions, pageInfo };
+  }
   /**
    * Get deployed contract with the given ID.
    *
@@ -4892,8 +4934,8 @@ var CHAIN_IDS = {
     foundry: 31337
   },
   fuel: {
-    beta5: 0,
-    devnet: 10
+    devnet: 0,
+    testnet: 0
   }
 };
 
@@ -4941,15 +4983,15 @@ var rawAssets = [
       },
       {
         type: "fuel",
-        chainId: CHAIN_IDS.fuel.beta5,
+        chainId: CHAIN_IDS.fuel.devnet,
         decimals: 9,
-        assetId: "0x0000000000000000000000000000000000000000000000000000000000000000"
+        assetId: "0xf8f8b6283d7fa5b672b530cbb84fcccb4ff8dc40f8176ef4544ddb1f1952ad07"
       },
       {
         type: "fuel",
-        chainId: CHAIN_IDS.fuel.devnet,
+        chainId: CHAIN_IDS.fuel.testnet,
         decimals: 9,
-        assetId: "0x0000000000000000000000000000000000000000000000000000000000000000"
+        assetId: "0xf8f8b6283d7fa5b672b530cbb84fcccb4ff8dc40f8176ef4544ddb1f1952ad07"
       }
     ]
   }
@@ -5463,6 +5505,21 @@ var Account = class extends AbstractAccount {
     }
     return this.provider.simulate(transactionRequest, { estimateTxDependencies: false });
   }
+  /**
+   * Generates an array of fake resources based on the provided coins.
+   *
+   * @param coins - An array of `FakeResources` objects representing the coins.
+   * @returns An array of `Resource` objects with generated properties.
+   */
+  generateFakeResources(coins) {
+    return coins.map((coin) => ({
+      id: hexlify13(randomBytes2(UTXO_ID_LEN3)),
+      owner: this.address,
+      blockCreated: bn19(1),
+      txCreatedIdx: bn19(1),
+      ...coin
+    }));
+  }
   /** @hidden * */
   validateTransferAmount(amount) {
     if (bn19(amount).lte(0)) {
@@ -5517,10 +5574,10 @@ var Account = class extends AbstractAccount {
 
 // src/signer/signer.ts
 import { Address as Address4 } from "@fuel-ts/address";
-import { randomBytes as randomBytes2 } from "@fuel-ts/crypto";
+import { randomBytes as randomBytes3 } from "@fuel-ts/crypto";
 import { hash } from "@fuel-ts/hasher";
 import { toBytes } from "@fuel-ts/math";
-import { hexlify as hexlify13, concat as concat3, arrayify as arrayify15 } from "@fuel-ts/utils";
+import { hexlify as hexlify14, concat as concat3, arrayify as arrayify15 } from "@fuel-ts/utils";
 import { secp256k1 } from "@noble/curves/secp256k1";
 var Signer = class {
   address;
@@ -5540,9 +5597,9 @@ var Signer = class {
       }
     }
     const privateKeyBytes = toBytes(privateKey, 32);
-    this.privateKey = hexlify13(privateKeyBytes);
-    this.publicKey = hexlify13(secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
-    this.compressedPublicKey = hexlify13(secp256k1.getPublicKey(privateKeyBytes, true));
+    this.privateKey = hexlify14(privateKeyBytes);
+    this.publicKey = hexlify14(secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
+    this.compressedPublicKey = hexlify14(secp256k1.getPublicKey(privateKeyBytes, true));
     this.address = Address4.fromPublicKey(this.publicKey);
   }
   /**
@@ -5560,7 +5617,7 @@ var Signer = class {
     const r = toBytes(`0x${signature.r.toString(16)}`, 32);
     const s = toBytes(`0x${signature.s.toString(16)}`, 32);
     s[0] |= (signature.recovery || 0) << 7;
-    return hexlify13(concat3([r, s]));
+    return hexlify14(concat3([r, s]));
   }
   /**
    * Add point on the current elliptic curve
@@ -5587,11 +5644,11 @@ var Signer = class {
     const s = signedMessageBytes.slice(32, 64);
     const recoveryParam = (s[0] & 128) >> 7;
     s[0] &= 127;
-    const sig = new secp256k1.Signature(BigInt(hexlify13(r)), BigInt(hexlify13(s))).addRecoveryBit(
+    const sig = new secp256k1.Signature(BigInt(hexlify14(r)), BigInt(hexlify14(s))).addRecoveryBit(
       recoveryParam
     );
     const publicKey = sig.recoverPublicKey(arrayify15(data)).toRawBytes(false).slice(1);
-    return hexlify13(publicKey);
+    return hexlify14(publicKey);
   }
   /**
    * Recover the address from a signature performed with [`sign`](#sign).
@@ -5610,7 +5667,7 @@ var Signer = class {
    * @returns random 32-byte hashed
    */
   static generatePrivateKey(entropy) {
-    return entropy ? hash(concat3([randomBytes2(32), arrayify15(entropy)])) : randomBytes2(32);
+    return entropy ? hash(concat3([randomBytes3(32), arrayify15(entropy)])) : randomBytes3(32);
   }
   /**
    * Extended publicKey from a compact publicKey
@@ -5620,7 +5677,7 @@ var Signer = class {
    */
   static extendPublicKey(publicKey) {
     const point = secp256k1.ProjectivePoint.fromHex(arrayify15(publicKey));
-    return hexlify13(point.toRawBytes(false).slice(1));
+    return hexlify14(point.toRawBytes(false).slice(1));
   }
 };
 
@@ -5629,14 +5686,14 @@ import { Address as Address5 } from "@fuel-ts/address";
 import {
   bufferFromString,
   keccak256,
-  randomBytes as randomBytes3,
+  randomBytes as randomBytes4,
   scrypt,
   stringFromBuffer,
   decryptJsonWalletData,
   encryptJsonWalletData
 } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode16, FuelError as FuelError16 } from "@fuel-ts/errors";
-import { hexlify as hexlify14 } from "@fuel-ts/utils";
+import { hexlify as hexlify15 } from "@fuel-ts/utils";
 import { v4 as uuidv4 } from "uuid";
 var DEFAULT_KDF_PARAMS_LOG_N = 13;
 var DEFAULT_KDF_PARAMS_R = 8;
@@ -5652,7 +5709,7 @@ var removeHexPrefix = (hexString) => {
 async function encryptKeystoreWallet(privateKey, address, password) {
   const privateKeyBuffer = bufferFromString(removeHexPrefix(privateKey), "hex");
   const ownerAddress = Address5.fromAddressOrString(address);
-  const salt = randomBytes3(DEFAULT_KEY_SIZE);
+  const salt = randomBytes4(DEFAULT_KEY_SIZE);
   const key = scrypt({
     password: bufferFromString(password),
     salt,
@@ -5661,7 +5718,7 @@ async function encryptKeystoreWallet(privateKey, address, password) {
     r: DEFAULT_KDF_PARAMS_R,
     p: DEFAULT_KDF_PARAMS_P
   });
-  const iv = randomBytes3(DEFAULT_IV_SIZE);
+  const iv = randomBytes4(DEFAULT_IV_SIZE);
   const ciphertext = await encryptJsonWalletData(privateKeyBuffer, key, iv);
   const data = Uint8Array.from([...key.subarray(16, 32), ...ciphertext]);
   const macHashUint8Array = keccak256(data);
@@ -5719,7 +5776,7 @@ async function decryptKeystoreWallet(jsonWallet, password) {
     );
   }
   const buffer = await decryptJsonWalletData(ciphertextBuffer, key, ivBuffer);
-  const privateKey = hexlify14(buffer);
+  const privateKey = hexlify15(buffer);
   return privateKey;
 }
 
@@ -5764,7 +5821,7 @@ var BaseWalletUnlocked = class extends Account {
    */
   async signMessage(message) {
     const signedMessage = await this.signer().sign(hashMessage(message));
-    return hexlify15(signedMessage);
+    return hexlify16(signedMessage);
   }
   /**
    * Signs a transaction with the wallet's private key.
@@ -5777,7 +5834,7 @@ var BaseWalletUnlocked = class extends Account {
     const chainId = this.provider.getChainId();
     const hashedTransaction = transactionRequest.getTransactionId(chainId);
     const signature = await this.signer().sign(hashedTransaction);
-    return hexlify15(signature);
+    return hexlify16(signature);
   }
   /**
    * Populates a transaction with the witnesses signature.
@@ -5810,7 +5867,7 @@ var BaseWalletUnlocked = class extends Account {
     );
   }
   /**
-   * Populates the witness signature for a transaction and sends a call to the network using `provider.call`.
+   * Populates the witness signature for a transaction and sends a call to the network using `provider.dryRun`.
    *
    * @param transactionRequestLike - The transaction request to simulate.
    * @returns A promise that resolves to the CallResult object.
@@ -5820,7 +5877,7 @@ var BaseWalletUnlocked = class extends Account {
     if (estimateTxDependencies) {
       await this.provider.estimateTxDependencies(transactionRequest);
     }
-    return this.provider.call(
+    return this.provider.dryRun(
       await this.populateTransactionWitnessesSignature(transactionRequest),
       {
         utxoValidation: true,
@@ -5848,13 +5905,13 @@ import { computeHmac as computeHmac2, ripemd160 } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode19, FuelError as FuelError19 } from "@fuel-ts/errors";
 import { sha256 as sha2564 } from "@fuel-ts/hasher";
 import { bn as bn20, toBytes as toBytes2, toHex } from "@fuel-ts/math";
-import { arrayify as arrayify18, hexlify as hexlify17, concat as concat5, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58 } from "@fuel-ts/utils";
+import { arrayify as arrayify18, hexlify as hexlify18, concat as concat5, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58 } from "@fuel-ts/utils";
 
 // src/mnemonic/mnemonic.ts
-import { randomBytes as randomBytes4, pbkdf2, computeHmac } from "@fuel-ts/crypto";
+import { randomBytes as randomBytes5, pbkdf2, computeHmac } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode18, FuelError as FuelError18 } from "@fuel-ts/errors";
 import { sha256 as sha2563 } from "@fuel-ts/hasher";
-import { arrayify as arrayify17, hexlify as hexlify16, concat as concat4, dataSlice, encodeBase58, toUtf8Bytes } from "@fuel-ts/utils";
+import { arrayify as arrayify17, hexlify as hexlify17, concat as concat4, dataSlice, encodeBase58, toUtf8Bytes } from "@fuel-ts/utils";
 
 // src/wordlists/words/english.ts
 var english = [
@@ -8048,7 +8105,7 @@ var Mnemonic = class {
   static mnemonicToEntropy(phrase, wordlist = english) {
     const words = getWords(phrase);
     assertMnemonic(words);
-    return hexlify16(mnemonicWordsToEntropy(words, wordlist));
+    return hexlify17(mnemonicWordsToEntropy(words, wordlist));
   }
   /**
    * @param entropy - Entropy source to the mnemonic phrase.
@@ -8173,7 +8230,7 @@ var Mnemonic = class {
    * @returns A randomly generated mnemonic
    */
   static generate(size = 32, extraEntropy = "") {
-    const entropy = extraEntropy ? sha2563(concat4([randomBytes4(size), arrayify17(extraEntropy)])) : randomBytes4(size);
+    const entropy = extraEntropy ? sha2563(concat4([randomBytes5(size), arrayify17(extraEntropy)])) : randomBytes5(size);
     return Mnemonic.entropyToMnemonic(entropy);
   }
 };
@@ -8181,10 +8238,10 @@ var mnemonic_default = Mnemonic;
 
 // src/hdwallet/hdwallet.ts
 var HARDENED_INDEX = 2147483648;
-var MainnetPRV2 = hexlify17("0x0488ade4");
-var MainnetPUB = hexlify17("0x0488b21e");
-var TestnetPRV2 = hexlify17("0x04358394");
-var TestnetPUB = hexlify17("0x043587cf");
+var MainnetPRV2 = hexlify18("0x0488ade4");
+var MainnetPUB = hexlify18("0x0488b21e");
+var TestnetPRV2 = hexlify18("0x04358394");
+var TestnetPUB = hexlify18("0x043587cf");
 function base58check(data) {
   return encodeBase582(concat5([data, dataSlice2(sha2564(sha2564(data)), 0, 4)]));
 }
@@ -8195,11 +8252,11 @@ function getExtendedKeyPrefix(isPublic = false, testnet = false) {
   return testnet ? TestnetPRV2 : MainnetPRV2;
 }
 function isPublicExtendedKey(extendedKey) {
-  return [MainnetPUB, TestnetPUB].includes(hexlify17(extendedKey.slice(0, 4)));
+  return [MainnetPUB, TestnetPUB].includes(hexlify18(extendedKey.slice(0, 4)));
 }
 function isValidExtendedKey(extendedKey) {
   return [MainnetPRV2, TestnetPRV2, MainnetPUB, TestnetPUB].includes(
-    hexlify17(extendedKey.slice(0, 4))
+    hexlify18(extendedKey.slice(0, 4))
   );
 }
 function parsePath(path2, depth = 0) {
@@ -8217,8 +8274,8 @@ function parsePath(path2, depth = 0) {
 var HDWallet = class {
   depth = 0;
   index = 0;
-  fingerprint = hexlify17("0x00000000");
-  parentFingerprint = hexlify17("0x00000000");
+  fingerprint = hexlify18("0x00000000");
+  parentFingerprint = hexlify18("0x00000000");
   privateKey;
   publicKey;
   chainCode;
@@ -8230,8 +8287,8 @@ var HDWallet = class {
   constructor(config) {
     if (config.privateKey) {
       const signer = new Signer(config.privateKey);
-      this.publicKey = hexlify17(signer.compressedPublicKey);
-      this.privateKey = hexlify17(config.privateKey);
+      this.publicKey = hexlify18(signer.compressedPublicKey);
+      this.privateKey = hexlify18(config.privateKey);
     } else {
       if (!config.publicKey) {
         throw new FuelError19(
@@ -8239,7 +8296,7 @@ var HDWallet = class {
           "Both public and private Key cannot be missing. At least one should be provided."
         );
       }
-      this.publicKey = hexlify17(config.publicKey);
+      this.publicKey = hexlify18(config.publicKey);
     }
     this.parentFingerprint = config.parentFingerprint || this.parentFingerprint;
     this.fingerprint = dataSlice2(ripemd160(sha2564(this.publicKey)), 0, 4);
@@ -8288,7 +8345,7 @@ var HDWallet = class {
         parentFingerprint: this.fingerprint
       });
     }
-    const signer = new Signer(hexlify17(IL));
+    const signer = new Signer(hexlify18(IL));
     const Ki = signer.addPoint(publicKey);
     return new HDWallet({
       publicKey: Ki,
@@ -8323,7 +8380,7 @@ var HDWallet = class {
       );
     }
     const prefix = getExtendedKeyPrefix(this.privateKey == null || isPublic, testnet);
-    const depth = hexlify17(Uint8Array.from([this.depth]));
+    const depth = hexlify18(Uint8Array.from([this.depth]));
     const parentFingerprint = this.parentFingerprint;
     const index = toHex(this.index, 4);
     const chainCode = this.chainCode;
@@ -8345,7 +8402,7 @@ var HDWallet = class {
     });
   }
   static fromExtendedKey(extendedKey) {
-    const decoded = hexlify17(toBytes2(decodeBase58(extendedKey)));
+    const decoded = hexlify18(toBytes2(decodeBase58(extendedKey)));
     const bytes = arrayify18(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
@@ -8355,9 +8412,9 @@ var HDWallet = class {
       throw new FuelError19(ErrorCode19.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
     }
     const depth = bytes[4];
-    const parentFingerprint = hexlify17(bytes.slice(5, 9));
-    const index = parseInt(hexlify17(bytes.slice(9, 13)).substring(2), 16);
-    const chainCode = hexlify17(bytes.slice(13, 45));
+    const parentFingerprint = hexlify18(bytes.slice(5, 9));
+    const index = parseInt(hexlify18(bytes.slice(9, 13)).substring(2), 16);
+    const chainCode = hexlify18(bytes.slice(13, 45));
     const key = bytes.slice(45, 78);
     if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
       throw new FuelError19(
@@ -8544,11 +8601,11 @@ __publicField(Wallet, "fromExtendedKey", WalletUnlocked.fromExtendedKey);
 __publicField(Wallet, "fromEncryptedJson", WalletUnlocked.fromEncryptedJson);
 
 // src/test-utils/seedTestWallet.ts
-import { randomBytes as randomBytes5 } from "@fuel-ts/crypto";
+import { randomBytes as randomBytes6 } from "@fuel-ts/crypto";
 var seedTestWallet = async (wallet, quantities, utxosAmount = 1) => {
   const accountsToBeFunded = Array.isArray(wallet) ? wallet : [wallet];
   const [{ provider }] = accountsToBeFunded;
-  const genesisWallet = new WalletUnlocked(process.env.GENESIS_SECRET || randomBytes5(32), provider);
+  const genesisWallet = new WalletUnlocked(process.env.GENESIS_SECRET || randomBytes6(32), provider);
   const request = new ScriptTransactionRequest();
   quantities.map(coinQuantityfy).forEach(
     ({ amount, assetId }) => accountsToBeFunded.forEach(({ address }) => {
@@ -8575,9 +8632,9 @@ var generateTestWallet = async (provider, quantities) => {
 
 // src/test-utils/launchNode.ts
 import { BYTES_32 as BYTES_322 } from "@fuel-ts/abi-coder";
-import { randomBytes as randomBytes6 } from "@fuel-ts/crypto";
-import { defaultSnapshotConfigs, defaultConsensusKey, hexlify as hexlify18 } from "@fuel-ts/utils";
-import { spawn } from "child_process";
+import { randomBytes as randomBytes7 } from "@fuel-ts/crypto";
+import { FuelError as FuelError20 } from "@fuel-ts/errors";
+import { defaultConsensusKey, hexlify as hexlify19, defaultSnapshotConfigs } from "@fuel-ts/utils";
 import { randomUUID } from "crypto";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
 import os from "os";
@@ -8608,22 +8665,55 @@ var killNode = (params) => {
       state.isDead = true;
       killFn(Number(child.pid));
     }
-    child.stdout.removeAllListeners();
     child.stderr.removeAllListeners();
     if (existsSync(configPath)) {
       rmSync(configPath, { recursive: true });
     }
   }
 };
+function getFinalStateConfigJSON({ stateConfig, chainConfig }) {
+  const defaultCoins = defaultSnapshotConfigs.stateConfig.coins.map((coin) => ({
+    ...coin,
+    amount: "18446744073709551615"
+  }));
+  const defaultMessages = defaultSnapshotConfigs.stateConfig.messages.map((message) => ({
+    ...message,
+    amount: "18446744073709551615"
+  }));
+  const coins = defaultCoins.concat(stateConfig.coins.map((coin) => ({ ...coin, amount: coin.amount.toString() }))).filter((coin, index, self) => self.findIndex((c) => c.tx_id === coin.tx_id) === index);
+  const messages = defaultMessages.concat(stateConfig.messages.map((msg) => ({ ...msg, amount: msg.amount.toString() }))).filter((msg, index, self) => self.findIndex((m) => m.nonce === msg.nonce) === index);
+  if (!process.env.GENESIS_SECRET) {
+    const pk = Signer.generatePrivateKey();
+    const signer = new Signer(pk);
+    process.env.GENESIS_SECRET = hexlify19(pk);
+    coins.push({
+      tx_id: hexlify19(randomBytes7(BYTES_322)),
+      owner: signer.address.toHexString(),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      amount: "18446744073709551615",
+      asset_id: chainConfig.consensus_parameters.V1.base_asset_id,
+      output_index: 0,
+      tx_pointer_block_height: 0,
+      tx_pointer_tx_idx: 0
+    });
+  }
+  const json = JSON.stringify({
+    ...stateConfig,
+    coins,
+    messages
+  });
+  const regexMakeNumber = /("amount":)"(\d+)"/gm;
+  return json.replace(regexMakeNumber, "$1$2");
+}
 var launchNode = async ({
   ip,
   port,
   args = [],
-  fuelCorePath = process.env.FUEL_CORE_PATH ?? void 0,
+  fuelCorePath = process.env.FUEL_CORE_PATH || void 0,
   loggingEnabled = true,
-  debugEnabled = false,
-  basePath
-}) => (
+  basePath,
+  snapshotConfig = defaultSnapshotConfigs
+} = {}) => (
   // eslint-disable-next-line no-async-promise-executor
   new Promise(async (resolve, reject) => {
     const remainingArgs = extractRemainingArgs(args, [
@@ -8640,7 +8730,7 @@ var launchNode = async ({
     const poaInstant = poaInstantFlagValue === "true" || poaInstantFlagValue === void 0;
     const nativeExecutorVersion = getFlagValueFromArgs(args, "--native-executor-version") || "0";
     const graphQLStartSubstring = "Binding GraphQL provider to";
-    const command = fuelCorePath ?? "fuel-core";
+    const command = fuelCorePath || "fuel-core";
     const ipToUse = ip || "0.0.0.0";
     const portToUse = port || (await getPortPromise({
       port: 4e3,
@@ -8651,64 +8741,32 @@ var launchNode = async ({
     let snapshotDirToUse;
     const prefix = basePath || os.tmpdir();
     const suffix = basePath ? "" : randomUUID();
-    const tempDirPath = path.join(prefix, ".fuels", suffix, "snapshotDir");
+    const tempDir = path.join(prefix, ".fuels", suffix, "snapshotDir");
     if (snapshotDir) {
       snapshotDirToUse = snapshotDir;
     } else {
-      if (!existsSync(tempDirPath)) {
-        mkdirSync(tempDirPath, { recursive: true });
-      }
-      let { stateConfigJson } = defaultSnapshotConfigs;
-      const { chainConfigJson, metadataJson } = defaultSnapshotConfigs;
-      stateConfigJson = {
-        ...stateConfigJson,
-        coins: [
-          ...stateConfigJson.coins.map((coin) => ({
-            ...coin,
-            amount: "18446744073709551615"
-          }))
-        ],
-        messages: stateConfigJson.messages.map((message) => ({
-          ...message,
-          amount: "18446744073709551615"
-        }))
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      };
-      if (!process.env.GENESIS_SECRET) {
-        const pk = Signer.generatePrivateKey();
-        const signer = new Signer(pk);
-        process.env.GENESIS_SECRET = hexlify18(pk);
-        stateConfigJson.coins.push({
-          tx_id: hexlify18(randomBytes6(BYTES_322)),
-          owner: signer.address.toHexString(),
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          amount: "18446744073709551615",
-          asset_id: chainConfigJson.consensus_parameters.V1.base_asset_id,
-          output_index: 0,
-          tx_pointer_block_height: 0,
-          tx_pointer_tx_idx: 0
-        });
+      if (!existsSync(tempDir)) {
+        mkdirSync(tempDir, { recursive: true });
       }
-      let fixedStateConfigJSON = JSON.stringify(stateConfigJson);
-      const regexMakeNumber = /("amount":)"(\d+)"/gm;
-      fixedStateConfigJSON = fixedStateConfigJSON.replace(regexMakeNumber, "$1$2");
-      const chainConfigWritePath = path.join(tempDirPath, "chainConfig.json");
-      const stateConfigWritePath = path.join(tempDirPath, "stateConfig.json");
-      const metadataWritePath = path.join(tempDirPath, "metadata.json");
-      const stateTransitionWritePath = path.join(tempDirPath, "state_transition_bytecode.wasm");
-      writeFileSync(chainConfigWritePath, JSON.stringify(chainConfigJson), "utf8");
-      writeFileSync(stateConfigWritePath, fixedStateConfigJSON, "utf8");
-      writeFileSync(metadataWritePath, JSON.stringify(metadataJson), "utf8");
-      writeFileSync(stateTransitionWritePath, JSON.stringify(""));
-      snapshotDirToUse = tempDirPath;
-    }
+      const { metadata } = snapshotConfig;
+      const metadataPath = path.join(tempDir, "metadata.json");
+      const chainConfigPath = path.join(tempDir, metadata.chain_config);
+      const stateConfigPath = path.join(tempDir, metadata.table_encoding.Json.filepath);
+      const stateTransitionPath = path.join(tempDir, "state_transition_bytecode.wasm");
+      writeFileSync(chainConfigPath, JSON.stringify(snapshotConfig.chainConfig), "utf8");
+      writeFileSync(stateConfigPath, getFinalStateConfigJSON(snapshotConfig), "utf8");
+      writeFileSync(metadataPath, JSON.stringify(metadata), "utf8");
+      writeFileSync(stateTransitionPath, JSON.stringify(""));
+      snapshotDirToUse = tempDir;
+    }
+    const { spawn } = await import("child_process");
     const child = spawn(
       command,
       [
         "run",
         ["--ip", ipToUse],
         ["--port", portToUse],
-        useInMemoryDb ? ["--db-type", "in-memory"] : ["--db-path", tempDirPath],
+        useInMemoryDb ? ["--db-type", "in-memory"] : ["--db-path", tempDir],
         ["--min-gas-price", "1"],
         poaInstant ? ["--poa-instant", "true"] : [],
         ["--native-executor-version", nativeExecutorVersion],
@@ -8719,35 +8777,38 @@ var launchNode = async ({
         "--debug",
         ...remainingArgs
       ].flat(),
-      {
-        stdio: "pipe"
-      }
+      { stdio: "pipe" }
     );
     if (loggingEnabled) {
-      child.stderr.pipe(process.stderr);
-    }
-    if (debugEnabled) {
-      child.stdout.pipe(process.stdout);
+      child.stderr.on("data", (chunk) => {
+        console.log(chunk.toString());
+      });
     }
     const cleanupConfig = {
       child,
-      configPath: tempDirPath,
+      configPath: tempDir,
       killFn: treeKill,
       state: {
         isDead: false
       }
     };
     child.stderr.on("data", (chunk) => {
-      if (chunk.indexOf(graphQLStartSubstring) !== -1) {
+      const text = typeof chunk === "string" ? chunk : chunk.toString();
+      if (text.indexOf(graphQLStartSubstring) !== -1) {
+        const rows = text.split("\n");
+        const rowWithUrl = rows.find((row) => row.indexOf(graphQLStartSubstring) !== -1);
+        const [realIp, realPort] = rowWithUrl.split(" ").at(-1).trim().split(":");
         resolve({
           cleanup: () => killNode(cleanupConfig),
-          ip: ipToUse,
-          port: portToUse,
+          ip: realIp,
+          port: realPort,
+          url: `http://${realIp}:${realPort}/v1/graphql`,
           snapshotDir: snapshotDirToUse
         });
       }
-      if (/error/i.test(chunk)) {
-        reject(chunk.toString());
+      if (/error/i.test(text)) {
+        console.log(text);
+        reject(new FuelError20(FuelError20.CODES.NODE_LAUNCH_FAILED, text));
       }
     });
     process.on("exit", () => killNode(cleanupConfig));
@@ -8780,11 +8841,258 @@ var launchNodeAndGetWallets = async ({
   };
   return { wallets, stop: cleanup, provider };
 };
+
+// src/test-utils/setup-test-provider-and-wallets.ts
+import { defaultSnapshotConfigs as defaultSnapshotConfigs3 } from "@fuel-ts/utils";
+import { mergeDeepRight } from "ramda";
+
+// src/test-utils/asset-id.ts
+import { randomBytes as randomBytes8 } from "@fuel-ts/crypto";
+import { hexlify as hexlify20 } from "@fuel-ts/utils";
+var _AssetId = class {
+  constructor(value) {
+    this.value = value;
+  }
+  static random(count = 1) {
+    const assetIds = [];
+    for (let i = 0; i < count; i++) {
+      assetIds.push(new _AssetId(hexlify20(randomBytes8(32))));
+    }
+    return assetIds;
+  }
+};
+var AssetId = _AssetId;
+__publicField(AssetId, "A", new _AssetId(
+  "0x0101010101010101010101010101010101010101010101010101010101010101"
+));
+__publicField(AssetId, "B", new _AssetId(
+  "0x0202020202020202020202020202020202020202020202020202020202020202"
+));
+
+// src/test-utils/wallet-config.ts
+import { randomBytes as randomBytes9 } from "@fuel-ts/crypto";
+import { FuelError as FuelError21 } from "@fuel-ts/errors";
+import { defaultSnapshotConfigs as defaultSnapshotConfigs2, hexlify as hexlify21 } from "@fuel-ts/utils";
+var WalletsConfig = class {
+  initialState;
+  options;
+  wallets;
+  generateWallets = () => {
+    const generatedWallets = [];
+    for (let index = 1; index <= this.options.count; index++) {
+      generatedWallets.push(new WalletUnlocked(randomBytes9(32)));
+    }
+    return generatedWallets;
+  };
+  constructor(baseAssetId, config) {
+    WalletsConfig.validate(config);
+    this.options = config;
+    const { assets: assets2, coinsPerAsset, amountPerCoin, messages } = this.options;
+    this.wallets = this.generateWallets();
+    this.initialState = {
+      messages: WalletsConfig.createMessages(this.wallets, messages),
+      coins: WalletsConfig.createCoins(
+        this.wallets,
+        baseAssetId,
+        assets2,
+        coinsPerAsset,
+        amountPerCoin
+      )
+    };
+  }
+  apply(snapshotConfig) {
+    return {
+      ...snapshotConfig,
+      stateConfig: {
+        ...snapshotConfig?.stateConfig ?? defaultSnapshotConfigs2.stateConfig,
+        coins: this.initialState.coins.concat(snapshotConfig?.stateConfig?.coins || []),
+        messages: this.initialState.messages.concat(snapshotConfig?.stateConfig?.messages ?? [])
+      }
+    };
+  }
+  /**
+   * Create messages for the wallets in the format that the chain expects.
+   */
+  static createMessages(wallets, messages) {
+    return messages.map((msg) => wallets.map((wallet) => msg.toChainMessage(wallet.address))).flatMap((x) => x);
+  }
+  /**
+   * Create coins for the wallets in the format that the chain expects.
+   */
+  static createCoins(wallets, baseAssetId, assets2, coinsPerAsset, amountPerCoin) {
+    const coins = [];
+    let assetIds = [baseAssetId];
+    if (Array.isArray(assets2)) {
+      assetIds = assetIds.concat(assets2.map((a) => a.value));
+    } else {
+      assetIds = assetIds.concat(AssetId.random(assets2 - 1).map((a) => a.value));
+    }
+    wallets.map((wallet) => wallet.address.toHexString()).forEach((walletAddress) => {
+      assetIds.forEach((assetId) => {
+        for (let index = 0; index < coinsPerAsset; index++) {
+          coins.push({
+            amount: amountPerCoin,
+            asset_id: assetId,
+            owner: walletAddress,
+            tx_pointer_block_height: 0,
+            tx_pointer_tx_idx: 0,
+            output_index: 0,
+            tx_id: hexlify21(randomBytes9(32))
+          });
+        }
+      });
+    });
+    return coins;
+  }
+  static validate({
+    count: wallets,
+    assets: assets2,
+    coinsPerAsset,
+    amountPerCoin
+  }) {
+    if (Array.isArray(wallets) && wallets.length === 0 || typeof wallets === "number" && wallets <= 0) {
+      throw new FuelError21(
+        FuelError21.CODES.INVALID_INPUT_PARAMETERS,
+        "Number of wallets must be greater than zero."
+      );
+    }
+    if (Array.isArray(assets2) && assets2.length === 0 || typeof assets2 === "number" && assets2 <= 0) {
+      throw new FuelError21(
+        FuelError21.CODES.INVALID_INPUT_PARAMETERS,
+        "Number of assets per wallet must be greater than zero."
+      );
+    }
+    if (coinsPerAsset <= 0) {
+      throw new FuelError21(
+        FuelError21.CODES.INVALID_INPUT_PARAMETERS,
+        "Number of coins per asset must be greater than zero."
+      );
+    }
+    if (amountPerCoin <= 0) {
+      throw new FuelError21(
+        FuelError21.CODES.INVALID_INPUT_PARAMETERS,
+        "Amount per coin must be greater than zero."
+      );
+    }
+  }
+};
+
+// src/test-utils/setup-test-provider-and-wallets.ts
+var defaultWalletConfigOptions = {
+  count: 2,
+  assets: [AssetId.A, AssetId.B],
+  coinsPerAsset: 1,
+  amountPerCoin: 1e10,
+  messages: []
+};
+async function setupTestProviderAndWallets({
+  walletsConfig: walletsConfigOptions = {},
+  providerOptions,
+  nodeOptions = {},
+  launchNodeServerPort = process.env.LAUNCH_NODE_SERVER_PORT || void 0
+} = {}) {
+  Symbol.dispose ??= Symbol("Symbol.dispose");
+  const walletsConfig = new WalletsConfig(
+    nodeOptions.snapshotConfig?.chainConfig?.consensus_parameters?.V1?.base_asset_id ?? defaultSnapshotConfigs3.chainConfig.consensus_parameters.V1.base_asset_id,
+    {
+      ...defaultWalletConfigOptions,
+      ...walletsConfigOptions
+    }
+  );
+  const launchNodeOptions = {
+    loggingEnabled: false,
+    ...nodeOptions,
+    snapshotConfig: mergeDeepRight(
+      defaultSnapshotConfigs3,
+      walletsConfig.apply(nodeOptions?.snapshotConfig)
+    ),
+    port: "0"
+  };
+  let cleanup;
+  let url;
+  if (launchNodeServerPort) {
+    const serverUrl = `http://localhost:${launchNodeServerPort}`;
+    url = await (await fetch(serverUrl, { method: "POST", body: JSON.stringify(launchNodeOptions) })).text();
+    cleanup = () => {
+      fetch(`${serverUrl}/cleanup/${url}`);
+    };
+  } else {
+    const settings = await launchNode(launchNodeOptions);
+    url = settings.url;
+    cleanup = settings.cleanup;
+  }
+  let provider;
+  try {
+    provider = await Provider.create(url, providerOptions);
+  } catch (err) {
+    cleanup();
+    throw err;
+  }
+  const wallets = walletsConfig.wallets;
+  wallets.forEach((wallet) => {
+    wallet.connect(provider);
+  });
+  return {
+    provider,
+    wallets,
+    cleanup,
+    [Symbol.dispose]: cleanup
+  };
+}
+
+// src/test-utils/test-message.ts
+import { Address as Address6 } from "@fuel-ts/address";
+import { randomBytes as randomBytes10 } from "@fuel-ts/crypto";
+import { bn as bn21 } from "@fuel-ts/math";
+import { hexlify as hexlify22 } from "@fuel-ts/utils";
+var TestMessage = class {
+  sender;
+  recipient;
+  nonce;
+  amount;
+  data;
+  da_height;
+  /**
+   * A helper class to create messages for testing purposes.
+   *
+   * Used in tandem with `WalletsConfig`.
+   * It can also be used standalone and passed into the initial state of a chain via the `.toChainMessage` method.
+   */
+  constructor({
+    sender = Address6.fromRandom(),
+    recipient = Address6.fromRandom(),
+    nonce = hexlify22(randomBytes10(32)),
+    amount = 1e6,
+    data = "02",
+    da_height = 0
+  } = {}) {
+    this.sender = sender;
+    this.recipient = recipient;
+    this.nonce = nonce;
+    this.amount = amount;
+    this.data = data;
+    this.da_height = da_height;
+  }
+  toChainMessage(recipient) {
+    return {
+      sender: this.sender.toB256(),
+      recipient: recipient?.toB256() ?? this.recipient.toB256(),
+      nonce: this.nonce,
+      amount: bn21(this.amount).toNumber(),
+      data: this.data,
+      da_height: this.da_height
+    };
+  }
+};
 export {
+  AssetId,
+  TestMessage,
+  WalletsConfig,
   generateTestWallet,
   killNode,
   launchNode,
   launchNodeAndGetWallets,
-  seedTestWallet
+  seedTestWallet,
+  setupTestProviderAndWallets
 };
 //# sourceMappingURL=test-utils.mjs.map