@tomo-inc/inject-providers 0.0.2 → 0.0.4

package/dist/index.js

@@ -0,0 +1,1985 @@
+import { ethErrors, EthereumRpcError } from 'eth-rpc-errors';
+import { EventEmitter } from 'events';
+import { JsonRpcEngine, createIdRemapMiddleware } from 'json-rpc-engine';
+import { createStreamMiddleware } from 'json-rpc-middleware-stream';
+import { toHex } from 'viem';
+import { PublicKey, VersionedTransaction, Transaction } from '@solana/web3.js';
+import bs58 from 'bs58';
+import { TronWeb } from 'tronweb';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/utils/dapp-info.ts
+var $ = document.querySelector.bind(document);
+async function getDappInfo() {
+  var _a;
+  return {
+    origin: (_a = window.top) == null ? void 0 : _a.location.origin,
+    // host: window.location.hostname,
+    favicon: await getSiteIcon(),
+    title: getSiteName(window),
+    desc: getSiteDesc(window)
+  };
+}
+function getSiteName(windowObject) {
+  const { document: document2 } = windowObject;
+  const siteName = document2.querySelector('head > meta[property="og:site_name"]');
+  if (siteName) {
+    return siteName.content;
+  }
+  const metaTitle = document2.querySelector('head > meta[name="title"]');
+  if (metaTitle) {
+    return metaTitle.content;
+  }
+  if (document2.title && document2.title.length > 0) {
+    return document2.title;
+  }
+  return window.location.hostname;
+}
+function getSiteDesc(windowObject) {
+  const { document: document2 } = windowObject;
+  const siteName = document2.querySelector('head > meta[property="og:description"]');
+  if (siteName) {
+    return siteName.content;
+  }
+  const siteNameX = document2.querySelector('head > meta[property="twitter:description"]');
+  if (siteNameX) {
+    return siteNameX.content;
+  }
+  const metaTitle = document2.querySelector('head > meta[name="description"]');
+  if (metaTitle) {
+    return metaTitle.content;
+  }
+  if (document2.title && document2.title.length > 0) {
+    return document2.title;
+  }
+  return document2.body.innerText.split("\n")[0] || "";
+}
+async function getSiteIcon(windowObject) {
+  var _a, _b;
+  const icon = ((_a = $('head > link[rel~="icon"]')) == null ? void 0 : _a.href) || ((_b = $('head > meta[itemprop="image"]')) == null ? void 0 : _b.content);
+  if (!icon) {
+    return "";
+  }
+  const isOK = await imgExists(icon);
+  if (isOK) {
+    return icon;
+  }
+  return "";
+}
+function imgExists(url) {
+  return new Promise((resolve, reject) => {
+    try {
+      const img = document.createElement("img");
+      img.onload = () => resolve(true);
+      img.onerror = () => resolve(false);
+      img.src = url;
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+
+// src/utils/dom.ts
+var domReadyCall = (callback) => {
+  if (document.readyState === "complete") {
+    callback();
+  } else {
+    const domContentLoadedHandler = (e) => {
+      callback();
+      document.removeEventListener("DOMContentLoaded", domContentLoadedHandler);
+    };
+    document.addEventListener("DOMContentLoaded", domContentLoadedHandler);
+  }
+};
+
+// src/utils/ready-promise.ts
+var ReadyPromise = class {
+  constructor(count) {
+    this._allCheck = [];
+    this._tasks = [];
+    this.check = (index) => {
+      this._allCheck[index - 1] = true;
+      this._proceed();
+    };
+    this.uncheck = (index) => {
+      this._allCheck[index - 1] = false;
+    };
+    this._proceed = () => {
+      if (this._allCheck.some((_) => !_)) {
+        return;
+      }
+      while (this._tasks.length) {
+        const { resolve, fn } = this._tasks.shift();
+        resolve(fn());
+      }
+    };
+    this.call = (fn) => {
+      return new Promise((resolve) => {
+        this._tasks.push({
+          fn,
+          resolve
+        });
+        this._proceed();
+      });
+    };
+    this._allCheck = [...Array(count)];
+  }
+};
+
+// src/utils/utils.ts
+function hexToUint8Array(hexString) {
+  const cleanHex = hexString.startsWith("0x") ? hexString.slice(2) : hexString;
+  if (cleanHex.length !== 128) {
+    throw new Error("Invalid signature length");
+  }
+  const bytes = new Uint8Array(64);
+  for (let i = 0; i < 64; i++) {
+    bytes[i] = parseInt(cleanHex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function isHexString(str) {
+  const hexRegex = /^(0x)?[0-9a-fA-F]+$/;
+  return hexRegex.test(str);
+}
+
+// src/btc/unisat.ts
+var chainType = "btc" /* BTC */;
+var BtcProvider = class extends EventEmitter {
+  constructor(productInfo, { sendRequest, onResponse }) {
+    super();
+    this._selectedAddress = null;
+    this._isConnected = false;
+    this._initialized = false;
+    this._isUnlocked = false;
+    this.rdns = "";
+    this.name = "";
+    this.chainId = "BITCOIN_MAINNET";
+    this._state = {
+      accounts: null,
+      isConnected: false,
+      isUnlocked: false,
+      initialized: false,
+      isPermanentlyDisconnected: false
+    };
+    this._requestPromise = new ReadyPromise(0);
+    this.initialize = async () => {
+      document.addEventListener("visibilitychange", async () => {
+        if (document.visibilityState === "visible") {
+          this._request({
+            method: "wallet_sendDomainMetadata",
+            params: await getDappInfo()
+          });
+        }
+      });
+      domReadyCall(async () => {
+        this._request({
+          method: "wallet_sendDomainMetadata",
+          params: await getDappInfo()
+        });
+      });
+      window.addEventListener("message", (event) => {
+        const { data, type, method } = event.data;
+        if (type === "subscribeWalletEvents" && method) {
+          this.subscribeWalletEventsCallback({ data, method });
+        }
+      });
+      this._state.initialized = true;
+      this._state.isConnected = true;
+      this.keepAlive();
+    };
+    this.subscribeWalletEventsCallback = ({ method, data }) => {
+      if (method === "accountsChanged") {
+        const addresses = (data == null ? void 0 : data[chainType]) || [];
+        const accounts = addresses.map(({ address }) => address);
+        this._handleAccountsChanged(accounts);
+      }
+      if (method === "chainChanged") {
+        const { chainId, type } = data;
+        if (type.indexOf(`${chainType}:`) === 0) {
+          this._handleChainChanged({ chainId, isConnected: true });
+        }
+      }
+    };
+    /**
+     * Sending a message to the extension to receive will keep the service worker alive.
+     */
+    this.keepAlive = () => {
+      this._request({
+        method: "keepAlive",
+        params: {}
+      }).then((v) => {
+        setTimeout(() => {
+          this.keepAlive();
+        }, 1e3);
+      });
+    };
+    //adapter data by reuqest function
+    this._request = async ({ method, params }, adapter) => {
+      if (!method) {
+        throw ethErrors.rpc.invalidRequest();
+      }
+      const dappInfo = await getDappInfo();
+      this.sendRequest(chainType, { method, params, dappInfo });
+      const connectFuns = {
+        getAccounts: true,
+        requestAccounts: true
+      };
+      return this.onResponse({ method }).then((res) => {
+        const { data } = res || {};
+        if (method === "wallet_switchEthereumChain") {
+          this._handleChainChanged({ chainId: data, isConnected: true });
+        }
+        if (method === "connect" && (data == null ? void 0 : data.address)) {
+          this._handleAccountsChanged([data == null ? void 0 : data.address]);
+        }
+        if (method in connectFuns && connectFuns[method]) {
+          this._handleAccountsChanged(data || []);
+        }
+        return adapter ? adapter(data) : data;
+      });
+    };
+    this.request = async ({ method, params }) => {
+      if (!method) {
+        throw ethErrors.rpc.invalidRequest();
+      }
+      return this._request({
+        method,
+        params
+      });
+    };
+    //res = { address, approved, balance, publicKey }
+    this.connect = async () => {
+      return this._request({
+        method: "connect"
+      });
+    };
+    //res = { disconnected }
+    this.disconnect = async () => {
+      return this._request({
+        method: "disconnect"
+      });
+    };
+    //unisat public methods
+    this.requestAccounts = async () => {
+      return this._request({
+        method: "requestAccounts"
+      });
+    };
+    this.getAccounts = async () => {
+      return this._request({
+        method: "getAccounts"
+      });
+    };
+    this.getPublicKey = async () => {
+      return this._request({
+        method: "getPublicKey"
+      });
+    };
+    //res = { address, balance }
+    this.getBalance = async () => {
+      return this._request({
+        method: "getBalance"
+      });
+    };
+    //res = {status === 'confirmed', confirmations > 1}
+    this.getTransactionStatus = async ({ txId }) => {
+      return this._request({
+        method: "getTransactionStatus",
+        params: { txId }
+      });
+    };
+    this.signMessage = async (text, type) => {
+      return this._request({
+        method: "signMessage",
+        params: {
+          text,
+          type
+        }
+      });
+    };
+    this.getNetwork = async () => {
+      return this._request({
+        method: "getNetwork"
+      });
+    };
+    this.switchNetwork = async (network) => {
+      return this._request({
+        method: "switchNetwork",
+        params: {
+          network
+        }
+      });
+    };
+    this.getChain = async () => {
+      return this._request({
+        method: "getChain"
+      });
+    };
+    this.switchChain = async (chainId) => {
+      return this._request({
+        method: "switchChain",
+        params: {
+          chainId
+        }
+      });
+    };
+    this.signPsbt = async (psbtHex, options) => {
+      return this._request({
+        method: "signPsbt",
+        params: {
+          psbtHex,
+          options: {
+            autoFinalized: options == null ? void 0 : options.autoFinalized
+          }
+        }
+      });
+    };
+    this.signPsbts = async (psbtHexs, options) => {
+      return this._request({
+        method: "signPsbts",
+        params: {
+          psbtHexs,
+          options
+        }
+      });
+    };
+    this.pushPsbt = async (psbtHex) => {
+      return this._request({
+        method: "pushPsbt",
+        params: {
+          psbtHex
+        }
+      });
+    };
+    this.sendBitcoin = async (toAddress, satoshis, options) => {
+      return this._request({
+        method: "sendBitcoin",
+        params: {
+          to: toAddress,
+          amount: satoshis,
+          feeRate: options == null ? void 0 : options.feeRate
+        }
+      });
+    };
+    this.signTx = async (rawtx) => {
+      return this._request({
+        method: "signTx",
+        params: {
+          rawtx
+        }
+      });
+    };
+    this.pushTx = async (rawtx) => {
+      return this._request({
+        method: "pushTx",
+        params: {
+          rawtx
+        }
+      });
+    };
+    this.name = productInfo.name;
+    this.rdns = productInfo.rdns;
+    this._handleAccountsChanged = this._handleAccountsChanged.bind(this);
+    this.setMaxListeners(100);
+    this.sendRequest = sendRequest;
+    this.onResponse = onResponse;
+    this.initialize();
+  }
+  _handleChainChanged({ chainId, isConnected } = {}) {
+    if (!chainId || typeof chainId !== "string" || !chainId.startsWith("0x")) {
+      return;
+    }
+    if (!isConnected || chainId === this.chainId || !this._state.initialized) {
+      return;
+    }
+    this.chainId = chainId;
+    this.emit("chainChanged", this.chainId);
+  }
+  _handleAccountsChanged(accounts) {
+    let _accounts = accounts;
+    if (!Array.isArray(accounts)) {
+      console.error("BTC: Received invalid accounts parameter.", accounts);
+      _accounts = [];
+    }
+    if (this._state.accounts !== _accounts) {
+      this._state.accounts = _accounts;
+      this._selectedAddress = _accounts[0];
+      if (this._state.initialized) {
+        this.emit("accountsChanged", accounts);
+      }
+    }
+  }
+};
+var chainType2 = "doge" /* DOGE */;
+var DogecoinProvider = class extends EventEmitter {
+  constructor(productInfo, { sendRequest, onResponse }) {
+    super();
+    this._selectedAddress = null;
+    this._network = null;
+    this._isConnected = false;
+    this._initialized = false;
+    this._isUnlocked = false;
+    this.rdns = "";
+    this.name = "";
+    this._state = {
+      accounts: null,
+      isConnected: false,
+      isUnlocked: false,
+      initialized: false,
+      isPermanentlyDisconnected: false
+    };
+    this._requestPromise = new ReadyPromise(0);
+    this.initialize = async () => {
+      document.addEventListener("visibilitychange", async () => {
+        if (document.visibilityState === "visible") {
+          this._request({
+            method: "wallet_sendDomainMetadata",
+            params: await getDappInfo()
+          });
+        }
+      });
+      domReadyCall(async () => {
+        this._request({
+          method: "wallet_sendDomainMetadata",
+          params: await getDappInfo()
+        });
+      });
+      this._state.initialized = true;
+      this._state.isConnected = true;
+      this.keepAlive();
+    };
+    /**
+     * Sending a message to the extension to receive will keep the service worker alive.
+     */
+    this.keepAlive = () => {
+      this._request({
+        method: "keepAlive",
+        params: {}
+      }).then((v) => {
+        setTimeout(() => {
+          this.keepAlive();
+        }, 1e3);
+      });
+    };
+    //adapter data by reuqest function
+    this._request = async ({ method, params }, adapter) => {
+      if (!method) {
+        throw ethErrors.rpc.invalidRequest();
+      }
+      const dappInfo = await getDappInfo();
+      this.sendRequest(chainType2, { method, params, dappInfo });
+      return this.onResponse({ method }).then((res) => {
+        const { data } = res || {};
+        return adapter ? adapter(data) : data;
+      });
+    };
+    this.request = async ({ method, params }) => {
+      if (!method) {
+        throw ethErrors.rpc.invalidRequest();
+      }
+      return this._request({
+        method,
+        params
+      });
+    };
+    //res = { address, approved, balance, publicKey }
+    this.connect = async () => {
+      return this._request({
+        method: "connect",
+        params: {}
+      });
+    };
+    //res = { address, balance }
+    this.getBalance = async () => {
+      return this._request({
+        method: "getBalance"
+      });
+    };
+    //res = { disconnected }
+    this.disconnect = async () => {
+      return this._request({
+        method: "disconnect",
+        params: {}
+      });
+    };
+    //res = { "connected, address, selectedWalletAddress }
+    this.getConnectionStatus = async () => {
+      return this._request({
+        method: "getConnectionStatus",
+        params: {}
+      });
+    };
+    //res = { txId }
+    this.requestTransaction = async ({ recipientAddress, dogeAmount }) => {
+      return this._request({
+        method: "requestTransaction",
+        params: {
+          to: recipientAddress,
+          amount: dogeAmount,
+          type: 3 /* SEND_DOGECOIN */
+        }
+      });
+    };
+    //res = {status === 'confirmed', confirmations > 1}
+    this.getTransactionStatus = async ({ txId }) => {
+      return this._request({
+        method: "getTransactionStatus",
+        params: { txId }
+      });
+    };
+    //res = { signedMessage }
+    this.requestSignedMessage = async ({ message, type = "" }) => {
+      return this._request({
+        method: "requestSignedMessage",
+        params: {
+          text: message,
+          type
+        }
+      });
+    };
+    //res = { decryptedMessage }
+    this.requestDecryptedMessage = async ({ message }) => {
+      return this._request({
+        method: "requestDecryptedMessage",
+        params: {
+          message
+        }
+      });
+    };
+    //res = { signedMessage }
+    this.getDRC20Balances = async (address, ticker) => {
+      return this._request({
+        method: "getDRC20Balances",
+        params: {
+          address,
+          ticker
+        }
+      });
+    };
+    //res = { availableBalance, transferableBalance, ticker, address }
+    this.getDRC20Balance = async ({ ticker }) => {
+      return this._request({
+        method: "getDRC20Balance",
+        params: {
+          ticker
+        }
+      });
+    };
+    //res = { inscriptions, ticker, address }
+    this.getTransferableDRC20 = async ({ ticker }) => {
+      return this._request({
+        method: "getTransferableDRC20",
+        params: {
+          ticker
+        }
+      });
+    };
+    //res = { txId, ticker, amount }
+    this.requestAvailableDRC20Transaction = async ({ ticker, amount }) => {
+      return this._request({
+        method: "requestAvailableDRC20Transaction",
+        params: {
+          ticker,
+          amount
+        }
+      });
+    };
+    //res = { txId }
+    this.requestInscriptionTransaction = async ({
+      location,
+      recipientAddress
+    }) => {
+      return this._request({
+        method: "requestInscriptionTransaction",
+        params: {
+          location,
+          recipientAddress
+        }
+      });
+    };
+    //res = { ?signedRawTx, ?txId }
+    this.requestPsbt = async ({
+      rawTx,
+      indexes,
+      feeOnly,
+      signOnly,
+      partial,
+      sighashType
+    }) => {
+      return this._request({
+        method: "requestPsbt",
+        params: {
+          rawTx,
+          indexes,
+          feeOnly,
+          signOnly,
+          partial,
+          sighashType
+        }
+      });
+    };
+    //---------//dunes
+    this.getDunesBalance = async (params) => {
+      return this._request({
+        method: "getDunesBalance",
+        params
+      });
+    };
+    this.requestDunesTransaction = async ({
+      ticker,
+      amount,
+      recipientAddress
+    }) => {
+      return this._request({
+        method: "requestDunesTransaction",
+        params: {
+          ticker,
+          amount,
+          recipientAddress
+        }
+      });
+    };
+    this.name = productInfo.name;
+    this.rdns = productInfo.rdns;
+    this.setMaxListeners(100);
+    this.sendRequest = sendRequest;
+    this.onResponse = onResponse;
+    this.initialize();
+  }
+};
+
+// src/evm/messages.ts
+var ProductInfo = { name: "ethereum.provider" };
+var messages = {
+  errors: {
+    disconnected: () => `${ProductInfo.name}: Disconnected from chain. Attempting to connect.`,
+    permanentlyDisconnected: () => `${ProductInfo.name}: Disconnected from ${ProductInfo.name} background. Page reload required.`,
+    sendSiteMetadata: () => `${ProductInfo.name}: Failed to send site metadata. This is an internal error, please report this bug.`,
+    unsupportedSync: (method) => `${ProductInfo.name}: The ${ProductInfo.name} Ethereum provider does not support synchronous methods like ${method} without a callback parameter.`,
+    invalidDuplexStream: () => "Must provide a Node.js-style duplex stream.",
+    invalidOptions: (maxEventListeners, shouldSendMetadata) => `Invalid options. Received: { maxEventListeners: ${maxEventListeners}, shouldSendMetadata: ${shouldSendMetadata} }`,
+    invalidRequestArgs: () => `Expected a single, non-array, object argument.`,
+    invalidRequestMethod: () => `'args.method' must be a non-empty string.`,
+    invalidRequestParams: () => `'args.params' must be an object or array if provided.`,
+    invalidLoggerObject: () => `'args.logger' must be an object if provided.`,
+    invalidLoggerMethod: (method) => `'args.logger' must include required method '${method}'.`
+  },
+  warnings: {
+    // deprecated methods
+    enableDeprecation: `${ProductInfo.name}: 'ethereum.enable()' is deprecated and may be removed in the future. Please use the 'eth_requestAccounts' RPC method instead.
+For more information, see: https://eips.ethereum.org/EIPS/eip-1102`,
+    sendDeprecation: `${ProductInfo.name}: 'ethereum.send(...)' is deprecated and may be removed in the future. Please use 'ethereum.sendAsync(...)' or 'ethereum.request(...)' instead.
+For more information, see: https://eips.ethereum.org/EIPS/eip-1193`,
+    // deprecated events
+    events: {
+      close: `${ProductInfo.name}: The event 'close' is deprecated and may be removed in the future. Please use 'disconnect' instead.
+For more information, see: https://eips.ethereum.org/EIPS/eip-1193#disconnect`,
+      data: `${ProductInfo.name}: The event 'data' is deprecated and will be removed in the future. Use 'message' instead.
+For more information, see: https://eips.ethereum.org/EIPS/eip-1193#message`,
+      networkChanged: `${ProductInfo.name}: The event 'networkChanged' is deprecated and may be removed in the future. Use 'chainChanged' instead.
+For more information, see: https://eips.ethereum.org/EIPS/eip-1193#chainchanged`,
+      notification: `${ProductInfo.name}: The event 'notification' is deprecated and may be removed in the future. Use 'message' instead.
+For more information, see: https://eips.ethereum.org/EIPS/eip-1193#message`
+    }}
+};
+var messages_default = messages;
+function createErrorMiddleware(log) {
+  return (req, res, next) => {
+    if (typeof req.method !== "string" || !req.method) {
+      res.error = ethErrors.rpc.invalidRequest({
+        message: `The request 'method' must be a non-empty string.`,
+        data: req
+      });
+    }
+    next((done) => {
+      const { error } = res;
+      if (!error) {
+        return done();
+      }
+      log.error(`RPC Error: ${error.message}`, error);
+      return done();
+    });
+  };
+}
+var getRpcPromiseCallback = (resolve, reject, unwrapResult = true) => (error, response) => {
+  if (error || response.error) {
+    reject(error || response.error);
+  } else {
+    !unwrapResult || Array.isArray(response) ? resolve(response) : resolve(response.result);
+  }
+};
+function logStreamDisconnectWarning(log, remoteLabel, error, emitter) {
+  let warningMsg = `Lost connection to "${remoteLabel}".`;
+  if (error == null ? void 0 : error.stack) {
+    warningMsg += `
+${error.stack}`;
+  }
+  log.warn(warningMsg);
+  if (emitter && emitter.listenerCount("error") > 0) {
+    emitter.emit("error", warningMsg);
+  }
+}
+var NOOP = () => void 0;
+var EMITTED_NOTIFICATIONS = [
+  "eth_subscription"
+  // per eth-json-rpc-filters/subscriptionManager
+];
+
+// src/evm/metamask.ts
+var chainType3 = "evm" /* EVM */;
+var EvmProvider = class extends EventEmitter {
+  /**
+   * @param connectionStream - A Node.js duplex stream
+   * @param options - An options bag
+   * @param options.jsonRpcStreamName - The name of the internal JSON-RPC stream.
+   * @param options.logger - The logging API to use. Default: console
+   * @param options.maxEventListeners - The maximum number of event
+   * listeners. Default: 100
+   * @param options.shouldSendMetadata - Whether the provider should
+   * send page metadata. Default: true
+   */
+  constructor(productInfo, {
+    logger = console,
+    maxEventListeners = 100,
+    shouldSendMetadata = true,
+    sendRequest,
+    onResponse
+  }) {
+    if (typeof maxEventListeners !== "number" || typeof shouldSendMetadata !== "boolean") {
+      throw new Error(messages_default.errors.invalidOptions(maxEventListeners, shouldSendMetadata));
+    }
+    validateLoggerObject(logger);
+    super();
+    this.subscribeWalletEventsCallback = ({ method, data }) => {
+      if (method === "accountsChanged") {
+        const addresses = (data == null ? void 0 : data[chainType3]) || [];
+        const accounts = addresses.map(({ address }) => address);
+        this._handleAccountsChanged(accounts, true);
+      }
+      if (method === "chainChanged") {
+        const { chainId, type } = data;
+        if (type.indexOf(`${chainType3}:`) === 0) {
+          const chainIdHex = toHex(parseInt(chainId));
+          this._handleChainChanged({ chainId: chainIdHex, isConnected: true });
+        }
+      }
+    };
+    this.keepAlive = () => {
+      this.request({
+        method: "keepAlive",
+        params: {}
+      }).then(() => {
+        setTimeout(() => {
+          this.keepAlive();
+        }, 1e3);
+      });
+    };
+    this._log = logger;
+    this.name = productInfo.name;
+    this.icon = productInfo.icon;
+    this.sendRequest = sendRequest;
+    this.onResponse = onResponse;
+    this.setMaxListeners(maxEventListeners);
+    this._state = {
+      sentWarnings: {
+        // methods
+        enable: false,
+        experimentalMethods: false,
+        send: false,
+        // events
+        events: {
+          close: false,
+          data: false,
+          networkChanged: false,
+          notification: false
+        }
+      },
+      accounts: null,
+      isConnected: false,
+      isUnlocked: false,
+      initialized: true,
+      isPermanentlyDisconnected: false
+    };
+    this.selectedAddress = null;
+    this.networkVersion = null;
+    this.chainId = null;
+    this._handleAccountsChanged = this._handleAccountsChanged.bind(this);
+    this._handleConnect = this._handleConnect.bind(this);
+    this._handleChainChanged = this._handleChainChanged.bind(this);
+    this._handleDisconnect = this._handleDisconnect.bind(this);
+    this._handleStreamDisconnect = this._handleStreamDisconnect.bind(this);
+    this._handleUnlockStateChanged = this._handleUnlockStateChanged.bind(this);
+    this._sendSync = this._sendSync.bind(this);
+    this._rpcRequest = this._rpcRequest.bind(this);
+    this._warnOfDeprecation = this._warnOfDeprecation.bind(this);
+    this.enable = this.enable.bind(this);
+    this.connect = this.connect.bind(this);
+    this.disconnect = this.disconnect.bind(this);
+    this.request = this.request.bind(this);
+    this.send = this.send.bind(this);
+    this.sendAsync = this.sendAsync.bind(this);
+    this.on("connect", () => {
+      this._state.isConnected = true;
+    });
+    const jsonRpcConnection = createStreamMiddleware();
+    const rpcEngine = new JsonRpcEngine();
+    rpcEngine.push(createIdRemapMiddleware());
+    rpcEngine.push(createErrorMiddleware(this._log));
+    rpcEngine.push(jsonRpcConnection.middleware);
+    this._rpcEngine = rpcEngine;
+    this._initializeState();
+    jsonRpcConnection.events.on("notification", (payload) => {
+      const { method, params } = payload;
+      if (method === "wallet_accountsChanged") {
+        this._handleAccountsChanged(params);
+      } else if (method === "wallet_unlockStateChanged") {
+        this._handleUnlockStateChanged(params);
+      } else if (method === "wallet_chainChanged") {
+        this._handleChainChanged(params);
+      } else if (EMITTED_NOTIFICATIONS.includes(method)) {
+        this.emit("data", payload);
+        this.emit("message", {
+          type: method,
+          data: params
+        });
+        this.emit("notification", payload.params.result);
+      } else if (method === "WALLET_STREAM_FAILURE") {
+        console.error(messages_default.errors.permanentlyDisconnected());
+      }
+    });
+  }
+  //====================
+  // Public Methods
+  //====================
+  /**
+   * Returns whether the provider can process RPC requests.
+   */
+  isConnected() {
+    return this._state.isConnected;
+  }
+  /**
+   * Submits an RPC request for the given method, with the given params.
+   * Resolves with the result of the method call, or rejects on error.
+   *
+   * @param args - The RPC request arguments.
+   * @param args.method - The RPC method name.
+   * @param args.params - The parameters for the RPC method.
+   * @returns A Promise that resolves with the result of the RPC method,
+   * or rejects if an error is encountered.
+   */
+  async request(args) {
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+      throw ethErrors.rpc.invalidRequest({
+        message: messages_default.errors.invalidRequestArgs(),
+        data: args
+      });
+    }
+    const { method, params } = args;
+    if (typeof method !== "string" || method.length === 0) {
+      throw ethErrors.rpc.invalidRequest({
+        message: messages_default.errors.invalidRequestMethod(),
+        data: args
+      });
+    }
+    if (method === "wallet_addEthereumChain") {
+      if (!Array.isArray(params) || params.length === 0) {
+        throw ethErrors.rpc.invalidRequest({
+          message: messages_default.errors.invalidRequestParams(),
+          data: args
+        });
+      }
+      const network = params[0];
+      if (!network || !network.chainName || !network.rpcUrls || !network.chainId || !network.nativeCurrency) {
+        throw ethErrors.rpc.invalidRequest({
+          message: messages_default.errors.invalidRequestParams(),
+          data: args
+        });
+      }
+    }
+    if (method === "personal_sign") {
+      if (!Array.isArray(params) || params.length !== 2 || !params[0] || !params[1]) {
+        throw ethErrors.rpc.invalidRequest({
+          message: messages_default.errors.invalidRequestParams(),
+          data: args
+        });
+      }
+    }
+    if (method === "wallet_watchAsset") {
+      const { type, options } = params;
+      const isNotCompelete = !options || !options.address || !options.symbol || !options.decimals;
+      if (!type || isNotCompelete) {
+        throw ethErrors.rpc.invalidRequest({
+          message: messages_default.errors.invalidRequestParams(),
+          data: args
+        });
+      }
+    }
+    if (params !== void 0 && !Array.isArray(params) && (typeof params !== "object" || params === null)) {
+      throw ethErrors.rpc.invalidRequest({
+        message: messages_default.errors.invalidRequestParams(),
+        data: args
+      });
+    }
+    const connectFuns = {
+      enable: true,
+      connect: true,
+      eth_accounts: true,
+      eth_requestAccounts: true
+    };
+    const dappInfo = await getDappInfo();
+    args = __spreadValues(__spreadValues({}, args), { dappInfo });
+    this.sendRequest(chainType3, args);
+    return this.onResponse(args).then((res) => {
+      const { data, method: method2 } = res || {};
+      if (method2 === "_wallet_getProviderState") {
+        this._handleAccountsChanged((data == null ? void 0 : data.accounts) || [], true);
+      }
+      if (method2 === "wallet_revokePermissions") {
+        this._handleAccountsChanged([], true);
+      }
+      if (method2 in connectFuns && connectFuns[method2]) {
+        this._handleAccountsChanged(data || [], true);
+      }
+      if (method2 === "wallet_switchEthereumChain" || method2 === "eth_chainId") {
+        this._handleChainChanged({ chainId: data, isConnected: true });
+      }
+      return data;
+    });
+  }
+  /**
+   * Submits an RPC request per the given JSON-RPC request object.
+   *
+   * @param payload - The RPC request object.
+   * @param cb - The callback function.
+   */
+  sendAsync(payload, callback) {
+    this._rpcRequest(payload, callback);
+  }
+  /**
+   * We override the following event methods so that we can warn consumers
+   * about deprecated events:
+   *   addListener, on, once, prependListener, prependOnceListener
+   */
+  addListener(eventName, listener) {
+    this._warnOfDeprecation(eventName);
+    return super.addListener(eventName, listener);
+  }
+  on(eventName, listener) {
+    this._warnOfDeprecation(eventName);
+    return super.on(eventName, listener);
+  }
+  once(eventName, listener) {
+    this._warnOfDeprecation(eventName);
+    return super.once(eventName, listener);
+  }
+  prependListener(eventName, listener) {
+    this._warnOfDeprecation(eventName);
+    return super.prependListener(eventName, listener);
+  }
+  prependOnceListener(eventName, listener) {
+    this._warnOfDeprecation(eventName);
+    return super.prependOnceListener(eventName, listener);
+  }
+  //====================
+  // Private Methods
+  //====================
+  /**
+   * Constructor helper.
+   * Populates initial state by calling 'getProviderState' and emits
+   * necessary events.
+   */
+  async _initializeState() {
+    try {
+      const {
+        accounts = [],
+        chainId = "0x01",
+        isUnlocked = false,
+        isConnected = false
+      } = await this.request({
+        method: "wallet_getProviderState"
+      });
+      this.emit("connect", { chainId });
+      this._handleChainChanged({ chainId, isConnected });
+      this._handleUnlockStateChanged({ accounts, isUnlocked });
+      this._handleAccountsChanged(accounts);
+      window.addEventListener("message", (event) => {
+        const { data, type, method } = event.data;
+        if (type === "subscribeWalletEvents" && method) {
+          this.subscribeWalletEventsCallback({ data, method });
+        }
+      });
+    } catch (error) {
+      this._log.error(`${this.name}: Failed to get initial state.`, error);
+    } finally {
+      this._state.initialized = true;
+      this.emit("_initialized");
+    }
+    this.keepAlive();
+  }
+  /**
+   * Internal RPC method. Forwards requests to background via the RPC engine.
+   * Also remap ids inbound and outbound.
+   *
+   * @param payload - The RPC request object.
+   * @param callback - The consumer's callback.
+   */
+  _rpcRequest(payload, callback) {
+    let cb = callback;
+    if (!Array.isArray(payload)) {
+      if (!payload.jsonrpc) {
+        payload.jsonrpc = "2.0";
+      }
+      if (payload.method === "eth_accounts" || payload.method === "eth_requestAccounts") {
+        cb = (err, res) => {
+          this._handleAccountsChanged(res.result || [], payload.method === "eth_accounts");
+          callback(err, res);
+        };
+      }
+      return this._rpcEngine.handle(payload, cb);
+    }
+    return this._rpcEngine.handle(payload, cb);
+  }
+  /**
+   * When the provider becomes connected, updates internal state and emits
+   * required events. Idempotent.
+   *
+   * @param chainId - The ID of the newly connected chain.
+   * @emits InpageProvider#connect
+   */
+  _handleConnect(chainId) {
+    if (!this._state.isConnected) {
+      this._state.isConnected = true;
+      this.emit("connect", { chainId });
+    }
+  }
+  /**
+   * When the provider becomes disconnected, updates internal state and emits
+   * required events. Idempotent with respect to the isRecoverable parameter.
+   *
+   * Error codes per the CloseEvent status codes as required by EIP-1193:
+   * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+   *
+   * @param isRecoverable - Whether the disconnection is recoverable.
+   * @param errorMessage - A custom error message.
+   * @emits InpageProvider#disconnect
+   */
+  _handleDisconnect(isRecoverable, errorMessage) {
+    if (this._state.isConnected || !this._state.isPermanentlyDisconnected && !isRecoverable) {
+      this._state.isConnected = false;
+      let error;
+      if (isRecoverable) {
+        error = new EthereumRpcError(
+          1013,
+          // Try again later
+          errorMessage || messages_default.errors.disconnected()
+        );
+      } else {
+        error = new EthereumRpcError(
+          1011,
+          // Internal error
+          errorMessage || messages_default.errors.permanentlyDisconnected()
+        );
+        this.chainId = null;
+        this.networkVersion = null;
+        this._state.accounts = null;
+        this.selectedAddress = null;
+        this._state.isUnlocked = false;
+        this._state.isPermanentlyDisconnected = true;
+      }
+      this.emit("disconnect", error);
+      this.emit("close", error);
+    }
+  }
+  /**
+   * Called when connection is lost to critical streams.
+   *
+   * @emits InpageProvider#disconnect
+   */
+  _handleStreamDisconnect(streamName, error) {
+    logStreamDisconnectWarning(this._log, streamName, error, this);
+    this._handleDisconnect(false, error ? error == null ? void 0 : error.message : void 0);
+  }
+  /**
+   * Upon receipt of a new chainId and networkVersion, emits corresponding
+   * events and sets relevant public state.
+   * Does nothing if neither the chainId nor the networkVersion are different
+   * from existing values.
+   *
+   * @emits InpageProvider#chainChanged
+   * @param networkInfo - An object with network info.
+   * @param networkInfo.chainId - The latest chain ID.
+   * @param networkInfo.networkVersion - The latest network ID.
+   */
+  _handleChainChanged({ chainId, isConnected } = {}) {
+    if (!chainId || typeof chainId !== "string" || !chainId.startsWith("0x")) {
+      return;
+    }
+    if (!isConnected) {
+      this._handleDisconnect(true);
+    } else {
+      this._handleConnect(chainId);
+      if (chainId !== this.chainId) {
+        this.chainId = chainId;
+        if (this._state.initialized) {
+          this.emit("chainChanged", this.chainId);
+        }
+      }
+    }
+  }
+  /**
+   * Called when accounts may have changed. Diffs the new accounts value with
+   * the current one, updates all state as necessary, and emits the
+   * accountsChanged event.
+   *
+   * @param accounts - The new accounts value.
+   * @param isEthAccounts - Whether the accounts value was returned by
+   * a call to eth_accounts.
+   */
+  _handleAccountsChanged(accounts, isEthAccounts = false) {
+    let _accounts = accounts;
+    if (!Array.isArray(accounts)) {
+      this._log.error(`${this.name}: Received invalid accounts parameter.`, accounts);
+      _accounts = [];
+    }
+    for (const account of accounts) {
+      if (typeof account !== "string") {
+        this._log.error(`${this.name}: Received non-string account.`, accounts);
+        _accounts = [];
+        break;
+      }
+    }
+    if (this._state.accounts !== _accounts) {
+      if (isEthAccounts && this._state.accounts !== null) ;
+      this._state.accounts = _accounts;
+      if (this.selectedAddress !== _accounts[0]) {
+        this.selectedAddress = _accounts[0] || null;
+      }
+      if (this._state.initialized) {
+        this.emit("accountsChanged", _accounts);
+      }
+    }
+  }
+  /**
+   * Upon receipt of a new isUnlocked state, sets relevant public state.
+   * Calls the accounts changed handler with the received accounts, or an empty
+   * array.
+   *
+   * Does nothing if the received value is equal to the existing value.
+   * There are no lock/unlock events.
+   *
+   * @param opts - Options bag.
+   * @param opts.accounts - The exposed accounts, if any.
+   * @param opts.isUnlocked - The latest isUnlocked value.
+   */
+  _handleUnlockStateChanged({ accounts, isUnlocked } = {}) {
+    if (typeof isUnlocked !== "boolean") {
+      this._log.error(`${this.name}: Received invalid isUnlocked parameter.`);
+      return;
+    }
+    if (isUnlocked !== this._state.isUnlocked) {
+      this._state.isUnlocked = isUnlocked;
+      this._handleAccountsChanged(accounts || []);
+    }
+  }
+  /**
+   * Warns of deprecation for the given event, if applicable.
+   */
+  _warnOfDeprecation(eventName) {
+    const events = this._state.sentWarnings.events;
+    if (events[eventName] === false) {
+      this._log.warn(messages_default.warnings.events[eventName]);
+      events[eventName] = true;
+    }
+  }
+  //====================
+  // Deprecated Methods
+  //====================
+  /**
+   * Equivalent to: ethereum.request('eth_requestAccounts')
+   *
+   * @deprecated Use request({ method: 'eth_requestAccounts' }) instead.
+   * @returns A promise that resolves to an array of addresses.
+   */
+  enable() {
+    return this.connect();
+  }
+  setConnectedStatus({ connected, address }) {
+    this._state.isConnected = connected;
+    this._state.accounts = address;
+  }
+  connect() {
+    if (!this._state.sentWarnings.enable) {
+      this._log.warn(messages_default.warnings.enableDeprecation);
+      this._state.sentWarnings.enable = true;
+    }
+    return new Promise((resolve, reject) => {
+      if (this._state.isConnected) {
+        resolve(this._state.accounts);
+      }
+      try {
+        this.request({
+          method: "eth_requestAccounts"
+        }).then((accounts) => {
+          if (accounts) {
+            this.emit("connect", {});
+            resolve(accounts);
+          } else {
+            reject(new Error("No accounts returned"));
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  disconnect() {
+    return new Promise((resolve, reject) => {
+      try {
+        (async () => {
+          const { isConnected } = await this.request({
+            method: "wallet_revokePermissions"
+          });
+          if (!isConnected) {
+            this._handleDisconnect(true);
+            this.emit("disconnect", null);
+          }
+          resolve(!isConnected);
+        })();
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  send(methodOrPayload, callbackOrArgs) {
+    if (!this._state.sentWarnings.send) {
+      this._log.warn(messages_default.warnings.sendDeprecation);
+      this._state.sentWarnings.send = true;
+    }
+    if (typeof methodOrPayload === "string" && (!callbackOrArgs || Array.isArray(callbackOrArgs))) {
+      return new Promise((resolve, reject) => {
+        try {
+          this._rpcRequest(
+            { method: methodOrPayload, params: callbackOrArgs },
+            getRpcPromiseCallback(resolve, reject, false)
+          );
+        } catch (error) {
+          reject(error);
+        }
+      });
+    } else if (methodOrPayload && typeof methodOrPayload === "object" && typeof callbackOrArgs === "function") {
+      return this._rpcRequest(
+        methodOrPayload,
+        callbackOrArgs
+      );
+    }
+    return this._sendSync(methodOrPayload);
+  }
+  /**
+   * Internal backwards compatibility method, used in send.
+   *
+   * @deprecated
+   */
+  _sendSync(payload) {
+    let result;
+    switch (payload.method) {
+      case "eth_accounts":
+        result = this.selectedAddress ? [this.selectedAddress] : [];
+        break;
+      case "eth_coinbase":
+        result = this.selectedAddress || null;
+        break;
+      case "eth_uninstallFilter":
+        this._rpcRequest(payload, NOOP);
+        result = true;
+        break;
+      case "net_version":
+        result = this.networkVersion || null;
+        break;
+      default:
+        throw new Error(messages_default.errors.unsupportedSync(payload.method));
+    }
+    return {
+      id: payload.id,
+      jsonrpc: payload.jsonrpc,
+      result
+    };
+  }
+};
+function validateLoggerObject(logger) {
+  if (logger !== console) {
+    if (typeof logger === "object") {
+      const methodKeys = ["log", "warn", "error", "debug", "info", "trace"];
+      for (const key of methodKeys) {
+        if (typeof logger[key] !== "function") {
+          throw new Error(messages_default.errors.invalidLoggerMethod(key));
+        }
+      }
+      return;
+    }
+    throw new Error(messages_default.errors.invalidLoggerObject());
+  }
+}
+var txToHex = (tx) => {
+  if (typeof tx === "string") {
+    return tx;
+  }
+  if ((tx == null ? void 0 : tx.message) && (tx == null ? void 0 : tx.signatures.length) > 0) {
+    return Buffer.from(tx.serialize()).toString("hex");
+  }
+  return Buffer.from(
+    tx.serialize({
+      requireAllSignatures: false,
+      verifySignatures: false
+    })
+  ).toString("hex");
+};
+var hexToTx = (hexString) => {
+  try {
+    const buffer = Buffer.from(hexString, "hex");
+    try {
+      return VersionedTransaction.deserialize(buffer);
+    } catch (e) {
+      return Transaction.from(buffer);
+    }
+  } catch (error) {
+    throw new Error(`Failed to deserialize transaction: ${error}`);
+  }
+};
+
+// src/solana/phantom.ts
+var chainType4 = "sol" /* SOL */;
+var PhantomProvider = class extends EventEmitter {
+  constructor(productInfo, { sendRequest, onResponse }) {
+    super();
+    this._isUnlocked = false;
+    this.name = "";
+    this.icon = "";
+    this.publicKey = null;
+    this.events = {
+      connect: true,
+      disconnect: true,
+      accountChanged: true
+    };
+    this._state = {
+      accounts: null,
+      isConnected: false,
+      isUnlocked: false,
+      initialized: false,
+      isPermanentlyDisconnected: false
+    };
+    // private _pushEventHandlers: PushEventHandlers;
+    this._requestPromise = new ReadyPromise(0);
+    this.initialize = async () => {
+      document.addEventListener("visibilitychange", async () => {
+        if (document.visibilityState === "visible") {
+          this._request({
+            method: "wallet_sendDomainMetadata",
+            params: await getDappInfo()
+          });
+        }
+      });
+      domReadyCall(async () => {
+        this._request({
+          method: "wallet_sendDomainMetadata",
+          params: await getDappInfo()
+        });
+      });
+      window.addEventListener("message", (event) => {
+        const { data, type, method } = event.data;
+        if (type === "subscribeWalletEvents" && method) {
+          this.subscribeWalletEventsCallback({ data, method });
+        }
+      });
+      this.keepAlive();
+      this._state.initialized = true;
+    };
+    this.subscribeWalletEventsCallback = ({ method, data }) => {
+      if (method === "accountsChanged") {
+        const accounts = data == null ? void 0 : data[chainType4];
+        this._handleAccountsChanged(accounts);
+      }
+    };
+    /**
+     * Sending a message to the extension to receive will keep the service worker alive.
+     */
+    this.keepAlive = () => {
+      this._request({
+        method: "keepAlive",
+        params: {}
+      }).then(() => {
+        setTimeout(() => {
+          this.keepAlive();
+        }, 1e3);
+      });
+    };
+    this._request = async (data, responseAdaptor) => {
+      if (!data || !data.method) {
+        throw ethErrors.rpc.invalidRequest();
+      }
+      const dappInfo = await getDappInfo();
+      this.sendRequest(chainType4, __spreadProps(__spreadValues({}, data), { dappInfo }));
+      return this.onResponse(data).then((res) => {
+        let { data: data2 } = res || {};
+        if (data2 && data2.publicKey) {
+          data2 = __spreadValues(__spreadValues({}, data2), { publicKey: new PublicKey(data2.publicKey) });
+        }
+        if (data2 && data2.address && !data2.publicKey) {
+          data2 = __spreadValues(__spreadValues({}, data2), { address: new PublicKey(data2.address) });
+        }
+        if (responseAdaptor) {
+          return responseAdaptor(data2);
+        }
+        return data2;
+      });
+    };
+    this.request = async ({ method, params }, responseAdaptor) => {
+      if (method === "signMessage") {
+        const { message, display = "utf8" } = params;
+        params = __spreadValues(__spreadValues({}, params), {
+          message: new TextDecoder().decode(message),
+          display
+        });
+      }
+      const dappInfo = await getDappInfo();
+      return this._request(
+        {
+          method,
+          params: __spreadValues(__spreadValues({}, dappInfo), params || {})
+        },
+        responseAdaptor
+      );
+    };
+    //phantom api
+    this.connect = async (params) => {
+      const dappInfo = await getDappInfo();
+      return this._request(
+        {
+          method: "connect",
+          params: __spreadValues(__spreadValues({}, dappInfo), params || {})
+        },
+        (data) => {
+          this.emit("connect", true);
+          this.publicKey = data == null ? void 0 : data.publicKey;
+          return data;
+        }
+      );
+    };
+    this.disconnect = async () => {
+      return this._request(
+        {
+          method: "disconnect",
+          params: await getDappInfo()
+        },
+        (data) => {
+          this.emit("disconnect", true);
+          this.publicKey = null;
+          return data;
+        }
+      );
+    };
+    this.getAccount = async () => {
+      return this._request({
+        method: "getAccount",
+        params: {}
+      });
+    };
+    this.signMessage = async (message, display) => {
+      return this._request(
+        {
+          method: "signMessage",
+          params: {
+            message: new TextDecoder().decode(message),
+            display
+          }
+        },
+        (data) => {
+          if (data && data.signedMessage) {
+            data = __spreadValues(__spreadValues({}, data), { signedMessage: new TextEncoder().encode(data.signedMessage) });
+          }
+          if (data && data.signature) {
+            const signature = hexToUint8Array(data.signature);
+            data = __spreadValues(__spreadValues({}, data), { signature });
+          }
+          return data;
+        }
+      );
+    };
+    //doc: https://github.com/phantom/sign-in-with-solana
+    this.signIn = async (params) => {
+      const { domain = window.location.host, statement, nonce, version, issuedAt, resources = [] } = params || {};
+      const address = this.publicKey ? this.publicKey.toString() : "";
+      let message = `${domain} wants you to sign in with your Solana account:
+${address}`;
+      if (statement) {
+        message += `
+
+${statement}`;
+      }
+      if (version) {
+        message += `
+
+Version:${version}`;
+      }
+      if (nonce) {
+        message += `
+Nonce:${nonce}`;
+      }
+      if (issuedAt) {
+        message += `
+Issued At:${issuedAt}`;
+      }
+      if (resources.length > 0) {
+        message += `
+Resources:`;
+        resources.forEach((resource) => {
+          message += `
+- ${resource}`;
+        });
+      }
+      return this._request(
+        {
+          method: "signIn",
+          params: {
+            message
+          }
+        },
+        (data) => {
+          if (data && data.signedMessage) {
+            data = __spreadValues(__spreadValues({}, data), { signedMessage: new TextEncoder().encode(data.signedMessage) });
+          }
+          if (data && data.signature) {
+            const signature = hexToUint8Array(data.signature);
+            data = __spreadValues(__spreadValues({}, data), { signature });
+          }
+          return data;
+        }
+      );
+    };
+    this.signTransaction = async (tx) => {
+      return this._request(
+        {
+          method: "signTransaction",
+          params: {
+            rawTransaction: txToHex(tx)
+          }
+        },
+        (data) => {
+          return hexToTx(data.signature);
+        }
+      );
+    };
+    this.signAllTransactions = async (txs) => {
+      const rawTransactions = [];
+      for (const tx of txs) {
+        rawTransactions.push(txToHex(tx));
+      }
+      return this._request(
+        {
+          method: "signAllTransactions",
+          params: {
+            rawTransactions
+          }
+        },
+        (data) => {
+          return data;
+        }
+      );
+    };
+    this.signAndSendTransaction = async (tx) => {
+      return this._request(
+        {
+          method: "signAndSendTransaction",
+          params: {
+            rawTransaction: txToHex(tx)
+          }
+        },
+        (data) => {
+          if (data && data.signature) {
+            const signature = bs58.decode(data.signature);
+            data = __spreadValues(__spreadValues({}, data), { signature });
+          }
+          return data;
+        }
+      );
+    };
+    this.signAndSendAllTransactions = async (txs) => {
+      const rawTransactions = [];
+      for (const tx of txs) {
+        rawTransactions.push(txToHex(tx));
+      }
+      return this._request({
+        method: "signAndSendAllTransactions",
+        params: {
+          rawTransactions
+        }
+      });
+    };
+    this.sendSolana = async (tx) => {
+      return this._request(
+        {
+          method: "sendSolana",
+          intent: true,
+          params: tx
+        },
+        (data) => {
+          if (data && data.signature) {
+            const signature = isHexString(data.signature) ? hexToUint8Array(data.signature) : bs58.decode(data.signature);
+            data = __spreadValues(__spreadValues({}, data), { signature });
+          }
+          return data;
+        }
+      );
+    };
+    this.sendToken = async (tx) => {
+      return this._request(
+        {
+          method: "sendToken",
+          intent: true,
+          params: tx
+        },
+        (data) => {
+          if (data && data.signature) {
+            const signature = isHexString(data.signature) ? hexToUint8Array(data.signature) : bs58.decode(data.signature);
+            data = __spreadValues(__spreadValues({}, data), { signature });
+          }
+          return data;
+        }
+      );
+    };
+    this.setMaxListeners(100);
+    this.name = productInfo.name;
+    this.icon = productInfo.icon;
+    this.sendRequest = sendRequest;
+    this.onResponse = onResponse;
+    this.initialize();
+    this._handleAccountsChanged = this._handleAccountsChanged.bind(this);
+    this.on("connect", () => {
+      this._state.isConnected = true;
+    });
+  }
+  on(eventName, listener) {
+    if (!this.events[eventName]) {
+      throw Error("${eventName} no supported.");
+    }
+    return super.on(eventName, listener);
+  }
+  _handleAccountsChanged(accounts) {
+    let _accounts = accounts;
+    if (!Array.isArray(accounts)) {
+      console.error(`${this.name}: Received invalid accounts parameter.`, accounts);
+      _accounts = [];
+    }
+    if (this._state.accounts !== _accounts) {
+      this._state.accounts = _accounts;
+      const { publicKey, address } = _accounts[0] || {};
+      const currentPublicKey = publicKey || address;
+      if (currentPublicKey) {
+        this.publicKey = new PublicKey(currentPublicKey);
+      }
+      if (this._state.initialized) {
+        this.emit("accountChanged", this.publicKey);
+      }
+    }
+  }
+};
+var chainType5 = "tron" /* TRON */;
+var TomoTronProvider = class extends EventEmitter {
+  constructor(productInfo, { sendRequest, onResponse }) {
+    super();
+    this._isUnlocked = false;
+    this.name = "";
+    this.icon = "";
+    this.ready = false;
+    this.tronWeb = null;
+    this.events = {
+      connect: true,
+      disconnect: true,
+      accountChanged: true
+    };
+    this._state = {
+      accounts: null,
+      isConnected: false,
+      isUnlocked: false,
+      initialized: false,
+      isPermanentlyDisconnected: false
+    };
+    // private _pushEventHandlers: PushEventHandlers;
+    this._requestPromise = new ReadyPromise(0);
+    this._initTronWeb = async (res) => {
+      const { fullHost = "https://api.trongrid.io", address } = res || {};
+      this.tronWeb = new TronWeb({
+        fullHost
+      });
+      this.tronWeb.defaultAddress.base58 = address;
+      this.tronWeb.defaultAddress.hex = TronWeb.address.toHex(address);
+      this.tronWeb["request"] = async ({ method, params }) => {
+        return await this.request({ method, params });
+      };
+      const trx = this.tronWeb.trx;
+      this.tronWeb.trx = new Proxy(trx, {
+        get: (target, prop) => {
+          switch (prop) {
+            case "sign":
+            case "signMessage":
+              throw new Error("Not supported");
+            case "signMessageV2":
+              return async (message, privateKey) => {
+                return await this.signMessage(message);
+              };
+            case "multiSign":
+              return async (transaction, privateKey) => {
+                const signedTransaction = await this.signTransaction(transaction);
+                return signedTransaction;
+              };
+            case "sendTransaction":
+              return async (to, amount) => {
+                const signedTransaction = await this.sendTransaction({ from: address, to, amount });
+                return signedTransaction;
+              };
+            case "sendToken":
+              return async (to, amount, tokenId) => {
+                const signedTransaction = await this.sendToken({ from: address, to, amount, tokenAddress: tokenId });
+                return signedTransaction;
+              };
+            // case "sendRawTransaction":
+            //   return async (transaction: Transaction, privateKey?: string) => {
+            //     const res = await this.sendRawTransaction(transaction);
+            //     return res;
+            //   };
+            default:
+              return Reflect.get(target, prop);
+          }
+        }
+      });
+    };
+    this.initialize = async () => {
+      document.addEventListener("visibilitychange", async () => {
+        if (document.visibilityState === "visible") {
+          this._request({
+            method: "wallet_sendDomainMetadata",
+            params: await getDappInfo()
+          });
+        }
+      });
+      domReadyCall(async () => {
+        this._request({
+          method: "wallet_sendDomainMetadata",
+          params: await getDappInfo()
+        });
+      });
+      window.addEventListener("message", (event) => {
+        const { data, type, method } = event.data;
+        if (type === "subscribeWalletEvents" && method) {
+          this.subscribeWalletEventsCallback({ data, method });
+        }
+      });
+      this._state.initialized = true;
+    };
+    this.subscribeWalletEventsCallback = ({ method, data }) => {
+      if (method === "accountsChanged") {
+        const accounts = data == null ? void 0 : data[chainType5];
+        this._handleAccountsChanged(accounts);
+      }
+    };
+    this._request = async (data, responseAdaptor) => {
+      if (!data || !data.method) {
+        throw ethErrors.rpc.invalidRequest();
+      }
+      const dappInfo = await getDappInfo();
+      this.sendRequest(chainType5, __spreadProps(__spreadValues({}, data), { dappInfo }));
+      return this.onResponse(data).then((res) => {
+        const { data: data2, method } = res || {};
+        if (method === "tron_requestAccounts") {
+          this.emit("connect", data2);
+        }
+        if (responseAdaptor) {
+          return responseAdaptor(data2);
+        }
+        return data2;
+      });
+    };
+    this.request = async ({ method, params }, responseAdaptor) => {
+      return this._request(
+        {
+          method,
+          params
+        },
+        responseAdaptor
+      );
+    };
+    //tronLink api
+    this.connect = async () => {
+      return this._request(
+        {
+          method: "connect"
+        },
+        (data) => {
+          this.emit("connect", data);
+          this.ready = true;
+          return data;
+        }
+      );
+    };
+    this.disconnect = async () => {
+      return this._request(
+        {
+          method: "disconnect"
+        },
+        (data) => {
+          this.emit("disconnect", true);
+          this.ready = false;
+          return data;
+        }
+      );
+    };
+    this.signMessage = async (message) => {
+      return this._request(
+        {
+          method: "signMessage",
+          params: {
+            message
+          }
+        },
+        (data) => {
+          return data;
+        }
+      );
+    };
+    this.signTransaction = async (transaction) => {
+      return this._request(
+        {
+          method: "signTransaction",
+          params: {
+            transaction
+          }
+        },
+        (data) => {
+          return data;
+        }
+      );
+    };
+    this.sendRawTransaction = async (transaction) => {
+      return this._request(
+        {
+          method: "sendRawTransaction",
+          params: {
+            transaction
+          }
+        },
+        (data) => {
+          return data;
+        }
+      );
+    };
+    this.sendTransaction = async (params) => {
+      return this._request(
+        {
+          method: "sendTransaction",
+          params
+        },
+        (data) => {
+          return data;
+        }
+      );
+    };
+    this.sendToken = async (params) => {
+      return this._request(
+        {
+          method: "sendToken",
+          params
+        },
+        (data) => {
+          return data;
+        }
+      );
+    };
+    this.setMaxListeners(100);
+    this.name = productInfo.name;
+    this.icon = productInfo.icon;
+    this.sendRequest = sendRequest;
+    this.onResponse = onResponse;
+    this.initialize();
+    this._handleAccountsChanged = this._handleAccountsChanged.bind(this);
+    this.on("connect", (res) => {
+      this._state.isConnected = true;
+      this._initTronWeb(res);
+      window.postMessage(
+        {
+          message: {
+            action: "connect",
+            data: res
+          }
+        },
+        window.location.origin
+      );
+    });
+    this.on("disconnect", (result) => {
+      this._state.isConnected = false;
+      this.tronWeb = null;
+      window.postMessage(
+        {
+          message: {
+            action: "disconnect",
+            data: result
+          }
+        },
+        window.location.origin
+      );
+    });
+    this.on("accountChanged", (address) => {
+      window.postMessage(
+        {
+          message: {
+            action: "accountChanged",
+            data: {
+              address
+            }
+          }
+        },
+        window.location.origin
+      );
+    });
+  }
+  on(eventName, listener) {
+    if (!this.events[eventName]) {
+      throw Error("${eventName} no supported.");
+    }
+    return super.on(eventName, listener);
+  }
+  _handleAccountsChanged(accounts) {
+    let _accounts = accounts;
+    if (!Array.isArray(accounts)) {
+      console.error(`${this.name}: Received invalid accounts parameter.`, accounts);
+      _accounts = [];
+    }
+    if (this._state.accounts !== _accounts) {
+      this._state.accounts = _accounts;
+      const { address } = _accounts[0] || {};
+      if (this._state.initialized) {
+        this.emit("accountChanged", address);
+      }
+    }
+  }
+};
+
+export { BtcProvider, DogecoinProvider, EvmProvider, PhantomProvider as SolanaProvider, TomoTronProvider as TronProvider };