rubic-sdk-next
Version:
Simplify dApp creation
148 lines • 6.12 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.OnChainManager = void 0;
const errors_1 = require("../../../common/errors");
const tokens_1 = require("../../../common/tokens");
const options_1 = require("../../../common/utils/options");
const blockchains_info_1 = require("../../../core/blockchain/utils/blockchains-info/blockchains-info");
const injector_1 = require("../../../core/injector/injector");
const get_price_tokens_from_input_tokens_1 = require("../../common/utils/get-price-tokens-from-input-tokens");
const default_provider_addresses_1 = require("../../cross-chain/calculation-manager/constants/default-provider-addresses");
const deflation_token_manager_1 = require("../../deflation-token-manager/deflation-token-manager");
const evm_wrap_trade_1 = require("./common/evm-wrap-trade/evm-wrap-trade");
const on_chain_proxy_service_1 = require("./common/on-chain-proxy-service/on-chain-proxy-service");
const on_chain_trade_type_1 = require("./models/on-chain-trade-type");
const transform_utils_1 = require("../../ws-api/transform-utils");
/**
* Contains methods to calculate on-chain trades.
*/
class OnChainManager {
constructor(providerAddress) {
this.providerAddress = providerAddress;
this.deflationTokenManager = new deflation_token_manager_1.DeflationTokenManager();
}
/**
* Calculates on-chain trades, sorted by output amount.
*
* @example
* ```ts
* const blockchain = BLOCKCHAIN_NAME.ETHEREUM;
* // ETH
* const fromTokenAddress = '0x0000000000000000000000000000000000000000';
* const fromAmount = 1;
* // USDT
* const toTokenAddress = '0xdac17f958d2ee523a2206206994597c13d831ec7';
*
* const trades = await sdk.onChainManager.calculateTrade(
* { blockchain, address: fromTokenAddress },
* fromAmount,
* toTokenAddress
* );
* const bestTrade = trades[0];
*
* trades.forEach(trade => {
* if (trade instanceof OnChainTrade) {
* console.log(trade.type, `to amount: ${trade.to.tokenAmount.toFormat(3)}`)
* }
* })
* ```
*
* @param fromToken Token to sell.
* @param fromAmount Amount to sell.
* @param toToken Token to get.
* @param options Additional options.
* @returns List of calculated on-chain trades.
*/
async calculateTrade(fromToken, fromAmount, toToken, options) {
if (toToken instanceof tokens_1.Token && fromToken.blockchain !== toToken.blockchain) {
throw new errors_1.RubicSdkError('Blockchains of from and to tokens must be same');
}
const { from, to } = await (0, get_price_tokens_from_input_tokens_1.getPriceTokensFromInputTokens)(fromToken, fromAmount.toString(), toToken);
const fullOptions = await this.getFullOptions(from, to, options);
if ((from.isNative && to.isWrapped) || (from.isWrapped && to.isNative)) {
const trade = this.getWrappedWrapTrade(from, to);
return [trade];
}
// @TODO API
const request = {
srcTokenAddress: from.address,
dstTokenBlockchain: to.blockchain,
srcTokenBlockchain: from.blockchain,
srcTokenAmount: from.stringWeiAmount,
dstTokenAddress: to.address
};
const routes = await injector_1.Injector.rubicApiService.fetchRoutes(request);
return Promise.all(routes.routes.map(route => transform_utils_1.TransformUtils.transformOnChain(route, request, null)));
}
async getFullOptions(from, to, options) {
const chainType = blockchains_info_1.BlockchainsInfo.getChainType(from.blockchain);
const [isDeflationFrom, isDeflationTo] = await Promise.all([
this.isDeflationToken(from),
this.isDeflationToken(to)
]);
let useProxy;
if (options?.useProxy === false) {
useProxy = options.useProxy;
}
else {
useProxy =
on_chain_proxy_service_1.OnChainProxyService.isSupportedBlockchain(from.blockchain) &&
(!isDeflationFrom.isDeflation || isDeflationFrom.isWhitelisted);
}
return (0, options_1.combineOptions)({ ...options, useProxy }, {
timeout: OnChainManager.defaultCalculationTimeout,
disabledProviders: [],
providerAddress: options?.providerAddress ||
this.providerAddress?.[chainType]?.onChain ||
default_provider_addresses_1.defaultProviderAddresses.onChain,
useProxy,
withDeflation: {
from: isDeflationFrom,
to: isDeflationTo
}
});
}
isDeflationToken(token) {
return this.deflationTokenManager.isDeflationToken(token);
}
static getWrapTrade(from, to) {
const fromToken = from;
const toToken = to;
return new evm_wrap_trade_1.EvmWrapTrade({
from: fromToken,
to: new tokens_1.PriceTokenAmount({
...toToken.asStruct,
weiAmount: from.weiAmount
}),
slippageTolerance: 0,
path: [],
gasFeeInfo: null,
useProxy: false,
proxyFeeInfo: undefined,
fromWithoutFee: fromToken,
apiResponse: null,
apiQuote: null,
withDeflation: {
from: { isDeflation: false },
to: { isDeflation: false }
}
});
}
getWrappedWrapTrade(fromToken, toToken) {
const wrappedTrade = {
error: undefined,
trade: null,
tradeType: on_chain_trade_type_1.ON_CHAIN_TRADE_TYPE.WRAPPED
};
try {
wrappedTrade.trade = OnChainManager.getWrapTrade(fromToken, toToken);
}
catch (err) {
wrappedTrade.error = err;
}
return wrappedTrade;
}
}
exports.OnChainManager = OnChainManager;
OnChainManager.defaultCalculationTimeout = 20000;
//# sourceMappingURL=on-chain-manager.js.map