@marko00/routing-finder-mare 1.0.0

package/dist/dexes/pools/SushiSwapV2.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SushiSwapV2Pool = void 0;
+const types_1 = require("../../utils/types/types");
+class SushiSwapV2Pool extends types_1.Pool {
+    constructor(poolId, dexId, tokens, reserves) {
+        super(poolId, dexId, tokens);
+        this.reserves = reserves.slice();
+        this.startingReserves = [...this.reserves];
+    }
+    reset() {
+        this.reserves = [...this.startingReserves];
+    }
+    calculateExpectedOutputAmount(tokenIn, tokenOut, amountIn) {
+        let reserveIn = this.reserves[0];
+        let reserveOut = this.reserves[1];
+        if (tokenIn.toLowerCase() === this.tokens[1]._address.toLowerCase()) {
+            reserveIn = this.reserves[1];
+            reserveOut = this.reserves[0];
+        }
+        return (amountIn * BigInt(997) * reserveOut) / (reserveIn * BigInt(1000) + amountIn * BigInt(997));
+    }
+    update(tokenIn, tokenOut, amountIn, amountOut) {
+        if (tokenIn.toLowerCase() === this.tokens[0]._address.toLowerCase()) {
+            this.reserves[0] += amountIn;
+            this.reserves[1] -= amountOut;
+        }
+        else {
+            this.reserves[1] += amountIn;
+            this.reserves[0] -= amountOut;
+        }
+    }
+}
+exports.SushiSwapV2Pool = SushiSwapV2Pool;

package/dist/dexes/pools/UniswapV2.d.ts

@@ -0,0 +1,9 @@
+import { Pool, Token } from '../../utils/types/types';
+export declare class UniswapV2Pool extends Pool {
+    reserves: bigint[];
+    startingReserves: bigint[];
+    constructor(poolId: string, dexId: string, tokens: Token[], reserves: bigint[]);
+    reset(): void;
+    calculateExpectedOutputAmount(tokenIn: string, tokenOut: string, amountIn: bigint): bigint;
+    update(tokenIn: string, tokenOut: string, amountIn: bigint, amountOut: bigint): void;
+}

package/dist/dexes/pools/UniswapV2.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniswapV2Pool = void 0;
+const types_1 = require("../../utils/types/types");
+class UniswapV2Pool extends types_1.Pool {
+    constructor(poolId, dexId, tokens, reserves) {
+        super(poolId, dexId, tokens);
+        this.reserves = reserves.slice();
+        this.startingReserves = [...this.reserves];
+    }
+    reset() {
+        this.reserves = [...this.startingReserves];
+    }
+    calculateExpectedOutputAmount(tokenIn, tokenOut, amountIn) {
+        let reserveIn = this.reserves[0];
+        let reserveOut = this.reserves[1];
+        if (tokenIn.toLowerCase() === this.tokens[1]._address.toLowerCase()) {
+            reserveIn = this.reserves[1];
+            reserveOut = this.reserves[0];
+        }
+        return (amountIn * BigInt(997) * reserveOut) / (reserveIn * BigInt(1000) + amountIn * BigInt(997));
+    }
+    update(tokenIn, tokenOut, amountIn, amountOut) {
+        if (tokenIn.toLowerCase() === this.tokens[0]._address.toLowerCase()) {
+            this.reserves[0] += amountIn;
+            this.reserves[1] -= amountOut;
+        }
+        else {
+            this.reserves[1] += amountIn;
+            this.reserves[0] -= amountOut;
+        }
+    }
+}
+exports.UniswapV2Pool = UniswapV2Pool;

package/dist/dexes/pools/uniswap/UniswapV3.d.ts

@@ -0,0 +1,7 @@
+import { Pool, Token } from '../../../utils/types/types';
+export declare class UniswapV3Pool extends Pool {
+    constructor(poolId: string, dexId: string, tokens: Token[]);
+    calculateExpectedOutputAmount(tokenIn: string, tokenOut: string, amountIn: bigint): bigint;
+    reset(): void;
+    update(tokenIn: string, tokenOut: string, amountIn: bigint): bigint;
+}

package/dist/dexes/pools/uniswap/UniswapV3.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniswapV3Pool = void 0;
+const types_1 = require("../../../utils/types/types");
+const uniswapState_1 = require("./uniswapState");
+class UniswapV3Pool extends types_1.Pool {
+    constructor(poolId, dexId, tokens) {
+        super(poolId.toLowerCase(), dexId, tokens);
+    }
+    calculateExpectedOutputAmount(tokenIn, tokenOut, amountIn) {
+        const poolData = uniswapState_1.UniswapState.getPoolState(this.poolId);
+        if (!poolData) {
+            console.log('ERROR: Data for uni v3 pool: ' + this.poolId + ' not found');
+            return BigInt(0);
+        }
+        return uniswapState_1.UniswapState.quoter.quote(poolData, tokenIn, tokenOut, amountIn)[0];
+    }
+    reset() {
+        uniswapState_1.UniswapState.resetPoolState(this.poolId);
+    }
+    update(tokenIn, tokenOut, amountIn) {
+        const poolData = uniswapState_1.UniswapState.getPoolState(this.poolId);
+        if (!poolData) {
+            console.log('ERROR: Data for uni v3 pool: ' + this.poolId + ' not found');
+            return BigInt(0);
+        }
+        // lastQuote will be stored each time we call quote
+        const lastQuote = poolData.lastQuote;
+        poolData.data.currentLiquidity = lastQuote.newLiquidity;
+        poolData.data.currentSqrtPriceX96 = lastQuote.newSqrtPriceX96;
+        poolData.data.currentTickIndex = lastQuote.newTickIndex;
+        // we don't need this, because we don't use amountIn anyway
+        return BigInt(0);
+    }
+}
+exports.UniswapV3Pool = UniswapV3Pool;

package/dist/dexes/pools/uniswap/types.d.ts

@@ -0,0 +1,76 @@
+export declare class PoolInfo {
+    pool: string;
+    token0: string;
+    token1: string;
+    tick: bigint;
+    tickLiquidityNet: bigint;
+    tickSpacing: bigint;
+    fee: bigint;
+    sqrtPriceX96: bigint;
+    liquidity: bigint;
+    constructor(pool: string, token0: string, token1: string, tick: bigint, tickLiquidityNet: bigint, tickSpacing: bigint, fee: bigint, sqrtPriceX96: bigint, liquidity: bigint);
+}
+export declare class TickData {
+    tick: bigint;
+    initialized: boolean;
+    liquidityNet: bigint;
+    clone(): TickData;
+    constructor(tick: bigint, initialized: boolean, liquidityNet: bigint);
+}
+export declare class PoolData {
+    info: PoolInfo;
+    zeroForOneTicks: TickData[];
+    oneForZeroTicks: TickData[];
+    constructor(info: PoolInfo, zeroForOneTicks: TickData[], oneForZeroTicks: TickData[]);
+}
+export type SwapState = {
+    amountSpecifiedRemaining: bigint;
+    amountCalculated: bigint;
+    sqrtPriceX96: bigint;
+    tick: bigint;
+    liquidity: bigint;
+};
+export type StepComputations = {
+    sqrtPriceStartX96: bigint;
+    tickNext: bigint;
+    initialized: boolean;
+    sqrtPriceNextX96: bigint;
+    amountIn: bigint;
+    amountOut: bigint;
+    feeAmount: bigint;
+};
+export declare class TradeInfo {
+    pool: string;
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: bigint;
+    fee: bigint;
+    constructor(pool: string, tokenIn: string, tokenOut: string, amountIn: bigint, fee: bigint);
+}
+export declare class AdaptedPoolData {
+    pool: string;
+    token0: string;
+    token1: string;
+    tickSpacing: bigint;
+    fee: bigint;
+    currentLiquidity: bigint;
+    currentSqrtPriceX96: bigint;
+    ticks: TickData[];
+    currentTickIndex: number;
+    clone(): AdaptedPoolData;
+    constructor(poolData: PoolData | null);
+    getCurrTickData(): TickData;
+}
+export declare class LastQuote {
+    newLiquidity: bigint;
+    newSqrtPriceX96: bigint;
+    newTickIndex: number;
+    clone(): LastQuote;
+    constructor(newLiquidity: bigint, newSqrtPriceX96: bigint, newTickIndex: number);
+}
+export declare class PoolState {
+    data: AdaptedPoolData;
+    lastQuote: LastQuote;
+    clone(): PoolState;
+    constructor(currData: AdaptedPoolData, lastQuote: LastQuote);
+}

package/dist/dexes/pools/uniswap/types.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolState = exports.LastQuote = exports.AdaptedPoolData = exports.TradeInfo = exports.PoolData = exports.TickData = exports.PoolInfo = void 0;
+class PoolInfo {
+    constructor(pool, token0, token1, tick, tickLiquidityNet, tickSpacing, fee, sqrtPriceX96, liquidity) {
+        this.pool = pool;
+        this.token0 = token0;
+        this.token1 = token1;
+        this.tick = tick;
+        this.tickLiquidityNet = tickLiquidityNet;
+        this.tickSpacing = tickSpacing;
+        this.fee = fee;
+        this.sqrtPriceX96 = sqrtPriceX96;
+        this.liquidity = liquidity;
+    }
+}
+exports.PoolInfo = PoolInfo;
+class TickData {
+    clone() {
+        return new TickData(this.tick, this.initialized, this.liquidityNet);
+    }
+    constructor(tick, initialized, liquidityNet) {
+        this.tick = tick;
+        this.initialized = initialized;
+        this.liquidityNet = liquidityNet;
+    }
+}
+exports.TickData = TickData;
+class PoolData {
+    constructor(info, zeroForOneTicks, oneForZeroTicks) {
+        this.info = info;
+        this.zeroForOneTicks = zeroForOneTicks;
+        this.oneForZeroTicks = oneForZeroTicks;
+    }
+}
+exports.PoolData = PoolData;
+// helper used for test
+class TradeInfo {
+    constructor(pool, tokenIn, tokenOut, amountIn, fee) {
+        this.pool = pool;
+        this.tokenIn = tokenIn;
+        this.tokenOut = tokenOut;
+        this.amountIn = amountIn;
+        this.fee = fee;
+    }
+}
+exports.TradeInfo = TradeInfo;
+class AdaptedPoolData {
+    clone() {
+        const newData = new AdaptedPoolData(null);
+        newData.pool = this.pool;
+        newData.token0 = this.token0;
+        newData.token1 = this.token1;
+        newData.tickSpacing = this.tickSpacing;
+        newData.fee = this.fee;
+        newData.currentLiquidity = this.currentLiquidity;
+        newData.currentSqrtPriceX96 = this.currentSqrtPriceX96;
+        newData.ticks = this.ticks.map(e => e.clone());
+        newData.currentTickIndex = this.currentTickIndex;
+        return newData;
+    }
+    constructor(poolData) {
+        if (!poolData) {
+            this.pool = '';
+            this.token0 = '';
+            this.token1 = '';
+            this.tickSpacing = BigInt(0);
+            this.fee = BigInt(0);
+            this.currentLiquidity = BigInt(0);
+            this.currentSqrtPriceX96 = BigInt(0);
+            this.ticks = [];
+            this.currentTickIndex = 0;
+            return;
+        }
+        this.pool = poolData.info.pool;
+        this.token0 = poolData.info.token0;
+        this.token1 = poolData.info.token1;
+        this.tickSpacing = poolData.info.tickSpacing;
+        this.fee = poolData.info.fee;
+        this.currentLiquidity = poolData.info.liquidity;
+        this.currentSqrtPriceX96 = poolData.info.sqrtPriceX96;
+        const currentTickData = new TickData(poolData.info.tick, true, poolData.info.tickLiquidityNet);
+        this.ticks = poolData.zeroForOneTicks.reverse().concat(currentTickData).concat(poolData.oneForZeroTicks);
+        this.currentTickIndex = poolData.zeroForOneTicks.length;
+    }
+    getCurrTickData() {
+        return this.ticks[this.currentTickIndex];
+    }
+}
+exports.AdaptedPoolData = AdaptedPoolData;
+class LastQuote {
+    clone() {
+        return new LastQuote(this.newLiquidity, this.newSqrtPriceX96, this.newTickIndex);
+    }
+    constructor(newLiquidity, newSqrtPriceX96, newTickIndex) {
+        this.newLiquidity = newLiquidity;
+        this.newSqrtPriceX96 = newSqrtPriceX96;
+        this.newTickIndex = newTickIndex;
+    }
+}
+exports.LastQuote = LastQuote;
+class PoolState {
+    clone() {
+        return new PoolState(this.data.clone(), this.lastQuote.clone());
+    }
+    constructor(currData, lastQuote) {
+        this.data = currData;
+        this.lastQuote = lastQuote;
+    }
+}
+exports.PoolState = PoolState;

package/dist/dexes/pools/uniswap/uniswapOffchainQuoter.d.ts

@@ -0,0 +1,13 @@
+import { PoolState } from "./types";
+export declare class UniswapOffchainQuoter {
+    quote(poolState: PoolState, tokenIn: string, tokenOut: string, amountIn: bigint): [bigint, bigint];
+    private initSwapState;
+    private initStepComputations;
+    private convertToFeeAmount;
+    private updateSwapIteration;
+    private updateSwapStep;
+    private calculateAmount;
+    private updateTickWithLiquidity;
+    private calculateRatioTargetX96;
+    private getSqrtPriceLimitX96;
+}

package/dist/dexes/pools/uniswap/uniswapOffchainQuoter.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniswapOffchainQuoter = void 0;
+const v3_sdk_1 = require("@uniswap/v3-sdk");
+const jsbi_1 = __importDefault(require("jsbi"));
+const types_1 = require("./types");
+class UniswapOffchainQuoter {
+    quote(poolState, tokenIn, tokenOut, amountIn) {
+        if (amountIn <= BigInt(0)) {
+            return [BigInt(0), BigInt(0)];
+        }
+        try {
+            const zeroForOne = tokenIn < tokenOut;
+            const sqrtPriceLimitX96 = this.getSqrtPriceLimitX96(zeroForOne);
+            let state = this.initSwapState(poolState, amountIn);
+            let tickDataIndex = zeroForOne
+                ? poolState.data.currentTickIndex - 1
+                : poolState.data.currentTickIndex + 1;
+            while (state.amountSpecifiedRemaining !== BigInt(0) &&
+                state.sqrtPriceX96 !== sqrtPriceLimitX96 &&
+                tickDataIndex >= 0 &&
+                tickDataIndex < poolState.data.ticks.length) {
+                const tickData = poolState.data.ticks[tickDataIndex];
+                let step = this.initStepComputations(state, tickData);
+                this.updateSwapIteration(state, step, tickData, poolState.data.fee, sqrtPriceLimitX96, zeroForOne);
+                tickDataIndex = zeroForOne ? tickDataIndex - 1 : tickDataIndex + 1;
+            }
+            // remember where we left off, so we can update pool later
+            poolState.lastQuote = new types_1.LastQuote(state.liquidity, state.sqrtPriceX96, zeroForOne ? tickDataIndex + 2 : tickDataIndex - 2);
+            const amountOut = state.amountCalculated > BigInt(0) ? state.amountCalculated : -state.amountCalculated;
+            return [amountOut, state.amountSpecifiedRemaining];
+        }
+        catch (e) {
+            return [BigInt(0), BigInt(0)];
+        }
+    }
+    initSwapState(poolState, amountIn) {
+        return {
+            amountSpecifiedRemaining: amountIn,
+            amountCalculated: BigInt(0),
+            sqrtPriceX96: poolState.data.currentSqrtPriceX96,
+            tick: poolState.data.getCurrTickData().tick,
+            liquidity: poolState.data.currentLiquidity
+        };
+    }
+    initStepComputations(state, tickData) {
+        return {
+            sqrtPriceStartX96: state.sqrtPriceX96,
+            tickNext: tickData.tick,
+            initialized: tickData.initialized,
+            sqrtPriceNextX96: BigInt(v3_sdk_1.TickMath.getSqrtRatioAtTick(Number(tickData.tick)).toString()),
+            amountIn: BigInt(0),
+            amountOut: BigInt(0),
+            feeAmount: BigInt(0)
+        };
+    }
+    convertToFeeAmount(fee) {
+        switch (fee.toString()) {
+            case "100":
+                return v3_sdk_1.FeeAmount.LOWEST;
+            case "500":
+                return v3_sdk_1.FeeAmount.LOW;
+            case "3000":
+                return v3_sdk_1.FeeAmount.MEDIUM;
+            case "10000":
+                return v3_sdk_1.FeeAmount.HIGH;
+            default:
+                throw new Error("Invalid fee amount");
+        }
+    }
+    updateSwapIteration(state, step, tickData, fee, sqrtPriceLimitX96, zeroForOne) {
+        this.updateSwapStep(state, step, fee, sqrtPriceLimitX96, zeroForOne);
+        this.calculateAmount(state, step);
+        this.updateTickWithLiquidity(state, step, tickData, zeroForOne);
+    }
+    updateSwapStep(state, step, fee, sqrtPriceLimitX96, zeroForOne) {
+        const [sqrtPriceX96, amountIn, amountOut, feeAmount] = v3_sdk_1.SwapMath.computeSwapStep(jsbi_1.default.BigInt(state.sqrtPriceX96.toString()), this.calculateRatioTargetX96(zeroForOne, step.sqrtPriceNextX96, sqrtPriceLimitX96), jsbi_1.default.BigInt(state.liquidity.toString()), jsbi_1.default.BigInt(state.amountSpecifiedRemaining.toString()), this.convertToFeeAmount(fee));
+        state.sqrtPriceX96 = BigInt(sqrtPriceX96.toString());
+        step.amountIn = BigInt(amountIn.toString());
+        step.amountOut = BigInt(amountOut.toString());
+        step.feeAmount = BigInt(feeAmount.toString());
+    }
+    calculateAmount(state, step) {
+        state.amountSpecifiedRemaining -= (step.amountIn + step.feeAmount);
+        state.amountCalculated -= step.amountOut;
+    }
+    updateTickWithLiquidity(state, step, tickData, zeroForOne) {
+        if (state.sqrtPriceX96 === step.sqrtPriceNextX96) {
+            // if the tick is initialized, run the tick transition
+            if (step.initialized) {
+                let liquidityNet = tickData.liquidityNet;
+                // if we're moving leftward, we interpret liquidityNet as the opposite sign
+                if (zeroForOne) {
+                    liquidityNet = -liquidityNet;
+                }
+                const finalLiquidity = v3_sdk_1.LiquidityMath.addDelta(jsbi_1.default.BigInt(state.liquidity.toString()), jsbi_1.default.BigInt(liquidityNet.toString()));
+                state.liquidity = BigInt(finalLiquidity.toString());
+            }
+            state.tick = zeroForOne ? step.tickNext - BigInt(1) : step.tickNext;
+        }
+        else if (state.sqrtPriceX96 !== step.sqrtPriceStartX96) {
+            // recompute unless we're on a lower tick boundary (i.e. already transitioned ticks), and haven't moved
+            const tick = v3_sdk_1.TickMath.getTickAtSqrtRatio(jsbi_1.default.BigInt(state.sqrtPriceX96.toString()));
+            state.tick = BigInt(tick.toString());
+        }
+    }
+    calculateRatioTargetX96(zeroForOne, sqrtPriceNextX96, sqrtPriceLimitX96) {
+        return (zeroForOne ? sqrtPriceNextX96 < sqrtPriceLimitX96 : sqrtPriceNextX96 > sqrtPriceLimitX96)
+            ? jsbi_1.default.BigInt(sqrtPriceLimitX96.toString())
+            : jsbi_1.default.BigInt(sqrtPriceNextX96.toString());
+    }
+    getSqrtPriceLimitX96(zeroForOne) {
+        return zeroForOne ?
+            BigInt(jsbi_1.default.add(v3_sdk_1.TickMath.MIN_SQRT_RATIO, jsbi_1.default.BigInt("1")).toString()) :
+            BigInt(jsbi_1.default.subtract(v3_sdk_1.TickMath.MAX_SQRT_RATIO, jsbi_1.default.BigInt("1")).toString());
+    }
+}
+exports.UniswapOffchainQuoter = UniswapOffchainQuoter;

package/dist/dexes/pools/uniswap/uniswapState.d.ts

@@ -0,0 +1,14 @@
+import { PoolState } from './types';
+import { UniswapOffchainQuoter } from './uniswapOffchainQuoter';
+import Web3 from 'web3';
+export declare class UniswapState {
+    private static poolStateMap;
+    private static startingPoolStateMap;
+    static quoter: UniswapOffchainQuoter;
+    private static batch_size;
+    private constructor();
+    static getPoolState(poolAddress: string): PoolState | undefined;
+    static resetPoolState(poolAddress: string): void;
+    private static getPoolsDataFromContract;
+    static initializeFreshPoolsData(pools: string[], chainId: number, rpcProvider: Web3): Promise<void>;
+}

package/dist/dexes/pools/uniswap/uniswapState.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniswapState = void 0;
+const utils_1 = require("./utils");
+const uniswapOffchainQuoter_1 = require("./uniswapOffchainQuoter");
+const UniswapHelper_1 = require("../../../contracts/rateX/UniswapHelper");
+class UniswapState {
+    constructor() { }
+    static getPoolState(poolAddress) {
+        return this.poolStateMap.get(poolAddress.toLowerCase());
+    }
+    static resetPoolState(poolAddress) {
+        const poolState = this.startingPoolStateMap.get(poolAddress.toLowerCase());
+        if (poolState) {
+            this.poolStateMap.set(poolAddress.toLowerCase(), poolState.clone());
+        }
+    }
+    static async getPoolsDataFromContract(pools, chainId, rpcProvider) {
+        //@ts-ignore
+        try {
+            const UniswapHelperContract = (0, UniswapHelper_1.CreateUniswapHelperContract)(chainId, rpcProvider);
+            const rawPoolsData = await UniswapHelperContract.methods.fetchData(pools, 15).call();
+            return rawPoolsData.map((rawPoolData) => (0, utils_1.convertRowPoolData)(rawPoolData));
+        }
+        catch (err) {
+            console.log('Error while fetching additional data from the smart contracts: ', err);
+            throw err;
+        }
+    }
+    static async initializeFreshPoolsData(pools, chainId, rpcProvider) {
+        const poolsSize = pools.length;
+        const numberOfBatches = Math.ceil(poolsSize / this.batch_size);
+        const promises = [];
+        for (let i = 0; i < numberOfBatches; i++) {
+            const batch = pools.slice(i * this.batch_size, (i + 1) * this.batch_size);
+            promises.push(this.getPoolsDataFromContract(batch, chainId, rpcProvider));
+        }
+        const allPoolsData = await Promise.all(promises);
+        allPoolsData.flat().forEach((poolData) => {
+            let poolState = (0, utils_1.convertInitialPoolDataToPoolState)(poolData);
+            // we will store keys as lowercase addresses
+            this.poolStateMap.set(poolData.info.pool.toLowerCase(), poolState);
+            this.startingPoolStateMap.set(poolData.info.pool.toLowerCase(), poolState.clone());
+        });
+    }
+}
+exports.UniswapState = UniswapState;
+UniswapState.poolStateMap = new Map();
+UniswapState.startingPoolStateMap = new Map();
+UniswapState.quoter = new uniswapOffchainQuoter_1.UniswapOffchainQuoter();
+UniswapState.batch_size = 3;

package/dist/dexes/pools/uniswap/utils.d.ts

@@ -0,0 +1,3 @@
+import { PoolData, PoolState } from "./types";
+export declare function convertRowPoolData(poolData: any): PoolData;
+export declare function convertInitialPoolDataToPoolState(poolData: PoolData): PoolState;

package/dist/dexes/pools/uniswap/utils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRowPoolData = convertRowPoolData;
+exports.convertInitialPoolDataToPoolState = convertInitialPoolDataToPoolState;
+const types_1 = require("./types");
+function convertRowPoolData(poolData) {
+    const getPoolInfo = (poolInfoRaw) => {
+        const pool = poolInfoRaw[0];
+        const token0 = poolInfoRaw[1];
+        const token1 = poolInfoRaw[2];
+        const tick = poolInfoRaw[3];
+        const tickLiquidityNet = poolInfoRaw[4];
+        const tickSpacing = poolInfoRaw[5];
+        const fee = poolInfoRaw[6];
+        const sqrtPriceX96 = poolInfoRaw[7];
+        const liquidity = poolInfoRaw[8];
+        return new types_1.PoolInfo(pool, token0, token1, tick, tickLiquidityNet, tickSpacing, fee, sqrtPriceX96, liquidity);
+    };
+    const getTickData = (tickDataRaw) => {
+        const tick = tickDataRaw[0];
+        const initialized = tickDataRaw[1];
+        const liquidityNet = tickDataRaw[2];
+        return new types_1.TickData(tick, initialized, liquidityNet);
+    };
+    const zeroForOneTicksRaw = poolData[1];
+    const zeroForOneTicks = [];
+    for (let i = 0; i < zeroForOneTicksRaw.length; i++) {
+        zeroForOneTicks.push(getTickData(zeroForOneTicksRaw[i]));
+    }
+    const oneForZeroTicksRaw = poolData[2];
+    const oneForZeroTicks = [];
+    for (let i = 0; i < oneForZeroTicksRaw.length; i++) {
+        oneForZeroTicks.push(getTickData(oneForZeroTicksRaw[i]));
+    }
+    return new types_1.PoolData(getPoolInfo(poolData[0]), zeroForOneTicks, oneForZeroTicks);
+}
+function convertInitialPoolDataToPoolState(poolData) {
+    const adaptedPoolData = new types_1.AdaptedPoolData(poolData);
+    const lastQuote = new types_1.LastQuote(adaptedPoolData.currentLiquidity, adaptedPoolData.currentSqrtPriceX96, adaptedPoolData.currentTickIndex);
+    return new types_1.PoolState(adaptedPoolData, lastQuote);
+}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import Web3 from "web3";
+import { Quote } from "./utils/types/types";
+import { prepareSwapParams } from "./utils/utils";
+export interface RateXConfig {
+    rpcUrl: string;
+    chainId: number;
+    dexes?: Array<Dexes>;
+    graphApiKey: string;
+}
+export declare enum Dexes {
+    UNISWAP_V2 = "UniswapV2",
+    UNISWAP_V3 = "UniswapV3",
+    SUSHISWAP_V2 = "Sushiswap",
+    BALANCER = "Balancer",
+    CAMELOT = "Camelot"
+}
+export declare class RateX {
+    rpcProvider: Web3;
+    chainId: number;
+    graphApiKey: string;
+    dexes: Array<Dexes>;
+    constructor(config: RateXConfig);
+    getQuote(tokenIn: string, tokenOut: string, amountIn: bigint): Promise<Quote>;
+    getSwapCalldata(tokenIn: string, tokenOut: string, amountIn: bigint, slippagePercentage: number, recipient: string, deadlineInMinutes: number): Promise<string>;
+    getSwapParameters(tokenIn: string, tokenOut: string, amountIn: bigint, slippagePercentage: number, recipient: string, deadlineInMinutes: number): Promise<ReturnType<typeof prepareSwapParams>>;
+}

package/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateX = exports.Dexes = void 0;
+const web3_1 = __importDefault(require("web3"));
+const main_1 = require("./routing/main");
+const graph_communication_1 = require("./swap/graph_communication");
+const utils_1 = require("./utils/utils");
+var Dexes;
+(function (Dexes) {
+    Dexes["UNISWAP_V2"] = "UniswapV2";
+    Dexes["UNISWAP_V3"] = "UniswapV3";
+    Dexes["SUSHISWAP_V2"] = "Sushiswap";
+    Dexes["BALANCER"] = "Balancer";
+    Dexes["CAMELOT"] = "Camelot";
+})(Dexes || (exports.Dexes = Dexes = {}));
+class RateX {
+    constructor(config) {
+        this.rpcProvider = new web3_1.default(new web3_1.default.providers.HttpProvider(config.rpcUrl));
+        this.chainId = config.chainId;
+        this.graphApiKey = config.graphApiKey;
+        this.dexes = config.dexes || [Dexes.SUSHISWAP_V2, Dexes.UNISWAP_V2, Dexes.UNISWAP_V3, Dexes.BALANCER, Dexes.CAMELOT];
+    }
+    ;
+    async getQuote(tokenIn, tokenOut, amountIn) {
+        const pools = await (0, graph_communication_1.fetchPoolsData)(tokenIn, tokenOut, 5, 5, this.chainId, this.rpcProvider, this.graphApiKey, this.dexes);
+        const route = await (0, main_1.findRoute)(tokenIn, tokenOut, amountIn, pools, this.chainId);
+        return route;
+    }
+    async getSwapCalldata(tokenIn, tokenOut, amountIn, slippagePercentage, recipient, deadlineInMinutes) {
+        let quote = await this.getQuote(tokenIn, tokenOut, amountIn);
+        return (0, utils_1.generateCalldata)(quote, slippagePercentage, deadlineInMinutes, tokenIn, tokenOut, amountIn, recipient);
+    }
+    async getSwapParameters(tokenIn, tokenOut, amountIn, slippagePercentage, recipient, deadlineInMinutes) {
+        let quote = await this.getQuote(tokenIn, tokenOut, amountIn);
+        return (0, utils_1.prepareSwapParams)(quote, slippagePercentage, deadlineInMinutes, tokenIn, tokenOut, amountIn, recipient);
+    }
+}
+exports.RateX = RateX;

package/dist/routes.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/routes.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+async function main() {
+    const rateX = new index_1.RateX({
+        rpcUrl: "https://tiniest-cold-general.sei-pacific.quiknode.pro/dfa7ceb1fbe6d4fdbce164d5e52201488999dd15",
+        chainId: 1329,
+        dexes: [index_1.Dexes.UNISWAP_V2, index_1.Dexes.UNISWAP_V3],
+        graphApiKey: "",
+    });
+    const tokenIn = "0xE30feDd158A2e3b13e9badaeABaFc5516e95e8C7"; // real Sei token
+    const tokenOut = "0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392"; // real Sei token
+    const amountIn = BigInt("1000000000000000000");
+    const quote = await rateX.getQuote(tokenIn, tokenOut, amountIn);
+    const swapParams = await rateX.getSwapParameters(tokenIn, tokenOut, amountIn, 1, // 1% slippage
+    "0xEC744EA7c6792c2D78abdd3E1B1254fdCd32E6fe", 30 // 30 minutes deadline
+    );
+    console.log("Swap parameters:", swapParams);
+}
+main().catch(console.error);

package/dist/routing/iterative_spliting/main.d.ts

@@ -0,0 +1,3 @@
+import { Quote, Pool } from "../../utils/types/types";
+declare function findRouteWithIterativeSplitting(tokenA: string, tokenB: string, amountIn: bigint, pools: Pool[], chainId: number): Promise<Quote>;
+export { findRouteWithIterativeSplitting };