@fuel-ts/account 0.76.3 → 0.78.0

package/dist/index.mjs

@@ -30,7 +30,7 @@ var __privateMethod = (obj, member, method) => {
 // src/account.ts
 import { Address as Address3 } from "@fuel-ts/address";
 import { BaseAssetId as BaseAssetId3 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode13, FuelError as FuelError14 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode14, FuelError as FuelError14 } from "@fuel-ts/errors";
 import { AbstractAccount } from "@fuel-ts/interfaces";
 import { bn as bn16 } from "@fuel-ts/math";
 import { arrayify as arrayify14 } from "@fuel-ts/utils";
@@ -73,7 +73,7 @@ var addAmountToAsset = (params) => {
 
 // src/providers/provider.ts
 import { Address as Address2 } from "@fuel-ts/address";
-import { ErrorCode as ErrorCode11, FuelError as FuelError12 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode12, FuelError as FuelError12 } from "@fuel-ts/errors";
 import { BN, bn as bn14, max } from "@fuel-ts/math";
 import {
   InputType as InputType6,
@@ -149,6 +149,9 @@ var TransactionStatusFragmentFragmentDoc = gql`
     time
     reason
   }
+  ... on SqueezedOutStatus {
+    reason
+  }
 }
     `;
 var TransactionFragmentFragmentDoc = gql`
@@ -891,7 +894,7 @@ function getSdk(requester) {
 }
 
 // src/providers/fuel-graphql-subscriber.ts
-import { FuelError } from "@fuel-ts/errors";
+import { ErrorCode, FuelError } from "@fuel-ts/errors";
 import { print } from "graphql";
 var _FuelGraphqlSubscriber = class {
   constructor(options) {
@@ -926,7 +929,16 @@ var _FuelGraphqlSubscriber = class {
       if (!text.startsWith("data:")) {
         continue;
       }
-      const { data, errors } = JSON.parse(text.split("data:")[1]);
+      let data;
+      let errors;
+      try {
+        ({ data, errors } = JSON.parse(text.replace(/^data:/, "")));
+      } catch (e) {
+        throw new FuelError(
+          ErrorCode.STREAM_PARSING_ERROR,
+          `Error while parsing stream data response: ${text}`
+        );
+      }
       if (Array.isArray(errors)) {
         throw new FuelError(
           FuelError.CODES.INVALID_REQUEST,
@@ -952,7 +964,7 @@ var FuelGraphqlSubscriber = _FuelGraphqlSubscriber;
 __publicField(FuelGraphqlSubscriber, "textDecoder", new TextDecoder());
 
 // src/providers/memory-cache.ts
-import { ErrorCode, FuelError as FuelError2 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode2, FuelError as FuelError2 } from "@fuel-ts/errors";
 import { hexlify as hexlify2 } from "@fuel-ts/utils";
 var cache = {};
 var DEFAULT_TTL_IN_MS = 30 * 1e3;
@@ -962,7 +974,7 @@ var MemoryCache = class {
     this.ttl = ttlInMs;
     if (typeof ttlInMs !== "number" || this.ttl <= 0) {
       throw new FuelError2(
-        ErrorCode.INVALID_TTL,
+        ErrorCode2.INVALID_TTL,
         `Invalid TTL: ${this.ttl}. Use a value greater than zero.`
       );
     }
@@ -1012,7 +1024,7 @@ var MemoryCache = class {
 
 // src/providers/transaction-request/input.ts
 import { ZeroBytes32 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode2, FuelError as FuelError3 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode3, FuelError as FuelError3 } from "@fuel-ts/errors";
 import { bn as bn2, toNumber } from "@fuel-ts/math";
 import { InputType } from "@fuel-ts/transactions";
 import { arrayify, hexlify as hexlify3 } from "@fuel-ts/utils";
@@ -1078,7 +1090,7 @@ var inputify = (value) => {
     }
     default: {
       throw new FuelError3(
-        ErrorCode2.INVALID_TRANSACTION_INPUT,
+        ErrorCode3.INVALID_TRANSACTION_INPUT,
         `Invalid transaction input type: ${type}.`
       );
     }
@@ -1087,7 +1099,7 @@ var inputify = (value) => {
 
 // src/providers/transaction-request/output.ts
 import { ZeroBytes32 as ZeroBytes322 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode3, FuelError as FuelError4 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode4, FuelError as FuelError4 } from "@fuel-ts/errors";
 import { bn as bn3 } from "@fuel-ts/math";
 import { OutputType } from "@fuel-ts/transactions";
 import { hexlify as hexlify4 } from "@fuel-ts/utils";
@@ -1135,7 +1147,7 @@ var outputify = (value) => {
     }
     default: {
       throw new FuelError4(
-        ErrorCode3.INVALID_TRANSACTION_INPUT,
+        ErrorCode4.INVALID_TRANSACTION_INPUT,
         `Invalid transaction output type: ${type}.`
       );
     }
@@ -1163,7 +1175,7 @@ var isMessage = (resource) => "recipient" in resource;
 
 // src/providers/utils/receipts.ts
 import { ZeroBytes32 as ZeroBytes323 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode4, FuelError as FuelError5 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode5, FuelError as FuelError5 } from "@fuel-ts/errors";
 import { bn as bn4 } from "@fuel-ts/math";
 import {
   ReceiptBurnCoder,
@@ -1368,12 +1380,12 @@ function assembleReceiptByType(receipt) {
       return burnReceipt;
     }
     default:
-      throw new FuelError5(ErrorCode4.INVALID_RECEIPT_TYPE, `Invalid receipt type: ${receiptType}.`);
+      throw new FuelError5(ErrorCode5.INVALID_RECEIPT_TYPE, `Invalid receipt type: ${receiptType}.`);
   }
 }
 
 // src/providers/utils/block-explorer.ts
-import { ErrorCode as ErrorCode5, FuelError as FuelError6 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode6, FuelError as FuelError6 } from "@fuel-ts/errors";
 var DEFAULT_BLOCK_EXPLORER_URL = "https://fuellabs.github.io/block-explorer-v2";
 var getPathFromInput = (key, value) => {
   const pathMap = {
@@ -1408,14 +1420,14 @@ var buildBlockExplorerUrl = (options = {}) => {
   const hasAnyDefinedValues = definedValues.length > 0;
   if (definedValues.length > 1) {
     throw new FuelError6(
-      ErrorCode5.ERROR_BUILDING_BLOCK_EXPLORER_URL,
+      ErrorCode6.ERROR_BUILDING_BLOCK_EXPLORER_URL,
       `Only one of the following can be passed in to buildBlockExplorerUrl: ${customInputParams.map((param) => param.key).join(", ")}.`
     );
   }
   if (path && definedValues.length > 0) {
     const inputKeys = customInputParams.map(({ key }) => key).join(", ");
     throw new FuelError6(
-      ErrorCode5.ERROR_BUILDING_BLOCK_EXPLORER_URL,
+      ErrorCode6.ERROR_BUILDING_BLOCK_EXPLORER_URL,
       `You cannot pass in a path to 'buildBlockExplorerUrl' along with any of the following: ${inputKeys}.`
     );
   }
@@ -1691,13 +1703,27 @@ var BaseTransactionRequest = class {
     this.outputs.push(output);
     return this.outputs.length - 1;
   }
+  /**
+   * @hidden
+   *
+   * Pushes a witness to the list and returns the index
+   *
+   * @param signature - The signature to add to the witness.
+   * @returns The index of the created witness.
+   */
+  addWitness(signature) {
+    this.witnesses.push(signature);
+    return this.witnesses.length - 1;
+  }
   /**
    * @hidden
    *
    * Creates an empty witness without any side effects and returns the index
+   *
+   * @returns The index of the created witness.
    */
-  createWitness() {
-    this.witnesses.push(concat([ZeroBytes324, ZeroBytes324]));
+  addEmptyWitness() {
+    this.addWitness(concat([ZeroBytes324, ZeroBytes324]));
     return this.witnesses.length - 1;
   }
   /**
@@ -1726,6 +1752,21 @@ var BaseTransactionRequest = class {
     }
     this.witnesses[index] = witness;
   }
+  /**
+   * Helper function to add an external signature to the transaction.
+   *
+   * @param account - The account/s to sign to the transaction.
+   * @returns The transaction with the signature witness added.
+   */
+  async addAccountWitnesses(account) {
+    const accounts = Array.isArray(account) ? account : [account];
+    await Promise.all(
+      accounts.map(async (acc) => {
+        this.addWitness(await acc.signTransaction(this));
+      })
+    );
+    return this;
+  }
   /**
    * Gets the coin inputs for a transaction.
    *
@@ -1791,7 +1832,7 @@ var BaseTransactionRequest = class {
     } else {
       witnessIndex = this.getCoinInputWitnessIndexByOwner(owner);
       if (typeof witnessIndex !== "number") {
-        witnessIndex = this.createWitness();
+        witnessIndex = this.addEmptyWitness();
       }
     }
     const input = {
@@ -1803,7 +1844,7 @@ var BaseTransactionRequest = class {
       txPointer: "0x00000000000000000000000000000000",
       witnessIndex,
       predicate: predicate?.bytes,
-      predicateData: predicate?.predicateData
+      predicateData: predicate?.predicateDataBytes
     };
     this.pushInput(input);
     this.addChangeOutput(owner, assetId);
@@ -1825,7 +1866,7 @@ var BaseTransactionRequest = class {
     } else {
       witnessIndex = this.getCoinInputWitnessIndexByOwner(recipient);
       if (typeof witnessIndex !== "number") {
-        witnessIndex = this.createWitness();
+        witnessIndex = this.addEmptyWitness();
       }
     }
     const input = {
@@ -1836,7 +1877,7 @@ var BaseTransactionRequest = class {
       amount,
       witnessIndex,
       predicate: predicate?.bytes,
-      predicateData: predicate?.predicateData
+      predicateData: predicate?.predicateDataBytes
     };
     this.pushInput(input);
     this.addChangeOutput(recipient, assetId);
@@ -2079,11 +2120,10 @@ import { arrayify as arrayify6, hexlify as hexlify9 } from "@fuel-ts/utils";
 
 // src/providers/transaction-request/hash-transaction.ts
 import { ZeroBytes32 as ZeroBytes325 } from "@fuel-ts/address/configs";
-import { uint64ToBytesBE } from "@fuel-ts/hasher";
+import { uint64ToBytesBE, sha256 } from "@fuel-ts/hasher";
 import { bn as bn7 } from "@fuel-ts/math";
 import { TransactionType as TransactionType2, InputType as InputType3, OutputType as OutputType3, TransactionCoder as TransactionCoder2 } from "@fuel-ts/transactions";
 import { concat as concat2 } from "@fuel-ts/utils";
-import { sha256 } from "ethers";
 import { clone as clone2 } from "ramda";
 function hashTransaction(transactionRequest, chainId) {
   const transaction = transactionRequest.toTransaction();
@@ -2470,7 +2510,7 @@ var ScriptTransactionRequest = class extends BaseTransactionRequest {
 };
 
 // src/providers/transaction-request/utils.ts
-import { ErrorCode as ErrorCode6, FuelError as FuelError7 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode7, FuelError as FuelError7 } from "@fuel-ts/errors";
 import { TransactionType as TransactionType5 } from "@fuel-ts/transactions";
 var transactionRequestify = (obj) => {
   if (obj instanceof ScriptTransactionRequest || obj instanceof CreateTransactionRequest) {
@@ -2485,13 +2525,13 @@ var transactionRequestify = (obj) => {
       return CreateTransactionRequest.from(obj);
     }
     default: {
-      throw new FuelError7(ErrorCode6.INVALID_TRANSACTION_TYPE, `Invalid transaction type: ${type}.`);
+      throw new FuelError7(ErrorCode7.INVALID_TRANSACTION_TYPE, `Invalid transaction type: ${type}.`);
     }
   }
 };
 
 // src/providers/transaction-response/transaction-response.ts
-import { ErrorCode as ErrorCode10, FuelError as FuelError11 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode11, FuelError as FuelError11 } from "@fuel-ts/errors";
 import { bn as bn13 } from "@fuel-ts/math";
 import { TransactionCoder as TransactionCoder4 } from "@fuel-ts/transactions";
 import { arrayify as arrayify10 } from "@fuel-ts/utils";
@@ -2574,7 +2614,7 @@ var calculateTransactionFee = (params) => {
 
 // src/providers/transaction-summary/operations.ts
 import { ZeroBytes32 as ZeroBytes328 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode8, FuelError as FuelError9 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode9, FuelError as FuelError9 } from "@fuel-ts/errors";
 import { bn as bn12 } from "@fuel-ts/math";
 import { ReceiptType as ReceiptType3, TransactionType as TransactionType7 } from "@fuel-ts/transactions";
 
@@ -2623,7 +2663,7 @@ var getFunctionCall = ({ abi, receipt, rawPayload, maxInputs }) => {
 };
 
 // src/providers/transaction-summary/input.ts
-import { ErrorCode as ErrorCode7, FuelError as FuelError8 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode8, FuelError as FuelError8 } from "@fuel-ts/errors";
 import { InputType as InputType5 } from "@fuel-ts/transactions";
 function getInputsByTypes(inputs, types) {
   return inputs.filter((i) => types.includes(i.type));
@@ -2662,7 +2702,7 @@ function getInputContractFromIndex(inputs, inputIndex) {
   }
   if (contractInput.type !== InputType5.Contract) {
     throw new FuelError8(
-      ErrorCode7.INVALID_TRANSACTION_INPUT,
+      ErrorCode8.INVALID_TRANSACTION_INPUT,
       `Contract input should be of type 'contract'.`
     );
   }
@@ -2751,7 +2791,7 @@ function getTransactionTypeName(transactionType) {
       return "Script" /* Script */;
     default:
       throw new FuelError9(
-        ErrorCode8.INVALID_TRANSACTION_TYPE,
+        ErrorCode9.INVALID_TRANSACTION_TYPE,
         `Invalid transaction type: ${transactionType}.`
       );
   }
@@ -3114,7 +3154,7 @@ var extractBurnedAssetsFromReceipts = (receipts) => {
 };
 
 // src/providers/transaction-summary/status.ts
-import { ErrorCode as ErrorCode9, FuelError as FuelError10 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode10, FuelError as FuelError10 } from "@fuel-ts/errors";
 var getTransactionStatusName = (gqlStatus) => {
   switch (gqlStatus) {
     case "FailureStatus":
@@ -3127,7 +3167,7 @@ var getTransactionStatusName = (gqlStatus) => {
       return "squeezedout" /* squeezedout */;
     default:
       throw new FuelError10(
-        ErrorCode9.INVALID_TRANSACTION_STATUS,
+        ErrorCode10.INVALID_TRANSACTION_STATUS,
         `Invalid transaction status: ${gqlStatus}.`
       );
   }
@@ -3347,6 +3387,12 @@ var TransactionResponse = class {
       transactionId: this.id
     });
     for await (const { statusChange } of subscription) {
+      if (statusChange.type === "SqueezedOutStatus") {
+        throw new FuelError11(
+          ErrorCode11.TRANSACTION_SQUEEZED_OUT,
+          `Transaction Squeezed Out with reason: ${statusChange.reason}`
+        );
+      }
       if (statusChange.type !== "SubmittedStatus") {
         break;
       }
@@ -3376,7 +3422,7 @@ var TransactionResponse = class {
     const result = await this.waitForResult(contractsAbiMap);
     if (result.isStatusFailure) {
       throw new FuelError11(
-        ErrorCode10.TRANSACTION_FAILED,
+        ErrorCode11.TRANSACTION_FAILED,
         `Transaction failed: ${result.gqlTransaction.status.reason}`
       );
     }
@@ -3524,14 +3570,15 @@ var _Provider = class {
   }
   static getFetchFn(options) {
     const { retryOptions, timeout } = options;
-    return autoRetryFetch((...args) => {
-      if (options.fetch) {
-        return options.fetch(...args);
-      }
+    return autoRetryFetch(async (...args) => {
       const url = args[0];
       const request = args[1];
       const signal = timeout ? AbortSignal.timeout(timeout) : void 0;
-      return fetch(url, { ...request, signal });
+      let fullRequest = { ...request, signal };
+      if (options.requestMiddleware) {
+        fullRequest = await options.requestMiddleware(fullRequest);
+      }
+      return options.fetch ? options.fetch(url, fullRequest, options) : fetch(url, fullRequest);
     }, retryOptions);
   }
   /**
@@ -3551,7 +3598,7 @@ var _Provider = class {
     const chain = _Provider.chainInfoCache[this.url];
     if (!chain) {
       throw new FuelError12(
-        ErrorCode11.CHAIN_INFO_CACHE_EMPTY,
+        ErrorCode12.CHAIN_INFO_CACHE_EMPTY,
         "Chain info cache is empty. Make sure you have called `Provider.create` to initialize the provider."
       );
     }
@@ -3564,7 +3611,7 @@ var _Provider = class {
     const node = _Provider.nodeInfoCache[this.url];
     if (!node) {
       throw new FuelError12(
-        ErrorCode11.NODE_INFO_CACHE_EMPTY,
+        ErrorCode12.NODE_INFO_CACHE_EMPTY,
         "Node info cache is empty. Make sure you have called `Provider.create` to initialize the provider."
       );
     }
@@ -3737,6 +3784,12 @@ var _Provider = class {
     if (awaitExecution) {
       const subscription = this.operations.submitAndAwait({ encodedTransaction });
       for await (const { submitAndAwait } of subscription) {
+        if (submitAndAwait.type === "SqueezedOutStatus") {
+          throw new FuelError12(
+            ErrorCode12.TRANSACTION_SQUEEZED_OUT,
+            `Transaction Squeezed Out with reason: ${submitAndAwait.reason}`
+          );
+        }
         if (submitAndAwait.type !== "SubmittedStatus") {
           break;
         }
@@ -3900,7 +3953,8 @@ var _Provider = class {
   async getTransactionCost(transactionRequestLike, forwardingQuantities = [], {
     estimateTxDependencies = true,
     estimatePredicates = true,
-    resourcesOwner
+    resourcesOwner,
+    signatureCallback
   } = {}) {
     const txRequestClone = clone3(transactionRequestify(transactionRequestLike));
     const chainInfo = this.getChain();
@@ -3919,6 +3973,9 @@ var _Provider = class {
       }
       await this.estimatePredicates(txRequestClone);
     }
+    if (signatureCallback && isScriptTransaction) {
+      await signatureCallback(txRequestClone);
+    }
     const minGas = txRequestClone.calculateMinGas(chainInfo);
     const maxGas = txRequestClone.calculateMaxGas(chainInfo, minGas);
     let receipts = [];
@@ -4247,7 +4304,7 @@ var _Provider = class {
     };
     if (commitBlockId && commitBlockHeight) {
       throw new FuelError12(
-        ErrorCode11.INVALID_INPUT_PARAMETERS,
+        ErrorCode12.INVALID_INPUT_PARAMETERS,
         "commitBlockId and commitBlockHeight cannot be used together"
       );
     }
@@ -4364,7 +4421,7 @@ __publicField(Provider, "chainInfoCache", {});
 __publicField(Provider, "nodeInfoCache", {});
 
 // src/providers/transaction-summary/get-transaction-summary.ts
-import { ErrorCode as ErrorCode12, FuelError as FuelError13 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode13, FuelError as FuelError13 } from "@fuel-ts/errors";
 import { bn as bn15 } from "@fuel-ts/math";
 import { TransactionCoder as TransactionCoder6 } from "@fuel-ts/transactions";
 import { arrayify as arrayify12 } from "@fuel-ts/utils";
@@ -4375,7 +4432,7 @@ async function getTransactionSummary(params) {
   });
   if (!gqlTransaction) {
     throw new FuelError13(
-      ErrorCode12.TRANSACTION_NOT_FOUND,
+      ErrorCode13.TRANSACTION_NOT_FOUND,
       `Transaction not found for given id: ${id}.`
     );
   }
@@ -4648,7 +4705,7 @@ var Account = class extends AbstractAccount {
    */
   get provider() {
     if (!this._provider) {
-      throw new FuelError14(ErrorCode13.MISSING_PROVIDER, "Provider not set");
+      throw new FuelError14(ErrorCode14.MISSING_PROVIDER, "Provider not set");
     }
     return this._provider;
   }
@@ -4701,7 +4758,7 @@ var Account = class extends AbstractAccount {
         break;
       }
       throw new FuelError14(
-        ErrorCode13.NOT_SUPPORTED,
+        ErrorCode14.NOT_SUPPORTED,
         `Wallets containing more than ${pageSize} coins exceed the current supported limit.`
       );
     }
@@ -4727,7 +4784,7 @@ var Account = class extends AbstractAccount {
         break;
       }
       throw new FuelError14(
-        ErrorCode13.NOT_SUPPORTED,
+        ErrorCode14.NOT_SUPPORTED,
         `Wallets containing more than ${pageSize} messages exceed the current supported limit.`
       );
     }
@@ -4763,7 +4820,7 @@ var Account = class extends AbstractAccount {
         break;
       }
       throw new FuelError14(
-        ErrorCode13.NOT_SUPPORTED,
+        ErrorCode14.NOT_SUPPORTED,
         `Wallets containing more than ${pageSize} balances exceed the current supported limit.`
       );
     }
@@ -4868,6 +4925,12 @@ var Account = class extends AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async transfer(destination, amount, assetId = BaseAssetId3, txParams = {}) {
+    if (bn16(amount).lte(0)) {
+      throw new FuelError14(
+        ErrorCode14.INVALID_TRANSFER_AMOUNT,
+        "Transfer amount must be a positive number."
+      );
+    }
     const request = await this.createTransfer(destination, amount, assetId, txParams);
     return this.sendTransaction(request, { estimateTxDependencies: false });
   }
@@ -4881,6 +4944,12 @@ var Account = class extends AbstractAccount {
    * @returns A promise that resolves to the transaction response.
    */
   async transferToContract(contractId, amount, assetId = BaseAssetId3, txParams = {}) {
+    if (bn16(amount).lte(0)) {
+      throw new FuelError14(
+        ErrorCode14.INVALID_TRANSFER_AMOUNT,
+        "Transfer amount must be a positive number."
+      );
+    }
     const contractAddress = Address3.fromAddressOrString(contractId);
     const { minGasPrice } = this.provider.getGasConfig();
     const params = { gasPrice: minGasPrice, ...txParams };
@@ -4950,10 +5019,25 @@ var Account = class extends AbstractAccount {
   }
   async signMessage(message) {
     if (!this._connector) {
-      throw new FuelError14(ErrorCode13.MISSING_CONNECTOR, "A connector is required to sign messages.");
+      throw new FuelError14(ErrorCode14.MISSING_CONNECTOR, "A connector is required to sign messages.");
     }
     return this._connector.signMessage(this.address.toString(), message);
   }
+  /**
+   * Signs a transaction with the wallet's private key.
+   *
+   * @param transactionRequestLike - The transaction request to sign.
+   * @returns A promise that resolves to the signature of the transaction.
+   */
+  async signTransaction(transactionRequestLike) {
+    if (!this._connector) {
+      throw new FuelError14(
+        ErrorCode14.MISSING_CONNECTOR,
+        "A connector is required to sign transactions."
+      );
+    }
+    return this._connector.signTransaction(this.address.toString(), transactionRequestLike);
+  }
   /**
    * Sends a transaction to the network.
    *
@@ -4996,13 +5080,13 @@ var Account = class extends AbstractAccount {
   }) {
     if (minGasPrice.gt(gasPrice)) {
       throw new FuelError14(
-        ErrorCode13.GAS_PRICE_TOO_LOW,
+        ErrorCode14.GAS_PRICE_TOO_LOW,
         `Gas price '${gasPrice}' is lower than the required: '${minGasPrice}'.`
       );
     }
     if (gasUsed.gt(gasLimit)) {
       throw new FuelError14(
-        ErrorCode13.GAS_LIMIT_TOO_LOW,
+        ErrorCode14.GAS_LIMIT_TOO_LOW,
         `Gas limit '${gasLimit}' is lower than the required: '${gasUsed}'.`
       );
     }
@@ -5133,7 +5217,7 @@ import {
   decryptJsonWalletData,
   encryptJsonWalletData
 } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode14, FuelError as FuelError15 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode15, FuelError as FuelError15 } from "@fuel-ts/errors";
 import { hexlify as hexlify14 } from "@fuel-ts/utils";
 import { v4 as uuidv4 } from "uuid";
 var DEFAULT_KDF_PARAMS_LOG_N = 13;
@@ -5212,7 +5296,7 @@ async function decryptKeystoreWallet(jsonWallet, password) {
   const macHash = stringFromBuffer(macHashUint8Array, "hex");
   if (mac !== macHash) {
     throw new FuelError15(
-      ErrorCode14.INVALID_PASSWORD,
+      ErrorCode15.INVALID_PASSWORD,
       "Failed to decrypt the keystore wallet, the provided password is incorrect."
     );
   }
@@ -5272,7 +5356,7 @@ var BaseWalletUnlocked = class extends Account {
    */
   async signTransaction(transactionRequestLike) {
     const transactionRequest = transactionRequestify(transactionRequestLike);
-    const chainId = this.provider.getChain().consensusParameters.chainId.toNumber();
+    const chainId = this.provider.getChainId();
     const hashedTransaction = transactionRequest.getTransactionId(chainId);
     const signature = await this.signer().sign(hashedTransaction);
     return hexlify15(signature);
@@ -5334,24 +5418,18 @@ var BaseWalletUnlocked = class extends Account {
 __publicField(BaseWalletUnlocked, "defaultPath", "m/44'/1179993420'/0'/0/0");
 
 // src/hdwallet/hdwallet.ts
-import { ErrorCode as ErrorCode17, FuelError as FuelError18 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode18, FuelError as FuelError18 } from "@fuel-ts/errors";
+import { sha256 as sha2564 } from "@fuel-ts/hasher";
 import { bn as bn17, toBytes as toBytes2, toHex } from "@fuel-ts/math";
 import { arrayify as arrayify18, hexlify as hexlify17, concat as concat5 } from "@fuel-ts/utils";
-import {
-  toBeHex,
-  dataSlice as dataSlice2,
-  encodeBase58 as encodeBase582,
-  decodeBase58,
-  sha256 as sha2564,
-  computeHmac as computeHmac2,
-  ripemd160
-} from "ethers";
+import { toBeHex, dataSlice as dataSlice2, encodeBase58 as encodeBase582, decodeBase58, computeHmac as computeHmac2, ripemd160 } from "ethers";
 
 // src/mnemonic/mnemonic.ts
 import { randomBytes as randomBytes3 } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode16, FuelError as FuelError17 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode17, FuelError as FuelError17 } from "@fuel-ts/errors";
+import { sha256 as sha2563 } from "@fuel-ts/hasher";
 import { arrayify as arrayify17, hexlify as hexlify16, concat as concat4 } from "@fuel-ts/utils";
-import { dataSlice, pbkdf2, sha256 as sha2563, computeHmac, encodeBase58 } from "ethers";
+import { dataSlice, pbkdf2, computeHmac, encodeBase58 } from "ethers";
 
 // src/wordlists/words/english.ts
 var english = [
@@ -7412,9 +7490,9 @@ var Language = /* @__PURE__ */ ((Language2) => {
 })(Language || {});
 
 // src/mnemonic/utils.ts
-import { ErrorCode as ErrorCode15, FuelError as FuelError16 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode16, FuelError as FuelError16 } from "@fuel-ts/errors";
+import { sha256 as sha2562 } from "@fuel-ts/hasher";
 import { arrayify as arrayify16 } from "@fuel-ts/utils";
-import { sha256 as sha2562 } from "ethers";
 function toUtf8Bytes(stri) {
   const str = stri.normalize("NFKD");
   const result = [];
@@ -7430,7 +7508,7 @@ function toUtf8Bytes(stri) {
       const c2 = str.charCodeAt(i);
       if (i >= str.length || (c2 & 64512) !== 56320) {
         throw new FuelError16(
-          ErrorCode15.INVALID_INPUT_PARAMETERS,
+          ErrorCode16.INVALID_INPUT_PARAMETERS,
           "Invalid UTF-8 in the input string."
         );
       }
@@ -7494,7 +7572,7 @@ function mnemonicWordsToEntropy(words, wordlist) {
     const index = wordlist.indexOf(words[i].normalize("NFKD"));
     if (index === -1) {
       throw new FuelError16(
-        ErrorCode15.INVALID_MNEMONIC,
+        ErrorCode16.INVALID_MNEMONIC,
         `Invalid mnemonic: the word '${words[i]}' is not found in the provided wordlist.`
       );
     }
@@ -7511,7 +7589,7 @@ function mnemonicWordsToEntropy(words, wordlist) {
   const checksum = arrayify16(sha2562(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
   if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
     throw new FuelError16(
-      ErrorCode15.INVALID_CHECKSUM,
+      ErrorCode16.INVALID_CHECKSUM,
       "Checksum validation failed for the provided mnemonic."
     );
   }
@@ -7526,7 +7604,7 @@ var MNEMONIC_SIZES = [12, 15, 18, 21, 24];
 function assertWordList(wordlist) {
   if (wordlist.length !== 2048) {
     throw new FuelError17(
-      ErrorCode16.INVALID_WORD_LIST,
+      ErrorCode17.INVALID_WORD_LIST,
       `Expected word list length of 2048, but got ${wordlist.length}.`
     );
   }
@@ -7534,7 +7612,7 @@ function assertWordList(wordlist) {
 function assertEntropy(entropy) {
   if (entropy.length % 4 !== 0 || entropy.length < 16 || entropy.length > 32) {
     throw new FuelError17(
-      ErrorCode16.INVALID_ENTROPY,
+      ErrorCode17.INVALID_ENTROPY,
       `Entropy should be between 16 and 32 bytes and a multiple of 4, but got ${entropy.length} bytes.`
     );
   }
@@ -7544,7 +7622,7 @@ function assertMnemonic(words) {
     const errorMsg = `Invalid mnemonic size. Expected one of [${MNEMONIC_SIZES.join(
       ", "
     )}] words, but got ${words.length}.`;
-    throw new FuelError17(ErrorCode16.INVALID_MNEMONIC, errorMsg);
+    throw new FuelError17(ErrorCode17.INVALID_MNEMONIC, errorMsg);
   }
 }
 var Mnemonic = class {
@@ -7663,7 +7741,7 @@ var Mnemonic = class {
     const seedArray = arrayify17(seed);
     if (seedArray.length < 16 || seedArray.length > 64) {
       throw new FuelError17(
-        ErrorCode16.INVALID_SEED,
+        ErrorCode17.INVALID_SEED,
         `Seed length should be between 16 and 64 bytes, but received ${seedArray.length} bytes.`
       );
     }
@@ -7740,7 +7818,7 @@ function isValidExtendedKey(extendedKey) {
 function parsePath(path, depth = 0) {
   const components = path.split("/");
   if (components.length === 0 || components[0] === "m" && depth !== 0) {
-    throw new FuelError18(ErrorCode17.HD_WALLET_ERROR, `invalid path - ${path}`);
+    throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, `invalid path - ${path}`);
   }
   if (components[0] === "m") {
     components.shift();
@@ -7770,7 +7848,7 @@ var HDWallet = class {
     } else {
       if (!config.publicKey) {
         throw new FuelError18(
-          ErrorCode17.HD_WALLET_ERROR,
+          ErrorCode18.HD_WALLET_ERROR,
           "Both public and private Key cannot be missing. At least one should be provided."
         );
       }
@@ -7800,7 +7878,7 @@ var HDWallet = class {
     if (index & HARDENED_INDEX) {
       if (!privateKey) {
         throw new FuelError18(
-          ErrorCode17.HD_WALLET_ERROR,
+          ErrorCode18.HD_WALLET_ERROR,
           "Cannot derive a hardened index without a private Key."
         );
       }
@@ -7853,7 +7931,7 @@ var HDWallet = class {
   toExtendedKey(isPublic = false, testnet = false) {
     if (this.depth >= 256) {
       throw new FuelError18(
-        ErrorCode17.HD_WALLET_ERROR,
+        ErrorCode18.HD_WALLET_ERROR,
         `Exceeded max depth of 255. Current depth: ${this.depth}.`
       );
     }
@@ -7884,10 +7962,10 @@ var HDWallet = class {
     const bytes = arrayify18(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
-      throw new FuelError18(ErrorCode17.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
+      throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
     }
     if (!validChecksum) {
-      throw new FuelError18(ErrorCode17.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
+      throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
     }
     const depth = bytes[4];
     const parentFingerprint = hexlify17(bytes.slice(5, 9));
@@ -7896,13 +7974,13 @@ var HDWallet = class {
     const key = bytes.slice(45, 78);
     if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
       throw new FuelError18(
-        ErrorCode17.HD_WALLET_ERROR,
+        ErrorCode18.HD_WALLET_ERROR,
         "Inconsistency detected: Depth is zero but fingerprint/index is non-zero."
       );
     }
     if (isPublicExtendedKey(bytes)) {
       if (key[0] !== 3) {
-        throw new FuelError18(ErrorCode17.HD_WALLET_ERROR, "Invalid public extended key.");
+        throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Invalid public extended key.");
       }
       return new HDWallet({
         publicKey: key,
@@ -7913,7 +7991,7 @@ var HDWallet = class {
       });
     }
     if (key[0] !== 0) {
-      throw new FuelError18(ErrorCode17.HD_WALLET_ERROR, "Invalid private extended key.");
+      throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Invalid private extended key.");
     }
     return new HDWallet({
       privateKey: key.slice(1),
@@ -8081,7 +8159,7 @@ __publicField(Wallet, "fromEncryptedJson", WalletUnlocked.fromEncryptedJson);
 // src/wallet-manager/wallet-manager.ts
 import { Address as Address8 } from "@fuel-ts/address";
 import { encrypt, decrypt } from "@fuel-ts/crypto";
-import { ErrorCode as ErrorCode20, FuelError as FuelError21 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode21, FuelError as FuelError21 } from "@fuel-ts/errors";
 import { EventEmitter } from "events";
 
 // src/wallet-manager/storages/memory-storage.ts
@@ -8104,7 +8182,7 @@ var MemoryStorage = class {
 
 // src/wallet-manager/vaults/mnemonic-vault.ts
 import { Address as Address6 } from "@fuel-ts/address";
-import { ErrorCode as ErrorCode18, FuelError as FuelError19 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode19, FuelError as FuelError19 } from "@fuel-ts/errors";
 var _secret;
 var MnemonicVault = class {
   constructor(options) {
@@ -8161,7 +8239,7 @@ var MnemonicVault = class {
       numberOfAccounts += 1;
     } while (numberOfAccounts < this.numberOfAccounts);
     throw new FuelError19(
-      ErrorCode18.WALLET_MANAGER_ERROR,
+      ErrorCode19.WALLET_MANAGER_ERROR,
       `Account with address '${address}' not found in derived wallets.`
     );
   }
@@ -8175,7 +8253,7 @@ __publicField(MnemonicVault, "type", "mnemonic");
 
 // src/wallet-manager/vaults/privatekey-vault.ts
 import { Address as Address7 } from "@fuel-ts/address";
-import { ErrorCode as ErrorCode19, FuelError as FuelError20 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode20, FuelError as FuelError20 } from "@fuel-ts/errors";
 var _privateKeys;
 var PrivateKeyVault = class {
   /**
@@ -8217,7 +8295,7 @@ var PrivateKeyVault = class {
     );
     if (!privateKey) {
       throw new FuelError20(
-        ErrorCode19.WALLET_MANAGER_ERROR,
+        ErrorCode20.WALLET_MANAGER_ERROR,
         `No private key found for address '${address}'.`
       );
     }
@@ -8241,7 +8319,7 @@ var ERROR_MESSAGES = {
 };
 function assert(condition, message) {
   if (!condition) {
-    throw new FuelError21(ErrorCode20.WALLET_MANAGER_ERROR, message);
+    throw new FuelError21(ErrorCode21.WALLET_MANAGER_ERROR, message);
   }
 }
 var _vaults, _passphrase, _isLocked, _serializeVaults, serializeVaults_fn, _deserializeVaults, deserializeVaults_fn;
@@ -8467,25 +8545,25 @@ deserializeVaults_fn = function(vaults) {
 __publicField(WalletManager, "Vaults", [MnemonicVault, PrivateKeyVault]);
 
 // src/wallet-manager/types.ts
-import { ErrorCode as ErrorCode21, FuelError as FuelError22 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode22, FuelError as FuelError22 } from "@fuel-ts/errors";
 var Vault = class {
   constructor(_options) {
-    throw new FuelError22(ErrorCode21.NOT_IMPLEMENTED, "Not implemented.");
+    throw new FuelError22(ErrorCode22.NOT_IMPLEMENTED, "Not implemented.");
   }
   serialize() {
-    throw new FuelError22(ErrorCode21.NOT_IMPLEMENTED, "Not implemented.");
+    throw new FuelError22(ErrorCode22.NOT_IMPLEMENTED, "Not implemented.");
   }
   getAccounts() {
-    throw new FuelError22(ErrorCode21.NOT_IMPLEMENTED, "Not implemented.");
+    throw new FuelError22(ErrorCode22.NOT_IMPLEMENTED, "Not implemented.");
   }
   addAccount() {
-    throw new FuelError22(ErrorCode21.NOT_IMPLEMENTED, "Not implemented.");
+    throw new FuelError22(ErrorCode22.NOT_IMPLEMENTED, "Not implemented.");
   }
   exportAccount(_address) {
-    throw new FuelError22(ErrorCode21.NOT_IMPLEMENTED, "Not implemented.");
+    throw new FuelError22(ErrorCode22.NOT_IMPLEMENTED, "Not implemented.");
   }
   getWallet(_address) {
-    throw new FuelError22(ErrorCode21.NOT_IMPLEMENTED, "Not implemented.");
+    throw new FuelError22(ErrorCode22.NOT_IMPLEMENTED, "Not implemented.");
   }
 };
 __publicField(Vault, "type");
@@ -8502,7 +8580,7 @@ import {
 } from "@fuel-ts/abi-coder";
 import { Address as Address9 } from "@fuel-ts/address";
 import { BaseAssetId as BaseAssetId4 } from "@fuel-ts/address/configs";
-import { ErrorCode as ErrorCode22, FuelError as FuelError23 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode23, FuelError as FuelError23 } from "@fuel-ts/errors";
 import { ByteArrayCoder, InputType as InputType7 } from "@fuel-ts/transactions";
 import { arrayify as arrayify20, hexlify as hexlify19 } from "@fuel-ts/utils";
 
@@ -8522,27 +8600,37 @@ var getPredicateRoot = (bytecode) => {
 // src/predicate/predicate.ts
 var Predicate = class extends Account {
   bytes;
-  predicateData = Uint8Array.from([]);
-  predicateArgs = [];
+  predicateDataBytes = Uint8Array.from([]);
+  predicateData = [];
   interface;
   /**
    * Creates an instance of the Predicate class.
    *
-   * @param bytes - The bytes of the predicate.
+   * @param bytecode - The bytecode of the predicate.
+   * @param abi - The JSON ABI of the predicate.
    * @param provider - The provider used to interact with the blockchain.
-   * @param jsonAbi - The JSON ABI of the predicate.
+   * @param inputData - The predicate input data (optional).
    * @param configurableConstants - Optional configurable constants for the predicate.
    */
-  constructor(bytes, provider, jsonAbi, configurableConstants) {
+  constructor({
+    bytecode,
+    abi,
+    provider,
+    inputData,
+    configurableConstants
+  }) {
     const { predicateBytes, predicateInterface } = Predicate.processPredicateData(
-      bytes,
-      jsonAbi,
+      bytecode,
+      abi,
       configurableConstants
     );
     const address = Address9.fromB256(getPredicateRoot(predicateBytes));
     super(address, provider);
     this.bytes = predicateBytes;
     this.interface = predicateInterface;
+    if (inputData !== void 0 && inputData.length > 0) {
+      this.predicateData = inputData;
+    }
   }
   /**
    * Populates the transaction data with predicate data.
@@ -8594,18 +8682,8 @@ var Predicate = class extends Account {
     const transactionRequest = this.populateTransactionPredicateData(transactionRequestLike);
     return super.simulateTransaction(transactionRequest);
   }
-  /**
-   * Sets data for the predicate.
-   *
-   * @param args - Arguments for the predicate function.
-   * @returns The Predicate instance with updated predicate data.
-   */
-  setData(...args) {
-    this.predicateArgs = args;
-    return this;
-  }
   getPredicateData(policiesLength) {
-    if (!this.predicateArgs.length) {
+    if (!this.predicateData.length) {
       return new Uint8Array();
     }
     const mainFn = this.interface?.functions.main;
@@ -8614,7 +8692,7 @@ var Predicate = class extends Account {
       maxInputs: this.provider.getChain().consensusParameters.maxInputs.toNumber()
     });
     const OFFSET = VM_TX_MEMORY + SCRIPT_FIXED_SIZE + INPUT_COIN_FIXED_SIZE + WORD_SIZE + paddedCode.byteLength + policiesLength * WORD_SIZE;
-    return mainFn?.encodeArguments(this.predicateArgs, OFFSET) || new Uint8Array();
+    return mainFn?.encodeArguments(this.predicateData, OFFSET) || new Uint8Array();
   }
   /**
    * Processes the predicate data and returns the altered bytecode and interface.
@@ -8631,7 +8709,7 @@ var Predicate = class extends Account {
       abiInterface = new Interface3(jsonAbi);
       if (abiInterface.functions.main === void 0) {
         throw new FuelError23(
-          ErrorCode22.ABI_MAIN_METHOD_MISSING,
+          ErrorCode23.ABI_MAIN_METHOD_MISSING,
           'Cannot use ABI without "main" function.'
         );
       }
@@ -8677,7 +8755,7 @@ var Predicate = class extends Account {
       });
     } catch (err) {
       throw new FuelError23(
-        ErrorCode22.INVALID_CONFIGURABLE_CONSTANTS,
+        ErrorCode23.INVALID_CONFIGURABLE_CONSTANTS,
         `Error setting configurable constants: ${err.message}.`
       );
     }
@@ -8686,7 +8764,7 @@ var Predicate = class extends Account {
 };
 
 // src/connectors/fuel.ts
-import { ErrorCode as ErrorCode23, FuelError as FuelError24 } from "@fuel-ts/errors";
+import { ErrorCode as ErrorCode24, FuelError as FuelError24 } from "@fuel-ts/errors";
 
 // src/connectors/fuel-connector.ts
 import { EventEmitter as EventEmitter2 } from "events";
@@ -8825,6 +8903,18 @@ var FuelConnector = class extends EventEmitter2 {
   async signMessage(_address, _message) {
     throw new Error("Method not implemented.");
   }
+  /**
+   * Should start the sign transaction process and return
+   * the signed transaction.
+   *
+   * @param address - The address to sign the transaction
+   * @param transaction - The transaction to sign
+   *
+   * @returns Transaction signature
+   */
+  async signTransaction(_address, _transaction) {
+    throw new Error("Method not implemented.");
+  }
   /**
    * Should start the send transaction process and return
    * the transaction id submitted to the network.
@@ -9307,7 +9397,7 @@ var _Fuel = class extends FuelConnector {
       const currentNetwork = await this.currentNetwork();
       provider = await Provider.create(currentNetwork.url);
     } else {
-      throw new FuelError24(ErrorCode23.INVALID_PROVIDER, "Provider is not valid.");
+      throw new FuelError24(ErrorCode24.INVALID_PROVIDER, "Provider is not valid.");
     }
     return provider;
   }