@broxus/js-core/dist/esm/models/dex/Dex.d.ts

MobX-based JavaScript Core library

import { type Address, type DecodeEventParams, type DecodeTransactionParams, type ProviderRpcClient, type SendInternalParams, type Subscriber, type Transaction } from 'everscale-inpage-provider';
import { SmartContractModel } from '../../core';
import { type DexRootAbi } from '../../models/dex/abi';
import { type DexDecodedEvent, type DexDecodedTransaction, type DexDeployAccountAbiParams, type DexDeployPairAbiParams, type DexDeployPoolAbiParams, type DexExpectedAccountAddressAbiParams, type DexExpectedPairAddressAbiParams, type DexExpectedPoolAddressAbiParams, DexUtils } from '../../models/dex/DexUtils';
import { type DexPoolType } from '../../models/dex/types';
import { type CallId, type Forceable, type SendMessageCallback, type Silentable, type Syncable, type TransactionCallbacks, type TransactionFailureReason, type TransactionSentDetails, type TransactionSuccessResult, type Watchable } from '../../types';
type DexCallbacks<SendParams = any, SuccessParams = any, FailureParams = any> = SendMessageCallback<SendParams> & TransactionCallbacks<TransactionSuccessResult<SuccessParams>, TransactionFailureReason<FailureParams>, TransactionSentDetails>;
export interface DexDeployAccountSuccessResult extends CallId {
    dexAccountAddress: Address;
}
export interface DexDeployAccountCallbacks extends DexCallbacks<unknown, DexDeployAccountSuccessResult> {
}
export interface DexDeployAccountParams extends DexDeployAccountAbiParams, Partial<CallId>, DexDeployAccountCallbacks {
}
export interface DexDeployPairSuccessResult {
    leftRootAddress: Address;
    pairAddress: Address;
    poolType: DexPoolType;
    rightRootAddress: Address;
}
export interface DexDeployPairCallbacks extends DexCallbacks<unknown, DexDeployPairSuccessResult> {
}
export interface DexDeployPairParams extends DexDeployPairAbiParams, Partial<CallId>, DexDeployPairCallbacks {
    expectedAddress?: Address | string;
}
export interface DexDeployPoolSuccessResult {
    poolAddress: Address;
    poolType: DexPoolType;
    roots: Address[];
}
export interface DexDeployPoolCallbacks extends DexCallbacks<unknown, DexDeployPoolSuccessResult> {
}
export interface DexDeployPoolParams extends DexDeployPoolAbiParams, Partial<CallId>, DexDeployPoolCallbacks {
    expectedAddress?: Address | string;
}
export interface DexCtorOptions {
    ttl?: number;
    watchDebounceDelay?: number;
}
export interface DexCreateOptions extends DexCtorOptions, Syncable, Watchable {
    watchCallback?: VoidFunction;
}
export interface DexData {
    manager: Address;
    owner: Address;
    vault: Address;
}
interface SyncOptions extends Forceable, Silentable {
    ttl?: number;
}
export declare class Dex extends SmartContractModel<DexData> {
    protected readonly _connection: ProviderRpcClient;
    protected readonly options?: Readonly<DexCtorOptions> | undefined;
    protected readonly _provider?: ProviderRpcClient | undefined;
    static Utils: typeof DexUtils;
    /**
     * @param {ProviderRpcClient} _connection Standalone RPC client that doesn't require connection to the TVM wallet provider
     * @param {Address | string} address DexRoot root address
     * @param {Readonly<DexCtorOptions>} [options] (optional) DexRoot Smart Contract Model options
     * @param {ProviderRpcClient} [_provider] (optional) RPC provider that require connection to the TVM wallet
     */
    constructor(_connection: ProviderRpcClient, address: Address | string, options?: Readonly<DexCtorOptions> | undefined, _provider?: ProviderRpcClient | undefined);
    /**
     * @param {ProviderRpcClient} connection Standalone RPC client that doesn't require connection to the TVM wallet provider
     * @param {Address | string} address DexRoot root address
     * @param {Readonly<DexCreateOptions>} [options] (optional) DexRoot Smart Contract Model options
     * @param {ProviderRpcClient} [provider] (optional) RPC provider that require connection to the TVM wallet
     */
    static create(connection: ProviderRpcClient, address: Address | string, options?: Readonly<DexCreateOptions>, provider?: ProviderRpcClient): Promise<Dex>;
    sync(options?: SyncOptions): Promise<void>;
    watch(callback?: VoidFunction): Promise<Subscriber>;
    unwatch(): Promise<void>;
    deployAccount(params: DexDeployAccountParams, args?: Partial<SendInternalParams>): Promise<Transaction | undefined>;
    /**
     * Stream-based **DexPair** deployment request
     * @param {DexDeployPairParams} params
     * @param {Partial<SendInternalParams>} args
     * @return {Promise<Transaction | undefined>}
     */
    deployPair(params: DexDeployPairParams, args?: Partial<SendInternalParams>): Promise<Transaction | undefined>;
    /**
     * Stream-based **DexStablePool** deployment request
     * @param {DexDeployPoolParams} params
     * @param {Partial<SendInternalParams>} args
     * @return {Promise<Transaction | undefined>}
     */
    deployStablePool(params: DexDeployPoolParams, args?: Partial<SendInternalParams>): Promise<Transaction | undefined>;
    getExpectedAccountAddress(params: DexExpectedAccountAddressAbiParams): Promise<Address>;
    getExpectedPairAddress(params: DexExpectedPairAddressAbiParams): Promise<Address>;
    getExpectedPoolAddress(params: DexExpectedPoolAddressAbiParams): Promise<Address>;
    get manager(): DexData['manager'];
    get owner(): DexData['owner'];
    get vault(): DexData['vault'];
    decodeEvent(args: DecodeEventParams<typeof DexRootAbi>): Promise<DexDecodedEvent | undefined>;
    decodeTransaction(args: DecodeTransactionParams<typeof DexRootAbi>): Promise<DexDecodedTransaction | undefined>;
    decodeTransactionEvents(transaction: Transaction): Promise<DexDecodedEvent[]>;
}
export {};