@hyperbridge/simplex 0.16.11 → 0.16.13

package/dist/index.cjs

@@ -1165,6 +1165,7 @@ var import_viem2 = require("viem");
 var import_sdk2 = require("@hyperbridge/sdk");
 var DEFAULT_BLOCK_SCAN_INTERVAL_SECONDS = 3;
 var MIN_BLOCK_SCAN_INTERVAL_SECONDS = 0.1;
+var DEFAULT_MIN_ORDER_SIZE_USD = 20;
 function validateRpcUrls(rpcUrls) {
   if (rpcUrls.length === 0) {
     throw new Error("rpcUrls must contain at least one URL");
@@ -1587,6 +1588,13 @@ var FillerConfigService = class {
   getBidValiditySeconds() {
     return this.fillerConfig?.bidValiditySeconds ?? 300;
   }
+  /**
+   * The order size, in USD, below which `order.fees` must cover the execution cost.
+   * Defaults to 20. An order at or above it is filled whatever fees it carries.
+   */
+  getMinOrderSizeUsd() {
+    return this.fillerConfig?.minOrderSizeUsd ?? DEFAULT_MIN_ORDER_SIZE_USD;
+  }
   /** Ceiling bps above user-requested output. Default 500 (5%). */
   getMaxOverfillBps() {
     return BigInt(this.fillerConfig?.overfillProtection?.maxOverfillBps ?? 500);
@@ -1690,6 +1698,12 @@ function validateConfig(config, cliWatchOnly = false) {
       );
     }
   }
+  const minOrderSize = config.simplex.minOrderSizeUsd;
+  if (minOrderSize !== void 0) {
+    if (!Number.isFinite(minOrderSize) || minOrderSize < 0) {
+      throw new Error(`simplex.minOrderSizeUsd must be a number >= 0 (USD); got ${minOrderSize}`);
+    }
+  }
   if (config.allowlist) {
     for (const user of config.allowlist.users ?? []) {
       if (!(0, import_viem2.isAddress)(user)) {
@@ -2663,6 +2677,35 @@ var LIMITS_QUERY = `
 		chains { id name tokens { symbol decimals } }
 	}
 `;
+var LEVEL_FIELDS = "fillChain priceBucket price worstPrice baseSize quoteSize orderCount solverCount";
+var SNAPSHOT_QUERY = `
+	query OrderbookSnapshot($id: ID!, $sourceChain: String, $fillChain: String) {
+		book(id: $id) {
+			id base quote
+			bids: levels(side: BID, sourceChain: $sourceChain, fillChain: $fillChain) { ${LEVEL_FIELDS} }
+			asks: levels(side: ASK, sourceChain: $sourceChain, fillChain: $fillChain) { ${LEVEL_FIELDS} }
+			bidLiquidity: availableLiquidity(side: BID, sourceChain: $sourceChain, fillChain: $fillChain)
+			askLiquidity: availableLiquidity(side: ASK, sourceChain: $sourceChain, fillChain: $fillChain)
+		}
+		serverInfo { priceGranularities { book granularity } }
+	}
+`;
+var LEVEL_ORDERS_QUERY = `
+	query OrderbookLevelOrders($id: ID!, $side: Side!, $fillChain: String, $sourceChain: String, $after: String) {
+		book(id: $id) {
+			orders(side: $side, fillChain: $fillChain, sourceChain: $sourceChain, first: 50, after: $after) {
+				edges {
+					node {
+						solver { address }
+						commitment fillChain price priceBucket advertisedSize quotedAmount resized expiresAt acceptedSources
+					}
+				}
+				pageInfo { hasNextPage endCursor }
+			}
+		}
+	}
+`;
+var LEVEL_ORDER_PAGES = 20;
 var POSTED_ORDER_FIELDS = "commitment side status price quotedAmount advertisedSize expiresAt acceptedSources";
 var SUBMIT_ORDER_MUTATION = `
 	mutation SubmitOrder($userOp: Bytes!) {
@@ -2727,6 +2770,44 @@ var OrderbookClient = class {
   async limits() {
     return this.request(LIMITS_QUERY, {});
   }
+  /** The public book across all solvers, restricted to the selected route. */
+  async snapshot(id, filters = {}) {
+    const { book, serverInfo } = await this.request(SNAPSHOT_QUERY, {
+      id,
+      sourceChain: filters.sourceChain || null,
+      fillChain: filters.fillChain || null
+    });
+    if (!book) return null;
+    const granularity = serverInfo.priceGranularities.find((entry) => entry.book === book.id)?.granularity ?? null;
+    return { ...book, granularity };
+  }
+  /**
+   * The orders behind one price level. The orderbook filters orders by side and route but not by
+   * price bucket, so this walks the side's orders on the level's fill chain and keeps the bucket.
+   * Null when the book does not exist.
+   */
+  async levelOrders(id, level) {
+    const found = [];
+    let after = null;
+    for (let page = 0; page < LEVEL_ORDER_PAGES; page++) {
+      const { book } = await this.request(LEVEL_ORDERS_QUERY, {
+        id,
+        side: level.side,
+        fillChain: level.fillChain,
+        sourceChain: level.sourceChain || null,
+        after
+      });
+      if (!book) return null;
+      for (const { node } of book.orders.edges) {
+        if (node.priceBucket !== level.priceBucket) continue;
+        const { solver, priceBucket: _bucket, ...order } = node;
+        found.push({ ...order, solver: solver.address });
+      }
+      if (!book.orders.pageInfo.hasNextPage || !book.orders.pageInfo.endCursor) break;
+      after = book.orders.pageInfo.endCursor;
+    }
+    return found;
+  }
   async submitOrder(userOp) {
     const { submitOrder } = await this.request(SUBMIT_ORDER_MUTATION, { userOp });
     switch (submitOrder.__typename) {
@@ -2911,16 +2992,16 @@ function signedAmounts(params) {
 function offerFor(params) {
   const { side, inputAmount, price, outputDecimals } = params;
   if (price <= 0n) throw new Error("A limit order's price must be greater than zero");
-  const scaled = side === "BID" ? inputAmount * price / ORDERBOOK_SCALE : inputAmount * ORDERBOOK_SCALE / price;
+  const scaled2 = side === "BID" ? inputAmount * price / ORDERBOOK_SCALE : inputAmount * ORDERBOOK_SCALE / price;
   const unit = outputDecimals >= 18 ? 1n : 10n ** BigInt(18 - outputDecimals);
-  return scaled / unit * unit;
+  return scaled2 / unit * unit;
 }
 function inputFor(params) {
   const { side, outputAmount, price, inputDecimals } = params;
   if (price <= 0n) throw new Error("A limit order's price must be greater than zero");
-  const scaled = side === "BID" ? divCeil(outputAmount * ORDERBOOK_SCALE, price) : divCeil(outputAmount * price, ORDERBOOK_SCALE);
+  const scaled2 = side === "BID" ? divCeil(outputAmount * ORDERBOOK_SCALE, price) : divCeil(outputAmount * price, ORDERBOOK_SCALE);
   const unit = inputDecimals >= 18 ? 1n : 10n ** BigInt(18 - inputDecimals);
-  return divCeil(scaled, unit) * unit;
+  return divCeil(scaled2, unit) * unit;
 }
 
 // src/orderbook/matching.ts
@@ -3176,6 +3257,14 @@ var LimitOrderService = class {
       throw err;
     }
   }
+  /** Public market levels read through the configured orderbook client. */
+  orderbookSnapshot(book, filters = {}) {
+    return this.client.snapshot(book, filters);
+  }
+  /** Every solver's order behind one public price level. */
+  orderbookLevelOrders(book, level) {
+    return this.client.levelOrders(book, level);
+  }
   /**
    * The pairs an order can be written against, the smallest payout each token may carry, and
    * the tokens the orderbook registers on each chain.
@@ -3230,16 +3319,16 @@ var LimitOrderService = class {
     if (!this.configService.getConfiguredChainIds().includes((0, import_sdk4.getChainId)(request.fillChain) ?? -1)) {
       throw new LimitOrderValidationError(`'${request.fillChain}' is not a chain this filler is configured for`);
     }
-    const scaled = { amountIn: 0n, amountOut: 0n };
+    const scaled2 = { amountIn: 0n, amountOut: 0n };
     for (const name of ["amountIn", "amountOut"]) {
       try {
-        scaled[name] = fromHuman(request[name] ?? "");
+        scaled2[name] = fromHuman(request[name] ?? "");
       } catch (err) {
         throw new LimitOrderValidationError(
           `${name} must be an amount in whole tokens, like "1000" or "1500.25"; ${err.message}`
         );
       }
-      if (scaled[name] <= 0n) throw new LimitOrderValidationError(`${name} must be greater than zero`);
+      if (scaled2[name] <= 0n) throw new LimitOrderValidationError(`${name} must be greater than zero`);
     }
     const sources = request.acceptedSources ?? [];
     if (sources.length === 0) {
@@ -3286,7 +3375,7 @@ var LimitOrderService = class {
       );
     }
     const floor = limits.serverInfo.minOrderSizes.find((entry) => entry.symbol === request.tokenOut);
-    if (floor && scaled.amountOut < BigInt(floor.size)) {
+    if (floor && scaled2.amountOut < BigInt(floor.size)) {
       throw new LimitOrderValidationError(
         `amountOut is below the orderbook's dust floor for ${request.tokenOut} (${toHuman(BigInt(floor.size))})`
       );
@@ -3296,7 +3385,7 @@ var LimitOrderService = class {
         throw new LimitOrderValidationError(`'${symbol}' does not resolve to a token address on ${request.fillChain}`);
       }
     }
-    return { amountIn: scaled.amountIn, amountOut: scaled.amountOut };
+    return { amountIn: scaled2.amountIn, amountOut: scaled2.amountOut };
   }
   /**
    * Refuses an order the wallet cannot pay out.
@@ -3822,6 +3911,451 @@ function underFunded(entry) {
   return entry.resized ? `UNDER_FUNDED: the orderbook is advertising ${entry.advertisedSize} of the ${entry.quotedAmount} quoted` : "UNDER_FUNDED: the solver's balance does not cover this posting";
 }
 
+// src/orderbook/profitability.ts
+var import_decimal3 = require("decimal.js");
+
+// src/data/inventory.ts
+var INVENTORY_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function inventoryOf(snapshot) {
+  if (snapshot.status !== "fresh") return null;
+  const held = {};
+  for (const chain of snapshot.chains) {
+    for (const asset of chain.assets) {
+      if (asset.total === null) return null;
+      held[asset.symbol] = (held[asset.symbol] ?? 0) + asset.total;
+    }
+  }
+  return Object.keys(held).length > 0 ? held : null;
+}
+function parseUtc(value) {
+  return Date.parse(`${value.replace(" ", "T")}Z`);
+}
+var InventoryRecorder = class {
+  constructor(store, balances, logger, now = Date.now) {
+    this.store = store;
+    this.balances = balances;
+    this.logger = logger;
+    this.now = now;
+    this.recording = false;
+    this.onSnapshot = (snapshot) => void this.consider(snapshot);
+  }
+  start() {
+    this.balances.on("snapshot", this.onSnapshot);
+    void this.consider(this.balances.getSnapshot());
+  }
+  stop() {
+    this.balances.off("snapshot", this.onSnapshot);
+  }
+  /** Takes a snapshot from `snapshot` if one is due and the read is complete. Never rejects. */
+  async consider(snapshot) {
+    if (this.recording) return;
+    const held = inventoryOf(snapshot);
+    if (!held) return;
+    this.recording = true;
+    try {
+      if (this.lastTakenAt === void 0) {
+        const latest = await this.store.latest();
+        this.lastTakenAt = latest ? parseUtc(latest.takenAt) : 0;
+      }
+      if (this.now() - this.lastTakenAt < INVENTORY_INTERVAL_MS) return;
+      await this.store.record(held);
+      this.lastTakenAt = this.now();
+      this.logger.info({ tokens: Object.keys(held).length }, "Recorded an inventory snapshot");
+    } catch (err) {
+      this.logger.warn({ err }, "Could not record an inventory snapshot");
+    } finally {
+      this.recording = false;
+    }
+  }
+};
+
+// src/orderbook/usd.ts
+var import_decimal2 = require("decimal.js");
+function limitOrderUsdEdges(orders) {
+  return orders.filter((order) => normalizeSymbol(order.base) !== normalizeSymbol(order.quote)).map((order) => ({
+    base: normalizeSymbol(order.base),
+    quote: normalizeSymbol(order.quote),
+    rate: new import_decimal2.Decimal(order.price).div(ORDERBOOK_SCALE.toString())
+  })).filter((edge) => edge.rate.isFinite() && edge.rate.gt(0));
+}
+function usdFactorsFrom(edges) {
+  const factors = /* @__PURE__ */ new Map();
+  for (const symbol of USD_STABLE_SYMBOLS) factors.set(symbol, new import_decimal2.Decimal(1));
+  const ordered = [...edges].sort((a, b) => a.base.localeCompare(b.base) || a.quote.localeCompare(b.quote));
+  let grew = true;
+  while (grew) {
+    grew = false;
+    for (const edge of ordered) {
+      const usdBase = factors.get(edge.base);
+      const usdQuote = factors.get(edge.quote);
+      if (usdBase && !usdQuote) {
+        factors.set(edge.quote, usdBase.div(edge.rate));
+        grew = true;
+      } else if (usdQuote && !usdBase) {
+        factors.set(edge.base, usdQuote.mul(edge.rate));
+        grew = true;
+      }
+    }
+  }
+  return factors;
+}
+function usdValueOf(factors, symbol, amount) {
+  const factor = factors.get(normalizeSymbol(symbol));
+  return factor ? amount.mul(factor) : null;
+}
+
+// src/orderbook/profitability.ts
+var Decimal3 = import_decimal3.Decimal.clone({ precision: 40 });
+var PROFIT_PERIODS = {
+  "7d": { bucket: "day", count: 7 },
+  "30d": { bucket: "day", count: 30 },
+  "12w": { bucket: "week", count: 12 },
+  "12m": { bucket: "month", count: 12 },
+  all: { bucket: "year", count: null }
+};
+var MINUTE = 6e4;
+var DAY = 864e5;
+var BALANCES_REACH_MS = 7 * DAY;
+function bucketStart(local, bucket) {
+  const date = new Date(local);
+  const year = date.getUTCFullYear();
+  const month = date.getUTCMonth();
+  if (bucket === "year") return Date.UTC(year, 0, 1);
+  if (bucket === "month") return Date.UTC(year, month, 1);
+  const day = Date.UTC(year, month, date.getUTCDate());
+  return bucket === "day" ? day : day - (date.getUTCDay() + 6) % 7 * DAY;
+}
+function shiftBucket(start, bucket, steps) {
+  if (bucket === "day") return start + steps * DAY;
+  if (bucket === "week") return start + steps * 7 * DAY;
+  const date = new Date(start);
+  return bucket === "month" ? Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + steps, 1) : Date.UTC(date.getUTCFullYear() + steps, 0, 1);
+}
+function scaled(value) {
+  return new Decimal3(value).div(ORDERBOOK_SCALE.toString());
+}
+function tradeOf(fill, at) {
+  try {
+    const paid = scaled(fill.amount);
+    const taken = fill.amountIn === null ? null : scaled(fill.amountIn);
+    const price = scaled(fill.price);
+    if (!paid.gt(0) || !price.gt(0) || taken !== null && !taken.gt(0)) return null;
+    const buying = fill.side === "BID";
+    const [baseAmount, quoteAmount] = buying ? [taken ?? paid.div(price), paid] : [paid, taken ?? paid.mul(price)];
+    return {
+      at,
+      book: fill.book,
+      base: normalizeSymbol(fill.base),
+      quote: normalizeSymbol(fill.quote),
+      buying,
+      baseAmount,
+      quoteAmount,
+      estimated: taken === null
+    };
+  } catch {
+    return null;
+  }
+}
+function add(holdings, symbol, amount) {
+  holdings.set(symbol, (holdings.get(symbol) ?? new Decimal3(0)).add(amount));
+}
+function apply(holdings, trade, sign) {
+  const base = trade.buying ? trade.baseAmount : trade.baseAmount.neg();
+  const quote = trade.buying ? trade.quoteAmount.neg() : trade.quoteAmount;
+  add(holdings, trade.base, base.mul(sign));
+  add(holdings, trade.quote, quote.mul(sign));
+}
+var Sums = class {
+  constructor() {
+    this.change = /* @__PURE__ */ new Map();
+    this.boughtUsd = new Decimal3(0);
+    this.soldUsd = new Decimal3(0);
+    this.buys = 0;
+    this.sells = 0;
+  }
+};
+var BookLedger = class {
+  constructor(id, base, quote) {
+    this.id = id;
+    this.base = base;
+    this.quote = quote;
+    this.bought = new Decimal3(0);
+    this.boughtQuote = new Decimal3(0);
+    this.sold = new Decimal3(0);
+    this.soldQuote = new Decimal3(0);
+    /** The rates of the book's latest buy and latest sell, over all of its history. */
+    this.latestBuy = null;
+    this.latestSell = null;
+    this.inPeriod = false;
+  }
+  /**
+   * The rate the book is valued at. Midway between the latest buy and the latest sell, because
+   * either alone sits half a spread to one side and would price open volume against whichever
+   * way the book happened to trade last.
+   */
+  rate() {
+    if (this.latestBuy && this.latestSell) return this.latestBuy.add(this.latestSell).div(2);
+    return this.latestBuy ?? this.latestSell;
+  }
+};
+function readingOf(reading) {
+  const held = /* @__PURE__ */ new Map();
+  const cover = /* @__PURE__ */ new Map();
+  for (const [symbol, amount] of Object.entries(reading.balances)) {
+    const chains = reading.chains[symbol];
+    if (!Number.isFinite(amount) || !chains?.length) continue;
+    add(held, normalizeSymbol(symbol), new Decimal3(amount));
+    cover.set(normalizeSymbol(symbol), [...chains].sort().join(","));
+  }
+  return { held, cover };
+}
+function movedBetween(earlier, later) {
+  if (!earlier || !later) return null;
+  const moved = /* @__PURE__ */ new Map();
+  for (const [symbol, cover] of later.cover) {
+    if (earlier.cover.get(symbol) !== cover) continue;
+    const before = earlier.held.get(symbol) ?? new Decimal3(0);
+    moved.set(symbol, (later.held.get(symbol) ?? new Decimal3(0)).sub(before));
+  }
+  return moved;
+}
+function nearestRecord(instant, records) {
+  let record;
+  let gap = Number.POSITIVE_INFINITY;
+  for (const candidate of records) {
+    const distance = Math.abs(candidate.at - instant);
+    if (candidate.live && distance > BALANCES_REACH_MS) continue;
+    if (distance < gap || distance === gap && record?.live && !candidate.live) {
+      record = candidate;
+      gap = distance;
+    }
+  }
+  return record;
+}
+function inventoryAt(instant, records, trades, outflows, readings) {
+  const record = nearestRecord(instant, records);
+  if (!record) return null;
+  const recorded = /* @__PURE__ */ new Map();
+  for (const [symbol, amount] of Object.entries(record.balances)) {
+    if (Number.isFinite(amount)) add(recorded, normalizeSymbol(symbol), new Decimal3(amount));
+  }
+  const held = new Map(recorded);
+  const after = record.at >= instant;
+  const [from, to] = after ? [instant, record.at] : [record.at, instant];
+  const sign = after ? -1 : 1;
+  for (const trade of trades) {
+    if (trade.at >= from && trade.at < to) apply(held, trade, sign);
+  }
+  for (const outflow of outflows) {
+    if (outflow.at >= from && outflow.at < to) {
+      add(held, normalizeSymbol(outflow.symbol), new Decimal3(outflow.amount).mul(-sign));
+    }
+  }
+  const moved = movedBetween(readings.get(from), readings.get(to));
+  if (moved) {
+    for (const [symbol, amount] of moved) {
+      held.set(symbol, (recorded.get(symbol) ?? new Decimal3(0)).add(amount.mul(sign)));
+    }
+  }
+  for (const [symbol, amount] of held) if (amount.isNegative()) held.set(symbol, new Decimal3(0));
+  return { held, record };
+}
+function tradesOf(fills, now) {
+  const trades = [];
+  for (const fill of fills) {
+    const at = parseUtc(fill.filledAt);
+    if (!Number.isFinite(at) || at > now) continue;
+    const trade = tradeOf(fill, at);
+    if (trade) trades.push(trade);
+  }
+  return trades.sort((a, b) => a.at - b.at);
+}
+function bucketStarts(period, now, offset, firstAt) {
+  const { bucket, count } = PROFIT_PERIODS[period];
+  const last = bucketStart(now - offset, bucket);
+  const first = count === null ? bucketStart((firstAt ?? now) - offset, bucket) : shiftBucket(last, bucket, 1 - count);
+  const starts = [];
+  for (let start = first; start <= last; start = shiftBucket(start, bucket, 1)) starts.push(start);
+  return starts;
+}
+function inventoryInstants(fills, options) {
+  const { period, now } = options;
+  const offset = (options.tzOffsetMinutes ?? 0) * MINUTE;
+  const records = (options.inventory ?? []).filter((record) => record.at <= now);
+  const instants = /* @__PURE__ */ new Set([now]);
+  for (const start of bucketStarts(period, now, offset, tradesOf(fills, now)[0]?.at)) {
+    instants.add(start + offset);
+    const record = nearestRecord(start + offset, records);
+    if (record) instants.add(record.at);
+  }
+  return [...instants].sort((a, b) => a - b);
+}
+function summarizeProfit(fills, options) {
+  const { period, now } = options;
+  const offset = (options.tzOffsetMinutes ?? 0) * MINUTE;
+  const { bucket } = PROFIT_PERIODS[period];
+  const records = (options.inventory ?? []).filter((record) => record.at <= now);
+  const outflows = options.outflows ?? [];
+  const readings = new Map((options.readings ?? []).map((reading) => [reading.at, readingOf(reading)]));
+  const trades = tradesOf(fills, now);
+  const starts = bucketStarts(period, now, offset, trades[0]?.at);
+  const first = starts[0];
+  const books = /* @__PURE__ */ new Map();
+  const spelling = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    for (const symbol of Object.keys(record.balances)) {
+      if (!spelling.has(normalizeSymbol(symbol))) spelling.set(normalizeSymbol(symbol), symbol);
+    }
+  }
+  for (const fill of fills) {
+    for (const symbol of [fill.base, fill.quote]) {
+      if (!spelling.has(normalizeSymbol(symbol))) spelling.set(normalizeSymbol(symbol), symbol);
+    }
+  }
+  for (const trade of trades) {
+    let book = books.get(trade.book);
+    if (!book) {
+      book = new BookLedger(trade.book, trade.base, trade.quote);
+      books.set(trade.book, book);
+    }
+    const rate = trade.quoteAmount.div(trade.baseAmount);
+    if (trade.buying) book.latestBuy = rate;
+    else book.latestSell = rate;
+  }
+  const edges = [];
+  for (const book of books.values()) {
+    const rate = book.rate();
+    if (rate && book.base !== book.quote) {
+      edges.push({ base: book.base, quote: book.quote, rate: new import_decimal3.Decimal(rate.toString()) });
+    }
+  }
+  const factors = usdFactorsFrom(edges);
+  const priceOf = (symbol) => {
+    const factor = factors.get(symbol);
+    return factor ? new Decimal3(factor.toString()) : null;
+  };
+  const unpriced = /* @__PURE__ */ new Set();
+  const valueOf = (holdings) => {
+    let total = new Decimal3(0);
+    for (const [symbol, amount] of holdings) {
+      if (amount.isZero()) continue;
+      const price = priceOf(symbol);
+      if (price) total = total.add(amount.mul(price));
+      else unpriced.add(symbol);
+    }
+    return total;
+  };
+  const totals = new Sums();
+  const buckets = new Map(starts.map((start) => [start, new Sums()]));
+  let estimatedFills = 0;
+  for (const trade of trades) {
+    const sums = buckets.get(bucketStart(trade.at - offset, bucket));
+    if (!sums) continue;
+    const book = books.get(trade.book);
+    if (!book) continue;
+    book.inPeriod = true;
+    if (trade.estimated) estimatedFills += 1;
+    if (trade.buying) {
+      book.bought = book.bought.add(trade.baseAmount);
+      book.boughtQuote = book.boughtQuote.add(trade.quoteAmount);
+    } else {
+      book.sold = book.sold.add(trade.baseAmount);
+      book.soldQuote = book.soldQuote.add(trade.quoteAmount);
+    }
+    const basePrice = priceOf(trade.base);
+    const quotePrice = priceOf(trade.quote);
+    const volume = basePrice ? trade.baseAmount.mul(basePrice) : quotePrice ? trade.quoteAmount.mul(quotePrice) : new Decimal3(0);
+    for (const sum of [totals, sums]) {
+      apply(sum.change, trade, 1);
+      if (trade.buying) {
+        sum.buys += 1;
+        sum.boughtUsd = sum.boughtUsd.add(volume);
+      } else {
+        sum.sells += 1;
+        sum.soldUsd = sum.soldUsd.add(volume);
+      }
+    }
+  }
+  const figures = (sums, startsAt, endsAt) => {
+    const profit = valueOf(sums.change);
+    const began2 = inventoryAt(startsAt, records, trades, outflows, readings);
+    const inventory = began2 ? valueOf(began2.held) : null;
+    const moved = movedBetween(readings.get(startsAt), readings.get(endsAt));
+    if (moved) {
+      for (const [symbol, amount] of sums.change) {
+        if (moved.has(symbol)) moved.set(symbol, (moved.get(symbol) ?? new Decimal3(0)).sub(amount));
+      }
+    }
+    return {
+      profitUsd: profit.toNumber(),
+      startInventoryUsd: inventory ? inventory.toNumber() : null,
+      returnPct: inventory?.gt(0) ? profit.div(inventory).mul(100).toNumber() : null,
+      transfersUsd: moved && moved.size > 0 ? valueOf(moved).toNumber() : null,
+      boughtUsd: sums.boughtUsd.toNumber(),
+      soldUsd: sums.soldUsd.toNumber(),
+      buys: sums.buys,
+      sells: sums.sells
+    };
+  };
+  const from = first + offset;
+  const began = inventoryAt(from, records, trades, outflows, readings);
+  const startInventory = began && {
+    at: from,
+    source: began.record.live ? "balances" : "snapshot",
+    recordedAt: began.record.at,
+    usd: valueOf(began.held).toNumber(),
+    tokens: [...began.held].filter(([, amount]) => amount.gt(0)).map(([symbol, amount]) => {
+      const price = priceOf(symbol);
+      return {
+        symbol: spelling.get(symbol) ?? symbol,
+        amount: amount.toNumber(),
+        usd: price ? amount.mul(price).toNumber() : null
+      };
+    }).sort((a, b) => (b.usd ?? 0) - (a.usd ?? 0) || a.symbol.localeCompare(b.symbol))
+  };
+  const rows = [];
+  for (const book of books.values()) {
+    if (!book.inPeriod) continue;
+    const averageBuy = book.bought.gt(0) ? book.boughtQuote.div(book.bought) : null;
+    const averageSell = book.sold.gt(0) ? book.soldQuote.div(book.sold) : null;
+    const baseChange = book.bought.sub(book.sold);
+    const quoteChange = book.soldQuote.sub(book.boughtQuote);
+    const basePrice = priceOf(book.base);
+    const quotePrice = priceOf(book.quote);
+    rows.push({
+      book: book.id,
+      base: spelling.get(book.base) ?? book.base,
+      quote: spelling.get(book.quote) ?? book.quote,
+      bought: book.bought.toNumber(),
+      sold: book.sold.toNumber(),
+      averageBuy: averageBuy ? averageBuy.toNumber() : null,
+      averageSell: averageSell ? averageSell.toNumber() : null,
+      spreadPct: averageBuy && averageSell ? averageSell.div(averageBuy).sub(1).mul(100).toNumber() : null,
+      baseChange: baseChange.toNumber(),
+      quoteChange: quoteChange.toNumber(),
+      rate: book.rate()?.toNumber() ?? null,
+      profitUsd: basePrice && quotePrice ? baseChange.mul(basePrice).add(quoteChange.mul(quotePrice)).toNumber() : null
+    });
+  }
+  rows.sort((a, b) => (b.profitUsd ?? 0) - (a.profitUsd ?? 0) || a.book.localeCompare(b.book));
+  return {
+    period,
+    bucket,
+    from,
+    to: now,
+    totals: figures(totals, from, now),
+    series: starts.map((start, index) => {
+      const sums = buckets.get(start) ?? new Sums();
+      const endsAt = index + 1 < starts.length ? starts[index + 1] + offset : now;
+      return { start: start + offset, ...figures(sums, start + offset, endsAt) };
+    }),
+    books: rows,
+    startInventory,
+    estimatedFills,
+    unpricedTokens: [...unpriced].map((symbol) => spelling.get(symbol) ?? symbol).sort()
+  };
+}
+
 // src/data/state.ts
 async function patchRuntimeState(store, patch) {
   if (store.patch) return store.patch(patch);
@@ -12861,6 +13395,7 @@ var CacheService = class {
       matchedLimitOrders: {},
       bidPlans: {},
       partialFills: {},
+      feeChecksWaived: {},
       feeTokens: {},
       tokenDecimals: {},
       solverSelection: {}
@@ -12900,6 +13435,10 @@ var CacheService = class {
     stalePartialIds.forEach((orderId) => {
       delete this.cacheData.partialFills[orderId];
     });
+    const staleWaivedIds = Object.entries(this.cacheData.feeChecksWaived).filter(([_, data]) => !this.isCacheValid(data.timestamp)).map(([orderId]) => orderId);
+    staleWaivedIds.forEach((orderId) => {
+      delete this.cacheData.feeChecksWaived[orderId];
+    });
   }
   getGasEstimate(orderId) {
     try {
@@ -13081,6 +13620,7 @@ var CacheService = class {
         })),
         partialFill: plan.partialFill,
         profit: plan.profit,
+        ...plan.inputDecimals !== void 0 ? { inputDecimals: plan.inputDecimals } : {},
         ...plan.budget ? { budget: budgetFromCache(plan.budget) } : {}
       }));
     } catch (error) {
@@ -13111,6 +13651,7 @@ var CacheService = class {
           })),
           partialFill: plan.partialFill,
           profit: plan.profit,
+          ...plan.inputDecimals !== void 0 ? { inputDecimals: plan.inputDecimals } : {},
           ...plan.budget ? { budget: budgetToCache(plan.budget) } : {}
         })),
         timestamp: Date.now()
@@ -13212,6 +13753,24 @@ var CacheService = class {
   clearPartialFill(orderId) {
     delete this.cacheData.partialFills[orderId];
   }
+  /**
+   * Whether the strategy's completed evaluation let a bid through without holding
+   * `order.fees` to the execution cost, because the order is at or above the
+   * operator's minimum size.
+   *
+   * Written and cleared the way {@link isPartialFill} is, for the same reason: the
+   * caller exempts such an order from its profit floor.
+   */
+  isFeeCheckWaived(orderId) {
+    const cache = this.cacheData.feeChecksWaived[orderId];
+    return cache !== void 0 && this.isCacheValid(cache.timestamp) && cache.waived;
+  }
+  setFeeCheckWaived(orderId, waived) {
+    this.cacheData.feeChecksWaived[orderId] = { waived, timestamp: Date.now() };
+  }
+  clearFeeCheckWaived(orderId) {
+    delete this.cacheData.feeChecksWaived[orderId];
+  }
   getFeeTokenWithDecimals(chain) {
     try {
       const cache = this.cacheData.feeTokens[chain];
@@ -15707,7 +16266,7 @@ var EVM_HOST = [
 ];
 
 // src/services/ContractInteractionService.ts
-var import_decimal2 = require("decimal.js");
+var import_decimal4 = require("decimal.js");
 
 // src/config/abis/IntentGatewayV2.ts
 var INTENT_GATEWAY_V2_ABI = [
@@ -18335,7 +18894,7 @@ function describeShortfall(balances) {
 }
 
 // src/services/ContractInteractionService.ts
-import_decimal2.Decimal.config({ precision: 28, rounding: 4 });
+import_decimal4.Decimal.config({ precision: 28, rounding: 4 });
 var FUNDING_GAS_PER_CALL = 400000n;
 var DEBIT_ORDER_GAS = 60000n;
 function settles(budget) {
@@ -18501,7 +19060,10 @@ var ContractInteractionService = class {
         order,
         prependCalls: void 0,
         maxPriorityFeePerGasBumpPercent: gasFeeBumpConfig?.maxPriorityFeePerGasBumpPercent,
-        maxFeePerGasBumpPercent: gasFeeBumpConfig?.maxFeePerGasBumpPercent
+        maxFeePerGasBumpPercent: gasFeeBumpConfig?.maxFeePerGasBumpPercent,
+        // No bid without the bundler's own figures: an op signed with the SDK's
+        // fixed fallback limits does not execute, so a failed estimate skips the order.
+        requireBundlerEstimate: true
       });
       this.logger.info({ orderId: order.id }, "Caching gas estimate");
       this.logger.info({ estimate }, "Estimate");
@@ -18524,7 +19086,7 @@ var ContractInteractionService = class {
         callGasLimit: estimate.callGasLimit
       };
     } catch (error) {
-      this.logger.error({ err: error }, "Error estimating gas, using generous fallback values");
+      this.logger.error({ err: error, orderId: order.id }, "Error estimating gas, not bidding on this order");
       throw new Error(`Failed to estimate gas: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
@@ -18673,7 +19235,7 @@ var ContractInteractionService = class {
    * @returns The total USD value of inputs (sum of normalized stable amounts, or 0 if none)
    */
   async getInputUsdValue(order) {
-    let inputUsdValue = new import_decimal2.Decimal(0);
+    let inputUsdValue = new import_decimal4.Decimal(0);
     const inputs = order.inputs;
     const sourceUsdc = this.configService.getUsdcAsset(order.source).toLowerCase();
     const sourceUsdt = this.configService.getUsdtAsset(order.source).toLowerCase();
@@ -18682,7 +19244,7 @@ var ContractInteractionService = class {
       const addr = tokenAddress.toLowerCase();
       if (addr !== sourceUsdc && addr !== sourceUsdt) continue;
       const decimals = await this.getTokenDecimals(tokenAddress, order.source);
-      const tokenAmount = new import_decimal2.Decimal((0, import_viem23.formatUnits)(input.amount, decimals));
+      const tokenAmount = new import_decimal4.Decimal((0, import_viem23.formatUnits)(input.amount, decimals));
       inputUsdValue = inputUsdValue.plus(tokenAmount);
     }
     return inputUsdValue;
@@ -19811,7 +20373,7 @@ var DelegationService = class {
 // src/services/RebalancingService.ts
 var import_viem28 = require("viem");
 var import_sdk13 = require("@hyperbridge/sdk");
-var import_decimal3 = require("decimal.js");
+var import_decimal5 = require("decimal.js");
 
 // src/services/rebalancers/binance.ts
 var import_wallet2 = require("@binance/wallet");
@@ -20962,7 +21524,7 @@ var RebalancingService = class {
         functionName: "balanceOf",
         args: [this.walletAddress]
       });
-      const balanceDecimal = new import_decimal3.Decimal((0, import_viem28.formatUnits)(balanceWei, Number(decimals)));
+      const balanceDecimal = new import_decimal5.Decimal((0, import_viem28.formatUnits)(balanceWei, Number(decimals)));
       return balanceDecimal.toNumber();
     } catch (error) {
       this.logger.error({ error, chain, asset }, "Failed to get current balance");
@@ -20995,7 +21557,7 @@ var RebalancingService = class {
 };
 
 // src/core/filler.ts
-var import_decimal4 = require("decimal.js");
+var import_decimal6 = require("decimal.js");
 var HYPERBRIDGE_CONNECT_TIMEOUT_MS = 3e4;
 function byAmount(a, b) {
   return BigInt(a.amount) < BigInt(b.amount) ? -1 : BigInt(a.amount) > BigInt(b.amount) ? 1 : 0;
@@ -21551,7 +22113,7 @@ var IntentFiller = class {
           try {
             const stratValue = await strategy.getOrderUsdValue(order);
             if (stratValue != null) {
-              inputUsdValue = import_decimal4.Decimal.max(baseInputUsd, stratValue.inputUsd);
+              inputUsdValue = import_decimal6.Decimal.max(baseInputUsd, stratValue.inputUsd);
               valued = true;
               break;
             }
@@ -21679,6 +22241,23 @@ var IntentFiller = class {
       this.monitor.emit("orderSkipped", { orderId: order.id, reason: "watch-only" });
       return null;
     }
+    const destinationHead = await this.destinationHead(order);
+    if (destinationHead !== null && order.deadline <= destinationHead) {
+      this.logger.info(
+        {
+          orderId: order.id,
+          destChain: order.destination,
+          deadline: order.deadline.toString(),
+          head: destinationHead.toString()
+        },
+        "Skipping order: its deadline has passed on the destination chain"
+      );
+      this.monitor.emit("orderSkipped", {
+        orderId: order.id,
+        reason: "Order deadline has passed on the destination chain"
+      });
+      return null;
+    }
     const evalStartMs = Date.now();
     const eligibleStrategies = await Promise.all(
       this.strategies.map(async (strategy) => {
@@ -21688,7 +22267,10 @@ var IntentFiller = class {
       })
     );
     const fillsPartially = this.fillsPartially(order);
-    const validStrategies = eligibleStrategies.filter((s) => s !== null && (s.profitability > 0 || fillsPartially)).sort((a, b) => b.profitability - a.profitability);
+    const feeCheckWaived = this.feeCheckWaived(order);
+    const validStrategies = eligibleStrategies.filter(
+      (s) => s !== null && (s.profitability > 0 || fillsPartially || feeCheckWaived)
+    ).sort((a, b) => b.profitability - a.profitability);
     const evalDurationSec = (Date.now() - evalStartMs) / 1e3;
     this.monitor.emit("orderTiming", { orderId: order.id, phase: "evaluation", durationSec: evalDurationSec });
     if (validStrategies.length === 0) {
@@ -21713,6 +22295,23 @@ var IntentFiller = class {
     );
     return validStrategies[0];
   }
+  /**
+   * The destination chain's latest block number, the clock `order.deadline` is read on.
+   *
+   * Null when the read fails. That is not an answer about the order, so evaluation goes
+   * on: the gas estimate simulates the same deadline check and refuses an expired order.
+   */
+  async destinationHead(order) {
+    try {
+      return await this.chainClientManager.getPublicClient(order.destination).getBlockNumber();
+    } catch (err) {
+      this.logger.warn(
+        { orderId: order.id, destChain: order.destination, err },
+        "Could not read the destination head to check the order's deadline"
+      );
+      return null;
+    }
+  }
   /**
    * Whether the strategy's evaluation concluded in a deliberate partial fill.
    *
@@ -21726,6 +22325,15 @@ var IntentFiller = class {
     if (!order.id) return false;
     return this.contractService.cacheService.isPartialFill(order.id);
   }
+  /**
+   * Whether the strategy's evaluation let a bid through without the fee check, because
+   * the order is at or above the operator's minimum size. Read from a flag the strategy
+   * sets only once it has an answer, as {@link fillsPartially} is.
+   */
+  feeCheckWaived(order) {
+    if (!order.id) return false;
+    return this.contractService.cacheService.isFeeCheckWaived(order.id);
+  }
   executeOrder(order, bestStrategy, solverSelectionActive, inputUsdValue, profitUsd) {
     const chainQueue = this.chainQueues.get((0, import_sdk14.getChainId)(order.destination));
     if (!chainQueue) {
@@ -21753,7 +22361,12 @@ var IntentFiller = class {
             else cache.clearFundingPrepends(order.id);
           }
           reservation = await this.holdAll([
-            { limitOrderId: plan.limitOrderId, payout: plan.payout, take: plan.fillerInputs[plan.leg]?.amount }
+            {
+              limitOrderId: plan.limitOrderId,
+              payout: plan.payout,
+              take: plan.fillerInputs[plan.leg]?.amount,
+              takeDecimals: plan.inputDecimals
+            }
           ]);
           if (reservation.length === 0) {
             this.logger.info(
@@ -21923,7 +22536,8 @@ var IntentFiller = class {
       taken.push({
         limitOrderId: hold.limitOrderId,
         amount,
-        ...hold.take !== void 0 ? { take: hold.take.toString() } : {}
+        ...hold.take !== void 0 ? { take: hold.take.toString() } : {},
+        ...hold.takeDecimals !== void 0 ? { takeDecimals: hold.takeDecimals } : {}
       });
     }
     return taken;
@@ -21950,6 +22564,7 @@ var IntentFiller = class {
     }
     const settled = executedHold(claimed, delivered.scaled, released);
     const charged = chargedFor(settled, delivered, released);
+    const takenIn = released > 0n && settled.takeDecimals !== void 0 ? toScaled(released, settled.takeDecimals) : null;
     const settledBid = rows.find(
       (row) => row.reservations.some(
         (hold) => hold.limitOrderId === settled.limitOrderId && hold.amount === settled.amount && hold.take === settled.take
@@ -21968,6 +22583,7 @@ var IntentFiller = class {
               commitment,
               bid: settledBid,
               amount: share.toString(),
+              amountIn: takenIn?.toString() ?? null,
               transactionHash: transactionHash ?? null
             });
           }
@@ -22116,44 +22732,7 @@ var IntentFiller = class {
 // src/strategies/fx.ts
 var import_sdk15 = require("@hyperbridge/sdk");
 var import_viem29 = require("viem");
-var import_decimal6 = require("decimal.js");
-
-// src/orderbook/usd.ts
-var import_decimal5 = require("decimal.js");
-function limitOrderUsdEdges(orders) {
-  return orders.filter((order) => normalizeSymbol(order.base) !== normalizeSymbol(order.quote)).map((order) => ({
-    base: normalizeSymbol(order.base),
-    quote: normalizeSymbol(order.quote),
-    rate: new import_decimal5.Decimal(order.price).div(ORDERBOOK_SCALE.toString())
-  })).filter((edge) => edge.rate.isFinite() && edge.rate.gt(0));
-}
-function usdFactorsFrom(edges) {
-  const factors = /* @__PURE__ */ new Map();
-  for (const symbol of USD_STABLE_SYMBOLS) factors.set(symbol, new import_decimal5.Decimal(1));
-  const ordered = [...edges].sort((a, b) => a.base.localeCompare(b.base) || a.quote.localeCompare(b.quote));
-  let grew = true;
-  while (grew) {
-    grew = false;
-    for (const edge of ordered) {
-      const usdBase = factors.get(edge.base);
-      const usdQuote = factors.get(edge.quote);
-      if (usdBase && !usdQuote) {
-        factors.set(edge.quote, usdBase.div(edge.rate));
-        grew = true;
-      } else if (usdQuote && !usdBase) {
-        factors.set(edge.base, usdQuote.mul(edge.rate));
-        grew = true;
-      }
-    }
-  }
-  return factors;
-}
-function usdValueOf(factors, symbol, amount) {
-  const factor = factors.get(normalizeSymbol(symbol));
-  return factor ? amount.mul(factor) : null;
-}
-
-// src/strategies/fx.ts
+var import_decimal7 = require("decimal.js");
 function adjustDecimalsFloor(amount, fromDecimals, toDecimals) {
   if (fromDecimals === toDecimals) return amount;
   if (fromDecimals < toDecimals) return amount * BigInt(10 ** (toDecimals - fromDecimals));
@@ -22201,7 +22780,7 @@ var FXFiller = class _FXFiller {
     this.maxConsecutiveClamps = configService.getMaxConsecutiveClamps();
     if (confirmationPolicy) {
       this.confirmationPolicy = {
-        getConfirmationBlocks: (chainId, amountUsd) => confirmationPolicy.getConfirmationBlocks(chainId, new import_decimal6.Decimal(amountUsd))
+        getConfirmationBlocks: (chainId, amountUsd) => confirmationPolicy.getConfirmationBlocks(chainId, new import_decimal7.Decimal(amountUsd))
       };
     }
   }
@@ -22297,11 +22876,13 @@ var FXFiller = class _FXFiller {
    * - Treat a payout below the ask as a partial fill, which only orders
    *   without output calldata and without an earlier partial fill allow.
    * - Cap each payout by the filler's balance plus funding-venue withdrawals,
-   *   then gate it on fees (full fills) and the same-asset spread.
+   *   then gate it on fees (full fills of orders below `minOrderSizeUsd`) and the
+   *   same-asset spread.
    * - Cache the resulting bids for later use in `executeOrder`.
    */
   async calculateProfitability(order) {
     if (order.id) this.contractService.cacheService.clearPartialFill(order.id);
+    if (order.id) this.contractService.cacheService.clearFeeCheckWaived(order.id);
     if (this.halted) {
       this.logger.warn({ orderId: order.id }, "FXFiller halted \u2014 rejecting order");
       return 0;
@@ -22317,6 +22898,15 @@ var FXFiller = class _FXFiller {
       const plans = [];
       const plannedOn = /* @__PURE__ */ new Map();
       const spentOn = /* @__PURE__ */ new Map();
+      let atOrAboveMinSize;
+      const feeCheckWaived = async () => {
+        if (atOrAboveMinSize === void 0) {
+          const usd = await this.getOrderUsdValue(order);
+          atOrAboveMinSize = usd !== null && usd.inputUsd.gte(this.configService.getMinOrderSizeUsd());
+        }
+        return atOrAboveMinSize;
+      };
+      let feesWaived = false;
       for (let leg = 0; leg < order.inputs.length; leg++) {
         const input = order.inputs[leg];
         const output = order.output.assets[leg];
@@ -22526,17 +23116,17 @@ var FXFiller = class _FXFiller {
           const outputSymbol = this.registry.symbolFor(outputToken, destChain);
           const sameAsset = outputSymbol !== null && normalizeSymbol(outputSymbol) === normalizeSymbol(candidate.order.base) && normalizeSymbol(outputSymbol) === normalizeSymbol(candidate.order.quote);
           let realizedSpreadProfit = 0n;
-          let sameAssetEdgeUsd = new import_decimal6.Decimal(0);
+          let sameAssetEdgeUsd = new import_decimal7.Decimal(0);
           let sameAssetProfitable = true;
           if (sameAsset) {
             const convertedInput = adjustDecimalsFloor(releasedInput, inputDecimals, outputDecimals);
             const spread = convertedInput - finalOutputAmount;
             if (spread <= 0n) sameAssetProfitable = false;
             realizedSpreadProfit = adjustDecimalsFloor(spread, outputDecimals, feeTokenDecimals);
-            const spreadUsd = outputSymbol && usdValueOf(usdFactors, outputSymbol, new import_decimal6.Decimal((0, import_viem29.formatUnits)(spread, outputDecimals)));
+            const spreadUsd = outputSymbol && usdValueOf(usdFactors, outputSymbol, new import_decimal7.Decimal((0, import_viem29.formatUnits)(spread, outputDecimals)));
             if (spreadUsd) sameAssetEdgeUsd = spreadUsd;
           }
-          const payoutSurplusUsd = new import_decimal6.Decimal(0);
+          const payoutSurplusUsd = new import_decimal7.Decimal(0);
           const { totalCostInSourceFeeToken, relayerFeeInSourceFeeToken, dispatchFee } = await this.contractService.estimateGasFillPost(order);
           if (sourceChain !== destChain && dispatchFee > 0n) {
             const feeToken = await this.contractService.getFeeTokenWithDecimals(destChain);
@@ -22560,17 +23150,21 @@ var FXFiller = class _FXFiller {
           const executionCost = totalCostInSourceFeeToken + relayerFeeInSourceFeeToken;
           const partialEdgeUsd = sameAssetEdgeUsd.plus(payoutSurplusUsd);
           if (!partialFill && order.fees < executionCost) {
-            this.logger.info(
-              {
-                orderId: order.id,
-                orderFees: (0, import_viem29.formatUnits)(order.fees, feeTokenDecimals),
-                fillGas: (0, import_viem29.formatUnits)(totalCostInSourceFeeToken, feeTokenDecimals),
-                relayerFee: (0, import_viem29.formatUnits)(relayerFeeInSourceFeeToken, feeTokenDecimals),
-                executionCost: (0, import_viem29.formatUnits)(executionCost, feeTokenDecimals)
-              },
-              "Skipping order: attached fees do not cover execution cost (fill gas + relayer fee)"
-            );
-            continue;
+            if (!await feeCheckWaived()) {
+              this.logger.info(
+                {
+                  orderId: order.id,
+                  orderFees: (0, import_viem29.formatUnits)(order.fees, feeTokenDecimals),
+                  fillGas: (0, import_viem29.formatUnits)(totalCostInSourceFeeToken, feeTokenDecimals),
+                  relayerFee: (0, import_viem29.formatUnits)(relayerFeeInSourceFeeToken, feeTokenDecimals),
+                  executionCost: (0, import_viem29.formatUnits)(executionCost, feeTokenDecimals),
+                  minOrderSizeUsd: this.configService.getMinOrderSizeUsd()
+                },
+                "Skipping order: attached fees do not cover execution cost (fill gas + relayer fee)"
+              );
+              continue;
+            }
+            feesWaived = true;
           }
           if (sameAsset && !sameAssetProfitable) {
             this.logger.info(
@@ -22604,7 +23198,8 @@ var FXFiller = class _FXFiller {
               realizedSpreadProfit: (0, import_viem29.formatUnits)(realizedSpreadProfit, feeTokenDecimals),
               payoutSurplusUsd: payoutSurplusUsd.toString(),
               totalProfit,
-              profitable: totalProfit > 0
+              profitable: totalProfit > 0,
+              feeCheckWaived: !partialFill && order.fees < executionCost
             },
             "FX swap profitability evaluation"
           );
@@ -22618,6 +23213,7 @@ var FXFiller = class _FXFiller {
             payout: toScaled(finalOutputAmount, outputDecimals),
             fillerOutputs,
             fillerInputs,
+            inputDecimals,
             fundingCalls: [...fundingCalls],
             partialFill,
             profit: totalProfit,
@@ -22636,6 +23232,7 @@ var FXFiller = class _FXFiller {
           plans[0].budget
         );
         this.contractService.cacheService.setPartialFill(order.id, plans[0].partialFill);
+        this.contractService.cacheService.setFeeCheckWaived(order.id, feesWaived);
         this.contractService.cacheService.setMatchedLimitOrder(order.id, [
           { limitOrderId: plans[0].limitOrderId, payout: plans[0].payout }
         ]);
@@ -22895,13 +23492,13 @@ var FXFiller = class _FXFiller {
   async getOrderUsdValue(order) {
     if (!this.limitOrders || order.inputs.length === 0) return null;
     const factors = usdFactorsFrom(limitOrderUsdEdges(await this.limitOrders.open()));
-    let inputUsd = new import_decimal6.Decimal(0);
+    let inputUsd = new import_decimal7.Decimal(0);
     for (const input of order.inputs) {
       const inputToken = (0, import_sdk15.bytes32ToBytes20)(input.token);
       const symbol = this.registry.symbolFor(inputToken, order.source);
       if (!symbol) return null;
       const decimals = await this.contractService.getTokenDecimals(inputToken, order.source);
-      const legUsd = usdValueOf(factors, symbol, new import_decimal6.Decimal((0, import_viem29.formatUnits)(input.amount, decimals)));
+      const legUsd = usdValueOf(factors, symbol, new import_decimal7.Decimal((0, import_viem29.formatUnits)(input.amount, decimals)));
       if (!legUsd) return null;
       inputUsd = inputUsd.plus(legUsd);
     }
@@ -23877,6 +24474,7 @@ async function bootFiller(config, options) {
     rebalancing: config.rebalancing,
     targetGasUnits: config.simplex.targetGasUnits,
     bidValiditySeconds: config.simplex.bidValiditySeconds,
+    minOrderSizeUsd: config.simplex.minOrderSizeUsd,
     blockScanIntervalSeconds: config.simplex.blockScanIntervalSeconds,
     gasFeeBump: config.simplex.gasFeeBump,
     overfillProtection: config.simplex.overfillProtection,
@@ -24085,9 +24683,10 @@ async function bootFiller(config, options) {
   const activity = new ActivityRecorder(options.data.activity, options.loggers, { describeToken });
   activity.attach(intentFiller.monitor);
   const network = resolvedChains.some((chain) => chainByChainId(chain.chainId)?.network === "testnet") ? "testnet" : "mainnet";
+  const indexerUrl = config.simplex.indexerUrl ?? DEFAULT_INDEXER_URLS[network];
   void backfillOrderSummaries({
     store: options.data.activity,
-    indexerUrl: config.simplex.indexerUrl ?? DEFAULT_INDEXER_URLS[network],
+    indexerUrl,
     fillerAddress: runtimeSigner.address,
     describeToken,
     onUpdated: (rows) => {
@@ -24153,6 +24752,15 @@ async function bootFiller(config, options) {
   vaultVenue?.startSweeping();
   started.push(() => balanceProvider.stop());
   await balanceProvider.start();
+  if (options.signer) {
+    const inventoryRecorder = new InventoryRecorder(
+      options.data.inventory,
+      balanceProvider,
+      moduleLogger(options.loggers, "inventory")
+    );
+    started.push(() => inventoryRecorder.stop());
+    inventoryRecorder.start();
+  }
   const watchOnlyChains = watchOnlyConfig ? Object.entries(watchOnlyConfig).filter(([, value]) => value === true).map(([chainId]) => Number.parseInt(chainId, 10)) : [];
   logger.info(
     {
@@ -24198,6 +24806,8 @@ async function bootFiller(config, options) {
     rebalancingService,
     resolvedChains,
     fillerAddress: runtimeSigner.address,
+    indexerUrl,
+    describeToken,
     watchOnly: watchOnlyConfig,
     config,
     configPath: options.configPath,
@@ -24472,10 +25082,20 @@ var MemoryLimitOrderStore = class {
       commitment: fill.commitment,
       bid: fill.bid ?? null,
       amount: fill.amount,
+      amountIn: fill.amountIn ?? null,
       transactionHash: fill.transactionHash ?? null,
       filledAt: sqliteDatetime(/* @__PURE__ */ new Date())
     });
   }
+  async fillHistory() {
+    return this.fillRows.flatMap((fill) => {
+      const order = this.orders.get(fill.limitOrderId);
+      if (!order) return [];
+      const { id, limitOrderId, amount, amountIn, filledAt } = fill;
+      const { book, base, quote, side, price } = order;
+      return [{ id, limitOrderId, book, base, quote, side, price, amount, amountIn, filledAt }];
+    });
+  }
   async fills(limitOrderId, limit = 100) {
     return this.fillRows.filter((fill) => fill.limitOrderId === limitOrderId).slice(-capLimit(limit)).reverse().map((fill) => ({ ...fill }));
   }
@@ -24582,12 +25202,29 @@ var MemoryStateStore = class {
     this.state = { ...state };
   }
 };
+var MemoryInventoryStore = class {
+  constructor() {
+    this.rows = [];
+  }
+  async record(balances) {
+    this.rows.push({ id: this.rows.length + 1, takenAt: sqliteDatetime(/* @__PURE__ */ new Date()), balances: { ...balances } });
+  }
+  async latest() {
+    const last = this.rows[this.rows.length - 1];
+    return last ? { ...last, balances: { ...last.balances } } : null;
+  }
+  async since(from) {
+    const cutoff = sqliteDatetime(from);
+    return this.rows.filter((row) => row.takenAt >= cutoff).map((row) => ({ ...row, balances: { ...row.balances } }));
+  }
+};
 var MemoryDataStore = class {
   constructor() {
     this.bids = new MemoryBidStore();
     this.activity = new MemoryActivityStore();
     this.state = new MemoryStateStore();
     this.limitOrders = new MemoryLimitOrderStore();
+    this.inventory = new MemoryInventoryStore();
   }
 };
 
@@ -25192,6 +25829,106 @@ var OrderScanner = class _OrderScanner {
   }
 };
 
+// src/data/indexer-inventory.ts
+var import_viem33 = require("viem");
+var READ_TIMEOUT_MS = 1e4;
+var SETTLED_AFTER_MS = 10 * 6e4;
+var BATCH = 40;
+var MAX_KEPT = 2e3;
+var IndexerInventory = class {
+  constructor(options) {
+    this.options = options;
+    this.kept = /* @__PURE__ */ new Map();
+    this.described = /* @__PURE__ */ new Map();
+    this.fetch = options.fetch ?? fetch;
+  }
+  /**
+   * A reading for each of `instants` the indexer could answer for. Never rejects: an instant it
+   * could not be asked about is simply missing from the answer.
+   */
+  async at(instants, now) {
+    const readings = [];
+    const wanted = [];
+    for (const instant of new Set(instants)) {
+      const kept = this.kept.get(instant);
+      if (kept) readings.push(kept);
+      else wanted.push(instant);
+    }
+    try {
+      for (let index = 0; index < wanted.length; index += BATCH) {
+        for (const reading of await this.read(wanted.slice(index, index + BATCH))) {
+          readings.push(reading);
+          if (reading.at <= now - SETTLED_AFTER_MS) this.keep(reading);
+        }
+      }
+    } catch (err) {
+      this.options.logger.warn(
+        { err: err instanceof Error ? err.message : String(err) },
+        "Could not read inventory from the indexer; carrying records by fills and sends alone"
+      );
+    }
+    return readings;
+  }
+  keep(reading) {
+    if (this.kept.size >= MAX_KEPT) this.kept.clear();
+    this.kept.set(reading.at, reading);
+  }
+  /** One request for several instants, each its own aliased query at that moment in history. */
+  async read(instants) {
+    const queries = instants.map(
+      (instant, index) => `r${index}: solverInventories(filter: { solver: { equalTo: $solver } }, blockHeight: "${Math.floor(instant)}", first: 1000) { nodes { chain tokenAddress balance } }`
+    );
+    const response = await this.fetch(this.options.indexerUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        query: `query SolverInventory($solver: String!) {
+${queries.join("\n")}
+}`,
+        variables: { solver: this.options.solver.toLowerCase() }
+      }),
+      signal: AbortSignal.timeout(READ_TIMEOUT_MS)
+    });
+    if (!response.ok) throw new Error(`Indexer responded ${response.status}`);
+    const body = await response.json();
+    if (body.errors?.length) throw new Error(body.errors.map((error) => error.message).join("; "));
+    const readings = [];
+    for (const [index, instant] of instants.entries()) {
+      const rows = body.data?.[`r${index}`]?.nodes;
+      if (rows) readings.push(await this.readingOf(instant, rows));
+    }
+    return readings;
+  }
+  async readingOf(at, rows) {
+    const balances = {};
+    const chains = {};
+    for (const row of rows) {
+      const token = await this.describe(row.chain, row.tokenAddress);
+      if (!token) continue;
+      let amount;
+      try {
+        amount = Number((0, import_viem33.formatUnits)(BigInt(row.balance), token.decimals));
+      } catch {
+        continue;
+      }
+      balances[token.symbol] = (balances[token.symbol] ?? 0) + amount;
+      chains[token.symbol] = [...chains[token.symbol] ?? [], row.chain];
+    }
+    return { at, balances, chains };
+  }
+  /** A token's symbol and decimals, remembered once both are known. */
+  async describe(chain, token) {
+    const key = `${chain}:${token.toLowerCase()}`;
+    const known = this.described.get(key);
+    if (known) return known;
+    const { symbol, decimals } = await this.options.describeToken(chain, token);
+    if (!symbol || decimals === null) return null;
+    const description = { symbol, decimals };
+    this.described.set(key, description);
+    return description;
+  }
+};
+
 // src/simplex.ts
 var EVENT_MAP = {
   newOrder: "order:detected",
@@ -25237,10 +25974,66 @@ var LimitOrderController = class {
     ]);
     return { order, fills, bids };
   }
+  /**
+   * What the operator's buys and sells earned over `period`, bucketed on a clock
+   * `tzOffsetMinutes` behind UTC.
+   *
+   * Profit is the change the period's fills made to what the solver holds, and
+   * it is compared with the inventory the period began with. That inventory
+   * comes from the stored snapshots and, when the balances have been read in
+   * full, from what is held now, each carried to the period's start by what
+   * moved between. The indexer says what moved, deposits and withdrawals
+   * included, wherever it has followed the solver; elsewhere the fills and
+   * sends on record stand in. It answers whether or not an orderbook is
+   * configured, and whether or not the indexer does.
+   */
+  async profitability(period, tzOffsetMinutes = 0) {
+    const now = Date.now();
+    const { data, balanceProvider } = this.runtime;
+    const [fills, snapshots, ledger] = await Promise.all([
+      data.limitOrders.fillHistory(),
+      data.inventory.since(/* @__PURE__ */ new Date(0)),
+      data.activity.walletTxs(500)
+    ]);
+    const inventory = snapshots.map((snapshot) => ({
+      at: parseUtc(snapshot.takenAt),
+      balances: snapshot.balances
+    }));
+    const held = inventoryOf(balanceProvider.getSnapshot());
+    if (held) inventory.push({ at: now, balances: held, live: true });
+    const outflows = [];
+    for (const tx of ledger) {
+      const amount = Number(tx.amount);
+      if (tx.kind === "send" && tx.token && Number.isFinite(amount) && amount > 0) {
+        outflows.push({ at: tx.ts, symbol: tx.token, amount });
+      }
+    }
+    const instants = inventoryInstants(fills, { period, now, tzOffsetMinutes, inventory });
+    const readings = await this.indexerInventory().at(instants, now);
+    return summarizeProfit(fills, { period, now, tzOffsetMinutes, inventory, outflows, readings });
+  }
+  /** One reader for the life of the filler, so the readings it has already fetched are kept. */
+  indexerInventory() {
+    this.indexed ?? (this.indexed = new IndexerInventory({
+      indexerUrl: this.runtime.indexerUrl,
+      solver: this.runtime.fillerAddress,
+      describeToken: this.runtime.describeToken,
+      logger: this.runtime.loggers.get("inventory")
+    }));
+    return this.indexed;
+  }
   /** The pairs the orderbook lists, the smallest payout each token may carry, and its tokens per chain. */
   books() {
     return this.service.books();
   }
+  /** Public bids and asks across solvers, optionally restricted to a route. */
+  orderbookSnapshot(book, filters = {}) {
+    return this.service.orderbookSnapshot(book, filters);
+  }
+  /** Every solver's order behind one public price level. */
+  orderbookLevelOrders(book, level) {
+    return this.service.orderbookLevelOrders(book, level);
+  }
   /** Creates the order, posts it, and reports what the orderbook made of it. */
   async create(request) {
     const posted = await this.service.create(request);