@fuel-ts/account 0.94.4 → 0.94.5

package/dist/index.mjs

@@ -35,7 +35,7 @@ import { ErrorCode as ErrorCode16, FuelError as FuelError17 } from "@fuel-ts/err
 import { AbstractAccount } from "@fuel-ts/interfaces";
 import { bn as bn19 } from "@fuel-ts/math";
 import { InputType as InputType8 } from "@fuel-ts/transactions";
-import { arrayify as arrayify14, hexlify as hexlify13, isDefined as isDefined3 } from "@fuel-ts/utils";
+import { arrayify as arrayify14, hexlify as hexlify14, isDefined as isDefined3 } from "@fuel-ts/utils";
 import { clone as clone7 } from "ramda";
 
 // src/providers/coin-quantity.ts
@@ -77,8 +77,8 @@ var addAmountToCoinQuantities = (params) => {
 import { Address as Address2 } from "@fuel-ts/address";
 import { ErrorCode as ErrorCode14, FuelError as FuelError15 } from "@fuel-ts/errors";
 import { BN as BN2, bn as bn17 } from "@fuel-ts/math";
-import { InputType as InputType7, InputMessageCoder, TransactionCoder as TransactionCoder5 } from "@fuel-ts/transactions";
-import { arrayify as arrayify11, hexlify as hexlify12, DateTime as DateTime2, isDefined as isDefined2 } from "@fuel-ts/utils";
+import { InputType as InputType7, InputMessageCoder as InputMessageCoder2, TransactionCoder as TransactionCoder5 } from "@fuel-ts/transactions";
+import { arrayify as arrayify11, hexlify as hexlify13, DateTime as DateTime2, isDefined as isDefined2 } from "@fuel-ts/utils";
 import { checkFuelCoreVersionCompatibility } from "@fuel-ts/versions";
 import { equalBytes } from "@noble/curves/abstract/utils";
 import { GraphQLClient } from "graphql-request";
@@ -1031,6 +1031,13 @@ var SubmitAndAwaitDocument = gql`
   }
 }
     ${TransactionStatusSubscriptionFragmentDoc}`;
+var SubmitAndAwaitStatusDocument = gql`
+    subscription submitAndAwaitStatus($encodedTransaction: HexString!) {
+  submitAndAwaitStatus(tx: $encodedTransaction) {
+    ...transactionStatusSubscriptionFragment
+  }
+}
+    ${TransactionStatusSubscriptionFragmentDoc}`;
 var StatusChangeDocument = gql`
     subscription statusChange($transactionId: TransactionId!) {
   statusChange(id: $transactionId) {
@@ -1127,6 +1134,9 @@ function getSdk(requester) {
     submitAndAwait(variables, options) {
       return requester(SubmitAndAwaitDocument, variables, options);
     },
+    submitAndAwaitStatus(variables, options) {
+      return requester(SubmitAndAwaitStatusDocument, variables, options);
+    },
     statusChange(variables, options) {
       return requester(StatusChangeDocument, variables, options);
     }
@@ -1153,7 +1163,9 @@ var _FuelGraphqlSubscriber = class {
         Accept: "text/event-stream"
       }
     });
-    return new _FuelGraphqlSubscriber(response.body.getReader());
+    const [errorReader, resultReader] = response.body.tee().map((stream) => stream.getReader());
+    await new _FuelGraphqlSubscriber(errorReader).next();
+    return new _FuelGraphqlSubscriber(resultReader);
   }
   events = [];
   parsingLeftover = "";
@@ -1196,10 +1208,8 @@ var _FuelGraphqlSubscriber = class {
   /**
    * Gets called when `break` is called in a `for-await-of` loop.
    */
-  async return() {
-    await this.stream.cancel();
-    this.stream.releaseLock();
-    return { done: true, value: void 0 };
+  return() {
+    return Promise.resolve({ done: true, value: void 0 });
   }
   [Symbol.asyncIterator]() {
     return this;
@@ -1416,7 +1426,7 @@ import {
   OutputType as OutputType2,
   TransactionType
 } from "@fuel-ts/transactions";
-import { concat, hexlify as hexlify7, isDefined } from "@fuel-ts/utils";
+import { concat, hexlify as hexlify8, isDefined } from "@fuel-ts/utils";
 
 // src/providers/message.ts
 var isMessageCoin = (message) => !("data" in message);
@@ -1431,14 +1441,9 @@ var isMessage = (resource) => "recipient" in resource;
 import { ZeroBytes32 as ZeroBytes323 } from "@fuel-ts/address/configs";
 import { ErrorCode as ErrorCode5, FuelError as FuelError5 } from "@fuel-ts/errors";
 import { bn as bn4 } from "@fuel-ts/math";
-import {
-  ReceiptBurnCoder,
-  ReceiptMessageOutCoder,
-  ReceiptMintCoder,
-  ReceiptType
-} from "@fuel-ts/transactions";
+import { getMintedAssetId, InputMessageCoder, ReceiptType } from "@fuel-ts/transactions";
 import { FAILED_TRANSFER_TO_ADDRESS_SIGNAL } from "@fuel-ts/transactions/configs";
-import { arrayify as arrayify2 } from "@fuel-ts/utils";
+import { arrayify as arrayify2, hexlify as hexlify5 } from "@fuel-ts/utils";
 var doesReceiptHaveMissingOutputVariables = (receipt) => receipt.type === ReceiptType.Revert && receipt.val.toString("hex") === FAILED_TRANSFER_TO_ADDRESS_SIGNAL;
 var doesReceiptHaveMissingContractId = (receipt) => receipt.type === ReceiptType.Panic && receipt.contractId !== "0x0000000000000000000000000000000000000000000000000000000000000000";
 var getReceiptsWithMissingData = (receipts) => receipts.reduce(
@@ -1584,12 +1589,12 @@ function assembleReceiptByType(receipt) {
       const amount = bn4(receipt.amount);
       const data = receipt.data ? arrayify2(receipt.data) : Uint8Array.from([]);
       const digest = hexOrZero(receipt.digest);
-      const messageId = ReceiptMessageOutCoder.getMessageId({
+      const messageId = InputMessageCoder.getMessageId({
         sender,
         recipient,
         nonce,
         amount,
-        data
+        data: hexlify5(data)
       });
       const receiptMessageOut = {
         type: ReceiptType.MessageOut,
@@ -1606,7 +1611,7 @@ function assembleReceiptByType(receipt) {
     case "MINT" /* Mint */: {
       const contractId = hexOrZero(receipt.id || receipt.contractId);
       const subId = hexOrZero(receipt.subId);
-      const assetId = ReceiptMintCoder.getAssetId(contractId, subId);
+      const assetId = getMintedAssetId(contractId, subId);
       const mintReceipt = {
         type: ReceiptType.Mint,
         subId,
@@ -1621,7 +1626,7 @@ function assembleReceiptByType(receipt) {
     case "BURN" /* Burn */: {
       const contractId = hexOrZero(receipt.id || receipt.contractId);
       const subId = hexOrZero(receipt.subId);
-      const assetId = ReceiptBurnCoder.getAssetId(contractId, subId);
+      const assetId = getMintedAssetId(contractId, subId);
       const burnReceipt = {
         type: ReceiptType.Burn,
         subId,
@@ -1806,13 +1811,13 @@ var calculateGasFee = (params) => {
 };
 
 // src/providers/utils/json.ts
-import { hexlify as hexlify5 } from "@fuel-ts/utils";
+import { hexlify as hexlify6 } from "@fuel-ts/utils";
 import { clone } from "ramda";
 function normalize(object) {
   Object.keys(object).forEach((key) => {
     switch (object[key]?.constructor.name) {
       case "Uint8Array":
-        object[key] = hexlify5(object[key]);
+        object[key] = hexlify6(object[key]);
         break;
       case "Array":
         object[key] = normalize(object[key]);
@@ -2002,11 +2007,11 @@ var cacheRequestInputsResourcesFromOwner = (inputs, owner) => inputs.reduce(
 );
 
 // src/providers/transaction-request/witness.ts
-import { arrayify as arrayify4, hexlify as hexlify6 } from "@fuel-ts/utils";
+import { arrayify as arrayify4, hexlify as hexlify7 } from "@fuel-ts/utils";
 var witnessify = (value) => {
   const data = arrayify4(value);
   return {
-    data: hexlify6(data),
+    data: hexlify7(data),
     dataLength: data.length
   };
 };
@@ -2223,9 +2228,9 @@ var BaseTransactionRequest = class {
     const found = this.inputs.find((input) => {
       switch (input.type) {
         case InputType3.Coin:
-          return hexlify7(input.owner) === ownerAddress.toB256();
+          return hexlify8(input.owner) === ownerAddress.toB256();
         case InputType3.Message:
-          return hexlify7(input.recipient) === ownerAddress.toB256();
+          return hexlify8(input.recipient) === ownerAddress.toB256();
         default:
           return false;
       }
@@ -2363,7 +2368,7 @@ var BaseTransactionRequest = class {
    */
   addChangeOutput(to, assetId) {
     const changeOutput = this.getChangeOutputs().find(
-      (output) => hexlify7(output.assetId) === assetId
+      (output) => hexlify8(output.assetId) === assetId
     );
     if (!changeOutput) {
       this.pushOutput({
@@ -2443,12 +2448,12 @@ var BaseTransactionRequest = class {
         usedQuantity = bn8("1000000000000000000");
       }
       if (assetInput && "assetId" in assetInput) {
-        assetInput.id = hexlify7(randomBytes(UTXO_ID_LEN2));
+        assetInput.id = hexlify8(randomBytes(UTXO_ID_LEN2));
         assetInput.amount = usedQuantity;
       } else {
         this.addResources([
           {
-            id: hexlify7(randomBytes(UTXO_ID_LEN2)),
+            id: hexlify8(randomBytes(UTXO_ID_LEN2)),
             amount: usedQuantity,
             assetId,
             owner: resourcesOwner || Address.fromRandom(),
@@ -2651,11 +2656,11 @@ var BlobTransactionRequest = class extends BaseTransactionRequest {
 import { ZeroBytes32 as ZeroBytes326 } from "@fuel-ts/address/configs";
 import { bn as bn10 } from "@fuel-ts/math";
 import { TransactionType as TransactionType3, OutputType as OutputType4 } from "@fuel-ts/transactions";
-import { arrayify as arrayify6, hexlify as hexlify9 } from "@fuel-ts/utils";
+import { arrayify as arrayify6, hexlify as hexlify10 } from "@fuel-ts/utils";
 import { clone as clone4 } from "ramda";
 
 // src/providers/transaction-request/storage-slot.ts
-import { arrayify as arrayify5, hexlify as hexlify8 } from "@fuel-ts/utils";
+import { arrayify as arrayify5, hexlify as hexlify9 } from "@fuel-ts/utils";
 var getStorageValue = (value) => {
   const v = new Uint8Array(32);
   v.set(arrayify5(value));
@@ -2672,8 +2677,8 @@ var storageSlotify = (storageSlot) => {
     value = storageSlot.value;
   }
   return {
-    key: hexlify8(key),
-    value: hexlify8(getStorageValue(value))
+    key: hexlify9(key),
+    value: hexlify9(getStorageValue(value))
   };
 };
 
@@ -2698,7 +2703,7 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
   constructor({ bytecodeWitnessIndex, salt, storageSlots, ...rest }) {
     super(rest);
     this.bytecodeWitnessIndex = bytecodeWitnessIndex ?? 0;
-    this.salt = hexlify9(salt ?? ZeroBytes326);
+    this.salt = hexlify10(salt ?? ZeroBytes326);
     this.storageSlots = [...storageSlots ?? []];
   }
   /**
@@ -2715,7 +2720,7 @@ var CreateTransactionRequest = class extends BaseTransactionRequest {
       ...baseTransaction,
       bytecodeWitnessIndex,
       storageSlotsCount: bn10(storageSlots.length),
-      salt: this.salt ? hexlify9(this.salt) : ZeroBytes326,
+      salt: this.salt ? hexlify10(this.salt) : ZeroBytes326,
       storageSlots
     };
   }
@@ -2768,7 +2773,7 @@ import { addressify as addressify2 } from "@fuel-ts/address";
 import { ZeroBytes32 as ZeroBytes327 } from "@fuel-ts/address/configs";
 import { bn as bn11 } from "@fuel-ts/math";
 import { InputType as InputType5, OutputType as OutputType5, TransactionType as TransactionType4 } from "@fuel-ts/transactions";
-import { arrayify as arrayify8, hexlify as hexlify10 } from "@fuel-ts/utils";
+import { arrayify as arrayify8, hexlify as hexlify11 } from "@fuel-ts/utils";
 import { clone as clone5 } from "ramda";
 
 // src/providers/transaction-request/scripts.ts
@@ -2838,8 +2843,8 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
       scriptLength: bn11(script.length),
       scriptDataLength: bn11(scriptData.length),
       receiptsRoot: ZeroBytes327,
-      script: hexlify10(script),
-      scriptData: hexlify10(scriptData)
+      script: hexlify11(script),
+      scriptData: hexlify11(scriptData)
     };
   }
   /**
@@ -3015,7 +3020,7 @@ import { arrayify as arrayify10, assertUnreachable } from "@fuel-ts/utils";
 // src/providers/transaction-summary/assemble-transaction-summary.ts
 import { bn as bn15 } from "@fuel-ts/math";
 import { PolicyType as PolicyType3 } from "@fuel-ts/transactions";
-import { DateTime, hexlify as hexlify11 } from "@fuel-ts/utils";
+import { DateTime, hexlify as hexlify12 } from "@fuel-ts/utils";
 
 // src/providers/transaction-summary/calculate-tx-fee-for-summary.ts
 import { bn as bn12 } from "@fuel-ts/math";
@@ -3778,7 +3783,7 @@ function assembleTransactionSummary(params) {
     baseAssetId
   } = params;
   const gasUsed = getGasUsedFromReceipts(receipts);
-  const rawPayload = hexlify11(transactionBytes);
+  const rawPayload = hexlify12(transactionBytes);
   const operations = getOperations({
     transactionType: transaction.type,
     inputs: transaction.inputs || [],
@@ -3887,29 +3892,30 @@ function mapGqlOutputsToTxOutputs(outputs) {
   });
 }
 var TransactionResponse = class {
-  /** Transaction ID */
-  id;
-  /** Current provider */
-  provider;
-  /** Gas used on the transaction */
-  gasUsed = bn16(0);
-  /** The graphql Transaction with receipts object. */
-  gqlTransaction;
-  request;
-  status;
-  abis;
   /**
    * Constructor for `TransactionResponse`.
    *
    * @param tx - The transaction ID or TransactionRequest.
    * @param provider - The provider.
    */
-  constructor(tx, provider, abis) {
+  constructor(tx, provider, abis, submitTxSubscription) {
+    this.submitTxSubscription = submitTxSubscription;
     this.id = typeof tx === "string" ? tx : tx.getTransactionId(provider.getChainId());
     this.provider = provider;
     this.abis = abis;
     this.request = typeof tx === "string" ? void 0 : tx;
   }
+  /** Transaction ID */
+  id;
+  /** Current provider */
+  provider;
+  /** Gas used on the transaction */
+  gasUsed = bn16(0);
+  /** The graphql Transaction with receipts object. */
+  gqlTransaction;
+  request;
+  status;
+  abis;
   /**
    * Async constructor for `TransactionResponse`. This method can be used to create
    * an instance of `TransactionResponse` and wait for the transaction to be fetched
@@ -4042,10 +4048,11 @@ var TransactionResponse = class {
     if (status && status !== "SubmittedStatus") {
       return;
     }
-    const subscription = await this.provider.operations.statusChange({
+    const subscription = this.submitTxSubscription ?? await this.provider.operations.statusChange({
       transactionId: this.id
     });
-    for await (const { statusChange } of subscription) {
+    for await (const sub of subscription) {
+      const statusChange = "statusChange" in sub ? sub.statusChange : sub.submitAndAwaitStatus;
       this.status = statusChange;
       if (statusChange.type === "SqueezedOutStatus") {
         this.unsetResourceCache();
@@ -4323,7 +4330,7 @@ var _Provider = class {
     const provider = new _Provider(urlToUse, {
       ...options,
       requestMiddleware: async (request) => {
-        if (auth) {
+        if (auth && request) {
           request.headers ??= {};
           request.headers.Authorization = auth;
         }
@@ -4578,16 +4585,14 @@ Supported fuel-core version: ${supportedVersion}.`
     }
     const { consensusParameters } = this.getChain();
     this.validateTransaction(transactionRequest, consensusParameters);
-    const encodedTransaction = hexlify12(transactionRequest.toTransactionBytes());
+    const encodedTransaction = hexlify13(transactionRequest.toTransactionBytes());
     let abis;
     if (isTransactionTypeScript(transactionRequest)) {
       abis = transactionRequest.abis;
     }
-    const {
-      submit: { id: transactionId }
-    } = await this.operations.submit({ encodedTransaction });
-    __privateMethod(this, _cacheInputs, cacheInputs_fn).call(this, transactionRequest.inputs, transactionId);
-    return new TransactionResponse(transactionRequest, this, abis);
+    const subscription = await this.operations.submitAndAwaitStatus({ encodedTransaction });
+    __privateMethod(this, _cacheInputs, cacheInputs_fn).call(this, transactionRequest.inputs, transactionRequest.getTransactionId(this.getChainId()));
+    return new TransactionResponse(transactionRequest, this, abis, subscription);
   }
   /**
    * Executes a transaction without actually submitting it to the chain.
@@ -4604,7 +4609,7 @@ Supported fuel-core version: ${supportedVersion}.`
     if (estimateTxDependencies) {
       return this.estimateTxDependencies(transactionRequest);
     }
-    const encodedTransaction = hexlify12(transactionRequest.toTransactionBytes());
+    const encodedTransaction = hexlify13(transactionRequest.toTransactionBytes());
     const { dryRun: dryRunStatuses } = await this.operations.dryRun({
       encodedTransactions: encodedTransaction,
       utxoValidation: utxoValidation || false
@@ -4630,7 +4635,7 @@ Supported fuel-core version: ${supportedVersion}.`
     if (!shouldEstimatePredicates) {
       return transactionRequest;
     }
-    const encodedTransaction = hexlify12(transactionRequest.toTransactionBytes());
+    const encodedTransaction = hexlify13(transactionRequest.toTransactionBytes());
     const response = await this.operations.estimatePredicates({
       encodedTransaction
     });
@@ -4671,7 +4676,7 @@ Supported fuel-core version: ${supportedVersion}.`
       const {
         dryRun: [{ receipts: rawReceipts, status }]
       } = await this.operations.dryRun({
-        encodedTransactions: [hexlify12(transactionRequest.toTransactionBytes())],
+        encodedTransactions: [hexlify13(transactionRequest.toTransactionBytes())],
         utxoValidation: false
       });
       receipts = rawReceipts.map(processGqlReceipt);
@@ -4721,7 +4726,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const serializedTransactionsMap = /* @__PURE__ */ new Map();
     allRequests.forEach((req, index) => {
       if (isTransactionTypeScript(req)) {
-        serializedTransactionsMap.set(index, hexlify12(req.toTransactionBytes()));
+        serializedTransactionsMap.set(index, hexlify13(req.toTransactionBytes()));
       }
     });
     let transactionsToProcess = Array.from(serializedTransactionsMap.keys());
@@ -4757,7 +4762,7 @@ Supported fuel-core version: ${supportedVersion}.`
             transactionRequest: request
           });
           request.maxFee = maxFee;
-          serializedTransactionsMap.set(requestIdx, hexlify12(request.toTransactionBytes()));
+          serializedTransactionsMap.set(requestIdx, hexlify13(request.toTransactionBytes()));
           nextRoundTransactions.push(requestIdx);
         }
       }
@@ -4778,7 +4783,7 @@ Supported fuel-core version: ${supportedVersion}.`
     if (estimateTxDependencies) {
       return this.estimateMultipleTxDependencies(transactionRequests);
     }
-    const encodedTransactions = transactionRequests.map((tx) => hexlify12(tx.toTransactionBytes()));
+    const encodedTransactions = transactionRequests.map((tx) => hexlify13(tx.toTransactionBytes()));
     const { dryRun: dryRunStatuses } = await this.operations.dryRun({
       encodedTransactions,
       utxoValidation: utxoValidation || false
@@ -4852,7 +4857,7 @@ Supported fuel-core version: ${supportedVersion}.`
     if (estimateTxDependencies) {
       return this.estimateTxDependencies(transactionRequest);
     }
-    const encodedTransactions = [hexlify12(transactionRequest.toTransactionBytes())];
+    const encodedTransactions = [hexlify13(transactionRequest.toTransactionBytes())];
     const { dryRun: dryRunStatuses } = await this.operations.dryRun({
       encodedTransactions,
       utxoValidation: true
@@ -4951,7 +4956,7 @@ Supported fuel-core version: ${supportedVersion}.`
         paginationLimit: RESOURCES_PAGE_SIZE_LIMIT,
         inputArgs: paginationArgs
       }),
-      filter: { owner: ownerAddress.toB256(), assetId: assetId && hexlify12(assetId) }
+      filter: { owner: ownerAddress.toB256(), assetId: assetId && hexlify13(assetId) }
     });
     const coins = edges.map(({ node }) => ({
       id: node.utxoId,
@@ -4977,8 +4982,8 @@ Supported fuel-core version: ${supportedVersion}.`
   async getResourcesToSpend(owner, quantities, excludedIds) {
     const ownerAddress = Address2.fromAddressOrString(owner);
     const excludeInput = {
-      messages: excludedIds?.messages?.map((nonce) => hexlify12(nonce)) || [],
-      utxos: excludedIds?.utxos?.map((id) => hexlify12(id)) || []
+      messages: excludedIds?.messages?.map((nonce) => hexlify13(nonce)) || [],
+      utxos: excludedIds?.utxos?.map((id) => hexlify13(id)) || []
     };
     if (this.cache) {
       const cached = this.cache.getActiveData();
@@ -4988,7 +4993,7 @@ Supported fuel-core version: ${supportedVersion}.`
     const coinsQuery = {
       owner: ownerAddress.toB256(),
       queryPerAsset: quantities.map(coinQuantityfy).map(({ assetId, amount, max: maxPerAsset }) => ({
-        assetId: hexlify12(assetId),
+        assetId: hexlify13(assetId),
         amount: amount.toString(10),
         max: maxPerAsset ? maxPerAsset.toString(10) : void 0
       })),
@@ -5217,7 +5222,7 @@ Supported fuel-core version: ${supportedVersion}.`
   async getContractBalance(contractId, assetId) {
     const { contractBalance } = await this.operations.getContractBalance({
       contract: Address2.fromAddressOrString(contractId).toB256(),
-      asset: hexlify12(assetId)
+      asset: hexlify13(assetId)
     });
     return bn17(contractBalance.amount, 10);
   }
@@ -5231,7 +5236,7 @@ Supported fuel-core version: ${supportedVersion}.`
   async getBalance(owner, assetId) {
     const { balance } = await this.operations.getBalance({
       owner: Address2.fromAddressOrString(owner).toB256(),
-      assetId: hexlify12(assetId)
+      assetId: hexlify13(assetId)
     });
     return bn17(balance.amount, 10);
   }
@@ -5277,7 +5282,7 @@ Supported fuel-core version: ${supportedVersion}.`
       owner: Address2.fromAddressOrString(address).toB256()
     });
     const messages = edges.map(({ node }) => ({
-      messageId: InputMessageCoder.getMessageId({
+      messageId: InputMessageCoder2.getMessageId({
         sender: node.sender,
         recipient: node.recipient,
         nonce: node.nonce,
@@ -5288,7 +5293,7 @@ Supported fuel-core version: ${supportedVersion}.`
       recipient: Address2.fromAddressOrString(node.recipient),
       nonce: node.nonce,
       amount: bn17(node.amount),
-      data: InputMessageCoder.decodeData(node.data),
+      data: InputMessageCoder2.decodeData(node.data),
       daHeight: bn17(node.daHeight)
     }));
     return {
@@ -5457,7 +5462,7 @@ Supported fuel-core version: ${supportedVersion}.`
       return null;
     }
     const message = {
-      messageId: InputMessageCoder.getMessageId({
+      messageId: InputMessageCoder2.getMessageId({
         sender: rawMessage.sender,
         recipient: rawMessage.recipient,
         nonce: rawMessage.nonce,
@@ -5468,7 +5473,7 @@ Supported fuel-core version: ${supportedVersion}.`
       recipient: Address2.fromAddressOrString(rawMessage.recipient),
       nonce: rawMessage.nonce,
       amount: bn17(rawMessage.amount),
-      data: InputMessageCoder.decodeData(rawMessage.data),
+      data: InputMessageCoder2.decodeData(rawMessage.data),
       daHeight: bn17(rawMessage.daHeight)
     };
     return message;
@@ -6351,7 +6356,7 @@ var Account = class extends AbstractAccount {
    */
   generateFakeResources(coins) {
     return coins.map((coin) => ({
-      id: hexlify13(randomBytes2(UTXO_ID_LEN3)),
+      id: hexlify14(randomBytes2(UTXO_ID_LEN3)),
       owner: this.address,
       blockCreated: bn19(1),
       txCreatedIdx: bn19(1),
@@ -6410,14 +6415,14 @@ var Account = class extends AbstractAccount {
 
 // src/wallet/base-wallet-unlocked.ts
 import { hashMessage } from "@fuel-ts/hasher";
-import { hexlify as hexlify16 } from "@fuel-ts/utils";
+import { hexlify as hexlify17 } from "@fuel-ts/utils";
 
 // src/signer/signer.ts
 import { Address as Address4 } from "@fuel-ts/address";
 import { randomBytes as randomBytes3 } from "@fuel-ts/crypto";
 import { hash } from "@fuel-ts/hasher";
 import { toBytes } from "@fuel-ts/math";
-import { hexlify as hexlify14, concat as concat3, arrayify as arrayify15 } from "@fuel-ts/utils";
+import { hexlify as hexlify15, concat as concat3, arrayify as arrayify15 } from "@fuel-ts/utils";
 import { secp256k1 } from "@noble/curves/secp256k1";
 var Signer = class {
   address;
@@ -6437,9 +6442,9 @@ var Signer = class {
       }
     }
     const privateKeyBytes = toBytes(privateKey, 32);
-    this.privateKey = hexlify14(privateKeyBytes);
-    this.publicKey = hexlify14(secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
-    this.compressedPublicKey = hexlify14(secp256k1.getPublicKey(privateKeyBytes, true));
+    this.privateKey = hexlify15(privateKeyBytes);
+    this.publicKey = hexlify15(secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
+    this.compressedPublicKey = hexlify15(secp256k1.getPublicKey(privateKeyBytes, true));
     this.address = Address4.fromPublicKey(this.publicKey);
   }
   /**
@@ -6457,7 +6462,7 @@ var Signer = class {
     const r = toBytes(`0x${signature.r.toString(16)}`, 32);
     const s = toBytes(`0x${signature.s.toString(16)}`, 32);
     s[0] |= (signature.recovery || 0) << 7;
-    return hexlify14(concat3([r, s]));
+    return hexlify15(concat3([r, s]));
   }
   /**
    * Add point on the current elliptic curve
@@ -6484,11 +6489,11 @@ var Signer = class {
     const s = signedMessageBytes.slice(32, 64);
     const recoveryParam = (s[0] & 128) >> 7;
     s[0] &= 127;
-    const sig = new secp256k1.Signature(BigInt(hexlify14(r)), BigInt(hexlify14(s))).addRecoveryBit(
+    const sig = new secp256k1.Signature(BigInt(hexlify15(r)), BigInt(hexlify15(s))).addRecoveryBit(
       recoveryParam
     );
     const publicKey = sig.recoverPublicKey(arrayify15(data)).toRawBytes(false).slice(1);
-    return hexlify14(publicKey);
+    return hexlify15(publicKey);
   }
   /**
    * Recover the address from a signature performed with [`sign`](#sign).
@@ -6517,7 +6522,7 @@ var Signer = class {
    */
   static extendPublicKey(publicKey) {
     const point = secp256k1.ProjectivePoint.fromHex(arrayify15(publicKey));
-    return hexlify14(point.toRawBytes(false).slice(1));
+    return hexlify15(point.toRawBytes(false).slice(1));
   }
 };
 
@@ -6534,7 +6539,7 @@ import {
   randomUUID
 } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode17, FuelError as FuelError18 } from "@fuel-ts/errors";
-import { hexlify as hexlify15 } from "@fuel-ts/utils";
+import { hexlify as hexlify16 } from "@fuel-ts/utils";
 var DEFAULT_KDF_PARAMS_LOG_N = 13;
 var DEFAULT_KDF_PARAMS_R = 8;
 var DEFAULT_KDF_PARAMS_P = 1;
@@ -6616,7 +6621,7 @@ async function decryptKeystoreWallet(jsonWallet, password) {
     );
   }
   const buffer = await decryptJsonWalletData(ciphertextBuffer, key, ivBuffer);
-  const privateKey = hexlify15(buffer);
+  const privateKey = hexlify16(buffer);
   return privateKey;
 }
 
@@ -6661,7 +6666,7 @@ var BaseWalletUnlocked = class extends Account {
    */
   async signMessage(message) {
     const signedMessage = await this.signer().sign(hashMessage(message));
-    return hexlify16(signedMessage);
+    return hexlify17(signedMessage);
   }
   /**
    * Signs a transaction with the wallet's private key.
@@ -6674,7 +6679,7 @@ var BaseWalletUnlocked = class extends Account {
     const chainId = this.provider.getChainId();
     const hashedTransaction = transactionRequest.getTransactionId(chainId);
     const signature = await this.signer().sign(hashedTransaction);
-    return hexlify16(signature);
+    return hexlify17(signature);
   }
   /**
    * Populates a transaction with the witnesses signature.
@@ -6744,13 +6749,13 @@ import { computeHmac as computeHmac2, ripemd160 } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode20, FuelError as FuelError21 } from "@fuel-ts/errors";
 import { sha256 as sha2564 } from "@fuel-ts/hasher";
 import { bn as bn20, toBytes as toBytes2, toHex } from "@fuel-ts/math";
-import { arrayify as arrayify18, hexlify as hexlify18, concat as concat5, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58 } from "@fuel-ts/utils";
+import { arrayify as arrayify18, hexlify as hexlify19, concat as concat5, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58 } from "@fuel-ts/utils";
 
 // src/mnemonic/mnemonic.ts
 import { randomBytes as randomBytes5, pbkdf2, computeHmac } from "@fuel-ts/crypto";
 import { ErrorCode as ErrorCode19, FuelError as FuelError20 } from "@fuel-ts/errors";
 import { sha256 as sha2563 } from "@fuel-ts/hasher";
-import { arrayify as arrayify17, hexlify as hexlify17, concat as concat4, dataSlice, encodeBase58, toUtf8Bytes } from "@fuel-ts/utils";
+import { arrayify as arrayify17, hexlify as hexlify18, concat as concat4, dataSlice, encodeBase58, toUtf8Bytes } from "@fuel-ts/utils";
 
 // src/wordlists/words/english.ts
 var english = [
@@ -8950,7 +8955,7 @@ var Mnemonic = class {
   static mnemonicToEntropy(phrase, wordlist = english) {
     const words = getWords(phrase);
     assertMnemonic(words);
-    return hexlify17(mnemonicWordsToEntropy(words, wordlist));
+    return hexlify18(mnemonicWordsToEntropy(words, wordlist));
   }
   /**
    * @param entropy - Entropy source to the mnemonic phrase.
@@ -9083,10 +9088,10 @@ var mnemonic_default = Mnemonic;
 
 // src/hdwallet/hdwallet.ts
 var HARDENED_INDEX = 2147483648;
-var MainnetPRV2 = hexlify18("0x0488ade4");
-var MainnetPUB = hexlify18("0x0488b21e");
-var TestnetPRV2 = hexlify18("0x04358394");
-var TestnetPUB = hexlify18("0x043587cf");
+var MainnetPRV2 = hexlify19("0x0488ade4");
+var MainnetPUB = hexlify19("0x0488b21e");
+var TestnetPRV2 = hexlify19("0x04358394");
+var TestnetPUB = hexlify19("0x043587cf");
 function base58check(data) {
   return encodeBase582(concat5([data, dataSlice2(sha2564(sha2564(data)), 0, 4)]));
 }
@@ -9097,11 +9102,11 @@ function getExtendedKeyPrefix(isPublic = false, testnet = false) {
   return testnet ? TestnetPRV2 : MainnetPRV2;
 }
 function isPublicExtendedKey(extendedKey) {
-  return [MainnetPUB, TestnetPUB].includes(hexlify18(extendedKey.slice(0, 4)));
+  return [MainnetPUB, TestnetPUB].includes(hexlify19(extendedKey.slice(0, 4)));
 }
 function isValidExtendedKey(extendedKey) {
   return [MainnetPRV2, TestnetPRV2, MainnetPUB, TestnetPUB].includes(
-    hexlify18(extendedKey.slice(0, 4))
+    hexlify19(extendedKey.slice(0, 4))
   );
 }
 function parsePath(path, depth = 0) {
@@ -9119,8 +9124,8 @@ function parsePath(path, depth = 0) {
 var HDWallet = class {
   depth = 0;
   index = 0;
-  fingerprint = hexlify18("0x00000000");
-  parentFingerprint = hexlify18("0x00000000");
+  fingerprint = hexlify19("0x00000000");
+  parentFingerprint = hexlify19("0x00000000");
   privateKey;
   publicKey;
   chainCode;
@@ -9132,8 +9137,8 @@ var HDWallet = class {
   constructor(config) {
     if (config.privateKey) {
       const signer = new Signer(config.privateKey);
-      this.publicKey = hexlify18(signer.compressedPublicKey);
-      this.privateKey = hexlify18(config.privateKey);
+      this.publicKey = hexlify19(signer.compressedPublicKey);
+      this.privateKey = hexlify19(config.privateKey);
     } else {
       if (!config.publicKey) {
         throw new FuelError21(
@@ -9141,7 +9146,7 @@ var HDWallet = class {
           "Both public and private Key cannot be missing. At least one should be provided."
         );
       }
-      this.publicKey = hexlify18(config.publicKey);
+      this.publicKey = hexlify19(config.publicKey);
     }
     this.parentFingerprint = config.parentFingerprint || this.parentFingerprint;
     this.fingerprint = dataSlice2(ripemd160(sha2564(this.publicKey)), 0, 4);
@@ -9190,7 +9195,7 @@ var HDWallet = class {
         parentFingerprint: this.fingerprint
       });
     }
-    const signer = new Signer(hexlify18(IL));
+    const signer = new Signer(hexlify19(IL));
     const Ki = signer.addPoint(publicKey);
     return new HDWallet({
       publicKey: Ki,
@@ -9225,7 +9230,7 @@ var HDWallet = class {
       );
     }
     const prefix = getExtendedKeyPrefix(this.privateKey == null || isPublic, testnet);
-    const depth = hexlify18(Uint8Array.from([this.depth]));
+    const depth = hexlify19(Uint8Array.from([this.depth]));
     const parentFingerprint = this.parentFingerprint;
     const index = toHex(this.index, 4);
     const chainCode = this.chainCode;
@@ -9247,7 +9252,7 @@ var HDWallet = class {
     });
   }
   static fromExtendedKey(extendedKey) {
-    const decoded = hexlify18(toBytes2(decodeBase58(extendedKey)));
+    const decoded = hexlify19(toBytes2(decodeBase58(extendedKey)));
     const bytes = arrayify18(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
@@ -9257,9 +9262,9 @@ var HDWallet = class {
       throw new FuelError21(ErrorCode20.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
     }
     const depth = bytes[4];
-    const parentFingerprint = hexlify18(bytes.slice(5, 9));
-    const index = parseInt(hexlify18(bytes.slice(9, 13)).substring(2), 16);
-    const chainCode = hexlify18(bytes.slice(13, 45));
+    const parentFingerprint = hexlify19(bytes.slice(5, 9));
+    const index = parseInt(hexlify19(bytes.slice(9, 13)).substring(2), 16);
+    const chainCode = hexlify19(bytes.slice(13, 45));
     const key = bytes.slice(45, 78);
     if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
       throw new FuelError21(
@@ -9863,17 +9868,17 @@ var StorageAbstract = class {
 import { Interface as Interface4 } from "@fuel-ts/abi-coder";
 import { Address as Address9 } from "@fuel-ts/address";
 import { ErrorCode as ErrorCode25, FuelError as FuelError26 } from "@fuel-ts/errors";
-import { arrayify as arrayify20, hexlify as hexlify20 } from "@fuel-ts/utils";
+import { arrayify as arrayify20, hexlify as hexlify21 } from "@fuel-ts/utils";
 
 // src/predicate/utils/getPredicateRoot.ts
 import { hash as hash2 } from "@fuel-ts/hasher";
 import { calcRoot } from "@fuel-ts/merkle";
-import { chunkAndPadBytes, hexlify as hexlify19, concat as concat6, arrayify as arrayify19 } from "@fuel-ts/utils";
+import { chunkAndPadBytes, hexlify as hexlify20, concat as concat6, arrayify as arrayify19 } from "@fuel-ts/utils";
 var getPredicateRoot = (bytecode) => {
   const chunkSize = 16 * 1024;
   const bytes = arrayify19(bytecode);
   const chunks = chunkAndPadBytes(bytes, chunkSize);
-  const codeRoot = calcRoot(chunks.map((c) => hexlify19(c)));
+  const codeRoot = calcRoot(chunks.map((c) => hexlify20(c)));
   const predicateRoot = hash2(concat6(["0x4655454C", codeRoot]));
   return predicateRoot;
 };
@@ -9926,8 +9931,8 @@ var Predicate = class extends Account {
     }
     request.inputs.filter(isRequestInputCoinOrMessage).forEach((input) => {
       if (isRequestInputResourceFromOwner(input, this.address)) {
-        input.predicate = hexlify20(this.bytes);
-        input.predicateData = hexlify20(this.getPredicateData());
+        input.predicate = hexlify21(this.bytes);
+        input.predicateData = hexlify21(this.getPredicateData());
         input.witnessIndex = 0;
       }
     });
@@ -10007,8 +10012,8 @@ var Predicate = class extends Account {
     );
     return resources.map((resource) => ({
       ...resource,
-      predicate: hexlify20(this.bytes),
-      predicateData: hexlify20(this.getPredicateData())
+      predicate: hexlify21(this.bytes),
+      predicateData: hexlify21(this.getPredicateData())
     }));
   }
   /**
@@ -10020,8 +10025,8 @@ var Predicate = class extends Account {
   generateFakeResources(coins) {
     return super.generateFakeResources(coins).map((coin) => ({
       ...coin,
-      predicate: hexlify20(this.bytes),
-      predicateData: hexlify20(this.getPredicateData())
+      predicate: hexlify21(this.bytes),
+      predicateData: hexlify21(this.getPredicateData())
     }));
   }
   /**