rubic-sdk/lib/features/cross-chain/calculation-manager/providers/meson-provider/networks/meson-cross-chain-evm-trade.js

Simplify dApp creation

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MesonCrossChainEvmTrade = void 0;
const ethers_1 = require("ethers");
const evm_web3_pure_1 = require("../../../../../../core/blockchain/web3-pure/typed-web3-pure/evm-web3-pure/evm-web3-pure");
const web3_pure_1 = require("../../../../../../core/blockchain/web3-pure/web3-pure");
const get_from_without_fee_1 = require("../../../../../common/utils/get-from-without-fee");
const cross_chain_trade_type_1 = require("../../../models/cross-chain-trade-type");
const rubic_proxy_contract_address_1 = require("../../common/constants/rubic-proxy-contract-address");
const evm_common_cross_chain_abi_1 = require("../../common/evm-cross-chain-trade/constants/evm-common-cross-chain-abi");
const gateway_rubic_cross_chain_abi_1 = require("../../common/evm-cross-chain-trade/constants/gateway-rubic-cross-chain-abi");
const evm_cross_chain_trade_1 = require("../../common/evm-cross-chain-trade/evm-cross-chain-trade");
const bridge_type_1 = require("../../common/models/bridge-type");
const proxy_cross_chain_evm_trade_1 = require("../../common/proxy-cross-chain-evm-facade/proxy-cross-chain-evm-trade");
const meson_abi_1 = require("../constants/meson-abi");
const meson_contract_addresses_1 = require("../constants/meson-contract-addresses");
const meson_cross_chain_api_service_1 = require("../services/meson-cross-chain-api-service");
const symbiosis_utils_1 = require("../../symbiosis-provider/symbiosis-utils");
class MesonCrossChainEvmTrade extends evm_cross_chain_trade_1.EvmCrossChainTrade {
    get fromBlockchain() {
        return this.from.blockchain;
    }
    get fromContractAddress() {
        return this.isProxyTrade
            ? rubic_proxy_contract_address_1.rubicProxyContractAddress[this.fromBlockchain].gateway
            : meson_contract_addresses_1.mesonContractAddresses[this.fromBlockchain];
    }
    get methodName() {
        return 'startBridgeTokensViaGenericCrossChain';
    }
    constructor(params) {
        super(params.providerAddress, params.routePath, params.useProxy);
        /**ABSTRACT PROPS */
        this.type = cross_chain_trade_type_1.CROSS_CHAIN_TRADE_TYPE.MESON;
        this.isAggregator = false;
        this.onChainSubtype = { from: undefined, to: undefined };
        this.bridgeType = bridge_type_1.BRIDGE_TYPE.MESON;
        this.to = params.crossChainTrade.to;
        this.from = params.crossChainTrade.from;
        this.feeInfo = params.crossChainTrade.feeInfo;
        this.gasData = params.crossChainTrade.gasData;
        this.priceImpact = params.crossChainTrade.priceImpact;
        this.toTokenAmountMin = this.to.tokenAmount;
        this.sourceAssetString = params.crossChainTrade.sourceAssetString;
        this.targetAssetString = params.crossChainTrade.targetAssetString;
    }
    async getContractParams(options) {
        const receiverAddress = options?.receiverAddress || this.walletAddress;
        const { data, value: providerValue, //  0.001078
        to: providerRouter } = await this.setTransactionConfig(false, options?.useCacheData || false, options?.receiverAddress || this.walletAddress);
        const { receiverAddress: proxyReceiver, toAddress } = await symbiosis_utils_1.SymbiosisUtils.getReceiver(this.from, this.to, this.walletAddress, options?.receiverAddress);
        const bridgeData = proxy_cross_chain_evm_trade_1.ProxyCrossChainEvmTrade.getBridgeData({ ...options, receiverAddress: proxyReceiver }, {
            walletAddress: receiverAddress,
            fromTokenAmount: this.from, // 0.0011
            toTokenAmount: this.to,
            srcChainTrade: null,
            providerAddress: this.providerAddress,
            type: `native:${this.bridgeType}`,
            fromAddress: this.walletAddress,
            toAddress
        });
        const extraNativeFee = '0';
        const providerData = await proxy_cross_chain_evm_trade_1.ProxyCrossChainEvmTrade.getGenericProviderData(providerRouter, data, this.from.blockchain, providerRouter, extraNativeFee);
        const methodArguments = [bridgeData, providerData];
        const value = this.getSwapValue(providerValue); // 0.0011
        const transactionConfiguration = evm_web3_pure_1.EvmWeb3Pure.encodeMethodCall(rubic_proxy_contract_address_1.rubicProxyContractAddress[this.from.blockchain].router, evm_common_cross_chain_abi_1.evmCommonCrossChainAbi, this.methodName, methodArguments, value);
        const sendingToken = this.from.isNative ? [] : [this.from.address];
        const sendingAmount = this.from.isNative ? [] : [this.from.stringWeiAmount];
        return {
            contractAddress: rubic_proxy_contract_address_1.rubicProxyContractAddress[this.from.blockchain].gateway,
            contractAbi: gateway_rubic_cross_chain_abi_1.gatewayRubicCrossChainAbi,
            methodName: 'startViaRubic',
            methodArguments: [sendingToken, sendingAmount, transactionConfiguration.data],
            value
        };
    }
    async getTransactionConfigAndAmount(receiverAddress) {
        const rubicMultiProxyAddress = rubic_proxy_contract_address_1.rubicProxyContractAddress[this.fromBlockchain].router;
        const fromAddress = this.isProxyTrade ? rubicMultiProxyAddress : this.walletAddress;
        const fromWithoutFee = (0, get_from_without_fee_1.getFromWithoutFee)(this.from, this.feeInfo.rubicProxy?.platformFee?.percent);
        const { encoded, initiator, fee } = await meson_cross_chain_api_service_1.MesonCcrApiService.fetchInfoForTx({
            sourceAssetString: this.sourceAssetString,
            targetAssetString: this.targetAssetString,
            amount: fromWithoutFee.tokenAmount.toFixed(),
            fromAddress,
            receiverAddress: receiverAddress || this.walletAddress,
            useProxy: this.isProxyTrade
        });
        const postingValue = ethers_1.ethers.utils.solidityPack(['address', 'uint40'], [initiator, 1]);
        const methodName = 'postSwapFromContract';
        const methodArgs = [encoded, postingValue, rubicMultiProxyAddress];
        const value = this.from.isNative ? fromWithoutFee.stringWeiAmount : '0';
        const toAmount = this.from.tokenAmount.minus(fee.totalFee);
        const config = evm_web3_pure_1.EvmWeb3Pure.encodeMethodCall(meson_contract_addresses_1.mesonContractAddresses[this.fromBlockchain], meson_abi_1.MESON_ABI, methodName, methodArgs, value);
        return { config, amount: web3_pure_1.Web3Pure.toWei(toAmount, this.to.decimals) };
    }
    getTradeInfo() {
        return {
            estimatedGas: this.estimatedGas,
            feeInfo: this.feeInfo,
            priceImpact: this.priceImpact || null,
            slippage: 0,
            routePath: this.routePath
        };
    }
}
exports.MesonCrossChainEvmTrade = MesonCrossChainEvmTrade;
//# sourceMappingURL=meson-cross-chain-evm-trade.js.map