sol-trade-sdk 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -27,7 +27,7 @@ import {
   DEFAULT_PRIORITY_FEE,
   DEFAULT_SLIPPAGE,
   DEFAULT_TIP_LAMPORTS,
-  DexType,
+  DexType2 as DexType,
   ExecutionPath,
   FilterMiddleware,
   GasFeeStrategy,
@@ -40,12 +40,15 @@ import {
   KNOWN_PROGRAM_IDS,
   KeyNotAvailableError,
   LoggingMiddleware,
+  MARKET_STATE_SIZE,
   MAX_INSTRUCTIONS_WARN,
   METEORA_DAMM_V2_AUTHORITY,
   METEORA_DAMM_V2_EVENT_AUTHORITY_SEED,
   METEORA_DAMM_V2_PROGRAM,
   METEORA_DAMM_V2_PROGRAM_ID,
+  METEORA_DAMM_V2_SWAP2_DISCRIMINATOR,
   METEORA_DAMM_V2_SWAP_DISCRIMINATOR,
+  METEORA_DAMM_V2_SWAP_MODE_PARTIAL_FILL,
   METEORA_POOL_SIZE,
   MeteoraDammV2Executor,
   MeteoraDammV2Params,
@@ -148,7 +151,7 @@ import {
   TradeError,
   TradeExecutorFactory,
   TradeTokenType,
-  TradeType,
+  TradeType2 as TradeType,
   TradingClient,
   TradingContext,
   TransactionBuilder,
@@ -191,18 +194,21 @@ import {
   createTradeConfig,
   decodeAmmInfo,
   decodeBonkPoolState,
+  decodeMarketState,
   decodeMeteoraPool,
   decodePool,
   decodeRaydiumCPMMpoolState,
   defaultExecuteOptions,
   defaultHotPathConfig,
   defaultTradeExecuteOptions,
+  deriveSerumVaultSigner,
   extractHintsFromLogs,
   fetchAddressLookupTableAccount,
   fetchAmmInfo,
   fetchBondingCurveAccount,
   fetchBonkPoolState,
   fetchDurableNonceInfo,
+  fetchMarketState,
   fetchMeteoraPool,
   fetchPool,
   fetchRaydiumCPMMpoolState,
@@ -261,6 +267,8 @@ import {
   nowMicroseconds,
   parseAddressLookupTable,
   pumpFunFeeRecipientMeta,
+  pumpFunParamsFromParserTrade,
+  pumpSwapParamsFromParserTrade,
   recommendedSenderThreadCoreIndices,
   retryWithBackoff,
   signWithKeypair,
@@ -276,10 +284,11 @@ import {
   validateTransactionSize,
   withAllBuiltinMiddlewares,
   withStandardMiddlewares
-} from "./chunk-NEZDFAYA.mjs";
+} from "./chunk-H4ZUMTTP.mjs";
 import {
   perf_exports
-} from "./chunk-MMQAMIKR.mjs";
+} from "./chunk-L6RZIXXN.mjs";
+import "./chunk-6BWS3CLP.mjs";
 export {
   AMM_INFO_SIZE,
   ASSOCIATED_TOKEN_PROGRAM,
@@ -322,12 +331,15 @@ export {
   KNOWN_PROGRAM_IDS,
   KeyNotAvailableError,
   LoggingMiddleware,
+  MARKET_STATE_SIZE,
   MAX_INSTRUCTIONS_WARN,
   METEORA_DAMM_V2_AUTHORITY,
   METEORA_DAMM_V2_EVENT_AUTHORITY_SEED,
   METEORA_DAMM_V2_PROGRAM,
   METEORA_DAMM_V2_PROGRAM_ID,
+  METEORA_DAMM_V2_SWAP2_DISCRIMINATOR,
   METEORA_DAMM_V2_SWAP_DISCRIMINATOR,
+  METEORA_DAMM_V2_SWAP_MODE_PARTIAL_FILL,
   METEORA_POOL_SIZE,
   MeteoraDammV2Executor,
   MeteoraDammV2Params,
@@ -473,18 +485,21 @@ export {
   createTradeConfig,
   decodeAmmInfo,
   decodeBonkPoolState,
+  decodeMarketState,
   decodeMeteoraPool,
   decodePool,
   decodeRaydiumCPMMpoolState,
   defaultExecuteOptions,
   defaultHotPathConfig,
   defaultTradeExecuteOptions,
+  deriveSerumVaultSigner,
   extractHintsFromLogs,
   fetchAddressLookupTableAccount,
   fetchAmmInfo,
   fetchBondingCurveAccount,
   fetchBonkPoolState,
   fetchDurableNonceInfo,
+  fetchMarketState,
   fetchMeteoraPool,
   fetchPool,
   fetchRaydiumCPMMpoolState,
@@ -544,6 +559,8 @@ export {
   parseAddressLookupTable,
   perf_exports as perf,
   pumpFunFeeRecipientMeta,
+  pumpFunParamsFromParserTrade,
+  pumpSwapParamsFromParserTrade,
   recommendedSenderThreadCoreIndices,
   retryWithBackoff,
   signWithKeypair,

package/dist/perf/index.mjs

@@ -104,7 +104,8 @@ import {
   spinLock,
   unlikely,
   yieldToEventLoop
-} from "../chunk-MMQAMIKR.mjs";
+} from "../chunk-L6RZIXXN.mjs";
+import "../chunk-6BWS3CLP.mjs";
 export {
   AlignedBuffer,
   AsyncSocket,

package/dist/pool/index.d.mts

@@ -0,0 +1,88 @@
+/**
+ * High-Performance Pool and Concurrency Utilities for Sol Trade SDK
+ */
+interface PoolStats {
+    activeTasks: number;
+    tasksCompleted: number;
+    queueSize: number;
+}
+/**
+ * High-performance worker pool for parallel task execution.
+ */
+declare class WorkerPool {
+    private taskQueue;
+    private activeWorkers;
+    private tasksCompleted;
+    private maxWorkers;
+    private maxQueueSize;
+    private idleResolvers;
+    constructor(workers?: number, maxQueueSize?: number);
+    submit<T>(task: () => Promise<T>): Promise<T>;
+    submitBatch<T>(tasks: Array<() => Promise<T>>): Promise<T[]>;
+    private processQueue;
+    idle(): Promise<void>;
+    getStats(): PoolStats;
+}
+/**
+ * Token bucket rate limiter.
+ */
+declare class RateLimiter {
+    private rate;
+    private burst;
+    private tokens;
+    private lastUpdate;
+    constructor(rate: number, burst?: number);
+    allow(): boolean;
+    wait(): Promise<void>;
+}
+/**
+ * Rate limiter with multiple keys.
+ */
+declare class MultiRateLimiter {
+    private rate;
+    private burst;
+    private limiters;
+    constructor(rate: number, burst?: number);
+    allow(key: string): boolean;
+    wait(key: string): Promise<void>;
+}
+interface Connection {
+    close(): void;
+    isAlive(): boolean;
+}
+/**
+ * Generic connection pool with automatic management.
+ */
+declare class ConnectionPool<T extends Connection> {
+    private factory;
+    private maxSize;
+    private timeout;
+    private pool;
+    private created;
+    private waiting;
+    constructor(factory: () => T, maxSize?: number, timeout?: number);
+    get(): Promise<T>;
+    release(conn: T): void;
+    private create;
+    closeAll(): void;
+    getStats(): {
+        created: number;
+        available: number;
+        waiting: number;
+    };
+}
+/**
+ * Generic object pool for reusing expensive objects.
+ */
+declare class ObjectPool<T> {
+    private factory;
+    private resetFunc?;
+    private maxSize;
+    private pool;
+    constructor(factory: () => T, resetFunc?: ((obj: T) => void) | undefined, maxSize?: number);
+    acquire(): T;
+    release(obj: T): void;
+    with<R>(fn: (obj: T) => R): R;
+}
+
+export { type Connection, ConnectionPool, MultiRateLimiter, ObjectPool, RateLimiter, WorkerPool };

package/dist/pool/index.d.ts

@@ -0,0 +1,88 @@
+/**
+ * High-Performance Pool and Concurrency Utilities for Sol Trade SDK
+ */
+interface PoolStats {
+    activeTasks: number;
+    tasksCompleted: number;
+    queueSize: number;
+}
+/**
+ * High-performance worker pool for parallel task execution.
+ */
+declare class WorkerPool {
+    private taskQueue;
+    private activeWorkers;
+    private tasksCompleted;
+    private maxWorkers;
+    private maxQueueSize;
+    private idleResolvers;
+    constructor(workers?: number, maxQueueSize?: number);
+    submit<T>(task: () => Promise<T>): Promise<T>;
+    submitBatch<T>(tasks: Array<() => Promise<T>>): Promise<T[]>;
+    private processQueue;
+    idle(): Promise<void>;
+    getStats(): PoolStats;
+}
+/**
+ * Token bucket rate limiter.
+ */
+declare class RateLimiter {
+    private rate;
+    private burst;
+    private tokens;
+    private lastUpdate;
+    constructor(rate: number, burst?: number);
+    allow(): boolean;
+    wait(): Promise<void>;
+}
+/**
+ * Rate limiter with multiple keys.
+ */
+declare class MultiRateLimiter {
+    private rate;
+    private burst;
+    private limiters;
+    constructor(rate: number, burst?: number);
+    allow(key: string): boolean;
+    wait(key: string): Promise<void>;
+}
+interface Connection {
+    close(): void;
+    isAlive(): boolean;
+}
+/**
+ * Generic connection pool with automatic management.
+ */
+declare class ConnectionPool<T extends Connection> {
+    private factory;
+    private maxSize;
+    private timeout;
+    private pool;
+    private created;
+    private waiting;
+    constructor(factory: () => T, maxSize?: number, timeout?: number);
+    get(): Promise<T>;
+    release(conn: T): void;
+    private create;
+    closeAll(): void;
+    getStats(): {
+        created: number;
+        available: number;
+        waiting: number;
+    };
+}
+/**
+ * Generic object pool for reusing expensive objects.
+ */
+declare class ObjectPool<T> {
+    private factory;
+    private resetFunc?;
+    private maxSize;
+    private pool;
+    constructor(factory: () => T, resetFunc?: ((obj: T) => void) | undefined, maxSize?: number);
+    acquire(): T;
+    release(obj: T): void;
+    with<R>(fn: (obj: T) => R): R;
+}
+
+export { type Connection, ConnectionPool, MultiRateLimiter, ObjectPool, RateLimiter, WorkerPool };

package/dist/pool/index.js

@@ -0,0 +1,262 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pool/index.ts
+var pool_exports = {};
+__export(pool_exports, {
+  ConnectionPool: () => ConnectionPool,
+  MultiRateLimiter: () => MultiRateLimiter,
+  ObjectPool: () => ObjectPool,
+  RateLimiter: () => RateLimiter,
+  WorkerPool: () => WorkerPool
+});
+module.exports = __toCommonJS(pool_exports);
+
+// src/pool/pool.ts
+var WorkerPool = class {
+  taskQueue = [];
+  activeWorkers = 0;
+  tasksCompleted = 0;
+  maxWorkers;
+  maxQueueSize;
+  idleResolvers = [];
+  constructor(workers = 4, maxQueueSize = 100) {
+    this.maxWorkers = workers;
+    this.maxQueueSize = maxQueueSize;
+  }
+  async submit(task) {
+    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(tasks) {
+    return Promise.all(tasks.map((task) => this.submit(task)));
+  }
+  async processQueue() {
+    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() {
+    if (this.activeWorkers === 0 && this.taskQueue.length === 0) {
+      return;
+    }
+    return new Promise((resolve) => {
+      this.idleResolvers.push(resolve);
+    });
+  }
+  getStats() {
+    return {
+      activeTasks: this.activeWorkers,
+      tasksCompleted: this.tasksCompleted,
+      queueSize: this.taskQueue.length
+    };
+  }
+};
+var RateLimiter = class {
+  constructor(rate, burst = 10) {
+    this.rate = rate;
+    this.burst = burst;
+    this.tokens = burst;
+    this.lastUpdate = Date.now();
+  }
+  rate;
+  burst;
+  tokens;
+  lastUpdate;
+  allow() {
+    const now = Date.now();
+    const elapsed = (now - this.lastUpdate) / 1e3;
+    this.lastUpdate = now;
+    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() {
+    while (!this.allow()) {
+      await new Promise((resolve) => setTimeout(resolve, 1));
+    }
+  }
+};
+var MultiRateLimiter = class {
+  constructor(rate, burst = 10) {
+    this.rate = rate;
+    this.burst = burst;
+  }
+  rate;
+  burst;
+  limiters = /* @__PURE__ */ new Map();
+  allow(key) {
+    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) {
+    while (!this.allow(key)) {
+      await new Promise((resolve) => setTimeout(resolve, 1));
+    }
+  }
+};
+var ConnectionPool = class {
+  constructor(factory, maxSize = 10, timeout = 3e4) {
+    this.factory = factory;
+    this.maxSize = maxSize;
+    this.timeout = timeout;
+  }
+  factory;
+  maxSize;
+  timeout;
+  pool = [];
+  created = 0;
+  waiting = 0;
+  async get() {
+    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();
+    }
+    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) {
+    if (!conn.isAlive()) {
+      this.created--;
+      return;
+    }
+    if (this.pool.length < this.maxSize) {
+      this.pool.push(conn);
+    } else {
+      conn.close();
+      this.created--;
+    }
+  }
+  create() {
+    const conn = this.factory();
+    this.created++;
+    return conn;
+  }
+  closeAll() {
+    for (const conn of this.pool) {
+      conn.close();
+    }
+    this.pool = [];
+    this.created = 0;
+  }
+  getStats() {
+    return {
+      created: this.created,
+      available: this.pool.length,
+      waiting: this.waiting
+    };
+  }
+};
+var ObjectPool = class {
+  constructor(factory, resetFunc, maxSize = 100) {
+    this.factory = factory;
+    this.resetFunc = resetFunc;
+    this.maxSize = maxSize;
+  }
+  factory;
+  resetFunc;
+  maxSize;
+  pool = [];
+  acquire() {
+    if (this.pool.length > 0) {
+      return this.pool.pop();
+    }
+    return this.factory();
+  }
+  release(obj) {
+    if (this.resetFunc) {
+      this.resetFunc(obj);
+    }
+    if (this.pool.length < this.maxSize) {
+      this.pool.push(obj);
+    }
+  }
+  with(fn) {
+    const obj = this.acquire();
+    try {
+      return fn(obj);
+    } finally {
+      this.release(obj);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectionPool,
+  MultiRateLimiter,
+  ObjectPool,
+  RateLimiter,
+  WorkerPool
+});