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

An SDK for building applications on top of Raydium.

import { bP as ReturnTypeMakeInstructions, q as ApiV3PoolInfoConcentratedItem, G as ClmmKeys, j as ApiV3Token } from '../../api-23ae421b.js';
import { PublicKey, TransactionInstruction, Connection } from '@solana/web3.js';
import BN__default from 'bn.js';
import { PersonalPositionLayout } from './layout.js';
import { SimpleClmmPoolInfo, OpenPositionFromBaseExtInfo, OpenPositionFromLiquidityExtInfo, ClosePositionExtInfo, ManipulateLiquidityExtInfo, ClmmPoolPersonalPosition, InitRewardExtInfo, ClmmLockAddress } from './type.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 'decimal.js';
import '../../module/token.js';
import '../../common/pubKey.js';
import '../../common/logger.js';
import '../../module/currency.js';
import '../../marshmallow/index.js';
import '../../marshmallow/buffer-layout.js';
import './libraries/constants.js';

interface CreatePoolInstruction {
    connection: Connection;
    programId: PublicKey;
    owner: PublicKey;
    mintA: ApiV3Token;
    mintB: ApiV3Token;
    ammConfigId: PublicKey;
    initialPriceX64: BN__default;
    forerunCreate?: boolean;
    extendMintAccount?: PublicKey[];
}
declare class ClmmInstrument {
    static createPoolInstruction(programId: PublicKey, poolId: PublicKey, poolCreator: PublicKey, ammConfigId: PublicKey, observationId: PublicKey, mintA: PublicKey, vaultA: PublicKey, mintProgramIdA: PublicKey, mintB: PublicKey, vaultB: PublicKey, mintProgramIdB: PublicKey, tickArrayBitmap: PublicKey, sqrtPriceX64: BN__default, supperMintEx: PublicKey[] | undefined): TransactionInstruction;
    static createCustomizablePoolInstruction(programId: PublicKey, poolId: PublicKey, poolCreator: PublicKey, ammConfig: PublicKey, mintA: PublicKey, mintB: PublicKey, vaultA: PublicKey, vaultB: PublicKey, observationId: PublicKey, tickArrayBitmap: PublicKey, mintProgramIdA: PublicKey, mintProgramIdB: PublicKey, sqrtPriceX64: BN__default, collectFeeOn: number, // new
    supperMintEx: PublicKey[], dynamicFeeConfig?: PublicKey): TransactionInstruction;
    static initializeRewardInstruction(programId: PublicKey, rewardFunder: PublicKey, poolId: PublicKey, operationId: PublicKey, ammConfigId: PublicKey, funderTokenAccount: PublicKey, tokenProgramId: PublicKey, rewardTokenMint: PublicKey, rewardTokenVault: PublicKey, openTime: BN__default, endTime: BN__default, emissionsPerSecondX64: BN__default): TransactionInstruction;
    static updateRewardInfosInstruction(programId: PublicKey, poolId: PublicKey): TransactionInstruction;
    static setRewardParamsInstruction(programId: PublicKey, authority: PublicKey, poolId: PublicKey, operationId: PublicKey, ammConfigId: PublicKey, ownerTokenAccount: PublicKey, rewardVault: PublicKey, rewardMint: PublicKey, rewardIndex: number, openTime: BN__default, endTime: BN__default, emissionsPerSecondX64: BN__default): TransactionInstruction;
    static closePositionInstruction(programId: PublicKey, nftOwner: PublicKey, positionNftMint: PublicKey, positionNftAccount: PublicKey, personalPosition: PublicKey, nft2022?: boolean): TransactionInstruction;
    static openPositionV2Instruction(programId: PublicKey, payer: PublicKey, poolId: PublicKey, positionNftOwner: PublicKey, positionNftMint: PublicKey, positionNftAccount: PublicKey, metadataAccount: PublicKey, protocolPosition: PublicKey, tickArrayLower: PublicKey, tickArrayUpper: PublicKey, personalPosition: PublicKey, ownerVaultA: PublicKey, ownerVaultB: PublicKey, vaultA: PublicKey, vaultB: PublicKey, mintA: PublicKey, mintB: PublicKey, tickLower: number, tickUpper: number, tickArrayLowerStart: number, tickArrayUpperStart: number, liquidity: BN__default, amountMaxA: BN__default, amountMaxB: BN__default, withMetadata: boolean, baseFlag: boolean | null, exTickArrayBitmap?: PublicKey): TransactionInstruction;
    static increaseLiquidityV2Instruction(programId: PublicKey, nftOwner: PublicKey, nftAccount: PublicKey, personalPosition: PublicKey, poolId: PublicKey, protocolPosition: PublicKey, tickArrayLower: PublicKey, tickArrayUpper: PublicKey, ownerVaultA: PublicKey, ownerVaultB: PublicKey, vaultA: PublicKey, vaultB: PublicKey, mintA: PublicKey, mintB: PublicKey, liquidity: BN__default, amountMaxA: BN__default, amountMaxB: BN__default, baseFlag: boolean | null, exTickArrayBitmap?: PublicKey): TransactionInstruction;
    static decreaseLiquidityV2Instruction(programId: PublicKey, nftOwner: PublicKey, nftAccount: PublicKey, personalPosition: PublicKey, poolId: PublicKey, protocolPosition: PublicKey, tickArrayLower: PublicKey, tickArrayUpper: PublicKey, ownerVaultA: PublicKey, ownerVaultB: PublicKey, vaultA: PublicKey, vaultB: PublicKey, mintA: PublicKey, mintB: PublicKey, rewardAccounts: {
        poolRewardVault: PublicKey;
        ownerRewardVault: PublicKey;
        rewardMint: PublicKey;
    }[], liquidity: BN__default, amountMinA: BN__default, amountMinB: BN__default, exTickArrayBitmap?: PublicKey): TransactionInstruction;
    static swapV2Instruction(programId: PublicKey, payer: PublicKey, poolId: PublicKey, ammConfig: PublicKey, inputTokenAccount: PublicKey, outputTokenAccount: PublicKey, inputVault: PublicKey, outputVault: PublicKey, inputTokenMint: PublicKey, outputTokenMint: PublicKey, tickArray: PublicKey[], observationId: PublicKey, amount: BN__default, otherAmountThreshold: BN__default, sqrtPriceLimitX64: BN__default, isBaseInput: boolean, tickArrayBitmapExtension?: PublicKey): TransactionInstruction;
    static collectRemainingRewardsInstruction(programId: PublicKey, rewardFunder: PublicKey, poolId: PublicKey, funderTokenAccount: PublicKey, rewardTokenVault: PublicKey, rewardMint: PublicKey, rewardIndex: number): TransactionInstruction;
    static openPositionWithToken22NftInstruction(programId: PublicKey, payer: PublicKey, poolId: PublicKey, positionNftOwner: PublicKey, positionNftMint: PublicKey, positionNftAccount: PublicKey, protocolPosition: PublicKey, tickArrayLower: PublicKey, tickArrayUpper: PublicKey, personalPosition: PublicKey, ownerVaultA: PublicKey, ownerVaultB: PublicKey, vaultA: PublicKey, vaultB: PublicKey, mintA: PublicKey, mintB: PublicKey, tickLower: number, tickUpper: number, tickArrayLowerStart: number, tickArrayUpperStart: number, liquidity: BN__default, amountMaxA: BN__default, amountMaxB: BN__default, withMetadata: boolean, baseFlag: boolean | null, exTickArrayBitmap?: PublicKey): TransactionInstruction;
    static openLimitOrderInstruction(programId: PublicKey, payer: PublicKey, poolId: PublicKey, tickArray: PublicKey, limitOrderNonce: PublicKey, limitOrder: PublicKey, inputTokenAccount: PublicKey, inputVault: PublicKey, inputVaultMint: PublicKey, inputTokenProgram: PublicKey, nonceIndex: number, zeroForOne: boolean, tickIndex: number, amount: BN__default, tickArrayBitmap?: PublicKey): TransactionInstruction;
    static increaseLimitOrderInstruction(programId: PublicKey, owner: PublicKey, poolId: PublicKey, tickArray: PublicKey, limitOrder: PublicKey, inputTokenAccount: PublicKey, inputVault: PublicKey, inputVaultMint: PublicKey, inputTokenProgram: PublicKey, amount: BN__default): TransactionInstruction;
    static decreaseLimitOrderInstruction(programId: PublicKey, owner: PublicKey, poolId: PublicKey, tickArray: PublicKey, limitOrder: PublicKey, inputTokenAccount: PublicKey, outputTokenAccount: PublicKey, inputVault: PublicKey, outputVault: PublicKey, inputVaultMint: PublicKey, outputVaultMint: PublicKey, amount: BN__default, amountMin: BN__default, tickArrayBitmap?: PublicKey): TransactionInstruction;
    static settleLimitOrderInstruction(programId: PublicKey, signer: PublicKey, poolId: PublicKey, tickArray: PublicKey, limitOrder: PublicKey, outputTokenAccount: PublicKey, outputVault: PublicKey, outputVaultMint: PublicKey, outputTokenProgram: PublicKey): TransactionInstruction;
    static closeLimitOrderInstruction(programId: PublicKey, signer: PublicKey, rentReceiver: PublicKey, limitOrder: PublicKey): TransactionInstruction;
    static createPoolInstructions(props: CreatePoolInstruction): ReturnTypeMakeInstructions<{
        poolId: PublicKey;
        observationId: PublicKey;
        exBitmapAccount: PublicKey;
        mintA: PublicKey;
        mintB: PublicKey;
        mintAProgram: PublicKey;
        mintBProgram: PublicKey;
        mintAVault: PublicKey;
        mintBVault: PublicKey;
    }>;
    static openPositionInstructions({ poolInfo, poolKeys, ownerInfo, tickLower, tickUpper, liquidity, amountMaxA, amountMaxB, base, withMetadata, getEphemeralSigners, nft2022, }: {
        poolInfo: ApiV3PoolInfoConcentratedItem;
        poolKeys: ClmmKeys;
        ownerInfo: {
            feePayer: PublicKey;
            wallet: PublicKey;
            tokenAccountA: PublicKey;
            tokenAccountB: PublicKey;
        };
        tickLower: number;
        tickUpper: number;
        liquidity: BN__default;
        amountMaxA: BN__default;
        amountMaxB: BN__default;
        base: "MintA" | "MintB" | null;
        withMetadata: "create" | "no-create";
        getEphemeralSigners?: (k: number) => any;
        nft2022?: boolean;
    }): Promise<ReturnTypeMakeInstructions>;
    static openPositionFromBaseInstructions({ poolInfo, poolKeys, ownerInfo, tickLower, tickUpper, base, baseAmount, otherAmountMax, liquidity, withMetadata, getEphemeralSigners, nft2022, }: {
        poolInfo: SimpleClmmPoolInfo;
        poolKeys: {
            vault: {
                A: string | PublicKey;
                B: string | PublicKey;
            };
            lookupTableAccount?: string;
        };
        ownerInfo: {
            feePayer: PublicKey;
            wallet: PublicKey;
            tokenAccountA: PublicKey;
            tokenAccountB: PublicKey;
        };
        tickLower: number;
        tickUpper: number;
        base: "MintA" | "MintB" | null;
        baseAmount: BN__default;
        otherAmountMax: BN__default;
        liquidity: BN__default;
        withMetadata: "create" | "no-create";
        getEphemeralSigners?: (k: number) => any;
        nft2022?: boolean;
    }): Promise<ReturnTypeMakeInstructions<OpenPositionFromBaseExtInfo>>;
    static openPositionFromLiquidityInstructions({ poolInfo, poolKeys, ownerInfo, tickLower, tickUpper, liquidity, amountMaxA, amountMaxB, base, withMetadata, getEphemeralSigners, nft2022, }: {
        poolInfo: SimpleClmmPoolInfo;
        poolKeys: ClmmKeys;
        ownerInfo: {
            wallet: PublicKey;
            tokenAccountA: PublicKey;
            tokenAccountB: PublicKey;
        };
        tickLower: number;
        tickUpper: number;
        liquidity: BN__default;
        amountMaxA: BN__default;
        amountMaxB: BN__default;
        base: "MintA" | "MintB" | null;
        withMetadata: "create" | "no-create";
        getEphemeralSigners?: (k: number) => any;
        nft2022?: boolean;
    }): Promise<ReturnTypeMakeInstructions<OpenPositionFromLiquidityExtInfo["address"]>>;
    static closePositionInstructions({ poolInfo, poolKeys, ownerInfo, ownerPosition, nft2022, }: {
        poolInfo: ApiV3PoolInfoConcentratedItem;
        poolKeys: ClmmKeys;
        ownerPosition: ReturnType<typeof PersonalPositionLayout.decode>;
        ownerInfo: {
            wallet: PublicKey;
        };
        nft2022?: boolean;
    }): ReturnTypeMakeInstructions<ClosePositionExtInfo["address"]>;
    static increasePositionFromLiquidityInstructions({ poolInfo, poolKeys, ownerPosition, ownerInfo, liquidity, amountMaxA, amountMaxB, nft2022, }: {
        poolInfo: ApiV3PoolInfoConcentratedItem;
        poolKeys: ClmmKeys;
        ownerPosition: ReturnType<typeof PersonalPositionLayout.decode>;
        ownerInfo: {
            wallet: PublicKey;
            tokenAccountA: PublicKey;
            tokenAccountB: PublicKey;
        };
        liquidity: BN__default;
        amountMaxA: BN__default;
        amountMaxB: BN__default;
        nft2022?: boolean;
    }): ReturnTypeMakeInstructions<ManipulateLiquidityExtInfo["address"]>;
    static increasePositionFromBaseInstructions({ poolInfo, poolKeys, ownerPosition, ownerInfo, base, baseAmount, otherAmountMax, nft2022, }: {
        poolInfo: ApiV3PoolInfoConcentratedItem;
        poolKeys: ClmmKeys;
        ownerPosition: ClmmPoolPersonalPosition;
        ownerInfo: {
            wallet: PublicKey;
            tokenAccountA: PublicKey;
            tokenAccountB: PublicKey;
        };
        base: "MintA" | "MintB";
        baseAmount: BN__default;
        otherAmountMax: BN__default;
        nft2022?: boolean;
    }): ReturnTypeMakeInstructions<ManipulateLiquidityExtInfo["address"]>;
    static decreaseLiquidityInstructions({ poolInfo, poolKeys, ownerPosition, ownerInfo, liquidity, amountMinA, amountMinB, programId, nft2022, }: {
        poolInfo: ApiV3PoolInfoConcentratedItem;
        poolKeys: ClmmKeys;
        ownerPosition: ReturnType<typeof PersonalPositionLayout.decode>;
        ownerInfo: {
            wallet: PublicKey;
            tokenAccountA: PublicKey;
            tokenAccountB: PublicKey;
            rewardAccounts: PublicKey[];
        };
        liquidity: BN__default;
        amountMinA: BN__default;
        amountMinB: BN__default;
        programId?: PublicKey;
        nft2022?: boolean;
    }): ReturnTypeMakeInstructions<ManipulateLiquidityExtInfo["address"]>;
    static makeSwapBaseInInstructions({ poolInfo, poolKeys, observationId, ownerInfo, inputMint, amountIn, amountOutMin, sqrtPriceLimitX64, remainingAccounts, }: {
        poolInfo: SimpleClmmPoolInfo;
        poolKeys: Pick<ClmmKeys, "vault" | "lookupTableAccount">;
        observationId: PublicKey;
        ownerInfo: {
            wallet: PublicKey;
            tokenAccountA: PublicKey;
            tokenAccountB: PublicKey;
        };
        inputMint: PublicKey;
        amountIn: BN__default;
        amountOutMin: BN__default;
        sqrtPriceLimitX64: BN__default;
        remainingAccounts: PublicKey[];
    }): ReturnTypeMakeInstructions;
    static makeSwapBaseOutInstructions({ poolInfo, poolKeys, observationId, ownerInfo, outputMint, amountOut, amountInMax, sqrtPriceLimitX64, remainingAccounts, }: {
        poolInfo: SimpleClmmPoolInfo;
        poolKeys: Pick<ClmmKeys, "vault" | "lookupTableAccount">;
        observationId: PublicKey;
        ownerInfo: {
            wallet: PublicKey;
            tokenAccountA: PublicKey;
            tokenAccountB: PublicKey;
        };
        outputMint: PublicKey;
        amountOut: BN__default;
        amountInMax: BN__default;
        sqrtPriceLimitX64: BN__default;
        remainingAccounts: PublicKey[];
    }): ReturnTypeMakeInstructions;
    static initRewardInstructions({ poolInfo, poolKeys, ownerInfo, rewardInfo, }: {
        poolInfo: ApiV3PoolInfoConcentratedItem;
        poolKeys: ClmmKeys;
        ownerInfo: {
            wallet: PublicKey;
            tokenAccount: PublicKey;
        };
        rewardInfo: {
            programId: PublicKey;
            mint: PublicKey;
            openTime: number;
            endTime: number;
            emissionsPerSecondX64: BN__default;
        };
    }): ReturnTypeMakeInstructions<InitRewardExtInfo["address"]>;
    static setRewardInstructions({ poolInfo, poolKeys, ownerInfo, rewardInfo, }: {
        poolInfo: ApiV3PoolInfoConcentratedItem;
        poolKeys: ClmmKeys;
        ownerInfo: {
            wallet: PublicKey;
            tokenAccount: PublicKey;
        };
        rewardInfo: {
            mint: PublicKey;
            openTime: number;
            endTime: number;
            emissionsPerSecondX64: BN__default;
        };
    }): ReturnTypeMakeInstructions;
    static collectRewardInstructions({ poolInfo, poolKeys, ownerInfo, rewardMint, }: {
        poolInfo: ApiV3PoolInfoConcentratedItem;
        poolKeys: ClmmKeys;
        ownerInfo: {
            wallet: PublicKey;
            tokenAccount: PublicKey;
        };
        rewardMint: PublicKey;
    }): ReturnTypeMakeInstructions;
    static makeLockPositions({ programId, authProgramId, poolProgramId, payer, wallet, nftMint, nft2022, getEphemeralSigners, }: {
        programId: PublicKey;
        authProgramId: PublicKey;
        poolProgramId: PublicKey;
        wallet: PublicKey;
        payer: PublicKey;
        nftMint: PublicKey;
        nft2022?: boolean;
        getEphemeralSigners?: (k: number) => any;
    }): Promise<ReturnTypeMakeInstructions<ClmmLockAddress>>;
    static lockPositionInstructionV2({ programId, auth, payer, positionOwner, lockOwner, positionNftAccount, positionId, positionNftMint, authPositionNftAccount, positionNftProgram, lockPositionId, lockNftMint, lockNftAccount, metadataAccount, withMetadata, }: {
        programId: PublicKey;
        auth: PublicKey;
        payer: PublicKey;
        positionOwner: PublicKey;
        lockOwner: PublicKey;
        positionNftAccount: PublicKey;
        positionId: PublicKey;
        positionNftMint: PublicKey;
        authPositionNftAccount: PublicKey;
        positionNftProgram: PublicKey;
        lockPositionId: PublicKey;
        lockNftMint: PublicKey;
        lockNftAccount: PublicKey;
        metadataAccount: PublicKey;
        withMetadata: boolean;
        nft2022?: boolean;
    }): TransactionInstruction;
    static lockPositionInstruction({ programId, authProgramId, poolProgramId, owner, positionNft, }: {
        programId: PublicKey;
        authProgramId: PublicKey;
        poolProgramId: PublicKey;
        owner: PublicKey;
        positionNft: PublicKey;
    }): TransactionInstruction;
    static harvestLockPositionInstruction(props: {
        poolKeys: ClmmKeys;
        programId: PublicKey;
        authProgramId: PublicKey;
        ownerPosition: ReturnType<typeof PersonalPositionLayout.decode>;
        owner: PublicKey;
        ownerRewardAccounts: PublicKey[];
        userVaultA: PublicKey;
        userVaultB: PublicKey;
    }): TransactionInstruction;
    static harvestLockPositionInstructionV2({ programId, auth, lockPositionId, clmmProgram, lockOwner, lockNftMint, lockNftAccount, positionNftAccount, positionId, poolId, protocolPosition, vaultA, vaultB, tickArrayLower, tickArrayUpper, userVaultA, userVaultB, mintA, mintB, rewardAccounts, exTickArrayBitmap, }: {
        programId: PublicKey;
        auth: PublicKey;
        lockPositionId: PublicKey;
        clmmProgram: PublicKey;
        lockOwner: PublicKey;
        lockNftMint: PublicKey;
        lockNftAccount: PublicKey;
        positionNftAccount: PublicKey;
        positionId: PublicKey;
        poolId: PublicKey;
        protocolPosition: PublicKey;
        vaultA: PublicKey;
        vaultB: PublicKey;
        tickArrayLower: PublicKey;
        tickArrayUpper: PublicKey;
        userVaultA: PublicKey;
        userVaultB: PublicKey;
        mintA: PublicKey;
        mintB: PublicKey;
        rewardAccounts: {
            poolRewardVault: PublicKey;
            ownerRewardVault: PublicKey;
            rewardMint: PublicKey;
        }[];
        exTickArrayBitmap?: PublicKey;
    }): TransactionInstruction;
}

export { ClmmInstrument };