symbiosis-js-sdk 3.7.5 → 3.7.6

package/dist/crosschain/swapping/baseSwapping.js

@@ -0,0 +1,852 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { AddressZero, MaxUint256 } from '@ethersproject/constants';
+import JSBI from 'jsbi';
+import { ChainId } from '../../constants.js';
+import { Percent, Profiler, TokenAmount, wrappedToken } from '../../entities/index.js';
+import { buildMetaSynthesize, getExternalId, getInternalId, getMinAmount, isEvmChainId, isTonChainId, isTronChainId, isTronToken, prepareTronTransaction, splitSlippage, tronAddressToEvm, } from '../chainUtils/index.js';
+import { BIPS_BASE, CROSS_CHAIN_ID } from '../constants.js';
+import { Portal__factory, Synthesis__factory } from '../contracts/index.js';
+import { amountsToPrices } from '../depository.js';
+import { SdkError } from '../sdkError.js';
+import { withTracing } from '../tracing.js';
+import { AggregatorTrade, WrapTrade } from '../trade/index.js';
+import { DepositoryTrade } from '../trade/depositoryTrade.js';
+import { Transit } from '../transit.js';
+import { TRON_METAROUTER_ABI } from '../tronAbis/index.js';
+import { isUseOneInchOnly } from '../utils.js';
+let BaseSwapping = (() => {
+    let _instanceExtraInitializers = [];
+    let _doExactIn_decorators;
+    let _buildTradeA_decorators;
+    let _buildTradeC_decorators;
+    return class BaseSwapping {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _doExactIn_decorators = [withTracing({
+                    onCall: function (params) {
+                        return {
+                            tokenAmountIn: params.tokenAmountIn.toString(),
+                            tokenOut: params.tokenOut.toString(),
+                            to: params.to,
+                            slippage: params.slippage,
+                            deadline: params.deadline,
+                            transitTokenIn: params.transitTokenIn?.toString(),
+                            transitTokenOut: params.transitTokenOut?.toString(),
+                            partnerAddress: params.partnerAddress,
+                            'omniPool.chainId': this.omniPoolConfig.chainId,
+                            'omniPool.address': this.omniPoolConfig.address,
+                        };
+                    },
+                    onReturn: (ret) => ({ priceImpact: ret.priceImpact.toFixed() }),
+                })];
+            _buildTradeA_decorators = [withTracing({
+                    onCall: function (tradeAContext) {
+                        return {
+                            tradeAContext,
+                            tokenOut: this.transitTokenIn.toString(),
+                        };
+                    },
+                })];
+            _buildTradeC_decorators = [withTracing()];
+            __esDecorate(this, null, _doExactIn_decorators, { kind: "method", name: "doExactIn", static: false, private: false, access: { has: obj => "doExactIn" in obj, get: obj => obj.doExactIn }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _buildTradeA_decorators, { kind: "method", name: "buildTradeA", static: false, private: false, access: { has: obj => "buildTradeA" in obj, get: obj => obj.buildTradeA }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _buildTradeC_decorators, { kind: "method", name: "buildTradeC", static: false, private: false, access: { has: obj => "buildTradeC" in obj, get: obj => obj.buildTradeC }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        // TODO rename to `transitAmount`
+        amountInUsd = __runInitializers(this, _instanceExtraInitializers);
+        from;
+        to;
+        tokenAmountIn;
+        tokenOut;
+        slippage;
+        deadline;
+        revertableAddresses;
+        tradeA;
+        transit;
+        tradeC;
+        symbiosis;
+        synthesisV2;
+        transitTokenIn;
+        transitTokenOut;
+        omniPoolConfig;
+        oneInchProtocols;
+        partnerAddress;
+        profiler;
+        constructor(symbiosis, omniPoolConfig) {
+            this.omniPoolConfig = omniPoolConfig;
+            this.symbiosis = symbiosis;
+            this.profiler = new Profiler();
+        }
+        async doExactIn({ tokenAmountIn, tokenOut, from, to, slippage, deadline, oneInchProtocols, transitTokenIn, transitTokenOut, revertableAddresses, tradeAContext, partnerAddress, }) {
+            const routes = [];
+            const routeType = [];
+            this.partnerAddress = partnerAddress;
+            this.oneInchProtocols = oneInchProtocols;
+            this.tokenAmountIn = tokenAmountIn;
+            this.tokenOut = tokenOut;
+            this.transitTokenIn =
+                transitTokenIn || this.symbiosis.transitToken(this.tokenAmountIn.token.chainId, this.omniPoolConfig);
+            this.transitTokenOut =
+                transitTokenOut || this.symbiosis.transitToken(this.tokenOut.chainId, this.omniPoolConfig);
+            this.from = tronAddressToEvm(from);
+            this.to = tronAddressToEvm(to);
+            this.slippage = this.buildDetailedSlippage(slippage);
+            this.deadline = deadline;
+            this.synthesisV2 = this.symbiosis.synthesis(this.omniPoolConfig.chainId);
+            if (isTronToken(this.tokenAmountIn.token) || isTronToken(this.tokenOut)) {
+                this.revertableAddresses = {
+                    AB: this.symbiosis.getRevertableAddress(this.tokenAmountIn.token.chainId),
+                    BC: this.symbiosis.getRevertableAddress(this.tokenOut.chainId),
+                };
+            }
+            else if (this.tokenAmountIn.token.chainId === ChainId.ABSTRACT_MAINNET ||
+                this.tokenOut.chainId === ChainId.ABSTRACT_MAINNET) {
+                this.revertableAddresses = {
+                    AB: this.symbiosis.getRevertableAddress(this.tokenAmountIn.token.chainId),
+                    BC: this.symbiosis.getRevertableAddress(this.tokenOut.chainId),
+                };
+            }
+            else if (isTonChainId(this.tokenAmountIn.token.chainId) || isTonChainId(this.tokenOut.chainId)) {
+                this.revertableAddresses = {
+                    AB: this.symbiosis.getRevertableAddress(this.tokenAmountIn.token.chainId),
+                    BC: this.symbiosis.getRevertableAddress(this.tokenOut.chainId),
+                };
+            }
+            else if (revertableAddresses) {
+                const AB = revertableAddresses.find((ra) => ra.chainId === this.tokenAmountIn.token.chainId);
+                if (!AB) {
+                    throw new SdkError(`Revertable address for chain ${this.tokenAmountIn.token.chainId} was not specified`);
+                }
+                const BC = revertableAddresses.find((ra) => ra.chainId === this.tokenOut.chainId);
+                if (!BC) {
+                    throw new SdkError(`Revertable address for chain ${this.tokenOut.chainId} was not specified`);
+                }
+                this.revertableAddresses = { AB: AB.address, BC: BC.address };
+            }
+            else {
+                this.revertableAddresses = {
+                    AB: this.symbiosis.getRevertableAddress(this.tokenAmountIn.token.chainId),
+                    BC: this.from,
+                };
+            }
+            if (!this.transitTokenIn.equals(tokenAmountIn.token)) {
+                this.tradeA = await this.buildTradeA(tradeAContext);
+                this.profiler.tick('A');
+                routes.push({
+                    provider: this.tradeA.tradeType,
+                    tokens: [this.tradeA.tokenAmountIn.token, this.tradeA.amountOut.token],
+                });
+                if (this.tradeA.tradeType !== 'wrap') {
+                    routeType.push('ANY');
+                }
+            }
+            const transitAmountIn = this.tradeA ? this.tradeA.amountOut : this.tokenAmountIn;
+            const transitAmountInMin = this.tradeA ? this.tradeA.amountOutMin : this.tokenAmountIn;
+            routes.push({
+                provider: 'symbiosis',
+                tokens: [this.transitTokenIn, this.transitTokenOut],
+            });
+            routeType.push('TRANSIT');
+            const promises = [
+                this.buildTransit(transitAmountIn, transitAmountInMin).init(),
+                (async () => {
+                    if (this.transitTokenOut.equals(tokenOut)) {
+                        // No need to trade on chain C if a transit token is what the user needs.
+                        return;
+                    }
+                    const fakeTradeCAmountIn = createFakeAmount(transitAmountIn, this.transitTokenOut);
+                    const fakeTradeCAmountInMin = createFakeAmount(new TokenAmount(transitAmountIn.token, getMinAmount(this.slippage['B'], transitAmountInMin.raw)), this.transitTokenOut);
+                    return this.buildTradeC(fakeTradeCAmountIn, fakeTradeCAmountInMin);
+                })(),
+            ];
+            const endTimerTransit = this.symbiosis.createMetricTimer();
+            const [transit, tradeC] = await Promise.all(promises);
+            endTimerTransit?.({
+                kind: 'crosschain-swap',
+                operation: tradeC ? 'transit + c' : 'transit',
+                tokenIn: this.transitTokenIn,
+                tokenOut: this.transitTokenOut,
+            });
+            this.profiler.tick(tradeC ? 'TRANSIT + C' : 'TRANSIT');
+            this.transit = transit;
+            // this call is necessary because buildMulticall depends on the result of doPostTransitAction
+            await this.doPostTransitAction();
+            this.profiler.tick('POST_TRANSIT_1');
+            this.tradeC = tradeC;
+            if (this.tradeC) {
+                routes.push({
+                    provider: this.tradeC.tradeType,
+                    tokens: [this.tradeC.tokenAmountIn.token, this.tradeC.amountOut.token],
+                });
+                if (this.tradeC.tradeType !== 'wrap') {
+                    routeType.push('ANY');
+                }
+            }
+            this.amountInUsd = this.transit.getBridgeAmountIn();
+            const endTimerAdvisor = this.symbiosis.createMetricTimer();
+            const { fee1Raw, fee2Raw } = await this.getAdvisorFees();
+            endTimerAdvisor?.({
+                kind: 'crosschain-swap',
+                operation: 'advisor',
+            });
+            this.profiler.tick('ADVISOR');
+            const fee1 = fee1Raw.fee;
+            const save1 = fee1Raw.save;
+            const fee2 = fee2Raw?.fee;
+            const save2 = fee2Raw?.save;
+            await this.transit.applyFees(fee1, fee2);
+            if (this.tradeC) {
+                this.tradeC.applyAmountIn(this.transit.amountOut, this.transit.amountOutMin);
+            }
+            this.profiler.tick('PATCHING');
+            await this.doPostTransitAction();
+            this.profiler.tick('POST_TRANSIT_2');
+            const tokenAmountOut = this.tradeC ? this.tradeC.amountOut : this.transit.amountOut;
+            const tokenAmountOutMin = this.tradeC ? this.tradeC.amountOutMin : this.transit.amountOutMin;
+            let payload;
+            if (isEvmChainId(this.tokenAmountIn.token.chainId)) {
+                const metaRouteParams = this.getMetaRouteParams(fee1, fee2);
+                const transactionRequest = this.getEvmTransactionRequest(metaRouteParams);
+                payload = {
+                    transactionType: 'evm',
+                    transactionRequest,
+                };
+            }
+            else if (isTronChainId(this.tokenAmountIn.token.chainId)) {
+                const metaRouteParams = this.getMetaRouteParams(fee1, fee2);
+                const transactionRequest = this.getTronTransactionRequest(metaRouteParams);
+                payload = {
+                    transactionType: 'tron',
+                    transactionRequest,
+                };
+            }
+            else if (isTonChainId(this.tokenAmountIn.token.chainId)) {
+                const transactionRequest = await this.getTonTransactionRequest(fee1, fee2);
+                payload = {
+                    transactionType: 'ton',
+                    transactionRequest,
+                };
+            }
+            else {
+                throw new SdkError(`Unsupported chain type: ${this.tokenAmountIn.token.chainId}`);
+            }
+            this.profiler.tick('TRANSACTION_REQUEST');
+            const fees = [
+                {
+                    provider: 'symbiosis',
+                    value: fee1,
+                    description: 'Cross-chain fee',
+                    save: save1,
+                },
+            ];
+            if (fee2) {
+                fees.push({
+                    provider: 'symbiosis',
+                    value: fee2,
+                    description: 'Cross-chain fee',
+                    save: save2,
+                });
+            }
+            if (this.transit.partnerFeeCall) {
+                fees.push(...this.transit.partnerFeeCall.fees);
+            }
+            return {
+                ...payload,
+                kind: 'crosschain-swap',
+                tokenAmountOut,
+                tokenAmountOutMin,
+                priceImpact: this.calculatePriceImpact(),
+                approveTo: this.approveTo(),
+                routes,
+                fees,
+                amountInUsd: this.amountInUsd,
+                timeLog: this.profiler.toString(),
+                routeType: routeType.join('-'),
+                poolAddress: this.omniPoolConfig.address,
+                tradeA: this.tradeA,
+                tradeC: this.tradeC,
+            };
+        }
+        async getAdvisorFees() {
+            const feePromises = [];
+            let feeToken1 = this.transit.feeToken1;
+            if (feeToken1.chainFromId) {
+                const original = this.symbiosis.getRepresentation(feeToken1, feeToken1.chainFromId);
+                if (original) {
+                    feeToken1 = original;
+                }
+            }
+            const fee1Config = this.symbiosis.feesConfig?.find((i) => i.token.equals(feeToken1));
+            if (fee1Config) {
+                feePromises.push({
+                    fee: new TokenAmount(this.transit.feeToken1, fee1Config.value),
+                    save: new TokenAmount(this.transit.feeToken1, '0'),
+                });
+            }
+            else {
+                feePromises.push(this.getFee(this.transit.feeToken1));
+            }
+            let feeToken2 = this.transit.feeToken2;
+            if (feeToken2) {
+                if (feeToken2.chainFromId) {
+                    const original = this.symbiosis.getRepresentation(feeToken2, feeToken2.chainFromId);
+                    if (original) {
+                        feeToken2 = original;
+                    }
+                }
+                const fee2Config = this.symbiosis.feesConfig?.find((i) => i.token.equals(feeToken2));
+                if (fee2Config) {
+                    feePromises.push({
+                        fee: new TokenAmount(this.transit.feeToken2, fee2Config.value),
+                        save: new TokenAmount(this.transit.feeToken2, '0'),
+                    });
+                }
+                else {
+                    feePromises.push(this.getFeeV2(this.transit.feeToken2));
+                }
+            }
+            else {
+                feePromises.push(undefined);
+            }
+            const [fee1Raw, fee2Raw] = await Promise.all(feePromises);
+            return {
+                fee1Raw,
+                fee2Raw,
+            };
+        }
+        getRevertableAddress(side) {
+            return this.revertableAddresses[side];
+        }
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        async doPostTransitAction() { }
+        buildDetailedSlippage(totalSlippage) {
+            const hasTradeA = !this.transitTokenIn.equals(wrappedToken(this.tokenAmountIn.token));
+            const hasTradeC = !this.transitTokenOut.equals(wrappedToken(this.tokenOut));
+            return splitSlippage(totalSlippage, hasTradeA, hasTradeC);
+        }
+        approveTo() {
+            return this.symbiosis.chainConfig(this.tokenAmountIn.token.chainId).metaRouterGateway;
+        }
+        getValue() {
+            return this.tokenAmountIn.token.isNative ? this.tokenAmountIn.raw.toString() : '0';
+        }
+        getMetaRouteParams(fee, feeV2) {
+            const [relayRecipient, otherSideCalldata] = this.otherSideData(fee, feeV2);
+            const amount = this.tradeA ? this.tradeA.tokenAmountIn : this.tokenAmountIn;
+            return {
+                amount: amount.raw.toString(),
+                nativeIn: amount.token.isNative,
+                approvedTokens: this.approvedTokens().map(tronAddressToEvm),
+                firstDexRouter: tronAddressToEvm(this.firstDexRouter()),
+                firstSwapCalldata: this.firstSwapCalldata(),
+                secondDexRouter: tronAddressToEvm(this.secondDexRouter()),
+                secondSwapCalldata: this.transit.direction === 'burn' ? this.secondSwapCalldata() : [],
+                relayRecipient,
+                otherSideCalldata,
+            };
+        }
+        getEvmTransactionRequest(params) {
+            const chainId = this.tokenAmountIn.token.chainId;
+            const metaRouter = this.symbiosis.metaRouter(chainId);
+            const data = metaRouter.interface.encodeFunctionData('metaRoute', [params]);
+            return {
+                chainId,
+                to: metaRouter.address,
+                data,
+                value: this.getValue(),
+            };
+        }
+        getTronTransactionRequest(params) {
+            const { chainId } = this.tokenAmountIn.token;
+            const { metaRouter } = this.symbiosis.chainConfig(chainId);
+            const tronWeb = this.symbiosis.tronWeb(chainId);
+            return prepareTronTransaction({
+                chainId,
+                tronWeb,
+                abi: TRON_METAROUTER_ABI,
+                contractAddress: metaRouter,
+                functionName: 'metaRoute',
+                params: [
+                    [
+                        params.firstSwapCalldata,
+                        params.secondSwapCalldata,
+                        params.approvedTokens,
+                        params.firstDexRouter,
+                        params.secondDexRouter,
+                        params.amount,
+                        params.nativeIn,
+                        params.relayRecipient,
+                        params.otherSideCalldata,
+                    ],
+                ],
+                ownerAddress: this.from,
+                value: this.getValue(),
+            });
+        }
+        async getTonTransactionRequest(fee, feeV2) {
+            let secondSwapCallData = this.secondSwapCalldata();
+            if (secondSwapCallData.length === 0) {
+                secondSwapCallData = '';
+            }
+            return buildMetaSynthesize({
+                symbiosis: this.symbiosis,
+                fee,
+                amountIn: this.transit.getBridgeAmountIn(),
+                secondDexRouter: this.secondDexRouter(),
+                secondSwapCallData: secondSwapCallData,
+                swapTokens: this.swapTokens().map(tronAddressToEvm),
+                from: this.from,
+                to: this.to,
+                revertableAddress: this.getRevertableAddress('AB'),
+                chainIdOut: this.omniPoolConfig.chainId,
+                validUntil: this.deadline,
+                finalReceiveSide: tronAddressToEvm(this.transit.isV2() ? this.finalReceiveSideV2() : AddressZero),
+                finalCallData: this.transit.isV2() ? this.finalCalldataV2(feeV2) : '',
+                finalOffset: this.transit.isV2() ? this.finalOffsetV2() : 0,
+            });
+        }
+        calculatePriceImpact() {
+            const zero = new Percent(JSBI.BigInt(0), BIPS_BASE); // 0%
+            const pia = this.tradeA?.priceImpact || zero;
+            const pib = this.transit.trade.priceImpact || zero;
+            const pic = this.tradeC?.priceImpact || zero;
+            let pi = pia.add(pib).add(pic);
+            const max = new Percent(JSBI.BigInt(10000), BIPS_BASE); // 100%
+            if (pi.greaterThan(max))
+                pi = max;
+            return new Percent(pi.numerator, pi.denominator);
+        }
+        async buildTradeA(tradeAContext) {
+            const tokenOut = this.transitTokenIn;
+            if (WrapTrade.isSupported(this.tokenAmountIn.token, tokenOut)) {
+                return new WrapTrade({
+                    tokenAmountIn: this.tokenAmountIn,
+                    tokenAmountInMin: this.tokenAmountIn, // correct because it is tradeA
+                    tokenOut,
+                    to: this.to,
+                });
+            }
+            const chainId = this.tokenAmountIn.token.chainId;
+            let from = this.symbiosis.chainConfig(chainId).metaRouter;
+            if (tradeAContext === 'multicallRouter') {
+                from = this.symbiosis.chainConfig(chainId).multicallRouter;
+            }
+            const to = from;
+            const trade = new AggregatorTrade({
+                tokenAmountIn: this.tokenAmountIn,
+                tokenAmountInMin: this.tokenAmountIn, // correct because it is tradeA
+                tokenOut,
+                from,
+                to,
+                slippage: this.slippage['A'],
+                symbiosis: this.symbiosis,
+                clientId: this.symbiosis.clientId,
+                deadline: this.deadline,
+                oneInchProtocols: this.oneInchProtocols,
+                preferOneInchUsage: isUseOneInchOnly(this),
+            });
+            const endTimerTradeA = this.symbiosis.createMetricTimer();
+            await trade.init();
+            endTimerTradeA?.({
+                operation: 'tradeA',
+                kind: 'crosschain-swap',
+                tokenIn: this.tokenAmountIn.token,
+                tokenOut: this.transitTokenIn,
+            });
+            return trade;
+        }
+        buildTransit(amountIn, amountInMin) {
+            this.symbiosis.validateLimits(amountIn);
+            return new Transit({
+                symbiosis: this.symbiosis,
+                amountIn,
+                amountInMin,
+                tokenOut: this.transitTokenOut,
+                slippage: this.slippage['B'],
+                deadline: this.deadline,
+                omniPoolConfig: this.omniPoolConfig,
+                partnerAddress: this.partnerAddress,
+            });
+        }
+        tradeCTo() {
+            return this.to;
+        }
+        /**
+         * Build final trade.
+         * @param amountIn
+         * @param amountInMin
+         * @returns initialized SymbiosisTrade.
+         */
+        async buildTradeC(amountIn, amountInMin) {
+            if (WrapTrade.isSupported(amountIn.token, this.tokenOut)) {
+                // We need to just wrap or unwrap the token.
+                return await new WrapTrade({
+                    tokenAmountIn: amountIn,
+                    tokenAmountInMin: amountInMin,
+                    tokenOut: this.tokenOut,
+                    to: this.to,
+                }).init();
+            }
+            const aggTrade = await new AggregatorTrade({
+                tokenAmountIn: amountIn,
+                tokenAmountInMin: amountInMin,
+                tokenOut: this.tokenOut,
+                from: this.symbiosis.chainConfig(this.tokenOut.chainId).metaRouter,
+                to: this.tradeCTo(),
+                slippage: this.slippage['C'],
+                symbiosis: this.symbiosis,
+                clientId: this.symbiosis.clientId,
+                deadline: this.deadline,
+                oneInchProtocols: this.oneInchProtocols,
+                preferOneInchUsage: isUseOneInchOnly(this),
+            }).init();
+            const dep = await this.symbiosis.depository(this.transitTokenOut.chainId);
+            if (dep) {
+                const depositParams = {
+                    tokenAmountIn: aggTrade.tokenAmountIn,
+                    tokenAmountInMin: aggTrade.tokenAmountInMin,
+                    to: aggTrade.to,
+                    outToken: aggTrade.amountOut.token,
+                    ...amountsToPrices(aggTrade, aggTrade.tokenAmountIn),
+                    extraBranches: [],
+                    ...dep.makeTargetCall(aggTrade),
+                };
+                // If there is a Depository on a C chain, then use aggTrade for price detection.
+                return await new DepositoryTrade(aggTrade, dep, depositParams, aggTrade).init();
+            }
+            else {
+                return aggTrade;
+            }
+        }
+        metaBurnSyntheticToken(fee1) {
+            const synthesis = this.symbiosis.synthesis(this.tokenAmountIn.token.chainId);
+            const amount = this.transit.getBridgeAmountIn();
+            return [
+                synthesis.address,
+                synthesis.interface.encodeFunctionData('metaBurnSyntheticToken', [
+                    {
+                        stableBridgingFee: fee1.raw.toString(),
+                        amount: amount.raw.toString(),
+                        syntCaller: tronAddressToEvm(this.from),
+                        crossChainID: CROSS_CHAIN_ID,
+                        finalReceiveSide: tronAddressToEvm(this.finalReceiveSide()),
+                        sToken: tronAddressToEvm(amount.token.address),
+                        finalCallData: this.finalCalldata(),
+                        finalOffset: this.finalOffset(),
+                        chain2address: tronAddressToEvm(this.to),
+                        receiveSide: tronAddressToEvm(this.symbiosis.portal(this.tokenOut.chainId).address),
+                        oppositeBridge: tronAddressToEvm(this.symbiosis.bridge(this.tokenOut.chainId).address),
+                        revertableAddress: this.getRevertableAddress('BC'),
+                        chainID: this.tokenOut.chainId,
+                        clientID: this.symbiosis.clientId,
+                    },
+                ]),
+            ];
+        }
+        metaSynthesize(fee1, fee2) {
+            const chainIdIn = this.tokenAmountIn.token.chainId;
+            const chainIdOut = this.transit.isV2() ? this.omniPoolConfig.chainId : this.tokenOut.chainId;
+            const tokenAmount = this.transit.getBridgeAmountIn();
+            const portal = this.symbiosis.portal(chainIdIn);
+            return [
+                portal.address,
+                portal.interface.encodeFunctionData('metaSynthesize', [
+                    {
+                        stableBridgingFee: fee1.raw.toString(),
+                        amount: tokenAmount.raw.toString(),
+                        rtoken: tronAddressToEvm(tokenAmount.token.address),
+                        chain2address: this.to,
+                        receiveSide: tronAddressToEvm(this.symbiosis.synthesis(chainIdOut).address),
+                        oppositeBridge: tronAddressToEvm(this.symbiosis.bridge(chainIdOut).address),
+                        syntCaller: tronAddressToEvm(this.from),
+                        chainID: chainIdOut,
+                        swapTokens: this.swapTokens().map(tronAddressToEvm),
+                        secondDexRouter: tronAddressToEvm(this.secondDexRouter()),
+                        secondSwapCalldata: this.secondSwapCalldata(),
+                        finalReceiveSide: tronAddressToEvm(this.transit.isV2() ? this.finalReceiveSideV2() : AddressZero),
+                        finalCalldata: this.transit.isV2() ? this.finalCalldataV2(fee2) : [],
+                        finalOffset: this.transit.isV2() ? this.finalOffsetV2() : 0,
+                        revertableAddress: this.getRevertableAddress('AB'),
+                        clientID: this.symbiosis.clientId,
+                    },
+                ]),
+            ];
+        }
+        otherSideData(fee1, fee2) {
+            return this.transit.direction === 'burn' ? this.metaBurnSyntheticToken(fee1) : this.metaSynthesize(fee1, fee2); // mint or v2
+        }
+        feeMintCallData() {
+            const chainIdIn = this.tokenAmountIn.token.chainId;
+            const chainIdOut = this.transit.isV2() ? this.omniPoolConfig.chainId : this.tokenOut.chainId;
+            const portalAddress = tronAddressToEvm(this.symbiosis.chainConfig(chainIdIn).portal);
+            const synthesisAddress = tronAddressToEvm(this.symbiosis.chainConfig(chainIdOut).synthesis);
+            const internalId = getInternalId({
+                contractAddress: portalAddress,
+                requestCount: MaxUint256,
+                chainId: chainIdIn,
+            });
+            const externalId = getExternalId({
+                internalId,
+                contractAddress: synthesisAddress,
+                revertableAddress: this.getRevertableAddress('AB'),
+                chainId: chainIdOut,
+            });
+            const amount = this.transit.getBridgeAmountIn();
+            const synthesisInterface = Synthesis__factory.createInterface();
+            const callData = synthesisInterface.encodeFunctionData('metaMintSyntheticToken', [
+                {
+                    stableBridgingFee: '0',
+                    amount: amount.raw.toString(),
+                    crossChainID: CROSS_CHAIN_ID,
+                    externalID: externalId,
+                    tokenReal: tronAddressToEvm(amount.token.address),
+                    chainID: chainIdIn,
+                    to: tronAddressToEvm(this.to),
+                    swapTokens: this.swapTokens().map(tronAddressToEvm),
+                    secondDexRouter: tronAddressToEvm(this.secondDexRouter()),
+                    secondSwapCalldata: this.secondSwapCalldata(),
+                    finalReceiveSide: tronAddressToEvm(this.transit.isV2() ? this.finalReceiveSideV2() : AddressZero),
+                    finalCalldata: this.transit.isV2() ? this.finalCalldataV2() : [],
+                    finalOffset: this.transit.isV2() ? this.finalOffsetV2() : 0,
+                },
+            ]);
+            return [synthesisAddress, callData];
+        }
+        feeBurnCallData() {
+            const chainIdIn = this.tokenAmountIn.token.chainId;
+            const chainIdOut = this.tokenOut.chainId;
+            const synthesisAddress = tronAddressToEvm(this.symbiosis.chainConfig(chainIdIn).synthesis);
+            const portalAddress = tronAddressToEvm(this.symbiosis.chainConfig(chainIdOut).portal);
+            const internalId = getInternalId({
+                contractAddress: synthesisAddress,
+                requestCount: MaxUint256,
+                chainId: chainIdIn,
+            });
+            const externalId = getExternalId({
+                internalId,
+                contractAddress: portalAddress,
+                revertableAddress: this.getRevertableAddress('AB'),
+                chainId: chainIdOut,
+            });
+            const amount = this.transit.amountOut;
+            const portalInterface = Portal__factory.createInterface();
+            const calldata = portalInterface.encodeFunctionData('metaUnsynthesize', [
+                '0', // _stableBridgingFee
+                CROSS_CHAIN_ID, // crossChainID
+                externalId, // _externalID,
+                tronAddressToEvm(this.to), // _to
+                amount.raw.toString(), // _amount
+                tronAddressToEvm(amount.token.address), // _rToken
+                tronAddressToEvm(this.finalReceiveSide()), // _finalReceiveSide
+                this.finalCalldata(), // _finalCalldata
+                this.finalOffset(), // _finalOffset
+            ]);
+            return [portalAddress, calldata];
+        }
+        feeBurnCallDataV2() {
+            const chainIdIn = this.omniPoolConfig.chainId;
+            const chainIdOut = this.tokenOut.chainId;
+            const synthesisAddress = tronAddressToEvm(this.symbiosis.chainConfig(chainIdIn).synthesis);
+            const portalAddress = tronAddressToEvm(this.symbiosis.chainConfig(chainIdOut).portal);
+            const internalId = getInternalId({
+                contractAddress: synthesisAddress,
+                requestCount: MaxUint256,
+                chainId: chainIdIn,
+            });
+            const externalId = getExternalId({
+                internalId,
+                contractAddress: portalAddress,
+                revertableAddress: this.getRevertableAddress('BC'),
+                chainId: chainIdOut,
+            });
+            const portalInterface = Portal__factory.createInterface();
+            const calldata = portalInterface.encodeFunctionData('metaUnsynthesize', [
+                '0', // _stableBridgingFee
+                CROSS_CHAIN_ID, // crossChainID
+                externalId, // _externalID,
+                tronAddressToEvm(this.to), // _to
+                this.transit.amountOut.raw.toString(), // _amount
+                tronAddressToEvm(this.transitTokenOut.address), // _rToken
+                tronAddressToEvm(this.finalReceiveSide()), // _finalReceiveSide
+                this.finalCalldata(), // _finalCalldata
+                this.finalOffset(), // _finalOffset
+            ]);
+            return [portalAddress, calldata];
+        }
+        async getFee(feeToken) {
+            const chainIdFrom = this.tokenAmountIn.token.chainId;
+            const chainIdTo = this.transit.isV2() ? this.omniPoolConfig.chainId : this.tokenOut.chainId;
+            const [receiveSide, calldata] = this.transit.direction === 'burn' ? this.feeBurnCallData() : this.feeMintCallData(); // mint or v2
+            const { price: fee, save } = await this.symbiosis.getBridgeFee({
+                receiveSide,
+                calldata,
+                chainIdFrom,
+                chainIdTo,
+            });
+            return {
+                fee: new TokenAmount(feeToken, fee),
+                save: new TokenAmount(feeToken, save),
+            };
+        }
+        async getFeeV2(feeToken) {
+            const [receiveSide, calldata] = this.feeBurnCallDataV2();
+            const { price: fee, save } = await this.symbiosis.getBridgeFee({
+                receiveSide,
+                calldata,
+                chainIdFrom: this.omniPoolConfig.chainId,
+                chainIdTo: this.tokenOut.chainId,
+            });
+            return {
+                fee: new TokenAmount(feeToken, fee),
+                save: new TokenAmount(feeToken, save),
+            };
+        }
+        approvedTokens() {
+            let firstToken = this.tradeA ? this.tradeA.tokenAmountIn.token.address : this.tokenAmountIn.token.address;
+            if (!firstToken) {
+                firstToken = AddressZero; // AddressZero if first token is GasToken
+            }
+            let tokens;
+            if (this.transit.direction === 'burn') {
+                tokens = [firstToken, ...this.transit.trade.route.map((i) => i.address)];
+            }
+            else {
+                tokens = [firstToken, this.tradeA ? this.tradeA.amountOut.token.address : this.tokenAmountIn.token.address];
+            }
+            return tokens;
+        }
+        firstDexRouter() {
+            return this.tradeA?.routerAddress || AddressZero;
+        }
+        firstSwapCalldata() {
+            return this.tradeA?.callData || [];
+        }
+        secondDexRouter() {
+            const multicallRouter = this.symbiosis.multicallRouter(this.omniPoolConfig.chainId);
+            return multicallRouter.address;
+        }
+        secondSwapCalldata() {
+            const calls = this.transit.calls();
+            if (!calls) {
+                return [];
+            }
+            const { calldatas, receiveSides, paths, offsets } = calls;
+            // this flow when there is swap on host chain, for example, USDC -> BOBA
+            if (this.transit.direction === 'mint' && this.tradeC) {
+                calldatas.push(this.finalCalldata());
+                receiveSides.push(this.finalReceiveSide());
+                paths.push(wrappedToken(this.tradeC.amountOut.token).address);
+                offsets.push(this.finalOffset());
+            }
+            const multicallRouter = this.symbiosis.multicallRouter(this.omniPoolConfig.chainId);
+            return multicallRouter.interface.encodeFunctionData('multicall', [
+                this.transit.amountIn.raw.toString(),
+                calldatas,
+                receiveSides,
+                paths,
+                offsets,
+                this.symbiosis.metaRouter(this.omniPoolConfig.chainId).address,
+            ]);
+        }
+        finalReceiveSide() {
+            return this.tradeC?.routerAddress || AddressZero;
+        }
+        finalCalldata() {
+            return this.tradeC?.callData || [];
+        }
+        finalOffset() {
+            return this.tradeC?.callDataOffset || 0;
+        }
+        finalReceiveSideV2() {
+            return this.synthesisV2.address;
+        }
+        finalCalldataV2(fee2) {
+            const amount = this.transit.trade.amountOut;
+            return this.synthesisV2.interface.encodeFunctionData('metaBurnSyntheticToken', [
+                {
+                    stableBridgingFee: fee2 ? fee2?.raw.toString() : '0',
+                    amount: amount.raw.toString(),
+                    syntCaller: tronAddressToEvm(this.symbiosis.metaRouter(this.omniPoolConfig.chainId).address),
+                    crossChainID: CROSS_CHAIN_ID,
+                    finalReceiveSide: tronAddressToEvm(this.finalReceiveSide()),
+                    sToken: tronAddressToEvm(amount.token.address),
+                    finalCallData: this.finalCalldata(),
+                    finalOffset: this.finalOffset(),
+                    chain2address: tronAddressToEvm(this.to),
+                    receiveSide: tronAddressToEvm(this.symbiosis.portal(this.tokenOut.chainId).address),
+                    oppositeBridge: tronAddressToEvm(this.symbiosis.bridge(this.tokenOut.chainId).address),
+                    revertableAddress: this.getRevertableAddress('BC'),
+                    chainID: this.tokenOut.chainId,
+                    clientID: this.symbiosis.clientId,
+                },
+            ]);
+        }
+        finalOffsetV2() {
+            return 100;
+        }
+        swapTokens() {
+            if (this.transit.trade.route.length === 0) {
+                return [];
+            }
+            const tokens = [
+                this.transit.trade.route[0].address,
+                this.transit.trade.route[this.transit.trade.route.length - 1].address,
+            ];
+            if (this.transit.isV2()) {
+                return tokens;
+            }
+            if (this.tradeC) {
+                tokens.push(wrappedToken(this.tradeC.amountOut.token).address);
+            }
+            else {
+                tokens.push(...this.extraSwapTokens());
+            }
+            return tokens;
+        }
+        extraSwapTokens() {
+            return [];
+        }
+    };
+})();
+export { BaseSwapping };
+function createFakeAmount(tokenAmount, token) {
+    const decimalsA = JSBI.exponentiate(JSBI.BigInt(10), JSBI.BigInt(tokenAmount.token.decimals));
+    const decimalsB = JSBI.exponentiate(JSBI.BigInt(10), JSBI.BigInt(token.decimals));
+    const fakeAmountRaw = JSBI.divide(JSBI.multiply(tokenAmount.raw, decimalsB), decimalsA);
+    return new TokenAmount(token, fakeAmountRaw);
+}
+//# sourceMappingURL=baseSwapping.js.map