@broxus/tvm-connect/lib/esm/services/TvmWalletService.d.ts

Nekoton-compatible wallets connector.

import { AbstractStore, type Forceable, type NativeCurrency, type TvmNetworkConfig } from '@broxus/js-core';
import { type AddNetwork, type Address, type AssetType, type FullContractState, type Network, type ProviderProperties, ProviderRpcClient, type Subscriber } from 'everscale-inpage-provider';
import { type IReactionDisposer } from 'mobx';
import { type ConnectOptions, type DisconnectOptions, type NekotonConnector } from '../core/NekotonConnector';
import { type TvmWalletProviderConfig } from '../types';
export interface TvmWalletServiceCtorParams {
    /**
     * Should the service be initialized in the background?
     * @default true
     */
    autoInit?: boolean;
    /**
     * Standalone connection (connection that`s not require permissions) params
     */
    connectionParams?: {
        factory?: (network?: TvmNetworkConfig) => ProviderRpcClient;
        provider?: ProviderProperties['provider'];
        type?: 'jrpc' | 'proto';
    };
    defaultNetworkId?: number;
    /**
     * List of supported networks
     */
    networks?: Readonly<TvmNetworkConfig[]>;
    providerId?: string;
    /**
     * List of supported Providers
     */
    providers?: Readonly<TvmWalletProviderConfig[]>;
}
export interface TvmWalletServiceData {
    contractState?: FullContractState;
    networks: Readonly<TvmNetworkConfig[]>;
}
export interface TvmWalletServiceState {
    isSyncing?: boolean;
    providerId?: string;
}
export declare class TvmWalletService extends AbstractStore<TvmWalletServiceData, TvmWalletServiceState> {
    protected readonly params?: Readonly<TvmWalletServiceCtorParams> | undefined;
    readonly name = "TvmWalletService";
    constructor(params?: Readonly<TvmWalletServiceCtorParams> | undefined);
    /**
     * Define current provider connector
     * @returns {NekotonConnector|undefined}
     */
    get connector(): NekotonConnector | undefined;
    /**
     * Initialize the wallet connection manually
     * @returns {Promise<ProviderRpcClient | undefined>}
     */
    init(): Promise<ProviderRpcClient | undefined>;
    /**
     * Manually connect to the wallet
     * @returns {Promise<void>}
     */
    connect(networkIdOParams?: number | AddNetwork, options?: ConnectOptions): Promise<void>;
    /**
     * Manually disconnect from the wallet
     * @param {DisconnectOptions} [options]
     * @returns {Promise<void>}
     */
    disconnect(options?: DisconnectOptions): Promise<void>;
    /**
     * Add custom token asset to the TVM Wallet
     * @param {Address | string} address
     * @param {AssetType} [type]
     */
    addAsset(address: Address | string, type?: AssetType): Promise<boolean | undefined>;
    /**
     * Add new network to the wallet.
     * Supported since version `0.3.40` of the `everscale-inpage-provider`
     * @param {AddNetwork} network
     * @param {boolean} switchNetwork
     * @returns {Promise<Network | null>}
     */
    addNetwork(network: AddNetwork, switchNetwork?: boolean): Promise<Network | null>;
    /**
     * Switch to network by the given networkId or network params.
     * Supported since version `0.3.40` of the `everscale-inpage-provider`
     * @param {number | AddNetwork} networkIdOParams
     * @returns {Promise<Network | null>}
     */
    switchNetwork(networkIdOParams: number | AddNetwork): Promise<Network | null>;
    /**
     * An independent RPC connection that allows you to receive data from the blockchain without being
     * able to send transactions.
     *
     * This connection does not require `accountInteraction` permissions.
     * @returns {ProviderRpcClient}
     */
    get connection(): ProviderRpcClient;
    /**
     * A Provider that requires a `basic` and `accountInteraction` permissions for the ability to send transactions.
     * @returns {ProviderRpcClient|undefined}
     */
    get provider(): ProviderRpcClient | undefined;
    /**
     * Returns computed wallet contract state
     * @returns {TvmWalletServiceData["contractState"]}
     */
    get contract(): TvmWalletServiceData['contractState'];
    /**
     * The list of the supported networks
     * @returns {TvmWalletServiceData["networks"]}
     */
    get networks(): TvmWalletServiceData['networks'];
    /**
     * Returns `true` if wallet contract is updating
     * @returns {TvmWalletServiceState["isSyncing"]}
     */
    get isSyncing(): TvmWalletServiceState['isSyncing'];
    /**
     * A unique identifier of the connected wallet (provider)
     * @returns {TvmWalletServiceState["providerId"]}
     */
    get providerId(): TvmWalletServiceState['providerId'];
    /**
     * Returns computed wallet address value
     * @returns {Address|undefined}
     */
    get address(): Address | undefined;
    /**
     * Returns computed wallet normalized balance value
     * @returns {FullContractState["balance"]}
     */
    get balance(): FullContractState['balance'];
    /**
     * Returns network native currency
     * @returns {NativeCurrency<Address>}
     */
    get currency(): Readonly<NativeCurrency<Address>>;
    /**
     * Whether provider is available.
     *
     * That means extension is installed and activated, else `false`
     * @returns {boolean}
     */
    get hasProvider(): boolean;
    /**
     * Returns `true` if wallet is connected
     * @returns {boolean}
     */
    get isConnected(): boolean;
    /**
     * Returns `true` if installed wallet has outdated version
     */
    get isOutdated(): boolean;
    /**
     * Returns `true` if connection to RPC is initialized and connected
     * @returns {boolean}
     */
    get isReady(): boolean;
    /**
     * Checks for supported network
     * @returns {boolean}
     */
    get isUnsupportedNetwork(): boolean;
    /**
     * Returns current network configuration
     * @returns {TvmNetworkConfig|undefined}
     */
    get network(): TvmNetworkConfig | undefined;
    /**
     * Returns details about current connected provider
     * @returns {TvmWalletProviderConfig["info"]|undefined}
     */
    get providerInfo(): TvmWalletProviderConfig['info'] | undefined;
    /**
     * The list of the supported providers
     * @returns {Readonly<TvmWalletServiceCtorParams["providers"]>}
     */
    get providers(): Readonly<TvmWalletProviderConfig[]>;
    /**
     * Returns computed account
     * @returns {NekotonConnector["account"]}
     */
    get account(): NekotonConnector['account'];
    /**
     * Returns current network chain id
     * @returns {NekotonConnector["chainId"]}
     */
    get chainId(): NekotonConnector['chainId'];
    /**
     * Returns `true` if wallet is connecting
     * @returns {NekotonConnector["isConnecting"]}
     */
    get isConnecting(): NekotonConnector['isConnecting'];
    /**
     * Returns `true` if wallet is disconnecting
     * @returns {NekotonConnector["isDisconnecting"]}
     */
    get isDisconnecting(): NekotonConnector['isDisconnecting'];
    /**
     * Returns `true` if wallet is initialized
     * @returns {NekotonConnector["isInitialized"]}
     */
    get isInitialized(): NekotonConnector['isInitialized'];
    /**
     * Returns `true` if wallet is initializing
     * @returns {NekotonConnector["isInitializing"]}
     */
    get isInitializing(): NekotonConnector['isInitializing'];
    protected syncContractState(options?: Forceable): Promise<void>;
    /**
     * Trying to resolve TVM Wallet connection
     * @protected
     */
    protected _init(): Promise<void>;
    protected watch(): Promise<void>;
    protected unwatch(): Promise<void>;
    protected accountDisposer: IReactionDisposer | undefined;
    protected contractSubscriber: Subscriber | undefined;
    protected networkDisposer: IReactionDisposer | undefined;
}