@unisat/wallet-state 1.0.1 → 1.0.4

package/lib/index.d.mts

@@ -0,0 +1,946 @@
+import * as _reduxjs_toolkit_dist_configureStore from '@reduxjs/toolkit/dist/configureStore';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import * as _unisat_wallet_types from '@unisat/wallet-types';
+import { ChainType, NetworkType, AddressType } from '@unisat/wallet-types';
+import * as _unisat_wallet_shared from '@unisat/wallet-shared';
+import { AppInfo, Inscription, WalletKeyring, WalletConfig, UnspentOutput, Account, BitcoinBalanceV2, TxHistoryItem, AppSummary, InscriptionSummary, AddressSummary, BitcoinBalance, ToSignInput, ConnectedSite, FeeSummary, CoinPrice, TickPriceItem, InscribeOrder, TokenTransfer, DecodedPsbt, TokenBalance, AddressTokenSummary, UTXO_Detail, UTXO, WebsiteResult, SignPsbtOptions, AddressFlagType, VersionDetail, CosmosSignDataType, RuneBalance, AddressRunesTokenSummary, CAT20Balance, AddressCAT20TokenSummary, AddressCAT20UtxoSummary, UserToSignInput, CAT20MergeOrder, CAT721Balance, AddressCAT721CollectionSummary, BtcChannelItem, BabylonAddressSummary, CosmosBalance, AlkanesBalance, AddressAlkanesTokenSummary, AlkanesCollection, AlkanesInfo, BRC20HistoryItem, CAT_VERSION, ToAddressInfo, RawTxInfo, TypeChain } from '@unisat/wallet-shared';
+import { AssetTabKey, OrdinalsAssetTabKey, CATAssetTabKey, AlkanesAssetTabKey, NavigationSource, TabOption } from './types/index.mjs';
+import React, { ReactNode } from 'react';
+import * as _unisat_babylon_service_types from '@unisat/babylon-service/types';
+import { BabylonConfigV2 } from '@unisat/babylon-service/types';
+import { TypedUseSelectorHook } from 'react-redux';
+
+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>;
+
+interface UIState {
+    assetTabKey: AssetTabKey;
+    ordinalsAssetTabKey: OrdinalsAssetTabKey;
+    catAssetTabKey: CATAssetTabKey;
+    alkanesAssetTabKey: AlkanesAssetTabKey;
+    uiTxCreateScreen: {
+        toInfo: {
+            address: string;
+            domain: string;
+            inscription?: Inscription;
+        };
+        inputAmount: string;
+        enableRBF: boolean;
+        feeRate: number;
+    };
+    babylonSendScreen: {
+        inputAmount: string;
+        memo: string;
+    };
+    navigationSource: NavigationSource;
+    isBalanceHidden: boolean;
+}
+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;
+}
+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;
+    enableRBF: boolean;
+}
+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;
+    enableRBF: boolean;
+}
+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;
+    enableRBF: boolean;
+    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 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;
+}
+declare const accountActions: _reduxjs_toolkit.CaseReducerActions<_reduxjs_toolkit.SliceCaseReducers<AccountsState>, string>;
+
+declare const I18nProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+
+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>;
+    };
+    boot(password: string): Promise<void>;
+    isBooted(): Promise<boolean>;
+    getApproval(): Promise<any>;
+    resolveApproval(data?: any, data2?: any): Promise<void>;
+    rejectApproval(data?: any, data2?: any, data3?: any): Promise<void>;
+    hasVault(): Promise<boolean>;
+    verifyPassword(password: string): Promise<void>;
+    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): 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): 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[]>;
+    signPsbtWithHex(psbtHex: string, toSignInputs: ToSignInput[], autoFinalized: boolean): Promise<string>;
+    sendBTC(data: {
+        to: string;
+        amount: number;
+        btcUtxos: UnspentOutput[];
+        feeRate: number;
+        enableRBF: boolean;
+        memo?: string;
+        memos?: string[];
+    }): Promise<{
+        psbtHex: string;
+        rawtx: string;
+        fee: number;
+    }>;
+    sendAllBTC(data: {
+        to: string;
+        btcUtxos: UnspentOutput[];
+        feeRate: number;
+        enableRBF: boolean;
+    }): Promise<{
+        psbtHex: string;
+        rawtx: string;
+        fee: number;
+    }>;
+    sendOrdinalsInscription(data: {
+        to: string;
+        inscriptionId: string;
+        feeRate: number;
+        outputValue?: number;
+        enableRBF: boolean;
+        btcUtxos: UnspentOutput[];
+    }): Promise<{
+        psbtHex: string;
+        rawtx: string;
+        fee: number;
+    }>;
+    sendOrdinalsInscriptions(data: {
+        to: string;
+        inscriptionIds: string[];
+        feeRate: number;
+        enableRBF: boolean;
+        btcUtxos: UnspentOutput[];
+    }): Promise<{
+        psbtHex: string;
+        rawtx: string;
+        fee: number;
+    }>;
+    splitOrdinalsInscription(data: {
+        inscriptionId: string;
+        feeRate: number;
+        outputValue: number;
+        enableRBF: boolean;
+        btcUtxos: UnspentOutput[];
+    }): Promise<{
+        psbtHex: string;
+        rawtx: string;
+        fee: number;
+        splitedCount: number;
+    }>;
+    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>;
+    getCurrentKeyring(): Promise<WalletKeyring>;
+    getKeyrings(): Promise<WalletKeyring[]>;
+    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>;
+    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>;
+    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: string, currentPage: number, pageSize: number): Promise<{
+        currentPage: number;
+        pageSize: number;
+        total: number;
+        list: TokenBalance[];
+    }>;
+    getBRC20ProgList(address: string, currentPage: number, pageSize: number): Promise<{
+        currentPage: number;
+        pageSize: number;
+        total: number;
+        list: TokenBalance[];
+    }>;
+    getBRC20TransferableList(address: string, ticker: 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: 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>;
+    sendRunes(data: {
+        to: string;
+        runeid: string;
+        runeAmount: string;
+        feeRate: number;
+        enableRBF: boolean;
+        btcUtxos?: UnspentOutput[];
+        assetUtxos?: UnspentOutput[];
+        outputValue?: number;
+    }): Promise<{
+        psbtHex: string;
+        rawtx: string;
+        fee: number;
+    }>;
+    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;
+        commitTx: string;
+        toSignInputs: UserToSignInput[];
+        feeRate: number;
+    }>;
+    transferCAT20Step2(version: 'v1' | 'v2', transferId: string, commitTx: string, toSignInputs: UserToSignInput[]): Promise<{
+        revealTx: string;
+        toSignInputs: UserToSignInput[];
+    }>;
+    transferCAT20Step3(version: 'v1' | 'v2', transferId: string, revealTx: string, toSignInputs: UserToSignInput[]): Promise<{
+        txid: string;
+    }>;
+    mergeCAT20Prepare(version: 'v1' | 'v2', tokenId: string, utxoCount: number, feeRate: number): Promise<CAT20MergeOrder>;
+    transferCAT20Step1ByMerge(version: 'v1' | 'v2', mergeId: string): Promise<{
+        id: string;
+        commitTx: string;
+        toSignInputs: UserToSignInput[];
+        feeRate: number;
+    }>;
+    getMergeCAT20Status(version: 'v1' | 'v2', mergeId: string): Promise<any>;
+    getAppList(): Promise<{
+        tab: string;
+        items: AppInfo[];
+    }[]>;
+    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;
+        commitTx: string;
+        toSignInputs: UserToSignInput[];
+        feeRate: number;
+    }>;
+    transferCAT721Step2(version: 'v1' | 'v2', transferId: string, commitTx: string, toSignInputs: UserToSignInput[]): Promise<{
+        revealTx: string;
+        toSignInputs: UserToSignInput[];
+    }>;
+    transferCAT721Step3(version: 'v1' | 'v2', transferId: string, revealTx: string, toSignInputs: UserToSignInput[]): 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;
+        psbtHex: string;
+        toSignInputs: UserToSignInput[];
+    }>;
+    singleStepTransferBRC20Step2(params: {
+        orderId: string;
+        commitTx: string;
+        toSignInputs: UserToSignInput[];
+    }): Promise<{
+        psbtHex: string;
+        toSignInputs: UserToSignInput[];
+    }>;
+    singleStepTransferBRC20Step3(params: {
+        orderId: string;
+        revealTx: string;
+        toSignInputs: UserToSignInput[];
+    }): Promise<{
+        txid: string;
+    }>;
+    setLastActiveTime(): void;
+    getOpenInSidePanel(): Promise<boolean>;
+    setOpenInSidePanel(openInSidePanel: boolean): Promise<void>;
+    sendCoinBypassHeadOffsets(tos: {
+        address: string;
+        satoshis: number;
+    }[], feeRate: number): Promise<{
+        psbtHex: string;
+        rawtx: string;
+        fee: number;
+    }>;
+    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>;
+    createAlkanesSendTx(params: {
+        userAddress: string;
+        userPubkey: string;
+        receiver: string;
+        alkaneid: string;
+        amount: string;
+        feeRate: number;
+    }): Promise<{
+        psbtHex: string;
+        toSignInputs: UserToSignInput[];
+    }>;
+    signAlkanesSendTx(params: {
+        commitTx: string;
+        toSignInputs: ToSignInput[];
+    }): Promise<{
+        txid: string;
+    }>;
+    sendAlkanes(params: {
+        to: string;
+        alkaneid: string;
+        amount: string;
+        feeRate: number;
+        enableRBF: boolean;
+    }): Promise<string>;
+    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[]>;
+}
+declare const WalletProvider: ({ children, wallet, }: {
+    children?: ReactNode;
+    wallet: WalletController;
+}) => JSX.Element;
+declare const useWallet: () => WalletController;
+
+interface PriceContextType {
+    isLoadingCoinPrice: boolean;
+    coinPrice: CoinPrice;
+    refreshCoinPrice: () => void;
+}
+declare function usePrice(): PriceContextType;
+declare function PriceProvider({ children }: {
+    children: ReactNode;
+}): JSX.Element;
+
+declare function useAccountsState(): AppState['accounts'];
+declare function useCurrentAccount(): Account;
+declare function useCurrentAddress(): string;
+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;
+
+type UiTypeCheck = {
+    isTab: boolean;
+    isNotification: boolean;
+    isPop: boolean;
+    isSidePanel: boolean;
+};
+declare const getUiType: () => UiTypeCheck;
+declare const useApproval: () => readonly [() => Promise<any>, (data?: any, stay?: boolean, forceReject?: boolean) => Promise<void>, (err: any, stay?: boolean, isInternal?: boolean) => Promise<void>];
+
+declare const useAppDispatch: () => _reduxjs_toolkit.ThunkDispatch<{
+    accounts: AccountsState;
+    transactions: TransactionsState;
+    settings: SettingsState;
+    global: GlobalState;
+    keyrings: KeyringsState;
+    ui: UIState;
+    discovery: DiscoveryState;
+}, undefined, _reduxjs_toolkit.AnyAction> & _reduxjs_toolkit.Dispatch<_reduxjs_toolkit.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 useSetTabCallback(): (tab: TabOption) => void;
+declare function useBooted(): boolean;
+declare function useIsUnlocked(): boolean;
+declare function useIsReady(): boolean;
+declare function useUnlockCallback(): (password: string) => Promise<void>;
+declare function useCreateAccountCallback(): (mnemonics: string, hdPath: string, passphrase: string, addressType: AddressType, accountCount: number) => Promise<void>;
+declare function useImportAccountsFromKeystoneCallback(): (urType: string, urCbor: string, addressType: AddressType, accountCount: number, hdPath: string, filterPubkey?: string[], connectionType?: 'USB' | 'QR') => Promise<void>;
+declare function useCreateColdWalletCallback(): (xpub: string, addressType: AddressType, alianName?: string, hdPath?: string, accountCount?: number) => Promise<void>;
+
+/**
+ * Use i18n Hook
+ * @returns i18n context
+ */
+declare const useI18n: () => any;
+/**
+ * Get current language
+ * @returns current language code
+ */
+declare const getCurrentLocale: () => Promise<string>;
+/**
+ * Select special languages for style adaptation
+ * @returns { currentLocale: string, isSpecialLocale: boolean }
+ */
+declare const getSpecialLocale: () => Promise<{
+    currentLocale: string;
+    isSpecialLocale: boolean;
+}>;
+
+declare function useKeyringsState(): AppState['keyrings'];
+declare function useKeyrings(): _unisat_wallet_shared.WalletKeyring[];
+declare function useCurrentKeyring(): _unisat_wallet_shared.WalletKeyring;
+
+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 useUnisatWebsite(): string;
+declare function useOrdinalsWebsite(): string;
+declare function useWalletConfig(): _unisat_wallet_shared.WalletConfig;
+declare function useVersionInfo(): {
+    currentVesion: string;
+    newVersion: string;
+    latestVersion: string;
+    skipped: boolean;
+};
+declare function useSkipVersionCallback(): (version: string) => void;
+declare function useAutoLockTimeId(): number;
+declare function getAddressTips(address: string, chanEnum: ChainType): {
+    homeTip: string;
+    sendTip: string;
+};
+declare function useAddressTips(): {
+    homeTip: string;
+    sendTip: string;
+};
+declare function useCAT721NFTContentBaseUrl(version: CAT_VERSION): "" | "https://tracker-fractal-mainnet.catprotocol.org" | "https://tracker2-fractal-mainnet.catprotocol.org" | "https://tracker-fractal-testnet.catprotocol.org";
+declare function useBRC20MarketPlaceWebsite(ticker: string): string;
+declare function useRunesMarketPlaceWebsite(ticker: string): string;
+declare function useCAT20MarketPlaceWebsite(tokenId: string): string;
+declare function useBabylonConfig(): _unisat_babylon_service_types.BabylonConfig;
+declare function useIsMainnetChain(): boolean;
+declare function useDeveloperMode(): boolean;
+declare function useSetDeveloperModeCallback(): (developerMode: boolean) => Promise<void>;
+
+declare function useTransactionsState(): AppState['transactions'];
+declare function useBitcoinTx(): BitcoinTx;
+declare function usePrepareSendBTCCallback(): ({ toAddressInfo, toAmount, feeRate, enableRBF, memo, memos, disableAutoAdjust, }: {
+    toAddressInfo: ToAddressInfo;
+    toAmount: number;
+    feeRate?: number;
+    enableRBF: boolean;
+    memo?: string;
+    memos?: string[];
+    disableAutoAdjust?: boolean;
+}) => Promise<RawTxInfo>;
+declare function usePrepareSendBypassHeadOffsetsCallback(): ({ toAddressInfo, toAmount, feeRate, }: {
+    toAddressInfo: ToAddressInfo;
+    toAmount: number;
+    feeRate: number;
+}) => Promise<RawTxInfo>;
+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<RawTxInfo>;
+declare function usePrepareSendOrdinalsInscriptionsCallback(): ({ toAddressInfo, inscriptionIds, feeRate, enableRBF, }: {
+    toAddressInfo: ToAddressInfo;
+    inscriptionIds: string[];
+    feeRate?: number;
+    enableRBF: boolean;
+}) => Promise<RawTxInfo>;
+declare function useCreateSplitTxCallback(): ({ inscriptionId, feeRate, outputValue, enableRBF, }: {
+    inscriptionId: string;
+    feeRate: number;
+    outputValue: number;
+    enableRBF: boolean;
+}) => Promise<{
+    rawTxInfo: RawTxInfo;
+    splitedCount: number;
+}>;
+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<RawTxInfo>;
+declare function useRunesTx(): RunesTx;
+declare function usePrepareSendAlkanesCallback(): (toAddressInfo: ToAddressInfo, alkaneid: string, amount: string, feeRate: number, enableRBF?: boolean) => Promise<string>;
+
+declare function useUIState(): AppState['ui'];
+declare function useAssetTabKey(): AssetTabKey;
+declare function useOrdinalsAssetTabKey(): OrdinalsAssetTabKey;
+declare function useCATAssetTabKey(): CATAssetTabKey;
+declare function useAlkanesAssetTabKey(): AlkanesAssetTabKey;
+declare function useUiTxCreateScreen(): {
+    toInfo: {
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    };
+    inputAmount: string;
+    enableRBF: boolean;
+    feeRate: number;
+};
+declare function useUpdateUiTxCreateScreen(): ({ toInfo, inputAmount, enableRBF, feeRate, }: {
+    toInfo?: {
+        address: string;
+        domain: string;
+        inscription?: Inscription;
+    };
+    inputAmount?: string;
+    enableRBF?: boolean;
+    feeRate?: number;
+}) => void;
+declare function useResetUiTxCreateScreen(): () => void;
+declare function useSupportedAssets(): {
+    tabKeys: AssetTabKey[];
+    assets: {
+        ordinals: boolean;
+        runes: boolean;
+        CAT20: boolean;
+        alkanes: boolean;
+    };
+    key: string;
+};
+declare const useIsInExpandView: () => boolean;
+declare const useUtxoTools: (chain: TypeChain) => {
+    openUtxoTools: () => void;
+};
+declare function useLocationState<T>(): T;
+
+declare function AccountUpdater(): any;
+
+declare const store: _reduxjs_toolkit_dist_configureStore.ToolkitStore<{
+    accounts: AccountsState;
+    transactions: TransactionsState;
+    settings: SettingsState;
+    global: GlobalState;
+    keyrings: KeyringsState;
+    ui: UIState;
+    discovery: DiscoveryState;
+}, _reduxjs_toolkit.AnyAction, _reduxjs_toolkit.MiddlewareArray<[_reduxjs_toolkit.ThunkMiddleware<{
+    accounts: AccountsState;
+    transactions: TransactionsState;
+    settings: SettingsState;
+    global: GlobalState;
+    keyrings: KeyringsState;
+    ui: UIState;
+    discovery: DiscoveryState;
+}, _reduxjs_toolkit.AnyAction>, _reduxjs_toolkit.Middleware<{}, any, _reduxjs_toolkit.Dispatch<_reduxjs_toolkit.AnyAction>>]>>;
+
+type AppState = ReturnType<typeof store.getState>;
+type AppDispatch = typeof store.dispatch;
+
+export { AccountUpdater, AlkanesAssetTabKey, AppDispatch, AppState, AssetTabKey, CATAssetTabKey, I18nProvider, NavigationSource, OrdinalsAssetTabKey, PriceProvider, TabOption, WalletProvider, accountActions, store as default, discoveryActions, getAddressTips, getCurrentLocale, getSpecialLocale, getUiType, globalActions, keyringsActions, settingsActions, transactionsActions, uiActions, useAccountAddress, useAccountBalance, useAccountInscriptions, useAccounts, useAccountsState, useAddressExplorerUrl, useAddressSummary, useAddressTips, useAlkanesAssetTabKey, useAppDispatch, useAppList, useAppSelector, useAppSummary, useApproval, useAssetTabKey, useAssetUtxosRunes, useAutoLockTimeId, useBRC20MarketPlaceWebsite, useBTCUnit, useBabylonConfig, useBannerList, useBitcoinTx, useBooted, useCAT20MarketPlaceWebsite, useCAT20TokenInfoExplorerUrl, useCAT721NFTContentBaseUrl, useCATAssetTabKey, useChain, useChainType, useChangeAddressFlagCallback, useChangeChainTypeCallback, useChangeLocaleCallback, useChangeNetworkTypeCallback, useCreateAccountCallback, useCreateColdWalletCallback, useCreateSplitTxCallback, useCurrentAccount, useCurrentAddress, useCurrentKeyring, useDeveloperMode, useDiscoveryState, useFetchAssetUtxosRunesCallback, useFetchBalanceCallback, useFetchUtxosCallback, useGetTxExplorerUrlCallback, useGlobalState, useHasNewBanner, useHistory, useI18n, useImportAccountCallback, useImportAccountsFromKeystoneCallback, useInscriptionSummary, useIsInExpandView, useIsKeystoneWallet, useIsMainnetChain, useIsReady, useIsUnlocked, useKeyrings, useKeyringsState, useLastFetchInfo, useLocale, useLocationState, useNetworkType, useOrdinalsAssetTabKey, useOrdinalsTx, useOrdinalsWebsite, usePrepareSendAlkanesCallback, usePrepareSendBTCCallback, usePrepareSendBypassHeadOffsetsCallback, usePrepareSendOrdinalsInscriptionCallback, usePrepareSendOrdinalsInscriptionsCallback, usePrepareSendRunesCallback, usePrice, usePushBitcoinTxCallback, usePushOrdinalsTxCallback, useReadApp, useReadTab, useReloadAccounts, useResetUiTxCreateScreen, useRunesMarketPlaceWebsite, useRunesTx, useSafeBalance, useSetCurrentAccountCallback, useSetDeveloperModeCallback, useSetSpendUnavailableUtxosCallback, useSetTabCallback, useSettingsState, useSkipVersionCallback, useSpendUnavailableUtxos, useSupportedAssets, useTab, useTransactionsState, useTxExplorerUrl, useUIState, useUiTxCreateScreen, useUnisatWebsite, useUnlockCallback, useUnreadAppSummary, useUpdateUiTxCreateScreen, useUtxoTools, useUtxos, useVersionInfo, useWallet, useWalletConfig };