@cexyio/cexy 0.1.0-dev.3 → 0.1.0-dev.5

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;
@@ -129,24 +139,27 @@ var KNOWN_CODES = /* @__PURE__ */ new Set([
   "UNDER_MAINTENANCE",
   "ENGINE_OVERLOADED"
 ]);
+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) {
@@ -309,6 +322,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 {
@@ -317,16 +331,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 {
@@ -337,8 +350,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,
@@ -353,8 +371,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);
   }
@@ -369,7 +387,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) {
@@ -413,7 +431,7 @@ var Transport = class {
     if (res.type === "opaqueredirect" || res.status >= 300 && res.status < 400 || res.redirected) {
       throw new CexyApiError({
         status: res.status,
-        code: "UNEXPECTED_REDIRECT",
+        code: CLIENT_ERROR_CODES.UNEXPECTED_REDIRECT,
         message: `${info.method} ${info.path}: the server answered with a redirect (HTTP ${res.status}); the SDK does not follow redirects. Check baseUrl.`,
         retryable: false
       });
@@ -452,6 +470,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";
@@ -483,6 +506,7 @@ function errMessage(err) {
 }
 
 // src/limiter.ts
+var MAX_BLOCK_MS = 12e4;
 var RateLimiter = class {
   #rpm;
   #tokens;
@@ -516,14 +540,14 @@ 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);
     }
   }
   /** 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);
     }
@@ -535,10 +559,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();
@@ -788,6 +815,14 @@ var WalletResource = class extends Resource {
     return this.data({ op: "deposit_address", query: params }, opts);
   }
 };
+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. */
@@ -818,7 +853,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
@@ -833,12 +868,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) {
@@ -848,11 +882,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;
@@ -876,10 +910,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;
@@ -887,23 +920,13 @@ 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;
       }
     }
   }
-  /**
-   * Cancels every open order in one market: `cancelAll({ symbol: "BTC/USDT" })`.
-   * To cancel across ALL markets, pass `symbol: null` explicitly: `cancelAll({ symbol: null })`.
-   * Omitting `symbol` is an error, so an account-wide cancel never happens by accident
-   * (the server itself treats `{}` as every market).
-   *
-   * The server limits cancel-all to 30 calls per minute per account. It is naturally
-   * repeatable, so it is retried after network errors; a retry reports only what that retry
-   * cancelled.
-   */
   async cancelAll(params, opts) {
     const hasSymbol = !!params && typeof params === "object" && Object.prototype.hasOwnProperty.call(params, "symbol");
     const symbol = hasSymbol ? params.symbol : void 0;
@@ -911,12 +934,97 @@ 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');
-    return 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;
+    if (!(maxRounds >= 1)) throw new CexyConfigError("cancelAll(): maxRounds must be >= 1");
+    if (!(budgetMs > 0)) throw new CexyConfigError("cancelAll(): timeBudgetMs must be > 0");
+    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 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 (; ; ) {
+      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 (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;
+      }
+      if (now() - start + waitMs >= budgetMs) {
+        stopped = "time_budget";
+        break;
+      }
+      if (waitMs > 0) await this.t.config.sleep(waitMs, opts?.signal);
+    }
+    return result();
   }
 };
 
 // src/version.ts
-var VERSION = "0.1.0-dev.3";
+var VERSION = "0.1.0-dev.5";
 var USER_AGENT = `cexy-typescript/${VERSION}`;
 
 // src/ws/emitter.ts
@@ -1684,7 +1792,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({
@@ -1697,6 +1806,7 @@ var CexyClient = class {
       userAgent: canSetUserAgent() ? [USER_AGENT, options.userAgentSuffix].filter(Boolean).join(" ") : null,
       sleep: sleep2,
       random: options.random ?? Math.random,
+      now: options.now ?? Date.now,
       onRetry: options.onRetry
     });
     const t = this.#transport;
@@ -1766,4 +1876,4 @@ function canSetUserAgent() {
   return !(typeof g.window !== "undefined" && typeof g.window.document !== "undefined");
 }
 
-export { AccountResource, ApiKeyAuthenticator, AssetsResource, AuthenticationError, 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 };
+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, isLocalHost, isRetryable, paginate };

package/package.json

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