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

package/README.md

@@ -75,8 +75,12 @@ if (res.stopped !== "done" || res.failed.length) console.warn("left over:", res.
 
 `untilDone` repeats while `has_more` is true or a failure is `INVALID_STATE` / `SERVICE_UNAVAILABLE`.
 After a call without progress it waits 1, 2, 4, 8, then 15 s, and it stops after `maxRounds` calls
-(default 20) or before a wait would pass `timeBudgetMs` (default 120 000). The server allows 30 cancel-all
-calls per minute per account; a 429 is retried after its Retry-After, which counts against the budget.
+(default 20) or before a wait would pass `timeBudgetMs` (default 120 000). Every round is exactly one
+request (the loop owns the retries, so it never sends more than `maxRounds` requests): a 429 round waits its
+Retry-After, which counts against the budget; another retryable error (5xx, network) takes the next backoff
+step; a wait that would pass the budget ends the loop with `stopped: "time_budget"` and `last_error_code`.
+A non-retryable error (e.g. a key without the trade scope) throws `CancelAllInterruptedError` with the error
+and the partial result. The server allows 30 cancel-all calls per minute per account.
 
 Give both `apiKey` and `apiSecret`, or neither: passing only one throws at construction.
 
@@ -145,10 +149,13 @@ try {
 
 - Timeout per attempt: `timeoutMs` (default 10 s). Retries: `maxRetries` (default 3), exponential backoff with full jitter.
 - Retried: network errors, timeouts and responses with `retryable: true`.
-- 429 waits at least `Retry-After` / `details.retry_after_seconds`.
+- 429 waits at least `Retry-After` / `details.retry_after_seconds`. Server wait hints are untrusted: unusable
+  values are ignored, and a hint longer than 120 s (`MAX_SERVER_WAIT_MS`) is never waited: the call fails at
+  once with `RateLimitError`, whose `retryAfterMs` still has the server's value. The client-side rate limiter
+  never blocks longer than 120 s because of a server hint.
 - GETs retry freely.
-- **Orders:** safety rests on `client_order_id`, not on `Idempotency-Key` (the server does not honour
-  that header on `POST /trading/orders`, order cancels or cancel-all). `placeOrder` always sends a
+- **Orders:** safety rests on `client_order_id`. The server does not honour `Idempotency-Key` on
+  `POST /trading/orders`, order cancels or cancel-all, so the SDK does not send it there. `placeOrder` always sends a
   `client_order_id` (a UUID if you do not set one); it is unique per account and a repeat is refused
   before any funds move. After an ambiguous failure (network error, timeout, 5xx) the SDK first looks the
   order up by that id. If the order exists it is returned with `recovered: true`; only if it does not
@@ -157,9 +164,9 @@ try {
 - **Cancels:** `cancelOrder` retries network errors; if a *retry* gets `INVALID_STATE`, the first attempt
   already cancelled the order, so the SDK fetches and returns it. `cancelAll` is naturally repeatable and
   is retried the same way (a retry reports only what it cancelled).
-- **Pool join/exit** send an auto-generated `Idempotency-Key`, reused on every retry; the server honours
-  it there, so they execute once. A 409 `CONCURRENT_MODIFICATION` (the same key still in flight) is
-  retried with the same key. Pass `{ idempotencyKey }` to control it yourself.
+- **Pool join/exit** are the only requests that send an `Idempotency-Key` (auto-generated, reused on every
+  retry); the server honours it there, so they execute once. A 409 `CONCURRENT_MODIFICATION` (the same key
+  still in flight) is retried with the same key. Pass `{ idempotencyKey }` to control it yourself.
 - `onRetry` lets you log retries.
 
 Every method takes a last `RequestOptions` argument: `{ signal, timeoutMs, maxRetries, idempotencyKey }`.

package/dist/index.cjs

@@ -31,6 +31,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;
@@ -136,20 +146,22 @@ 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) {
@@ -312,6 +324,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 {
@@ -320,16 +333,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 {
@@ -340,8 +352,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,
@@ -356,8 +373,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);
   }
@@ -372,7 +389,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) {
@@ -455,6 +472,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";
@@ -486,6 +508,7 @@ function errMessage(err) {
 }
 
 // src/limiter.ts
+var MAX_BLOCK_MS = 12e4;
 var RateLimiter = class {
   #rpm;
   #tokens;
@@ -519,14 +542,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);
     }
@@ -538,10 +561,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();
@@ -793,6 +819,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. */
@@ -823,7 +855,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
@@ -838,12 +870,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) {
@@ -853,11 +884,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;
@@ -881,10 +912,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;
@@ -892,7 +922,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;
@@ -906,7 +936,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;
@@ -915,53 +945,88 @@ 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) {
         stopped = "time_budget";
         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.5";
 var USER_AGENT = `cexy-typescript/${VERSION}`;
 
 // src/ws/emitter.ts
@@ -1729,7 +1794,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({
@@ -1817,6 +1883,7 @@ exports.ApiKeyAuthenticator = ApiKeyAuthenticator;
 exports.AssetsResource = AssetsResource;
 exports.AuthenticationError = AuthenticationError;
 exports.CLIENT_ERROR_CODES = CLIENT_ERROR_CODES;
+exports.CancelAllInterruptedError = CancelAllInterruptedError;
 exports.CexyApiError = CexyApiError;
 exports.CexyClient = CexyClient;
 exports.CexyConfigError = CexyConfigError;
@@ -1837,6 +1904,7 @@ exports.InvalidAmountError = InvalidAmountError;
 exports.JurisdictionBlockedError = JurisdictionBlockedError;
 exports.KNOWN_EVENT_TYPES = KNOWN_EVENT_TYPES;
 exports.LiveOrderBook = LiveOrderBook;
+exports.MAX_SERVER_WAIT_MS = MAX_SERVER_WAIT_MS;
 exports.MarketsResource = MarketsResource;
 exports.NetworksResource = NetworksResource;
 exports.NotFoundError = NotFoundError;

package/dist/index.d.cts

@@ -36,12 +36,6 @@ declare class ApiKeyAuthenticator implements Authenticator {
     toJSON(): Record<string, string>;
 }
 
-/**
- * Client-side token bucket. `CexyClient` defaults to 100 requests/minute without credentials
- * and 300/minute with an API key (the server allows about 120/min per IP and 600/min per
- * key; this keeps a margin). It adapts to `X-RateLimit-Limit`, `X-RateLimit-Remaining` and
- * `X-RateLimit-Reset` when the server sends them, and to 429 `Retry-After`.
- */
 interface RateLimiterOptions {
     requestsPerMinute: number;
     /** @internal for tests */
@@ -62,7 +56,10 @@ declare class RateLimiter {
     acquire(signal?: AbortSignal): Promise<void>;
     /** Adapts to the server's rate-limit headers. Never raises the configured limit. */
     update(headers: Headers): void;
-    /** 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: number): void;
 }
 
@@ -135,10 +132,10 @@ interface RequestOptions {
     /** Overrides the client's `maxRetries`. */
     maxRetries?: number;
     /**
-     * Mutations only: the `Idempotency-Key` to send. Generated automatically when absent.
-     * The server honours it on pool join/exit; set it yourself to make a retry across process
-     * restarts safe there. Orders and cancels do NOT honour it: their safety comes from
-     * `client_order_id` (see `placeOrder`).
+     * Pool join/exit only: the `Idempotency-Key` to send (generated automatically when absent,
+     * and reused on every retry). The server honours it there; set it yourself to make a retry
+     * across process restarts safe. No other request sends the header: orders and cancels do
+     * not honour it, and their safety comes from `client_order_id` (see `placeOrder`).
      */
     idempotencyKey?: string;
 }
@@ -184,14 +181,17 @@ declare class Transport {
     readonly config: TransportConfig;
     constructor(config: TransportConfig);
     /**
-     * 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.
      */
     request(spec: CallSpec, opts?: RequestOptions): Promise<RawResponse>;
-    /** 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).
+     */
     backoff(op: OperationId, info: OperationInfo, attempt: number, err: unknown, idempotencyKey: string | undefined, signal?: AbortSignal): Promise<void>;
     /** Full-jitter exponential backoff, or the server's hint plus a little jitter. */
     retryDelay(attempt: number, err: unknown): number;
@@ -3238,6 +3238,11 @@ interface CancelAllUntilDoneResult extends CancelAllResult {
     rounds: number;
     /** `done`: nothing left to retry; otherwise the loop's limit that ended it. */
     stopped: CancelAllStopReason;
+    /**
+     * The error code of the last round when that round failed with a retryable error (e.g.
+     * `RATE_LIMITED`, `SERVICE_UNAVAILABLE`, `CONNECTION_ERROR`); absent when it succeeded.
+     */
+    last_error_code?: string;
 }
 type Candle = S["CandleResponse"];
 type CandleInterval = S["CandleInterval"];
@@ -3427,7 +3432,7 @@ declare class TradingResource 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
@@ -3459,10 +3464,18 @@ declare class TradingResource extends Resource {
      * waits 1, 2, 4, 8 and then 15 s, starting over after any progress. It stops after
      * `maxRounds` calls or before a wait would pass `timeBudgetMs`, and returns the merged
      * result with `rounds` and `stopped`. Other failure codes are returned, never retried.
+     * In this mode every round is exactly one HTTP request (the loop owns the retries, so it
+     * never sends more than `maxRounds` requests): a 429 round waits the server's Retry-After
+     * (without advancing the backoff), another retryable error (5xx, network) takes the next
+     * backoff step, and a wait that would pass the budget ends the loop with
+     * `stopped: "time_budget"` and `last_error_code`. A non-retryable error (e.g. a key without
+     * the trade scope) throws `CancelAllInterruptedError`, which carries the error and the
+     * partial result.
      *
-     * The server allows 30 cancel-all calls per minute per account (a 429 is retried after its
-     * Retry-After). The call is naturally repeatable and needs no Idempotency-Key, so it is
-     * retried after network errors; a retry reports only what that retry did.
+     * The server allows 30 cancel-all calls per minute per account. A single call (without
+     * `untilDone`) follows the normal retry policy: a 429 is retried after its Retry-After (up to
+     * 120 s; a longer one fails at once) and network errors are retried, since the call is
+     * naturally repeatable; a retry reports only what that retry did. No Idempotency-Key is sent.
      */
     cancelAll(params: CancelAllParams & {
         untilDone: true;
@@ -3512,6 +3525,16 @@ declare class OrderStateUnknownError extends CexyError {
     readonly clientOrderId: string;
     constructor(clientOrderId: string, cause: unknown);
 }
+/**
+ * A `cancelAll({ ..., untilDone: true })` loop hit an error it does not retry (for example
+ * `ForbiddenError` for a key without the trade scope). `error` is that error; `partial` is what
+ * the earlier rounds did, in the same shape as the loop's normal result.
+ */
+declare class CancelAllInterruptedError extends CexyError {
+    readonly error: unknown;
+    readonly partial: CancelAllUntilDoneResult;
+    constructor(error: unknown, partial: CancelAllUntilDoneResult);
+}
 interface CexyApiErrorInit {
     status: number;
     code: ErrorCode;
@@ -3576,6 +3599,12 @@ declare const CLIENT_ERROR_CODES: {
 };
 /** True for codes listed in errors.yaml (server codes; see `CLIENT_ERROR_CODES` for the SDK's own). */
 declare function isKnownErrorCode(code: string): code is KnownErrorCode;
+/**
+ * The longest wait the SDK accepts from a server hint (`Retry-After`, `retry_after_seconds`,
+ * `X-RateLimit-Reset`): 120 s. A longer hint is never waited; the call fails at once instead
+ * (see `Transport.backoff`), and the client-side rate limiter caps its block at this value.
+ */
+declare const MAX_SERVER_WAIT_MS = 120000;
 /**
  * Builds the right error subclass for an HTTP error response.
  * - A known code maps by HTTP status (401 -> AuthenticationError, 403 -> ForbiddenError, ...).
@@ -4022,11 +4051,11 @@ declare function isAmount(value: unknown): value is Amount;
 declare function assertAmountFields(body: Record<string, unknown>, fields: readonly string[], context: string): void;
 
 /** SDK version, kept in sync with package.json (a test enforces this). */
-declare const VERSION = "0.1.0-dev.4";
+declare const VERSION = "0.1.0-dev.5";
 /** Default User-Agent product token. */
-declare const USER_AGENT = "cexy-typescript/0.1.0-dev.4";
+declare const USER_AGENT = "cexy-typescript/0.1.0-dev.5";
 
 /** True for loopback hosts, the only ones where plain-text transport may be allowed. */
 declare function isLocalHost(hostname: string): boolean;
 
-export { AccountResource, type Amount, type ApiKey, ApiKeyAuthenticator, type ApiScope, type Asset, type AssetNetwork, AssetsResource, type AuthRequest, type AuthResult, type AuthenticatedFrame, AuthenticationError, type Authenticator, type Balance, type BalanceUpdatedEvent, type BookLevel, CLIENT_ERROR_CODES, type CancelAllParams, type CancelAllRequest, type CancelAllResult, type CancelAllStopReason, type CancelAllUntilDoneResult, type CancelFailure, type Candle, type CandleInterval, CexyApiError, type CexyApiErrorInit, CexyClient, type CexyClientOptions, CexyConfigError, CexyConnectionError, CexyError, CexyTimeoutError, CexyWebSocket, CexyWebSocketError, type CexyWebSocketEvents, type CexyWebSocketOptions, type CloseInfo, ConflictError, type CursorParams, DEFAULT_BASE_URL, DEFAULT_RPM_ANONYMOUS, DEFAULT_RPM_WITH_KEY, DEFAULT_WS_URL, type Deposit, type DepositAddress, type DepositEvent, type DepositStatus, type ErrorBody, type ErrorCode, type ErrorFrame, type EventMap, type ExchangeConfig, type ExitPoolRequest, type ExitPoolResult, ExportsResource, type FeeSchedule, FeesResource, type FetchLike, type Fill, ForbiddenError, InvalidAmountError, type IterateOptions, type JoinPoolRequest, type JoinPoolResult, JurisdictionBlockedError, KNOWN_EVENT_TYPES, type KnownErrorCode, type LedgerEntry, type LedgerEntryKind, type LiquidityRole, type Listener, LiveOrderBook, type LiveOrderBookEvents, type LiveOrderBookOptions, type MaintenanceState, type Market, type MarketStatus, type MarketStatusEvent, MarketsResource, type Network, NetworksResource, NotFoundError, type Notification, type NotificationKind, OPERATIONS, type OperationAuth, type OperationId, type OperationInfo, type OperationScope, type Order, type OrderBook, type OrderBookUpdateData, type OrderBookUpdateEvent, type OrderEvent, type OrderSide, OrderStateUnknownError, type OrderStatus, type OrderType, PRIVATE_CHANNELS, type Page, type PlaceOrderRequest, type PlaceOrderResponse, type PlaceOrderResult, type PongFrame, type Pool, type PoolStatus, PoolsResource, type PublicTrade, type QueryOf, RateLimitError, RateLimiter, type RateLimiterOptions, type RateLimiterState, type ReconnectOptions, type RequestOptions, type ResyncReason, type RetryInfo, SUPPORTED_PROTOCOL_VERSION, ServerError, type ServerTime, type SessionRevokedData, type SessionRevokedEvent, type SnapshotSource, type SortDirection, type SubAccount, type SubscribeResult, type SubscribedFrame, type TickerUpdateEvent, type TimeInForce, type TradeNewEvent, TradingResource, type TriggerDirection, TypedEmitter, USER_AGENT, UnprocessableError, type UnsubscribedFrame, VERSION, ValidationError, WS_BOOK_DEPTH, WalletResource, type WebSocketConstructor, type WebSocketLike, type WelcomeFrame, type Withdrawal, type WithdrawalAddress, type WithdrawalStatus, type WithdrawalUpdatedEvent, type WsEvent, type WsLogger, assertAmountFields, type components, errorFromResponse, isAmount, isKnownErrorCode, isLocalHost, isRetryable, type operations, paginate, type paths };
+export { AccountResource, type Amount, type ApiKey, ApiKeyAuthenticator, type ApiScope, type Asset, type AssetNetwork, AssetsResource, type AuthRequest, type AuthResult, type AuthenticatedFrame, AuthenticationError, type Authenticator, type Balance, type BalanceUpdatedEvent, type BookLevel, CLIENT_ERROR_CODES, CancelAllInterruptedError, type CancelAllParams, type CancelAllRequest, type CancelAllResult, type CancelAllStopReason, type CancelAllUntilDoneResult, type CancelFailure, type Candle, type CandleInterval, CexyApiError, type CexyApiErrorInit, CexyClient, type CexyClientOptions, CexyConfigError, CexyConnectionError, CexyError, CexyTimeoutError, CexyWebSocket, CexyWebSocketError, type CexyWebSocketEvents, type CexyWebSocketOptions, type CloseInfo, ConflictError, type CursorParams, DEFAULT_BASE_URL, DEFAULT_RPM_ANONYMOUS, DEFAULT_RPM_WITH_KEY, DEFAULT_WS_URL, type Deposit, type DepositAddress, type DepositEvent, type DepositStatus, type ErrorBody, type ErrorCode, type ErrorFrame, type EventMap, type ExchangeConfig, type ExitPoolRequest, type ExitPoolResult, ExportsResource, type FeeSchedule, FeesResource, type FetchLike, type Fill, ForbiddenError, InvalidAmountError, type IterateOptions, type JoinPoolRequest, type JoinPoolResult, JurisdictionBlockedError, KNOWN_EVENT_TYPES, type KnownErrorCode, type LedgerEntry, type LedgerEntryKind, type LiquidityRole, type Listener, LiveOrderBook, type LiveOrderBookEvents, type LiveOrderBookOptions, MAX_SERVER_WAIT_MS, type MaintenanceState, type Market, type MarketStatus, type MarketStatusEvent, MarketsResource, type Network, NetworksResource, NotFoundError, type Notification, type NotificationKind, OPERATIONS, type OperationAuth, type OperationId, type OperationInfo, type OperationScope, type Order, type OrderBook, type OrderBookUpdateData, type OrderBookUpdateEvent, type OrderEvent, type OrderSide, OrderStateUnknownError, type OrderStatus, type OrderType, PRIVATE_CHANNELS, type Page, type PlaceOrderRequest, type PlaceOrderResponse, type PlaceOrderResult, type PongFrame, type Pool, type PoolStatus, PoolsResource, type PublicTrade, type QueryOf, RateLimitError, RateLimiter, type RateLimiterOptions, type RateLimiterState, type ReconnectOptions, type RequestOptions, type ResyncReason, type RetryInfo, SUPPORTED_PROTOCOL_VERSION, ServerError, type ServerTime, type SessionRevokedData, type SessionRevokedEvent, type SnapshotSource, type SortDirection, type SubAccount, type SubscribeResult, type SubscribedFrame, type TickerUpdateEvent, type TimeInForce, type TradeNewEvent, TradingResource, type TriggerDirection, TypedEmitter, USER_AGENT, UnprocessableError, type UnsubscribedFrame, VERSION, ValidationError, WS_BOOK_DEPTH, WalletResource, type WebSocketConstructor, type WebSocketLike, type WelcomeFrame, type Withdrawal, type WithdrawalAddress, type WithdrawalStatus, type WithdrawalUpdatedEvent, type WsEvent, type WsLogger, assertAmountFields, type components, errorFromResponse, isAmount, isKnownErrorCode, isLocalHost, isRetryable, type operations, paginate, type paths };

package/dist/index.d.ts

@@ -36,12 +36,6 @@ declare class ApiKeyAuthenticator implements Authenticator {
     toJSON(): Record<string, string>;
 }
 
-/**
- * Client-side token bucket. `CexyClient` defaults to 100 requests/minute without credentials
- * and 300/minute with an API key (the server allows about 120/min per IP and 600/min per
- * key; this keeps a margin). It adapts to `X-RateLimit-Limit`, `X-RateLimit-Remaining` and
- * `X-RateLimit-Reset` when the server sends them, and to 429 `Retry-After`.
- */
 interface RateLimiterOptions {
     requestsPerMinute: number;
     /** @internal for tests */
@@ -62,7 +56,10 @@ declare class RateLimiter {
     acquire(signal?: AbortSignal): Promise<void>;
     /** Adapts to the server's rate-limit headers. Never raises the configured limit. */
     update(headers: Headers): void;
-    /** 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: number): void;
 }
 
@@ -135,10 +132,10 @@ interface RequestOptions {
     /** Overrides the client's `maxRetries`. */
     maxRetries?: number;
     /**
-     * Mutations only: the `Idempotency-Key` to send. Generated automatically when absent.
-     * The server honours it on pool join/exit; set it yourself to make a retry across process
-     * restarts safe there. Orders and cancels do NOT honour it: their safety comes from
-     * `client_order_id` (see `placeOrder`).
+     * Pool join/exit only: the `Idempotency-Key` to send (generated automatically when absent,
+     * and reused on every retry). The server honours it there; set it yourself to make a retry
+     * across process restarts safe. No other request sends the header: orders and cancels do
+     * not honour it, and their safety comes from `client_order_id` (see `placeOrder`).
      */
     idempotencyKey?: string;
 }
@@ -184,14 +181,17 @@ declare class Transport {
     readonly config: TransportConfig;
     constructor(config: TransportConfig);
     /**
-     * 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.
      */
     request(spec: CallSpec, opts?: RequestOptions): Promise<RawResponse>;
-    /** 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).
+     */
     backoff(op: OperationId, info: OperationInfo, attempt: number, err: unknown, idempotencyKey: string | undefined, signal?: AbortSignal): Promise<void>;
     /** Full-jitter exponential backoff, or the server's hint plus a little jitter. */
     retryDelay(attempt: number, err: unknown): number;
@@ -3238,6 +3238,11 @@ interface CancelAllUntilDoneResult extends CancelAllResult {
     rounds: number;
     /** `done`: nothing left to retry; otherwise the loop's limit that ended it. */
     stopped: CancelAllStopReason;
+    /**
+     * The error code of the last round when that round failed with a retryable error (e.g.
+     * `RATE_LIMITED`, `SERVICE_UNAVAILABLE`, `CONNECTION_ERROR`); absent when it succeeded.
+     */
+    last_error_code?: string;
 }
 type Candle = S["CandleResponse"];
 type CandleInterval = S["CandleInterval"];
@@ -3427,7 +3432,7 @@ declare class TradingResource 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
@@ -3459,10 +3464,18 @@ declare class TradingResource extends Resource {
      * waits 1, 2, 4, 8 and then 15 s, starting over after any progress. It stops after
      * `maxRounds` calls or before a wait would pass `timeBudgetMs`, and returns the merged
      * result with `rounds` and `stopped`. Other failure codes are returned, never retried.
+     * In this mode every round is exactly one HTTP request (the loop owns the retries, so it
+     * never sends more than `maxRounds` requests): a 429 round waits the server's Retry-After
+     * (without advancing the backoff), another retryable error (5xx, network) takes the next
+     * backoff step, and a wait that would pass the budget ends the loop with
+     * `stopped: "time_budget"` and `last_error_code`. A non-retryable error (e.g. a key without
+     * the trade scope) throws `CancelAllInterruptedError`, which carries the error and the
+     * partial result.
      *
-     * The server allows 30 cancel-all calls per minute per account (a 429 is retried after its
-     * Retry-After). The call is naturally repeatable and needs no Idempotency-Key, so it is
-     * retried after network errors; a retry reports only what that retry did.
+     * The server allows 30 cancel-all calls per minute per account. A single call (without
+     * `untilDone`) follows the normal retry policy: a 429 is retried after its Retry-After (up to
+     * 120 s; a longer one fails at once) and network errors are retried, since the call is
+     * naturally repeatable; a retry reports only what that retry did. No Idempotency-Key is sent.
      */
     cancelAll(params: CancelAllParams & {
         untilDone: true;
@@ -3512,6 +3525,16 @@ declare class OrderStateUnknownError extends CexyError {
     readonly clientOrderId: string;
     constructor(clientOrderId: string, cause: unknown);
 }
+/**
+ * A `cancelAll({ ..., untilDone: true })` loop hit an error it does not retry (for example
+ * `ForbiddenError` for a key without the trade scope). `error` is that error; `partial` is what
+ * the earlier rounds did, in the same shape as the loop's normal result.
+ */
+declare class CancelAllInterruptedError extends CexyError {
+    readonly error: unknown;
+    readonly partial: CancelAllUntilDoneResult;
+    constructor(error: unknown, partial: CancelAllUntilDoneResult);
+}
 interface CexyApiErrorInit {
     status: number;
     code: ErrorCode;
@@ -3576,6 +3599,12 @@ declare const CLIENT_ERROR_CODES: {
 };
 /** True for codes listed in errors.yaml (server codes; see `CLIENT_ERROR_CODES` for the SDK's own). */
 declare function isKnownErrorCode(code: string): code is KnownErrorCode;
+/**
+ * The longest wait the SDK accepts from a server hint (`Retry-After`, `retry_after_seconds`,
+ * `X-RateLimit-Reset`): 120 s. A longer hint is never waited; the call fails at once instead
+ * (see `Transport.backoff`), and the client-side rate limiter caps its block at this value.
+ */
+declare const MAX_SERVER_WAIT_MS = 120000;
 /**
  * Builds the right error subclass for an HTTP error response.
  * - A known code maps by HTTP status (401 -> AuthenticationError, 403 -> ForbiddenError, ...).
@@ -4022,11 +4051,11 @@ declare function isAmount(value: unknown): value is Amount;
 declare function assertAmountFields(body: Record<string, unknown>, fields: readonly string[], context: string): void;
 
 /** SDK version, kept in sync with package.json (a test enforces this). */
-declare const VERSION = "0.1.0-dev.4";
+declare const VERSION = "0.1.0-dev.5";
 /** Default User-Agent product token. */
-declare const USER_AGENT = "cexy-typescript/0.1.0-dev.4";
+declare const USER_AGENT = "cexy-typescript/0.1.0-dev.5";
 
 /** True for loopback hosts, the only ones where plain-text transport may be allowed. */
 declare function isLocalHost(hostname: string): boolean;
 
-export { AccountResource, type Amount, type ApiKey, ApiKeyAuthenticator, type ApiScope, type Asset, type AssetNetwork, AssetsResource, type AuthRequest, type AuthResult, type AuthenticatedFrame, AuthenticationError, type Authenticator, type Balance, type BalanceUpdatedEvent, type BookLevel, CLIENT_ERROR_CODES, type CancelAllParams, type CancelAllRequest, type CancelAllResult, type CancelAllStopReason, type CancelAllUntilDoneResult, type CancelFailure, type Candle, type CandleInterval, CexyApiError, type CexyApiErrorInit, CexyClient, type CexyClientOptions, CexyConfigError, CexyConnectionError, CexyError, CexyTimeoutError, CexyWebSocket, CexyWebSocketError, type CexyWebSocketEvents, type CexyWebSocketOptions, type CloseInfo, ConflictError, type CursorParams, DEFAULT_BASE_URL, DEFAULT_RPM_ANONYMOUS, DEFAULT_RPM_WITH_KEY, DEFAULT_WS_URL, type Deposit, type DepositAddress, type DepositEvent, type DepositStatus, type ErrorBody, type ErrorCode, type ErrorFrame, type EventMap, type ExchangeConfig, type ExitPoolRequest, type ExitPoolResult, ExportsResource, type FeeSchedule, FeesResource, type FetchLike, type Fill, ForbiddenError, InvalidAmountError, type IterateOptions, type JoinPoolRequest, type JoinPoolResult, JurisdictionBlockedError, KNOWN_EVENT_TYPES, type KnownErrorCode, type LedgerEntry, type LedgerEntryKind, type LiquidityRole, type Listener, LiveOrderBook, type LiveOrderBookEvents, type LiveOrderBookOptions, type MaintenanceState, type Market, type MarketStatus, type MarketStatusEvent, MarketsResource, type Network, NetworksResource, NotFoundError, type Notification, type NotificationKind, OPERATIONS, type OperationAuth, type OperationId, type OperationInfo, type OperationScope, type Order, type OrderBook, type OrderBookUpdateData, type OrderBookUpdateEvent, type OrderEvent, type OrderSide, OrderStateUnknownError, type OrderStatus, type OrderType, PRIVATE_CHANNELS, type Page, type PlaceOrderRequest, type PlaceOrderResponse, type PlaceOrderResult, type PongFrame, type Pool, type PoolStatus, PoolsResource, type PublicTrade, type QueryOf, RateLimitError, RateLimiter, type RateLimiterOptions, type RateLimiterState, type ReconnectOptions, type RequestOptions, type ResyncReason, type RetryInfo, SUPPORTED_PROTOCOL_VERSION, ServerError, type ServerTime, type SessionRevokedData, type SessionRevokedEvent, type SnapshotSource, type SortDirection, type SubAccount, type SubscribeResult, type SubscribedFrame, type TickerUpdateEvent, type TimeInForce, type TradeNewEvent, TradingResource, type TriggerDirection, TypedEmitter, USER_AGENT, UnprocessableError, type UnsubscribedFrame, VERSION, ValidationError, WS_BOOK_DEPTH, WalletResource, type WebSocketConstructor, type WebSocketLike, type WelcomeFrame, type Withdrawal, type WithdrawalAddress, type WithdrawalStatus, type WithdrawalUpdatedEvent, type WsEvent, type WsLogger, assertAmountFields, type components, errorFromResponse, isAmount, isKnownErrorCode, isLocalHost, isRetryable, type operations, paginate, type paths };
+export { AccountResource, type Amount, type ApiKey, ApiKeyAuthenticator, type ApiScope, type Asset, type AssetNetwork, AssetsResource, type AuthRequest, type AuthResult, type AuthenticatedFrame, AuthenticationError, type Authenticator, type Balance, type BalanceUpdatedEvent, type BookLevel, CLIENT_ERROR_CODES, CancelAllInterruptedError, type CancelAllParams, type CancelAllRequest, type CancelAllResult, type CancelAllStopReason, type CancelAllUntilDoneResult, type CancelFailure, type Candle, type CandleInterval, CexyApiError, type CexyApiErrorInit, CexyClient, type CexyClientOptions, CexyConfigError, CexyConnectionError, CexyError, CexyTimeoutError, CexyWebSocket, CexyWebSocketError, type CexyWebSocketEvents, type CexyWebSocketOptions, type CloseInfo, ConflictError, type CursorParams, DEFAULT_BASE_URL, DEFAULT_RPM_ANONYMOUS, DEFAULT_RPM_WITH_KEY, DEFAULT_WS_URL, type Deposit, type DepositAddress, type DepositEvent, type DepositStatus, type ErrorBody, type ErrorCode, type ErrorFrame, type EventMap, type ExchangeConfig, type ExitPoolRequest, type ExitPoolResult, ExportsResource, type FeeSchedule, FeesResource, type FetchLike, type Fill, ForbiddenError, InvalidAmountError, type IterateOptions, type JoinPoolRequest, type JoinPoolResult, JurisdictionBlockedError, KNOWN_EVENT_TYPES, type KnownErrorCode, type LedgerEntry, type LedgerEntryKind, type LiquidityRole, type Listener, LiveOrderBook, type LiveOrderBookEvents, type LiveOrderBookOptions, MAX_SERVER_WAIT_MS, type MaintenanceState, type Market, type MarketStatus, type MarketStatusEvent, MarketsResource, type Network, NetworksResource, NotFoundError, type Notification, type NotificationKind, OPERATIONS, type OperationAuth, type OperationId, type OperationInfo, type OperationScope, type Order, type OrderBook, type OrderBookUpdateData, type OrderBookUpdateEvent, type OrderEvent, type OrderSide, OrderStateUnknownError, type OrderStatus, type OrderType, PRIVATE_CHANNELS, type Page, type PlaceOrderRequest, type PlaceOrderResponse, type PlaceOrderResult, type PongFrame, type Pool, type PoolStatus, PoolsResource, type PublicTrade, type QueryOf, RateLimitError, RateLimiter, type RateLimiterOptions, type RateLimiterState, type ReconnectOptions, type RequestOptions, type ResyncReason, type RetryInfo, SUPPORTED_PROTOCOL_VERSION, ServerError, type ServerTime, type SessionRevokedData, type SessionRevokedEvent, type SnapshotSource, type SortDirection, type SubAccount, type SubscribeResult, type SubscribedFrame, type TickerUpdateEvent, type TimeInForce, type TradeNewEvent, TradingResource, type TriggerDirection, TypedEmitter, USER_AGENT, UnprocessableError, type UnsubscribedFrame, VERSION, ValidationError, WS_BOOK_DEPTH, WalletResource, type WebSocketConstructor, type WebSocketLike, type WelcomeFrame, type Withdrawal, type WithdrawalAddress, type WithdrawalStatus, type WithdrawalUpdatedEvent, type WsEvent, type WsLogger, assertAmountFields, type components, errorFromResponse, isAmount, isKnownErrorCode, isLocalHost, isRetryable, type operations, paginate, type paths };

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;
@@ -134,20 +144,22 @@ 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 +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 {
@@ -318,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 {
@@ -338,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,
@@ -354,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);
   }
@@ -370,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) {
@@ -453,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";
@@ -484,6 +506,7 @@ function errMessage(err) {
 }
 
 // src/limiter.ts
+var MAX_BLOCK_MS = 12e4;
 var RateLimiter = class {
   #rpm;
   #tokens;
@@ -517,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);
     }
@@ -536,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();
@@ -791,6 +817,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 +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
@@ -836,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) {
@@ -851,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;
@@ -879,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;
@@ -890,7 +920,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 +934,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 +943,88 @@ 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) {
         stopped = "time_budget";
         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.5";
 var USER_AGENT = `cexy-typescript/${VERSION}`;
 
 // src/ws/emitter.ts
@@ -1727,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({
@@ -1810,4 +1876,4 @@ 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 };
+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.4",
+  "version": "0.1.0-dev.5",
   "description": "Official TypeScript/JavaScript SDK for the CEXY.io REST and WebSocket API",
   "license": "MIT",
   "author": "CEXY.io",