@pump-fun/pump-swap-sdk/dist/sdk/pumpAmmInternal.d.mts

Official SDK for interacting with Pump Swap AMM protocol on Solana

import { Connection, PublicKey, AccountInfo, TransactionInstruction } from '@solana/web3.js';
import { G as GlobalConfig, P as Pool, i as GlobalVolumeAccumulator, U as UserVolumeAccumulator, k as CreatePoolSolanaState, m as LiquiditySolanaState, D as DepositBaseResult, b as DepositQuoteResult, W as WithdrawResult, l as SwapSolanaState, n as CollectCoinCreatorFeeSolanaState } from '../sdk-CtszEpqH.mjs';
import BN from 'bn.js';
import '@solana/spl-token';

declare const POOL_ACCOUNT_NEW_SIZE = 300;
declare class PumpAmmInternalSdk {
    readonly connection: Connection;
    private readonly program;
    private readonly offlineProgram;
    private readonly globalConfig;
    constructor(connection: Connection, programId?: string);
    programId(): PublicKey;
    globalConfigKey(): PublicKey;
    poolKey(index: number, creator: PublicKey, baseMint: PublicKey, quoteMint: PublicKey): [PublicKey, number];
    lpMintKey(pool: PublicKey): [PublicKey, number];
    fetchGlobalConfigAccount(): Promise<GlobalConfig>;
    fetchPool(pool: PublicKey): Promise<Pool>;
    decodeGlobalConfig(globalConfigAccountInfo: AccountInfo<Buffer>): GlobalConfig;
    decodePool(poolAccountInfo: AccountInfo<Buffer>): Pool;
    fetchGlobalVolumeAccumulator(): Promise<GlobalVolumeAccumulator>;
    decodeGlobalVolumeAccumulator(globalVolumeAccumulatorAccountInfo: AccountInfo<Buffer>): GlobalVolumeAccumulator;
    fetchUserVolumeAccumulator(user: PublicKey): Promise<UserVolumeAccumulator | null>;
    decodeUserVolumeAccumulator(userVolumeAccumulatorAccountInfo: AccountInfo<Buffer>): UserVolumeAccumulator;
    createPoolInstructionsInternal(createPoolSolanaState: CreatePoolSolanaState, baseIn: BN, quoteIn: BN): Promise<TransactionInstruction[]>;
    depositInstructionsInternal(liquiditySolanaState: LiquiditySolanaState, lpToken: BN, maxBase: BN, maxQuote: BN): Promise<TransactionInstruction[]>;
    private withWsolAccounts;
    private withWsolAccount;
    private accountExists;
    depositBaseInputInternal(liquiditySolanaState: LiquiditySolanaState, base: BN, slippage: number): DepositBaseResult;
    depositQuoteInputInternal(liquiditySolanaState: LiquiditySolanaState, quote: BN, slippage: number): DepositQuoteResult;
    withdrawInstructionsInternal(liquiditySolanaState: LiquiditySolanaState, lpTokenAmountIn: BN, minBaseAmountOut: BN, minQuoteAmountOut: BN): Promise<TransactionInstruction[]>;
    withdrawInputsInternal(liquiditySolanaState: LiquiditySolanaState, lpAmount: BN, slippage: number): WithdrawResult;
    private liquidityAccounts;
    buyInstructionsInternal(swapSolanaState: SwapSolanaState, baseOut: BN, maxQuoteIn: BN): Promise<TransactionInstruction[]>;
    createPoolSolanaState(index: number, creator: PublicKey, baseMint: PublicKey, quoteMint: PublicKey, userBaseTokenAccount?: PublicKey | undefined, userQuoteTokenAccount?: PublicKey | undefined): Promise<CreatePoolSolanaState>;
    swapSolanaState(poolKey: PublicKey, user: PublicKey, userBaseTokenAccount?: PublicKey | undefined, userQuoteTokenAccount?: PublicKey | undefined): Promise<SwapSolanaState>;
    swapSolanaStateNoPool(poolKey: PublicKey, user: PublicKey, userBaseTokenAccount?: PublicKey | undefined, userQuoteTokenAccount?: PublicKey | undefined): Promise<SwapSolanaState>;
    liquiditySolanaState(poolKey: PublicKey, user: PublicKey, userBaseTokenAccount?: PublicKey | undefined, userQuoteTokenAccount?: PublicKey | undefined, userPoolTokenAccount?: PublicKey | undefined): Promise<LiquiditySolanaState>;
    buyInstructionsInternalNoPool(swapSolanaState: SwapSolanaState, baseOut: BN, maxQuoteIn: BN): Promise<TransactionInstruction[]>;
    buyBaseInput(swapSolanaState: SwapSolanaState, base: BN, slippage: number): Promise<TransactionInstruction[]>;
    buyQuoteInput(swapSolanaState: SwapSolanaState, quote: BN, slippage: number): Promise<TransactionInstruction[]>;
    sellInstructionsInternal(swapSolanaState: SwapSolanaState, baseAmountIn: BN, minQuoteAmountOut: BN): Promise<TransactionInstruction[]>;
    private withFixPoolInstructions;
    sellInstructionsInternalNoPool(swapSolanaState: SwapSolanaState, baseAmountIn: BN, minQuoteAmountOut: BN): Promise<TransactionInstruction[]>;
    sellBaseInput(swapSolanaState: SwapSolanaState, base: BN, slippage: number): Promise<TransactionInstruction[]>;
    sellQuoteInput(swapSolanaState: SwapSolanaState, quote: BN, slippage: number): Promise<TransactionInstruction[]>;
    extendAccount(account: PublicKey, user: PublicKey): Promise<TransactionInstruction>;
    collectCoinCreatorFeeSolanaState(coinCreator: PublicKey, coinCreatorTokenAccount?: PublicKey | undefined): Promise<CollectCoinCreatorFeeSolanaState>;
    collectCoinCreatorFee(collectCoinCreatorFeeSolanaState: CollectCoinCreatorFeeSolanaState): Promise<TransactionInstruction[]>;
    getCoinCreatorVaultBalance(coinCreator: PublicKey): Promise<BN>;
    setCoinCreator(pool: PublicKey): Promise<TransactionInstruction>;
    private swapAccounts;
    coinCreatorVaultAuthorityPda(coinCreator: PublicKey): PublicKey;
    coinCreatorVaultAta(coinCreatorVaultAuthority: PublicKey, quoteMint: PublicKey, quoteTokenProgram: PublicKey): PublicKey;
    claimTokenIncentivesInternal(user: PublicKey, payer: PublicKey): Promise<TransactionInstruction[]>;
    getTotalUnclaimedTokens(user: PublicKey): Promise<BN>;
    getCurrentDayTokens(user: PublicKey): Promise<BN>;
    syncUserVolumeAccumulator(user: PublicKey): Promise<TransactionInstruction>;
    initUserVolumeAccumulator({ payer, user, }: {
        payer: PublicKey;
        user: PublicKey;
    }): Promise<TransactionInstruction>;
    closeUserVolumeAccumulator(user: PublicKey): Promise<TransactionInstruction>;
}

export { POOL_ACCOUNT_NEW_SIZE, PumpAmmInternalSdk };