@imbingox/acex 0.4.0-beta.12 → 0.4.0-beta.14

package/src/internal/watermark.ts

@@ -28,6 +28,17 @@ export function shouldApplyWatermarkedUpdate(
   const graceMs = options.graceMs ?? CROSS_CLOCK_WATERMARK_GRACE_MS;
   const requestStartedAt = options.requestStartedAt;
 
+  if (options.source === "command" && requestStartedAt !== undefined) {
+    const hasMissingExchangeTs =
+      current.exchangeTs === undefined || incoming.exchangeTs === undefined;
+    if (hasMissingExchangeTs) {
+      return (
+        current.receivedAt <= requestStartedAt &&
+        incoming.receivedAt >= current.receivedAt
+      );
+    }
+  }
+
   if (
     options.source === "rest" &&
     requestStartedAt !== undefined &&

package/src/managers/order/data-status.ts

@@ -0,0 +1,61 @@
+import type { OrderDataStatus, Venue } from "../../types/index.ts";
+
+export const DEFAULT_MAX_CLOSED_ORDERS_PER_SYMBOL = 500;
+
+export function cloneOrderStatus(status: OrderDataStatus): OrderDataStatus {
+  return { ...status };
+}
+
+export function createOrderDataStatus(
+  accountId: string,
+  venue: Venue,
+  activity: "active" | "inactive",
+): OrderDataStatus {
+  return {
+    accountId,
+    venue,
+    activity,
+    ready: false,
+    runtimeStatus: activity === "active" ? "bootstrap_pending" : "stopped",
+  };
+}
+
+export function normalizeMaxClosedOrdersPerSymbol(
+  value: number | undefined,
+): number {
+  return value !== undefined && Number.isInteger(value) && value > 0
+    ? value
+    : DEFAULT_MAX_CLOSED_ORDERS_PER_SYMBOL;
+}
+
+export function successfulStatus(
+  status: OrderDataStatus,
+  options: {
+    ready?: boolean;
+    lastReceivedAt?: number;
+    lastReadyAt?: number;
+    preserveStatus?: boolean;
+  },
+): OrderDataStatus {
+  const preservesStreamState =
+    options.preserveStatus &&
+    (status.runtimeStatus === "reconnecting" ||
+      status.reason === "ws_disconnected" ||
+      status.reason === "heartbeat_timeout");
+  const ready = options.ready ?? true;
+
+  return {
+    ...status,
+    activity: "active",
+    ready,
+    runtimeStatus: preservesStreamState ? status.runtimeStatus : "healthy",
+    reason: preservesStreamState ? status.reason : undefined,
+    lastReceivedAt: options.lastReceivedAt ?? status.lastReceivedAt,
+    lastReadyAt: ready
+      ? (options.lastReadyAt ??
+        (options.preserveStatus ? status.lastReadyAt : undefined) ??
+        Date.now())
+      : status.lastReadyAt,
+    inactiveSince: undefined,
+  };
+}

package/src/managers/order/identity.ts

@@ -0,0 +1,77 @@
+import type { OrderSnapshot } from "../../types/index.ts";
+
+export const SDK_CLIENT_ORDER_ID_PREFIX = "acex-";
+export const VENUE_CLIENT_ORDER_ID_PATTERN = /^[.A-Z:/a-z0-9_-]{1,32}$/;
+
+const SYSTEM_CLIENT_ORDER_ID_PATTERNS = [
+  /^adl_autoclose$/,
+  /^autoclose-/,
+  /^settlement_autoclose-/,
+];
+
+export function getOrderLookupKeys(input: {
+  symbol: string;
+  orderId?: string;
+  clientOrderId?: string;
+}): string[] {
+  const keys: string[] = [];
+  if (input.orderId) {
+    keys.push(`symbol:${input.symbol}:order:${input.orderId}`);
+  }
+
+  if (input.clientOrderId) {
+    keys.push(`symbol:${input.symbol}:client:${input.clientOrderId}`);
+  }
+
+  return keys;
+}
+
+export function shouldMatchOrderQuery(
+  candidate: OrderSnapshot,
+  input: { symbol?: string; orderId?: string; clientOrderId?: string },
+): boolean {
+  if (input.symbol && candidate.symbol !== input.symbol) {
+    return false;
+  }
+
+  if (input.orderId && candidate.orderId !== input.orderId) {
+    return false;
+  }
+
+  if (input.clientOrderId && candidate.clientOrderId !== input.clientOrderId) {
+    return false;
+  }
+
+  return Boolean(input.orderId || input.clientOrderId);
+}
+
+export function shouldMatchStoredOrderIdentity(
+  candidate: OrderSnapshot,
+  input: { symbol: string; orderId?: string; clientOrderId?: string },
+): boolean {
+  if (candidate.symbol !== input.symbol) {
+    return false;
+  }
+
+  if (candidate.orderId && input.orderId) {
+    return candidate.orderId === input.orderId;
+  }
+
+  // clientOrderId is only a temporary identity for an order that does not yet
+  // have an orderId. A candidate that already carries an orderId (including an
+  // old order sitting in closed that reused this clientOrderId) must not be
+  // merged by a cid-only update; otherwise the stale orderId would be carried
+  // forward and pollute closed. When the orderId is later filled in, the
+  // candidate still lacks an orderId and matches normally.
+  return Boolean(
+    input.clientOrderId &&
+      candidate.clientOrderId === input.clientOrderId &&
+      !candidate.orderId,
+  );
+}
+
+export function isSystemClientOrderId(clientOrderId: string): boolean {
+  return SYSTEM_CLIENT_ORDER_ID_PATTERNS.some((pattern) =>
+    pattern.test(clientOrderId),
+  );
+}

package/src/managers/order/model.ts

@@ -0,0 +1,36 @@
+import type {
+  OrderDataStatus,
+  OrderSnapshot,
+  Venue,
+} from "../../types/index.ts";
+
+export interface OrderRecord {
+  accountId: string;
+  venue: Venue;
+  subscribed: boolean;
+  openOrders: Map<string, Map<string, OrderSnapshot>>;
+  closedOrders: Map<string, Map<string, OrderSnapshot>>;
+  localOrderLocations: Map<string, OrderLocation>;
+  orderIdIndex: Map<string, Map<string, string>>;
+  orderIdOnlyIndex: Map<string, Set<string>>;
+  clientOrderIdIndex: Map<string, Set<string>>;
+  pendingClientOrderIdIndex: Map<string, PendingOrderClaim>;
+  status: OrderDataStatus;
+}
+
+export type OrderTable = "open" | "closed";
+
+export interface OrderLocation {
+  table: OrderTable;
+  symbol: string;
+  localOrderId: string;
+}
+
+export interface PendingOrderClaim {
+  localOrderId: string;
+  symbol: string;
+}
+
+export interface OrderManagerOptions {
+  maxClosedOrdersPerSymbol?: number;
+}

package/src/managers/order/snapshot.ts

@@ -0,0 +1,87 @@
+import BigNumber from "bignumber.js";
+import type { RawOrderUpdate } from "../../adapters/types.ts";
+import { toCanonical } from "../../internal/decimal.ts";
+import type { OrderSnapshot, Venue } from "../../types/index.ts";
+
+export function createSnapshot(
+  accountId: string,
+  venue: Venue,
+  input: RawOrderUpdate,
+  previous?: OrderSnapshot,
+): OrderSnapshot {
+  const amount = new BigNumber(input.amount);
+  const rawFilled = new BigNumber(input.filled);
+  const filled = previous
+    ? BigNumber.maximum(rawFilled, previous.filled)
+    : rawFilled;
+  const filledWasClamped = !filled.eq(rawFilled);
+  const remaining =
+    input.remaining === undefined || filledWasClamped
+      ? amount.minus(filled)
+      : new BigNumber(input.remaining);
+
+  return {
+    accountId,
+    venue,
+    orderId: input.orderId ?? previous?.orderId,
+    clientOrderId: input.clientOrderId ?? previous?.clientOrderId,
+    symbol: input.symbol,
+    side: input.side,
+    type: input.type,
+    status: mergeOrderStatus(input, previous),
+    price:
+      input.price === undefined ? previous?.price : toCanonical(input.price),
+    triggerPrice:
+      input.triggerPrice === undefined
+        ? previous?.triggerPrice
+        : toCanonical(input.triggerPrice),
+    amount: toCanonical(amount),
+    filled: toCanonical(filled),
+    remaining: toCanonical(remaining),
+    reduceOnly: input.reduceOnly ?? previous?.reduceOnly,
+    positionSide: input.positionSide ?? previous?.positionSide,
+    avgFillPrice:
+      input.avgFillPrice === undefined
+        ? previous?.avgFillPrice
+        : toCanonical(input.avgFillPrice),
+    exchangeTs: input.exchangeTs,
+    receivedAt: input.receivedAt,
+    updatedAt: input.receivedAt,
+    seq: (previous?.seq ?? 0) + 1,
+  };
+}
+
+export function mergeOrderStatus(
+  input: RawOrderUpdate,
+  previous?: OrderSnapshot,
+): OrderSnapshot["status"] {
+  if (!previous) {
+    return input.status;
+  }
+
+  if (orderPriority(input.status) < orderPriority(previous.status)) {
+    return previous.status;
+  }
+
+  return input.status;
+}
+
+export function isOpenOrder(snapshot: OrderSnapshot): boolean {
+  return snapshot.status === "open" || snapshot.status === "partially_filled";
+}
+
+export function orderPriority(status: OrderSnapshot["status"]): number {
+  switch (status) {
+    case "filled":
+      return 5;
+    case "canceled":
+    case "expired":
+      return 4;
+    case "rejected":
+      return 3;
+    case "partially_filled":
+      return 2;
+    case "open":
+      return 1;
+  }
+}