@pump-fun/pump-sdk 1.5.0-devnet.1 → 1.6.0-devnet.1

package/src/index.ts

@@ -13,6 +13,8 @@ export {
   pumpPoolAuthorityPda,
   CANONICAL_POOL_INDEX,
   canonicalPumpPoolPda,
+  globalVolumeAccumulatorPda,
+  userVolumeAccumulatorPda,
 } from "./pda";
 export {
   getPumpProgram,

package/src/pda.ts

@@ -1,6 +1,7 @@
 import { PublicKey, PublicKeyInitData } from "@solana/web3.js";
 import { NATIVE_MINT } from "@solana/spl-token";
 import { poolPda } from "@pump-fun/pump-swap-sdk";
+import { PUMP_PROGRAM_ID } from "./sdk";
 
 export function globalPda(programId: PublicKey): PublicKey {
   const [globalPda] = PublicKey.findProgramAddressSync(
@@ -56,3 +57,22 @@ export function canonicalPumpPoolPda(
     pumpAmmProgramId,
   );
 }
+
+export function globalVolumeAccumulatorPda(
+  programId: PublicKey = PUMP_PROGRAM_ID,
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("global_volume_accumulator")],
+    programId,
+  );
+}
+
+export function userVolumeAccumulatorPda(
+  user: PublicKey,
+  programId: PublicKey = PUMP_PROGRAM_ID,
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("user_volume_accumulator"), user.toBuffer()],
+    programId,
+  );
+}

package/src/sdk.ts

@@ -4,6 +4,7 @@ import {
   createAssociatedTokenAccountIdempotentInstruction,
   getAssociatedTokenAddressSync,
   NATIVE_MINT,
+  TOKEN_2022_PROGRAM_ID,
   TOKEN_PROGRAM_ID,
 } from "@solana/spl-token";
 import {
@@ -23,8 +24,10 @@ import {
   creatorVaultPda,
   globalPda,
   pumpPoolAuthorityPda,
+  globalVolumeAccumulatorPda,
+  userVolumeAccumulatorPda,
 } from "./pda";
-import { BondingCurve, Global } from "./state";
+import { BondingCurve, Global, GlobalVolumeAccumulator, UserVolumeAccumulator } from "./state";
 
 export function getPumpProgram(
   connection: Connection,
@@ -49,6 +52,10 @@ export const PUMP_AMM_PROGRAM_ID = new PublicKey(
 
 export const BONDING_CURVE_NEW_SIZE = 150;
 
+export const PUMP_TOKEN_MINT = new PublicKey(
+  "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn",
+);
+
 export class PumpSdk {
   private readonly connection: Connection;
   private readonly pumpProgram: Program<Pump>;
@@ -104,6 +111,14 @@ export class PumpSdk {
     );
   }
 
+  globalVolumeAccumulatorPda(): [PublicKey, number] {
+    return globalVolumeAccumulatorPda(this.offlinePumpProgram.programId);
+  }
+
+  userVolumeAccumulatorPda(user: PublicKey): [PublicKey, number] {
+    return userVolumeAccumulatorPda(user, this.offlinePumpProgram.programId);
+  }
+
   decodeGlobal(accountInfo: AccountInfo<Buffer>): Global {
     return this.offlinePumpProgram.coder.accounts.decode<Global>(
       "global",
@@ -118,6 +133,19 @@ export class PumpSdk {
     );
   }
 
+  decodeGlobalVolumeAccumulator(accountInfo: AccountInfo<Buffer>): GlobalVolumeAccumulator {
+    return this.offlinePumpProgram.coder.accounts.decode<GlobalVolumeAccumulator>(
+      "globalVolumeAccumulator",
+      accountInfo.data,
+    );
+  }
+
+  decodeUserVolumeAccumulator(accountInfo: AccountInfo<Buffer>): UserVolumeAccumulator {
+    return this.offlinePumpProgram.coder.accounts.decode<UserVolumeAccumulator>(
+      "userVolumeAccumulator",
+      accountInfo.data,
+    );
+  }
   async fetchGlobal(): Promise<Global> {
     return await this.pumpProgram.account.global.fetch(this.globalPda());
   }
@@ -168,6 +196,18 @@ export class PumpSdk {
     return { bondingCurveAccountInfo, bondingCurve };
   }
 
+  async fetchGlobalVolumeAccumulator(): Promise<GlobalVolumeAccumulator> {
+    return await this.pumpProgram.account.globalVolumeAccumulator.fetch(
+      this.globalVolumeAccumulatorPda()[0],
+    );
+  }
+
+  async fetchUserVolumeAccumulator(user: PublicKey): Promise<UserVolumeAccumulator> {
+    return await this.pumpProgram.account.userVolumeAccumulator.fetch(
+      this.userVolumeAccumulatorPda(user)[0],
+    );
+  }
+
   async createInstruction({
     mint,
     name,
@@ -506,6 +546,66 @@ export class PumpSdk {
 
     return new BN(accountInfo.lamports - rentExemptionLamports);
   }
+
+  async adminUpdatePumpIncentives(
+    admin: PublicKey,    
+    startTime: BN,
+    endTime: BN,
+    dayNumber: BN,
+    pumpTokenSupplyPerDay: BN,
+    mint: PublicKey = PUMP_TOKEN_MINT,
+    tokenProgram: PublicKey = TOKEN_2022_PROGRAM_ID,
+  ): Promise<TransactionInstruction> {
+    return await this.offlinePumpProgram.methods
+      .updatePumpIncentives(
+        startTime,
+        endTime,
+        dayNumber.toNumber(),
+        pumpTokenSupplyPerDay,
+      )
+      .accountsPartial({
+        admin,
+        globalVolumeAccumulator: this.globalVolumeAccumulatorPda()[0],
+        globalConfig: this.globalPda(),
+        mint,
+        tokenProgram,
+      })
+      .instruction();
+  }
+
+  async claimPumpIncentives(
+    user: PublicKey,
+    payer: PublicKey,
+    mint: PublicKey = PUMP_TOKEN_MINT,
+    tokenProgram: PublicKey = TOKEN_2022_PROGRAM_ID
+  ): Promise<TransactionInstruction[]> {
+    const userPumpAta = getAssociatedTokenAddressSync(
+      mint,
+      user,
+      true,
+      tokenProgram,
+    );
+
+    return [
+      createAssociatedTokenAccountIdempotentInstruction(
+        payer,
+        userPumpAta,
+        user,
+        mint,
+        tokenProgram,
+      ),
+      await this.offlinePumpProgram.methods
+        .claimPumpIncentives()
+        .accountsPartial({          
+          user,
+          payer,
+          globalVolumeAccumulator: this.globalVolumeAccumulatorPda()[0],
+          mint,
+          tokenProgram,
+        })
+        .instruction(),
+    ];
+  } 
 }
 
 function getFeeRecipient(global: Global): PublicKey {

package/src/state.ts

@@ -30,3 +30,17 @@ export interface BondingCurve {
   complete: boolean;
   creator: PublicKey;
 }
+
+export interface GlobalVolumeAccumulator {
+  startTime: BN;
+  endTime: BN;
+  totalPumpTokenSupply: BN[];
+  solVolumes: BN[];
+}
+
+export interface UserVolumeAccumulator {
+  lastUpdateTimestamp: BN;
+  currentSolVolume: BN;
+  totalUnclaimedPumpTokens: BN;
+  totalClaimedPumpTokens: BN;
+}