@pump-fun/pump-sdk 1.18.4 → 1.18.6

package/src/sdk.ts

@@ -1,41 +1,29 @@
 import { AnchorProvider, Program } from "@coral-xyz/anchor";
-import { PumpAmmAdminSdk, PumpAmmSdk } from "@pump-fun/pump-swap-sdk";
+import { PUMP_AMM_SDK } from "@pump-fun/pump-swap-sdk";
 import {
   createAssociatedTokenAccountIdempotentInstruction,
   getAssociatedTokenAddressSync,
-  NATIVE_MINT,
-  TOKEN_2022_PROGRAM_ID,
-  TOKEN_PROGRAM_ID,
 } from "@solana/spl-token";
 import {
   AccountInfo,
   Connection,
   PublicKey,
-  PublicKeyInitData,
   TransactionInstruction,
 } from "@solana/web3.js";
 import pumpIdl from "./idl/pump.json";
 import { Pump } from "./idl/pump";
 import BN from "bn.js";
 
-import {
-  bondingCurvePda,
-  creatorVaultPda,
-  pumpFeeConfigPda,
-  globalPda,
-  globalVolumeAccumulatorPda,
-  userVolumeAccumulatorPda,
-} from "./pda";
+import { bondingCurvePda, creatorVaultPda } from "./pda";
 import {
   BondingCurve,
   FeeConfig,
   Global,
   GlobalVolumeAccumulator,
   UserVolumeAccumulator,
-  UserVolumeAccumulatorTotalStats,
 } from "./state";
-import { currentDayTokens, totalUnclaimedTokens } from "./tokenIncentives";
 import { getStaticRandomFeeRecipient } from "./bondingCurve";
+import { OFFLINE_PUMP_PROGRAM } from "./onlineSdk";
 
 export function getPumpProgram(connection: Connection): Program<Pump> {
   return new Program(
@@ -63,24 +51,10 @@ export const PUMP_TOKEN_MINT = new PublicKey(
 );
 
 export class PumpSdk {
-  private readonly connection: Connection;
-  private readonly pumpProgram: Program<Pump>;
   private readonly offlinePumpProgram: Program<Pump>;
-  private readonly pumpAmmSdk: PumpAmmSdk;
-  private readonly pumpAmmAdminSdk: PumpAmmAdminSdk;
-
-  constructor(connection: Connection) {
-    this.connection = connection;
-
-    this.pumpProgram = getPumpProgram(connection);
-    this.offlinePumpProgram = getPumpProgram(null as any as Connection);
-
-    this.pumpAmmSdk = new PumpAmmSdk(connection);
-    this.pumpAmmAdminSdk = new PumpAmmAdminSdk(connection);
-  }
 
-  programId(): PublicKey {
-    return this.offlinePumpProgram.programId;
+  constructor() {
+    this.offlinePumpProgram = OFFLINE_PUMP_PROGRAM;
   }
 
   decodeGlobal(accountInfo: AccountInfo<Buffer>): Global {
@@ -144,105 +118,6 @@ export class PumpSdk {
     }
   }
 
-  async fetchGlobal(): Promise<Global> {
-    return await this.pumpProgram.account.global.fetch(globalPda());
-  }
-
-  async fetchFeeConfig(): Promise<FeeConfig> {
-    return await this.pumpProgram.account.feeConfig.fetch(pumpFeeConfigPda());
-  }
-
-  async fetchBondingCurve(mint: PublicKeyInitData): Promise<BondingCurve> {
-    return await this.pumpProgram.account.bondingCurve.fetch(
-      bondingCurvePda(mint),
-    );
-  }
-
-  async fetchBuyState(mint: PublicKey, user: PublicKey) {
-    const [bondingCurveAccountInfo, associatedUserAccountInfo] =
-      await this.connection.getMultipleAccountsInfo([
-        bondingCurvePda(mint),
-        getAssociatedTokenAddressSync(mint, user, true),
-      ]);
-
-    if (!bondingCurveAccountInfo) {
-      throw new Error(
-        `Bonding curve account not found for mint: ${mint.toBase58()}`,
-      );
-    }
-
-    const bondingCurve = this.decodeBondingCurve(bondingCurveAccountInfo);
-    return { bondingCurveAccountInfo, bondingCurve, associatedUserAccountInfo };
-  }
-
-  async fetchSellState(mint: PublicKey, user: PublicKey) {
-    const [bondingCurveAccountInfo, associatedUserAccountInfo] =
-      await this.connection.getMultipleAccountsInfo([
-        bondingCurvePda(mint),
-        getAssociatedTokenAddressSync(mint, user, true),
-      ]);
-
-    if (!bondingCurveAccountInfo) {
-      throw new Error(
-        `Bonding curve account not found for mint: ${mint.toBase58()}`,
-      );
-    }
-
-    if (!associatedUserAccountInfo) {
-      throw new Error(
-        `Associated token account not found for mint: ${mint.toBase58()} and user: ${user.toBase58()}`,
-      );
-    }
-
-    const bondingCurve = this.decodeBondingCurve(bondingCurveAccountInfo);
-    return { bondingCurveAccountInfo, bondingCurve };
-  }
-
-  async fetchGlobalVolumeAccumulator(): Promise<GlobalVolumeAccumulator> {
-    return await this.pumpProgram.account.globalVolumeAccumulator.fetch(
-      globalVolumeAccumulatorPda()[0],
-    );
-  }
-
-  async fetchUserVolumeAccumulator(
-    user: PublicKey,
-  ): Promise<UserVolumeAccumulator | null> {
-    return await this.pumpProgram.account.userVolumeAccumulator.fetchNullable(
-      userVolumeAccumulatorPda(user)[0],
-    );
-  }
-
-  async fetchUserVolumeAccumulatorTotalStats(
-    user: PublicKey,
-  ): Promise<UserVolumeAccumulatorTotalStats> {
-    const userVolumeAccumulator = (await this.fetchUserVolumeAccumulator(
-      user,
-    )) ?? {
-      totalUnclaimedTokens: new BN(0),
-      totalClaimedTokens: new BN(0),
-      currentSolVolume: new BN(0),
-    };
-
-    const userVolumeAccumulatorAmm =
-      (await this.pumpAmmSdk.fetchUserVolumeAccumulator(user)) ?? {
-        totalUnclaimedTokens: new BN(0),
-        totalClaimedTokens: new BN(0),
-        currentSolVolume: new BN(0),
-      };
-
-    return {
-      totalUnclaimedTokens: userVolumeAccumulator.totalUnclaimedTokens.add(
-        userVolumeAccumulatorAmm.totalUnclaimedTokens,
-      ),
-      totalClaimedTokens: userVolumeAccumulator.totalClaimedTokens.add(
-        userVolumeAccumulatorAmm.totalClaimedTokens,
-      ),
-      currentSolVolume: userVolumeAccumulator.currentSolVolume.add(
-        userVolumeAccumulatorAmm.currentSolVolume,
-      ),
-    };
-  }
-
   async createInstruction({
     mint,
     name,
@@ -488,266 +363,6 @@ export class PumpSdk {
       .instruction();
   }
 
-  async collectCoinCreatorFeeInstructions(
-    coinCreator: PublicKey,
-  ): Promise<TransactionInstruction[]> {
-    let quoteMint = NATIVE_MINT;
-    let quoteTokenProgram = TOKEN_PROGRAM_ID;
-
-    let coinCreatorVaultAuthority =
-      this.pumpAmmSdk.coinCreatorVaultAuthorityPda(coinCreator);
-    let coinCreatorVaultAta = this.pumpAmmSdk.coinCreatorVaultAta(
-      coinCreatorVaultAuthority,
-      quoteMint,
-      quoteTokenProgram,
-    );
-
-    let coinCreatorTokenAccount = getAssociatedTokenAddressSync(
-      quoteMint,
-      coinCreator,
-      true,
-      quoteTokenProgram,
-    );
-    const [coinCreatorVaultAtaAccountInfo, coinCreatorTokenAccountInfo] =
-      await this.connection.getMultipleAccountsInfo([
-        coinCreatorVaultAta,
-        coinCreatorTokenAccount,
-      ]);
-
-    return [
-      await this.offlinePumpProgram.methods
-        .collectCreatorFee()
-        .accountsPartial({
-          creator: coinCreator,
-        })
-        .instruction(),
-      ...(await this.pumpAmmSdk.collectCoinCreatorFee({
-        coinCreator,
-        quoteMint,
-        quoteTokenProgram,
-        coinCreatorVaultAuthority,
-        coinCreatorVaultAta,
-        coinCreatorTokenAccount,
-        coinCreatorVaultAtaAccountInfo,
-        coinCreatorTokenAccountInfo,
-      })),
-    ];
-  }
-
-  async adminSetCoinCreatorInstructions(
-    newCoinCreator: PublicKey,
-    mint: PublicKey,
-  ): Promise<TransactionInstruction[]> {
-    const global = await this.fetchGlobal();
-
-    return [
-      await this.offlinePumpProgram.methods
-        .adminSetCreator(newCoinCreator)
-        .accountsPartial({
-          adminSetCreatorAuthority: global.adminSetCreatorAuthority,
-          mint,
-        })
-        .instruction(),
-      await this.pumpAmmAdminSdk.adminSetCoinCreator(mint, newCoinCreator),
-    ];
-  }
-
-  async getCreatorVaultBalance(creator: PublicKey): Promise<BN> {
-    const creatorVault = creatorVaultPda(creator);
-    const accountInfo = await this.connection.getAccountInfo(creatorVault);
-
-    if (accountInfo === null) {
-      return new BN(0);
-    }
-
-    const rentExemptionLamports =
-      await this.connection.getMinimumBalanceForRentExemption(
-        accountInfo.data.length,
-      );
-
-    if (accountInfo.lamports < rentExemptionLamports) {
-      return new BN(0);
-    }
-
-    return new BN(accountInfo.lamports - rentExemptionLamports);
-  }
-
-  async getCreatorVaultBalanceBothPrograms(creator: PublicKey): Promise<BN> {
-    const balance = await this.getCreatorVaultBalance(creator);
-    const ammBalance =
-      await this.pumpAmmSdk.getCoinCreatorVaultBalance(creator);
-    return balance.add(ammBalance);
-  }
-
-  async adminUpdateTokenIncentives(
-    startTime: BN,
-    endTime: BN,
-    dayNumber: BN,
-    tokenSupplyPerDay: BN,
-    secondsInADay: BN = new BN(86_400),
-    mint: PublicKey = PUMP_TOKEN_MINT,
-    tokenProgram: PublicKey = TOKEN_2022_PROGRAM_ID,
-  ): Promise<TransactionInstruction> {
-    const { authority } = await this.fetchGlobal();
-
-    return await this.offlinePumpProgram.methods
-      .adminUpdateTokenIncentives(
-        startTime,
-        endTime,
-        secondsInADay,
-        dayNumber,
-        tokenSupplyPerDay,
-      )
-      .accountsPartial({
-        authority,
-        mint,
-        tokenProgram,
-      })
-      .instruction();
-  }
-
-  async adminUpdateTokenIncentivesBothPrograms(
-    startTime: BN,
-    endTime: BN,
-    dayNumber: BN,
-    tokenSupplyPerDay: BN,
-    secondsInADay: BN = new BN(86_400),
-    mint: PublicKey = PUMP_TOKEN_MINT,
-    tokenProgram: PublicKey = TOKEN_2022_PROGRAM_ID,
-  ): Promise<TransactionInstruction[]> {
-    return [
-      await this.adminUpdateTokenIncentives(
-        startTime,
-        endTime,
-        dayNumber,
-        tokenSupplyPerDay,
-        secondsInADay,
-        mint,
-        tokenProgram,
-      ),
-      await this.pumpAmmAdminSdk.adminUpdateTokenIncentives(
-        startTime,
-        endTime,
-        dayNumber,
-        tokenSupplyPerDay,
-        secondsInADay,
-        mint,
-        tokenProgram,
-      ),
-    ];
-  }
-
-  async claimTokenIncentives(
-    user: PublicKey,
-    payer: PublicKey,
-  ): Promise<TransactionInstruction[]> {
-    const { mint } = await this.fetchGlobalVolumeAccumulator();
-
-    if (mint.equals(PublicKey.default)) {
-      return [];
-    }
-
-    const [mintAccountInfo, userAccumulatorAccountInfo] =
-      await this.connection.getMultipleAccountsInfo([
-        mint,
-        userVolumeAccumulatorPda(user)[0],
-      ]);
-
-    if (!mintAccountInfo) {
-      return [];
-    }
-
-    if (!userAccumulatorAccountInfo) {
-      return [];
-    }
-
-    return [
-      await this.offlinePumpProgram.methods
-        .claimTokenIncentives()
-        .accountsPartial({
-          user,
-          payer,
-          mint,
-          tokenProgram: mintAccountInfo.owner,
-        })
-        .instruction(),
-    ];
-  }
-
-  async claimTokenIncentivesBothPrograms(
-    user: PublicKey,
-    payer: PublicKey,
-  ): Promise<TransactionInstruction[]> {
-    return [
-      ...(await this.claimTokenIncentives(user, payer)),
-      ...(await this.pumpAmmSdk.claimTokenIncentives(user, payer)),
-    ];
-  }
-
-  async getTotalUnclaimedTokens(user: PublicKey): Promise<BN> {
-    const [
-      globalVolumeAccumulatorAccountInfo,
-      userVolumeAccumulatorAccountInfo,
-    ] = await this.connection.getMultipleAccountsInfo([
-      globalVolumeAccumulatorPda()[0],
-      userVolumeAccumulatorPda(user)[0],
-    ]);
-
-    if (
-      !globalVolumeAccumulatorAccountInfo ||
-      !userVolumeAccumulatorAccountInfo
-    ) {
-      return new BN(0);
-    }
-
-    const globalVolumeAccumulator = this.decodeGlobalVolumeAccumulator(
-      globalVolumeAccumulatorAccountInfo,
-    );
-    const userVolumeAccumulator = this.decodeUserVolumeAccumulator(
-      userVolumeAccumulatorAccountInfo,
-    );
-
-    return totalUnclaimedTokens(globalVolumeAccumulator, userVolumeAccumulator);
-  }
-
-  async getTotalUnclaimedTokensBothPrograms(user: PublicKey): Promise<BN> {
-    return (await this.getTotalUnclaimedTokens(user)).add(
-      await this.pumpAmmSdk.getTotalUnclaimedTokens(user),
-    );
-  }
-
-  async getCurrentDayTokens(user: PublicKey): Promise<BN> {
-    const [
-      globalVolumeAccumulatorAccountInfo,
-      userVolumeAccumulatorAccountInfo,
-    ] = await this.connection.getMultipleAccountsInfo([
-      globalVolumeAccumulatorPda()[0],
-      userVolumeAccumulatorPda(user)[0],
-    ]);
-
-    if (
-      !globalVolumeAccumulatorAccountInfo ||
-      !userVolumeAccumulatorAccountInfo
-    ) {
-      return new BN(0);
-    }
-
-    const globalVolumeAccumulator = this.decodeGlobalVolumeAccumulator(
-      globalVolumeAccumulatorAccountInfo,
-    );
-    const userVolumeAccumulator = this.decodeUserVolumeAccumulator(
-      userVolumeAccumulatorAccountInfo,
-    );
-
-    return currentDayTokens(globalVolumeAccumulator, userVolumeAccumulator);
-  }
-
-  async getCurrentDayTokensBothPrograms(user: PublicKey): Promise<BN> {
-    return (await this.getCurrentDayTokens(user)).add(
-      await this.pumpAmmSdk.getCurrentDayTokens(user),
-    );
-  }
-
   async syncUserVolumeAccumulator(
     user: PublicKey,
   ): Promise<TransactionInstruction> {
@@ -762,7 +377,7 @@ export class PumpSdk {
   ): Promise<TransactionInstruction[]> {
     return [
       await this.syncUserVolumeAccumulator(user),
-      await this.pumpAmmSdk.syncUserVolumeAccumulator(user),
+      await PUMP_AMM_SDK.syncUserVolumeAccumulator(user),
     ];
   }
 
@@ -914,7 +529,9 @@ export class PumpSdk {
   }
 }
 
-function getFeeRecipient(global: Global): PublicKey {
+export const PUMP_SDK = new PumpSdk();
+
+export function getFeeRecipient(global: Global): PublicKey {
   const feeRecipients = [global.feeRecipient, ...global.feeRecipients];
   return feeRecipients[Math.floor(Math.random() * feeRecipients.length)];
 }