@broxus/js-core/dist/esm/models/dex-pool/DexPoolUtils.js

MobX-based JavaScript Core library

import { DexPoolType } from '../../models/dex';
import { DexPairUtils } from '../../models/dex-pair';
import { DexStablePairUtils } from '../../models/dex-stable-pair';
import { DexStablePoolUtils } from '../../models/dex-stable-pool';
import { getFullContractState, resolveTvmAddress } from '../../utils';
export class DexPoolUtils {
    static async getDetails(connection, poolAddress, cachedState) {
        const state = cachedState ?? (await getFullContractState(connection, poolAddress));
        const type = await DexPoolUtils.getPoolType(connection, poolAddress, state);
        if (type === DexPoolType.CONSTANT_PRODUCT) {
            const result = await DexPairUtils.getDetails(connection, poolAddress, state);
            return {
                address: resolveTvmAddress(poolAddress),
                balances: result.balances,
                contractState: state,
                isActive: result.isActive,
                lpToken: result.lpToken,
                lpWallet: result.lpWallet,
                tokens: result.tokens,
                type: result.type,
                wallets: result.wallets,
            };
        }
        if (type === DexPoolType.STABLE_PAIR) {
            const result = await DexStablePairUtils.getDetails(connection, poolAddress, state);
            return {
                address: resolveTvmAddress(poolAddress),
                balances: result.balances,
                contractState: state,
                isActive: result.isActive,
                lpToken: result.lpToken,
                lpWallet: result.lpWallet,
                tokens: result.tokens,
                type: result.type,
                wallets: result.wallets,
            };
        }
        if (type === DexPoolType.STABLE_POOL) {
            const result = await DexStablePoolUtils.getDetails(connection, poolAddress, state);
            return {
                address: resolveTvmAddress(poolAddress),
                balances: result.balances,
                contractState: state,
                isActive: result.isActive,
                lpToken: result.lpToken,
                lpWallet: result.lpWallet,
                tokens: result.tokens,
                type: result.type,
                wallets: result.wallets,
            };
        }
        throw new Error(`Unexpected pool type. Expected: 1, 2 or 3. Got: ${type}`);
    }
    static async getBalances(connection, poolAddress, cachedState) {
        const state = cachedState ?? (await getFullContractState(connection, poolAddress));
        const type = await DexPoolUtils.getPoolType(connection, poolAddress, state);
        if (type === DexPoolType.CONSTANT_PRODUCT) {
            return DexPairUtils.getBalances(connection, poolAddress, state);
        }
        if (type === DexPoolType.STABLE_PAIR) {
            return DexStablePairUtils.getBalances(connection, poolAddress, state);
        }
        if (type === DexPoolType.STABLE_POOL) {
            return DexStablePoolUtils.getBalances(connection, poolAddress, state);
        }
        throw new Error(`Unexpected pool type. Expected: 1, 2 or 3. Got: ${type}`);
    }
    static async getVirtualPrice(connection, poolAddress, cachedState) {
        const state = cachedState ?? (await getFullContractState(connection, poolAddress));
        const type = await DexPoolUtils.getPoolType(connection, poolAddress, state);
        if (type === DexPoolType.STABLE_PAIR) {
            return DexStablePairUtils.getVirtualPrice(connection, poolAddress, state);
        }
        if (type === DexPoolType.STABLE_POOL) {
            return DexStablePoolUtils.getVirtualPrice(connection, poolAddress, state);
        }
        return null;
    }
    static async getFeeParams(connection, poolAddress, cachedState) {
        const state = cachedState ?? (await getFullContractState(connection, poolAddress));
        const type = await DexPoolUtils.getPoolType(connection, poolAddress, state);
        if (type === DexPoolType.CONSTANT_PRODUCT) {
            const result = await DexPairUtils.getFeeParams(connection, poolAddress, state);
            return {
                beneficiaryAddress: result.beneficiaryAddress,
                beneficiaryNumerator: result.beneficiaryNumerator,
                denominator: result.denominator,
                numerator: result.numerator,
                threshold: result.threshold,
            };
        }
        if (type === DexPoolType.STABLE_PAIR) {
            const result = await DexStablePairUtils.getFeeParams(connection, poolAddress, state);
            return {
                beneficiaryAddress: result.beneficiaryAddress,
                beneficiaryNumerator: result.beneficiaryNumerator,
                denominator: result.denominator,
                numerator: result.numerator,
                threshold: result.threshold,
            };
        }
        if (type === DexPoolType.STABLE_POOL) {
            const result = await DexStablePoolUtils.getFeeParams(connection, poolAddress, state);
            return {
                beneficiaryAddress: result.beneficiaryAddress,
                beneficiaryNumerator: result.beneficiaryNumerator,
                denominator: result.denominator,
                numerator: result.numerator,
                threshold: result.threshold,
            };
        }
        throw new Error(`Unexpected pool type. Expected: 1, 2 or 3. Got: ${type}`);
    }
    static async getRoot(connection, poolAddress, cachedState) {
        const state = cachedState ?? (await getFullContractState(connection, poolAddress));
        const type = await DexPoolUtils.getPoolType(connection, poolAddress, state);
        if (type === DexPoolType.CONSTANT_PRODUCT) {
            return DexPairUtils.getRoot(connection, poolAddress, state);
        }
        if (type === DexPoolType.STABLE_PAIR) {
            return DexStablePairUtils.getRoot(connection, poolAddress, state);
        }
        if (type === DexPoolType.STABLE_POOL) {
            return DexStablePoolUtils.getRoot(connection, poolAddress, state);
        }
        throw new Error(`Unexpected pool type. Expected: 1, 2 or 3. Got: ${type}`);
    }
    static async isActive(connection, poolAddress, cachedState) {
        const state = cachedState ?? (await getFullContractState(connection, poolAddress));
        const type = await DexPoolUtils.getPoolType(connection, poolAddress, state);
        if (type === DexPoolType.CONSTANT_PRODUCT) {
            return DexPairUtils.isActive(connection, poolAddress, state);
        }
        if (type === DexPoolType.STABLE_PAIR) {
            return DexStablePairUtils.isActive(connection, poolAddress, state);
        }
        if (type === DexPoolType.STABLE_POOL) {
            return DexStablePoolUtils.isActive(connection, poolAddress, state);
        }
        throw new Error(`Unexpected pool type. Expected: 1, 2 or 3. Got: ${type}`);
    }
    static async getVault(connection, poolAddress, cachedState) {
        const state = cachedState ?? (await getFullContractState(connection, poolAddress));
        const type = await DexPoolUtils.getPoolType(connection, poolAddress, state);
        if (type === DexPoolType.CONSTANT_PRODUCT) {
            return DexPairUtils.getVault(connection, poolAddress, state);
        }
        if (type === DexPoolType.STABLE_PAIR) {
            return DexStablePairUtils.getVault(connection, poolAddress, state);
        }
        if (type === DexPoolType.STABLE_POOL) {
            return DexStablePoolUtils.getVault(connection, poolAddress, state);
        }
        throw new Error(`Unexpected pool type. Expected: 1, 2 or 3. Got: ${type}`);
    }
    static async getTokenRoots(connection, poolAddress, cachedState) {
        const state = cachedState ?? (await getFullContractState(connection, poolAddress));
        const type = await DexPoolUtils.getPoolType(connection, poolAddress, state);
        if (type === DexPoolType.CONSTANT_PRODUCT) {
            const result = await DexPairUtils.getTokenRoots(connection, poolAddress, state);
            return { lp: result.lp, tokens: [result.left, result.right] };
        }
        if (type === DexPoolType.STABLE_PAIR) {
            const result = await DexStablePairUtils.getTokenRoots(connection, poolAddress, state);
            return { lp: result.lp, tokens: [result.left, result.right] };
        }
        if (type === DexPoolType.STABLE_POOL) {
            const result = await DexStablePoolUtils.getTokenRoots(connection, poolAddress, state);
            return { lp: result.lp, tokens: result.tokens };
        }
        throw new Error(`Unexpected pool type. Expected: 1, 2 or 3. Got: ${type}`);
    }
    static async getTokenWallets(connection, poolAddress, cachedState) {
        const state = cachedState ?? (await getFullContractState(connection, poolAddress));
        const type = await DexPoolUtils.getPoolType(connection, poolAddress, state);
        if (type === DexPoolType.CONSTANT_PRODUCT) {
            const result = await DexPairUtils.getTokenWallets(connection, poolAddress, state);
            return { lp: result.lp, tokens: [result.left, result.right] };
        }
        if (type === DexPoolType.STABLE_PAIR) {
            const result = await DexStablePairUtils.getTokenWallets(connection, poolAddress, state);
            return { lp: result.lp, tokens: [result.left, result.right] };
        }
        if (type === DexPoolType.STABLE_POOL) {
            const result = await DexStablePoolUtils.getTokenWallets(connection, poolAddress, state);
            return { lp: result.lp, tokens: result.tokens };
        }
        throw new Error(`Unexpected pool type. Expected: 1, 2 or 3. Got: ${type}`);
    }
    static async getPoolType(connection, pairAddress, cachedState) {
        const state = cachedState ?? (await getFullContractState(connection, pairAddress));
        try {
            return await DexPairUtils.getPoolType(connection, pairAddress, state);
        }
        catch { }
        try {
            return await DexStablePairUtils.getPoolType(connection, pairAddress, state);
        }
        catch { }
        try {
            return await DexStablePoolUtils.getPoolType(connection, pairAddress, state);
        }
        catch { }
        throw new Error('Cant get pool type');
    }
}