sol-trade-sdk 0.1.0

package/src/pool/pool.ts

@@ -0,0 +1,294 @@
+/**
+ * High-Performance Pool and Concurrency Utilities for Sol Trade SDK
+ */
+
+// ===== Types =====
+
+interface PoolStats {
+  activeTasks: number;
+  tasksCompleted: number;
+  queueSize: number;
+}
+
+// ===== Worker Pool =====
+
+/**
+ * High-performance worker pool for parallel task execution.
+ */
+export class WorkerPool {
+  private taskQueue: Array<() => Promise<any>> = [];
+  private activeWorkers = 0;
+  private tasksCompleted = 0;
+  private maxWorkers: number;
+  private maxQueueSize: number;
+  private idleResolvers: Array<() => void> = [];
+
+  constructor(workers: number = 4, maxQueueSize: number = 100) {
+    this.maxWorkers = workers;
+    this.maxQueueSize = maxQueueSize;
+  }
+
+  async submit<T>(task: () => Promise<T>): Promise<T> {
+    if (this.taskQueue.length >= this.maxQueueSize) {
+      throw new Error('Task queue is full');
+    }
+
+    return new Promise((resolve, reject) => {
+      this.taskQueue.push(async () => {
+        try {
+          const result = await task();
+          resolve(result);
+          return result;
+        } catch (error) {
+          reject(error);
+          throw error;
+        }
+      });
+      this.processQueue();
+    });
+  }
+
+  async submitBatch<T>(tasks: Array<() => Promise<T>>): Promise<T[]> {
+    return Promise.all(tasks.map(task => this.submit(task)));
+  }
+
+  private async processQueue(): Promise<void> {
+    while (this.taskQueue.length > 0 && this.activeWorkers < this.maxWorkers) {
+      const task = this.taskQueue.shift()!;
+      this.activeWorkers++;
+
+      try {
+        await task();
+      } finally {
+        this.activeWorkers--;
+        this.tasksCompleted++;
+        this.processQueue();
+      }
+    }
+
+    if (this.activeWorkers === 0 && this.taskQueue.length === 0) {
+      this.idleResolvers.forEach(resolve => resolve());
+      this.idleResolvers = [];
+    }
+  }
+
+  async idle(): Promise<void> {
+    if (this.activeWorkers === 0 && this.taskQueue.length === 0) {
+      return;
+    }
+    return new Promise(resolve => {
+      this.idleResolvers.push(resolve);
+    });
+  }
+
+  getStats(): PoolStats {
+    return {
+      activeTasks: this.activeWorkers,
+      tasksCompleted: this.tasksCompleted,
+      queueSize: this.taskQueue.length,
+    };
+  }
+}
+
+// ===== Rate Limiter =====
+
+/**
+ * Token bucket rate limiter.
+ */
+export class RateLimiter {
+  private tokens: number;
+  private lastUpdate: number;
+
+  constructor(
+    private rate: number,
+    private burst: number = 10
+  ) {
+    this.tokens = burst;
+    this.lastUpdate = Date.now();
+  }
+
+  allow(): boolean {
+    const now = Date.now();
+    const elapsed = (now - this.lastUpdate) / 1000;
+    this.lastUpdate = now;
+
+    // Add tokens based on elapsed time
+    this.tokens += elapsed * this.rate;
+    if (this.tokens > this.burst) {
+      this.tokens = this.burst;
+    }
+
+    if (this.tokens >= 1) {
+      this.tokens--;
+      return true;
+    }
+    return false;
+  }
+
+  async wait(): Promise<void> {
+    while (!this.allow()) {
+      await new Promise(resolve => setTimeout(resolve, 1));
+    }
+  }
+}
+
+// ===== Multi Rate Limiter =====
+
+/**
+ * Rate limiter with multiple keys.
+ */
+export class MultiRateLimiter {
+  private limiters: Map<string, RateLimiter> = new Map();
+
+  constructor(
+    private rate: number,
+    private burst: number = 10
+  ) {}
+
+  allow(key: string): boolean {
+    let limiter = this.limiters.get(key);
+    if (!limiter) {
+      limiter = new RateLimiter(this.rate, this.burst);
+      this.limiters.set(key, limiter);
+    }
+    return limiter.allow();
+  }
+
+  async wait(key: string): Promise<void> {
+    while (!this.allow(key)) {
+      await new Promise(resolve => setTimeout(resolve, 1));
+    }
+  }
+}
+
+// ===== Connection Pool =====
+
+export interface Connection {
+  close(): void;
+  isAlive(): boolean;
+}
+
+/**
+ * Generic connection pool with automatic management.
+ */
+export class ConnectionPool<T extends Connection> {
+  private pool: T[] = [];
+  private created = 0;
+  private waiting = 0;
+
+  constructor(
+    private factory: () => T,
+    private maxSize: number = 10,
+    private timeout: number = 30000
+  ) {}
+
+  async get(): Promise<T> {
+    if (this.pool.length > 0) {
+      const conn = this.pool.pop()!;
+      if (conn.isAlive()) {
+        return conn;
+      }
+      this.created--;
+      return this.create();
+    }
+
+    if (this.created < this.maxSize) {
+      return this.create();
+    }
+
+    // Wait for available connection
+    this.waiting++;
+    const startTime = Date.now();
+    
+    while (Date.now() - startTime < this.timeout) {
+      await new Promise(resolve => setTimeout(resolve, 10));
+      if (this.pool.length > 0) {
+        const conn = this.pool.pop()!;
+        if (conn.isAlive()) {
+          this.waiting--;
+          return conn;
+        }
+        this.created--;
+      }
+    }
+
+    this.waiting--;
+    throw new Error('Connection timeout');
+  }
+
+  release(conn: T): void {
+    if (!conn.isAlive()) {
+      this.created--;
+      return;
+    }
+
+    if (this.pool.length < this.maxSize) {
+      this.pool.push(conn);
+    } else {
+      conn.close();
+      this.created--;
+    }
+  }
+
+  private create(): T {
+    const conn = this.factory();
+    this.created++;
+    return conn;
+  }
+
+  closeAll(): void {
+    for (const conn of this.pool) {
+      conn.close();
+    }
+    this.pool = [];
+    this.created = 0;
+  }
+
+  getStats(): { created: number; available: number; waiting: number } {
+    return {
+      created: this.created,
+      available: this.pool.length,
+      waiting: this.waiting,
+    };
+  }
+}
+
+// ===== Object Pool =====
+
+/**
+ * Generic object pool for reusing expensive objects.
+ */
+export class ObjectPool<T> {
+  private pool: T[] = [];
+
+  constructor(
+    private factory: () => T,
+    private resetFunc?: (obj: T) => void,
+    private maxSize: number = 100
+  ) {}
+
+  acquire(): T {
+    if (this.pool.length > 0) {
+      return this.pool.pop()!;
+    }
+    return this.factory();
+  }
+
+  release(obj: T): void {
+    if (this.resetFunc) {
+      this.resetFunc(obj);
+    }
+    if (this.pool.length < this.maxSize) {
+      this.pool.push(obj);
+    }
+  }
+
+  with<R>(fn: (obj: T) => R): R {
+    const obj = this.acquire();
+    try {
+      return fn(obj);
+    } finally {
+      this.release(obj);
+    }
+  }
+}

package/src/rpc/client.ts

@@ -0,0 +1,345 @@
+/**
+ * High-Performance RPC Client for Sol Trade SDK
+ * Provides async methods for Solana RPC communication.
+ */
+
+import { TTLCache, ShardedCache } from '../cache/cache';
+
+// ===== Types =====
+
+interface RPCConfig {
+  endpoint: string;
+  timeout?: number;
+  maxRetries?: number;
+  retryDelay?: number;
+  headers?: Record<string, string>;
+  maxConnections?: number;
+}
+
+interface AccountInfo {
+  lamports: number;
+  data: Buffer;
+  owner: string;
+  executable: boolean;
+  rentEpoch: number;
+}
+
+interface BlockhashResult {
+  blockhash: string;
+  lastValidBlockHeight: number;
+}
+
+interface SignatureStatus {
+  slot: number;
+  confirmations?: number;
+  err?: any;
+  confirmationStatus: string;
+}
+
+interface SimulateResult {
+  err?: any;
+  accounts?: AccountInfo[];
+  unitsConsumed: number;
+  returnData?: {
+    data: Buffer;
+    programId: string;
+  };
+}
+
+interface JsonRpcResponse<T> {
+  result?: T;
+  error?: {
+    code?: number;
+    message?: string;
+  };
+}
+
+// ===== RPC Error =====
+
+export class RPCError extends Error {
+  constructor(public code: number, message: string) {
+    super(`RPC Error ${code}: ${message}`);
+    this.name = 'RPCError';
+  }
+}
+
+// ===== Async RPC Client =====
+
+/**
+ * High-performance async RPC client.
+ */
+export class AsyncRPCClient {
+  private requestId = 0;
+  private requestsCount = 0;
+  private errorCount = 0;
+  private totalLatency = 0;
+
+  // Caches
+  private blockhashCache = new TTLCache<string, string>(2000);
+  private accountCache = new ShardedCache<string, Buffer>(16, 500, 10000);
+
+  constructor(private config: RPCConfig) {}
+
+  private async makeRequest<T>(method: string, params: any[] = []): Promise<T> {
+    this.requestId++;
+    this.requestsCount++;
+
+    const payload = {
+      jsonrpc: '2.0',
+      id: this.requestId,
+      method,
+      params,
+    };
+
+    const startTime = Date.now();
+
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.config.timeout || 30000);
+
+      const response = await fetch(this.config.endpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...this.config.headers,
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeout);
+
+      const data = await response.json() as JsonRpcResponse<T>;
+
+      if (data.error) {
+        this.errorCount++;
+        throw new RPCError(
+          data.error.code || -1,
+          data.error.message || 'Unknown error'
+        );
+      }
+
+      return data.result as T;
+    } catch (error) {
+      this.errorCount++;
+      if (error instanceof RPCError) throw error;
+      throw new RPCError(-1, error instanceof Error ? error.message : 'Unknown error');
+    } finally {
+      this.totalLatency += Date.now() - startTime;
+    }
+  }
+
+  // ===== Core Methods =====
+
+  async getBalance(pubkey: string, commitment: string = 'confirmed'): Promise<number> {
+    const result = await this.makeRequest<{ value: number }>('getBalance', [
+      pubkey,
+      { commitment },
+    ]);
+    return result.value;
+  }
+
+  async getAccountInfo(
+    pubkey: string,
+    encoding: string = 'base64',
+    commitment: string = 'confirmed'
+  ): Promise<AccountInfo | null> {
+    // Check cache
+    const cached = this.accountCache.get(pubkey);
+    if (cached) {
+      return {
+        lamports: 0,
+        data: cached,
+        owner: '',
+        executable: false,
+        rentEpoch: 0,
+      };
+    }
+
+    const result = await this.makeRequest<{ value: any }>('getAccountInfo', [
+      pubkey,
+      { encoding, commitment },
+    ]);
+
+    if (!result.value) {
+      return null;
+    }
+
+    const data = result.value.data;
+    let rawData: Buffer;
+
+    if (Array.isArray(data) && data[0]) {
+      rawData = Buffer.from(data[0], 'base64');
+    } else {
+      rawData = Buffer.alloc(0);
+    }
+
+    this.accountCache.set(pubkey, rawData);
+
+    return {
+      lamports: result.value.lamports || 0,
+      data: rawData,
+      owner: result.value.owner || '',
+      executable: result.value.executable || false,
+      rentEpoch: result.value.rentEpoch || 0,
+    };
+  }
+
+  async getMultipleAccounts(
+    pubkeys: string[],
+    encoding: string = 'base64',
+    commitment: string = 'confirmed'
+  ): Promise<(AccountInfo | null)[]> {
+    const result = await this.makeRequest<{ value: any[] }>('getMultipleAccounts', [
+      pubkeys,
+      { encoding, commitment },
+    ]);
+
+    return (result.value || []).map((value: any) => {
+      if (!value) return null;
+
+      const data = value.data;
+      let rawData: Buffer;
+
+      if (Array.isArray(data) && data[0]) {
+        rawData = Buffer.from(data[0], 'base64');
+      } else {
+        rawData = Buffer.alloc(0);
+      }
+
+      return {
+        lamports: value.lamports || 0,
+        data: rawData,
+        owner: value.owner || '',
+        executable: value.executable || false,
+        rentEpoch: value.rentEpoch || 0,
+      };
+    });
+  }
+
+  async getLatestBlockhash(commitment: string = 'confirmed'): Promise<BlockhashResult> {
+    // Check cache
+    const cached = this.blockhashCache.get('latest');
+    if (cached) {
+      return {
+        blockhash: cached,
+        lastValidBlockHeight: 0,
+      };
+    }
+
+    const result = await this.makeRequest<BlockhashResult>('getLatestBlockhash', [
+      { commitment },
+    ]);
+
+    this.blockhashCache.set('latest', result.blockhash);
+
+    return {
+      blockhash: result.blockhash,
+      lastValidBlockHeight: result.lastValidBlockHeight,
+    };
+  }
+
+  async getSignatureStatuses(
+    signatures: string[],
+    searchTransactionHistory: boolean = false
+  ): Promise<(SignatureStatus | null)[]> {
+    const result = await this.makeRequest<{ value: any[] }>('getSignatureStatuses', [
+      signatures,
+      { searchTransactionHistory },
+    ]);
+
+    return (result.value || []).map((value: any) => {
+      if (!value) return null;
+
+      return {
+        slot: value.slot || 0,
+        confirmations: value.confirmations,
+        err: value.err,
+        confirmationStatus: value.confirmationStatus || 'processed',
+      };
+    });
+  }
+
+  async sendTransaction(
+    transaction: Buffer,
+    options: {
+      skipPreflight?: boolean;
+      preflightCommitment?: string;
+    } = {}
+  ): Promise<string> {
+    const encoded = transaction.toString('base64');
+
+    return this.makeRequest<string>('sendTransaction', [
+      encoded,
+      {
+        encoding: 'base64',
+        skipPreflight: options.skipPreflight || false,
+        preflightCommitment: options.preflightCommitment || 'confirmed',
+      },
+    ]);
+  }
+
+  async simulateTransaction(
+    transaction: Buffer,
+    options: {
+      sigVerify?: boolean;
+    } = {}
+  ): Promise<SimulateResult> {
+    const encoded = transaction.toString('base64');
+
+    const result = await this.makeRequest<{ value: any }>('simulateTransaction', [
+      encoded,
+      {
+        encoding: 'base64',
+        sigVerify: options.sigVerify || false,
+      },
+    ]);
+
+    return {
+      err: result.value?.err,
+      accounts: result.value?.accounts,
+      unitsConsumed: result.value?.unitsConsumed || 0,
+      returnData: result.value?.returnData,
+    };
+  }
+
+  // ===== Utility Methods =====
+
+  /** Rust `poll_any_transaction_confirmation`: success when err is none and status is confirmed or finalized. */
+  async waitForConfirmation(
+    signature: string,
+    timeout: number = 30000,
+    pollInterval: number = 1000
+  ): Promise<boolean> {
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < timeout) {
+      const statuses = await this.getSignatureStatuses([signature]);
+      const status = statuses[0];
+
+      if (status) {
+        if (status.err) {
+          return false;
+        }
+        const cs = status.confirmationStatus;
+        if (cs === 'confirmed' || cs === 'finalized') {
+          return true;
+        }
+      }
+
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+
+    return false;
+  }
+
+  getStats(): { requests: number; errors: number; avgLatencyMs: number } {
+    return {
+      requests: this.requestsCount,
+      errors: this.errorCount,
+      avgLatencyMs: this.requestsCount > 0
+        ? this.totalLatency / this.requestsCount
+        : 0,
+    };
+  }
+}

package/src/sdk-errors.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared SDK errors (avoids circular imports with `index` / `swqos`).
+ */
+export class TradeError extends Error {
+  constructor(
+    public code: number,
+    message: string,
+    public cause?: Error
+  ) {
+    super(message);
+    this.name = 'TradeError';
+  }
+}

package/src/security/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Security module for Sol Trade SDK
+ *
+ * Provides secure key storage and input validation
+ */
+
+export {
+  SecureKeyStorage,
+  SecureKeyError,
+  KeyNotAvailableError,
+  signWithKeypair,
+  type KeyMetadata,
+} from './secure-key';
+
+export {
+  ValidationError,
+  KNOWN_PROGRAM_IDS,
+  validateRpcUrl,
+  validateProgramId,
+  validateAmount,
+  validateSlippage,
+  validatePubkey,
+  validateMintPair,
+  validateTransactionSize,
+  validateSignature,
+} from './validators';