@fuel-ts/account 0.0.0-rc-2238-20240514123903 → 0.0.0-rc-1356-20240514125020

package/dist/test-utils.mjs

@@ -26,7 +26,7 @@ import { hexlify as hexlify15 } from "@fuel-ts/utils";
 import { Address as Address3 } from "@fuel-ts/address";
 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 { bn as bn20 } from "@fuel-ts/math";
 import { arrayify as arrayify14, isDefined as isDefined2 } from "@fuel-ts/utils";
 import { clone as clone4 } from "ramda";
 
@@ -68,7 +68,7 @@ var addAmountToCoinQuantities = (params) => {
 // src/providers/provider.ts
 import { Address as Address2 } from "@fuel-ts/address";
 import { ErrorCode as ErrorCode13, FuelError as FuelError13 } from "@fuel-ts/errors";
-import { BN, bn as bn17 } from "@fuel-ts/math";
+import { BN, bn as bn18 } from "@fuel-ts/math";
 import {
   InputType as InputType7,
   TransactionType as TransactionType8,
@@ -1645,15 +1645,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";
@@ -2282,6 +2273,15 @@ var BaseTransactionRequest = class {
       }
     });
   }
+  shiftPredicateData() {
+    this.inputs.forEach((input) => {
+      if ("predicateData" in input && "padPredicateData" in input && typeof input.padPredicateData === "function") {
+        input.predicateData = input.padPredicateData(
+          BaseTransactionRequest.getPolicyMeta(this).policies.length
+        );
+      }
+    });
+  }
 };
 
 // src/providers/transaction-request/create-transaction-request.ts
@@ -2704,12 +2704,12 @@ var transactionRequestify = (obj) => {
 
 // src/providers/transaction-response/transaction-response.ts
 import { ErrorCode as ErrorCode12, FuelError as FuelError12 } from "@fuel-ts/errors";
-import { bn as bn16 } from "@fuel-ts/math";
+import { bn as bn17 } from "@fuel-ts/math";
 import { TransactionCoder as TransactionCoder4 } from "@fuel-ts/transactions";
 import { arrayify as arrayify10 } from "@fuel-ts/utils";
 
 // src/providers/transaction-summary/assemble-transaction-summary.ts
-import { bn as bn15 } from "@fuel-ts/math";
+import { bn as bn16 } from "@fuel-ts/math";
 import { PolicyType as PolicyType3 } from "@fuel-ts/transactions";
 import { DateTime, hexlify as hexlify11 } from "@fuel-ts/utils";
 
@@ -2786,32 +2786,43 @@ var calculateTXFeeForSummary = (params) => {
 // src/providers/transaction-summary/operations.ts
 import { ZeroBytes32 as ZeroBytes328 } from "@fuel-ts/address/configs";
 import { ErrorCode as ErrorCode10, FuelError as FuelError10 } from "@fuel-ts/errors";
-import { bn as bn13 } from "@fuel-ts/math";
+import { bn as bn14 } from "@fuel-ts/math";
 import { ReceiptType as ReceiptType4, TransactionType as TransactionType7 } from "@fuel-ts/transactions";
 
 // src/providers/transaction-summary/call.ts
-import { Interface as Interface2 } from "@fuel-ts/abi-coder";
-var getFunctionCall = ({ abi, receipt }) => {
+import { Interface as Interface2, calculateVmTxMemory } from "@fuel-ts/abi-coder";
+import { bn as bn13 } from "@fuel-ts/math";
+var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
   const abiInterface = new Interface2(abi);
   const callFunctionSelector = receipt.param1.toHex(8);
   const functionFragment = abiInterface.getFunction(callFunctionSelector);
   const inputs = functionFragment.jsonFn.inputs;
-  const encodedArgs = receipt.param2.toHex();
+  let encodedArgs;
+  if (functionFragment.isInputDataPointer) {
+    if (rawPayload) {
+      const argsOffset = bn13(receipt.param2).sub(calculateVmTxMemory({ maxInputs: maxInputs.toNumber() })).toNumber();
+      encodedArgs = `0x${rawPayload.slice(2).slice(argsOffset * 2)}`;
+    }
+  } else {
+    encodedArgs = receipt.param2.toHex();
+  }
   let argumentsProvided;
-  const data = functionFragment.decodeArguments(encodedArgs);
-  if (data) {
-    argumentsProvided = inputs.reduce((prev, input, index) => {
-      const value = data[index];
-      const name = input.name;
-      if (name) {
-        return {
-          ...prev,
-          // reparse to remove bn
-          [name]: JSON.parse(JSON.stringify(value))
-        };
-      }
-      return prev;
-    }, {});
+  if (encodedArgs) {
+    const data = functionFragment.decodeArguments(encodedArgs);
+    if (data) {
+      argumentsProvided = inputs.reduce((prev, input, index) => {
+        const value = data[index];
+        const name = input.name;
+        if (name) {
+          return {
+            ...prev,
+            // reparse to remove bn
+            [name]: JSON.parse(JSON.stringify(value))
+          };
+        }
+        return prev;
+      }, {});
+    }
   }
   const call = {
     functionSignature: functionFragment.signature,
@@ -2951,7 +2962,7 @@ var mergeAssets = (op1, op2) => {
     if (!matchingAsset) {
       return asset1;
     }
-    const mergedAmount = bn13(asset1.amount).add(matchingAsset.amount);
+    const mergedAmount = bn14(asset1.amount).add(matchingAsset.amount);
     return { ...asset1, amount: mergedAmount };
   });
   return mergedAssets.concat(filteredAssets);
@@ -3274,7 +3285,7 @@ var extractBurnedAssetsFromReceipts = (receipts) => {
 
 // src/providers/transaction-summary/status.ts
 import { ErrorCode as ErrorCode11, FuelError as FuelError11 } from "@fuel-ts/errors";
-import { bn as bn14 } from "@fuel-ts/math";
+import { bn as bn15 } from "@fuel-ts/math";
 var getTransactionStatusName = (gqlStatus) => {
   switch (gqlStatus) {
     case "FailureStatus":
@@ -3308,15 +3319,15 @@ var processGraphqlStatus = (gqlTransactionStatus) => {
         time = gqlTransactionStatus.time;
         blockId = gqlTransactionStatus.block.id;
         isStatusSuccess = true;
-        totalFee = bn14(gqlTransactionStatus.totalFee);
-        totalGas = bn14(gqlTransactionStatus.totalGas);
+        totalFee = bn15(gqlTransactionStatus.totalFee);
+        totalGas = bn15(gqlTransactionStatus.totalGas);
         break;
       case "FailureStatus":
         time = gqlTransactionStatus.time;
         blockId = gqlTransactionStatus.block.id;
         isStatusFailure = true;
-        totalFee = bn14(gqlTransactionStatus.totalFee);
-        totalGas = bn14(gqlTransactionStatus.totalGas);
+        totalFee = bn15(gqlTransactionStatus.totalFee);
+        totalGas = bn15(gqlTransactionStatus.totalGas);
         break;
       case "SubmittedStatus":
         time = gqlTransactionStatus.time;
@@ -3366,7 +3377,7 @@ function assembleTransactionSummary(params) {
     maxInputs
   });
   const typeName = getTransactionTypeName(transaction.type);
-  const tip = bn15(transaction.policies?.find((policy) => policy.type === PolicyType3.Tip)?.data);
+  const tip = bn16(transaction.policies?.find((policy) => policy.type === PolicyType3.Tip)?.data);
   const { isStatusFailure, isStatusPending, isStatusSuccess, blockId, status, time, totalFee } = processGraphqlStatus(gqlTransactionStatus);
   const fee = calculateTXFeeForSummary({
     totalFee,
@@ -3437,7 +3448,7 @@ var TransactionResponse = class {
   /** Current provider */
   provider;
   /** Gas used on the transaction */
-  gasUsed = bn16(0);
+  gasUsed = bn17(0);
   /** The graphql Transaction with receipts object. */
   gqlTransaction;
   abis;
@@ -3605,6 +3616,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) {
@@ -3671,47 +3683,47 @@ var processGqlChain = (chain) => {
   } = consensusParameters;
   return {
     name,
-    baseChainHeight: bn17(daHeight),
+    baseChainHeight: bn18(daHeight),
     consensusParameters: {
       version,
-      chainId: bn17(chainId),
+      chainId: bn18(chainId),
       baseAssetId,
       feeParameters: {
         version: feeParams.version,
-        gasPerByte: bn17(feeParams.gasPerByte),
-        gasPriceFactor: bn17(feeParams.gasPriceFactor)
+        gasPerByte: bn18(feeParams.gasPerByte),
+        gasPriceFactor: bn18(feeParams.gasPriceFactor)
       },
       contractParameters: {
         version: contractParams.version,
-        contractMaxSize: bn17(contractParams.contractMaxSize),
-        maxStorageSlots: bn17(contractParams.maxStorageSlots)
+        contractMaxSize: bn18(contractParams.contractMaxSize),
+        maxStorageSlots: bn18(contractParams.maxStorageSlots)
       },
       txParameters: {
         version: txParams.version,
-        maxInputs: bn17(txParams.maxInputs),
-        maxOutputs: bn17(txParams.maxOutputs),
-        maxWitnesses: bn17(txParams.maxWitnesses),
-        maxGasPerTx: bn17(txParams.maxGasPerTx),
-        maxSize: bn17(txParams.maxSize),
-        maxBytecodeSubsections: bn17(txParams.maxBytecodeSubsections)
+        maxInputs: bn18(txParams.maxInputs),
+        maxOutputs: bn18(txParams.maxOutputs),
+        maxWitnesses: bn18(txParams.maxWitnesses),
+        maxGasPerTx: bn18(txParams.maxGasPerTx),
+        maxSize: bn18(txParams.maxSize),
+        maxBytecodeSubsections: bn18(txParams.maxBytecodeSubsections)
       },
       predicateParameters: {
         version: predicateParams.version,
-        maxPredicateLength: bn17(predicateParams.maxPredicateLength),
-        maxPredicateDataLength: bn17(predicateParams.maxPredicateDataLength),
-        maxGasPerPredicate: bn17(predicateParams.maxGasPerPredicate),
-        maxMessageDataLength: bn17(predicateParams.maxMessageDataLength)
+        maxPredicateLength: bn18(predicateParams.maxPredicateLength),
+        maxPredicateDataLength: bn18(predicateParams.maxPredicateDataLength),
+        maxGasPerPredicate: bn18(predicateParams.maxGasPerPredicate),
+        maxMessageDataLength: bn18(predicateParams.maxMessageDataLength)
       },
       scriptParameters: {
         version: scriptParams.version,
-        maxScriptLength: bn17(scriptParams.maxScriptLength),
-        maxScriptDataLength: bn17(scriptParams.maxScriptDataLength)
+        maxScriptLength: bn18(scriptParams.maxScriptLength),
+        maxScriptDataLength: bn18(scriptParams.maxScriptDataLength)
       },
       gasCosts
     },
     latestBlock: {
       id: latestBlock.id,
-      height: bn17(latestBlock.height),
+      height: bn18(latestBlock.height),
       time: latestBlock.header.time,
       transactions: latestBlock.transactions.map((i) => ({
         id: i.id
@@ -3907,7 +3919,7 @@ Supported fuel-core version: ${supportedVersion}.`
    */
   async getBlockNumber() {
     const { chain } = await this.operations.getChain();
-    return bn17(chain.latestBlock.height, 10);
+    return bn18(chain.latestBlock.height, 10);
   }
   /**
    * Returns the chain information.
@@ -3917,8 +3929,8 @@ Supported fuel-core version: ${supportedVersion}.`
   async fetchNode() {
     const { nodeInfo } = await this.operations.getNodeInfo();
     const processedNodeInfo = {
-      maxDepth: bn17(nodeInfo.maxDepth),
-      maxTx: bn17(nodeInfo.maxTx),
+      maxDepth: bn18(nodeInfo.maxDepth),
+      maxTx: bn18(nodeInfo.maxTx),
       nodeVersion: nodeInfo.nodeVersion,
       utxoValidation: nodeInfo.utxoValidation,
       vmBacktrace: nodeInfo.vmBacktrace
@@ -4050,7 +4062,7 @@ Supported fuel-core version: ${supportedVersion}.`
     } = response;
     if (inputs) {
       inputs.forEach((input, index) => {
-        if ("predicateGasUsed" in input && bn17(input.predicateGasUsed).gt(0)) {
+        if ("predicateGasUsed" in input && bn18(input.predicateGasUsed).gt(0)) {
           transactionRequest.inputs[index].predicateGasUsed = input.predicateGasUsed;
         }
       });
@@ -4208,12 +4220,12 @@ Supported fuel-core version: ${supportedVersion}.`
       gasPrice = await this.estimateGasPrice(10);
     }
     const minFee = calculateGasFee({
-      gasPrice: bn17(gasPrice),
+      gasPrice: bn18(gasPrice),
       gas: minGas,
       priceFactor: gasPriceFactor,
       tip: transactionRequest.tip
     }).add(1);
-    let gasLimit = bn17(0);
+    let gasLimit = bn18(0);
     if (transactionRequest.type === TransactionType8.Script) {
       gasLimit = transactionRequest.gasLimit;
       if (transactionRequest.gasLimit.eq(0)) {
@@ -4226,7 +4238,7 @@ Supported fuel-core version: ${supportedVersion}.`
     }
     const maxGas = transactionRequest.calculateMaxGas(chainInfo, minGas);
     const maxFee = calculateGasFee({
-      gasPrice: bn17(gasPrice),
+      gasPrice: bn18(gasPrice),
       gas: maxGas,
       priceFactor: gasPriceFactor,
       tip: transactionRequest.tip
@@ -4291,7 +4303,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const allQuantities = mergeQuantities(coinOutputsQuantities, quantitiesToContract);
     txRequestClone.fundWithFakeUtxos(allQuantities, baseAssetId, resourcesOwner?.address);
     if (isScriptTransaction) {
-      txRequestClone.gasLimit = bn17(0);
+      txRequestClone.gasLimit = bn18(0);
     }
     if (resourcesOwner && "populateTransactionPredicateData" in resourcesOwner) {
       resourcesOwner.populateTransactionPredicateData(txRequestClone);
@@ -4312,7 +4324,7 @@ Supported fuel-core version: ${supportedVersion}.`
     let dryRunStatus;
     let missingContractIds = [];
     let outputVariables = 0;
-    let gasUsed = bn17(0);
+    let gasUsed = bn18(0);
     txRequestClone.maxFee = maxFee;
     if (isScriptTransaction) {
       txRequestClone.gasLimit = gasLimit;
@@ -4377,10 +4389,10 @@ Supported fuel-core version: ${supportedVersion}.`
     return coins.map((coin) => ({
       id: coin.utxoId,
       assetId: coin.assetId,
-      amount: bn17(coin.amount),
+      amount: bn18(coin.amount),
       owner: Address2.fromAddressOrString(coin.owner),
-      blockCreated: bn17(coin.blockCreated),
-      txCreatedIdx: bn17(coin.txCreatedIdx)
+      blockCreated: bn18(coin.blockCreated),
+      txCreatedIdx: bn18(coin.txCreatedIdx)
     }));
   }
   /**
@@ -4417,9 +4429,9 @@ Supported fuel-core version: ${supportedVersion}.`
       switch (coin.type) {
         case "MessageCoin":
           return {
-            amount: bn17(coin.amount),
+            amount: bn18(coin.amount),
             assetId: coin.assetId,
-            daHeight: bn17(coin.daHeight),
+            daHeight: bn18(coin.daHeight),
             sender: Address2.fromAddressOrString(coin.sender),
             recipient: Address2.fromAddressOrString(coin.recipient),
             nonce: coin.nonce
@@ -4427,11 +4439,11 @@ Supported fuel-core version: ${supportedVersion}.`
         case "Coin":
           return {
             id: coin.utxoId,
-            amount: bn17(coin.amount),
+            amount: bn18(coin.amount),
             assetId: coin.assetId,
             owner: Address2.fromAddressOrString(coin.owner),
-            blockCreated: bn17(coin.blockCreated),
-            txCreatedIdx: bn17(coin.txCreatedIdx)
+            blockCreated: bn18(coin.blockCreated),
+            txCreatedIdx: bn18(coin.txCreatedIdx)
           };
         default:
           return null;
@@ -4448,13 +4460,13 @@ Supported fuel-core version: ${supportedVersion}.`
   async getBlock(idOrHeight) {
     let variables;
     if (typeof idOrHeight === "number") {
-      variables = { height: bn17(idOrHeight).toString(10) };
+      variables = { height: bn18(idOrHeight).toString(10) };
     } else if (idOrHeight === "latest") {
       variables = { height: (await this.getBlockNumber()).toString(10) };
     } else if (idOrHeight.length === 66) {
       variables = { blockId: idOrHeight };
     } else {
-      variables = { blockId: bn17(idOrHeight).toString(10) };
+      variables = { blockId: bn18(idOrHeight).toString(10) };
     }
     const { block } = await this.operations.getBlock(variables);
     if (!block) {
@@ -4462,7 +4474,7 @@ Supported fuel-core version: ${supportedVersion}.`
     }
     return {
       id: block.id,
-      height: bn17(block.height),
+      height: bn18(block.height),
       time: block.header.time,
       transactionIds: block.transactions.map((tx) => tx.id)
     };
@@ -4477,7 +4489,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const { blocks: fetchedData } = await this.operations.getBlocks(params);
     const blocks = fetchedData.edges.map(({ node: block }) => ({
       id: block.id,
-      height: bn17(block.height),
+      height: bn18(block.height),
       time: block.header.time,
       transactionIds: block.transactions.map((tx) => tx.id)
     }));
@@ -4492,7 +4504,7 @@ Supported fuel-core version: ${supportedVersion}.`
   async getBlockWithTransactions(idOrHeight) {
     let variables;
     if (typeof idOrHeight === "number") {
-      variables = { blockHeight: bn17(idOrHeight).toString(10) };
+      variables = { blockHeight: bn18(idOrHeight).toString(10) };
     } else if (idOrHeight === "latest") {
       variables = { blockHeight: (await this.getBlockNumber()).toString() };
     } else {
@@ -4504,7 +4516,7 @@ Supported fuel-core version: ${supportedVersion}.`
     }
     return {
       id: block.id,
-      height: bn17(block.height, 10),
+      height: bn18(block.height, 10),
       time: block.header.time,
       transactionIds: block.transactions.map((tx) => tx.id),
       transactions: block.transactions.map(
@@ -4553,7 +4565,7 @@ Supported fuel-core version: ${supportedVersion}.`
       contract: Address2.fromAddressOrString(contractId).toB256(),
       asset: hexlify12(assetId)
     });
-    return bn17(contractBalance.amount, 10);
+    return bn18(contractBalance.amount, 10);
   }
   /**
    * Returns the balance for the given owner for the given asset ID.
@@ -4567,7 +4579,7 @@ Supported fuel-core version: ${supportedVersion}.`
       owner: Address2.fromAddressOrString(owner).toB256(),
       assetId: hexlify12(assetId)
     });
-    return bn17(balance.amount, 10);
+    return bn18(balance.amount, 10);
   }
   /**
    * Returns balances for the given owner.
@@ -4585,7 +4597,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const balances = result.balances.edges.map((edge) => edge.node);
     return balances.map((balance) => ({
       assetId: balance.assetId,
-      amount: bn17(balance.amount)
+      amount: bn18(balance.amount)
     }));
   }
   /**
@@ -4607,15 +4619,15 @@ Supported fuel-core version: ${supportedVersion}.`
         sender: message.sender,
         recipient: message.recipient,
         nonce: message.nonce,
-        amount: bn17(message.amount),
+        amount: bn18(message.amount),
         data: message.data
       }),
       sender: Address2.fromAddressOrString(message.sender),
       recipient: Address2.fromAddressOrString(message.recipient),
       nonce: message.nonce,
-      amount: bn17(message.amount),
+      amount: bn18(message.amount),
       data: InputMessageCoder.decodeData(message.data),
-      daHeight: bn17(message.daHeight)
+      daHeight: bn18(message.daHeight)
     }));
   }
   /**
@@ -4668,19 +4680,19 @@ Supported fuel-core version: ${supportedVersion}.`
     } = result.messageProof;
     return {
       messageProof: {
-        proofIndex: bn17(messageProof.proofIndex),
+        proofIndex: bn18(messageProof.proofIndex),
         proofSet: messageProof.proofSet
       },
       blockProof: {
-        proofIndex: bn17(blockProof.proofIndex),
+        proofIndex: bn18(blockProof.proofIndex),
         proofSet: blockProof.proofSet
       },
       messageBlockHeader: {
         id: messageBlockHeader.id,
-        daHeight: bn17(messageBlockHeader.daHeight),
+        daHeight: bn18(messageBlockHeader.daHeight),
         transactionsCount: Number(messageBlockHeader.transactionsCount),
         transactionsRoot: messageBlockHeader.transactionsRoot,
-        height: bn17(messageBlockHeader.height),
+        height: bn18(messageBlockHeader.height),
         prevRoot: messageBlockHeader.prevRoot,
         time: messageBlockHeader.time,
         applicationHash: messageBlockHeader.applicationHash,
@@ -4692,10 +4704,10 @@ Supported fuel-core version: ${supportedVersion}.`
       },
       commitBlockHeader: {
         id: commitBlockHeader.id,
-        daHeight: bn17(commitBlockHeader.daHeight),
+        daHeight: bn18(commitBlockHeader.daHeight),
         transactionsCount: Number(commitBlockHeader.transactionsCount),
         transactionsRoot: commitBlockHeader.transactionsRoot,
-        height: bn17(commitBlockHeader.height),
+        height: bn18(commitBlockHeader.height),
         prevRoot: commitBlockHeader.prevRoot,
         time: commitBlockHeader.time,
         applicationHash: commitBlockHeader.applicationHash,
@@ -4708,19 +4720,19 @@ Supported fuel-core version: ${supportedVersion}.`
       sender: Address2.fromAddressOrString(sender),
       recipient: Address2.fromAddressOrString(recipient),
       nonce,
-      amount: bn17(amount),
+      amount: bn18(amount),
       data
     };
   }
   async getLatestGasPrice() {
     const { latestGasPrice } = await this.operations.getLatestGasPrice();
-    return bn17(latestGasPrice.gasPrice);
+    return bn18(latestGasPrice.gasPrice);
   }
   async estimateGasPrice(blockHorizon) {
     const { estimateGasPrice } = await this.operations.estimateGasPrice({
       blockHorizon: String(blockHorizon)
     });
-    return bn17(estimateGasPrice.gasPrice);
+    return bn18(estimateGasPrice.gasPrice);
   }
   /**
    * Returns Message Proof for given transaction id and the message id from MessageOut receipt.
@@ -4741,10 +4753,10 @@ Supported fuel-core version: ${supportedVersion}.`
    */
   async produceBlocks(amount, startTime) {
     const { produceBlocks: latestBlockHeight } = await this.operations.produceBlocks({
-      blocksToProduce: bn17(amount).toString(10),
+      blocksToProduce: bn18(amount).toString(10),
       startTimestamp: startTime ? DateTime2.fromUnixMilliseconds(startTime).toTai64() : void 0
     });
-    return bn17(latestBlockHeight);
+    return bn18(latestBlockHeight);
   }
   // eslint-disable-next-line @typescript-eslint/require-await
   async getTransactionResponse(transactionId) {
@@ -4790,7 +4802,7 @@ __publicField(Provider, "nodeInfoCache", {});
 
 // src/providers/transaction-summary/get-transaction-summary.ts
 import { ErrorCode as ErrorCode14, FuelError as FuelError14 } from "@fuel-ts/errors";
-import { bn as bn18 } from "@fuel-ts/math";
+import { bn as bn19 } from "@fuel-ts/math";
 import { TransactionCoder as TransactionCoder6 } from "@fuel-ts/transactions";
 import { arrayify as arrayify12 } from "@fuel-ts/utils";
 
@@ -5068,9 +5080,9 @@ var Account = class extends AbstractAccount {
     const { addedSignatures, estimatedPredicates, requiredQuantities, updateMaxFee } = params;
     const fee = request.maxFee;
     const baseAssetId = this.provider.getBaseAssetId();
-    const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || bn19(0);
+    const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || bn20(0);
     const requiredQuantitiesWithFee = addAmountToCoinQuantities({
-      amount: bn19(fee),
+      amount: bn20(fee),
       assetId: baseAssetId,
       coinQuantities: requiredQuantities
     });
@@ -5078,7 +5090,7 @@ var Account = class extends AbstractAccount {
     requiredQuantitiesWithFee.forEach(({ amount, assetId }) => {
       quantitiesDict[assetId] = {
         required: amount,
-        owned: bn19(0)
+        owned: bn20(0)
       };
     });
     request.inputs.filter(isRequestInputResource).forEach((input) => {
@@ -5105,6 +5117,7 @@ var Account = class extends AbstractAccount {
         cacheRequestInputsResourcesFromOwner(request.inputs, this.address)
       );
       request.addResources(resources);
+      request.shiftPredicateData();
       request.updatePredicateGasUsed(estimatedPredicates);
       const requestToReestimate2 = clone4(request);
       if (addedSignatures) {
@@ -5136,6 +5149,7 @@ var Account = class extends AbstractAccount {
       }
       fundingAttempts += 1;
     }
+    request.shiftPredicateData();
     request.updatePredicateGasUsed(estimatedPredicates);
     const requestToReestimate = clone4(request);
     if (addedSignatures) {
@@ -5186,7 +5200,7 @@ var Account = class extends AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async transfer(destination, amount, assetId, txParams = {}) {
-    if (bn19(amount).lte(0)) {
+    if (bn20(amount).lte(0)) {
       throw new FuelError15(
         ErrorCode15.INVALID_TRANSFER_AMOUNT,
         "Transfer amount must be a positive number."
@@ -5206,7 +5220,7 @@ var Account = class extends AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async transferToContract(contractId, amount, assetId, txParams = {}) {
-    if (bn19(amount).lte(0)) {
+    if (bn20(amount).lte(0)) {
       throw new FuelError15(
         ErrorCode15.INVALID_TRANSFER_AMOUNT,
         "Transfer amount must be a positive number."
@@ -5216,7 +5230,7 @@ var Account = class extends AbstractAccount {
     const assetIdToTransfer = assetId ?? this.provider.getBaseAssetId();
     const { script, scriptData } = await assembleTransferToContractScript({
       hexlifiedContractId: contractAddress.toB256(),
-      amountToTransfer: bn19(amount),
+      amountToTransfer: bn20(amount),
       assetId: assetIdToTransfer
     });
     let request = new ScriptTransactionRequest({
@@ -5227,7 +5241,7 @@ var Account = class extends AbstractAccount {
     request.addContractInputAndOutput(contractAddress);
     const txCost = await this.provider.getTransactionCost(request, {
       resourcesOwner: this,
-      quantitiesToContract: [{ amount: bn19(amount), assetId: String(assetIdToTransfer) }]
+      quantitiesToContract: [{ amount: bn20(amount), assetId: String(assetIdToTransfer) }]
     });
     request = this.validateGasLimitAndMaxFee({
       transactionRequest: request,
@@ -5252,7 +5266,7 @@ var Account = class extends AbstractAccount {
       "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
     );
     const amountDataArray = arrayify14(
-      "0x".concat(bn19(amount).toHex().substring(2).padStart(16, "0"))
+      "0x".concat(bn20(amount).toHex().substring(2).padStart(16, "0"))
     );
     const script = new Uint8Array([
       ...arrayify14(withdrawScript.bytes),
@@ -5262,7 +5276,7 @@ var Account = class extends AbstractAccount {
     const params = { script, ...txParams };
     const baseAssetId = this.provider.getBaseAssetId();
     let request = new ScriptTransactionRequest(params);
-    const quantitiesToContract = [{ amount: bn19(amount), assetId: baseAssetId }];
+    const quantitiesToContract = [{ amount: bn20(amount), assetId: baseAssetId }];
     const txCost = await this.provider.getTransactionCost(request, { quantitiesToContract });
     request = this.validateGasLimitAndMaxFee({
       transactionRequest: request,
@@ -5679,7 +5693,7 @@ __publicField(BaseWalletUnlocked, "defaultPath", "m/44'/1179993420'/0'/0/0");
 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 { bn as bn21, 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";
 
 // src/mnemonic/mnemonic.ts
@@ -8143,7 +8157,7 @@ var HDWallet = class {
     const IR = bytes.slice(32);
     if (privateKey) {
       const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
-      const ki = bn20(IL).add(privateKey).mod(N).toBytes(32);
+      const ki = bn21(IL).add(privateKey).mod(N).toBytes(32);
       return new HDWallet({
         privateKey: ki,
         chainCode: IR,
@@ -8440,7 +8454,7 @@ var generateTestWallet = async (provider, quantities) => {
 // src/test-utils/launchNode.ts
 import { UTXO_ID_LEN as UTXO_ID_LEN3 } from "@fuel-ts/abi-coder";
 import { randomBytes as randomBytes6 } from "@fuel-ts/crypto";
-import { defaultSnapshotConfigs, defaultConsensusKey, hexlify as hexlify18 } from "@fuel-ts/utils";
+import { defaultConsensusKey, hexlify as hexlify18, defaultSnapshotConfigs } from "@fuel-ts/utils";
 import { findBinPath } from "@fuel-ts/utils/cli-utils";
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
@@ -8480,6 +8494,40 @@ var killNode = (params) => {
     }
   }
 };
+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 = hexlify18(pk);
+    coins.push({
+      tx_id: hexlify18(randomBytes6(UTXO_ID_LEN3)),
+      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,
@@ -8487,7 +8535,8 @@ var launchNode = async ({
   useSystemFuelCore = false,
   loggingEnabled = true,
   debugEnabled = false,
-  basePath
+  basePath,
+  snapshotConfig = defaultSnapshotConfigs
 }) => (
   // eslint-disable-next-line no-async-promise-executor
   new Promise(async (resolve, reject) => {
@@ -8516,56 +8565,23 @@ 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(UTXO_ID_LEN3)),
-          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 child = spawn(
       command,
@@ -8573,7 +8589,7 @@ var launchNode = async ({
         "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"] : [],
         ["--consensus-key", consensusKey],
@@ -8595,23 +8611,28 @@ var launchNode = async ({
     }
     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)) {
+        reject(text.toString());
       }
     });
     process.on("exit", () => killNode(cleanupConfig));
@@ -8644,11 +8665,237 @@ 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 randomBytes7 } 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(randomBytes7(32)));
+  }
+};
+var AssetId = _AssetId;
+__publicField(AssetId, "A", new _AssetId(
+  "0x0101010101010101010101010101010101010101010101010101010101010101"
+));
+__publicField(AssetId, "B", new _AssetId(
+  "0x0202020202020202020202020202020202020202020202020202020202020202"
+));
+
+// src/test-utils/wallet-config.ts
+import { randomBytes as randomBytes8 } from "@fuel-ts/crypto";
+import { FuelError as FuelError20 } from "@fuel-ts/errors";
+import { defaultSnapshotConfigs as defaultSnapshotConfigs2, hexlify as hexlify20 } from "@fuel-ts/utils";
+var WalletConfig = class {
+  initialState;
+  options;
+  wallets;
+  generateWallets = () => {
+    const generatedWallets = [];
+    for (let index = 1; index <= this.options.count; index++) {
+      generatedWallets.push(new WalletUnlocked(randomBytes8(32)));
+    }
+    return generatedWallets;
+  };
+  constructor(baseAssetId, config) {
+    const BASE_ASSET_ID = baseAssetId.startsWith("0x") ? baseAssetId : `0x${baseAssetId}`;
+    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,
+        BASE_ASSET_ID,
+        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 ?? [])
+      }
+    };
+  }
+  static createMessages(wallets, messages) {
+    return messages.map((msg) => wallets.map((wallet) => msg.toChainMessage(wallet.address))).flatMap((x) => x);
+  }
+  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 {
+      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: amountPerCoin,
+            asset_id: assetId,
+            owner: walletAddress,
+            tx_pointer_block_height: 0,
+            tx_pointer_tx_idx: 0,
+            output_index: 0,
+            tx_id: hexlify20(randomBytes8(32))
+          });
+        }
+      });
+    });
+    return coins;
+  }
+  static guard({
+    count: wallets,
+    assets: assets2,
+    coinsPerAsset,
+    amountPerCoin
+  }) {
+    if (Array.isArray(wallets) && wallets.length === 0 || typeof wallets === "number" && wallets <= 0) {
+      throw new FuelError20(
+        FuelError20.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 FuelError20(
+        FuelError20.CODES.INVALID_INPUT_PARAMETERS,
+        "Number of assets per wallet must be greater than zero."
+      );
+    }
+    if (coinsPerAsset <= 0) {
+      throw new FuelError20(
+        FuelError20.CODES.INVALID_INPUT_PARAMETERS,
+        "Number of coins per asset must be greater than zero."
+      );
+    }
+    if (amountPerCoin <= 0) {
+      throw new FuelError20(
+        FuelError20.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(
+    nodeOptions.snapshotConfig?.chainConfig?.consensus_parameters?.V1?.base_asset_id ?? defaultSnapshotConfigs3.chainConfig.consensus_parameters.V1.base_asset_id,
+    {
+      ...defaultWalletConfigOptions,
+      ...walletConfigOptions
+    }
+  );
+  const { cleanup, url } = await launchNode({
+    loggingEnabled: false,
+    ...nodeOptions,
+    snapshotConfig: mergeDeepRight(
+      defaultSnapshotConfigs3,
+      walletConfig.apply(nodeOptions?.snapshotConfig)
+    ),
+    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 randomBytes9 } from "@fuel-ts/crypto";
+import { bn as bn22 } from "@fuel-ts/math";
+import { hexlify as hexlify21 } 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 = hexlify21(randomBytes9(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: bn22(this.amount).toNumber(),
+      data: this.data,
+      da_height: this.da_height
+    };
+  }
+};
 export {
+  AssetId,
+  TestMessage,
+  WalletConfig,
   generateTestWallet,
   killNode,
   launchNode,
   launchNodeAndGetWallets,
-  seedTestWallet
+  seedTestWallet,
+  setupTestProviderAndWallets
 };
 //# sourceMappingURL=test-utils.mjs.map