@marko00/routing-finder-mare 1.0.0

package/dexes/pools/uniswap/types.ts

@@ -0,0 +1,174 @@
+export 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) {
+        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;
+    }
+}
+
+export class TickData {
+    tick: bigint;
+    initialized: boolean;
+    liquidityNet: bigint;
+
+    clone() {
+        return new TickData(this.tick, this.initialized, this.liquidityNet);
+    }
+
+    constructor(tick: bigint, initialized: boolean, liquidityNet: bigint) {
+        this.tick = tick;
+        this.initialized = initialized;
+        this.liquidityNet = liquidityNet;
+    }
+}
+
+export class PoolData {
+    info: PoolInfo;
+    zeroForOneTicks: TickData[];
+    oneForZeroTicks: TickData[];
+
+    constructor(info: PoolInfo, zeroForOneTicks: TickData[], oneForZeroTicks: TickData[]) {
+        this.info = info;
+        this.zeroForOneTicks = zeroForOneTicks;
+        this.oneForZeroTicks = oneForZeroTicks;
+    }
+}
+
+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
+}
+
+
+// helper used for test
+export class TradeInfo {
+    pool: string;
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: bigint;
+    fee: bigint;
+
+    constructor(pool: string, tokenIn: string, tokenOut: string, amountIn: bigint, fee: bigint) {
+        this.pool = pool;
+        this.tokenIn = tokenIn;
+        this.tokenOut = tokenOut;
+        this.amountIn = amountIn;
+        this.fee = fee;
+    }
+}
+
+export class AdaptedPoolData {
+    pool: string;
+    token0: string;
+    token1: string;
+    tickSpacing: bigint;
+    fee: bigint;
+    currentLiquidity: bigint;
+    currentSqrtPriceX96: bigint;
+    ticks: TickData[];
+
+    currentTickIndex: number; // currenTick info is at ticks[currentTickIndex]
+
+    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: PoolData | null) {
+        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;
+    }
+
+    public getCurrTickData(): TickData {
+        return this.ticks[this.currentTickIndex];
+    }
+}
+
+export class LastQuote {
+    newLiquidity: bigint;
+    newSqrtPriceX96: bigint;
+    newTickIndex: number; // index in array of ticks
+
+    clone() {
+        return new LastQuote(this.newLiquidity, this.newSqrtPriceX96, this.newTickIndex)
+    }
+
+    constructor(newLiquidity: bigint, newSqrtPriceX96: bigint, newTickIndex: number) {
+        this.newLiquidity = newLiquidity;
+        this.newSqrtPriceX96 = newSqrtPriceX96;
+        this.newTickIndex = newTickIndex;
+    }
+}
+
+export class PoolState {
+    data: AdaptedPoolData;
+    lastQuote: LastQuote;
+
+    clone() {
+        return new PoolState(this.data.clone(), this.lastQuote.clone())
+    }
+
+    constructor(currData: AdaptedPoolData, lastQuote: LastQuote) {
+        this.data = currData;
+        this.lastQuote = lastQuote;
+    }
+}

package/dexes/pools/uniswap/uniswapOffchainQuoter.ts

@@ -0,0 +1,173 @@
+import { FeeAmount, LiquidityMath, SwapMath, TickMath } from "@uniswap/v3-sdk";
+import JSBI from "jsbi";
+import { LastQuote, PoolState, StepComputations, SwapState, TickData } from "./types";
+
+export class UniswapOffchainQuoter {
+
+    public quote(
+        poolState: PoolState,
+        tokenIn: string,
+        tokenOut: string,
+        amountIn: bigint
+    ): [bigint, bigint] {
+
+        if (amountIn <= BigInt(0)) {
+            return [BigInt(0), BigInt(0)];
+        }
+
+        try {
+            const zeroForOne: boolean = tokenIn < tokenOut;
+            const sqrtPriceLimitX96 = this.getSqrtPriceLimitX96(zeroForOne);
+
+            let state: SwapState = 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: StepComputations = 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 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)];
+        }
+    }
+
+    private initSwapState(poolState: PoolState, amountIn: bigint): SwapState {
+        return {
+            amountSpecifiedRemaining: amountIn,
+            amountCalculated: BigInt(0),
+            sqrtPriceX96: poolState.data.currentSqrtPriceX96,
+            tick: poolState.data.getCurrTickData().tick,
+            liquidity: poolState.data.currentLiquidity
+        };
+    }
+
+    private initStepComputations(state: SwapState, tickData: TickData): StepComputations {
+        return {
+            sqrtPriceStartX96: state.sqrtPriceX96,
+            tickNext: tickData.tick,
+            initialized: tickData.initialized,
+            sqrtPriceNextX96: BigInt(TickMath.getSqrtRatioAtTick(Number(tickData.tick)).toString()),
+            amountIn: BigInt(0),
+            amountOut: BigInt(0),
+            feeAmount: BigInt(0)
+        };
+    }
+
+    private convertToFeeAmount(fee: bigint): FeeAmount {
+        switch (fee.toString()) {
+            case "100":
+                return FeeAmount.LOWEST;
+            case "500":
+                return FeeAmount.LOW;
+            case "3000":
+                return FeeAmount.MEDIUM;
+            case "10000":
+                return FeeAmount.HIGH;
+            default:
+                throw new Error("Invalid fee amount");
+        }
+    }
+
+    private updateSwapIteration(
+        state: SwapState,
+        step: StepComputations,
+        tickData: TickData,
+        fee: bigint,
+        sqrtPriceLimitX96: bigint,
+        zeroForOne: boolean
+    ) {
+        this.updateSwapStep(state, step, fee, sqrtPriceLimitX96, zeroForOne);
+        this.calculateAmount(state, step);
+        this.updateTickWithLiquidity(state, step, tickData, zeroForOne);
+    }
+
+    private updateSwapStep(
+        state: SwapState,
+        step: StepComputations,
+        fee: bigint,
+        sqrtPriceLimitX96: bigint,
+        zeroForOne: boolean
+    ) {
+        const [sqrtPriceX96, amountIn, amountOut, feeAmount] =
+            SwapMath.computeSwapStep(
+                JSBI.BigInt(state.sqrtPriceX96.toString()),
+                this.calculateRatioTargetX96(zeroForOne, step.sqrtPriceNextX96, sqrtPriceLimitX96),
+                JSBI.BigInt(state.liquidity.toString()),
+                JSBI.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());
+    }
+
+    private calculateAmount(state: SwapState, step: StepComputations) {
+        state.amountSpecifiedRemaining -= (step.amountIn + step.feeAmount);
+        state.amountCalculated -= step.amountOut;
+    }
+
+    private updateTickWithLiquidity(
+        state: SwapState,
+        step: StepComputations,
+        tickData: TickData,
+        zeroForOne: boolean
+    ) {
+        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 = LiquidityMath.addDelta(
+                    JSBI.BigInt(state.liquidity.toString()),
+                    JSBI.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 = TickMath.getTickAtSqrtRatio(JSBI.BigInt(state.sqrtPriceX96.toString()));
+            state.tick = BigInt(tick.toString());
+        }
+    }
+
+    private calculateRatioTargetX96(
+        zeroForOne: boolean,
+        sqrtPriceNextX96: bigint,
+        sqrtPriceLimitX96: bigint
+    ): JSBI {
+        return (zeroForOne ? sqrtPriceNextX96 < sqrtPriceLimitX96 : sqrtPriceNextX96 > sqrtPriceLimitX96)
+            ? JSBI.BigInt(sqrtPriceLimitX96.toString())
+            : JSBI.BigInt(sqrtPriceNextX96.toString());
+    }
+
+    private getSqrtPriceLimitX96(zeroForOne: boolean): bigint {
+        return zeroForOne ?
+            BigInt(JSBI.add(TickMath.MIN_SQRT_RATIO, JSBI.BigInt("1")).toString()) :
+            BigInt(JSBI.subtract(TickMath.MAX_SQRT_RATIO, JSBI.BigInt("1")).toString());
+    }
+}

package/dexes/pools/uniswap/uniswapState.ts

@@ -0,0 +1,56 @@
+import { PoolData, PoolState } from './types'
+import { convertInitialPoolDataToPoolState, convertRowPoolData } from './utils'
+import { UniswapOffchainQuoter } from './uniswapOffchainQuoter'
+import { CreateUniswapHelperContract } from '../../../contracts/rateX/UniswapHelper'
+import Web3 from 'web3'
+
+export class UniswapState {
+  private static poolStateMap: Map<string, PoolState> = new Map<string, PoolState>()
+  private static startingPoolStateMap: Map<string, PoolState> = new Map<string, PoolState>()
+  public static quoter: UniswapOffchainQuoter = new UniswapOffchainQuoter()
+  private static batch_size = 3
+
+  private constructor() { }
+
+  public static getPoolState(poolAddress: string): PoolState | undefined {
+    return this.poolStateMap.get(poolAddress.toLowerCase())
+  }
+  public static resetPoolState(poolAddress: string): void {
+    const poolState = this.startingPoolStateMap.get(poolAddress.toLowerCase())
+    if (poolState) {
+      this.poolStateMap.set(poolAddress.toLowerCase(), poolState.clone())
+    }
+  }
+
+  private static async getPoolsDataFromContract(pools: string[], chainId: number, rpcProvider: Web3): Promise<PoolData[]> {
+    //@ts-ignore
+    try {
+      const UniswapHelperContract = CreateUniswapHelperContract(chainId, rpcProvider)
+      const rawPoolsData: any[] = await UniswapHelperContract.methods.fetchData(pools, 15).call()
+      return rawPoolsData.map((rawPoolData: any) => convertRowPoolData(rawPoolData))
+    } catch (err) {
+      console.log('Error while fetching additional data from the smart contracts: ', err)
+      throw err
+    }
+  }
+
+  public static async initializeFreshPoolsData(pools: string[], chainId: number, rpcProvider: Web3) {
+    const poolsSize = pools.length
+    const numberOfBatches = Math.ceil(poolsSize / this.batch_size)
+
+    const promises: Promise<PoolData[]>[] = []
+
+    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: PoolData) => {
+      let poolState = 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())
+    })
+  }
+}

package/dexes/pools/uniswap/utils.ts

@@ -0,0 +1,71 @@
+import {AdaptedPoolData, LastQuote, PoolData, PoolInfo, PoolState, TickData} from "./types";
+
+export function convertRowPoolData(poolData: any): PoolData {
+
+    const getPoolInfo = (poolInfoRaw: any): PoolInfo => {
+        const pool: string = poolInfoRaw[0];
+        const token0: string = poolInfoRaw[1];
+        const token1: string = poolInfoRaw[2];
+        const tick: bigint = poolInfoRaw[3];
+        const tickLiquidityNet: bigint = poolInfoRaw[4];
+        const tickSpacing: bigint = poolInfoRaw[5];
+        const fee: bigint = poolInfoRaw[6];
+        const sqrtPriceX96: bigint = poolInfoRaw[7];
+        const liquidity: bigint = poolInfoRaw[8];
+
+        return new PoolInfo(
+            pool,
+            token0,
+            token1,
+            tick,
+            tickLiquidityNet,
+            tickSpacing,
+            fee,
+            sqrtPriceX96,
+            liquidity
+        );
+    }
+
+    const getTickData = (tickDataRaw: any): TickData => {
+        const tick: bigint = tickDataRaw[0];
+        const initialized: boolean = tickDataRaw[1];
+        const liquidityNet: bigint = tickDataRaw[2];
+
+        return new TickData(
+            tick,
+            initialized,
+            liquidityNet
+        );
+    }
+
+    const zeroForOneTicksRaw = poolData[1];
+    const zeroForOneTicks: TickData[] = [];
+    for (let i = 0; i < zeroForOneTicksRaw.length; i++) {
+        zeroForOneTicks.push(getTickData(zeroForOneTicksRaw[i]));
+    }
+
+    const oneForZeroTicksRaw = poolData[2];
+    const oneForZeroTicks: TickData[] = [];
+    for (let i = 0; i < oneForZeroTicksRaw.length; i++) {
+        oneForZeroTicks.push(getTickData(oneForZeroTicksRaw[i]));
+    }
+
+    return new PoolData(
+        getPoolInfo(poolData[0]),
+        zeroForOneTicks,
+        oneForZeroTicks
+    );
+}
+
+export function convertInitialPoolDataToPoolState(poolData: PoolData): PoolState {
+    const adaptedPoolData = new AdaptedPoolData(poolData);
+    const lastQuote = new LastQuote(
+        adaptedPoolData.currentLiquidity,
+        adaptedPoolData.currentSqrtPriceX96,
+        adaptedPoolData.currentTickIndex
+    );
+
+    return new PoolState(adaptedPoolData, lastQuote);
+}
+
+

package/dist/contracts/abi/BalancerHelperAbi.d.ts

@@ -0,0 +1,25 @@
+export declare const BalancerHelperAbi: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+})[];

package/dist/contracts/abi/BalancerHelperAbi.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BalancerHelperAbi = void 0;
+exports.BalancerHelperAbi = [{ "inputs": [{ "internalType": "address", "name": "_balancerVault", "type": "address" }], "stateMutability": "nonpayable", "type": "constructor" }, { "inputs": [{ "internalType": "bytes32", "name": "_poolId", "type": "bytes32" }], "name": "getWeightedPoolInfo", "outputs": [{ "internalType": "uint8", "name": "decimals", "type": "uint8" }, { "internalType": "address[]", "name": "tokens", "type": "address[]" }, { "internalType": "uint256[]", "name": "balances", "type": "uint256[]" }, { "internalType": "uint256[]", "name": "weights", "type": "uint256[]" }, { "internalType": "uint256", "name": "feePercentage", "type": "uint256" }], "stateMutability": "view", "type": "function" }];

package/dist/contracts/abi/CamelotHelperAbi.d.ts

@@ -0,0 +1,45 @@
+export declare const CamelotHelperAbi: {
+    inputs: {
+        components: ({
+            internalType: string;
+            name: string;
+            type: string;
+            components?: undefined;
+        } | {
+            components: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            internalType: string;
+            name: string;
+            type: string;
+        })[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        components: ({
+            internalType: string;
+            name: string;
+            type: string;
+            components?: undefined;
+        } | {
+            components: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            internalType: string;
+            name: string;
+            type: string;
+        })[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];

package/dist/contracts/abi/CamelotHelperAbi.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CamelotHelperAbi = void 0;
+exports.CamelotHelperAbi = [{ "inputs": [{ "components": [{ "internalType": "address", "name": "poolId", "type": "address" }, { "internalType": "string", "name": "dexId", "type": "string" }, { "components": [{ "internalType": "address", "name": "_address", "type": "address" }, { "internalType": "uint256", "name": "decimals", "type": "uint256" }], "internalType": "struct IHelperState.Token[]", "name": "tokens", "type": "tuple[]" }], "internalType": "struct IHelperState.PoolInfo[]", "name": "poolsInfo", "type": "tuple[]" }], "name": "getPoolsData", "outputs": [{ "components": [{ "internalType": "address", "name": "poolId", "type": "address" }, { "internalType": "string", "name": "dexId", "type": "string" }, { "components": [{ "internalType": "address", "name": "_address", "type": "address" }, { "internalType": "uint256", "name": "decimals", "type": "uint256" }], "internalType": "struct IHelperState.Token[]", "name": "tokens", "type": "tuple[]" }, { "internalType": "uint112[2]", "name": "reserves", "type": "uint112[2]" }, { "internalType": "uint16[2]", "name": "fees", "type": "uint16[2]" }, { "internalType": "bool", "name": "stableSwap", "type": "bool" }], "internalType": "struct CamelotHelper.CamelotPool[]", "name": "pools", "type": "tuple[]" }], "stateMutability": "view", "type": "function" }];

package/dist/contracts/abi/RateXAbi.d.ts

@@ -0,0 +1,71 @@
+export declare const RateXAbi: ({
+    inputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: never[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: ({
+        components: ({
+            components: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            internalType: string;
+            name: string;
+            type: string;
+        } | {
+            internalType: string;
+            name: string;
+            type: string;
+            components?: undefined;
+        })[];
+        internalType: string;
+        name: string;
+        type: string;
+    } | {
+        internalType: string;
+        name: string;
+        type: string;
+        components?: undefined;
+    })[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];