@broxus/js-bridge-essentials/dist/esm/models/alien-proxy/AlienProxyUtils.js

Bridge JavaScript Essentials library

import { getFullContractState, resolveTvmAddress } from '@broxus/js-core';
import { PublicKey } from '@solana/web3.js';
import { alienProxyContract, mergePoolContract, mergeRouterContract } from '../../models/alien-proxy/contracts';
import { TokenRootAlienEvm } from '../../models/token-root-alien-evm';
import { TokenRootAlienSolana } from '../../models/token-root-alien-solana';
export class AlienProxyUtils {
    static async getConfiguration(connection, proxyAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, proxyAddress);
        return alienProxyContract(connection, proxyAddress)
            .methods.getConfiguration({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
    }
    static async getTvmEvmConfiguration(connection, proxyAddress, cachedState) {
        const result = await AlienProxyUtils.getConfiguration(connection, proxyAddress, cachedState);
        return result.value0.everscaleConfiguration;
    }
    static async getSolTvmConfiguration(connection, proxyAddress, cachedState) {
        const result = await AlienProxyUtils.getConfiguration(connection, proxyAddress, cachedState);
        return result.value1.solanaConfiguration;
    }
    static async getTvmSolConfiguration(connection, proxyAddress, cachedState) {
        const result = await AlienProxyUtils.getConfiguration(connection, proxyAddress, cachedState);
        return result.value1.everscaleConfiguration;
    }
    /**
     * Derive EVM alien token address in TVM by the given proxy address and EVM token params
     * @param {ProviderRpcClient} connection
     * @param {Address | string} proxyAddress
     * @param {Omit<DecodedAbiFunctionInputs<typeof AlienProxyAbi, 'deriveEVMAlienTokenRoot'>, 'answerId'>} params
     * @param {FullContractState} [cachedState] - optional. Full contract state of the alien proxy contract
     */
    static async deriveEvmAlienTokenRoot(connection, proxyAddress, params, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, proxyAddress);
        const result = await alienProxyContract(connection, proxyAddress)
            .methods.deriveEVMAlienTokenRoot({ answerId: 0, ...params })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    /**
     * Derive Solana alien token address in TVM by the given proxy address and Solana token params
     * @param {ProviderRpcClient} connection
     * @param {Address | string} proxyAddress
     * @param {Omit<DecodedAbiFunctionInputs<typeof AlienProxyAbi, 'deriveSolanaAlienTokenRoot'>, 'answerId'>} params
     * @param {FullContractState} [cachedState] - optional. Full contract state of the alien proxy contract
     */
    static async deriveSolanaAlienTokenRoot(connection, proxyAddress, params, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, proxyAddress);
        const result = await alienProxyContract(connection, proxyAddress)
            .methods.deriveSolanaAlienTokenRoot({ answerId: 0, ...params })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    /**
     * Get derive merge router address by the given TVM-like token and proxy addresses
     * @param {ProviderRpcClient} connection
     * @param {Address | string} proxyAddress
     * @param {Address | string} tokenAddress
     * @param {FullContractState} [cachedState] - optional. Full contract state of the alien proxy contract
     */
    static async deriveMergeRouter(connection, proxyAddress, tokenAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, proxyAddress);
        const result = await alienProxyContract(connection, proxyAddress)
            .methods.deriveMergeRouter({
            answerId: 0,
            token: resolveTvmAddress(tokenAddress),
        })
            .call({ cachedState: state, responsible: true });
        return result.router;
    }
    /**
     * Get merge pool address by the given merge router address
     * @param {ProviderRpcClient} connection
     * @param {Address | string} mergeRouterAddress
     * @param {FullContractState} [cachedState] - optional. Full contract state of the merge router contract
     */
    static async getMergePoolAddress(connection, mergeRouterAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, mergeRouterAddress);
        const result = await mergeRouterContract(connection, mergeRouterAddress)
            .methods.getPool({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return result.value0;
    }
    static async getMergePoolTokens(connection, mergePoolAddress, cachedState) {
        const state = cachedState ?? await getFullContractState(connection, mergePoolAddress);
        const result = await mergePoolContract(connection, mergePoolAddress)
            .methods.getTokens({ answerId: 0 })
            .call({ cachedState: state, responsible: true });
        return {
            canon: result._canon,
            tokens: result._tokens.map(([addr, settings]) => [addr, settings]),
        };
    }
    static async getEvmTokenMergeDetails(connection, proxyAddress, tokenAddress, chainId, cachedState) {
        try {
            const state = cachedState ?? await getFullContractState(connection, proxyAddress);
            const mergeRouterAddress = await AlienProxyUtils.deriveMergeRouter(connection, proxyAddress, tokenAddress, state);
            const mergePoolAddress = await AlienProxyUtils.getMergePoolAddress(connection, mergeRouterAddress);
            const mergedTokens = await AlienProxyUtils.getMergePoolTokens(connection, mergePoolAddress);
            const aliens = await Promise.all(mergedTokens.tokens.map(async ([address, settings]) => {
                if (!settings.enabled) {
                    return { isMerged: false };
                }
                try {
                    const meta = await TokenRootAlienEvm.Utils.meta(connection, address);
                    return {
                        canonicalAddress: mergedTokens.canon,
                        evmTokenAddress: meta.evmTokenAddress,
                        isMerged: meta.baseChainId === chainId,
                        tvmTokenAddress: tokenAddress,
                    };
                }
                catch (e) {
                    return { isMerged: false };
                }
            }));
            const merged = aliens.find(e => e.isMerged);
            return merged
                ? {
                    canonicalAddress: merged.canonicalAddress,
                    evmTokenAddress: merged.evmTokenAddress,
                    isMerged: true,
                    mergePoolAddress,
                    mergeRouterAddress,
                    tvmTokenAddress: resolveTvmAddress(merged.tvmTokenAddress ?? tokenAddress),
                }
                : undefined;
        }
        catch (e) {
            return undefined;
        }
    }
    static async getSolTokenMergeDetails(connection, proxyAddress, tokenAddress, cachedState) {
        try {
            const state = cachedState ?? await getFullContractState(connection, proxyAddress);
            const mergeRouterAddress = await AlienProxyUtils.deriveMergeRouter(connection, proxyAddress, tokenAddress, state);
            const mergePoolAddress = await AlienProxyUtils.getMergePoolAddress(connection, mergeRouterAddress);
            const mergedTokens = await AlienProxyUtils.getMergePoolTokens(connection, mergePoolAddress);
            const aliens = await Promise.all(mergedTokens.tokens.map(async ([address, settings]) => {
                if (!settings.enabled) {
                    return { isMerged: false };
                }
                try {
                    const meta = await TokenRootAlienSolana.Utils.meta(connection, address);
                    return {
                        canonicalAddress: mergedTokens.canon,
                        isMerged: true,
                        solTokenAddress: meta.solTokenAddress,
                        tvmTokenAddress: tokenAddress,
                    };
                }
                catch (e) {
                    return { isMerged: false };
                }
            }));
            const merged = aliens.find(e => e.isMerged);
            return merged?.solTokenAddress
                ? {
                    canonicalAddress: merged.canonicalAddress,
                    isMerged: true,
                    mergePoolAddress,
                    mergeRouterAddress,
                    solTokenAddress: new PublicKey(merged.solTokenAddress),
                    tvmTokenAddress: resolveTvmAddress(merged.tvmTokenAddress ?? tokenAddress),
                }
                : undefined;
        }
        catch (e) {
            return undefined;
        }
    }
}