@broxus/js-bridge-essentials/dist/esm/services/BridgeAssetsService.d.ts

Bridge JavaScript Essentials library

import { AbstractStore, type TokenRaw, type TvmBasedNetwork, TvmToken } from '@broxus/js-core';
import { type Connection } from '@solana/web3.js';
import { type TonClient } from '@ton/ton';
import { type ProviderRpcClient } from 'everscale-inpage-provider';
import type Web3 from 'web3';
import { EvmToken, EvmTonPipelineConfig, EvmTvmPipelineConfig, SolTvmPipelineConfig, SolanaToken, TonEvmPipelineConfig, TonToken, TvmEvmPipelineConfig, TvmSolPipelineConfig } from '../models';
import { type CurrencyRaw, type EvmBasedNetwork, type NetworkConfig, type NetworkType, type SolanaNetwork, TokenType, type TonBasedNetwork } from '../types';
export interface BridgeRawAssetVault {
    chainId: string;
    ethereumConfiguration: string;
    vault: string;
}
export interface BridgeRawAsset {
    proxy: string;
    vaults: BridgeRawAssetVault[];
}
export interface BridgeRawSolanaAsset {
    chainId: string;
    proxy: string;
    solanaConfiguration: string;
    tvmConfiguration: string;
    vault: string;
}
export interface BridgeRawAssets {
    evm_tvm: BridgeRawAsset;
    tvm_evm: BridgeRawAsset;
    solana_tvm: BridgeRawSolanaAsset;
    tvm_solana: BridgeRawSolanaAsset;
    evm_ton: BridgeRawAsset;
    ton_evm: BridgeRawAsset;
}
export interface BridgeAssetsManifest {
    name: string;
    multitoken: BridgeRawAssets;
}
export type AssetKeyLiteral<T extends NetworkType = NetworkType> = `${T}_${string}_${string}`;
export interface BridgeAssetAttributes<T extends NetworkType = NetworkType> {
    key: AssetKeyLiteral<T>;
    tags?: Set<string>;
    wrappedLogoURI?: string;
    wrappedName?: string;
    wrappedSymbol?: string;
}
export interface SolanaFeeInfo {
    divisor: number;
    multiplier: number;
}
export interface SolanaTokenKind {
    mint: string;
    vault: string;
}
export interface EverTokenKind {
    decimals: number;
    mint: string;
    token: string;
}
export interface SolanaTokenSettings {
    account_kind: {
        TokenSettings: number[];
    };
    deposit_limit: string;
    emergency: boolean;
    fee_deposit_info: SolanaFeeInfo;
    fee_supply: number;
    fee_withdrawal_info: SolanaFeeInfo;
    is_initialized: boolean;
    kind: {
        Solana: SolanaTokenKind;
    } | {
        Ever: EverTokenKind;
    };
    name: string;
    symbol: string;
    withdrawal_daily_amount: string;
    withdrawal_daily_limit: string;
    withdrawal_epoch: string;
    withdrawal_limit: string;
}
export type EvmBridgeAsset = EvmToken<BridgeAssetAttributes<EvmBasedNetwork>>;
export type TvmBridgeAsset = TvmToken<BridgeAssetAttributes<TvmBasedNetwork>>;
export type TonBridgeAsset = TonToken<BridgeAssetAttributes<TonBasedNetwork>>;
export type SolanaBridgeAsset = SolanaToken<BridgeAssetAttributes<SolanaNetwork>>;
export type BridgeAsset = EvmBridgeAsset | TvmBridgeAsset | SolanaBridgeAsset | TonBridgeAsset;
export interface ImportedBridgeAsset extends Omit<BridgeAssetAttributes, 'tags'> {
    chainId: string;
    decimals: number;
    icon: string;
    logoURI: string;
    name: string;
    root: string;
    symbol: string;
    tags: string[];
}
export interface BridgeAssetsServiceCtorParams {
    assetsUrlMap: {
        [chainId: string]: string;
    };
    currenciesListUrl?: string;
    getEvmProvider?: () => Web3 | undefined;
    getSolConnection?: () => Connection | undefined;
    getTonConnection?: () => TonClient | undefined;
    getTvmProvider?: () => ProviderRpcClient | undefined;
    networks?: Readonly<NetworkConfig[]>;
    tokensListsUrls?: {
        [vendor: string]: string[];
    };
}
export interface BridgeAssetsServiceData {
    assets: Map<string, BridgeRawAssets>;
    currencies: CurrencyRaw<string>[];
    externals: string[];
    rawTokens: TokenRaw<string>[];
    tokens: BridgeAsset[];
}
export interface BridgeAssetsServiceState {
    isAssetsFetched: boolean;
    isBuilt: boolean;
    isFetching: boolean;
    isTokensFetched: boolean;
}
export declare class BridgeAssetsService extends AbstractStore<BridgeAssetsServiceData, BridgeAssetsServiceState> {
    protected readonly params: Readonly<BridgeAssetsServiceCtorParams>;
    constructor(params: Readonly<BridgeAssetsServiceCtorParams>);
    init(): Promise<void>;
    protected build(): Promise<void>;
    get assets(): BridgeAssetsServiceData['assets'];
    get tokens(): BridgeAssetsServiceData['tokens'];
    get isFetching(): BridgeAssetsServiceState['isFetching'];
    /**
     * Returns token by the given `networkType`, `chainId` and token `root` address.
     * @param {NetworkType} networkType
     * @param {string} chainId
     * @param {string} root
     * @returns {BridgeAsset}
     */
    get(networkType: EvmBasedNetwork, chainId: string, root: string): EvmBridgeAsset | undefined;
    get(networkType: TvmBasedNetwork, chainId: string, root: string): TvmBridgeAsset | undefined;
    get(networkType: TonBasedNetwork, chainId: string, root: string, lowercase?: boolean): TonBridgeAsset | undefined;
    get(networkType: SolanaNetwork, chainId: string, root: string, lowercase?: boolean): SolanaBridgeAsset | undefined;
    getByRoot(root: string): BridgeAsset | undefined;
    getByKey(root: string): BridgeAsset | undefined;
    /**
     * Check if token was stored to the cache.
     * @param {string} key
     * @returns {boolean}
     */
    has(key: string): boolean;
    /**
     * Add a new token to the tokens list.
     * @param {BridgeAsset} token
     */
    add(token: BridgeAsset): void;
    /**
     * Remove token from the tokens list
     * @param {BridgeAsset} token
     */
    remove(token: BridgeAsset): void;
    /**
     * Returns the minimum required pipeline configuration for TVM - Evm transfers.
     * @param {string} root - TVM token root
     * @param {string} sourceId - source TVM network chain id
     * @param {string} targetId - target EVM network chain id
     * @returns {Promise<SolTvmPipelineConfig | undefined>}
     */
    resolveTvmEvmPipeline(root: string, sourceId: string, targetId: string): Promise<TvmEvmPipelineConfig | undefined>;
    /**
     * Returns the minimum required pipeline configuration for Solana - TVM transfers.
     * @param {string} root - EVM token root
     * @param {string} sourceId - source EVM network chain id
     * @param {string} targetId - target TVM network chain id
     * @param {BridgeAsset} fallbackAsset
     * @returns {Promise<SolTvmPipelineConfig | undefined>}
     */
    resolveEvmTvmPipeline(root: string, sourceId: string, targetId: string, fallbackAsset?: BridgeAsset): Promise<EvmTvmPipelineConfig | undefined>;
    /**
     * Returns the minimum required pipeline configuration for TVM - Solana transfers.
     * @param {string} root - TVM token root
     * @param {string} sourceId - source Solana network chain id
     * @param {string} targetId - target TVM network chain id
     * @returns {Promise<SolTvmPipelineConfig | undefined>}
     */
    resolveTvmSolPipeline(root: string, sourceId: string, targetId: string): Promise<TvmSolPipelineConfig | undefined>;
    /**
     * Returns the minimum required pipeline configuration for Solana - TVM transfers.
     * @param {string} root - Solana mint address
     * @param {string} sourceId - source Solana network chain id
     * @param {string} targetId - target TVM network chain id
     * @returns {Promise<SolTvmPipelineConfig | undefined>}
     */
    resolveSolTvmPipeline(root: string, sourceId: string, targetId: string): Promise<SolTvmPipelineConfig | undefined>;
    /**
     * Returns the minimum required pipeline configuration for TON - EVM transfers.
     * @param {string} root - TON or TVM-like (TON raw) token root
     * @param {string} sourceId - source TON network chain id
     * @param {string} targetId - target EVM network chain id
     * @returns {Promise<SolTvmPipelineConfig | undefined>}
     */
    resolveTonEvmPipeline(root: string, sourceId: string, targetId: string): Promise<TonEvmPipelineConfig | undefined>;
    /**
     * Returns the minimum required pipeline configuration for EVM - TON transfers.
     * @param {string} root - EVM token root
     * @param {string} sourceId - source EVM network chain id
     * @param {string} targetId - target TON network chain id
     * @param {BridgeAsset} fallbackAsset
     * @returns {Promise<SolTvmPipelineConfig | undefined>}
     */
    resolveEvmTonPipeline(root: string, sourceId: string, targetId: string, fallbackAsset?: BridgeAsset): Promise<EvmTonPipelineConfig | undefined>;
    resolveEvmAsset(root: string, chainId: string, fallbackAsset?: BridgeAsset): Promise<EvmBridgeAsset>;
    resolveTvmAsset(root: string, chainId: string, fallbackAsset?: BridgeAsset): Promise<TvmBridgeAsset>;
    resolveTonAsset(root: string, chainId: string, fallbackAsset?: BridgeAsset): Promise<TonBridgeAsset>;
    resolveSolanaAsset(root: string, chainId: string, fallbackAsset?: BridgeAsset): Promise<SolanaBridgeAsset>;
    isNativeCurrency(root: string): boolean;
    /**
     * Returns generated pipeline type
     * @param {string} proxy
     * @param {NetworkType} sourceType
     * @param sourceId
     * @param {NetworkType} target
     */
    getPipelineType(proxy: string, sourceType: NetworkType, sourceId: string, target: NetworkType): TokenType | undefined;
    get isReady(): boolean;
    isCustomToken(root: string): boolean;
    isWhitelisted(root: string): boolean;
    /**
     * Returns tokens map where key is a token root address.
     * @protected
     */
    protected get _byKey(): Record<string, BridgeAsset>;
    protected get _byRoot(): Record<string, BridgeAsset>;
}