@unisat/wallet-state 1.2.0 → 1.2.1

package/lib/index.d.ts

@@ -1,31 +1,2827 @@
-export declare function createAppStore(): import("@reduxjs/toolkit/dist/configureStore").ToolkitStore<{
-    accounts: import("./reducers/accounts").AccountsState;
-    transactions: import("./reducers/transactions").TransactionsState;
-    settings: import("./reducers/settings").SettingsState;
-    global: import("./reducers/global").GlobalState;
-    keyrings: import("./reducers/keyrings").KeyringsState;
-    ui: import("./reducers/ui").UIState;
-    discovery: import("./reducers/discovery").DiscoveryState;
-    browser: import("./reducers/browser").BrowserState;
-}, import("redux").AnyAction, import("@reduxjs/toolkit").MiddlewareArray<[import("@reduxjs/toolkit").ThunkMiddleware<{
-    accounts: import("./reducers/accounts").AccountsState;
-    transactions: import("./reducers/transactions").TransactionsState;
-    settings: import("./reducers/settings").SettingsState;
-    global: import("./reducers/global").GlobalState;
-    keyrings: import("./reducers/keyrings").KeyringsState;
-    ui: import("./reducers/ui").UIState;
-    discovery: import("./reducers/discovery").DiscoveryState;
-    browser: import("./reducers/browser").BrowserState;
-}, import("redux").AnyAction>, import("redux").Middleware<{}, any, import("redux").Dispatch<import("redux").AnyAction>>]>>;
-export type AppStore = ReturnType<typeof createAppStore>;
-export type AppState = ReturnType<AppStore['getState']>;
-export type AppDispatch = AppStore['dispatch'];
-export * from './context';
-export * from './hooks';
-export * from './updater';
-export * from './reducers';
-export * from './types';
-export * from './ui-hooks';
-export { uiEventBus } from './utils/eventBus';
-export { useAsyncEffect } from './utils/ui-utils';
-//# sourceMappingURL=index.d.ts.map
+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, AppExtra, 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 { AssetTabKey, OrdinalsAssetTabKey, CATAssetTabKey, AlkanesAssetTabKey, MoreAssetTabKey, NavigationSource, TabOption } from './types/index.js';
+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;
+        img: string;
+        link: string;
+    }[];
+    appList: {
+        tab: string;
+        items: AppInfo[];
+    }[];
+    lastFetchTime: number;
+    lastFetchChainType: ChainType;
+    cachedBannerIds: string[];
+    hasNewBanner: boolean;
+}
+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;
+    catAssetTabKey: CATAssetTabKey;
+    alkanesAssetTabKey: AlkanesAssetTabKey;
+    moreAssetTabKey: MoreAssetTabKey;
+    uiTxCreateScreen: {
+        toInfo: {
+            address: string;
+            domain: string;
+            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;
+        memo: string;
+    };
+    navigationSource: NavigationSource;
+    isBalanceHidden: boolean;
+    balanceDetailExpanded: boolean;
+    walletTopTabScreen: {
+        toptabKey: WallettopTabScreenTabKey;
+    };
+}
+declare const uiActions: _reduxjs_toolkit.CaseReducerActions<_reduxjs_toolkit.SliceCaseReducers<UIState>, string>;
+
+interface KeyringsState {
+    keyrings: WalletKeyring[];
+    current: WalletKeyring;
+}
+declare const keyringsActions: _reduxjs_toolkit.CaseReducerActions<_reduxjs_toolkit.SliceCaseReducers<KeyringsState>, string>;
+
+interface GlobalState {
+    tab: TabOption;
+    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;
+
+interface SettingsState {
+    locale: string;
+    networkType: NetworkType;
+    chainType: ChainType;
+    walletConfig: WalletConfig;
+    skippedVersion: string;
+    autoLockTimeId: number;
+    developerMode: boolean;
+}
+declare const settingsActions: _reduxjs_toolkit.CaseReducerActions<_reduxjs_toolkit.SliceCaseReducers<SettingsState>, string>;
+
+interface BitcoinTx {
+    fromAddress: string;
+    toAddress: string;
+    toSatoshis: number;
+    rawtx: string;
+    txid: string;
+    fee: number;
+    estimateFee: number;
+    changeSatoshis: number;
+    sending: boolean;
+    autoAdjust: boolean;
+    psbtHex: string;
+    feeRate: number;
+    toDomain: string;
+}
+interface OrdinalsTx {
+    fromAddress: string;
+    toAddress: string;
+    inscription: Inscription;
+    rawtx: string;
+    txid: string;
+    fee: number;
+    estimateFee: number;
+    changeSatoshis: number;
+    sending: boolean;
+    psbtHex: string;
+    feeRate: number;
+    toDomain: string;
+    outputValue: number;
+}
+interface RunesTx {
+    fromAddress: string;
+    toAddress: string;
+    rawtx: string;
+    txid: string;
+    fee: number;
+    estimateFee: number;
+    changeSatoshis: number;
+    sending: boolean;
+    psbtHex: string;
+    feeRate: number;
+    toDomain: string;
+    outputValue: number;
+    runeid?: string;
+    runeAmount?: string;
+}
+interface TransactionsState {
+    bitcoinTx: BitcoinTx;
+    ordinalsTx: OrdinalsTx;
+    runesTx: RunesTx;
+    utxos: UnspentOutput[];
+    spendUnavailableUtxos: UnspentOutput[];
+    assetUtxos_inscriptions: UnspentOutput[];
+    assetUtxos_runes: UnspentOutput[];
+}
+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;
+    loading: boolean;
+    balanceMap: {
+        [key: string]: {
+            amount: string;
+            btc_amount: string;
+            confirm_btc_amount: string;
+            pending_btc_amount: string;
+            inscription_amount: string;
+            expired: boolean;
+        };
+    };
+    balanceV2Map: {
+        [key: string]: BitcoinBalanceV2;
+    };
+    historyMap: {
+        [key: string]: {
+            list: TxHistoryItem[];
+            expired: boolean;
+        };
+    };
+    inscriptionsMap: {
+        [key: string]: {
+            list: Inscription[];
+            expired: boolean;
+        };
+    };
+    appSummary: AppSummary;
+    inscriptionSummary: InscriptionSummary;
+    addressSummary: AddressSummary;
+    model: Molels;
+    molelsPopover: MolelsPopover;
+}
+declare const accountActions: _reduxjs_toolkit.CaseReducerActions<_reduxjs_toolkit.SliceCaseReducers<AccountsState>, string>;
+
+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;
+    CreateReadonlyWalletScreen: 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;
+    address: string;
+    chain: ChainType;
+    isAlias: boolean;
+    isContact: boolean;
+    sortIndex?: number;
+}
+type ContactBookStore = Record<string, ContactBookItem | undefined>;
+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<boolean>;
+    changePassword: (password: string, newPassword: string) => Promise<void>;
+    unlock(password: string): Promise<void>;
+    isUnlocked(): Promise<boolean>;
+    lockWallet(): Promise<void>;
+    setPopupOpen(isOpen: boolean): void;
+    isReady(): Promise<boolean>;
+    getIsFirstOpen(): Promise<boolean>;
+    updateIsFirstOpen(): Promise<void>;
+    getAddressBalanceV2(address: string): Promise<BitcoinBalanceV2>;
+    getAddressBalance(address: string): Promise<BitcoinBalance>;
+    getAddressCacheBalance(address: string): Promise<BitcoinBalance>;
+    getMultiAddressAssets(addresses: string): Promise<AddressSummary[]>;
+    findGroupAssets(groups: {
+        type: number;
+        address_arr: string[];
+        pubkey_arr: string[];
+    }[]): Promise<{
+        type: number;
+        address_arr: string[];
+        pubkey_arr: string[];
+        satoshis_arr: number[];
+    }[]>;
+    getAddressInscriptions(address: string, cursor: number, size: number): Promise<{
+        list: Inscription[];
+        total: number;
+    }>;
+    getAddressHistory: (params: {
+        address: string;
+        start: number;
+        limit: number;
+    }) => Promise<{
+        start: number;
+        total: number;
+        detail: TxHistoryItem[];
+    }>;
+    getAddressCacheHistory: (address: string) => Promise<TxHistoryItem[]>;
+    getLocale(): Promise<string>;
+    setLocale(locale: string): Promise<void>;
+    getCurrency(): Promise<string>;
+    setCurrency(currency: string): Promise<void>;
+    clearKeyrings(): Promise<void>;
+    getPrivateKey(password: string, account: {
+        address: string;
+        type: string;
+    }): Promise<{
+        hex: string;
+        wif: string;
+    }>;
+    getMnemonics(password: string, keyring: WalletKeyring): Promise<{
+        hdPath: string;
+        mnemonic: string;
+        passphrase: string;
+    }>;
+    createKeyringWithPrivateKey(data: string, addressType: AddressType, alianName?: string): Promise<Account[]>;
+    getPreMnemonics(): Promise<any>;
+    generatePreMnemonic(): Promise<string>;
+    removePreMnemonics(): void;
+    createKeyringWithMnemonics(mnemonic: string, hdPath: string, passphrase: string, addressType: AddressType, accountCount: number, accountIndexDerivation?: boolean): Promise<{
+        address: string;
+        type: string;
+    }[]>;
+    createKeyringWithKeystone(urType: string, urCbor: string, addressType: AddressType, hdPath: string, accountCount: number, filterPubkey?: string[], connectionType?: 'USB' | 'QR'): Promise<{
+        address: string;
+        type: string;
+    }[]>;
+    createTmpKeyringWithPrivateKey(privateKey: string, addressType: AddressType): Promise<WalletKeyring>;
+    createTmpKeyringWithKeystone(urType: string, urCbor: string, addressType: AddressType, hdPath: string, accountCount?: number): Promise<WalletKeyring>;
+    createKeyringWithColdWallet(xpub: string, addressType: AddressType, alianName?: string, hdPath?: string, accountCount?: number): Promise<WalletKeyring>;
+    deriveAccountsFromXpub(xpub: string, addressType: AddressType, hdPath?: string, accountCount?: number): Promise<{
+        pubkey: string;
+        address: string;
+    }[]>;
+    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>;
+    getAllAlianName: () => (ContactBookItem | undefined)[];
+    getContactsByMap: () => ContactBookStore;
+    getCurrentAccount(): Promise<Account>;
+    getAccounts(): Promise<Account[]>;
+    getNextAlianName: (keyring: WalletKeyring) => Promise<string>;
+    getCurrentKeyringAccounts(): Promise<Account[]>;
+    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<ToSignData>;
+    createSendAllBTCPsbt(data: {
+        to: string;
+        btcUtxos: UnspentOutput[];
+        feeRate: number;
+        enableRBF?: boolean;
+    }): Promise<ToSignData>;
+    createSendInscriptionPsbt(data: {
+        to: string;
+        inscriptionId: string;
+        feeRate: number;
+        outputValue?: number;
+        btcUtxos: UnspentOutput[];
+        enableRBF?: boolean;
+    }): Promise<ToSignData>;
+    createSendMultipleInscriptionsPsbt(data: {
+        to: string;
+        inscriptionIds: string[];
+        feeRate: number;
+        btcUtxos: UnspentOutput[];
+        enableRBF?: boolean;
+    }): Promise<ToSignData>;
+    createSplitInscriptionPsbt(data: {
+        inscriptionId: string;
+        feeRate: number;
+        outputValue: number;
+        btcUtxos: UnspentOutput[];
+        enableRBF?: boolean;
+    }): Promise<ToSignData>;
+    pushTx(rawtx: string): Promise<string>;
+    queryDomainInfo(domain: string): Promise<Inscription>;
+    getInscriptionSummary(): Promise<InscriptionSummary>;
+    getAppSummary(): Promise<AppSummary>;
+    getBTCUtxos(): Promise<UnspentOutput[]>;
+    getAssetUtxosInscriptions(inscriptionId: string): Promise<UnspentOutput[]>;
+    getNetworkType(): Promise<NetworkType>;
+    setNetworkType(type: NetworkType): Promise<void>;
+    getChainType(): Promise<ChainType>;
+    setChainType(type: ChainType): Promise<void>;
+    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;
+    }>;
+    getRunesPrice(ticks: string[]): Promise<{
+        [tick: string]: TickPriceItem;
+    }>;
+    getCAT20sPrice(tokenIds: string[]): Promise<{
+        [tokenId: string]: TickPriceItem;
+    }>;
+    getAlkanesPrice(alkaneid: string[]): Promise<{
+        [tick: string]: TickPriceItem;
+    }>;
+    setEditingKeyring(keyringIndex: number): Promise<void>;
+    getEditingKeyring(): Promise<WalletKeyring>;
+    setEditingAccount(account: Account): Promise<void>;
+    getEditingAccount(): Promise<Account>;
+    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;
+        pageSize: number;
+        total: number;
+        list: Inscription[];
+    }>;
+    getBRC20List({ address, currentPage, pageSize, }: {
+        address: string;
+        currentPage: number;
+        pageSize: number;
+    }): Promise<{
+        currentPage: number;
+        pageSize: number;
+        total: number;
+        list: TokenBalance[];
+    }>;
+    getBRC20ProgList({ address, currentPage, pageSize, }: {
+        address: string;
+        currentPage: number;
+        pageSize: number;
+    }): Promise<{
+        currentPage: number;
+        pageSize: number;
+        total: number;
+        list: TokenBalance[];
+    }>;
+    getBRC20TransferableList({ address, ticker, tickerHex, currentPage, pageSize, }: {
+        address: string;
+        ticker: string;
+        tickerHex: string;
+        currentPage: number;
+        pageSize: number;
+    }): Promise<{
+        currentPage: number;
+        pageSize: number;
+        total: number;
+        list: TokenTransfer[];
+    }>;
+    getOrdinalsInscriptions(address: string, currentPage: number, pageSize: number): Promise<{
+        currentPage: number;
+        pageSize: number;
+        total: number;
+        list: Inscription[];
+    }>;
+    getBRC20Summary({ address, ticker, }: {
+        address: string;
+        ticker: string;
+    }): Promise<AddressTokenSummary>;
+    expireUICachedData(address: string): Promise<void>;
+    getWalletConfig(): Promise<WalletConfig>;
+    getSkippedVersion(): Promise<string>;
+    setSkippedVersion(version: string): Promise<void>;
+    getInscriptionUtxoDetail(inscriptionId: string): Promise<UTXO_Detail>;
+    getUtxoByInscriptionId(inscriptionId: string): Promise<UTXO>;
+    getInscriptionInfo(inscriptionId: string): Promise<Inscription>;
+    checkWebsite(website: string): Promise<WebsiteResult>;
+    readTab(tabName: string): Promise<void>;
+    readApp(appid: number): Promise<void>;
+    formatOptionsToSignInputs(psbtHex: string, options?: SignPsbtOptions): Promise<ToSignInput[]>;
+    getAddressSummary(address: string): Promise<AddressSummary>;
+    getShowSafeNotice(): Promise<boolean>;
+    setShowSafeNotice(show: boolean): Promise<void>;
+    addAddressFlag(account: Account, flag: AddressFlagType): Promise<Account>;
+    removeAddressFlag(account: Account, flag: AddressFlagType): Promise<Account>;
+    getVersionDetail(version: string): Promise<VersionDetail>;
+    genSignPsbtUr(psbtHex: string): Promise<{
+        type: string;
+        cbor: string;
+    }>;
+    parseSignPsbtUr(type: string, cbor: string, isFinalize?: boolean): Promise<{
+        psbtHex: string;
+        rawtx?: string;
+    }>;
+    genSignMsgUr(text: string, msgType?: string): Promise<{
+        type: string;
+        cbor: string;
+        requestId: string;
+    }>;
+    parseSignMsgUr(type: string, cbor: string, msgType: string): Promise<{
+        signature: string;
+    }>;
+    getKeystoneConnectionType(): Promise<'USB' | 'QR'>;
+    genSignCosmosUr(cosmosSignRequest: {
+        requestId?: string;
+        signData: string;
+        dataType: CosmosSignDataType;
+        path: string;
+        chainId?: string;
+        accountNumber?: string;
+        address?: string;
+    }): Promise<{
+        type: string;
+        cbor: string;
+        requestId: string;
+    }>;
+    parseCosmosSignUr(type: string, cbor: string): Promise<any>;
+    cosmosSignData(chainId: string, signBytesHex: string): Promise<{
+        publicKey: string;
+        signature: string;
+    }>;
+    getEnableSignData(): Promise<boolean>;
+    setEnableSignData(enable: boolean): Promise<void>;
+    getRunesList(address: string, currentPage: number, pageSize: number): Promise<{
+        currentPage: number;
+        pageSize: number;
+        total: number;
+        list: RuneBalance[];
+    }>;
+    getAssetUtxosRunes(rune: string): Promise<UnspentOutput[]>;
+    getAddressRunesTokenSummary(address: string, runeid: string): Promise<AddressRunesTokenSummary>;
+    createSendRunesPsbt(data: {
+        to: string;
+        runeid: string;
+        runeAmount: string;
+        feeRate: number;
+        btcUtxos?: UnspentOutput[];
+        assetUtxos?: UnspentOutput[];
+        outputValue?: number;
+        enableRBF?: boolean;
+    }): Promise<ToSignData>;
+    setAutoLockTimeId(timeId: number): Promise<void>;
+    getAutoLockTimeId(): Promise<number>;
+    getDeveloperMode(): Promise<boolean>;
+    setDeveloperMode(developerMode: boolean): Promise<void>;
+    getCAT20List(version: 'v1' | 'v2', address: string, currentPage: number, pageSize: number): Promise<{
+        currentPage: number;
+        pageSize: number;
+        total: number;
+        list: CAT20Balance[];
+    }>;
+    getAddressCAT20TokenSummary(version: 'v1' | 'v2', address: string, tokenId: string): Promise<AddressCAT20TokenSummary>;
+    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;
+        feeRate: number;
+        toSignData: ToSignData;
+    }>;
+    transferCAT20Step2(version: 'v1' | 'v2', transferId: string, psbtHex: string): Promise<{
+        toSignData: ToSignData;
+    }>;
+    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;
+        feeRate: number;
+        toSignData: ToSignData;
+    }>;
+    getMergeCAT20Status(version: 'v1' | 'v2', mergeId: string): Promise<any>;
+    getAppList(): Promise<{
+        tab: string;
+        items: AppInfo[];
+    }[]>;
+    getAppExtra(id: string | number, locale?: string): Promise<AppExtra>;
+    getBannerList(): Promise<{
+        id: string;
+        img: string;
+        link: string;
+    }[]>;
+    getBlockActiveInfo(): Promise<{
+        allTransactions: number;
+        allAddrs: number;
+    }>;
+    getCAT721List(version: 'v1' | 'v2', address: string, currentPage: number, pageSize: number): Promise<{
+        currentPage: number;
+        pageSize: number;
+        total: number;
+        list: CAT721Balance[];
+    }>;
+    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;
+        feeRate: number;
+        toSignData: ToSignData;
+    }>;
+    transferCAT721Step2(version: 'v1' | 'v2', transferId: string, psbtHex: string): Promise<{
+        toSignData: ToSignData;
+    }>;
+    transferCAT721Step3(version: 'v1' | 'v2', transferId: string, psbtHex: string): Promise<{
+        txid: string;
+    }>;
+    getBuyCoinChannelList(coin: string): Promise<BtcChannelItem[]>;
+    createBuyCoinPaymentUrl(coin: string, address: string, channel: string): Promise<string>;
+    getBabylonAddress(address: string): Promise<string>;
+    getBabylonAddressSummary(chainId: string, babylonConfig?: BabylonConfigV2): Promise<BabylonAddressSummary>;
+    createSendTokenStep1(chainId: string, tokenBalance: CosmosBalance, to: string, memo: string, { gasLimit, gasPrice, gasAdjustment, }: {
+        gasLimit: number;
+        gasPrice: string;
+        gasAdjustment?: number;
+    }): Promise<string>;
+    createSendTokenStep2(chainId: string, signature: string): Promise<string>;
+    simulateBabylonGas(chainId: string, recipient: string, amount: {
+        denom: string;
+        amount: string;
+    }, memo: string): Promise<number>;
+    getBabylonConfig(): Promise<BabylonConfigV2>;
+    getContactByAddress(address: string): Promise<ContactBookItem | undefined>;
+    getContactByAddressAndChain(address: string, chain: ChainType): Promise<ContactBookItem | undefined>;
+    updateContact(data: ContactBookItem): Promise<void>;
+    removeContact(address: string, chain?: ChainType): Promise<void>;
+    listContacts(): Promise<ContactBookItem[]>;
+    saveContactsOrder(contacts: ContactBookItem[]): Promise<void>;
+    singleStepTransferBRC20Step1(params: {
+        userAddress: string;
+        userPubkey: string;
+        receiver: string;
+        ticker: string;
+        amount: string;
+        feeRate: number;
+    }): Promise<{
+        orderId: string;
+        toSignData: ToSignData;
+    }>;
+    singleStepTransferBRC20Step2(params: {
+        orderId: string;
+        commitTx: string;
+    }): Promise<{
+        toSignData: ToSignData;
+    }>;
+    singleStepTransferBRC20Step3(params: {
+        orderId: string;
+        revealTx: string;
+    }): Promise<{
+        txid: string;
+    }>;
+    setLastActiveTime(): void;
+    getOpenInSidePanel(): Promise<boolean>;
+    setOpenInSidePanel(openInSidePanel: boolean): Promise<void>;
+    createSendBTCOffsetPsbt(tos: {
+        address: string;
+        satoshis: number;
+    }[], feeRate: number, enableRBF?: boolean): Promise<ToSignData>;
+    getAlkanesList(address: string, currentPage: number, pageSize: number): Promise<{
+        currentPage: number;
+        pageSize: number;
+        total: number;
+        list: AlkanesBalance[];
+    }>;
+    getAssetUtxosAlkanes(rune: string): Promise<UnspentOutput[]>;
+    getAddressAlkanesTokenSummary(address: string, alkaneid: string, fetchAvailable: boolean): Promise<AddressAlkanesTokenSummary>;
+    createSendAlkanesPsbt(params: {
+        to: string;
+        alkaneid: string;
+        amount: string;
+        feeRate: number;
+        type: 'ft' | 'nft';
+        enableRBF?: boolean;
+    }): Promise<ToSignData>;
+    getAlkanesCollectionList(address: string, currentPage: number, pageSize: number): Promise<{
+        list: AlkanesCollection[];
+        total: number;
+    }>;
+    getAlkanesCollectionItems(address: string, collectionId: string, currentPage: number, pageSize: number): Promise<{
+        currentPage: number;
+        pageSize: number;
+        list: AlkanesInfo[];
+        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>;
+    getEnableRBF(): Promise<boolean>;
+    setEnableRBF(enableRBF: 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;
+}) => react_jsx_runtime.JSX.Element;
+declare const useWallet: () => WalletController;
+
+declare function useAccountsState(): AppState['accounts'];
+declare function useCurrentAccount(): Account;
+declare function useCurrentAddress(): string;
+declare function useCurrentAccountCapabilities(): _unisat_wallet_shared.AccountCapabilities;
+declare function useAccounts(): Account[];
+declare function useAccountBalance(): _unisat_wallet_shared.BitcoinBalanceV2;
+declare function useAddressSummary(): _unisat_wallet_shared.AddressSummary;
+declare function useAccountInscriptions(): {
+    list: _unisat_wallet_shared.Inscription[];
+    expired: boolean;
+};
+declare function useInscriptionSummary(): _unisat_wallet_shared.InscriptionSummary;
+declare function useAppSummary(): _unisat_wallet_shared.AppSummary;
+declare function useUnreadAppSummary(): _unisat_wallet_shared.AppInfo;
+declare function useReadTab(): (name: 'app' | 'home' | 'settings') => Promise<void>;
+declare function useReadApp(): (id: number) => Promise<void>;
+declare function useHistory(): {
+    list: _unisat_wallet_shared.TxHistoryItem[];
+    expired: boolean;
+};
+declare function useAccountAddress(): string;
+declare function useSetCurrentAccountCallback(): (account: Account) => void;
+declare function useImportAccountCallback(): (privateKey: string, addressType: AddressType) => Promise<{
+    success: boolean;
+    error: any;
+}>;
+declare function useChangeAddressFlagCallback(): (isAdd: boolean, flag: number) => Promise<void>;
+declare function useFetchBalanceCallback(): () => Promise<void>;
+declare function useReloadAccounts(): () => Promise<void>;
+declare function useIsKeystoneWallet(): boolean;
+declare function useModelPopover(): MolelsPopover;
+
+declare const useAppDispatch: () => redux_thunk.ThunkDispatch<{
+    accounts: AccountsState;
+    transactions: TransactionsState;
+    settings: SettingsState;
+    global: GlobalState;
+    keyrings: KeyringsState;
+    ui: UIState;
+    discovery: DiscoveryState;
+    browser: BrowserState;
+}, undefined, redux.AnyAction> & redux.Dispatch<redux.AnyAction>;
+declare const useAppSelector: TypedUseSelectorHook<AppState>;
+
+declare function useDiscoveryState(): AppState['discovery'];
+declare function useAppList(): {
+    tab: string;
+    items: _unisat_wallet_shared.AppInfo[];
+}[];
+declare function useBannerList(): {
+    id: string;
+    img: string;
+    link: string;
+}[];
+declare function useLastFetchInfo(): {
+    lastFetchTime: number;
+    lasfFetchChainType: _unisat_wallet_types.ChainType;
+};
+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, 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>;
+
+declare function useKeyringsState(): AppState['keyrings'];
+declare function useKeyrings(): _unisat_wallet_shared.WalletKeyring[];
+declare function useCurrentKeyring(): _unisat_wallet_shared.WalletKeyring;
+
+declare function useSettingsState(): AppState['settings'];
+declare function useLocale(): string;
+declare function useChangeLocaleCallback(): (locale: string) => Promise<void>;
+declare function useNetworkType(): NetworkType;
+declare function useChangeNetworkTypeCallback(): (type: NetworkType) => Promise<void>;
+declare function useChainType(): ChainType;
+declare function useChain(): _unisat_wallet_shared.TypeChain;
+declare function useChangeChainTypeCallback(): (type: ChainType) => Promise<void>;
+declare function useBTCUnit(): string;
+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 useRunesTokenInfoExplorerUrl(runeId: string): string;
+declare function useAlkanesTokenInfoExplorerUrl(alkaneId: string): string;
+declare function useUnisatWebsite(): string;
+declare function useIconBaseUrl(): string;
+declare function useOrdinalsWebsite(): string;
+declare function useWalletConfig(): _unisat_wallet_shared.WalletConfig;
+declare function useVersionInfo(): {
+    currentVesion: string;
+    newVersion: string;
+    latestVersion: string;
+    skipped: boolean;
+    downloadUrl: string;
+    isNewest: boolean;
+};
+declare function useSkipVersionCallback(): (version: string) => void;
+declare function useAutoLockTimeId(): number;
+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 useBabylonConfig(): _unisat_babylon_service_types.BabylonConfig;
+declare function useIsMainnetChain(): boolean;
+declare function useDeveloperMode(): boolean;
+declare function useSetDeveloperModeCallback(): (developerMode: boolean) => Promise<void>;
+
+declare function useTransactionsState(): AppState['transactions'];
+declare function useBitcoinTx(): BitcoinTx;
+declare function usePrepareSendBTCCallback(): ({ toAddressInfo, toAmount, feeRate, memo, memos, disableAutoAdjust, enableRBF, }: {
+    toAddressInfo: ToAddressInfo;
+    toAmount: number;
+    feeRate?: number;
+    memo?: string;
+    memos?: string[];
+    disableAutoAdjust?: boolean;
+    enableRBF?: boolean;
+}) => Promise<ToSignData>;
+declare function usePrepareSendBypassHeadOffsetsCallback(): ({ toAddressInfo, toAmount, feeRate, enableRBF, }: {
+    toAddressInfo: ToAddressInfo;
+    toAmount: number;
+    feeRate: number;
+    enableRBF?: boolean;
+}) => 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, }: {
+    toAddressInfo: ToAddressInfo;
+    inscriptionId: string;
+    feeRate?: number;
+    outputValue?: number;
+    enableRBF?: boolean;
+}) => Promise<ToSignData>;
+declare function usePrepareSendOrdinalsInscriptionsCallback(): ({ toAddressInfo, inscriptionIds, feeRate, enableRBF, }: {
+    toAddressInfo: ToAddressInfo;
+    inscriptionIds: string[];
+    feeRate?: number;
+    enableRBF?: boolean;
+}) => Promise<ToSignData>;
+declare function useCreateSplitTxCallback(): ({ inscriptionId, feeRate, outputValue, enableRBF, }: {
+    inscriptionId: string;
+    feeRate: number;
+    outputValue: number;
+    enableRBF?: boolean;
+}) => Promise<ToSignData>;
+declare function usePushOrdinalsTxCallback(): (rawtx: string) => Promise<{
+    success: boolean;
+    txid: string;
+    error: string;
+}>;
+declare function useUtxos(): UnspentOutput[];
+declare function useFetchUtxosCallback(): () => Promise<UnspentOutput[]>;
+declare function useSpendUnavailableUtxos(): UnspentOutput[];
+declare function useSetSpendUnavailableUtxosCallback(): (utxos: UnspentOutput[]) => void;
+declare function useSafeBalance(): string;
+declare function useAssetUtxosRunes(): UnspentOutput[];
+declare function useFetchAssetUtxosRunesCallback(): (rune: string) => Promise<UnspentOutput[]>;
+declare function usePrepareSendRunesCallback(): ({ toAddressInfo, runeid, runeAmount, outputValue, feeRate, enableRBF, }: {
+    toAddressInfo: ToAddressInfo;
+    runeid: string;
+    runeAmount: string;
+    outputValue?: number;
+    feeRate: number;
+    enableRBF?: boolean;
+}) => Promise<ToSignData>;
+declare function useRunesTx(): RunesTx;
+declare function usePrepareSendAlkanesCallback(): (toAddressInfo: ToAddressInfo, alkaneid: string, amount: string, feeRate: number, type: 'ft' | 'nft', enableRBF?: boolean) => Promise<ToSignData>;
+
+declare function useUIState(): AppState['ui'];
+declare function useAssetTabKey(): AssetTabKey;
+declare function useOrdinalsAssetTabKey(): OrdinalsAssetTabKey;
+declare function useCATAssetTabKey(): CATAssetTabKey;
+declare function useAlkanesAssetTabKey(): AlkanesAssetTabKey;
+declare function useMoreAssetTabKey(): MoreAssetTabKey;
+declare function useUiTxCreateScreen(): {
+    toInfo: {
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    };
+    inputAmount: string;
+    enableRBF: boolean;
+};
+declare function useUpdateUiTxCreateScreen(): ({ toInfo, inputAmount, enableRBF, }: {
+    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 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 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 AccountUpdater(): any;
+
+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;
+    enableRBF: boolean;
+    rawTxInfo: RawTxInfo;
+    tokenInfo: TokenInfo;
+}
+interface UpdateContextDataParams$2 {
+    tabKey?: BRC20SendTabKey;
+    tokenBalance?: TokenBalance;
+    transferAmount?: string;
+    transferableList?: TokenTransfer[];
+    inscriptionIdSet?: Set<string>;
+    receiver?: string;
+    enableRBF?: boolean;
+    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;
+};
+
+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[];
+    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;
+    };
+    showProgBalance: boolean;
+    showSwapBalance: boolean;
+    onClickWrapBrc20Prog: () => void;
+    onClickUnwrapBrc20Prog: () => void;
+    onClickSendBrc20Prog: () => void;
+    onClickSwapInSwap: () => void;
+    onClickAddLiquidityInSwap: () => 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;
+    enableRBF: boolean;
+    setEnableRBF: (value: boolean) => void;
+    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;
+    enableRBF: boolean;
+    onRBFChange: (value: boolean) => 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;
+    enableRBF: boolean;
+}
+interface UpdateContextDataParams$1 {
+    step?: Step;
+    ticket?: string;
+    session?: any;
+    tokenBalance?: TokenBalance;
+    order?: InscribeOrder;
+    toSignData?: ToSignData;
+    amount?: string;
+    tokenInfo?: TokenInfo;
+    amountEditable?: boolean;
+    enableRBF?: 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;
+    enableRBF: boolean;
+    setEnableRBF: (value: boolean) => void;
+    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;
+    onClickViewOnExplorer: () => 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;
+    onClickViewOnExplorer: () => 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>>;
+    enableRBF: boolean;
+    setEnableRBF: (value: boolean) => void;
+    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;
+    enableMerge: boolean;
+    enableTrade: boolean;
+    iconInfo: {
+        iconUrl: string;
+        iconShortName: string;
+    };
+    onClickMerge: (e: any) => void;
+    onClickSend: (e: any) => void;
+    onClickTrade: (e: any) => void;
+    onClickBack: () => void;
+    onClickViewOnExplorer: (e: any) => 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;
+    enableRBF: boolean;
+    setEnableRBF: (value: boolean) => void;
+    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;
+    };
+    enableRBF: boolean;
+    disabled: boolean;
+    error: string;
+    setToInfo: react.Dispatch<react.SetStateAction<{
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    }>>;
+    setEnableRBF: (value: boolean) => void;
+    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;
+    enableRBF: boolean;
+    disabled: boolean;
+    error: string;
+    setToInfo: react.Dispatch<react.SetStateAction<{
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    }>>;
+    setInputAmount: react.Dispatch<react.SetStateAction<string>>;
+    setEnableRBF: (value: boolean) => void;
+    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;
+    disabledSend: boolean;
+};
+
+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;
+    readonlySignature: string;
+    setReadonlySignature: react.Dispatch<react.SetStateAction<string>>;
+    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;
+    readonlySignedPsbtHex: string;
+    setReadonlySignedPsbtHex: react.Dispatch<react.SetStateAction<string>>;
+    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, 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, MoreAssetTabKey, 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, useAlkanesTokenInfoExplorerUrl, 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, useCurrentAccountCapabilities, 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, useMoreAssetTabKey, 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, useRunesTokenInfoExplorerUrl, 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 };