sol-trade-sdk 0.1.0

package/src/calc/pumpfun.ts

@@ -0,0 +1,124 @@
+/**
+ * PumpFun bonding curve calculations.
+ * Based on sol-trade-sdk Rust implementation.
+ */
+
+// Constants from Rust
+export const FEE_BASIS_POINTS = 100; // 1%
+export const CREATOR_FEE = 50; // 0.5%
+export const INITIAL_VIRTUAL_TOKEN_RESERVES = 1_073_000_000_000_000;
+export const INITIAL_VIRTUAL_SOL_RESERVES = 30_000_000_000; // 30 SOL
+export const INITIAL_REAL_TOKEN_RESERVES = 793_100_000_000_000;
+export const TOKEN_TOTAL_SUPPLY = 1_000_000_000_000_000;
+export const LAMPORTS_PER_SOL = 1_000_000_000;
+
+/**
+ * Compute fee for a given amount
+ */
+export function computeFee(amount: number, feeBasisPoints: number): number {
+  return Math.floor((amount * feeBasisPoints) / 10_000);
+}
+
+/**
+ * Calculate token amount received for given SOL amount using bonding curve formula
+ */
+export function getBuyTokenAmountFromSolAmount(
+  virtualTokenReserves: number,
+  virtualSolReserves: number,
+  realTokenReserves: number,
+  creator: Uint8Array,
+  amount: number,
+): number {
+  if (amount === 0) {
+    return 0;
+  }
+
+  if (virtualTokenReserves === 0) {
+    return 0;
+  }
+
+  // Calculate total fee
+  const hasCreator = creator.some(b => b !== 0);
+  const totalFeeBasisPoints = FEE_BASIS_POINTS + (hasCreator ? CREATOR_FEE : 0);
+
+  // Calculate input amount after fees
+  const inputAmount = Math.floor((amount * 10_000) / (totalFeeBasisPoints + 10_000));
+
+  const denominator = virtualSolReserves + inputAmount;
+
+  let tokensReceived = Math.floor((inputAmount * virtualTokenReserves) / denominator);
+
+  // Cap at real reserves
+  tokensReceived = Math.min(tokensReceived, realTokenReserves);
+
+  // Special handling for small amounts
+  if (tokensReceived <= 100 * 1_000_000) {
+    if (amount > 0.01 * LAMPORTS_PER_SOL) {
+      tokensReceived = 25547619 * 1_000_000;
+    } else {
+      tokensReceived = 255476 * 1_000_000;
+    }
+  }
+
+  return tokensReceived;
+}
+
+/**
+ * Calculate SOL amount received for given token amount
+ */
+export function getSellSolAmountFromTokenAmount(
+  virtualTokenReserves: number,
+  virtualSolReserves: number,
+  creator: Uint8Array,
+  amount: number,
+): number {
+  if (amount === 0) {
+    return 0;
+  }
+
+  if (virtualTokenReserves === 0) {
+    return 0;
+  }
+
+  // Calculate SOL received
+  const numerator = amount * virtualSolReserves;
+  const denominator = virtualTokenReserves + amount;
+
+  const solCost = Math.floor(numerator / denominator);
+
+  // Calculate fee
+  const hasCreator = creator.some(b => b !== 0);
+  const totalFeeBasisPoints = FEE_BASIS_POINTS + (hasCreator ? CREATOR_FEE : 0);
+
+  const fee = computeFee(solCost, totalFeeBasisPoints);
+
+  return Math.max(0, solCost - fee);
+}
+
+/**
+ * Calculate max SOL cost with slippage for buy
+ */
+export function calculateWithSlippageBuy(amount: number, slippageBasisPoints: number): number {
+  return amount + Math.floor((amount * slippageBasisPoints) / 10_000);
+}
+
+/**
+ * Calculate min tokens out with slippage for sell
+ */
+export function calculateWithSlippageSell(amount: number, slippageBasisPoints: number): number {
+  return amount - Math.floor((amount * slippageBasisPoints) / 10_000);
+}
+
+/**
+ * Convert lamports to SOL
+ */
+export function lamportsToSol(lamports: number): number {
+  return lamports / LAMPORTS_PER_SOL;
+}
+
+/**
+ * Convert SOL to lamports
+ */
+export function solToLamports(sol: number): number {
+  return Math.floor(sol * LAMPORTS_PER_SOL);
+}

package/src/common/bonding_curve.ts

@@ -0,0 +1,272 @@
+/**
+ * Bonding curve account for Pump.fun.
+ * Based on sol-trade-sdk Rust implementation.
+ */
+
+import { PublicKey } from '@solana/web3.js';
+import {
+  getBuyTokenAmountFromSolAmount,
+  getSellSolAmountFromTokenAmount,
+  INITIAL_VIRTUAL_TOKEN_RESERVES,
+  INITIAL_VIRTUAL_SOL_RESERVES,
+  INITIAL_REAL_TOKEN_RESERVES,
+  TOKEN_TOTAL_SUPPLY,
+} from '../calc/pumpfun';
+
+/**
+ * Represents the bonding curve account for token pricing
+ */
+export class BondingCurveAccount {
+  discriminator: number = 0;
+  account: PublicKey = PublicKey.default;
+  virtualTokenReserves: number = 0;
+  virtualSolReserves: number = 0;
+  realTokenReserves: number = 0;
+  realSolReserves: number = 0;
+  tokenTotalSupply: number = TOKEN_TOTAL_SUPPLY;
+  complete: boolean = false;
+  creator: PublicKey = PublicKey.default;
+  isMayhemMode: boolean = false;
+  isCashbackCoin: boolean = false;
+
+  constructor(fields?: Partial<BondingCurveAccount>) {
+    if (fields) {
+      Object.assign(this, fields);
+    }
+  }
+
+  /**
+   * Create from dev trade data
+   */
+  static fromDevTrade(
+    bondingCurve: PublicKey,
+    mint: PublicKey,
+    devTokenAmount: number,
+    devSolAmount: number,
+    creator: PublicKey,
+    isMayhemMode: boolean = false,
+    isCashbackCoin: boolean = false,
+  ): BondingCurveAccount {
+    return new BondingCurveAccount({
+      discriminator: 0,
+      account: bondingCurve,
+      virtualTokenReserves: INITIAL_VIRTUAL_TOKEN_RESERVES - devTokenAmount,
+      virtualSolReserves: INITIAL_VIRTUAL_SOL_RESERVES + devSolAmount,
+      realTokenReserves: INITIAL_REAL_TOKEN_RESERVES - devTokenAmount,
+      realSolReserves: devSolAmount,
+      tokenTotalSupply: TOKEN_TOTAL_SUPPLY,
+      complete: false,
+      creator,
+      isMayhemMode,
+      isCashbackCoin,
+    });
+  }
+
+  /**
+   * Create from trade data
+   */
+  static fromTrade(
+    bondingCurve: PublicKey,
+    mint: PublicKey,
+    creator: PublicKey,
+    virtualTokenReserves: number,
+    virtualSolReserves: number,
+    realTokenReserves: number,
+    realSolReserves: number,
+    isMayhemMode: boolean = false,
+    isCashbackCoin: boolean = false,
+  ): BondingCurveAccount {
+    return new BondingCurveAccount({
+      discriminator: 0,
+      account: bondingCurve,
+      virtualTokenReserves,
+      virtualSolReserves,
+      realTokenReserves,
+      realSolReserves,
+      tokenTotalSupply: TOKEN_TOTAL_SUPPLY,
+      complete: false,
+      creator,
+      isMayhemMode,
+      isCashbackCoin,
+    });
+  }
+
+  /**
+   * Calculate tokens received for given SOL amount
+   */
+  getBuyPrice(amount: number): number {
+    if (this.complete) {
+      throw new Error('Curve is complete');
+    }
+
+    return getBuyTokenAmountFromSolAmount(
+      this.virtualTokenReserves,
+      this.virtualSolReserves,
+      this.realTokenReserves,
+      this.creator.toBytes(),
+      amount,
+    );
+  }
+
+  /**
+   * Calculate SOL received for given token amount
+   */
+  getSellPrice(amount: number): number {
+    if (this.complete) {
+      throw new Error('Curve is complete');
+    }
+
+    return getSellSolAmountFromTokenAmount(
+      this.virtualTokenReserves,
+      this.virtualSolReserves,
+      this.creator.toBytes(),
+      amount,
+    );
+  }
+
+  /**
+   * Calculate current market cap in SOL
+   */
+  getMarketCapSol(): number {
+    if (this.virtualTokenReserves === 0) {
+      return 0;
+    }
+
+    const pricePerToken = this.virtualSolReserves / this.virtualTokenReserves;
+    return (pricePerToken * this.tokenTotalSupply) / 1e9;
+  }
+
+  /**
+   * Calculate price to buy out all remaining tokens
+   */
+  getBuyOutPrice(amount: number): number {
+    if (this.complete) {
+      throw new Error('Curve is complete');
+    }
+
+    // Rough estimate: current price * amount
+    if (this.virtualTokenReserves === 0) {
+      return 0;
+    }
+
+    const priceRatio = this.virtualSolReserves / this.virtualTokenReserves;
+    return Math.floor(priceRatio * amount);
+  }
+
+  /**
+   * Calculate the current token price in SOL.
+   * 100% from Rust: src/common/bonding_curve.rs get_token_price
+   */
+  getTokenPrice(): number {
+    const vSol = this.virtualSolReserves / 100_000_000.0;
+    const vTokens = this.virtualTokenReserves / 100_000.0;
+    if (vTokens === 0) {
+      return 0.0;
+    }
+    return vSol / vTokens;
+  }
+
+  /**
+   * Calculate the final market cap in SOL after all tokens are sold.
+   * 100% from Rust: src/common/bonding_curve.rs get_final_market_cap_sol
+   */
+  getFinalMarketCapSol(feeBasisPoints: number = 95): bigint {
+    const totalSellValue = this.getBuyOutPriceInternal(this.realTokenReserves, feeBasisPoints);
+    const totalVirtualValue = BigInt(this.virtualSolReserves) + BigInt(totalSellValue);
+    const totalVirtualTokens = BigInt(this.virtualTokenReserves) - BigInt(this.realTokenReserves);
+
+    if (totalVirtualTokens === 0n) {
+      return 0n;
+    }
+
+    return (BigInt(this.tokenTotalSupply) * totalVirtualValue) / totalVirtualTokens;
+  }
+
+  private getBuyOutPriceInternal(amount: number, feeBasisPoints: number): number {
+    const solTokens = Math.max(amount, this.realSolReserves);
+
+    if (this.virtualTokenReserves <= solTokens) {
+      return 0;
+    }
+
+    const totalSellValue = Number((BigInt(solTokens) * BigInt(this.virtualSolReserves)) / (BigInt(this.virtualTokenReserves) - BigInt(solTokens))) + 1;
+    const fee = Math.floor((totalSellValue * feeBasisPoints) / 10000);
+
+    return totalSellValue + fee;
+  }
+}
+
+// ===== Decoding Functions - from Rust: src/instruction/utils/pumpfun.rs =====
+
+export const BONDING_CURVE_ACCOUNT_SIZE = 8 + 8 + 8 + 8 + 8 + 8 + 1 + 32 + 1 + 1; // 77 bytes after discriminator
+
+/**
+ * Decode a BondingCurveAccount from on-chain account data.
+ * 100% from Rust: src/common/bonding_curve.rs
+ */
+export function decodeBondingCurveAccount(data: Buffer, account?: PublicKey): BondingCurveAccount | null {
+  if (data.length < BONDING_CURVE_ACCOUNT_SIZE) {
+    return null;
+  }
+
+  try {
+    let offset = 0;
+
+    // Check if data starts with discriminator (8 bytes)
+    if (data.length >= 8 + BONDING_CURVE_ACCOUNT_SIZE) {
+      // Skip discriminator
+      offset = 8;
+    }
+
+    // virtual_token_reserves: u64
+    const virtualTokenReserves = Number(data.readBigUInt64LE(offset));
+    offset += 8;
+
+    // virtual_sol_reserves: u64
+    const virtualSolReserves = Number(data.readBigUInt64LE(offset));
+    offset += 8;
+
+    // real_token_reserves: u64
+    const realTokenReserves = Number(data.readBigUInt64LE(offset));
+    offset += 8;
+
+    // real_sol_reserves: u64
+    const realSolReserves = Number(data.readBigUInt64LE(offset));
+    offset += 8;
+
+    // token_total_supply: u64
+    const tokenTotalSupply = Number(data.readBigUInt64LE(offset));
+    offset += 8;
+
+    // complete: bool
+    const complete = data.readUInt8(offset) === 1;
+    offset += 1;
+
+    // creator: Pubkey (32 bytes)
+    const creator = new PublicKey(data.subarray(offset, offset + 32));
+    offset += 32;
+
+    // is_mayhem_mode: bool
+    const isMayhemMode = data.readUInt8(offset) === 1;
+    offset += 1;
+
+    // is_cashback_coin: bool
+    const isCashbackCoin = data.readUInt8(offset) === 1;
+
+    return new BondingCurveAccount({
+      discriminator: 0,
+      account: account ?? PublicKey.default,
+      virtualTokenReserves,
+      virtualSolReserves,
+      realTokenReserves,
+      realSolReserves,
+      tokenTotalSupply,
+      complete,
+      creator,
+      isMayhemMode,
+      isCashbackCoin,
+    });
+  } catch {
+    return null;
+  }
+}

package/src/common/compute-budget.ts

@@ -0,0 +1,148 @@
+/**
+ * Compute Budget Manager - 100% port from Rust: src/trading/common/compute_budget_manager.rs
+ * 
+ * Provides utilities for managing compute budget instructions:
+ * - Setting compute unit price
+ * - Setting compute unit limit
+ * - Caching for performance
+ */
+
+import { TransactionInstruction, PublicKey } from '@solana/web3.js';
+
+// ===== Constants =====
+
+const COMPUTE_BUDGET_PROGRAM_ID = new PublicKey('ComputeBudget111111111111111111111111111111');
+
+// Instruction types for Compute Budget program
+const COMPUTE_BUDGET_INSTRUCTIONS = {
+  REQUEST_UNITS: 0,
+  REQUEST_HEAP_FRAME: 1,
+  SET_COMPUTE_UNIT_LIMIT: 2,
+  SET_COMPUTE_UNIT_PRICE: 3,
+} as const;
+
+// ===== Cache =====
+
+interface ComputeBudgetCacheKey {
+  unitPrice: bigint;
+  unitLimit: number;
+}
+
+const computeBudgetCache = new Map<string, TransactionInstruction[]>();
+
+function getCacheKey(key: ComputeBudgetCacheKey): string {
+  return `${key.unitPrice}:${key.unitLimit}`;
+}
+
+// ===== Instruction Builders =====
+
+/**
+ * Create Set Compute Unit Price instruction
+ */
+function setComputeUnitPrice(price: bigint): TransactionInstruction {
+  const data = Buffer.alloc(9);
+  data.writeUInt8(COMPUTE_BUDGET_INSTRUCTIONS.SET_COMPUTE_UNIT_PRICE, 0);
+  data.writeBigUInt64LE(price, 1);
+  
+  return new TransactionInstruction({
+    keys: [],
+    programId: COMPUTE_BUDGET_PROGRAM_ID,
+    data,
+  });
+}
+
+/**
+ * Create Set Compute Unit Limit instruction
+ */
+function setComputeUnitLimit(limit: number): TransactionInstruction {
+  const data = Buffer.alloc(5);
+  data.writeUInt8(COMPUTE_BUDGET_INSTRUCTIONS.SET_COMPUTE_UNIT_LIMIT, 0);
+  data.writeUInt32LE(limit, 1);
+  
+  return new TransactionInstruction({
+    keys: [],
+    programId: COMPUTE_BUDGET_PROGRAM_ID,
+    data,
+  });
+}
+
+// ===== Public Functions =====
+
+/**
+ * Extend instructions array with compute budget instructions
+ * Uses caching for performance
+ * 100% from Rust: src/trading/common/compute_budget_manager.rs extend_compute_budget_instructions
+ */
+export function extendComputeBudgetInstructions(
+  instructions: TransactionInstruction[],
+  unitPrice: bigint,
+  unitLimit: number
+): void {
+  const cacheKey: ComputeBudgetCacheKey = { unitPrice, unitLimit };
+  const key = getCacheKey(cacheKey);
+  
+  let cachedInstructions = computeBudgetCache.get(key);
+  
+  if (!cachedInstructions) {
+    cachedInstructions = [];
+    
+    if (unitPrice > BigInt(0)) {
+      cachedInstructions.push(setComputeUnitPrice(unitPrice));
+    }
+    
+    if (unitLimit > 0) {
+      cachedInstructions.push(setComputeUnitLimit(unitLimit));
+    }
+    
+    computeBudgetCache.set(key, cachedInstructions);
+  }
+  
+  instructions.push(...cachedInstructions);
+}
+
+/**
+ * Get compute budget instructions as array
+ * 100% from Rust: src/trading/common/compute_budget_manager.rs compute_budget_instructions
+ */
+export function computeBudgetInstructions(
+  unitPrice: bigint,
+  unitLimit: number
+): TransactionInstruction[] {
+  const cacheKey: ComputeBudgetCacheKey = { unitPrice, unitLimit };
+  const key = getCacheKey(cacheKey);
+  
+  let cachedInstructions = computeBudgetCache.get(key);
+  
+  if (!cachedInstructions) {
+    cachedInstructions = [];
+    
+    if (unitPrice > BigInt(0)) {
+      cachedInstructions.push(setComputeUnitPrice(unitPrice));
+    }
+    
+    if (unitLimit > 0) {
+      cachedInstructions.push(setComputeUnitLimit(unitLimit));
+    }
+    
+    computeBudgetCache.set(key, cachedInstructions);
+  }
+  
+  return [...cachedInstructions]; // Return copy
+}
+
+/**
+ * Clear the compute budget cache
+ */
+export function clearComputeBudgetCache(): void {
+  computeBudgetCache.clear();
+}
+
+// ===== Predefined Compute Budgets =====
+
+export const COMPUTE_BUDGET_PRESETS = {
+  LOW: { unitLimit: 100_000, unitPrice: BigInt(1_000) },
+  MEDIUM: { unitLimit: 200_000, unitPrice: BigInt(10_000) },
+  HIGH: { unitLimit: 400_000, unitPrice: BigInt(50_000) },
+  VERY_HIGH: { unitLimit: 800_000, unitPrice: BigInt(100_000) },
+  MAX: { unitLimit: 1_400_000, unitPrice: BigInt(200_000) },
+} as const;