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

package/README.md

@@ -62,6 +62,9 @@ await cexy.trading.cancelAll({ symbol: "BTC/USDT" }); // { symbol: null } = ever
 `cancelAll` requires `symbol`: the server treats a missing symbol as "every market", so the SDK makes
 you say so with `{ symbol: null }`. An unknown symbol throws `NotFoundError`.
 
+It also cancels stop orders that have not triggered yet (status `pending_trigger`) and releases
+their reservations, so nothing fires into the market after the call.
+
 One call handles at most 500 orders and puts each in exactly one list: `cancelled`, `already_closed`
 (it filled, was refused or was cancelled elsewhere first; not an error) or `failed`, with the reason in
 `failures` (`INVALID_STATE` for an order still being placed). `has_more: true` means more orders remain.
@@ -75,8 +78,14 @@ 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 wait imposed by the client rate limiter (e.g. `X-RateLimit-Remaining: 0` with a Reset) counts too: if it
+would pass the budget the loop stops without calling, with `last_error_code: "RATE_LIMITED"`.
+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 +154,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 +169,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 }`.
@@ -176,6 +188,22 @@ for await (const order of cexy.trading.iterateOrderHistory({ symbol: "BTC/USDT",
 // cap the total: cexy.account.iterateLedger({}, { maxItems: 500 })
 ```
 
+Each ledger entry's `reference` says what caused it, as a union told apart by `type` (`deposit`,
+`withdrawal`, `order`, `trade`, `transfer`, `adjustment`, `pool`, `futures_transfer`, `system`).
+Newer types the SDK does not know yet arrive unchanged instead of failing; narrow with
+`isLedgerReference`:
+
+```ts
+import { isLedgerReference } from "@cexyio/cexy";
+
+for await (const e of cexy.account.iterateLedger({}, { maxItems: 100 })) {
+  if (isLedgerReference(e.reference, "trade")) console.log(e.reference.trade_id);
+  else if (!isLedgerReference(e.reference)) console.log("new cause type:", e.reference.type);
+}
+```
+
+Ids (`OrderId`, `TradeId`, `UserId`, …) are plain strings; the SDK does not check their format.
+
 ## Rate limits
 
 The client has a token-bucket limiter: **100 requests/minute without a key** (the server allows 120/min

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;
@@ -129,27 +139,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) {
@@ -312,6 +325,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 +334,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 +353,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 +374,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 +390,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 +473,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 +509,7 @@ function errMessage(err) {
 }
 
 // src/limiter.ts
+var MAX_BLOCK_MS = 12e4;
 var RateLimiter = class {
   #rpm;
   #tokens;
@@ -519,14 +543,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);
     }
@@ -538,10 +573,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 +831,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 +867,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 +882,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 +896,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 +924,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 +934,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 +948,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 +957,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
@@ -1729,7 +1808,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({
@@ -1812,11 +1892,29 @@ function canSetUserAgent() {
   return !(typeof g.window !== "undefined" && typeof g.window.document !== "undefined");
 }
 
+// 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;
+}
+
 exports.AccountResource = AccountResource;
 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 +1935,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;
@@ -1860,6 +1959,7 @@ exports.assertAmountFields = assertAmountFields;
 exports.errorFromResponse = errorFromResponse;
 exports.isAmount = isAmount;
 exports.isKnownErrorCode = isKnownErrorCode;
+exports.isLedgerReference = isLedgerReference;
 exports.isLocalHost = isLocalHost;
 exports.isRetryable = isRetryable;
 exports.paginate = paginate;