rubic-sdk 5.53.0-alpha.unichain.15 → 5.53.0-alpha.unichain.16

package/lib/features/on-chain/calculation-manager/providers/dexes/common/sync-swap-abstract/utils/sync-swap-path-factory.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncSwapPathFactory = void 0;
+const ethers_1 = require("ethers");
+const sync_swap_router_1 = require("./sync-swap-router");
+const constants_1 = require("./constants");
+class SyncSwapPathFactory {
+    static hasLiquidity(routePool, tokenInAddress, amountOut) {
+        if (tokenInAddress && amountOut) {
+            const reserveOut = routePool.tokenA === tokenInAddress ? routePool.reserveB : routePool.reserveA;
+            return reserveOut.gt(amountOut);
+        }
+        return (routePool.reserveA.gte(SyncSwapPathFactory.liquidityMinReserve) &&
+            routePool.reserveB.gte(SyncSwapPathFactory.liquidityMinReserve));
+    }
+    static createPath(steps) {
+        return steps.map(({ routePool, tokenInAddress }) => {
+            const step = {
+                pool: routePool,
+                tokenIn: tokenInAddress,
+                swapFee: tokenInAddress === routePool.tokenA ? routePool.swapFeeAB : routePool.swapFeeBA
+            };
+            return step;
+        });
+    }
+    static getPoolKey(tokenAAddress, tokenBAddress, poolType) {
+        return tokenAAddress < tokenBAddress
+            ? `${tokenAAddress}:${tokenBAddress}:${poolType}`
+            : `${tokenBAddress}:${tokenAAddress}:${poolType}`;
+    }
+    static getPathsWith1Hop(poolsA, poolsB, tokenIn, baseToken) {
+        const paths = [];
+        for (const poolA of poolsA) {
+            for (const poolB of poolsB) {
+                if (poolA && poolB) {
+                    paths.push(SyncSwapPathFactory.createPath([
+                        { routePool: poolA, tokenInAddress: tokenIn },
+                        { routePool: poolB, tokenInAddress: baseToken }
+                    ]));
+                }
+            }
+        }
+        return paths;
+    }
+    static getPathsWith2Hops(poolsA, poolsBase, poolsB, tokenIn, baseToken1, baseToken2) {
+        const paths = [];
+        for (const poolA of poolsA) {
+            for (const poolBase of poolsBase) {
+                for (const poolB of poolsB) {
+                    if (poolA && poolBase && poolB) {
+                        paths.push(SyncSwapPathFactory.createPath([
+                            { routePool: poolA, tokenInAddress: tokenIn },
+                            { routePool: poolBase, tokenInAddress: baseToken1 },
+                            { routePool: poolB, tokenInAddress: baseToken2 }
+                        ]));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    static findAllPossiblePaths(tokenIn, tokenOut, routePools, enableHops = true) {
+        const { pools: { poolsDirect, poolsA, poolsB, poolsBase }, routeTokens } = routePools;
+        const paths = [];
+        for (const pool of poolsDirect) {
+            if (SyncSwapPathFactory.hasLiquidity(pool, tokenIn)) {
+                const path = SyncSwapPathFactory.createPath([
+                    {
+                        routePool: pool,
+                        tokenInAddress: tokenIn
+                    }
+                ]);
+                paths.push(path);
+            }
+        }
+        if (!enableHops)
+            return paths;
+        const poolsByPoolKey = new Map();
+        for (const pool of [...poolsA, ...poolsB, ...poolsBase]) {
+            if (SyncSwapPathFactory.hasLiquidity(pool)) {
+                poolsByPoolKey.set(SyncSwapPathFactory.getPoolKey(pool.tokenA, pool.tokenB, pool.poolType), pool);
+            }
+        }
+        for (const baseToken of routeTokens) {
+            if (baseToken === tokenIn || baseToken === tokenOut) {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            const poolA1 = poolsByPoolKey.get(SyncSwapPathFactory.getPoolKey(tokenIn, baseToken, '1'));
+            const poolA2 = poolsByPoolKey.get(SyncSwapPathFactory.getPoolKey(tokenIn, baseToken, '2'));
+            const poolB1 = poolsByPoolKey.get(SyncSwapPathFactory.getPoolKey(baseToken, tokenOut, '1'));
+            const poolB2 = poolsByPoolKey.get(SyncSwapPathFactory.getPoolKey(baseToken, tokenOut, '2'));
+            paths.push(...SyncSwapPathFactory.getPathsWith1Hop([poolA1, poolA2].filter(Boolean), [poolB1, poolB2].filter(Boolean), tokenIn, baseToken));
+        }
+        for (const baseToken1 of routeTokens) {
+            if (baseToken1 === tokenIn || baseToken1 === tokenOut) {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            const poolA1 = poolsByPoolKey.get(SyncSwapPathFactory.getPoolKey(tokenIn, baseToken1, '1'));
+            const poolA2 = poolsByPoolKey.get(SyncSwapPathFactory.getPoolKey(tokenIn, baseToken1, '2'));
+            for (const baseToken2 of routeTokens) {
+                if (baseToken2 === tokenIn ||
+                    baseToken2 === tokenOut ||
+                    baseToken2 === baseToken1) {
+                    // eslint-disable-next-line no-continue
+                    continue;
+                }
+                const poolBase1 = poolsByPoolKey.get(SyncSwapPathFactory.getPoolKey(baseToken1, baseToken2, '1'));
+                const poolBase2 = poolsByPoolKey.get(SyncSwapPathFactory.getPoolKey(baseToken1, baseToken2, '2'));
+                const poolB1 = poolsByPoolKey.get(SyncSwapPathFactory.getPoolKey(baseToken2, tokenOut, '1'));
+                const poolB2 = poolsByPoolKey.get(SyncSwapPathFactory.getPoolKey(baseToken2, tokenOut, '2'));
+                paths.push(...SyncSwapPathFactory.getPathsWith2Hops([poolA1, poolA2].filter(Boolean), [poolBase1, poolBase2].filter(Boolean), [poolB1, poolB2].filter(Boolean), tokenIn, baseToken1, baseToken2));
+            }
+        }
+        return paths;
+    }
+    static async getBestPath(paths, amountIn, blockchainName) {
+        const pathAmountIn = ethers_1.BigNumber.from(amountIn);
+        const pathsWithAmount = await Promise.all(paths.map(async (path, index) => ({
+            pathWithAmounts: await sync_swap_router_1.SyncSwapRouter.calculatePathAmountsByInput(path, pathAmountIn, false, blockchainName),
+            index
+        })));
+        const sortedIndexes = pathsWithAmount
+            .sort((next, prev) => {
+            if (!prev.pathWithAmounts) {
+                return next.pathWithAmounts?.amountOut ? -1 : 1;
+            }
+            if (!next.pathWithAmounts) {
+                return 1;
+            }
+            return prev.pathWithAmounts.amountOut.lte(next.pathWithAmounts.amountOut) ? 1 : -1;
+        })
+            .map(path => path.index);
+        return paths.filter((_el, index) => sortedIndexes.slice(-4).includes(index));
+    }
+    static getQuoteOutStable(params) {
+        const multiplier = 10000;
+        const adjustedReserveIn = params.reserveIn
+            .mul(params.tokenInPrecisionMultiplier)
+            .mul(multiplier);
+        const adjustedReserveOut = params.reserveOut
+            .mul(params.tokenOutPrecisionMultiplier)
+            .mul(multiplier);
+        const amountIn = params.amount;
+        const feeDeductedAmountIn = amountIn.sub(amountIn.mul(params.swapFee).div(constants_1.MAX_FEE));
+        const d = sync_swap_router_1.SyncSwapRouter.computeDFromAdjustedBalances(constants_1.STABLE_POOL_A, adjustedReserveIn, adjustedReserveOut, false);
+        const x = adjustedReserveIn.add(feeDeductedAmountIn.mul(params.tokenInPrecisionMultiplier));
+        const y = sync_swap_router_1.SyncSwapRouter.getY(constants_1.STABLE_POOL_A, x, d);
+        const dy = adjustedReserveOut.sub(y).sub(1);
+        return dy.div(params.tokenOutPrecisionMultiplier);
+    }
+    static getQuoteOutClassic(params) {
+        const amountIn = params.amount;
+        const multiplier = 100000;
+        const amountInWithFee = amountIn.mul(constants_1.MAX_FEE.sub(params.swapFee));
+        return amountInWithFee
+            .mul(params.reserveOut.mul(multiplier))
+            .div(params.reserveIn.mul(multiplier).mul(constants_1.MAX_FEE));
+    }
+    static calculateQuoteOut(params) {
+        if (params.amount.isZero()) {
+            return constants_1.ZERO;
+        }
+        return params.stable
+            ? SyncSwapPathFactory.getQuoteOutStable(params)
+            : SyncSwapPathFactory.getQuoteOutClassic(params);
+    }
+}
+exports.SyncSwapPathFactory = SyncSwapPathFactory;
+SyncSwapPathFactory.liquidityMinReserve = ethers_1.BigNumber.from(1000);
+//# sourceMappingURL=sync-swap-path-factory.js.map

package/lib/features/on-chain/calculation-manager/providers/dexes/common/sync-swap-abstract/utils/sync-swap-path-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-swap-path-factory.js","sourceRoot":"","sources":["../../../../../../../../../src/features/on-chain/calculation-manager/providers/dexes/common/sync-swap-abstract/utils/sync-swap-path-factory.ts"],"names":[],"mappings":"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"}

package/lib/features/on-chain/calculation-manager/providers/dexes/common/sync-swap-abstract/utils/sync-swap-router.d.ts

@@ -0,0 +1,22 @@
+import { BigNumber } from 'ethers';
+import { EvmBlockchainName } from '../../../../../../../../core/blockchain/models/blockchain-name';
+import { BestPathsWithAmounts, Path, PathWithAmounts } from './typings';
+export declare class SyncSwapRouter {
+    static findBestAmountsForPathsExactIn(paths: Path[], amountInString: string, blockchainName: EvmBlockchainName, _ts?: number): Promise<BestPathsWithAmounts>;
+    private static copyStep;
+    private static getAmountOutClassic;
+    static computeDFromAdjustedBalances(A: BigNumber, xp0: BigNumber, xp1: BigNumber, checkOverflow: boolean): BigNumber;
+    static getY(A: BigNumber, x: BigNumber, d: BigNumber): BigNumber;
+    private static getAmountOutStable;
+    private static calculateAmountOut;
+    private static splitAmounts2;
+    private static splitAmounts3;
+    private static splitAmounts4;
+    private static splitAmounts5;
+    private static fixSplitAmounts;
+    private static splitAmount;
+    private static calculateAmountOutForStep;
+    static calculatePathAmountsByInput(path: Path, amountIn: BigNumber, _updateReserves: boolean, blockchainName: EvmBlockchainName): Promise<PathWithAmounts | null>;
+    private static calculateGroupAmounts;
+    private static getPoolPrecision;
+}

package/lib/features/on-chain/calculation-manager/providers/dexes/common/sync-swap-abstract/utils/sync-swap-router.js

@@ -0,0 +1,448 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncSwapRouter = void 0;
+const ethers_1 = require("ethers");
+const blockchain_1 = require("../../../../../../../../common/utils/blockchain");
+const decorators_1 = require("../../../../../../../../common/utils/decorators");
+const injector_1 = require("../../../../../../../../core/injector/injector");
+const sync_swap_stable_pool_1 = require("../sync-swap-stable-pool");
+const constants_1 = require("./constants");
+const sync_swap_path_factory_1 = require("./sync-swap-path-factory");
+const typings_1 = require("./typings");
+class SyncSwapRouter {
+    static async findBestAmountsForPathsExactIn(paths, amountInString, blockchainName, _ts) {
+        const amountIn = ethers_1.BigNumber.from(amountInString);
+        const pathAmounts = await SyncSwapRouter.splitAmount(amountIn, paths.length);
+        const groups = [];
+        const groupPromises = [];
+        for (const amounts of pathAmounts) {
+            const promise = new Promise((resolve, reject) => {
+                SyncSwapRouter.calculateGroupAmounts(paths, amounts, blockchainName).then(group => {
+                    if (group === null) {
+                        reject(new Error('expired'));
+                    }
+                    else {
+                        groups.push(group);
+                        resolve(true);
+                    }
+                });
+            });
+            groupPromises.push(promise);
+        }
+        await Promise.all(groupPromises);
+        let bestPathsWithAmounts = [];
+        let bestAmountOut = constants_1.ZERO;
+        let bestQuoteOut = constants_1.ZERO;
+        let bestPriceImpact = null;
+        for (const group of groups) {
+            const groupAmountOut = group.amountOut;
+            if (!groupAmountOut.isZero() && !group.quoteOut.isZero()) {
+                const amountLoss = group.quoteOut.sub(groupAmountOut);
+                const groupPriceImpact = amountLoss.mul(constants_1.ETHER).div(group.quoteOut);
+                if (bestPriceImpact === null || groupPriceImpact.lt(bestPriceImpact)) {
+                    bestPriceImpact = groupPriceImpact;
+                }
+                if (groupAmountOut.gt(bestAmountOut)) {
+                    bestPathsWithAmounts = group.pathsWithAmounts;
+                    bestAmountOut = groupAmountOut;
+                    bestQuoteOut = group.quoteOut;
+                }
+            }
+        }
+        return {
+            found: bestAmountOut !== null,
+            direction: typings_1.routeDirection.EXACT_IN,
+            pathsWithAmounts: bestPathsWithAmounts,
+            amountIn,
+            amountOut: bestAmountOut,
+            quote: bestQuoteOut,
+            bestPriceImpact,
+            gas: constants_1.ZERO
+        };
+    }
+    static copyStep(step) {
+        const pool = step.pool;
+        return {
+            pool: {
+                isAlpha: pool.isAlpha,
+                vault: pool.vault,
+                pool: pool.pool,
+                tokenA: pool.tokenA,
+                tokenB: pool.tokenB,
+                poolType: pool.poolType,
+                reserveA: ethers_1.BigNumber.from(pool.reserveA),
+                reserveB: ethers_1.BigNumber.from(pool.reserveB),
+                swapFeeAB: pool.swapFeeAB,
+                swapFeeBA: pool.swapFeeBA
+            },
+            tokenIn: step.tokenIn,
+            swapFee: step.swapFee
+        };
+    }
+    static getAmountOutClassic(params, checkOverflow) {
+        const amountIn = params.amount;
+        const reserveIn = params.reserveIn;
+        if (checkOverflow && reserveIn.add(amountIn).gt(constants_1.UINT128_MAX)) {
+            throw Error('overflow');
+        }
+        const amountInWithFee = amountIn.mul(constants_1.MAX_FEE.sub(params.swapFee));
+        if (checkOverflow && amountInWithFee.gt(constants_1.UINT256_MAX)) {
+            throw Error('overflow');
+        }
+        const numerator = amountInWithFee.mul(params.reserveOut);
+        if (checkOverflow && numerator.gt(constants_1.UINT256_MAX)) {
+            throw Error('overflow');
+        }
+        const denominator = params.reserveIn.mul(constants_1.MAX_FEE).add(amountInWithFee);
+        if (checkOverflow && denominator.gt(constants_1.UINT256_MAX)) {
+            throw Error('overflow');
+        }
+        return numerator.div(denominator);
+    }
+    static computeDFromAdjustedBalances(A, xp0, xp1, checkOverflow) {
+        const s = xp0.add(xp1);
+        if (s.isZero()) {
+            return constants_1.ZERO;
+        }
+        let prevD;
+        let d = s;
+        const nA = A.mul(constants_1.TWO);
+        for (let i = 0; i < constants_1.MAX_LOOP_LIMIT; i++) {
+            const dSq = d.mul(d);
+            if (checkOverflow && dSq.gt(constants_1.UINT256_MAX)) {
+                throw Error('overflow');
+            }
+            const d2 = dSq.div(xp0).mul(d);
+            if (checkOverflow && d2.gt(constants_1.UINT256_MAX)) {
+                throw Error('overflow');
+            }
+            const dP = d2.div(xp1).div(constants_1.FOUR);
+            prevD = d;
+            const d0 = nA.mul(s).add(dP.mul(constants_1.TWO)).mul(d);
+            if (checkOverflow && d0.gt(constants_1.UINT256_MAX)) {
+                throw Error('overflow');
+            }
+            d = d0.div(nA.sub(constants_1.ONE).mul(d).add(dP.mul(constants_1.THREE)));
+            if (d.sub(prevD).abs().lte(constants_1.ONE)) {
+                return d;
+            }
+        }
+        return d;
+    }
+    static getY(A, x, d) {
+        const nA = A.mul(constants_1.TWO);
+        const c = d.mul(d).div(x.mul(constants_1.TWO)).mul(d).div(nA.mul(constants_1.TWO));
+        const b = d.div(nA).add(x);
+        let yPrev;
+        let y = d;
+        for (let i = 0; i < constants_1.MAX_LOOP_LIMIT; i++) {
+            yPrev = y;
+            y = y.mul(y).add(c).div(y.mul(constants_1.TWO).add(b).sub(d));
+            if (y.sub(yPrev).abs().lte(constants_1.ONE)) {
+                break;
+            }
+        }
+        return y;
+    }
+    static getAmountOutStable(params, checkOverflow) {
+        const adjustedReserveIn = params.reserveIn.mul(params.tokenInPrecisionMultiplier);
+        if (checkOverflow && adjustedReserveIn.gt(constants_1.MAX_XP)) {
+            throw Error('overflow');
+        }
+        const adjustedReserveOut = params.reserveOut.mul(params.tokenOutPrecisionMultiplier);
+        if (checkOverflow && adjustedReserveOut.gt(constants_1.MAX_XP)) {
+            throw Error('overflow');
+        }
+        const amountIn = params.amount;
+        const feeDeductedAmountIn = amountIn.sub(amountIn.mul(params.swapFee).div(constants_1.MAX_FEE));
+        const d = SyncSwapRouter.computeDFromAdjustedBalances(constants_1.STABLE_POOL_A, adjustedReserveIn, adjustedReserveOut, checkOverflow);
+        const x = adjustedReserveIn.add(feeDeductedAmountIn.mul(params.tokenInPrecisionMultiplier));
+        const y = SyncSwapRouter.getY(constants_1.STABLE_POOL_A, x, d);
+        const dy = adjustedReserveOut.sub(y).sub(1);
+        return dy.div(params.tokenOutPrecisionMultiplier);
+    }
+    static calculateAmountOut(params, checkOverflow) {
+        if (params.amount.isZero()) {
+            return constants_1.ZERO;
+        }
+        let amountOut;
+        try {
+            if (params.stable) {
+                amountOut = SyncSwapRouter.getAmountOutStable(params, checkOverflow);
+            }
+            else {
+                amountOut = SyncSwapRouter.getAmountOutClassic(params, checkOverflow);
+            }
+        }
+        catch (error) {
+            return constants_1.ZERO;
+        }
+        return amountOut;
+    }
+    static splitAmounts2(amount, granularity) {
+        const oneSplit = amount.div(granularity);
+        if (oneSplit.isZero()) {
+            return [];
+        }
+        const amounts = [];
+        for (let i = 0; i <= granularity; i++) {
+            const a = oneSplit.mul(i);
+            const b = oneSplit.mul(granularity - i);
+            amounts.push([a, b]);
+        }
+        return amounts;
+    }
+    static splitAmounts3(amount, granularity) {
+        const oneSplit = amount.div(granularity);
+        if (oneSplit.isZero()) {
+            return [];
+        }
+        const amounts = [];
+        for (let i = 0; i <= granularity; i++) {
+            const a = oneSplit.mul(i);
+            const remaining = granularity - i;
+            for (let j = 0; j <= remaining; j++) {
+                const b = oneSplit.mul(j);
+                const c = oneSplit.mul(remaining - j);
+                amounts.push([a, b, c]);
+            }
+        }
+        return amounts;
+    }
+    static splitAmounts4(amount, granularity) {
+        const oneSplit = amount.div(granularity);
+        if (oneSplit.isZero()) {
+            return [];
+        }
+        const amounts = [];
+        for (let i = 0; i <= granularity; i++) {
+            const a = oneSplit.mul(i);
+            const remaining = granularity - i;
+            for (let j = 0; j <= remaining; j++) {
+                const b = oneSplit.mul(j);
+                const remaining2 = remaining - j;
+                for (let k = 0; k <= remaining2; k++) {
+                    const c = oneSplit.mul(k);
+                    const d = oneSplit.mul(remaining2 - k);
+                    amounts.push([a, b, c, d]);
+                }
+            }
+        }
+        return amounts;
+    }
+    static splitAmounts5(amount, granularity) {
+        const oneSplit = amount.div(granularity);
+        if (oneSplit.isZero()) {
+            return [];
+        }
+        const amounts = [];
+        for (let i = 0; i <= granularity; i++) {
+            const a = oneSplit.mul(i);
+            const remaining = granularity - i;
+            for (let j = 0; j <= remaining; j++) {
+                const b = oneSplit.mul(j);
+                const remaining2 = remaining - j;
+                for (let k = 0; k <= remaining2; k++) {
+                    const c = oneSplit.mul(k);
+                    const remaining3 = remaining2 - k;
+                    for (let l = 0; l <= remaining3; l++) {
+                        const d = oneSplit.mul(l);
+                        const e = oneSplit.mul(remaining3 - l);
+                        amounts.push([a, b, c, d, e]);
+                    }
+                }
+            }
+        }
+        return amounts;
+    }
+    static fixSplitAmounts(amount, amounts) {
+        for (const group of amounts) {
+            let sum = constants_1.ZERO;
+            for (const amount of group) {
+                sum = sum.add(amount);
+            }
+            if (!sum.eq(amount)) {
+                const diff = amount.sub(sum);
+                for (const amount of group) {
+                    // only add diff to non-zero amount
+                    if (!amount.isZero()) {
+                        group[0] = group[0].add(diff);
+                        break;
+                    }
+                }
+            }
+        }
+        return amounts;
+    }
+    static async splitAmount(amount, parts) {
+        if (parts === 0) {
+            return [];
+        }
+        if (parts === 1) {
+            return [[amount]];
+        }
+        if (parts === 2) {
+            return SyncSwapRouter.fixSplitAmounts(amount, SyncSwapRouter.splitAmounts2(amount, constants_1.granularity));
+        }
+        if (parts === 3) {
+            return SyncSwapRouter.fixSplitAmounts(amount, SyncSwapRouter.splitAmounts3(amount, constants_1.granularity));
+        }
+        if (parts === 4) {
+            return SyncSwapRouter.fixSplitAmounts(amount, SyncSwapRouter.splitAmounts4(amount, constants_1.granularity));
+        }
+        if (parts === 5) {
+            return SyncSwapRouter.fixSplitAmounts(amount, SyncSwapRouter.splitAmounts5(amount, constants_1.granularity));
+        }
+        throw Error('Unsupported split parts');
+    }
+    static async calculateAmountOutForStep(step, amountIn, quoteIn, blockchainName) {
+        const isTokenAIn = step.pool.tokenA === step.tokenIn;
+        const [reserveIn, reserveOut] = isTokenAIn
+            ? [step.pool.reserveA, step.pool.reserveB]
+            : [step.pool.reserveB, step.pool.reserveA];
+        let tokenInPrecisionMultiplier;
+        let tokenOutPrecisionMultiplier;
+        // create multiplier for stable pools
+        const stable = step.pool.poolType === '2';
+        if (stable) {
+            const [tokenInAddress] = isTokenAIn
+                ? [step.pool.tokenA, step.pool.tokenB]
+                : [step.pool.tokenB, step.pool.tokenA];
+            const { fromPrecisionMultiplier, toPrecisionMultiplier } = await this.getPoolPrecision(step.pool.pool, tokenInAddress, blockchainName);
+            tokenInPrecisionMultiplier = ethers_1.BigNumber.from(fromPrecisionMultiplier);
+            tokenOutPrecisionMultiplier = ethers_1.BigNumber.from(toPrecisionMultiplier);
+        }
+        else {
+            tokenInPrecisionMultiplier = constants_1.ZERO;
+            tokenOutPrecisionMultiplier = constants_1.ZERO;
+        }
+        const swapFee = ethers_1.BigNumber.from(step.swapFee);
+        const amountOut = SyncSwapRouter.calculateAmountOut({
+            stable,
+            amount: amountIn,
+            reserveIn,
+            reserveOut,
+            swapFee,
+            tokenInPrecisionMultiplier,
+            tokenOutPrecisionMultiplier
+        }, true);
+        let quoteOut = constants_1.ZERO;
+        let updatedStep = null;
+        if (!amountOut.isZero()) {
+            updatedStep = SyncSwapRouter.copyStep(step);
+            if (isTokenAIn) {
+                updatedStep.pool.reserveA = step.pool.reserveA.add(amountIn);
+                updatedStep.pool.reserveB = step.pool.reserveB.sub(amountOut);
+            }
+            else {
+                updatedStep.pool.reserveB = step.pool.reserveB.add(amountIn);
+                updatedStep.pool.reserveA = step.pool.reserveA.sub(amountOut);
+            }
+            quoteOut = sync_swap_path_factory_1.SyncSwapPathFactory.calculateQuoteOut({
+                stable,
+                amount: quoteIn,
+                reserveIn,
+                reserveOut,
+                swapFee,
+                tokenInPrecisionMultiplier,
+                tokenOutPrecisionMultiplier
+            });
+        }
+        return [amountOut, quoteOut, updatedStep];
+    }
+    static async calculatePathAmountsByInput(path, amountIn, _updateReserves, blockchainName) {
+        const stepsWithAmount = [];
+        let amountInNext = amountIn;
+        let quoteInNext = amountIn;
+        for (let i = 0; i < path.length; i++) {
+            const step = path[i];
+            const [stepAmountOut, stepQuoteOut, updatedStep] = 
+            // eslint-disable-next-line no-await-in-loop
+            await SyncSwapRouter.calculateAmountOutForStep(step, amountInNext, quoteInNext, blockchainName);
+            if (stepAmountOut.isZero()) {
+                return null;
+            }
+            stepsWithAmount.push({
+                ...step,
+                updatedStep,
+                amountIn: amountInNext
+            });
+            amountInNext = stepAmountOut;
+            quoteInNext = stepQuoteOut;
+        }
+        const pathAmountOut = amountInNext;
+        const pathQuoteOut = quoteInNext;
+        return {
+            direction: typings_1.routeDirection.EXACT_IN,
+            stepsWithAmount,
+            amountOut: pathAmountOut,
+            amountIn,
+            quote: pathQuoteOut
+        };
+    }
+    static async calculateGroupAmounts(paths, amounts, blockchainName) {
+        const pathsWithAmounts = [];
+        let amountOut = constants_1.ZERO;
+        let quoteOut = constants_1.ZERO;
+        const groupPaths = paths;
+        const lastSteps = new Map();
+        for (let i = 0; i < groupPaths.length; i++) {
+            const pathAmountIn = amounts[i];
+            if (pathAmountIn.isZero()) {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            const path = groupPaths[i];
+            for (let j = 0; j < path.length; j++) {
+                const lastStep = lastSteps.get(path[j].pool.pool);
+                if (lastStep !== undefined) {
+                    path[j] = SyncSwapRouter.copyStep(lastStep);
+                }
+            }
+            const pathWithAmounts = 
+            // eslint-disable-next-line no-await-in-loop
+            await SyncSwapRouter.calculatePathAmountsByInput(path, pathAmountIn, true, blockchainName);
+            if (pathWithAmounts != null) {
+                for (const step of pathWithAmounts.stepsWithAmount) {
+                    if (step.updatedStep !== null) {
+                        lastSteps.set(step.pool.pool, step.updatedStep);
+                    }
+                }
+                pathsWithAmounts.push(pathWithAmounts);
+                amountOut = amountOut.add(pathWithAmounts.amountOut);
+                quoteOut = quoteOut.add(pathWithAmounts.quote);
+            }
+        }
+        return {
+            pathsWithAmounts,
+            amountOut,
+            quoteOut
+        };
+    }
+    static async getPoolPrecision(address, fromAddress, blockchainName) {
+        const web3Public = injector_1.Injector.web3PublicService.getWeb3Public(blockchainName);
+        const token0 = await web3Public.callContractMethod(address, sync_swap_stable_pool_1.syncSwapStablePool, 'token0', []);
+        const token0PM = await web3Public.callContractMethod(address, sync_swap_stable_pool_1.syncSwapStablePool, 'token0PrecisionMultiplier', []);
+        const token1PM = await web3Public.callContractMethod(address, sync_swap_stable_pool_1.syncSwapStablePool, 'token1PrecisionMultiplier', []);
+        return (0, blockchain_1.compareAddresses)(token0, fromAddress)
+            ? {
+                fromPrecisionMultiplier: token0PM,
+                toPrecisionMultiplier: token1PM
+            }
+            : {
+                fromPrecisionMultiplier: token1PM,
+                toPrecisionMultiplier: token0PM
+            };
+    }
+}
+exports.SyncSwapRouter = SyncSwapRouter;
+__decorate([
+    decorators_1.Cache
+], SyncSwapRouter, "getPoolPrecision", null);
+//# sourceMappingURL=sync-swap-router.js.map