rubic-sdk/lib/features/cross-chain/calculation-manager/providers/symbiosis-provider/chain-trades/symbiosis-ccr-evm-trade.js

Simplify dApp creation

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SymbiosisEvmCcrTrade = void 0;
const errors_1 = require("../../../../../../common/errors");
const blockchain_name_1 = require("../../../../../../core/blockchain/models/blockchain-name");
const blockchains_info_1 = require("../../../../../../core/blockchain/utils/blockchains-info/blockchains-info");
const evm_web3_pure_1 = require("../../../../../../core/blockchain/web3-pure/typed-web3-pure/evm-web3-pure/evm-web3-pure");
const injector_1 = require("../../../../../../core/injector/injector");
const symbiosis_api_service_1 = require("../../../../../common/providers/symbiosis/services/symbiosis-api-service");
const check_unsupported_receiver_address_1 = require("../../../../../common/utils/check-unsupported-receiver-address");
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 symbiosis_utils_1 = require("../symbiosis-utils");
/**
 * Calculated Symbiosis cross-chain trade.
 */
class SymbiosisEvmCcrTrade 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
            : this.contractAddresses.providerGateway;
    }
    get methodName() {
        return 'startBridgeTokensViaGenericCrossChain';
    }
    get tronWeb3Public() {
        return injector_1.Injector.web3PublicService.getWeb3Public(blockchain_name_1.BLOCKCHAIN_NAME.TRON);
    }
    constructor(crossChainTrade, providerAddress, routePath, useProxy) {
        super(providerAddress, routePath, useProxy);
        this.type = cross_chain_trade_type_1.CROSS_CHAIN_TRADE_TYPE.SYMBIOSIS;
        this.isAggregator = false;
        this.bridgeType = bridge_type_1.BRIDGE_TYPE.SYMBIOSIS;
        this.from = crossChainTrade.from;
        this.to = crossChainTrade.to;
        this.swappingParams = crossChainTrade.swapParams;
        this.gasData = crossChainTrade.gasData;
        this.priceImpact = crossChainTrade.priceImpact;
        this.toTokenAmountMin = this.to.tokenAmount.multipliedBy(1 - crossChainTrade.slippage);
        this.feeInfo = crossChainTrade.feeInfo;
        this.slippage = crossChainTrade.slippage;
        this.transitAmount = crossChainTrade.transitAmount;
        this.onChainSubtype = symbiosis_utils_1.SymbiosisUtils.getSubtype(crossChainTrade.tradeType, crossChainTrade.to.blockchain);
        this.contractAddresses = crossChainTrade.contractAddresses;
        this.promotions = crossChainTrade?.promotions || [];
    }
    async getContractParams(options) {
        const { data, value: providerValue, to } = await this.setTransactionConfig(false, options?.useCacheData || false, options?.receiverAddress);
        const { receiverAddress, 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 }, {
            walletAddress: this.walletAddress,
            fromTokenAmount: this.from,
            toTokenAmount: this.to,
            toAddress,
            srcChainTrade: null,
            providerAddress: this.providerAddress,
            type: `native:${this.type}`,
            fromAddress: this.walletAddress
        });
        const providerData = await proxy_cross_chain_evm_trade_1.ProxyCrossChainEvmTrade.getGenericProviderData(to, data, this.fromBlockchain, this.contractAddresses.providerGateway, '0');
        const methodArguments = [bridgeData, providerData];
        const value = this.getSwapValue(providerValue);
        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
        };
    }
    /**
     * Used for direct provider swaps.
     * @param options Swap options
     */
    async swapDirect(options = {}) {
        await this.checkTradeErrors();
        await this.checkReceiverAddress(options.receiverAddress, !blockchains_info_1.BlockchainsInfo.isEvmBlockchainName(this.to.blockchain));
        await this.checkAllowanceAndApprove(options);
        const { onConfirm, gasPriceOptions } = options;
        let transactionHash;
        const onTransactionHash = (hash) => {
            if (onConfirm) {
                onConfirm(hash);
            }
            transactionHash = hash;
        };
        try {
            const { data, value, to } = await this.setTransactionConfig(false, options?.useCacheData || false, options?.receiverAddress);
            await this.web3Private.trySendTransaction(to, {
                data,
                value,
                onTransactionHash,
                gasPriceOptions
            });
            return transactionHash;
        }
        catch (err) {
            if (err instanceof errors_1.FailedToCheckForTransactionReceiptError) {
                return transactionHash;
            }
            throw err;
        }
    }
    getTradeAmountRatio(fromUsd) {
        return fromUsd.dividedBy(this.to.tokenAmount);
    }
    getTradeInfo() {
        return {
            estimatedGas: this.estimatedGas,
            feeInfo: this.feeInfo,
            priceImpact: this.priceImpact ?? null,
            slippage: this.slippage * 100,
            routePath: this.routePath
        };
    }
    async getTransactionConfigAndAmount(receiverAddress) {
        const walletAddress = this.walletAddress;
        if (this.from.blockchain === 'BAHAMUT' || this.to.blockchain === 'BAHAMUT') {
            (0, check_unsupported_receiver_address_1.checkUnsupportedReceiverAddress)(receiverAddress, this.walletAddress);
        }
        const params = {
            ...this.swappingParams,
            from: walletAddress,
            to: receiverAddress || walletAddress,
            revertableAddress: symbiosis_utils_1.SymbiosisUtils.getRevertableAddress(receiverAddress, walletAddress, this.to.blockchain)
        };
        const tradeData = await symbiosis_api_service_1.SymbiosisApiService.getCrossChainSwapTx(params);
        const tx = tradeData.tx;
        const config = {
            data: tx.data.toString(),
            value: tx.value?.toString() || '0',
            to: tx.to
        };
        return { config, amount: tradeData.tokenAmountOut.amount };
    }
}
exports.SymbiosisEvmCcrTrade = SymbiosisEvmCcrTrade;
//# sourceMappingURL=symbiosis-ccr-evm-trade.js.map