@pump-fun/pump-sdk 1.3.8-devnet.1 → 1.4.0-devnet.1

package/src/sdk.ts

@@ -2,7 +2,6 @@ import { AnchorProvider, Program } from "@coral-xyz/anchor";
 import { PumpAmmSdk } from "@pump-fun/pump-swap-sdk";
 import {
   createAssociatedTokenAccountIdempotentInstruction,
-  getAccount,
   getAssociatedTokenAddressSync,
 } from "@solana/spl-token";
 import {
@@ -115,14 +114,61 @@ export class PumpSdk {
     );
   }
 
-  async createInstruction(
-    mint: PublicKey,
-    name: string,
-    symbol: string,
-    uri: string,
-    creator: PublicKey,
-    user: PublicKey,
-  ): Promise<TransactionInstruction> {
+  async fetchBuyState(mint: PublicKey, user: PublicKey) {
+    const [bondingCurveAccountInfo, associatedUserAccountInfo] =
+      await this.connection.getMultipleAccountsInfo([
+        this.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([
+        this.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 createInstruction({
+    mint,
+    name,
+    symbol,
+    uri,
+    creator,
+    user,
+  }: {
+    mint: PublicKey;
+    name: string;
+    symbol: string;
+    uri: string;
+    creator: PublicKey;
+    user: PublicKey;
+  }): Promise<TransactionInstruction> {
     return await this.pumpProgram.methods
       .create(name, symbol, uri, creator)
       .accountsPartial({
@@ -132,144 +178,208 @@ export class PumpSdk {
       .instruction();
   }
 
-  async buyInstructions(
-    global: Global,
-    bondingCurveAccountInfo: AccountInfo<Buffer> | null,
-    bondingCurve: BondingCurve,
-    mint: PublicKey,
-    user: PublicKey,
-    amount: BN,
-    solAmount: BN,
-    slippage: number,
-    newCoinCreator: PublicKey,
-  ): Promise<TransactionInstruction[]> {
-    return this.withFixBondingCurve(
-      mint,
-      bondingCurveAccountInfo,
-      user,
-      async () => {
-        const instructions: TransactionInstruction[] = [];
+  async buyInstructions({
+    global,
+    bondingCurveAccountInfo,
+    bondingCurve,
+    associatedUserAccountInfo,
+    mint,
+    user,
+    amount,
+    solAmount,
+    slippage,
+  }: {
+    global: Global;
+    bondingCurveAccountInfo: AccountInfo<Buffer>;
+    bondingCurve: BondingCurve;
+    associatedUserAccountInfo: AccountInfo<Buffer> | null;
+    mint: PublicKey;
+    user: PublicKey;
+    amount: BN;
+    solAmount: BN;
+    slippage: number;
+  }): Promise<TransactionInstruction[]> {
+    const instructions: TransactionInstruction[] = [];
+
+    if (bondingCurveAccountInfo.data.length < BONDING_CURVE_NEW_SIZE) {
+      instructions.push(
+        await this.extendAccountInstruction({
+          account: this.bondingCurvePda(mint),
+          user,
+        }),
+      );
+    }
 
-        const associatedUser = getAssociatedTokenAddressSync(mint, user, true);
+    const associatedUser = getAssociatedTokenAddressSync(mint, user, true);
 
-        const userTokenAccount = await getAccount(
-          this.connection,
+    if (!associatedUserAccountInfo) {
+      instructions.push(
+        createAssociatedTokenAccountIdempotentInstruction(
+          user,
           associatedUser,
-        ).catch((e) => null);
-
-        // if user account doesn't exist add an instruction to create it
-        if (!userTokenAccount) {
-          instructions.push(
-            createAssociatedTokenAccountIdempotentInstruction(
-              user,
-              associatedUser,
-              user,
-              mint,
-            ),
-          );
-        }
-
-        instructions.push(
-          await this.pumpProgram.methods
-            .buy(
-              amount,
-              solAmount.add(
-                solAmount
-                  .mul(new BN(Math.floor(slippage * 10)))
-                  .div(new BN(1000)),
-              ),
-            )
-            .accountsPartial({
-              feeRecipient: getFeeRecipient(global),
-              mint,
-              associatedUser,
-              user,
-              creatorVault: this.creatorVaultPda(
-                bondingCurveAccountInfo === null
-                  ? newCoinCreator
-                  : bondingCurve.creator,
-              ),
-            })
-            .instruction(),
-        );
-
-        return instructions;
-      },
+          user,
+          mint,
+        ),
+      );
+    }
+
+    instructions.push(
+      await this.buyInstruction({
+        global,
+        mint,
+        creator: bondingCurve.creator,
+        user,
+        associatedUser,
+        amount,
+        solAmount,
+        slippage,
+      }),
     );
+
+    return instructions;
   }
 
-  async sellInstructions(
-    global: Global,
-    bondingCurveAccountInfo: AccountInfo<Buffer> | null,
-    mint: PublicKey,
-    user: PublicKey,
-    amount: BN,
-    solAmount: BN,
-    slippage: number,
-  ): Promise<TransactionInstruction[]> {
-    return this.withFixBondingCurve(
-      mint,
-      bondingCurveAccountInfo,
-      user,
-      async () => {
-        return [
-          await this.pumpProgram.methods
-            .sell(
-              amount,
-              solAmount.sub(
-                solAmount
-                  .mul(new BN(Math.floor(slippage * 10)))
-                  .div(new BN(1000)),
-              ),
-            )
-            .accountsPartial({
-              feeRecipient: getFeeRecipient(global),
-              mint,
-              associatedUser: getAssociatedTokenAddressSync(mint, user, true),
-              user,
-            })
-            .instruction(),
-        ];
-      },
-    );
+  async createAndBuyInstructions({
+    global,
+    mint,
+    name,
+    symbol,
+    uri,
+    creator,
+    user,
+    amount,
+    solAmount,
+  }: {
+    global: Global;
+    mint: PublicKey;
+    name: string;
+    symbol: string;
+    uri: string;
+    creator: PublicKey;
+    user: PublicKey;
+    amount: BN;
+    solAmount: BN;
+  }): Promise<TransactionInstruction[]> {
+    const associatedUser = getAssociatedTokenAddressSync(mint, user, true);
+    return [
+      await this.createInstruction({ mint, name, symbol, uri, creator, user }),
+      await this.extendAccountInstruction({
+        account: this.bondingCurvePda(mint),
+        user,
+      }),
+      createAssociatedTokenAccountIdempotentInstruction(
+        user,
+        associatedUser,
+        user,
+        mint,
+      ),
+      await this.buyInstruction({
+        global,
+        mint,
+        creator,
+        user,
+        associatedUser,
+        amount,
+        solAmount,
+        slippage: 1,
+      }),
+    ];
   }
 
-  async fixExistingBondingCurve(
-    mint: PublicKey,
-    bondingCurveAccountInfo: AccountInfo<Buffer> | null,
-    user: PublicKey,
-  ): Promise<TransactionInstruction[]> {
-    return this.withFixBondingCurve(
-      mint,
-      bondingCurveAccountInfo,
-      user,
-      async () => [],
-    );
+  private async buyInstruction({
+    global,
+    mint,
+    creator,
+    user,
+    associatedUser,
+    amount,
+    solAmount,
+    slippage,
+  }: {
+    global: Global;
+    mint: PublicKey;
+    creator: PublicKey;
+    user: PublicKey;
+    associatedUser: PublicKey;
+    amount: BN;
+    solAmount: BN;
+    slippage: number;
+  }) {
+    return await this.pumpProgram.methods
+      .buy(
+        amount,
+        solAmount.add(
+          solAmount.mul(new BN(Math.floor(slippage * 10))).div(new BN(1000)),
+        ),
+      )
+      .accountsPartial({
+        feeRecipient: getFeeRecipient(global),
+        mint,
+        associatedUser,
+        user,
+        creatorVault: this.creatorVaultPda(creator),
+      })
+      .instruction();
   }
 
-  private async withFixBondingCurve(
-    mint: PublicKey,
-    bondingCurveAccountInfo: AccountInfo<Buffer> | null,
-    user: PublicKey,
-    block: () => Promise<TransactionInstruction[]>,
-  ): Promise<TransactionInstruction[]> {
-    if (
-      bondingCurveAccountInfo === null ||
-      bondingCurveAccountInfo.data.length < BONDING_CURVE_NEW_SIZE
-    ) {
-      return [
-        await this.extendAccount(this.bondingCurvePda(mint), user),
-        ...(await block()),
-      ];
+  async sellInstructions({
+    global,
+    bondingCurveAccountInfo,
+    bondingCurve,
+    mint,
+    user,
+    amount,
+    solAmount,
+    slippage,
+  }: {
+    global: Global;
+    bondingCurveAccountInfo: AccountInfo<Buffer>;
+    bondingCurve: BondingCurve;
+    mint: PublicKey;
+    user: PublicKey;
+    amount: BN;
+    solAmount: BN;
+    slippage: number;
+  }): Promise<TransactionInstruction[]> {
+    const instructions: TransactionInstruction[] = [];
+
+    if (bondingCurveAccountInfo.data.length < BONDING_CURVE_NEW_SIZE) {
+      instructions.push(
+        await this.extendAccountInstruction({
+          account: this.bondingCurvePda(mint),
+          user,
+        }),
+      );
     }
 
-    return await block();
+    instructions.push(
+      await this.pumpProgram.methods
+        .sell(
+          amount,
+          solAmount.sub(
+            solAmount.mul(new BN(Math.floor(slippage * 10))).div(new BN(1000)),
+          ),
+        )
+        .accountsPartial({
+          feeRecipient: getFeeRecipient(global),
+          mint,
+          associatedUser: getAssociatedTokenAddressSync(mint, user, true),
+          user,
+          creatorVault: this.creatorVaultPda(bondingCurve.creator),
+        })
+        .instruction(),
+    );
+
+    return instructions;
   }
 
-  async extendAccount(
-    account: PublicKey,
-    user: PublicKey,
-  ): Promise<TransactionInstruction> {
+  async extendAccountInstruction({
+    account,
+    user,
+  }: {
+    account: PublicKey;
+    user: PublicKey;
+  }): Promise<TransactionInstruction> {
     return this.pumpProgram.methods
       .extendAccount()
       .accountsPartial({
@@ -279,15 +389,22 @@ export class PumpSdk {
       .instruction();
   }
 
-  async migrateInstruction(
-    mint: PublicKey,
-    user: PublicKey,
-  ): Promise<TransactionInstruction> {
+  async migrateInstruction({
+    global,
+    mint,
+    user,
+  }: {
+    global: Global;
+    mint: PublicKey;
+    user: PublicKey;
+  }): Promise<TransactionInstruction> {
     return this.pumpProgram.methods
       .migrate()
       .accountsPartial({
         mint,
         user,
+        pumpAmm: this.pumpAmmSdk.programId(),
+        withdrawAuthority: global.withdrawAuthority,
       })
       .instruction();
   }

package/src/bondingCurve.spec.ts

@@ -1,65 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import BN from "bn.js";
-import {
-  getBuySolAmountFromTokenAmount,
-  getBuyTokenAmountFromSolAmount,
-} from "./bondingCurve";
-
-describe("tests", () => {
-  let initialVirtualTokenReserves = new BN(1_073_000_000_000_000);
-  let initialVirtualSolReserves = new BN(30_000_000_000);
-  let initialRealTokenReserves = new BN(793_100_000_000_000);
-  let initialRealSolReserves = new BN(0);
-  let tokenTotalSupply = new BN(1_000_000_000_000_000);
-
-  const global = {
-    initialized: true,
-    authority: PublicKey.default,
-    feeRecipient: PublicKey.default,
-    initialVirtualTokenReserves,
-    initialVirtualSolReserves,
-    initialRealTokenReserves,
-    tokenTotalSupply,
-    feeBasisPoints: new BN(95),
-    withdrawAuthority: PublicKey.default,
-    enableMigrate: true,
-    poolMigrationFee: new BN(0),
-    creatorFeeBasisPoints: new BN(5),
-    feeRecipients: [],
-  };
-
-  const bondingCurve = {
-    creator: PublicKey.default,
-    virtualTokenReserves: initialVirtualTokenReserves,
-    virtualSolReserves: initialVirtualSolReserves,
-    realTokenReserves: initialRealTokenReserves,
-    realSolReserves: initialRealSolReserves,
-    tokenTotalSupply: tokenTotalSupply,
-    complete: true,
-  };
-
-  let solAmount = new BN(10_000_000);
-  let tokenAmount = new BN(354_008_574_488);
-
-  it("getBuyTokenAmountFromSolAmount", () => {
-    const result = getBuyTokenAmountFromSolAmount(
-      global,
-      bondingCurve,
-      solAmount,
-      true,
-    );
-
-    expect(result.toString()).toBe(tokenAmount.toString());
-  });
-
-  it("getBuySolAmountFromTokenAmount", () => {
-    const result = getBuySolAmountFromTokenAmount(
-      global,
-      bondingCurve,
-      tokenAmount,
-      true,
-    );
-
-    expect(result.toString()).toBe(solAmount.addn(1).toString());
-  });
-});