@cexyio/cexy 0.1.0-dev.4 → 0.1.0-dev.6

package/dist/index.js

@@ -29,6 +29,16 @@ var OrderStateUnknownError = class extends CexyError {
     this.clientOrderId = clientOrderId;
   }
 };
+var CancelAllInterruptedError = class extends CexyError {
+  error;
+  partial;
+  constructor(error, partial) {
+    const what = error instanceof CexyApiError ? `${error.code}: ${error.message}` : String(error);
+    super(`cancelAll stopped after ${partial.rounds} round(s): ${what}`, { cause: error });
+    this.error = error;
+    this.partial = partial;
+  }
+};
 var CexyApiError = class extends CexyError {
   status;
   code;
@@ -127,27 +137,30 @@ var KNOWN_CODES = /* @__PURE__ */ new Set([
   "INTERNAL",
   "SERVICE_UNAVAILABLE",
   "UNDER_MAINTENANCE",
-  "ENGINE_OVERLOADED"
+  "ENGINE_OVERLOADED",
+  "PRICE_UNAVAILABLE"
 ]);
 var CLIENT_ERROR_CODES = { UNEXPECTED_REDIRECT: "UNEXPECTED_REDIRECT" };
 function isKnownErrorCode(code) {
   return KNOWN_CODES.has(code);
 }
 var DEFAULT_RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var MAX_SERVER_WAIT_MS = 12e4;
 function retryAfterMs(headers, details) {
   let best = null;
-  const h = headers?.get("retry-after");
+  const h = headers?.get("retry-after")?.trim();
   if (h) {
-    const secs = Number(h);
-    if (Number.isFinite(secs)) best = Math.max(0, secs * 1e3);
-    else {
+    if (/^\d+(\.\d+)?$/.test(h)) {
+      const ms = Number(h) * 1e3;
+      if (Number.isFinite(ms)) best = ms;
+    } else if (/[a-z]/i.test(h)) {
       const at = Date.parse(h);
-      if (!Number.isNaN(at)) best = Math.max(0, at - Date.now());
+      if (Number.isFinite(at)) best = Math.max(0, at - Date.now());
     }
   }
   const d = details?.["retry_after_seconds"];
-  const ds = typeof d === "number" ? d : typeof d === "string" ? Number(d) : NaN;
-  if (Number.isFinite(ds)) best = Math.max(best ?? 0, ds * 1e3);
+  const ds = typeof d === "number" ? d : typeof d === "string" && /^\d+(\.\d+)?$/.test(d.trim()) ? Number(d) : NaN;
+  if (Number.isFinite(ds) && ds >= 0 && Number.isFinite(ds * 1e3)) best = Math.max(best ?? 0, ds * 1e3);
   return best;
 }
 function errorFromResponse(status, body, headers, redact = (t) => t) {
@@ -310,6 +323,7 @@ var OPERATIONS = {
 };
 
 // src/http.ts
+var IDEMPOTENT_OPS = /* @__PURE__ */ new Set(["join_pool", "exit_pool"]);
 var BACKOFF_BASE_MS = 500;
 var BACKOFF_MAX_MS = 1e4;
 var Transport = class {
@@ -318,16 +332,15 @@ var Transport = class {
     this.config = config;
   }
   /**
-   * Sends a request with the standard retry policy: GETs retry on retryable errors and
-   * network failures. Mutations carry an `Idempotency-Key` reused on every attempt; the server
-   * honours it on pool join/exit, which makes their retries safe. The other mutations routed
-   * here (cancel-all) are naturally repeatable. `placeOrder` and `cancelOrder` use
+   * Sends a request with the standard retry policy: retryable errors and network failures are
+   * retried. Pool join/exit carry an `Idempotency-Key` reused on every attempt (the server
+   * honours it there, which makes their retries safe); the other mutations routed here
+   * (cancel-all) are naturally repeatable and send no key. `placeOrder` and `cancelOrder` use
    * `attempt()` with their own policies.
    */
   async request(spec, opts = {}) {
     const info = OPERATIONS[spec.op];
-    const isMutation = info.method !== "GET";
-    const idempotencyKey = isMutation ? spec.idempotencyKey ?? opts.idempotencyKey ?? newId() : void 0;
+    const idempotencyKey = IDEMPOTENT_OPS.has(spec.op) ? spec.idempotencyKey ?? opts.idempotencyKey ?? newId() : void 0;
     const maxRetries = opts.maxRetries ?? this.config.maxRetries;
     for (let attempt = 0; ; attempt++) {
       try {
@@ -338,8 +351,13 @@ var Transport = class {
       }
     }
   }
-  /** Waits before retry number `attempt + 1`, honouring server hints. */
+  /**
+   * Waits before retry number `attempt + 1`, honouring server hints. A server hint longer than
+   * `MAX_SERVER_WAIT_MS` is not waited: `err` is thrown at once (it still carries the hint).
+   */
   async backoff(op2, info, attempt, err, idempotencyKey, signal) {
+    const hint = serverHintMs(err);
+    if (hint !== null && hint > MAX_SERVER_WAIT_MS) throw err;
     const delayMs = this.retryDelay(attempt, err);
     this.config.onRetry?.({
       operation: op2,
@@ -354,8 +372,8 @@ var Transport = class {
   }
   /** Full-jitter exponential backoff, or the server's hint plus a little jitter. */
   retryDelay(attempt, err) {
-    const hint = err instanceof RateLimitError ? err.retryAfterMs : err instanceof CexyApiError ? retryAfterMs(void 0, err.details) : null;
-    if (hint !== null && hint > 0) return Math.ceil(hint + this.config.random() * 250);
+    const hint = serverHintMs(err);
+    if (hint !== null && hint > 0 && hint <= MAX_SERVER_WAIT_MS) return Math.ceil(hint + this.config.random() * 250);
     const cap = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** attempt);
     return Math.ceil(this.config.random() * cap);
   }
@@ -370,7 +388,7 @@ var Transport = class {
       body = JSON.stringify(spec.body);
       headers.set("Content-Type", "application/json");
     }
-    if (info.method !== "GET" && spec.idempotencyKey) headers.set("Idempotency-Key", spec.idempotencyKey);
+    if (IDEMPOTENT_OPS.has(spec.op) && spec.idempotencyKey) headers.set("Idempotency-Key", spec.idempotencyKey);
     if (info.auth === "api_key") {
       const auth = this.config.authenticator;
       if (!auth) {
@@ -453,6 +471,11 @@ var Transport = class {
     return this.config.authenticator ? this.config.authenticator.redact(text) : text;
   }
 };
+function serverHintMs(err) {
+  if (err instanceof RateLimitError) return err.retryAfterMs;
+  if (err instanceof CexyApiError) return retryAfterMs(void 0, err.details);
+  return null;
+}
 function isRetryable(err) {
   if (err instanceof CexyConnectionError) return true;
   if (err instanceof CexyApiError) return err.retryable || err.code === "CONCURRENT_MODIFICATION";
@@ -484,6 +507,7 @@ function errMessage(err) {
 }
 
 // src/limiter.ts
+var MAX_BLOCK_MS = 12e4;
 var RateLimiter = class {
   #rpm;
   #tokens;
@@ -517,14 +541,25 @@ var RateLimiter = class {
         return;
       }
       const msPerToken = 6e4 / this.#rpm;
-      await this.#sleep(Math.ceil((1 - this.#tokens) * msPerToken), signal);
+      await this.#sleep(Math.min(MAX_BLOCK_MS, Math.ceil((1 - this.#tokens) * msPerToken)), signal);
     }
   }
+  /**
+   * How long `acquire()` would wait right now, in ms (0 when a request may go at once). Lets a
+   * caller with a time budget, such as the cancelAll untilDone loop, count the limiter's wait.
+   */
+  pendingWaitMs() {
+    this.#refill();
+    const block = this.#blockedUntil - this.#now();
+    if (block > 0) return block;
+    if (this.#tokens >= 1) return 0;
+    return Math.min(MAX_BLOCK_MS, Math.ceil((1 - this.#tokens) * (6e4 / this.#rpm)));
+  }
   /** Adapts to the server's rate-limit headers. Never raises the configured limit. */
   update(headers) {
     this.#refill();
     const limit = num(headers.get("x-ratelimit-limit"));
-    if (limit !== null && limit > 0 && limit < this.#rpm) {
+    if (limit !== null && limit >= 1 && limit < this.#rpm) {
       this.#rpm = limit;
       this.#tokens = Math.min(this.#tokens, limit);
     }
@@ -536,10 +571,13 @@ var RateLimiter = class {
       else this.blockFor(6e4 / this.#rpm);
     }
   }
-  /** Blocks all requests for `ms` (used for 429 Retry-After). */
+  /**
+   * Blocks all requests for `ms` (used for 429 Retry-After and `X-RateLimit-Reset`). Server
+   * hints are untrusted: non-finite values are ignored and the block is capped at 120 s.
+   */
   blockFor(ms) {
-    if (!(ms > 0)) return;
-    this.#blockedUntil = Math.max(this.#blockedUntil, this.#now() + ms);
+    if (!(ms > 0) || !Number.isFinite(ms)) return;
+    this.#blockedUntil = Math.max(this.#blockedUntil, this.#now() + Math.min(ms, MAX_BLOCK_MS));
   }
   #refill() {
     const now = this.#now();
@@ -791,6 +829,12 @@ var WalletResource = class extends Resource {
 };
 var CANCEL_RETRY_CODES = /* @__PURE__ */ new Set(["INVALID_STATE", "SERVICE_UNAVAILABLE"]);
 var CANCEL_BACKOFF_S = [1, 2, 4, 8, 15];
+function errorCode(err) {
+  if (err instanceof CexyApiError) return err.code;
+  if (err instanceof CexyTimeoutError) return "TIMEOUT";
+  if (err instanceof CexyConnectionError) return "CONNECTION_ERROR";
+  return "ERROR";
+}
 var ORDER_AMOUNT_FIELDS = ["price", "quantity", "quote_quantity", "stop_price"];
 var TradingResource = class extends Resource {
   /** Open orders, optionally filtered by market/status. */
@@ -821,7 +865,7 @@ var TradingResource = class extends Resource {
    *
    * Retry safety rests on `client_order_id` (generated as a UUID when absent): it is unique
    * per account and the server refuses a repeat before any funds move. The server does NOT
-   * honour `Idempotency-Key` on orders (the header is sent but gives no protection). After an
+   * honour `Idempotency-Key` on orders, so none is sent. After an
    * ambiguous failure (network error, timeout or 5xx) the SDK first looks the order up by
    * `client_order_id` and returns it if it exists (`recovered: true`); only if it does not
    * exist does it send the order again, with the same `client_order_id`, so a late-arriving
@@ -836,12 +880,11 @@ var TradingResource = class extends Resource {
     assertAmountFields(order, ORDER_AMOUNT_FIELDS, "placeOrder");
     const clientOrderId = order.client_order_id ?? newId();
     const body = { ...order, client_order_id: clientOrderId };
-    const idempotencyKey = opts.idempotencyKey ?? newId();
     const maxRetries = opts.maxRetries ?? this.t.config.maxRetries;
     const info = OPERATIONS.place_order;
     for (let attempt = 0; ; attempt++) {
       try {
-        const raw = await this.t.attempt({ op: "place_order", body, idempotencyKey }, opts);
+        const raw = await this.t.attempt({ op: "place_order", body }, opts);
         const data = raw.data.data;
         return { ...data, client_order_id: clientOrderId, recovered: false };
       } catch (err) {
@@ -851,11 +894,11 @@ var TradingResource = class extends Resource {
           const existing = await this.#lookup(clientOrderId, err, opts);
           if (existing) return { order: existing, fills: [], client_order_id: clientOrderId, recovered: true };
           if (duplicateAfterRetry || attempt >= maxRetries) throw err;
-          await this.t.backoff("place_order", info, attempt, err, idempotencyKey, opts.signal);
+          await this.t.backoff("place_order", info, attempt, err, void 0, opts.signal);
           continue;
         }
         if (isRetryable(err) && attempt < maxRetries) {
-          await this.t.backoff("place_order", info, attempt, err, idempotencyKey, opts.signal);
+          await this.t.backoff("place_order", info, attempt, err, void 0, opts.signal);
           continue;
         }
         throw err;
@@ -879,10 +922,9 @@ var TradingResource = class extends Resource {
   async cancelOrder(orderId, opts = {}) {
     const maxRetries = opts.maxRetries ?? this.t.config.maxRetries;
     const info = OPERATIONS.cancel_order;
-    const idempotencyKey = opts.idempotencyKey ?? newId();
     for (let attempt = 0; ; attempt++) {
       try {
-        const raw = await this.t.attempt({ op: "cancel_order", pathParams: { order_id: orderId }, idempotencyKey }, opts);
+        const raw = await this.t.attempt({ op: "cancel_order", pathParams: { order_id: orderId } }, opts);
         return raw.data.data;
       } catch (err) {
         if (opts.signal?.aborted) throw err;
@@ -890,7 +932,7 @@ var TradingResource = class extends Resource {
           return this.order(orderId, { signal: opts.signal, timeoutMs: opts.timeoutMs });
         }
         if (isRetryable(err) && attempt < maxRetries) {
-          await this.t.backoff("cancel_order", info, attempt, err, idempotencyKey, opts.signal);
+          await this.t.backoff("cancel_order", info, attempt, err, void 0, opts.signal);
           continue;
         }
         throw err;
@@ -904,7 +946,7 @@ var TradingResource = class extends Resource {
     if (typeof symbol === "string" && symbol !== "") body = { symbol };
     else if (hasSymbol && symbol === null) body = {};
     else throw new CexyConfigError('cancelAll(): pass { symbol: "BASE/QUOTE" }, or { symbol: null } to cancel in every market');
-    const once = () => this.data({ op: "cancel_all", body }, opts);
+    const once = (o) => this.data({ op: "cancel_all", body }, o ?? opts);
     if (params.untilDone !== true) return once();
     const maxRounds = params.maxRounds ?? 20;
     const budgetMs = params.timeBudgetMs ?? 12e4;
@@ -913,53 +955,90 @@ var TradingResource = class extends Resource {
     const now = this.t.config.now ?? Date.now;
     const start = now();
     const state = /* @__PURE__ */ new Map();
+    const roundOpts = { ...opts, maxRetries: 0 };
     let rounds = 0;
     let idle = 0;
-    let last;
+    let hasMore = false;
+    let lastErrorCode;
     let stopped;
+    const result = () => {
+      const pick = (list) => [...state].filter(([, v]) => v.list === list).map(([id]) => id);
+      return {
+        cancelled: pick("cancelled"),
+        already_closed: pick("already_closed"),
+        failed: pick("failed"),
+        failures: [...state.values()].flatMap((v) => v.list === "failed" && v.failure ? [v.failure] : []),
+        has_more: hasMore,
+        rounds,
+        stopped,
+        ...lastErrorCode !== void 0 ? { last_error_code: lastErrorCode } : {}
+      };
+    };
     for (; ; ) {
-      last = await once();
-      rounds++;
-      const failures = last.failures ?? [];
-      for (const id of last.cancelled ?? []) state.set(id, { list: "cancelled" });
-      for (const id of last.already_closed ?? []) state.set(id, { list: "already_closed" });
-      for (const id of last.failed ?? []) {
-        const failure = failures.find((f) => f.order_id === id);
-        state.set(id, failure ? { list: "failed", failure } : { list: "failed" });
-      }
-      const progress = (last.cancelled?.length ?? 0) + (last.already_closed?.length ?? 0) > 0;
-      if (!last.has_more && !failures.some((f) => CANCEL_RETRY_CODES.has(f.code))) {
-        stopped = "done";
-        break;
+      let waitMs = 0;
+      let res;
+      try {
+        res = await once(roundOpts);
+      } catch (err) {
+        rounds++;
+        if (opts?.signal?.aborted) throw err;
+        if (!isRetryable(err)) {
+          stopped = "done";
+          throw new CancelAllInterruptedError(err, result());
+        }
+        lastErrorCode = errorCode(err);
+        if (rounds >= maxRounds) {
+          stopped = "max_rounds";
+          break;
+        }
+        const hint = err instanceof RateLimitError ? err.retryAfterMs : null;
+        if (hint !== null) {
+          waitMs = hint;
+          if (hint > MAX_SERVER_WAIT_MS) {
+            stopped = "time_budget";
+            break;
+          }
+        } else {
+          waitMs = (CANCEL_BACKOFF_S[Math.min(idle++, CANCEL_BACKOFF_S.length - 1)] ?? 15) * 1e3;
+        }
       }
-      if (rounds >= maxRounds) {
-        stopped = "max_rounds";
-        break;
+      if (res) {
+        rounds++;
+        lastErrorCode = void 0;
+        hasMore = res.has_more;
+        const failures = res.failures ?? [];
+        for (const id of res.cancelled ?? []) state.set(id, { list: "cancelled" });
+        for (const id of res.already_closed ?? []) state.set(id, { list: "already_closed" });
+        for (const id of res.failed ?? []) {
+          const failure = failures.find((f) => f.order_id === id);
+          state.set(id, failure ? { list: "failed", failure } : { list: "failed" });
+        }
+        const progress = (res.cancelled?.length ?? 0) + (res.already_closed?.length ?? 0) > 0;
+        if (!res.has_more && !failures.some((f) => CANCEL_RETRY_CODES.has(f.code))) {
+          stopped = "done";
+          break;
+        }
+        if (rounds >= maxRounds) {
+          stopped = "max_rounds";
+          break;
+        }
+        if (progress) idle = 0;
+        else waitMs = (CANCEL_BACKOFF_S[Math.min(idle++, CANCEL_BACKOFF_S.length - 1)] ?? 15) * 1e3;
       }
-      let waitMs = 0;
-      if (progress) idle = 0;
-      else waitMs = (CANCEL_BACKOFF_S[Math.min(idle++, CANCEL_BACKOFF_S.length - 1)] ?? 15) * 1e3;
-      if (now() - start + waitMs >= budgetMs) {
+      const limiterMs = this.t.config.limiter?.pendingWaitMs() ?? 0;
+      if (now() - start + Math.max(waitMs, limiterMs) >= budgetMs) {
         stopped = "time_budget";
+        if (limiterMs > waitMs) lastErrorCode = "RATE_LIMITED";
         break;
       }
       if (waitMs > 0) await this.t.config.sleep(waitMs, opts?.signal);
     }
-    const pick = (list) => [...state].filter(([, v]) => v.list === list).map(([id]) => id);
-    return {
-      cancelled: pick("cancelled"),
-      already_closed: pick("already_closed"),
-      failed: pick("failed"),
-      failures: [...state.values()].flatMap((v) => v.list === "failed" && v.failure ? [v.failure] : []),
-      has_more: last.has_more,
-      rounds,
-      stopped
-    };
+    return result();
   }
 };
 
 // src/version.ts
-var VERSION = "0.1.0-dev.4";
+var VERSION = "0.1.0-dev.6";
 var USER_AGENT = `cexy-typescript/${VERSION}`;
 
 // src/ws/emitter.ts
@@ -1727,7 +1806,8 @@ var CexyClient = class {
     const sleep2 = options.sleep ?? sleep;
     const limiter = options.rateLimit === false ? null : new RateLimiter({
       requestsPerMinute: options.rateLimit?.requestsPerMinute ?? (authenticator ? DEFAULT_RPM_WITH_KEY : DEFAULT_RPM_ANONYMOUS),
-      sleep: sleep2
+      sleep: sleep2,
+      ...options.now ? { now: options.now } : {}
     });
     this.#baseUrl = baseUrl;
     this.#transport = new Transport({
@@ -1810,4 +1890,21 @@ function canSetUserAgent() {
   return !(typeof g.window !== "undefined" && typeof g.window.document !== "undefined");
 }
 
-export { AccountResource, ApiKeyAuthenticator, AssetsResource, AuthenticationError, CLIENT_ERROR_CODES, CexyApiError, CexyClient, CexyConfigError, CexyConnectionError, CexyError, CexyTimeoutError, CexyWebSocket, CexyWebSocketError, ConflictError, DEFAULT_BASE_URL, DEFAULT_RPM_ANONYMOUS, DEFAULT_RPM_WITH_KEY, DEFAULT_WS_URL, ExportsResource, FeesResource, ForbiddenError, InvalidAmountError, JurisdictionBlockedError, KNOWN_EVENT_TYPES, LiveOrderBook, MarketsResource, NetworksResource, NotFoundError, OPERATIONS, OrderStateUnknownError, PRIVATE_CHANNELS, PoolsResource, RateLimitError, RateLimiter, SUPPORTED_PROTOCOL_VERSION, ServerError, TradingResource, TypedEmitter, USER_AGENT, UnprocessableError, VERSION, ValidationError, WS_BOOK_DEPTH, WalletResource, assertAmountFields, errorFromResponse, isAmount, isKnownErrorCode, isLocalHost, isRetryable, paginate };
+// src/ledger.ts
+var KNOWN_LEDGER_REFERENCE_TYPES = /* @__PURE__ */ new Set([
+  "deposit",
+  "withdrawal",
+  "order",
+  "trade",
+  "transfer",
+  "adjustment",
+  "pool",
+  "futures_transfer",
+  "system"
+]);
+function isLedgerReference(ref, type) {
+  if (typeof ref !== "object" || ref === null || typeof ref.type !== "string") return false;
+  return type === void 0 ? KNOWN_LEDGER_REFERENCE_TYPES.has(ref.type) : ref.type === type;
+}
+
+export { AccountResource, ApiKeyAuthenticator, AssetsResource, AuthenticationError, CLIENT_ERROR_CODES, CancelAllInterruptedError, CexyApiError, CexyClient, CexyConfigError, CexyConnectionError, CexyError, CexyTimeoutError, CexyWebSocket, CexyWebSocketError, ConflictError, DEFAULT_BASE_URL, DEFAULT_RPM_ANONYMOUS, DEFAULT_RPM_WITH_KEY, DEFAULT_WS_URL, ExportsResource, FeesResource, ForbiddenError, InvalidAmountError, JurisdictionBlockedError, KNOWN_EVENT_TYPES, LiveOrderBook, MAX_SERVER_WAIT_MS, MarketsResource, NetworksResource, NotFoundError, OPERATIONS, OrderStateUnknownError, PRIVATE_CHANNELS, PoolsResource, RateLimitError, RateLimiter, SUPPORTED_PROTOCOL_VERSION, ServerError, TradingResource, TypedEmitter, USER_AGENT, UnprocessableError, VERSION, ValidationError, WS_BOOK_DEPTH, WalletResource, assertAmountFields, errorFromResponse, isAmount, isKnownErrorCode, isLedgerReference, isLocalHost, isRetryable, paginate };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cexyio/cexy",
-  "version": "0.1.0-dev.4",
+  "version": "0.1.0-dev.6",
   "description": "Official TypeScript/JavaScript SDK for the CEXY.io REST and WebSocket API",
   "license": "MIT",
   "author": "CEXY.io",