@hyperbridge/simplex 0.16.12 → 0.17.0

package/dist/sqlite.d.ts

@@ -1,4 +1,4 @@
-import { A as ActivityStore, L as LoggerContext, c as ActivityInsert, d as ActivityEvent, z as OrderSummary, O as OrderHistoryPage, W as WalletTx, B as BidStore, n as BidInsert, i as StoredBid, p as LimitOrderHold, k as BidStats, e as LimitOrderStore, q as LimitOrderInsert, f as LimitOrder, g as LimitOrderFilter, r as LimitOrderPosting, t as LimitOrderStatus, o as LimitOrderFillInsert, h as LimitOrderFill, l as StateStore, R as RuntimeState, S as SimplexDataStore } from './types-B5zkFhxR.js';
+import { A as ActivityStore, L as LoggerContext, c as ActivityInsert, d as ActivityEvent, D as OrderSummary, O as OrderHistoryPage, W as WalletTx, B as BidStore, n as BidInsert, i as StoredBid, r as LimitOrderHold, k as BidStats, I as InventoryStore, o as InventorySnapshot, e as LimitOrderStore, s as LimitOrderInsert, f as LimitOrder, g as LimitOrderFilter, t as LimitOrderPosting, v as LimitOrderStatus, p as LimitOrderFillInsert, q as LimitOrderFillRecord, h as LimitOrderFill, l as StateStore, R as RuntimeState, S as SimplexDataStore } from './types-BPyUX8qu.js';
 import { DatabaseSync } from 'node:sqlite';
 import 'pino';
 
@@ -51,6 +51,22 @@ declare class SqliteBidStore implements BidStore {
     recent(limit?: number): Promise<StoredBid[]>;
 }
 
+/**
+ * SQLite-backed {@link InventoryStore}, in `activity.db` beside the rest of the history.
+ *
+ * One row per snapshot, with the balances as a JSON object rather than a row per token: a
+ * snapshot is only ever read whole, and the set of tokens a solver holds changes over time.
+ * A database written before snapshots existed simply gains the table, with nothing in it.
+ */
+declare class SqliteInventoryStore implements InventoryStore {
+    private db;
+    constructor(db: DatabaseSync);
+    private toSnapshot;
+    record(balances: Record<string, number>): Promise<void>;
+    latest(): Promise<InventorySnapshot | null>;
+    since(from: Date): Promise<InventorySnapshot[]>;
+}
+
 declare class SqliteLimitOrderStore implements LimitOrderStore {
     private db;
     private logger;
@@ -67,6 +83,7 @@ declare class SqliteLimitOrderStore implements LimitOrderStore {
     reserve(id: string, amount: string): Promise<boolean>;
     transaction<T>(settle: () => Promise<T>): Promise<T>;
     recordFill(fill: LimitOrderFillInsert): Promise<void>;
+    fillHistory(): Promise<LimitOrderFillRecord[]>;
     fills(limitOrderId: string, limit?: number): Promise<LimitOrderFill[]>;
     drawDown(id: string, amount: string): Promise<LimitOrder | null>;
     clampRemaining(id: string, room: string): Promise<LimitOrder | null>;
@@ -134,6 +151,7 @@ declare class SqliteStateStore implements StateStore {
  * `activity.db`) so an existing data directory written by an earlier version is
  * picked up unchanged. Operator state and limit orders ride in `bids.db` beside
  * the bids; a `runtime-state.json` from before that is imported once and deleted.
+ * Inventory snapshots ride in `activity.db`, which is the history.
  *
  * Built on `node:sqlite`, so there is nothing to install and nothing to
  * compile — the engine ships inside the Node runtime. That is why the package
@@ -145,6 +163,7 @@ declare class SqliteDataStore implements SimplexDataStore {
     readonly activity: ActivityStore;
     readonly state: StateStore;
     readonly limitOrders: LimitOrderStore;
+    readonly inventory: InventoryStore;
     private databases;
     private logger;
     constructor(dataDir: string, loggers?: LoggerContext);
@@ -168,4 +187,4 @@ declare class SqliteDataStore implements SimplexDataStore {
     close(): Promise<void>;
 }
 
-export { SqliteActivityStore, SqliteBidStore, SqliteDataStore, SqliteLimitOrderStore, SqliteStateStore };
+export { SqliteActivityStore, SqliteBidStore, SqliteDataStore, SqliteInventoryStore, SqliteLimitOrderStore, SqliteStateStore };

package/dist/sqlite.js

@@ -616,6 +616,39 @@ var SqliteBidStore = class {
   }
 };
 
+// src/data/sqlite/inventory.ts
+var SqliteInventoryStore = class {
+  constructor(db) {
+    this.db = db;
+    this.db.exec(`
+			CREATE TABLE IF NOT EXISTS inventory_snapshots (
+				id INTEGER PRIMARY KEY AUTOINCREMENT,
+				taken_at TEXT NOT NULL DEFAULT (datetime('now')),
+				balances TEXT NOT NULL
+			);
+
+			CREATE INDEX IF NOT EXISTS idx_inventory_snapshots_taken_at ON inventory_snapshots(taken_at);
+		`);
+  }
+  toSnapshot(row) {
+    return { id: row.id, takenAt: row.takenAt, balances: JSON.parse(row.balances) };
+  }
+  async record(balances) {
+    this.db.prepare("INSERT INTO inventory_snapshots (balances) VALUES (?)").run(JSON.stringify(balances));
+  }
+  async latest() {
+    const row = this.db.prepare("SELECT id, taken_at as takenAt, balances FROM inventory_snapshots ORDER BY id DESC LIMIT 1").get();
+    return row ? this.toSnapshot(row) : null;
+  }
+  async since(from) {
+    const cutoff = from.toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "");
+    const rows = this.db.prepare(
+      "SELECT id, taken_at as takenAt, balances FROM inventory_snapshots WHERE taken_at >= ? ORDER BY taken_at, id"
+    ).all(cutoff);
+    return rows.map((row) => this.toSnapshot(row));
+  }
+};
+
 // src/data/sqlite/limit-orders.ts
 var LIMIT_ORDER_COLUMNS = `
 	id,
@@ -634,6 +667,7 @@ var LIMIT_ORDER_COLUMNS = `
 	status,
 	commitment,
 	order_nonce as orderNonce,
+	entry_point as entryPoint,
 	book_expires_at as bookExpiresAt,
 	book_price as bookPrice,
 	last_error as lastError,
@@ -670,6 +704,7 @@ var SqliteLimitOrderStore = class {
 				status TEXT NOT NULL,
 				commitment TEXT,
 				order_nonce TEXT NOT NULL DEFAULT '0',
+				entry_point TEXT,
 				book_expires_at TEXT,
 				book_price TEXT,
 				last_error TEXT,
@@ -687,12 +722,21 @@ var SqliteLimitOrderStore = class {
 				commitment TEXT NOT NULL,
 				bid TEXT,
 				amount TEXT NOT NULL,
+				amount_in TEXT,
 				transaction_hash TEXT,
 				filled_at TEXT NOT NULL DEFAULT (datetime('now'))
 			);
 
 			CREATE INDEX IF NOT EXISTS idx_limit_order_fills_order ON limit_order_fills(limit_order_id);
 		`);
+    if (!columnNames(this.db, "limit_orders").has("entry_point")) {
+      this.db.exec("ALTER TABLE limit_orders ADD COLUMN entry_point TEXT");
+      this.logger.info({ column: "entry_point" }, "Migrated limit order storage schema");
+    }
+    if (!columnNames(this.db, "limit_order_fills").has("amount_in")) {
+      this.db.exec("ALTER TABLE limit_order_fills ADD COLUMN amount_in TEXT");
+      this.logger.info({ column: "amount_in" }, "Migrated limit order fill schema");
+    }
   }
   // biome-ignore lint/suspicious/noExplicitAny: raw sqlite row
   toLimitOrder(row) {
@@ -753,13 +797,14 @@ var SqliteLimitOrderStore = class {
     const result = this.db.prepare(`
 				UPDATE limit_orders
 				SET commitment = ?, book_expires_at = ?, book_price = ?, order_nonce = ?,
-				    status = ?, last_error = ?, updated_at = datetime('now')
+				    entry_point = ?, status = ?, last_error = ?, updated_at = datetime('now')
 				WHERE id = ?${statusGuard(only)}
 			`).run(
       posting.commitment,
       posting.bookExpiresAt,
       posting.bookPrice,
       posting.orderNonce,
+      posting.entryPoint,
       posting.status,
       posting.lastError,
       id,
@@ -802,12 +847,27 @@ var SqliteLimitOrderStore = class {
   }
   async recordFill(fill) {
     this.db.prepare(
-      "INSERT INTO limit_order_fills (limit_order_id, commitment, bid, amount, transaction_hash) VALUES (?, ?, ?, ?, ?)"
-    ).run(fill.limitOrderId, fill.commitment, fill.bid ?? null, fill.amount, fill.transactionHash ?? null);
+      "INSERT INTO limit_order_fills (limit_order_id, commitment, bid, amount, amount_in, transaction_hash) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(
+      fill.limitOrderId,
+      fill.commitment,
+      fill.bid ?? null,
+      fill.amount,
+      fill.amountIn ?? null,
+      fill.transactionHash ?? null
+    );
+  }
+  async fillHistory() {
+    return this.db.prepare(
+      `SELECT f.id, f.limit_order_id as limitOrderId, o.book, o.base, o.quote, o.side, o.price,
+					f.amount, f.amount_in as amountIn, f.filled_at as filledAt
+				FROM limit_order_fills f JOIN limit_orders o ON o.id = f.limit_order_id
+				ORDER BY f.filled_at, f.id`
+    ).all();
   }
   async fills(limitOrderId, limit = 100) {
     return this.db.prepare(
-      `SELECT id, limit_order_id as limitOrderId, commitment, bid, amount, transaction_hash as transactionHash,
+      `SELECT id, limit_order_id as limitOrderId, commitment, bid, amount, amount_in as amountIn, transaction_hash as transactionHash,
 					filled_at as filledAt
 				FROM limit_order_fills WHERE limit_order_id = ? ORDER BY id DESC LIMIT ?`
     ).all(limitOrderId, Math.min(Math.max(limit, 1), 500));
@@ -994,6 +1054,7 @@ var SqliteDataStore = class {
     this.activity = new SqliteActivityStore(activityDb, loggers);
     this.state = new SqliteStateStore(bidsDb, dataDir, loggers);
     this.limitOrders = new SqliteLimitOrderStore(bidsDb, loggers);
+    this.inventory = new SqliteInventoryStore(activityDb);
     this.logger.info({ dataDir }, "SQLite data store opened");
   }
   /**
@@ -1028,6 +1089,7 @@ export {
   SqliteActivityStore,
   SqliteBidStore,
   SqliteDataStore,
+  SqliteInventoryStore,
   SqliteLimitOrderStore,
   SqliteStateStore
 };