monad-v3-sdk 2.1.0

package/dist/types/BigIntish.d.ts

@@ -0,0 +1,2 @@
+import JSBI from 'jsbi';
+export declare type BigintIsh = JSBI | number | string;

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './BigIntish';

package/dist/utils/calldata.d.ts

@@ -0,0 +1,20 @@
+import { BigintIsh } from '../types/BigIntish';
+/**
+ * Generated method parameters for executing a call.
+ */
+export interface MethodParameters {
+    /**
+     * The hex encoded calldata to perform the given operation
+     */
+    calldata: string | string[];
+    /**
+     * The amount of ether (wei) to send in hex.
+     */
+    value: string;
+}
+/**
+ * Converts a big int to a hex string
+ * @param bigintIsh
+ * @returns The hex encoded calldata
+ */
+export declare function toHex(bigintIsh: BigintIsh): string;

package/dist/utils/chunkArray.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_GAS_REQUIRED = 200000;
+export default function chunkArray<T>(items: T[], gasLimit?: number): T[][];

package/dist/utils/computePoolAddress.d.ts

@@ -0,0 +1,28 @@
+import { Token } from '../entities';
+/**
+ * Computes a pool address
+ * @param poolDeployer The Algebra Pool Deployer address
+ * @param tokenA The first token of the pair, irrespective of sort order
+ * @param tokenB The second token of the pair, irrespective of sort order
+ * @param initCodeHashManualOverride The initial code hash override
+ * @returns The pool address
+ */
+export declare function computePoolAddress({ tokenA, tokenB, initCodeHashManualOverride, poolDeployer }: {
+    tokenA: Token;
+    tokenB: Token;
+    initCodeHashManualOverride?: string;
+    poolDeployer?: string;
+}): string;
+export declare function computeCustomPoolAddress({ tokenA, tokenB, customPoolDeployer, initCodeHashManualOverride, mainPoolDeployer }: {
+    tokenA: Token;
+    tokenB: Token;
+    customPoolDeployer: string;
+    initCodeHashManualOverride?: string;
+    mainPoolDeployer?: string;
+}): string;
+export declare function computePoolAddressZkSync({ poolDeployer, tokenA, tokenB, initCodeHashManualOverride, }: {
+    tokenA: Token;
+    tokenB: Token;
+    initCodeHashManualOverride?: string;
+    poolDeployer?: string;
+}): string;

package/dist/utils/computeSurroundingTicks.d.ts

@@ -0,0 +1,2 @@
+import { Token } from "../entities";
+export default function computeSurroundingTicks(token0: Token, token1: Token, activeTickProcessed: any, sortedTickData: any, pivot: number, ascending: boolean): any[];

package/dist/utils/encodeRouteToPath.d.ts

@@ -0,0 +1,8 @@
+import { Route } from '../entities/route';
+import { Currency } from "../entities";
+/**
+ * Converts a route to a hex encoded path
+ * @param route the v3 path to convert to an encoded path
+ * @param exactOutput whether the route should be encoded in reverse, for making exact output swaps
+ */
+export declare function encodeRouteToPath(route: Route<Currency, Currency>, exactOutput: boolean): string;

package/dist/utils/encodeSqrtRatioX96.d.ts

@@ -0,0 +1,9 @@
+import JSBI from 'jsbi';
+import { BigintIsh } from '../types/BigIntish';
+/**
+ * Returns the sqrt ratio as a Q64.96 corresponding to a given ratio of amount1 and amount0
+ * @param amount1 The numerator amount i.e., the amount of token1
+ * @param amount0 The denominator amount i.e., the amount of token0
+ * @returns The sqrt ratio
+ */
+export declare function encodeSqrtRatioX96(amount1: BigintIsh, amount0: BigintIsh): JSBI;

package/dist/utils/format.d.ts

@@ -0,0 +1,14 @@
+import { Currency, CurrencyAmount, Price } from '../entities';
+import { BigNumberish } from '@ethersproject/bignumber';
+export declare const capitalize: (s: any) => string;
+export declare const formatK: (value: string) => any;
+export declare function shortenAddress(address: string, chars?: number): string;
+export declare function shortenString(string: string, length: number): string;
+export declare function formatPercent(percentString: any): string;
+export declare const formatNumber: (number: any, usd?: boolean, scale?: boolean) => string;
+export declare function formatNumberScale(number: any, usd?: boolean, decimals?: number): string;
+export declare function escapeRegExp(string: string): string;
+export declare const formatBalance: (value: BigNumberish, decimals?: number, maxFraction?: number) => string;
+export declare function formatCurrencyAmount(amount: CurrencyAmount<Currency> | undefined, sigFigs: number): string;
+export declare function formatPrice(price: Price<Currency, Currency> | undefined, sigFigs: number): string;
+export declare function formatDateAgo(date: Date): string;

package/dist/utils/formatTickPrice.d.ts

@@ -0,0 +1,5 @@
+import { Price, Token } from '../entities';
+import { Bound } from "../enums/bound";
+export declare function formatTickPrice(price: Price<Token, Token> | undefined, atLimit: {
+    [bound in Bound]?: boolean | undefined;
+}, direction: Bound, placeholder?: string): string;

package/dist/utils/fullMath.d.ts

@@ -0,0 +1,7 @@
+import JSBI from 'jsbi';
+export declare abstract class FullMath {
+    /**
+     * Cannot be constructed.
+     */
+    static mulDivRoundingUp(a: JSBI, b: JSBI, denominator: JSBI): JSBI;
+}

package/dist/utils/getRatio.d.ts

@@ -0,0 +1,2 @@
+import { Currency, Price } from '../entities';
+export declare function getRatio(lower: Price<Currency, Currency>, current: Price<Currency, Currency>, upper: Price<Currency, Currency>): number | undefined;

package/dist/utils/getTickToPrice.d.ts

@@ -0,0 +1,2 @@
+import { Price, Token } from '../entities';
+export declare function getTickToPrice(baseToken?: Token, quoteToken?: Token, tick?: number): Price<Token, Token> | undefined;

package/dist/utils/index.d.ts

@@ -0,0 +1,15 @@
+export * from './calldata';
+export * from './computePoolAddress';
+export * from './encodeRouteToPath';
+export * from './encodeSqrtRatioX96';
+export * from './fullMath';
+export * from './isSorted';
+export * from './liquidityMath';
+export * from './maxLiquidityForAmounts';
+export * from './mostSignificantBit';
+export * from './nearestUsableTick';
+export * from './priceTickConversions';
+export * from './sqrtPriceMath';
+export * from './tickMath';
+export * from './tickList';
+export * from './getTickToPrice';

package/dist/utils/isSorted.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Determines if a tick list is sorted
+ * @param list The tick list
+ * @param comparator The comparator
+ * @returns true if sorted
+ */
+export declare function isSorted<T>(list: Array<T>, comparator: (a: T, b: T) => number): boolean;

package/dist/utils/liquidityMath.d.ts

@@ -0,0 +1,7 @@
+import JSBI from 'jsbi';
+export declare abstract class LiquidityMath {
+    /**
+     * Cannot be constructed.
+     */
+    static addDelta(x: JSBI, y: JSBI): JSBI;
+}

package/dist/utils/maxLiquidityForAmounts.d.ts

@@ -0,0 +1,14 @@
+import { BigintIsh } from '../types/BigIntish';
+import JSBI from 'jsbi';
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+ * and the prices at the tick boundaries.
+ * @param sqrtRatioCurrentX96 the current price
+ * @param sqrtRatioAX96 price at lower boundary
+ * @param sqrtRatioBX96 price at upper boundary
+ * @param amount0 token0 amount
+ * @param amount1 token1 amount
+ * @param useFullPrecision if false, liquidity will be maximized according to what the router can calculate,
+ * not what core can theoretically support
+ */
+export declare function maxLiquidityForAmounts(sqrtRatioCurrentX96: JSBI, sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, amount0: BigintIsh, amount1: BigintIsh, useFullPrecision: boolean): JSBI;

package/dist/utils/mostSignificantBit.d.ts

@@ -0,0 +1,2 @@
+import JSBI from 'jsbi';
+export declare function mostSignificantBit(x: JSBI): number;

package/dist/utils/nearestUsableTick.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the closest tick that is nearest a given tick and usable for the given tick spacing
+ * @param tick the target tick
+ * @param tickSpacing the spacing of the pool
+ */
+export declare function nearestUsableTick(tick: number, tickSpacing: number): number;

package/dist/utils/priceTickConversions.d.ts

@@ -0,0 +1,16 @@
+import { Price } from '../entities/Price';
+import { Token } from '../entities/Token';
+/**
+ * Returns a price object corresponding to the input tick and the base/quote token
+ * Inputs must be tokens because the address order is used to interpret the price represented by the tick
+ * @param baseToken the base token of the price
+ * @param quoteToken the quote token of the price
+ * @param tick the tick for which to return the price
+ */
+export declare function tickToPrice(baseToken: Token, quoteToken: Token, tick: number): Price<Token, Token>;
+/**
+ * Returns the first tick for which the given price is greater than or equal to the tick price
+ * @param price for which to return the closest tick that represents a price less than or equal to the input price,
+ * i.e. the price of the returned tick is less than or equal to the input price
+ */
+export declare function priceToClosestTick(price: Price<Token, Token>): number;

package/dist/utils/sortedInsert.d.ts

@@ -0,0 +1 @@
+export declare function sortedInsert<T>(items: T[], add: T, maxSize: number, comparator: (a: T, b: T) => number): T | null;

package/dist/utils/sqrt.d.ts

@@ -0,0 +1,7 @@
+import JSBI from 'jsbi';
+export declare const MAX_SAFE_INTEGER: JSBI;
+/**
+ * Computes floor(sqrt(value))
+ * @param value the value for which to compute the square root, rounded down
+ */
+export declare function sqrt(value: JSBI): JSBI;

package/dist/utils/sqrtPriceMath.d.ts

@@ -0,0 +1,12 @@
+import JSBI from 'jsbi';
+export declare abstract class SqrtPriceMath {
+    /**
+     * Cannot be constructed.
+     */
+    static getAmount0Delta(sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, liquidity: JSBI, roundUp: boolean): JSBI;
+    static getAmount1Delta(sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, liquidity: JSBI, roundUp: boolean): JSBI;
+    static getNextSqrtPriceFromInput(sqrtPX96: JSBI, liquidity: JSBI, amountIn: JSBI, zeroForOne: boolean): JSBI;
+    static getNextSqrtPriceFromOutput(sqrtPX96: JSBI, liquidity: JSBI, amountOut: JSBI, zeroForOne: boolean): JSBI;
+    private static getNextSqrtPriceFromAmount0RoundingUp;
+    private static getNextSqrtPriceFromAmount1RoundingDown;
+}

package/dist/utils/stringToColour.d.ts

@@ -0,0 +1,5 @@
+export declare const stringToColour: (str: string) => {
+    background: string;
+    text: string;
+    border: string;
+};

package/dist/utils/swapMath.d.ts

@@ -0,0 +1,7 @@
+import JSBI from 'jsbi';
+export declare abstract class SwapMath {
+    /**
+     * Cannot be constructed.
+     */
+    static computeSwapStep(sqrtRatioCurrentX96: JSBI, sqrtRatioTargetX96: JSBI, liquidity: JSBI, amountRemaining: JSBI, feePips: number): [JSBI, JSBI, JSBI, JSBI];
+}

package/dist/utils/tickList.d.ts

@@ -0,0 +1,22 @@
+import { Tick } from '../entities/tick';
+/**
+ * Utility methods for interacting with sorted lists of ticks
+ */
+export declare abstract class TickList {
+    /**
+     * Cannot be constructed
+     */
+    static validateList(ticks: Tick[], tickSpacing: number): void;
+    static isBelowSmallest(ticks: readonly Tick[], tick: number): boolean;
+    static isAtOrAboveLargest(ticks: readonly Tick[], tick: number): boolean;
+    static getTick(ticks: readonly Tick[], index: number): Tick;
+    static nextInitializedTick(ticks: readonly Tick[], tick: number, lte: boolean): Tick;
+    static nextInitializedTickWithinOneWord(ticks: readonly Tick[], tick: number, lte: boolean, tickSpacing: number): [number, boolean];
+    /**
+     * Finds the largest tick in the list of ticks that is less than or equal to tick
+     * @param ticks list of ticks
+     * @param tick tick to find the largest tick that is less than or equal to tick
+     * @private
+     */
+    private static binarySearch;
+}

package/dist/utils/tickMath.d.ts

@@ -0,0 +1,33 @@
+import JSBI from 'jsbi';
+export declare abstract class TickMath {
+    /**
+     * Cannot be constructed.
+     */
+    /**
+     * The minimum tick that can be used on any pool.
+     */
+    static MIN_TICK: number;
+    /**
+     * The maximum tick that can be used on any pool.
+     */
+    static MAX_TICK: number;
+    /**
+     * The sqrt ratio corresponding to the minimum tick that could be used on any pool.
+     */
+    static MIN_SQRT_RATIO: JSBI;
+    /**
+     * The sqrt ratio corresponding to the maximum tick that could be used on any pool.
+     */
+    static MAX_SQRT_RATIO: JSBI;
+    /**
+     * Returns the sqrt ratio as a Q64.96 for the given tick. The sqrt ratio is computed as sqrt(1.0001)^tick
+     * @param tick the tick for which to compute the sqrt ratio
+     */
+    static getSqrtRatioAtTick(tick: number): JSBI;
+    /**
+     * Returns the tick corresponding to a given sqrt ratio, s.t. #getSqrtRatioAtTick(tick) <= sqrtRatioX96
+     * and #getSqrtRatioAtTick(tick + 1) > sqrtRatioX96
+     * @param sqrtRatioX96 the sqrt ratio as a Q64.96 for which to compute the tick
+     */
+    static getTickAtSqrtRatio(sqrtRatioX96: JSBI): number;
+}

package/dist/utils/validateAndParseAddress.d.ts

@@ -0,0 +1 @@
+export declare function validateAndParseAddress(address: string): string;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "license": "MIT",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "scripts": {
+    "start": "tsdx watch",
+    "build": "tsdx build",
+    "lint": "tsdx lint",
+    "prepare": "tsdx build",
+    "size": "size-limit",
+    "analyze": "size-limit --why"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "tsdx lint"
+    }
+  },
+  "prettier": {
+    "printWidth": 80,
+    "semi": true,
+    "singleQuote": true,
+    "trailingComma": "es5"
+  },
+  "name": "monad-v3-sdk",
+  "author": "cryptoalgebra",
+  "module": "dist/sdk.esm.js",
+  "dependencies": {
+    "@ethersproject/abi": "^5.7.0",
+    "@ethersproject/address": "^5.7.0",
+    "@ethersproject/bignumber": "^5.8.0",
+    "@ethersproject/bytes": "^5.8.0",
+    "@ethersproject/keccak256": "^5.8.0",
+    "@ethersproject/solidity": "^5.7.0",
+    "@ethersproject/strings": "^5.8.0",
+    "@ethersproject/units": "^5.7.0",
+    "big.js": "^6.2.1",
+    "decimal.js-light": "^2.5.1",
+    "jsbi": "^3.2.5",
+    "numeral": "^2.0.6",
+    "tiny-invariant": "^1.3.1",
+    "tiny-warning": "^1.0.3",
+    "toformat": "^2.0.0"
+  },
+  "devDependencies": {
+    "@size-limit/preset-small-lib": "^9.0.0",
+    "husky": "^8.0.3",
+    "size-limit": "^9.0.0",
+    "tsdx": "^0.14.1",
+    "tslib": "^2.6.2",
+    "typescript": "^5.2.2"
+  },
+  "version": "2.1.0"
+}