@dappworks/kit 0.5.34 → 0.5.36

package/dist/chunk-BR7IWH2E.mjs

@@ -0,0 +1,1284 @@
+import { AIem } from './chunk-WMV5O3PI.mjs';
+import { DialogStore } from './chunk-NKGQRF5D.mjs';
+import { ToastPlugin } from './chunk-7EL2RQI7.mjs';
+import { RootStore, rootStore } from './chunk-KIS52LFU.mjs';
+import { helper } from './chunk-7WJMHFRA.mjs';
+import { __spreadProps, __spreadValues } from './chunk-6F7H4PAA.mjs';
+import { observable, makeAutoObservable } from 'mobx';
+import BigNumber2 from 'bignumber.js';
+import React3, { useEffect } from 'react';
+import { useRouter } from 'next/router.js';
+import { observer } from 'mobx-react-lite';
+import { toHex, createWalletClient, custom, publicActions } from 'viem';
+import EventEmitter from 'events';
+import { useAccount, useSwitchChain, useConnect, useDisconnect, useWalletClient } from 'wagmi';
+import { getDefaultConfig, useConnectModal } from '@rainbow-me/rainbowkit';
+import { Icon } from '@iconify/react';
+import { iopayWallet, metaMaskWallet, walletConnectWallet, okxWallet, binanceWallet, safeWallet, gateWallet } from '@rainbow-me/rainbowkit/wallets';
+import SafeAppsSDK, { TransactionStatus } from '@safe-global/safe-apps-sdk';
+import { Card, Input } from '@nextui-org/react';
+import TransportWebUSB from '@ledgerhq/hw-transport-webusb';
+import Eth from '@ledgerhq/hw-app-eth';
+import { ethers } from 'ethers';
+
+//@ts-ignore
+observable();
+var PromiseHook = class {
+  static Get(cls) {
+    try {
+      return async ({ args, select, id, unselect }) => {
+        let instance;
+        if (!id || !this.entities[id]) {
+          instance = new cls(args);
+          instance.refresh = async () => {
+            const hooks = Object.entries(instance).filter((i) => {
+              if (!this.isPromiseHook(instance[i[0]]))
+                return false;
+              if (i[1].lazy)
+                return false;
+              if (select && !select[i[0]])
+                return false;
+              if (unselect && unselect[i[0]])
+                return false;
+              return true;
+            }).map((i) => {
+              const hook = instance[i[0]];
+              return hook;
+            });
+            await Promise.all(hooks.map((i) => i.call()));
+          };
+          if (id) {
+            this.entities[id] = instance;
+          }
+        } else {
+          instance = this.entities[id];
+        }
+        await instance.refresh();
+        return instance;
+      };
+    } catch (e) {
+      throw e;
+    }
+  }
+  static isPromiseHook(target) {
+    return (target == null ? void 0 : target._type) == "promiseHook";
+  }
+  //ttl : ms
+  static wrap({ func, defaultValue, lazy }) {
+    let context;
+    const call = (args) => {
+      context.loading = true;
+      if (!context._call) {
+        context._call = func(args).then((i) => {
+          context.value = i;
+          context.loading = false;
+          context._call = null;
+          return i;
+        }).catch((i) => {
+          console.error(i, func);
+          context.value = defaultValue;
+          context._call = null;
+          context.loading = false;
+          throw i;
+        });
+      }
+      return context._call;
+    };
+    const get = async (args) => {
+      if (!context.value) {
+        return call(args);
+      }
+      return context.value;
+    };
+    if (!context) {
+      context = observable({
+        _type: "promiseHook",
+        _value: defaultValue,
+        get value() {
+          return context["_value"];
+        },
+        set value(val) {
+          context["_value"] = val;
+        },
+        get,
+        lazy,
+        loading: false,
+        call,
+        defaultValue,
+        toJSON() {
+          return context.value;
+        },
+        toString() {
+          return context.value;
+        }
+      });
+    }
+    return context;
+  }
+};
+PromiseHook.entities = observable([]);
+var BigNumberState = class {
+  constructor(args) {
+    this.value = new BigNumber2(0);
+    this.loading = false;
+    this.decimals = 18;
+    this.fixed = 6;
+    Object.assign(this, args);
+    makeAutoObservable(this, {
+      getFormat: false
+    });
+  }
+  get format() {
+    if (this.loading)
+      return "...";
+    return this.getFormat();
+  }
+  getFormat({ decimals = this.decimals, fixed = this.fixed } = {}) {
+    if (this.loading)
+      return "...";
+    if (this.formatter)
+      return this.formatter(this);
+    return helper.number.toPrecisionFloor(new BigNumber2(this.value).dividedBy(10 ** decimals).toFixed(), {
+      decimals: fixed
+    });
+  }
+  setDecimals(decimals) {
+    this.decimals = decimals;
+  }
+  setValue(value) {
+    this.value = value;
+    this.setLoading(false);
+  }
+  setLoading(val) {
+    this.loading = val;
+  }
+};
+var BigNumberInputState = class {
+  constructor(args) {
+    this.value = new BigNumber2(0);
+    this.format = "";
+    this.loading = false;
+    this.decimals = 18;
+    Object.assign(this, args);
+    makeAutoObservable(this);
+  }
+  get noDecimasValue() {
+    return new BigNumber2(this.value).dividedBy(10 ** this.decimals);
+  }
+  setValue(value) {
+    this.value = new BigNumber2(value);
+    this.format = helper.number.warpBigNumber(this.value.toFixed(), this.decimals, { format: "0.000", fallback: "" }).format;
+    this.setLoading(false);
+  }
+  setFormat(val) {
+    this.format = val;
+    this.value = new BigNumber2(val).multipliedBy(10 ** this.decimals);
+  }
+  setLoading(val) {
+    this.loading = val;
+  }
+  setDecimals(val) {
+    this.decimals = val;
+  }
+  get isZero() {
+    return this.value.isZero() && this.format == "";
+  }
+};
+var StorageState = class _StorageState {
+  constructor(args) {
+    this.value = null;
+    this.default = null;
+    Object.assign(this, args);
+    makeAutoObservable(this);
+    this.load();
+  }
+  static safeParse(val) {
+    try {
+      return JSON.parse(val);
+    } catch (error) {
+      return val;
+    }
+  }
+  load() {
+    var _a;
+    try {
+      if (typeof window == "undefined")
+        return;
+      const value = (_a = window == null ? void 0 : window.localStorage) == null ? void 0 : _a.getItem(this.key);
+      this.value = _StorageState.safeParse(value);
+      if (this.value == null) {
+        this.value = this.default;
+      }
+      return this.value;
+    } catch (error) {
+      console.error(error);
+      return null;
+    }
+  }
+  save(value) {
+    try {
+      if (typeof window == "undefined")
+        return;
+      if (value !== null || value !== void 0) {
+        this.value = value;
+      }
+      window == null ? void 0 : window.localStorage.setItem(this.key, JSON.stringify(value));
+    } catch (error) {
+      console.error(error);
+      return null;
+    }
+  }
+  setValue(value) {
+    this.save(value);
+  }
+  clear() {
+    try {
+      if (typeof window == "undefined")
+        return;
+      window == null ? void 0 : window.localStorage.removeItem(this.key);
+    } catch (error) {
+      return null;
+    }
+  }
+};
+var StorageListState = class _StorageListState {
+  constructor(args) {
+    this.list = [];
+    Object.assign(this, args);
+    makeAutoObservable(this);
+    this.load();
+  }
+  static safeParse(val) {
+    try {
+      return JSON.parse(val);
+    } catch (error) {
+      return val;
+    }
+  }
+  load() {
+    try {
+      const value = localStorage.getItem(this.key);
+      if (value) {
+        this.list = _StorageListState.safeParse(value);
+      }
+      return _StorageListState.safeParse(value);
+    } catch (error) {
+      console.error(error);
+      return null;
+    }
+  }
+  push(value) {
+    this.list.push(value);
+    this.save();
+  }
+  remove(index) {
+    this.list.splice(index, 1);
+    this.save();
+  }
+  save() {
+    try {
+      localStorage.setItem(this.key, JSON.stringify(this.list));
+    } catch (error) {
+    }
+  }
+  clear() {
+    try {
+      localStorage.removeItem(this.key);
+      this.list = [];
+    } catch (error) {
+    }
+  }
+};
+
+// store/standard/ObjectPool.ts
+var _ObjectPool = class _ObjectPool {
+  static get(key, func) {
+    if (!_ObjectPool.pool[key]) {
+      _ObjectPool.pool[key] = func();
+    }
+    return _ObjectPool.pool[key];
+  }
+};
+_ObjectPool.pool = {};
+var ObjectPool = _ObjectPool;
+var WalletConfigStore = class {
+  constructor(args) {
+    this.sid = "WalletConfigStore";
+    this.autoObservable = true;
+    this.appName = "Dappkit";
+    this.projectId = "b69e844f38265667350efd78e3e1a5fb";
+    this.defaultChainId = 4689;
+    this.updateTicker = 1;
+    this.walletUpdateTick = 0;
+    this.isConnect = false;
+    this.isInSafeApp = false;
+    // This mode to resolve and walletClient and nextui in some extreme cases cause page infinite redraw bugs
+    this.compatibleMode = true;
+    Object.assign(this, args);
+  }
+  set(params) {
+    Object.assign(this, params);
+    this.updateTicker += 1;
+  }
+  get reconnectOnMount() {
+    if (!this.compatibleMode)
+      return true;
+    if (!this.isConnect && this.walletUpdateTick == 0) {
+      return true;
+    }
+    if (!this.isConnect && this.walletUpdateTick != 0) {
+      return false;
+    }
+    if (this.isConnect) {
+      return true;
+    }
+  }
+  get rainbowKitConfig() {
+    var _a;
+    return ObjectPool.get(`rainbowKitConfig-${(_a = this.supportedChains) == null ? void 0 : _a.map((i) => i.id).join("-")}`, () => {
+      return getDefaultConfig({
+        pollingInterval: 2500,
+        appName: this.appName,
+        projectId: this.projectId,
+        //@ts-ignore
+        chains: this.supportedChains,
+        wallets: [
+          {
+            groupName: "Recommended",
+            wallets: [iopayWallet, metaMaskWallet]
+          },
+          {
+            groupName: "Others",
+            wallets: [metaMaskWallet, walletConnectWallet, iopayWallet, okxWallet, binanceWallet, safeWallet, gateWallet]
+          }
+        ]
+      });
+    });
+  }
+};
+
+// module/Wallet/walletPluginStore.tsx
+var defaultRPCList = [
+  { name: "https://babel-api.fastblocks.io", latency: 0, height: 0, custom: false },
+  { name: "https://babel-api.mainnet.iotex.one", latency: 0, height: 0 },
+  { name: "https://babel-api.mainnet.iotex.io", latency: 0, height: 0 },
+  { name: "https://iotex-network.rpc.thirdweb.com", latency: 0, height: 0 },
+  // { name: 'https://iotexrpc.com', latency: 0, height: 0, },
+  { name: "https://iotex.api.onfinality.io/public", latency: 0, height: 0 }
+  // { name: 'https://rpc.ankr.com/iotex', latency: 0, height: 0, },
+];
+var WalletRpcStore = class {
+  constructor() {
+    this.sid = "WalletPluginStore";
+    this.autoObservable = true;
+    this.curRpc = new StorageState({ default: "https://babel-api.mainnet.iotex.one", key: "curRPC-v2", value: "https://babel-api.mainnet.iotex.one" });
+    this.isAutoSelectRpc = new StorageState({ key: "isAutoSelectRpc", default: true });
+    this.customRpc = "";
+    this.rpcList = new StorageState({ key: "customRpcList-v2", default: defaultRPCList, value: [] });
+    this.showCustomRpc = false;
+  }
+  get currentRpc() {
+    var _a, _b;
+    console.log((_a = this.rpcList.value) == null ? void 0 : _a.find((i) => i.name == this.curRpc));
+    return ((_b = this.rpcList.value) == null ? void 0 : _b.find((i) => i.name == this.curRpc.value)) || null;
+  }
+  addCustomRpc() {
+    const item = { name: this.customRpc, latency: 0, height: 0, custom: true };
+    if (defaultRPCList.find((i) => i.name === item.name)) {
+      return RootStore.Get(ToastPlugin).error("Rpc already exists");
+    }
+    if (this.rpcList.value) {
+      this.rpcList.save([...this.rpcList.value, item]);
+      this.refresh();
+      return;
+    }
+    this.rpcList.save([...defaultRPCList, item]);
+    this.refresh();
+  }
+  async addToMetamask(url) {
+    var _a;
+    try {
+      if (typeof window == "undefined")
+        return;
+      await ((_a = window == null ? void 0 : window.ethereum) == null ? void 0 : _a.request({
+        method: "wallet_addEthereumChain",
+        params: [{
+          chainId: `0x${4689 .toString(16)}`,
+          chainName: "IoTeX Mainnet",
+          nativeCurrency: {
+            name: "IoTeX",
+            symbol: "IOTX",
+            decimals: 18
+          },
+          rpcUrls: [url],
+          blockExplorerUrls: ["https://iotexscan.io"]
+        }]
+      }));
+      RootStore.Get(ToastPlugin).success("Network added");
+      console.log("Network added");
+    } catch (error) {
+      console.error("Failed to add network", error);
+    }
+  }
+  async switchOrAddChain(chainId) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await window.ethereum.request({
+          method: "wallet_switchEthereumChain",
+          params: [{ chainId: toHex(chainId) }]
+        });
+        resolve(true);
+      } catch (switchError) {
+        if (switchError.code === 4902) {
+          try {
+            await this.addToMetamaskById(chainId);
+          } catch (addError) {
+            reject(addError);
+          }
+        } else {
+          reject(switchError);
+        }
+      }
+    });
+  }
+  async addToMetamaskById(id) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (typeof window == "undefined")
+          return;
+        const chain = RootStore.Get(WalletConfigStore).supportedChains.find((i) => i.id == id);
+        const res = await window.ethereum.request({
+          method: "wallet_addEthereumChain",
+          params: [{
+            "chainId": toHex(chain.id),
+            "chainName": chain.name,
+            "nativeCurrency": {
+              "name": chain.nativeCurrency.name,
+              "symbol": chain.nativeCurrency.symbol,
+              "decimals": chain.nativeCurrency.decimals
+            },
+            "rpcUrls": JSON.parse(JSON.stringify(chain.rpcUrls.default.http)),
+            "blockExplorerUrls": [chain.blockExplorers.default.url]
+          }]
+        });
+        console.log(res);
+        resolve(res);
+      } catch (switchError) {
+        reject(false);
+      }
+    });
+  }
+  refresh() {
+    this.showCustomRpc = false;
+    this.customRpc = "";
+    setTimeout(() => {
+      this.testRpc();
+    }, 500);
+  }
+  latencyColor(latency) {
+    if (latency < 0) {
+      return "text-red-500";
+    }
+    if (latency < 1) {
+      return "text-green-500";
+    }
+    if (latency < 2) {
+      return "text-yellow-500";
+    }
+    return "text-red-500";
+  }
+  async testRpcFunction(url) {
+    const start = performance.now();
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          method: "eth_getBlockByNumber",
+          params: ["latest", false],
+          id: 1
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Error from server: ${response.status}`);
+      }
+      const res = await response.json();
+      console.log(res);
+      const end = performance.now();
+      return { url, lentency: Number(helper.number.numberFormat((end - start) / 1e3, "0.000", { fallback: "-1" })), height: parseInt(res.result.number, 16) };
+    } catch (error) {
+      console.error("RPC Latency Test Failed:", error);
+      return { url, lentency: -1, height: -1 };
+    }
+  }
+  testRpc() {
+    var _a;
+    (_a = this.rpcList) == null ? void 0 : _a.value.forEach((i) => {
+      this.testRpcFunction(i.name).then((res) => {
+        i.latency = res.lentency;
+        i.height = res.height;
+      });
+    });
+    this.rpcList.save(this.rpcList.value);
+  }
+  removeRpc(name) {
+    this.rpcList.save(this.rpcList.value.filter((i) => i.name !== name));
+  }
+  scoreIcon(score) {
+    if (score < 0) {
+      return /* @__PURE__ */ React3.createElement(Icon, { icon: "codicon:error", width: "18", height: "18", style: { color: "#FF0000" } });
+    }
+    if (score < 1) {
+      return /* @__PURE__ */ React3.createElement(Icon, { icon: "icon-park-solid:check-one", width: "18", height: "18", style: { color: "#289726" } });
+    }
+    if (score < 2) {
+      return /* @__PURE__ */ React3.createElement(Icon, { icon: "bxs:error", width: "18", height: "18", style: { color: "#FFA500" } });
+    }
+    return /* @__PURE__ */ React3.createElement(Icon, { icon: "codicon:error", width: "18", height: "18", style: { color: "#FF0000" } });
+  }
+  get wallet() {
+    return RootStore.Get(WalletStore);
+  }
+  // debounceAutoSelectRpc = pDebounce(this.autoSelectRpc, 3000)
+  async autoSelectRpc() {
+    console.log("autoSelectRpc");
+    for (let i = 0; i < this.rpcList.value.length; i++) {
+      const item = this.rpcList.value[i];
+      const res = await this.testRpcFunction(item.name);
+      if (res.lentency != -1 || res.height > 0) {
+        this.curRpc.save(item.name);
+        break;
+      }
+    }
+  }
+};
+var WalletHistoryStore = class {
+  constructor() {
+    this.sid = "WalletHistoryStore";
+    this.isRender = false;
+    this.autoObservable = true;
+    this.history = new StorageState({ value: [], key: "history" });
+  }
+  set(params) {
+    Object.assign(this, params);
+  }
+  get historyList() {
+    if (this.isRender) {
+      return this.history.value;
+    }
+    return [];
+  }
+  recordHistory(item) {
+    let value = this.history.load();
+    if (!value) {
+      value = [item];
+    } else {
+      value = [...value, item];
+    }
+    this.history.setValue(value);
+  }
+  updateHistoryStatusByTx(tx, status) {
+    let value = this.history.load();
+    if (!value) {
+      return;
+    }
+    value = value.map((i) => {
+      if (i.tx == tx) {
+        i.status = status;
+        return i;
+      }
+      if (!tx) {
+        i.status = status;
+      }
+      return i;
+    });
+    this.history.setValue(value);
+  }
+  clearHistory() {
+    this.history.setValue(null);
+  }
+};
+var SuccessTxDialog = observer((props) => {
+  return /* @__PURE__ */ React3.createElement("div", { className: "flex-col gap-4 py-10" }, /* @__PURE__ */ React3.createElement("div", { className: "w-full flex items-center justify-center" }, /* @__PURE__ */ React3.createElement(Icon, { icon: "icon-park-solid:check-one", width: "48", height: "48", className: "text-green-500" })), /* @__PURE__ */ React3.createElement("div", { className: "text-2xl font-[900] text-center mt-4" }, props.msg), /* @__PURE__ */ React3.createElement(
+    "div",
+    {
+      className: "flex items-center justify-center text-green-500 text-sm mt-6 gap-2 cursor-pointer hover:text-green-600 transition",
+      onClick: (e) => window.open(`https://iotexscan.io/tx/${props.hash}`, "_blank")
+    },
+    "View on IoTeXScan ",
+    /* @__PURE__ */ React3.createElement(Icon, { icon: "material-symbols:chip-extraction-rounded", width: "18", height: "18" })
+  ));
+});
+var ShowSuccessTxDialog = ({ msg, hash }) => {
+  RootStore.Get(DialogStore).setData({
+    title: "",
+    content: /* @__PURE__ */ React3.createElement(SuccessTxDialog, { msg, hash }),
+    isOpen: true
+  });
+};
+var _transport = null;
+var _signer = null;
+async function createTransport() {
+  if (_transport) {
+    return _transport;
+  }
+  try {
+    const res = await TransportWebUSB.create();
+    console.log("createTransport res", res);
+    _transport = res;
+    return res;
+  } catch (error) {
+    console.error("Error creating transport", error);
+    throw error;
+  }
+}
+function waiter(duration) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, duration);
+  });
+}
+var GlobalLedgerProvider = ObjectPool.get("provider", async () => {
+  return new ethers.providers.JsonRpcProvider("https://babel-api.mainnet.iotex.io");
+});
+var GlobalLedgerSigner = async () => {
+  var _a;
+  try {
+    if (_signer) {
+      return _signer;
+    }
+    const transport = await createTransport();
+    _signer = new LedgerSigner(transport, await GlobalLedgerProvider, "44'/304'/0'/0/0");
+    return _signer;
+  } catch (error) {
+    console.error("Error creating ledger signer", error);
+    RootStore.Get(ToastPlugin).error((_a = error.message) != null ? _a : "Failed to connect to Ledger");
+    RootStore.Get(WalletStore).isLedger = false;
+    return null;
+  }
+};
+var ConnectLedger = async () => {
+  RootStore.Get(WalletStore).isLedger = true;
+  console.log("ConnectLedger");
+  const signer = await GlobalLedgerSigner();
+  console.log("signer", signer);
+  const interval = setInterval(async () => {
+    try {
+      const address = await (signer == null ? void 0 : signer.getAddress());
+      if (address) {
+        RootStore.Get(WalletStore).set({
+          account: address,
+          isConnect: true
+        });
+        clearInterval(interval);
+        return signer;
+      }
+    } catch (error) {
+      console.error("Error getting address", error);
+    }
+  }, 1e3);
+};
+var DisconnectLedger = () => {
+  RootStore.Get(WalletStore).set({
+    isConnect: false,
+    isLedger: false
+  });
+};
+var LedgerSigner = class _LedgerSigner extends ethers.Signer {
+  constructor(transport, provider, path) {
+    super();
+    ethers.utils.defineReadOnly(this, "path", path || "44'/304'/0'/0/0");
+    ethers.utils.defineReadOnly(this, "provider", provider || null);
+    const eth = new Eth(transport);
+    const _eth = eth.getAppConfiguration().then((config) => {
+      return eth;
+    }, (error) => {
+      return Promise.reject(error);
+    });
+    ethers.utils.defineReadOnly(this, "_eth", _eth);
+  }
+  _retry(callback, timeout) {
+    return new Promise(async (resolve, reject) => {
+      if (timeout && timeout > 0) {
+        setTimeout(() => {
+          reject(new Error("timeout"));
+        }, timeout);
+      }
+      const eth = await this._eth;
+      for (let i = 0; i < 50; i++) {
+        try {
+          const result = await callback(eth);
+          return resolve(result);
+        } catch (error) {
+          if (error.id !== "TransportLocked") {
+            return reject(error);
+          }
+        }
+        await waiter(100);
+      }
+      return reject(new Error("timeout"));
+    });
+  }
+  async getAddress() {
+    const account = await this._retry((eth) => eth.getAddress(this.path));
+    return ethers.utils.getAddress(account.address);
+  }
+  async signMessage(message) {
+    if (typeof message === "string") {
+      message = ethers.utils.toUtf8Bytes(message);
+    }
+    const messageHex = ethers.utils.hexlify(message).substring(2);
+    const sig = await this._retry((eth) => eth.signPersonalMessage(this.path, messageHex));
+    sig.r = "0x" + sig.r;
+    sig.s = "0x" + sig.s;
+    return ethers.utils.joinSignature(sig);
+  }
+  async signTransaction(transaction) {
+    const tx = await ethers.utils.resolveProperties(transaction);
+    const baseTx = {
+      chainId: tx.chainId || void 0,
+      data: tx.data || void 0,
+      gasLimit: tx.gasLimit || void 0,
+      gasPrice: tx.gasPrice || void 0,
+      nonce: tx.nonce ? ethers.BigNumber.from(tx.nonce).toNumber() : void 0,
+      to: tx.to || void 0,
+      value: tx.value || void 0
+    };
+    const unsignedTx = ethers.utils.serializeTransaction(baseTx).substring(2);
+    const sig = await this._retry((eth) => eth.signTransaction(this.path, unsignedTx));
+    return ethers.utils.serializeTransaction(baseTx, {
+      v: ethers.BigNumber.from("0x" + sig.v).toNumber(),
+      r: "0x" + sig.r,
+      s: "0x" + sig.s
+    });
+  }
+  connect(provider) {
+    return new _LedgerSigner(provider, this.path);
+  }
+};
+
+// module/Wallet/index.tsx
+var WalletStore = class _WalletStore {
+  constructor(args) {
+    this.sid = "wallet";
+    this.autoObservable = true;
+    this.account = null;
+    this.isSuccessDialogOpen = false;
+    this.isLedger = false;
+    this.isConnect = false;
+    this.event = new EventEmitter();
+    this.updateTicker = 0;
+    this.addressMode = "0x";
+    this.isIoTeXChain = false;
+    this.balance = PromiseHook.wrap({
+      func: async () => {
+        var _a;
+        if (!this.publicClient || !this.account)
+          return helper.number.warpBigNumber("0");
+        const balance = await this.publicClient.getBalance({
+          address: this.account
+        });
+        if (balance) {
+          return helper.number.warpBigNumber((_a = balance == null ? void 0 : balance.toString()) != null ? _a : "0");
+        }
+      }
+    });
+    Object.assign(this, args);
+  }
+  // isInSafeApp = false;
+  get isInSafeApp() {
+    return RootStore.Get(WalletConfigStore).isInSafeApp;
+  }
+  setAddressMode(mode) {
+    this.addressMode = mode;
+    localStorage.setItem("addressMode", mode);
+  }
+  get accountFormat() {
+    return this.account ? helper.address.convertAddress(this.addressMode, this.account) : "-";
+  }
+  get connectAccountEllipsisFormat() {
+    return this.account ? helper.string.truncate(helper.address.convertAddress(this.addressMode, this.account), 11, "...") : "-";
+  }
+  get accountEllipsisFormat() {
+    return this.account ? helper.string.truncate(helper.address.convertAddress(this.addressMode, this.account), 16, "...") : "-";
+  }
+  get supportedChains() {
+    return RootStore.Get(WalletConfigStore).supportedChains;
+  }
+  use() {
+    const { chain, address, isConnected } = useAccount();
+    const { switchChainAsync } = useSwitchChain();
+    const { openConnectModal } = useConnectModal();
+    const { connect } = useConnect();
+    const { disconnect } = useDisconnect();
+    const walletConfigStore = RootStore.Get(WalletConfigStore);
+    this.set({
+      //@ts-ignore
+      connect,
+      // @ts-ignore 
+      // walletClient,
+      openConnectModal,
+      switchChain: switchChainAsync,
+      disconnect
+    });
+    useEffect(() => {
+      RootStore.Get(WalletHistoryStore).set({ isRender: true });
+      this.set({
+        isConnect: isConnected,
+        account: address,
+        chain
+      });
+      if ((chain == null ? void 0 : chain.id) == 4689) {
+        this.isIoTeXChain = true;
+      } else {
+        this.isIoTeXChain = false;
+      }
+      walletConfigStore.set({
+        isConnect: isConnected
+      });
+      if (this.account) {
+        this.updateTicker++;
+        walletConfigStore.set({
+          walletUpdateTick: this.updateTicker
+        });
+        this.event.emit("walletAccount:ready");
+      }
+    }, [address, isConnected, chain]);
+    useEffect(() => {
+      setTimeout(() => {
+        this.balance.call();
+      }, 1500);
+    }, [this.updateTicker]);
+  }
+  useWalletClientWithCompatibleMode() {
+    if (RootStore.Get(WalletConfigStore).compatibleMode) {
+      if (this.account) {
+        this.walletClient = createWalletClient({
+          account: this.account,
+          chain: this.chain,
+          transport: custom(window.ethereum),
+          pollingInterval: 2500
+        }).extend(publicActions);
+      }
+      console.log(this.walletClient, "this.walletClientxxx");
+    }
+  }
+  useWalletClientWithoutCompatibleMode() {
+    const { data: walletClient, isSuccess } = useWalletClient({
+      query: {
+        refetchInterval: 2500
+      }
+    });
+    useEffect(() => {
+      if (isSuccess && walletClient) {
+        this.set({ walletClient });
+      }
+    }, [walletClient, isSuccess]);
+  }
+  //always return or return default chain
+  get publicClient() {
+    if (this.chain && this.supportedChains.some((i) => i.id === this.chain.id)) {
+      if (this.chain.id == 4689) {
+        return AIem.PubClient("4689", {
+          rpcUrls: { default: { http: [RootStore.Get(WalletRpcStore).curRpc.value] } },
+          multicall: true,
+          pollingInterval: 2500
+        });
+      }
+      return AIem.PubClient(this.chain.id.toString(), { pollingInterval: 2500 });
+    } else {
+      return AIem.PubClient("4689", { pollingInterval: 2500 });
+    }
+  }
+  set(args) {
+    Object.assign(this, args);
+  }
+  toJSON() {
+    const { account } = this;
+    return { account };
+  }
+  async prepare(chainId) {
+    RootStore.Get(WalletRpcStore);
+    return new Promise(async (res, rej) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+      try {
+        if (this.account) {
+          if (this.isLedger) {
+            res(this);
+          }
+          if ((!chainId || Number((_a = this.chain) == null ? void 0 : _a.id) == Number(chainId)) && this.walletClient) {
+            res(this);
+          }
+          const interval = setInterval(() => {
+            var _a2;
+            if (((_a2 = this.chain) == null ? void 0 : _a2.id) == chainId) {
+              try {
+                this.useWalletClientWithCompatibleMode();
+                res(this);
+              } catch (error) {
+                console.log(error, "myerror");
+                rej(error);
+              }
+              clearInterval(interval);
+            }
+          }, 1e3);
+          if (chainId != ((_b = this.chain) == null ? void 0 : _b.id)) {
+            try {
+              await ((_c = this.walletClient) == null ? void 0 : _c.switchChain({ id: chainId }));
+            } catch (error) {
+              console.log(error.message);
+              if ((_d = error == null ? void 0 : error.message) == null ? void 0 : _d.includes("wallet_addEthereumChain")) {
+                const chain = RootStore.Get(WalletConfigStore).supportedChains.find((i) => i.id == chainId);
+                try {
+                  await RootStore.Get(WalletRpcStore).addToMetamaskById(chainId);
+                  await this.walletClient.switchChain({ id: chainId });
+                } catch (error2) {
+                  RootStore.Get(DialogStore).setData({
+                    isOpen: true,
+                    title: "Chain Addition Failed",
+                    size: "2xl",
+                    content: /* @__PURE__ */ React3.createElement("div", null, /* @__PURE__ */ React3.createElement(Card, { className: "p-2" }, /* @__PURE__ */ React3.createElement("div", { className: "p-2 flex items-center justify-center gap-4" }, /* @__PURE__ */ React3.createElement("div", { className: "text-yellow-500 text-sm" }, "We encountered an issue while adding the chain. This might be caused by a compatibility issue with your current plugin. Please try adding the chain manually or review your plugin settings to ensure compatibility."))), /* @__PURE__ */ React3.createElement("div", { className: "flex flex-col gap-4 my-4" }, /* @__PURE__ */ React3.createElement(
+                      Input,
+                      {
+                        label: "Network Name",
+                        value: chain.name,
+                        startContent: /* @__PURE__ */ React3.createElement(Icon, { icon: "fluent:rename-24-filled", width: "20", height: "20" })
+                      }
+                    ), /* @__PURE__ */ React3.createElement(
+                      Input,
+                      {
+                        label: "Network RPC",
+                        value: (_f = (_e = chain.rpcUrls.default) == null ? void 0 : _e.http) == null ? void 0 : _f[0],
+                        startContent: /* @__PURE__ */ React3.createElement(Icon, { icon: "material-symbols:link", width: "20", height: "20" })
+                      }
+                    ), /* @__PURE__ */ React3.createElement(
+                      Input,
+                      {
+                        label: "Chain ID",
+                        value: chain.id.toString(),
+                        startContent: /* @__PURE__ */ React3.createElement(Icon, { icon: "f7:grid-circle-fill", width: "20", height: "20" })
+                      }
+                    ), /* @__PURE__ */ React3.createElement(
+                      Input,
+                      {
+                        label: "Native Currency Symbol",
+                        value: (_g = chain.nativeCurrency) == null ? void 0 : _g.symbol,
+                        startContent: /* @__PURE__ */ React3.createElement(Icon, { icon: "mingcute:coin-fill", width: "20", height: "20" })
+                      }
+                    ), /* @__PURE__ */ React3.createElement(
+                      Input,
+                      {
+                        label: "Block Explorer URL",
+                        value: (_i = (_h = chain.blockExplorers) == null ? void 0 : _h.default) == null ? void 0 : _i.url,
+                        startContent: /* @__PURE__ */ React3.createElement(Icon, { icon: "material-symbols:explore", width: "20", height: "20" })
+                      }
+                    )))
+                  });
+                  console.log(error2.message);
+                }
+              } else {
+                rej(error);
+              }
+            }
+          }
+        } else {
+          this.openConnectModal();
+          const interval = setInterval(() => {
+            if (this.account) {
+              clearInterval(interval);
+              res(this);
+            }
+          }, 1e3);
+        }
+      } catch (error) {
+        rej(error);
+      }
+    });
+  }
+  async waitForTransactionReceipt({ hash }) {
+    if (this.isInSafeApp) {
+      const sdk = new SafeAppsSDK();
+      while (true) {
+        const queued = await sdk.txs.getBySafeTxHash(hash);
+        if (queued.txStatus === TransactionStatus.AWAITING_CONFIRMATIONS || queued.txStatus === TransactionStatus.AWAITING_EXECUTION || queued.txStatus === TransactionStatus.CANCELLED) {
+          await new Promise((resolve) => setTimeout(resolve, 2e3));
+        } else {
+          return this.publicClient.waitForTransactionReceipt({ hash: queued.txHash });
+        }
+      }
+    } else {
+      return this.publicClient.waitForTransactionReceipt({ hash });
+    }
+  }
+  static async SendTx(...args) {
+    return RootStore.Get(_WalletStore).sendTx(...args);
+  }
+  static async SendRawTx(...args) {
+    return RootStore.Get(_WalletStore).sendRawTx(...args);
+  }
+  async sendTx({
+    chainId,
+    tx,
+    autoAlert = true,
+    loadingText,
+    successText,
+    onError,
+    historyItem,
+    showSuccessDialog = false
+  }) {
+    var _a, _b, _c;
+    const toast = RootStore.Get(ToastPlugin);
+    let hash;
+    const historyStore = RootStore.Get(WalletHistoryStore);
+    try {
+      if (loadingText)
+        toast.loading(loadingText);
+      if (!chainId)
+        throw new Error("chainId, address, data is required");
+      await RootStore.Get(_WalletStore).prepare(Number(chainId));
+      hash = await tx();
+      if (historyItem) {
+        historyStore.recordHistory(__spreadProps(__spreadValues({}, historyItem), { tx: hash, timestamp: Date.now(), status: "loading", chainId: Number(chainId) }));
+      }
+      const receipt = await this.waitForTransactionReceipt({ hash });
+      if (receipt.status == "success") {
+        toast.dismiss();
+        toast.success("The transaction was successful");
+        if (historyItem) {
+          if (showSuccessDialog) {
+            ShowSuccessTxDialog({ msg: historyItem.msg, hash });
+          }
+          historyStore.updateHistoryStatusByTx(hash, "success");
+        }
+      } else {
+        toast.dismiss();
+        toast.error("The transaction failed");
+        historyStore.updateHistoryStatusByTx(hash, "fail");
+      }
+      if (successText)
+        toast.success(successText);
+      this.updateTicker++;
+      return receipt;
+    } catch (error) {
+      console.log(error);
+      toast.dismiss();
+      if (autoAlert) {
+        const msg = /reason="[A-Za-z0-9_ :"]*/g.exec(error == null ? void 0 : error.message);
+        console.log("sendTx", error == null ? void 0 : error.message);
+        if (((_a = error == null ? void 0 : error.message) == null ? void 0 : _a.includes("rejected")) || String(error).toLowerCase().includes("rejected") || String(error).toLowerCase().includes("denied")) {
+          toast.error("User rejected transaction");
+          return;
+        }
+        if (((_b = error == null ? void 0 : error.message) == null ? void 0 : _b.includes("The Transaction may not be processed on a block yet")) || ((_c = error == null ? void 0 : error.message) == null ? void 0 : _c.includes("could not be found"))) {
+          if (historyItem) {
+            historyStore.updateHistoryStatusByTx(hash, "success");
+          }
+          toast.success("The transaction was successful");
+          return;
+        }
+        if (msg) {
+          onError == null ? void 0 : onError(new Error(msg || "Transaction failed"));
+        } else {
+          if (error == null ? void 0 : error.message.includes("viem")) {
+            const messageArr = error == null ? void 0 : error.message.split("\n");
+            console.log("messageArr---", messageArr);
+            if (messageArr.length > 0) {
+              onError == null ? void 0 : onError(new Error(messageArr[0] || "Transaction failed"));
+            }
+          } else {
+            onError == null ? void 0 : onError(new Error((error == null ? void 0 : error.message) || "Transaction failed"));
+          }
+        }
+      } else {
+        onError == null ? void 0 : onError(error);
+        throw error;
+      }
+    }
+  }
+  async sendRawTx({
+    chainId,
+    address,
+    data,
+    value = "0",
+    autoAlert = true,
+    onSended,
+    onSuccess,
+    onError,
+    historyItem,
+    loadingText,
+    showSuccessDialog = false
+  }) {
+    var _a, _b, _c, _d;
+    chainId = Number(chainId);
+    const toast = RootStore.Get(ToastPlugin);
+    try {
+      if (!chainId || !address)
+        throw new Error("chainId, address, is required");
+      await RootStore.Get(_WalletStore).prepare(chainId);
+      if (loadingText)
+        toast.loading(loadingText);
+      const historyStore = RootStore.Get(WalletHistoryStore);
+      let hash;
+      if (this.isLedger) {
+        const ledger = await GlobalLedgerSigner();
+        console.log(ledger, "ledger signer");
+        const tx = await ledger.sendTransaction({
+          to: address,
+          data,
+          value: value ? BigInt(value) : void 0,
+          from: this.account,
+          type: 0
+        });
+        hash = tx == null ? void 0 : tx.hash;
+      } else {
+        hash = await this.walletClient.sendTransaction({
+          account: this.account,
+          to: address,
+          data,
+          value: value ? BigInt(value) : void 0
+        });
+      }
+      let receipt = await this.waitForTransactionReceipt({ hash });
+      if (historyItem) {
+        historyStore.recordHistory(__spreadProps(__spreadValues({}, historyItem), { tx: receipt.transactionHash, timestamp: Date.now(), status: "loading", chainId: Number(chainId) }));
+      }
+      this.updateTicker++;
+      onSended ? onSended({ res: receipt }) : null;
+      if (receipt.status == "success") {
+        if (historyItem) {
+          if (showSuccessDialog) {
+            ShowSuccessTxDialog({ msg: historyItem.msg, hash });
+          }
+          historyStore.updateHistoryStatusByTx(receipt.transactionHash, "success");
+        }
+        onSuccess && onSuccess({ res: receipt });
+        toast.dismiss();
+        toast.success("The transaction was successful");
+      } else {
+        if (historyItem) {
+          historyStore.updateHistoryStatusByTx(receipt.transactionHash, "fail");
+        }
+        onError && (onError == null ? void 0 : onError(new Error("The transaction failed")));
+        toast.dismiss();
+        toast.error("The transaction failed");
+      }
+      return receipt;
+    } catch (error) {
+      toast.dismiss();
+      onError == null ? void 0 : onError(error);
+      console.log(error);
+      /reason="[A-Za-z0-9_ :"]*/g.exec(error == null ? void 0 : error.message);
+      if (((_a = error == null ? void 0 : error.message) == null ? void 0 : _a.includes("rejected")) || ((_b = error == null ? void 0 : error.message) == null ? void 0 : _b.includes("cancel")) || String(error).toLowerCase().includes("cancel") || String(error).toLowerCase().includes("rejected") || String(error).toLowerCase().includes("user denied")) {
+        autoAlert && toast.error("User rejected transaction");
+        onError == null ? void 0 : onError(error);
+        return;
+      }
+      if ((_c = error == null ? void 0 : error.message) == null ? void 0 : _c.includes("Price slippage check")) {
+        autoAlert && toast.error("The latest pool price has changed, please try to increase the slippage tolerance or reload the page.");
+        onError == null ? void 0 : onError(error);
+        return;
+      }
+      if (error == null ? void 0 : error.message.includes("viem")) {
+        const messageArr = error == null ? void 0 : error.message.split("\n");
+        console.log("messageArr---", messageArr);
+        if (messageArr.length > 0) {
+          onError == null ? void 0 : onError(new Error((_d = messageArr[0]) != null ? _d : "Transaction failed"));
+          return;
+        }
+      }
+      if (!autoAlert) {
+        onError == null ? void 0 : onError(error);
+        throw error;
+      }
+    }
+  }
+  async signMessage(message) {
+    if (this.isLedger) {
+      const ledger = await GlobalLedgerSigner();
+      return ledger.signMessage(message);
+    }
+    return this.walletClient.signMessage(message);
+  }
+};
+var AutoMan = class {
+  constructor() {
+    this.sid = "AutoMan";
+    this.stype = "Plugin";
+    this.provider = observer(() => {
+      const wallet = RootStore.Get(WalletStore);
+      const router = useRouter();
+      useEffect(() => {
+        console.log("automan proverider");
+        const stores = Object.values(rootStore.instance).filter((i) => i._active > 0);
+        const promise = stores.reduce((p, c) => {
+          const promise2 = Object.values(c).filter((i) => !!(i == null ? void 0 : i.call));
+          return [...p, ...promise2];
+        }, []);
+        const autoUpdate = promise.filter((i) => i.autoUpdate);
+        console.log({ autoUpdate });
+        autoUpdate.forEach((i) => !i.loading.value && i.call());
+      }, [wallet.updateTicker, router.asPath]);
+      return /* @__PURE__ */ React3.createElement(React3.Fragment, null);
+    });
+  }
+  static use(stores, promises) {
+    useEffect(() => {
+      Object.keys(stores).forEach((storeName) => {
+        const store = stores[storeName];
+        Object.keys(store).forEach((key) => {
+          const i = store[key];
+          if (!!(i == null ? void 0 : i.getOrCall) && (i.autoInit || !!(promises == null ? void 0 : promises[storeName][key]))) {
+            if (!store._active)
+              store._active = 0;
+            store._active += 1;
+            i.getOrCall();
+          }
+        });
+      });
+      return () => {
+        Object.values(stores).forEach((store) => {
+          if (!store._active)
+            store._active = 0;
+          store._active -= 1;
+          if (store.autoClean !== false && !store._active > 0) {
+            Object.entries(store).filter(([key, i]) => !!(i == null ? void 0 : i.value)).forEach(([key, i]) => {
+              console.log("clean", key);
+              i.value = null;
+            });
+          }
+        });
+        if (!!promises) {
+          Object.entries(promises).forEach(([storaName, promise]) => {
+            const store = stores[storaName];
+            Object.keys(promise).forEach((key) => {
+              const promise2 = store[key];
+              console.log("clean", key);
+              if (!promise2)
+                return;
+              if (!promise2._active)
+                promise2._active = 0;
+              promise2._active -= 1;
+              if (!promise2._active > 0) {
+                promise2.value = null;
+              }
+            });
+          });
+        }
+      };
+    }, []);
+    return stores;
+  }
+};
+var AppProvider = observer(({ children }) => {
+  const rootStore2 = RootStore.init();
+  return /* @__PURE__ */ React3.createElement(React3.Fragment, null, rootStore2.providers.map((store) => {
+    const Component = store.provider;
+    return /* @__PURE__ */ React3.createElement(Component, { rootStore: rootStore2, key: store.sid });
+  }), children && children);
+});
+
+export { AppProvider, AutoMan, BigNumberInputState, BigNumberState, ConnectLedger, DisconnectLedger, ObjectPool, PromiseHook, StorageListState, StorageState, WalletConfigStore, WalletHistoryStore, WalletRpcStore, WalletStore };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk-BR7IWH2E.mjs.map