@fuel-ts/account 0.0.0-rc-1889-20240322122653 → 0.0.0-rc-1356-20240322130951

package/dist/test-utils.mjs

@@ -1,3 +1,23 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
 // src/wallet/base-wallet-unlocked.ts
 import { hashMessage } from "@fuel-ts/hasher";
 import { hexlify as hexlify15 } from "@fuel-ts/utils";
@@ -871,12 +891,11 @@ function getSdk(requester) {
 // src/providers/fuel-graphql-subscriber.ts
 import { ErrorCode, FuelError } from "@fuel-ts/errors";
 import { print } from "graphql";
-var FuelGraphqlSubscriber = class _FuelGraphqlSubscriber {
+var _FuelGraphqlSubscriber = class {
   constructor(options) {
     this.options = options;
   }
   stream;
-  static textDecoder = new TextDecoder();
   async setStream() {
     const { url, query, variables, fetchFn } = this.options;
     const response = await fetchFn(`${url}-sub`, {
@@ -936,6 +955,8 @@ var FuelGraphqlSubscriber = class _FuelGraphqlSubscriber {
     return this;
   }
 };
+var FuelGraphqlSubscriber = _FuelGraphqlSubscriber;
+__publicField(FuelGraphqlSubscriber, "textDecoder", new TextDecoder());
 
 // src/providers/memory-cache.ts
 import { ErrorCode as ErrorCode2, FuelError as FuelError2 } from "@fuel-ts/errors";
@@ -1465,15 +1486,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/transaction-request/errors.ts
 var NoWitnessAtIndexError = class extends Error {
   constructor(index) {
@@ -1495,7 +1507,7 @@ var witnessify = (value) => {
 };
 
 // src/providers/transaction-request/transaction-request.ts
-var BaseTransactionRequest = class _BaseTransactionRequest {
+var BaseTransactionRequest = class {
   /** Gas price for transaction */
   gasPrice;
   /** Block until which tx cannot be included */
@@ -1565,7 +1577,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
     const inputs = this.inputs?.map(inputify) ?? [];
     const outputs = this.outputs?.map(outputify) ?? [];
     const witnesses = this.witnesses?.map(witnessify) ?? [];
-    const { policyTypes, policies } = _BaseTransactionRequest.getPolicyMeta(this);
+    const { policyTypes, policies } = BaseTransactionRequest.getPolicyMeta(this);
     return {
       policyTypes,
       inputs,
@@ -3103,7 +3115,7 @@ function assembleTransactionSummary(params) {
 }
 
 // src/providers/transaction-response/transaction-response.ts
-var TransactionResponse = class _TransactionResponse {
+var TransactionResponse = class {
   /** Transaction ID */
   id;
   /** Current provider */
@@ -3131,7 +3143,7 @@ var TransactionResponse = class _TransactionResponse {
    * @param provider - The provider.
    */
   static async create(id, provider) {
-    const response = new _TransactionResponse(id, provider);
+    const response = new TransactionResponse(id, provider);
     await response.fetch();
     return response;
   }
@@ -3259,6 +3271,7 @@ import { BigNumberCoder } from "@fuel-ts/abi-coder";
 import { ReceiptType as ReceiptType5 } from "@fuel-ts/transactions";
 
 // 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) {
@@ -3346,7 +3359,8 @@ var processGqlChain = (chain) => {
     }
   };
 };
-var Provider = class _Provider {
+var _cacheInputs, cacheInputs_fn;
+var _Provider = class {
   /**
    * Constructor to initialize a Provider.
    *
@@ -3357,25 +3371,27 @@ var Provider = class _Provider {
    */
   constructor(url, options = {}) {
     this.url = url;
+    /**
+     * @hidden
+     */
+    __privateAdd(this, _cacheInputs);
+    __publicField(this, "operations");
+    __publicField(this, "cache");
+    __publicField(this, "options", {
+      timeout: void 0,
+      cacheUtxo: void 0,
+      fetch: void 0,
+      retryOptions: void 0
+    });
     this.options = { ...this.options, ...options };
     this.url = url;
     this.operations = this.createOperations();
     this.cache = options.cacheUtxo ? new MemoryCache(options.cacheUtxo) : void 0;
   }
-  operations;
-  cache;
   static clearChainAndNodeCaches() {
     _Provider.nodeInfoCache = {};
     _Provider.chainInfoCache = {};
   }
-  static chainInfoCache = {};
-  static nodeInfoCache = {};
-  options = {
-    timeout: void 0,
-    cacheUtxo: void 0,
-    fetch: void 0,
-    retryOptions: void 0
-  };
   static getFetchFn(options) {
     const { retryOptions, timeout } = options;
     return autoRetryFetch(async (...args) => {
@@ -3572,19 +3588,6 @@ var Provider = class _Provider {
     } = this.getChain();
     return chainId.toNumber();
   }
-  /**
-   * @hidden
-   */
-  #cacheInputs(inputs) {
-    if (!this.cache) {
-      return;
-    }
-    inputs.forEach((input) => {
-      if (input.type === InputType6.Coin) {
-        this.cache?.set(input.id);
-      }
-    });
-  }
   /**
    * Submits a transaction to the chain to be executed.
    *
@@ -3597,7 +3600,7 @@ var Provider = class _Provider {
   // #region Provider-sendTransaction
   async sendTransaction(transactionRequestLike, { estimateTxDependencies = true, awaitExecution = false } = {}) {
     const transactionRequest = transactionRequestify(transactionRequestLike);
-    this.#cacheInputs(transactionRequest.inputs);
+    __privateMethod(this, _cacheInputs, cacheInputs_fn).call(this, transactionRequest.inputs);
     if (estimateTxDependencies) {
       await this.estimateTxDependencies(transactionRequest);
     }
@@ -4222,6 +4225,20 @@ var Provider = class _Provider {
     return new TransactionResponse(transactionId, this);
   }
 };
+var Provider = _Provider;
+_cacheInputs = new WeakSet();
+cacheInputs_fn = function(inputs) {
+  if (!this.cache) {
+    return;
+  }
+  inputs.forEach((input) => {
+    if (input.type === InputType6.Coin) {
+      this.cache?.set(input.id);
+    }
+  });
+};
+__publicField(Provider, "chainInfoCache", {});
+__publicField(Provider, "nodeInfoCache", {});
 
 // src/providers/transaction-summary/get-transaction-summary.ts
 import { ErrorCode as ErrorCode13, FuelError as FuelError13 } from "@fuel-ts/errors";
@@ -4722,7 +4739,7 @@ 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 { secp256k1 } from "@noble/curves/secp256k1";
-var Signer = class _Signer {
+var Signer = class {
   address;
   publicKey;
   compressedPublicKey;
@@ -4801,7 +4818,7 @@ var Signer = class _Signer {
    * @returns Address from signature
    */
   static recoverAddress(data, signature) {
-    return Address4.fromPublicKey(_Signer.recoverPublicKey(data, signature));
+    return Address4.fromPublicKey(Signer.recoverPublicKey(data, signature));
   }
   /**
    * Generate a random privateKey
@@ -4925,10 +4942,6 @@ async function decryptKeystoreWallet(jsonWallet, password) {
 
 // src/wallet/base-wallet-unlocked.ts
 var BaseWalletUnlocked = class extends Account {
-  /**
-   * Default HDWallet path.
-   */
-  static defaultPath = "m/44'/1179993420'/0'/0/0";
   /**
    * A function that returns the wallet's signer.
    */
@@ -5034,6 +5047,10 @@ var BaseWalletUnlocked = class extends Account {
     return encryptKeystoreWallet(this.privateKey, this.address, password);
   }
 };
+/**
+ * Default HDWallet path.
+ */
+__publicField(BaseWalletUnlocked, "defaultPath", "m/44'/1179993420'/0'/0/0");
 
 // src/hdwallet/hdwallet.ts
 import { ErrorCode as ErrorCode18, FuelError as FuelError18 } from "@fuel-ts/errors";
@@ -7237,7 +7254,7 @@ function assertMnemonic(words) {
     throw new FuelError17(ErrorCode17.INVALID_MNEMONIC, errorMsg);
   }
 }
-var Mnemonic = class _Mnemonic {
+var Mnemonic = class {
   wordlist;
   /**
    *
@@ -7254,7 +7271,7 @@ var Mnemonic = class _Mnemonic {
    * @returns Entropy hash
    */
   mnemonicToEntropy(phrase) {
-    return _Mnemonic.mnemonicToEntropy(phrase, this.wordlist);
+    return Mnemonic.mnemonicToEntropy(phrase, this.wordlist);
   }
   /**
    *
@@ -7262,7 +7279,7 @@ var Mnemonic = class _Mnemonic {
    * @returns Mnemonic phrase
    */
   entropyToMnemonic(entropy) {
-    return _Mnemonic.entropyToMnemonic(entropy, this.wordlist);
+    return Mnemonic.entropyToMnemonic(entropy, this.wordlist);
   }
   /**
    *
@@ -7303,8 +7320,8 @@ var Mnemonic = class _Mnemonic {
    * @returns 64-byte array contains privateKey and chainCode as described on BIP39
    */
   static mnemonicToMasterKeys(phrase, passphrase = "") {
-    const seed = _Mnemonic.mnemonicToSeed(phrase, passphrase);
-    return _Mnemonic.masterKeysFromSeed(seed);
+    const seed = Mnemonic.mnemonicToSeed(phrase, passphrase);
+    return Mnemonic.masterKeysFromSeed(seed);
   }
   /**
    * Validates if given mnemonic is  valid
@@ -7320,7 +7337,7 @@ var Mnemonic = class _Mnemonic {
       return false;
     }
     while (i < words.length) {
-      if (_Mnemonic.binarySearch(words[i]) === false) {
+      if (Mnemonic.binarySearch(words[i]) === false) {
         return false;
       }
       i += 1;
@@ -7367,7 +7384,7 @@ var Mnemonic = class _Mnemonic {
    * @returns BIP-32 extended private key
    */
   static seedToExtendedKey(seed, testnet = false) {
-    const masterKey = _Mnemonic.masterKeysFromSeed(seed);
+    const masterKey = Mnemonic.masterKeysFromSeed(seed);
     const prefix = arrayify17(testnet ? TestnetPRV : MainnetPRV);
     const depth = "0x00";
     const fingerprint = "0x00000000";
@@ -7399,7 +7416,7 @@ var Mnemonic = class _Mnemonic {
    */
   static generate(size = 32, extraEntropy = "") {
     const entropy = extraEntropy ? sha2563(concat4([randomBytes3(size), arrayify17(extraEntropy)])) : randomBytes3(size);
-    return _Mnemonic.entropyToMnemonic(entropy);
+    return Mnemonic.entropyToMnemonic(entropy);
   }
 };
 var mnemonic_default = Mnemonic;
@@ -7439,7 +7456,7 @@ function parsePath(path2, depth = 0) {
     (p) => ~p.indexOf(`'`) ? parseInt(p, 10) + HARDENED_INDEX : parseInt(p, 10)
   );
 }
-var HDWallet = class _HDWallet {
+var HDWallet = class {
   depth = 0;
   index = 0;
   fingerprint = hexlify17("0x00000000");
@@ -7505,7 +7522,7 @@ var HDWallet = class _HDWallet {
     if (privateKey) {
       const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
       const ki = bn17(IL).add(privateKey).mod(N).toBytes(32);
-      return new _HDWallet({
+      return new HDWallet({
         privateKey: ki,
         chainCode: IR,
         index,
@@ -7515,7 +7532,7 @@ var HDWallet = class _HDWallet {
     }
     const signer = new Signer(hexlify17(IL));
     const Ki = signer.addPoint(publicKey);
-    return new _HDWallet({
+    return new HDWallet({
       publicKey: Ki,
       chainCode: IR,
       index,
@@ -7564,7 +7581,7 @@ var HDWallet = class _HDWallet {
    */
   static fromSeed(seed) {
     const masterKey = mnemonic_default.masterKeysFromSeed(seed);
-    return new _HDWallet({
+    return new HDWallet({
       chainCode: arrayify18(masterKey.slice(32)),
       privateKey: arrayify18(masterKey.slice(0, 32))
     });
@@ -7594,7 +7611,7 @@ var HDWallet = class _HDWallet {
       if (key[0] !== 3) {
         throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Invalid public extended key.");
       }
-      return new _HDWallet({
+      return new HDWallet({
         publicKey: key,
         chainCode,
         index,
@@ -7605,7 +7622,7 @@ var HDWallet = class _HDWallet {
     if (key[0] !== 0) {
       throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Invalid private extended key.");
     }
-    return new _HDWallet({
+    return new HDWallet({
       privateKey: key.slice(1),
       chainCode,
       index,
@@ -7628,7 +7645,7 @@ var WalletLocked = class extends Account {
     return new WalletUnlocked(privateKey, this._provider);
   }
 };
-var WalletUnlocked = class _WalletUnlocked extends BaseWalletUnlocked {
+var WalletUnlocked = class extends BaseWalletUnlocked {
   /**
    * Locks the wallet and returns an instance of WalletLocked.
    *
@@ -7646,7 +7663,7 @@ var WalletUnlocked = class _WalletUnlocked extends BaseWalletUnlocked {
    */
   static generate(generateOptions) {
     const privateKey = Signer.generatePrivateKey(generateOptions?.entropy);
-    return new _WalletUnlocked(privateKey, generateOptions?.provider);
+    return new WalletUnlocked(privateKey, generateOptions?.provider);
   }
   /**
    * Create a Wallet Unlocked from a seed.
@@ -7658,8 +7675,8 @@ var WalletUnlocked = class _WalletUnlocked extends BaseWalletUnlocked {
    */
   static fromSeed(seed, path2, provider) {
     const hdWallet = hdwallet_default.fromSeed(seed);
-    const childWallet = hdWallet.derivePath(path2 || _WalletUnlocked.defaultPath);
-    return new _WalletUnlocked(childWallet.privateKey, provider);
+    const childWallet = hdWallet.derivePath(path2 || WalletUnlocked.defaultPath);
+    return new WalletUnlocked(childWallet.privateKey, provider);
   }
   /**
    * Create a Wallet Unlocked from a mnemonic phrase.
@@ -7673,8 +7690,8 @@ var WalletUnlocked = class _WalletUnlocked extends BaseWalletUnlocked {
   static fromMnemonic(mnemonic, path2, passphrase, provider) {
     const seed = mnemonic_default.mnemonicToSeed(mnemonic, passphrase);
     const hdWallet = hdwallet_default.fromSeed(seed);
-    const childWallet = hdWallet.derivePath(path2 || _WalletUnlocked.defaultPath);
-    return new _WalletUnlocked(childWallet.privateKey, provider);
+    const childWallet = hdWallet.derivePath(path2 || WalletUnlocked.defaultPath);
+    return new WalletUnlocked(childWallet.privateKey, provider);
   }
   /**
    * Create a Wallet Unlocked from an extended key.
@@ -7685,7 +7702,7 @@ var WalletUnlocked = class _WalletUnlocked extends BaseWalletUnlocked {
    */
   static fromExtendedKey(extendedKey, provider) {
     const hdWallet = hdwallet_default.fromExtendedKey(extendedKey);
-    return new _WalletUnlocked(hdWallet.privateKey, provider);
+    return new WalletUnlocked(hdWallet.privateKey, provider);
   }
   /**
    * Create a Wallet Unlocked from an encrypted JSON.
@@ -7697,7 +7714,7 @@ var WalletUnlocked = class _WalletUnlocked extends BaseWalletUnlocked {
    */
   static async fromEncryptedJson(jsonWallet, password, provider) {
     const privateKey = await decryptKeystoreWallet(jsonWallet, password);
-    return new _WalletUnlocked(privateKey, provider);
+    return new WalletUnlocked(privateKey, provider);
   }
 };
 
@@ -7723,50 +7740,50 @@ var Wallet = class {
   static fromPrivateKey(privateKey, provider) {
     return new WalletUnlocked(privateKey, provider);
   }
-  /**
-   * Generate a new Wallet Unlocked with a random key pair.
-   *
-   * @param generateOptions - Options to customize the generation process (optional).
-   * @returns An unlocked wallet instance.
-   */
-  static generate = WalletUnlocked.generate;
-  /**
-   * Create a Wallet Unlocked from a seed.
-   *
-   * @param seed - The seed phrase.
-   * @param provider - A Provider instance (optional).
-   * @param path - The derivation path (optional).
-   * @returns An unlocked wallet instance.
-   */
-  static fromSeed = WalletUnlocked.fromSeed;
-  /**
-   * Create a Wallet Unlocked from a mnemonic phrase.
-   *
-   * @param mnemonic - The mnemonic phrase.
-   * @param provider - A Provider instance (optional).
-   * @param path - The derivation path (optional).
-   * @param passphrase - The passphrase for the mnemonic (optional).
-   * @returns An unlocked wallet instance.
-   */
-  static fromMnemonic = WalletUnlocked.fromMnemonic;
-  /**
-   * Create a Wallet Unlocked from an extended key.
-   *
-   * @param extendedKey - The extended key.
-   * @param provider - A Provider instance (optional).
-   * @returns An unlocked wallet instance.
-   */
-  static fromExtendedKey = WalletUnlocked.fromExtendedKey;
-  /**
-   * Create a Wallet Unlocked from an encrypted JSON.
-   *
-   * @param jsonWallet - The encrypted JSON keystore.
-   * @param password - The password to decrypt the JSON.
-   * @param provider - A Provider instance (optional).
-   * @returns An unlocked wallet instance.
-   */
-  static fromEncryptedJson = WalletUnlocked.fromEncryptedJson;
 };
+/**
+ * Generate a new Wallet Unlocked with a random key pair.
+ *
+ * @param generateOptions - Options to customize the generation process (optional).
+ * @returns An unlocked wallet instance.
+ */
+__publicField(Wallet, "generate", WalletUnlocked.generate);
+/**
+ * Create a Wallet Unlocked from a seed.
+ *
+ * @param seed - The seed phrase.
+ * @param provider - A Provider instance (optional).
+ * @param path - The derivation path (optional).
+ * @returns An unlocked wallet instance.
+ */
+__publicField(Wallet, "fromSeed", WalletUnlocked.fromSeed);
+/**
+ * Create a Wallet Unlocked from a mnemonic phrase.
+ *
+ * @param mnemonic - The mnemonic phrase.
+ * @param provider - A Provider instance (optional).
+ * @param path - The derivation path (optional).
+ * @param passphrase - The passphrase for the mnemonic (optional).
+ * @returns An unlocked wallet instance.
+ */
+__publicField(Wallet, "fromMnemonic", WalletUnlocked.fromMnemonic);
+/**
+ * Create a Wallet Unlocked from an extended key.
+ *
+ * @param extendedKey - The extended key.
+ * @param provider - A Provider instance (optional).
+ * @returns An unlocked wallet instance.
+ */
+__publicField(Wallet, "fromExtendedKey", WalletUnlocked.fromExtendedKey);
+/**
+ * Create a Wallet Unlocked from an encrypted JSON.
+ *
+ * @param jsonWallet - The encrypted JSON keystore.
+ * @param password - The password to decrypt the JSON.
+ * @param provider - A Provider instance (optional).
+ * @returns An unlocked wallet instance.
+ */
+__publicField(Wallet, "fromEncryptedJson", WalletUnlocked.fromEncryptedJson);
 
 // src/test-utils/seedTestWallet.ts
 import { randomBytes as randomBytes4 } from "@fuel-ts/crypto";
@@ -7845,7 +7862,8 @@ var launchNode = async ({
   useSystemFuelCore = false,
   loggingEnabled = true,
   debugEnabled = false,
-  basePath
+  basePath,
+  chainConfig = defaultChainConfig
 }) => (
   // eslint-disable-next-line no-async-promise-executor
   new Promise(async (resolve, reject) => {
@@ -7882,17 +7900,17 @@ var launchNode = async ({
         mkdirSync(tempDirPath, { recursive: true });
       }
       const tempChainConfigFilePath = path.join(tempDirPath, "chainConfig.json");
-      let chainConfig = defaultChainConfig;
+      let generatedChainConfig = chainConfig;
       if (!process.env.GENESIS_SECRET) {
         const pk = Signer.generatePrivateKey();
         const signer = new Signer(pk);
         process.env.GENESIS_SECRET = hexlify18(pk);
-        chainConfig = {
-          ...defaultChainConfig,
+        generatedChainConfig = {
+          ...generatedChainConfig,
           initial_state: {
-            ...defaultChainConfig.initial_state,
+            ...generatedChainConfig.initial_state,
             coins: [
-              ...defaultChainConfig.initial_state.coins,
+              ...generatedChainConfig.initial_state.coins,
               {
                 owner: signer.address.toHexString(),
                 amount: toHex2(1e9),
@@ -7902,7 +7920,7 @@ var launchNode = async ({
           }
         };
       }
-      writeFileSync(tempChainConfigFilePath, JSON.stringify(chainConfig), "utf8");
+      writeFileSync(tempChainConfigFilePath, JSON.stringify(generatedChainConfig), "utf8");
       chainConfigPathToUse = tempChainConfigFilePath;
     }
     const child = spawn(
@@ -7940,16 +7958,21 @@ var launchNode = async ({
       }
     };
     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}/graphql`,
           chainConfigPath: chainConfigPathToUse
         });
       }
-      if (/error/i.test(chunk)) {
-        reject(chunk.toString());
+      if (/error/i.test(text)) {
+        reject(text.toString());
       }
     });
     process.on("exit", () => killNode(cleanupConfig));
@@ -7981,11 +8004,221 @@ var launchNodeAndGetWallets = async ({
   };
   return { wallets, stop: cleanup, provider };
 };
+
+// src/test-utils/setup-test-provider-and-wallets.ts
+import { defaultChainConfig as defaultChainConfig2 } from "@fuel-ts/utils";
+import { mergeDeepRight } from "ramda";
+
+// src/test-utils/asset-id.ts
+import { BaseAssetId as BaseAssetId5 } from "@fuel-ts/address/configs";
+import { randomBytes as randomBytes5 } from "@fuel-ts/crypto";
+import { hexlify as hexlify19 } from "@fuel-ts/utils";
+var _AssetId = class {
+  constructor(value) {
+    this.value = value;
+  }
+  static random() {
+    return new _AssetId(hexlify19(randomBytes5(32)));
+  }
+};
+var AssetId = _AssetId;
+__publicField(AssetId, "BaseAssetId", new _AssetId(BaseAssetId5));
+__publicField(AssetId, "A", new _AssetId(
+  "0x0101010101010101010101010101010101010101010101010101010101010101"
+));
+__publicField(AssetId, "B", new _AssetId(
+  "0x0202020202020202020202020202020202020202020202020202020202020202"
+));
+
+// src/test-utils/wallet-config.ts
+import { randomBytes as randomBytes6 } from "@fuel-ts/crypto";
+import { FuelError as FuelError19 } from "@fuel-ts/errors";
+import { toHex as toHex3 } from "@fuel-ts/math";
+var WalletConfig = class {
+  initialState;
+  options;
+  wallets;
+  generateWallets = () => {
+    const generatedWallets = [];
+    for (let index = 1; index <= this.options.count; index++) {
+      generatedWallets.push(new WalletUnlocked(randomBytes6(32)));
+    }
+    return generatedWallets;
+  };
+  constructor(config) {
+    WalletConfig.guard(config);
+    this.options = config;
+    const { assets: assets2, coinsPerAsset, amountPerCoin, messages } = this.options;
+    this.wallets = this.generateWallets();
+    this.initialState = {
+      messages: WalletConfig.createMessages(this.wallets, messages),
+      coins: WalletConfig.createCoins(this.wallets, assets2, coinsPerAsset, amountPerCoin)
+    };
+  }
+  apply(chainConfig) {
+    return {
+      ...chainConfig,
+      initial_state: {
+        ...chainConfig?.initial_state,
+        coins: this.initialState.coins.concat(chainConfig?.initial_state?.coins || []),
+        messages: this.initialState.messages.concat(chainConfig?.initial_state?.messages ?? [])
+      }
+    };
+  }
+  static createMessages(wallets, messages) {
+    return messages.map((msg) => wallets.map((wallet) => msg.toChainMessage(wallet.address))).flatMap((x) => x);
+  }
+  static createCoins(wallets, assets2, coinsPerAsset, amountPerCoin) {
+    const coins = [];
+    let assetIds = [AssetId.BaseAssetId.value];
+    if (Array.isArray(assets2)) {
+      assetIds = assetIds.concat(assets2.map((a) => a.value));
+    } else {
+      for (let index = 0; index < assets2 - 1; index++) {
+        assetIds.push(AssetId.random().value);
+      }
+    }
+    wallets.map((wallet) => wallet.address.toHexString()).forEach((walletAddress) => {
+      assetIds.forEach((assetId) => {
+        for (let index = 0; index < coinsPerAsset; index++) {
+          coins.push({
+            amount: toHex3(amountPerCoin, 8),
+            asset_id: assetId,
+            owner: walletAddress
+          });
+        }
+      });
+    });
+    return coins;
+  }
+  static guard({
+    count: wallets,
+    assets: assets2,
+    coinsPerAsset,
+    amountPerCoin
+  }) {
+    if (Array.isArray(wallets) && wallets.length === 0 || typeof wallets === "number" && wallets <= 0) {
+      throw new FuelError19(
+        FuelError19.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 FuelError19(
+        FuelError19.CODES.INVALID_INPUT_PARAMETERS,
+        "Number of assets per wallet must be greater than zero."
+      );
+    }
+    if (coinsPerAsset <= 0) {
+      throw new FuelError19(
+        FuelError19.CODES.INVALID_INPUT_PARAMETERS,
+        "Number of coins per asset must be greater than zero."
+      );
+    }
+    if (amountPerCoin <= 0) {
+      throw new FuelError19(
+        FuelError19.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({
+  walletConfig: walletConfigOptions = {},
+  providerOptions,
+  nodeOptions = {}
+} = {}) {
+  Symbol.dispose ??= Symbol("Symbol.dispose");
+  const walletConfig = new WalletConfig({
+    ...defaultWalletConfigOptions,
+    ...walletConfigOptions
+  });
+  const { cleanup, url } = await launchNode({
+    ...nodeOptions,
+    chainConfig: mergeDeepRight(defaultChainConfig2, walletConfig.apply(nodeOptions?.chainConfig)),
+    port: "0"
+  });
+  let provider;
+  try {
+    provider = await Provider.create(url, providerOptions);
+  } catch (err) {
+    cleanup();
+    throw err;
+  }
+  const wallets = walletConfig.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 randomBytes7 } from "@fuel-ts/crypto";
+import { BN as BN3 } from "@fuel-ts/math";
+import { hexlify as hexlify20 } 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 `WalletConfig`.
+   * 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 = hexlify20(randomBytes7(32)),
+    amount = 1e6,
+    data = "02",
+    da_height = "0x00"
+  } = {}) {
+    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: new BN3(this.amount).toHex(8),
+      data: this.data,
+      da_height: this.da_height
+    };
+  }
+};
 export {
+  AssetId,
+  TestMessage,
+  WalletConfig,
   generateTestWallet,
   killNode,
   launchNode,
   launchNodeAndGetWallets,
-  seedTestWallet
+  seedTestWallet,
+  setupTestProviderAndWallets
 };
 //# sourceMappingURL=test-utils.mjs.map