@fuel-ts/account 0.96.1 → 0.97.1

package/dist/test-utils.js

@@ -329,6 +329,8 @@ var launchNode = async ({
             console.log(
               `fuel-core node under pid ${child.pid} does not exist. The node might have been killed before cleanup was called. Exiting cleanly.`
             );
+          } else if (error.message.includes("pid must be a positive integer")) {
+            process.kill(+child.pid);
           } else {
             throw e;
           }
@@ -357,6 +359,7 @@ var launchNode = async ({
         reject(new import_errors.FuelError(import_errors.FuelError.CODES.NODE_LAUNCH_FAILED, text));
       }
     });
+    process.setMaxListeners(100);
     process.on("exit", cleanup);
     process.on("SIGINT", cleanup);
     process.on("SIGUSR1", cleanup);
@@ -408,7 +411,7 @@ var addAmountToCoinQuantities = (params) => {
 
 // src/providers/provider.ts
 var import_address4 = require("@fuel-ts/address");
-var import_errors18 = require("@fuel-ts/errors");
+var import_errors19 = require("@fuel-ts/errors");
 var import_math19 = require("@fuel-ts/math");
 var import_transactions22 = require("@fuel-ts/transactions");
 var import_utils30 = require("@fuel-ts/utils");
@@ -461,9 +464,6 @@ var ReceiptFragmentDoc = import_graphql_tag.default`
 var SuccessStatusFragmentDoc = import_graphql_tag.default`
     fragment SuccessStatusFragment on SuccessStatus {
   type: __typename
-  block {
-    id
-  }
   time
   programState {
     returnType
@@ -476,6 +476,14 @@ var SuccessStatusFragmentDoc = import_graphql_tag.default`
   totalFee
 }
     ${ReceiptFragmentDoc}`;
+var SuccessStatusWithBlockIdFragmentDoc = import_graphql_tag.default`
+    fragment SuccessStatusWithBlockIdFragment on SuccessStatus {
+  ...SuccessStatusFragment
+  block {
+    id
+  }
+}
+    ${SuccessStatusFragmentDoc}`;
 var MalleableTransactionFieldsFragmentDoc = import_graphql_tag.default`
     fragment malleableTransactionFieldsFragment on Transaction {
   receiptsRoot
@@ -520,9 +528,6 @@ var MalleableTransactionFieldsFragmentDoc = import_graphql_tag.default`
 var FailureStatusFragmentDoc = import_graphql_tag.default`
     fragment FailureStatusFragment on FailureStatus {
   type: __typename
-  block {
-    id
-  }
   totalGas
   totalFee
   time
@@ -532,6 +537,14 @@ var FailureStatusFragmentDoc = import_graphql_tag.default`
   }
 }
     ${ReceiptFragmentDoc}`;
+var FailureStatusWithBlockIdFragmentDoc = import_graphql_tag.default`
+    fragment FailureStatusWithBlockIdFragment on FailureStatus {
+  ...FailureStatusFragment
+  block {
+    id
+  }
+}
+    ${FailureStatusFragmentDoc}`;
 var SqueezedOutStatusFragmentDoc = import_graphql_tag.default`
     fragment SqueezedOutStatusFragment on SqueezedOutStatus {
   type: __typename
@@ -544,13 +557,13 @@ var TransactionStatusSubscriptionFragmentDoc = import_graphql_tag.default`
     ...SubmittedStatusFragment
   }
   ... on SuccessStatus {
-    ...SuccessStatusFragment
+    ...SuccessStatusWithBlockIdFragment
     transaction {
       ...malleableTransactionFieldsFragment
     }
   }
   ... on FailureStatus {
-    ...FailureStatusFragment
+    ...FailureStatusWithBlockIdFragment
     transaction {
       ...malleableTransactionFieldsFragment
     }
@@ -560,9 +573,9 @@ var TransactionStatusSubscriptionFragmentDoc = import_graphql_tag.default`
   }
 }
     ${SubmittedStatusFragmentDoc}
-${SuccessStatusFragmentDoc}
+${SuccessStatusWithBlockIdFragmentDoc}
 ${MalleableTransactionFieldsFragmentDoc}
-${FailureStatusFragmentDoc}
+${FailureStatusWithBlockIdFragmentDoc}
 ${SqueezedOutStatusFragmentDoc}`;
 var TransactionStatusFragmentDoc = import_graphql_tag.default`
     fragment transactionStatusFragment on TransactionStatus {
@@ -592,6 +605,12 @@ var TransactionFragmentDoc = import_graphql_tag.default`
   }
 }
     ${TransactionStatusFragmentDoc}`;
+var TransactionRawPayloadFragmentDoc = import_graphql_tag.default`
+    fragment transactionRawPayloadFragment on Transaction {
+  id
+  rawPayload
+}
+    `;
 var InputEstimatePredicatesFragmentDoc = import_graphql_tag.default`
     fragment inputEstimatePredicatesFragment on Input {
   ... on InputCoin {
@@ -679,7 +698,6 @@ var CoinFragmentDoc = import_graphql_tag.default`
     fragment coinFragment on Coin {
   type: __typename
   utxoId
-  owner
   amount
   assetId
   blockCreated
@@ -703,10 +721,15 @@ var MessageFragmentDoc = import_graphql_tag.default`
   sender
   recipient
   data
-  nonce
   daHeight
 }
     `;
+var GetMessageFragmentDoc = import_graphql_tag.default`
+    fragment getMessageFragment on Message {
+  ...messageFragment
+  nonce
+}
+    ${MessageFragmentDoc}`;
 var MessageProofFragmentDoc = import_graphql_tag.default`
     fragment messageProofFragment on MessageProof {
   messageProof {
@@ -751,7 +774,6 @@ var MessageProofFragmentDoc = import_graphql_tag.default`
   }
   sender
   recipient
-  nonce
   amount
   data
 }
@@ -900,12 +922,6 @@ var RelayedTransactionStatusFragmentDoc = import_graphql_tag.default`
   }
 }
     `;
-var TransactionRawPayloadFragmentDoc = import_graphql_tag.default`
-    fragment transactionRawPayload on Transaction {
-  id
-  rawPayload
-}
-    `;
 var GetVersionDocument = import_graphql_tag.default`
     query getVersion {
   nodeInfo {
@@ -948,16 +964,34 @@ var GetTransactionDocument = import_graphql_tag.default`
 var GetTransactionWithReceiptsDocument = import_graphql_tag.default`
     query getTransactionWithReceipts($transactionId: TransactionId!) {
   transaction(id: $transactionId) {
-    ...transactionFragment
+    id
+    rawPayload
+    status {
+      ... on SubmittedStatus {
+        ...SubmittedStatusFragment
+      }
+      ... on SuccessStatus {
+        ...SuccessStatusWithBlockIdFragment
+      }
+      ... on FailureStatus {
+        ...FailureStatusWithBlockIdFragment
+      }
+      ... on SqueezedOutStatus {
+        ...SqueezedOutStatusFragment
+      }
+    }
   }
 }
-    ${TransactionFragmentDoc}`;
+    ${SubmittedStatusFragmentDoc}
+${SuccessStatusWithBlockIdFragmentDoc}
+${FailureStatusWithBlockIdFragmentDoc}
+${SqueezedOutStatusFragmentDoc}`;
 var GetTransactionsDocument = import_graphql_tag.default`
     query getTransactions($after: String, $before: String, $first: Int, $last: Int) {
   transactions(after: $after, before: $before, first: $first, last: $last) {
     edges {
       node {
-        ...transactionFragment
+        rawPayload
       }
     }
     pageInfo {
@@ -965,8 +999,7 @@ var GetTransactionsDocument = import_graphql_tag.default`
     }
   }
 }
-    ${TransactionFragmentDoc}
-${PageInfoFragmentDoc}`;
+    ${PageInfoFragmentDoc}`;
 var GetTransactionsByOwnerDocument = import_graphql_tag.default`
     query getTransactionsByOwner($owner: Address!, $after: String, $before: String, $first: Int, $last: Int) {
   transactionsByOwner(
@@ -1025,7 +1058,7 @@ var GetBlockWithTransactionsDocument = import_graphql_tag.default`
   block(id: $blockId, height: $blockHeight) {
     ...blockFragment
     transactions {
-      ...transactionRawPayload
+      ...transactionRawPayloadFragment
     }
   }
 }
@@ -1050,6 +1083,7 @@ var GetCoinDocument = import_graphql_tag.default`
     query getCoin($coinId: UtxoId!) {
   coin(utxoId: $coinId) {
     ...coinFragment
+    owner
   }
 }
     ${CoinFragmentDoc}`;
@@ -1158,13 +1192,13 @@ var GetMessagesDocument = import_graphql_tag.default`
     }
     edges {
       node {
-        ...messageFragment
+        ...getMessageFragment
       }
     }
   }
 }
     ${PageInfoFragmentDoc}
-${MessageFragmentDoc}`;
+${GetMessageFragmentDoc}`;
 var GetMessageProofDocument = import_graphql_tag.default`
     query getMessageProof($transactionId: TransactionId!, $nonce: Nonce!, $commitBlockId: BlockId, $commitBlockHeight: U32) {
   messageProof(
@@ -1696,9 +1730,11 @@ function assembleReceiptByType(receipt) {
   const { receiptType } = receipt;
   switch (receiptType) {
     case "CALL" /* Call */: {
+      const id = hexOrZero(receipt.id || receipt.contractId);
       const callReceipt = {
         type: import_transactions3.ReceiptType.Call,
-        from: hexOrZero(receipt.id || receipt.contractId),
+        id,
+        from: id,
         to: hexOrZero(receipt?.to),
         amount: (0, import_math5.bn)(receipt.amount),
         assetId: hexOrZero(receipt.assetId),
@@ -1755,24 +1791,36 @@ function assembleReceiptByType(receipt) {
       return revertReceipt;
     }
     case "LOG" /* Log */: {
+      const ra = (0, import_math5.bn)(receipt.ra);
+      const rb = (0, import_math5.bn)(receipt.rb);
+      const rc = (0, import_math5.bn)(receipt.rc);
+      const rd = (0, import_math5.bn)(receipt.rd);
       const logReceipt = {
         type: import_transactions3.ReceiptType.Log,
         id: hexOrZero(receipt.id || receipt.contractId),
-        val0: (0, import_math5.bn)(receipt.ra),
-        val1: (0, import_math5.bn)(receipt.rb),
-        val2: (0, import_math5.bn)(receipt.rc),
-        val3: (0, import_math5.bn)(receipt.rd),
+        ra,
+        rb,
+        rc,
+        rd,
+        val0: ra,
+        val1: rb,
+        val2: rc,
+        val3: rd,
         pc: (0, import_math5.bn)(receipt.pc),
         is: (0, import_math5.bn)(receipt.is)
       };
       return logReceipt;
     }
     case "LOG_DATA" /* LogData */: {
+      const ra = (0, import_math5.bn)(receipt.ra);
+      const rb = (0, import_math5.bn)(receipt.rb);
       const logDataReceipt = {
         type: import_transactions3.ReceiptType.LogData,
         id: hexOrZero(receipt.id || receipt.contractId),
-        val0: (0, import_math5.bn)(receipt.ra),
-        val1: (0, import_math5.bn)(receipt.rb),
+        ra,
+        rb,
+        val0: ra,
+        val1: rb,
         ptr: (0, import_math5.bn)(receipt.ptr),
         len: (0, import_math5.bn)(receipt.len),
         digest: hexOrZero(receipt.digest),
@@ -1783,9 +1831,11 @@ function assembleReceiptByType(receipt) {
       return logDataReceipt;
     }
     case "TRANSFER" /* Transfer */: {
+      const id = hexOrZero(receipt.id || receipt.contractId);
       const transferReceipt = {
         type: import_transactions3.ReceiptType.Transfer,
-        from: hexOrZero(receipt.id || receipt.contractId),
+        id,
+        from: id,
         to: hexOrZero(receipt.toAddress || receipt?.to),
         amount: (0, import_math5.bn)(receipt.amount),
         assetId: hexOrZero(receipt.assetId),
@@ -1795,9 +1845,11 @@ function assembleReceiptByType(receipt) {
       return transferReceipt;
     }
     case "TRANSFER_OUT" /* TransferOut */: {
+      const id = hexOrZero(receipt.id || receipt.contractId);
       const transferOutReceipt = {
         type: import_transactions3.ReceiptType.TransferOut,
-        from: hexOrZero(receipt.id || receipt.contractId),
+        id,
+        from: id,
         to: hexOrZero(receipt.toAddress || receipt.to),
         amount: (0, import_math5.bn)(receipt.amount),
         assetId: hexOrZero(receipt.assetId),
@@ -2774,7 +2826,7 @@ var BlobTransactionRequest = class extends BaseTransactionRequest {
   type = import_transactions7.TransactionType.Blob;
   /** Blob ID */
   blobId;
-  /** Witness index of contract bytecode to create */
+  /** Witness index of the bytecode to create */
   witnessIndex;
   /**
    * Creates an instance `BlobTransactionRequest`.
@@ -4105,14 +4157,14 @@ var processGraphqlStatus = (gqlTransactionStatus) => {
     switch (gqlTransactionStatus.type) {
       case "SuccessStatus":
         time = gqlTransactionStatus.time;
-        blockId = gqlTransactionStatus.block.id;
+        blockId = gqlTransactionStatus.block?.id;
         isStatusSuccess = true;
         totalFee = (0, import_math16.bn)(gqlTransactionStatus.totalFee);
         totalGas = (0, import_math16.bn)(gqlTransactionStatus.totalGas);
         break;
       case "FailureStatus":
         time = gqlTransactionStatus.time;
-        blockId = gqlTransactionStatus.block.id;
+        blockId = gqlTransactionStatus.block?.id;
         isStatusFailure = true;
         totalFee = (0, import_math16.bn)(gqlTransactionStatus.totalFee);
         totalGas = (0, import_math16.bn)(gqlTransactionStatus.totalGas);
@@ -4547,11 +4599,53 @@ var handleGqlErrorMessage = (errorMessage, rawError) => {
         {},
         rawError
       );
+    case "max number of coins is reached while trying to fit the target" /* MAX_COINS_REACHED */:
+      throw new import_errors17.FuelError(
+        import_errors17.ErrorCode.MAX_COINS_REACHED,
+        "The account retrieving coins has exceeded the maximum number of coins per asset. Please consider combining your coins into a single UTXO.",
+        {},
+        rawError
+      );
     default:
       throw new import_errors17.FuelError(import_errors17.ErrorCode.INVALID_REQUEST, errorMessage);
   }
 };
 
+// src/providers/utils/validate-pagination-args.ts
+var import_errors18 = require("@fuel-ts/errors");
+var validatePaginationArgs = (params) => {
+  const { paginationLimit, inputArgs = {} } = params;
+  const { first, last, after, before } = inputArgs;
+  if (after && before) {
+    throw new import_errors18.FuelError(
+      import_errors18.ErrorCode.INVALID_INPUT_PARAMETERS,
+      'Pagination arguments "after" and "before" cannot be used together'
+    );
+  }
+  if ((first || 0) > paginationLimit || (last || 0) > paginationLimit) {
+    throw new import_errors18.FuelError(
+      import_errors18.ErrorCode.INVALID_INPUT_PARAMETERS,
+      `Pagination limit for this query cannot exceed ${paginationLimit} items`
+    );
+  }
+  if (first && before) {
+    throw new import_errors18.FuelError(
+      import_errors18.ErrorCode.INVALID_INPUT_PARAMETERS,
+      'The use of pagination argument "first" with "before" is not supported'
+    );
+  }
+  if (last && after) {
+    throw new import_errors18.FuelError(
+      import_errors18.ErrorCode.INVALID_INPUT_PARAMETERS,
+      'The use of pagination argument "last" with "after" is not supported'
+    );
+  }
+  if (!first && !last) {
+    inputArgs.first = paginationLimit;
+  }
+  return inputArgs;
+};
+
 // src/providers/provider.ts
 var MAX_RETRIES = 10;
 var RESOURCES_PAGE_SIZE_LIMIT = 512;
@@ -4696,7 +4790,7 @@ var _Provider = class {
     try {
       parsedUrl = new URL(url);
     } catch (error) {
-      throw new import_errors18.FuelError(import_errors18.FuelError.CODES.INVALID_URL, "Invalid URL provided.", { url }, error);
+      throw new import_errors19.FuelError(import_errors19.FuelError.CODES.INVALID_URL, "Invalid URL provided.", { url }, error);
     }
     const username = parsedUrl.username;
     const password = parsedUrl.password;
@@ -4731,8 +4825,8 @@ var _Provider = class {
   getChain() {
     const chain = _Provider.chainInfoCache[this.urlWithoutAuth];
     if (!chain) {
-      throw new import_errors18.FuelError(
-        import_errors18.ErrorCode.CHAIN_INFO_CACHE_EMPTY,
+      throw new import_errors19.FuelError(
+        import_errors19.ErrorCode.CHAIN_INFO_CACHE_EMPTY,
         "Chain info cache is empty. Make sure you have called `Provider.create` to initialize the provider."
       );
     }
@@ -4746,8 +4840,8 @@ var _Provider = class {
   getNode() {
     const node = _Provider.nodeInfoCache[this.urlWithoutAuth];
     if (!node) {
-      throw new import_errors18.FuelError(
-        import_errors18.ErrorCode.NODE_INFO_CACHE_EMPTY,
+      throw new import_errors19.FuelError(
+        import_errors19.ErrorCode.NODE_INFO_CACHE_EMPTY,
         "Node info cache is empty. Make sure you have called `Provider.create` to initialize the provider."
       );
     }
@@ -4843,7 +4937,7 @@ Supported fuel-core version: ${supportedVersion}.`
   createOperations() {
     const fetchFn = _Provider.getFetchFn(this.options);
     const gqlClient = new import_graphql_request.GraphQLClient(this.urlWithoutAuth, {
-      fetch: (url, requestInit) => fetchFn(url, requestInit, this.options),
+      fetch: (input, requestInit) => fetchFn(input.toString(), requestInit || {}, this.options),
       responseMiddleware: (response) => {
         if ("response" in response) {
           const graphQlResponse = response.response;
@@ -4973,14 +5067,14 @@ Supported fuel-core version: ${supportedVersion}.`
       }
     } = this.getChain();
     if ((0, import_math19.bn)(tx.inputs.length).gt(maxInputs)) {
-      throw new import_errors18.FuelError(
-        import_errors18.ErrorCode.MAX_INPUTS_EXCEEDED,
+      throw new import_errors19.FuelError(
+        import_errors19.ErrorCode.MAX_INPUTS_EXCEEDED,
         `The transaction exceeds the maximum allowed number of inputs. Tx inputs: ${tx.inputs.length}, max inputs: ${maxInputs}`
       );
     }
     if ((0, import_math19.bn)(tx.outputs.length).gt(maxOutputs)) {
-      throw new import_errors18.FuelError(
-        import_errors18.ErrorCode.MAX_OUTPUTS_EXCEEDED,
+      throw new import_errors19.FuelError(
+        import_errors19.ErrorCode.MAX_OUTPUTS_EXCEEDED,
         `The transaction exceeds the maximum allowed number of outputs. Tx outputs: ${tx.outputs.length}, max outputs: ${maxOutputs}`
       );
     }
@@ -5094,7 +5188,8 @@ Supported fuel-core version: ${supportedVersion}.`
         dryRun: [{ receipts: rawReceipts, status }]
       } = await this.operations.dryRun({
         encodedTransactions: [(0, import_utils30.hexlify)(transactionRequest.toTransactionBytes())],
-        utxoValidation: false
+        utxoValidation: false,
+        gasPrice: "0"
       });
       receipts = rawReceipts.map(processGqlReceipt);
       dryRunStatus = status;
@@ -5108,7 +5203,8 @@ Supported fuel-core version: ${supportedVersion}.`
           missingContractIds.push(contractId);
         });
         const { maxFee } = await this.estimateTxGasAndFee({
-          transactionRequest
+          transactionRequest,
+          gasPrice: (0, import_math19.bn)(0)
         });
         transactionRequest.maxFee = maxFee;
       } else {
@@ -5244,7 +5340,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const chainInfo = this.getChain();
     const { gasPriceFactor, maxGasPerTx } = this.getGasConfig();
     const minGas = transactionRequest.calculateMinGas(chainInfo);
-    if (!gasPrice) {
+    if (!(0, import_utils30.isDefined)(gasPrice)) {
       gasPrice = await this.estimateGasPrice(10);
     }
     const minFee = calculateGasFee({
@@ -5393,7 +5489,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const {
       coins: { edges, pageInfo }
     } = await this.operations.getCoins({
-      ...this.validatePaginationArgs({
+      ...validatePaginationArgs({
         paginationLimit: RESOURCES_PAGE_SIZE_LIMIT,
         inputArgs: paginationArgs
       }),
@@ -5403,7 +5499,7 @@ Supported fuel-core version: ${supportedVersion}.`
       id: node.utxoId,
       assetId: node.assetId,
       amount: (0, import_math19.bn)(node.amount),
-      owner: import_address4.Address.fromAddressOrString(node.owner),
+      owner: ownerAddress,
       blockCreated: (0, import_math19.bn)(node.blockCreated),
       txCreatedIdx: (0, import_math19.bn)(node.txCreatedIdx)
     }));
@@ -5457,7 +5553,7 @@ Supported fuel-core version: ${supportedVersion}.`
             id: coin.utxoId,
             amount: (0, import_math19.bn)(coin.amount),
             assetId: coin.assetId,
-            owner: import_address4.Address.fromAddressOrString(coin.owner),
+            owner: ownerAddress,
             blockCreated: (0, import_math19.bn)(coin.blockCreated),
             txCreatedIdx: (0, import_math19.bn)(coin.txCreatedIdx)
           };
@@ -5532,7 +5628,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const {
       blocks: { edges, pageInfo }
     } = await this.operations.getBlocks({
-      ...this.validatePaginationArgs({
+      ...validatePaginationArgs({
         paginationLimit: BLOCKS_PAGE_SIZE_LIMIT,
         inputArgs: params
       })
@@ -5611,7 +5707,7 @@ Supported fuel-core version: ${supportedVersion}.`
         0
       )?.[0];
     } catch (error) {
-      if (error instanceof import_errors18.FuelError && error.code === import_errors18.ErrorCode.UNSUPPORTED_TRANSACTION_TYPE) {
+      if (error instanceof import_errors19.FuelError && error.code === import_errors19.ErrorCode.UNSUPPORTED_TRANSACTION_TYPE) {
         console.warn("Unsupported transaction type encountered");
         return null;
       }
@@ -5627,7 +5723,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const {
       transactions: { edges, pageInfo }
     } = await this.operations.getTransactions({
-      ...this.validatePaginationArgs({
+      ...validatePaginationArgs({
         inputArgs: paginationArgs,
         paginationLimit: TRANSACTIONS_PAGE_SIZE_LIMIT
       })
@@ -5637,7 +5733,7 @@ Supported fuel-core version: ${supportedVersion}.`
       try {
         return coder.decode((0, import_utils30.arrayify)(rawPayload), 0)[0];
       } catch (error) {
-        if (error instanceof import_errors18.FuelError && error.code === import_errors18.ErrorCode.UNSUPPORTED_TRANSACTION_TYPE) {
+        if (error instanceof import_errors19.FuelError && error.code === import_errors19.ErrorCode.UNSUPPORTED_TRANSACTION_TYPE) {
           console.warn("Unsupported transaction type encountered");
           return null;
         }
@@ -5722,7 +5818,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const {
       messages: { edges, pageInfo }
     } = await this.operations.getMessages({
-      ...this.validatePaginationArgs({
+      ...validatePaginationArgs({
         inputArgs: paginationArgs,
         paginationLimit: RESOURCES_PAGE_SIZE_LIMIT
       }),
@@ -5763,8 +5859,8 @@ Supported fuel-core version: ${supportedVersion}.`
       nonce
     };
     if (commitBlockId && commitBlockHeight) {
-      throw new import_errors18.FuelError(
-        import_errors18.ErrorCode.INVALID_INPUT_PARAMETERS,
+      throw new import_errors19.FuelError(
+        import_errors19.ErrorCode.INVALID_INPUT_PARAMETERS,
         "commitBlockId and commitBlockHeight cannot be used together"
       );
     }
@@ -5946,13 +6042,13 @@ Supported fuel-core version: ${supportedVersion}.`
       messageId: import_transactions22.InputMessageCoder.getMessageId({
         sender: rawMessage.sender,
         recipient: rawMessage.recipient,
-        nonce: rawMessage.nonce,
+        nonce,
         amount: (0, import_math19.bn)(rawMessage.amount),
         data: rawMessage.data
       }),
       sender: import_address4.Address.fromAddressOrString(rawMessage.sender),
       recipient: import_address4.Address.fromAddressOrString(rawMessage.recipient),
-      nonce: rawMessage.nonce,
+      nonce,
       amount: (0, import_math19.bn)(rawMessage.amount),
       data: import_transactions22.InputMessageCoder.decodeData(rawMessage.data),
       daHeight: (0, import_math19.bn)(rawMessage.daHeight)
@@ -5974,41 +6070,6 @@ Supported fuel-core version: ${supportedVersion}.`
     }
     return relayedTransactionStatus;
   }
-  /**
-   * @hidden
-   */
-  validatePaginationArgs(params) {
-    const { paginationLimit, inputArgs = {} } = params;
-    const { first, last, after, before } = inputArgs;
-    if (after && before) {
-      throw new import_errors18.FuelError(
-        import_errors18.ErrorCode.INVALID_INPUT_PARAMETERS,
-        'Pagination arguments "after" and "before" cannot be used together'
-      );
-    }
-    if ((first || 0) > paginationLimit || (last || 0) > paginationLimit) {
-      throw new import_errors18.FuelError(
-        import_errors18.ErrorCode.INVALID_INPUT_PARAMETERS,
-        `Pagination limit for this query cannot exceed ${paginationLimit} items`
-      );
-    }
-    if (first && before) {
-      throw new import_errors18.FuelError(
-        import_errors18.ErrorCode.INVALID_INPUT_PARAMETERS,
-        'The use of pagination argument "first" with "before" is not supported'
-      );
-    }
-    if (last && after) {
-      throw new import_errors18.FuelError(
-        import_errors18.ErrorCode.INVALID_INPUT_PARAMETERS,
-        'The use of pagination argument "last" with "after" is not supported'
-      );
-    }
-    if (!first && !last) {
-      inputArgs.first = paginationLimit;
-    }
-    return inputArgs;
-  }
   /**
    * @hidden
    */
@@ -6054,7 +6115,7 @@ __publicField(Provider, "chainInfoCache", {});
 __publicField(Provider, "nodeInfoCache", {});
 
 // src/providers/transaction-summary/get-transaction-summary.ts
-var import_errors19 = require("@fuel-ts/errors");
+var import_errors20 = require("@fuel-ts/errors");
 var import_math20 = require("@fuel-ts/math");
 var import_transactions23 = require("@fuel-ts/transactions");
 var import_utils33 = require("@fuel-ts/utils");
@@ -6688,7 +6749,7 @@ __publicField(TestAssetId, "B", new _TestAssetId(
 
 // src/test-utils/wallet-config.ts
 var import_crypto9 = require("@fuel-ts/crypto");
-var import_errors25 = require("@fuel-ts/errors");
+var import_errors26 = require("@fuel-ts/errors");
 var import_utils44 = require("@fuel-ts/utils");
 
 // src/wallet/base-wallet-unlocked.ts
@@ -6697,11 +6758,11 @@ var import_utils39 = require("@fuel-ts/utils");
 
 // src/account.ts
 var import_abi_coder8 = require("@fuel-ts/abi-coder");
-var import_address5 = require("@fuel-ts/address");
+var import_address6 = require("@fuel-ts/address");
 var import_crypto5 = require("@fuel-ts/crypto");
-var import_errors20 = require("@fuel-ts/errors");
+var import_errors21 = require("@fuel-ts/errors");
 var import_interfaces = require("@fuel-ts/interfaces");
-var import_math22 = require("@fuel-ts/math");
+var import_math21 = require("@fuel-ts/math");
 var import_transactions24 = require("@fuel-ts/transactions");
 var import_utils37 = require("@fuel-ts/utils");
 var import_ramda9 = require("ramda");
@@ -6722,37 +6783,45 @@ var mergeQuantities = (...coinQuantities) => {
 
 // src/utils/formatTransferToContractScriptData.ts
 var import_abi_coder7 = require("@fuel-ts/abi-coder");
-var import_math21 = require("@fuel-ts/math");
+var import_address5 = require("@fuel-ts/address");
 var import_utils36 = require("@fuel-ts/utils");
 var asm = __toESM(require("@fuels/vm-asm"));
-var formatTransferToContractScriptData = (params) => {
-  const { assetId, amountToTransfer, hexlifiedContractId } = params;
+var formatTransferToContractScriptData = (transferParams) => {
   const numberCoder = new import_abi_coder7.BigNumberCoder("u64");
-  const encoded = numberCoder.encode(new import_math21.BN(amountToTransfer).toNumber());
-  const scriptData = Uint8Array.from([
-    ...(0, import_utils36.arrayify)(hexlifiedContractId),
-    ...encoded,
-    ...(0, import_utils36.arrayify)(assetId)
-  ]);
-  return scriptData;
+  return transferParams.reduce((acc, transferParam) => {
+    const { assetId, amount, contractId } = transferParam;
+    const encoded = numberCoder.encode(amount);
+    const scriptData = (0, import_utils36.concat)([
+      import_address5.Address.fromAddressOrString(contractId).toBytes(),
+      encoded,
+      (0, import_utils36.arrayify)(assetId)
+    ]);
+    return (0, import_utils36.concat)([acc, scriptData]);
+  }, new Uint8Array());
 };
-var assembleTransferToContractScript = async (params) => {
-  const scriptData = formatTransferToContractScriptData(params);
+var assembleTransferToContractScript = async (transferParams) => {
+  const scriptData = formatTransferToContractScriptData(transferParams);
   await asm.initWasm();
-  const gtf2 = asm.gtf(16, 0, asm.GTFArgs.ScriptData);
-  const addi2 = asm.addi(17, 16, 32);
-  const lw2 = asm.lw(18, 17, 0);
-  const addi22 = asm.addi(19, 17, 8);
-  const tr2 = asm.tr(16, 18, 19);
-  const ret2 = asm.ret(1);
-  const script = Uint8Array.from([
-    ...gtf2.to_bytes(),
-    ...addi2.to_bytes(),
-    ...lw2.to_bytes(),
-    ...addi22.to_bytes(),
-    ...tr2.to_bytes(),
-    ...ret2.to_bytes()
-  ]);
+  let script = new Uint8Array();
+  transferParams.forEach((_, i) => {
+    const offset = (import_abi_coder7.CONTRACT_ID_LEN + import_abi_coder7.WORD_SIZE + import_abi_coder7.ASSET_ID_LEN) * i;
+    script = (0, import_utils36.concat)([
+      script,
+      // Load ScriptData into register 0x10.
+      asm.gtf(16, 0, asm.GTFArgs.ScriptData).to_bytes(),
+      // Add the offset to 0x10 so it will point to the current contract ID, store in 0x11.
+      asm.addi(17, 16, offset).to_bytes(),
+      // Add CONTRACT_ID_LEN to 0x11 to point to the amount in the ScriptData, store in 0x12.
+      asm.addi(18, 17, import_abi_coder7.CONTRACT_ID_LEN).to_bytes(),
+      // Load word to the amount at 0x12 into register 0x13.
+      asm.lw(19, 18, 0).to_bytes(),
+      // Add WORD_SIZE to 0x12 to point to the asset ID in the ScriptData, store in 0x14.
+      asm.addi(20, 18, import_abi_coder7.WORD_SIZE).to_bytes(),
+      // Perform the transfer using contract ID in 0x11, amount in 0x13, and asset ID in 0x14.
+      asm.tr(17, 19, 20).to_bytes()
+    ]);
+  });
+  script = (0, import_utils36.concat)([script, asm.ret(1).to_bytes()]);
   return { script, scriptData };
 };
 
@@ -6782,7 +6851,7 @@ var Account = class extends import_interfaces.AbstractAccount {
     super();
     this._provider = provider;
     this._connector = connector;
-    this.address = import_address5.Address.fromDynamicInput(address);
+    this.address = import_address6.Address.fromDynamicInput(address);
   }
   /**
    * The provider used to interact with the network.
@@ -6793,7 +6862,7 @@ var Account = class extends import_interfaces.AbstractAccount {
    */
   get provider() {
     if (!this._provider) {
-      throw new import_errors20.FuelError(import_errors20.ErrorCode.MISSING_PROVIDER, "Provider not set");
+      throw new import_errors21.FuelError(import_errors21.ErrorCode.MISSING_PROVIDER, "Provider not set");
     }
     return this._provider;
   }
@@ -6873,9 +6942,9 @@ var Account = class extends import_interfaces.AbstractAccount {
     const { addedSignatures, estimatedPredicates, requiredQuantities, updateMaxFee, gasPrice } = params;
     const fee = request.maxFee;
     const baseAssetId = this.provider.getBaseAssetId();
-    const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || (0, import_math22.bn)(0);
+    const requiredInBaseAsset = requiredQuantities.find((quantity) => quantity.assetId === baseAssetId)?.amount || (0, import_math21.bn)(0);
     const requiredQuantitiesWithFee = addAmountToCoinQuantities({
-      amount: (0, import_math22.bn)(fee),
+      amount: (0, import_math21.bn)(fee),
       assetId: baseAssetId,
       coinQuantities: requiredQuantities
     });
@@ -6883,7 +6952,7 @@ var Account = class extends import_interfaces.AbstractAccount {
     requiredQuantitiesWithFee.forEach(({ amount, assetId }) => {
       quantitiesDict[assetId] = {
         required: amount,
-        owned: (0, import_math22.bn)(0)
+        owned: (0, import_math21.bn)(0)
       };
     });
     request.inputs.filter(isRequestInputResource).forEach((input) => {
@@ -6944,8 +7013,8 @@ var Account = class extends import_interfaces.AbstractAccount {
       fundingAttempts += 1;
     }
     if (needsToBeFunded) {
-      throw new import_errors20.FuelError(
-        import_errors20.ErrorCode.NOT_ENOUGH_FUNDS,
+      throw new import_errors21.FuelError(
+        import_errors21.ErrorCode.NOT_ENOUGH_FUNDS,
         `The account ${this.address} does not have enough base asset funds to cover the transaction execution.`
       );
     }
@@ -6959,7 +7028,8 @@ var Account = class extends import_interfaces.AbstractAccount {
       return request;
     }
     const { maxFee } = await this.provider.estimateTxGasAndFee({
-      transactionRequest: requestToReestimate
+      transactionRequest: requestToReestimate,
+      gasPrice
     });
     request.maxFee = maxFee;
     return request;
@@ -7016,7 +7086,7 @@ var Account = class extends import_interfaces.AbstractAccount {
     const { destination, amount, assetId } = transferParams;
     this.validateTransferAmount(amount);
     request.addCoinOutput(
-      import_address5.Address.fromAddressOrString(destination),
+      import_address6.Address.fromAddressOrString(destination),
       amount,
       assetId ?? this.provider.getBaseAssetId()
     );
@@ -7050,35 +7120,35 @@ var Account = class extends import_interfaces.AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async transferToContract(contractId, amount, assetId, txParams = {}) {
-    if ((0, import_math22.bn)(amount).lte(0)) {
-      throw new import_errors20.FuelError(
-        import_errors20.ErrorCode.INVALID_TRANSFER_AMOUNT,
-        "Transfer amount must be a positive number."
-      );
-    }
-    const contractAddress = import_address5.Address.fromAddressOrString(contractId);
-    const assetIdToTransfer = assetId ?? this.provider.getBaseAssetId();
-    const { script, scriptData } = await assembleTransferToContractScript({
-      hexlifiedContractId: contractAddress.toB256(),
-      amountToTransfer: (0, import_math22.bn)(amount),
-      assetId: assetIdToTransfer
-    });
+    return this.batchTransferToContracts([{ amount, assetId, contractId }], txParams);
+  }
+  async batchTransferToContracts(contractTransferParams, txParams = {}) {
     let request = new ScriptTransactionRequest({
-      ...txParams,
-      script,
-      scriptData
-    });
-    request.addContractInputAndOutput(contractAddress);
-    const txCost = await this.getTransactionCost(request, {
-      quantities: [{ amount: (0, import_math22.bn)(amount), assetId: String(assetIdToTransfer) }]
+      ...txParams
     });
-    request = this.validateGasLimitAndMaxFee({
-      transactionRequest: request,
-      gasUsed: txCost.gasUsed,
-      maxFee: txCost.maxFee,
-      txParams
+    const quantities = [];
+    const transferParams = contractTransferParams.map((transferParam) => {
+      const amount = (0, import_math21.bn)(transferParam.amount);
+      const contractAddress = import_address6.Address.fromAddressOrString(transferParam.contractId);
+      const assetId = transferParam.assetId ? (0, import_utils37.hexlify)(transferParam.assetId) : this.provider.getBaseAssetId();
+      if (amount.lte(0)) {
+        throw new import_errors21.FuelError(
+          import_errors21.ErrorCode.INVALID_TRANSFER_AMOUNT,
+          "Transfer amount must be a positive number."
+        );
+      }
+      request.addContractInputAndOutput(contractAddress);
+      quantities.push({ amount, assetId });
+      return {
+        amount,
+        contractId: contractAddress.toB256(),
+        assetId
+      };
     });
-    await this.fund(request, txCost);
+    const { script, scriptData } = await assembleTransferToContractScript(transferParams);
+    request.script = script;
+    request.scriptData = scriptData;
+    request = await this.estimateAndFundTransaction(request, txParams, { quantities });
     return this.sendTransaction(request);
   }
   /**
@@ -7090,12 +7160,12 @@ var Account = class extends import_interfaces.AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async withdrawToBaseLayer(recipient, amount, txParams = {}) {
-    const recipientAddress = import_address5.Address.fromAddressOrString(recipient);
+    const recipientAddress = import_address6.Address.fromAddressOrString(recipient);
     const recipientDataArray = (0, import_utils37.arrayify)(
       "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
     );
     const amountDataArray = (0, import_utils37.arrayify)(
-      "0x".concat((0, import_math22.bn)(amount).toHex().substring(2).padStart(16, "0"))
+      "0x".concat((0, import_math21.bn)(amount).toHex().substring(2).padStart(16, "0"))
     );
     const script = new Uint8Array([
       ...(0, import_utils37.arrayify)(withdrawScript.bytes),
@@ -7105,7 +7175,7 @@ var Account = class extends import_interfaces.AbstractAccount {
     const params = { script, ...txParams };
     const baseAssetId = this.provider.getBaseAssetId();
     let request = new ScriptTransactionRequest(params);
-    const quantities = [{ amount: (0, import_math22.bn)(amount), assetId: baseAssetId }];
+    const quantities = [{ amount: (0, import_math21.bn)(amount), assetId: baseAssetId }];
     const txCost = await this.getTransactionCost(request, { quantities });
     request = this.validateGasLimitAndMaxFee({
       transactionRequest: request,
@@ -7131,7 +7201,7 @@ var Account = class extends import_interfaces.AbstractAccount {
     const baseAssetId = this.provider.getBaseAssetId();
     const coinOutputsQuantities = txRequestClone.getCoinOutputsQuantities();
     const requiredQuantities = mergeQuantities(coinOutputsQuantities, quantities);
-    const transactionFeeForDryRun = [{ assetId: baseAssetId, amount: (0, import_math22.bn)("100000000000000000") }];
+    const transactionFeeForDryRun = [{ assetId: baseAssetId, amount: (0, import_math21.bn)("100000000000000000") }];
     const findAssetInput = (assetId) => txRequestClone.inputs.find((input) => {
       if (input.type === import_transactions24.InputType.Coin) {
         return input.assetId === assetId;
@@ -7178,7 +7248,7 @@ var Account = class extends import_interfaces.AbstractAccount {
    */
   async signMessage(message) {
     if (!this._connector) {
-      throw new import_errors20.FuelError(import_errors20.ErrorCode.MISSING_CONNECTOR, "A connector is required to sign messages.");
+      throw new import_errors21.FuelError(import_errors21.ErrorCode.MISSING_CONNECTOR, "A connector is required to sign messages.");
     }
     return this._connector.signMessage(this.address.toString(), message);
   }
@@ -7190,8 +7260,8 @@ var Account = class extends import_interfaces.AbstractAccount {
    */
   async signTransaction(transactionRequestLike) {
     if (!this._connector) {
-      throw new import_errors20.FuelError(
-        import_errors20.ErrorCode.MISSING_CONNECTOR,
+      throw new import_errors21.FuelError(
+        import_errors21.ErrorCode.MISSING_CONNECTOR,
         "A connector is required to sign transactions."
       );
     }
@@ -7242,24 +7312,24 @@ var Account = class extends import_interfaces.AbstractAccount {
     return coins.map((coin) => ({
       id: (0, import_utils37.hexlify)((0, import_crypto5.randomBytes)(import_abi_coder8.UTXO_ID_LEN)),
       owner: this.address,
-      blockCreated: (0, import_math22.bn)(1),
-      txCreatedIdx: (0, import_math22.bn)(1),
+      blockCreated: (0, import_math21.bn)(1),
+      txCreatedIdx: (0, import_math21.bn)(1),
       ...coin
     }));
   }
   /** @hidden * */
   validateTransferAmount(amount) {
-    if ((0, import_math22.bn)(amount).lte(0)) {
-      throw new import_errors20.FuelError(
-        import_errors20.ErrorCode.INVALID_TRANSFER_AMOUNT,
+    if ((0, import_math21.bn)(amount).lte(0)) {
+      throw new import_errors21.FuelError(
+        import_errors21.ErrorCode.INVALID_TRANSFER_AMOUNT,
         "Transfer amount must be a positive number."
       );
     }
   }
   /** @hidden * */
-  async estimateAndFundTransaction(transactionRequest, txParams) {
+  async estimateAndFundTransaction(transactionRequest, txParams, costParams) {
     let request = transactionRequest;
-    const txCost = await this.getTransactionCost(request);
+    const txCost = await this.getTransactionCost(request, costParams);
     request = this.validateGasLimitAndMaxFee({
       transactionRequest: request,
       gasUsed: txCost.gasUsed,
@@ -7280,16 +7350,16 @@ var Account = class extends import_interfaces.AbstractAccount {
     if (!(0, import_utils37.isDefined)(setGasLimit)) {
       request.gasLimit = gasUsed;
     } else if (gasUsed.gt(setGasLimit)) {
-      throw new import_errors20.FuelError(
-        import_errors20.ErrorCode.GAS_LIMIT_TOO_LOW,
+      throw new import_errors21.FuelError(
+        import_errors21.ErrorCode.GAS_LIMIT_TOO_LOW,
         `Gas limit '${setGasLimit}' is lower than the required: '${gasUsed}'.`
       );
     }
     if (!(0, import_utils37.isDefined)(setMaxFee)) {
       request.maxFee = maxFee;
     } else if (maxFee.gt(setMaxFee)) {
-      throw new import_errors20.FuelError(
-        import_errors20.ErrorCode.MAX_FEE_TOO_LOW,
+      throw new import_errors21.FuelError(
+        import_errors21.ErrorCode.MAX_FEE_TOO_LOW,
         `Max fee '${setMaxFee}' is lower than the required: '${maxFee}'.`
       );
     }
@@ -7298,9 +7368,9 @@ var Account = class extends import_interfaces.AbstractAccount {
 };
 
 // src/wallet/keystore-wallet.ts
-var import_address6 = require("@fuel-ts/address");
+var import_address7 = require("@fuel-ts/address");
 var import_crypto6 = require("@fuel-ts/crypto");
-var import_errors21 = require("@fuel-ts/errors");
+var import_errors22 = require("@fuel-ts/errors");
 var import_utils38 = require("@fuel-ts/utils");
 var DEFAULT_KDF_PARAMS_LOG_N = 13;
 var DEFAULT_KDF_PARAMS_R = 8;
@@ -7315,7 +7385,7 @@ var removeHexPrefix = (hexString) => {
 };
 async function encryptKeystoreWallet(privateKey, address, password) {
   const privateKeyBuffer = (0, import_crypto6.bufferFromString)(removeHexPrefix(privateKey), "hex");
-  const ownerAddress = import_address6.Address.fromAddressOrString(address);
+  const ownerAddress = import_address7.Address.fromAddressOrString(address);
   const salt = (0, import_crypto6.randomBytes)(DEFAULT_KEY_SIZE);
   const key = (0, import_crypto6.scrypt)({
     password: (0, import_crypto6.bufferFromString)(password),
@@ -7377,8 +7447,8 @@ async function decryptKeystoreWallet(jsonWallet, password) {
   const macHashUint8Array = (0, import_crypto6.keccak256)(data);
   const macHash = (0, import_crypto6.stringFromBuffer)(macHashUint8Array, "hex");
   if (mac !== macHash) {
-    throw new import_errors21.FuelError(
-      import_errors21.ErrorCode.INVALID_PASSWORD,
+    throw new import_errors22.FuelError(
+      import_errors22.ErrorCode.INVALID_PASSWORD,
       "Failed to decrypt the keystore wallet, the provided password is incorrect."
     );
   }
@@ -7508,14 +7578,14 @@ __publicField(BaseWalletUnlocked, "defaultPath", "m/44'/1179993420'/0'/0/0");
 
 // src/hdwallet/hdwallet.ts
 var import_crypto8 = require("@fuel-ts/crypto");
-var import_errors24 = require("@fuel-ts/errors");
+var import_errors25 = require("@fuel-ts/errors");
 var import_hasher7 = require("@fuel-ts/hasher");
-var import_math23 = require("@fuel-ts/math");
+var import_math22 = require("@fuel-ts/math");
 var import_utils43 = require("@fuel-ts/utils");
 
 // src/mnemonic/mnemonic.ts
 var import_crypto7 = require("@fuel-ts/crypto");
-var import_errors23 = require("@fuel-ts/errors");
+var import_errors24 = require("@fuel-ts/errors");
 var import_hasher6 = require("@fuel-ts/hasher");
 var import_utils41 = require("@fuel-ts/utils");
 
@@ -9572,7 +9642,7 @@ var english = [
 ];
 
 // src/mnemonic/utils.ts
-var import_errors22 = require("@fuel-ts/errors");
+var import_errors23 = require("@fuel-ts/errors");
 var import_hasher5 = require("@fuel-ts/hasher");
 var import_utils40 = require("@fuel-ts/utils");
 function getLowerMask(bits) {
@@ -9621,8 +9691,8 @@ function mnemonicWordsToEntropy(words, wordlist) {
   for (let i = 0; i < words.length; i += 1) {
     const index = wordlist.indexOf(words[i].normalize("NFKD"));
     if (index === -1) {
-      throw new import_errors22.FuelError(
-        import_errors22.ErrorCode.INVALID_MNEMONIC,
+      throw new import_errors23.FuelError(
+        import_errors23.ErrorCode.INVALID_MNEMONIC,
         `Invalid mnemonic: the word '${words[i]}' is not found in the provided wordlist.`
       );
     }
@@ -9638,8 +9708,8 @@ function mnemonicWordsToEntropy(words, wordlist) {
   const checksumMask = getUpperMask(checksumBits);
   const checksum = (0, import_utils40.arrayify)((0, import_hasher5.sha256)(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
   if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
-    throw new import_errors22.FuelError(
-      import_errors22.ErrorCode.INVALID_CHECKSUM,
+    throw new import_errors23.FuelError(
+      import_errors23.ErrorCode.INVALID_CHECKSUM,
       "Checksum validation failed for the provided mnemonic."
     );
   }
@@ -9653,16 +9723,16 @@ var TestnetPRV = "0x04358394";
 var MNEMONIC_SIZES = [12, 15, 18, 21, 24];
 function assertWordList(wordlist) {
   if (wordlist.length !== 2048) {
-    throw new import_errors23.FuelError(
-      import_errors23.ErrorCode.INVALID_WORD_LIST,
+    throw new import_errors24.FuelError(
+      import_errors24.ErrorCode.INVALID_WORD_LIST,
       `Expected word list length of 2048, but got ${wordlist.length}.`
     );
   }
 }
 function assertEntropy(entropy) {
   if (entropy.length % 4 !== 0 || entropy.length < 16 || entropy.length > 32) {
-    throw new import_errors23.FuelError(
-      import_errors23.ErrorCode.INVALID_ENTROPY,
+    throw new import_errors24.FuelError(
+      import_errors24.ErrorCode.INVALID_ENTROPY,
       `Entropy should be between 16 and 32 bytes and a multiple of 4, but got ${entropy.length} bytes.`
     );
   }
@@ -9672,7 +9742,7 @@ function assertMnemonic(words) {
     const errorMsg = `Invalid mnemonic size. Expected one of [${MNEMONIC_SIZES.join(
       ", "
     )}] words, but got ${words.length}.`;
-    throw new import_errors23.FuelError(import_errors23.ErrorCode.INVALID_MNEMONIC, errorMsg);
+    throw new import_errors24.FuelError(import_errors24.ErrorCode.INVALID_MNEMONIC, errorMsg);
   }
 }
 var Mnemonic = class {
@@ -9790,8 +9860,8 @@ var Mnemonic = class {
   static masterKeysFromSeed(seed) {
     const seedArray = (0, import_utils41.arrayify)(seed);
     if (seedArray.length < 16 || seedArray.length > 64) {
-      throw new import_errors23.FuelError(
-        import_errors23.ErrorCode.INVALID_SEED,
+      throw new import_errors24.FuelError(
+        import_errors24.ErrorCode.INVALID_SEED,
         `Seed length should be between 16 and 64 bytes, but received ${seedArray.length} bytes.`
       );
     }
@@ -9868,7 +9938,7 @@ function isValidExtendedKey(extendedKey) {
 function parsePath(path2, depth = 0) {
   const components = path2.split("/");
   if (components.length === 0 || components[0] === "m" && depth !== 0) {
-    throw new import_errors24.FuelError(import_errors24.ErrorCode.HD_WALLET_ERROR, `invalid path - ${path2}`);
+    throw new import_errors25.FuelError(import_errors25.ErrorCode.HD_WALLET_ERROR, `invalid path - ${path2}`);
   }
   if (components[0] === "m") {
     components.shift();
@@ -9897,8 +9967,8 @@ var HDWallet = class {
       this.privateKey = (0, import_utils43.hexlify)(config.privateKey);
     } else {
       if (!config.publicKey) {
-        throw new import_errors24.FuelError(
-          import_errors24.ErrorCode.HD_WALLET_ERROR,
+        throw new import_errors25.FuelError(
+          import_errors25.ErrorCode.HD_WALLET_ERROR,
           "Both public and private Key cannot be missing. At least one should be provided."
         );
       }
@@ -9927,8 +9997,8 @@ var HDWallet = class {
     const data = new Uint8Array(37);
     if (index & HARDENED_INDEX) {
       if (!privateKey) {
-        throw new import_errors24.FuelError(
-          import_errors24.ErrorCode.HD_WALLET_ERROR,
+        throw new import_errors25.FuelError(
+          import_errors25.ErrorCode.HD_WALLET_ERROR,
           "Cannot derive a hardened index without a private Key."
         );
       }
@@ -9936,13 +10006,13 @@ var HDWallet = class {
     } else {
       data.set((0, import_utils43.arrayify)(this.publicKey));
     }
-    data.set((0, import_math23.toBytes)(index, 4), 33);
+    data.set((0, import_math22.toBytes)(index, 4), 33);
     const bytes = (0, import_utils43.arrayify)((0, import_crypto8.computeHmac)("sha512", chainCode, data));
     const IL = bytes.slice(0, 32);
     const IR = bytes.slice(32);
     if (privateKey) {
       const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
-      const ki = (0, import_math23.bn)(IL).add(privateKey).mod(N).toBytes(32);
+      const ki = (0, import_math22.bn)(IL).add(privateKey).mod(N).toBytes(32);
       return new HDWallet({
         privateKey: ki,
         chainCode: IR,
@@ -9980,15 +10050,15 @@ var HDWallet = class {
    */
   toExtendedKey(isPublic = false, testnet = false) {
     if (this.depth >= 256) {
-      throw new import_errors24.FuelError(
-        import_errors24.ErrorCode.HD_WALLET_ERROR,
+      throw new import_errors25.FuelError(
+        import_errors25.ErrorCode.HD_WALLET_ERROR,
         `Exceeded max depth of 255. Current depth: ${this.depth}.`
       );
     }
     const prefix = getExtendedKeyPrefix(this.privateKey == null || isPublic, testnet);
     const depth = (0, import_utils43.hexlify)(Uint8Array.from([this.depth]));
     const parentFingerprint = this.parentFingerprint;
-    const index = (0, import_math23.toHex)(this.index, 4);
+    const index = (0, import_math22.toHex)(this.index, 4);
     const chainCode = this.chainCode;
     const key = this.privateKey != null && !isPublic ? (0, import_utils43.concat)(["0x00", this.privateKey]) : this.publicKey;
     const extendedKey = (0, import_utils43.arrayify)((0, import_utils43.concat)([prefix, depth, parentFingerprint, index, chainCode, key]));
@@ -10008,14 +10078,14 @@ var HDWallet = class {
     });
   }
   static fromExtendedKey(extendedKey) {
-    const decoded = (0, import_utils43.hexlify)((0, import_math23.toBytes)((0, import_utils43.decodeBase58)(extendedKey)));
+    const decoded = (0, import_utils43.hexlify)((0, import_math22.toBytes)((0, import_utils43.decodeBase58)(extendedKey)));
     const bytes = (0, import_utils43.arrayify)(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
-      throw new import_errors24.FuelError(import_errors24.ErrorCode.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
+      throw new import_errors25.FuelError(import_errors25.ErrorCode.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
     }
     if (!validChecksum) {
-      throw new import_errors24.FuelError(import_errors24.ErrorCode.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
+      throw new import_errors25.FuelError(import_errors25.ErrorCode.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
     }
     const depth = bytes[4];
     const parentFingerprint = (0, import_utils43.hexlify)(bytes.slice(5, 9));
@@ -10023,14 +10093,14 @@ var HDWallet = class {
     const chainCode = (0, import_utils43.hexlify)(bytes.slice(13, 45));
     const key = bytes.slice(45, 78);
     if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
-      throw new import_errors24.FuelError(
-        import_errors24.ErrorCode.HD_WALLET_ERROR,
+      throw new import_errors25.FuelError(
+        import_errors25.ErrorCode.HD_WALLET_ERROR,
         "Inconsistency detected: Depth is zero but fingerprint/index is non-zero."
       );
     }
     if (isPublicExtendedKey(bytes)) {
       if (key[0] !== 3) {
-        throw new import_errors24.FuelError(import_errors24.ErrorCode.HD_WALLET_ERROR, "Invalid public extended key.");
+        throw new import_errors25.FuelError(import_errors25.ErrorCode.HD_WALLET_ERROR, "Invalid public extended key.");
       }
       return new HDWallet({
         publicKey: key,
@@ -10041,7 +10111,7 @@ var HDWallet = class {
       });
     }
     if (key[0] !== 0) {
-      throw new import_errors24.FuelError(import_errors24.ErrorCode.HD_WALLET_ERROR, "Invalid private extended key.");
+      throw new import_errors25.FuelError(import_errors25.ErrorCode.HD_WALLET_ERROR, "Invalid private extended key.");
     }
     return new HDWallet({
       privateKey: key.slice(1),
@@ -10285,26 +10355,26 @@ var WalletsConfig = class {
     amountPerCoin
   }) {
     if (Array.isArray(wallets) && wallets.length === 0 || typeof wallets === "number" && wallets <= 0) {
-      throw new import_errors25.FuelError(
-        import_errors25.FuelError.CODES.INVALID_INPUT_PARAMETERS,
+      throw new import_errors26.FuelError(
+        import_errors26.FuelError.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 import_errors25.FuelError(
-        import_errors25.FuelError.CODES.INVALID_INPUT_PARAMETERS,
+      throw new import_errors26.FuelError(
+        import_errors26.FuelError.CODES.INVALID_INPUT_PARAMETERS,
         "Number of assets per wallet must be greater than zero."
       );
     }
     if (coinsPerAsset <= 0) {
-      throw new import_errors25.FuelError(
-        import_errors25.FuelError.CODES.INVALID_INPUT_PARAMETERS,
+      throw new import_errors26.FuelError(
+        import_errors26.FuelError.CODES.INVALID_INPUT_PARAMETERS,
         "Number of coins per asset must be greater than zero."
       );
     }
     if (amountPerCoin < 0) {
-      throw new import_errors25.FuelError(
-        import_errors25.FuelError.CODES.INVALID_INPUT_PARAMETERS,
+      throw new import_errors26.FuelError(
+        import_errors26.FuelError.CODES.INVALID_INPUT_PARAMETERS,
         "Amount per coin must be greater than or equal to zero."
       );
     }
@@ -10375,9 +10445,9 @@ async function setupTestProviderAndWallets({
 }
 
 // src/test-utils/test-message.ts
-var import_address7 = require("@fuel-ts/address");
+var import_address8 = require("@fuel-ts/address");
 var import_crypto10 = require("@fuel-ts/crypto");
-var import_math24 = require("@fuel-ts/math");
+var import_math23 = require("@fuel-ts/math");
 var import_utils46 = require("@fuel-ts/utils");
 var TestMessage = class {
   sender;
@@ -10393,8 +10463,8 @@ var TestMessage = class {
    * It can also be used standalone and passed into the initial state of a chain via the `.toChainMessage` method.
    */
   constructor({
-    sender = import_address7.Address.fromRandom(),
-    recipient = import_address7.Address.fromRandom(),
+    sender = import_address8.Address.fromRandom(),
+    recipient = import_address8.Address.fromRandom(),
     nonce = (0, import_utils46.hexlify)((0, import_crypto10.randomBytes)(32)),
     amount = 1e6,
     data = "",
@@ -10414,7 +10484,7 @@ var TestMessage = class {
       sender: this.sender.toB256(),
       recipient: recipient?.toB256() ?? this.recipient.toB256(),
       nonce: this.nonce,
-      amount: (0, import_math24.bn)(this.amount).toNumber(),
+      amount: (0, import_math23.bn)(this.amount).toNumber(),
       data,
       da_height: this.da_height
     };