@agg-build/sdk 4.17.4 → 4.18.0

package/dist/market-data.mjs

@@ -0,0 +1,352 @@
+import {
+  CandleBuilder
+} from "./chunk-VD5UTAVD.mjs";
+import {
+  AggWebSocket,
+  decodeChartHistory,
+  loadImmutableHistory,
+  readChartHistoryText
+} from "./chunk-QXBVA5TW.mjs";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-WNQUEZJF.mjs";
+
+// src/market-data/engine.ts
+var intervals = ["1m", "5m", "1h", "1d"];
+var MarketDataEngine = class {
+  constructor() {
+    this.socket = null;
+    this.generation = 0;
+    this.receivedAtMs = 0;
+    this.revision = 0;
+    this.deliveredClosed = /* @__PURE__ */ new Map();
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.builders = /* @__PURE__ */ new Map();
+    this.dirty = /* @__PURE__ */ new Map();
+    this.inFlight = false;
+    this.deliveryToken = null;
+    this.disposed = false;
+    this.history = /* @__PURE__ */ new Map();
+    this.measurements = {
+      received: 0,
+      published: 0,
+      coalesced: 0,
+      maxPendingOutcomes: 0,
+      maxInFlight: 0
+    };
+  }
+  start(options, event) {
+    this.dispose();
+    this.disposed = false;
+    this.generation = 0;
+    this.revision = 0;
+    const callbacks = {};
+    const names = [
+      "onConnected",
+      "onAuthenticated",
+      "onHeartbeat",
+      "onSubscribed",
+      "onUnsubscribed",
+      "onMarketResolved",
+      "onError",
+      "onOrderSubmitted",
+      "onBalanceUpdate",
+      "onOrderEvent",
+      "onRedeemEvent",
+      "onWithdrawalLifecycle",
+      "onArbMarket",
+      "onArbFeed",
+      "onDiagnostics",
+      "onConnectionStateChange"
+    ];
+    for (const name of names) {
+      Object.assign(callbacks, {
+        [name]: (...args) => {
+          var _a;
+          if (name === "onConnectionStateChange" && args[0] === false) {
+            for (const builder of this.builders.values()) builder.reset();
+            this.dirty.clear();
+            this.deliveredClosed.clear();
+          }
+          if (name === "onMarketResolved") {
+            const id = args[0].outcomeId;
+            (_a = this.builders.get(id)) == null ? void 0 : _a.dispose();
+            this.builders.delete(id);
+            this.dirty.delete(id);
+          }
+          if (name === "onDiagnostics") {
+            const diagnostic = args[0];
+            if (diagnostic.outcomeId && ["seq_gap", "checksum_mismatch"].includes(diagnostic.type))
+              this.mark(diagnostic.outcomeId, false);
+          }
+          event({ name, args, revision: this.revision });
+        }
+      });
+    }
+    callbacks.onFrameReceived = (receivedAtMs) => {
+      this.receivedAtMs = receivedAtMs;
+      this.revision++;
+    };
+    callbacks.onBookTick = (id, tick) => {
+      if (tick.midpoint != null) this.builder(id).addMidpoint(tick.midpoint, tick.timestamp);
+      this.mark(id, tick.source === "snapshot");
+    };
+    callbacks.onTrade = (trade) => {
+      this.builder(trade.outcomeId).addTrade(trade.price, trade.size, trade.timestamp);
+      this.mark(trade.outcomeId, false, trade);
+    };
+    this.socket = new AggWebSocket(__spreadProps(__spreadValues({}, options), { callbacks, deferBookViews: true }));
+  }
+  observeViews(observer) {
+    this.observer = observer;
+  }
+  setSubscriptions(subscriptions, generation) {
+    var _a;
+    if (generation < this.generation) return;
+    this.generation = generation;
+    const desired = new Map(subscriptions.map((sub) => [`${sub.channel}:${sub.id}`, sub]));
+    for (const [key, unsubscribe] of this.subscriptions) {
+      if (!desired.has(key)) {
+        unsubscribe();
+        this.subscriptions.delete(key);
+      }
+    }
+    for (const [key, sub] of desired) {
+      if (this.subscriptions.has(key) || !this.socket) continue;
+      const unsubscribe = sub.channel === "arb" ? this.socket.subscribeArb(sub.id, () => {
+      }) : sub.channel === "arb-feed" ? this.socket.subscribeArbFeed(() => {
+      }) : this.socket.subscribe(sub.id, sub.channel);
+      this.subscriptions.set(key, unsubscribe);
+    }
+    for (const sub of subscriptions)
+      if (sub.channel === "orderbook" && ((_a = this.socket) == null ? void 0 : _a.getBook(sub.id))) this.mark(sub.id, false);
+    const outcomes = new Set(
+      subscriptions.filter((sub) => sub.channel === "orderbook" || sub.channel === "trades").map((sub) => sub.id)
+    );
+    for (const id of this.dirty.keys()) if (!outcomes.has(id)) this.dirty.delete(id);
+    for (const id of this.deliveredClosed.keys())
+      if (!outcomes.has(id)) this.deliveredClosed.delete(id);
+    for (const [id, builder] of this.builders)
+      if (!outcomes.has(id)) {
+        builder.dispose();
+        this.builders.delete(id);
+        this.dirty.delete(id);
+        this.deliveredClosed.delete(id);
+      }
+  }
+  authenticate(token) {
+    var _a;
+    (_a = this.socket) == null ? void 0 : _a.authenticate(token);
+  }
+  resnapshot(ids) {
+    var _a;
+    (_a = this.socket) == null ? void 0 : _a.resnapshot(ids);
+  }
+  connect() {
+    var _a;
+    (_a = this.socket) == null ? void 0 : _a.connect();
+  }
+  disconnect() {
+    var _a;
+    (_a = this.socket) == null ? void 0 : _a.disconnect();
+  }
+  resume() {
+    var _a;
+    (_a = this.socket) == null ? void 0 : _a.resnapshot([...this.builders.keys()]);
+  }
+  getMeasurements() {
+    var _a, _b, _c, _d, _e;
+    const socket = (_b = (_a = this.socket) == null ? void 0 : _a.getDiagnostics()) != null ? _b : null;
+    return __spreadProps(__spreadValues({}, this.measurements), {
+      activeSubscriptions: this.subscriptions.size,
+      activeOutcomes: (/* @__PURE__ */ new Set([
+        ...(_c = socket == null ? void 0 : socket.orderbookOutcomeIds) != null ? _c : [],
+        ...(_d = socket == null ? void 0 : socket.tradeOutcomeIds) != null ? _d : []
+      ])).size,
+      cachedBooks: (_e = socket == null ? void 0 : socket.cachedBooks) != null ? _e : 0,
+      builders: this.builders.size,
+      historyTasks: this.history.size,
+      pendingOutcomes: this.dirty.size,
+      inFlightDeliveries: this.inFlight ? 1 : 0,
+      retainedCandleOutcomes: this.deliveredClosed.size,
+      socket
+    });
+  }
+  decodeHistory(payload) {
+    return decodeChartHistory(payload);
+  }
+  /** Fetch/decode on the processing side; newer range generations abort obsolete fetches. */
+  loadHistoryRange(request) {
+    return __async(this, null, function* () {
+      const previous = this.history.get(request.key);
+      if (previous && previous.generation > request.generation) return null;
+      previous == null ? void 0 : previous.controller.abort();
+      const controller = new AbortController();
+      const entry = { generation: request.generation, controller };
+      this.history.set(request.key, entry);
+      const timeout = setTimeout(() => controller.abort(), 1e4);
+      try {
+        const response = yield fetch(request.url, {
+          headers: request.headers,
+          signal: controller.signal
+        });
+        if (!response.ok) throw new Error(`History request failed (${response.status})`);
+        const body = decodeChartHistory(yield readChartHistoryText(response));
+        if (body.data.length > 4096) throw new Error("Invalid or unbounded history response");
+        if (this.history.get(request.key) !== entry || this.disposed) return null;
+        return __spreadProps(__spreadValues({}, body), { data: [...body.data].sort((a, b) => a.t - b.t) });
+      } finally {
+        clearTimeout(timeout);
+        if (this.history.get(request.key) === entry) this.history.delete(request.key);
+      }
+    });
+  }
+  loadImmutableRange(key, generation, manifest) {
+    return __async(this, null, function* () {
+      const previous = this.history.get(key);
+      if (previous && previous.generation > generation) throw new Error("Obsolete history range");
+      previous == null ? void 0 : previous.controller.abort();
+      const entry = { generation, controller: new AbortController() };
+      this.history.set(key, entry);
+      const timer = setTimeout(() => entry.controller.abort(), 1e4);
+      try {
+        const data = yield loadImmutableHistory({ manifest, signal: entry.controller.signal });
+        if (this.history.get(key) !== entry || this.disposed)
+          throw new Error("Obsolete history range");
+        return data;
+      } finally {
+        clearTimeout(timer);
+        if (this.history.get(key) === entry) this.history.delete(key);
+      }
+    });
+  }
+  cancelHistoryRange(key, generation) {
+    const entry = this.history.get(key);
+    if (!entry || generation !== void 0 && entry.generation !== generation) return;
+    entry.controller.abort();
+    this.history.delete(key);
+  }
+  dispose() {
+    var _a, _b;
+    this.disposed = true;
+    (_a = this.cancelDelivery) == null ? void 0 : _a.call(this);
+    this.cancelDelivery = void 0;
+    this.deliveryToken = null;
+    this.inFlight = false;
+    this.observer = void 0;
+    (_b = this.socket) == null ? void 0 : _b.destroy();
+    this.socket = null;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+    this.subscriptions.clear();
+    this.dirty.clear();
+    this.deliveredClosed.clear();
+    for (const builder of this.builders.values()) builder.dispose();
+    this.builders.clear();
+    for (const request of this.history.values()) request.controller.abort();
+    this.history.clear();
+  }
+  builder(id) {
+    let builder = this.builders.get(id);
+    if (!builder) {
+      builder = new CandleBuilder();
+      this.builders.set(id, builder);
+    }
+    return builder;
+  }
+  mark(id, snapshot, trade) {
+    var _a, _b, _c;
+    const previous = this.dirty.get(id);
+    this.measurements.received++;
+    if (previous) this.measurements.coalesced++;
+    this.dirty.set(id, {
+      snapshot: snapshot || !!(previous == null ? void 0 : previous.snapshot),
+      receivedAtMs: (_a = previous == null ? void 0 : previous.receivedAtMs) != null ? _a : this.receivedAtMs || Date.now(),
+      trades: trade ? [trade, ...(_b = previous == null ? void 0 : previous.trades) != null ? _b : []].slice(0, 50) : (_c = previous == null ? void 0 : previous.trades) != null ? _c : []
+    });
+    this.measurements.maxPendingOutcomes = Math.max(
+      this.measurements.maxPendingOutcomes,
+      this.dirty.size
+    );
+    this.schedule();
+  }
+  schedule() {
+    if (this.timer || this.inFlight || this.disposed || !this.observer) return;
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      void this.publish();
+    }, 50);
+  }
+  publish() {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (this.inFlight || this.disposed || !this.observer || !this.dirty.size) return;
+      const views = [...this.dirty].map(([outcomeId, dirty]) => {
+        var _a2, _b2, _c;
+        const builder = this.builder(outcomeId);
+        return __spreadProps(__spreadValues({
+          outcomeId,
+          revision: this.revision,
+          integrity: ((_a2 = this.socket) == null ? void 0 : _a2.isResyncing(outcomeId)) ? "resyncing" : "ok",
+          book: (_c = (_b2 = this.socket) == null ? void 0 : _b2.getBook(outcomeId)) != null ? _c : null
+        }, dirty), {
+          candles: Object.fromEntries(
+            intervals.map((interval) => [
+              interval,
+              {
+                forming: builder.getForming(interval) ? __spreadValues({}, builder.getForming(interval)) : null,
+                // Bounded recovery tail. Full historical ranges never travel per tick.
+                closed: builder.getClosed(interval).filter(
+                  (candle) => {
+                    var _a3, _b3;
+                    return candle.openTime > ((_b3 = (_a3 = this.deliveredClosed.get(outcomeId)) == null ? void 0 : _a3[interval]) != null ? _b3 : -Infinity);
+                  }
+                ).map((candle) => __spreadValues({}, candle))
+              }
+            ])
+          )
+        });
+      });
+      const generation = this.generation;
+      this.dirty.clear();
+      this.inFlight = true;
+      const token = {};
+      this.deliveryToken = token;
+      const cancelled = new Promise((resolve) => {
+        this.cancelDelivery = resolve;
+      });
+      this.measurements.maxInFlight = 1;
+      try {
+        yield Promise.race([
+          this.observer({ generation, views, publishedAtMs: Date.now() }),
+          cancelled
+        ]);
+        if (this.disposed || this.deliveryToken !== token) return;
+        for (const view of generation === this.generation ? views : []) {
+          const delivered = (_a = this.deliveredClosed.get(view.outcomeId)) != null ? _a : {};
+          for (const interval of intervals) {
+            const last = view.candles[interval].closed.at(-1);
+            if (last) delivered[interval] = last.openTime;
+          }
+          this.deliveredClosed.set(view.outcomeId, delivered);
+        }
+        this.measurements.published++;
+      } catch (e) {
+        if (!this.disposed && this.deliveryToken === token) (_b = this.socket) == null ? void 0 : _b.disconnect();
+      } finally {
+        if (this.deliveryToken === token) {
+          this.deliveryToken = null;
+          this.cancelDelivery = void 0;
+          this.inFlight = false;
+          if (this.dirty.size) this.schedule();
+        }
+      }
+    });
+  }
+};
+export {
+  MarketDataEngine,
+  decodeChartHistory
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agg-build/sdk",
-  "version": "4.17.4",
+  "version": "4.18.0",
   "description": "Vanilla TypeScript client for the AGG prediction market aggregator (auth, markets, orderbooks, charts, trading, managed execution, WebSockets). Works in browsers, Node.js, and React Native.",
   "sideEffects": false,
   "license": "MIT",
@@ -28,6 +28,12 @@
     "*": {
       "server": [
         "./dist/server.d.ts"
+      ],
+      "browser": [
+        "./dist/browser.d.ts"
+      ],
+      "market-data": [
+        "./dist/market-data.d.ts"
       ]
     }
   },
@@ -59,6 +65,26 @@
         "types": "./dist/server.d.ts",
         "default": "./dist/server.js"
       }
+    },
+    "./browser": {
+      "import": {
+        "types": "./dist/browser.d.mts",
+        "default": "./dist/browser.mjs"
+      },
+      "require": {
+        "types": "./dist/browser.d.ts",
+        "default": "./dist/browser.js"
+      }
+    },
+    "./market-data": {
+      "import": {
+        "types": "./dist/market-data.d.mts",
+        "default": "./dist/market-data.mjs"
+      },
+      "require": {
+        "types": "./dist/market-data.d.ts",
+        "default": "./dist/market-data.js"
+      }
     }
   },
   "publishConfig": {