sol-trade-sdk 0.1.0

package/src/common/fast_fn.ts

@@ -0,0 +1,150 @@
+/**
+ * Fast functions with caching.
+ * Based on sol-trade-sdk Rust implementation.
+ */
+
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+
+// Instruction cache
+const instructionCache = new Map<string, TransactionInstruction[]>();
+
+// PDA cache
+const pdaCache = new Map<string, PublicKey>();
+
+// ATA cache
+const ataCache = new Map<string, PublicKey>();
+
+/**
+ * Get cached instruction or compute and cache
+ */
+export function getCachedInstructions(
+  cacheKey: string,
+  computeFn: () => TransactionInstruction[],
+): TransactionInstruction[] {
+  const cached = instructionCache.get(cacheKey);
+  if (cached) {
+    return [...cached];
+  }
+
+  const result = computeFn();
+  instructionCache.set(cacheKey, [...result]);
+  return result;
+}
+
+/**
+ * Fast ATA creation with caching
+ */
+export function createAssociatedTokenAccountIdempotentFast(
+  payer: PublicKey,
+  owner: PublicKey,
+  mint: PublicKey,
+  tokenProgram: PublicKey,
+): TransactionInstruction[] {
+  const cacheKey = `${payer.toBase58()}-${owner.toBase58()}-${mint.toBase58()}-${tokenProgram.toBase58()}`;
+
+  return getCachedInstructions(cacheKey, () => {
+    // Get ATA address
+    const ata = getAssociatedTokenAddressFast(owner, mint, tokenProgram);
+
+    // Create instruction data
+    // [1] = create idempotent
+    const data = Buffer.from([1, ...payer.toBytes(), ...ata.toBytes(), ...owner.toBytes(), ...mint.toBytes(), ...tokenProgram.toBytes()]);
+
+    // This is a simplified placeholder - actual implementation would use proper ATA program
+    return [];
+  });
+}
+
+/**
+ * Fast ATA address derivation with caching
+ */
+export function getAssociatedTokenAddressFast(
+  owner: PublicKey,
+  mint: PublicKey,
+  tokenProgram: PublicKey,
+): PublicKey {
+  const cacheKey = `${owner.toBase58()}-${mint.toBase58()}-${tokenProgram.toBase58()}`;
+
+  const cached = ataCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+
+  // Derive ATA (simplified - would use proper PDA derivation)
+  // ATA = find_program_address([owner, token_program, mint], associated_token_program)
+  const result = PublicKey.default; // Placeholder
+  ataCache.set(cacheKey, result);
+  return result;
+}
+
+/**
+ * Fast ATA address derivation with seed optimization
+ */
+export function getAssociatedTokenAddressWithProgramIdFastUseSeed(
+  owner: PublicKey,
+  mint: PublicKey,
+  tokenProgram: PublicKey,
+  useSeed: boolean = false,
+): PublicKey {
+  if (useSeed) {
+    // Use seed-optimized path
+    const cacheKey = `seed-${owner.toBase58()}-${mint.toBase58()}-${tokenProgram.toBase58()}`;
+    const cached = ataCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    // Derive with seed optimization
+    const result = PublicKey.default; // Placeholder
+    ataCache.set(cacheKey, result);
+    return result;
+  }
+
+  return getAssociatedTokenAddressFast(owner, mint, tokenProgram);
+}
+
+/**
+ * Create ATA with seed optimization
+ */
+export function createAssociatedTokenAccountIdempotentFastUseSeed(
+  payer: PublicKey,
+  owner: PublicKey,
+  mint: PublicKey,
+  tokenProgram: PublicKey,
+  useSeed: boolean = false,
+): TransactionInstruction[] {
+  if (useSeed) {
+    const cacheKey = `seed-create-${payer.toBase58()}-${owner.toBase58()}-${mint.toBase58()}-${tokenProgram.toBase58()}`;
+
+    return getCachedInstructions(cacheKey, () => {
+      // Seed-optimized ATA creation
+      return [];
+    });
+  }
+
+  return createAssociatedTokenAccountIdempotentFast(payer, owner, mint, tokenProgram);
+}
+
+/**
+ * Clear all caches (for testing)
+ */
+export function clearCaches(): void {
+  instructionCache.clear();
+  pdaCache.clear();
+  ataCache.clear();
+}
+
+/**
+ * Get cache statistics
+ */
+export function getCacheStats(): {
+  instructionCacheSize: number;
+  pdaCacheSize: number;
+  ataCacheSize: number;
+} {
+  return {
+    instructionCacheSize: instructionCache.size,
+    pdaCacheSize: pdaCache.size,
+    ataCacheSize: ataCache.size,
+  };
+}

package/src/common/gas-fee-strategy.ts

@@ -0,0 +1,253 @@
+/**
+ * Gas Fee Strategy for Sol Trade SDK
+ */
+
+// TradeType is defined in index.ts to avoid circular imports
+export enum TradeType {
+  Buy = 'Buy',
+  Sell = 'Sell',
+}
+
+// SwqosType is defined locally to avoid circular imports
+export enum SwqosType {
+  Default = 'Default',
+  Jito = 'Jito',
+  Bloxroute = 'Bloxroute',
+  ZeroSlot = 'ZeroSlot',
+  Temporal = 'Temporal',
+  FlashBlock = 'FlashBlock',
+  BlockRazor = 'BlockRazor',
+  Node1 = 'Node1',
+  Astralane = 'Astralane',
+  NextBlock = 'NextBlock',
+  Helius = 'Helius',
+  Stellium = 'Stellium',
+  Lightspeed = 'Lightspeed',
+  Soyas = 'Soyas',
+  Speedlanding = 'Speedlanding',
+  Triton = 'Triton',
+  QuickNode = 'QuickNode',
+  Syndica = 'Syndica',
+  Figment = 'Figment',
+  Alchemy = 'Alchemy',
+}
+
+export enum GasFeeStrategyType {
+  Normal = 'Normal',
+  LowTipHighCuPrice = 'LowTipHighCuPrice',
+  HighTipLowCuPrice = 'HighTipLowCuPrice',
+}
+
+export interface GasFeeStrategyValue {
+  cuLimit: number;
+  cuPrice: number;
+  tip: number;
+}
+
+interface StrategyKey {
+  swqosType: SwqosType;
+  tradeType: TradeType;
+  strategyType: GasFeeStrategyType;
+}
+
+export class GasFeeStrategy {
+  private strategies: Map<string, GasFeeStrategyValue> = new Map();
+
+  constructor() {}
+
+  /**
+   * Set global fee strategy for all SWQOS types
+   */
+  setGlobalFeeStrategy(
+    buyCuLimit: number,
+    sellCuLimit: number,
+    buyCuPrice: number,
+    sellCuPrice: number,
+    buyTip: number,
+    sellTip: number
+  ): void {
+    const allTypes = [
+      SwqosType.Jito,
+      SwqosType.NextBlock,
+      SwqosType.ZeroSlot,
+      SwqosType.Temporal,
+      SwqosType.Bloxroute,
+      SwqosType.Node1,
+      SwqosType.FlashBlock,
+      SwqosType.BlockRazor,
+      SwqosType.Astralane,
+      SwqosType.Stellium,
+      SwqosType.Lightspeed,
+      SwqosType.Soyas,
+      SwqosType.Speedlanding,
+      SwqosType.Helius,
+    ];
+
+    for (const swqosType of allTypes) {
+      this.set(swqosType, TradeType.Buy, GasFeeStrategyType.Normal, buyCuLimit, buyCuPrice, buyTip);
+      this.set(swqosType, TradeType.Sell, GasFeeStrategyType.Normal, sellCuLimit, sellCuPrice, sellTip);
+    }
+
+    // Default (RPC) has no tip
+    this.set(SwqosType.Default, TradeType.Buy, GasFeeStrategyType.Normal, buyCuLimit, buyCuPrice, 0);
+    this.set(SwqosType.Default, TradeType.Sell, GasFeeStrategyType.Normal, sellCuLimit, sellCuPrice, 0);
+  }
+
+  /**
+   * Set high-low fee strategies for multiple SWQOS types
+   */
+  setHighLowFeeStrategies(
+    swqosTypes: SwqosType[],
+    tradeType: TradeType,
+    cuLimit: number,
+    lowCuPrice: number,
+    highCuPrice: number,
+    lowTip: number,
+    highTip: number
+  ): void {
+    for (const swqosType of swqosTypes) {
+      this.delete(swqosType, tradeType, GasFeeStrategyType.Normal);
+      this.set(swqosType, tradeType, GasFeeStrategyType.LowTipHighCuPrice, cuLimit, highCuPrice, lowTip);
+      this.set(swqosType, tradeType, GasFeeStrategyType.HighTipLowCuPrice, cuLimit, lowCuPrice, highTip);
+    }
+  }
+
+  /**
+   * Set a specific gas fee strategy
+   */
+  set(
+    swqosType: SwqosType,
+    tradeType: TradeType,
+    strategyType: GasFeeStrategyType,
+    cuLimit: number,
+    cuPrice: number,
+    tip: number
+  ): void {
+    // Remove conflicting strategies
+    if (strategyType === GasFeeStrategyType.Normal) {
+      this.delete(swqosType, tradeType, GasFeeStrategyType.LowTipHighCuPrice);
+      this.delete(swqosType, tradeType, GasFeeStrategyType.HighTipLowCuPrice);
+    } else {
+      this.delete(swqosType, tradeType, GasFeeStrategyType.Normal);
+    }
+
+    const key = this.getKey(swqosType, tradeType, strategyType);
+    this.strategies.set(key, { cuLimit, cuPrice, tip });
+  }
+
+  /**
+   * Get a specific gas fee strategy
+   */
+  get(
+    swqosType: SwqosType,
+    tradeType: TradeType,
+    strategyType: GasFeeStrategyType
+  ): GasFeeStrategyValue | undefined {
+    const key = this.getKey(swqosType, tradeType, strategyType);
+    return this.strategies.get(key);
+  }
+
+  /**
+   * Delete a specific gas fee strategy
+   */
+  delete(swqosType: SwqosType, tradeType: TradeType, strategyType: GasFeeStrategyType): void {
+    const key = this.getKey(swqosType, tradeType, strategyType);
+    this.strategies.delete(key);
+  }
+
+  /**
+   * Delete all strategies for a SWQOS type and trade type
+   */
+  deleteAll(swqosType: SwqosType, tradeType: TradeType): void {
+    this.delete(swqosType, tradeType, GasFeeStrategyType.Normal);
+    this.delete(swqosType, tradeType, GasFeeStrategyType.LowTipHighCuPrice);
+    this.delete(swqosType, tradeType, GasFeeStrategyType.HighTipLowCuPrice);
+  }
+
+  /**
+   * Get all strategies for a trade type
+   */
+  getStrategies(tradeType: TradeType): Array<{
+    swqosType: SwqosType;
+    strategyType: GasFeeStrategyType;
+    value: GasFeeStrategyValue;
+  }> {
+    const results: Array<{
+      swqosType: SwqosType;
+      strategyType: GasFeeStrategyType;
+      value: GasFeeStrategyValue;
+    }> = [];
+
+    this.strategies.forEach((value, key) => {
+      const parsed = this.parseKey(key);
+      if (parsed.tradeType === tradeType) {
+        results.push({
+          swqosType: parsed.swqosType,
+          strategyType: parsed.strategyType,
+          value,
+        });
+      }
+    });
+
+    return results;
+  }
+
+  /**
+   * Update buy tip for all strategies
+   */
+  updateBuyTip(buyTip: number): void {
+    this.strategies.forEach((value, key) => {
+      const parsed = this.parseKey(key);
+      if (parsed.tradeType === TradeType.Buy) {
+        value.tip = buyTip;
+        this.strategies.set(key, value);
+      }
+    });
+  }
+
+  /**
+   * Update sell tip for all strategies
+   */
+  updateSellTip(sellTip: number): void {
+    this.strategies.forEach((value, key) => {
+      const parsed = this.parseKey(key);
+      if (parsed.tradeType === TradeType.Sell) {
+        value.tip = sellTip;
+        this.strategies.set(key, value);
+      }
+    });
+  }
+
+  /**
+   * Clear all strategies
+   */
+  clear(): void {
+    this.strategies.clear();
+  }
+
+  private getKey(
+    swqosType: SwqosType,
+    tradeType: TradeType,
+    strategyType: GasFeeStrategyType
+  ): string {
+    return `${swqosType}:${tradeType}:${strategyType}`;
+  }
+
+  private parseKey(key: string): StrategyKey {
+    const [swqosType, tradeType, strategyType] = key.split(':');
+    return {
+      swqosType: swqosType as SwqosType,
+      tradeType: tradeType as TradeType,
+      strategyType: strategyType as GasFeeStrategyType,
+    };
+  }
+}
+
+/**
+ * Create a new gas fee strategy with defaults
+ */
+export function createGasFeeStrategy(): GasFeeStrategy {
+  const strategy = new GasFeeStrategy();
+  strategy.setGlobalFeeStrategy(200000, 200000, 100000, 100000, 0.001, 0.001);
+  return strategy;
+}

package/src/common/map-pool.ts

@@ -0,0 +1,23 @@
+/**
+ * Bounded concurrency for async work (Rust SWQOS worker pool parity, best-effort in JS).
+ */
+
+export async function mapWithConcurrencyLimit<T, R>(
+  items: readonly T[],
+  concurrency: number,
+  fn: (item: T, index: number) => Promise<R>
+): Promise<R[]> {
+  if (items.length === 0) return [];
+  const limit = Math.max(1, Math.min(concurrency, items.length));
+  const results: R[] = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    for (;;) {
+      const i = next++;
+      if (i >= items.length) return;
+      results[i] = await fn(items[i]!, i);
+    }
+  };
+  await Promise.all(Array.from({ length: limit }, () => worker()));
+  return results;
+}

package/src/common/nonce.ts

@@ -0,0 +1,40 @@
+/**
+ * Durable nonce helpers — aligned with Rust `src/common/nonce_cache.rs` `fetch_nonce_info`.
+ */
+
+import { Connection, PublicKey } from '@solana/web3.js';
+import bs58 from 'bs58';
+
+/** Same shape as `DurableNonceInfo` in `index.ts` (used for `buy`/`sell` without circular imports). */
+export interface FetchedDurableNonce {
+  nonceAccount: PublicKey;
+  authority: PublicKey;
+  /** Base58-encoded current nonce blockhash (32 bytes), for `recentBlockhash` / `nonceHash`. */
+  nonceHash: string;
+  /** Duplicate of `nonceHash` for parity with existing `DurableNonceInfo.recentBlockhash`. */
+  recentBlockhash: string;
+}
+
+/**
+ * Fetch durable nonce authority + current blockhash from a nonce account (RPC).
+ * Layout matches Rust: version (4) + authority_type (4) + authority (32) + blockhash (32) starting at offset 40.
+ */
+export async function fetchDurableNonceInfo(
+  connection: Pick<Connection, 'getAccountInfo'>,
+  nonceAccount: PublicKey
+): Promise<FetchedDurableNonce | null> {
+  const account = await connection.getAccountInfo(nonceAccount);
+  if (!account?.data || account.data.length < 72) {
+    return null;
+  }
+  const data = Buffer.from(account.data);
+  const authority = new PublicKey(data.subarray(8, 40));
+  const hashBytes = data.subarray(40, 72);
+  const nonceHash = bs58.encode(hashBytes);
+  return {
+    nonceAccount,
+    authority,
+    nonceHash,
+    recentBlockhash: nonceHash,
+  };
+}