@otoplo/wallet-common 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2278 @@
+import { AddressType } from 'libnexa-ts';
+import { AsyncThunk } from '@reduxjs/toolkit';
+import { AsyncThunkConfig } from '@reduxjs/toolkit';
+import { CaseReducerActions } from '@reduxjs/toolkit';
+import { DAppInfo } from 'wallet-comms-sdk';
+import { DAppProvider } from 'wallet-comms-sdk';
+import { HDPrivateKey } from 'libnexa-ts';
+import { PayloadAction } from '@reduxjs/toolkit';
+import { PublicKey } from 'libnexa-ts';
+import { Reducer } from 'redux';
+import { RequestResponse } from '@otoplo/electrum-client';
+import { Script } from 'libnexa-ts';
+import { ScriptElement } from 'libnexa-ts';
+import { SessionDetails } from 'wallet-comms-sdk';
+import { Transaction } from 'libnexa-ts';
+import { TransportScheme } from '@otoplo/electrum-client';
+
+export declare interface Account {
+    id: number;
+    name: string;
+    address: string;
+    balance: Balance;
+    tokensBalance: Record<string, Balance>;
+    tokens: AssetEntity[];
+    sessions: Record<string, SessionInfo>;
+}
+
+export declare interface AccountDTO {
+    id: number;
+    name: string;
+    address: string;
+    height: number;
+    hidden: number;
+    statusHash: string;
+    balance: Balance;
+    tokensBalance: Record<string, Balance>;
+    type: AccountType;
+}
+
+export declare interface AccountEntity {
+    id: number;
+    name: string;
+    address: string;
+    height: number;
+    hidden: number;
+    statusHash: string;
+    balance: string;
+    tokensBalance: string;
+}
+
+export declare enum AccountType {
+    MAIN = 0,
+    VAULT = 1,
+    DAPP = 2
+}
+
+export declare interface AddressDTO {
+    address: string;
+    space: number;
+    idx: number;
+    used: boolean;
+    height: number;
+    statusHash: string;
+    balance: Balance;
+    tokensBalance: Record<string, Balance>;
+    type: AccountType;
+}
+
+export declare interface AddressEntity {
+    address: string;
+    space: number;
+    idx: number;
+    used: boolean;
+    height: number;
+    statusHash: string;
+    balance: string;
+    tokensBalance: string;
+}
+
+export declare interface AddressKey {
+    keyPath: string;
+    address: string;
+    balance: Balance;
+    tokensBalance: Record<string, Balance>;
+}
+
+declare interface AddSessionPayload {
+    accountId: number;
+    sessionInfo: SessionInfo;
+}
+
+export declare interface AppNotification {
+    id: string;
+    type: 'wallet' | 'web3';
+    title: string;
+    message?: string;
+    createdAt: number;
+    action?: NotificationAction;
+}
+
+export declare interface AssetEntity {
+    accountId: number;
+    tokenIdHex: string;
+    type: AssetType;
+    addedTime: number;
+}
+
+export declare interface AssetInfo {
+    token: string;
+    tokenIdHex: string;
+    decimals: number;
+    name?: string;
+    ticker?: string;
+    iconUrl?: string;
+}
+
+export declare interface AssetMovement {
+    address: string;
+    nexaAmount: string;
+    assetId: string;
+    assetAmount: string;
+}
+
+export declare class AssetService {
+    private readonly walletDb;
+    private readonly rostrumService;
+    private readonly walletCache;
+    constructor(walletDb: WalletDB, rostrumService: RostrumService, walletCache: WalletCache);
+    getTokenInfo(token: string, checkCache?: boolean): Promise<TokenEntity | undefined>;
+    isNftToken(token: string): Promise<boolean>;
+    getAssetInfo(token: string): Promise<AssetInfo | undefined>;
+    handleNftReceive(accountId: number, tokenIdHex: string, time: number): Promise<void>;
+    private saveNft;
+    fetchAndSaveTokens(accountId: number, tokenBalances: Record<string, Balance>): Promise<void>;
+    syncNfts(accountId: number, tokensBalance: Record<string, Balance>): Promise<void>;
+}
+
+export declare interface AssetTransactionEntity {
+    accountId: number;
+    assetId: string;
+    txIdem: string;
+    time: number;
+}
+
+export declare enum AssetType {
+    TOKEN = "token",
+    NFT = "nft"
+}
+
+export declare const authActions: CaseReducerActions<    {
+setWalletExist: (state: {
+isWalletExist: boolean;
+isAuthorized: boolean;
+}, action: PayloadAction<boolean>) => void;
+setAuthorized: (state: {
+isWalletExist: boolean;
+isAuthorized: boolean;
+}, action: PayloadAction<boolean>) => void;
+}, "auth">;
+
+export declare const authReducer: Reducer<AuthState>;
+
+export declare interface AuthState {
+    isWalletExist: boolean;
+    isAuthorized: boolean;
+}
+
+export declare interface Balance {
+    confirmed: string | number;
+    unconfirmed: string | number;
+}
+
+export declare interface BlockTip {
+    height: number;
+    hex: string;
+}
+
+export declare function capitalizeFirstLetter(str: string): string;
+
+export declare const currencies: string[];
+
+declare type Currency = keyof typeof currencySymbols;
+
+declare const currencySymbols: {
+    readonly usd: "$";
+    readonly eur: "€";
+    readonly gbp: "£";
+    readonly cny: "¥";
+    readonly jpy: "¥";
+    readonly aud: "A$";
+    readonly cad: "C$";
+    readonly chf: "Fr";
+};
+
+export declare function currentTimestamp(): number;
+
+export declare const dappModalActions: CaseReducerActions<    {
+showRequest(state: {
+modalType: SessionRequestType | null;
+currentRequest: {
+type: SessionRequestType;
+accountId: number;
+sessionId: string;
+request: any;
+} | null;
+}, action: PayloadAction<DappRpcRequest>): void;
+clear(state: {
+modalType: SessionRequestType | null;
+currentRequest: {
+type: SessionRequestType;
+accountId: number;
+sessionId: string;
+request: any;
+} | null;
+}): void;
+}, "dappModal">;
+
+export declare const dappModalReducer: Reducer<DappModalState>;
+
+export declare interface DappModalState {
+    modalType: SessionRequestType | null;
+    currentRequest: DappRpcRequest | null;
+}
+
+export declare interface DappRpcRequest {
+    type: SessionRequestType;
+    accountId: number;
+    sessionId: string;
+    request: any;
+}
+
+export declare type DBEvent = {
+    type: 'tx_refresh';
+} | {
+    type: 'nft_refresh';
+} | {
+    type: 'token_added';
+    accountId: number;
+    token: AssetEntity;
+} | {
+    type: 'token_removed';
+    accountId: number;
+    tokenId: string;
+} | {
+    type: 'nft_deleted';
+    id: string;
+};
+
+export declare interface DBStore {
+    clearData(): Promise<void>;
+    initSchema(): Promise<boolean>;
+    upsertTransaction(txEntry: TransactionEntity): Promise<void>;
+    upsertAssetTransaction(assetTx: AssetTransactionEntity): Promise<void>;
+    getTransactions(account: number, tokenId?: string): Promise<TransactionEntity[] | undefined>;
+    getPageTransactions(account: number, pageNum: number, pageSize: number, tokenId?: string): Promise<TransactionEntity[] | undefined>;
+    countTransactions(account: number, tokenId?: string): Promise<number>;
+    clearTransactions(account: number): Promise<void>;
+    upsertToken(token: TokenEntity): Promise<void>;
+    getTokens(account: number): Promise<AssetEntity[] | undefined>;
+    getToken(id: string): Promise<TokenEntity | undefined>;
+    deleteToken(id: string): Promise<void>;
+    countNfts(account: number): Promise<number>;
+    upsertNft(nft: NftEntity): Promise<void>;
+    getNfts(account: number, pageNum: number, pageSize: number): Promise<AssetEntity[] | undefined>;
+    getNft(id: string): Promise<NftEntity | undefined>;
+    deleteNft(id: string): Promise<void>;
+    isNftExist(id: string): Promise<boolean>;
+    upsertAsset(asset: AssetEntity): Promise<void>;
+    deleteAsset(account: number, id: string): Promise<void>;
+    countAssetsById(id: string): Promise<number>;
+    isAssetExistForAccount(account: number, id: string): Promise<boolean>;
+    upsertAccount(account: AccountEntity): Promise<void>;
+    getAccounts(): Promise<AccountEntity[]>;
+    countAccounts(): Promise<number>;
+    updateAccountName(account: number, name: string): Promise<void>;
+    upsertSession(session: SessionEntity): Promise<void>;
+    getSessionsByAccount(accountId: number): Promise<SessionEntity[]>;
+    deleteSession(sessionId: string): Promise<void>;
+    upsertAddress(address: AddressEntity): Promise<void>;
+    getReceiveAddresses(): Promise<AddressEntity[]>;
+    getChangeAddresses(): Promise<AddressEntity[]>;
+    countAddresses(): Promise<number>;
+    getVaults(): Promise<VaultEntity[]>;
+    upsertVault(vault: VaultEntity): Promise<void>;
+}
+
+export declare type DBUpdateCallback = (event: DBEvent) => void;
+
+export declare function encryptMnemonic(phrase: string, password: string): Promise<string>;
+
+export declare function estimateDateByFutureBlock(current: number, future: number): string;
+
+export declare function fetchAssetBlob(url: string): Promise<Uint8Array>;
+
+export declare function fetchAssetDoc(url: string): Promise<any>;
+
+export declare function fetchNiftyNFT(id: string): Promise<Uint8Array>;
+
+export declare const fetchPrice: AsyncThunk<Record<string, Price>, void, AsyncThunkConfig>;
+
+export declare function generateNewMnemonic(size?: 12 | 24): string;
+
+export declare function generateVaultAddress(pubKey: PublicKey, args: number[]): string | undefined;
+
+export declare function generateVaultConstraint(pubKey: PublicKey): Script;
+
+export declare function generateVaultVisibleArgs(args: number[]): ScriptElement[];
+
+export declare function getAddressBuffer(address: string): Uint8Array;
+
+export declare function getCurrencySymbol(currency: Currency): string;
+
+export declare function getExplorerUrl(): string;
+
+export declare function getFileMediaType(filename: string): 'video' | 'audio' | 'image' | 'unknown';
+
+export declare function getFileMimeType(filename: string): string;
+
+export declare function getNexaPrices(): Promise<Record<string, number>>;
+
+export declare function getNiftyToken(): TokenEntity;
+
+export declare function getVaultConstraintHash(pubKey: PublicKey): Uint8Array;
+
+export declare function getVaultTemplate(): Script;
+
+export declare function getVaultTemplateHash(): Uint8Array;
+
+export declare interface IFirstUse {
+    block_hash: string;
+    block_height: number;
+    height: number;
+    tx_hash: string;
+}
+
+export declare interface IListUnspentRecord {
+    has_token: boolean;
+    height: number;
+    outpoint_hash: string;
+    tx_hash: string;
+    tx_pos: number;
+    value: number;
+}
+
+export declare function initializePrices(): Record<string, Price>;
+
+export declare interface IScriptPubKey {
+    addresses: string[];
+    argHash: string;
+    asm: string;
+    group: string;
+    groupAuthority: string | number;
+    groupQuantity: string | number;
+    hex: string;
+    scriptHash: string;
+    token_id_hex?: string;
+    type: string;
+}
+
+export declare interface IScriptSig {
+    asm: string;
+    hex: string;
+}
+
+export declare function isGenesisHashValid(hash: string): boolean;
+
+export declare function isMnemonicValid(mnemonic: string): boolean;
+
+export declare function isNiftySubgroup(group: string): boolean;
+
+export declare function isNullOrEmpty(arg?: string | any[] | null): arg is undefined | [] | null | '';
+
+export declare interface ISpent {
+    height: number;
+    tx_hash: string;
+    tx_pos: number;
+}
+
+export declare function isTestnet(): boolean;
+
+export declare function isValidNexaAddress(address: string, type?: AddressType): boolean;
+
+export declare interface ITokenGenesis {
+    decimal_places?: number;
+    document_hash?: string;
+    document_url?: string;
+    group: string;
+    height: number;
+    name?: string;
+    op_return?: string;
+    ticker?: string;
+    token_id_hex: string;
+    txid: string;
+    txidem: string;
+    op_return_id: number;
+}
+
+export declare interface ITokenListUnspent {
+    cursor?: any;
+    unspent: ITokenUtxo[];
+}
+
+export declare interface ITokensBalance {
+    cursor?: any;
+    confirmed: Record<string, string | number>;
+    unconfirmed: Record<string, string | number>;
+}
+
+export declare interface ITokenUtxo {
+    group: string;
+    height: number;
+    outpoint_hash: string;
+    token_amount: number | string;
+    token_id_hex: string;
+    tx_hash: string;
+    tx_pos: number;
+    value: number;
+}
+
+export declare interface ITransaction {
+    blockhash: string;
+    blocktime: number;
+    confirmations: number;
+    fee: number;
+    fee_satoshi: number;
+    hash: string;
+    height: number;
+    hex: string;
+    locktime: number;
+    size: number;
+    time: number;
+    txid: string;
+    txidem: string;
+    version: number;
+    vin: ITXInput[];
+    vout: ITXOutput[];
+}
+
+export declare interface ITXHistory {
+    fee?: number;
+    height: number;
+    tx_hash: string;
+}
+
+export declare interface ITXInput {
+    outpoint: string;
+    scriptSig: IScriptSig;
+    sequence: number;
+    value: number;
+    value_satoshi: string | number;
+    addresses: string[];
+    group: string;
+    groupAuthority: string | number;
+    groupQuantity: string | number;
+    token_id_hex?: string;
+}
+
+export declare interface ITXOutput {
+    n: number;
+    outpoint_hash: string;
+    scriptPubKey: IScriptPubKey;
+    type: number;
+    value: number;
+    value_satoshi: string | number;
+}
+
+export declare interface IUtxo {
+    addresses: string[];
+    amount: number;
+    group: string;
+    group_authority: string | number;
+    group_quantity: string | number;
+    height: number;
+    scripthash: string;
+    scriptpubkey: string;
+    spent: ISpent;
+    status: string;
+    template_argumenthash: string;
+    template_scripthash: string;
+    token_id_hex: string;
+    tx_hash: string;
+    tx_idem: string;
+    tx_pos: number;
+}
+
+export declare class KeyManager {
+    private seed;
+    private masterKey;
+    private accountKeys;
+    private walletKeys;
+    init(mnemonic: string | Uint8Array): void;
+    reset(): void;
+    private getAccountKey;
+    getKey(keyPath: string | KeyPath): HDPrivateKey;
+}
+
+export declare interface KeyPath {
+    account: AccountType;
+    type: KeySpace;
+    index: number;
+}
+
+export declare function keyPathToString(account: AccountType, type: KeySpace, index: number): string;
+
+export declare enum KeySpace {
+    RECEIVE = 0,
+    CHANGE = 1
+}
+
+export declare abstract class KVStore {
+    abstract getValue(key: string): Promise<string | null>;
+    abstract setValue(key: string, value: string): Promise<void>;
+    abstract removeValue(key: string): Promise<void>;
+    abstract clearData(): Promise<void>;
+    protected getPrefix(): string;
+    getEncryptedSeed(): Promise<string | null>;
+    saveEncryptedSeed(seed: string): Promise<void>;
+    getVersionCode(): Promise<string | null>;
+    setVersionCode(code: string): Promise<void>;
+    getReleaseNumber(): Promise<string | null>;
+    setReleaseNumber(release: string): Promise<void>;
+    getRostrumParams(): Promise<RostrumParams | undefined>;
+    saveRostrumParams(params: RostrumParams): Promise<void>;
+    removeRostrumParams(): Promise<void>;
+    setHideZeroTokenConfig(hide: boolean): Promise<void>;
+    getHideZeroTokenConfig(): Promise<boolean>;
+    setHideZeroVaultsConfig(hide: boolean): Promise<void>;
+    getHideZeroVaultsConfig(): Promise<boolean>;
+    getSelectedCurrency(): Promise<string>;
+    setSelectedCurrency(currency: string): Promise<void>;
+    getUseBiometric(): Promise<boolean>;
+    setUseBiometric(useBiometric: boolean): Promise<void>;
+    getRequireAuth(): Promise<boolean>;
+    setRequireAuth(requireAuth: boolean): Promise<void>;
+    getReleaseNotesTime(): Promise<number | undefined>;
+    setReleaseNotesTime(time: string): Promise<void>;
+    getIsTestnet(): Promise<boolean>;
+    setIsTestnet(isTestnet: boolean): Promise<void>;
+    getAutoLockSeconds(): Promise<number>;
+    setAutoLockSeconds(autoLock: number): Promise<void>;
+}
+
+export declare const loaderActions: CaseReducerActions<    {
+setLoader: (state: {
+counter: number;
+loading: boolean;
+text?: string | undefined;
+}, action: PayloadAction<Omit<LoaderState, "counter">>) => void;
+}, "loader">;
+
+export declare const loaderReducer: Reducer<LoaderState>;
+
+export declare interface LoaderState {
+    counter: number;
+    loading: boolean;
+    text?: string;
+}
+
+export declare const MAIN_WALLET_ID = -1;
+
+export declare const MAX_INT64 = 9223372036854775807n;
+
+declare type MethodHandler = {
+    resolve: (value: any) => void;
+    reject: (value: any) => void;
+};
+
+export declare interface MovementDetails {
+    asset?: AssetInfo;
+    amount: bigint;
+}
+
+export declare interface NftEntity {
+    token: string;
+    tokenIdHex: string;
+    parentGroup: string;
+    source: string;
+    collection: string;
+}
+
+export declare interface NftPreview {
+    infoJson: string;
+    image: string;
+}
+
+export declare type NotificationAction = {
+    type: 'DAPP_REQUEST';
+    account: number;
+    sessionId: string;
+    payload: string;
+} | {
+    type: 'DISPATCH';
+    actionType: string;
+    payload?: any;
+} | {
+    type: 'NONE';
+};
+
+export declare const notificationsActions: CaseReducerActions<    {
+addNotification: (state: {
+wallet: {
+[x: string]: {
+id: string;
+type: "wallet" | "web3";
+title: string;
+message?: string | undefined;
+createdAt: number;
+action?: {
+type: "DAPP_REQUEST";
+account: number;
+sessionId: string;
+payload: string;
+} | {
+type: "DISPATCH";
+actionType: string;
+payload?: any;
+} | {
+type: "NONE";
+} | undefined;
+};
+};
+web3: {
+[x: string]: {
+id: string;
+type: "wallet" | "web3";
+title: string;
+message?: string | undefined;
+createdAt: number;
+action?: {
+type: "DAPP_REQUEST";
+account: number;
+sessionId: string;
+payload: string;
+} | {
+type: "DISPATCH";
+actionType: string;
+payload?: any;
+} | {
+type: "NONE";
+} | undefined;
+};
+};
+}, action: PayloadAction<AppNotification>) => void;
+removeNotification: (state: {
+wallet: {
+[x: string]: {
+id: string;
+type: "wallet" | "web3";
+title: string;
+message?: string | undefined;
+createdAt: number;
+action?: {
+type: "DAPP_REQUEST";
+account: number;
+sessionId: string;
+payload: string;
+} | {
+type: "DISPATCH";
+actionType: string;
+payload?: any;
+} | {
+type: "NONE";
+} | undefined;
+};
+};
+web3: {
+[x: string]: {
+id: string;
+type: "wallet" | "web3";
+title: string;
+message?: string | undefined;
+createdAt: number;
+action?: {
+type: "DAPP_REQUEST";
+account: number;
+sessionId: string;
+payload: string;
+} | {
+type: "DISPATCH";
+actionType: string;
+payload?: any;
+} | {
+type: "NONE";
+} | undefined;
+};
+};
+}, action: PayloadAction<string>) => void;
+clearAll: (state: {
+wallet: {
+[x: string]: {
+id: string;
+type: "wallet" | "web3";
+title: string;
+message?: string | undefined;
+createdAt: number;
+action?: {
+type: "DAPP_REQUEST";
+account: number;
+sessionId: string;
+payload: string;
+} | {
+type: "DISPATCH";
+actionType: string;
+payload?: any;
+} | {
+type: "NONE";
+} | undefined;
+};
+};
+web3: {
+[x: string]: {
+id: string;
+type: "wallet" | "web3";
+title: string;
+message?: string | undefined;
+createdAt: number;
+action?: {
+type: "DAPP_REQUEST";
+account: number;
+sessionId: string;
+payload: string;
+} | {
+type: "DISPATCH";
+actionType: string;
+payload?: any;
+} | {
+type: "NONE";
+} | undefined;
+};
+};
+}, action: PayloadAction<"wallet" | "web3" | "all">) => void;
+}, "notifications">;
+
+export declare const notificationsReducer: Reducer<NotificationsState>;
+
+export declare interface NotificationsState {
+    wallet: Record<string, AppNotification>;
+    web3: Record<string, AppNotification>;
+}
+
+export declare function parseTokenDataUrl(data?: string): string | null;
+
+export declare interface Price {
+    value: number;
+    change: number;
+}
+
+declare interface RemoveSessionPayload {
+    accountId: number;
+    sessionId: string;
+}
+
+export declare interface RostrumParams {
+    scheme: TransportScheme;
+    host: string;
+    port: number;
+    label: string;
+}
+
+export declare class RostrumService {
+    private readonly kvStore;
+    private client?;
+    constructor(kvStore: KVStore);
+    getFeatures(): Promise<ServerFeatures>;
+    getBlockTip(): Promise<BlockTip>;
+    getBalance(address: string): Promise<Balance>;
+    getTransactionsHistory(address: string, fromHeight?: number): Promise<ITXHistory[]>;
+    getFirstUse(address: string): Promise<IFirstUse>;
+    isAddressUsed(address: string): Promise<boolean>;
+    getTransaction(id: string, verbose?: boolean): Promise<ITransaction>;
+    getUtxo(outpoint: string): Promise<IUtxo>;
+    getNexaUtxos(address: string): Promise<IListUnspentRecord[]>;
+    getTokenUtxos(address: string, token: string): Promise<ITokenUtxo[]>;
+    getTokensBalance(address: string): Promise<Record<string, Balance>>;
+    getTokenGenesis(token: string): Promise<ITokenGenesis>;
+    broadcast(txHex: string): Promise<string>;
+    subscribeHeaders(handler: (block: number) => void): Promise<Error | RequestResponse>;
+    subscribeAddress(address: string, handler: (data: unknown) => void): Promise<Error | RequestResponse>;
+    getLatency(): Promise<number>;
+    connect(params?: RostrumParams): Promise<void>;
+    disconnect(force?: boolean): Promise<boolean>;
+    private execute;
+    private waitForConnection;
+    getCurrentInstance(): Promise<RostrumParams>;
+    static getPredefinedInstances(): RostrumParams[];
+}
+
+export declare interface ServerFeatures {
+    genesis_hash: string;
+    server_version: string;
+}
+
+export declare interface SessionEntity {
+    sessionId: string;
+    accountId: number;
+    uri: string;
+}
+
+export declare type SessionEvent = {
+    type: 'session_added';
+    accountId: number;
+    sessionInfo: SessionInfo;
+} | {
+    type: 'session_removed';
+    accountId: number;
+    sessionId: string;
+} | {
+    type: 'sessions_cleared';
+    accountId: number;
+} | {
+    type: 'new_notification';
+    notification: AppNotification;
+} | {
+    type: 'new_request';
+    request: DappRpcRequest;
+};
+
+export declare interface SessionInfo {
+    details: SessionDetails;
+    appInfo: DAppInfo;
+}
+
+export declare class SessionManager {
+    private readonly walletDb;
+    private readonly keyManager;
+    private readonly providers;
+    private readonly handlers;
+    private removeOnClose;
+    private updateCallback?;
+    private constructor();
+    onUpdate(callback: SessionUpdateCallback): void;
+    private notify;
+    getHandler(request: string): MethodHandler | undefined;
+    add(account: AccountDTO, provider: DAppProvider, sessionInfo: SessionInfo): void;
+    remove(accountId: number, sessionId: string): void;
+    reload(accounts: Map<number, AccountDTO>): Promise<void>;
+    clear(): void;
+    revoke(accountId: number, sessionId: string): Promise<void>;
+    replayMessage(accountId: number, sessionId: string, payload: string): Promise<void>;
+    private registerHandlers;
+}
+
+export declare enum SessionRequestType {
+    SignMessage = "signMessage",
+    AddToken = "addToken",
+    SignTransaction = "signTransaction",
+    SendTransaction = "sendTransaction"
+}
+
+export declare type SessionUpdateCallback = (event: SessionEvent) => void;
+
+export declare const sharedReducers: {
+    loader: Reducer<LoaderState>;
+    dapp: Reducer<DappModalState>;
+    status: Reducer<StatusState>;
+    wallet: Reducer<WalletState>;
+    auth: Reducer<AuthState>;
+    notifications: Reducer<NotificationsState>;
+};
+
+export declare type SharedState = {
+    loader: ReturnType<typeof loaderReducer>;
+    dapp: ReturnType<typeof dappModalReducer>;
+    status: ReturnType<typeof statusReducer>;
+    wallet: ReturnType<typeof walletReducer>;
+    auth: ReturnType<typeof authReducer>;
+    notifications: ReturnType<typeof notificationsReducer>;
+};
+
+export declare const statusActions: CaseReducerActions<    {
+setHeight: (state: {
+status: "Online" | "Offline";
+height: number;
+price: {
+[x: string]: {
+value: number;
+change: number;
+};
+};
+hasNetwork: boolean;
+isSuspended: boolean;
+}, action: PayloadAction<number>) => void;
+setOffline: (state: {
+status: "Online" | "Offline";
+height: number;
+price: {
+[x: string]: {
+value: number;
+change: number;
+};
+};
+hasNetwork: boolean;
+isSuspended: boolean;
+}) => void;
+setHasNetwork: (state: {
+status: "Online" | "Offline";
+height: number;
+price: {
+[x: string]: {
+value: number;
+change: number;
+};
+};
+hasNetwork: boolean;
+isSuspended: boolean;
+}, action: PayloadAction<boolean>) => void;
+setIsSuspended: (state: {
+status: "Online" | "Offline";
+height: number;
+price: {
+[x: string]: {
+value: number;
+change: number;
+};
+};
+hasNetwork: boolean;
+isSuspended: boolean;
+}, action: PayloadAction<boolean>) => void;
+}, "status">;
+
+export declare const statusReducer: Reducer<StatusState>;
+
+export declare interface StatusState {
+    status: "Online" | "Offline";
+    height: number;
+    price: Record<string, Price>;
+    hasNetwork: boolean;
+    isSuspended: boolean;
+}
+
+export declare function stringToKeyPath(path: string): KeyPath;
+
+export declare function sumBalance(balances: Balance[]): Balance;
+
+export declare function sumTokensBalance(balances: Record<string, Balance>[]): Record<string, Balance>;
+
+export declare function tokenAmountToAssetAmount(amount?: string | number | bigint): string;
+
+export declare interface TokenEntity {
+    token: string;
+    tokenIdHex: string;
+    name: string;
+    ticker: string;
+    iconUrl: string;
+    decimals: number;
+    parentGroup: string;
+}
+
+export declare function tokenHexToAddr(token: string): string;
+
+export declare function tokenIdToHex(token: string): string;
+
+export declare interface TransactionDetails {
+    tx: Transaction;
+    send: MovementDetails[];
+    receive: MovementDetails[];
+}
+
+export declare interface TransactionDTO {
+    accountId: number;
+    txIdem: string;
+    txId: string;
+    time: number;
+    height: number;
+    type: TransactionType;
+    fee: string;
+    othersOutputs: AssetMovement[];
+    myOutputs: AssetMovement[];
+    myInputs: AssetMovement[];
+}
+
+export declare interface TransactionEntity {
+    accountId: number;
+    txIdem: string;
+    txId: string;
+    time: number;
+    height: number;
+    type: TransactionType;
+    fee: string;
+    othersOutputs: string;
+    myOutputs: string;
+    myInputs: string;
+}
+
+export declare class TransactionService {
+    private readonly rostrumService;
+    private readonly keyManager;
+    private readonly walletDb;
+    private readonly MAX_INPUTS_OUTPUTS;
+    constructor(rostrumService: RostrumService, keysManager: KeyManager, walletDb: WalletDB);
+    broadcastTransaction(txHex: string): Promise<string>;
+    fetchTransactionsHistory(address: string, fromHeight: number): Promise<{
+        txs: ITXHistory[];
+        lastHeight: number;
+    }>;
+    fetchVaultTransactions(address: string): Promise<TransactionDTO[]>;
+    classifyAndSaveTransaction(accountId: number, txHash: string, myAddresses: string[]): Promise<void>;
+    private classifyTransaction;
+    buildAndSignTransferTransaction(from: AddressKey[], toAddr: string, toChange: string, amount: string, feeFromAmount?: boolean, token?: string, feePerByte?: number, data?: string): Promise<Transaction>;
+    buildAndSignConsolidateTransaction(from: AddressKey[], toChange: string, templateData?: TxTemplateData): Promise<Transaction>;
+    private prepareTransaction;
+    private populateNexaInputsAndChange;
+    private populateTokenInputsAndChange;
+    private finalizeTransaction;
+    printTransactionJson(tx?: Transaction | null): string;
+}
+
+export declare class TransactionTransformer {
+    private readonly rostrumService;
+    private readonly keyManager;
+    private readonly assetService;
+    constructor(rostrumService: RostrumService, keyManager: KeyManager, assetService: AssetService);
+    transformRawTransaction(hex: string, addressKey: AddressKey): Promise<TransactionDetails>;
+    private createContext;
+    private processInputs;
+    private processInput;
+    private processOutputs;
+    private signInputs;
+    private validateAndGetSubscript;
+    private processSignatureCoverage;
+    private checkSignatureCoverage;
+    private processAssetMovements;
+    private processAssetMovement;
+}
+
+export declare type TransactionType = 'receive' | 'send' | 'swap' | 'self';
+
+export declare function transformTokenIconUrl(icon: string, documentUrl: string): string;
+
+export declare function truncateStringMiddle(str?: string, maxLength?: number): string;
+
+export declare interface TxOptions {
+    isConsolidate?: boolean;
+    templateData?: TxTemplateData;
+    feeFromAmount?: boolean;
+}
+
+export declare interface TxTemplateData {
+    templateScript: Script;
+    constraintScript: Script;
+    visibleArgs: any[];
+    publicKey: PublicKey;
+}
+
+export declare const useAccount: (id: number) => Account;
+
+export declare const useAllNotifications: () => AppNotification[];
+
+export declare const useAuth: () => AuthState;
+
+export declare const useBlockHeight: () => number;
+
+export declare const useDAppSession: (account: number, session: string) => SessionInfo;
+
+export declare const useLastAccountId: () => number;
+
+export declare const useMainReceiveAddress: (account: number) => string;
+
+export declare const useSelectedAccount: () => number;
+
+export declare const useTokenBalance: (account: number, tokenIdHex: string) => Balance;
+
+export declare const useVaults: () => Record<string, VaultInfo>;
+
+export declare const useWalletBalance: (account: number) => Balance;
+
+export declare const useWalletNotifications: () => AppNotification[];
+
+export declare const useWeb3Notifications: () => AppNotification[];
+
+export declare function validateAndDecryptMnemonic(encSeed: string, password: string): Promise<string | boolean>;
+
+export declare const VAULT_FIRST_BLOCK = 274710;
+
+export declare const VAULT_SCRIPT_PREFIX = "0014461ad25081cb0119d034385ff154c8d3ad6bdd76";
+
+export declare interface VaultDTO {
+    address: string;
+    idx: number;
+    block: number;
+    height: number;
+    statusHash: string;
+    balance: Balance;
+    tokensBalance: Record<string, Balance>;
+    type: AccountType;
+}
+
+export declare interface VaultEntity {
+    address: string;
+    idx: number;
+    block: number;
+    height: number;
+    statusHash: string;
+    balance: string;
+    tokensBalance: string;
+}
+
+export declare interface VaultInfo {
+    address: string;
+    balance: Balance;
+    block: number;
+    index: number;
+}
+
+export declare const walletActions: CaseReducerActions<    {
+setInitLoad: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<boolean>) => void;
+setSelectedAccount: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<number>) => void;
+setSync: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<boolean>) => void;
+setVault: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<VaultInfo>) => void;
+setVaultBalance: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<{
+address: string;
+balance: Balance;
+}>) => void;
+setAccount: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<Account>) => void;
+setMainAddress: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<string>) => void;
+setAccountBalance: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<{
+id: number;
+balance: Balance;
+tokensBalance: Record<string, Balance>;
+}>) => void;
+setAccountName: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<{
+id: number;
+name: string;
+}>) => void;
+setTokens: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<{
+id: number;
+assets: AssetEntity[];
+}>) => void;
+addToken: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<{
+id: number;
+asset: AssetEntity;
+}>) => void;
+removeToken: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<{
+id: number;
+tokenId: string;
+}>) => void;
+refreshTxs: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}) => void;
+refreshNfts: (state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}) => void;
+addSession(state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<AddSessionPayload>): void;
+removeSession(state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<RemoveSessionPayload>): void;
+clearSessions(state: {
+isAuthorized: boolean;
+selectedAccount: number;
+accounts: {
+[x: number]: {
+id: number;
+name: string;
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+tokensBalance: {
+[x: string]: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+};
+tokens: {
+accountId: number;
+tokenIdHex: string;
+type: AssetType;
+addedTime: number;
+}[];
+sessions: {
+[x: string]: {
+details: {
+version: string;
+relayUrl: string;
+secret: string;
+sessionId: string;
+};
+appInfo: {
+name: string;
+url: string;
+description?: string | undefined;
+icon?: string | undefined;
+};
+};
+};
+};
+};
+vaults: {
+[x: string]: {
+address: string;
+balance: {
+confirmed: string | number;
+unconfirmed: string | number;
+};
+block: number;
+index: number;
+};
+};
+sync: boolean;
+initLoad: boolean;
+txUpdateTrigger: number;
+nftsUpdateTrigger: number;
+}, action: PayloadAction<{
+accountId: number;
+}>): void;
+}, "wallet">;
+
+export declare class WalletCache {
+    private readonly walletDb;
+    private readonly tokens;
+    private readonly nfts;
+    constructor(walletDb: WalletDB);
+    clear(): void;
+    getTokenById(id: string): Promise<TokenEntity | undefined>;
+    getNftById(id: string): Promise<NftEntity | undefined>;
+    removeToken(id: string): void;
+    removeNft(id: string): void;
+}
+
+export declare class WalletDB {
+    private readonly store;
+    private updateCallback?;
+    constructor(store: DBStore);
+    onUpdate(callback: DBUpdateCallback): void;
+    private notify;
+    initSchema(): Promise<boolean>;
+    clearData(): Promise<void>;
+    addLocalTransaction(tx: TransactionEntity): Promise<void>;
+    addAssetTransaction(assetTx: AssetTransactionEntity): Promise<void>;
+    getLocalTransactions(account: number, tokenId?: string): Promise<TransactionEntity[] | undefined>;
+    getPageLocalTransactions(account: number, pageNum: number, pageSize: number, tokenId?: string): Promise<TransactionEntity[] | undefined>;
+    countLocalTransactions(account: number, tokenId?: string): Promise<number>;
+    clearLocalTransactions(account: number): Promise<void>;
+    saveToken(account: number, token: TokenEntity): Promise<void>;
+    getLocalTokens(account: number): Promise<AssetEntity[] | undefined>;
+    getToken(id: string): Promise<TokenEntity | undefined>;
+    deleteToken(account: number, tokenId: string): Promise<void>;
+    saveNft(asset: AssetEntity, nft: NftEntity): Promise<void>;
+    getLocalNfts(account: number, pageNum: number, pageSize: number): Promise<AssetEntity[] | undefined>;
+    getLocalNft(id: string): Promise<NftEntity | undefined>;
+    deleteNft(account: number, tokenId: string, notify?: boolean): Promise<void>;
+    countLocalNfts(account: number): Promise<number>;
+    isNftExist(id: string): Promise<boolean>;
+    saveAsset(asset: AssetEntity, notifyNft?: boolean): Promise<void>;
+    removeAsset(account: number, id: string): Promise<void>;
+    isAssetExistForAccount(account: number, id: string): Promise<boolean>;
+    saveAccount(account: AccountDTO): Promise<void>;
+    getAccounts(): Promise<AccountDTO[]>;
+    countAccounts(): Promise<number>;
+    updateAccountName(account: number, name: string): Promise<void>;
+    saveSession(session: SessionEntity): Promise<void>;
+    getAccountSessions(accountId: number): Promise<SessionEntity[]>;
+    removeSession(sessionId: string): Promise<void>;
+    saveAddress(address: AddressDTO): Promise<void>;
+    getReceiveAddresses(): Promise<AddressDTO[]>;
+    getChangeAddresses(): Promise<AddressDTO[]>;
+    countAddresses(): Promise<number>;
+    getVaults(): Promise<VaultDTO[]>;
+    saveVault(vault: VaultDTO): Promise<void>;
+}
+
+export declare type WalletEvent = {
+    type: 'new_tip';
+    tip: number;
+} | {
+    type: 'new_account';
+    account: Account;
+} | {
+    type: 'new_vault';
+    vault: VaultInfo;
+} | {
+    type: 'discover_wallet';
+    loading: boolean;
+} | {
+    type: 'load_wallet';
+    loading: boolean;
+} | {
+    type: 'sync_wallet';
+    loading: boolean;
+} | {
+    type: 'account_balance_updated';
+    accountId: number;
+    balance: Balance;
+    tokensBalance: Record<string, Balance>;
+} | {
+    type: 'vault_balance_updated';
+    address: string;
+    balance: Balance;
+} | {
+    type: 'main_address_updated';
+    address: string;
+};
+
+export declare class WalletManager {
+    private readonly keyManager;
+    private readonly kvStore;
+    private readonly walletDb;
+    private readonly rostrumService;
+    private readonly assetService;
+    private readonly transactionService;
+    private readonly sessionManager;
+    private static readonly GAP_LIMIT;
+    private static readonly DEBOUNCE_MS;
+    private addressResolvers;
+    accounts: Map<number, AccountDTO>;
+    accountsAddressToId: Map<string, number>;
+    receiveAddresses: AddressDTO[];
+    changeAddresses: AddressDTO[];
+    vaults: Map<string, VaultDTO>;
+    private pendingUpdates;
+    private updateTimer?;
+    private updateCallback?;
+    private readonly discoveryService;
+    constructor(keyManager: KeyManager, kvStore: KVStore, walletDb: WalletDB, rostrumService: RostrumService, assetService: AssetService, transactionService: TransactionService, sessionManager: SessionManager);
+    onUpdate(callback: WalletUpdateCallback): void;
+    private notify;
+    private getAllAddresses;
+    getMainAddresses(): AddressDTO[];
+    getReceiveAddress(): string;
+    getChangeAddress(accountId?: number): string;
+    getUsedAddressKeys(accountId?: number): AddressKey[];
+    reloadRostrum(params: RostrumParams): Promise<void>;
+    initRostrum(): Promise<void>;
+    initialize(): Promise<void>;
+    private discoverWallet;
+    private loadWallet;
+    private initialSync;
+    reconnectSync(): Promise<void>;
+    private initState;
+    private deriveAddresses;
+    private deriveAccounts;
+    private saveAddresses;
+    private saveAccounts;
+    private subscribeAddresses;
+    private onSubscribeEvent;
+    private registerUpdate;
+    private processPendingUpdates;
+    private postProcessWalletUpdate;
+    private postProcessAccountUpdate;
+    private fetchAndUpdateAddress;
+    private fetchAndUpdateAccount;
+    private fetchAndUpdateVault;
+    private checkGapLimit;
+    addNewAccount(id: number, name: string): Promise<void>;
+    updateAccountName(id: number, name: string): Promise<void>;
+    rescanAccount(id: number): void;
+    getVaultNextIndex(): number;
+    addNewVault(address: string, block: number, index: number): Promise<void>;
+    private addVault;
+    rescanVaults(): Promise<boolean>;
+    private isVaultAddress;
+    private isAccountAddress;
+    private isMainAddress;
+}
+
+export declare const walletReducer: Reducer<WalletState>;
+
+export declare interface WalletState {
+    isAuthorized: boolean;
+    selectedAccount: number;
+    accounts: Record<number, Account>;
+    vaults: Record<string, VaultInfo>;
+    sync: boolean;
+    initLoad: boolean;
+    txUpdateTrigger: number;
+    nftsUpdateTrigger: number;
+}
+
+export declare type WalletUpdateCallback = (event: WalletEvent) => void;
+
+export { }