@broxus/js-core/dist/esm/models/tvm-token/TvmToken.d.ts

MobX-based JavaScript Core library

import { type ProviderRpcClient, type Subscriber, Address } from 'everscale-inpage-provider';
import { type SmartContractWatchCallback, SmartContractModel } from '../../core';
import { type TvmTokenWalletCreateOptions, TvmTokenWallet } from '../../models/tvm-token-wallet';
import { TvmTokenUtils } from '../../models/tvm-token/TvmTokenUtils';
import { type Forceable, type ObjectLiteral, type Silentable, type Syncable, type TokenLikeModel, type TokenRaw, type Watchable } from '../../types';
export interface TvmTokenCtorData extends Omit<TvmTokenData, 'address'> {
    address: Address | string;
}
export interface TvmTokenCtorOptions {
    ttl?: number;
    watchDebounceDelay?: number;
}
export interface TvmTokenCreateOptions extends Syncable, TvmTokenCtorOptions, Watchable {
    watchCallback?: VoidFunction;
}
export interface TvmTokenData extends Omit<TokenRaw<Address>, 'tags'> {
    burnByRootDisabled?: boolean;
    burnPaused?: boolean;
    mintDisabled?: boolean;
    rootOwnerAddress?: Address;
    tags?: string[] | Set<string>;
    totalSupply?: string;
}
interface SyncOptions extends Forceable, Silentable {
    ttl?: number;
}
export declare class TvmToken<T extends TvmTokenData | ObjectLiteral = TvmTokenData> extends SmartContractModel<T & TvmTokenData> implements TokenLikeModel<Address> {
    protected readonly _connection: ProviderRpcClient;
    protected readonly options?: Readonly<TvmTokenCtorOptions> | undefined;
    protected readonly _provider?: ProviderRpcClient | undefined;
    static Utils: typeof TvmTokenUtils;
    static Wallet: typeof TvmTokenWallet;
    /**
     * @template T
     * @param {ProviderRpcClient} _connection
     *   Standalone RPC client that doesn't require connection to the TVM wallet provider
     * @param {TvmTokenCtorData['address'] | Readonly<T & TvmTokenCtorData>} data
     *   TvmToken root address or an object of a token attributes (e.g. decimals, symbol, name)
     * @param {Readonly<GaugeAccountCtorOptions>} [options]
     *   (optional) TvmToken Smart Contract Model options
     * @param {ProviderRpcClient} [_provider]
     *   (optional) RPC provider that require connection to the TVM wallet
     */
    constructor(_connection: ProviderRpcClient, data: TvmTokenCtorData['address'] | Readonly<T & TvmTokenCtorData>, options?: Readonly<TvmTokenCtorOptions> | undefined, _provider?: ProviderRpcClient | undefined);
    /**
     * @template {TvmTokenCtorData | ObjectLiteral} V
     * @param {ProviderRpcClient} connection
     *   Standalone RPC client that doesn't require connection to the TVM wallet provider
     * @param {TvmTokenCtorData['address'] | Readonly<V & TvmTokenCtorData>} data
     *   TvmToken root address or an object of a token attributes (e.g. decimals, symbol, name)
     * @param {Readonly<TvmTokenCreateOptions>} [options]
     *   (optional) TvmToken Smart Contract Model options
     * @param {ProviderRpcClient} [provider]
     *   (optional) RPC provider that require connection to the TVM wallet
     */
    static create<V extends TvmTokenCtorData | ObjectLiteral = TvmTokenCtorData>(connection: ProviderRpcClient, data: TvmTokenCtorData['address'] | Readonly<V & TvmTokenCtorData>, options?: Readonly<TvmTokenCreateOptions>, provider?: ProviderRpcClient): Promise<TvmToken<V>>;
    sync(options?: SyncOptions): Promise<void>;
    watch(callback?: SmartContractWatchCallback<T & TvmTokenData>): Promise<Subscriber>;
    unwatch(): Promise<void>;
    wallet(ownerAddress: Address | string, options?: TvmTokenWalletCreateOptions): Promise<TvmTokenWallet>;
    walletOf(ownerAddress: Address | string): Promise<Address>;
    balance(ownerAddress: Address | string): Promise<string | undefined>;
    /**
     * Returns token `address` as a string.
     * @returns {string}
     */
    get root(): string;
    /**
     * Returns token `chainId`. Basically describes in the assets manifest.
     * @returns {TvmTokenData['chainId']}
     */
    get chainId(): TvmTokenData['chainId'];
    /**
     * Returns token `decimals`. Can be described in the assets manifest or
     * retrieved from a blockchain by a token address
     * (use **TvmToken.Utils.getDecimals(address)**).
     * @returns {TvmTokenData['decimals']}
     */
    get decimals(): TvmTokenData['decimals'];
    /**
     * Returns token `logoURI`. Basically describes in the assets manifest.
     * @returns {TvmTokenData['logoURI']}
     */
    get icon(): TvmTokenData['logoURI'];
    /**
     * Returns token `name`. Can be described in the assets manifest or
     * retrieved from a blockchain by a token address
     * (use **TvmToken.Utils.getName(address)**)
     * @returns {TvmTokenData['name']}
     */
    get name(): TvmTokenData['name'];
    /**
     * Returns token `symbol`. Can be described in the assets manifest or
     * retrieved from a blockchain by a token address
     * (use **TvmToken.Utils.getSymbol(address)**)
     * @returns {TvmTokenData['symbol']}
     */
    get symbol(): TvmTokenData['symbol'];
    /**
     * Returns token `rootOwnerAddress`. Can be described in the assets manifest or
     * retrieved from a blockchain by a token address
     * (use **TvmToken.Utils.rootOwnerAddress(address)**)
     * @returns {TvmTokenData['rootOwnerAddress']}
     */
    get rootOwnerAddress(): TvmTokenData['rootOwnerAddress'];
    /**
     * Returns token `totalSupply`. Can be described in the assets manifest or
     * retrieved from a blockchain by a token address
     * (use **TvmToken.Utils.totalSupply(address)**)
     * @returns {TvmTokenData['totalSupply']}
     */
    get totalSupply(): TvmTokenData['totalSupply'];
    /**
     * Returns token `vendor` as organization slug. Basically describes in the assets manifest.
     * @returns {TvmTokenData['vendor']}
     */
    get vendor(): TvmTokenData['vendor'];
    /**
     * Returns token `verified` flag. Basically describes in the assets manifest.
     * @returns {TvmTokenData['verified']}
     */
    get verified(): TvmTokenData['verified'];
    get burnByRootDisabled(): TvmTokenData['burnByRootDisabled'];
    get burnPaused(): TvmTokenData['burnPaused'];
    get mintDisabled(): TvmTokenData['mintDisabled'];
    /**
     * Get value by the given key
     * @param {K extends keyof T & string} key
     */
    get<K extends keyof T & string>(key: K): T[K];
    /**
     * Returns copy of the current token
     */
    clone(): TvmToken<T>;
}
export {};