@broxus/js-core/dist/esm/models/dex/DexUtils.js

MobX-based JavaScript Core library

import { DEFAULT_NATIVE_CURRENCY_DECIMALS } from '../../constants';
import { dexRootContract } from '../../models/dex/contracts';
import { getFullContractState, resolveTvmAddress, toInt } from '../../utils';
export class DexUtils {
    /**
     * Sends a delayed message to deploy a DEX Account
     * @param {ProviderRpcClient} provider
     * @param {Address | string} dexRootAddress
     * @param {DexDeployAccountAbiParams} params
     * @param {Partial<SendInternalParams>} [args]
     * @returns {Promise<DelayedMessageExecution>}
     */
    static deployAccount(provider, dexRootAddress, params, args) {
        const ownerAddress = resolveTvmAddress(params.ownerAddress);
        const senderAddress = params.senderAddress ? resolveTvmAddress(params.senderAddress) : undefined;
        const sendGasTo = params.sendGasTo ? resolveTvmAddress(params.sendGasTo) : undefined;
        return dexRootContract(provider, dexRootAddress)
            .methods.deployAccount({
            account_owner: resolveTvmAddress(params.ownerAddress),
            send_gas_to: sendGasTo ?? senderAddress ?? ownerAddress,
        })
            .sendDelayed({
            amount: toInt(2, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: false,
            from: senderAddress ?? ownerAddress,
            ...args,
        });
    }
    /**
     * Sends a delayed message to deploy a pair
     * @param {ProviderRpcClient} provider
     * @param {Address | string} dexRootAddress
     * @param {DexDeployPairAbiParams} params
     * @param {Partial<SendInternalParams>} [args]
     * @returns {Promise<DelayedMessageExecution>}
     */
    static deployPair(provider, dexRootAddress, params, args) {
        return dexRootContract(provider, dexRootAddress)
            .methods.deployPair({
            left_root: resolveTvmAddress(params.leftRootAddress),
            right_root: resolveTvmAddress(params.rightRootAddress),
            send_gas_to: resolveTvmAddress(params.sendGasTo),
        })
            .sendDelayed({
            amount: toInt(10, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: false,
            from: resolveTvmAddress(params.sendGasTo),
            ...args,
        });
    }
    /**
     * Sends a delayed message to deploy a pool
     * @param {ProviderRpcClient} provider
     * @param {Address | string} dexRootAddress
     * @param {DexDeployPoolAbiParams} params
     * @param {Partial<SendInternalParams>} [args]
     * @returns {Promise<DelayedMessageExecution>}
     */
    static deployStablePool(provider, dexRootAddress, params, args) {
        return dexRootContract(provider, dexRootAddress)
            .methods.deployStablePool({
            roots: params.roots.map(resolveTvmAddress),
            send_gas_to: resolveTvmAddress(params.sendGasTo),
        })
            .sendDelayed({
            amount: toInt(10, DEFAULT_NATIVE_CURRENCY_DECIMALS),
            bounce: false,
            from: resolveTvmAddress(params.sendGasTo),
            ...args,
        });
    }
    /**
     * Returns an expected user DEX account address
     * by a given DEX root address and user wallet address
     * @param {ProviderRpcClient} connection
     * @param {Address | string} dexRootAddress
     * @param {DexExpectedAccountAddressAbiParams} params
     * @param {FullContractState} [cachedState]
     * @returns {Promise<Address>}
     */
    static async getExpectedAccountAddress(connection, dexRootAddress, params, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, dexRootAddress);
        const result = await dexRootContract(connection, dexRootAddress)
            .methods.getExpectedAccountAddress({
            account_owner: resolveTvmAddress(params.ownerAddress),
            answerId: 0,
        })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    /**
     * Returns an expected pair address by a given DEX root address
     * and left and right tokens addresses
     * @param {ProviderRpcClient} connection
     * @param {Address | string} dexRootAddress
     * @param {DexExpectedPairAddressAbiParams} params
     * @param {FullContractState} [cachedState]
     * @return {Promise<Address>}
     */
    static async getExpectedPairAddress(connection, dexRootAddress, params, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, dexRootAddress);
        const result = await dexRootContract(connection, dexRootAddress)
            .methods.getExpectedPairAddress({
            answerId: 0,
            left_root: resolveTvmAddress(params.leftRootAddress),
            right_root: resolveTvmAddress(params.rightRootAddress),
        })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    /**
     * Returns an expected pool address by a given DEX root address
     * and possible included tokens addresses
     * @param {ProviderRpcClient} connection
     * @param {Address | string} dexRootAddress
     * @param {DexExpectedPoolAddressAbiParams} params
     * @param {FullContractState} [cachedState]
     * @return {Promise<Address>}
     */
    static async getExpectedPoolAddress(connection, dexRootAddress, params, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, dexRootAddress);
        const result = await dexRootContract(connection, dexRootAddress)
            .methods.getExpectedPoolAddress({
            _roots: params.roots.map(resolveTvmAddress),
            answerId: 0,
        })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    static async getManager(connection, dexRootAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, dexRootAddress);
        const result = await dexRootContract(connection, dexRootAddress)
            .methods.getManager({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    static async getOwner(connection, dexRootAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, dexRootAddress);
        const result = await dexRootContract(connection, dexRootAddress)
            .methods.getOwner({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return result.dex_owner;
    }
    static async getVault(connection, dexRootAddress, cachedState) {
        const result = await dexRootContract(connection, dexRootAddress)
            .methods.getVault({ answerId: 0 })
            .call({ cachedState, responsible: true });
        return result.value0;
    }
    static decodeEvent(connection, dexRootAddress, args) {
        return dexRootContract(connection, dexRootAddress).decodeEvent(args);
    }
    static decodeTransaction(connection, dexRootAddress, args) {
        return dexRootContract(connection, dexRootAddress).decodeTransaction(args);
    }
    static decodeTransactionEvents(connection, dexRootAddress, transaction) {
        return dexRootContract(connection, dexRootAddress).decodeTransactionEvents({ transaction });
    }
}