rubic-sdk/lib/features/cross-chain/calculation-manager/providers/bridgers-provider/bridgers-cross-chain-provider.js

Simplify dApp creation

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.BridgersCrossChainProvider = void 0;
const bignumber_js_1 = __importDefault(require("bignumber.js"));
const errors_1 = require("../../../../../common/errors");
const tokens_1 = require("../../../../../common/tokens");
const blockchain_name_1 = require("../../../../../core/blockchain/models/blockchain-name");
const blockchains_info_1 = require("../../../../../core/blockchain/utils/blockchains-info/blockchains-info");
const bridgers_native_address_1 = require("../../../../common/providers/bridgers/constants/bridgers-native-address");
const to_bridgers_blockchain_1 = require("../../../../common/providers/bridgers/constants/to-bridgers-blockchain");
const get_from_without_fee_1 = require("../../../../common/utils/get-from-without-fee");
const token_native_address_proxy_1 = require("../../../../common/utils/token-native-address-proxy");
const cross_chain_trade_type_1 = require("../../models/cross-chain-trade-type");
const bridgers_cross_chain_provider_factory_1 = require("./bridgers-cross-chain-provider-factory");
const bridgers_cross_chain_supported_blockchain_1 = require("./constants/bridgers-cross-chain-supported-blockchain");
const cross_chain_provider_1 = require("../common/cross-chain-provider");
const proxy_cross_chain_evm_trade_1 = require("../common/proxy-cross-chain-evm-facade/proxy-cross-chain-evm-trade");
class BridgersCrossChainProvider extends cross_chain_provider_1.CrossChainProvider {
    constructor() {
        super(...arguments);
        this.type = cross_chain_trade_type_1.CROSS_CHAIN_TRADE_TYPE.BRIDGERS;
    }
    isSupportedBlockchain(blockchain) {
        return bridgers_cross_chain_supported_blockchain_1.bridgersCrossChainSupportedBlockchains.some(supportedBlockchain => supportedBlockchain === blockchain);
    }
    areSupportedBlockchains(fromBlockchain, toBlockchain) {
        const isTonEvm = fromBlockchain === blockchain_name_1.BLOCKCHAIN_NAME.TON &&
            this.isSupportedBlockchain(toBlockchain) &&
            blockchains_info_1.BlockchainsInfo.isEvmBlockchainName(toBlockchain);
        const isEvmTon = this.isSupportedBlockchain(fromBlockchain) &&
            blockchains_info_1.BlockchainsInfo.isEvmBlockchainName(fromBlockchain) &&
            toBlockchain === blockchain_name_1.BLOCKCHAIN_NAME.TON;
        const isTronEvm = fromBlockchain === blockchain_name_1.BLOCKCHAIN_NAME.TRON &&
            this.isSupportedBlockchain(toBlockchain) &&
            blockchains_info_1.BlockchainsInfo.isEvmBlockchainName(toBlockchain);
        const isEvmTron = this.isSupportedBlockchain(fromBlockchain) &&
            blockchains_info_1.BlockchainsInfo.isEvmBlockchainName(fromBlockchain) &&
            toBlockchain === blockchain_name_1.BLOCKCHAIN_NAME.TRON;
        return isEvmTon || isTonEvm || isEvmTron || isTronEvm;
    }
    async calculate(from, toToken, options) {
        const fromBlockchain = from.blockchain;
        const toBlockchain = toToken.blockchain;
        if (!this.areSupportedBlockchains(fromBlockchain, toBlockchain)) {
            return {
                trade: null,
                error: new errors_1.NotSupportedTokensError(),
                tradeType: this.type
            };
        }
        try {
            const useProxy = options?.useProxy?.[this.type] ?? true;
            let feeInfo = await this.getFeeInfo(fromBlockchain, options.providerAddress, from, useProxy);
            const fromWithoutFee = (0, get_from_without_fee_1.getFromWithoutFee)(from, feeInfo.rubicProxy?.platformFee?.percent);
            const fromTokenAddress = (0, token_native_address_proxy_1.createTokenNativeAddressProxy)(fromWithoutFee, bridgers_native_address_1.bridgersNativeAddress, false).address;
            const toTokenAddress = (0, token_native_address_proxy_1.createTokenNativeAddressProxy)(toToken, bridgers_native_address_1.bridgersNativeAddress, false).address;
            const quoteRequest = {
                fromTokenAddress,
                toTokenAddress,
                fromTokenAmount: fromWithoutFee.stringWeiAmount,
                fromTokenChain: to_bridgers_blockchain_1.toBridgersBlockchain[fromBlockchain],
                toTokenChain: to_bridgers_blockchain_1.toBridgersBlockchain[toBlockchain],
                sourceFlag: 'rubic'
            };
            const quoteResponse = await this.httpClient.post('https://sswap.swft.pro/api/sswap/quote', quoteRequest);
            const transactionData = quoteResponse.data?.txData;
            if (quoteResponse.resCode !== 100 || !transactionData) {
                return {
                    trade: null,
                    error: new errors_1.BridgersPairIsUnavailableError(),
                    tradeType: this.type
                };
            }
            const outputAmount = fromWithoutFee.tokenAmount
                .minus(transactionData.serviceFee)
                .multipliedBy(transactionData.instantRate)
                .minus(transactionData.chainFee);
            const to = new tokens_1.PriceTokenAmount({
                ...toToken.asStruct,
                blockchain: toBlockchain,
                tokenAmount: outputAmount
            });
            const toTokenAmountMin = to.tokenAmount.multipliedBy(1 - options.slippageTolerance);
            const trade = bridgers_cross_chain_provider_factory_1.BridgersCrossChainProviderFactory.createTrade({
                crossChainTrade: {
                    from: from,
                    to,
                    toTokenAmountMin,
                    feeInfo,
                    gasData: await this.getGasData(from),
                    slippage: options.slippageTolerance
                },
                providerAddress: options.providerAddress,
                routePath: await this.getRoutePath(from, to),
                useProxy
            });
            return this.getCalculationResponse(from, transactionData, trade);
        }
        catch (err) {
            return {
                trade: null,
                error: cross_chain_provider_1.CrossChainProvider.parseError(err),
                tradeType: this.type
            };
        }
    }
    getCalculationResponse(from, transactionData, trade) {
        if (from.tokenAmount.lt(transactionData.depositMin)) {
            return {
                trade,
                error: new errors_1.MinAmountError(new bignumber_js_1.default(transactionData.depositMin), from.symbol),
                tradeType: this.type
            };
        }
        if (from.tokenAmount.gt(transactionData.depositMax)) {
            return {
                trade,
                error: new errors_1.MaxAmountError(new bignumber_js_1.default(transactionData.depositMax), from.symbol),
                tradeType: this.type
            };
        }
        return {
            trade,
            tradeType: this.type
        };
    }
    async getFeeInfo(fromBlockchain, providerAddress, percentFeeToken, useProxy) {
        return proxy_cross_chain_evm_trade_1.ProxyCrossChainEvmTrade.getFeeInfo(fromBlockchain, providerAddress, percentFeeToken, useProxy);
    }
    async getRoutePath(fromToken, toToken) {
        return [{ type: 'cross-chain', provider: this.type, path: [fromToken, toToken] }];
    }
}
exports.BridgersCrossChainProvider = BridgersCrossChainProvider;
//# sourceMappingURL=bridgers-cross-chain-provider.js.map