@imbingox/acex 0.3.1-beta.0 → 0.4.0-beta.10

package/src/managers/account-manager.ts

@@ -15,7 +15,12 @@ import type {
   PrivateSubscriptionState,
 } from "../client/context.ts";
 import { AsyncEventBus } from "../internal/async-event-bus.ts";
+import { toCanonical } from "../internal/decimal.ts";
 import { matchesAccountFilter } from "../internal/filters.ts";
+import {
+  canDeleteMissingFromSnapshot,
+  shouldApplyWatermarkedUpdate,
+} from "../internal/watermark.ts";
 import type {
   AccountDataStatus,
   AccountEvent,
@@ -56,6 +61,50 @@ function getBigNumber(
   return value === undefined ? fallback : new BigNumber(value);
 }
 
+function isZeroDecimal(value: string): boolean {
+  return new BigNumber(value).isZero();
+}
+
+function isZeroBalance(balance: BalanceSnapshot): boolean {
+  return (
+    isZeroDecimal(balance.free) &&
+    isZeroDecimal(balance.used) &&
+    isZeroDecimal(balance.total)
+  );
+}
+
+function successfulStatus(
+  status: AccountDataStatus,
+  options: {
+    ready?: boolean;
+    lastReceivedAt?: number;
+    lastReadyAt?: number;
+    preserveStatus?: boolean;
+  },
+): AccountDataStatus {
+  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,
+  };
+}
+
 export class AccountManagerImpl
   implements
     AccountManager,
@@ -277,7 +326,7 @@ export class AccountManagerImpl
     accountId: string,
     venue: Venue,
     update: RawAccountUpdate,
-    options: { preserveStatus?: boolean } = {},
+    options: { preserveStatus?: boolean; requestStartedAt?: number } = {},
   ): void {
     const record = this.getOrCreateRecord(accountId, venue);
     if (!record.subscribed) {
@@ -295,7 +344,17 @@ export class AccountManagerImpl
     );
     let risk = previous.risk;
 
+    let latestAppliedAt = 0;
     for (const balance of update.balances ?? []) {
+      if (
+        !shouldApplyWatermarkedUpdate(balances[balance.asset], balance, {
+          requestStartedAt: options.requestStartedAt,
+          source: options.requestStartedAt === undefined ? "stream" : "rest",
+        })
+      ) {
+        continue;
+      }
+
       const nextBalance = this.createBalance(
         accountId,
         venue,
@@ -303,6 +362,7 @@ export class AccountManagerImpl
         balances[balance.asset],
       );
       balances[balance.asset] = nextBalance;
+      latestAppliedAt = Math.max(latestAppliedAt, nextBalance.receivedAt);
       this.accountBus.publish({
         type: "balance.updated",
         accountId,
@@ -315,6 +375,15 @@ export class AccountManagerImpl
 
     for (const position of update.positions ?? []) {
       const key = positionKey(position.symbol, position.side);
+      if (
+        !shouldApplyWatermarkedUpdate(positions.get(key), position, {
+          requestStartedAt: options.requestStartedAt,
+          source: options.requestStartedAt === undefined ? "stream" : "rest",
+        })
+      ) {
+        continue;
+      }
+
       const nextPosition = this.createPosition(
         accountId,
         venue,
@@ -322,12 +391,13 @@ export class AccountManagerImpl
         positions.get(key),
       );
 
-      if (nextPosition.size.isZero()) {
+      if (isZeroDecimal(nextPosition.size)) {
         positions.delete(key);
       } else {
         positions.set(key, nextPosition);
       }
 
+      latestAppliedAt = Math.max(latestAppliedAt, nextPosition.receivedAt);
       this.accountBus.publish({
         type: "position.updated",
         accountId,
@@ -338,8 +408,15 @@ export class AccountManagerImpl
       });
     }
 
-    if (update.risk) {
+    if (
+      update.risk &&
+      shouldApplyWatermarkedUpdate(previous.risk, update.risk, {
+        requestStartedAt: options.requestStartedAt,
+        source: options.requestStartedAt === undefined ? "stream" : "rest",
+      })
+    ) {
       risk = this.createRisk(accountId, venue, update.risk, previous.risk);
+      latestAppliedAt = Math.max(latestAppliedAt, risk.receivedAt);
       this.accountBus.publish({
         type: "risk.updated",
         accountId,
@@ -349,34 +426,166 @@ export class AccountManagerImpl
       });
     }
 
+    if (latestAppliedAt === 0) {
+      return;
+    }
+
+    record.snapshot = {
+      accountId,
+      venue,
+      balances,
+      positions: [...positions.values()],
+      risk,
+      exchangeTs:
+        update.exchangeTs === undefined
+          ? previous.exchangeTs
+          : update.exchangeTs,
+      receivedAt: latestAppliedAt,
+      updatedAt: latestAppliedAt,
+    };
+    record.status = successfulStatus(record.status, {
+      preserveStatus: options.preserveStatus,
+      lastReceivedAt: latestAppliedAt,
+      lastReadyAt: latestAppliedAt,
+    });
+    this.publishStatus(record);
+  }
+
+  onPrivateAccountReconcile(
+    accountId: string,
+    venue: Venue,
+    snapshot: RawAccountBootstrap,
+    options: { requestStartedAt: number; preserveStatus?: boolean },
+  ): void {
+    const record = this.getOrCreateRecord(accountId, venue);
+    if (!record.subscribed) {
+      return;
+    }
+
+    const previous =
+      record.snapshot ?? this.createEmptySnapshot(accountId, venue);
+    const balances = { ...previous.balances };
+    const positions = new Map(
+      previous.positions.map((position) => [
+        positionKey(position.symbol, position.side),
+        position,
+      ]),
+    );
+    let risk = previous.risk;
+
+    const incomingBalanceAssets = new Set<string>();
+    for (const balance of snapshot.balances) {
+      incomingBalanceAssets.add(balance.asset);
+      if (
+        !shouldApplyWatermarkedUpdate(balances[balance.asset], balance, {
+          requestStartedAt: options.requestStartedAt,
+          source: "rest",
+        })
+      ) {
+        continue;
+      }
+
+      const nextBalance = this.createBalance(
+        accountId,
+        venue,
+        balance,
+        balances[balance.asset],
+      );
+      if (isZeroBalance(nextBalance)) {
+        delete balances[balance.asset];
+      } else {
+        balances[balance.asset] = nextBalance;
+      }
+    }
+
+    for (const [asset, balance] of Object.entries(balances)) {
+      if (
+        (!incomingBalanceAssets.has(asset) || isZeroBalance(balance)) &&
+        canDeleteMissingFromSnapshot(balance, {
+          requestStartedAt: options.requestStartedAt,
+          snapshotExchangeTs: snapshot.exchangeTs,
+        })
+      ) {
+        delete balances[asset];
+      }
+    }
+
+    const incomingPositionKeys = new Set<string>();
+    for (const position of snapshot.positions) {
+      const key = positionKey(position.symbol, position.side);
+      incomingPositionKeys.add(key);
+      if (
+        !shouldApplyWatermarkedUpdate(positions.get(key), position, {
+          requestStartedAt: options.requestStartedAt,
+          source: "rest",
+        })
+      ) {
+        continue;
+      }
+
+      const nextPosition = this.createPosition(
+        accountId,
+        venue,
+        position,
+        positions.get(key),
+      );
+      if (isZeroDecimal(nextPosition.size)) {
+        positions.delete(key);
+      } else {
+        positions.set(key, nextPosition);
+      }
+    }
+
+    for (const [key, position] of positions.entries()) {
+      if (
+        !incomingPositionKeys.has(key) &&
+        canDeleteMissingFromSnapshot(position, {
+          requestStartedAt: options.requestStartedAt,
+          snapshotExchangeTs: snapshot.exchangeTs,
+        })
+      ) {
+        positions.delete(key);
+      }
+    }
+
+    if (
+      snapshot.risk &&
+      shouldApplyWatermarkedUpdate(previous.risk, snapshot.risk, {
+        requestStartedAt: options.requestStartedAt,
+        source: "rest",
+      })
+    ) {
+      risk = this.createRisk(accountId, venue, snapshot.risk, previous.risk);
+    }
+
     record.snapshot = {
       accountId,
       venue,
       balances,
       positions: [...positions.values()],
       risk,
-      exchangeTs: update.exchangeTs ?? previous.exchangeTs,
-      receivedAt: update.receivedAt,
-      updatedAt: update.receivedAt,
+      exchangeTs:
+        snapshot.exchangeTs === undefined
+          ? previous.exchangeTs
+          : snapshot.exchangeTs,
+      receivedAt: snapshot.receivedAt,
+      updatedAt: snapshot.receivedAt,
     };
-    record.status = options.preserveStatus
-      ? {
-          ...record.status,
-          activity: "active",
-          lastReceivedAt: update.receivedAt,
-          lastReadyAt: record.status.lastReadyAt ?? update.receivedAt,
-          inactiveSince: undefined,
-        }
-      : {
-          ...record.status,
-          activity: "active",
-          ready: true,
-          runtimeStatus: "healthy",
-          reason: undefined,
-          lastReceivedAt: update.receivedAt,
-          lastReadyAt: update.receivedAt,
-          inactiveSince: undefined,
-        };
+    record.status = successfulStatus(record.status, {
+      preserveStatus: options.preserveStatus,
+      lastReceivedAt: snapshot.receivedAt,
+      lastReadyAt: snapshot.receivedAt,
+    });
+
+    const event: AccountSnapshotReplacedEvent = {
+      type: "account.snapshot_replaced",
+      accountId,
+      venue,
+      snapshot: record.snapshot,
+      ts: this.context.now(),
+    };
+
+    this.accountBus.publish(event);
     this.publishStatus(record);
   }
 
@@ -461,7 +670,7 @@ export class AccountManagerImpl
     );
     const positions = bootstrap.positions
       .map((position) => this.createPosition(accountId, venue, position))
-      .filter((position) => !position.size.isZero());
+      .filter((position) => !isZeroDecimal(position.size));
     const risk = bootstrap.risk
       ? this.createRisk(accountId, venue, bootstrap.risk)
       : undefined;
@@ -499,9 +708,12 @@ export class AccountManagerImpl
     input: RawBalanceUpdate,
     previous?: BalanceSnapshot,
   ): BalanceSnapshot {
-    const previousFree = previous?.free ?? new BigNumber(0);
-    const previousUsed = previous?.used ?? new BigNumber(0);
-    const previousTotal = previous?.total ?? previousFree.plus(previousUsed);
+    const previousFree = new BigNumber(previous?.free ?? 0);
+    const previousUsed = new BigNumber(previous?.used ?? 0);
+    const previousTotal =
+      previous?.total === undefined
+        ? previousFree.plus(previousUsed)
+        : new BigNumber(previous.total);
     const free = getBigNumber(input.free, previousFree);
     const total = getBigNumber(input.total, previousTotal);
     const used =
@@ -515,27 +727,27 @@ export class AccountManagerImpl
       accountId,
       venue,
       asset: input.asset,
-      free,
-      used,
-      total,
+      free: toCanonical(free),
+      used: toCanonical(used),
+      total: toCanonical(total),
       exchangeTs: input.exchangeTs,
       receivedAt: input.receivedAt,
       updatedAt: input.receivedAt,
       seq: (previous?.seq ?? 0) + 1,
       lending: input.lending
         ? {
-            supplied: new BigNumber(input.lending.supplied),
-            borrowed: new BigNumber(input.lending.borrowed),
-            interest: new BigNumber(input.lending.interest),
-            netAsset: new BigNumber(input.lending.netAsset),
+            supplied: toCanonical(input.lending.supplied),
+            borrowed: toCanonical(input.lending.borrowed),
+            interest: toCanonical(input.lending.interest),
+            netAsset: toCanonical(input.lending.netAsset),
             supplyAPY:
               input.lending.supplyAPY === undefined
                 ? undefined
-                : new BigNumber(input.lending.supplyAPY),
+                : toCanonical(input.lending.supplyAPY),
             borrowAPY:
               input.lending.borrowAPY === undefined
                 ? undefined
-                : new BigNumber(input.lending.borrowAPY),
+                : toCanonical(input.lending.borrowAPY),
           }
         : previous?.lending,
     };
@@ -552,27 +764,27 @@ export class AccountManagerImpl
       venue,
       symbol: input.symbol,
       side: input.side,
-      size: new BigNumber(input.size),
+      size: toCanonical(input.size),
       entryPrice:
         input.entryPrice === undefined
           ? previous?.entryPrice
-          : new BigNumber(input.entryPrice),
+          : toCanonical(input.entryPrice),
       markPrice:
         input.markPrice === undefined
           ? previous?.markPrice
-          : new BigNumber(input.markPrice),
+          : toCanonical(input.markPrice),
       unrealizedPnl:
         input.unrealizedPnl === undefined
           ? previous?.unrealizedPnl
-          : new BigNumber(input.unrealizedPnl),
+          : toCanonical(input.unrealizedPnl),
       leverage:
         input.leverage === undefined
           ? previous?.leverage
-          : new BigNumber(input.leverage),
+          : toCanonical(input.leverage),
       liquidationPrice:
         input.liquidationPrice === undefined
           ? previous?.liquidationPrice
-          : new BigNumber(input.liquidationPrice),
+          : toCanonical(input.liquidationPrice),
       exchangeTs: input.exchangeTs,
       receivedAt: input.receivedAt,
       updatedAt: input.receivedAt,
@@ -592,27 +804,27 @@ export class AccountManagerImpl
       netEquity:
         input.netEquity === undefined
           ? previous?.netEquity
-          : new BigNumber(input.netEquity),
+          : toCanonical(input.netEquity),
       riskEquity:
         input.riskEquity === undefined
           ? previous?.riskEquity
-          : new BigNumber(input.riskEquity),
+          : toCanonical(input.riskEquity),
       riskRatio:
         input.riskRatio === undefined
           ? previous?.riskRatio
-          : new BigNumber(input.riskRatio),
+          : toCanonical(input.riskRatio),
       riskLeverage:
         input.riskLeverage === undefined
           ? previous?.riskLeverage
-          : new BigNumber(input.riskLeverage),
+          : toCanonical(input.riskLeverage),
       initialMargin:
         input.initialMargin === undefined
           ? previous?.initialMargin
-          : new BigNumber(input.initialMargin),
+          : toCanonical(input.initialMargin),
       maintenanceMargin:
         input.maintenanceMargin === undefined
           ? previous?.maintenanceMargin
-          : new BigNumber(input.maintenanceMargin),
+          : toCanonical(input.maintenanceMargin),
       exchangeTs: input.exchangeTs,
       receivedAt: input.receivedAt,
       updatedAt: input.receivedAt,
@@ -622,27 +834,27 @@ export class AccountManagerImpl
             marginLevel:
               input.lending.marginLevel === undefined
                 ? undefined
-                : new BigNumber(input.lending.marginLevel),
+                : toCanonical(input.lending.marginLevel),
             healthFactor:
               input.lending.healthFactor === undefined
                 ? undefined
-                : new BigNumber(input.lending.healthFactor),
+                : toCanonical(input.lending.healthFactor),
             ltv:
               input.lending.ltv === undefined
                 ? undefined
-                : new BigNumber(input.lending.ltv),
+                : toCanonical(input.lending.ltv),
             liquidationThreshold:
               input.lending.liquidationThreshold === undefined
                 ? undefined
-                : new BigNumber(input.lending.liquidationThreshold),
+                : toCanonical(input.lending.liquidationThreshold),
             totalCollateralUSD:
               input.lending.totalCollateralUSD === undefined
                 ? undefined
-                : new BigNumber(input.lending.totalCollateralUSD),
+                : toCanonical(input.lending.totalCollateralUSD),
             totalDebtUSD:
               input.lending.totalDebtUSD === undefined
                 ? undefined
-                : new BigNumber(input.lending.totalDebtUSD),
+                : toCanonical(input.lending.totalDebtUSD),
           }
         : previous?.lending,
     };