@raydium-io/raydium-sdk-v2/lib/raydium/clmm/libraries/pool.d.ts

An SDK for building applications on top of Raydium.

import { Connection, PublicKey, EpochInfo } from '@solana/web3.js';
import BN__default from 'bn.js';
import { PoolInfoLayout, DynamicFeeInfoLayout, RewardInfoLayout, TickArrayBitmapExtensionLayout, TickArrayLayout } from '../layout.js';
import { q as ApiV3PoolInfoConcentratedItem, j as ApiV3Token } from '../../../api-23ae421b.js';
import { ClmmPoolRewardInfo, ComputeClmmPoolInfo, ReturnTypeFetchExBitmaps, ReturnTypeFetchMultiplePoolTickArrays, ReturnTypeComputeAmountOut, ReturnTypeComputeAmountOutFormat, ReturnTypeComputeAmountOutBaseOut, ReturnTypeGetLiquidityAmountOut } from '../type.js';
import Decimal from 'decimal.js';
import '../../../marshmallow/index.js';
import '../../../marshmallow/buffer-layout.js';
import 'axios';
import '../../../solana/type.js';
import '@solana/spl-token';
import '../../../api/url.js';
import '../../../common/owner.js';
import '../../../common/txTool/lookupTable.js';
import '../../../common/txTool/txType.js';
import '../../../module/token.js';
import '../../../common/pubKey.js';
import '../../../common/logger.js';
import '../../../module/currency.js';
import './constants.js';

declare class PoolFee {
    static tickSpacingIndexFromTick(tickIndex: number, tickSpacing: number): number;
}
declare class DynamicFeeInfo {
    static getDynamicFeeInfo({ poolInfo }: {
        poolInfo: ReturnType<typeof PoolInfoLayout.decode>;
    }): {
        filterPeriod: number;
        decayPeriod: number;
        reductionFactor: number;
        dynamicFeeControl: number;
        maxVolatilityAccumulator: number;
        tickSpacingIndexReference: number;
        volatilityReference: number;
        volatilityAccumulator: number;
        lastUpdateTimestamp: BN__default;
    } | undefined;
    static updateReference({ dynamicFeeInfo, tickSpacingIndex, currentTimestamp, }: {
        dynamicFeeInfo: ReturnType<typeof DynamicFeeInfoLayout.decode>;
        tickSpacingIndex: number;
        currentTimestamp: number;
    }): void;
    static updateVolatilityAccumulator({ state, tickSpacingIndex, }: {
        state: ReturnType<typeof DynamicFeeInfoLayout.decode>;
        tickSpacingIndex: number;
    }): void;
}
declare class PoolUtil {
    static isFeeOnInput(feeOn: number, zeroForOne: boolean): boolean;
    static isFeeOnTokenA(poolInfo: ReturnType<typeof PoolInfoLayout.decode>, zeroForOne: boolean): boolean;
    static isOverflowDefaultTickarrayBitmap({ tickSpacing, tickIndexs }: {
        tickSpacing: number;
        tickIndexs: number[];
    }): boolean;
    static tickArrayStartIndexRange({ tickSpacing }: {
        tickSpacing: number;
    }): {
        maxTickBoundary: number;
        minTickBoundary: number;
    };
    static updatePoolRewardInfos({ connection, apiPoolInfo, chainTime, poolLiquidity, rewardInfos, }: {
        connection: Connection;
        apiPoolInfo: ApiV3PoolInfoConcentratedItem;
        chainTime: number;
        poolLiquidity: BN__default;
        rewardInfos: ReturnType<typeof RewardInfoLayout.decode>[];
    }): Promise<ClmmPoolRewardInfo[]>;
}

declare class PoolUtils {
    static getOutputAmountAndRemainAccounts(poolInfo: ComputeClmmPoolInfo, tickarrayBitmapExtension: ReturnType<typeof TickArrayBitmapExtensionLayout.decode>, tickArrayCache: {
        [key: string]: ReturnType<typeof TickArrayLayout.decode> & {
            address: PublicKey;
        };
    }, inputTokenMint: PublicKey, inputAmount: BN__default, blockTimestamp: number, sqrtPriceLimitX64?: BN__default): {
        allTrade: boolean;
        expectedAmountOut: BN__default;
        remainingAccounts: PublicKey[];
        executionPrice: BN__default;
        feeAmount: BN__default;
    };
    static getInputAmountAndRemainAccounts(poolInfo: ComputeClmmPoolInfo, tickarrayBitmapExtension: ReturnType<typeof TickArrayBitmapExtensionLayout.decode>, tickArrayCache: {
        [key: string]: ReturnType<typeof TickArrayLayout.decode>;
    }, outputTokenMint: PublicKey, outputAmount: BN__default, blockTimestamp: number, sqrtPriceLimitX64?: BN__default): {
        allTrade: boolean;
        expectedAmountIn: BN__default;
        remainingAccounts: PublicKey[];
        executionPrice: BN__default;
        feeAmount: BN__default;
    };
    static fetchExBitmaps({ connection, exBitmapAddress, batchRequest, }: {
        connection: Connection;
        exBitmapAddress: PublicKey[];
        batchRequest: boolean;
    }): Promise<ReturnTypeFetchExBitmaps>;
    static fetchMultiplePoolTickArrays({ connection, poolKeys, batchRequest, }: {
        connection: Connection;
        poolKeys: Omit<ComputeClmmPoolInfo, "ammConfig">[];
        batchRequest?: boolean;
    }): Promise<ReturnTypeFetchMultiplePoolTickArrays>;
    static computeAmountOut({ poolInfo, tickarrayBitmapExtension, tickArrayCache, baseMint, epochInfo, amountIn, slippage, blockTimestamp, priceLimit, }: {
        poolInfo: ComputeClmmPoolInfo;
        tickarrayBitmapExtension: ReturnType<typeof TickArrayBitmapExtensionLayout.decode>;
        tickArrayCache: {
            [key: string]: ReturnType<typeof TickArrayLayout.decode> & {
                address: PublicKey;
            };
        };
        baseMint: PublicKey;
        epochInfo: EpochInfo;
        amountIn: BN__default;
        slippage: number;
        priceLimit?: Decimal;
        catchLiquidityInsufficient: boolean;
        blockTimestamp: number;
    }): ReturnTypeComputeAmountOut;
    static computeAmountOutFormat({ poolInfo, tickarrayBitmapExtension, tickArrayCache, amountIn, tokenOut: _tokenOut, slippage, epochInfo, blockTimestamp, catchLiquidityInsufficient, }: {
        poolInfo: ComputeClmmPoolInfo;
        tickarrayBitmapExtension: ReturnType<typeof TickArrayBitmapExtensionLayout.decode>;
        tickArrayCache: {
            [key: string]: ReturnType<typeof TickArrayLayout.decode> & {
                address: PublicKey;
            };
        };
        amountIn: BN__default;
        tokenOut: ApiV3Token;
        slippage: number;
        epochInfo: EpochInfo;
        blockTimestamp: number;
        catchLiquidityInsufficient?: boolean;
    }): ReturnTypeComputeAmountOutFormat;
    static computeAmountIn({ poolInfo, tickarrayBitmapExtension, tickArrayCache, baseMint, epochInfo, amountOut, slippage, priceLimit, blockTimestamp, }: {
        poolInfo: ComputeClmmPoolInfo;
        tickarrayBitmapExtension: ReturnType<typeof TickArrayBitmapExtensionLayout.decode>;
        tickArrayCache: {
            [key: string]: ReturnType<typeof TickArrayLayout.decode>;
        };
        baseMint: PublicKey;
        epochInfo: EpochInfo;
        amountOut: BN__default;
        slippage: number;
        priceLimit?: Decimal;
        blockTimestamp: number;
    }): ReturnTypeComputeAmountOutBaseOut;
    static estimateAprsForPriceRangeMultiplier({ poolInfo, aprType, positionTickLowerIndex, positionTickUpperIndex, }: {
        poolInfo: ApiV3PoolInfoConcentratedItem;
        aprType: "day" | "week" | "month";
        positionTickLowerIndex: number;
        positionTickUpperIndex: number;
    }): {
        feeApr: number;
        rewardsApr: number[];
        apr: number;
    };
    static estimateAprsForPriceRangeDelta({ poolInfo, poolLiquidity, aprType, mintPrice, liquidity, positionTickLowerIndex, positionTickUpperIndex, chainTime, }: {
        poolInfo: ApiV3PoolInfoConcentratedItem;
        poolLiquidity: BN__default;
        aprType: "day" | "week" | "month";
        mintPrice: {
            [mint: string]: {
                value: number;
            };
        };
        liquidity: BN__default;
        positionTickLowerIndex: number;
        positionTickUpperIndex: number;
        chainTime: number;
    }): {
        feeApr: number;
        rewardsApr: number[];
        apr: number;
    };
    static getLiquidityAmountOutFromAmountIn({ poolInfo, inputA, tickLower, tickUpper, amount, slippage, add, epochInfo, amountHasFee, }: {
        poolInfo: ApiV3PoolInfoConcentratedItem;
        inputA: boolean;
        tickLower: number;
        tickUpper: number;
        amount: BN__default;
        slippage: number;
        add: boolean;
        epochInfo: EpochInfo;
        amountHasFee: boolean;
    }): Promise<ReturnTypeGetLiquidityAmountOut>;
    static getAmountsFromLiquidity({ epochInfo, poolInfo, tickLower, tickUpper, liquidity, slippage, add, }: {
        epochInfo: EpochInfo;
        poolInfo: ApiV3PoolInfoConcentratedItem;
        tickLower: number;
        tickUpper: number;
        liquidity: BN__default;
        slippage: number;
        add: boolean;
    }): Promise<ReturnTypeGetLiquidityAmountOut>;
    static fetchComputeMultipleClmmInfo({ connection, poolList, rpcDataMap, }: {
        rpcDataMap?: Record<string, ReturnType<typeof PoolInfoLayout.decode>>;
        connection: Connection;
        poolList: Pick<ApiV3PoolInfoConcentratedItem, "id" | "programId" | "mintA" | "mintB" | "config" | "price">[];
    }): Promise<Record<string, ComputeClmmPoolInfo>>;
    static fetchComputeClmmInfo({ connection, poolInfo, rpcData, }: {
        connection: Connection;
        poolInfo: Pick<ApiV3PoolInfoConcentratedItem, "id" | "programId" | "mintA" | "mintB" | "config" | "price">;
        rpcData?: ReturnType<typeof PoolInfoLayout.decode>;
    }): Promise<ComputeClmmPoolInfo>;
    static fetchTickArrayInfo({ connection, programId, poolId, tick, tickSpacing, }: {
        connection: Connection;
        programId: PublicKey;
        poolId: PublicKey;
        tick: number;
        tickSpacing: number;
    }): Promise<ReturnType<typeof TickArrayLayout.decode>>;
    static fetchMultipleTickArrayInfo({ connection, tickInfoList, }: {
        connection: Connection;
        tickInfoList: {
            programId: PublicKey;
            poolId: PublicKey;
            tick: number;
            tickSpacing: number;
        }[];
    }): Promise<(ReturnType<typeof TickArrayLayout.decode> | null)[]>;
}
declare function clmmComputeInfoToApiInfo(pool: ComputeClmmPoolInfo): ApiV3PoolInfoConcentratedItem;

export { DynamicFeeInfo, PoolFee, PoolUtil, PoolUtils, clmmComputeInfoToApiInfo };