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

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,79 +16,138 @@ 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";
+import {
+  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(
     pumpIdl as Pump,
-    new AnchorProvider(connection, null as any, {}),
+    new AnchorProvider(connection, null as any, {})
   );
 }
 
 export const PUMP_PROGRAM_ID = new PublicKey(
-  "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P",
+  "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",
+  "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA"
 );
 
 export const MAYHEM_PROGRAM_ID = new PublicKey(
-  "MAyhSmzXzV1pTf7LsNkrNwkWKTo4ougAJ1PPg47MD4e",
+  "MAyhSmzXzV1pTf7LsNkrNwkWKTo4ougAJ1PPg47MD4e"
 );
 
 export const PUMP_FEE_PROGRAM_ID = new PublicKey(
-  "pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ",
+  "pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ"
 );
 
 export const BONDING_CURVE_NEW_SIZE = 151;
 
 export const PUMP_TOKEN_MINT = new PublicKey(
-  "pumpCmXqMfrsAkQ5r49WcJnRayYRqmXz6ae8H7H9Dfn",
+  "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 {
     return this.offlinePumpProgram.coder.accounts.decode<Global>(
       "global",
-      accountInfo.data,
+      accountInfo.data
     );
   }
 
   decodeFeeConfig(accountInfo: AccountInfo<Buffer>): FeeConfig {
     return this.offlinePumpProgram.coder.accounts.decode<FeeConfig>(
       "feeConfig",
-      accountInfo.data,
+      accountInfo.data
     );
   }
 
   decodeBondingCurve(accountInfo: AccountInfo<Buffer>): BondingCurve {
     return this.offlinePumpProgram.coder.accounts.decode<BondingCurve>(
       "bondingCurve",
-      accountInfo.data,
+      accountInfo.data
     );
   }
 
   decodeBondingCurveNullable(
-    accountInfo: AccountInfo<Buffer>,
+    accountInfo: AccountInfo<Buffer>
   ): BondingCurve | null {
     try {
+      let data = accountInfo.data;
+      // Ensure buffer is at least 82 bytes
+      if (data.length < 82) {
+        const padded = Buffer.alloc(82);
+        data.copy(padded);
+        accountInfo = {
+          ...accountInfo,
+          data: padded,
+        };
+      }
+
       return this.decodeBondingCurve(accountInfo);
     } catch (e) {
       console.warn("Failed to decode bonding curve", e);
@@ -96,25 +156,25 @@ export class PumpSdk {
   }
 
   decodeGlobalVolumeAccumulator(
-    accountInfo: AccountInfo<Buffer>,
+    accountInfo: AccountInfo<Buffer>
   ): GlobalVolumeAccumulator {
     return this.offlinePumpProgram.coder.accounts.decode<GlobalVolumeAccumulator>(
       "globalVolumeAccumulator",
-      accountInfo.data,
+      accountInfo.data
     );
   }
 
   decodeUserVolumeAccumulator(
-    accountInfo: AccountInfo<Buffer>,
+    accountInfo: AccountInfo<Buffer>
   ): UserVolumeAccumulator {
     return this.offlinePumpProgram.coder.accounts.decode<UserVolumeAccumulator>(
       "userVolumeAccumulator",
-      accountInfo.data,
+      accountInfo.data
     );
   }
 
   decodeUserVolumeAccumulatorNullable(
-    accountInfo: AccountInfo<Buffer>,
+    accountInfo: AccountInfo<Buffer>
   ): UserVolumeAccumulator | null {
     try {
       return this.decodeUserVolumeAccumulator(accountInfo);
@@ -124,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.
    */
@@ -159,7 +226,7 @@ export class PumpSdk {
     uri,
     creator,
     user,
-    mayhemMode
+    mayhemMode,
   }: {
     mint: PublicKey;
     name: string;
@@ -214,11 +281,16 @@ export class PumpSdk {
         await this.extendAccountInstruction({
           account: bondingCurvePda(mint),
           user,
-        }),
+        })
       );
     }
 
-    const associatedUser = getAssociatedTokenAddressSync(mint, user, true, tokenProgram);
+    const associatedUser = getAssociatedTokenAddressSync(
+      mint,
+      user,
+      true,
+      tokenProgram
+    );
 
     if (!associatedUserAccountInfo) {
       instructions.push(
@@ -228,7 +300,7 @@ export class PumpSdk {
           user,
           mint,
           tokenProgram
-        ),
+        )
       );
     }
 
@@ -244,7 +316,7 @@ export class PumpSdk {
         slippage,
         tokenProgram,
         mayhemMode: bondingCurve.isMayhemMode,
-      }),
+      })
     );
 
     return instructions;
@@ -273,9 +345,22 @@ export class PumpSdk {
     solAmount: BN;
     mayhemMode: boolean;
   }): Promise<TransactionInstruction[]> {
-    const associatedUser = getAssociatedTokenAddressSync(mint, user, true, TOKEN_2022_PROGRAM_ID);
+    const associatedUser = getAssociatedTokenAddressSync(
+      mint,
+      user,
+      true,
+      TOKEN_2022_PROGRAM_ID
+    );
     return [
-      await this.createV2Instruction({ mint, name, symbol, uri, creator, user, mayhemMode }),
+      await this.createV2Instruction({
+        mint,
+        name,
+        symbol,
+        uri,
+        creator,
+        user,
+        mayhemMode,
+      }),
       await this.extendAccountInstruction({
         account: bondingCurvePda(mint),
         user,
@@ -285,7 +370,7 @@ export class PumpSdk {
         associatedUser,
         user,
         mint,
-        TOKEN_2022_PROGRAM_ID,
+        TOKEN_2022_PROGRAM_ID
       ),
       await this.buyInstruction({
         global,
@@ -337,7 +422,7 @@ export class PumpSdk {
         user,
         associatedUser,
         user,
-        mint,
+        mint
       ),
       await this.buyInstruction({
         global,
@@ -385,7 +470,7 @@ export class PumpSdk {
       feeRecipient: getFeeRecipient(global, mayhemMode),
       amount,
       solAmount: solAmount.add(
-        solAmount.mul(new BN(Math.floor(slippage * 10))).div(new BN(1000)),
+        solAmount.mul(new BN(Math.floor(slippage * 10))).div(new BN(1000))
       ),
       tokenProgram,
     });
@@ -401,7 +486,7 @@ export class PumpSdk {
     solAmount,
     slippage,
     tokenProgram = TOKEN_PROGRAM_ID,
-    mayhemMode = false
+    mayhemMode = false,
   }: {
     global: Global;
     bondingCurveAccountInfo: AccountInfo<Buffer>;
@@ -421,7 +506,7 @@ export class PumpSdk {
         await this.extendAccountInstruction({
           account: bondingCurvePda(mint),
           user,
-        }),
+        })
       );
     }
 
@@ -433,10 +518,10 @@ export class PumpSdk {
         feeRecipient: getFeeRecipient(global, mayhemMode),
         amount,
         solAmount: solAmount.sub(
-          solAmount.mul(new BN(Math.floor(slippage * 10))).div(new BN(1000)),
+          solAmount.mul(new BN(Math.floor(slippage * 10))).div(new BN(1000))
         ),
         tokenProgram,
-      }),
+      })
     );
 
     return instructions;
@@ -462,21 +547,36 @@ export class PumpSdk {
     withdrawAuthority,
     mint,
     user,
-    tokenProgram = TOKEN_PROGRAM_ID
+    tokenProgram = TOKEN_PROGRAM_ID,
   }: {
     withdrawAuthority: PublicKey;
     mint: PublicKey;
     user: PublicKey;
     tokenProgram: PublicKey;
   }): Promise<TransactionInstruction> {
-    const bondingCurve = bondingCurvePda(mint)
-    const associatedBondingCurve = getAssociatedTokenAddressSync(mint, bondingCurve, true, tokenProgram)
+    const bondingCurve = bondingCurvePda(mint);
+    const associatedBondingCurve = getAssociatedTokenAddressSync(
+      mint,
+      bondingCurve,
+      true,
+      tokenProgram
+    );
 
     const poolAuthority = pumpPoolAuthorityPda(mint);
-    const poolAuthorityMintAccount = getAssociatedTokenAddressSync(mint, poolAuthority, true, tokenProgram)
+    const poolAuthorityMintAccount = getAssociatedTokenAddressSync(
+      mint,
+      poolAuthority,
+      true,
+      tokenProgram
+    );
 
     const pool = canonicalPumpPoolPda(mint);
-    const poolBaseTokenAccount = getAssociatedTokenAddressSync(mint, pool, true, tokenProgram)
+    const poolBaseTokenAccount = getAssociatedTokenAddressSync(
+      mint,
+      pool,
+      true,
+      tokenProgram
+    );
     return this.offlinePumpProgram.methods
       .migrate()
       .accountsPartial({
@@ -485,13 +585,13 @@ export class PumpSdk {
         withdrawAuthority,
         associatedBondingCurve,
         poolAuthorityMintAccount,
-        poolBaseTokenAccount
+        poolBaseTokenAccount,
       })
       .instruction();
   }
 
   async syncUserVolumeAccumulator(
-    user: PublicKey,
+    user: PublicKey
   ): Promise<TransactionInstruction> {
     return await this.offlinePumpProgram.methods
       .syncUserVolumeAccumulator()
@@ -499,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,
@@ -540,7 +631,7 @@ export class PumpSdk {
   }
 
   async closeUserVolumeAccumulator(
-    user: PublicKey,
+    user: PublicKey
   ): Promise<TransactionInstruction> {
     return await this.offlinePumpProgram.methods
       .closeUserVolumeAccumulator()
@@ -567,7 +658,12 @@ export class PumpSdk {
   }): Promise<TransactionInstruction> {
     return await this.getBuyInstructionInternal({
       user,
-      associatedUser: getAssociatedTokenAddressSync(mint, user, true, tokenProgram),
+      associatedUser: getAssociatedTokenAddressSync(
+        mint,
+        user,
+        true,
+        tokenProgram
+      ),
       mint,
       creator,
       feeRecipient,
@@ -632,7 +728,7 @@ export class PumpSdk {
       feeRecipient,
       amount,
       solAmount,
-      tokenProgram
+      tokenProgram,
     });
   }
 
@@ -658,23 +754,261 @@ export class PumpSdk {
       .accountsPartial({
         feeRecipient,
         mint,
-        associatedUser: getAssociatedTokenAddressSync(mint, user, true, tokenProgram),
+        associatedUser: getAssociatedTokenAddressSync(
+          mint,
+          user,
+          true,
+          tokenProgram
+        ),
         user,
         creatorVault: creatorVaultPda(creator),
-        tokenProgram: tokenProgram
+        tokenProgram: tokenProgram,
       })
       .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);
 }