@pump-fun/pump-sdk 1.24.0 → 1.25.0-devnet.1

package/src/index.ts

@@ -1,5 +1,6 @@
 export { Pump } from "./idl/pump";
 export { default as pumpIdl } from "./idl/pump.json";
+export type { PumpFees } from "./idl/pump_fees";
 export {
   getBuyTokenAmountFromSolAmount,
   getBuySolAmountFromTokenAmount,
@@ -10,11 +11,16 @@ export {
 export * from "./pda";
 export {
   getPumpProgram,
+  getPumpAmmProgram,
+  getPumpFeeProgram,
   PUMP_PROGRAM_ID,
   PUMP_AMM_PROGRAM_ID,
+  PUMP_FEE_PROGRAM_ID,
+  MAYHEM_PROGRAM_ID,
   BONDING_CURVE_NEW_SIZE,
   PumpSdk,
   PUMP_SDK,
+  hasCoinCreatorMigratedToSharingConfig,
 } from "./sdk";
 export { OnlinePumpSdk } from "./onlineSdk";
 export {
@@ -24,5 +30,10 @@ export {
   GlobalVolumeAccumulator,
   UserVolumeAccumulator,
   UserVolumeAccumulatorTotalStats,
+  Shareholder,
+  SharingConfig,
+  DistributeCreatorFeesEvent,
+  MinimumDistributableFeeEvent,
 } from "./state";
 export { totalUnclaimedTokens, currentDayTokens } from "./tokenIncentives";
+export * from "./errors";

package/src/pda.ts

@@ -1,11 +1,13 @@
 import { PublicKey, PublicKeyInitData } from "@solana/web3.js";
 import { getAssociatedTokenAddressSync, NATIVE_MINT, TOKEN_2022_PROGRAM_ID } from "@solana/spl-token";
-import { poolPda, pumpFeePda, pumpPda } from "@pump-fun/pump-swap-sdk";
-import { MAYHEM_PROGRAM_ID, PUMP_PROGRAM_ID } from "./sdk";
+import { poolPda, pumpFeePda, pumpPda, pumpAmmPda } from "@pump-fun/pump-swap-sdk";
+import { MAYHEM_PROGRAM_ID, PUMP_PROGRAM_ID, PUMP_AMM_PROGRAM_ID, PUMP_FEE_PROGRAM_ID } from "./sdk";
 import { Buffer } from "buffer";
 
 export const GLOBAL_PDA = pumpPda([Buffer.from("global")]);
 
+export const AMM_GLOBAL_PDA = pumpAmmPda([Buffer.from("amm_global")]);
+
 export const PUMP_FEE_CONFIG_PDA = pumpFeePda([
   Buffer.from("fee_config"),
   PUMP_PROGRAM_ID.toBuffer(),
@@ -15,6 +17,22 @@ export const GLOBAL_VOLUME_ACCUMULATOR_PDA = pumpPda([
   Buffer.from("global_volume_accumulator"),
 ]);
 
+export const AMM_GLOBAL_VOLUME_ACCUMULATOR_PDA = pumpAmmPda([
+  Buffer.from("global_volume_accumulator"),
+]);
+
+
+export const PUMP_EVENT_AUTHORITY_PDA = getEventAuthorityPda(PUMP_PROGRAM_ID);
+export const PUMP_AMM_EVENT_AUTHORITY_PDA = getEventAuthorityPda(PUMP_AMM_PROGRAM_ID);
+export const PUMP_FEE_EVENT_AUTHORITY_PDA = getEventAuthorityPda(PUMP_FEE_PROGRAM_ID);
+
+export function getEventAuthorityPda(programId: PublicKey): PublicKey {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("__event_authority")],
+    programId
+  )[0];
+}
+
 export function bondingCurvePda(mint: PublicKeyInitData): PublicKey {
   return pumpPda([
     Buffer.from("bonding-curve"),
@@ -75,4 +93,18 @@ export const getTokenVaultPda = (mintPubkey: PublicKey): PublicKey => {
     true,
     TOKEN_2022_PROGRAM_ID
   );
-};
+};
+
+export const feeSharingConfigPda = (mint: PublicKey): PublicKey => {
+  return pumpFeePda([
+    Buffer.from("sharing-config"),
+    mint.toBuffer(),
+  ]);
+};
+
+export const ammCreatorVaultPda = (creator: PublicKey): PublicKey => {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("creator_vault"), creator.toBuffer()],
+    PUMP_AMM_PROGRAM_ID
+  )[0];
+};

package/src/sdk.ts

@@ -1,8 +1,9 @@
 import { AnchorProvider, Program } from "@coral-xyz/anchor";
-import { PUMP_AMM_SDK } from "@pump-fun/pump-swap-sdk";
 import {
   createAssociatedTokenAccountIdempotentInstruction,
+  ASSOCIATED_TOKEN_PROGRAM_ID,
   getAssociatedTokenAddressSync,
+  NATIVE_MINT,
   TOKEN_2022_PROGRAM_ID,
   TOKEN_PROGRAM_ID,
 } from "@solana/spl-token";
@@ -15,26 +16,36 @@ import {
 import pumpIdl from "./idl/pump.json";
 import { Pump } from "./idl/pump";
 import BN from "bn.js";
-
 import {
-  bondingCurvePda,
-  canonicalPumpPoolPda,
-  creatorVaultPda,
-  getGlobalParamsPda,
-  getMayhemStatePda,
-  getSolVaultPda,
-  getTokenVaultPda,
-  pumpPoolAuthorityPda,
-} from "./pda";
+  NoShareholdersError,
+  TooManyShareholdersError,
+  ZeroShareError,
+  ShareCalculationOverflowError,
+  InvalidShareTotalError,
+  DuplicateShareholderError,
+  PoolRequiredForGraduatedError,
+} from "./errors";
+
+import { bondingCurvePda, canonicalPumpPoolPda, creatorVaultPda, getGlobalParamsPda, getMayhemStatePda, getSolVaultPda, getTokenVaultPda, pumpPoolAuthorityPda, ammCreatorVaultPda, feeSharingConfigPda } from "./pda";
 import {
   BondingCurve,
   FeeConfig,
   Global,
   GlobalVolumeAccumulator,
   UserVolumeAccumulator,
+  Shareholder,
+  SharingConfig,
+  DistributeCreatorFeesEvent,
+  MinimumDistributableFeeEvent,
 } from "./state";
 import { getStaticRandomFeeRecipient } from "./bondingCurve";
+import { getFeeRecipient } from "./fees";
 import { OFFLINE_PUMP_PROGRAM } from "./onlineSdk";
+import PumpAmmIdl from "./idl/pump_amm.json";
+import { PumpAmm } from "./idl/pump_amm";
+import PumpFeesIdl from "./idl/pump_fees.json";
+import { PumpFees } from "./idl/pump_fees";
+import { coinCreatorVaultAtaPda, coinCreatorVaultAuthorityPda, PUMP_AMM_EVENT_AUTHORITY_PDA, pumpAmmPda } from "@pump-fun/pump-swap-sdk";
 
 export function getPumpProgram(connection: Connection): Program<Pump> {
   return new Program(
@@ -47,6 +58,22 @@ export const PUMP_PROGRAM_ID = new PublicKey(
   "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"
 );
 
+export function getPumpAmmProgram(connection: Connection): Program<PumpAmm> {
+  return new Program(
+    PumpAmmIdl as PumpAmm,
+    new AnchorProvider(connection, null as any, {}),
+  );
+}
+
+export function getPumpFeeProgram(
+    connection: Connection,
+): Program<PumpFees> {
+  return new Program(
+    PumpFeesIdl as PumpFees,
+    new AnchorProvider(connection, null as any, {}),
+  );
+}
+
 export const PUMP_AMM_PROGRAM_ID = new PublicKey(
   "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA"
 );
@@ -65,11 +92,24 @@ export const PUMP_TOKEN_MINT = new PublicKey(
   "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn"
 );
 
+export const MAX_SHAREHOLDERS = 10;
+
 export class PumpSdk {
   private readonly offlinePumpProgram: Program<Pump>;
+  private readonly offlinePumpFeeProgram: Program<PumpFees>;
+  private readonly offlinePumpAmmProgram: Program<PumpAmm>;
 
   constructor() {
     this.offlinePumpProgram = OFFLINE_PUMP_PROGRAM;
+    // Create offline programs for fee and AMM
+    this.offlinePumpFeeProgram = new Program(
+      PumpFeesIdl as PumpFees,
+      new AnchorProvider(null as any, null as any, {})
+    );
+    this.offlinePumpAmmProgram = new Program(
+      PumpAmmIdl as PumpAmm,
+      new AnchorProvider(null as any, null as any, {})
+    );
   }
 
   decodeGlobal(accountInfo: AccountInfo<Buffer>): Global {
@@ -144,6 +184,13 @@ export class PumpSdk {
     }
   }
 
+  decodeSharingConfig(accountInfo: AccountInfo<Buffer>): SharingConfig {
+    return this.offlinePumpFeeProgram.coder.accounts.decode<SharingConfig>(
+      "sharingConfig",
+      accountInfo.data,
+    );
+  }
+
   /**
    * @deprecated Use `createInstructionV2` instead.
    */
@@ -552,15 +599,6 @@ export class PumpSdk {
       .instruction();
   }
 
-  async syncUserVolumeAccumulatorBothPrograms(
-    user: PublicKey
-  ): Promise<TransactionInstruction[]> {
-    return [
-      await this.syncUserVolumeAccumulator(user),
-      await PUMP_AMM_SDK.syncUserVolumeAccumulator(user),
-    ];
-  }
-
   async setCreator({
     mint,
     setCreatorAuthority,
@@ -728,22 +766,249 @@ export class PumpSdk {
       })
       .instruction();
   }
+
+  /**
+   * Creates a fee sharing configuration for a token.
+   *
+   * @param params - Parameters for creating a fee sharing configuration
+   * @param params.creator - The creator of the token
+   * @param params.mint - The mint address of the token
+   * @param params.pool - The pool address of the token (null for ungraduated coins)
+   */
+  async createFeeSharingConfig({
+    creator,
+    mint,
+    pool,
+  }: {
+    creator: PublicKey;
+    mint: PublicKey;
+    pool: PublicKey | null;
+  }): Promise<TransactionInstruction> {
+    return await this.offlinePumpFeeProgram.methods
+      .createFeeSharingConfig()
+      .accountsPartial({
+        payer: creator,
+        mint,
+        pool,
+      })
+      .instruction();
+  }
+
+
+  /**
+   * Updates the fee shares for a token's creator fee distribution.
+   *
+   * @param params - Parameters for updating fee shares
+   * @param params.authority - The current authority that can modify the fee sharing config
+   * @param params.mint - The mint address of the token
+   * @param params.curShareholders - Array of current shareholders
+   * @param params.newShareholders - Array of new shareholders and their share percentages
+   *
+   * @requirements for newShareholders:
+   * - Must contain at least 1 shareholder (cannot be empty)
+   * - Maximum of 10 shareholders allowed
+   * - Each shareholder must have a positive share (shareBps > 0)
+   * - Total shares must equal exactly 10,000 basis points (100%)
+   * - No duplicate addresses allowed
+   * - shareBps is in basis points where 1 bps = 0.01% (e.g., 1500 = 15%)
+   *
+   * @throws {NoShareholdersError} If shareholders array is empty
+   * @throws {TooManyShareholdersError} If more than 10 shareholders
+   * @throws {ZeroShareError} If any shareholder has zero or negative shares
+   * @throws {InvalidShareTotalError} If total shares don't equal 10,000 basis points
+   * @throws {DuplicateShareholderError} If duplicate addresses are found
+   *
+   * @example
+   * ```typescript
+   * const instruction = await PUMP_SDK.updateFeeShares({
+   *   authority: authorityPublicKey,
+   *   mint: mintPublicKey,
+   *   curShareholders: [wallet1, wallet2, wallet3],
+   *   newShareholders: [
+   *     { address: wallet1, shareBps: 5000 }, // 50%
+   *     { address: wallet2, shareBps: 3000 }, // 30%
+   *     { address: wallet3, shareBps: 2000 }, // 20%
+   *   ]
+   * });
+   * ```
+   */
+  async updateFeeShares({
+    authority,
+    mint,
+    currentShareholders,
+    newShareholders,
+  }: {
+    authority: PublicKey;
+    mint: PublicKey;
+    currentShareholders: PublicKey[];
+    newShareholders: Shareholder[];
+  }): Promise<TransactionInstruction> {
+    if (newShareholders.length === 0) {
+      throw new NoShareholdersError();
+    }
+
+    if (newShareholders.length > MAX_SHAREHOLDERS) {
+      throw new TooManyShareholdersError(newShareholders.length, MAX_SHAREHOLDERS);
+    }
+
+    let totalShares = 0;
+    const addresses = new Set<string>();
+
+    for (const shareholder of newShareholders) {
+      if (shareholder.shareBps <= 0) {
+        throw new ZeroShareError(shareholder.address.toString());
+      }
+
+      totalShares += shareholder.shareBps;
+      addresses.add(shareholder.address.toString());
+    }
+
+    if (totalShares !== 10_000) {
+      throw new InvalidShareTotalError(totalShares);
+    }
+
+    if (addresses.size !== newShareholders.length) {
+      throw new DuplicateShareholderError();
+    }
+
+    const sharingConfigPda = feeSharingConfigPda(mint);
+    const coinCreatorVaultAuthority = coinCreatorVaultAuthorityPda(sharingConfigPda);
+
+    return await this.offlinePumpFeeProgram.methods
+      .updateFeeShares(
+        newShareholders.map(sh => ({
+          address: sh.address,
+          shareBps: sh.shareBps,
+        }))
+      )
+      .accountsPartial({
+        authority,
+        mint,
+        coinCreatorVaultAta: coinCreatorVaultAtaPda(coinCreatorVaultAuthority, NATIVE_MINT, TOKEN_PROGRAM_ID),
+      })
+      .remainingAccounts(
+        currentShareholders.map((pubkey) => ({
+          pubkey,
+          isWritable: true,
+          isSigner: false,
+        }))
+      )
+      .instruction();
+  }
+
+  decodeDistributeCreatorFeesEvent(data: Buffer): DistributeCreatorFeesEvent {
+    return this.offlinePumpProgram.coder.types.decode<DistributeCreatorFeesEvent>(
+      "distributeCreatorFeesEvent",
+      data
+    );
+  }
+
+  async distributeCreatorFees({
+    mint,
+    sharingConfig,
+    sharingConfigAddress,
+  }: {
+    mint: PublicKey;
+    sharingConfig: SharingConfig;
+    sharingConfigAddress: PublicKey;
+  }): Promise<TransactionInstruction> {
+    return await this.offlinePumpProgram.methods
+      .distributeCreatorFees()
+      .accountsPartial({
+        mint,
+        creatorVault: creatorVaultPda(sharingConfigAddress),
+      })
+      .remainingAccounts(
+        sharingConfig.shareholders.map((shareholder) => ({
+          pubkey: shareholder.address,
+          isWritable: true,
+          isSigner: false,
+        }))
+      )
+      .instruction();
+  }
+
+  decodeMinimumDistributableFee(data: Buffer): MinimumDistributableFeeEvent {
+    return this.offlinePumpProgram.coder.types.decode<MinimumDistributableFeeEvent>(
+      "minimumDistributableFeeEvent",
+      data
+    );
+  }
+
+  async getMinimumDistributableFee({
+    mint,
+    sharingConfig,
+    sharingConfigAddress,
+  }: {
+    mint: PublicKey;
+    sharingConfig: SharingConfig;
+    sharingConfigAddress: PublicKey;
+  }): Promise<TransactionInstruction> {
+    return await this.offlinePumpProgram.methods
+      .getMinimumDistributableFee()
+      .accountsPartial({
+        mint,
+        creatorVault: creatorVaultPda(sharingConfigAddress),
+      })
+      .remainingAccounts(
+        sharingConfig.shareholders.map((shareholder) => ({
+          pubkey: shareholder.address,
+          isWritable: true,
+          isSigner: false,
+        }))
+      )
+      .instruction();
+  }
 }
 
 export const PUMP_SDK = new PumpSdk();
 
-export function getFeeRecipient(
-  global: Global,
-  mayhemMode: boolean
-): PublicKey {
-  if (mayhemMode) {
-    const feeRecipients = [
-      global.reservedFeeRecipient,
-      ...global.reservedFeeRecipients,
-    ];
-    return feeRecipients[Math.floor(Math.random() * feeRecipients.length)];
-  } else {
-    const feeRecipients = [global.feeRecipient, ...global.feeRecipients];
-    return feeRecipients[Math.floor(Math.random() * feeRecipients.length)];
-  }
+/**
+ * Checks if a creator has migrated to using a fee sharing configuration.
+ *
+ * When a creator sets up fee sharing, the creator address in the BondingCurve or Pool
+ * is replaced with the fee sharing config PDA address. This function checks if that
+ * migration has occurred.
+ *
+ * @param params - Parameters for checking migration status
+ * @param params.mint - The mint address of the token
+ * @param params.creator - The creator address to check
+ *                         - For ungraduated coins: use BondingCurve.creator
+ *                         - For graduated coins: use Pool.coinCreator (from AMM pool)
+ *
+ * @returns true if the creator has migrated to fee sharing config, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { hasCoinCreatorMigratedToSharingConfig } from "@pump-fun/sdk";
+ *
+ * // For an ungraduated coin
+ * const bondingCurve = await program.account.bondingCurve.fetch(bondingCurvePda(mint));
+ * const hasMigrated = hasCoinCreatorMigratedToSharingConfig({
+ *   mint,
+ *   creator: bondingCurve.creator
+ * });
+ *
+ * // For a graduated coin
+ * const pool = await ammProgram.account.pool.fetch(poolAddress);
+ * const hasMigrated = hasCoinCreatorMigratedToSharingConfig({
+ *   mint,
+ *   creator: pool.coinCreator
+ * });
+ *
+ * if (hasMigrated) {
+ *   // Creator fees are distributed according to fee sharing config
+ * } else {
+ *   // Creator fees go directly to the creator address
+ * }
+ * ```
+ */
+export function hasCoinCreatorMigratedToSharingConfig({
+  mint,
+  creator,
+}: {
+  mint: PublicKey;
+  creator: PublicKey;
+}): boolean {
+  return feeSharingConfigPda(mint).equals(creator);
 }

package/src/state.ts

@@ -77,3 +77,31 @@ export interface Fees {
   protocolFeeBps: BN;
   creatorFeeBps: BN;
 }
+
+export interface Shareholder {
+  address: PublicKey;
+  shareBps: number;
+}
+
+export interface SharingConfig {
+  version: number;
+  mint: PublicKey;
+  admin: PublicKey;
+  adminRevoked: boolean;
+  shareholders: Shareholder[];
+}
+
+export interface DistributeCreatorFeesEvent {
+  timestamp: BN;
+  mint: PublicKey;
+  sharingConfig: PublicKey;
+  admin: PublicKey;
+  shareholders: Shareholder[];
+  distributed: BN;
+}
+
+export interface MinimumDistributableFeeEvent {
+  minimumRequired: BN;
+  distributableFees: BN;
+  canDistribute: boolean;
+}