@marko00/routing-finder-mare 1.0.0

package/routing/uni_like_algo/swap_finder.ts

@@ -0,0 +1,185 @@
+import {AlgoParams, QueueItem, TQuoteUniLike, TRouteWithQuote} from "./types";
+import Queue from "mnemonist/queue";
+
+export class SwapFinder {
+
+    private algoParams: AlgoParams;
+    private percentagesToSortedQuotes: Map<number, TRouteWithQuote[]>;
+    private percentages: number[];
+    private amountIn: bigint;
+    private bestQuote: bigint;
+    private bestSwap: TRouteWithQuote[];
+    private queue: Queue<QueueItem>;
+    private numOfSplits: number;
+
+    public constructor(algoParams: AlgoParams, routesWithQuotes: TRouteWithQuote[], percentages: number[], amountIn: bigint) {
+        this.algoParams = algoParams;
+        this.percentages = percentages;
+        this.amountIn = amountIn;
+        this.percentagesToSortedQuotes = this.getSortedQuotes(routesWithQuotes);
+
+        this.bestQuote = BigInt(0);
+        this.bestSwap = [];
+        this.queue = new Queue<QueueItem>();
+        this.numOfSplits = 1;
+    }
+
+    private readyToFinishSplitting() {
+        const maxSplitsReached: boolean = this.numOfSplits > this.algoParams.maxSplit;
+        const bestSwapNotImprovedWithNewSplit: boolean =
+            this.numOfSplits >= 3 && (this.bestSwap.length < this.numOfSplits - 1);
+
+        return maxSplitsReached || bestSwapNotImprovedWithNewSplit;
+    }
+
+    public findBestRoute(): TQuoteUniLike {
+        this.initBestQuoteAndSwapForFullAmount();
+        this.initQueueWithHighestQuotes();
+
+        while (this.queue.size > 0) {
+            let layer = this.queue.size;
+            this.numOfSplits++;
+            if (this.readyToFinishSplitting()) {
+                break;
+            }
+            this.processLayer(layer);
+        }
+
+        this.addMissingAmountIn();
+
+        return {
+            quote: this.bestQuote,
+            routes: this.bestSwap
+        };
+    }
+
+    private addMissingAmountIn() {
+        const totalAmountIn = this.bestSwap.reduce((acc, route) => acc + route.amount.amountIn, BigInt(0));
+        const diff = this.amountIn - totalAmountIn;
+        if (diff > BigInt(0)) {
+            this.bestSwap[this.bestSwap.length - 1].amount.amountIn += diff;
+        }
+    }
+
+    private processLayer(layer: number) {
+        while (layer > 0) {
+            layer--;
+            const q = this.queue.dequeue()!;
+            this.processPairedItemsInLayer(q);
+        }
+    }
+
+    private processPairedItemsInLayer(q: QueueItem) {
+        for (let i = q.percentageIndex; i >= 0; --i) {
+            const percentage = this.percentages[i];
+            if (percentage > q.ramainingPercentage || !this.percentagesToSortedQuotes.has(percentage)) {
+                continue;
+            }
+            this.processPairedItem(q, percentage, i);
+        }
+    }
+
+    private processPairedItem(q: QueueItem, percentage: number, index: number) {
+        const candidateRoutes = this.percentagesToSortedQuotes.get(percentage)!;
+        const routeWithQuote = this.findFirstRouteNotUsingUsedPools(q.currentRoutes, candidateRoutes);
+        if (!routeWithQuote) {
+            return;
+        }
+
+        const newRemainingPercentage = q.ramainingPercentage - percentage;
+        const newCurrentRoutes = [...q.currentRoutes, routeWithQuote];
+
+        if (newRemainingPercentage === 0) {
+            this.updateBestQuoteAndSwapIfBetter(newCurrentRoutes);
+        }
+        else {
+            this.queue.enqueue({
+                percentageIndex: index,
+                currentRoutes: newCurrentRoutes,
+                ramainingPercentage: newRemainingPercentage
+            });
+        }
+    }
+
+    private updateBestQuoteAndSwapIfBetter(currentRoutes: TRouteWithQuote[]) {
+        const quote = currentRoutes.reduce((acc, route) => acc + route.quote, BigInt(0));
+        if (quote > this.bestQuote) {
+            this.bestQuote = quote;
+            this.bestSwap = currentRoutes;
+        }
+    }
+
+    private initBestQuoteAndSwapForFullAmount() {
+        if (this.percentagesToSortedQuotes.has(100)) {
+            this.bestQuote = this.percentagesToSortedQuotes.get(100)![0].quote;
+            this.bestSwap = [this.percentagesToSortedQuotes.get(100)![0]];
+        }
+    }
+
+    private initQueueWithHighestQuotes() {
+        for (let i = this.percentages.length - 1; i >= 0; --i) {
+            this.insertHigestQuoteForPercentageIfExist(i);
+            this.insertSecondHigestQuoteForPercentageIfExist(i);
+        }
+    }
+
+    private insertHigestQuoteForPercentageIfExist(percentageIndex: number) {
+        const percentage = this.percentages[percentageIndex];
+        if (this.percentagesToSortedQuotes.has(percentage)) {
+            this.queue.enqueue({
+                percentageIndex: percentageIndex,
+                currentRoutes: [this.percentagesToSortedQuotes.get(percentage)![0]],
+                ramainingPercentage: 100 - percentage
+            });
+        }
+    }
+
+    private insertSecondHigestQuoteForPercentageIfExist(percentageIndex: number) {
+        const percentage = this.percentages[percentageIndex];
+        if (this.percentagesToSortedQuotes.get(percentage)![1]) {
+            this.queue.enqueue({
+                percentageIndex: percentageIndex,
+                currentRoutes: [this.percentagesToSortedQuotes.get(percentage)![1]],
+                ramainingPercentage: 100 - percentage
+            });
+        }
+    }
+
+    private getSortedQuotes(routeWithQuotes: TRouteWithQuote[]) {
+        const map = new Map<number, TRouteWithQuote[]>();
+        routeWithQuotes.forEach(routeWithQuote => {
+            const percentage = routeWithQuote.amount.percentage;
+            if (!map.has(percentage)) {
+                map.set(percentage, []);
+            }
+            map.get(percentage)?.push(routeWithQuote);
+        });
+        map.forEach((value, key) => {
+            value.sort((a, b) => {
+                return Number(b.quote - a.quote);
+            })
+        });
+
+        return map;
+    }
+
+    private findFirstRouteNotUsingUsedPools(
+        usedRoutes: TRouteWithQuote[],
+        candidateRoutes: TRouteWithQuote[]
+    ) {
+        const usedPoolsSet = new Set<string>();
+        usedRoutes.forEach(route => {
+            route.route.steps.forEach(step => usedPoolsSet.add(step.pool.poolId));
+        });
+
+        for (const candidateRoute of candidateRoutes) {
+            const candidatePools = candidateRoute.route.steps.map(step => step.pool.poolId);
+            if (candidatePools.some(pool => usedPoolsSet.has(pool))) {
+                continue;
+            }
+            return candidateRoute;
+        }
+        return null;
+    }
+
+}

package/routing/uni_like_algo/types.ts

@@ -0,0 +1,54 @@
+import {Pool} from "../../utils/types/types";
+
+export interface TRouteStep {
+    pool: Pool,
+    tokenOut: string;
+}
+
+export interface TRoute {
+    steps: TRouteStep[],
+    tokenIn: string,
+    tokenOut: string
+}
+
+export interface TRouteWithQuote {
+    route: TRoute,
+    quote: bigint,
+    amount: AmountPercentage
+}
+
+export interface AmountPercentage {
+    amountIn: bigint,
+    percentage: number
+}
+
+export class ComputeRoutesParams {
+    tokenIn: string;
+    tokenOut: string;
+    pools: Pool[];
+    maxHops: number;
+
+    constructor(tokenIn: string, tokenOut: string, pools: Pool[], maxHops: number) {
+        this.tokenIn = tokenIn;
+        this.tokenOut = tokenOut;
+        this.pools = pools;
+        this.maxHops = maxHops;
+    }
+}
+
+export interface QueueItem {
+    percentageIndex: number,
+    currentRoutes: TRouteWithQuote[],
+    ramainingPercentage: number
+}
+
+export interface TQuoteUniLike {
+    routes: TRouteWithQuote[],
+    quote: bigint
+}
+
+export type AlgoParams = {
+    maxHops: number,
+    distributionPercentage: number,
+    maxSplit: number
+}

package/swap/graph_communication.ts

@@ -0,0 +1,212 @@
+import Web3 from 'web3';
+import { Pool, PoolInfo, DEXGraphFunctionality } from '../utils/types/types'
+import { Dexes } from '../index';
+import { myLocalStorage } from './my_local_storage';
+import UniswapV2 from '../dexes/graph_queries/UniswapV2';
+import SushiSwapV2 from '../dexes/graph_queries/SushiSwapV2';
+import UniswapV3 from '../dexes/graph_queries/UniswapV3';
+import BalancerV2 from '../dexes/graph_queries/BalancerV2';
+import CamelotV2 from '../dexes/graph_queries/CamelotV2';
+
+let initializedMainnet = false
+let initializedArbitrum = false
+let initializedSei = false;
+let initializedPas = false;
+
+let initializedDexes: DEXGraphFunctionality[] = []
+let dexesPools: Map<DEXGraphFunctionality, PoolInfo[]> = new Map<DEXGraphFunctionality, PoolInfo[]>()
+
+async function initializeDexes(chainId: number, graphApiKey: string, dexes: Array<Dexes>): Promise<void> {
+  try {
+    // Clear Previous Dex Graph Mappings and Initialized DEX array
+    dexesPools.clear()
+    initializedDexes = []
+
+    for (const dex of dexes) {
+      let Dex;
+      switch (dex) {
+        case Dexes.BALANCER:
+          Dex = BalancerV2;
+          break;
+        case Dexes.CAMELOT:
+          if (chainId === 1)
+            continue;
+          Dex = CamelotV2;
+          break;
+        case Dexes.SUSHISWAP_V2:
+          Dex = SushiSwapV2;
+          break;
+        case Dexes.UNISWAP_V2:
+          if (chainId === 42161)
+            continue;
+          Dex = UniswapV2;
+          break;
+        case Dexes.UNISWAP_V3:
+          Dex = UniswapV3;
+          break;
+        default:
+          throw Error("Invalid Dex value")
+      }
+      const dexInstance: DEXGraphFunctionality = Dex.initialize(myLocalStorage)
+      dexInstance.setEndpoint(chainId, graphApiKey)
+      initializedDexes.push(dexInstance)
+      dexesPools.set(dexInstance, [])
+    }
+  } catch (err) {
+    console.error('Error reading directory dexes_graph:', err)
+  }
+}
+
+async function checkInitializedDexes(chainId: number, graphApiKey: string, dexes: Array<Dexes>) {
+  if (chainId === 1 && !initializedMainnet) {
+    await initializeDexes(chainId, graphApiKey, dexes)
+    initializedArbitrum = false
+    initializedSei = false
+    initializedPas = false
+    initializedMainnet = true
+  }
+  if (chainId === 42161 && !initializedArbitrum) {
+    await initializeDexes(chainId, graphApiKey, dexes)
+    initializedMainnet = false
+    initializedSei = false
+    initializedPas = false
+    initializedArbitrum = true
+  }
+
+  if (chainId === 1329 && !initializedSei)
+  {
+    await initializeDexes(chainId, graphApiKey, dexes)
+    initializedMainnet = false
+    initializedArbitrum = false
+    initializedPas = false
+    initializedSei = true
+  }
+
+  if (chainId === 420420417 && !initializedPas)
+  {
+    await initializeDexes(chainId, graphApiKey, dexes)
+    initializedMainnet = false
+    initializedArbitrum = false
+    initializedSei = false
+    initializedPas = true
+  }
+
+}
+
+/*   Returns dictionary of dexes and their poolIds for token1 and token2:
+ *   UniswapV3: [poolId1, poolId2, ...],
+ *   SushiSwapV2: [poolId1, poolId2, ...]
+ */
+async function getPoolIdsForTokenPairs(tokenA: string, tokenB: string, numPools: number = 3, chainId: number, graphApiKey: string, dexes: Array<Dexes>): Promise<void> {
+  await checkInitializedDexes(chainId, graphApiKey, dexes)
+
+  const allPoolsPromises = initializedDexes.map((dex) => dex.getPoolsWithTokenPair(tokenA, tokenB, numPools))
+  const allPoolsResults = await Promise.all(allPoolsPromises)
+
+  initializedDexes.forEach((dex, index) => {
+    const pools = allPoolsResults[index]
+    if (dexesPools.has(dex)) {
+      dexesPools.get(dex)?.push(...pools)
+    } else {
+      dexesPools.set(dex, pools)
+    }
+  })
+}
+
+/* Get pools from each dex in initializedDexes list that have token as one of the tokens in the pool
+ * @param token: token address to match (for now the chain is Arbitrum -> param for the future)
+ * @param numPools: number of pools to return from each dex
+ * @param amountIn: amount of token1 to swap (in wei) - currently unused
+ * @returns: list of poolIds
+ */
+async function getPoolIdsForToken(token: string, numPools: number = 5, chainId: number, graphApiKey: string, dexes: Array<Dexes>): Promise<void> {
+  await checkInitializedDexes(chainId, graphApiKey, dexes)
+
+  const allPoolsPromises = initializedDexes.map((dex) => dex.getPoolsWithToken(token, numPools))
+  const allPoolsResults = await Promise.all(allPoolsPromises)
+
+  initializedDexes.forEach((dex, index) => {
+    const pools = allPoolsResults[index]
+    if (dexesPools.has(dex)) {
+      dexesPools.get(dex)?.push(...pools)
+    } else {
+      dexesPools.set(dex, pools)
+    }
+  })
+}
+
+/* Get top pools from each dex in initializedDexes list - returns a list of poolIds
+ * @param numPools: number of pools to return from each dex
+ * @param amountIn: amount of token1 to swap (in wei) - currently unused
+ * @returns: list of poolIds
+ */
+async function getTopPools(numPools: number = 5, chainId: number, graphApiKey: string, dexes: Array<Dexes>): Promise<void> {
+  await checkInitializedDexes(chainId, graphApiKey, dexes)
+
+  const allPoolsPromises = initializedDexes.map((dex) => dex.getTopPools(numPools))
+  const allPoolsResults = await Promise.all(allPoolsPromises)
+
+  initializedDexes.forEach((dex, index) => {
+    const pools = allPoolsResults[index]
+    if (dexesPools.has(dex)) {
+      dexesPools.get(dex)?.push(...pools)
+    } else {
+      dexesPools.set(dex, pools)
+    }
+  })
+}
+
+/* We are fetching pools from multiple dexes, so we might get duplicate pools
+ * top numTopPools pools for tokenFrom and tokenTo are fetched from each DEX
+ * top numTopPools by TVL from each DEX
+ * top numTopPools that contain tokenFrom and tokenTo from each DEX (possible direct swap)
+ */
+async function fetchPoolsData(
+  tokenFrom: string,
+  tokenTo: string,
+  numFromToPools: number = 5,
+  numTopPools: number = 5,
+  chainId: number,
+  rpcProvider: Web3,
+  graphApiKey: string,
+  dexes: Array<Dexes>
+): Promise<Pool[]> {
+  let pools: Pool[] = []
+  dexesPools.forEach((poolInfos: PoolInfo[], dex: DEXGraphFunctionality) => {
+    dexesPools.set(dex, [])
+  })
+
+  await checkInitializedDexes(chainId, graphApiKey, dexes)
+
+  // call Graph API
+  const promises: Promise<void>[] = []
+  promises.push(getPoolIdsForToken(tokenFrom, numFromToPools, chainId, graphApiKey, dexes))
+  promises.push(getPoolIdsForToken(tokenTo, numFromToPools, chainId, graphApiKey, dexes))
+  promises.push(getTopPools(numTopPools, chainId, graphApiKey, dexes))
+  promises.push(getPoolIdsForTokenPairs(tokenFrom, tokenTo, numFromToPools, chainId, graphApiKey, dexes))
+  await Promise.all(promises)
+  filterDuplicatePools()
+
+  // call Solidity for additional pool data
+  const dexPoolsPromises: Promise<Pool[]>[] = []
+  for (let [dex, poolInfos] of dexesPools.entries()) {
+    dexPoolsPromises.push(dex.getAdditionalPoolDataFromSolidity(poolInfos, rpcProvider))
+  }
+  const allPoolsData = await Promise.all(dexPoolsPromises)
+  allPoolsData.forEach((poolsData: Pool[]) => {
+    pools.push(...poolsData)
+  })
+
+  return pools
+}
+
+function filterDuplicatePools(): void {
+  dexesPools.forEach((poolInfos: PoolInfo[], dex: DEXGraphFunctionality, self) => {
+    const filteredPoolInfos = poolInfos.filter((poolInfo: PoolInfo, index: number, allPoolInfos: PoolInfo[]) => {
+      return allPoolInfos.findIndex((pool2) => pool2.poolId === poolInfo.poolId) === index
+    })
+    self.set(dex, filteredPoolInfos)
+  })
+}
+
+export { fetchPoolsData }

package/swap/my_local_storage.ts

@@ -0,0 +1,27 @@
+import { Pool } from "../utils/types/types";
+
+interface ILocalStorage {
+    setItem(key: string, value: Pool): void;
+    getItem(key: string): Pool | null;
+    removeItem(key: string): void;
+}
+
+const values: { [key: string]: Pool } = {};
+
+class MockLocalStorage implements ILocalStorage {
+
+
+    setItem(key: string, value: Pool): void {
+        values[key] = value;
+    }
+
+    getItem(key: string): Pool | null {
+        return values[key] || null;
+    }
+
+    removeItem(key: string): void {
+        delete values[key];
+    }
+}
+
+export const myLocalStorage: ILocalStorage = new MockLocalStorage();

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "module": "CommonJS",
+    "declaration": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "resolveJsonModule": true,
+    "isolatedModules": false,
+    "noEmitOnError": true
+  },
+  "include": [
+    "."
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "./dexes/pools/uniswap/testUniswapOffchainQuoter.ts"
+  ]
+}

package/utils/addresses.ts

@@ -0,0 +1,64 @@
+// hardcode it like this for now
+export const addresses = {
+
+    // Acutally used.
+    name: "sei",
+    uniQuoterV2: "0x38F759cf0Af1D0dcAEd723a3967A3B658738eDe9",
+
+    wethToken: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    daiToken: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
+    usdtToken: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+    wbtcToken: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f",
+    usdcToken: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    uniToken: "0xFa7F8980b0f1E64A2062791cc3b0871572f1F7f0",
+    linkToken: "0xf97f4df75117a78c1A5a0DBb814Af92458539FB4",
+    usdceToken: "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
+    gmxToken: "0xfc5A1A6EB076a2C7aD06eD22C90d7E710E35ad0a",
+
+    sushiRouter: "0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506",
+    sushiFactory: "0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
+
+    // uniQuoter: "0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6",
+    // uniQuoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+    // uniRouter: "0xE592427A0AEce92De3Edee1F18E0157C05861564",
+
+    univ3_wbtc_eth_pool_0_05: "0x2f5e87C9312fa29aed5c179E456625D79015299c", // 0.05 fee
+    univ3_wbtc_eth_pool_0_3: "0x149e36E72726e0BceA5c59d40df2c43F60f5A22D", // 0.3 fee
+    sushi_wbtc_eth_pool: "0x515e252b2b5c22b4b2b6Df66c2eBeeA871AA4d69", // 0.3 fee always
+    gmx_usdc_pool_0_1: "0x0A36952Fb8C8dc6daeFB2fADb07C5212f560880e",
+    uni_weth_pool: "0xC24f7d8E51A64dc1238880BD00bb961D54cbeb29",
+    weth_link_pool: "0x468b88941e7Cc0B88c1869d68ab6b570bCEF62Ff",
+    dai_usdce_pool_0_0_1: "0xF0428617433652c9dc6D1093A42AdFbF30D29f74",
+
+    impersonate_weth: "0x0df5dfd95966753f01cb80e76dc20ea958238c46",
+    impersonate_dai: "0xd85e038593d7a098614721eae955ec2022b9b91b"
+
+    // name: "arbitrum",
+    //
+    // wethToken: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    // daiToken: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
+    // usdtToken: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+    // wbtcToken: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f",
+    // usdcToken: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    // uniToken: "0xFa7F8980b0f1E64A2062791cc3b0871572f1F7f0",
+    // linkToken: "0xf97f4df75117a78c1A5a0DBb814Af92458539FB4",
+    // usdceToken: "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
+    // gmxToken: "0xfc5A1A6EB076a2C7aD06eD22C90d7E710E35ad0a",
+    //
+    // sushiRouter: "0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506",
+    // sushiFactory: "0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
+    //
+    // uniQuoter: "0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6",
+    // uniQuoterV2: "0x61fFE014bA17989E743c5F6cB21bF9697530B21e",
+    // uniRouter: "0xE592427A0AEce92De3Edee1F18E0157C05861564",
+    // univ3_wbtc_eth_pool_0_05: "0x2f5e87C9312fa29aed5c179E456625D79015299c", // 0.05 fee
+    // univ3_wbtc_eth_pool_0_3: "0x149e36E72726e0BceA5c59d40df2c43F60f5A22D", // 0.3 fee
+    // sushi_wbtc_eth_pool: "0x515e252b2b5c22b4b2b6Df66c2eBeeA871AA4d69", // 0.3 fee always
+    // gmx_usdc_pool_0_1: "0x0A36952Fb8C8dc6daeFB2fADb07C5212f560880e",
+    // uni_weth_pool: "0xC24f7d8E51A64dc1238880BD00bb961D54cbeb29",
+    // weth_link_pool: "0x468b88941e7Cc0B88c1869d68ab6b570bCEF62Ff",
+    // dai_usdce_pool_0_0_1: "0xF0428617433652c9dc6D1093A42AdFbF30D29f74",
+    //
+    // impersonate_weth: "0x0df5dfd95966753f01cb80e76dc20ea958238c46",
+    // impersonate_dai: "0xd85e038593d7a098614721eae955ec2022b9b91b"
+}

package/utils/math/fixed-points.ts

@@ -0,0 +1,88 @@
+// Ported from Solidity:
+// https://github.com/balancer-labs/balancer-core-v2/blob/70843e6a61ad11208c1cfabf5cfe15be216ca8d3/pkg/solidity-utils/contracts/math/FixedPoint.sol
+
+import BigNumber from "bignumber.js"
+import * as logExp from "./log-exp"
+
+export const ZERO = new BigNumber(0)
+export const ONE = new BigNumber("1000000000000000000")             // 10^18
+
+export const MAX_POW_RELATIVE_ERROR = new BigNumber(10000)          // 10^(-14)
+
+// Minimum base for the power function when the exponent is 'free' (larger than ONE)
+export const MIN_POW_BASE_FREE_EXPONENT = new BigNumber("700000000000000000")  // 0.7e18
+
+export const add = (a: BigNumber, b: BigNumber): BigNumber => {
+  // Fixed Point addition is the same as regular checked addition
+  return a.plus(b)
+}
+
+export const sub = (a: BigNumber, b: BigNumber): BigNumber => {
+  // Fixed Point subtraction is the same as regular checked subtraction
+  if (b.gt(a))
+    throw new Error("SUB_OVERFLOW")
+  return a.minus(b)
+};
+
+export const mulDown = (a: BigNumber, b: BigNumber): BigNumber => {
+  return a.times(b).idiv(ONE)
+};
+
+export const mulUp = (a: BigNumber, b: BigNumber): BigNumber => {
+  const product = a.times(b)
+  if (product.isZero()) {
+    return product
+  } else {
+    // The traditional divUp formula is:
+    // divUp(x, y) := (x + y - 1) / y
+    // To avoid intermediate overflow in the addition, we distribute the division and get:
+    // divUp(x, y) := (x - 1) / y + 1
+    // Note that this requires x != 0, which we already tested for
+    return product.minus(new BigNumber(1)).idiv(ONE).plus(new BigNumber(1))
+  }
+}
+
+export const divDown = (a: BigNumber, b: BigNumber): BigNumber => {
+  if (b.isZero())
+    throw new Error("ZERO_DIVISION");
+  if (a.isZero())
+    return a
+  else
+    return a.times(ONE).idiv(b);
+}
+
+export const divUp = (a: BigNumber, b: BigNumber): BigNumber => {
+  if (b.isZero())
+    throw new Error("ZERO_DIVISION");
+  if (a.isZero())
+    return a;
+  else {
+    // The traditional divUp formula is:
+    // divUp(x, y) := (x + y - 1) / y
+    // To avoid intermediate overflow in the addition, we distribute the division and get:
+    // divUp(x, y) := (x - 1) / y + 1
+    // Note that this requires x != 0, which we already tested for.
+    return a.times(ONE).minus(new BigNumber(1)).idiv(b).plus(new BigNumber(1));
+  }
+};
+
+export const powDown = (x: BigNumber, y: BigNumber): BigNumber => {
+
+  const raw = logExp.pow(x, y);
+  const maxError = add(mulUp(raw, MAX_POW_RELATIVE_ERROR), new BigNumber(1));
+  if (raw.lt(maxError))
+    return new BigNumber(0)
+  else {
+    return sub(raw, maxError)
+  }
+}
+
+export const powUp = (x: BigNumber, y: BigNumber): BigNumber => {
+  const raw = logExp.pow(x, y)
+  const maxError = add(mulUp(raw, MAX_POW_RELATIVE_ERROR), new BigNumber(1))
+  return add(raw, maxError)
+}
+
+export const complement = (x: BigNumber): BigNumber => {
+  return x.lt(ONE) ? ONE.minus(x) : new BigNumber(0)
+}