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

package/dist/index.js

@@ -43,6 +43,7 @@ __export(index_exports, {
   getPumpProgram: () => getPumpProgram,
   getSellSolAmountFromTokenAmount: () => getSellSolAmountFromTokenAmount,
   globalPda: () => globalPda,
+  newBondingCurve: () => newBondingCurve,
   pumpIdl: () => pump_default,
   pumpPoolAuthorityPda: () => pumpPoolAuthorityPda
 });
@@ -2684,9 +2685,9 @@ var pump_default = {
 // src/bondingCurve.ts
 var import_web3 = require("@solana/web3.js");
 var import_bn = __toESM(require("bn.js"));
-function getFee(global, bondingCurve, amount, newCoin) {
+function getFee(global, bondingCurve, amount, isNewBondingCurve) {
   return computeFee(amount, global.feeBasisPoints).add(
-    newCoin || !import_web3.PublicKey.default.equals(bondingCurve.creator) ? computeFee(amount, global.creatorFeeBasisPoints) : new import_bn.default(0)
+    isNewBondingCurve || !import_web3.PublicKey.default.equals(bondingCurve.creator) ? computeFee(amount, global.creatorFeeBasisPoints) : new import_bn.default(0)
   );
 }
 function computeFee(amount, feeBasisPoints) {
@@ -2695,30 +2696,51 @@ function computeFee(amount, feeBasisPoints) {
 function ceilDiv(a, b) {
   return a.add(b.subn(1)).div(b);
 }
-function getBuyTokenAmountFromSolAmount(global, bondingCurve, amount, newCoin) {
+function newBondingCurve(global) {
+  return {
+    virtualTokenReserves: global.initialVirtualTokenReserves,
+    virtualSolReserves: global.initialVirtualSolReserves,
+    realTokenReserves: global.initialRealTokenReserves,
+    realSolReserves: new import_bn.default(0),
+    tokenTotalSupply: global.tokenTotalSupply,
+    complete: false,
+    creator: import_web3.PublicKey.default
+  };
+}
+function getBuyTokenAmountFromSolAmount(global, bondingCurve, amount) {
   if (amount.eq(new import_bn.default(0))) {
     return new import_bn.default(0);
   }
+  let isNewBondingCurve = false;
+  if (bondingCurve === null) {
+    bondingCurve = newBondingCurve(global);
+    isNewBondingCurve = true;
+  }
   if (bondingCurve.virtualTokenReserves.eq(new import_bn.default(0))) {
     return new import_bn.default(0);
   }
   const totalFeeBasisPoints = global.feeBasisPoints.add(
-    newCoin || !import_web3.PublicKey.default.equals(bondingCurve.creator) ? global.creatorFeeBasisPoints : new import_bn.default(0)
+    isNewBondingCurve || !import_web3.PublicKey.default.equals(bondingCurve.creator) ? global.creatorFeeBasisPoints : new import_bn.default(0)
   );
   const inputAmount = amount.muln(1e4).div(totalFeeBasisPoints.addn(1e4));
   const tokensReceived = inputAmount.mul(bondingCurve.virtualTokenReserves).div(bondingCurve.virtualSolReserves.add(inputAmount));
   return import_bn.default.min(tokensReceived, bondingCurve.realTokenReserves);
 }
-function getBuySolAmountFromTokenAmount(global, bondingCurve, amount, newCoin) {
+function getBuySolAmountFromTokenAmount(global, bondingCurve, amount) {
   if (amount.eq(new import_bn.default(0))) {
     return new import_bn.default(0);
   }
+  let isNewBondingCurve = false;
+  if (bondingCurve === null) {
+    bondingCurve = newBondingCurve(global);
+    isNewBondingCurve = true;
+  }
   if (bondingCurve.virtualTokenReserves.eq(new import_bn.default(0))) {
     return new import_bn.default(0);
   }
   const minAmount = import_bn.default.min(amount, bondingCurve.realTokenReserves);
   const solCost = minAmount.mul(bondingCurve.virtualSolReserves).div(bondingCurve.virtualTokenReserves.sub(minAmount)).add(new import_bn.default(1));
-  return solCost.add(getFee(global, bondingCurve, solCost, newCoin));
+  return solCost.add(getFee(global, bondingCurve, solCost, isNewBondingCurve));
 }
 function getSellSolAmountFromTokenAmount(global, bondingCurve, amount) {
   if (amount.eq(new import_bn.default(0))) {
@@ -2843,103 +2865,208 @@ var PumpSdk = class {
       this.bondingCurvePda(mint)
     );
   }
-  async createInstruction(mint, name, symbol, uri, creator, user) {
+  async fetchBuyState(mint, user) {
+    const [bondingCurveAccountInfo, associatedUserAccountInfo] = await this.connection.getMultipleAccountsInfo([
+      this.bondingCurvePda(mint),
+      (0, import_spl_token2.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, user) {
+    const [bondingCurveAccountInfo, associatedUserAccountInfo] = await this.connection.getMultipleAccountsInfo([
+      this.bondingCurvePda(mint),
+      (0, import_spl_token2.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
+  }) {
     return await this.pumpProgram.methods.create(name, symbol, uri, creator).accountsPartial({
       mint,
       user
     }).instruction();
   }
-  async buyInstructions(global, bondingCurveAccountInfo, bondingCurve, mint, user, amount, solAmount, slippage, newCoinCreator) {
-    return this.withFixBondingCurve(
-      mint,
-      bondingCurveAccountInfo,
-      user,
-      async () => {
-        const instructions = [];
-        const associatedUser = (0, import_spl_token2.getAssociatedTokenAddressSync)(mint, user, true);
-        const userTokenAccount = await (0, import_spl_token2.getAccount)(
-          this.connection,
-          associatedUser
-        ).catch((e) => null);
-        if (!userTokenAccount) {
-          instructions.push(
-            (0, import_spl_token2.createAssociatedTokenAccountIdempotentInstruction)(
-              user,
-              associatedUser,
-              user,
-              mint
-            )
-          );
-        }
-        instructions.push(
-          await this.pumpProgram.methods.buy(
-            amount,
-            solAmount.add(
-              solAmount.mul(new import_bn2.default(Math.floor(slippage * 10))).div(new import_bn2.default(1e3))
-            )
-          ).accountsPartial({
-            feeRecipient: getFeeRecipient(global),
-            mint,
-            associatedUser,
-            user,
-            creatorVault: this.creatorVaultPda(
-              bondingCurveAccountInfo === null ? newCoinCreator : bondingCurve.creator
-            )
-          }).instruction()
-        );
-        return instructions;
-      }
+  async buyInstructions({
+    global,
+    bondingCurveAccountInfo,
+    bondingCurve,
+    associatedUserAccountInfo,
+    mint,
+    user,
+    amount,
+    solAmount,
+    slippage
+  }) {
+    const instructions = [];
+    if (bondingCurveAccountInfo.data.length < BONDING_CURVE_NEW_SIZE) {
+      instructions.push(
+        await this.extendAccountInstruction({
+          account: this.bondingCurvePda(mint),
+          user
+        })
+      );
+    }
+    const associatedUser = (0, import_spl_token2.getAssociatedTokenAddressSync)(mint, user, true);
+    if (!associatedUserAccountInfo) {
+      instructions.push(
+        (0, import_spl_token2.createAssociatedTokenAccountIdempotentInstruction)(
+          user,
+          associatedUser,
+          user,
+          mint
+        )
+      );
+    }
+    instructions.push(
+      await this.buyInstruction({
+        global,
+        mint,
+        creator: bondingCurve.creator,
+        user,
+        associatedUser,
+        amount,
+        solAmount,
+        slippage
+      })
     );
+    return instructions;
   }
-  async sellInstructions(global, bondingCurveAccountInfo, mint, user, amount, solAmount, slippage) {
-    return this.withFixBondingCurve(
-      mint,
-      bondingCurveAccountInfo,
-      user,
-      async () => {
-        return [
-          await this.pumpProgram.methods.sell(
-            amount,
-            solAmount.sub(
-              solAmount.mul(new import_bn2.default(Math.floor(slippage * 10))).div(new import_bn2.default(1e3))
-            )
-          ).accountsPartial({
-            feeRecipient: getFeeRecipient(global),
-            mint,
-            associatedUser: (0, import_spl_token2.getAssociatedTokenAddressSync)(mint, user, true),
-            user
-          }).instruction()
-        ];
-      }
-    );
+  async createAndBuyInstructions({
+    global,
+    mint,
+    name,
+    symbol,
+    uri,
+    creator,
+    user,
+    amount,
+    solAmount
+  }) {
+    const associatedUser = (0, import_spl_token2.getAssociatedTokenAddressSync)(mint, user, true);
+    return [
+      await this.createInstruction({ mint, name, symbol, uri, creator, user }),
+      await this.extendAccountInstruction({
+        account: this.bondingCurvePda(mint),
+        user
+      }),
+      (0, import_spl_token2.createAssociatedTokenAccountIdempotentInstruction)(
+        user,
+        associatedUser,
+        user,
+        mint
+      ),
+      await this.buyInstruction({
+        global,
+        mint,
+        creator,
+        user,
+        associatedUser,
+        amount,
+        solAmount,
+        slippage: 1
+      })
+    ];
   }
-  async fixExistingBondingCurve(mint, bondingCurveAccountInfo, user) {
-    return this.withFixBondingCurve(
+  async buyInstruction({
+    global,
+    mint,
+    creator,
+    user,
+    associatedUser,
+    amount,
+    solAmount,
+    slippage
+  }) {
+    return await this.pumpProgram.methods.buy(
+      amount,
+      solAmount.add(
+        solAmount.mul(new import_bn2.default(Math.floor(slippage * 10))).div(new import_bn2.default(1e3))
+      )
+    ).accountsPartial({
+      feeRecipient: getFeeRecipient(global),
       mint,
-      bondingCurveAccountInfo,
+      associatedUser,
       user,
-      async () => []
-    );
+      creatorVault: this.creatorVaultPda(creator)
+    }).instruction();
   }
-  async withFixBondingCurve(mint, bondingCurveAccountInfo, user, block) {
-    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
+  }) {
+    const instructions = [];
+    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 import_bn2.default(Math.floor(slippage * 10))).div(new import_bn2.default(1e3))
+        )
+      ).accountsPartial({
+        feeRecipient: getFeeRecipient(global),
+        mint,
+        associatedUser: (0, import_spl_token2.getAssociatedTokenAddressSync)(mint, user, true),
+        user,
+        creatorVault: this.creatorVaultPda(bondingCurve.creator)
+      }).instruction()
+    );
+    return instructions;
   }
-  async extendAccount(account, user) {
+  async extendAccountInstruction({
+    account,
+    user
+  }) {
     return this.pumpProgram.methods.extendAccount().accountsPartial({
       account,
       user
     }).instruction();
   }
-  async migrateInstruction(mint, user) {
+  async migrateInstruction({
+    global,
+    mint,
+    user
+  }) {
     return this.pumpProgram.methods.migrate().accountsPartial({
       mint,
-      user
+      user,
+      pumpAmm: this.pumpAmmSdk.programId(),
+      withdrawAuthority: global.withdrawAuthority
     }).instruction();
   }
   async collectCoinCreatorFeeInstructions(coinCreator) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pump-fun/pump-sdk",
-  "version": "1.3.8-devnet.1",
+  "version": "1.4.0-devnet.1",
   "description": "Pump Bonding Curve SDK",
   "keywords": [],
   "homepage": "https://github.com/pump-fun/pump-sdk#readme",

package/src/bondingCurve.ts

@@ -6,10 +6,10 @@ function getFee(
   global: Global,
   bondingCurve: BondingCurve,
   amount: BN,
-  newCoin: boolean,
+  isNewBondingCurve: boolean,
 ): BN {
   return computeFee(amount, global.feeBasisPoints).add(
-    newCoin || !PublicKey.default.equals(bondingCurve.creator)
+    isNewBondingCurve || !PublicKey.default.equals(bondingCurve.creator)
       ? computeFee(amount, global.creatorFeeBasisPoints)
       : new BN(0),
   );
@@ -23,23 +23,41 @@ function ceilDiv(a: BN, b: BN): BN {
   return a.add(b.subn(1)).div(b);
 }
 
+export function newBondingCurve(global: Global): BondingCurve {
+  return {
+    virtualTokenReserves: global.initialVirtualTokenReserves,
+    virtualSolReserves: global.initialVirtualSolReserves,
+    realTokenReserves: global.initialRealTokenReserves,
+    realSolReserves: new BN(0),
+    tokenTotalSupply: global.tokenTotalSupply,
+    complete: false,
+    creator: PublicKey.default,
+  };
+}
+
 export function getBuyTokenAmountFromSolAmount(
   global: Global,
-  bondingCurve: BondingCurve,
+  bondingCurve: BondingCurve | null,
   amount: BN,
-  newCoin: boolean,
 ): BN {
   if (amount.eq(new BN(0))) {
     return new BN(0);
   }
 
+  let isNewBondingCurve = false;
+
+  if (bondingCurve === null) {
+    bondingCurve = newBondingCurve(global);
+    isNewBondingCurve = true;
+  }
+
   // migrated bonding curve
   if (bondingCurve.virtualTokenReserves.eq(new BN(0))) {
     return new BN(0);
   }
 
   const totalFeeBasisPoints = global.feeBasisPoints.add(
-    newCoin || !PublicKey.default.equals(bondingCurve.creator)
+    isNewBondingCurve || !PublicKey.default.equals(bondingCurve.creator)
       ? global.creatorFeeBasisPoints
       : new BN(0),
   );
@@ -55,14 +73,20 @@ export function getBuyTokenAmountFromSolAmount(
 
 export function getBuySolAmountFromTokenAmount(
   global: Global,
-  bondingCurve: BondingCurve,
+  bondingCurve: BondingCurve | null,
   amount: BN,
-  newCoin: boolean,
 ): BN {
   if (amount.eq(new BN(0))) {
     return new BN(0);
   }
 
+  let isNewBondingCurve = false;
+
+  if (bondingCurve === null) {
+    bondingCurve = newBondingCurve(global);
+    isNewBondingCurve = true;
+  }
+
   // migrated bonding curve
   if (bondingCurve.virtualTokenReserves.eq(new BN(0))) {
     return new BN(0);
@@ -75,7 +99,7 @@ export function getBuySolAmountFromTokenAmount(
     .div(bondingCurve.virtualTokenReserves.sub(minAmount))
     .add(new BN(1));
 
-  return solCost.add(getFee(global, bondingCurve, solCost, newCoin));
+  return solCost.add(getFee(global, bondingCurve, solCost, isNewBondingCurve));
 }
 
 export function getSellSolAmountFromTokenAmount(

package/src/index.ts

@@ -4,6 +4,7 @@ export {
   getBuyTokenAmountFromSolAmount,
   getBuySolAmountFromTokenAmount,
   getSellSolAmountFromTokenAmount,
+  newBondingCurve,
 } from "./bondingCurve";
 export {
   globalPda,

package/src/pda.ts

@@ -5,18 +5,18 @@ import { poolPda } from "@pump-fun/pump-swap-sdk";
 export function globalPda(programId: PublicKey): PublicKey {
   const [globalPda] = PublicKey.findProgramAddressSync(
     [Buffer.from("global")],
-    programId
+    programId,
   );
   return globalPda;
 }
 
 export function bondingCurvePda(
   programId: PublicKey,
-  mint: PublicKeyInitData
+  mint: PublicKeyInitData,
 ): PublicKey {
   const [bondingCurvePda] = PublicKey.findProgramAddressSync(
     [Buffer.from("bonding-curve"), new PublicKey(mint).toBuffer()],
-    programId
+    programId,
   );
   return bondingCurvePda;
 }
@@ -24,18 +24,18 @@ export function bondingCurvePda(
 export function creatorVaultPda(programId: PublicKey, creator: PublicKey) {
   const [creatorVault] = PublicKey.findProgramAddressSync(
     [Buffer.from("creator-vault"), creator.toBuffer()],
-    programId
+    programId,
   );
   return creatorVault;
 }
 
 export function pumpPoolAuthorityPda(
   mint: PublicKey,
-  pumpProgramId: PublicKey
+  pumpProgramId: PublicKey,
 ): [PublicKey, number] {
   return PublicKey.findProgramAddressSync(
     [Buffer.from("pool-authority"), mint.toBuffer()],
-    pumpProgramId
+    pumpProgramId,
   );
 }
 
@@ -44,7 +44,7 @@ export const CANONICAL_POOL_INDEX = 0;
 export function canonicalPumpPoolPda(
   pumpProgramId: PublicKey,
   pumpAmmProgramId: PublicKey,
-  mint: PublicKey
+  mint: PublicKey,
 ): [PublicKey, number] {
   const [pumpPoolAuthority] = pumpPoolAuthorityPda(mint, pumpProgramId);
 
@@ -53,6 +53,6 @@ export function canonicalPumpPoolPda(
     pumpPoolAuthority,
     mint,
     NATIVE_MINT,
-    pumpAmmProgramId
+    pumpAmmProgramId,
   );
 }