@marko00/routing-finder-mare 1.0.0

package/dist/dexes/graph_queries/UniswapV3.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const graphql_request_1 = require("graphql-request");
+const dexIdsList_1 = require("../dexIdsList");
+const uniswapState_1 = require("../pools/uniswap/uniswapState");
+const UniswapV3_1 = require("../pools/uniswap/UniswapV3");
+const graphQueryFilters_1 = require("./graphQueryFilters");
+class UniswapV3 {
+    constructor() {
+        this.endpoint = ``;
+        this.chainId = 1;
+        this.dexId = dexIdsList_1.dexIds.UNI_V3;
+        this.myLocalStorage = null;
+    }
+    static initialize(myLocalStorage) {
+        const object = new UniswapV3();
+        object.myLocalStorage = myLocalStorage;
+        return object;
+    }
+    setEndpoint(chainId, graphApiKey) {
+        if (chainId == 1329) {
+            this.endpoint = 'https://indexer.us.hyperindex.xyz/32230f9/converter';
+        }
+        if (chainId == 1) {
+            this.endpoint = `https://gateway-arbitrum.network.thegraph.com/api/${graphApiKey}/subgraphs/id/5zvR82QoaXYFyDEKLZ9t6v9adgnptxYpKpSbxtgVENFV`;
+        }
+        if (chainId == 42161) {
+            this.endpoint = `https://gateway-arbitrum.network.thegraph.com/api/${graphApiKey}/subgraphs/id/FbCGRftH4a3yZugY7TnbYgPJVEv2LvMT6oF1fxPe9aJM`;
+        }
+        if (chainId == 420420417) {
+            this.endpoint = `https://saphyre-service-dev.saphyre.xyz/api/graphql/v3`;
+        }
+        this.chainId = chainId;
+    }
+    async getTopPools(numPools) {
+        const poolsInfo = [];
+        const { resultKey } = (0, graphQueryFilters_1.v3LiquidityCollection)(this.chainId);
+        const queryResult = await (0, graphql_request_1.request)(this.endpoint, queryTopPools(numPools, this.chainId));
+        queryResult[resultKey].forEach((pool) => {
+            poolsInfo.push(createPoolFromGraph(pool, this.dexId));
+        });
+        return poolsInfo;
+    }
+    async getPoolsWithTokenPair(tokenA, tokenB, numPools) {
+        const a = tokenA.toLowerCase();
+        const b = tokenB.toLowerCase();
+        const { resultKey } = (0, graphQueryFilters_1.v3LiquidityCollection)(this.chainId);
+        const [resAb, resBa] = await Promise.all([
+            (0, graphql_request_1.request)(this.endpoint, queryPoolsWithTokenPairDirected(a, b, numPools, this.chainId)),
+            (0, graphql_request_1.request)(this.endpoint, queryPoolsWithTokenPairDirected(b, a, numPools, this.chainId)),
+        ]);
+        return mergePoolsByVolume([resAb[resultKey], resBa[resultKey]], numPools, this.dexId);
+    }
+    async getPoolsWithToken(token, numPools) {
+        const t = token.toLowerCase();
+        const { resultKey } = (0, graphQueryFilters_1.v3LiquidityCollection)(this.chainId);
+        const [res0, res1] = await Promise.all([
+            (0, graphql_request_1.request)(this.endpoint, queryPoolsWithTokenOnSide0(t, numPools, this.chainId)),
+            (0, graphql_request_1.request)(this.endpoint, queryPoolsWithTokenOnSide1(t, numPools, this.chainId)),
+        ]);
+        return mergePoolsByVolume([res0[resultKey], res1[resultKey]], numPools, this.dexId);
+    }
+    async getAdditionalPoolDataFromSolidity(poolInfos, rpcProvider) {
+        const pools = poolInfos.map((poolInfo) => poolInfo.poolId);
+        await uniswapState_1.UniswapState.initializeFreshPoolsData(pools, this.chainId, rpcProvider);
+        const pools2 = poolInfos.map((poolInfo) => new UniswapV3_1.UniswapV3Pool(poolInfo.poolId, this.dexId, poolInfo.tokens));
+        for (const pool of pools2)
+            // @ts-ignore
+            this.myLocalStorage.setItem(pool.poolId.toLowerCase(), pool);
+        return pools2;
+    }
+}
+exports.default = UniswapV3;
+function queryTopPools(numPools, chainId) {
+    const { field } = (0, graphQueryFilters_1.v3LiquidityCollection)(chainId);
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) `
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `);
+}
+function queryPoolsWithTokenPairDirected(token0Id, token1Id, numPools, chainId) {
+    const { field } = (0, graphQueryFilters_1.v3LiquidityCollection)(chainId);
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) `
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD, where : {
+      ${(0, graphQueryFilters_1.whereDirectedTokenPair)(token0Id, token1Id, chainId)},
+      }) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `);
+}
+function queryPoolsWithTokenOnSide0(token, numPools, chainId) {
+    const { field } = (0, graphQueryFilters_1.v3LiquidityCollection)(chainId);
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) `
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD, where : {
+      ${(0, graphQueryFilters_1.whereTokenOnSide)('token0', token, chainId)},
+      }) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `);
+}
+function queryPoolsWithTokenOnSide1(token, numPools, chainId) {
+    const { field } = (0, graphQueryFilters_1.v3LiquidityCollection)(chainId);
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) `
+    {
+      ${field}(first : ${numPools}, orderDirection : desc, orderBy : volumeUSD, where : {
+      ${(0, graphQueryFilters_1.whereTokenOnSide)('token1', token, chainId)},
+      }) {
+      id,
+      volumeUSD,
+      token0 {
+        id,
+        name,
+        decimals,
+      },
+      token1 {
+        id,
+        name,
+        decimals,
+      },
+    },
+    }
+  `);
+}
+function mergePoolsByVolume(poolLists, numPools, dexId) {
+    const byId = new Map();
+    for (const list of poolLists) {
+        for (const pool of list) {
+            byId.set(String(pool.id).toLowerCase(), pool);
+        }
+    }
+    const merged = [...byId.values()];
+    merged.sort((a, b) => {
+        const va = parseFloat(a.volumeUSD) || 0;
+        const vb = parseFloat(b.volumeUSD) || 0;
+        return vb - va;
+    });
+    return merged.slice(0, numPools).map((p) => createPoolFromGraph(p, dexId));
+}
+function createPoolFromGraph(jsonData, dexId) {
+    const pool = {
+        poolId: jsonData.id,
+        dexId: dexId,
+        tokens: [
+            {
+                _address: jsonData.token0.id,
+                decimals: Number(jsonData.token0.decimals),
+                name: jsonData.token0.name,
+            },
+            {
+                _address: jsonData.token1.id,
+                decimals: Number(jsonData.token1.decimals),
+                name: jsonData.token1.name,
+            },
+        ],
+    };
+    return pool;
+}

package/dist/dexes/graph_queries/graphQueryFilters.d.ts

@@ -0,0 +1,19 @@
+/** Chains whose graph URL goes through HyperIndex → Hasura (Saphyre / Sei). */
+export declare function usesHyperIndexConverter(chainId: number): boolean;
+/** V2 liquidity collection: merged schema uses V2_Factory_Pair; The Graph uses pairs. */
+export declare function v2LiquidityCollection(chainId: number): {
+    field: string;
+    resultKey: string;
+};
+/** V3 liquidity collection: merged schema uses V3_Factory_Pool; The Graph uses pools. */
+export declare function v3LiquidityCollection(chainId: number): {
+    field: string;
+    resultKey: string;
+};
+/**
+ * `where` clause fragment for a pool/pair token side.
+ * - HyperIndex: `token0: { id: "0x..." }` (scalar address becomes invalid `token1: { _eq }` on Token_bool_exp)
+ * - The Graph: `token0: "0x..."`
+ */
+export declare function whereTokenOnSide(side: 'token0' | 'token1', address: string, chainId: number): string;
+export declare function whereDirectedTokenPair(token0Id: string, token1Id: string, chainId: number): string;

package/dist/dexes/graph_queries/graphQueryFilters.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usesHyperIndexConverter = usesHyperIndexConverter;
+exports.v2LiquidityCollection = v2LiquidityCollection;
+exports.v3LiquidityCollection = v3LiquidityCollection;
+exports.whereTokenOnSide = whereTokenOnSide;
+exports.whereDirectedTokenPair = whereDirectedTokenPair;
+/** Chains whose graph URL goes through HyperIndex → Hasura (Saphyre / Sei). */
+function usesHyperIndexConverter(chainId) {
+    return chainId === 1329 || chainId === 420420417;
+}
+/** V2 liquidity collection: merged schema uses V2_Factory_Pair; The Graph uses pairs. */
+function v2LiquidityCollection(chainId) {
+    if (usesHyperIndexConverter(chainId)) {
+        return { field: 'V2_Factory_Pair', resultKey: 'V2_Factory_Pair' };
+    }
+    return { field: 'pairs', resultKey: 'pairs' };
+}
+/** V3 liquidity collection: merged schema uses V3_Factory_Pool; The Graph uses pools. */
+function v3LiquidityCollection(chainId) {
+    if (usesHyperIndexConverter(chainId)) {
+        return { field: 'V3_Factory_Pool', resultKey: 'V3_Factory_Pool' };
+    }
+    return { field: 'pools', resultKey: 'pools' };
+}
+/**
+ * `where` clause fragment for a pool/pair token side.
+ * - HyperIndex: `token0: { id: "0x..." }` (scalar address becomes invalid `token1: { _eq }` on Token_bool_exp)
+ * - The Graph: `token0: "0x..."`
+ */
+function whereTokenOnSide(side, address, chainId) {
+    const id = address.toLowerCase();
+    if (usesHyperIndexConverter(chainId)) {
+        return `${side} : { id : "${id}" }`;
+    }
+    return `${side} : "${id}"`;
+}
+function whereDirectedTokenPair(token0Id, token1Id, chainId) {
+    return `${whereTokenOnSide('token0', token0Id, chainId)}, ${whereTokenOnSide('token1', token1Id, chainId)}`;
+}

package/dist/dexes/graph_queries/x_template.d.ts

@@ -0,0 +1,12 @@
+import { Pool, PoolInfo, DEXGraphFunctionality } from '../../utils/types/types';
+export default class NewDex implements DEXGraphFunctionality {
+    endpoint: string;
+    dexId: string;
+    chainId: number;
+    static initialize(): DEXGraphFunctionality;
+    setEndpoint(chainId: number): void;
+    getTopPools(numPools: number): Promise<PoolInfo[]>;
+    getPoolsWithTokenPair(token1: string, token2: string, first: number): Promise<PoolInfo[]>;
+    getPoolsWithToken(token: string, numPools: number): Promise<PoolInfo[]>;
+    getAdditionalPoolDataFromSolidity(poolInfos: PoolInfo[]): Promise<Pool[]>;
+}

package/dist/dexes/graph_queries/x_template.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const graphql_request_1 = require("graphql-request");
+class NewDex {
+    constructor() {
+        this.endpoint = '';
+        this.dexId = '';
+        this.chainId = 1;
+    }
+    static initialize() {
+        return new NewDex();
+    }
+    setEndpoint(chainId) {
+        if (chainId == 42161) {
+            this.endpoint = '';
+        }
+        this.chainId = chainId;
+    }
+    async getTopPools(numPools) {
+        const poolsInfo = [];
+        const queryResult = await (0, graphql_request_1.request)(this.endpoint, queryTopPools(numPools));
+        queryResult.pairs.forEach((pair) => {
+            poolsInfo.push(pair.id);
+        });
+        return poolsInfo;
+    }
+    async getPoolsWithTokenPair(token1, token2, first) {
+        const poolsInfo = [];
+        const queryResult = await (0, graphql_request_1.request)(this.endpoint, queryPoolsWithTokenPair(token1, token2, first));
+        queryResult.pairs.forEach((pair) => {
+            poolsInfo.push(pair.id);
+        });
+        return poolsInfo;
+    }
+    async getPoolsWithToken(token, numPools) {
+        const poolsInfo = [];
+        const queryResult = await (0, graphql_request_1.request)(this.endpoint, queryPoolsWithToken(token, numPools));
+        queryResult.pairs.forEach((pair) => {
+            poolsInfo.push(pair.id);
+        });
+        return poolsInfo;
+    }
+    async getAdditionalPoolDataFromSolidity(poolInfos) {
+        return [];
+    }
+}
+exports.default = NewDex;
+function queryTopPools(numPools) {
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) ``);
+}
+function queryPoolsWithTokenPair(tokenA, tokenB, numPools) {
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) ``);
+}
+function queryPoolsWithToken(token, numPools) {
+    return (0, graphql_1.parse)((0, graphql_request_1.gql) ``);
+}

package/dist/dexes/pools/Balancer/BalancerState.d.ts

@@ -0,0 +1,6 @@
+import { Pool, PoolInfo } from '../../../utils/types/types';
+import Web3 from 'web3';
+export declare class BalancerState {
+    private constructor();
+    static getPoolDataFromContract(pools: PoolInfo[], chainId: number, rpcProvider: Web3): Promise<Pool[]>;
+}

package/dist/dexes/pools/Balancer/BalancerState.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BalancerState = void 0;
+const BalancerWeightedPool_1 = require("./BalancerWeightedPool");
+const BalancerHelper_1 = require("../../../contracts/rateX/BalancerHelper");
+class BalancerState {
+    constructor() { }
+    static async getPoolDataFromContract(pools, chainId, rpcProvider) {
+        const promises = pools.map(async (pool) => {
+            // return token address after '-' split
+            pool.tokens.forEach((token) => token._address = token._address.split('-')[1]);
+            const BalancerHelperContract = (0, BalancerHelper_1.CreateBalancerHelperContract)(chainId, rpcProvider);
+            try {
+                // @ts-ignore
+                const res = await BalancerHelperContract.methods
+                    .getWeightedPoolInfo(pool.poolId)
+                    .call();
+                const [decimals, tokens, balances, weights, swapFeePercentage] = [res[0], res[1], res[2], res[3], res[4]];
+                const weightedPool = new BalancerWeightedPool_1.BalancerWeightedPool(pool.poolId, pool.dexId, pool.tokens, balances, weights, swapFeePercentage);
+                return weightedPool;
+            }
+            catch (err) {
+                console.log('Weighted Get Pool Info Error: ', err);
+                return null; // Handle the error as needed
+            }
+        });
+        const newPools = await Promise.all(promises);
+        // @ts-ignore
+        return newPools.filter((pool) => pool !== null); // Filter out any null values
+    }
+}
+exports.BalancerState = BalancerState;

package/dist/dexes/pools/Balancer/BalancerWeightedPool.d.ts

@@ -0,0 +1,12 @@
+import { Token, Pool } from '../../../utils/types/types';
+import BigNumber from 'bignumber.js';
+export declare class BalancerWeightedPool extends Pool {
+    reserves: BigNumber[];
+    startingReserves: BigNumber[];
+    weights: BigNumber[];
+    swapFeePercentage: BigNumber;
+    constructor(poolId: string, dexId: string, tokens: Token[], reserves: BigInt[], weights: BigInt[], swapFeePercentage: 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/Balancer/BalancerWeightedPool.js

@@ -0,0 +1,109 @@
+"use strict";
+// Ported from Solidity: https://github.com/balancer/balancer-v2-monorepo/blob/master/pkg/pool-weighted/contracts/WeightedMath.sol
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BalancerWeightedPool = void 0;
+const types_1 = require("../../../utils/types/types");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const fp = __importStar(require("../../../utils/math/fixed-points"));
+const math = __importStar(require("../../../utils/math/math"));
+// Swap limits: amounts swapped may not be larger than this percentage of total balance of the token being swapped
+// Example - if the pool has 100 WETH, we can swap a maximum od 30 WETH
+const _MAX_IN_RATIO = new bignumber_js_1.default(0.3e18);
+class BalancerWeightedPool extends types_1.Pool {
+    constructor(poolId, dexId, tokens, reserves, weights, swapFeePercentage) {
+        super(poolId, dexId, tokens);
+        this.reserves = reserves.map((r) => new bignumber_js_1.default(r.toString()));
+        this.startingReserves = [...this.reserves];
+        this.weights = weights.map((r) => new bignumber_js_1.default(r.toString()));
+        this.swapFeePercentage = new bignumber_js_1.default(swapFeePercentage.toString());
+    }
+    reset() {
+        this.reserves = [...this.startingReserves];
+    }
+    calculateExpectedOutputAmount(tokenIn, tokenOut, amountIn) {
+        return calculateOutputAmount(this, tokenIn, tokenOut, (0, bignumber_js_1.default)(amountIn.toString()));
+    }
+    update(tokenIn, tokenOut, amountIn, amountOut) {
+        // CHECK ???
+        const i = this.tokens.findIndex((token) => token._address === tokenIn);
+        const j = this.tokens.findIndex((token) => token._address === tokenOut);
+        this.reserves[i] = fp.add(this.reserves[i], (0, bignumber_js_1.default)(amountIn.toString()));
+        this.reserves[j] = fp.sub(this.reserves[j], (0, bignumber_js_1.default)(amountOut.toString()));
+    }
+}
+exports.BalancerWeightedPool = BalancerWeightedPool;
+function calculateOutputAmount(pool, tokenA, tokenB, tokenAmountIn, swapFeePercentage) {
+    // Subtract the fee from the amount in if requested
+    if (swapFeePercentage)
+        tokenAmountIn = fp.sub(tokenAmountIn, fp.mulUp(tokenAmountIn, swapFeePercentage));
+    // Get the index of the token we are swapping from and to
+    const i = pool.tokens.findIndex((token) => token._address === tokenA);
+    const j = pool.tokens.findIndex((token) => token._address === tokenB);
+    try {
+        const res = _calcOutGivenIn(pool.reserves[i], pool.weights[i], pool.reserves[j], pool.weights[j], tokenAmountIn);
+        return BigInt(res.toFixed());
+    }
+    catch (e) {
+        return BigInt(0);
+    }
+}
+/* Computes how many tokens can be taken out of a pool if `amountIn` are sent, given the current balances and weights.
+    Amount out, so we round down overall:
+**********************************************************************************************
+// outGivenIn                                                                                //
+// aO = amountOut                                                                            //
+// bO = balanceOut                                                                           //
+// bI = balanceIn              /      /            bI             \    (wI / wO) \           //
+// aI = amountIn    aO = bO * |  1 - | --------------------------  | ^            |          //
+// wI = weightIn               \      \       ( bI + aI )         /              /           //
+// wO = weightOut                                                                            //
+**********************************************************************************************
+The multiplication rounds down, and the subtrahend (power) runds up (so the base rounds up too).
+Because bI / (bI + aI) <= 1, the exponent rounds down.  */
+// Ovde puca!!!!!!!!!!!!!!
+function _calcOutGivenIn(balanceIn, weightIn, balanceOut, weightOut, amountIn) {
+    // Cannot exceed maximum in ratio (30% of tokenIn balance)
+    if (amountIn.gte(fp.mulDown(balanceIn, _MAX_IN_RATIO)))
+        throw new Error('MAX_IN_RATIO');
+    const denominator = math.add(balanceIn, amountIn);
+    const base = fp.divUp(balanceIn, denominator);
+    const exponent = fp.divDown(weightIn, weightOut);
+    const power = fp.powUp(base, exponent);
+    return fp.mulDown(balanceOut, fp.complement(power));
+}

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

@@ -0,0 +1,12 @@
+import { Pool, Token } from '../../utils/types/types';
+import BigNumber from "bignumber.js";
+export declare class CamelotPool extends Pool {
+    fees: BigNumber[];
+    reserves: BigNumber[];
+    startingReserves: BigNumber[];
+    stableSwap: boolean;
+    constructor(poolId: string, dexId: string, tokens: Token[], reserves: bigint[], fees: bigint[], stableSwap: boolean);
+    reset(): void;
+    calculateExpectedOutputAmount(tokenIn: string, tokenOut: string, amountIn: bigint): bigint;
+    update(tokenIn: string, tokenOut: string, amountIn: bigint, amountOut: bigint): void;
+}

package/dist/dexes/pools/Camelot.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CamelotPool = void 0;
+const types_1 = require("../../utils/types/types");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+// Camelot V2 pools have 2 tokens in the pool, and a fee
+// Example contracts of one Camelot V2 pool: https://arbiscan.io/address/0xa6c5c7d189fa4eb5af8ba34e63dcdd3a635d433f#readContract
+const feeDenominator = new bignumber_js_1.default(100000);
+class CamelotPool extends types_1.Pool {
+    constructor(poolId, dexId, tokens, reserves, fees, stableSwap) {
+        super(poolId, dexId, tokens);
+        this.reserves = reserves.map((r) => (0, bignumber_js_1.default)(r.toString()));
+        this.startingReserves = [...this.reserves];
+        this.fees = fees.map((f) => (0, bignumber_js_1.default)(f.toString()));
+        this.stableSwap = stableSwap;
+    }
+    reset() {
+        this.reserves = [...this.startingReserves];
+    }
+    // function getAmountOut on Camelot V2 pools smart contracts
+    calculateExpectedOutputAmount(tokenIn, tokenOut, amountIn) {
+        // this function will be called by our routing algorithm which uses bigint values
+        const amountInBN = new bignumber_js_1.default(amountIn.toString());
+        if (this.stableSwap)
+            return calculateStableSwap(this, tokenIn, tokenOut, amountInBN);
+        else
+            return calculateRegularSwap(this, tokenIn, tokenOut, amountInBN);
+    }
+    update(tokenIn, tokenOut, amountIn, amountOut) {
+        const i = this.tokens.findIndex((token) => token._address === tokenIn);
+        const j = this.tokens.findIndex((token) => token._address === tokenOut);
+        this.reserves[i] = this.reserves[i].plus((0, bignumber_js_1.default)(amountIn.toString()));
+        this.reserves[j] = this.reserves[j].minus((0, bignumber_js_1.default)(amountOut.toString()));
+    }
+}
+exports.CamelotPool = CamelotPool;
+function calculateStableSwap(pool, tokenIn, tokenOut, amountIn) {
+    const feePercent = tokenIn.toLowerCase() === pool.tokens[0]._address.toLowerCase() ? pool.fees[0] : pool.fees[1];
+    let reserve0 = pool.reserves[0];
+    let reserve1 = pool.reserves[1];
+    const precisionMultiplier0 = new bignumber_js_1.default(10 ** pool.tokens[0].decimals);
+    const precisionMultiplier1 = new bignumber_js_1.default(10 ** pool.tokens[1].decimals);
+    amountIn = amountIn.minus(amountIn.times(feePercent).div(feeDenominator)); // remove fee from amount received
+    const xy = _k(pool);
+    reserve0 = reserve0.times(1e18).div(precisionMultiplier0);
+    reserve1 = reserve1.times(1e18).div(precisionMultiplier1);
+    const [reserveA, reserveB] = tokenIn.toLowerCase() === pool.tokens[0]._address.toLowerCase()
+        ? [reserve0, reserve1]
+        : [reserve1, reserve0];
+    // amountIn = tokenIn == token0 ? amountIn * 1e18 / precisionMultiplier0 : amountIn * 1e18 / precisionMultiplier1;
+    amountIn = tokenIn.toLowerCase() === pool.tokens[0]._address.toLowerCase()
+        ? amountIn.times(1e18).div(precisionMultiplier0)
+        : amountIn.times(1e18).div(precisionMultiplier1);
+    // uint y = reserveB - _get_y(amountIn + reserveA, xy, reserveB);
+    const y = reserveB.minus(_get_y(amountIn.plus(reserveA), xy, reserveB));
+    // return y * (tokenIn == token0 ? precisionMultiplier1 : precisionMultiplier0) / 1e18;
+    let result = tokenIn.toLowerCase() === pool.tokens[0]._address.toLowerCase()
+        ? y.times(precisionMultiplier1).div(1e18)
+        : y.times(precisionMultiplier0).div(1e18);
+    result = floor(result);
+    return BigInt(result.toFixed());
+}
+// named the same as in Camelot V2 pools smart contracts
+function _k(pool) {
+    // for simplicity extract values
+    let reserve0 = pool.reserves[0];
+    let reserve1 = pool.reserves[1];
+    if (pool.stableSwap) {
+        const precisionMultiplier0 = new bignumber_js_1.default(10 ** pool.tokens[0].decimals);
+        const precisionMultiplier1 = new bignumber_js_1.default(10 ** pool.tokens[1].decimals);
+        const x = reserve0.times(1e18).div(precisionMultiplier0);
+        const y = reserve1.times(1e18).div(precisionMultiplier1);
+        const a = x.times(y).div(1e18);
+        const b = x.times(x).div(1e18).plus(y.times(y).div(1e18));
+        let res = a.times(b).div(1e18);
+        return floor(res); // x3y+y3x >= k
+    }
+    return reserve0.times(reserve1);
+}
+// named the same as in Camelot V2 pools smart contracts
+function _get_y(x0, xy, y) {
+    for (let i = 0; i < 255; i++) {
+        const y_prev = y;
+        const k = _f(x0, y);
+        if (k.lt(xy)) {
+            let dy = xy.minus(k).times(1e18).dividedToIntegerBy(_d(x0, y));
+            y = y.plus(dy);
+        }
+        else {
+            let dy = k.minus(xy).times(1e18).dividedToIntegerBy(_d(x0, y));
+            y = y.minus(dy);
+        }
+        const diff = y.minus(y_prev).abs();
+        if (diff.lte(1))
+            break;
+    }
+    return floor(y);
+}
+function _f(x0, y) {
+    // return x0 * (y * y / 1e18 * y / 1e18) / 1e18 + (x0 * x0 / 1e18 * x0 / 1e18) * y / 1e18;
+    const ySquared = y.times(y).dividedToIntegerBy(1e18);
+    const x0Squared = x0.times(x0).dividedToIntegerBy(1e18);
+    const term1 = x0.times((ySquared).times(y).dividedToIntegerBy(1e18)).dividedToIntegerBy(1e18);
+    const term2 = y.times(x0Squared.times(x0).dividedToIntegerBy(1e18)).dividedToIntegerBy(1e18);
+    return term1.plus(term2);
+}
+function _d(x0, y) {
+    // return 3 * x0 * (y * y / 1e18) / 1e18 + (x0 * x0 / 1e18 * x0 / 1e18);
+    const ySquared = y.times(y).dividedToIntegerBy(1e18);
+    const x0Squared = x0.times(x0).dividedToIntegerBy(1e18);
+    const term1 = x0.times(ySquared).times(3).dividedToIntegerBy(1e18);
+    const term2 = x0Squared.times(x0).dividedToIntegerBy(1e18);
+    return term1.plus(term2);
+}
+function calculateRegularSwap(pool, tokenIn, tokenOut, amountIn) {
+    const feePercent = tokenIn.toLowerCase() === pool.tokens[0]._address.toLowerCase() ? pool.fees[0] : pool.fees[1];
+    const [reserveA, reserveB] = tokenIn.toLowerCase() === pool.tokens[0]._address.toLowerCase()
+        ? [pool.reserves[0], pool.reserves[1]]
+        : [pool.reserves[1], pool.reserves[0]];
+    amountIn = amountIn.times(feeDenominator.minus(feePercent));
+    const numerator = amountIn.times(reserveB);
+    const denominator = reserveA.times(feeDenominator).plus(amountIn);
+    const result = floor(numerator.div(denominator));
+    return BigInt(result.toFixed());
+}
+/*  Custom floor function because BigNumber library does not implement it
+    @param num: the BigNumber number to be floored
+*/
+function floor(num) {
+    const whole = num.toFixed().toString().split('.')[0];
+    return new bignumber_js_1.default(whole);
+}

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

@@ -0,0 +1,9 @@
+import { Pool, Token } from '../../utils/types/types';
+export declare class SushiSwapV2Pool 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;
+}