@paul.lumberwork/bonding-curve-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,544 @@
+import { BN } from '@coral-xyz/anchor';
+import { PublicKey, LAMPORTS_PER_SOL, SystemProgram, Keypair, SYSVAR_RENT_PUBKEY, ComputeBudgetProgram } from '@solana/web3.js';
+import { getAssociatedTokenAddressSync, ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, getAccount } from '@solana/spl-token';
+
+// src/sdk/index.ts
+var PROGRAM_ID = new PublicKey("6o7oTqg2CfvcMCJTLNEJsef7c875zGpTvcnFctNAjudL");
+var ADMIN_WALLET = new PublicKey("7eGpbyRpcM7WpNKQtd6XkteNQWHbWXP7icZjKzNK2aTk");
+var METADATA_PROGRAM_ID = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+var K_SCALE = 10000000000000000000000n;
+var LAMPORTS = LAMPORTS_PER_SOL;
+var TOKEN_DECIMALS = 6;
+var FEE_BPS = 100;
+var CURVE_PERCENT = 70;
+var LP_PERCENT = 20;
+var TREASURY_PERCENT = 10;
+var PumpFunSDK = class {
+  constructor(program, wallet) {
+    this.program = program;
+    this.connection = program.provider.connection;
+    this.wallet = wallet;
+    [this.launchpadPda] = PublicKey.findProgramAddressSync(
+      [Buffer.from("launchpad")],
+      program.programId
+    );
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // PDA Derivation Helpers
+  // ═══════════════════════════════════════════════════════════════════════════
+  deriveAddresses(mint) {
+    const [tokenLaunch] = PublicKey.findProgramAddressSync(
+      [Buffer.from("token_launch"), mint.toBuffer()],
+      this.program.programId
+    );
+    const [bondingCurve] = PublicKey.findProgramAddressSync(
+      [Buffer.from("bonding_curve"), tokenLaunch.toBuffer()],
+      this.program.programId
+    );
+    const [vault] = PublicKey.findProgramAddressSync(
+      [Buffer.from("vault"), tokenLaunch.toBuffer()],
+      this.program.programId
+    );
+    const curveTokenAccount = getAssociatedTokenAddressSync(mint, bondingCurve, true);
+    const [metadata] = PublicKey.findProgramAddressSync(
+      [Buffer.from("metadata"), METADATA_PROGRAM_ID.toBuffer(), mint.toBuffer()],
+      METADATA_PROGRAM_ID
+    );
+    return { mint, tokenLaunch, bondingCurve, vault, curveTokenAccount, metadata };
+  }
+  deriveUserPosition(tokenLaunch, user) {
+    const [userPosition] = PublicKey.findProgramAddressSync(
+      [Buffer.from("user_position"), tokenLaunch.toBuffer(), user.toBuffer()],
+      this.program.programId
+    );
+    return userPosition;
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Initialize Launchpad (one-time setup)
+  // ═══════════════════════════════════════════════════════════════════════════
+  async initializeLaunchpad(platformFeeBps = 200) {
+    try {
+      await this.program.account.launchpad.fetch(this.launchpadPda);
+      return "already_initialized";
+    } catch {
+      const tx = await this.program.methods.initializeLaunchpad(platformFeeBps).accountsPartial({
+        authority: this.wallet.publicKey,
+        launchpad: this.launchpadPda,
+        treasury: this.wallet.publicKey,
+        systemProgram: SystemProgram.programId
+      }).rpc();
+      return tx;
+    }
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Create Token Launch
+  // ═══════════════════════════════════════════════════════════════════════════
+  async createTokenLaunch(config) {
+    const mintKeypair = Keypair.generate();
+    const addresses = this.deriveAddresses(mintKeypair.publicKey);
+    const creatorWallet = config.creatorWallet || this.wallet.publicKey;
+    const totalSupplyRaw = new BN(config.totalSupply).mul(new BN(10 ** TOKEN_DECIMALS));
+    const kValue = new BN(config.k);
+    const tx = await this.program.methods.createTokenLaunch(config.name, config.symbol, config.uri, totalSupplyRaw, kValue).accountsPartial({
+      creator: creatorWallet,
+      launchpad: this.launchpadPda,
+      mint: mintKeypair.publicKey,
+      tokenLaunch: addresses.tokenLaunch,
+      bondingCurve: addresses.bondingCurve,
+      vault: addresses.vault,
+      curveTokenAccount: addresses.curveTokenAccount,
+      metadata: addresses.metadata,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      metadataProgram: METADATA_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
+      rent: SYSVAR_RENT_PUBKEY
+    }).signers([mintKeypair]).transaction();
+    const { blockhash } = await this.connection.getLatestBlockhash();
+    tx.recentBlockhash = blockhash;
+    tx.feePayer = this.wallet.publicKey;
+    tx.partialSign(mintKeypair);
+    const signedTx = await this.wallet.signTransaction(tx);
+    const txSignature = await this.connection.sendRawTransaction(signedTx.serialize(), {
+      skipPreflight: true
+    });
+    await this.connection.confirmTransaction({
+      signature: txSignature,
+      ...await this.connection.getLatestBlockhash()
+    });
+    return { txSignature, addresses, mintKeypair };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Buy Tokens
+  // ═══════════════════════════════════════════════════════════════════════════
+  async buy(mint, solAmount, options) {
+    const addresses = this.deriveAddresses(mint);
+    const userTokenAccount = getAssociatedTokenAddressSync(mint, this.wallet.publicKey);
+    const userPosition = this.deriveUserPosition(addresses.tokenLaunch, this.wallet.publicKey);
+    await this.program.account.bondingCurve.fetch(addresses.bondingCurve);
+    let tokensBefore = 0n;
+    try {
+      const account = await getAccount(this.connection, userTokenAccount);
+      tokensBefore = account.amount;
+    } catch {
+    }
+    const solLamports = new BN(Math.floor(solAmount * LAMPORTS_PER_SOL));
+    const preInstructions = [];
+    if (options?.computeUnits) {
+      preInstructions.push(
+        ComputeBudgetProgram.setComputeUnitLimit({ units: options.computeUnits })
+      );
+    }
+    const tx = await this.program.methods.buyTokens(solLamports).accountsPartial({
+      contributor: this.wallet.publicKey,
+      launchpad: this.launchpadPda,
+      adminWallet: ADMIN_WALLET,
+      tokenLaunch: addresses.tokenLaunch,
+      bondingCurve: addresses.bondingCurve,
+      mint,
+      vault: addresses.vault,
+      curveTokenAccount: addresses.curveTokenAccount,
+      userTokenAccount,
+      userPosition,
+      systemProgram: SystemProgram.programId,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID
+    }).preInstructions(preInstructions).rpc();
+    const curveAfter = await this.program.account.bondingCurve.fetch(addresses.bondingCurve);
+    const tokensAfter = (await getAccount(this.connection, userTokenAccount)).amount;
+    const tokensReceived = tokensAfter - tokensBefore;
+    const progress = Number(curveAfter.soldSupply.toString()) / Number(curveAfter.tokensForCurve.toString()) * 100;
+    return {
+      txSignature: tx,
+      tokensTraded: tokensReceived,
+      solTraded: BigInt(solLamports.toString()),
+      newProgress: progress,
+      isCurveComplete: curveAfter.complete
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Sell Tokens
+  // ═══════════════════════════════════════════════════════════════════════════
+  async sell(mint, tokenAmount, minSolOut = 0, options) {
+    const addresses = this.deriveAddresses(mint);
+    const userTokenAccount = getAssociatedTokenAddressSync(mint, this.wallet.publicKey);
+    const userPosition = this.deriveUserPosition(addresses.tokenLaunch, this.wallet.publicKey);
+    await this.program.account.bondingCurve.fetch(addresses.bondingCurve);
+    const walletBefore = await this.connection.getBalance(this.wallet.publicKey);
+    const tokensRaw = new BN(tokenAmount).mul(new BN(10 ** TOKEN_DECIMALS));
+    const minSolLamports = new BN(Math.floor(minSolOut * LAMPORTS_PER_SOL));
+    const preInstructions = [];
+    if (options?.computeUnits) {
+      preInstructions.push(
+        ComputeBudgetProgram.setComputeUnitLimit({ units: options.computeUnits })
+      );
+    }
+    const tx = await this.program.methods.sellTokens(tokensRaw, minSolLamports).accountsPartial({
+      contributor: this.wallet.publicKey,
+      launchpad: this.launchpadPda,
+      adminWallet: ADMIN_WALLET,
+      tokenLaunch: addresses.tokenLaunch,
+      bondingCurve: addresses.bondingCurve,
+      mint,
+      vault: addresses.vault,
+      curveTokenAccount: addresses.curveTokenAccount,
+      userTokenAccount,
+      userPosition,
+      systemProgram: SystemProgram.programId,
+      tokenProgram: TOKEN_PROGRAM_ID
+    }).preInstructions(preInstructions).rpc();
+    const curveAfter = await this.program.account.bondingCurve.fetch(addresses.bondingCurve);
+    const walletAfter = await this.connection.getBalance(this.wallet.publicKey);
+    const solReceived = BigInt(walletAfter - walletBefore);
+    const progress = Number(curveAfter.soldSupply.toString()) / Number(curveAfter.tokensForCurve.toString()) * 100;
+    return {
+      txSignature: tx,
+      tokensTraded: BigInt(tokensRaw.toString()),
+      solTraded: solReceived,
+      newProgress: progress,
+      isCurveComplete: curveAfter.complete
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Admin Withdraw
+  // ═══════════════════════════════════════════════════════════════════════════
+  async adminWithdraw(mint) {
+    const addresses = this.deriveAddresses(mint);
+    const adminTokenAccount = getAssociatedTokenAddressSync(mint, this.wallet.publicKey);
+    const launchpad = await this.program.account.launchpad.fetch(this.launchpadPda);
+    const treasuryWallet = launchpad.treasury;
+    const treasuryTokenAccount = getAssociatedTokenAddressSync(mint, treasuryWallet, true);
+    const curve = await this.program.account.bondingCurve.fetch(addresses.bondingCurve);
+    const lpSol = BigInt(curve.realSolReserves.toString());
+    const lpTokens = BigInt(curve.tokenReservesForLp.toString());
+    const accumulatedFees = BigInt(curve.accumulatedFees.toString());
+    const treasuryTokensAmount = BigInt(curve.tokenReservesForTreasury.toString());
+    const tx = await this.program.methods.adminWithdraw().accountsPartial({
+      admin: this.wallet.publicKey,
+      launchpad: this.launchpadPda,
+      tokenLaunch: addresses.tokenLaunch,
+      bondingCurve: addresses.bondingCurve,
+      mint,
+      vault: addresses.vault,
+      curveTokenAccount: addresses.curveTokenAccount,
+      adminTokenAccount,
+      treasuryWallet,
+      treasuryTokenAccount,
+      systemProgram: SystemProgram.programId,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID
+    }).rpc();
+    return {
+      txSignature: tx,
+      solWithdrawn: lpSol,
+      tokensWithdrawn: lpTokens,
+      feesToTreasury: accumulatedFees,
+      treasuryTokens: treasuryTokensAmount
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Estimate Buy (tokens received for SOL)
+  // ═══════════════════════════════════════════════════════════════════════════
+  async estimateBuy(mint, solAmount) {
+    const addresses = this.deriveAddresses(mint);
+    const curve = await this.program.account.bondingCurve.fetch(addresses.bondingCurve);
+    const k = BigInt(curve.k.toString());
+    const soldSupply = BigInt(curve.soldSupply.toString());
+    const tokensForCurve = BigInt(curve.tokensForCurve.toString());
+    const solLamports = BigInt(Math.floor(solAmount * LAMPORTS_PER_SOL));
+    const feeAmount = solLamports / 100n;
+    const solAfterFees = solLamports - feeAmount;
+    const tokensOut = this.calculateTokensForSol(k, soldSupply, solAfterFees);
+    const available = tokensForCurve - soldSupply;
+    const actualTokensOut = tokensOut > available ? available : tokensOut;
+    const pricePerToken = solAfterFees / (actualTokensOut / BigInt(10 ** TOKEN_DECIMALS));
+    const newSoldSupply = soldSupply + actualTokensOut;
+    const priceBefore = this.calculatePrice(k, soldSupply);
+    const priceAfter = this.calculatePrice(k, newSoldSupply);
+    const priceImpactBps = priceBefore > 0n ? Number((priceAfter - priceBefore) * 10000n / priceBefore) : 0;
+    return {
+      tokensOut: actualTokensOut,
+      solCost: solLamports,
+      pricePerToken,
+      priceImpactBps,
+      feeAmount
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Estimate Sell (SOL received for tokens)
+  // ═══════════════════════════════════════════════════════════════════════════
+  async estimateSell(mint, tokenAmount) {
+    const addresses = this.deriveAddresses(mint);
+    const curve = await this.program.account.bondingCurve.fetch(addresses.bondingCurve);
+    const k = BigInt(curve.k.toString());
+    const soldSupply = BigInt(curve.soldSupply.toString());
+    const realSolReserves = BigInt(curve.realSolReserves.toString());
+    const tokensRaw = BigInt(tokenAmount) * BigInt(10 ** TOKEN_DECIMALS);
+    if (tokensRaw > soldSupply) {
+      throw new Error(`Cannot sell ${tokenAmount} tokens. Only ${soldSupply / BigInt(10 ** TOKEN_DECIMALS)} available.`);
+    }
+    const grossRefund = this.calculateRefund(k, soldSupply, soldSupply - tokensRaw);
+    const cappedRefund = grossRefund > realSolReserves ? realSolReserves : grossRefund;
+    const feeAmount = cappedRefund / 100n;
+    const netSolOut = cappedRefund - feeAmount;
+    const pricePerToken = netSolOut / BigInt(tokenAmount);
+    const newSoldSupply = soldSupply - tokensRaw;
+    const priceBefore = this.calculatePrice(k, soldSupply);
+    const priceAfter = this.calculatePrice(k, newSoldSupply);
+    const priceImpactBps = priceBefore > 0n ? Number((priceBefore - priceAfter) * 10000n / priceBefore) : 0;
+    return {
+      tokensOut: tokensRaw,
+      // tokens being sold
+      solCost: netSolOut,
+      // SOL to receive
+      pricePerToken,
+      priceImpactBps,
+      feeAmount
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Get Curve State
+  // ═══════════════════════════════════════════════════════════════════════════
+  async getCurveState(mint) {
+    const addresses = this.deriveAddresses(mint);
+    const curve = await this.program.account.bondingCurve.fetch(addresses.bondingCurve);
+    return {
+      tokenLaunch: curve.tokenLaunch,
+      k: BigInt(curve.k.toString()),
+      totalSupply: BigInt(curve.totalSupply.toString()),
+      soldSupply: BigInt(curve.soldSupply.toString()),
+      realSolReserves: BigInt(curve.realSolReserves.toString()),
+      tokenReservesForLp: BigInt(curve.tokenReservesForLp.toString()),
+      tokenReservesForTreasury: BigInt(curve.tokenReservesForTreasury.toString()),
+      tokensForCurve: BigInt(curve.tokensForCurve.toString()),
+      accumulatedFees: BigInt(curve.accumulatedFees.toString()),
+      complete: curve.complete,
+      bump: curve.bump
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Get Token Launch State
+  // ═══════════════════════════════════════════════════════════════════════════
+  async getTokenLaunchState(mint) {
+    const addresses = this.deriveAddresses(mint);
+    const launch = await this.program.account.tokenLaunch.fetch(addresses.tokenLaunch);
+    return {
+      creator: launch.creator,
+      mint: launch.mint,
+      vault: launch.vault,
+      bondingCurve: launch.bondingCurve,
+      totalSupply: BigInt(launch.totalSupply.toString()),
+      curveAllocation: BigInt(launch.curveAllocation.toString()),
+      lpAllocation: BigInt(launch.lpAllocation.toString()),
+      treasuryAllocation: BigInt(launch.treasuryAllocation.toString()),
+      totalSolRaised: BigInt(launch.totalSolRaised.toString()),
+      tradingActive: launch.tradingActive,
+      migrated: launch.migrated,
+      initialK: BigInt(launch.initialK.toString()),
+      name: launch.name,
+      symbol: launch.symbol
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Get Progress
+  // ═══════════════════════════════════════════════════════════════════════════
+  async getProgress(mint) {
+    const curve = await this.getCurveState(mint);
+    const percent = Number(curve.soldSupply * 100n / curve.tokensForCurve);
+    const currentPrice = this.calculatePrice(curve.k, curve.soldSupply);
+    return {
+      percent,
+      soldSupply: curve.soldSupply,
+      tokensForCurve: curve.tokensForCurve,
+      solRaised: curve.realSolReserves,
+      currentPrice,
+      isComplete: curve.complete
+    };
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Event Listeners
+  // ═══════════════════════════════════════════════════════════════════════════
+  /**
+   * Listen for LaunchCreated events
+   * @param callback Function to call when event is emitted
+   * @returns Listener ID for removal
+   */
+  onLaunchCreated(callback) {
+    return this.program.addEventListener("launchCreated", (event, slot, signature) => {
+      callback({
+        tokenLaunch: event.tokenLaunch,
+        mint: event.mint,
+        creator: event.creator,
+        name: event.name,
+        symbol: event.symbol,
+        totalSupply: BigInt(event.totalSupply.toString()),
+        curveAllocation: BigInt(event.curveAllocation.toString()),
+        lpAllocation: BigInt(event.lpAllocation.toString()),
+        treasuryAllocation: BigInt(event.treasuryAllocation.toString()),
+        initialK: BigInt(event.initialK.toString()),
+        initialPrice: BigInt(event.initialPrice.toString()),
+        timestamp: BigInt(event.timestamp.toString())
+      }, slot, signature);
+    });
+  }
+  /**
+   * Listen for TokensPurchased events
+   * @param callback Function to call when event is emitted
+   * @returns Listener ID for removal
+   */
+  onTokensPurchased(callback) {
+    return this.program.addEventListener("tokensPurchased", (event, slot, signature) => {
+      callback({
+        tokenLaunch: event.tokenLaunch,
+        mint: event.mint,
+        buyer: event.buyer,
+        solAmount: BigInt(event.solAmount.toString()),
+        solAfterFees: BigInt(event.solAfterFees.toString()),
+        tokensReceived: BigInt(event.tokensReceived.toString()),
+        curveFee: BigInt(event.curveFee.toString()),
+        adminFee: BigInt(event.adminFee.toString()),
+        priceAfter: BigInt(event.priceAfter.toString()),
+        totalSold: BigInt(event.totalSold.toString()),
+        progress: event.progress,
+        timestamp: BigInt(event.timestamp.toString()),
+        isCurveComplete: event.isCurveComplete
+      }, slot, signature);
+    });
+  }
+  /**
+   * Listen for TokensSold events
+   * @param callback Function to call when event is emitted
+   * @returns Listener ID for removal
+   */
+  onTokensSold(callback) {
+    return this.program.addEventListener("tokensSold", (event, slot, signature) => {
+      callback({
+        tokenLaunch: event.tokenLaunch,
+        mint: event.mint,
+        seller: event.seller,
+        tokensSold: BigInt(event.tokensSold.toString()),
+        grossSolRefund: BigInt(event.grossSolRefund.toString()),
+        netSolRefund: BigInt(event.netSolRefund.toString()),
+        curveFee: BigInt(event.curveFee.toString()),
+        adminFee: BigInt(event.adminFee.toString()),
+        priceAfter: BigInt(event.priceAfter.toString()),
+        totalSold: BigInt(event.totalSold.toString()),
+        progress: event.progress,
+        timestamp: BigInt(event.timestamp.toString())
+      }, slot, signature);
+    });
+  }
+  /**
+   * Listen for CurveComplete events
+   * @param callback Function to call when event is emitted
+   * @returns Listener ID for removal
+   */
+  onCurveComplete(callback) {
+    return this.program.addEventListener("curveComplete", (event, slot, signature) => {
+      callback({
+        tokenLaunch: event.tokenLaunch,
+        mint: event.mint,
+        totalSolRaised: BigInt(event.totalSolRaised.toString()),
+        finalPrice: BigInt(event.finalPrice.toString()),
+        timestamp: BigInt(event.timestamp.toString())
+      }, slot, signature);
+    });
+  }
+  /**
+   * Listen for AdminWithdraw events
+   * @param callback Function to call when event is emitted
+   * @returns Listener ID for removal
+   */
+  onAdminWithdraw(callback) {
+    return this.program.addEventListener("adminWithdraw", (event, slot, signature) => {
+      callback({
+        tokenLaunch: event.tokenLaunch,
+        mint: event.mint,
+        admin: event.admin,
+        creator: event.creator,
+        treasury: event.treasury,
+        solWithdrawn: BigInt(event.solWithdrawn.toString()),
+        tokensWithdrawn: BigInt(event.tokensWithdrawn.toString()),
+        feesToTreasury: BigInt(event.feesToTreasury.toString()),
+        treasuryTokens: BigInt(event.treasuryTokens.toString()),
+        timestamp: BigInt(event.timestamp.toString())
+      }, slot, signature);
+    });
+  }
+  /**
+   * Remove an event listener
+   * @param listenerId The ID returned from addEventListener
+   */
+  async removeEventListener(listenerId) {
+    await this.program.removeEventListener(listenerId);
+  }
+  // ═══════════════════════════════════════════════════════════════════════════
+  // Math Helpers (Pure functions, no async)
+  // ═══════════════════════════════════════════════════════════════════════════
+  /** Calculate price at a given supply: price = k × supply / K_SCALE */
+  calculatePrice(k, supply) {
+    if (supply === 0n) return 0n;
+    return k * supply / K_SCALE;
+  }
+  /** Calculate cost to buy from s1 to s2: cost = (k/2) × (s2² - s1²) / K_SCALE */
+  calculateCost(k, s1, s2) {
+    if (s2 <= s1) return 0n;
+    const s1Sq = s1 * s1;
+    const s2Sq = s2 * s2;
+    const diffSq = s2Sq - s1Sq;
+    return k * diffSq / 2n / K_SCALE;
+  }
+  /** Calculate tokens received for SOL: s2 = sqrt(s1² + 2×sol×K_SCALE/k) */
+  calculateTokensForSol(k, currentSupply, solIn) {
+    if (solIn === 0n || k === 0n) return 0n;
+    const s1Sq = currentSupply * currentSupply;
+    const addition = 2n * solIn * K_SCALE / k;
+    const s2Sq = s1Sq + addition;
+    const s2 = this.isqrt(s2Sq);
+    return s2 - currentSupply;
+  }
+  /** Calculate refund for selling tokens: refund = (k/2) × (s1² - s2²) / K_SCALE */
+  calculateRefund(k, s1, s2) {
+    if (s1 <= s2) return 0n;
+    const s1Sq = s1 * s1;
+    const s2Sq = s2 * s2;
+    const diffSq = s1Sq - s2Sq;
+    return k * diffSq / 2n / K_SCALE;
+  }
+  /** Integer square root using Newton's method */
+  isqrt(n) {
+    if (n === 0n) return 0n;
+    if (n === 1n) return 1n;
+    let x = n;
+    let y = (x + 1n) / 2n;
+    while (y < x) {
+      x = y;
+      y = (x + n / x) / 2n;
+    }
+    return x;
+  }
+  /** Calculate K for a given target SOL and curve supply */
+  static calculateK(curveSupply, targetSol) {
+    const numerator = 2n * targetSol * K_SCALE;
+    const denominator = curveSupply * curveSupply;
+    return numerator / denominator;
+  }
+};
+function formatTokens(raw) {
+  const tokens = Number(raw) / 10 ** TOKEN_DECIMALS;
+  return tokens.toLocaleString(void 0, { maximumFractionDigits: 2 });
+}
+function formatSol(lamports) {
+  const sol = Number(lamports) / LAMPORTS_PER_SOL;
+  return sol.toFixed(4);
+}
+function parseSol(sol) {
+  return BigInt(Math.floor(sol * LAMPORTS_PER_SOL));
+}
+function parseTokens(tokens) {
+  return BigInt(Math.floor(tokens * 10 ** TOKEN_DECIMALS));
+}
+
+export { ADMIN_WALLET, CURVE_PERCENT, FEE_BPS, K_SCALE, LAMPORTS, LP_PERCENT, METADATA_PROGRAM_ID, PROGRAM_ID, PumpFunSDK, TOKEN_DECIMALS, TREASURY_PERCENT, formatSol, formatTokens, parseSol, parseTokens };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map