monad-v3-sdk 2.1.0

package/dist/classes/nonfungiblePositionManager.d.ts

@@ -0,0 +1,145 @@
+import { BigintIsh } from '../types/BigIntish';
+import { Currency } from '../entities/Currency';
+import { CurrencyAmount } from '../entities/CurrencyAmount';
+import { Percent } from '../entities/Percent';
+import NativeCurrency from '../entities/NativeCurrency';
+import { Position } from '../entities/position';
+import { MethodParameters } from '../utils/calldata';
+import { Interface } from '@ethersproject/abi';
+import { PermitOptions, SelfPermit } from './selfPermit';
+import { Pool } from '../entities/pool';
+export declare const MaxUint128: string;
+export interface MintSpecificOptions {
+    /**
+     * The account that should receive the minted NFT.
+     */
+    recipient: string;
+    /**
+     * Creates pool if not initialized before mint.
+     */
+    createPool?: boolean;
+}
+export interface IncreaseSpecificOptions {
+    /**
+     * Indicates the ID of the position to increase liquidity for.
+     */
+    tokenId: BigintIsh;
+}
+/**
+ * Options for producing the calldata to add liquidity.
+ */
+export interface CommonAddLiquidityOptions {
+    /**
+     * How much the pool price is allowed to move.
+     */
+    slippageTolerance: Percent;
+    /**
+     * When the transaction expires, in epoch seconds.
+     */
+    deadline: BigintIsh;
+    /**
+     * Pool Deployer address. ZERO_ADDRESS if base pool
+     */
+    deployer?: string;
+    /**
+     * Whether to spend ether. If true, one of the pool tokens must be WETH, by default false
+     */
+    useNative?: NativeCurrency;
+    /**
+     * The optional permit parameters for spending token0
+     */
+    token0Permit?: PermitOptions;
+    /**
+     * The optional permit parameters for spending token1
+     */
+    token1Permit?: PermitOptions;
+}
+export declare type MintOptions = CommonAddLiquidityOptions & MintSpecificOptions;
+export declare type IncreaseOptions = CommonAddLiquidityOptions & IncreaseSpecificOptions;
+export declare type AddLiquidityOptions = MintOptions | IncreaseOptions;
+export interface CollectOptions {
+    /**
+     * Indicates the ID of the position to collect for.
+     */
+    tokenId: BigintIsh;
+    /**
+     * Expected value of tokensOwed0, including as-of-yet-unaccounted-for fees/liquidity value to be burned
+     */
+    expectedCurrencyOwed0: CurrencyAmount<Currency>;
+    /**
+     * Expected value of tokensOwed1, including as-of-yet-unaccounted-for fees/liquidity value to be burned
+     */
+    expectedCurrencyOwed1: CurrencyAmount<Currency>;
+    /**
+     * The account that should receive the tokens.
+     */
+    recipient: string;
+}
+export interface NFTPermitOptions {
+    v: 0 | 1 | 27 | 28;
+    r: string;
+    s: string;
+    deadline: BigintIsh;
+    spender: string;
+}
+/**
+ * Options for producing the calldata to exit a position.
+ */
+export interface RemoveLiquidityOptions {
+    /**
+     * The ID of the token to exit
+     */
+    tokenId: BigintIsh;
+    /**
+     * The percentage of position liquidity to exit.
+     */
+    liquidityPercentage: Percent;
+    /**
+     * How much the pool price is allowed to move.
+     */
+    slippageTolerance: Percent;
+    /**
+     * When the transaction expires, in epoch seconds.
+     */
+    deadline: BigintIsh;
+    /**
+     * Whether the NFT should be burned if the entire position is being exited, by default false.
+     */
+    burnToken?: boolean;
+    /**
+     * The optional permit of the token ID being exited, in case the exit transaction is being sent by an account that does not own the NFT
+     */
+    permit?: NFTPermitOptions;
+    /**
+     * Parameters to be passed on to collect
+     */
+    collectOptions: Omit<CollectOptions, 'tokenId'>;
+}
+export declare abstract class NonfungiblePositionManager extends SelfPermit {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static createCallParameters(pool: Pool, deployer?: string): MethodParameters;
+    static addCallParameters(position: Position, options: AddLiquidityOptions): {
+        calldata: string[];
+        value: string;
+    };
+    static collectCallParameters(options: CollectOptions): {
+        calldata: string[];
+        value: string;
+    };
+    /**
+     * Produces the calldata for completely or partially exiting a position
+     * @param position The position to exit
+     * @param options Additional information necessary for generating the calldata
+     * @returns The call parameters
+     */
+    static removeCallParameters(position: Position, options: RemoveLiquidityOptions): {
+        calldata: string[];
+        value: string;
+    };
+    private static encodeCreate;
+    private static encodeCollect;
+}

package/dist/classes/selfPermit.d.ts

@@ -0,0 +1,22 @@
+import { BigintIsh } from '../types/BigIntish';
+import { Token } from '../entities/Token';
+import { Interface } from '@ethersproject/abi';
+export interface StandardPermitArguments {
+    v: 0 | 1 | 27 | 28;
+    r: string;
+    s: string;
+    amount: BigintIsh;
+    deadline: BigintIsh;
+}
+export interface AllowedPermitArguments {
+    v: 0 | 1 | 27 | 28;
+    r: string;
+    s: string;
+    nonce: BigintIsh;
+    expiry: BigintIsh;
+}
+export declare type PermitOptions = StandardPermitArguments | AllowedPermitArguments;
+export declare abstract class SelfPermit {
+    static INTERFACE: Interface;
+    protected static encodePermit(token: Token, options: PermitOptions): string;
+}

package/dist/classes/swapRouter.d.ts

@@ -0,0 +1,67 @@
+import { Interface } from '@ethersproject/abi';
+import { BigintIsh } from '../types/BigIntish';
+import { Currency } from '../entities/Currency';
+import { Percent } from '../entities/Percent';
+import { TradeType } from '../enums/tradeType';
+import { Trade } from '../entities/trade';
+import { PermitOptions, SelfPermit } from './selfPermit';
+import { MethodParameters } from '../utils/calldata';
+export interface FeeOptions {
+    /**
+     * The percent of the output that will be taken as a fee.
+     */
+    fee: Percent;
+    /**
+     * The recipient of the fee.
+     */
+    recipient: string;
+}
+/**
+ * Options for producing the arguments to send calls to the router.
+ */
+export interface SwapOptions {
+    /**
+     * How much the execution price is allowed to move unfavorably from the trade execution price.
+     */
+    slippageTolerance: Percent;
+    /**
+     * The account that should receive the output.
+     */
+    recipient: string;
+    /**
+     * When the transaction expires, in epoch seconds.
+     */
+    deadline: BigintIsh;
+    /**
+     * Deflationary token.
+     */
+    feeOnTransfer: boolean;
+    /**
+     * The optional permit parameters for spending the input.
+     */
+    inputTokenPermit?: PermitOptions;
+    /**
+     * The optional price limit for the trade.
+     */
+    sqrtPriceLimitX96?: BigintIsh;
+    /**
+     * Optional information for taking a fee on output.
+     */
+    fee?: FeeOptions;
+}
+/**
+ * Represents the SwapRouter, and has static methods for helping execute trades.
+ */
+export declare abstract class SwapRouter extends SelfPermit {
+    static INTERFACE: Interface;
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    /**
+     * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
+     * @param trade to produce call parameters for
+     * @param options options for the call parameters
+     */
+    static swapCallParameters(trades: Trade<Currency, Currency, TradeType> | Trade<Currency, Currency, TradeType>[], options: SwapOptions): MethodParameters;
+}

package/dist/constants/addresses.d.ts

@@ -0,0 +1,6 @@
+export declare const POOL_DEPLOYER_ADDRESSES: {
+    [x: number]: string;
+};
+export declare const POOL_INIT_CODE_HASH: {
+    [x: number]: string;
+};

package/dist/constants/chainIds.d.ts

@@ -0,0 +1,3 @@
+export declare const ChainId: {
+    Monad: number;
+};

package/dist/constants/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const ADDRESS_ZERO = "0x0000000000000000000000000000000000000000";
+export declare const INITIAL_POOL_FEE = 100;
+export declare const DEFAULT_TICK_SPACING = 60;

package/dist/constants/index.d.ts

@@ -0,0 +1,4 @@
+export * from './chainIds';
+export * from './constants';
+export * from './internalConstants';
+export * from './addresses';

package/dist/constants/internalConstants.d.ts

@@ -0,0 +1,7 @@
+import JSBI from 'jsbi';
+export declare const NEGATIVE_ONE: JSBI;
+export declare const ZERO: JSBI;
+export declare const ONE: JSBI;
+export declare const Q96: JSBI;
+export declare const Q192: JSBI;
+export declare const MaxUint256: JSBI;

package/dist/entities/AbstractCurrency.d.ts

@@ -0,0 +1,48 @@
+import { Currency } from './Currency';
+import { Token } from './Token';
+/**
+ * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
+ */
+export declare abstract class AbstractCurrency {
+    /**
+     * Returns whether the currency is native to the chain and must be wrapped (e.g. Ether)
+     */
+    abstract readonly isNative: boolean;
+    /**
+     * Returns whether the currency is a token that is usable without wrapping
+     */
+    abstract readonly isToken: boolean;
+    /**
+     * The chain ID on which this currency resides
+     */
+    readonly chainId: number;
+    /**
+     * The decimals used in representing currency amounts
+     */
+    readonly decimals: number;
+    /**
+     * The symbol of the currency, i.e. a short textual non-unique identifier
+     */
+    readonly symbol?: string;
+    /**
+     * The name of the currency, i.e. a descriptive textual non-unique identifier
+     */
+    readonly name?: string;
+    /**
+     * Constructs an instance of the base class `BaseCurrency`.
+     * @param chainId the chain ID on which this currency resides
+     * @param decimals decimals of the currency
+     * @param symbol symbol of the currency
+     * @param name of the currency
+     */
+    protected constructor(chainId: number, decimals: number, symbol?: string, name?: string);
+    /**
+     * Returns whether this currency is functionally equivalent to the other currency
+     * @param other the other currency
+     */
+    abstract equals(other: Currency): boolean;
+    /**
+     * Return the wrapped version of this currency.
+     */
+    abstract get wrapped(): Token;
+}

package/dist/entities/Currency.d.ts

@@ -0,0 +1,3 @@
+import NativeCurrency from './NativeCurrency';
+import { Token } from './Token';
+export declare type Currency = NativeCurrency | Token;

package/dist/entities/CurrencyAmount.d.ts

@@ -0,0 +1,32 @@
+import { BigintIsh } from "../types/BigIntish";
+import { Currency } from './Currency';
+import { Fraction } from './Fraction';
+import JSBI from 'jsbi';
+import { Rounding } from '../enums/rounding';
+import { Token } from './Token';
+export declare class CurrencyAmount<T extends Currency> extends Fraction {
+    readonly currency: T;
+    readonly decimalScale: JSBI;
+    /**
+     * Returns a new currency amount instance from the unitless amount of token, i.e. the raw amount
+     * @param currency the currency in the amount
+     * @param rawAmount the raw token or ether amount
+     */
+    static fromRawAmount<T extends Currency>(currency: T, rawAmount: BigintIsh): CurrencyAmount<T>;
+    /**
+     * Construct a currency amount with a denominator that is not equal to 1
+     * @param currency the currency
+     * @param numerator the numerator of the fractional token amount
+     * @param denominator the denominator of the fractional token amount
+     */
+    static fromFractionalAmount<T extends Currency>(currency: T, numerator: BigintIsh, denominator: BigintIsh): CurrencyAmount<T>;
+    protected constructor(currency: T, numerator: BigintIsh, denominator?: BigintIsh);
+    add(other: CurrencyAmount<T>): CurrencyAmount<T>;
+    subtract(other: CurrencyAmount<T>): CurrencyAmount<T>;
+    multiply(other: Fraction | BigintIsh): CurrencyAmount<T>;
+    divide(other: Fraction | BigintIsh): CurrencyAmount<T>;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+    toExact(format?: object): string;
+    get wrapped(): CurrencyAmount<Token>;
+}

package/dist/entities/ExtendedNative.d.ts

@@ -0,0 +1,7 @@
+import { Native } from './Native';
+import { Token } from './Token';
+export declare class ExtendedNative extends Native {
+    private static _cachedNative;
+    get wrapped(): Token;
+    static onChain(chainId: number, symbol: string, name: string): ExtendedNative;
+}

package/dist/entities/Fraction.d.ts

@@ -0,0 +1,25 @@
+import { BigintIsh } from '../types/BigIntish';
+import JSBI from 'jsbi';
+import { Rounding } from '../enums/rounding';
+export declare class Fraction {
+    readonly numerator: JSBI;
+    readonly denominator: JSBI;
+    constructor(numerator: BigintIsh, denominator?: BigintIsh);
+    private static tryParseFraction;
+    get quotient(): JSBI;
+    get remainder(): Fraction;
+    invert(): Fraction;
+    add(other: Fraction | BigintIsh): Fraction;
+    subtract(other: Fraction | BigintIsh): Fraction;
+    lessThan(other: Fraction | BigintIsh): boolean;
+    equalTo(other: Fraction | BigintIsh): boolean;
+    greaterThan(other: Fraction | BigintIsh): boolean;
+    multiply(other: Fraction | BigintIsh): Fraction;
+    divide(other: Fraction | BigintIsh): Fraction;
+    toSignificant(significantDigits: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces: number, format?: object, rounding?: Rounding): string;
+    /**
+     * Helper method for converting any super class back to a fraction
+     */
+    get asFraction(): Fraction;
+}

package/dist/entities/Native.d.ts

@@ -0,0 +1,13 @@
+import { Token } from "./Token";
+import { Currency } from "./Currency";
+import NativeCurrency from './NativeCurrency';
+/**
+ * Native is the main usage of a 'native' currency
+ */
+export declare class Native extends NativeCurrency {
+    protected constructor(chainId: number, symbol: string, name: string);
+    get wrapped(): Token;
+    private static _naitveCache;
+    static onChain(chainId: number, symbol: string, name: string): Native;
+    equals(other: Currency): boolean;
+}

package/dist/entities/NativeCurrency.d.ts

@@ -0,0 +1,8 @@
+import { AbstractCurrency } from './AbstractCurrency';
+/**
+ * Represents the native currency of the chain on which it resides, e.g.
+ */
+export default abstract class NativeCurrency extends AbstractCurrency {
+    readonly isNative: true;
+    readonly isToken: false;
+}

package/dist/entities/Percent.d.ts

@@ -0,0 +1,16 @@
+import { BigintIsh } from '../types/BigIntish';
+import { Fraction } from './Fraction';
+import { Rounding } from '../enums/rounding';
+export declare class Percent extends Fraction {
+    /**
+     * This boolean prevents a fraction from being interpreted as a Percent
+     */
+    readonly isPercent: true;
+    constructor(numerator: BigintIsh, denominator?: BigintIsh);
+    add(other: Fraction | BigintIsh): Percent;
+    subtract(other: Fraction | BigintIsh): Percent;
+    multiply(other: Fraction | BigintIsh): Percent;
+    divide(other: Fraction | BigintIsh): Percent;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}

package/dist/entities/Price.d.ts

@@ -0,0 +1,39 @@
+import { BigintIsh } from '../types/BigIntish';
+import { Currency } from './Currency';
+import { CurrencyAmount } from './CurrencyAmount';
+import { Fraction } from './Fraction';
+import { Rounding } from '../enums/rounding';
+export declare class Price<TBase extends Currency, TQuote extends Currency> extends Fraction {
+    readonly baseCurrency: TBase;
+    readonly quoteCurrency: TQuote;
+    readonly scalar: Fraction;
+    /**
+     * Construct a price, either with the base and quote currency amount, or the
+     * @param args
+     */
+    constructor(...args: [TBase, TQuote, BigintIsh, BigintIsh] | [{
+        baseAmount: CurrencyAmount<TBase>;
+        quoteAmount: CurrencyAmount<TQuote>;
+    }]);
+    /**
+     * Flip the price, switching the base and quote currency
+     */
+    invert(): Price<TQuote, TBase>;
+    /**
+     * Multiply the price by another price, returning a new price. The other price must have the same base currency as this price's quote currency
+     * @param other the other price
+     */
+    multiply<TOtherQuote extends Currency>(other: Price<TQuote, TOtherQuote>): Price<TBase, TOtherQuote>;
+    /**
+     * Return the amount of quote currency corresponding to a given amount of the base currency
+     * @param currencyAmount the amount of base currency to quote against the price
+     */
+    quote(currencyAmount: CurrencyAmount<TBase>): CurrencyAmount<TQuote>;
+    /**
+     * Get the value scaled by decimals for formatting
+     * @private
+     */
+    private get adjustedForDecimals();
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}

package/dist/entities/Token.d.ts

@@ -0,0 +1,32 @@
+import { AbstractCurrency } from './AbstractCurrency';
+import { Currency } from './Currency';
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+export declare class Token extends AbstractCurrency {
+    readonly chainId: number;
+    readonly address: string;
+    readonly isNative: false;
+    readonly isToken: true;
+    constructor(chainId: number, address: string, decimals: number, symbol?: string, name?: string);
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+     * @param other other token to compare
+     */
+    equals(other: Currency): boolean;
+    /**
+     * Returns true if the address of this token sorts before the address of the other token
+     * @param other other token to compare
+     * @throws if the tokens have the same address
+     * @throws if the tokens are on different chains
+     */
+    sortsBefore(other: Token): boolean;
+    /**
+     * Return this token, which does not need to be wrapped
+     */
+    get wrapped(): Token;
+}
+/**
+ * Compares two currencies for equality
+ */
+export declare function currencyEquals(currencyA: Currency, currencyB: Currency): boolean;

package/dist/entities/index.d.ts

@@ -0,0 +1,17 @@
+export * from './pool';
+export * from './position';
+export * from './route';
+export * from './tick';
+export * from './trade';
+export * from './tickDataProvider';
+export * from './tickListDataProvider';
+export * from './Price';
+export * from './Token';
+export * from './Percent';
+export * from './CurrencyAmount';
+export * from './Currency';
+export * from './NativeCurrency';
+export * from './Native';
+export * from './Fraction';
+export * from './ExtendedNative';
+export * from './wnative';

package/dist/entities/pool.d.ts

@@ -0,0 +1,86 @@
+import { CurrencyAmount } from './CurrencyAmount';
+import { Price } from './Price';
+import { Token } from './Token';
+import { BigintIsh } from '../types/BigIntish';
+import JSBI from 'jsbi';
+import { Tick, TickConstructorArgs } from './tick';
+import { TickDataProvider } from './tickDataProvider';
+/**
+ * Represents a V3 pool
+ */
+export declare class Pool {
+    readonly token0: Token;
+    readonly token1: Token;
+    readonly fee: number;
+    readonly sqrtRatioX96: JSBI;
+    readonly deployer: string;
+    readonly liquidity: JSBI;
+    readonly tickCurrent: number;
+    readonly tickDataProvider: TickDataProvider;
+    readonly _tickSpacing: number;
+    /**
+     * Construct a pool
+     * @param tokenA One of the tokens in the pool
+     * @param tokenB The other token in the pool
+     * @param fee The fee in hundredths of a bips of the input amount of every swap that is collected by the pool
+     * @param sqrtRatioX96 The sqrt of the current ratio of amounts of token1 to token0
+     * @param liquidity The current value of in range liquidity
+     * @param tickCurrent The current tick of the pool
+     * @param ticks The current state of the pool ticks or a data provider that can return tick data
+     * @param _tickSpacing The spacing between ticks
+     */
+    constructor(tokenA: Token, tokenB: Token, fee: number, sqrtRatioX96: BigintIsh, deployer: string, liquidity: BigintIsh, tickCurrent: number, _tickSpacing: number, ticks?: TickDataProvider | (Tick | TickConstructorArgs)[]);
+    private _token0Price?;
+    /**
+     * Returns the current mid price of the pool in terms of token0, i.e. the ratio of token1 over token0
+     */
+    get token0Price(): Price<Token, Token>;
+    private _token1Price?;
+    /**
+     * Returns the current mid price of the pool in terms of token1, i.e. the ratio of token0 over token1
+     */
+    get token1Price(): Price<Token, Token>;
+    /**
+     * Returns the chain ID of the tokens in the pool.
+     */
+    get chainId(): number;
+    get tickSpacing(): number;
+    static getAddress(tokenA: Token, tokenB: Token, initCodeHashManualOverride?: string): string;
+    /**
+     * Returns true if the token is either token0 or token1
+     * @param token The token to check
+     * @returns True if token is either token0 or token
+     */
+    involvesToken(token: Token): boolean;
+    /**
+     * Return the price of the given token in terms of the other token in the pool.
+     * @param token The token to return price of
+     * @returns The price of the given token, in terms of the other.
+     */
+    priceOf(token: Token): Price<Token, Token>;
+    /**
+     * Given an input amount of a token, return the computed output amount, and a pool with state updated after the trade
+     * @param inputAmount The input amount for which to quote the output amount
+     * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit
+     * @returns The output amount and the pool with updated state
+     */
+    getOutputAmount(inputAmount: CurrencyAmount<Token>, sqrtPriceLimitX96?: JSBI): Promise<[CurrencyAmount<Token>, Pool]>;
+    /**
+     * Given a desired output amount of a token, return the computed input amount and a pool with state updated after the trade
+     * @param outputAmount the output amount for which to quote the input amount
+     * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+     * @returns The input amount and the pool with updated state
+     */
+    getInputAmount(outputAmount: CurrencyAmount<Token>, sqrtPriceLimitX96?: JSBI): Promise<[CurrencyAmount<Token>, Pool]>;
+    /**
+     * Executes a swap
+     * @param zeroForOne Whether the amount in is token0 or token1
+     * @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
+     * @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+     * @returns amountCalculated
+     * @returns sqrtRatioX96
+     * @returns liquidity
+     * @returns tickCurrent
+     */
+    private swap;
+}