@fuel-ts/account 0.0.0-rc-1889-20240322122653 → 0.0.0-rc-1815-20240322131329

package/dist/index.mjs

@@ -1,3 +1,32 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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/account.ts
 import { Address as Address3 } from "@fuel-ts/address";
 import { BaseAssetId as BaseAssetId3 } from "@fuel-ts/address/configs";
@@ -867,12 +896,11 @@ function getSdk(requester) {
 // src/providers/fuel-graphql-subscriber.ts
 import { ErrorCode, FuelError } from "@fuel-ts/errors";
 import { print } from "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`, {
@@ -932,6 +960,8 @@ var FuelGraphqlSubscriber = class _FuelGraphqlSubscriber {
     return this;
   }
 };
+var FuelGraphqlSubscriber = _FuelGraphqlSubscriber;
+__publicField(FuelGraphqlSubscriber, "textDecoder", new TextDecoder());
 
 // src/providers/memory-cache.ts
 import { ErrorCode as ErrorCode2, FuelError as FuelError2 } from "@fuel-ts/errors";
@@ -1565,7 +1595,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 */
@@ -1635,7 +1665,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,
@@ -1673,13 +1703,27 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
     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;
   }
   /**
@@ -1708,6 +1752,21 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
     }
     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.
    *
@@ -1773,7 +1832,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
     } else {
       witnessIndex = this.getCoinInputWitnessIndexByOwner(owner);
       if (typeof witnessIndex !== "number") {
-        witnessIndex = this.createWitness();
+        witnessIndex = this.addEmptyWitness();
       }
     }
     const input = {
@@ -1807,7 +1866,7 @@ var BaseTransactionRequest = class _BaseTransactionRequest {
     } else {
       witnessIndex = this.getCoinInputWitnessIndexByOwner(recipient);
       if (typeof witnessIndex !== "number") {
-        witnessIndex = this.createWitness();
+        witnessIndex = this.addEmptyWitness();
       }
     }
     const input = {
@@ -3220,7 +3279,7 @@ function assembleTransactionSummary(params) {
 }
 
 // src/providers/transaction-response/transaction-response.ts
-var TransactionResponse = class _TransactionResponse {
+var TransactionResponse = class {
   /** Transaction ID */
   id;
   /** Current provider */
@@ -3248,7 +3307,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;
   }
@@ -3476,7 +3535,8 @@ var processGqlChain = (chain) => {
     }
   };
 };
-var Provider = class _Provider {
+var _cacheInputs, cacheInputs_fn;
+var _Provider = class {
   /**
    * Constructor to initialize a Provider.
    *
@@ -3487,25 +3547,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) => {
@@ -3702,19 +3764,6 @@ var Provider = class _Provider {
     } = this.getChain();
     return chainId.toNumber();
   }
-  /**
-   * @hidden
-   */
-  #cacheInputs(inputs) {
-    if (!this.cache) {
-      return;
-    }
-    inputs.forEach((input) => {
-      if (input.type === InputType6.Coin) {
-        this.cache?.set(input.id);
-      }
-    });
-  }
   /**
    * Submits a transaction to the chain to be executed.
    *
@@ -3727,7 +3776,7 @@ 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);
     }
@@ -3904,7 +3953,8 @@ var Provider = class _Provider {
   async getTransactionCost(transactionRequestLike, forwardingQuantities = [], {
     estimateTxDependencies = true,
     estimatePredicates = true,
-    resourcesOwner
+    resourcesOwner,
+    signatureCallback
   } = {}) {
     const txRequestClone = clone3(transactionRequestify(transactionRequestLike));
     const chainInfo = this.getChain();
@@ -3923,6 +3973,9 @@ var Provider = class _Provider {
       }
       await this.estimatePredicates(txRequestClone);
     }
+    if (signatureCallback && isScriptTransaction) {
+      await signatureCallback(txRequestClone);
+    }
     const minGas = txRequestClone.calculateMinGas(chainInfo);
     const maxGas = txRequestClone.calculateMaxGas(chainInfo, minGas);
     let receipts = [];
@@ -4352,6 +4405,20 @@ 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 === InputType6.Coin) {
+      this.cache?.set(input.id);
+    }
+  });
+};
+__publicField(Provider, "chainInfoCache", {});
+__publicField(Provider, "nodeInfoCache", {});
 
 // src/providers/transaction-summary/get-transaction-summary.ts
 import { ErrorCode as ErrorCode13, FuelError as FuelError13 } from "@fuel-ts/errors";
@@ -4956,6 +5023,21 @@ var Account = class extends AbstractAccount {
     }
     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.
    *
@@ -5022,7 +5104,7 @@ import { hash } from "@fuel-ts/hasher";
 import { toBytes } from "@fuel-ts/math";
 import { hexlify as hexlify13, concat as concat3, arrayify as arrayify15 } from "@fuel-ts/utils";
 import { secp256k1 } from "@noble/curves/secp256k1";
-var Signer = class _Signer {
+var Signer = class {
   address;
   publicKey;
   compressedPublicKey;
@@ -5101,7 +5183,7 @@ var Signer = class _Signer {
    * @returns Address from signature
    */
   static recoverAddress(data, signature) {
-    return Address4.fromPublicKey(_Signer.recoverPublicKey(data, signature));
+    return Address4.fromPublicKey(Signer.recoverPublicKey(data, signature));
   }
   /**
    * Generate a random privateKey
@@ -5225,10 +5307,6 @@ async function decryptKeystoreWallet(jsonWallet, password) {
 
 // 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.
    */
@@ -5278,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,6 +5412,10 @@ 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
 import { ErrorCode as ErrorCode18, FuelError as FuelError18 } from "@fuel-ts/errors";
@@ -7543,7 +7625,7 @@ function assertMnemonic(words) {
     throw new FuelError17(ErrorCode17.INVALID_MNEMONIC, errorMsg);
   }
 }
-var Mnemonic = class _Mnemonic {
+var Mnemonic = class {
   wordlist;
   /**
    *
@@ -7560,7 +7642,7 @@ var Mnemonic = class _Mnemonic {
    * @returns Entropy hash
    */
   mnemonicToEntropy(phrase) {
-    return _Mnemonic.mnemonicToEntropy(phrase, this.wordlist);
+    return Mnemonic.mnemonicToEntropy(phrase, this.wordlist);
   }
   /**
    *
@@ -7568,7 +7650,7 @@ var Mnemonic = class _Mnemonic {
    * @returns Mnemonic phrase
    */
   entropyToMnemonic(entropy) {
-    return _Mnemonic.entropyToMnemonic(entropy, this.wordlist);
+    return Mnemonic.entropyToMnemonic(entropy, this.wordlist);
   }
   /**
    *
@@ -7609,8 +7691,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
@@ -7626,7 +7708,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;
@@ -7673,7 +7755,7 @@ var Mnemonic = class _Mnemonic {
    * @returns BIP-32 extended private key
    */
   static seedToExtendedKey(seed, testnet = false) {
-    const masterKey = _Mnemonic.masterKeysFromSeed(seed);
+    const masterKey = Mnemonic.masterKeysFromSeed(seed);
     const prefix = arrayify17(testnet ? TestnetPRV : MainnetPRV);
     const depth = "0x00";
     const fingerprint = "0x00000000";
@@ -7705,7 +7787,7 @@ var Mnemonic = class _Mnemonic {
    */
   static generate(size = 32, extraEntropy = "") {
     const entropy = extraEntropy ? sha2563(concat4([randomBytes3(size), arrayify17(extraEntropy)])) : randomBytes3(size);
-    return _Mnemonic.entropyToMnemonic(entropy);
+    return Mnemonic.entropyToMnemonic(entropy);
   }
 };
 var mnemonic_default = Mnemonic;
@@ -7745,7 +7827,7 @@ 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 = hexlify17("0x00000000");
@@ -7811,7 +7893,7 @@ var HDWallet = class _HDWallet {
     if (privateKey) {
       const N = "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141";
       const ki = bn17(IL).add(privateKey).mod(N).toBytes(32);
-      return new _HDWallet({
+      return new HDWallet({
         privateKey: ki,
         chainCode: IR,
         index,
@@ -7821,7 +7903,7 @@ var HDWallet = class _HDWallet {
     }
     const signer = new Signer(hexlify17(IL));
     const Ki = signer.addPoint(publicKey);
-    return new _HDWallet({
+    return new HDWallet({
       publicKey: Ki,
       chainCode: IR,
       index,
@@ -7870,7 +7952,7 @@ var HDWallet = class _HDWallet {
    */
   static fromSeed(seed) {
     const masterKey = mnemonic_default.masterKeysFromSeed(seed);
-    return new _HDWallet({
+    return new HDWallet({
       chainCode: arrayify18(masterKey.slice(32)),
       privateKey: arrayify18(masterKey.slice(0, 32))
     });
@@ -7900,7 +7982,7 @@ var HDWallet = class _HDWallet {
       if (key[0] !== 3) {
         throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Invalid public extended key.");
       }
-      return new _HDWallet({
+      return new HDWallet({
         publicKey: key,
         chainCode,
         index,
@@ -7911,7 +7993,7 @@ var HDWallet = class _HDWallet {
     if (key[0] !== 0) {
       throw new FuelError18(ErrorCode18.HD_WALLET_ERROR, "Invalid private extended key.");
     }
-    return new _HDWallet({
+    return new HDWallet({
       privateKey: key.slice(1),
       chainCode,
       index,
@@ -7934,7 +8016,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.
    *
@@ -7952,7 +8034,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.
@@ -7964,8 +8046,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.
@@ -7979,8 +8061,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.
@@ -7991,7 +8073,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.
@@ -8003,7 +8085,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);
   }
 };
 
@@ -8029,50 +8111,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
 import { Address as Address8 } from "@fuel-ts/address";
@@ -8101,14 +8183,14 @@ var MemoryStorage = class {
 // src/wallet-manager/vaults/mnemonic-vault.ts
 import { Address as Address6 } from "@fuel-ts/address";
 import { ErrorCode as ErrorCode19, FuelError as FuelError19 } from "@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;
   }
@@ -8120,7 +8202,7 @@ var MnemonicVault = class {
   }
   serialize() {
     return {
-      secret: this.#secret,
+      secret: __privateGet(this, _secret),
       rootPath: this.rootPath,
       numberOfAccounts: this.numberOfAccounts
     };
@@ -8129,7 +8211,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
@@ -8140,7 +8222,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
@@ -8150,7 +8232,7 @@ var MnemonicVault = class {
     let numberOfAccounts = 0;
     const ownerAddress = Address6.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;
       }
@@ -8166,27 +8248,29 @@ var MnemonicVault = class {
     return Wallet.fromPrivateKey(privateKey);
   }
 };
+_secret = new WeakMap();
+__publicField(MnemonicVault, "type", "mnemonic");
 
 // src/wallet-manager/vaults/privatekey-vault.ts
 import { Address as Address7 } from "@fuel-ts/address";
 import { ErrorCode as ErrorCode20, FuelError as FuelError20 } from "@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) {
@@ -8197,16 +8281,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 = Address7.fromAddressOrString(address);
-    const privateKey = this.#privateKeys.find(
+    const privateKey = __privateGet(this, _privateKeys).find(
       (pk) => Wallet.fromPrivateKey(pk).address.equals(ownerAddress)
     );
     if (!privateKey) {
@@ -8222,6 +8306,8 @@ var PrivateKeyVault = class {
     return Wallet.fromPrivateKey(privateKey);
   }
 };
+_privateKeys = new WeakMap();
+__publicField(PrivateKeyVault, "type", "privateKey");
 
 // src/wallet-manager/wallet-manager.ts
 var ERROR_MESSAGES = {
@@ -8236,43 +8322,46 @@ function assert(condition, message) {
     throw new FuelError21(ErrorCode21.WALLET_MANAGER_ERROR, message);
   }
 }
-var WalletManager = class _WalletManager extends 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 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();
   }
@@ -8280,7 +8369,7 @@ var WalletManager = class _WalletManager extends 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
@@ -8290,7 +8379,7 @@ var WalletManager = class _WalletManager extends 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 }))
     );
   }
@@ -8299,7 +8388,7 @@ var WalletManager = class _WalletManager extends EventEmitter {
    */
   getWallet(address) {
     const ownerAddress = Address8.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);
@@ -8310,8 +8399,8 @@ var WalletManager = class _WalletManager extends EventEmitter {
    */
   exportPrivateKey(address) {
     const ownerAddress = Address8.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);
@@ -8323,7 +8412,7 @@ var WalletManager = class _WalletManager extends 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();
@@ -8334,7 +8423,7 @@ var WalletManager = class _WalletManager extends EventEmitter {
    * created by the vault.
    */
   async removeVault(index) {
-    this.#vaults.splice(index, 1);
+    __privateGet(this, _vaults).splice(index, 1);
     await this.saveState();
   }
   /**
@@ -8345,11 +8434,11 @@ var WalletManager = class _WalletManager extends 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();
   }
   /**
@@ -8357,9 +8446,9 @@ var WalletManager = class _WalletManager extends EventEmitter {
    * secrets.
    */
   lock() {
-    this.#isLocked = true;
-    this.#vaults = [];
-    this.#passphrase = "";
+    __privateSet(this, _isLocked, true);
+    __privateSet(this, _vaults, []);
+    __privateSet(this, _passphrase, "");
     this.emit("lock");
   }
   /**
@@ -8367,8 +8456,8 @@ var WalletManager = class _WalletManager extends 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");
@@ -8381,9 +8470,9 @@ var WalletManager = class _WalletManager extends 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) {
@@ -8394,51 +8483,24 @@ var WalletManager = class _WalletManager extends 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 decrypt(this.#passphrase, JSON.parse(data));
-      this.#vaults = this.#deserializeVaults(state.vaults);
+      const state = await 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 encrypt(this.#passphrase, {
-      vaults: this.#serializeVaults(this.#vaults)
+    await assert(!__privateGet(this, _isLocked), ERROR_MESSAGES.wallet_not_unlocked);
+    const encryptedData = await 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.
    */
@@ -8448,11 +8510,43 @@ var WalletManager = class _WalletManager extends 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
 import { ErrorCode as ErrorCode22, FuelError as FuelError22 } from "@fuel-ts/errors";
 var Vault = class {
-  static type;
   constructor(_options) {
     throw new FuelError22(ErrorCode22.NOT_IMPLEMENTED, "Not implemented.");
   }
@@ -8472,6 +8566,7 @@ var Vault = class {
     throw new FuelError22(ErrorCode22.NOT_IMPLEMENTED, "Not implemented.");
   }
 };
+__publicField(Vault, "type");
 var StorageAbstract = class {
 };
 
@@ -8503,7 +8598,7 @@ var getPredicateRoot = (bytecode) => {
 };
 
 // src/predicate/predicate.ts
-var Predicate = class _Predicate extends Account {
+var Predicate = class extends Account {
   bytes;
   predicateDataBytes = Uint8Array.from([]);
   predicateData = [];
@@ -8524,7 +8619,7 @@ var Predicate = class _Predicate extends Account {
     inputData,
     configurableConstants
   }) {
-    const { predicateBytes, predicateInterface } = _Predicate.processPredicateData(
+    const { predicateBytes, predicateInterface } = Predicate.processPredicateData(
       bytecode,
       abi,
       configurableConstants
@@ -8620,7 +8715,7 @@ var Predicate = class _Predicate extends Account {
       }
     }
     if (configurableConstants && Object.keys(configurableConstants).length) {
-      predicateBytes = _Predicate.setConfigurableConstants(
+      predicateBytes = Predicate.setConfigurableConstants(
         predicateBytes,
         configurableConstants,
         abiInterface
@@ -8808,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.
@@ -9000,9 +9107,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;
@@ -9327,6 +9432,9 @@ var Fuel = class _Fuel extends FuelConnector {
     await this.clean();
   }
 };
+var Fuel = _Fuel;
+__publicField(Fuel, "STORAGE_KEY", "fuel-current-connector");
+__publicField(Fuel, "defaultConfig", {});
 export {
   Account,
   AddressType,