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

package/README.md

@@ -60,7 +60,27 @@ 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 }`. The server allows cancel-all 30 times per minute per account.
+you say so with `{ symbol: null }`. An unknown symbol throws `NotFoundError`.
+
+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.
+To let the SDK repeat the call for you:
+
+```ts
+const res = await cexy.trading.cancelAll({ symbol: null, untilDone: true });
+// res.stopped: "done" | "max_rounds" | "time_budget"; res.rounds: calls made
+if (res.stopped !== "done" || res.failed.length) console.warn("left over:", res.failures);
+```
+
+`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). 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.
 
@@ -110,7 +130,7 @@ Every API failure throws a `CexyApiError` (or a subclass) with `status`, `code`,
 | `UnprocessableError` | 422: `INSUFFICIENT_FUNDS`, `MARKET_UNAVAILABLE`, ... |
 | `RateLimitError` | 429, with `retryAfterMs` |
 | `ServerError` | 5xx |
-| `CexyApiError` | any code this SDK version does not know yet |
+| `CexyApiError` | any code this SDK version does not know yet, and `UNEXPECTED_REDIRECT` (the server answered with a 3xx; set by the SDK, see `CLIENT_ERROR_CODES`) |
 
 Local problems use `CexyConfigError`, `InvalidAmountError`, `CexyConnectionError` / `CexyTimeoutError`
 and `OrderStateUnknownError`. `ErrorCode` is a union of the known codes plus `string`, because new codes
@@ -129,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
@@ -141,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 }`.
@@ -231,7 +254,8 @@ endpoints from a server. Browsers do not let scripts set `User-Agent`, so the SD
   `http://` / `ws://` solely for `localhost`, `127.0.0.1` or `::1` (local test servers).
 - The SDK **never follows HTTP redirects**. A 3xx answer throws a `CexyApiError` with code
   `UNEXPECTED_REDIRECT` (not retried), so credentials are never re-sent to another host and an order
-  is never re-posted to a redirect target. If you pass your own `fetch`, it must honour `redirect: "manual"`.
+  is never re-posted to a redirect target. If you pass your own `fetch`, it must honour `redirect: "manual"`: one that follows redirects
+  anyway has already sent your credentials by the time the SDK notices.
 - The SDK redacts the secret from `toString()`, `util.inspect`, `JSON.stringify` and error messages.
 - Keep keys in environment variables or a secret manager, not in code.
 

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;
@@ -131,24 +141,27 @@ var KNOWN_CODES = /* @__PURE__ */ new Set([
   "UNDER_MAINTENANCE",
   "ENGINE_OVERLOADED"
 ]);
+var CLIENT_ERROR_CODES = { UNEXPECTED_REDIRECT: "UNEXPECTED_REDIRECT" };
 function isKnownErrorCode(code) {
   return KNOWN_CODES.has(code);
 }
 var DEFAULT_RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var MAX_SERVER_WAIT_MS = 12e4;
 function retryAfterMs(headers, details) {
   let best = null;
-  const h = headers?.get("retry-after");
+  const h = headers?.get("retry-after")?.trim();
   if (h) {
-    const secs = Number(h);
-    if (Number.isFinite(secs)) best = Math.max(0, secs * 1e3);
-    else {
+    if (/^\d+(\.\d+)?$/.test(h)) {
+      const ms = Number(h) * 1e3;
+      if (Number.isFinite(ms)) best = ms;
+    } else if (/[a-z]/i.test(h)) {
       const at = Date.parse(h);
-      if (!Number.isNaN(at)) best = Math.max(0, at - Date.now());
+      if (Number.isFinite(at)) best = Math.max(0, at - Date.now());
     }
   }
   const d = details?.["retry_after_seconds"];
-  const ds = typeof d === "number" ? d : typeof d === "string" ? Number(d) : NaN;
-  if (Number.isFinite(ds)) best = Math.max(best ?? 0, ds * 1e3);
+  const ds = typeof d === "number" ? d : typeof d === "string" && /^\d+(\.\d+)?$/.test(d.trim()) ? Number(d) : NaN;
+  if (Number.isFinite(ds) && ds >= 0 && Number.isFinite(ds * 1e3)) best = Math.max(best ?? 0, ds * 1e3);
   return best;
 }
 function errorFromResponse(status, body, headers, redact = (t) => t) {
@@ -311,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 {
@@ -319,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 {
@@ -339,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,
@@ -355,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);
   }
@@ -371,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) {
@@ -415,7 +433,7 @@ var Transport = class {
     if (res.type === "opaqueredirect" || res.status >= 300 && res.status < 400 || res.redirected) {
       throw new CexyApiError({
         status: res.status,
-        code: "UNEXPECTED_REDIRECT",
+        code: CLIENT_ERROR_CODES.UNEXPECTED_REDIRECT,
         message: `${info.method} ${info.path}: the server answered with a redirect (HTTP ${res.status}); the SDK does not follow redirects. Check baseUrl.`,
         retryable: false
       });
@@ -454,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";
@@ -485,6 +508,7 @@ function errMessage(err) {
 }
 
 // src/limiter.ts
+var MAX_BLOCK_MS = 12e4;
 var RateLimiter = class {
   #rpm;
   #tokens;
@@ -518,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);
     }
@@ -537,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();
@@ -790,6 +817,14 @@ var WalletResource = class extends Resource {
     return this.data({ op: "deposit_address", query: params }, opts);
   }
 };
+var CANCEL_RETRY_CODES = /* @__PURE__ */ new Set(["INVALID_STATE", "SERVICE_UNAVAILABLE"]);
+var CANCEL_BACKOFF_S = [1, 2, 4, 8, 15];
+function errorCode(err) {
+  if (err instanceof CexyApiError) return err.code;
+  if (err instanceof CexyTimeoutError) return "TIMEOUT";
+  if (err instanceof CexyConnectionError) return "CONNECTION_ERROR";
+  return "ERROR";
+}
 var ORDER_AMOUNT_FIELDS = ["price", "quantity", "quote_quantity", "stop_price"];
 var TradingResource = class extends Resource {
   /** Open orders, optionally filtered by market/status. */
@@ -820,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
@@ -835,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) {
@@ -850,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;
@@ -878,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;
@@ -889,23 +922,13 @@ var TradingResource = class extends Resource {
           return this.order(orderId, { signal: opts.signal, timeoutMs: opts.timeoutMs });
         }
         if (isRetryable(err) && attempt < maxRetries) {
-          await this.t.backoff("cancel_order", info, attempt, err, idempotencyKey, opts.signal);
+          await this.t.backoff("cancel_order", info, attempt, err, void 0, opts.signal);
           continue;
         }
         throw err;
       }
     }
   }
-  /**
-   * Cancels every open order in one market: `cancelAll({ symbol: "BTC/USDT" })`.
-   * To cancel across ALL markets, pass `symbol: null` explicitly: `cancelAll({ symbol: null })`.
-   * Omitting `symbol` is an error, so an account-wide cancel never happens by accident
-   * (the server itself treats `{}` as every market).
-   *
-   * The server limits cancel-all to 30 calls per minute per account. It is naturally
-   * repeatable, so it is retried after network errors; a retry reports only what that retry
-   * cancelled.
-   */
   async cancelAll(params, opts) {
     const hasSymbol = !!params && typeof params === "object" && Object.prototype.hasOwnProperty.call(params, "symbol");
     const symbol = hasSymbol ? params.symbol : void 0;
@@ -913,12 +936,97 @@ var TradingResource = class extends Resource {
     if (typeof symbol === "string" && symbol !== "") body = { symbol };
     else if (hasSymbol && symbol === null) body = {};
     else throw new CexyConfigError('cancelAll(): pass { symbol: "BASE/QUOTE" }, or { symbol: null } to cancel in every market');
-    return this.data({ op: "cancel_all", body }, opts);
+    const once = (o) => this.data({ op: "cancel_all", body }, o ?? opts);
+    if (params.untilDone !== true) return once();
+    const maxRounds = params.maxRounds ?? 20;
+    const budgetMs = params.timeBudgetMs ?? 12e4;
+    if (!(maxRounds >= 1)) throw new CexyConfigError("cancelAll(): maxRounds must be >= 1");
+    if (!(budgetMs > 0)) throw new CexyConfigError("cancelAll(): timeBudgetMs must be > 0");
+    const now = this.t.config.now ?? Date.now;
+    const start = now();
+    const state = /* @__PURE__ */ new Map();
+    const roundOpts = { ...opts, maxRetries: 0 };
+    let rounds = 0;
+    let idle = 0;
+    let hasMore = false;
+    let lastErrorCode;
+    let stopped;
+    const result = () => {
+      const pick = (list) => [...state].filter(([, v]) => v.list === list).map(([id]) => id);
+      return {
+        cancelled: pick("cancelled"),
+        already_closed: pick("already_closed"),
+        failed: pick("failed"),
+        failures: [...state.values()].flatMap((v) => v.list === "failed" && v.failure ? [v.failure] : []),
+        has_more: hasMore,
+        rounds,
+        stopped,
+        ...lastErrorCode !== void 0 ? { last_error_code: lastErrorCode } : {}
+      };
+    };
+    for (; ; ) {
+      let waitMs = 0;
+      let res;
+      try {
+        res = await once(roundOpts);
+      } catch (err) {
+        rounds++;
+        if (opts?.signal?.aborted) throw err;
+        if (!isRetryable(err)) {
+          stopped = "done";
+          throw new CancelAllInterruptedError(err, result());
+        }
+        lastErrorCode = errorCode(err);
+        if (rounds >= maxRounds) {
+          stopped = "max_rounds";
+          break;
+        }
+        const hint = err instanceof RateLimitError ? err.retryAfterMs : null;
+        if (hint !== null) {
+          waitMs = hint;
+          if (hint > MAX_SERVER_WAIT_MS) {
+            stopped = "time_budget";
+            break;
+          }
+        } else {
+          waitMs = (CANCEL_BACKOFF_S[Math.min(idle++, CANCEL_BACKOFF_S.length - 1)] ?? 15) * 1e3;
+        }
+      }
+      if (res) {
+        rounds++;
+        lastErrorCode = void 0;
+        hasMore = res.has_more;
+        const failures = res.failures ?? [];
+        for (const id of res.cancelled ?? []) state.set(id, { list: "cancelled" });
+        for (const id of res.already_closed ?? []) state.set(id, { list: "already_closed" });
+        for (const id of res.failed ?? []) {
+          const failure = failures.find((f) => f.order_id === id);
+          state.set(id, failure ? { list: "failed", failure } : { list: "failed" });
+        }
+        const progress = (res.cancelled?.length ?? 0) + (res.already_closed?.length ?? 0) > 0;
+        if (!res.has_more && !failures.some((f) => CANCEL_RETRY_CODES.has(f.code))) {
+          stopped = "done";
+          break;
+        }
+        if (rounds >= maxRounds) {
+          stopped = "max_rounds";
+          break;
+        }
+        if (progress) idle = 0;
+        else waitMs = (CANCEL_BACKOFF_S[Math.min(idle++, CANCEL_BACKOFF_S.length - 1)] ?? 15) * 1e3;
+      }
+      if (now() - start + waitMs >= budgetMs) {
+        stopped = "time_budget";
+        break;
+      }
+      if (waitMs > 0) await this.t.config.sleep(waitMs, opts?.signal);
+    }
+    return result();
   }
 };
 
 // src/version.ts
-var VERSION = "0.1.0-dev.3";
+var VERSION = "0.1.0-dev.5";
 var USER_AGENT = `cexy-typescript/${VERSION}`;
 
 // src/ws/emitter.ts
@@ -1686,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({
@@ -1699,6 +1808,7 @@ var CexyClient = class {
       userAgent: canSetUserAgent() ? [USER_AGENT, options.userAgentSuffix].filter(Boolean).join(" ") : null,
       sleep: sleep2,
       random: options.random ?? Math.random,
+      now: options.now ?? Date.now,
       onRetry: options.onRetry
     });
     const t = this.#transport;
@@ -1772,6 +1882,8 @@ 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;
@@ -1792,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;