@imbingox/acex 0.4.0-beta.11 → 0.4.0-beta.13

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;
+  }
+}

package/src/managers/order/store.ts

@@ -0,0 +1,486 @@
+import type { OrderSnapshot } from "../../types/index.ts";
+import {
+  isSystemClientOrderId,
+  shouldMatchStoredOrderIdentity,
+} from "./identity.ts";
+import type { OrderLocation, OrderRecord, OrderTable } from "./model.ts";
+import { isOpenOrder } from "./snapshot.ts";
+
+export interface SetSnapshotResult {
+  location?: OrderLocation;
+  trimmedSnapshots: OrderSnapshot[];
+}
+
+export interface SetSnapshotOptions {
+  maxClosedOrdersPerSymbol: number;
+  previousLocation?: OrderLocation;
+}
+
+export interface LocalOrderResolution {
+  localOrderId?: string;
+  source?: "exact" | "pending" | "provisional" | "preferred";
+}
+
+export function getSnapshotAtLocation(
+  record: OrderRecord,
+  location: OrderLocation,
+): OrderSnapshot | undefined {
+  return getOrderTable(record, location.table)
+    .get(location.symbol)
+    ?.get(location.localOrderId);
+}
+
+export function getSnapshotByLocalOrderId(
+  record: OrderRecord,
+  localOrderId: string,
+): OrderSnapshot | undefined {
+  const location = record.localOrderLocations.get(localOrderId);
+  return location ? getSnapshotAtLocation(record, location) : undefined;
+}
+
+export function getOrderTable(
+  record: OrderRecord,
+  table: OrderTable,
+): Map<string, Map<string, OrderSnapshot>> {
+  return table === "open" ? record.openOrders : record.closedOrders;
+}
+
+function getOrCreateSymbolOrders(
+  table: Map<string, Map<string, OrderSnapshot>>,
+  symbol: string,
+): Map<string, OrderSnapshot> {
+  const existing = table.get(symbol);
+  if (existing) {
+    return existing;
+  }
+
+  const created = new Map<string, OrderSnapshot>();
+  table.set(symbol, created);
+  return created;
+}
+
+function getOrCreateOrderIdSymbolIndex(
+  record: OrderRecord,
+  symbol: string,
+): Map<string, string> {
+  const existing = record.orderIdIndex.get(symbol);
+  if (existing) {
+    return existing;
+  }
+
+  const created = new Map<string, string>();
+  record.orderIdIndex.set(symbol, created);
+  return created;
+}
+
+export function getLocalOrderIdForVenueOrderId(
+  record: OrderRecord,
+  symbol: string,
+  orderId: string,
+): string | undefined {
+  return record.orderIdIndex.get(symbol)?.get(orderId);
+}
+
+export function getLocationByLocalOrderId(
+  record: OrderRecord,
+  localOrderId: string,
+): OrderLocation | undefined {
+  return record.localOrderLocations.get(localOrderId);
+}
+
+export function getExistingSnapshot(
+  record: OrderRecord,
+  update: { symbol: string; orderId?: string; clientOrderId?: string },
+): OrderSnapshot | undefined {
+  const location = getExistingSnapshotLocation(record, update);
+  return location ? getSnapshotAtLocation(record, location) : undefined;
+}
+
+export function getExistingSnapshotLocation(
+  record: OrderRecord,
+  update: { symbol: string; orderId?: string; clientOrderId?: string },
+): OrderLocation | undefined {
+  const resolution = resolveLocalOrderIdForUpdate(record, update);
+  return resolution.localOrderId
+    ? record.localOrderLocations.get(resolution.localOrderId)
+    : undefined;
+}
+
+export function resolveLocalOrderIdForUpdate(
+  record: OrderRecord,
+  update: { symbol: string; orderId?: string; clientOrderId?: string },
+  options: {
+    preferredLocalOrderId?: string;
+    pendingLocalOrderId?: string;
+  } = {},
+): LocalOrderResolution {
+  if (update.orderId) {
+    const exact = getLocalOrderIdForVenueOrderId(
+      record,
+      update.symbol,
+      update.orderId,
+    );
+    if (exact) {
+      return { localOrderId: exact, source: "exact" };
+    }
+  }
+
+  if (options.preferredLocalOrderId) {
+    return {
+      localOrderId: options.preferredLocalOrderId,
+      source: "preferred",
+    };
+  }
+
+  if (options.pendingLocalOrderId) {
+    return { localOrderId: options.pendingLocalOrderId, source: "pending" };
+  }
+
+  if (update.clientOrderId && !isSystemClientOrderId(update.clientOrderId)) {
+    for (const localOrderId of record.clientOrderIdIndex.get(
+      update.clientOrderId,
+    ) ?? []) {
+      const snapshot = getSnapshotByLocalOrderId(record, localOrderId);
+      if (snapshot && shouldMatchStoredOrderIdentity(snapshot, update)) {
+        return { localOrderId, source: "provisional" };
+      }
+    }
+  }
+
+  return {};
+}
+
+export function getSnapshotsForOrderId(
+  record: OrderRecord,
+  orderId: string,
+): OrderSnapshot[] {
+  return getSnapshotsForLocalOrderIds(
+    record,
+    record.orderIdOnlyIndex.get(orderId),
+  );
+}
+
+export function getSnapshotsForClientOrderId(
+  record: OrderRecord,
+  clientOrderId: string,
+): OrderSnapshot[] {
+  return getSnapshotsForLocalOrderIds(
+    record,
+    record.clientOrderIdIndex.get(clientOrderId),
+  );
+}
+
+export function getSnapshotsForLocalOrderIds(
+  record: OrderRecord,
+  localOrderIds?: Iterable<string>,
+): OrderSnapshot[] {
+  if (!localOrderIds) {
+    return [];
+  }
+
+  const snapshots: OrderSnapshot[] = [];
+  for (const localOrderId of localOrderIds) {
+    const snapshot = getSnapshotByLocalOrderId(record, localOrderId);
+    if (snapshot) {
+      snapshots.push(snapshot);
+    }
+  }
+
+  return snapshots;
+}
+
+export function getOpenOrderSnapshots(
+  record: OrderRecord,
+  symbol?: string,
+): OrderSnapshot[] {
+  if (symbol) {
+    return [...(record.openOrders.get(symbol)?.values() ?? [])];
+  }
+
+  return getSnapshotsInTable(record.openOrders);
+}
+
+export function getAllSnapshots(record: OrderRecord): OrderSnapshot[] {
+  return [
+    ...getSnapshotsInTable(record.openOrders),
+    ...getSnapshotsInTable(record.closedOrders),
+  ];
+}
+
+export function getSnapshotsInTable(
+  table: Map<string, Map<string, OrderSnapshot>>,
+): OrderSnapshot[] {
+  const snapshots: OrderSnapshot[] = [];
+  for (const symbolOrders of table.values()) {
+    snapshots.push(...symbolOrders.values());
+  }
+
+  return snapshots;
+}
+
+export function getSnapshotCount(record: OrderRecord): number {
+  return (
+    getSnapshotCountInTable(record.openOrders) +
+    getSnapshotCountInTable(record.closedOrders)
+  );
+}
+
+export function getSnapshotCountInTable(
+  table: Map<string, Map<string, OrderSnapshot>>,
+): number {
+  let size = 0;
+  for (const symbolOrders of table.values()) {
+    size += symbolOrders.size;
+  }
+
+  return size;
+}
+
+function addLocalOrderIdToSetIndex(
+  index: Map<string, Set<string>>,
+  key: string,
+  localOrderId: string,
+): void {
+  const localOrderIds = index.get(key);
+  if (localOrderIds) {
+    localOrderIds.add(localOrderId);
+    return;
+  }
+
+  index.set(key, new Set([localOrderId]));
+}
+
+function removeLocalOrderIdFromSetIndex(
+  index: Map<string, Set<string>>,
+  key: string,
+  localOrderId: string,
+): void {
+  const localOrderIds = index.get(key);
+  if (!localOrderIds) {
+    return;
+  }
+
+  localOrderIds.delete(localOrderId);
+
+  if (localOrderIds.size === 0) {
+    index.delete(key);
+  }
+}
+
+export function selectLatestSnapshot(
+  snapshots: OrderSnapshot[],
+): OrderSnapshot | undefined {
+  let latest: OrderSnapshot | undefined;
+  for (const snapshot of snapshots) {
+    if (!latest) {
+      latest = snapshot;
+      continue;
+    }
+
+    const snapshotOpen = isOpenOrder(snapshot);
+    const latestOpen = isOpenOrder(latest);
+    if (snapshotOpen !== latestOpen) {
+      // Open candidate has absolute priority: current active order takes
+      // precedence over historical terminal state (when clientOrderId is
+      // reused, the old order is already closed).
+      if (snapshotOpen) {
+        latest = snapshot;
+      }
+      continue;
+    }
+
+    // Both open or both closed: take the latest by updatedAt.
+    // seq must not be used -- seq is a per-order version number and is not
+    // comparable across orders (e.g. different orders that reuse a cid).
+    if (snapshot.updatedAt > latest.updatedAt) {
+      latest = snapshot;
+    }
+  }
+
+  return latest;
+}
+
+export function isVenueClientOrderIdInUseForOpenOrder(
+  record: OrderRecord,
+  venueClientOrderId: string,
+): boolean {
+  for (const localOrderId of record.clientOrderIdIndex.get(
+    venueClientOrderId,
+  ) ?? []) {
+    const location = record.localOrderLocations.get(localOrderId);
+    if (location?.table === "open") {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function setSnapshot(
+  record: OrderRecord,
+  localOrderId: string,
+  snapshot: OrderSnapshot,
+  options: SetSnapshotOptions,
+): SetSnapshotResult {
+  if (!snapshot.orderId && !snapshot.clientOrderId) {
+    return { trimmedSnapshots: [] };
+  }
+
+  const currentLocation =
+    options.previousLocation ?? record.localOrderLocations.get(localOrderId);
+  if (currentLocation) {
+    return moveSnapshot(record, currentLocation, localOrderId, snapshot, {
+      maxClosedOrdersPerSymbol: options.maxClosedOrdersPerSymbol,
+    });
+  }
+
+  return insertSnapshot(record, localOrderId, snapshot, {
+    maxClosedOrdersPerSymbol: options.maxClosedOrdersPerSymbol,
+  });
+}
+
+function insertSnapshot(
+  record: OrderRecord,
+  localOrderId: string,
+  snapshot: OrderSnapshot,
+  options: { maxClosedOrdersPerSymbol: number },
+): SetSnapshotResult {
+  const existingLocation = record.localOrderLocations.get(localOrderId);
+  if (existingLocation) {
+    deleteSnapshot(record, existingLocation);
+  }
+
+  const location: OrderLocation = {
+    table: isOpenOrder(snapshot) ? "open" : "closed",
+    symbol: snapshot.symbol,
+    localOrderId,
+  };
+
+  const table = getOrderTable(record, location.table);
+  const symbolOrders = getOrCreateSymbolOrders(table, location.symbol);
+  symbolOrders.set(localOrderId, snapshot);
+  record.localOrderLocations.set(localOrderId, location);
+
+  if (snapshot.orderId) {
+    const symbolIndex = getOrCreateOrderIdSymbolIndex(record, snapshot.symbol);
+    symbolIndex.set(snapshot.orderId, localOrderId);
+    addLocalOrderIdToSetIndex(
+      record.orderIdOnlyIndex,
+      snapshot.orderId,
+      localOrderId,
+    );
+  }
+
+  if (snapshot.clientOrderId) {
+    addLocalOrderIdToSetIndex(
+      record.clientOrderIdIndex,
+      snapshot.clientOrderId,
+      localOrderId,
+    );
+  }
+
+  const trimmedSnapshots = trimClosedOrdersForSymbol(record, location, {
+    maxClosedOrdersPerSymbol: options.maxClosedOrdersPerSymbol,
+  });
+  return { location, trimmedSnapshots };
+}
+
+function deleteSnapshot(
+  record: OrderRecord,
+  location: OrderLocation,
+): OrderSnapshot | undefined {
+  const snapshot = getSnapshotAtLocation(record, location);
+  if (!snapshot) {
+    return undefined;
+  }
+
+  const table = getOrderTable(record, location.table);
+  const symbolOrders = table.get(location.symbol);
+  symbolOrders?.delete(location.localOrderId);
+  if (symbolOrders?.size === 0) {
+    table.delete(location.symbol);
+  }
+  record.localOrderLocations.delete(location.localOrderId);
+
+  if (snapshot.orderId) {
+    const symbolIndex = record.orderIdIndex.get(location.symbol);
+    if (
+      symbolIndex?.get(snapshot.orderId) &&
+      symbolIndex.get(snapshot.orderId) === location.localOrderId
+    ) {
+      symbolIndex.delete(snapshot.orderId);
+    }
+    if (symbolIndex?.size === 0) {
+      record.orderIdIndex.delete(location.symbol);
+    }
+    removeLocalOrderIdFromSetIndex(
+      record.orderIdOnlyIndex,
+      snapshot.orderId,
+      location.localOrderId,
+    );
+  }
+
+  if (snapshot.clientOrderId) {
+    removeLocalOrderIdFromSetIndex(
+      record.clientOrderIdIndex,
+      snapshot.clientOrderId,
+      location.localOrderId,
+    );
+  }
+
+  return snapshot;
+}
+
+function moveSnapshot(
+  record: OrderRecord,
+  previousLocation: OrderLocation,
+  localOrderId: string,
+  snapshot: OrderSnapshot,
+  options: { maxClosedOrdersPerSymbol: number },
+): SetSnapshotResult {
+  deleteSnapshot(record, previousLocation);
+  return insertSnapshot(record, localOrderId, snapshot, {
+    maxClosedOrdersPerSymbol: options.maxClosedOrdersPerSymbol,
+  });
+}
+
+function trimClosedOrdersForSymbol(
+  record: OrderRecord,
+  location: OrderLocation,
+  options: { maxClosedOrdersPerSymbol: number },
+): OrderSnapshot[] {
+  if (location.table !== "closed") {
+    return [];
+  }
+
+  let symbolOrders = record.closedOrders.get(location.symbol);
+  if (!symbolOrders || symbolOrders.size <= options.maxClosedOrdersPerSymbol) {
+    return [];
+  }
+
+  const trimmedSnapshots: OrderSnapshot[] = [];
+  const trimBatchSize = Math.max(
+    1,
+    Math.floor(options.maxClosedOrdersPerSymbol / 10),
+  );
+  while (symbolOrders && symbolOrders.size > options.maxClosedOrdersPerSymbol) {
+    const keys = symbolOrders.keys();
+    for (let deleted = 0; deleted < trimBatchSize; deleted += 1) {
+      const next = keys.next();
+      if (next.done) {
+        break;
+      }
+      const deletedSnapshot = deleteSnapshot(record, {
+        table: "closed",
+        symbol: location.symbol,
+        localOrderId: next.value,
+      });
+      if (deletedSnapshot) {
+        trimmedSnapshots.push(deletedSnapshot);
+      }
+    }
+    symbolOrders = record.closedOrders.get(location.symbol);
+  }
+
+  return trimmedSnapshots;
+}