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

package/dist/index.js

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,6 +27,32 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 
 // src/index.ts
 var src_exports = {};
@@ -144,7 +171,6 @@ __export(src_exports, {
   resolveGasDependentCosts: () => resolveGasDependentCosts,
   resolveIconPaths: () => resolveIconPaths,
   returnZeroScript: () => returnZeroScript,
-  sleep: () => sleep,
   transactionRequestify: () => transactionRequestify,
   urlJoin: () => urlJoin,
   withTimeout: () => withTimeout,
@@ -158,7 +184,7 @@ var import_configs11 = require("@fuel-ts/address/configs");
 var import_errors15 = require("@fuel-ts/errors");
 var import_interfaces = require("@fuel-ts/interfaces");
 var import_math17 = require("@fuel-ts/math");
-var import_utils27 = require("@fuel-ts/utils");
+var import_utils28 = require("@fuel-ts/utils");
 
 // src/providers/coin-quantity.ts
 var import_configs = require("@fuel-ts/address/configs");
@@ -201,9 +227,9 @@ var import_address3 = require("@fuel-ts/address");
 var import_errors13 = require("@fuel-ts/errors");
 var import_math14 = require("@fuel-ts/math");
 var import_transactions17 = require("@fuel-ts/transactions");
-var import_utils22 = require("@fuel-ts/utils");
+var import_utils23 = require("@fuel-ts/utils");
 var import_versions = require("@fuel-ts/versions");
-var import_utils23 = require("@noble/curves/abstract/utils");
+var import_utils24 = require("@noble/curves/abstract/utils");
 var import_ethers = require("ethers");
 var import_graphql_request = require("graphql-request");
 var import_ramda3 = require("ramda");
@@ -1016,12 +1042,11 @@ function getSdk(requester) {
 // src/providers/fuel-graphql-subscriber.ts
 var import_errors = require("@fuel-ts/errors");
 var import_graphql = require("graphql");
-var FuelGraphqlSubscriber = class _FuelGraphqlSubscriber {
+var _FuelGraphqlSubscriber = class {
   constructor(options) {
     this.options = options;
   }
   stream;
-  static textDecoder = new TextDecoder();
   async setStream() {
     const { url, query, variables, fetchFn } = this.options;
     const response = await fetchFn(`${url}-sub`, {
@@ -1081,6 +1106,8 @@ var FuelGraphqlSubscriber = class _FuelGraphqlSubscriber {
     return this;
   }
 };
+var FuelGraphqlSubscriber = _FuelGraphqlSubscriber;
+__publicField(FuelGraphqlSubscriber, "textDecoder", new TextDecoder());
 
 // src/providers/memory-cache.ts
 var import_errors2 = require("@fuel-ts/errors");
@@ -1661,15 +1688,6 @@ function normalizeJSON(root) {
   return normalize((0, import_ramda.clone)(root));
 }
 
-// src/providers/utils/sleep.ts
-function sleep(time) {
-  return new Promise((resolve) => {
-    setTimeout(() => {
-      resolve(true);
-    }, time);
-  });
-}
-
 // src/providers/transaction-request/errors.ts
 var ChangeOutputCollisionError = class extends Error {
   name = "ChangeOutputCollisionError";
@@ -1703,7 +1721,7 @@ var witnessify = (value) => {
 };
 
 // src/providers/transaction-request/transaction-request.ts
-var BaseTransactionRequest = class _BaseTransactionRequest {
+var BaseTransactionRequest = class {
   /** Gas price for transaction */
   gasPrice;
   /** Block until which tx cannot be included */
@@ -1773,7 +1791,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
     const inputs = this.inputs?.map(inputify) ?? [];
     const outputs = this.outputs?.map(outputify) ?? [];
     const witnesses = this.witnesses?.map(witnessify) ?? [];
-    const { policyTypes, policies } = _BaseTransactionRequest.getPolicyMeta(this);
+    const { policyTypes, policies } = BaseTransactionRequest.getPolicyMeta(this);
     return {
       policyTypes,
       inputs,
@@ -3358,7 +3376,7 @@ function assembleTransactionSummary(params) {
 }
 
 // src/providers/transaction-response/transaction-response.ts
-var TransactionResponse = class _TransactionResponse {
+var TransactionResponse = class {
   /** Transaction ID */
   id;
   /** Current provider */
@@ -3386,7 +3404,7 @@ var TransactionResponse = class _TransactionResponse {
    * @param provider - The provider.
    */
   static async create(id, provider) {
-    const response = new _TransactionResponse(id, provider);
+    const response = new TransactionResponse(id, provider);
     await response.fetch();
     return response;
   }
@@ -3527,6 +3545,7 @@ function getDecodedLogs(receipts, abiInterface) {
 }
 
 // src/providers/utils/auto-retry-fetch.ts
+var import_utils22 = require("@fuel-ts/utils");
 function getWaitDelay(options, retryAttemptNum) {
   const duration = options.baseDelay ?? 150;
   switch (options.backoff) {
@@ -3556,7 +3575,7 @@ function autoRetryFetch(fetchFn, options, retryAttemptNum = 0) {
         throw error;
       }
       const delay = getWaitDelay(options, retryNum);
-      await sleep(delay);
+      await (0, import_utils22.sleep)(delay);
       return autoRetryFetch(fetchFn, options, retryNum)(...args);
     }
   };
@@ -3614,7 +3633,8 @@ var processGqlChain = (chain) => {
     }
   };
 };
-var Provider = class _Provider {
+var _cacheInputs, cacheInputs_fn;
+var _Provider = class {
   /**
    * Constructor to initialize a Provider.
    *
@@ -3625,25 +3645,27 @@ var Provider = class _Provider {
    */
   constructor(url, options = {}) {
     this.url = url;
+    /**
+     * @hidden
+     */
+    __privateAdd(this, _cacheInputs);
+    __publicField(this, "operations");
+    __publicField(this, "cache");
+    __publicField(this, "options", {
+      timeout: void 0,
+      cacheUtxo: void 0,
+      fetch: void 0,
+      retryOptions: void 0
+    });
     this.options = { ...this.options, ...options };
     this.url = url;
     this.operations = this.createOperations();
     this.cache = options.cacheUtxo ? new MemoryCache(options.cacheUtxo) : void 0;
   }
-  operations;
-  cache;
   static clearChainAndNodeCaches() {
     _Provider.nodeInfoCache = {};
     _Provider.chainInfoCache = {};
   }
-  static chainInfoCache = {};
-  static nodeInfoCache = {};
-  options = {
-    timeout: void 0,
-    cacheUtxo: void 0,
-    fetch: void 0,
-    retryOptions: void 0
-  };
   static getFetchFn(options) {
     const { retryOptions, timeout } = options;
     return autoRetryFetch(async (...args) => {
@@ -3840,19 +3862,6 @@ var Provider = class _Provider {
     } = this.getChain();
     return chainId.toNumber();
   }
-  /**
-   * @hidden
-   */
-  #cacheInputs(inputs) {
-    if (!this.cache) {
-      return;
-    }
-    inputs.forEach((input) => {
-      if (input.type === import_transactions17.InputType.Coin) {
-        this.cache?.set(input.id);
-      }
-    });
-  }
   /**
    * Submits a transaction to the chain to be executed.
    *
@@ -3865,11 +3874,11 @@ var Provider = class _Provider {
   // #region Provider-sendTransaction
   async sendTransaction(transactionRequestLike, { estimateTxDependencies = true, awaitExecution = false } = {}) {
     const transactionRequest = transactionRequestify(transactionRequestLike);
-    this.#cacheInputs(transactionRequest.inputs);
+    __privateMethod(this, _cacheInputs, cacheInputs_fn).call(this, transactionRequest.inputs);
     if (estimateTxDependencies) {
       await this.estimateTxDependencies(transactionRequest);
     }
-    const encodedTransaction = (0, import_utils22.hexlify)(transactionRequest.toTransactionBytes());
+    const encodedTransaction = (0, import_utils23.hexlify)(transactionRequest.toTransactionBytes());
     if (awaitExecution) {
       const subscription = this.operations.submitAndAwait({ encodedTransaction });
       for await (const { submitAndAwait } of subscription) {
@@ -3908,7 +3917,7 @@ var Provider = class _Provider {
     if (estimateTxDependencies) {
       return this.estimateTxDependencies(transactionRequest);
     }
-    const encodedTransaction = (0, import_utils22.hexlify)(transactionRequest.toTransactionBytes());
+    const encodedTransaction = (0, import_utils23.hexlify)(transactionRequest.toTransactionBytes());
     const { dryRun: gqlReceipts } = await this.operations.dryRun({
       encodedTransaction,
       utxoValidation: utxoValidation || false
@@ -3927,13 +3936,13 @@ var Provider = class _Provider {
   async estimatePredicates(transactionRequest) {
     const shouldEstimatePredicates = Boolean(
       transactionRequest.inputs.find(
-        (input) => "predicate" in input && input.predicate && !(0, import_utils23.equalBytes)((0, import_utils22.arrayify)(input.predicate), (0, import_utils22.arrayify)("0x")) && new import_math14.BN(input.predicateGasUsed).isZero()
+        (input) => "predicate" in input && input.predicate && !(0, import_utils24.equalBytes)((0, import_utils23.arrayify)(input.predicate), (0, import_utils23.arrayify)("0x")) && new import_math14.BN(input.predicateGasUsed).isZero()
       )
     );
     if (!shouldEstimatePredicates) {
       return transactionRequest;
     }
-    const encodedTransaction = (0, import_utils22.hexlify)(transactionRequest.toTransactionBytes());
+    const encodedTransaction = (0, import_utils23.hexlify)(transactionRequest.toTransactionBytes());
     const response = await this.operations.estimatePredicates({
       encodedTransaction
     });
@@ -3976,7 +3985,7 @@ var Provider = class _Provider {
     let outputVariables = 0;
     for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
       const { dryRun: gqlReceipts } = await this.operations.dryRun({
-        encodedTransaction: (0, import_utils22.hexlify)(transactionRequest.toTransactionBytes()),
+        encodedTransaction: (0, import_utils23.hexlify)(transactionRequest.toTransactionBytes()),
         utxoValidation: false
       });
       receipts = gqlReceipts.map(processGqlReceipt);
@@ -4014,7 +4023,7 @@ var Provider = class _Provider {
     if (estimateTxDependencies) {
       return this.estimateTxDependencies(transactionRequest);
     }
-    const encodedTransaction = (0, import_utils22.hexlify)(transactionRequest.toTransactionBytes());
+    const encodedTransaction = (0, import_utils23.hexlify)(transactionRequest.toTransactionBytes());
     const { dryRun: gqlReceipts } = await this.operations.dryRun({
       encodedTransaction,
       utxoValidation: true
@@ -4124,7 +4133,7 @@ var Provider = class _Provider {
     const result = await this.operations.getCoins({
       first: 10,
       ...paginationArgs,
-      filter: { owner: ownerAddress.toB256(), assetId: assetId && (0, import_utils22.hexlify)(assetId) }
+      filter: { owner: ownerAddress.toB256(), assetId: assetId && (0, import_utils23.hexlify)(assetId) }
     });
     const coins = result.coins.edges.map((edge) => edge.node);
     return coins.map((coin) => ({
@@ -4148,19 +4157,19 @@ var Provider = class _Provider {
   async getResourcesToSpend(owner, quantities, excludedIds) {
     const ownerAddress = import_address3.Address.fromAddressOrString(owner);
     const excludeInput = {
-      messages: excludedIds?.messages?.map((nonce) => (0, import_utils22.hexlify)(nonce)) || [],
-      utxos: excludedIds?.utxos?.map((id) => (0, import_utils22.hexlify)(id)) || []
+      messages: excludedIds?.messages?.map((nonce) => (0, import_utils23.hexlify)(nonce)) || [],
+      utxos: excludedIds?.utxos?.map((id) => (0, import_utils23.hexlify)(id)) || []
     };
     if (this.cache) {
       const uniqueUtxos = new Set(
-        excludeInput.utxos.concat(this.cache?.getActiveData().map((id) => (0, import_utils22.hexlify)(id)))
+        excludeInput.utxos.concat(this.cache?.getActiveData().map((id) => (0, import_utils23.hexlify)(id)))
       );
       excludeInput.utxos = Array.from(uniqueUtxos);
     }
     const coinsQuery = {
       owner: ownerAddress.toB256(),
       queryPerAsset: quantities.map(coinQuantityfy).map(({ assetId, amount, max: maxPerAsset }) => ({
-        assetId: (0, import_utils22.hexlify)(assetId),
+        assetId: (0, import_utils23.hexlify)(assetId),
         amount: amount.toString(10),
         max: maxPerAsset ? maxPerAsset.toString(10) : void 0
       })),
@@ -4263,7 +4272,7 @@ var Provider = class _Provider {
       time: block.header.time,
       transactionIds: block.transactions.map((tx) => tx.id),
       transactions: block.transactions.map(
-        (tx) => new import_transactions17.TransactionCoder().decode((0, import_utils22.arrayify)(tx.rawPayload), 0)?.[0]
+        (tx) => new import_transactions17.TransactionCoder().decode((0, import_utils23.arrayify)(tx.rawPayload), 0)?.[0]
       )
     };
   }
@@ -4279,7 +4288,7 @@ var Provider = class _Provider {
       return null;
     }
     return new import_transactions17.TransactionCoder().decode(
-      (0, import_utils22.arrayify)(transaction.rawPayload),
+      (0, import_utils23.arrayify)(transaction.rawPayload),
       0
     )?.[0];
   }
@@ -4306,7 +4315,7 @@ var Provider = class _Provider {
   async getContractBalance(contractId, assetId) {
     const { contractBalance } = await this.operations.getContractBalance({
       contract: import_address3.Address.fromAddressOrString(contractId).toB256(),
-      asset: (0, import_utils22.hexlify)(assetId)
+      asset: (0, import_utils23.hexlify)(assetId)
     });
     return (0, import_math14.bn)(contractBalance.amount, 10);
   }
@@ -4320,7 +4329,7 @@ var Provider = class _Provider {
   async getBalance(owner, assetId) {
     const { balance } = await this.operations.getBalance({
       owner: import_address3.Address.fromAddressOrString(owner).toB256(),
-      assetId: (0, import_utils22.hexlify)(assetId)
+      assetId: (0, import_utils23.hexlify)(assetId)
     });
     return (0, import_math14.bn)(balance.amount, 10);
   }
@@ -4481,7 +4490,7 @@ var Provider = class _Provider {
   async produceBlocks(amount, startTime) {
     const { produceBlocks: latestBlockHeight } = await this.operations.produceBlocks({
       blocksToProduce: (0, import_math14.bn)(amount).toString(10),
-      startTimestamp: startTime ? import_utils22.DateTime.fromUnixMilliseconds(startTime).toTai64() : void 0
+      startTimestamp: startTime ? import_utils23.DateTime.fromUnixMilliseconds(startTime).toTai64() : void 0
     });
     return (0, import_math14.bn)(latestBlockHeight);
   }
@@ -4490,12 +4499,26 @@ var Provider = class _Provider {
     return new TransactionResponse(transactionId, this);
   }
 };
+var Provider = _Provider;
+_cacheInputs = new WeakSet();
+cacheInputs_fn = function(inputs) {
+  if (!this.cache) {
+    return;
+  }
+  inputs.forEach((input) => {
+    if (input.type === import_transactions17.InputType.Coin) {
+      this.cache?.set(input.id);
+    }
+  });
+};
+__publicField(Provider, "chainInfoCache", {});
+__publicField(Provider, "nodeInfoCache", {});
 
 // src/providers/transaction-summary/get-transaction-summary.ts
 var import_errors14 = require("@fuel-ts/errors");
 var import_math15 = require("@fuel-ts/math");
 var import_transactions18 = require("@fuel-ts/transactions");
-var import_utils25 = require("@fuel-ts/utils");
+var import_utils26 = require("@fuel-ts/utils");
 async function getTransactionSummary(params) {
   const { id, provider, abiMap } = params;
   const { transaction: gqlTransaction } = await provider.operations.getTransactionWithReceipts({
@@ -4508,7 +4531,7 @@ async function getTransactionSummary(params) {
     );
   }
   const [decodedTransaction] = new import_transactions18.TransactionCoder().decode(
-    (0, import_utils25.arrayify)(gqlTransaction.rawPayload),
+    (0, import_utils26.arrayify)(gqlTransaction.rawPayload),
     0
   );
   const receipts = gqlTransaction.receipts?.map(processGqlReceipt) || [];
@@ -4519,7 +4542,7 @@ async function getTransactionSummary(params) {
     id: gqlTransaction.id,
     receipts,
     transaction: decodedTransaction,
-    transactionBytes: (0, import_utils25.arrayify)(gqlTransaction.rawPayload),
+    transactionBytes: (0, import_utils26.arrayify)(gqlTransaction.rawPayload),
     gqlTransactionStatus: gqlTransaction.status,
     gasPerByte: (0, import_math15.bn)(gasPerByte),
     gasPriceFactor: (0, import_math15.bn)(gasPriceFactor),
@@ -4561,13 +4584,13 @@ async function getTransactionsSummaries(params) {
   const transactions = edges.map((edge) => {
     const { node: gqlTransaction } = edge;
     const { id, rawPayload, receipts: gqlReceipts, status } = gqlTransaction;
-    const [decodedTransaction] = new import_transactions18.TransactionCoder().decode((0, import_utils25.arrayify)(rawPayload), 0);
+    const [decodedTransaction] = new import_transactions18.TransactionCoder().decode((0, import_utils26.arrayify)(rawPayload), 0);
     const receipts = gqlReceipts?.map(processGqlReceipt) || [];
     const transactionSummary = assembleTransactionSummary({
       id,
       receipts,
       transaction: decodedTransaction,
-      transactionBytes: (0, import_utils25.arrayify)(rawPayload),
+      transactionBytes: (0, import_utils26.arrayify)(rawPayload),
       gqlTransactionStatus: status,
       abiMap,
       gasPerByte,
@@ -4711,16 +4734,16 @@ var assets = [
 // src/utils/formatTransferToContractScriptData.ts
 var import_abi_coder4 = require("@fuel-ts/abi-coder");
 var import_math16 = require("@fuel-ts/math");
-var import_utils26 = require("@fuel-ts/utils");
+var import_utils27 = require("@fuel-ts/utils");
 var asm = __toESM(require("@fuels/vm-asm"));
 var formatTransferToContractScriptData = (params) => {
   const { assetId, amountToTransfer, hexlifiedContractId } = params;
   const numberCoder = new import_abi_coder4.BigNumberCoder("u64");
   const encoded = numberCoder.encode(new import_math16.BN(amountToTransfer).toNumber());
   const scriptData = Uint8Array.from([
-    ...(0, import_utils26.arrayify)(hexlifiedContractId),
+    ...(0, import_utils27.arrayify)(hexlifiedContractId),
     ...encoded,
-    ...(0, import_utils26.arrayify)(assetId)
+    ...(0, import_utils27.arrayify)(assetId)
   ]);
   return scriptData;
 };
@@ -5060,14 +5083,14 @@ var Account = class extends import_interfaces.AbstractAccount {
   async withdrawToBaseLayer(recipient, amount, txParams = {}) {
     const { minGasPrice } = this.provider.getGasConfig();
     const recipientAddress = import_address4.Address.fromAddressOrString(recipient);
-    const recipientDataArray = (0, import_utils27.arrayify)(
+    const recipientDataArray = (0, import_utils28.arrayify)(
       "0x".concat(recipientAddress.toHexString().substring(2).padStart(64, "0"))
     );
-    const amountDataArray = (0, import_utils27.arrayify)(
+    const amountDataArray = (0, import_utils28.arrayify)(
       "0x".concat((0, import_math17.bn)(amount).toHex().substring(2).padStart(16, "0"))
     );
     const script = new Uint8Array([
-      ...(0, import_utils27.arrayify)(withdrawScript.bytes),
+      ...(0, import_utils28.arrayify)(withdrawScript.bytes),
       ...recipientDataArray,
       ...amountDataArray
     ]);
@@ -5151,16 +5174,16 @@ var Account = class extends import_interfaces.AbstractAccount {
 
 // src/wallet/base-wallet-unlocked.ts
 var import_hasher3 = require("@fuel-ts/hasher");
-var import_utils30 = require("@fuel-ts/utils");
+var import_utils31 = require("@fuel-ts/utils");
 
 // src/signer/signer.ts
 var import_address5 = require("@fuel-ts/address");
 var import_crypto = require("@fuel-ts/crypto");
 var import_hasher2 = require("@fuel-ts/hasher");
 var import_math18 = require("@fuel-ts/math");
-var import_utils28 = require("@fuel-ts/utils");
+var import_utils29 = require("@fuel-ts/utils");
 var import_secp256k1 = require("@noble/curves/secp256k1");
-var Signer = class _Signer {
+var Signer = class {
   address;
   publicKey;
   compressedPublicKey;
@@ -5178,9 +5201,9 @@ var Signer = class _Signer {
       }
     }
     const privateKeyBytes = (0, import_math18.toBytes)(privateKey, 32);
-    this.privateKey = (0, import_utils28.hexlify)(privateKeyBytes);
-    this.publicKey = (0, import_utils28.hexlify)(import_secp256k1.secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
-    this.compressedPublicKey = (0, import_utils28.hexlify)(import_secp256k1.secp256k1.getPublicKey(privateKeyBytes, true));
+    this.privateKey = (0, import_utils29.hexlify)(privateKeyBytes);
+    this.publicKey = (0, import_utils29.hexlify)(import_secp256k1.secp256k1.getPublicKey(privateKeyBytes, false).slice(1));
+    this.compressedPublicKey = (0, import_utils29.hexlify)(import_secp256k1.secp256k1.getPublicKey(privateKeyBytes, true));
     this.address = import_address5.Address.fromPublicKey(this.publicKey);
   }
   /**
@@ -5194,11 +5217,11 @@ var Signer = class _Signer {
    * @returns hashed signature
    */
   sign(data) {
-    const signature = import_secp256k1.secp256k1.sign((0, import_utils28.arrayify)(data), (0, import_utils28.arrayify)(this.privateKey));
+    const signature = import_secp256k1.secp256k1.sign((0, import_utils29.arrayify)(data), (0, import_utils29.arrayify)(this.privateKey));
     const r = (0, import_math18.toBytes)(`0x${signature.r.toString(16)}`, 32);
     const s = (0, import_math18.toBytes)(`0x${signature.s.toString(16)}`, 32);
     s[0] |= (signature.recovery || 0) << 7;
-    return (0, import_utils28.hexlify)((0, import_utils28.concat)([r, s]));
+    return (0, import_utils29.hexlify)((0, import_utils29.concat)([r, s]));
   }
   /**
    * Add point on the current elliptic curve
@@ -5207,8 +5230,8 @@ var Signer = class _Signer {
    * @returns compressed point on the curve
    */
   addPoint(point) {
-    const p0 = import_secp256k1.secp256k1.ProjectivePoint.fromHex((0, import_utils28.arrayify)(this.compressedPublicKey));
-    const p1 = import_secp256k1.secp256k1.ProjectivePoint.fromHex((0, import_utils28.arrayify)(point));
+    const p0 = import_secp256k1.secp256k1.ProjectivePoint.fromHex((0, import_utils29.arrayify)(this.compressedPublicKey));
+    const p1 = import_secp256k1.secp256k1.ProjectivePoint.fromHex((0, import_utils29.arrayify)(point));
     const result = p0.add(p1);
     return `0x${result.toHex(true)}`;
   }
@@ -5220,16 +5243,16 @@ var Signer = class _Signer {
    * @returns public key from signature from the
    */
   static recoverPublicKey(data, signature) {
-    const signedMessageBytes = (0, import_utils28.arrayify)(signature);
+    const signedMessageBytes = (0, import_utils29.arrayify)(signature);
     const r = signedMessageBytes.slice(0, 32);
     const s = signedMessageBytes.slice(32, 64);
     const recoveryParam = (s[0] & 128) >> 7;
     s[0] &= 127;
-    const sig = new import_secp256k1.secp256k1.Signature(BigInt((0, import_utils28.hexlify)(r)), BigInt((0, import_utils28.hexlify)(s))).addRecoveryBit(
+    const sig = new import_secp256k1.secp256k1.Signature(BigInt((0, import_utils29.hexlify)(r)), BigInt((0, import_utils29.hexlify)(s))).addRecoveryBit(
       recoveryParam
     );
-    const publicKey = sig.recoverPublicKey((0, import_utils28.arrayify)(data)).toRawBytes(false).slice(1);
-    return (0, import_utils28.hexlify)(publicKey);
+    const publicKey = sig.recoverPublicKey((0, import_utils29.arrayify)(data)).toRawBytes(false).slice(1);
+    return (0, import_utils29.hexlify)(publicKey);
   }
   /**
    * Recover the address from a signature performed with [`sign`](#sign).
@@ -5239,7 +5262,7 @@ var Signer = class _Signer {
    * @returns Address from signature
    */
   static recoverAddress(data, signature) {
-    return import_address5.Address.fromPublicKey(_Signer.recoverPublicKey(data, signature));
+    return import_address5.Address.fromPublicKey(Signer.recoverPublicKey(data, signature));
   }
   /**
    * Generate a random privateKey
@@ -5248,7 +5271,7 @@ var Signer = class _Signer {
    * @returns random 32-byte hashed
    */
   static generatePrivateKey(entropy) {
-    return entropy ? (0, import_hasher2.hash)((0, import_utils28.concat)([(0, import_crypto.randomBytes)(32), (0, import_utils28.arrayify)(entropy)])) : (0, import_crypto.randomBytes)(32);
+    return entropy ? (0, import_hasher2.hash)((0, import_utils29.concat)([(0, import_crypto.randomBytes)(32), (0, import_utils29.arrayify)(entropy)])) : (0, import_crypto.randomBytes)(32);
   }
   /**
    * Extended publicKey from a compact publicKey
@@ -5257,8 +5280,8 @@ var Signer = class _Signer {
    * @returns extended publicKey
    */
   static extendPublicKey(publicKey) {
-    const point = import_secp256k1.secp256k1.ProjectivePoint.fromHex((0, import_utils28.arrayify)(publicKey));
-    return (0, import_utils28.hexlify)(point.toRawBytes(false).slice(1));
+    const point = import_secp256k1.secp256k1.ProjectivePoint.fromHex((0, import_utils29.arrayify)(publicKey));
+    return (0, import_utils29.hexlify)(point.toRawBytes(false).slice(1));
   }
 };
 
@@ -5266,7 +5289,7 @@ var Signer = class _Signer {
 var import_address6 = require("@fuel-ts/address");
 var import_crypto2 = require("@fuel-ts/crypto");
 var import_errors16 = require("@fuel-ts/errors");
-var import_utils29 = require("@fuel-ts/utils");
+var import_utils30 = require("@fuel-ts/utils");
 var import_uuid = require("uuid");
 var DEFAULT_KDF_PARAMS_LOG_N = 13;
 var DEFAULT_KDF_PARAMS_R = 8;
@@ -5349,16 +5372,12 @@ async function decryptKeystoreWallet(jsonWallet, password) {
     );
   }
   const buffer = await (0, import_crypto2.decryptJsonWalletData)(ciphertextBuffer, key, ivBuffer);
-  const privateKey = (0, import_utils29.hexlify)(buffer);
+  const privateKey = (0, import_utils30.hexlify)(buffer);
   return privateKey;
 }
 
 // src/wallet/base-wallet-unlocked.ts
 var BaseWalletUnlocked = class extends Account {
-  /**
-   * Default HDWallet path.
-   */
-  static defaultPath = "m/44'/1179993420'/0'/0/0";
   /**
    * A function that returns the wallet's signer.
    */
@@ -5398,7 +5417,7 @@ var BaseWalletUnlocked = class extends Account {
    */
   async signMessage(message) {
     const signedMessage = await this.signer().sign((0, import_hasher3.hashMessage)(message));
-    return (0, import_utils30.hexlify)(signedMessage);
+    return (0, import_utils31.hexlify)(signedMessage);
   }
   /**
    * Signs a transaction with the wallet's private key.
@@ -5411,7 +5430,7 @@ var BaseWalletUnlocked = class extends Account {
     const chainId = this.provider.getChain().consensusParameters.chainId.toNumber();
     const hashedTransaction = transactionRequest.getTransactionId(chainId);
     const signature = await this.signer().sign(hashedTransaction);
-    return (0, import_utils30.hexlify)(signature);
+    return (0, import_utils31.hexlify)(signature);
   }
   /**
    * Populates a transaction with the witnesses signature.
@@ -5464,19 +5483,23 @@ var BaseWalletUnlocked = class extends Account {
     return encryptKeystoreWallet(this.privateKey, this.address, password);
   }
 };
+/**
+ * Default HDWallet path.
+ */
+__publicField(BaseWalletUnlocked, "defaultPath", "m/44'/1179993420'/0'/0/0");
 
 // src/hdwallet/hdwallet.ts
 var import_errors19 = require("@fuel-ts/errors");
 var import_hasher6 = require("@fuel-ts/hasher");
 var import_math19 = require("@fuel-ts/math");
-var import_utils34 = require("@fuel-ts/utils");
+var import_utils35 = require("@fuel-ts/utils");
 var import_ethers3 = require("ethers");
 
 // src/mnemonic/mnemonic.ts
 var import_crypto3 = require("@fuel-ts/crypto");
 var import_errors18 = require("@fuel-ts/errors");
 var import_hasher5 = require("@fuel-ts/hasher");
-var import_utils32 = require("@fuel-ts/utils");
+var import_utils33 = require("@fuel-ts/utils");
 var import_ethers2 = require("ethers");
 
 // src/wordlists/words/english.ts
@@ -7540,7 +7563,7 @@ var Language = /* @__PURE__ */ ((Language2) => {
 // src/mnemonic/utils.ts
 var import_errors17 = require("@fuel-ts/errors");
 var import_hasher4 = require("@fuel-ts/hasher");
-var import_utils31 = require("@fuel-ts/utils");
+var import_utils32 = require("@fuel-ts/utils");
 function toUtf8Bytes(stri) {
   const str = stri.normalize("NFKD");
   const result = [];
@@ -7607,14 +7630,14 @@ function entropyToMnemonicIndices(entropy) {
     }
   }
   const checksumBits = entropy.length / 4;
-  const checksum = (0, import_utils31.arrayify)((0, import_hasher4.sha256)(entropy))[0] & getUpperMask(checksumBits);
+  const checksum = (0, import_utils32.arrayify)((0, import_hasher4.sha256)(entropy))[0] & getUpperMask(checksumBits);
   indices[indices.length - 1] <<= checksumBits;
   indices[indices.length - 1] |= checksum >> 8 - checksumBits;
   return indices;
 }
 function mnemonicWordsToEntropy(words, wordlist) {
   const size = Math.ceil(11 * words.length / 8);
-  const entropy = (0, import_utils31.arrayify)(new Uint8Array(size));
+  const entropy = (0, import_utils32.arrayify)(new Uint8Array(size));
   let offset = 0;
   for (let i = 0; i < words.length; i += 1) {
     const index = wordlist.indexOf(words[i].normalize("NFKD"));
@@ -7634,7 +7657,7 @@ function mnemonicWordsToEntropy(words, wordlist) {
   const entropyBits = 32 * words.length / 3;
   const checksumBits = words.length / 3;
   const checksumMask = getUpperMask(checksumBits);
-  const checksum = (0, import_utils31.arrayify)((0, import_hasher4.sha256)(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
+  const checksum = (0, import_utils32.arrayify)((0, import_hasher4.sha256)(entropy.slice(0, entropyBits / 8)))[0] & checksumMask;
   if (checksum !== (entropy[entropy.length - 1] & checksumMask)) {
     throw new import_errors17.FuelError(
       import_errors17.ErrorCode.INVALID_CHECKSUM,
@@ -7673,7 +7696,7 @@ function assertMnemonic(words) {
     throw new import_errors18.FuelError(import_errors18.ErrorCode.INVALID_MNEMONIC, errorMsg);
   }
 }
-var Mnemonic = class _Mnemonic {
+var Mnemonic = class {
   wordlist;
   /**
    *
@@ -7690,7 +7713,7 @@ var Mnemonic = class _Mnemonic {
    * @returns Entropy hash
    */
   mnemonicToEntropy(phrase) {
-    return _Mnemonic.mnemonicToEntropy(phrase, this.wordlist);
+    return Mnemonic.mnemonicToEntropy(phrase, this.wordlist);
   }
   /**
    *
@@ -7698,7 +7721,7 @@ var Mnemonic = class _Mnemonic {
    * @returns Mnemonic phrase
    */
   entropyToMnemonic(entropy) {
-    return _Mnemonic.entropyToMnemonic(entropy, this.wordlist);
+    return Mnemonic.entropyToMnemonic(entropy, this.wordlist);
   }
   /**
    *
@@ -7709,7 +7732,7 @@ var Mnemonic = class _Mnemonic {
   static mnemonicToEntropy(phrase, wordlist = english) {
     const words = getWords(phrase);
     assertMnemonic(words);
-    return (0, import_utils32.hexlify)(mnemonicWordsToEntropy(words, wordlist));
+    return (0, import_utils33.hexlify)(mnemonicWordsToEntropy(words, wordlist));
   }
   /**
    * @param entropy - Entropy source to the mnemonic phrase.
@@ -7717,7 +7740,7 @@ var Mnemonic = class _Mnemonic {
    * @returns 64-byte array contains privateKey and chainCode as described on BIP39
    */
   static entropyToMnemonic(entropy, wordlist = english) {
-    const entropyBytes = (0, import_utils32.arrayify)(entropy);
+    const entropyBytes = (0, import_utils33.arrayify)(entropy);
     assertWordList(wordlist);
     assertEntropy(entropyBytes);
     return entropyToMnemonicIndices(entropyBytes).map((i) => wordlist[i]).join(" ");
@@ -7739,8 +7762,8 @@ var Mnemonic = class _Mnemonic {
    * @returns 64-byte array contains privateKey and chainCode as described on BIP39
    */
   static mnemonicToMasterKeys(phrase, passphrase = "") {
-    const seed = _Mnemonic.mnemonicToSeed(phrase, passphrase);
-    return _Mnemonic.masterKeysFromSeed(seed);
+    const seed = Mnemonic.mnemonicToSeed(phrase, passphrase);
+    return Mnemonic.masterKeysFromSeed(seed);
   }
   /**
    * Validates if given mnemonic is  valid
@@ -7756,7 +7779,7 @@ var Mnemonic = class _Mnemonic {
       return false;
     }
     while (i < words.length) {
-      if (_Mnemonic.binarySearch(words[i]) === false) {
+      if (Mnemonic.binarySearch(words[i]) === false) {
         return false;
       }
       i += 1;
@@ -7786,14 +7809,14 @@ var Mnemonic = class _Mnemonic {
    * @returns 64-byte array contains privateKey and chainCode as described on BIP39
    */
   static masterKeysFromSeed(seed) {
-    const seedArray = (0, import_utils32.arrayify)(seed);
+    const seedArray = (0, import_utils33.arrayify)(seed);
     if (seedArray.length < 16 || seedArray.length > 64) {
       throw new import_errors18.FuelError(
         import_errors18.ErrorCode.INVALID_SEED,
         `Seed length should be between 16 and 64 bytes, but received ${seedArray.length} bytes.`
       );
     }
-    return (0, import_utils32.arrayify)((0, import_ethers2.computeHmac)("sha512", MasterSecret, seedArray));
+    return (0, import_utils33.arrayify)((0, import_ethers2.computeHmac)("sha512", MasterSecret, seedArray));
   }
   /**
    * Get the extendKey as defined on BIP-32 from the provided seed
@@ -7803,23 +7826,23 @@ var Mnemonic = class _Mnemonic {
    * @returns BIP-32 extended private key
    */
   static seedToExtendedKey(seed, testnet = false) {
-    const masterKey = _Mnemonic.masterKeysFromSeed(seed);
-    const prefix = (0, import_utils32.arrayify)(testnet ? TestnetPRV : MainnetPRV);
+    const masterKey = Mnemonic.masterKeysFromSeed(seed);
+    const prefix = (0, import_utils33.arrayify)(testnet ? TestnetPRV : MainnetPRV);
     const depth = "0x00";
     const fingerprint = "0x00000000";
     const index = "0x00000000";
     const chainCode = masterKey.slice(32);
     const privateKey = masterKey.slice(0, 32);
-    const extendedKey = (0, import_utils32.concat)([
+    const extendedKey = (0, import_utils33.concat)([
       prefix,
       depth,
       fingerprint,
       index,
       chainCode,
-      (0, import_utils32.concat)(["0x00", privateKey])
+      (0, import_utils33.concat)(["0x00", privateKey])
     ]);
     const checksum = (0, import_ethers2.dataSlice)((0, import_hasher5.sha256)((0, import_hasher5.sha256)(extendedKey)), 0, 4);
-    return (0, import_ethers2.encodeBase58)((0, import_utils32.concat)([extendedKey, checksum]));
+    return (0, import_ethers2.encodeBase58)((0, import_utils33.concat)([extendedKey, checksum]));
   }
   /**
    *  Create a new mnemonic using a randomly generated number as entropy.
@@ -7834,20 +7857,20 @@ var Mnemonic = class _Mnemonic {
    * @returns A randomly generated mnemonic
    */
   static generate(size = 32, extraEntropy = "") {
-    const entropy = extraEntropy ? (0, import_hasher5.sha256)((0, import_utils32.concat)([(0, import_crypto3.randomBytes)(size), (0, import_utils32.arrayify)(extraEntropy)])) : (0, import_crypto3.randomBytes)(size);
-    return _Mnemonic.entropyToMnemonic(entropy);
+    const entropy = extraEntropy ? (0, import_hasher5.sha256)((0, import_utils33.concat)([(0, import_crypto3.randomBytes)(size), (0, import_utils33.arrayify)(extraEntropy)])) : (0, import_crypto3.randomBytes)(size);
+    return Mnemonic.entropyToMnemonic(entropy);
   }
 };
 var mnemonic_default = Mnemonic;
 
 // src/hdwallet/hdwallet.ts
 var HARDENED_INDEX = 2147483648;
-var MainnetPRV2 = (0, import_utils34.hexlify)("0x0488ade4");
-var MainnetPUB = (0, import_utils34.hexlify)("0x0488b21e");
-var TestnetPRV2 = (0, import_utils34.hexlify)("0x04358394");
-var TestnetPUB = (0, import_utils34.hexlify)("0x043587cf");
+var MainnetPRV2 = (0, import_utils35.hexlify)("0x0488ade4");
+var MainnetPUB = (0, import_utils35.hexlify)("0x0488b21e");
+var TestnetPRV2 = (0, import_utils35.hexlify)("0x04358394");
+var TestnetPUB = (0, import_utils35.hexlify)("0x043587cf");
 function base58check(data) {
-  return (0, import_ethers3.encodeBase58)((0, import_utils34.concat)([data, (0, import_ethers3.dataSlice)((0, import_hasher6.sha256)((0, import_hasher6.sha256)(data)), 0, 4)]));
+  return (0, import_ethers3.encodeBase58)((0, import_utils35.concat)([data, (0, import_ethers3.dataSlice)((0, import_hasher6.sha256)((0, import_hasher6.sha256)(data)), 0, 4)]));
 }
 function getExtendedKeyPrefix(isPublic = false, testnet = false) {
   if (isPublic) {
@@ -7856,11 +7879,11 @@ function getExtendedKeyPrefix(isPublic = false, testnet = false) {
   return testnet ? TestnetPRV2 : MainnetPRV2;
 }
 function isPublicExtendedKey(extendedKey) {
-  return [MainnetPUB, TestnetPUB].includes((0, import_utils34.hexlify)(extendedKey.slice(0, 4)));
+  return [MainnetPUB, TestnetPUB].includes((0, import_utils35.hexlify)(extendedKey.slice(0, 4)));
 }
 function isValidExtendedKey(extendedKey) {
   return [MainnetPRV2, TestnetPRV2, MainnetPUB, TestnetPUB].includes(
-    (0, import_utils34.hexlify)(extendedKey.slice(0, 4))
+    (0, import_utils35.hexlify)(extendedKey.slice(0, 4))
   );
 }
 function parsePath(path, depth = 0) {
@@ -7875,11 +7898,11 @@ function parsePath(path, depth = 0) {
     (p) => ~p.indexOf(`'`) ? parseInt(p, 10) + HARDENED_INDEX : parseInt(p, 10)
   );
 }
-var HDWallet = class _HDWallet {
+var HDWallet = class {
   depth = 0;
   index = 0;
-  fingerprint = (0, import_utils34.hexlify)("0x00000000");
-  parentFingerprint = (0, import_utils34.hexlify)("0x00000000");
+  fingerprint = (0, import_utils35.hexlify)("0x00000000");
+  parentFingerprint = (0, import_utils35.hexlify)("0x00000000");
   privateKey;
   publicKey;
   chainCode;
@@ -7891,8 +7914,8 @@ var HDWallet = class _HDWallet {
   constructor(config) {
     if (config.privateKey) {
       const signer = new Signer(config.privateKey);
-      this.publicKey = (0, import_utils34.hexlify)(signer.compressedPublicKey);
-      this.privateKey = (0, import_utils34.hexlify)(config.privateKey);
+      this.publicKey = (0, import_utils35.hexlify)(signer.compressedPublicKey);
+      this.privateKey = (0, import_utils35.hexlify)(config.privateKey);
     } else {
       if (!config.publicKey) {
         throw new import_errors19.FuelError(
@@ -7900,7 +7923,7 @@ var HDWallet = class _HDWallet {
           "Both public and private Key cannot be missing. At least one should be provided."
         );
       }
-      this.publicKey = (0, import_utils34.hexlify)(config.publicKey);
+      this.publicKey = (0, import_utils35.hexlify)(config.publicKey);
     }
     this.parentFingerprint = config.parentFingerprint || this.parentFingerprint;
     this.fingerprint = (0, import_ethers3.dataSlice)((0, import_ethers3.ripemd160)((0, import_hasher6.sha256)(this.publicKey)), 0, 4);
@@ -7919,9 +7942,9 @@ var HDWallet = class _HDWallet {
    * @returns A new instance of HDWallet on the derived index
    */
   deriveIndex(index) {
-    const privateKey = this.privateKey && (0, import_utils34.arrayify)(this.privateKey);
-    const publicKey = (0, import_utils34.arrayify)(this.publicKey);
-    const chainCode = (0, import_utils34.arrayify)(this.chainCode);
+    const privateKey = this.privateKey && (0, import_utils35.arrayify)(this.privateKey);
+    const publicKey = (0, import_utils35.arrayify)(this.publicKey);
+    const chainCode = (0, import_utils35.arrayify)(this.chainCode);
     const data = new Uint8Array(37);
     if (index & HARDENED_INDEX) {
       if (!privateKey) {
@@ -7932,16 +7955,16 @@ var HDWallet = class _HDWallet {
       }
       data.set(privateKey, 1);
     } else {
-      data.set((0, import_utils34.arrayify)(this.publicKey));
+      data.set((0, import_utils35.arrayify)(this.publicKey));
     }
     data.set((0, import_math19.toBytes)(index, 4), 33);
-    const bytes = (0, import_utils34.arrayify)((0, import_ethers3.computeHmac)("sha512", chainCode, data));
+    const bytes = (0, import_utils35.arrayify)((0, import_ethers3.computeHmac)("sha512", chainCode, data));
     const IL = bytes.slice(0, 32);
     const IR = bytes.slice(32);
     if (privateKey) {
       const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
       const ki = (0, import_math19.bn)(IL).add(privateKey).mod(N).toBytes(32);
-      return new _HDWallet({
+      return new HDWallet({
         privateKey: ki,
         chainCode: IR,
         index,
@@ -7949,9 +7972,9 @@ var HDWallet = class _HDWallet {
         parentFingerprint: this.fingerprint
       });
     }
-    const signer = new Signer((0, import_utils34.hexlify)(IL));
+    const signer = new Signer((0, import_utils35.hexlify)(IL));
     const Ki = signer.addPoint(publicKey);
-    return new _HDWallet({
+    return new HDWallet({
       publicKey: Ki,
       chainCode: IR,
       index,
@@ -7984,12 +8007,12 @@ var HDWallet = class _HDWallet {
       );
     }
     const prefix = getExtendedKeyPrefix(this.privateKey == null || isPublic, testnet);
-    const depth = (0, import_utils34.hexlify)(Uint8Array.from([this.depth]));
+    const depth = (0, import_utils35.hexlify)(Uint8Array.from([this.depth]));
     const parentFingerprint = this.parentFingerprint;
     const index = (0, import_math19.toHex)(this.index, 4);
     const chainCode = this.chainCode;
-    const key = this.privateKey != null && !isPublic ? (0, import_utils34.concat)(["0x00", this.privateKey]) : this.publicKey;
-    const extendedKey = (0, import_utils34.arrayify)((0, import_utils34.concat)([prefix, depth, parentFingerprint, index, chainCode, key]));
+    const key = this.privateKey != null && !isPublic ? (0, import_utils35.concat)(["0x00", this.privateKey]) : this.publicKey;
+    const extendedKey = (0, import_utils35.arrayify)((0, import_utils35.concat)([prefix, depth, parentFingerprint, index, chainCode, key]));
     return base58check(extendedKey);
   }
   /**
@@ -8000,14 +8023,14 @@ var HDWallet = class _HDWallet {
    */
   static fromSeed(seed) {
     const masterKey = mnemonic_default.masterKeysFromSeed(seed);
-    return new _HDWallet({
-      chainCode: (0, import_utils34.arrayify)(masterKey.slice(32)),
-      privateKey: (0, import_utils34.arrayify)(masterKey.slice(0, 32))
+    return new HDWallet({
+      chainCode: (0, import_utils35.arrayify)(masterKey.slice(32)),
+      privateKey: (0, import_utils35.arrayify)(masterKey.slice(0, 32))
     });
   }
   static fromExtendedKey(extendedKey) {
     const decoded = (0, import_ethers3.toBeHex)((0, import_ethers3.decodeBase58)(extendedKey));
-    const bytes = (0, import_utils34.arrayify)(decoded);
+    const bytes = (0, import_utils35.arrayify)(decoded);
     const validChecksum = base58check(bytes.slice(0, 78)) === extendedKey;
     if (bytes.length !== 82 || !isValidExtendedKey(bytes)) {
       throw new import_errors19.FuelError(import_errors19.ErrorCode.HD_WALLET_ERROR, "Provided key is not a valid extended key.");
@@ -8016,9 +8039,9 @@ var HDWallet = class _HDWallet {
       throw new import_errors19.FuelError(import_errors19.ErrorCode.HD_WALLET_ERROR, "Provided key has an invalid checksum.");
     }
     const depth = bytes[4];
-    const parentFingerprint = (0, import_utils34.hexlify)(bytes.slice(5, 9));
-    const index = parseInt((0, import_utils34.hexlify)(bytes.slice(9, 13)).substring(2), 16);
-    const chainCode = (0, import_utils34.hexlify)(bytes.slice(13, 45));
+    const parentFingerprint = (0, import_utils35.hexlify)(bytes.slice(5, 9));
+    const index = parseInt((0, import_utils35.hexlify)(bytes.slice(9, 13)).substring(2), 16);
+    const chainCode = (0, import_utils35.hexlify)(bytes.slice(13, 45));
     const key = bytes.slice(45, 78);
     if (depth === 0 && parentFingerprint !== "0x00000000" || depth === 0 && index !== 0) {
       throw new import_errors19.FuelError(
@@ -8030,7 +8053,7 @@ var HDWallet = class _HDWallet {
       if (key[0] !== 3) {
         throw new import_errors19.FuelError(import_errors19.ErrorCode.HD_WALLET_ERROR, "Invalid public extended key.");
       }
-      return new _HDWallet({
+      return new HDWallet({
         publicKey: key,
         chainCode,
         index,
@@ -8041,7 +8064,7 @@ var HDWallet = class _HDWallet {
     if (key[0] !== 0) {
       throw new import_errors19.FuelError(import_errors19.ErrorCode.HD_WALLET_ERROR, "Invalid private extended key.");
     }
-    return new _HDWallet({
+    return new HDWallet({
       privateKey: key.slice(1),
       chainCode,
       index,
@@ -8064,7 +8087,7 @@ var WalletLocked = class extends Account {
     return new WalletUnlocked(privateKey, this._provider);
   }
 };
-var WalletUnlocked = class _WalletUnlocked extends BaseWalletUnlocked {
+var WalletUnlocked = class extends BaseWalletUnlocked {
   /**
    * Locks the wallet and returns an instance of WalletLocked.
    *
@@ -8082,7 +8105,7 @@ var WalletUnlocked = class _WalletUnlocked extends BaseWalletUnlocked {
    */
   static generate(generateOptions) {
     const privateKey = Signer.generatePrivateKey(generateOptions?.entropy);
-    return new _WalletUnlocked(privateKey, generateOptions?.provider);
+    return new WalletUnlocked(privateKey, generateOptions?.provider);
   }
   /**
    * Create a Wallet Unlocked from a seed.
@@ -8094,8 +8117,8 @@ var WalletUnlocked = class _WalletUnlocked extends BaseWalletUnlocked {
    */
   static fromSeed(seed, path, provider) {
     const hdWallet = hdwallet_default.fromSeed(seed);
-    const childWallet = hdWallet.derivePath(path || _WalletUnlocked.defaultPath);
-    return new _WalletUnlocked(childWallet.privateKey, provider);
+    const childWallet = hdWallet.derivePath(path || WalletUnlocked.defaultPath);
+    return new WalletUnlocked(childWallet.privateKey, provider);
   }
   /**
    * Create a Wallet Unlocked from a mnemonic phrase.
@@ -8109,8 +8132,8 @@ var WalletUnlocked = class _WalletUnlocked extends BaseWalletUnlocked {
   static fromMnemonic(mnemonic, path, passphrase, provider) {
     const seed = mnemonic_default.mnemonicToSeed(mnemonic, passphrase);
     const hdWallet = hdwallet_default.fromSeed(seed);
-    const childWallet = hdWallet.derivePath(path || _WalletUnlocked.defaultPath);
-    return new _WalletUnlocked(childWallet.privateKey, provider);
+    const childWallet = hdWallet.derivePath(path || WalletUnlocked.defaultPath);
+    return new WalletUnlocked(childWallet.privateKey, provider);
   }
   /**
    * Create a Wallet Unlocked from an extended key.
@@ -8121,7 +8144,7 @@ var WalletUnlocked = class _WalletUnlocked extends BaseWalletUnlocked {
    */
   static fromExtendedKey(extendedKey, provider) {
     const hdWallet = hdwallet_default.fromExtendedKey(extendedKey);
-    return new _WalletUnlocked(hdWallet.privateKey, provider);
+    return new WalletUnlocked(hdWallet.privateKey, provider);
   }
   /**
    * Create a Wallet Unlocked from an encrypted JSON.
@@ -8133,7 +8156,7 @@ var WalletUnlocked = class _WalletUnlocked extends BaseWalletUnlocked {
    */
   static async fromEncryptedJson(jsonWallet, password, provider) {
     const privateKey = await decryptKeystoreWallet(jsonWallet, password);
-    return new _WalletUnlocked(privateKey, provider);
+    return new WalletUnlocked(privateKey, provider);
   }
 };
 
@@ -8159,50 +8182,50 @@ var Wallet = class {
   static fromPrivateKey(privateKey, provider) {
     return new WalletUnlocked(privateKey, provider);
   }
-  /**
-   * Generate a new Wallet Unlocked with a random key pair.
-   *
-   * @param generateOptions - Options to customize the generation process (optional).
-   * @returns An unlocked wallet instance.
-   */
-  static generate = WalletUnlocked.generate;
-  /**
-   * Create a Wallet Unlocked from a seed.
-   *
-   * @param seed - The seed phrase.
-   * @param provider - A Provider instance (optional).
-   * @param path - The derivation path (optional).
-   * @returns An unlocked wallet instance.
-   */
-  static fromSeed = WalletUnlocked.fromSeed;
-  /**
-   * Create a Wallet Unlocked from a mnemonic phrase.
-   *
-   * @param mnemonic - The mnemonic phrase.
-   * @param provider - A Provider instance (optional).
-   * @param path - The derivation path (optional).
-   * @param passphrase - The passphrase for the mnemonic (optional).
-   * @returns An unlocked wallet instance.
-   */
-  static fromMnemonic = WalletUnlocked.fromMnemonic;
-  /**
-   * Create a Wallet Unlocked from an extended key.
-   *
-   * @param extendedKey - The extended key.
-   * @param provider - A Provider instance (optional).
-   * @returns An unlocked wallet instance.
-   */
-  static fromExtendedKey = WalletUnlocked.fromExtendedKey;
-  /**
-   * Create a Wallet Unlocked from an encrypted JSON.
-   *
-   * @param jsonWallet - The encrypted JSON keystore.
-   * @param password - The password to decrypt the JSON.
-   * @param provider - A Provider instance (optional).
-   * @returns An unlocked wallet instance.
-   */
-  static fromEncryptedJson = WalletUnlocked.fromEncryptedJson;
 };
+/**
+ * Generate a new Wallet Unlocked with a random key pair.
+ *
+ * @param generateOptions - Options to customize the generation process (optional).
+ * @returns An unlocked wallet instance.
+ */
+__publicField(Wallet, "generate", WalletUnlocked.generate);
+/**
+ * Create a Wallet Unlocked from a seed.
+ *
+ * @param seed - The seed phrase.
+ * @param provider - A Provider instance (optional).
+ * @param path - The derivation path (optional).
+ * @returns An unlocked wallet instance.
+ */
+__publicField(Wallet, "fromSeed", WalletUnlocked.fromSeed);
+/**
+ * Create a Wallet Unlocked from a mnemonic phrase.
+ *
+ * @param mnemonic - The mnemonic phrase.
+ * @param provider - A Provider instance (optional).
+ * @param path - The derivation path (optional).
+ * @param passphrase - The passphrase for the mnemonic (optional).
+ * @returns An unlocked wallet instance.
+ */
+__publicField(Wallet, "fromMnemonic", WalletUnlocked.fromMnemonic);
+/**
+ * Create a Wallet Unlocked from an extended key.
+ *
+ * @param extendedKey - The extended key.
+ * @param provider - A Provider instance (optional).
+ * @returns An unlocked wallet instance.
+ */
+__publicField(Wallet, "fromExtendedKey", WalletUnlocked.fromExtendedKey);
+/**
+ * Create a Wallet Unlocked from an encrypted JSON.
+ *
+ * @param jsonWallet - The encrypted JSON keystore.
+ * @param password - The password to decrypt the JSON.
+ * @param provider - A Provider instance (optional).
+ * @returns An unlocked wallet instance.
+ */
+__publicField(Wallet, "fromEncryptedJson", WalletUnlocked.fromEncryptedJson);
 
 // src/wallet-manager/wallet-manager.ts
 var import_address9 = require("@fuel-ts/address");
@@ -8231,14 +8254,14 @@ var MemoryStorage = class {
 // src/wallet-manager/vaults/mnemonic-vault.ts
 var import_address7 = require("@fuel-ts/address");
 var import_errors20 = require("@fuel-ts/errors");
+var _secret;
 var MnemonicVault = class {
-  static type = "mnemonic";
-  #secret;
-  pathKey = "{}";
-  rootPath = `m/44'/1179993420'/${this.pathKey}'/0/0`;
-  numberOfAccounts = 0;
   constructor(options) {
-    this.#secret = options.secret || mnemonic_default.generate();
+    __privateAdd(this, _secret, void 0);
+    __publicField(this, "pathKey", "{}");
+    __publicField(this, "rootPath", `m/44'/1179993420'/${this.pathKey}'/0/0`);
+    __publicField(this, "numberOfAccounts", 0);
+    __privateSet(this, _secret, options.secret || mnemonic_default.generate());
     this.rootPath = options.rootPath || this.rootPath;
     this.numberOfAccounts = options.numberOfAccounts || 1;
   }
@@ -8250,7 +8273,7 @@ var MnemonicVault = class {
   }
   serialize() {
     return {
-      secret: this.#secret,
+      secret: __privateGet(this, _secret),
       rootPath: this.rootPath,
       numberOfAccounts: this.numberOfAccounts
     };
@@ -8259,7 +8282,7 @@ var MnemonicVault = class {
     const accounts = [];
     let numberOfAccounts = 0;
     do {
-      const wallet = Wallet.fromMnemonic(this.#secret, this.getDerivePath(numberOfAccounts));
+      const wallet = Wallet.fromMnemonic(__privateGet(this, _secret), this.getDerivePath(numberOfAccounts));
       accounts.push({
         publicKey: wallet.publicKey,
         address: wallet.address
@@ -8270,7 +8293,7 @@ var MnemonicVault = class {
   }
   addAccount() {
     this.numberOfAccounts += 1;
-    const wallet = Wallet.fromMnemonic(this.#secret, this.getDerivePath(this.numberOfAccounts - 1));
+    const wallet = Wallet.fromMnemonic(__privateGet(this, _secret), this.getDerivePath(this.numberOfAccounts - 1));
     return {
       publicKey: wallet.publicKey,
       address: wallet.address
@@ -8280,7 +8303,7 @@ var MnemonicVault = class {
     let numberOfAccounts = 0;
     const ownerAddress = import_address7.Address.fromAddressOrString(address);
     do {
-      const wallet = Wallet.fromMnemonic(this.#secret, this.getDerivePath(numberOfAccounts));
+      const wallet = Wallet.fromMnemonic(__privateGet(this, _secret), this.getDerivePath(numberOfAccounts));
       if (wallet.address.equals(ownerAddress)) {
         return wallet.privateKey;
       }
@@ -8296,27 +8319,29 @@ var MnemonicVault = class {
     return Wallet.fromPrivateKey(privateKey);
   }
 };
+_secret = new WeakMap();
+__publicField(MnemonicVault, "type", "mnemonic");
 
 // src/wallet-manager/vaults/privatekey-vault.ts
 var import_address8 = require("@fuel-ts/address");
 var import_errors21 = require("@fuel-ts/errors");
+var _privateKeys;
 var PrivateKeyVault = class {
-  static type = "privateKey";
-  #privateKeys = [];
   /**
    * If privateKey vault is initialized with a secretKey, it creates
    * one account with the fallowing secret
    */
   constructor(options = {}) {
+    __privateAdd(this, _privateKeys, []);
     if (options.secret) {
-      this.#privateKeys = [options.secret];
+      __privateSet(this, _privateKeys, [options.secret]);
     } else {
-      this.#privateKeys = options.accounts || [Wallet.generate().privateKey];
+      __privateSet(this, _privateKeys, options.accounts || [Wallet.generate().privateKey]);
     }
   }
   serialize() {
     return {
-      accounts: this.#privateKeys
+      accounts: __privateGet(this, _privateKeys)
     };
   }
   getPublicAccount(privateKey) {
@@ -8327,16 +8352,16 @@ var PrivateKeyVault = class {
     };
   }
   getAccounts() {
-    return this.#privateKeys.map((pk) => this.getPublicAccount(pk));
+    return __privateGet(this, _privateKeys).map((pk) => this.getPublicAccount(pk));
   }
   addAccount() {
     const wallet = Wallet.generate();
-    this.#privateKeys.push(wallet.privateKey);
+    __privateGet(this, _privateKeys).push(wallet.privateKey);
     return this.getPublicAccount(wallet.privateKey);
   }
   exportAccount(address) {
     const ownerAddress = import_address8.Address.fromAddressOrString(address);
-    const privateKey = this.#privateKeys.find(
+    const privateKey = __privateGet(this, _privateKeys).find(
       (pk) => Wallet.fromPrivateKey(pk).address.equals(ownerAddress)
     );
     if (!privateKey) {
@@ -8352,6 +8377,8 @@ var PrivateKeyVault = class {
     return Wallet.fromPrivateKey(privateKey);
   }
 };
+_privateKeys = new WeakMap();
+__publicField(PrivateKeyVault, "type", "privateKey");
 
 // src/wallet-manager/wallet-manager.ts
 var ERROR_MESSAGES = {
@@ -8366,43 +8393,46 @@ function assert(condition, message) {
     throw new import_errors22.FuelError(import_errors22.ErrorCode.WALLET_MANAGER_ERROR, message);
   }
 }
-var WalletManager = class _WalletManager extends import_events.EventEmitter {
-  /**
-   * Vaults
-   *
-   * Vaults are responsible to store secret keys and return an `Wallet` instance,
-   * to interact with the network.
-   *
-   * Each vault has access to its own state
-   *
-   */
-  static Vaults = [MnemonicVault, PrivateKeyVault];
-  /**
-   * Storage
-   *
-   * Persistent encrypted data. `The default storage works only on memory`.
-   */
-  storage = new MemoryStorage();
-  /* Key name passed to the storage */
-  STORAGE_KEY = "WalletManager";
-  // `This variables are only accessible from inside the class`
-  #vaults = [];
-  #passphrase = "";
-  #isLocked = true;
+var _vaults, _passphrase, _isLocked, _serializeVaults, serializeVaults_fn, _deserializeVaults, deserializeVaults_fn;
+var _WalletManager = class extends import_events.EventEmitter {
   constructor(options) {
     super();
+    /**
+     * Serialize all vaults to store
+     *
+     * `This is only accessible from inside the class`
+     */
+    __privateAdd(this, _serializeVaults);
+    /**
+     * Deserialize all vaults to state
+     *
+     * `This is only accessible from inside the class`
+     */
+    __privateAdd(this, _deserializeVaults);
+    /**
+     * Storage
+     *
+     * Persistent encrypted data. `The default storage works only on memory`.
+     */
+    __publicField(this, "storage", new MemoryStorage());
+    /* Key name passed to the storage */
+    __publicField(this, "STORAGE_KEY", "WalletManager");
+    // `This variables are only accessible from inside the class`
+    __privateAdd(this, _vaults, []);
+    __privateAdd(this, _passphrase, "");
+    __privateAdd(this, _isLocked, true);
     this.storage = options?.storage || this.storage;
   }
   get isLocked() {
-    return this.#isLocked;
+    return __privateGet(this, _isLocked);
   }
   /**
    * Return the vault serialized object containing all the privateKeys,
    * the format of the return depends on the Vault type.
    */
   exportVault(vaultId) {
-    assert(!this.#isLocked, ERROR_MESSAGES.wallet_not_unlocked);
-    const vaultState = this.#vaults.find((_, idx) => idx === vaultId);
+    assert(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
+    const vaultState = __privateGet(this, _vaults).find((_, idx) => idx === vaultId);
     assert(vaultState, ERROR_MESSAGES.vault_not_found);
     return vaultState.vault.serialize();
   }
@@ -8410,7 +8440,7 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
    * List all vaults on the Wallet Manager, this function not return secret's
    */
   getVaults() {
-    return this.#vaults.map((v, idx) => ({
+    return __privateGet(this, _vaults).map((v, idx) => ({
       title: v.title,
       type: v.type,
       vaultId: idx
@@ -8420,7 +8450,7 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
    * List all accounts on the Wallet Manager not vault information is revealed
    */
   getAccounts() {
-    return this.#vaults.flatMap(
+    return __privateGet(this, _vaults).flatMap(
       (vaultState, vaultId) => vaultState.vault.getAccounts().map((account) => ({ ...account, vaultId }))
     );
   }
@@ -8429,7 +8459,7 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
    */
   getWallet(address) {
     const ownerAddress = import_address9.Address.fromAddressOrString(address);
-    const vaultState = this.#vaults.find(
+    const vaultState = __privateGet(this, _vaults).find(
       (vs) => vs.vault.getAccounts().find((a) => a.address.equals(ownerAddress))
     );
     assert(vaultState, ERROR_MESSAGES.address_not_found);
@@ -8440,8 +8470,8 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
    */
   exportPrivateKey(address) {
     const ownerAddress = import_address9.Address.fromAddressOrString(address);
-    assert(!this.#isLocked, ERROR_MESSAGES.wallet_not_unlocked);
-    const vaultState = this.#vaults.find(
+    assert(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
+    const vaultState = __privateGet(this, _vaults).find(
       (vs) => vs.vault.getAccounts().find((a) => a.address.equals(ownerAddress))
     );
     assert(vaultState, ERROR_MESSAGES.address_not_found);
@@ -8453,7 +8483,7 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
    */
   async addAccount(options) {
     await this.loadState();
-    const vaultState = this.#vaults[options?.vaultId || 0];
+    const vaultState = __privateGet(this, _vaults)[options?.vaultId || 0];
     await assert(vaultState, ERROR_MESSAGES.vault_not_found);
     const account = vaultState.vault.addAccount();
     await this.saveState();
@@ -8464,7 +8494,7 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
    * created by the vault.
    */
   async removeVault(index) {
-    this.#vaults.splice(index, 1);
+    __privateGet(this, _vaults).splice(index, 1);
     await this.saveState();
   }
   /**
@@ -8475,11 +8505,11 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
     await this.loadState();
     const Vault2 = this.getVaultClass(vaultConfig.type);
     const vault = new Vault2(vaultConfig);
-    this.#vaults = this.#vaults.concat({
+    __privateSet(this, _vaults, __privateGet(this, _vaults).concat({
       title: vaultConfig.title,
       type: vaultConfig.type,
       vault
-    });
+    }));
     await this.saveState();
   }
   /**
@@ -8487,9 +8517,9 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
    * secrets.
    */
   lock() {
-    this.#isLocked = true;
-    this.#vaults = [];
-    this.#passphrase = "";
+    __privateSet(this, _isLocked, true);
+    __privateSet(this, _vaults, []);
+    __privateSet(this, _passphrase, "");
     this.emit("lock");
   }
   /**
@@ -8497,8 +8527,8 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
    * Vaults with secrets are not unlocked or instantiated on this moment.
    */
   async unlock(passphrase) {
-    this.#passphrase = passphrase;
-    this.#isLocked = false;
+    __privateSet(this, _passphrase, passphrase);
+    __privateSet(this, _isLocked, false);
     try {
       await this.loadState();
       this.emit("unlock");
@@ -8511,9 +8541,9 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
    * Update WalletManager encryption passphrase
    */
   async updatePassphrase(oldpass, newpass) {
-    const isLocked = this.#isLocked;
+    const isLocked = __privateGet(this, _isLocked);
     await this.unlock(oldpass);
-    this.#passphrase = newpass;
+    __privateSet(this, _passphrase, newpass);
     await this.saveState();
     await this.loadState();
     if (isLocked) {
@@ -8524,51 +8554,24 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
    * Retrieve and decrypt WalletManager state from storage
    */
   async loadState() {
-    await assert(!this.#isLocked, ERROR_MESSAGES.wallet_not_unlocked);
+    await assert(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
     const data = await this.storage.getItem(this.STORAGE_KEY);
     if (data) {
-      const state = await (0, import_crypto4.decrypt)(this.#passphrase, JSON.parse(data));
-      this.#vaults = this.#deserializeVaults(state.vaults);
+      const state = await (0, import_crypto4.decrypt)(__privateGet(this, _passphrase), JSON.parse(data));
+      __privateSet(this, _vaults, __privateMethod(this, _deserializeVaults, deserializeVaults_fn).call(this, state.vaults));
     }
   }
   /**
    * Store encrypted WalletManager state on storage
    */
   async saveState() {
-    await assert(!this.#isLocked, ERROR_MESSAGES.wallet_not_unlocked);
-    const encryptedData = await (0, import_crypto4.encrypt)(this.#passphrase, {
-      vaults: this.#serializeVaults(this.#vaults)
+    await assert(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
+    const encryptedData = await (0, import_crypto4.encrypt)(__privateGet(this, _passphrase), {
+      vaults: __privateMethod(this, _serializeVaults, serializeVaults_fn).call(this, __privateGet(this, _vaults))
     });
     await this.storage.setItem(this.STORAGE_KEY, JSON.stringify(encryptedData));
     this.emit("update");
   }
-  /**
-   * Serialize all vaults to store
-   *
-   * `This is only accessible from inside the class`
-   */
-  #serializeVaults(vaults) {
-    return vaults.map(({ title, type, vault }) => ({
-      title,
-      type,
-      data: vault.serialize()
-    }));
-  }
-  /**
-   * Deserialize all vaults to state
-   *
-   * `This is only accessible from inside the class`
-   */
-  #deserializeVaults(vaults) {
-    return vaults.map(({ title, type, data: vaultConfig }) => {
-      const VaultClass = this.getVaultClass(type);
-      return {
-        title,
-        type,
-        vault: new VaultClass(vaultConfig)
-      };
-    });
-  }
   /**
    * Return a instantiable Class reference from `WalletManager.Vaults` supported list.
    */
@@ -8578,11 +8581,43 @@ var WalletManager = class _WalletManager extends import_events.EventEmitter {
     return VaultClass;
   }
 };
+var WalletManager = _WalletManager;
+_vaults = new WeakMap();
+_passphrase = new WeakMap();
+_isLocked = new WeakMap();
+_serializeVaults = new WeakSet();
+serializeVaults_fn = function(vaults) {
+  return vaults.map(({ title, type, vault }) => ({
+    title,
+    type,
+    data: vault.serialize()
+  }));
+};
+_deserializeVaults = new WeakSet();
+deserializeVaults_fn = function(vaults) {
+  return vaults.map(({ title, type, data: vaultConfig }) => {
+    const VaultClass = this.getVaultClass(type);
+    return {
+      title,
+      type,
+      vault: new VaultClass(vaultConfig)
+    };
+  });
+};
+/**
+ * Vaults
+ *
+ * Vaults are responsible to store secret keys and return an `Wallet` instance,
+ * to interact with the network.
+ *
+ * Each vault has access to its own state
+ *
+ */
+__publicField(WalletManager, "Vaults", [MnemonicVault, PrivateKeyVault]);
 
 // src/wallet-manager/types.ts
 var import_errors23 = require("@fuel-ts/errors");
 var Vault = class {
-  static type;
   constructor(_options) {
     throw new import_errors23.FuelError(import_errors23.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
@@ -8602,6 +8637,7 @@ var Vault = class {
     throw new import_errors23.FuelError(import_errors23.ErrorCode.NOT_IMPLEMENTED, "Not implemented.");
   }
 };
+__publicField(Vault, "type");
 var StorageAbstract = class {
 };
 
@@ -8611,23 +8647,23 @@ var import_address10 = require("@fuel-ts/address");
 var import_configs12 = require("@fuel-ts/address/configs");
 var import_errors24 = require("@fuel-ts/errors");
 var import_transactions19 = require("@fuel-ts/transactions");
-var import_utils36 = require("@fuel-ts/utils");
+var import_utils37 = require("@fuel-ts/utils");
 
 // src/predicate/utils/getPredicateRoot.ts
 var import_hasher7 = require("@fuel-ts/hasher");
 var import_merkle = require("@fuel-ts/merkle");
-var import_utils35 = require("@fuel-ts/utils");
+var import_utils36 = require("@fuel-ts/utils");
 var getPredicateRoot = (bytecode) => {
   const chunkSize = 16 * 1024;
-  const bytes = (0, import_utils35.arrayify)(bytecode);
-  const chunks = (0, import_utils35.chunkAndPadBytes)(bytes, chunkSize);
-  const codeRoot = (0, import_merkle.calcRoot)(chunks.map((c) => (0, import_utils35.hexlify)(c)));
-  const predicateRoot = (0, import_hasher7.hash)((0, import_utils35.concat)(["0x4655454C", codeRoot]));
+  const bytes = (0, import_utils36.arrayify)(bytecode);
+  const chunks = (0, import_utils36.chunkAndPadBytes)(bytes, chunkSize);
+  const codeRoot = (0, import_merkle.calcRoot)(chunks.map((c) => (0, import_utils36.hexlify)(c)));
+  const predicateRoot = (0, import_hasher7.hash)((0, import_utils36.concat)(["0x4655454C", codeRoot]));
   return predicateRoot;
 };
 
 // src/predicate/predicate.ts
-var Predicate = class _Predicate extends Account {
+var Predicate = class extends Account {
   bytes;
   predicateDataBytes = Uint8Array.from([]);
   predicateData = [];
@@ -8648,7 +8684,7 @@ var Predicate = class _Predicate extends Account {
     inputData,
     configurableConstants
   }) {
-    const { predicateBytes, predicateInterface } = _Predicate.processPredicateData(
+    const { predicateBytes, predicateInterface } = Predicate.processPredicateData(
       bytecode,
       abi,
       configurableConstants
@@ -8671,7 +8707,7 @@ var Predicate = class _Predicate extends Account {
     const request = transactionRequestify(transactionRequestLike);
     const { policies } = BaseTransactionRequest.getPolicyMeta(request);
     request.inputs?.forEach((input) => {
-      if (input.type === import_transactions19.InputType.Coin && (0, import_utils36.hexlify)(input.owner) === this.address.toB256()) {
+      if (input.type === import_transactions19.InputType.Coin && (0, import_utils37.hexlify)(input.owner) === this.address.toB256()) {
         input.predicate = this.bytes;
         input.predicateData = this.getPredicateData(policies.length);
       }
@@ -8732,7 +8768,7 @@ var Predicate = class _Predicate extends Account {
    * @returns An object containing the new predicate bytes and interface.
    */
   static processPredicateData(bytes, jsonAbi, configurableConstants) {
-    let predicateBytes = (0, import_utils36.arrayify)(bytes);
+    let predicateBytes = (0, import_utils37.arrayify)(bytes);
     let abiInterface;
     if (jsonAbi) {
       abiInterface = new import_abi_coder5.Interface(jsonAbi);
@@ -8744,7 +8780,7 @@ var Predicate = class _Predicate extends Account {
       }
     }
     if (configurableConstants && Object.keys(configurableConstants).length) {
-      predicateBytes = _Predicate.setConfigurableConstants(
+      predicateBytes = Predicate.setConfigurableConstants(
         predicateBytes,
         configurableConstants,
         abiInterface
@@ -9124,9 +9160,7 @@ async function withTimeout(promise, timeout = 1050) {
 var HAS_CONNECTOR_TIMEOUT = 2e3;
 var PING_CACHE_TIME = 5e3;
 var { warn } = console;
-var Fuel = class _Fuel extends FuelConnector {
-  static STORAGE_KEY = "fuel-current-connector";
-  static defaultConfig = {};
+var _Fuel = class extends FuelConnector {
   _storage = null;
   _connectors = [];
   _targetObject = null;
@@ -9451,6 +9485,9 @@ var Fuel = class _Fuel extends FuelConnector {
     await this.clean();
   }
 };
+var Fuel = _Fuel;
+__publicField(Fuel, "STORAGE_KEY", "fuel-current-connector");
+__publicField(Fuel, "defaultConfig", {});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Account,
@@ -9567,7 +9604,6 @@ var Fuel = class _Fuel extends FuelConnector {
   resolveGasDependentCosts,
   resolveIconPaths,
   returnZeroScript,
-  sleep,
   transactionRequestify,
   urlJoin,
   withTimeout,