@unisat/wallet-state 1.0.0 → 1.0.2

package/lib/index.mjs

@@ -0,0 +1,2124 @@
+import { save, load } from 'redux-localstorage-simple';
+import { createAction, createSlice, configureStore } from '@reduxjs/toolkit';
+import { setupListeners } from '@reduxjs/toolkit/query/react';
+import { ChainType, AddressType, NetworkType } from '@unisat/wallet-types';
+import { DEFAULT_LOCKTIME_ID, CHAINS_MAP, CAT_VERSION, VERSION } from '@unisat/wallet-shared';
+import log from 'loglevel';
+import { createContext, useContext, useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import { FALLBACK_LOCALE, getSupportedLocales, LOCALE_NAMES, t, getCurrentLocaleAsync, BROWSER_TO_APP_LOCALE_MAP, initI18n, changeLanguage } from '@unisat/i18n';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import compareVersions from 'compare-versions';
+import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+import { BABYLON_CONFIG_MAP } from '@unisat/babylon-service/types';
+import '@unisat/keyring-service/types';
+import { useDispatch, useSelector } from 'react-redux';
+import { useNavigate } from 'react-router-dom';
+import { timeUtils, numUtils } from '@unisat/base-utils';
+
+// src/index.ts
+var updateVersion = createAction("global/updateVersion");
+
+// src/reducers/accounts.ts
+var initialAccount = {
+  type: "",
+  address: "",
+  brandName: "",
+  alianName: "",
+  displayBrandName: "",
+  index: 0,
+  balance: 0,
+  pubkey: "",
+  key: "",
+  flag: 0
+};
+var initialState = {
+  accounts: [],
+  current: initialAccount,
+  loading: false,
+  balanceMap: {},
+  balanceV2Map: {},
+  historyMap: {},
+  inscriptionsMap: {},
+  appSummary: {
+    apps: []
+  },
+  inscriptionSummary: {
+    mintedList: []
+  },
+  addressSummary: {
+    totalSatoshis: 0,
+    btcSatoshis: 0,
+    assetSatoshis: 0,
+    inscriptionCount: 0,
+    brc20Count: 0,
+    brc20Count5Byte: 0,
+    brc20Count6Byte: 0,
+    loading: true,
+    address: "",
+    runesCount: 0
+  }
+};
+var slice = createSlice({
+  name: "accounts",
+  initialState,
+  reducers: {
+    pendingLogin(state) {
+      state.loading = true;
+    },
+    setCurrent(state, action) {
+      const { payload } = action;
+      state.current = payload || initialAccount;
+    },
+    setAccounts(state, action) {
+      const { payload } = action;
+      state.accounts = payload;
+    },
+    setBalance(state, action) {
+      const {
+        payload: {
+          address,
+          amount,
+          btc_amount,
+          inscription_amount,
+          confirm_btc_amount,
+          pending_btc_amount
+        }
+      } = action;
+      state.balanceMap[address] = state.balanceMap[address] || {
+        amount: "0",
+        btc_amount: "0",
+        inscription_amount: "0",
+        confirm_btc_amount: "0",
+        pending_btc_amount: "0",
+        expired: true
+      };
+      state.balanceMap[address].amount = amount;
+      state.balanceMap[address].btc_amount = btc_amount;
+      state.balanceMap[address].inscription_amount = inscription_amount;
+      state.balanceMap[address].confirm_btc_amount = confirm_btc_amount;
+      state.balanceMap[address].pending_btc_amount = pending_btc_amount;
+      state.balanceMap[address].expired = false;
+    },
+    setBalanceV2(state, action) {
+      const {
+        payload: {
+          balance: { availableBalance, unavailableBalance, totalBalance },
+          address
+        }
+      } = action;
+      state.balanceV2Map[address] = state.balanceV2Map[address] || {
+        availableBalance: 0,
+        unavailableBalance: 0,
+        totalBalance: 0
+      };
+      state.balanceV2Map[address].availableBalance = availableBalance;
+      state.balanceV2Map[address].unavailableBalance = unavailableBalance;
+      state.balanceV2Map[address].totalBalance = totalBalance;
+    },
+    setAddressSummary(state, action) {
+      state.addressSummary = action.payload;
+    },
+    expireBalance(state) {
+      const balance = state.balanceMap[state.current.address];
+      if (balance) {
+        balance.expired = true;
+      }
+    },
+    setHistory(state, action) {
+      const {
+        payload: { address, list }
+      } = action;
+      state.historyMap[address] = state.historyMap[address] || {
+        list: [],
+        expired: true
+      };
+      state.historyMap[address].list = list;
+      state.historyMap[address].expired = false;
+    },
+    expireHistory(state) {
+      const history = state.historyMap[state.current.address];
+      if (history) {
+        history.expired = true;
+      }
+    },
+    setInscriptions(state, action) {
+      const {
+        payload: { address, list }
+      } = action;
+      state.inscriptionsMap[address] = state.inscriptionsMap[address] || {
+        list: [],
+        expired: true
+      };
+      state.inscriptionsMap[address].list = list;
+      state.inscriptionsMap[address].expired = false;
+    },
+    expireInscriptions(state) {
+      const inscriptions = state.inscriptionsMap[state.current.address];
+      if (inscriptions) {
+        inscriptions.expired = true;
+      }
+    },
+    setCurrentAccountName(state, action) {
+      const { payload } = action;
+      state.current.alianName = payload;
+      const account = state.accounts.find((v) => v.address === state.current.address);
+      if (account) {
+        account.alianName = payload;
+      }
+    },
+    setCurrentAddressFlag(state, action) {
+      const { payload } = action;
+      state.current.flag = payload;
+      const account = state.accounts.find((v) => v.address === state.current.address);
+      if (account) {
+        account.flag = payload;
+      }
+    },
+    setInscriptionSummary(state, action) {
+      const { payload } = action;
+      state.inscriptionSummary = payload;
+    },
+    setAppSummary(state, action) {
+      const { payload } = action;
+      state.appSummary = payload;
+    },
+    rejectLogin(state) {
+      state.loading = false;
+    },
+    reset(state) {
+      return initialState;
+    },
+    updateAccountName(state, action) {
+      const account = action.payload;
+      if (state.current.key === account.key) {
+        state.current.alianName = account.alianName;
+      }
+      state.accounts.forEach((v) => {
+        if (v.key === account.key) {
+          v.alianName = account.alianName;
+        }
+      });
+    }
+  },
+  extraReducers: (builder) => {
+    builder.addCase(updateVersion, (state) => {
+      if (!state.addressSummary) {
+        state.addressSummary = {
+          totalSatoshis: 0,
+          btcSatoshis: 0,
+          assetSatoshis: 0,
+          inscriptionCount: 0,
+          brc20Count: 0,
+          brc20Count5Byte: 0,
+          brc20Count6Byte: 0,
+          loading: true,
+          address: "",
+          runesCount: 0
+        };
+      }
+      if (!state.balanceV2Map) {
+        state.balanceV2Map = {};
+      }
+    });
+  }
+});
+var accountActions = slice.actions;
+var accounts_default = slice.reducer;
+var initialState2 = {
+  bannerList: [],
+  appList: [],
+  lastFetchTime: 0,
+  lastFetchChainType: ChainType.BITCOIN_MAINNET,
+  cachedBannerIds: [],
+  hasNewBanner: true
+};
+var slice2 = createSlice({
+  name: "discovery",
+  initialState: initialState2,
+  reducers: {
+    reset(state) {
+      return initialState2;
+    },
+    setBannerList(state, action) {
+      const { payload } = action;
+      const newBannerIds = payload.bannerList.map((banner) => banner.id);
+      const hasNewBanner = newBannerIds.some((id) => !state.cachedBannerIds.includes(id));
+      state.bannerList = payload.bannerList;
+      state.lastFetchChainType = payload.chainType;
+      state.lastFetchTime = payload.fetchTime;
+      state.hasNewBanner = hasNewBanner;
+      state.cachedBannerIds = newBannerIds;
+    },
+    setAppList(state, action) {
+      const { payload } = action;
+      state.appList = payload.appList;
+      state.lastFetchChainType = payload.chainType;
+      state.lastFetchTime = payload.fetchTime;
+    },
+    clearNewBannerFlag(state) {
+      state.hasNewBanner = false;
+    }
+  }
+});
+slice2.actions;
+var discovery_default = slice2.reducer;
+var initialState3 = {
+  tab: "home",
+  isUnlocked: false,
+  isReady: false,
+  isBooted: false
+};
+var reducers = {
+  reset: (state) => initialState3,
+  update: (state, action) => {
+    const { payload } = action;
+    state = Object.assign({}, state, payload);
+    return state;
+  }
+};
+var slice3 = createSlice({
+  name: "global",
+  initialState: initialState3,
+  reducers,
+  extraReducers: (builder) => {
+    builder.addCase(updateVersion, (state) => {
+    });
+  }
+});
+var globalActions = slice3.actions;
+var global_default = slice3.reducer;
+var initialKeyring = {
+  key: "",
+  index: 0,
+  type: "",
+  addressType: AddressType.P2TR,
+  accounts: [],
+  alianName: "",
+  hdPath: ""
+};
+var initialState4 = {
+  keyrings: [],
+  current: initialKeyring
+};
+var slice4 = createSlice({
+  name: "keyrings",
+  initialState: initialState4,
+  reducers: {
+    setCurrent(state, action) {
+      const { payload } = action;
+      state.current = payload || initialKeyring;
+    },
+    setKeyrings(state, action) {
+      const { payload } = action;
+      state.keyrings = payload;
+    },
+    reset(state) {
+      return initialState4;
+    },
+    updateKeyringName(state, action) {
+      const keyring = action.payload;
+      if (state.current.key === keyring.key) {
+        state.current.alianName = keyring.alianName;
+      }
+      state.keyrings.forEach((v) => {
+        if (v.key === keyring.key) {
+          v.alianName = keyring.alianName;
+        }
+      });
+    },
+    updateAccountName(state, action) {
+      const account = action.payload;
+      state.current.accounts.forEach((v) => {
+        if (v.key === account.key) {
+          v.alianName = account.alianName;
+        }
+      });
+      state.keyrings.forEach((v) => {
+        v.accounts.forEach((w) => {
+          if (w.key === account.key) {
+            w.alianName = account.alianName;
+          }
+        });
+      });
+    }
+  },
+  extraReducers: (builder) => {
+    builder.addCase(updateVersion, (state) => {
+    });
+  }
+});
+var keyringsActions = slice4.actions;
+var keyrings_default = slice4.reducer;
+var initialState5 = {
+  locale: "English",
+  networkType: NetworkType.MAINNET,
+  chainType: ChainType.BITCOIN_MAINNET,
+  walletConfig: {
+    version: "",
+    moonPayEnabled: true,
+    statusMessage: "",
+    endpoint: "",
+    chainTip: "",
+    disableUtxoTools: true
+  },
+  skippedVersion: "",
+  autoLockTimeId: DEFAULT_LOCKTIME_ID,
+  developerMode: false
+};
+var slice5 = createSlice({
+  name: "settings",
+  initialState: initialState5,
+  reducers: {
+    reset(state) {
+      return initialState5;
+    },
+    updateSettings(state, action) {
+      const { payload } = action;
+      state = Object.assign({}, state, payload);
+      return state;
+    }
+  },
+  extraReducers: (builder) => {
+    builder.addCase(updateVersion, (state) => {
+      if (!state.networkType) {
+        state.networkType = NetworkType.MAINNET;
+      }
+    });
+  }
+});
+var settingsActions = slice5.actions;
+var settings_default = slice5.reducer;
+var initialState6 = {
+  bitcoinTx: {
+    fromAddress: "",
+    toAddress: "",
+    toSatoshis: 0,
+    rawtx: "",
+    txid: "",
+    fee: 0,
+    estimateFee: 0,
+    changeSatoshis: 0,
+    sending: false,
+    autoAdjust: false,
+    psbtHex: "",
+    feeRate: 5,
+    toDomain: "",
+    enableRBF: false
+  },
+  ordinalsTx: {
+    fromAddress: "",
+    toAddress: "",
+    inscription: {
+      inscriptionId: "",
+      inscriptionNumber: 0,
+      address: "",
+      outputValue: 0,
+      preview: "",
+      content: "",
+      contentType: "",
+      contentLength: 0,
+      timestamp: 0,
+      genesisTransaction: "",
+      location: "",
+      output: "",
+      offset: 0,
+      contentBody: "",
+      utxoHeight: 0,
+      utxoConfirmation: 0
+    },
+    rawtx: "",
+    txid: "",
+    fee: 0,
+    estimateFee: 0,
+    changeSatoshis: 0,
+    sending: false,
+    psbtHex: "",
+    feeRate: 5,
+    toDomain: "",
+    outputValue: 1e4,
+    enableRBF: false
+  },
+  runesTx: {
+    fromAddress: "",
+    toAddress: "",
+    rawtx: "",
+    txid: "",
+    fee: 0,
+    estimateFee: 0,
+    changeSatoshis: 0,
+    sending: false,
+    psbtHex: "",
+    feeRate: 5,
+    toDomain: "",
+    outputValue: 1e4,
+    enableRBF: false
+  },
+  utxos: [],
+  spendUnavailableUtxos: [],
+  assetUtxos_inscriptions: [],
+  assetUtxos_runes: []
+};
+var slice6 = createSlice({
+  name: "transactions",
+  initialState: initialState6,
+  reducers: {
+    updateBitcoinTx(state, action) {
+      const { payload } = action;
+      state.bitcoinTx = Object.assign({}, state.bitcoinTx, payload);
+    },
+    updateOrdinalsTx(state, action) {
+      const { payload } = action;
+      state.ordinalsTx = Object.assign({}, state.ordinalsTx, payload);
+    },
+    updateRunesTx(state, action) {
+      const { payload } = action;
+      state.runesTx = Object.assign({}, state.runesTx, payload);
+    },
+    setUtxos(state, action) {
+      state.utxos = action.payload;
+    },
+    setSpendUnavailableUtxos(state, action) {
+      state.spendUnavailableUtxos = action.payload;
+    },
+    setAssetUtxosInscriptions(state, action) {
+      state.assetUtxos_inscriptions = action.payload;
+    },
+    setAssetUtxosRunes(state, action) {
+      state.assetUtxos_runes = action.payload;
+    },
+    reset(state) {
+      return initialState6;
+    }
+  },
+  extraReducers: (builder) => {
+    builder.addCase(updateVersion, (state) => {
+      if (!state.assetUtxos_inscriptions) {
+        state.assetUtxos_inscriptions = [];
+      }
+      if (!state.spendUnavailableUtxos) {
+        state.spendUnavailableUtxos = [];
+      }
+      if (!state.assetUtxos_runes) {
+        state.assetUtxos_runes = [];
+      }
+    });
+  }
+});
+var transactionsActions = slice6.actions;
+var transactions_default = slice6.reducer;
+var initialState7 = {
+  assetTabKey: 0 /* ORDINALS */,
+  ordinalsAssetTabKey: 0 /* ALL */,
+  catAssetTabKey: 0 /* CAT20 */,
+  alkanesAssetTabKey: 0 /* TOKEN */,
+  uiTxCreateScreen: {
+    toInfo: {
+      address: "",
+      domain: ""
+    },
+    inputAmount: "",
+    enableRBF: false,
+    feeRate: 1
+  },
+  babylonSendScreen: {
+    inputAmount: "",
+    memo: ""
+  },
+  navigationSource: 1 /* NORMAL */,
+  isBalanceHidden: false
+};
+var slice7 = createSlice({
+  name: "ui",
+  initialState: initialState7,
+  reducers: {
+    reset(state) {
+      return initialState7;
+    },
+    updateAssetTabScreen(state, action) {
+      const { payload } = action;
+      if (payload.assetTabKey !== void 0) {
+        state.assetTabKey = payload.assetTabKey;
+      }
+      if (payload.ordinalsAssetTabKey !== void 0) {
+        state.ordinalsAssetTabKey = payload.ordinalsAssetTabKey;
+      }
+      if (payload.catAssetTabKey !== void 0) {
+        state.catAssetTabKey = payload.catAssetTabKey;
+      }
+      if (payload.alkanesAssetTabKey !== void 0) {
+        state.alkanesAssetTabKey = payload.alkanesAssetTabKey;
+      }
+      return state;
+    },
+    updateTxCreateScreen(state, action) {
+      if (action.payload.toInfo !== void 0) {
+        state.uiTxCreateScreen.toInfo = action.payload.toInfo;
+      }
+      if (action.payload.inputAmount !== void 0) {
+        state.uiTxCreateScreen.inputAmount = action.payload.inputAmount;
+      }
+      if (action.payload.enableRBF !== void 0) {
+        state.uiTxCreateScreen.enableRBF = action.payload.enableRBF;
+      }
+      if (action.payload.feeRate !== void 0) {
+        state.uiTxCreateScreen.feeRate = action.payload.feeRate;
+      }
+    },
+    resetTxCreateScreen(state) {
+      state.uiTxCreateScreen = initialState7.uiTxCreateScreen;
+    },
+    updateBabylonSendScreen(state, action) {
+      if (action.payload.inputAmount !== void 0) {
+        state.babylonSendScreen.inputAmount = action.payload.inputAmount;
+      }
+      if (action.payload.memo !== void 0) {
+        state.babylonSendScreen.memo = action.payload.memo;
+      }
+    },
+    resetBabylonSendScreen(state) {
+      state.babylonSendScreen = initialState7.babylonSendScreen;
+    },
+    setNavigationSource(state, action) {
+      state.navigationSource = action.payload;
+    },
+    setBalanceHidden(state, action) {
+      state.isBalanceHidden = action.payload;
+    }
+  },
+  extraReducers: (builder) => {
+    builder.addCase(updateVersion, (state) => {
+      if (!state.assetTabKey) {
+        state.assetTabKey = 0 /* ORDINALS */;
+      }
+      if (!state.ordinalsAssetTabKey) {
+        state.ordinalsAssetTabKey = 0 /* ALL */;
+      }
+      if (!state.catAssetTabKey) {
+        state.catAssetTabKey = 0 /* CAT20 */;
+      }
+      if (!state.alkanesAssetTabKey) {
+        state.alkanesAssetTabKey = 0 /* TOKEN */;
+      }
+      if (!state.uiTxCreateScreen) {
+        state.uiTxCreateScreen = initialState7.uiTxCreateScreen;
+      }
+      if (!state.babylonSendScreen) {
+        state.babylonSendScreen = initialState7.babylonSendScreen;
+      }
+      if (state.isBalanceHidden === void 0) {
+        state.isBalanceHidden = false;
+      }
+    });
+  }
+});
+var uiActions = slice7.actions;
+var ui_default = slice7.reducer;
+var WalletContext = createContext(null);
+var WalletProvider = ({
+  children,
+  wallet
+}) => /* @__PURE__ */ jsx(WalletContext.Provider, { value: { wallet }, children });
+var useWallet = () => {
+  const { wallet } = useContext(WalletContext);
+  return wallet;
+};
+var I18nContext = createContext({
+  t: (key) => key,
+  locale: FALLBACK_LOCALE,
+  supportedLocales: [],
+  localeNames: {},
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  changeLocale: async () => {
+  }
+});
+var I18nProvider = ({ children }) => {
+  const [locale, setLocale] = useState(FALLBACK_LOCALE);
+  const [isInitialized, setIsInitialized] = useState(false);
+  const [error, setError] = useState(null);
+  const wallet = useWallet();
+  useEffect(() => {
+    const initialize = async () => {
+      try {
+        let localeToUse = FALLBACK_LOCALE;
+        const userSelectedLanguage = localStorage.getItem("userSelectedLanguage") === "true";
+        if (userSelectedLanguage) {
+          const savedLocale = localStorage.getItem("i18nextLng");
+          if (savedLocale && getSupportedLocales().includes(savedLocale)) {
+            localeToUse = savedLocale;
+            log.debug(`Using user selected language: ${savedLocale}`);
+          }
+        } else {
+          try {
+            const isFirstOpen = await wallet.getIsFirstOpen();
+            if (isFirstOpen) {
+              const browserLang = navigator.language;
+              log.debug(`New user - Browser language: ${browserLang}`);
+              const mappedLocale = BROWSER_TO_APP_LOCALE_MAP[browserLang];
+              if (mappedLocale && getSupportedLocales().includes(mappedLocale)) {
+                localeToUse = mappedLocale;
+                log.debug(`Using mapped browser language: ${mappedLocale}`);
+              } else if (getSupportedLocales().includes(browserLang)) {
+                localeToUse = browserLang;
+                log.debug(`Using browser language: ${browserLang}`);
+              } else {
+                const mainLang = browserLang.split("-")[0];
+                if (getSupportedLocales().includes(mainLang)) {
+                  localeToUse = mainLang;
+                  log.debug(`Using browser main language: ${mainLang}`);
+                } else {
+                  log.debug(`Browser language not supported, using default: ${FALLBACK_LOCALE}`);
+                  localeToUse = FALLBACK_LOCALE;
+                }
+              }
+            } else {
+              log.debug("Existing user - Using default English");
+              localeToUse = FALLBACK_LOCALE;
+            }
+          } catch (error2) {
+            log.error("Failed to get user status, using default language:", error2);
+            localeToUse = FALLBACK_LOCALE;
+          }
+        }
+        localStorage.setItem("i18nextLng", localeToUse);
+        await initI18n(localeToUse);
+        chrome.storage.local.set({ i18nextLng: localeToUse });
+        await initI18n(localeToUse);
+        setIsInitialized(true);
+      } catch (error2) {
+        log.error("Failed to initialize i18n:", error2);
+        setLocale(FALLBACK_LOCALE);
+        setIsInitialized(true);
+        setError(error2 instanceof Error ? error2 : new Error("Unknown error"));
+      }
+    };
+    initialize();
+  }, [wallet]);
+  const changeLocale = async (newLocale) => {
+    try {
+      await changeLanguage(newLocale);
+      setLocale(newLocale);
+      localStorage.setItem("userSelectedLanguage", "true");
+      localStorage.setItem("i18nextLng", newLocale);
+      chrome.storage.local.set({ i18nextLng: newLocale });
+    } catch (error2) {
+      setError(error2 instanceof Error ? error2 : new Error("Unknown error"));
+    }
+  };
+  const t2 = (key, substitutions) => {
+    try {
+      return t(key, substitutions);
+    } catch (error2) {
+      log.error(`Translation error for key "${key}":`, error2);
+      return key;
+    }
+  };
+  if (!isInitialized) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        style: {
+          display: "flex",
+          flexDirection: "column",
+          width: "100vw",
+          height: "100vh",
+          overflowY: "auto",
+          overflowX: "hidden"
+        },
+        children: /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              display: "flex",
+              flex: 1,
+              flexDirection: "column",
+              justifyItems: "center",
+              alignItems: "center"
+            },
+            children: /* @__PURE__ */ jsx("div", {})
+          }
+        )
+      }
+    );
+  }
+  if (error && process.env.NODE_ENV === "development") {
+    return /* @__PURE__ */ jsxs("div", { style: { color: "red", padding: "20px" }, children: [
+      /* @__PURE__ */ jsx("h2", { children: "Error initializing i18n" }),
+      /* @__PURE__ */ jsx("p", { children: error.message }),
+      /* @__PURE__ */ jsx("pre", { children: error.stack })
+    ] });
+  }
+  return /* @__PURE__ */ jsx(
+    I18nContext.Provider,
+    {
+      value: {
+        t: t2,
+        locale,
+        supportedLocales: getSupportedLocales(),
+        localeNames: LOCALE_NAMES,
+        changeLocale
+      },
+      children
+    }
+  );
+};
+function getAddressType(address, networkType) {
+  if (address.startsWith("bc1q") || address.startsWith("tb1q")) {
+    return AddressType.P2WPKH;
+  } else if (address.startsWith("bc1p") || address.startsWith("tb1p")) {
+    return AddressType.P2TR;
+  } else if (address.startsWith("1") || address.startsWith("m") || address.startsWith("n")) {
+    return AddressType.P2PKH;
+  } else if (address.startsWith("3") || address.startsWith("2")) {
+    return AddressType.P2SH_P2WPKH;
+  } else {
+    return AddressType.UNKNOWN;
+  }
+}
+var fetchLocale = async (locale) => {
+  const res = await fetch(`./_locales/${locale}/messages.json`);
+  const data = await res.json();
+  return Object.keys(data).reduce((res2, key) => {
+    return {
+      ...res2,
+      [key.replace(/__/g, " ")]: data[key].message
+    };
+  }, {});
+};
+i18n.use(initReactI18next).init({
+  fallbackLng: "en",
+  defaultNS: "translations",
+  interpolation: {
+    escapeValue: false
+    // react already safes from xss
+  }
+});
+var I18N_NS = "translations";
+var addResourceBundle = async (locale) => {
+  if (i18n.hasResourceBundle(locale, I18N_NS))
+    return;
+  const bundle = await fetchLocale(locale);
+  i18n.addResourceBundle(locale, "translations", bundle);
+};
+addResourceBundle("en");
+i18n.on("languageChanged", function(lng) {
+  addResourceBundle(lng);
+});
+var i18n_default = i18n;
+var useAppDispatch = () => useDispatch();
+var useAppSelector = useSelector;
+
+// src/hooks/keyrings.ts
+function useKeyringsState() {
+  return useAppSelector((state) => state.keyrings);
+}
+function useKeyrings() {
+  const keyringsState = useKeyringsState();
+  return keyringsState.keyrings;
+}
+function useCurrentKeyring() {
+  const keyringsState = useKeyringsState();
+  return keyringsState.current;
+}
+
+// src/hooks/accounts.ts
+function useAccountsState() {
+  return useAppSelector((state) => state.accounts);
+}
+function useCurrentAccount() {
+  const accountsState = useAccountsState();
+  return accountsState.current;
+}
+function useCurrentAddress() {
+  const accountsState = useAccountsState();
+  return accountsState.current.address;
+}
+function useAccountBalance() {
+  const accountsState = useAccountsState();
+  const currentAccount = useCurrentAccount();
+  return accountsState.balanceV2Map[currentAccount.address] || {
+    availableBalance: 0,
+    unavailableBalance: 0,
+    totalBalance: 0
+  };
+}
+function useAccountAddress() {
+  const currentAccount = useCurrentAccount();
+  return currentAccount.address;
+}
+function useFetchBalanceCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const currentAccount = useCurrentAccount();
+  const balance = useAccountBalance();
+  return useCallback(async () => {
+    if (!currentAccount.address)
+      return;
+    const summary = await wallet.getAddressSummary(currentAccount.address);
+    summary.address = currentAccount.address;
+    dispatch(accountActions["setAddressSummary"](summary));
+    const balanceV2 = await wallet.getAddressBalanceV2(currentAccount.address);
+    dispatch(
+      accountActions["setBalanceV2"]({
+        address: currentAccount.address,
+        balance: balanceV2
+      })
+    );
+  }, [dispatch, wallet, currentAccount, balance]);
+}
+function useReloadAccounts() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  return useCallback(async () => {
+    const keyrings = await wallet.getKeyrings();
+    dispatch(keyringsActions["setKeyrings"](keyrings));
+    const currentKeyring = await wallet.getCurrentKeyring();
+    dispatch(keyringsActions["setCurrent"](currentKeyring));
+    const _accounts = await wallet.getAccounts();
+    dispatch(accountActions["setAccounts"](_accounts));
+    const account = await wallet.getCurrentAccount();
+    dispatch(accountActions["setCurrent"](account));
+    dispatch(accountActions["expireBalance"](null));
+    dispatch(accountActions["expireInscriptions"](null));
+    wallet.getWalletConfig().then((data) => {
+      dispatch(settingsActions["updateSettings"]({ walletConfig: data }));
+    });
+  }, [dispatch, wallet]);
+}
+
+// src/hooks/settings.ts
+function useSettingsState() {
+  return useAppSelector((state) => state.settings);
+}
+function useLocale() {
+  const settings = useSettingsState();
+  return settings.locale;
+}
+function useChangeLocaleCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  return useCallback(
+    async (locale) => {
+      await wallet.setLocale(locale);
+      await addResourceBundle(locale);
+      i18n_default.changeLanguage(locale);
+      dispatch(
+        settingsActions.updateSettings({
+          locale
+        })
+      );
+      window.location.reload();
+    },
+    [dispatch, wallet]
+  );
+}
+function useNetworkType() {
+  const accountsState = useSettingsState();
+  const chain = CHAINS_MAP[accountsState.chainType];
+  if (chain) {
+    return chain.networkType;
+  } else {
+    return NetworkType.TESTNET;
+  }
+}
+function useChangeNetworkTypeCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  return useCallback(
+    async (type) => {
+      if (type === NetworkType.MAINNET) {
+        await wallet.setChainType(ChainType.BITCOIN_MAINNET);
+        dispatch(
+          settingsActions.updateSettings({
+            chainType: ChainType.BITCOIN_MAINNET
+          })
+        );
+      } else if (type === NetworkType.TESTNET) {
+        await wallet.setChainType(ChainType.BITCOIN_TESTNET);
+        dispatch(
+          settingsActions.updateSettings({
+            chainType: ChainType.BITCOIN_TESTNET
+          })
+        );
+      }
+    },
+    [dispatch]
+  );
+}
+function useChainType() {
+  const accountsState = useSettingsState();
+  return accountsState.chainType;
+}
+function useChain() {
+  const accountsState = useSettingsState();
+  return CHAINS_MAP[accountsState.chainType];
+}
+function useChangeChainTypeCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  return useCallback(
+    async (type) => {
+      dispatch(
+        settingsActions.updateSettings({
+          chainType: type
+        })
+      );
+      await wallet.setChainType(type);
+    },
+    [dispatch]
+  );
+}
+function useBTCUnit() {
+  const chainType = useChainType();
+  return CHAINS_MAP[chainType].unit;
+}
+function useTxExplorerUrl(txid) {
+  const chain = useChain();
+  if (chain.enum === ChainType.BITCOIN_MAINNET) {
+    return `${chain.unisatExplorerUrl}/tx/${txid}`;
+  } else if (chain.defaultExplorer === "mempool-space") {
+    return `${chain.mempoolSpaceUrl}/tx/${txid}`;
+  } else {
+    return `${chain.unisatExplorerUrl}/tx/${txid}`;
+  }
+}
+function useGetTxExplorerUrlCallback() {
+  const chain = useChain();
+  return useCallback(
+    (txid) => {
+      if (chain.enum === ChainType.BITCOIN_MAINNET) {
+        return `${chain.unisatExplorerUrl}/tx/${txid}`;
+      } else if (chain.defaultExplorer === "mempool-space") {
+        return `${chain.mempoolSpaceUrl}/tx/${txid}`;
+      } else {
+        return `${chain.unisatExplorerUrl}/tx/${txid}`;
+      }
+    },
+    [chain]
+  );
+}
+function useAddressExplorerUrl(address) {
+  const chain = useChain();
+  if (chain.enum === ChainType.BITCOIN_MAINNET) {
+    return `${chain.unisatExplorerUrl}/address/${address}`;
+  } else if (chain.defaultExplorer === "mempool-space") {
+    return `${chain.mempoolSpaceUrl}/address/${address}`;
+  } else {
+    return `${chain.unisatExplorerUrl}/address/${address}`;
+  }
+}
+function useCAT20TokenInfoExplorerUrl(version, tokenId) {
+  const chain = useChain();
+  if (version === CAT_VERSION.V1) {
+    return `${chain.unisatExplorerUrl}/cat20/${tokenId}`;
+  } else {
+    return `${chain.unisatExplorerUrl}/cat20-v2/${tokenId}`;
+  }
+}
+function useUnisatWebsite() {
+  const chainType = useChainType();
+  return CHAINS_MAP[chainType].unisatUrl;
+}
+function useOrdinalsWebsite() {
+  const chainType = useChainType();
+  return CHAINS_MAP[chainType].ordinalsUrl;
+}
+function useWalletConfig() {
+  const accountsState = useSettingsState();
+  return accountsState.walletConfig;
+}
+function useVersionInfo() {
+  const accountsState = useSettingsState();
+  const walletConfig = accountsState.walletConfig;
+  const newVersion = walletConfig.version;
+  const skippedVersion = accountsState.skippedVersion;
+  const currentVesion = VERSION;
+  let skipped = false;
+  let latestVersion = "";
+  if (!newVersion) {
+    skipped = true;
+  }
+  if (newVersion == skippedVersion) {
+    skipped = true;
+  }
+  if (newVersion) {
+    if (compareVersions(currentVesion, newVersion) >= 0) {
+      skipped = true;
+    } else {
+      latestVersion = newVersion;
+    }
+  }
+  if (currentVesion === "0.0.0") {
+    skipped = true;
+  }
+  return {
+    currentVesion,
+    newVersion,
+    latestVersion,
+    skipped
+  };
+}
+function useSkipVersionCallback() {
+  const wallet = useWallet();
+  const dispatch = useAppDispatch();
+  return useCallback((version) => {
+    wallet.setSkippedVersion(version).then((v) => {
+      dispatch(settingsActions.updateSettings({ skippedVersion: version }));
+    });
+  }, []);
+}
+function useAutoLockTimeId() {
+  const state = useSettingsState();
+  return state.autoLockTimeId;
+}
+function getAddressTips(address, chanEnum) {
+  let ret = {
+    homeTip: "",
+    sendTip: ""
+  };
+  try {
+    const chain = CHAINS_MAP[chanEnum];
+    const addressType = getAddressType(address, chain.networkType);
+    if (chain.isFractal && addressType === AddressType.P2PKH) {
+      ret = {
+        homeTip: t("legacy_address_warning_3"),
+        sendTip: t("legacy_address_warning_4")
+      };
+    }
+  } catch (e) {
+    console.log(e);
+  }
+  return ret;
+}
+function useAddressTips() {
+  const chain = useChain();
+  const account = useCurrentAccount();
+  return getAddressTips(account.address, chain.enum);
+}
+function useCAT721NFTContentBaseUrl(version) {
+  const chainType = useChainType();
+  if (chainType === ChainType.FRACTAL_BITCOIN_MAINNET) {
+    if (version === CAT_VERSION.V1) {
+      return "https://tracker-fractal-mainnet.catprotocol.org";
+    } else {
+      return "https://tracker2-fractal-mainnet.catprotocol.org";
+    }
+  } else if (chainType === ChainType.FRACTAL_BITCOIN_TESTNET) {
+    return "https://tracker-fractal-testnet.catprotocol.org";
+  } else {
+    return "";
+  }
+}
+function useBRC20MarketPlaceWebsite(ticker) {
+  const chainType = useChainType();
+  if (chainType === ChainType.BITCOIN_MAINNET) {
+    if (ticker.length == 6) {
+      return `${CHAINS_MAP[chainType].unisatUrl}/market/brc20_prog?tick=${ticker}`;
+    }
+  }
+  return `${CHAINS_MAP[chainType].unisatUrl}/market/brc20?tick=${ticker}`;
+}
+function useRunesMarketPlaceWebsite(ticker) {
+  const chainType = useChainType();
+  return `${CHAINS_MAP[chainType].unisatUrl}/runes/market?tick=${ticker}`;
+}
+function useCAT20MarketPlaceWebsite(tokenId) {
+  const chainType = useChainType();
+  return `${CHAINS_MAP[chainType].unisatUrl}/dex/cat20/${tokenId}`;
+}
+function useBabylonConfig() {
+  const chainType = useChainType();
+  return BABYLON_CONFIG_MAP[chainType] || BABYLON_CONFIG_MAP[ChainType.BITCOIN_MAINNET];
+}
+function useIsMainnetChain() {
+  const chainType = useChainType();
+  return chainType === ChainType.BITCOIN_MAINNET || chainType === ChainType.FRACTAL_BITCOIN_MAINNET;
+}
+function useDeveloperMode() {
+  const settings = useSettingsState();
+  return settings.developerMode;
+}
+function useSetDeveloperModeCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  return useCallback(
+    async (developerMode) => {
+      await wallet.setDeveloperMode(developerMode);
+      dispatch(
+        settingsActions.updateSettings({
+          developerMode
+        })
+      );
+    },
+    [dispatch, wallet]
+  );
+}
+var PriceContext = createContext({});
+function usePrice() {
+  const context = useContext(PriceContext);
+  if (!context) {
+    throw Error("Feature flag hooks can only be used by children of BridgeProvider.");
+  } else {
+    return context;
+  }
+}
+var isRequestingCoinPrice = false;
+var refreshCoinPriceTime = 0;
+function PriceProvider({ children }) {
+  const wallet = useWallet();
+  const chainType = useChainType();
+  const chain = useChain();
+  const [isLoadingCoinPrice, setIsLoadingCoinPrice] = useState(false);
+  const [coinPrice, setCoinPrice] = useState({
+    btc: 0,
+    fb: 0
+  });
+  const refreshCoinPrice = useCallback(() => {
+    if (chain.showPrice === false) {
+      return;
+    }
+    if (isRequestingCoinPrice) {
+      return;
+    }
+    if (Date.now() - refreshCoinPriceTime < 30 * 1e3) {
+      return;
+    }
+    isRequestingCoinPrice = true;
+    setIsLoadingCoinPrice(true);
+    wallet.getCoinPrice().then((res) => {
+      refreshCoinPriceTime = Date.now();
+      setCoinPrice(res);
+    }).catch((e) => {
+      setCoinPrice({
+        btc: 0,
+        fb: 0
+      });
+    }).finally(() => {
+      setIsLoadingCoinPrice(false);
+      isRequestingCoinPrice = false;
+    });
+  }, [chainType, chain]);
+  useEffect(() => {
+    refreshCoinPrice();
+  }, [refreshCoinPrice]);
+  const value = {
+    isLoadingCoinPrice,
+    coinPrice,
+    refreshCoinPrice
+  };
+  return /* @__PURE__ */ jsx(PriceContext.Provider, { value, children });
+}
+var UI_TYPE = {
+  Tab: "index",
+  Pop: "popup",
+  Notification: "notification",
+  SidePanel: "sidepanel"
+};
+var getUiType = () => {
+  const { pathname } = window.location;
+  return Object.entries(UI_TYPE).reduce((m, [key, value]) => {
+    m[`is${key}`] = pathname === `/${value}.html`;
+    return m;
+  }, {});
+};
+var useApproval = () => {
+  const wallet = useWallet();
+  const navigate = useNavigate();
+  const getApproval = wallet.getApproval;
+  const resolveApproval = async (data, stay = false, forceReject = false) => {
+    const approval = await getApproval();
+    if (approval) {
+      wallet.resolveApproval(data, forceReject);
+    }
+    if (stay) {
+      return;
+    }
+    setTimeout(() => {
+      navigate("/");
+    });
+  };
+  const rejectApproval = async (err, stay = false, isInternal = false) => {
+    const approval = await getApproval();
+    if (approval) {
+      await wallet.rejectApproval(err, stay, isInternal);
+    }
+    if (!stay) {
+      navigate("/");
+    }
+  };
+  useEffect(() => {
+    if (!getUiType().isNotification) {
+      return () => {
+      };
+    }
+    window.addEventListener("beforeunload", rejectApproval);
+    return () => window.removeEventListener("beforeunload", rejectApproval);
+  }, []);
+  return [getApproval, resolveApproval, rejectApproval];
+};
+
+// src/hooks/discovery.ts
+function useDiscoveryState() {
+  return useAppSelector((state) => state.discovery);
+}
+function useAppList() {
+  const state = useDiscoveryState();
+  return state.appList;
+}
+function useBannerList() {
+  const state = useDiscoveryState();
+  return state.bannerList;
+}
+function useLastFetchInfo() {
+  const state = useDiscoveryState();
+  return {
+    lastFetchTime: state.lastFetchTime,
+    lasfFetchChainType: state.lastFetchChainType
+  };
+}
+function useHasNewBanner() {
+  const state = useDiscoveryState();
+  return state.hasNewBanner;
+}
+function useGlobalState() {
+  return useAppSelector((state) => state.global);
+}
+function useTab() {
+  const globalState = useGlobalState();
+  return globalState.tab;
+}
+function useSetTabCallback() {
+  const dispatch = useAppDispatch();
+  return useCallback(
+    (tab) => {
+      dispatch(
+        globalActions["update"]({
+          tab
+        })
+      );
+    },
+    [dispatch]
+  );
+}
+function useBooted() {
+  const globalState = useGlobalState();
+  return globalState.isBooted;
+}
+function useIsUnlocked() {
+  const globalState = useGlobalState();
+  return globalState.isUnlocked;
+}
+function useIsReady() {
+  const globalState = useGlobalState();
+  return globalState.isReady;
+}
+function useUnlockCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const [, resolveApproval] = useApproval();
+  return useCallback(
+    async (password) => {
+      await wallet.unlock(password);
+      dispatch(globalActions.update({ isUnlocked: true }));
+      resolveApproval();
+    },
+    [dispatch, wallet]
+  );
+}
+function useCreateAccountCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  return useCallback(
+    async (mnemonics, hdPath, passphrase, addressType, accountCount) => {
+      await wallet.createKeyringWithMnemonics(
+        mnemonics,
+        hdPath,
+        passphrase,
+        addressType,
+        accountCount
+      );
+      dispatch(globalActions.update({ isUnlocked: true }));
+    },
+    [dispatch, wallet]
+  );
+}
+function useImportAccountsFromKeystoneCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  return useCallback(
+    async (urType, urCbor, addressType, accountCount, hdPath, filterPubkey, connectionType = "USB") => {
+      await wallet.createKeyringWithKeystone(
+        urType,
+        urCbor,
+        addressType,
+        hdPath,
+        accountCount,
+        filterPubkey,
+        connectionType
+      );
+      dispatch(globalActions.update({ isUnlocked: true }));
+    },
+    [dispatch, wallet]
+  );
+}
+function useCreateColdWalletCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  return useCallback(
+    async (xpub, addressType, alianName, hdPath, accountCount) => {
+      await wallet.createKeyringWithColdWallet(xpub, addressType, alianName, hdPath, accountCount);
+      dispatch(globalActions.update({ isUnlocked: true }));
+    },
+    [dispatch, wallet]
+  );
+}
+var defaultI18nContext = {
+  t: (key) => key,
+  locale: FALLBACK_LOCALE,
+  supportedLocales: [FALLBACK_LOCALE],
+  localeNames: LOCALE_NAMES,
+  changeLocale: async () => {
+  }
+};
+var useI18n = () => {
+  try {
+    const context = useContext(I18nContext);
+    if (!context) {
+      console.warn("useI18n must be used within an I18nProvider, using default context instead");
+      return defaultI18nContext;
+    }
+    return context;
+  } catch (error) {
+    console.error("Error in useI18n:", error);
+    return defaultI18nContext;
+  }
+};
+var getCurrentLocale = async () => {
+  return await getCurrentLocaleAsync();
+};
+var getSpecialLocale = async () => {
+  const currentLocale = await getCurrentLocale();
+  const specialLocales = ["es", "ru", "fr", "ja"];
+  const isSpecialLocale = specialLocales.includes(currentLocale);
+  return { currentLocale, isSpecialLocale };
+};
+function useTools() {
+  return {
+    showLoading: (show) => {
+    }
+  };
+}
+function useTransactionsState() {
+  return useAppSelector((state) => state.transactions);
+}
+function useBitcoinTx() {
+  const transactionsState = useTransactionsState();
+  return transactionsState.bitcoinTx;
+}
+function usePrepareSendBTCCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const fromAddress = useAccountAddress();
+  const utxos = useUtxos();
+  const fetchUtxos = useFetchUtxosCallback();
+  useCurrentAccount();
+  useBTCUnit();
+  const { t: t2 } = useI18n();
+  return useCallback(
+    async ({
+      toAddressInfo,
+      toAmount,
+      feeRate,
+      enableRBF,
+      memo,
+      memos,
+      disableAutoAdjust
+    }) => {
+      let _utxos = utxos;
+      if (_utxos.length === 0) {
+        _utxos = await fetchUtxos();
+      }
+      const safeBalance = _utxos.filter((v) => v.inscriptions.length == 0).reduce((pre, cur) => pre + cur.satoshis, 0);
+      if (safeBalance < toAmount) {
+        throw new Error(t2("insufficient_balance"));
+      }
+      if (!feeRate) {
+        const summary = await wallet.getFeeSummary();
+        feeRate = summary.list[1].feeRate;
+      }
+      let res;
+      if (safeBalance === toAmount && !disableAutoAdjust) {
+        res = await wallet.sendAllBTC({
+          to: toAddressInfo.address,
+          btcUtxos: _utxos,
+          enableRBF,
+          feeRate
+        });
+      } else {
+        res = await wallet.sendBTC({
+          to: toAddressInfo.address,
+          amount: toAmount,
+          btcUtxos: _utxos,
+          enableRBF,
+          feeRate,
+          memo,
+          memos
+        });
+      }
+      dispatch(
+        transactionsActions.updateBitcoinTx({
+          rawtx: res.rawtx,
+          psbtHex: res.psbtHex,
+          fromAddress,
+          feeRate,
+          enableRBF
+        })
+      );
+      const rawTxInfo = {
+        psbtHex: res.psbtHex,
+        rawtx: res.rawtx,
+        toAddressInfo,
+        fee: res.fee
+      };
+      return rawTxInfo;
+    },
+    [dispatch, wallet, fromAddress, utxos, fetchUtxos]
+  );
+}
+function usePrepareSendBypassHeadOffsetsCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const fromAddress = useAccountAddress();
+  useCurrentAccount();
+  useBTCUnit();
+  return useCallback(
+    async ({
+      toAddressInfo,
+      toAmount,
+      feeRate
+    }) => {
+      const res = await wallet.sendCoinBypassHeadOffsets(
+        [
+          {
+            address: toAddressInfo.address,
+            satoshis: toAmount
+          }
+        ],
+        feeRate
+      );
+      dispatch(
+        transactionsActions.updateBitcoinTx({
+          rawtx: res.rawtx,
+          psbtHex: res.psbtHex,
+          fromAddress,
+          feeRate
+        })
+      );
+      const rawTxInfo = {
+        psbtHex: res.psbtHex,
+        rawtx: res.rawtx,
+        toAddressInfo,
+        fee: res.fee
+      };
+      return rawTxInfo;
+    },
+    [dispatch, wallet, fromAddress]
+  );
+}
+function usePushBitcoinTxCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const tools = useTools();
+  return useCallback(
+    async (rawtx) => {
+      const ret = {
+        success: false,
+        txid: "",
+        error: ""
+      };
+      try {
+        tools.showLoading(true);
+        const txid = await wallet.pushTx(rawtx);
+        await timeUtils.sleep(3);
+        tools.showLoading(false);
+        dispatch(transactionsActions.updateBitcoinTx({ txid }));
+        dispatch(accountActions.expireBalance());
+        setTimeout(() => {
+          dispatch(accountActions.expireBalance());
+        }, 2e3);
+        setTimeout(() => {
+          dispatch(accountActions.expireBalance());
+        }, 5e3);
+        ret.success = true;
+        ret.txid = txid;
+      } catch (e) {
+        ret.error = e.message;
+      }
+      return ret;
+    },
+    [dispatch, wallet]
+  );
+}
+function useOrdinalsTx() {
+  const transactionsState = useTransactionsState();
+  return transactionsState.ordinalsTx;
+}
+function usePrepareSendOrdinalsInscriptionCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const fromAddress = useAccountAddress();
+  const utxos = useUtxos();
+  const fetchUtxos = useFetchUtxosCallback();
+  useCurrentAccount();
+  return useCallback(
+    async ({
+      toAddressInfo,
+      inscriptionId,
+      feeRate,
+      outputValue,
+      enableRBF
+    }) => {
+      if (!feeRate) {
+        const summary = await wallet.getFeeSummary();
+        feeRate = summary.list[1].feeRate;
+      }
+      let btcUtxos = utxos;
+      if (btcUtxos.length === 0) {
+        btcUtxos = await fetchUtxos();
+      }
+      const res = await wallet.sendOrdinalsInscription({
+        to: toAddressInfo.address,
+        inscriptionId,
+        feeRate,
+        outputValue,
+        enableRBF,
+        btcUtxos
+      });
+      dispatch(
+        transactionsActions.updateOrdinalsTx({
+          rawtx: res.rawtx,
+          psbtHex: res.psbtHex,
+          fromAddress,
+          // inscription,
+          feeRate,
+          outputValue,
+          enableRBF
+        })
+      );
+      const rawTxInfo = {
+        psbtHex: res.psbtHex,
+        rawtx: res.rawtx,
+        toAddressInfo
+      };
+      return rawTxInfo;
+    },
+    [dispatch, wallet, fromAddress, utxos]
+  );
+}
+function usePrepareSendOrdinalsInscriptionsCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const fromAddress = useAccountAddress();
+  const fetchUtxos = useFetchUtxosCallback();
+  const utxos = useUtxos();
+  useCurrentAccount();
+  return useCallback(
+    async ({
+      toAddressInfo,
+      inscriptionIds,
+      feeRate,
+      enableRBF
+    }) => {
+      if (!feeRate) {
+        const summary = await wallet.getFeeSummary();
+        feeRate = summary.list[1].feeRate;
+      }
+      let btcUtxos = utxos;
+      if (btcUtxos.length === 0) {
+        btcUtxos = await fetchUtxos();
+      }
+      const res = await wallet.sendOrdinalsInscriptions({
+        to: toAddressInfo.address,
+        inscriptionIds,
+        feeRate,
+        enableRBF,
+        btcUtxos
+      });
+      dispatch(
+        transactionsActions.updateOrdinalsTx({
+          rawtx: res.rawtx,
+          psbtHex: res.psbtHex,
+          fromAddress,
+          feeRate,
+          enableRBF
+        })
+      );
+      const rawTxInfo = {
+        psbtHex: res.psbtHex,
+        rawtx: res.rawtx,
+        toAddressInfo
+      };
+      return rawTxInfo;
+    },
+    [dispatch, wallet, fromAddress, utxos]
+  );
+}
+function useCreateSplitTxCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const fromAddress = useAccountAddress();
+  const utxos = useUtxos();
+  const fetchUtxos = useFetchUtxosCallback();
+  useCurrentAccount();
+  return useCallback(
+    async ({
+      inscriptionId,
+      feeRate,
+      outputValue,
+      enableRBF
+    }) => {
+      let btcUtxos = utxos;
+      if (btcUtxos.length === 0) {
+        btcUtxos = await fetchUtxos();
+      }
+      const res = await wallet.splitOrdinalsInscription({
+        inscriptionId,
+        feeRate,
+        outputValue,
+        enableRBF,
+        btcUtxos
+      });
+      dispatch(
+        transactionsActions.updateOrdinalsTx({
+          rawtx: res.rawtx,
+          psbtHex: res.psbtHex,
+          fromAddress,
+          // inscription,
+          enableRBF,
+          feeRate,
+          outputValue
+        })
+      );
+      const rawTxInfo = {
+        psbtHex: res.psbtHex,
+        rawtx: res.rawtx,
+        toAddressInfo: {
+          address: fromAddress
+        }
+      };
+      return { rawTxInfo, splitedCount: res.splitedCount };
+    },
+    [dispatch, wallet, fromAddress, utxos]
+  );
+}
+function usePushOrdinalsTxCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const tools = useTools();
+  return useCallback(
+    async (rawtx) => {
+      const ret = {
+        success: false,
+        txid: "",
+        error: ""
+      };
+      try {
+        tools.showLoading(true);
+        const txid = await wallet.pushTx(rawtx);
+        await timeUtils.sleep(3);
+        tools.showLoading(false);
+        dispatch(transactionsActions.updateOrdinalsTx({ txid }));
+        dispatch(accountActions.expireBalance());
+        setTimeout(() => {
+          dispatch(accountActions.expireBalance());
+        }, 2e3);
+        setTimeout(() => {
+          dispatch(accountActions.expireBalance());
+        }, 5e3);
+        ret.success = true;
+        ret.txid = txid;
+      } catch (e) {
+        console.log(e);
+        ret.error = e.message;
+      }
+      return ret;
+    },
+    [dispatch, wallet]
+  );
+}
+function useUtxos() {
+  const transactionsState = useTransactionsState();
+  return transactionsState.utxos;
+}
+function useFetchUtxosCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const account = useCurrentAccount();
+  return useCallback(async () => {
+    const data = await wallet.getBTCUtxos();
+    dispatch(transactionsActions.setUtxos(data));
+    return data;
+  }, [wallet, account]);
+}
+function useSpendUnavailableUtxos() {
+  const transactionsState = useTransactionsState();
+  return transactionsState.spendUnavailableUtxos;
+}
+function useSetSpendUnavailableUtxosCallback() {
+  const dispatch = useAppDispatch();
+  return useCallback(
+    (utxos) => {
+      dispatch(transactionsActions.setSpendUnavailableUtxos(utxos));
+    },
+    [dispatch]
+  );
+}
+function useSafeBalance() {
+  const utxos = useUtxos();
+  return useMemo(() => {
+    const satoshis = utxos.filter((v) => v.inscriptions.length === 0).reduce((pre, cur) => pre + cur.satoshis, 0);
+    return numUtils.satoshisToAmount(satoshis);
+  }, [utxos]);
+}
+function useAssetUtxosRunes() {
+  const transactionsState = useTransactionsState();
+  return transactionsState.assetUtxos_runes;
+}
+function useFetchAssetUtxosRunesCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const account = useCurrentAccount();
+  return useCallback(
+    async (rune) => {
+      const data = await wallet.getAssetUtxosRunes(rune);
+      dispatch(transactionsActions.setAssetUtxosRunes(data));
+      return data;
+    },
+    [wallet, account]
+  );
+}
+function usePrepareSendRunesCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const fromAddress = useAccountAddress();
+  const utxos = useUtxos();
+  const fetchUtxos = useFetchUtxosCallback();
+  const assetUtxosRunes = useAssetUtxosRunes();
+  const fetchAssetUtxosRunes = useFetchAssetUtxosRunesCallback();
+  const account = useCurrentAccount();
+  return useCallback(
+    async ({
+      toAddressInfo,
+      runeid,
+      runeAmount,
+      outputValue,
+      feeRate,
+      enableRBF
+    }) => {
+      if (!feeRate) {
+        const summary = await wallet.getFeeSummary();
+        feeRate = summary.list[1].feeRate;
+      }
+      let btcUtxos = utxos;
+      if (btcUtxos.length === 0) {
+        btcUtxos = await fetchUtxos();
+      }
+      let assetUtxos = assetUtxosRunes;
+      if (assetUtxos.length == 0) {
+        assetUtxos = await fetchAssetUtxosRunes(runeid);
+      }
+      const res = await wallet.sendRunes({
+        to: toAddressInfo.address,
+        runeid,
+        runeAmount,
+        outputValue,
+        feeRate,
+        enableRBF,
+        btcUtxos,
+        assetUtxos
+      });
+      dispatch(
+        transactionsActions.updateRunesTx({
+          rawtx: res.rawtx,
+          psbtHex: res.psbtHex,
+          fromAddress,
+          feeRate,
+          enableRBF,
+          runeid,
+          runeAmount,
+          outputValue
+        })
+      );
+      const rawTxInfo = {
+        psbtHex: res.psbtHex,
+        rawtx: res.rawtx,
+        toAddressInfo
+      };
+      return rawTxInfo;
+    },
+    [dispatch, wallet, fromAddress, utxos, assetUtxosRunes, fetchAssetUtxosRunes, account]
+  );
+}
+function useRunesTx() {
+  const transactionsState = useTransactionsState();
+  return transactionsState.runesTx;
+}
+function usePrepareSendAlkanesCallback() {
+  const wallet = useWallet();
+  const account = useCurrentAccount();
+  const callback = useCallback(
+    async (toAddressInfo, alkaneid, amount, feeRate, enableRBF = false) => {
+      return await wallet.sendAlkanes({
+        to: toAddressInfo.address,
+        alkaneid,
+        amount,
+        feeRate,
+        enableRBF
+      });
+    },
+    [wallet, account]
+  );
+  return callback;
+}
+function useUIState() {
+  return useAppSelector((state) => state.ui);
+}
+function useAssetTabKey() {
+  const uiState = useUIState();
+  return uiState.assetTabKey;
+}
+function useOrdinalsAssetTabKey() {
+  const uiState = useUIState();
+  return uiState.ordinalsAssetTabKey;
+}
+function useCATAssetTabKey() {
+  const uiState = useUIState();
+  return uiState.catAssetTabKey;
+}
+function useAlkanesAssetTabKey() {
+  const uiState = useUIState();
+  return uiState.alkanesAssetTabKey;
+}
+function useUiTxCreateScreen() {
+  const uiState = useUIState();
+  return uiState.uiTxCreateScreen;
+}
+function useUpdateUiTxCreateScreen() {
+  const dispatch = useAppDispatch();
+  return ({
+    toInfo,
+    inputAmount,
+    enableRBF,
+    feeRate
+  }) => {
+    dispatch(uiActions.updateTxCreateScreen({ toInfo, inputAmount, enableRBF, feeRate }));
+  };
+}
+function useResetUiTxCreateScreen() {
+  const dispatch = useAppDispatch();
+  return () => {
+    dispatch(uiActions.resetTxCreateScreen());
+  };
+}
+function useSupportedAssets() {
+  const chainType = useChainType();
+  const currentAddress = useCurrentAddress();
+  useNetworkType();
+  useCurrentAccount();
+  const assetTabKeys = [];
+  const assets = {
+    ordinals: false,
+    runes: false,
+    CAT20: false,
+    alkanes: false
+  };
+  assets.ordinals = true;
+  assetTabKeys.push(0 /* ORDINALS */);
+  assets.runes = true;
+  assetTabKeys.push(2 /* RUNES */);
+  if (chainType === ChainType.FRACTAL_BITCOIN_MAINNET || chainType === ChainType.FRACTAL_BITCOIN_TESTNET) {
+    const addressType = getAddressType(currentAddress);
+    if (addressType == AddressType.P2TR || addressType == AddressType.P2WPKH) {
+      assets.CAT20 = true;
+      assetTabKeys.push(3 /* CAT */);
+    }
+  }
+  if (chainType === ChainType.BITCOIN_SIGNET || chainType === ChainType.BITCOIN_MAINNET) {
+    assets.alkanes = true;
+    assetTabKeys.push(4 /* ALKANES */);
+  }
+  return {
+    tabKeys: assetTabKeys,
+    assets,
+    key: assetTabKeys.join(",")
+  };
+}
+var useIsInExpandView = () => {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return useMemo(() => {
+    if (window.innerWidth > 156 * 3) {
+      return true;
+    } else {
+      return false;
+    }
+  }, [window.innerWidth]);
+};
+var useUtxoTools = (chain) => {
+  const openUtxoTools = () => {
+    window.open(`${chain.unisatUrl}/utxo?tab=all`);
+  };
+  return {
+    openUtxoTools
+  };
+};
+
+// src/utils/eventBus.ts
+var EventBus = class {
+  constructor() {
+    this.events = {};
+    this.emit = (type, params) => {
+      const listeners = this.events[type];
+      if (listeners) {
+        listeners.forEach((fn) => {
+          fn(params);
+        });
+      }
+    };
+    this.once = (type, fn) => {
+      const listeners = this.events[type];
+      const func = (...params) => {
+        fn(...params);
+        this.events[type] = this.events[type].filter((item) => item !== func);
+      };
+      if (listeners) {
+        this.events[type].push(func);
+      } else {
+        this.events[type] = [func];
+      }
+    };
+    this.addEventListener = (type, fn) => {
+      const listeners = this.events[type];
+      if (listeners) {
+        this.events[type].push(fn);
+      } else {
+        this.events[type] = [fn];
+      }
+    };
+    this.removeEventListener = (type, fn) => {
+      const listeners = this.events[type];
+      if (listeners) {
+        this.events[type] = this.events[type].filter((item) => item !== fn);
+      }
+    };
+    this.removeAllEventListeners = (type) => {
+      this.events[type] = [];
+    };
+  }
+};
+var eventBus_default = new EventBus();
+
+// src/updater/accounts.ts
+function AccountUpdater() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  const currentAccount = useCurrentAccount();
+  const isUnlocked = useIsUnlocked();
+  const selfRef = useRef({
+    preAccountKey: "",
+    loadingBalance: false,
+    loadingHistory: false
+  });
+  const self = selfRef.current;
+  const reloadAccounts = useReloadAccounts();
+  const onCurrentChange = useCallback(async () => {
+    if (isUnlocked && currentAccount && currentAccount.key != self.preAccountKey) {
+      self.preAccountKey = currentAccount.key;
+      reloadAccounts();
+    }
+  }, [dispatch, currentAccount, wallet, isUnlocked]);
+  useEffect(() => {
+    onCurrentChange();
+  }, [currentAccount && currentAccount.key, isUnlocked]);
+  const fetchBalance = useFetchBalanceCallback();
+  useEffect(() => {
+    if (self.loadingBalance) {
+      return;
+    }
+    if (!isUnlocked) {
+      return;
+    }
+    self.loadingBalance = true;
+    fetchBalance().finally(() => {
+      self.loadingBalance = false;
+    });
+  }, [fetchBalance, wallet, isUnlocked, self]);
+  useEffect(() => {
+    const accountChangeHandler = (account) => {
+      if (account && account.address) {
+        dispatch(accountActions.setCurrent(account));
+      }
+    };
+    eventBus_default.addEventListener("accountsChanged", accountChangeHandler);
+    return () => {
+      eventBus_default.removeEventListener("accountsChanged", accountChangeHandler);
+    };
+  }, [dispatch]);
+  useEffect(() => {
+    const chaintChangeHandler = (params) => {
+      dispatch(
+        settingsActions.updateSettings({
+          chainType: params.type
+        })
+      );
+      reloadAccounts();
+    };
+    eventBus_default.addEventListener("chainChanged", chaintChangeHandler);
+    return () => {
+      eventBus_default.removeEventListener("chainChanged", chaintChangeHandler);
+    };
+  }, [dispatch]);
+  useEffect(() => {
+    const lockHandler = () => {
+      dispatch(globalActions.update({ isUnlocked: false }));
+    };
+    eventBus_default.addEventListener("lock", lockHandler);
+    return () => {
+      eventBus_default.removeEventListener("lock", lockHandler);
+    };
+  }, [dispatch]);
+  useEffect(() => {
+    const unlockHandler = () => {
+      dispatch(globalActions.update({ isUnlocked: true }));
+    };
+    eventBus_default.addEventListener("unlock", unlockHandler);
+    return () => {
+      eventBus_default.removeEventListener("unlock", unlockHandler);
+    };
+  }, [dispatch]);
+  return null;
+}
+
+// src/index.ts
+var PERSISTED_KEYS = ["ui", "discovery"];
+var store = configureStore({
+  reducer: {
+    accounts: accounts_default,
+    transactions: transactions_default,
+    settings: settings_default,
+    global: global_default,
+    keyrings: keyrings_default,
+    ui: ui_default,
+    discovery: discovery_default
+  },
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware({ thunk: true }).concat(save({ states: PERSISTED_KEYS, debounce: 1e3 })),
+  preloadedState: load({ states: PERSISTED_KEYS, disableWarnings: true })
+});
+store.dispatch(updateVersion());
+setupListeners(store.dispatch);
+var src_default = store;
+
+export { AccountUpdater, I18nProvider, PriceProvider, WalletProvider, src_default as default, getAddressTips, getCurrentLocale, getSpecialLocale, getUiType, useAddressExplorerUrl, useAddressTips, useAlkanesAssetTabKey, useAppDispatch, useAppList, useAppSelector, useApproval, useAssetTabKey, useAssetUtxosRunes, useAutoLockTimeId, useBRC20MarketPlaceWebsite, useBTCUnit, useBabylonConfig, useBannerList, useBitcoinTx, useBooted, useCAT20MarketPlaceWebsite, useCAT20TokenInfoExplorerUrl, useCAT721NFTContentBaseUrl, useCATAssetTabKey, useChain, useChainType, useChangeChainTypeCallback, useChangeLocaleCallback, useChangeNetworkTypeCallback, useCreateAccountCallback, useCreateColdWalletCallback, useCreateSplitTxCallback, useCurrentKeyring, useDeveloperMode, useDiscoveryState, useFetchAssetUtxosRunesCallback, useFetchUtxosCallback, useGetTxExplorerUrlCallback, useGlobalState, useHasNewBanner, useI18n, useImportAccountsFromKeystoneCallback, useIsInExpandView, useIsMainnetChain, useIsReady, useIsUnlocked, useKeyrings, useKeyringsState, useLastFetchInfo, useLocale, useNetworkType, useOrdinalsAssetTabKey, useOrdinalsTx, useOrdinalsWebsite, usePrepareSendAlkanesCallback, usePrepareSendBTCCallback, usePrepareSendBypassHeadOffsetsCallback, usePrepareSendOrdinalsInscriptionCallback, usePrepareSendOrdinalsInscriptionsCallback, usePrepareSendRunesCallback, usePrice, usePushBitcoinTxCallback, usePushOrdinalsTxCallback, useResetUiTxCreateScreen, useRunesMarketPlaceWebsite, useRunesTx, useSafeBalance, useSetDeveloperModeCallback, useSetSpendUnavailableUtxosCallback, useSetTabCallback, useSettingsState, useSkipVersionCallback, useSpendUnavailableUtxos, useSupportedAssets, useTab, useTransactionsState, useTxExplorerUrl, useUIState, useUiTxCreateScreen, useUnisatWebsite, useUnlockCallback, useUpdateUiTxCreateScreen, useUtxoTools, useUtxos, useVersionInfo, useWallet, useWalletConfig };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.mjs.map