sol-trade-sdk 0.1.0

package/src/compute/compute_budget_manager.ts

@@ -0,0 +1,187 @@
+/**
+ * Compute Budget Manager - Caching compute budget instructions.
+ * Based on sol-trade-sdk Rust implementation patterns.
+ */
+
+// ===== Constants =====
+
+/**
+ * ComputeBudgetProgram is the Solana compute budget program ID
+ */
+export const COMPUTE_BUDGET_PROGRAM = new Uint8Array([
+  0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x65, 0x42, 0x75, 0x64, 0x67, 0x65,
+  0x74, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
+  0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
+]);
+
+/**
+ * Instruction discriminators
+ */
+export const SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR = new Uint8Array([
+  0x02, 0x00, 0x00, 0x00,
+]);
+export const SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR = new Uint8Array([
+  0x00, 0x00, 0x00, 0x00,
+]);
+
+// ===== Cache Key =====
+
+/**
+ * Cache key for compute budget instructions
+ */
+interface ComputeBudgetCacheKey {
+  unitPrice: bigint;
+  unitLimit: number;
+}
+
+function cacheKeyToString(key: ComputeBudgetCacheKey): string {
+  return `${key.unitPrice}:${key.unitLimit}`;
+}
+
+// ===== Cache =====
+
+/**
+ * Stores compute budget instructions.
+ * Uses Map for high-performance access.
+ */
+class ComputeBudgetCache {
+  private cache = new Map<string, Uint8Array[]>();
+
+  get(key: ComputeBudgetCacheKey): Uint8Array[] | undefined {
+    return this.cache.get(cacheKeyToString(key));
+  }
+
+  set(key: ComputeBudgetCacheKey, value: Uint8Array[]): void {
+    this.cache.set(cacheKeyToString(key), value);
+  }
+
+  has(key: ComputeBudgetCacheKey): boolean {
+    return this.cache.has(cacheKeyToString(key));
+  }
+
+  get size(): number {
+    return this.cache.size;
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+}
+
+// Global cache instance
+const globalCache = new ComputeBudgetCache();
+
+// ===== Instruction Builders =====
+
+/**
+ * Create set compute unit price instruction
+ */
+export function setComputeUnitPrice(price: bigint): Uint8Array {
+  // Instruction: [discriminator (4 bytes) | price (8 bytes)]
+  const data = new Uint8Array(12);
+  data.set(SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR, 0);
+  
+  // Little-endian price (8 bytes)
+  const view = new DataView(data.buffer, 4, 8);
+  view.setBigUint64(0, price, true); // little-endian
+  
+  return data;
+}
+
+/**
+ * Create set compute unit limit instruction
+ */
+export function setComputeUnitLimit(limit: number): Uint8Array {
+  // Instruction: [discriminator (4 bytes) | limit (4 bytes)]
+  const data = new Uint8Array(8);
+  data.set(SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR, 0);
+  
+  // Little-endian limit (4 bytes)
+  const view = new DataView(data.buffer, 4, 4);
+  view.setUint32(0, limit, true); // little-endian
+  
+  return data;
+}
+
+// ===== Cached Instruction Functions =====
+
+/**
+ * Extend instructions with compute budget instructions.
+ * On cache hit, extends from cached array (no allocation).
+ */
+export function extendComputeBudgetInstructions(
+  instructions: Uint8Array[],
+  unitPrice: bigint,
+  unitLimit: number
+): Uint8Array[] {
+  const cacheKey: ComputeBudgetCacheKey = { unitPrice, unitLimit };
+
+  // Check cache
+  const cached = globalCache.get(cacheKey);
+  if (cached) {
+    instructions.push(...cached);
+    return instructions;
+  }
+
+  // Build new instructions
+  const insts: Uint8Array[] = [];
+  if (unitPrice > 0n) {
+    insts.push(setComputeUnitPrice(unitPrice));
+  }
+  if (unitLimit > 0) {
+    insts.push(setComputeUnitLimit(unitLimit));
+  }
+
+  // Store in cache
+  globalCache.set(cacheKey, insts);
+
+  instructions.push(...insts);
+  return instructions;
+}
+
+/**
+ * Returns compute budget instructions.
+ * Note: prefer extendComputeBudgetInstructions on hot path.
+ */
+export function computeBudgetInstructions(
+  unitPrice: bigint,
+  unitLimit: number
+): Uint8Array[] {
+  const cacheKey: ComputeBudgetCacheKey = { unitPrice, unitLimit };
+
+  // Check cache
+  const cached = globalCache.get(cacheKey);
+  if (cached) {
+    return [...cached]; // Return copy
+  }
+
+  // Build new instructions
+  const insts: Uint8Array[] = [];
+  if (unitPrice > 0n) {
+    insts.push(setComputeUnitPrice(unitPrice));
+  }
+  if (unitLimit > 0) {
+    insts.push(setComputeUnitLimit(unitLimit));
+  }
+
+  // Store in cache
+  globalCache.set(cacheKey, insts);
+
+  return [...insts];
+}
+
+// ===== Cache Statistics =====
+
+/**
+ * Get cache size
+ */
+export function getCacheStats(): number {
+  return globalCache.size;
+}
+
+/**
+ * Clear the cache (for testing)
+ */
+export function clearCache(): void {
+  globalCache.clear();
+}

package/src/compute/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Compute Budget Module for Sol Trade SDK
+ *
+ * Provides cached compute budget instructions for low-latency transaction building.
+ */
+
+export {
+  // Constants
+  COMPUTE_BUDGET_PROGRAM,
+  SET_COMPUTE_UNIT_PRICE_DISCRIMINATOR,
+  SET_COMPUTE_UNIT_LIMIT_DISCRIMINATOR,
+  // Instruction builders
+  setComputeUnitPrice,
+  setComputeUnitLimit,
+  // Cached functions
+  extendComputeBudgetInstructions,
+  computeBudgetInstructions,
+  // Cache stats
+  getCacheStats,
+  clearCache,
+} from './compute_budget_manager';

package/src/constants/index.ts

@@ -0,0 +1,96 @@
+/**
+ * Constants for Sol Trade SDK
+ */
+
+import { PublicKey } from '@solana/web3.js';
+
+// System programs
+export const SYSTEM_PROGRAM = new PublicKey('11111111111111111111111111111111');
+
+// Token programs
+export const TOKEN_PROGRAM = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+export const TOKEN_PROGRAM_2022 = new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');
+
+// Token mints
+export const SOL_TOKEN_ACCOUNT = new PublicKey('So11111111111111111111111111111111111111111');
+export const WSOL_TOKEN_ACCOUNT = new PublicKey('So11111111111111111111111111111111111111112');
+export const USD1_TOKEN_ACCOUNT = new PublicKey('USD1ttGY1N17NEEHLmELoaybftRBUSErhqYiQzvEmuB');
+export const USDC_TOKEN_ACCOUNT = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
+
+// Associated token program
+export const ASSOCIATED_TOKEN_PROGRAM = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+
+// Rent sysvar
+export const RENT = new PublicKey('SysvarRent111111111111111111111111111111111');
+
+// DEX Programs — aligned with sol-trade-sdk Rust (mainnet)
+export const PUMPFUN_PROGRAM = new PublicKey('6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P');
+/** PumpSwap AMM program (same as `instruction/pumpswap` PUMPSWAP_PROGRAM) */
+export const PUMPSWAP_PROGRAM_ID = new PublicKey('pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA');
+export const BONK_PROGRAM = new PublicKey('LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj');
+export const RAYDIUM_CPMM_PROGRAM = new PublicKey('CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C');
+export const RAYDIUM_AMM_V4_PROGRAM = new PublicKey('675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8');
+export const METEORA_DAMM_V2_PROGRAM = new PublicKey('cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG');
+
+// Fee recipients (generic SDK defaults)
+export const SDK_FEE_RECIPIENT = new PublicKey('CebN5WGQ4jvEPvsVU4EoHEpgzq1VV7AbicfhtW4Cs9tM');
+
+export const SDK_MAYHEM_FEE_RECIPIENTS: PublicKey[] = [
+  new PublicKey('7VtWHe8WJeU9Sy5j1XF5n8qPzDtJjWxMgYVtJ89AQrVj'),
+  new PublicKey('82jN8eGgPvMSW1KP9W6GdW4bQ3YbB7sGgC6BhZnLVQvR'),
+];
+
+// Instruction discriminators — aligned with `instruction/pumpfun_builder` / Rust
+export const PUMPFUN_DISCRIMINATORS = {
+  BUY: Buffer.from([102, 6, 61, 18, 1, 218, 235, 234]),
+  SELL: Buffer.from([51, 230, 133, 164, 1, 127, 131, 173]),
+  BUY_EXACT_SOL_IN: Buffer.from([56, 252, 116, 8, 158, 223, 205, 95]),
+  CLAIM_CASHBACK: Buffer.from([37, 58, 35, 126, 190, 53, 228, 197]),
+};
+
+export const PUMPSWAP_DISCRIMINATORS = {
+  SWAP: Buffer.from([43, 4, 237, 11, 26, 201, 30, 98]),
+  DEPOSIT: Buffer.from([242, 35, 198, 137, 82, 225, 242, 178]),
+  WITHDRAW: Buffer.from([183, 18, 178, 128, 70, 157, 46, 34]),
+};
+
+// Default values
+export const DEFAULT_SLIPPAGE = 500; // 5%
+export const DEFAULT_COMPUTE_UNITS = 200000;
+export const DEFAULT_PRIORITY_FEE = 100000;
+export const DEFAULT_TIP_LAMPORTS = 100000;
+
+/** Aggregate for consumers expecting a single `CONSTANTS` object (matches historical `index` export). */
+export const CONSTANTS = {
+  SYSTEM_PROGRAM,
+  TOKEN_PROGRAM,
+  TOKEN_PROGRAM_2022,
+  SOL_TOKEN_ACCOUNT,
+  WSOL_TOKEN_ACCOUNT,
+  USD1_TOKEN_ACCOUNT,
+  USDC_TOKEN_ACCOUNT,
+  ASSOCIATED_TOKEN_PROGRAM,
+  RENT,
+  PUMPFUN_PROGRAM,
+  PUMPSWAP_PROGRAM: PUMPSWAP_PROGRAM_ID,
+  BONK_PROGRAM,
+  RAYDIUM_CPMM_PROGRAM,
+  RAYDIUM_AMM_V4_PROGRAM,
+  METEORA_DAMM_V2_PROGRAM,
+  DEFAULT_SLIPPAGE,
+  DEFAULT_COMPUTE_UNITS,
+  DEFAULT_PRIORITY_FEE,
+  DEFAULT_TIP_LAMPORTS,
+} as const;
+
+// SWQOS endpoints
+export const SWQOS_ENDPOINTS: Record<string, Record<string, string>> = {
+  Jito: {
+    Frankfurt: 'frankfurt.mainnet.block-engine.jito.wtf',
+    NewYork: 'amsterdam.mainnet.block-engine.jito.wtf',
+    Amsterdam: 'amsterdam.mainnet.block-engine.jito.wtf',
+    Tokyo: 'tokyo.mainnet.block-engine.jito.wtf',
+    Singapore: 'singapore.mainnet.block-engine.jito.wtf',
+  },
+  // Add more SWQOS endpoints as needed
+};