@fuel-ts/account 0.0.0-pr-1699-20240202183346 → 0.0.0-pr-1699-20240202203055

package/dist/index.mjs

@@ -8535,21 +8535,1010 @@ var Predicate = class extends Account {
     return mutatedBytes;
   }
 };
+
+// src/connectors/fuel-wallet-connector.ts
+import { JSONRPCClient } from "json-rpc-2.0";
+import { v4 as randomUUID } from "uuid";
+
+// src/connectors/fuel-connector.ts
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/connectors/types/connector-types.ts
+var FuelConnectorMethods = /* @__PURE__ */ ((FuelConnectorMethods2) => {
+  FuelConnectorMethods2["ping"] = "ping";
+  FuelConnectorMethods2["version"] = "version";
+  FuelConnectorMethods2["connect"] = "connect";
+  FuelConnectorMethods2["disconnect"] = "disconnect";
+  FuelConnectorMethods2["isConnected"] = "isConnected";
+  FuelConnectorMethods2["accounts"] = "accounts";
+  FuelConnectorMethods2["currentAccount"] = "currentAccount";
+  FuelConnectorMethods2["signMessage"] = "signMessage";
+  FuelConnectorMethods2["sendTransaction"] = "sendTransaction";
+  FuelConnectorMethods2["assets"] = "assets";
+  FuelConnectorMethods2["addAsset"] = "addAsset";
+  FuelConnectorMethods2["addAssets"] = "addAssets";
+  FuelConnectorMethods2["networks"] = "networks";
+  FuelConnectorMethods2["currentNetwork"] = "currentNetwork";
+  FuelConnectorMethods2["addNetwork"] = "addNetwork";
+  FuelConnectorMethods2["selectNetwork"] = "selectNetwork";
+  FuelConnectorMethods2["addABI"] = "addABI";
+  FuelConnectorMethods2["getABI"] = "getABI";
+  FuelConnectorMethods2["hasABI"] = "hasABI";
+  return FuelConnectorMethods2;
+})(FuelConnectorMethods || {});
+var FuelConnectorEventTypes = /* @__PURE__ */ ((FuelConnectorEventTypes2) => {
+  FuelConnectorEventTypes2["connectors"] = "connectors";
+  FuelConnectorEventTypes2["currentConnector"] = "currentConnector";
+  FuelConnectorEventTypes2["connection"] = "connection";
+  FuelConnectorEventTypes2["accounts"] = "accounts";
+  FuelConnectorEventTypes2["currentAccount"] = "currentAccount";
+  FuelConnectorEventTypes2["networks"] = "networks";
+  FuelConnectorEventTypes2["currentNetwork"] = "currentNetwork";
+  FuelConnectorEventTypes2["assets"] = "assets";
+  FuelConnectorEventTypes2["abis"] = "abis";
+  return FuelConnectorEventTypes2;
+})(FuelConnectorEventTypes || {});
+var FuelConnectorEventType = "FuelConnector";
+
+// src/connectors/types/constants.ts
+var CONNECTOR_SCRIPT = "FuelConnectorScript";
+var CONTENT_SCRIPT_NAME = "FuelContentScript";
+var BACKGROUND_SCRIPT_NAME = "FuelBackgroundScript";
+var POPUP_SCRIPT_NAME = "FuelPopUpScript";
+var VAULT_SCRIPT_NAME = "FuelVaultScript";
+var EVENT_MESSAGE = "message";
+
+// src/connectors/types/data-type.ts
+var MessageTypes = /* @__PURE__ */ ((MessageTypes2) => {
+  MessageTypes2["ping"] = "ping";
+  MessageTypes2["uiEvent"] = "uiEvent";
+  MessageTypes2["event"] = "event";
+  MessageTypes2["request"] = "request";
+  MessageTypes2["response"] = "response";
+  MessageTypes2["removeConnection"] = "removeConnection";
+  return MessageTypes2;
+})(MessageTypes || {});
+
+// src/connectors/fuel-connector.ts
+var FuelConnector = class extends EventEmitter2 {
+  name = "";
+  metadata = {};
+  connected = false;
+  installed = false;
+  events = FuelConnectorEventTypes;
+  /**
+   * Should return true if the connector is loaded
+   * in less then one second.
+   *
+   * @returns Always true.
+   */
+  async ping() {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should return the current version of the connector
+   * and the network version that is compatible.
+   *
+   * @returns boolean - connection status.
+   */
+  async version() {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should return true if the connector is connected
+   * to any of the accounts available.
+   *
+   * @returns The connection status.
+   */
+  async isConnected() {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should return all the accounts authorized for the
+   * current connection.
+   *
+   * @returns The accounts addresses strings
+   */
+  async accounts() {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should start the connection process and return
+   * true if the account authorize the connection.
+   *
+   * and return false if the user reject the connection.
+   *
+   * @emits accounts
+   * @returns boolean - connection status.
+   */
+  async connect() {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should disconnect the current connection and
+   * return false if the disconnection was successful.
+   *
+   * @emits assets connection
+   * @returns The connection status.
+   */
+  async disconnect() {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should start the sign message process and return
+   * the signed message.
+   *
+   * @param address - The address to sign the message
+   * @param message - The message to sign all text will be treated as text utf-8
+   *
+   * @returns Message signature
+   */
+  async signMessage(_address, _message) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should start the send transaction process and return
+   * the transaction id submitted to the network.
+   *
+   * If the network is not available for the connection
+   * it should throw an error to avoid the transaction
+   * to be sent to the wrong network and lost.
+   *
+   * @param address - The address to sign the transaction
+   * @param transaction - The transaction to send
+   *
+   * @returns The transaction id
+   */
+  async sendTransaction(_address, _transaction) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should return the current account selected inside the connector, if the account
+   * is authorized for the connection.
+   *
+   * If the account is not authorized it should return null.
+   *
+   * @returns The current account selected otherwise null.
+   */
+  async currentAccount() {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should add the the assets metadata to the connector and return true if the asset
+   * was added successfully.
+   *
+   * If the asset already exists it should throw an error.
+   *
+   * @emits assets
+   * @param assets - The assets to add the metadata to the connection.
+   * @throws Error if the asset already exists
+   * @returns True if the asset was added successfully
+   */
+  async addAssets(_assets) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should add the the asset metadata to the connector and return true if the asset
+   * was added successfully.
+   *
+   * If the asset already exists it should throw an error.
+   *
+   * @emits assets
+   * @param asset - The asset to add the metadata to the connection.
+   * @throws Error if the asset already exists
+   * @returns True if the asset was added successfully
+   */
+  async addAsset(_asset) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should return all the assets added to the connector. If a connection is already established.
+   *
+   * @returns Array of assets metadata from the connector vinculated to the all accounts from a specific Wallet.
+   */
+  async assets() {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should start the add network process and return true if the network was added successfully.
+   *
+   * @emits networks
+   * @throws Error if the network already exists
+   * @param networkUrl - The URL of the network to be added.
+   * @returns Return true if the network was added successfully
+   */
+  async addNetwork(_networkUrl) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should start the select network process and return true if the network has change successfully.
+   *
+   * @emits networks
+   * @throws Error if the network already exists
+   * @param network - The network to be selected.
+   * @returns Return true if the network was added successfully
+   */
+  async selectNetwork(_network) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should return all the networks available from the connector. If the connection is already established.
+   *
+   * @returns Return all the networks added to the connector.
+   */
+  async networks() {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should return the current network selected inside the connector. Even if the connection is not established.
+   *
+   * @returns Return the current network selected inside the connector.
+   */
+  async currentNetwork() {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should add the ABI to the connector and return true if the ABI was added successfully.
+   *
+   * @param contractId - The contract id to add the ABI.
+   * @param abi - The JSON ABI that represents a contract.
+   * @returns Return true if the ABI was added successfully.
+   */
+  async addABI(_contractId, _abi) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should return the ABI from the connector vinculated to the all accounts from a specific Wallet.
+   *
+   * @param id - The contract id to get the ABI.
+   * @returns The ABI if it exists, otherwise return null.
+   */
+  async getABI(_id) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Should return true if the abi exists in the connector vinculated to the all accounts from a specific Wallet.
+   *
+   * @param id - The contract id to get the abi
+   * @returns Returns true if the abi exists or false if not.
+   */
+  async hasABI(_id) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Event listener for the connector.
+   *
+   * @param eventName - The event name to listen
+   * @param listener - The listener function
+   */
+  on(eventName, listener) {
+    super.on(eventName, listener);
+    return this;
+  }
+};
+
+// src/connectors/fuel-wallet-connector.ts
+var { warn } = console;
+var FuelWalletConnector = class extends FuelConnector {
+  name = "";
+  connected = false;
+  installed = false;
+  events = FuelConnectorEventTypes;
+  metadata = {
+    image: "/connectors/fuel-wallet.svg",
+    install: {
+      action: "Install",
+      description: "To connect your Fuel Wallet, install the browser extension.",
+      link: "https://chrome.google.com/webstore/detail/fuel-wallet/dldjpboieedgcmpkchcjcbijingjcgok"
+    }
+  };
+  client;
+  constructor(name = "Fuel Wallet") {
+    super();
+    this.name = name;
+    this.setMaxListeners(100);
+    this.client = new JSONRPCClient(this.sendRequest.bind(this), this.createRequestId);
+    this.setupListener();
+    this.setupConnector();
+  }
+  /**
+   * ============================================================
+   * Application communication methods
+   * ============================================================
+   */
+  async setupConnector() {
+    if (typeof window !== "undefined") {
+      try {
+        await this.ping();
+        window.dispatchEvent(new CustomEvent("FuelConnector", { detail: this }));
+      } catch (e) {
+        warn(e);
+      }
+    }
+  }
+  acceptMessage(message) {
+    const { data: event } = message;
+    return message.origin === window.origin && event.type !== "request" /* request */ && event.connectorName === this.name && event.target === CONNECTOR_SCRIPT;
+  }
+  setupListener() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    window.addEventListener(EVENT_MESSAGE, this.onMessage.bind(this));
+  }
+  createRequestId() {
+    return randomUUID();
+  }
+  postMessage(message, origin) {
+    window.postMessage(message, origin || window.origin);
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async sendRequest(request) {
+    if (!request) {
+      return;
+    }
+    this.postMessage({
+      type: "request" /* request */,
+      target: CONTENT_SCRIPT_NAME,
+      connectorName: this.name,
+      request
+    });
+  }
+  onResponse(message) {
+    this.client.receive(message.response);
+  }
+  onEvent(message) {
+    message.events.forEach((eventData) => {
+      if (eventData.event === "start") {
+        this.setupConnector();
+      } else {
+        this.emit(eventData.event, ...eventData.params);
+      }
+    });
+  }
+  onMessage = (message) => {
+    const messageFroze = Object.freeze(message);
+    if (!this.acceptMessage(messageFroze)) {
+      return;
+    }
+    const { data: event } = messageFroze;
+    this.onCommunicationMessage(event);
+  };
+  onCommunicationMessage = (message) => {
+    switch (message.type) {
+      case "response" /* response */:
+        this.onResponse(message);
+        break;
+      case "event" /* event */:
+        this.onEvent(message);
+        break;
+      default:
+    }
+  };
+  /**
+   * ============================================================
+   * Connector methods
+   * ============================================================
+   */
+  async ping() {
+    return this.client.timeout(800).request("ping", {});
+  }
+  async isConnected() {
+    try {
+      return await this.client.request("isConnected", {});
+    } catch {
+      return false;
+    }
+  }
+  async connect() {
+    return this.client.request("connect", {});
+  }
+  async disconnect() {
+    return this.client.request("disconnect", {});
+  }
+  async accounts() {
+    return this.client.request("accounts", {});
+  }
+  async currentAccount() {
+    return this.client.request("currentAccount", {});
+  }
+  async signMessage(address, message) {
+    if (!message.trim()) {
+      throw new Error("Message is required");
+    }
+    return this.client.request("signMessage", {
+      address,
+      message
+    });
+  }
+  async sendTransaction(address, transaction) {
+    if (!transaction) {
+      throw new Error("Transaction is required");
+    }
+    const txRequest = transactionRequestify(transaction);
+    const network = await this.currentNetwork();
+    const provider = {
+      url: network.url
+    };
+    return this.client.request("sendTransaction", {
+      address,
+      transaction: JSON.stringify(txRequest),
+      provider
+    });
+  }
+  async assets() {
+    return this.client.request("assets", {});
+  }
+  async addAsset(asset) {
+    return this.addAssets([asset]);
+  }
+  async addAssets(assets) {
+    const assetsData = assets.map((asset) => {
+      const fuelNetworkAsset = asset.networks.find((n) => n.type === "fuel");
+      if (!fuelNetworkAsset) {
+        throw new Error("Asset for Fuel Network not found!");
+      }
+      return {
+        ...asset,
+        imageUrl: asset.icon,
+        decimals: fuelNetworkAsset.decimals,
+        assetId: fuelNetworkAsset.assetId
+      };
+    });
+    return this.client.request("addAssets", {
+      assets: assetsData
+    });
+  }
+  async addABI(contractId, abi) {
+    return this.client.request("addAbi", {
+      abiMap: {
+        [contractId]: abi
+      }
+    });
+  }
+  async getABI(contractId) {
+    return this.client.request("getAbi", {
+      contractId
+    });
+  }
+  async hasABI(contractId) {
+    const abi = await this.getABI(contractId);
+    return !!abi;
+  }
+  async currentNetwork() {
+    return this.client.request("network", {});
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async selectNetwork(_network) {
+    throw new Error("Method not implemented.");
+  }
+  async networks() {
+    return this.client.request("networks", {});
+  }
+  async addNetwork(networkUrl) {
+    const provider = await Provider.create(networkUrl);
+    return this.client.request("addNetwork", {
+      network: {
+        url: provider.url,
+        name: provider.getChain().name
+      }
+    });
+  }
+  async version() {
+    return this.client.request("version", {
+      app: "0.0.0",
+      network: "0.0.0"
+    });
+  }
+};
+
+// src/connectors/fuel-wallet-development-connector.ts
+var FuelWalletDevelopmentConnector = class extends FuelWalletConnector {
+  metadata = {
+    image: "/connectors/fuel-wallet-dev.svg",
+    install: {
+      action: "Install",
+      description: "To connect your Fuel Wallet, you need to install the browser extension first.",
+      link: "https://chrome.google.com/webstore/detail/fuel-wallet-development/hcgmehahnlbhpilepakbdinkhhaackmc"
+    }
+  };
+  constructor() {
+    super("Fuel Wallet Development");
+  }
+};
+
+// src/connectors/fuelet-wallet-connector.ts
+var FueletWalletConnector = class extends FuelWalletConnector {
+  name = "Fuelet Wallet";
+  metadata = {
+    image: {
+      light: "/connectors/fuelet-light.svg",
+      dark: "/connectors/fuelet-dark.svg"
+    },
+    install: {
+      action: "Install",
+      description: "Install Fuelet Wallet in order to connect it.",
+      link: "https://fuelet.app/download/"
+    }
+  };
+  constructor() {
+    super("Fuelet Wallet");
+  }
+};
+
+// src/connectors/default-connector.ts
+function defaultConnectors({ devMode } = {}) {
+  const connectors = [new FuelWalletConnector(), new FueletWalletConnector()];
+  if (devMode) {
+    connectors.push(new FuelWalletDevelopmentConnector());
+  }
+  return connectors;
+}
+
+// src/connectors/fuel-wallet-locked.ts
+var FuelWalletLocked = class extends WalletLocked {
+  connector;
+  _provider;
+  constructor(address, connector, provider) {
+    super(address, provider);
+    this.connector = connector;
+    this._provider = provider;
+  }
+  async signMessage(message) {
+    return this.connector.signMessage(this.address.toString(), message);
+  }
+  async sendTransaction(transaction) {
+    const transactionId = await this.connector.sendTransaction(
+      this.address.toString(),
+      transaction
+    );
+    return this.provider.getTransactionResponse(transactionId);
+  }
+};
+
+// src/connectors/fuel-wallet-provider.ts
+var FuelWalletProvider = class extends Provider {
+  static async create(url, options) {
+    const provider = new FuelWalletProvider(url, options);
+    await provider.fetchChainAndNodeInfo();
+    return provider;
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async getTransactionResponse(transactionId) {
+    return new TransactionResponse(transactionId, this);
+  }
+};
+
+// src/connectors/utils/cache.ts
+function cacheFor(fn, { cache: cache2, cacheTime, key }) {
+  return async (...args) => {
+    if (cache2[key] && cache2[key]?.value) {
+      return cache2[key]?.value;
+    }
+    clearTimeout(cache2[key]?.timeout);
+    const result = await fn(...args);
+    cache2[key] = {
+      timeout: Number(
+        setTimeout(() => {
+          cache2[key] = null;
+        }, cacheTime)
+      ),
+      value: result
+    };
+    return result;
+  };
+}
+
+// src/connectors/utils/dispatch-fuel-connector-event.ts
+function dispatchFuelConnectorEvent(connector) {
+  window.dispatchEvent(
+    new CustomEvent(FuelConnectorEventType, {
+      detail: connector
+    })
+  );
+}
+
+// src/connectors/utils/get-asset-by-chain.ts
+function getAssetByChain(asset, chainId, network = "fuel") {
+  const assetFuelNetwork = asset.networks.find(
+    (item) => item.chainId === chainId && item.type === network
+  );
+  if (!assetFuelNetwork) {
+    throw new Error("Asset not found for the given chain and network.");
+  }
+  return {
+    ...asset,
+    assetId: assetFuelNetwork.assetId,
+    decimals: assetFuelNetwork.decimals,
+    chainId: assetFuelNetwork.chainId,
+    network: assetFuelNetwork.type
+  };
+}
+
+// src/connectors/utils/promises.ts
+function deferPromise() {
+  const defer = {};
+  defer.promise = new Promise((resolve, reject) => {
+    defer.reject = reject;
+    defer.resolve = resolve;
+  });
+  return defer;
+}
+async function withTimeout(promise, timeout = 1050) {
+  const timeoutPromise = new Promise((resolve, reject) => {
+    setTimeout(() => {
+      reject(new Error("Promise timed out"));
+    }, timeout);
+  });
+  return Promise.race([timeoutPromise, promise]);
+}
+
+// src/connectors/fuel.ts
+var HAS_CONNECTOR_TIMEOUT = 2e3;
+var PING_CACHE_TIME = 5e3;
+var _Fuel = class extends FuelConnector {
+  _storage = null;
+  _connectors = [];
+  _targetObject = null;
+  _unsubscribes = [];
+  _targetUnsubscribe;
+  _pingCache = {};
+  _currentConnector;
+  constructor(config = _Fuel.defaultConfig) {
+    super();
+    this.setMaxListeners(1e3);
+    this._connectors = config.connectors ?? defaultConnectors({
+      devMode: config.devMode
+    });
+    this._targetObject = this.getTargetObject(config.targetObject);
+    this._storage = config.storage === void 0 ? this.getStorage() : config.storage;
+    this.setupMethods();
+    this.setDefaultConnector();
+    this._targetUnsubscribe = this.setupConnectorListener();
+  }
+  /**
+   * Return the target object to listen for global events.
+   */
+  getTargetObject(targetObject) {
+    if (targetObject) {
+      return targetObject;
+    }
+    if (typeof window !== "undefined") {
+      return window;
+    }
+    if (typeof document !== "undefined") {
+      return document;
+    }
+    return null;
+  }
+  /**
+   * Return the storage used.
+   */
+  getStorage() {
+    if (typeof window !== "undefined") {
+      return window.localStorage;
+    }
+    return void 0;
+  }
+  /**
+   * Setup the default connector from the storage.
+   */
+  setDefaultConnector() {
+    const connectorName = this._storage?.getItem(_Fuel.STORAGE_KEY) || this._connectors[0]?.name;
+    if (connectorName) {
+      return this.selectConnector(connectorName, {
+        emitEvents: false
+      });
+    }
+    return void 0;
+  }
+  /**
+   * Start listener for all the events of the current
+   * connector and emit them to the Fuel instance
+   */
+  setupConnectorEvents(events) {
+    if (!this._currentConnector) {
+      return;
+    }
+    const currentConnector = this._currentConnector;
+    this._unsubscribes.map((unSub) => unSub());
+    this._unsubscribes = events.map((event) => {
+      const handler = (...args) => this.emit(event, ...args);
+      currentConnector.on(event, handler);
+      return () => currentConnector.off(event, handler);
+    });
+  }
+  /**
+   * Call method from the current connector.
+   */
+  async callMethod(method, ...args) {
+    const hasConnector = await this.hasConnector();
+    await this.pingConnector();
+    if (!this._currentConnector || !hasConnector) {
+      throw new Error(
+        `No connector selected for calling ${method}. Use hasConnector before executing other methods.`
+      );
+    }
+    if (typeof this._currentConnector[method] === "function") {
+      return this._currentConnector[method](...args);
+    }
+    return void 0;
+  }
+  /**
+   * Create a method for each method proxy that is available on the Common interface
+   * and call the method from the current connector.
+   */
+  setupMethods() {
+    Object.values(FuelConnectorMethods).forEach((method) => {
+      this[method] = async (...args) => this.callMethod(method, ...args);
+    });
+  }
+  /**
+   * Fetch the status of a connector and set the installed and connected
+   * status.
+   */
+  async fetchConnectorStatus(connector) {
+    const requestTimestamp = Date.now();
+    const [isConnected, ping] = await Promise.allSettled([
+      withTimeout(connector.isConnected()),
+      withTimeout(this.pingConnector(connector))
+    ]);
+    const isStale = requestTimestamp < (connector._latestUpdate || 0);
+    if (!isStale) {
+      connector._latestUpdate = Date.now();
+      connector.installed = ping.status === "fulfilled" && ping.value;
+      connector.connected = isConnected.status === "fulfilled" && isConnected.value;
+    }
+    return {
+      installed: connector.installed,
+      connected: connector.connected
+    };
+  }
+  /**
+   * Fetch the status of all connectors and set the installed and connected
+   * status.
+   */
+  async fetchConnectorsStatus() {
+    return Promise.all(
+      this._connectors.map(async (connector) => this.fetchConnectorStatus(connector))
+    );
+  }
+  /**
+   * Fetch the status of a connector and set the installed and connected
+   * status. If no connector is provided it will ping the current connector.
+   */
+  async pingConnector(connector) {
+    const curConnector = connector || this._currentConnector;
+    if (!curConnector) {
+      return false;
+    }
+    try {
+      return await cacheFor(async () => withTimeout(curConnector.ping()), {
+        key: curConnector.name,
+        cache: this._pingCache,
+        cacheTime: PING_CACHE_TIME
+      })();
+    } catch {
+      throw new Error("Current connector is not available.");
+    }
+  }
+  /**
+   * Setup a listener for the FuelConnector event and add the connector
+   * to the list of new connectors.
+   */
+  setupConnectorListener = () => {
+    const { _targetObject: targetObject } = this;
+    const eventName = FuelConnectorEventType;
+    if (targetObject?.on) {
+      targetObject.on(eventName, this.addConnector);
+      return () => {
+        targetObject.off?.(eventName, this.addConnector);
+      };
+    }
+    if (targetObject?.addEventListener) {
+      const handler = (e) => {
+        this.addConnector(e.detail);
+      };
+      targetObject.addEventListener(eventName, handler);
+      return () => {
+        targetObject.removeEventListener?.(eventName, handler);
+      };
+    }
+    return () => {
+    };
+  };
+  /**
+   * Add a new connector to the list of connectors.
+   */
+  addConnector = async (connector) => {
+    if (!this.getConnector(connector)) {
+      this._connectors.push(connector);
+    }
+    await this.fetchConnectorStatus(connector);
+    this.emit(this.events.connectors, this._connectors);
+    if (!this._currentConnector) {
+      await this.selectConnector(connector.name, {
+        emitEvents: false
+      });
+    }
+  };
+  triggerConnectorEvents = async () => {
+    const [isConnected, networks, currentNetwork] = await Promise.all([
+      this.isConnected(),
+      this.networks(),
+      this.currentNetwork()
+    ]);
+    this.emit(this.events.connection, isConnected);
+    this.emit(this.events.networks, networks);
+    this.emit(this.events.currentNetwork, currentNetwork);
+    if (isConnected) {
+      const [accounts, currentAccount] = await Promise.all([
+        this.accounts(),
+        this.currentAccount()
+      ]);
+      this.emit(this.events.accounts, accounts);
+      this.emit(this.events.currentAccount, currentAccount);
+    }
+  };
+  /**
+   * Get a connector from the list of connectors.
+   */
+  getConnector = (connector) => this._connectors.find((c) => {
+    const connectorName = typeof connector === "string" ? connector : connector.name;
+    return c.name === connectorName || c === connector;
+  }) || null;
+  /**
+   * Return the list of connectors with the status of installed and connected.
+   */
+  async connectors() {
+    await this.fetchConnectorsStatus();
+    return this._connectors;
+  }
+  /**
+   * Set the current connector to be used.
+   */
+  async selectConnector(connectorName, options = {
+    emitEvents: true
+  }) {
+    const connector = this.getConnector(connectorName);
+    if (!connector) {
+      return false;
+    }
+    if (this._currentConnector?.name === connectorName) {
+      return true;
+    }
+    const { installed } = await this.fetchConnectorStatus(connector);
+    if (installed) {
+      this._currentConnector = connector;
+      this.emit(this.events.currentConnector, connector);
+      this.setupConnectorEvents(Object.values(FuelConnectorEventTypes));
+      this._storage?.setItem(_Fuel.STORAGE_KEY, connector.name);
+      if (options.emitEvents) {
+        this.triggerConnectorEvents();
+      }
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Return the current selected connector.
+   */
+  currentConnector() {
+    return this._currentConnector;
+  }
+  /**
+   * Return true if any connector is available.
+   */
+  async hasConnector() {
+    if (this._currentConnector) {
+      return true;
+    }
+    const defer = deferPromise();
+    this.once(this.events.currentConnector, () => {
+      defer.resolve(true);
+    });
+    return withTimeout(defer.promise, HAS_CONNECTOR_TIMEOUT).then(() => true).catch(() => false);
+  }
+  async hasWallet() {
+    return this.hasConnector();
+  }
+  /**
+   * Return a Fuel Provider instance with extends features to work with
+   * connectors.
+   *
+   * @deprecated Provider is going to be deprecated in the future.
+   */
+  async getProvider(providerOrNetwork) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        "Get provider is deprecated, use getWallet instead. Provider is going to be removed in the future."
+      );
+    }
+    return this._getProvider(providerOrNetwork);
+  }
+  /**
+   * Return a Fuel Provider instance with extends features to work with
+   * connectors.
+   */
+  async _getProvider(providerOrNetwork) {
+    let provider;
+    if (providerOrNetwork && "getTransactionResponse" in providerOrNetwork) {
+      provider = providerOrNetwork;
+    } else if (providerOrNetwork && "chainId" in providerOrNetwork && "url" in providerOrNetwork) {
+      provider = await FuelWalletProvider.create(providerOrNetwork.url);
+    } else if (!providerOrNetwork) {
+      const currentNetwork = await this.currentNetwork();
+      provider = await FuelWalletProvider.create(currentNetwork.url);
+    } else {
+      throw new Error("Provider is not valid.");
+    }
+    return provider;
+  }
+  /**
+   * Return a Fuel Wallet Locked instance with extends features to work with
+   * connectors.
+   */
+  async getWallet(address, providerOrNetwork) {
+    const provider = await this._getProvider(providerOrNetwork);
+    return new FuelWalletLocked(address, this, provider);
+  }
+  /**
+   * Remove all open listeners this is useful when you want to
+   * remove the Fuel instance and avoid memory leaks.
+   */
+  unsubscribe() {
+    this._unsubscribes.map((unSub) => unSub());
+    this._targetUnsubscribe();
+    this.removeAllListeners();
+  }
+  /**
+   * Clean all the data from the storage.
+   */
+  clean() {
+    this._storage?.removeItem(_Fuel.STORAGE_KEY);
+  }
+  /**
+   * Removes all listeners and cleans the storage.
+   */
+  destroy() {
+    this.unsubscribe();
+    this.clean();
+  }
+};
+var Fuel = _Fuel;
+__publicField(Fuel, "STORAGE_KEY", "fuel-current-connector");
+__publicField(Fuel, "defaultConfig", {});
 export {
   Account,
   AddressType,
+  BACKGROUND_SCRIPT_NAME,
   BaseTransactionRequest,
   BaseWalletUnlocked,
+  CONNECTOR_SCRIPT,
+  CONTENT_SCRIPT_NAME,
   ChainName,
   ChangeOutputCollisionError,
   CreateTransactionRequest,
+  EVENT_MESSAGE,
+  Fuel,
+  FuelConnector,
+  FuelConnectorEventType,
+  FuelConnectorEventTypes,
+  FuelConnectorMethods,
+  FuelWalletConnector,
+  FuelWalletDevelopmentConnector,
+  FuelWalletLocked,
+  FuelWalletProvider,
+  FueletWalletConnector,
   hdwallet_default as HDWallet,
   Language,
   MNEMONIC_SIZES,
+  MessageTypes,
   mnemonic_default as Mnemonic,
   NoWitnessAtIndexError,
   NoWitnessByOwnerError,
   OperationName,
+  POPUP_SCRIPT_NAME,
   Predicate,
   Provider,
   ScriptTransactionRequest,
@@ -8559,6 +9548,7 @@ export {
   TransactionStatus,
   TransactionType,
   TransactionTypeName,
+  VAULT_SCRIPT_NAME,
   Vault,
   Wallet,
   WalletLocked,
@@ -8569,11 +9559,15 @@ export {
   assembleReceiptByType,
   assembleTransactionSummary,
   buildBlockExplorerUrl,
+  cacheFor,
   calculateMetadataGasForTxCreate,
   calculateMetadataGasForTxScript,
   calculatePriceWithFactor,
   calculateTransactionFee,
   coinQuantityfy,
+  defaultConnectors,
+  deferPromise,
+  dispatchFuelConnectorEvent,
   english,
   extractBurnedAssetsFromReceipts,
   extractMintedAssetsFromReceipts,
@@ -8582,6 +9576,7 @@ export {
   fromTai64ToUnix,
   fromUnixToTai64,
   gasUsedByInputs,
+  getAssetByChain,
   getContractCallOperations,
   getContractCreatedOperations,
   getContractTransferOperations,
@@ -8637,6 +9632,7 @@ export {
   returnZeroScript,
   sleep,
   transactionRequestify,
+  withTimeout,
   withdrawScript
 };
 //# sourceMappingURL=index.mjs.map