@unisat/wallet-state 1.0.4 → 1.1.0

package/lib/index.d.ts

@@ -1,15 +1,65 @@
 import * as _reduxjs_toolkit_dist_configureStore from '@reduxjs/toolkit/dist/configureStore';
 import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as redux from 'redux';
+import * as _unisat_wallet_shared from '@unisat/wallet-shared';
+import { AppInfo, Inscription, WalletKeyring, WalletConfig, UnspentOutput, Account, BitcoinBalanceV2, TxHistoryItem, AppSummary, InscriptionSummary, AddressSummary, TokenBalance, TokenInfo, RuneBalance, RuneInfo, AlkanesBalance, AlkanesInfo, CAT_VERSION, CAT20Balance, CAT20TokenInfo, CAT721CollectionInfo, BabylonTxInfo, ToSignData, CoinPrice, VersionDetail, BitcoinBalance, SignedData, ToSignMessage, SignedMessage, ConnectedSite, FeeSummary, TickPriceItem, InscribeOrder, TokenTransfer, DecodedPsbt, LocalPsbtSummary, AddressTokenSummary, UTXO_Detail, UTXO, WebsiteResult, SignPsbtOptions, ToSignInput, AddressFlagType, CosmosSignDataType, AddressRunesTokenSummary, AddressCAT20TokenSummary, AddressCAT20UtxoSummary, CAT20MergeOrder, CAT721Balance, AddressCAT721CollectionSummary, BtcChannelItem, BabylonAddressSummary, CosmosBalance, AddressAlkanesTokenSummary, AlkanesCollection, BRC20HistoryItem, RateUsStatus, Announcement, StoredNotification, DummyTxType, ToAddressInfo, RawTxInfo, SignPsbtParams, SignPsbtResult, WordsType, RestoreWalletType, ApprovalSession, PsbtActionInfo } from '@unisat/wallet-shared';
+export { PsbtLocalInfo } from '@unisat/wallet-shared';
 import * as _unisat_wallet_types from '@unisat/wallet-types';
 import { ChainType, NetworkType, AddressType } from '@unisat/wallet-types';
-import * as _unisat_wallet_shared from '@unisat/wallet-shared';
-import { AppInfo, Inscription, WalletKeyring, WalletConfig, UnspentOutput, Account, BitcoinBalanceV2, TxHistoryItem, AppSummary, InscriptionSummary, AddressSummary, BitcoinBalance, ToSignInput, ConnectedSite, FeeSummary, CoinPrice, TickPriceItem, InscribeOrder, TokenTransfer, DecodedPsbt, TokenBalance, AddressTokenSummary, UTXO_Detail, UTXO, WebsiteResult, SignPsbtOptions, AddressFlagType, VersionDetail, CosmosSignDataType, RuneBalance, AddressRunesTokenSummary, CAT20Balance, AddressCAT20TokenSummary, AddressCAT20UtxoSummary, UserToSignInput, CAT20MergeOrder, CAT721Balance, AddressCAT721CollectionSummary, BtcChannelItem, BabylonAddressSummary, CosmosBalance, AlkanesBalance, AddressAlkanesTokenSummary, AlkanesCollection, AlkanesInfo, BRC20HistoryItem, CAT_VERSION, ToAddressInfo, RawTxInfo, TypeChain } from '@unisat/wallet-shared';
 import { AssetTabKey, OrdinalsAssetTabKey, CATAssetTabKey, AlkanesAssetTabKey, NavigationSource, TabOption } from './types/index.js';
-import React, { ReactNode } from 'react';
+import * as react from 'react';
+import react__default, { ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as _unisat_babylon_service_types from '@unisat/babylon-service/types';
 import { BabylonConfigV2 } from '@unisat/babylon-service/types';
+import * as redux_thunk from 'redux-thunk';
 import { TypedUseSelectorHook } from 'react-redux';
 
+declare enum WalletTabScreenTabKey {
+    ALL = 0,
+    BRC20 = 1
+}
+type suspensionType = {
+    suspensionIf: boolean;
+    info: AppInfo | object | any;
+    web: any;
+};
+type wcars = {
+    if?: boolean;
+    url: string;
+};
+type guideListsType = {
+    id: number;
+    title: string;
+    content: string;
+    img: string;
+};
+interface setSessionDateProps {
+    icon: string;
+    name: string;
+    origin: string;
+}
+interface BrowserState {
+    walletTabScreen: {
+        tabKey: wcars;
+        riskIf: boolean;
+        collect: any;
+        historyList: any;
+        suspension: suspensionType;
+        yy: any;
+        riseHeight: number;
+        ScanData: string;
+        amountValue: string;
+        guideList: guideListsType[];
+        popUp: boolean;
+        setStatusBar: boolean;
+        i18Class: string;
+        setSessionDate: setSessionDateProps;
+        webViewLod: boolean;
+    };
+}
+declare const browserActions: _reduxjs_toolkit.CaseReducerActions<_reduxjs_toolkit.SliceCaseReducers<BrowserState>, string>;
+
 interface DiscoveryState {
     bannerList: {
         id: string;
@@ -27,6 +77,13 @@ interface DiscoveryState {
 }
 declare const discoveryActions: _reduxjs_toolkit.CaseReducerActions<_reduxjs_toolkit.SliceCaseReducers<DiscoveryState>, string>;
 
+declare enum WallettopTabScreenTabKey {
+    Ordinals = 0,
+    Atomicals = 1,
+    Runes = 2,
+    CAT20 = 3,
+    Alkanes = 4
+}
 interface UIState {
     assetTabKey: AssetTabKey;
     ordinalsAssetTabKey: OrdinalsAssetTabKey;
@@ -39,8 +96,21 @@ interface UIState {
             inscription?: Inscription;
         };
         inputAmount: string;
-        enableRBF: boolean;
+    };
+    addressInput: {
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    };
+    amountInput: {
+        amount: string;
+    };
+    feeRateBar: {
         feeRate: number;
+        feeRateInputVal: string;
+        enableLowFeeRate: boolean;
+        feeOptionIndex: number;
+        showCustomInput: boolean;
     };
     babylonSendScreen: {
         inputAmount: string;
@@ -48,6 +118,10 @@ interface UIState {
     };
     navigationSource: NavigationSource;
     isBalanceHidden: boolean;
+    balanceDetailExpanded: boolean;
+    walletTopTabScreen: {
+        toptabKey: WallettopTabScreenTabKey;
+    };
 }
 declare const uiActions: _reduxjs_toolkit.CaseReducerActions<_reduxjs_toolkit.SliceCaseReducers<UIState>, string>;
 
@@ -62,6 +136,29 @@ interface GlobalState {
     isUnlocked: boolean;
     isReady: boolean;
     isBooted: boolean;
+    screenState?: {
+        type: string;
+        options: any;
+    };
+    isRefresh: boolean;
+    backRefresh: boolean;
+    wallRefresh: boolean;
+    wallTabRefresh: boolean;
+    unlockRefres: boolean;
+    unlockRead: boolean;
+    layerState: boolean;
+    isUnlockTimeRefres: boolean;
+    infiniteListScrollOffset: number;
+    infiniteListScrollDirection: 'up' | 'down';
+    infiniteListScrollActiveTime: number;
+    isScrollViewTop: number;
+    isScrollViewBot: number;
+    isBiometricsSupported: boolean;
+    hasBiometricsKey: boolean;
+    wallTabFocusRefresh: 0;
+    goBackRefresh: 0;
+    switchChainModalVisible: boolean;
+    isLockedOverlayVisible: boolean;
 }
 declare const globalActions: any;
 
@@ -90,7 +187,6 @@ interface BitcoinTx {
     psbtHex: string;
     feeRate: number;
     toDomain: string;
-    enableRBF: boolean;
 }
 interface OrdinalsTx {
     fromAddress: string;
@@ -106,7 +202,6 @@ interface OrdinalsTx {
     feeRate: number;
     toDomain: string;
     outputValue: number;
-    enableRBF: boolean;
 }
 interface RunesTx {
     fromAddress: string;
@@ -121,7 +216,6 @@ interface RunesTx {
     feeRate: number;
     toDomain: string;
     outputValue: number;
-    enableRBF: boolean;
     runeid?: string;
     runeAmount?: string;
 }
@@ -136,6 +230,14 @@ interface TransactionsState {
 }
 declare const transactionsActions: _reduxjs_toolkit.CaseReducerActions<_reduxjs_toolkit.SliceCaseReducers<TransactionsState>, string>;
 
+interface Molels {
+    states: boolean;
+}
+interface MolelsPopover {
+    state: boolean;
+    title: string;
+    data: any;
+}
 interface AccountsState {
     accounts: Account[];
     current: Account;
@@ -168,12 +270,342 @@ interface AccountsState {
     appSummary: AppSummary;
     inscriptionSummary: InscriptionSummary;
     addressSummary: AddressSummary;
+    model: Molels;
+    molelsPopover: MolelsPopover;
 }
 declare const accountActions: _reduxjs_toolkit.CaseReducerActions<_reduxjs_toolkit.SliceCaseReducers<AccountsState>, string>;
 
-declare const I18nProvider: React.FC<{
-    children: React.ReactNode;
-}>;
+interface ApprovalContextType {
+    getApproval: () => Promise<any>;
+    resolveApproval: (data?: any, stay?: boolean, forceReject?: boolean) => Promise<void>;
+    rejectApproval: (reason?: string, stay?: boolean, isInternal?: boolean) => Promise<void>;
+}
+declare const ApprovalContext: react__default.Context<ApprovalContextType>;
+declare function useApproval(): ApprovalContextType;
+
+interface DeviceContextType {
+    isMobile: boolean;
+    isIOS: boolean;
+    isAndroid: boolean;
+    isExtensionInExpandView: boolean;
+    isExtensionInSideBar: boolean;
+    isExtension: boolean;
+    isMobileScreenSize: boolean;
+    isDesktopScreenSize: boolean;
+    platform: string;
+    hasBottomButton: boolean;
+    cardColumnsInList: number;
+}
+declare const DeviceContext: react__default.Context<DeviceContextType>;
+declare function useDevice(): DeviceContextType;
+
+interface I18nContextType {
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    locale: string;
+    supportedLocales: string[];
+    localeNames: Record<string, string>;
+    changeLocale: (locale: string) => Promise<void>;
+    addResourceBundle?: (locale: string) => Promise<void>;
+    isSpecialLocale: boolean;
+}
+declare const I18nContext: react__default.Context<I18nContextType>;
+declare function useI18n(): I18nContextType;
+
+type RouteParamList = {
+    WelcomeScreen: undefined;
+    UnlockScreen: {
+        autoUnlockByFace: boolean;
+    };
+    CreatePasswordScreen: {
+        isNewAccount?: boolean;
+        isKeystone?: boolean;
+        fromColdWallet?: boolean;
+    };
+    MainScreen: undefined;
+    WalletTabScreen: undefined;
+    AppTabScreen: undefined;
+    TabMainScreen: undefined;
+    DiscoverTabScreen: undefined;
+    SettingsTabScreen: undefined;
+    CreateHDWalletScreen: {
+        restoreTiTle?: boolean;
+        topTitle?: boolean;
+        finalButton?: string;
+        existingMnemonic?: string;
+        isBackupFlow?: boolean;
+        isImport?: boolean;
+        comeFrom?: string;
+        fromUnlock?: boolean;
+        goBack?: boolean;
+    };
+    CreateSimpleWalletScreen: undefined;
+    CreateWatchWalletScreen: undefined;
+    CreateColdWalletScreen: {
+        fromUnlock?: boolean;
+    };
+    CreateKeystoneWalletScreen: {
+        fromUnlock?: boolean;
+    };
+    EditWalletNameScreen: {
+        keyring: WalletKeyring;
+    };
+    ExportMnemonicsScreen: {
+        keyring: WalletKeyring;
+    };
+    ExportPrivateKeyScreen: {
+        account: Account;
+    };
+    SwitchAccountScreen: undefined;
+    ReceiveScreen: undefined;
+    HistoryScreen: undefined;
+    KeyringOrAccountScreen: undefined;
+    AddKeyringScreen: undefined;
+    ImportHDWalletScreen: {
+        comeFrom?: string;
+    };
+    CreateAccountScreen: {
+        keyringKey?: string;
+    };
+    CreateKeystoneScreen: {
+        comeFrom?: string;
+        goBack?: boolean;
+    };
+    EditAccountNameScreen: {
+        account: Account;
+    };
+    KeyringDetailScreen: {
+        keyringKey?: string;
+    };
+    ConnectedSitesScreen: undefined;
+    AddressTypeScreen: undefined;
+    AdvancedScreen: undefined;
+    ContactsScreen: {
+        returnWithNetwork?: ChainType;
+        lastEditedContactAddress?: string;
+    };
+    EditContactScreen: {
+        address?: string;
+        chain?: string;
+        selectedNetworkFilter: string;
+    };
+    AboutUsScreen: undefined;
+    LanguageScreen: undefined;
+    ChangePasswordScreen: undefined;
+    ModuleAssets: undefined;
+    NotificationListScreen: undefined;
+    UtxoToolsMainScreen: undefined;
+    ScanScreen: {
+        from?: string;
+    };
+    BrowserScreen: {
+        info: any;
+    };
+    TxCreateScreen: undefined;
+    OrdinalsInscriptionScreen: {
+        inscription: Inscription;
+        inscriptionId?: string;
+        withSend?: boolean;
+    };
+    SendOrdinalsInscriptionScreen: {
+        inscription: Inscription;
+        inscriptionId?: string;
+    };
+    SplitOrdinalsInscriptionScreen: {
+        inscription: Inscription;
+        inscriptionId?: string;
+    };
+    BRC20TokenScreen: {
+        ticker: string;
+        tokenBalance?: TokenBalance;
+    };
+    BRC20SendScreen: {
+        tokenBalance: TokenBalance;
+        tokenInfo: TokenInfo;
+        selectedInscriptionIds?: string[];
+        selectedAmount?: string;
+    };
+    BRC20InscribeTransfer: {
+        ticker: string;
+    };
+    BRC20SingleStepScreen: {
+        tokenBalance: TokenBalance;
+        tokenInfo: TokenInfo;
+    };
+    InscribeTransferScreen: {
+        ticker: string;
+    };
+    RunesTokenScreen: {
+        runeid: string;
+    };
+    SendRunesScreen: {
+        runeBalance: RuneBalance;
+        runeInfo: RuneInfo;
+    };
+    AlkanesTokenScreen: {
+        alkaneid: string;
+    };
+    SendAlkanesScreen: {
+        tokenBalance: AlkanesBalance;
+        tokenInfo: AlkanesInfo;
+    };
+    AlkanesCollectionScreen: {
+        collectionId: string;
+    };
+    AlkanesNFTScreen: {
+        alkanesInfo: AlkanesInfo;
+    };
+    SendAlkanesNFTScreen: {
+        alkanesInfo: AlkanesInfo;
+    };
+    CAT20TokenScreen: {
+        tokenId: string;
+        version: CAT_VERSION;
+    };
+    SendCAT20Screen: {
+        version: CAT_VERSION;
+        cat20Balance: CAT20Balance;
+        cat20Info: CAT20TokenInfo;
+    };
+    MergeCAT20Screen: {
+        version: CAT_VERSION;
+        cat20Balance: CAT20Balance;
+        cat20Info: CAT20TokenInfo;
+    };
+    CAT721CollectionScreen: {
+        collectionId: string;
+        version: CAT_VERSION;
+    };
+    CAT721NFTScreen: {
+        version: CAT_VERSION;
+        collectionInfo: CAT721CollectionInfo;
+        localId: string;
+    };
+    SendCAT721Screen: {
+        version: CAT_VERSION;
+        collectionInfo: CAT721CollectionInfo;
+        localId: string;
+    };
+    BabylonTxConfirmScreen: {
+        txInfo: BabylonTxInfo;
+    };
+    BabylonStakingScreen: undefined;
+    SendBabyScreen: undefined;
+    TxConfirmScreen: {
+        toSignData: ToSignData;
+    };
+    TxSuccessScreen: {
+        txid: string;
+    };
+    TxFailScreen: {
+        error: string;
+    };
+};
+type RouteTypes = keyof RouteParamList;
+type NavigateArgs<T extends RouteTypes> = RouteParamList[T] extends undefined ? [screenName: T] : [screenName: T, params: RouteParamList[T]];
+interface NavigationContextType {
+    navigate<T extends RouteTypes>(...args: NavigateArgs<T>): void;
+    replace<T extends RouteTypes>(...args: NavigateArgs<T>): void;
+    poptotop: () => void;
+    goBack: () => void;
+    navToTab: () => void;
+    navToTest: () => void;
+    navToLock: (params?: any) => void;
+    navToWelcome: () => void;
+    getRouteState<T extends RouteTypes>(): RouteParamList[T];
+    navToUtxoTools: () => void;
+    navToUrl: (url: string, externalBrowser?: boolean) => void;
+    navToExplorerTx: (txid: string) => void;
+    navToExplorerAddress: (address: string) => void;
+    navToMarketPlace: () => void;
+    navToMarketPlaceBrc20: (ticker: string) => void;
+    navToInscribeBrc20: (ticker: string) => void;
+    openExtensionInTab?: () => void;
+    navToRootHome: () => void;
+}
+declare const NavigationContext: react__default.Context<NavigationContextType>;
+declare function useNavigation(): NavigationContextType;
+
+interface PriceContextType {
+    isLoadingCoinPrice: boolean;
+    coinPrice: CoinPrice;
+    refreshCoinPrice: () => void;
+}
+declare function usePrice(): PriceContextType;
+declare function PriceProvider({ children }: {
+    children: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+type AutoLockTime = {
+    id: number;
+    time: number;
+    label: string;
+};
+type WebSearchHistoryItem = string;
+type WebRiskWarningItem = {
+    url: string;
+};
+interface BaseStorageProvider {
+    get: (key: string) => Promise<any>;
+    set: (key: string, value: any) => Promise<void>;
+}
+interface StorageContextType {
+    get: (key: string) => Promise<string>;
+    set: (key: string, value: string) => Promise<void>;
+    clear: () => Promise<void>;
+    getAutomaticLockTime: () => Promise<AutoLockTime>;
+    clearAutomaticLockTime: () => Promise<void>;
+    getAnnouncementDismissedIds: () => Promise<string[]>;
+    setAnnouncementDismissedIds: (ids: string[]) => Promise<void>;
+    clearAnnouncementDismissedIds: () => Promise<void>;
+    getI18nSavedLang: () => Promise<string>;
+    setI18nSavedLang: (lang: string) => Promise<void>;
+    clearI18nSavedLang: () => Promise<void>;
+    getWebSearchHistory: () => Promise<WebSearchHistoryItem[]>;
+    setWebSearchHistory: (history: WebSearchHistoryItem[]) => Promise<void>;
+    clearWebSearchHistory: () => Promise<void>;
+    getWebRiskWarning: () => Promise<WebRiskWarningItem[]>;
+    setWebRiskWarning: (warnings: WebRiskWarningItem[]) => Promise<void>;
+    clearWebRiskWarning: () => Promise<void>;
+    getEnableExplore: () => Promise<boolean>;
+    setEnableExplore: (enable: boolean) => Promise<void>;
+    clearEnableExplore: () => Promise<void>;
+    getUnbackupKeyringIds: () => Promise<string[]>;
+    setUnbackupKeyringIds: (keyrings: string[]) => Promise<void>;
+    clearUnbackupKeyringIds: () => Promise<void>;
+    getEnableFaceId: () => Promise<boolean>;
+    setEnableFaceId: (enable: boolean) => Promise<void>;
+    clearEnableFaceId: () => Promise<void>;
+    getBalanceHidden: () => Promise<boolean>;
+    setBalanceHidden: (enable: boolean) => Promise<void>;
+    clearBalanceHidden: () => Promise<void>;
+    getVersionDetail: () => Promise<VersionDetail>;
+    setVersionDetail: (detail: VersionDetail) => Promise<void>;
+    clearVersionDetail: () => Promise<void>;
+    getThemeMode: () => Promise<string>;
+    setThemeMode: (mode: string) => Promise<void>;
+    clearThemeMode: () => Promise<void>;
+    getUtxoManageVisited: () => Promise<boolean>;
+    setUtxoManageVisited: () => Promise<void>;
+    clearUtxoManageVisited: () => Promise<void>;
+}
+declare function createStorageProvider(base: BaseStorageProvider): StorageContextType;
+declare const StorageContext: react__default.Context<StorageContextType>;
+declare function useStorage(): StorageContextType;
+
+type ToastFunction = (content: string) => void;
+type LoadingFunction = (visible: boolean, content?: string) => void;
+interface ToolsContextType {
+    toast: ToastFunction;
+    toastSuccess: ToastFunction;
+    toastError: ToastFunction;
+    toastWarning: ToastFunction;
+    showLoading: LoadingFunction;
+    showTip: ToastFunction;
+    copyToClipboard: (text: string) => void;
+    openUrl: (url: string) => void;
+}
+declare const ToolsContext: react__default.Context<ToolsContextType>;
+declare function useTools(): ToolsContextType;
 
 interface ContactBookItem {
     name: string;
@@ -188,13 +620,17 @@ interface WalletController {
     openapi: {
         [key: string]: (...params: any) => Promise<any>;
     };
+    requestMethod: (...params: any) => Promise<any>;
+    setBackgroundInited(value: boolean): Promise<void>;
+    getBackgroundInited(): Promise<boolean>;
+    getDesc: () => string;
     boot(password: string): Promise<void>;
     isBooted(): Promise<boolean>;
     getApproval(): Promise<any>;
     resolveApproval(data?: any, data2?: any): Promise<void>;
     rejectApproval(data?: any, data2?: any, data3?: any): Promise<void>;
     hasVault(): Promise<boolean>;
-    verifyPassword(password: string): Promise<void>;
+    verifyPassword(password: string): Promise<boolean>;
     changePassword: (password: string, newPassword: string) => Promise<void>;
     unlock(password: string): Promise<void>;
     isUnlocked(): Promise<boolean>;
@@ -252,7 +688,7 @@ interface WalletController {
     getPreMnemonics(): Promise<any>;
     generatePreMnemonic(): Promise<string>;
     removePreMnemonics(): void;
-    createKeyringWithMnemonics(mnemonic: string, hdPath: string, passphrase: string, addressType: AddressType, accountCount: number): Promise<{
+    createKeyringWithMnemonics(mnemonic: string, hdPath: string, passphrase: string, addressType: AddressType, accountCount: number, accountIndexDerivation?: boolean): Promise<{
         address: string;
         type: string;
     }[]>;
@@ -267,7 +703,9 @@ interface WalletController {
         pubkey: string;
         address: string;
     }[]>;
-    createTmpKeyringWithMnemonics(mnemonic: string, hdPath: string, passphrase: string, addressType: AddressType, accountCount?: number): Promise<WalletKeyring>;
+    createTmpKeyringWithMnemonics(mnemonic: string, hdPath: string, passphrase: string, addressType: AddressType, accountCount?: number, accountIndexDerivation?: boolean): Promise<WalletKeyring>;
+    createTmpKeyringWithMnemonics2(mnemonic: string, passphrase: string, hdPaths: string[], addressTypes: AddressType[]): Promise<WalletKeyring[]>;
+    createTmpKeyringWithMnemonicsScan(mnemonic: string, hdPath: string, passphrase: string, addressType: AddressType, accountCount: number, accountIndexDerivation?: boolean): Promise<WalletKeyring>;
     removeKeyring(keyring: WalletKeyring): Promise<WalletKeyring>;
     deriveNewAccountFromMnemonic(keyring: WalletKeyring, alianName?: string): Promise<string[]>;
     getAccountsCount(): Promise<number>;
@@ -277,65 +715,40 @@ interface WalletController {
     getAccounts(): Promise<Account[]>;
     getNextAlianName: (keyring: WalletKeyring) => Promise<string>;
     getCurrentKeyringAccounts(): Promise<Account[]>;
-    signPsbtWithHex(psbtHex: string, toSignInputs: ToSignInput[], autoFinalized: boolean): Promise<string>;
-    sendBTC(data: {
+    signPsbtV2(toSignData: ToSignData): Promise<SignedData>;
+    signMessage(params: ToSignMessage): Promise<SignedMessage>;
+    createSendBTCPsbt(data: {
         to: string;
         amount: number;
         btcUtxos: UnspentOutput[];
         feeRate: number;
-        enableRBF: boolean;
         memo?: string;
         memos?: string[];
-    }): Promise<{
-        psbtHex: string;
-        rawtx: string;
-        fee: number;
-    }>;
-    sendAllBTC(data: {
+    }): Promise<ToSignData>;
+    createSendAllBTCPsbt(data: {
         to: string;
         btcUtxos: UnspentOutput[];
         feeRate: number;
-        enableRBF: boolean;
-    }): Promise<{
-        psbtHex: string;
-        rawtx: string;
-        fee: number;
-    }>;
-    sendOrdinalsInscription(data: {
+    }): Promise<ToSignData>;
+    createSendInscriptionPsbt(data: {
         to: string;
         inscriptionId: string;
         feeRate: number;
         outputValue?: number;
-        enableRBF: boolean;
         btcUtxos: UnspentOutput[];
-    }): Promise<{
-        psbtHex: string;
-        rawtx: string;
-        fee: number;
-    }>;
-    sendOrdinalsInscriptions(data: {
+    }): Promise<ToSignData>;
+    createSendMultipleInscriptionsPsbt(data: {
         to: string;
         inscriptionIds: string[];
         feeRate: number;
-        enableRBF: boolean;
         btcUtxos: UnspentOutput[];
-    }): Promise<{
-        psbtHex: string;
-        rawtx: string;
-        fee: number;
-    }>;
-    splitOrdinalsInscription(data: {
+    }): Promise<ToSignData>;
+    createSplitInscriptionPsbt(data: {
         inscriptionId: string;
         feeRate: number;
         outputValue: number;
-        enableRBF: boolean;
         btcUtxos: UnspentOutput[];
-    }): Promise<{
-        psbtHex: string;
-        rawtx: string;
-        fee: number;
-        splitedCount: number;
-    }>;
+    }): Promise<ToSignData>;
     pushTx(rawtx: string): Promise<string>;
     queryDomainInfo(domain: string): Promise<Inscription>;
     getInscriptionSummary(): Promise<InscriptionSummary>;
@@ -349,14 +762,17 @@ interface WalletController {
     getConnectedSites(): Promise<ConnectedSite[]>;
     removeConnectedSite(origin: string): Promise<void>;
     getCurrentConnectedSite(id: string): Promise<ConnectedSite>;
+    updateConnectSite(origin: string, data: Partial<ConnectedSite>): Promise<void>;
     getCurrentKeyring(): Promise<WalletKeyring>;
     getKeyrings(): Promise<WalletKeyring[]>;
+    getTotalKeyringCount(): Promise<number>;
     changeKeyring(keyring: WalletKeyring, accountIndex?: number): Promise<void>;
     getAllAddresses(keyring: WalletKeyring, index: number): Promise<string[]>;
     setKeyringAlianName(keyring: WalletKeyring, name: string): Promise<WalletKeyring>;
     changeAddressType(addressType: AddressType): Promise<void>;
     setAccountAlianName(account: Account, name: string): Promise<Account>;
     getFeeSummary(): Promise<FeeSummary>;
+    getLowFeeSummary(): Promise<FeeSummary>;
     getCoinPrice(): Promise<CoinPrice>;
     getBrc20sPrice(ticks: string[]): Promise<{
         [tick: string]: TickPriceItem;
@@ -377,6 +793,7 @@ interface WalletController {
     inscribeBRC20Transfer(address: string, tick: string, amount: string, feeRate: number, outputValue: number): Promise<InscribeOrder>;
     getInscribeResult(orderId: string): Promise<TokenTransfer>;
     decodePsbt(psbtHex: string, website: string): Promise<DecodedPsbt>;
+    analyzeLocalPsbts(toSignDatas: ToSignData[]): Promise<LocalPsbtSummary>;
     decodeContracts(contracts: any[], account: any): Promise<any[]>;
     getAllInscriptionList(address: string, currentPage: number, pageSize: number): Promise<{
         currentPage: number;
@@ -471,20 +888,15 @@ interface WalletController {
     }>;
     getAssetUtxosRunes(rune: string): Promise<UnspentOutput[]>;
     getAddressRunesTokenSummary(address: string, runeid: string): Promise<AddressRunesTokenSummary>;
-    sendRunes(data: {
+    createSendRunesPsbt(data: {
         to: string;
         runeid: string;
         runeAmount: string;
         feeRate: number;
-        enableRBF: boolean;
         btcUtxos?: UnspentOutput[];
         assetUtxos?: UnspentOutput[];
         outputValue?: number;
-    }): Promise<{
-        psbtHex: string;
-        rawtx: string;
-        fee: number;
-    }>;
+    }): Promise<ToSignData>;
     setAutoLockTimeId(timeId: number): Promise<void>;
     getAutoLockTimeId(): Promise<number>;
     getDeveloperMode(): Promise<boolean>;
@@ -499,23 +911,20 @@ interface WalletController {
     getAddressCAT20UtxoSummary(version: 'v1' | 'v2', address: string, tokenId: string): Promise<AddressCAT20UtxoSummary>;
     transferCAT20Step1(version: 'v1' | 'v2', to: string, tokenId: string, tokenAmount: string, feeRate: number): Promise<{
         id: string;
-        commitTx: string;
-        toSignInputs: UserToSignInput[];
         feeRate: number;
+        toSignData: ToSignData;
     }>;
-    transferCAT20Step2(version: 'v1' | 'v2', transferId: string, commitTx: string, toSignInputs: UserToSignInput[]): Promise<{
-        revealTx: string;
-        toSignInputs: UserToSignInput[];
+    transferCAT20Step2(version: 'v1' | 'v2', transferId: string, psbtHex: string): Promise<{
+        toSignData: ToSignData;
     }>;
-    transferCAT20Step3(version: 'v1' | 'v2', transferId: string, revealTx: string, toSignInputs: UserToSignInput[]): Promise<{
+    transferCAT20Step3(version: 'v1' | 'v2', transferId: string, psbtHex: string): Promise<{
         txid: string;
     }>;
     mergeCAT20Prepare(version: 'v1' | 'v2', tokenId: string, utxoCount: number, feeRate: number): Promise<CAT20MergeOrder>;
     transferCAT20Step1ByMerge(version: 'v1' | 'v2', mergeId: string): Promise<{
         id: string;
-        commitTx: string;
-        toSignInputs: UserToSignInput[];
         feeRate: number;
+        toSignData: ToSignData;
     }>;
     getMergeCAT20Status(version: 'v1' | 'v2', mergeId: string): Promise<any>;
     getAppList(): Promise<{
@@ -540,15 +949,13 @@ interface WalletController {
     getAddressCAT721CollectionSummary(version: 'v1' | 'v2', address: string, collectionId: string): Promise<AddressCAT721CollectionSummary>;
     transferCAT721Step1(version: 'v1' | 'v2', to: string, collectionId: string, localId: string, feeRate: number): Promise<{
         id: string;
-        commitTx: string;
-        toSignInputs: UserToSignInput[];
         feeRate: number;
+        toSignData: ToSignData;
     }>;
-    transferCAT721Step2(version: 'v1' | 'v2', transferId: string, commitTx: string, toSignInputs: UserToSignInput[]): Promise<{
-        revealTx: string;
-        toSignInputs: UserToSignInput[];
+    transferCAT721Step2(version: 'v1' | 'v2', transferId: string, psbtHex: string): Promise<{
+        toSignData: ToSignData;
     }>;
-    transferCAT721Step3(version: 'v1' | 'v2', transferId: string, revealTx: string, toSignInputs: UserToSignInput[]): Promise<{
+    transferCAT721Step3(version: 'v1' | 'v2', transferId: string, psbtHex: string): Promise<{
         txid: string;
     }>;
     getBuyCoinChannelList(coin: string): Promise<BtcChannelItem[]>;
@@ -581,35 +988,27 @@ interface WalletController {
         feeRate: number;
     }): Promise<{
         orderId: string;
-        psbtHex: string;
-        toSignInputs: UserToSignInput[];
+        toSignData: ToSignData;
     }>;
     singleStepTransferBRC20Step2(params: {
         orderId: string;
         commitTx: string;
-        toSignInputs: UserToSignInput[];
     }): Promise<{
-        psbtHex: string;
-        toSignInputs: UserToSignInput[];
+        toSignData: ToSignData;
     }>;
     singleStepTransferBRC20Step3(params: {
         orderId: string;
         revealTx: string;
-        toSignInputs: UserToSignInput[];
     }): Promise<{
         txid: string;
     }>;
     setLastActiveTime(): void;
     getOpenInSidePanel(): Promise<boolean>;
     setOpenInSidePanel(openInSidePanel: boolean): Promise<void>;
-    sendCoinBypassHeadOffsets(tos: {
+    createSendBTCOffsetPsbt(tos: {
         address: string;
         satoshis: number;
-    }[], feeRate: number): Promise<{
-        psbtHex: string;
-        rawtx: string;
-        fee: number;
-    }>;
+    }[], feeRate: number): Promise<ToSignData>;
     getAlkanesList(address: string, currentPage: number, pageSize: number): Promise<{
         currentPage: number;
         pageSize: number;
@@ -618,30 +1017,13 @@ interface WalletController {
     }>;
     getAssetUtxosAlkanes(rune: string): Promise<UnspentOutput[]>;
     getAddressAlkanesTokenSummary(address: string, alkaneid: string, fetchAvailable: boolean): Promise<AddressAlkanesTokenSummary>;
-    createAlkanesSendTx(params: {
-        userAddress: string;
-        userPubkey: string;
-        receiver: string;
-        alkaneid: string;
-        amount: string;
-        feeRate: number;
-    }): Promise<{
-        psbtHex: string;
-        toSignInputs: UserToSignInput[];
-    }>;
-    signAlkanesSendTx(params: {
-        commitTx: string;
-        toSignInputs: ToSignInput[];
-    }): Promise<{
-        txid: string;
-    }>;
-    sendAlkanes(params: {
+    createSendAlkanesPsbt(params: {
         to: string;
         alkaneid: string;
         amount: string;
         feeRate: number;
-        enableRBF: boolean;
-    }): Promise<string>;
+        type: 'ft' | 'nft';
+    }): Promise<ToSignData>;
     getAlkanesCollectionList(address: string, currentPage: number, pageSize: number): Promise<{
         list: AlkanesCollection[];
         total: number;
@@ -653,23 +1035,39 @@ interface WalletController {
         total: number;
     }>;
     getBRC20RecentHistory(address: string, ticker: string): Promise<BRC20HistoryItem[]>;
+    resetAllData(): Promise<void>;
+    getGuideReaded(): Promise<boolean>;
+    setGuideReaded(): Promise<void>;
+    getRateUsStatus(): Promise<RateUsStatus>;
+    setHasRated(hasRated: boolean): Promise<void>;
+    setRatePromptDismissedAt(timestamp: number | null): Promise<void>;
+    setHasShownSecondPrompt(hasShown: boolean): Promise<void>;
+    resetRateUsStatus(): Promise<void>;
+    getAnnouncements(cursor: number, size: number): Promise<{
+        hasMore: boolean;
+        list: Announcement[];
+    }>;
+    getNotifications(): Promise<StoredNotification[]>;
+    readNotification(id: string): Promise<void>;
+    readAllNotifications(): Promise<void>;
+    deleteNotification(id: string): Promise<void>;
+    getNotificationUnreadCount(): Promise<number>;
+    getAcceptLowFeeMode(): Promise<boolean>;
+    setAcceptLowFeeMode(accept: boolean): Promise<void>;
+    createTmpKeyringWithPublicKey(publicKey: string, addressType: AddressType): Promise<WalletKeyring>;
+    createKeyringWithPublicKey(data: string, addressType: AddressType): Promise<void>;
+    createTmpKeyringWithAddress(address: string): Promise<WalletKeyring>;
+    createKeyringWithAddress(address: string): Promise<void>;
+    createDummyPsbt(params: {
+        txType: DummyTxType;
+    }): Promise<ToSignData>;
 }
 declare const WalletProvider: ({ children, wallet, }: {
     children?: ReactNode;
     wallet: WalletController;
-}) => JSX.Element;
+}) => react_jsx_runtime.JSX.Element;
 declare const useWallet: () => WalletController;
 
-interface PriceContextType {
-    isLoadingCoinPrice: boolean;
-    coinPrice: CoinPrice;
-    refreshCoinPrice: () => void;
-}
-declare function usePrice(): PriceContextType;
-declare function PriceProvider({ children }: {
-    children: ReactNode;
-}): JSX.Element;
-
 declare function useAccountsState(): AppState['accounts'];
 declare function useCurrentAccount(): Account;
 declare function useCurrentAddress(): string;
@@ -699,17 +1097,9 @@ declare function useChangeAddressFlagCallback(): (isAdd: boolean, flag: number)
 declare function useFetchBalanceCallback(): () => Promise<void>;
 declare function useReloadAccounts(): () => Promise<void>;
 declare function useIsKeystoneWallet(): boolean;
+declare function useModelPopover(): MolelsPopover;
 
-type UiTypeCheck = {
-    isTab: boolean;
-    isNotification: boolean;
-    isPop: boolean;
-    isSidePanel: boolean;
-};
-declare const getUiType: () => UiTypeCheck;
-declare const useApproval: () => readonly [() => Promise<any>, (data?: any, stay?: boolean, forceReject?: boolean) => Promise<void>, (err: any, stay?: boolean, isInternal?: boolean) => Promise<void>];
-
-declare const useAppDispatch: () => _reduxjs_toolkit.ThunkDispatch<{
+declare const useAppDispatch: () => redux_thunk.ThunkDispatch<{
     accounts: AccountsState;
     transactions: TransactionsState;
     settings: SettingsState;
@@ -717,7 +1107,8 @@ declare const useAppDispatch: () => _reduxjs_toolkit.ThunkDispatch<{
     keyrings: KeyringsState;
     ui: UIState;
     discovery: DiscoveryState;
-}, undefined, _reduxjs_toolkit.AnyAction> & _reduxjs_toolkit.Dispatch<_reduxjs_toolkit.AnyAction>;
+    browser: BrowserState;
+}, undefined, redux.AnyAction> & redux.Dispatch<redux.AnyAction>;
 declare const useAppSelector: TypedUseSelectorHook<AppState>;
 
 declare function useDiscoveryState(): AppState['discovery'];
@@ -738,34 +1129,44 @@ declare function useHasNewBanner(): boolean;
 
 declare function useGlobalState(): AppState['global'];
 declare function useTab(): TabOption;
+declare function useScreenState(): {
+    type: string;
+    options: any;
+};
+declare function useUpdateScreenStateCallback(): (screenState: Partial<AppState['global']['screenState']>) => void;
 declare function useSetTabCallback(): (tab: TabOption) => void;
 declare function useBooted(): boolean;
 declare function useIsUnlocked(): boolean;
 declare function useIsReady(): boolean;
+declare function useIsRefresh(): boolean;
+declare function useBackRefresh(): boolean;
+declare function useWallRefresh(): boolean;
+declare function useWallTabRefresh(): boolean;
+declare function useWallTabFocusRefresh(): 0;
+declare function useGoBackRefresh(): 0;
+declare function useLayerState(): boolean;
+declare function useUnlockRefresh(): boolean;
+declare function useUnlockRead(): boolean;
+declare function useIsUnlockTimeRefres(): boolean;
+declare function useInfiniteListScrollOffset(): number;
+declare function useInfiniteListScrollState(): {
+    offset: number;
+    direction: "up" | "down";
+    activeTime: number;
+};
+declare function useIsScrollViewTop(): number;
+declare function useIsScrollViewBot(): number;
+declare function useIsBiometricsSupported(): boolean;
+declare function useHasBiometricsKey(): boolean;
+declare function useSwitchChainModalVisible(): boolean;
+declare function useSetLockedOverlayVisibleCallback(): (visible: boolean) => void;
+declare function useLockedOverlayVisible(): boolean;
+declare function useLockCallback(): () => Promise<void>;
 declare function useUnlockCallback(): (password: string) => Promise<void>;
-declare function useCreateAccountCallback(): (mnemonics: string, hdPath: string, passphrase: string, addressType: AddressType, accountCount: number) => Promise<void>;
+declare function useCreateAccountCallback(): (mnemonics: string, hdPath: string, passphrase: string, addressType: AddressType, accountCount: number, accountIndexDerivation?: boolean) => Promise<void>;
 declare function useImportAccountsFromKeystoneCallback(): (urType: string, urCbor: string, addressType: AddressType, accountCount: number, hdPath: string, filterPubkey?: string[], connectionType?: 'USB' | 'QR') => Promise<void>;
 declare function useCreateColdWalletCallback(): (xpub: string, addressType: AddressType, alianName?: string, hdPath?: string, accountCount?: number) => Promise<void>;
 
-/**
- * Use i18n Hook
- * @returns i18n context
- */
-declare const useI18n: () => any;
-/**
- * Get current language
- * @returns current language code
- */
-declare const getCurrentLocale: () => Promise<string>;
-/**
- * Select special languages for style adaptation
- * @returns { currentLocale: string, isSpecialLocale: boolean }
- */
-declare const getSpecialLocale: () => Promise<{
-    currentLocale: string;
-    isSpecialLocale: boolean;
-}>;
-
 declare function useKeyringsState(): AppState['keyrings'];
 declare function useKeyrings(): _unisat_wallet_shared.WalletKeyring[];
 declare function useCurrentKeyring(): _unisat_wallet_shared.WalletKeyring;
@@ -783,7 +1184,9 @@ declare function useTxExplorerUrl(txid: string): string;
 declare function useGetTxExplorerUrlCallback(): (txid: string) => string;
 declare function useAddressExplorerUrl(address: string): string;
 declare function useCAT20TokenInfoExplorerUrl(version: CAT_VERSION, tokenId: string): string;
+declare function useBRC20TokenInfoExplorerUrl(ticker: string): string;
 declare function useUnisatWebsite(): string;
+declare function useIconBaseUrl(): string;
 declare function useOrdinalsWebsite(): string;
 declare function useWalletConfig(): _unisat_wallet_shared.WalletConfig;
 declare function useVersionInfo(): {
@@ -791,21 +1194,16 @@ declare function useVersionInfo(): {
     newVersion: string;
     latestVersion: string;
     skipped: boolean;
+    downloadUrl: string;
+    isNewest: boolean;
 };
 declare function useSkipVersionCallback(): (version: string) => void;
 declare function useAutoLockTimeId(): number;
-declare function getAddressTips(address: string, chanEnum: ChainType): {
-    homeTip: string;
-    sendTip: string;
-};
 declare function useAddressTips(): {
     homeTip: string;
     sendTip: string;
 };
 declare function useCAT721NFTContentBaseUrl(version: CAT_VERSION): "" | "https://tracker-fractal-mainnet.catprotocol.org" | "https://tracker2-fractal-mainnet.catprotocol.org" | "https://tracker-fractal-testnet.catprotocol.org";
-declare function useBRC20MarketPlaceWebsite(ticker: string): string;
-declare function useRunesMarketPlaceWebsite(ticker: string): string;
-declare function useCAT20MarketPlaceWebsite(tokenId: string): string;
 declare function useBabylonConfig(): _unisat_babylon_service_types.BabylonConfig;
 declare function useIsMainnetChain(): boolean;
 declare function useDeveloperMode(): boolean;
@@ -813,48 +1211,41 @@ declare function useSetDeveloperModeCallback(): (developerMode: boolean) => Prom
 
 declare function useTransactionsState(): AppState['transactions'];
 declare function useBitcoinTx(): BitcoinTx;
-declare function usePrepareSendBTCCallback(): ({ toAddressInfo, toAmount, feeRate, enableRBF, memo, memos, disableAutoAdjust, }: {
+declare function usePrepareSendBTCCallback(): ({ toAddressInfo, toAmount, feeRate, memo, memos, disableAutoAdjust, }: {
     toAddressInfo: ToAddressInfo;
     toAmount: number;
     feeRate?: number;
-    enableRBF: boolean;
     memo?: string;
     memos?: string[];
     disableAutoAdjust?: boolean;
-}) => Promise<RawTxInfo>;
+}) => Promise<ToSignData>;
 declare function usePrepareSendBypassHeadOffsetsCallback(): ({ toAddressInfo, toAmount, feeRate, }: {
     toAddressInfo: ToAddressInfo;
     toAmount: number;
     feeRate: number;
-}) => Promise<RawTxInfo>;
+}) => Promise<ToSignData>;
 declare function usePushBitcoinTxCallback(): (rawtx: string) => Promise<{
     success: boolean;
     txid: string;
     error: string;
 }>;
 declare function useOrdinalsTx(): OrdinalsTx;
-declare function usePrepareSendOrdinalsInscriptionCallback(): ({ toAddressInfo, inscriptionId, feeRate, outputValue, enableRBF, }: {
+declare function usePrepareSendOrdinalsInscriptionCallback(): ({ toAddressInfo, inscriptionId, feeRate, outputValue, }: {
     toAddressInfo: ToAddressInfo;
     inscriptionId: string;
     feeRate?: number;
     outputValue?: number;
-    enableRBF: boolean;
-}) => Promise<RawTxInfo>;
-declare function usePrepareSendOrdinalsInscriptionsCallback(): ({ toAddressInfo, inscriptionIds, feeRate, enableRBF, }: {
+}) => Promise<ToSignData>;
+declare function usePrepareSendOrdinalsInscriptionsCallback(): ({ toAddressInfo, inscriptionIds, feeRate, }: {
     toAddressInfo: ToAddressInfo;
     inscriptionIds: string[];
     feeRate?: number;
-    enableRBF: boolean;
-}) => Promise<RawTxInfo>;
-declare function useCreateSplitTxCallback(): ({ inscriptionId, feeRate, outputValue, enableRBF, }: {
+}) => Promise<ToSignData>;
+declare function useCreateSplitTxCallback(): ({ inscriptionId, feeRate, outputValue, }: {
     inscriptionId: string;
     feeRate: number;
     outputValue: number;
-    enableRBF: boolean;
-}) => Promise<{
-    rawTxInfo: RawTxInfo;
-    splitedCount: number;
-}>;
+}) => Promise<ToSignData>;
 declare function usePushOrdinalsTxCallback(): (rawtx: string) => Promise<{
     success: boolean;
     txid: string;
@@ -867,16 +1258,15 @@ declare function useSetSpendUnavailableUtxosCallback(): (utxos: UnspentOutput[])
 declare function useSafeBalance(): string;
 declare function useAssetUtxosRunes(): UnspentOutput[];
 declare function useFetchAssetUtxosRunesCallback(): (rune: string) => Promise<UnspentOutput[]>;
-declare function usePrepareSendRunesCallback(): ({ toAddressInfo, runeid, runeAmount, outputValue, feeRate, enableRBF, }: {
+declare function usePrepareSendRunesCallback(): ({ toAddressInfo, runeid, runeAmount, outputValue, feeRate, }: {
     toAddressInfo: ToAddressInfo;
     runeid: string;
     runeAmount: string;
     outputValue?: number;
     feeRate: number;
-    enableRBF: boolean;
-}) => Promise<RawTxInfo>;
+}) => Promise<ToSignData>;
 declare function useRunesTx(): RunesTx;
-declare function usePrepareSendAlkanesCallback(): (toAddressInfo: ToAddressInfo, alkaneid: string, amount: string, feeRate: number, enableRBF?: boolean) => Promise<string>;
+declare function usePrepareSendAlkanesCallback(): (toAddressInfo: ToAddressInfo, alkaneid: string, amount: string, feeRate: number, type: 'ft' | 'nft') => Promise<ToSignData>;
 
 declare function useUIState(): AppState['ui'];
 declare function useAssetTabKey(): AssetTabKey;
@@ -890,57 +1280,1479 @@ declare function useUiTxCreateScreen(): {
         inscription?: Inscription;
     };
     inputAmount: string;
-    enableRBF: boolean;
-    feeRate: number;
 };
-declare function useUpdateUiTxCreateScreen(): ({ toInfo, inputAmount, enableRBF, feeRate, }: {
+declare function useUpdateUiTxCreateScreen(): ({ toInfo, inputAmount, }: {
     toInfo?: {
         address: string;
         domain: string;
         inscription?: Inscription;
     };
     inputAmount?: string;
-    enableRBF?: boolean;
+}) => void;
+declare function useFeeRateBar(): {
+    feeRate: number;
+    feeRateInputVal: string;
+    enableLowFeeRate: boolean;
+    feeOptionIndex: number;
+    showCustomInput: boolean;
+};
+declare function useUpdateFeeRateBar(): ({ feeRate, feeRateInputVal, enableLowFeeRate, feeOptionIndex, showCustomInput, }: {
     feeRate?: number;
+    feeRateInputVal?: string;
+    enableLowFeeRate?: boolean;
+    feeOptionIndex?: number;
+    showCustomInput?: boolean;
+}) => void;
+declare function useResetFeeRateBar(): () => void;
+declare function useAddressInput(): {
+    address: string;
+    domain: string;
+    inscription?: Inscription;
+};
+declare function useUpdateAddressInput(): ({ address, domain }: {
+    address?: string;
+    domain?: string;
+}) => void;
+declare function useResetAddressInput(): () => void;
+declare function useAmountInput(): {
+    amount: string;
+};
+declare function useUpdateAmountInput(): ({ amount }: {
+    amount?: string;
 }) => void;
+declare function useResetAmountInput(): () => void;
+declare function useResetTxState(): () => void;
 declare function useResetUiTxCreateScreen(): () => void;
-declare function useSupportedAssets(): {
+declare const useThrottle: (callback: any, delay: any, lastCallRef: any) => (...args: any[]) => void;
+declare function getSupportedAssets(chainType: ChainType, address: string): {
+    assets: {
+        ordinals: boolean;
+        runes: boolean;
+        CAT20: boolean;
+        alkanes: boolean;
+        brc20Prog: boolean;
+    };
     tabKeys: AssetTabKey[];
+    key: string;
+};
+declare function useSupportedAssets(): {
     assets: {
         ordinals: boolean;
         runes: boolean;
         CAT20: boolean;
         alkanes: boolean;
+        brc20Prog: boolean;
     };
+    tabKeys: AssetTabKey[];
     key: string;
 };
 declare const useIsInExpandView: () => boolean;
-declare const useUtxoTools: (chain: TypeChain) => {
-    openUtxoTools: () => void;
+declare function useWalletTopTabScreenState(): {
+    toptabKey: WallettopTabScreenTabKey;
+};
+declare function useBRC20IconInfo(ticker: string): {
+    iconUrl: string;
+    iconShortName: string;
+};
+declare function useRunesIconInfo(spacedRune: string): {
+    iconUrl: string;
+    iconShortName: string;
+};
+declare function useAlkanesIconInfo(name: string, alkaneid: string): {
+    iconUrl: string;
+    iconShortName: string;
+};
+declare function useCAT20IconInfo(name: string, tokenId: string): {
+    iconUrl: string;
+    iconShortName: string;
+};
+declare function useBRC20MarketPlaceWebsite(ticker: string): string;
+declare function useRunesMarketUrl(ticker: string): string;
+declare function useAlkanesMarketPlaceWebsite(alkaneid: string): string;
+declare function useCAT20MarketPlaceWebsite(tokenId: string): string;
+declare function useRunesInscribeUrl(rune: string): string;
+declare function useBalanceCardDetailExpanded(): boolean;
+declare function useToggleBalanceCardDetailExpanded(): () => void;
+
+declare function useBrowserState(): AppState['browser'];
+declare function useWalletTabScreenState(): {
+    tabKey: {
+        if?: boolean;
+        url: string;
+    };
+    riskIf: boolean;
+    collect: any;
+    historyList: any;
+    suspension: {
+        suspensionIf: boolean;
+        info: any;
+        web: any;
+    };
+    yy: any;
+    riseHeight: number;
+    ScanData: string;
+    amountValue: string;
+    guideList: {
+        id: number;
+        title: string;
+        content: string;
+        img: string;
+    }[];
+    popUp: boolean;
+    setStatusBar: boolean;
+    i18Class: string;
+    setSessionDate: setSessionDateProps;
+    webViewLod: boolean;
 };
-declare function useLocationState<T>(): T;
 
 declare function AccountUpdater(): any;
 
-declare const store: _reduxjs_toolkit_dist_configureStore.ToolkitStore<{
-    accounts: AccountsState;
-    transactions: TransactionsState;
-    settings: SettingsState;
-    global: GlobalState;
-    keyrings: KeyringsState;
-    ui: UIState;
-    discovery: DiscoveryState;
-}, _reduxjs_toolkit.AnyAction, _reduxjs_toolkit.MiddlewareArray<[_reduxjs_toolkit.ThunkMiddleware<{
-    accounts: AccountsState;
-    transactions: TransactionsState;
-    settings: SettingsState;
-    global: GlobalState;
-    keyrings: KeyringsState;
-    ui: UIState;
-    discovery: DiscoveryState;
-}, _reduxjs_toolkit.AnyAction>, _reduxjs_toolkit.Middleware<{}, any, _reduxjs_toolkit.Dispatch<_reduxjs_toolkit.AnyAction>>]>>;
+interface AddressTypeItem {
+    address: string;
+    assets: {
+        total_btc: string;
+        satoshis: number;
+        total_inscription: number;
+    };
+    name: string;
+    value: AddressType;
+}
+declare function useAddressTypeScreenLogic(): {
+    currentKeyring: _unisat_wallet_shared.WalletKeyring;
+    items: AddressTypeItem[];
+    wallet: WalletController;
+    onClickItem: (item: AddressTypeItem) => Promise<void>;
+};
+
+declare function useAlkanesListLogic(): {
+    items: AlkanesBalance[];
+    total: number;
+    loading: boolean;
+    hasMore: boolean;
+    onRefresh: () => Promise<void>;
+    onLoadMore: () => void;
+    onClickItem: (item: AlkanesBalance) => void;
+    priceMap: {
+        [key: string]: TickPriceItem;
+    };
+};
+
+declare function useAmountInputLogic(props: {
+    value?: string;
+    runesDecimal?: number;
+    disableDecimal?: boolean;
+    enableBrc20Decimal?: boolean;
+    onAmountInputChange?: (amount: string) => void;
+    min?: number;
+    step?: number;
+}): {
+    handleInputAmount: (e: {
+        target: {
+            value: string;
+        };
+    } | string) => void;
+    handleStepUp: () => void;
+    handleStepDown: () => void;
+    handleReset: () => void;
+    inputValue: string;
+};
+
+declare function useAnnouncementCardLogic(): {
+    loading: boolean;
+    validAnnouncements: Announcement[];
+    current: Announcement;
+    activeIndex: number;
+    handleDotClick: (index: number) => void;
+    handleDismissAll: () => Promise<void>;
+    isLinkable: (announcement: Announcement) => boolean;
+};
+
+declare enum BRC20SendTabKey {
+    STEP1 = 0,
+    STEP2 = 1,
+    STEP3 = 2
+}
+interface ContextData$2 {
+    tabKey: BRC20SendTabKey;
+    tokenBalance: TokenBalance;
+    transferAmount: string;
+    transferableList: TokenTransfer[];
+    inscriptionIdSet: Set<string>;
+    receiver: string;
+    rawTxInfo: RawTxInfo;
+    tokenInfo: TokenInfo;
+}
+interface UpdateContextDataParams$2 {
+    tabKey?: BRC20SendTabKey;
+    tokenBalance?: TokenBalance;
+    transferAmount?: string;
+    transferableList?: TokenTransfer[];
+    inscriptionIdSet?: Set<string>;
+    receiver?: string;
+    rawTxInfo?: RawTxInfo;
+}
+interface BRC20SendStepParams {
+    contextData: ContextData$2;
+    updateContextData: (params: UpdateContextDataParams$2) => void;
+}
+declare function useBRC20SendScreenLogic(): {
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    contextData: ContextData$2;
+    updateContextData: (params: UpdateContextDataParams$2) => void;
+    onHeaderBack: () => void;
+    onTabClick: (key: string) => void;
+};
+declare function useBRC20SendScreenLogicStep1({ contextData, updateContextData, }: BRC20SendStepParams): {
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    disabled: boolean;
+    tokenBalance: TokenBalance;
+    onClickNext: () => void;
+};
+declare function useBRC20SendScreenLogicStep2({ contextData, updateContextData, }: BRC20SendStepParams): {
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    disabled: boolean;
+    onStep2ClickNext: () => Promise<void>;
+    onStep2ClickBack: () => Promise<void>;
+};
+declare function useBRC20SendScreenLogicStep3({ contextData, updateContextData, }: BRC20SendStepParams): {
+    signPsbtParams: SignPsbtParams;
+    onSignPsbtConfirm: (res: any) => Promise<void>;
+};
+declare function useTransferableListLogic({ contextData, updateContextData }: BRC20SendStepParams): {
+    items: TokenTransfer[];
+    selectedCount: number;
+    allSelected: boolean;
+    loading: boolean;
+    loadingLump: boolean;
+    onClickItem: (item: TokenTransfer) => void;
+    onCheckBoxChange: (e: any) => void;
+    onClickCheckBoxInMobile: () => void;
+    onClickRefresh: () => void;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+};
 
-type AppState = ReturnType<typeof store.getState>;
-type AppDispatch = typeof store.dispatch;
+declare enum BRC20SingleStepKey {
+    STEP1 = "STEP1",
+    STEP2 = "STEP2",
+    STEP3 = "STEP3"
+}
+declare function useBRC20SingleStepScreenLogic(): {
+    signPsbtParamsStep2: SignPsbtParams;
+    signPsbtParamsStep3: SignPsbtParams;
+    availableBalance: string;
+    tokenBalance: _unisat_wallet_shared.TokenBalance;
+    tokenInfo: _unisat_wallet_shared.TokenInfo;
+    inputAmount: string;
+    setInputAmount: react.Dispatch<react.SetStateAction<string>>;
+    disabled: boolean;
+    error: string;
+    toInfo: {
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    };
+    setToInfo: react.Dispatch<react.SetStateAction<{
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    }>>;
+    step: BRC20SingleStepKey;
+    onClickBack: () => void;
+    onClickConfirmStep1: () => Promise<void>;
+    onClickConfirmStep2: (signPsbtResult: SignPsbtResult) => Promise<void>;
+    onClickConfirmStep3: (signPsbtResult: SignPsbtResult) => Promise<void>;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    tools: ToolsContextType;
+};
+
+declare enum BRC20TokenScreenTabKey {
+    DETAILS = "details",
+    HISTORY = "history"
+}
+interface BRC20OutWalletBalanceItem {
+    key: 'wallet' | 'swap' | 'prog';
+    label: string;
+    amount: string;
+}
+declare function useBRC20TokenHistoryLogic(props: {
+    ticker: string;
+    displayName?: string;
+}): {
+    displayItems: {
+        date: string;
+        items: {
+            key: string;
+            icon: string;
+            mainTitle: string;
+            subTitle: string;
+            amount: string;
+            pending: boolean;
+            txid: string;
+        }[];
+    }[];
+    isFailed: boolean;
+    isEmpty: boolean;
+    isLoading: boolean;
+};
+declare function useBRC20TokenScreenLogic(): {
+    totalBalance: string;
+    onSwapBalance: string;
+    onProgBalance: string;
+    inWalletBalance: string;
+    outWalletBalanceItems: BRC20OutWalletBalanceItem[];
+    hasOutWalletBalance: boolean;
+    enableHistory: boolean;
+    enableTrade: boolean;
+    enableMint: boolean;
+    enableTransfer: boolean;
+    loading: boolean;
+    tokenSummary: AddressTokenSummary;
+    deployInscription: Inscription;
+    activeTab: BRC20TokenScreenTabKey;
+    setActiveTab: react.Dispatch<react.SetStateAction<BRC20TokenScreenTabKey>>;
+    tabItems: {
+        key: BRC20TokenScreenTabKey;
+        label: string;
+    }[];
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    ticker: string;
+    chain: _unisat_wallet_shared.TypeChain;
+    tools: ToolsContextType;
+    isBrc20Prog: boolean;
+    iconInfo: {
+        iconUrl: string;
+        iconShortName: string;
+    };
+    onClickWrapBrc20Prog: () => void;
+    onClickUnwrapBrc20Prog: () => void;
+    onClickSendBrc20Prog: () => void;
+    onClickSwapInSwap: () => void;
+    onClickAddLiquidityInSwap: () => void;
+    onClickRemoveLiquidityInSwap: () => void;
+    onClickWrapInSwap: () => void;
+    onClickUnwrapInSwap: () => void;
+    onClickSendInSwap: () => void;
+    onClickMint: () => void;
+    onClickSend: () => void;
+    onClickTrade: () => void;
+    onClickSingleStepSend: () => void;
+};
+
+declare function useEditWalletNameScreenLogic(): {
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    keyring: _unisat_wallet_shared.WalletKeyring;
+    isValidName: boolean;
+    truncatedTitle: string;
+    handleOnClick: () => Promise<void>;
+    handleOnKeyUp: (e: React.KeyboardEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    onInputChange: (e: {
+        target: {
+            value: string;
+        };
+    } | string) => void;
+};
+
+declare enum FeeRateType {
+    SLOW = 0,
+    AVG = 1,
+    FAST = 2,
+    CUSTOM = 3
+}
+interface FeeOption {
+    type?: FeeRateType;
+    title: string;
+    desc?: string;
+    feeRate: number;
+}
+declare function useFeeRateBarLogic({ readonly }: {
+    readonly?: boolean;
+}): {
+    feeOptions: FeeOption[];
+    feeOptionIndex: number;
+    setFeeOptionIndex: (index: number) => Promise<void>;
+    feeRateInputVal: string;
+    adjustFeeRateInput: (inputVal: string) => void;
+    isCustomOption: (option: FeeOption) => boolean;
+    fontSize: string;
+    isSpecialLocale: boolean;
+    toggleLowFeeRate: () => Promise<void>;
+    showCustomInput: boolean;
+    toggleCustomInput: (show: boolean) => void;
+    supportLowFeeMode: boolean;
+    showLowFeeModeTipsPopover: boolean;
+    setShowLowFeeModeTipsPopover: react.Dispatch<react.SetStateAction<boolean>>;
+    isSub1FeeOptionOn: boolean;
+};
+
+declare function useLockTimePageLogic(): {
+    autoLockTimeId: number;
+    autoLockTimes: {
+        id: number;
+        time: number;
+        label: string;
+    }[];
+    loading: boolean;
+    handleSelectOption: (option: any) => Promise<void>;
+};
+
+declare function useUnreadNotificationsCount(): number;
+declare function useNotificationsLogic(): {
+    notifications: StoredNotification[];
+    loading: boolean;
+    unreadCount: number;
+    handleReadNotification: (id: string) => Promise<void>;
+    handleReadAll: () => Promise<void>;
+    handleDeleteNotification: (id: string) => Promise<void>;
+    fetchNotifications: () => Promise<void>;
+    handleCardClick: (notification: StoredNotification) => Promise<void>;
+    formatTime: (timestamp: number) => string;
+};
+
+declare function useSendOrdinalsInscriptionScreenLogic(): {
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    onAddressInputChange: (val: any) => void;
+    toInfo: {
+        address: string;
+        domain: string;
+    };
+    outputValue: number;
+    minOutputValue: number;
+    defaultOutputValue: number;
+    setOutputValue: react.Dispatch<react.SetStateAction<number>>;
+    inscriptions: Inscription[];
+    disabled: boolean;
+    error: string;
+    onClickBack: () => void;
+    onClickNext: () => void;
+};
+
+declare function useTxCreateScreenLogic(): {
+    headerTitle: string;
+    chain: _unisat_wallet_shared.TypeChain;
+    toInfo: {
+        address: string;
+        domain: string;
+        inscription?: _unisat_wallet_shared.Inscription;
+    };
+    onAddressInputChange: (val: any) => void;
+    toSatoshis: number;
+    inputAmount: string;
+    onAmountInputChange: (amount: any) => void;
+    onAmountMaxClick: () => void;
+    showUnavailable: boolean;
+    availableAmount: string;
+    unavailableAmount: string;
+    unavailableTipText: string;
+    btcUnit: string;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    walletConfig: _unisat_wallet_shared.WalletConfig;
+    isSpecialLocale: boolean;
+    error: string;
+    disabled: boolean;
+    onClickNext: () => void;
+};
+
+declare enum Step {
+    STEP1 = 0,
+    STEP2 = 1,
+    STEP3 = 2,
+    STEP4 = 3
+}
+interface ContextData$1 {
+    step: Step;
+    ticker: string;
+    session?: any;
+    tokenBalance?: TokenBalance;
+    order?: InscribeOrder;
+    toSignData?: ToSignData;
+    amount?: string;
+    isApproval: boolean;
+    tokenInfo?: TokenInfo;
+    amountEditable?: boolean;
+}
+interface UpdateContextDataParams$1 {
+    step?: Step;
+    ticket?: string;
+    session?: any;
+    tokenBalance?: TokenBalance;
+    order?: InscribeOrder;
+    toSignData?: ToSignData;
+    amount?: string;
+    tokenInfo?: TokenInfo;
+    amountEditable?: boolean;
+}
+interface BRC20InscribeTransferParams {
+    contextData: ContextData$1;
+    updateContextData: (params: UpdateContextDataParams$1) => void;
+}
+declare function useBRC20InscribeTransferLogic(): {
+    contextData: ContextData$1;
+    updateContextData: (params: UpdateContextDataParams$1) => void;
+};
+declare function useBRC20InscribeTransferLogicStep1(params: BRC20InscribeTransferParams): {
+    onClickInscribe: () => Promise<void>;
+    loading: boolean;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    nav: NavigationContextType;
+    inputAmount: string;
+    inputError: string;
+    setInputAmount: react.Dispatch<react.SetStateAction<string>>;
+    inputDisabled: boolean;
+    inputErrorAvailable: string;
+    defaultOutputValue: number;
+    setOutputValue: react.Dispatch<react.SetStateAction<number>>;
+    disabled: boolean;
+    loadingOnly: boolean;
+    handleCancel: () => void;
+};
+declare function useBRC20InscribeTransferLogicStep2(params: BRC20InscribeTransferParams): {
+    isEmpty: boolean;
+    networkFee: string;
+    outputValue: string;
+    minerFee: string;
+    originServiceFee: string;
+    serviceFee: string;
+    totalFee: string;
+    btcUnit: string;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    session: any;
+    amount: string;
+    tokenBalance: TokenBalance;
+    order?: undefined;
+    toSignData?: undefined;
+} | {
+    networkFee: string;
+    outputValue: string;
+    minerFee: string;
+    originServiceFee: string;
+    serviceFee: string;
+    totalFee: string;
+    btcUnit: string;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    session: any;
+    amount: string;
+    tokenBalance: TokenBalance;
+    order: InscribeOrder;
+    toSignData: ToSignData;
+    isEmpty?: undefined;
+};
+declare function useBRC20InscribeTransferLogicStep3(params: BRC20InscribeTransferParams): {
+    signPsbtParams: SignPsbtParams;
+    onSignPsbtHandleConfirm: (signedDatas: SignedData[]) => Promise<void>;
+    onSignPsbtHandleCancel: () => void;
+    onHeaderBack: () => void;
+};
+declare function useBRC20InscribeTransferLogicStep4(params: BRC20InscribeTransferParams): {
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    result: any;
+    onClickConfirm: () => void;
+};
+
+declare function useAlkanesNFTScreenLogic(): {
+    alkanesInfo: _unisat_wallet_shared.AlkanesInfo;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    availableUtxo: number;
+    onClickBack: () => void;
+    onClickSend: () => void;
+    disabledSend: boolean;
+};
+
+declare function useAlkanesTokenScreenLogic(): {
+    tokenSummary: AddressAlkanesTokenSummary;
+    loading: boolean;
+    enableMint: boolean;
+    enableTransfer: boolean;
+    enableTrade: boolean;
+    warning: boolean;
+    setWarning: react.Dispatch<react.SetStateAction<boolean>>;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    tools: ToolsContextType;
+    onClickMint: () => void;
+    onClickSend: () => void;
+    onClickTrade: () => void;
+    iconInfo: {
+        iconUrl: string;
+        iconShortName: string;
+    };
+};
+
+declare enum TabType {
+    STEP1 = "STEP1",
+    STEP2 = "STEP2",
+    CHOOSE_ADDRESS_TYPE = "CHOOSE_ADDRESS_TYPE"
+}
+interface ContextData {
+    mnemonics: string;
+    hdPath: string;
+    passphrase: string;
+    addressType: AddressType;
+    step1Completed: boolean;
+    tabType: TabType;
+    restoreWalletType: RestoreWalletType;
+    isRestore: boolean;
+    isCustom: boolean;
+    customHdPath: string;
+    addressTypeIndex: number;
+    wordsType: WordsType;
+    walletName?: string;
+}
+interface UpdateContextDataParams {
+    mnemonics?: string;
+    hdPath?: string;
+    passphrase?: string;
+    addressType?: AddressType;
+    step1Completed?: boolean;
+    tabType?: TabType;
+    restoreWalletType?: RestoreWalletType;
+    isCustom?: boolean;
+    customHdPath?: string;
+    addressTypeIndex?: number;
+    wordsType?: WordsType;
+    walletName?: string;
+}
+interface WordsItem {
+    key: WordsType;
+    label: string;
+    count: number;
+}
+interface CreateWalletLogicParams {
+    contextData: ContextData;
+    updateContextData: (params: UpdateContextDataParams) => void;
+}
+declare function useCreateWalletLogicImportWordsStep(params: CreateWalletLogicParams): {
+    wordsItems: WordsItem[];
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    disabled: boolean;
+    inputWords: string[];
+    inputWordsText: string;
+    onHandleEventPaste: (event: any, index: number) => void;
+    onClickNext: () => Promise<void>;
+    onClickWordsItem: (wordsItem: WordsItem) => void;
+    inputWordsError: boolean;
+    onInputWordsTextChange: (e: {
+        target: {
+            value: string;
+        };
+    } | string) => void;
+    onInputWordsChange: (e: {
+        target: {
+            value: string;
+        };
+    } | string, index: number) => void;
+    loading: boolean;
+    enablePhrase: boolean;
+    walletName: string;
+    onInputWalletNameChange: (e: {
+        target: {
+            value: string;
+        };
+    } | string) => void;
+    enteredWordsCount: number;
+    shouldEnteredWordsCount: number;
+};
+
+declare enum TabKey {
+    DETAILS = "DETAILS",
+    PROVENANCE = "PROVENANCE"
+}
+declare function useOrdinalsInscriptionScreenLogic(): {
+    inscription: Inscription;
+    isLoadingDetails: boolean;
+    isInitialLoading: boolean;
+    isNeedToSplit: boolean;
+    isMultiStuck: boolean;
+    tabKey: TabKey;
+    setTabKey: react.Dispatch<react.SetStateAction<TabKey>>;
+    TabKey: typeof TabKey;
+    resetState: () => void;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    inscriptionId: string;
+    onClickSend: () => void;
+    onClickSplit: () => void;
+    isUnconfirmed: boolean;
+    withSend: boolean;
+    shouldShowTabs: boolean;
+    nav: NavigationContextType;
+};
+
+declare function useRunesTokenScreenLogic(): {
+    runeid: string;
+    tokenSummary: AddressRunesTokenSummary;
+    iconInfo: {
+        iconUrl: string;
+        iconShortName: string;
+    };
+    loading: boolean;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    enableMint: boolean;
+    onClickMint: () => void;
+    tools: ToolsContextType;
+    ordinalsWebsite: string;
+    txExplorerUrl: string;
+    enableTransfer: boolean;
+    onClickSend: () => void;
+    enableTrade: boolean;
+    onClickTrade: () => void;
+};
+
+interface BRC20BalanceCardProps {
+    tokenBalance: TokenBalance;
+    onClick?: () => void;
+    price?: TickPriceItem;
+}
+declare function useBRC20BalanceCardLogic(props: BRC20BalanceCardProps): {
+    ticker: string;
+    displayName: string;
+    selfMint: boolean;
+    tag: string;
+    iconInfo: {
+        iconUrl: string;
+        iconShortName: string;
+    };
+    totalBalance: string;
+    hasOutWalletBalance: boolean;
+    onProgBalance: string;
+    inWalletBalance: string;
+    onSwapBalance: string;
+    price: TickPriceItem;
+    showPrice: boolean;
+    onClick: () => void;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+};
+
+declare function useExportMnemonicsScreenLogic(): {
+    words: string[];
+    pathName: string;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    setPassword: react.Dispatch<react.SetStateAction<string>>;
+    disabled: boolean;
+    btnClick: () => Promise<void>;
+    handleOnKeyUp: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    mnemonic: string;
+    passphrase: string;
+    error: string;
+    copy: (str: string) => void;
+    keyring: _unisat_wallet_shared.WalletKeyring;
+    onClickBack: () => void;
+};
+
+declare function useExportPrivateKeyScreenLogic(): {
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    setPassword: react.Dispatch<react.SetStateAction<string>>;
+    disabled: boolean;
+    btnClick: () => Promise<void>;
+    handleOnKeyUp: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    privateKey: {
+        hex: string;
+        wif: string;
+    };
+    error: string;
+    copy: (str: string) => void;
+    onClickBack: () => void;
+};
+
+declare function useSendRunesScreenLogic(): {
+    runeInfo: _unisat_wallet_shared.RuneInfo;
+    inputAmount: string;
+    totalBalanceStr: string;
+    availableBalanceStr: string;
+    setInputAmount: react.Dispatch<react.SetStateAction<string>>;
+    disabled: boolean;
+    toInfo: {
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    };
+    setToInfo: react.Dispatch<react.SetStateAction<{
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    }>>;
+    error: string;
+    defaultOutputValue: number;
+    minOutputValue: number;
+    setOutputValue: react.Dispatch<react.SetStateAction<number>>;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    onClickBack: () => void;
+    onClickNext: () => void;
+};
+
+declare function useEditContactScreenLogic(): {
+    name: string;
+    contactAddress: string;
+    chainType: ChainType;
+    error: string;
+    loading: boolean;
+    handleNameChange: (e: {
+        target: {
+            value: string;
+        };
+    } | string) => void;
+    handleAddressChange: (e: {
+        target: {
+            value: string;
+        };
+    } | string) => void;
+    handleSubmit: () => Promise<void>;
+    handleDelete: () => Promise<void>;
+    onClickBack: () => void;
+    address: string;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+};
+
+declare function useEditAccountNameScreenLogic(): {
+    alianName: string;
+    handleOnClick: () => Promise<void>;
+    handleOnKeyUp: (e: React.KeyboardEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    isValidName: boolean;
+    truncatedTitle: string;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    account: Account;
+    onInputChange: (e: {
+        target: {
+            value: string;
+        };
+    } | string) => void;
+    onClickBack: () => void;
+};
+
+declare function useAlkanesCollectionListLogic(): {
+    items: AlkanesCollection[];
+    total: number;
+    loading: boolean;
+    hasMore: boolean;
+    onRefresh: () => Promise<void>;
+    onLoadMore: () => void;
+    onClickItem: (item: AlkanesCollection) => void;
+};
+
+declare function useBRC20ListLogic(): {
+    items: TokenBalance[];
+    total: number;
+    loading: boolean;
+    hasMore: boolean;
+    onRefresh: () => Promise<void>;
+    onLoadMore: () => void;
+    onClickItem: (item: TokenBalance) => void;
+    priceMap: {
+        [key: string]: TickPriceItem;
+    };
+};
+
+declare function useInscriptionListLogic(): {
+    items: Inscription[];
+    total: number;
+    loading: boolean;
+    hasMore: boolean;
+    onRefresh: () => Promise<void>;
+    onLoadMore: () => void;
+    onClickItem: (item: Inscription) => void;
+};
+
+declare function useRunesListLogic(): {
+    items: RuneBalance[];
+    total: number;
+    loading: boolean;
+    hasMore: boolean;
+    onRefresh: () => Promise<void>;
+    onLoadMore: () => void;
+    onClickItem: (item: RuneBalance) => void;
+    priceMap: {
+        [key: string]: TickPriceItem;
+    };
+};
+
+declare function useCAT20ListLogic(version: CAT_VERSION): {
+    tokens: CAT20Balance[];
+    total: number;
+    loading: boolean;
+    hasMore: boolean;
+    onRefresh: () => Promise<void>;
+    onLoadMore: () => void;
+    onClickItem: (item: CAT20Balance) => void;
+    priceMap: {
+        [key: string]: TickPriceItem;
+    };
+};
+
+declare enum SendCAT20ScreenStep {
+    PREPARE = 0,
+    SIGN_COMMIT = 1,
+    WAITING = 2,
+    SIGN_REVEAL = 3
+}
+declare function useSendCAT20ScreenLogic(): {
+    cat20Info: _unisat_wallet_shared.CAT20TokenInfo;
+    cat20Balance: _unisat_wallet_shared.CAT20Balance;
+    availableTokenAmount: string;
+    toInfo: {
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    };
+    setToInfo: react.Dispatch<react.SetStateAction<{
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    }>>;
+    inputAmount: string;
+    setInputAmount: react.Dispatch<react.SetStateAction<string>>;
+    error: string;
+    disabled: boolean;
+    step: SendCAT20ScreenStep;
+    showMergeBTCUTXOPopover: boolean;
+    setShowMergeBTCUTXOPopover: react.Dispatch<react.SetStateAction<boolean>>;
+    shouldShowMerge: boolean;
+    onClickNext: () => Promise<void>;
+    onClickBack: () => void;
+    onSignCommitPsbtHandleConfirm: (signedDatas: SignedData[]) => Promise<void>;
+    onSignCommitPsbtHandleCancel: () => void;
+    onSignCommitPsbtHandleBack: () => void;
+    signCommitPsbtParams: SignPsbtParams;
+    onSignRevealPsbtHandleConfirm: (signedDatas: SignedData[]) => Promise<void>;
+    onSignRevealPsbtHandleCancel: () => void;
+    onSignRevealPsbtHandleBack: () => void;
+    signRevealPsbtParams: SignPsbtParams;
+    onClickMergeUTXO: () => void;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+};
+
+declare enum SendCAT721ScreenStep {
+    PREPARE = 0,
+    SIGN_COMMIT = 1,
+    WAITING = 2,
+    SIGN_REVEAL = 3
+}
+declare function useSendCAT721ScreenLogic(): {
+    version: _unisat_wallet_shared.CAT_VERSION;
+    localId: string;
+    collectionInfo: _unisat_wallet_shared.CAT721CollectionInfo;
+    toInfo: {
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    };
+    setToInfo: react.Dispatch<react.SetStateAction<{
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    }>>;
+    error: string;
+    disabled: boolean;
+    step: SendCAT721ScreenStep;
+    showMergeBTCUTXOPopover: boolean;
+    setShowMergeBTCUTXOPopover: react.Dispatch<react.SetStateAction<boolean>>;
+    onClickNext: () => Promise<void>;
+    onClickBack: () => void;
+    onSignCommitPsbtHandleConfirm: (signedDatas: SignedData[]) => Promise<void>;
+    onSignCommitPsbtHandleCancel: () => void;
+    onSignCommitPsbtHandleBack: () => void;
+    signCommitPsbtParams: SignPsbtParams;
+    onSignRevealPsbtHandleConfirm: (signedDatas: SignedData[]) => Promise<void>;
+    onSignRevealPsbtHandleCancel: () => void;
+    onSignRevealPsbtHandleBack: () => void;
+    signRevealPsbtParams: SignPsbtParams;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+};
+
+declare function useAlkanesNFTListLogic(collectionId: string): {
+    items: AlkanesInfo[];
+    total: number;
+    loading: boolean;
+    hasMore: boolean;
+    onRefresh: () => Promise<void>;
+    onLoadMore: () => void;
+    onClickItem: (item: AlkanesInfo) => void;
+};
+
+declare function useBRC20ProgListLogic(): {
+    items: TokenBalance[];
+    total: number;
+    loading: boolean;
+    hasMore: boolean;
+    onRefresh: () => Promise<void>;
+    onLoadMore: () => void;
+    onClickItem: (item: TokenBalance) => void;
+    priceMap: {
+        [key: string]: TickPriceItem;
+    };
+};
+
+declare function useCAT721ListLogic(version: CAT_VERSION): {
+    tokens: CAT721Balance[];
+    total: number;
+    loading: boolean;
+    hasMore: boolean;
+    onRefresh: () => Promise<void>;
+    onLoadMore: () => void;
+    onClickItem: (item: CAT721Balance) => void;
+};
+
+declare function useCAT20TokenScreenLogic(): {
+    tokenSummary: AddressCAT20TokenSummary;
+    loading: boolean;
+    tokenUrl: string;
+    enableTransfer: boolean;
+    enableTrade: boolean;
+    iconInfo: {
+        iconUrl: string;
+        iconShortName: string;
+    };
+    onClickMerge: (e: any) => void;
+    onClickSend: (e: any) => void;
+    onClickTrade: (e: any) => void;
+    onClickBack: () => void;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+};
+
+declare function useSplitOrdinalsInscriptionScreenLogic(): {
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    inscriptions: Inscription[];
+    minOutputValue: number;
+    splitedCount: number;
+    error: string;
+    disabled: boolean;
+    onOutputValueChange: (value: number) => void;
+    onClickBack: () => void;
+    onClickNext: () => void;
+};
+
+declare function useCreatePasswordScreenLogic(): {
+    disabled: boolean;
+    strongTextRenderData: {
+        text: any;
+        color: string;
+        tip: any;
+    } | {
+        text: any;
+        color: string;
+        tip?: undefined;
+    };
+    matchTextRenderData: {
+        text: string;
+    };
+    onClickConfirm: () => void;
+    onPasswordChange: (e: string | {
+        target: {
+            value: string;
+        };
+    }) => void;
+    onConfirmPasswordChange: (e: string | {
+        target: {
+            value: string;
+        };
+    }) => void;
+};
+
+declare enum SendAlkanesNFTScreenStep {
+    CREATE_TX = 0,
+    SIGN_TX = 1
+}
+declare function useSendAlkanesNFTScreenLogic(): {
+    step: number;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    alkanesInfo: _unisat_wallet_shared.AlkanesInfo;
+    toInfo: {
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    };
+    disabled: boolean;
+    error: string;
+    setToInfo: react.Dispatch<react.SetStateAction<{
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    }>>;
+    onCreateTxHandleConfirm: () => Promise<void>;
+    onCreateTxHandleBack: () => void;
+    onSignPsbtHandleConfirm: (signedDatas: SignedData[]) => Promise<void>;
+    onSignPsbtHandleCancel: () => void;
+    onSignPsbtHandleBack: () => void;
+    signPsbtParams: SignPsbtParams;
+};
+
+declare enum SendAlkanesScreenStep {
+    CREATE_TX = 0,
+    SIGN_TX = 1
+}
+declare function useSendAlkanesScreenLogic(): {
+    step: SendAlkanesScreenStep;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    tokenBalance: _unisat_wallet_shared.AlkanesBalance;
+    tokenInfo: _unisat_wallet_shared.AlkanesInfo;
+    toInfo: {
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    };
+    totalBalanceStr: string;
+    availableBalanceStr: string;
+    inputAmount: string;
+    disabled: boolean;
+    error: string;
+    setToInfo: react.Dispatch<react.SetStateAction<{
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    }>>;
+    setInputAmount: react.Dispatch<react.SetStateAction<string>>;
+    onClickBack: () => void;
+    onClickNext: () => Promise<void>;
+    onSignPsbtHandleConfirm: (signedDatas: SignedData[]) => Promise<void>;
+    onSignPsbtHandleCancel: () => void;
+    onSignPsbtHandleBack: () => void;
+    signPsbtParams: SignPsbtParams;
+};
+
+interface RunesBalanceCardProps {
+    tokenBalance: RuneBalance;
+    onClick?: () => void;
+    price?: TickPriceItem;
+}
+declare function useRunesBalanceCardLogic(props: RunesBalanceCardProps): {
+    tokenBalance: RuneBalance;
+    balance: BigNumber;
+    balanceStr: string;
+    showPrice: boolean;
+    price: TickPriceItem;
+    iconInfo: {
+        iconUrl: string;
+        iconShortName: string;
+    };
+    onClick: () => void;
+};
+
+interface CAT20BalanceCardProps {
+    tokenBalance: CAT20Balance;
+    onClick?: () => void;
+    showPrice?: boolean;
+    price?: TickPriceItem;
+}
+declare function useCAT20BalanceCardLogic(props: CAT20BalanceCardProps): {
+    tokenBalance: CAT20Balance;
+    balance: BigNumber;
+    balanceStr: string;
+    price: TickPriceItem;
+    showPrice: boolean;
+    iconInfo: {
+        iconUrl: string;
+        iconShortName: string;
+    };
+    onClick: () => void;
+};
+
+interface AlkanesBalanceCardProps {
+    tokenBalance: AlkanesBalance;
+    onClick?: () => void;
+    price?: TickPriceItem;
+}
+declare function useAlkanesBalanceCardLogic(props: AlkanesBalanceCardProps): {
+    tokenBalance: AlkanesBalance;
+    balance: BigNumber;
+    balanceStr: string;
+    showPrice: boolean;
+    price: TickPriceItem;
+    iconInfo: {
+        iconUrl: string;
+        iconShortName: string;
+    };
+    onClick: () => void;
+};
+
+declare function useCAT721NFTScreenLogic(): {
+    collectionInfo: _unisat_wallet_shared.CAT721CollectionInfo;
+    localId: string;
+    version: _unisat_wallet_shared.CAT_VERSION;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    onClickBack: () => void;
+    onClickSend: () => void;
+};
+
+interface SignMessageProps {
+    header?: React.ReactNode;
+    params: {
+        data: {
+            toSignMessages: ToSignMessage[];
+        };
+        session?: {
+            origin: string;
+            icon: string;
+            name: string;
+        };
+    };
+    handleCancel?: () => void;
+    handleConfirm?: (signedMessages: SignedMessage[]) => void;
+}
+declare function useSignMessageLogic(props: SignMessageProps): {
+    loading: boolean;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    session: {
+        origin: string;
+        icon: string;
+        name: string;
+    };
+    isKeystoneSigning: boolean;
+    isColdWalletSigning: boolean;
+    showMultiSignView: boolean;
+    disclaimerVisible: boolean;
+    toSignMessages: ToSignMessage[];
+    currentToSignMessage: ToSignMessage;
+    isScammer: boolean;
+    allowQuickMultiSign: boolean;
+    isAllSigned: boolean;
+    signedCount: number;
+    multiSignList: {
+        index: number;
+        title: string;
+        buttonText: string;
+        buttonPreset: string;
+        onClick: () => void;
+    }[];
+    onClickBack: () => void;
+    onClickSign: () => void;
+    onQuickMultiSign: () => Promise<void>;
+    onTryMultiSign: () => Promise<void>;
+    onTrustSite: () => Promise<void>;
+    onKeystoneSigningSuccess: (data: SignedMessage) => void;
+    onKeystoneSigningBack: () => void;
+    onColdWalletSigningSuccess: (data: SignedMessage) => void;
+    onColdWalletSigningBack: () => void;
+    onDisclaimerModalClose: () => void;
+};
+
+interface SignPsbtProps {
+    header?: React.ReactNode;
+    params: {
+        data: {
+            toSignDatas: ToSignData[];
+        };
+        session?: ApprovalSession;
+    };
+    handleCancel?: () => void;
+    handleConfirm?: (signedDatas: SignedData[]) => void;
+    fromApproval?: boolean;
+}
+declare function useSignPsbtLogic(props: SignPsbtProps): {
+    isPsbtRiskPopoverVisible: boolean;
+    contractPopoverData: any;
+    setContractPopoverData: react.Dispatch<any>;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+    brc20PriceMap: Record<string, TickPriceItem>;
+    runesPriceMap: Record<string, TickPriceItem>;
+    session: ApprovalSession;
+    isPsbtSigning: boolean;
+    isKeystoneSigning: boolean;
+    isColdWalletSigning: boolean;
+    showMultiSignView: boolean;
+    showLoading: boolean;
+    disclaimerVisible: boolean;
+    localPsbtSummary: LocalPsbtSummary;
+    toSignDatas: ToSignData[];
+    currentToSignData: ToSignData;
+    currentDecodedPsbt: DecodedPsbt;
+    networkFee: string;
+    isValid: boolean;
+    hasRisk: boolean;
+    showFeeSection: boolean;
+    isScammer: boolean;
+    allowQuickMultiSign: boolean;
+    isAllSigned: boolean;
+    signedCount: number;
+    multiSignList: {
+        index: number;
+        buttonText: string;
+        buttonPreset: string;
+        psbtInfo: _unisat_wallet_shared.PsbtLocalInfo;
+        onClick: () => void;
+    }[];
+    backButtonText: string;
+    onClickBack: () => void;
+    onClickSign: () => void;
+    onQuickMultiSign: () => Promise<void>;
+    onTryMultiSign: () => Promise<void>;
+    onTrustSite: () => Promise<void>;
+    onKeystoneSigningSuccess: (data: SignedData) => void;
+    onKeystoneSigningBack: () => void;
+    onColdWalletSigningSuccess: (data: {
+        psbtHex: string;
+        rawtx: string;
+    }) => void;
+    onColdWalletSigningBack: () => void;
+    onRiskPopoverConfirm: () => void;
+    onRiskPopoverClose: () => void;
+    onDisclaimerModalClose: () => void;
+};
+
+declare function useTxConfirmScreenLogic(): {
+    signPsbtParams: SignPsbtParams;
+    onClickBack: () => void;
+    onClickCancel: () => void;
+    onClickConfirm: (signedDatas: SignPsbtResult) => Promise<void>;
+};
+
+declare function useTxFailScreenLogic(): {
+    error: string;
+    onClickBack: () => void;
+    onClickDone: () => void;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+};
+
+declare function useTxSuccessScreenLogic(): {
+    txid: string;
+    onClickExploreTx: () => void;
+    onClickDone: () => void;
+    onClickCopy: () => void;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+};
+
+interface ActionOverviewSectionProps {
+    action: PsbtActionInfo;
+    decodedPsbt: DecodedPsbt;
+}
+declare function useActionOverviewSectionLogic({ action, decodedPsbt }: ActionOverviewSectionProps): {
+    decodedPsbt: DecodedPsbt;
+    action: PsbtActionInfo;
+    commonDetails: any[];
+    chain: _unisat_wallet_shared.TypeChain;
+};
+
+interface SettingsItemType {
+    key: string;
+    label?: string;
+    value?: string;
+    desc?: string;
+    danger?: boolean;
+    right: boolean;
+    icon?: string;
+    badge?: string;
+    onClick?: () => void;
+}
+declare function useSettingsTabScreenLogic(): {
+    settings_connectedSites: SettingsItemType;
+    settings_addressBook: SettingsItemType;
+    settings_addressType: SettingsItemType;
+    settings_advanced: {
+        key: string;
+        label: string;
+        value: string;
+        desc: string;
+        right: boolean;
+        icon: string;
+        onClick: () => void;
+    };
+    settings_feedback: {
+        key: string;
+        label: string;
+        value: string;
+        desc: string;
+        route: string;
+        right: boolean;
+        icon: string;
+        onClick: () => void;
+    };
+    settings_rateus: {
+        key: string;
+        label: string;
+        value: string;
+        desc: string;
+        route: string;
+        right: boolean;
+        icon: string;
+        onClick: () => void;
+    };
+    settings_aboutus: {
+        key: string;
+        label: string;
+        value: string;
+        desc: string;
+        right: boolean;
+        icon: string;
+        badge: string;
+        onClick: () => void;
+    };
+    settings_lockwallet: {
+        key: string;
+        label: string;
+        value: string;
+        desc: string;
+        right: boolean;
+        onClick: () => void;
+    };
+    settings_expandview: {
+        key: string;
+        label: string;
+        value: string;
+        desc: string;
+        right: boolean;
+        onClick: () => void;
+    };
+};
+
+declare function useBalanceCardLogic(): {
+    totalBalance: number;
+    availableBalance: number;
+    unavailableBalance: number;
+    totalAmount: string;
+    availableAmount: string;
+    unavailableAmount: string;
+    totalAmountMainPart: string;
+    totalAmountSubPart: string;
+    balanceValue: string;
+    unavailableTipText: string;
+    isCurrentChainBalance: boolean;
+    showUtxoToolButton: boolean;
+    handleUnlock: (e?: React.MouseEvent) => void;
+    isDetailExpanded: boolean;
+    handleExpandToggle: () => void;
+    isBalanceHidden: boolean;
+    handleHiddenToggle: (e?: React.MouseEvent) => void;
+    refreshBalance: (e?: React.MouseEvent) => void;
+    btcUnit: string;
+    isBtcMainnet: boolean;
+    chain: _unisat_wallet_shared.TypeChain;
+    t: (key: string, substitutions?: string | string[] | Record<string, string | number>) => string;
+};
+
+declare function useBtcDisplayLogic(balance: string): {
+    totalAmountMainPart: string;
+    totalAmountSubPart: string;
+};
+
+type Listener = (params?: any) => void;
+declare class EventBus {
+    events: Record<string, Listener[]>;
+    emit: (type: string, params?: any) => void;
+    once: (type: string, fn: Listener) => void;
+    addEventListener: (type: string, fn: Listener) => void;
+    removeEventListener: (type: string, fn: Listener) => void;
+    removeAllEventListeners: (type: string) => void;
+}
+declare const uiEventBus: EventBus;
+
+declare function useAsyncEffect(effect: () => Promise<void | (() => void)>, deps?: React.DependencyList): void;
+
+declare function createAppStore(): _reduxjs_toolkit_dist_configureStore.ToolkitStore<{
+    accounts: AccountsState;
+    transactions: TransactionsState;
+    settings: SettingsState;
+    global: GlobalState;
+    keyrings: KeyringsState;
+    ui: UIState;
+    discovery: DiscoveryState;
+    browser: BrowserState;
+}, redux.AnyAction, _reduxjs_toolkit.MiddlewareArray<[_reduxjs_toolkit.ThunkMiddleware<{
+    accounts: AccountsState;
+    transactions: TransactionsState;
+    settings: SettingsState;
+    global: GlobalState;
+    keyrings: KeyringsState;
+    ui: UIState;
+    discovery: DiscoveryState;
+    browser: BrowserState;
+}, redux.AnyAction>, redux.Middleware<{}, any, redux.Dispatch<redux.AnyAction>>]>>;
+type AppStore = ReturnType<typeof createAppStore>;
+type AppState = ReturnType<AppStore['getState']>;
+type AppDispatch = AppStore['dispatch'];
 
-export { AccountUpdater, AlkanesAssetTabKey, AppDispatch, AppState, AssetTabKey, CATAssetTabKey, I18nProvider, NavigationSource, OrdinalsAssetTabKey, PriceProvider, TabOption, WalletProvider, accountActions, store as default, discoveryActions, getAddressTips, getCurrentLocale, getSpecialLocale, getUiType, globalActions, keyringsActions, settingsActions, transactionsActions, uiActions, useAccountAddress, useAccountBalance, useAccountInscriptions, useAccounts, useAccountsState, useAddressExplorerUrl, useAddressSummary, useAddressTips, useAlkanesAssetTabKey, useAppDispatch, useAppList, useAppSelector, useAppSummary, useApproval, useAssetTabKey, useAssetUtxosRunes, useAutoLockTimeId, useBRC20MarketPlaceWebsite, useBTCUnit, useBabylonConfig, useBannerList, useBitcoinTx, useBooted, useCAT20MarketPlaceWebsite, useCAT20TokenInfoExplorerUrl, useCAT721NFTContentBaseUrl, useCATAssetTabKey, useChain, useChainType, useChangeAddressFlagCallback, useChangeChainTypeCallback, useChangeLocaleCallback, useChangeNetworkTypeCallback, useCreateAccountCallback, useCreateColdWalletCallback, useCreateSplitTxCallback, useCurrentAccount, useCurrentAddress, useCurrentKeyring, useDeveloperMode, useDiscoveryState, useFetchAssetUtxosRunesCallback, useFetchBalanceCallback, useFetchUtxosCallback, useGetTxExplorerUrlCallback, useGlobalState, useHasNewBanner, useHistory, useI18n, useImportAccountCallback, useImportAccountsFromKeystoneCallback, useInscriptionSummary, useIsInExpandView, useIsKeystoneWallet, useIsMainnetChain, useIsReady, useIsUnlocked, useKeyrings, useKeyringsState, useLastFetchInfo, useLocale, useLocationState, useNetworkType, useOrdinalsAssetTabKey, useOrdinalsTx, useOrdinalsWebsite, usePrepareSendAlkanesCallback, usePrepareSendBTCCallback, usePrepareSendBypassHeadOffsetsCallback, usePrepareSendOrdinalsInscriptionCallback, usePrepareSendOrdinalsInscriptionsCallback, usePrepareSendRunesCallback, usePrice, usePushBitcoinTxCallback, usePushOrdinalsTxCallback, useReadApp, useReadTab, useReloadAccounts, useResetUiTxCreateScreen, useRunesMarketPlaceWebsite, useRunesTx, useSafeBalance, useSetCurrentAccountCallback, useSetDeveloperModeCallback, useSetSpendUnavailableUtxosCallback, useSetTabCallback, useSettingsState, useSkipVersionCallback, useSpendUnavailableUtxos, useSupportedAssets, useTab, useTransactionsState, useTxExplorerUrl, useUIState, useUiTxCreateScreen, useUnisatWebsite, useUnlockCallback, useUnreadAppSummary, useUpdateUiTxCreateScreen, useUtxoTools, useUtxos, useVersionInfo, useWallet, useWalletConfig };
+export { AccountUpdater, ActionOverviewSectionProps, AlkanesAssetTabKey, AlkanesBalanceCardProps, AppDispatch, AppState, AppStore, ApprovalContext, ApprovalContextType, AssetTabKey, BRC20BalanceCardProps, BRC20InscribeTransferParams, BRC20OutWalletBalanceItem, BRC20SendStepParams, BRC20SendTabKey, BRC20SingleStepKey, BRC20TokenScreenTabKey, CAT20BalanceCardProps, CATAssetTabKey, ContextData$2 as ContextData, DeviceContext, DeviceContextType, I18nContext, I18nContextType, NavigationContext, NavigationContextType, NavigationSource, OrdinalsAssetTabKey, PriceProvider, RouteTypes, RunesBalanceCardProps, SendAlkanesNFTScreenStep, SendAlkanesScreenStep, SendCAT20ScreenStep, SendCAT721ScreenStep, SettingsItemType, SignMessageProps, SignPsbtProps, StorageContext, StorageContextType, TabOption, ToolsContext, ToolsContextType, UpdateContextDataParams$2 as UpdateContextDataParams, WalletProvider, WalletTabScreenTabKey, accountActions, browserActions, createAppStore, createStorageProvider, discoveryActions, getSupportedAssets, globalActions, keyringsActions, settingsActions, transactionsActions, uiActions, uiEventBus, useAccountAddress, useAccountBalance, useAccountInscriptions, useAccounts, useAccountsState, useActionOverviewSectionLogic, useAddressExplorerUrl, useAddressInput, useAddressSummary, useAddressTips, useAddressTypeScreenLogic, useAlkanesAssetTabKey, useAlkanesBalanceCardLogic, useAlkanesCollectionListLogic, useAlkanesIconInfo, useAlkanesListLogic, useAlkanesMarketPlaceWebsite, useAlkanesNFTListLogic, useAlkanesNFTScreenLogic, useAlkanesTokenScreenLogic, useAmountInput, useAmountInputLogic, useAnnouncementCardLogic, useAppDispatch, useAppList, useAppSelector, useAppSummary, useApproval, useAssetTabKey, useAssetUtxosRunes, useAsyncEffect, useAutoLockTimeId, useBRC20BalanceCardLogic, useBRC20IconInfo, useBRC20InscribeTransferLogic, useBRC20InscribeTransferLogicStep1, useBRC20InscribeTransferLogicStep2, useBRC20InscribeTransferLogicStep3, useBRC20InscribeTransferLogicStep4, useBRC20ListLogic, useBRC20MarketPlaceWebsite, useBRC20ProgListLogic, useBRC20SendScreenLogic, useBRC20SendScreenLogicStep1, useBRC20SendScreenLogicStep2, useBRC20SendScreenLogicStep3, useBRC20SingleStepScreenLogic, useBRC20TokenHistoryLogic, useBRC20TokenInfoExplorerUrl, useBRC20TokenScreenLogic, useBTCUnit, useBabylonConfig, useBackRefresh, useBalanceCardDetailExpanded, useBalanceCardLogic, useBannerList, useBitcoinTx, useBooted, useBrowserState, useBtcDisplayLogic, useCAT20BalanceCardLogic, useCAT20IconInfo, useCAT20ListLogic, useCAT20MarketPlaceWebsite, useCAT20TokenInfoExplorerUrl, useCAT20TokenScreenLogic, useCAT721ListLogic, useCAT721NFTContentBaseUrl, useCAT721NFTScreenLogic, useCATAssetTabKey, useChain, useChainType, useChangeAddressFlagCallback, useChangeChainTypeCallback, useChangeLocaleCallback, useChangeNetworkTypeCallback, useCreateAccountCallback, useCreateColdWalletCallback, useCreatePasswordScreenLogic, useCreateSplitTxCallback, useCreateWalletLogicImportWordsStep, useCurrentAccount, useCurrentAddress, useCurrentKeyring, useDeveloperMode, useDevice, useDiscoveryState, useEditAccountNameScreenLogic, useEditContactScreenLogic, useEditWalletNameScreenLogic, useExportMnemonicsScreenLogic, useExportPrivateKeyScreenLogic, useFeeRateBar, useFeeRateBarLogic, useFetchAssetUtxosRunesCallback, useFetchBalanceCallback, useFetchUtxosCallback, useGetTxExplorerUrlCallback, useGlobalState, useGoBackRefresh, useHasBiometricsKey, useHasNewBanner, useHistory, useI18n, useIconBaseUrl, useImportAccountCallback, useImportAccountsFromKeystoneCallback, useInfiniteListScrollOffset, useInfiniteListScrollState, useInscriptionListLogic, useInscriptionSummary, useIsBiometricsSupported, useIsInExpandView, useIsKeystoneWallet, useIsMainnetChain, useIsReady, useIsRefresh, useIsScrollViewBot, useIsScrollViewTop, useIsUnlockTimeRefres, useIsUnlocked, useKeyrings, useKeyringsState, useLastFetchInfo, useLayerState, useLocale, useLockCallback, useLockTimePageLogic, useLockedOverlayVisible, useModelPopover, useNavigation, useNetworkType, useNotificationsLogic, useOrdinalsAssetTabKey, useOrdinalsInscriptionScreenLogic, useOrdinalsTx, useOrdinalsWebsite, usePrepareSendAlkanesCallback, usePrepareSendBTCCallback, usePrepareSendBypassHeadOffsetsCallback, usePrepareSendOrdinalsInscriptionCallback, usePrepareSendOrdinalsInscriptionsCallback, usePrepareSendRunesCallback, usePrice, usePushBitcoinTxCallback, usePushOrdinalsTxCallback, useReadApp, useReadTab, useReloadAccounts, useResetAddressInput, useResetAmountInput, useResetFeeRateBar, useResetTxState, useResetUiTxCreateScreen, useRunesBalanceCardLogic, useRunesIconInfo, useRunesInscribeUrl, useRunesListLogic, useRunesMarketUrl, useRunesTokenScreenLogic, useRunesTx, useSafeBalance, useScreenState, useSendAlkanesNFTScreenLogic, useSendAlkanesScreenLogic, useSendCAT20ScreenLogic, useSendCAT721ScreenLogic, useSendOrdinalsInscriptionScreenLogic, useSendRunesScreenLogic, useSetCurrentAccountCallback, useSetDeveloperModeCallback, useSetLockedOverlayVisibleCallback, useSetSpendUnavailableUtxosCallback, useSetTabCallback, useSettingsState, useSettingsTabScreenLogic, useSignMessageLogic, useSignPsbtLogic, useSkipVersionCallback, useSpendUnavailableUtxos, useSplitOrdinalsInscriptionScreenLogic, useStorage, useSupportedAssets, useSwitchChainModalVisible, useTab, useThrottle, useToggleBalanceCardDetailExpanded, useTools, useTransactionsState, useTransferableListLogic, useTxConfirmScreenLogic, useTxCreateScreenLogic, useTxExplorerUrl, useTxFailScreenLogic, useTxSuccessScreenLogic, useUIState, useUiTxCreateScreen, useUnisatWebsite, useUnlockCallback, useUnlockRead, useUnlockRefresh, useUnreadAppSummary, useUnreadNotificationsCount, useUpdateAddressInput, useUpdateAmountInput, useUpdateFeeRateBar, useUpdateScreenStateCallback, useUpdateUiTxCreateScreen, useUtxos, useVersionInfo, useWallRefresh, useWallTabFocusRefresh, useWallTabRefresh, useWallet, useWalletConfig, useWalletTabScreenState, useWalletTopTabScreenState };