@unisat/wallet-state 1.0.1 → 1.0.2

package/lib/index.js

@@ -0,0 +1,2225 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var reduxLocalstorageSimple = require('redux-localstorage-simple');
+var toolkit = require('@reduxjs/toolkit');
+var react$1 = require('@reduxjs/toolkit/query/react');
+var walletTypes = require('@unisat/wallet-types');
+var walletShared = require('@unisat/wallet-shared');
+var log = require('loglevel');
+var react = require('react');
+var i18n = require('@unisat/i18n');
+var jsxRuntime = require('react/jsx-runtime');
+var compareVersions = require('compare-versions');
+var i18n$1 = require('i18next');
+var reactI18next = require('react-i18next');
+var types = require('@unisat/babylon-service/types');
+require('@unisat/keyring-service/types');
+var reactRedux = require('react-redux');
+var reactRouterDom = require('react-router-dom');
+var baseUtils = require('@unisat/base-utils');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var log__default = /*#__PURE__*/_interopDefault(log);
+var compareVersions__default = /*#__PURE__*/_interopDefault(compareVersions);
+var i18n__default = /*#__PURE__*/_interopDefault(i18n$1);
+
+// src/index.ts
+var updateVersion = toolkit.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 = toolkit.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: walletTypes.ChainType.BITCOIN_MAINNET,
+  cachedBannerIds: [],
+  hasNewBanner: true
+};
+var slice2 = toolkit.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 = toolkit.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: walletTypes.AddressType.P2TR,
+  accounts: [],
+  alianName: "",
+  hdPath: ""
+};
+var initialState4 = {
+  keyrings: [],
+  current: initialKeyring
+};
+var slice4 = toolkit.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: walletTypes.NetworkType.MAINNET,
+  chainType: walletTypes.ChainType.BITCOIN_MAINNET,
+  walletConfig: {
+    version: "",
+    moonPayEnabled: true,
+    statusMessage: "",
+    endpoint: "",
+    chainTip: "",
+    disableUtxoTools: true
+  },
+  skippedVersion: "",
+  autoLockTimeId: walletShared.DEFAULT_LOCKTIME_ID,
+  developerMode: false
+};
+var slice5 = toolkit.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 = walletTypes.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 = toolkit.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 = toolkit.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 = react.createContext(null);
+var WalletProvider = ({
+  children,
+  wallet
+}) => /* @__PURE__ */ jsxRuntime.jsx(WalletContext.Provider, { value: { wallet }, children });
+var useWallet = () => {
+  const { wallet } = react.useContext(WalletContext);
+  return wallet;
+};
+var I18nContext = react.createContext({
+  t: (key) => key,
+  locale: i18n.FALLBACK_LOCALE,
+  supportedLocales: [],
+  localeNames: {},
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  changeLocale: async () => {
+  }
+});
+var I18nProvider = ({ children }) => {
+  const [locale, setLocale] = react.useState(i18n.FALLBACK_LOCALE);
+  const [isInitialized, setIsInitialized] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const wallet = useWallet();
+  react.useEffect(() => {
+    const initialize = async () => {
+      try {
+        let localeToUse = i18n.FALLBACK_LOCALE;
+        const userSelectedLanguage = localStorage.getItem("userSelectedLanguage") === "true";
+        if (userSelectedLanguage) {
+          const savedLocale = localStorage.getItem("i18nextLng");
+          if (savedLocale && i18n.getSupportedLocales().includes(savedLocale)) {
+            localeToUse = savedLocale;
+            log__default.default.debug(`Using user selected language: ${savedLocale}`);
+          }
+        } else {
+          try {
+            const isFirstOpen = await wallet.getIsFirstOpen();
+            if (isFirstOpen) {
+              const browserLang = navigator.language;
+              log__default.default.debug(`New user - Browser language: ${browserLang}`);
+              const mappedLocale = i18n.BROWSER_TO_APP_LOCALE_MAP[browserLang];
+              if (mappedLocale && i18n.getSupportedLocales().includes(mappedLocale)) {
+                localeToUse = mappedLocale;
+                log__default.default.debug(`Using mapped browser language: ${mappedLocale}`);
+              } else if (i18n.getSupportedLocales().includes(browserLang)) {
+                localeToUse = browserLang;
+                log__default.default.debug(`Using browser language: ${browserLang}`);
+              } else {
+                const mainLang = browserLang.split("-")[0];
+                if (i18n.getSupportedLocales().includes(mainLang)) {
+                  localeToUse = mainLang;
+                  log__default.default.debug(`Using browser main language: ${mainLang}`);
+                } else {
+                  log__default.default.debug(`Browser language not supported, using default: ${i18n.FALLBACK_LOCALE}`);
+                  localeToUse = i18n.FALLBACK_LOCALE;
+                }
+              }
+            } else {
+              log__default.default.debug("Existing user - Using default English");
+              localeToUse = i18n.FALLBACK_LOCALE;
+            }
+          } catch (error2) {
+            log__default.default.error("Failed to get user status, using default language:", error2);
+            localeToUse = i18n.FALLBACK_LOCALE;
+          }
+        }
+        localStorage.setItem("i18nextLng", localeToUse);
+        await i18n.initI18n(localeToUse);
+        chrome.storage.local.set({ i18nextLng: localeToUse });
+        await i18n.initI18n(localeToUse);
+        setIsInitialized(true);
+      } catch (error2) {
+        log__default.default.error("Failed to initialize i18n:", error2);
+        setLocale(i18n.FALLBACK_LOCALE);
+        setIsInitialized(true);
+        setError(error2 instanceof Error ? error2 : new Error("Unknown error"));
+      }
+    };
+    initialize();
+  }, [wallet]);
+  const changeLocale = async (newLocale) => {
+    try {
+      await i18n.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 i18n.t(key, substitutions);
+    } catch (error2) {
+      log__default.default.error(`Translation error for key "${key}":`, error2);
+      return key;
+    }
+  };
+  if (!isInitialized) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        style: {
+          display: "flex",
+          flexDirection: "column",
+          width: "100vw",
+          height: "100vh",
+          overflowY: "auto",
+          overflowX: "hidden"
+        },
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              display: "flex",
+              flex: 1,
+              flexDirection: "column",
+              justifyItems: "center",
+              alignItems: "center"
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsx("div", {})
+          }
+        )
+      }
+    );
+  }
+  if (error && process.env.NODE_ENV === "development") {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { color: "red", padding: "20px" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h2", { children: "Error initializing i18n" }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { children: error.message }),
+      /* @__PURE__ */ jsxRuntime.jsx("pre", { children: error.stack })
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    I18nContext.Provider,
+    {
+      value: {
+        t: t2,
+        locale,
+        supportedLocales: i18n.getSupportedLocales(),
+        localeNames: i18n.LOCALE_NAMES,
+        changeLocale
+      },
+      children
+    }
+  );
+};
+function getAddressType(address, networkType) {
+  if (address.startsWith("bc1q") || address.startsWith("tb1q")) {
+    return walletTypes.AddressType.P2WPKH;
+  } else if (address.startsWith("bc1p") || address.startsWith("tb1p")) {
+    return walletTypes.AddressType.P2TR;
+  } else if (address.startsWith("1") || address.startsWith("m") || address.startsWith("n")) {
+    return walletTypes.AddressType.P2PKH;
+  } else if (address.startsWith("3") || address.startsWith("2")) {
+    return walletTypes.AddressType.P2SH_P2WPKH;
+  } else {
+    return walletTypes.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__default.default.use(reactI18next.initReactI18next).init({
+  fallbackLng: "en",
+  defaultNS: "translations",
+  interpolation: {
+    escapeValue: false
+    // react already safes from xss
+  }
+});
+var I18N_NS = "translations";
+var addResourceBundle = async (locale) => {
+  if (i18n__default.default.hasResourceBundle(locale, I18N_NS))
+    return;
+  const bundle = await fetchLocale(locale);
+  i18n__default.default.addResourceBundle(locale, "translations", bundle);
+};
+addResourceBundle("en");
+i18n__default.default.on("languageChanged", function(lng) {
+  addResourceBundle(lng);
+});
+var i18n_default = i18n__default.default;
+var useAppDispatch = () => reactRedux.useDispatch();
+var useAppSelector = reactRedux.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 react.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 react.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 react.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 = walletShared.CHAINS_MAP[accountsState.chainType];
+  if (chain) {
+    return chain.networkType;
+  } else {
+    return walletTypes.NetworkType.TESTNET;
+  }
+}
+function useChangeNetworkTypeCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  return react.useCallback(
+    async (type) => {
+      if (type === walletTypes.NetworkType.MAINNET) {
+        await wallet.setChainType(walletTypes.ChainType.BITCOIN_MAINNET);
+        dispatch(
+          settingsActions.updateSettings({
+            chainType: walletTypes.ChainType.BITCOIN_MAINNET
+          })
+        );
+      } else if (type === walletTypes.NetworkType.TESTNET) {
+        await wallet.setChainType(walletTypes.ChainType.BITCOIN_TESTNET);
+        dispatch(
+          settingsActions.updateSettings({
+            chainType: walletTypes.ChainType.BITCOIN_TESTNET
+          })
+        );
+      }
+    },
+    [dispatch]
+  );
+}
+function useChainType() {
+  const accountsState = useSettingsState();
+  return accountsState.chainType;
+}
+function useChain() {
+  const accountsState = useSettingsState();
+  return walletShared.CHAINS_MAP[accountsState.chainType];
+}
+function useChangeChainTypeCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  return react.useCallback(
+    async (type) => {
+      dispatch(
+        settingsActions.updateSettings({
+          chainType: type
+        })
+      );
+      await wallet.setChainType(type);
+    },
+    [dispatch]
+  );
+}
+function useBTCUnit() {
+  const chainType = useChainType();
+  return walletShared.CHAINS_MAP[chainType].unit;
+}
+function useTxExplorerUrl(txid) {
+  const chain = useChain();
+  if (chain.enum === walletTypes.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 react.useCallback(
+    (txid) => {
+      if (chain.enum === walletTypes.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 === walletTypes.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 === walletShared.CAT_VERSION.V1) {
+    return `${chain.unisatExplorerUrl}/cat20/${tokenId}`;
+  } else {
+    return `${chain.unisatExplorerUrl}/cat20-v2/${tokenId}`;
+  }
+}
+function useUnisatWebsite() {
+  const chainType = useChainType();
+  return walletShared.CHAINS_MAP[chainType].unisatUrl;
+}
+function useOrdinalsWebsite() {
+  const chainType = useChainType();
+  return walletShared.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 = walletShared.VERSION;
+  let skipped = false;
+  let latestVersion = "";
+  if (!newVersion) {
+    skipped = true;
+  }
+  if (newVersion == skippedVersion) {
+    skipped = true;
+  }
+  if (newVersion) {
+    if (compareVersions__default.default(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 react.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 = walletShared.CHAINS_MAP[chanEnum];
+    const addressType = getAddressType(address, chain.networkType);
+    if (chain.isFractal && addressType === walletTypes.AddressType.P2PKH) {
+      ret = {
+        homeTip: i18n.t("legacy_address_warning_3"),
+        sendTip: i18n.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 === walletTypes.ChainType.FRACTAL_BITCOIN_MAINNET) {
+    if (version === walletShared.CAT_VERSION.V1) {
+      return "https://tracker-fractal-mainnet.catprotocol.org";
+    } else {
+      return "https://tracker2-fractal-mainnet.catprotocol.org";
+    }
+  } else if (chainType === walletTypes.ChainType.FRACTAL_BITCOIN_TESTNET) {
+    return "https://tracker-fractal-testnet.catprotocol.org";
+  } else {
+    return "";
+  }
+}
+function useBRC20MarketPlaceWebsite(ticker) {
+  const chainType = useChainType();
+  if (chainType === walletTypes.ChainType.BITCOIN_MAINNET) {
+    if (ticker.length == 6) {
+      return `${walletShared.CHAINS_MAP[chainType].unisatUrl}/market/brc20_prog?tick=${ticker}`;
+    }
+  }
+  return `${walletShared.CHAINS_MAP[chainType].unisatUrl}/market/brc20?tick=${ticker}`;
+}
+function useRunesMarketPlaceWebsite(ticker) {
+  const chainType = useChainType();
+  return `${walletShared.CHAINS_MAP[chainType].unisatUrl}/runes/market?tick=${ticker}`;
+}
+function useCAT20MarketPlaceWebsite(tokenId) {
+  const chainType = useChainType();
+  return `${walletShared.CHAINS_MAP[chainType].unisatUrl}/dex/cat20/${tokenId}`;
+}
+function useBabylonConfig() {
+  const chainType = useChainType();
+  return types.BABYLON_CONFIG_MAP[chainType] || types.BABYLON_CONFIG_MAP[walletTypes.ChainType.BITCOIN_MAINNET];
+}
+function useIsMainnetChain() {
+  const chainType = useChainType();
+  return chainType === walletTypes.ChainType.BITCOIN_MAINNET || chainType === walletTypes.ChainType.FRACTAL_BITCOIN_MAINNET;
+}
+function useDeveloperMode() {
+  const settings = useSettingsState();
+  return settings.developerMode;
+}
+function useSetDeveloperModeCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  return react.useCallback(
+    async (developerMode) => {
+      await wallet.setDeveloperMode(developerMode);
+      dispatch(
+        settingsActions.updateSettings({
+          developerMode
+        })
+      );
+    },
+    [dispatch, wallet]
+  );
+}
+var PriceContext = react.createContext({});
+function usePrice() {
+  const context = react.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] = react.useState(false);
+  const [coinPrice, setCoinPrice] = react.useState({
+    btc: 0,
+    fb: 0
+  });
+  const refreshCoinPrice = react.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]);
+  react.useEffect(() => {
+    refreshCoinPrice();
+  }, [refreshCoinPrice]);
+  const value = {
+    isLoadingCoinPrice,
+    coinPrice,
+    refreshCoinPrice
+  };
+  return /* @__PURE__ */ jsxRuntime.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 = reactRouterDom.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("/");
+    }
+  };
+  react.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 react.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 react.useCallback(
+    async (password) => {
+      await wallet.unlock(password);
+      dispatch(globalActions.update({ isUnlocked: true }));
+      resolveApproval();
+    },
+    [dispatch, wallet]
+  );
+}
+function useCreateAccountCallback() {
+  const dispatch = useAppDispatch();
+  const wallet = useWallet();
+  return react.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 react.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 react.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: i18n.FALLBACK_LOCALE,
+  supportedLocales: [i18n.FALLBACK_LOCALE],
+  localeNames: i18n.LOCALE_NAMES,
+  changeLocale: async () => {
+  }
+};
+var useI18n = () => {
+  try {
+    const context = react.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 i18n.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 react.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 react.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 react.useCallback(
+    async (rawtx) => {
+      const ret = {
+        success: false,
+        txid: "",
+        error: ""
+      };
+      try {
+        tools.showLoading(true);
+        const txid = await wallet.pushTx(rawtx);
+        await baseUtils.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 react.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 react.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 react.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 react.useCallback(
+    async (rawtx) => {
+      const ret = {
+        success: false,
+        txid: "",
+        error: ""
+      };
+      try {
+        tools.showLoading(true);
+        const txid = await wallet.pushTx(rawtx);
+        await baseUtils.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 react.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 react.useCallback(
+    (utxos) => {
+      dispatch(transactionsActions.setSpendUnavailableUtxos(utxos));
+    },
+    [dispatch]
+  );
+}
+function useSafeBalance() {
+  const utxos = useUtxos();
+  return react.useMemo(() => {
+    const satoshis = utxos.filter((v) => v.inscriptions.length === 0).reduce((pre, cur) => pre + cur.satoshis, 0);
+    return baseUtils.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 react.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 react.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 = react.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 === walletTypes.ChainType.FRACTAL_BITCOIN_MAINNET || chainType === walletTypes.ChainType.FRACTAL_BITCOIN_TESTNET) {
+    const addressType = getAddressType(currentAddress);
+    if (addressType == walletTypes.AddressType.P2TR || addressType == walletTypes.AddressType.P2WPKH) {
+      assets.CAT20 = true;
+      assetTabKeys.push(3 /* CAT */);
+    }
+  }
+  if (chainType === walletTypes.ChainType.BITCOIN_SIGNET || chainType === walletTypes.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 react.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 = react.useRef({
+    preAccountKey: "",
+    loadingBalance: false,
+    loadingHistory: false
+  });
+  const self = selfRef.current;
+  const reloadAccounts = useReloadAccounts();
+  const onCurrentChange = react.useCallback(async () => {
+    if (isUnlocked && currentAccount && currentAccount.key != self.preAccountKey) {
+      self.preAccountKey = currentAccount.key;
+      reloadAccounts();
+    }
+  }, [dispatch, currentAccount, wallet, isUnlocked]);
+  react.useEffect(() => {
+    onCurrentChange();
+  }, [currentAccount && currentAccount.key, isUnlocked]);
+  const fetchBalance = useFetchBalanceCallback();
+  react.useEffect(() => {
+    if (self.loadingBalance) {
+      return;
+    }
+    if (!isUnlocked) {
+      return;
+    }
+    self.loadingBalance = true;
+    fetchBalance().finally(() => {
+      self.loadingBalance = false;
+    });
+  }, [fetchBalance, wallet, isUnlocked, self]);
+  react.useEffect(() => {
+    const accountChangeHandler = (account) => {
+      if (account && account.address) {
+        dispatch(accountActions.setCurrent(account));
+      }
+    };
+    eventBus_default.addEventListener("accountsChanged", accountChangeHandler);
+    return () => {
+      eventBus_default.removeEventListener("accountsChanged", accountChangeHandler);
+    };
+  }, [dispatch]);
+  react.useEffect(() => {
+    const chaintChangeHandler = (params) => {
+      dispatch(
+        settingsActions.updateSettings({
+          chainType: params.type
+        })
+      );
+      reloadAccounts();
+    };
+    eventBus_default.addEventListener("chainChanged", chaintChangeHandler);
+    return () => {
+      eventBus_default.removeEventListener("chainChanged", chaintChangeHandler);
+    };
+  }, [dispatch]);
+  react.useEffect(() => {
+    const lockHandler = () => {
+      dispatch(globalActions.update({ isUnlocked: false }));
+    };
+    eventBus_default.addEventListener("lock", lockHandler);
+    return () => {
+      eventBus_default.removeEventListener("lock", lockHandler);
+    };
+  }, [dispatch]);
+  react.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 = toolkit.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(reduxLocalstorageSimple.save({ states: PERSISTED_KEYS, debounce: 1e3 })),
+  preloadedState: reduxLocalstorageSimple.load({ states: PERSISTED_KEYS, disableWarnings: true })
+});
+store.dispatch(updateVersion());
+react$1.setupListeners(store.dispatch);
+var src_default = store;
+
+exports.AccountUpdater = AccountUpdater;
+exports.I18nProvider = I18nProvider;
+exports.PriceProvider = PriceProvider;
+exports.WalletProvider = WalletProvider;
+exports.default = src_default;
+exports.getAddressTips = getAddressTips;
+exports.getCurrentLocale = getCurrentLocale;
+exports.getSpecialLocale = getSpecialLocale;
+exports.getUiType = getUiType;
+exports.useAddressExplorerUrl = useAddressExplorerUrl;
+exports.useAddressTips = useAddressTips;
+exports.useAlkanesAssetTabKey = useAlkanesAssetTabKey;
+exports.useAppDispatch = useAppDispatch;
+exports.useAppList = useAppList;
+exports.useAppSelector = useAppSelector;
+exports.useApproval = useApproval;
+exports.useAssetTabKey = useAssetTabKey;
+exports.useAssetUtxosRunes = useAssetUtxosRunes;
+exports.useAutoLockTimeId = useAutoLockTimeId;
+exports.useBRC20MarketPlaceWebsite = useBRC20MarketPlaceWebsite;
+exports.useBTCUnit = useBTCUnit;
+exports.useBabylonConfig = useBabylonConfig;
+exports.useBannerList = useBannerList;
+exports.useBitcoinTx = useBitcoinTx;
+exports.useBooted = useBooted;
+exports.useCAT20MarketPlaceWebsite = useCAT20MarketPlaceWebsite;
+exports.useCAT20TokenInfoExplorerUrl = useCAT20TokenInfoExplorerUrl;
+exports.useCAT721NFTContentBaseUrl = useCAT721NFTContentBaseUrl;
+exports.useCATAssetTabKey = useCATAssetTabKey;
+exports.useChain = useChain;
+exports.useChainType = useChainType;
+exports.useChangeChainTypeCallback = useChangeChainTypeCallback;
+exports.useChangeLocaleCallback = useChangeLocaleCallback;
+exports.useChangeNetworkTypeCallback = useChangeNetworkTypeCallback;
+exports.useCreateAccountCallback = useCreateAccountCallback;
+exports.useCreateColdWalletCallback = useCreateColdWalletCallback;
+exports.useCreateSplitTxCallback = useCreateSplitTxCallback;
+exports.useCurrentKeyring = useCurrentKeyring;
+exports.useDeveloperMode = useDeveloperMode;
+exports.useDiscoveryState = useDiscoveryState;
+exports.useFetchAssetUtxosRunesCallback = useFetchAssetUtxosRunesCallback;
+exports.useFetchUtxosCallback = useFetchUtxosCallback;
+exports.useGetTxExplorerUrlCallback = useGetTxExplorerUrlCallback;
+exports.useGlobalState = useGlobalState;
+exports.useHasNewBanner = useHasNewBanner;
+exports.useI18n = useI18n;
+exports.useImportAccountsFromKeystoneCallback = useImportAccountsFromKeystoneCallback;
+exports.useIsInExpandView = useIsInExpandView;
+exports.useIsMainnetChain = useIsMainnetChain;
+exports.useIsReady = useIsReady;
+exports.useIsUnlocked = useIsUnlocked;
+exports.useKeyrings = useKeyrings;
+exports.useKeyringsState = useKeyringsState;
+exports.useLastFetchInfo = useLastFetchInfo;
+exports.useLocale = useLocale;
+exports.useNetworkType = useNetworkType;
+exports.useOrdinalsAssetTabKey = useOrdinalsAssetTabKey;
+exports.useOrdinalsTx = useOrdinalsTx;
+exports.useOrdinalsWebsite = useOrdinalsWebsite;
+exports.usePrepareSendAlkanesCallback = usePrepareSendAlkanesCallback;
+exports.usePrepareSendBTCCallback = usePrepareSendBTCCallback;
+exports.usePrepareSendBypassHeadOffsetsCallback = usePrepareSendBypassHeadOffsetsCallback;
+exports.usePrepareSendOrdinalsInscriptionCallback = usePrepareSendOrdinalsInscriptionCallback;
+exports.usePrepareSendOrdinalsInscriptionsCallback = usePrepareSendOrdinalsInscriptionsCallback;
+exports.usePrepareSendRunesCallback = usePrepareSendRunesCallback;
+exports.usePrice = usePrice;
+exports.usePushBitcoinTxCallback = usePushBitcoinTxCallback;
+exports.usePushOrdinalsTxCallback = usePushOrdinalsTxCallback;
+exports.useResetUiTxCreateScreen = useResetUiTxCreateScreen;
+exports.useRunesMarketPlaceWebsite = useRunesMarketPlaceWebsite;
+exports.useRunesTx = useRunesTx;
+exports.useSafeBalance = useSafeBalance;
+exports.useSetDeveloperModeCallback = useSetDeveloperModeCallback;
+exports.useSetSpendUnavailableUtxosCallback = useSetSpendUnavailableUtxosCallback;
+exports.useSetTabCallback = useSetTabCallback;
+exports.useSettingsState = useSettingsState;
+exports.useSkipVersionCallback = useSkipVersionCallback;
+exports.useSpendUnavailableUtxos = useSpendUnavailableUtxos;
+exports.useSupportedAssets = useSupportedAssets;
+exports.useTab = useTab;
+exports.useTransactionsState = useTransactionsState;
+exports.useTxExplorerUrl = useTxExplorerUrl;
+exports.useUIState = useUIState;
+exports.useUiTxCreateScreen = useUiTxCreateScreen;
+exports.useUnisatWebsite = useUnisatWebsite;
+exports.useUnlockCallback = useUnlockCallback;
+exports.useUpdateUiTxCreateScreen = useUpdateUiTxCreateScreen;
+exports.useUtxoTools = useUtxoTools;
+exports.useUtxos = useUtxos;
+exports.useVersionInfo = useVersionInfo;
+exports.useWallet = useWallet;
+exports.useWalletConfig = useWalletConfig;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map