@hyperbridge/simplex 0.16.12 → 0.16.13

package/dist/bin/simplex.js

@@ -29007,17 +29007,17 @@ function cosh(x4) {
 }
 function clone(obj) {
   var i6, p3, ps;
-  function Decimal2(v7) {
+  function Decimal3(v7) {
     var e4, i7, t6, x4 = this;
-    if (!(x4 instanceof Decimal2)) return new Decimal2(v7);
-    x4.constructor = Decimal2;
+    if (!(x4 instanceof Decimal3)) return new Decimal3(v7);
+    x4.constructor = Decimal3;
     if (isDecimalInstance(v7)) {
       x4.s = v7.s;
       if (external) {
-        if (!v7.d || v7.e > Decimal2.maxE) {
+        if (!v7.d || v7.e > Decimal3.maxE) {
           x4.e = NaN;
           x4.d = null;
-        } else if (v7.e < Decimal2.minE) {
+        } else if (v7.e < Decimal3.minE) {
           x4.e = 0;
           x4.d = [0];
         } else {
@@ -29047,10 +29047,10 @@ function clone(obj) {
       if (v7 === ~~v7 && v7 < 1e7) {
         for (e4 = 0, i7 = v7; i7 >= 10; i7 /= 10) e4++;
         if (external) {
-          if (e4 > Decimal2.maxE) {
+          if (e4 > Decimal3.maxE) {
             x4.e = NaN;
             x4.d = null;
-          } else if (e4 < Decimal2.minE) {
+          } else if (e4 < Decimal3.minE) {
             x4.e = 0;
             x4.d = [0];
           } else {
@@ -29092,58 +29092,58 @@ function clone(obj) {
     }
     throw Error(invalidArgument + v7);
   }
-  Decimal2.prototype = P;
-  Decimal2.ROUND_UP = 0;
-  Decimal2.ROUND_DOWN = 1;
-  Decimal2.ROUND_CEIL = 2;
-  Decimal2.ROUND_FLOOR = 3;
-  Decimal2.ROUND_HALF_UP = 4;
-  Decimal2.ROUND_HALF_DOWN = 5;
-  Decimal2.ROUND_HALF_EVEN = 6;
-  Decimal2.ROUND_HALF_CEIL = 7;
-  Decimal2.ROUND_HALF_FLOOR = 8;
-  Decimal2.EUCLID = 9;
-  Decimal2.config = Decimal2.set = config;
-  Decimal2.clone = clone;
-  Decimal2.isDecimal = isDecimalInstance;
-  Decimal2.abs = abs;
-  Decimal2.acos = acos;
-  Decimal2.acosh = acosh;
-  Decimal2.add = add2;
-  Decimal2.asin = asin;
-  Decimal2.asinh = asinh;
-  Decimal2.atan = atan;
-  Decimal2.atanh = atanh;
-  Decimal2.atan2 = atan2;
-  Decimal2.cbrt = cbrt;
-  Decimal2.ceil = ceil;
-  Decimal2.clamp = clamp;
-  Decimal2.cos = cos;
-  Decimal2.cosh = cosh;
-  Decimal2.div = div;
-  Decimal2.exp = exp;
-  Decimal2.floor = floor;
-  Decimal2.hypot = hypot;
-  Decimal2.ln = ln;
-  Decimal2.log = log;
-  Decimal2.log10 = log10;
-  Decimal2.log2 = log2;
-  Decimal2.max = max;
-  Decimal2.min = min;
-  Decimal2.mod = mod3;
-  Decimal2.mul = mul;
-  Decimal2.pow = pow;
-  Decimal2.random = random;
-  Decimal2.round = round;
-  Decimal2.sign = sign;
-  Decimal2.sin = sin;
-  Decimal2.sinh = sinh;
-  Decimal2.sqrt = sqrt;
-  Decimal2.sub = sub;
-  Decimal2.sum = sum;
-  Decimal2.tan = tan;
-  Decimal2.tanh = tanh;
-  Decimal2.trunc = trunc;
+  Decimal3.prototype = P;
+  Decimal3.ROUND_UP = 0;
+  Decimal3.ROUND_DOWN = 1;
+  Decimal3.ROUND_CEIL = 2;
+  Decimal3.ROUND_FLOOR = 3;
+  Decimal3.ROUND_HALF_UP = 4;
+  Decimal3.ROUND_HALF_DOWN = 5;
+  Decimal3.ROUND_HALF_EVEN = 6;
+  Decimal3.ROUND_HALF_CEIL = 7;
+  Decimal3.ROUND_HALF_FLOOR = 8;
+  Decimal3.EUCLID = 9;
+  Decimal3.config = Decimal3.set = config;
+  Decimal3.clone = clone;
+  Decimal3.isDecimal = isDecimalInstance;
+  Decimal3.abs = abs;
+  Decimal3.acos = acos;
+  Decimal3.acosh = acosh;
+  Decimal3.add = add2;
+  Decimal3.asin = asin;
+  Decimal3.asinh = asinh;
+  Decimal3.atan = atan;
+  Decimal3.atanh = atanh;
+  Decimal3.atan2 = atan2;
+  Decimal3.cbrt = cbrt;
+  Decimal3.ceil = ceil;
+  Decimal3.clamp = clamp;
+  Decimal3.cos = cos;
+  Decimal3.cosh = cosh;
+  Decimal3.div = div;
+  Decimal3.exp = exp;
+  Decimal3.floor = floor;
+  Decimal3.hypot = hypot;
+  Decimal3.ln = ln;
+  Decimal3.log = log;
+  Decimal3.log10 = log10;
+  Decimal3.log2 = log2;
+  Decimal3.max = max;
+  Decimal3.min = min;
+  Decimal3.mod = mod3;
+  Decimal3.mul = mul;
+  Decimal3.pow = pow;
+  Decimal3.random = random;
+  Decimal3.round = round;
+  Decimal3.sign = sign;
+  Decimal3.sin = sin;
+  Decimal3.sinh = sinh;
+  Decimal3.sqrt = sqrt;
+  Decimal3.sub = sub;
+  Decimal3.sum = sum;
+  Decimal3.tan = tan;
+  Decimal3.tanh = tanh;
+  Decimal3.trunc = trunc;
   if (obj === void 0) obj = {};
   if (obj) {
     if (obj.defaults !== true) {
@@ -29151,8 +29151,8 @@ function clone(obj) {
       for (i6 = 0; i6 < ps.length; ) if (!obj.hasOwnProperty(p3 = ps[i6++])) obj[p3] = this[p3];
     }
   }
-  Decimal2.config(obj);
-  return Decimal2;
+  Decimal3.config(obj);
+  return Decimal3;
 }
 function div(x4, y5) {
   return new this(x4).div(y5);
@@ -51069,7 +51069,7 @@ var require_bn = __commonJS({
         }
         return this;
       };
-      BN3.prototype.add = function add3(num2) {
+      BN3.prototype.add = function add4(num2) {
         var res;
         if (num2.negative !== 0 && this.negative === 0) {
           num2.negative = 0;
@@ -52906,7 +52906,7 @@ var require_bn = __commonJS({
         }
         return this.m.sub(a6)._forceRed(this);
       };
-      Red.prototype.add = function add3(a6, b5) {
+      Red.prototype.add = function add4(a6, b5) {
         this._verify2(a6, b5);
         var res = a6.add(b5);
         if (res.cmp(this.m) >= 0) {
@@ -55786,10 +55786,10 @@ var init_fflate = __esm({
             lm = void 0;
             break;
           } else {
-            let add3 = sym - 254;
+            let add4 = sym - 254;
             if (sym > 264) {
               const i6 = sym - 257, b5 = fleb[i6];
-              add3 = bits(dat, pos, (1 << b5) - 1) + fl[i6];
+              add4 = bits(dat, pos, (1 << b5) - 1) + fl[i6];
               pos += b5;
             }
             const d5 = dm[bits16(dat, pos) & dms], dsym = d5 >>> 4;
@@ -55805,7 +55805,7 @@ var init_fflate = __esm({
               throw "unexpected EOF";
             if (noBuf)
               cbuf(bt + 131072);
-            const end = bt + add3;
+            const end = bt + add4;
             for (; bt < end; bt += 4) {
               buf[bt] = buf[bt - dt];
               buf[bt + 1] = buf[bt + 1 - dt];
@@ -83509,15 +83509,15 @@ var require_fromEvent = __commonJS({
         return function(handler) {
           return target[methodName](eventName, handler, options);
         };
-      }) : isNodeStyleEventEmitter(target) ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target, eventName)) : isJQueryStyleEventEmitter(target) ? jqueryMethods.map(toCommonHandlerRegistry(target, eventName)) : [], 2), add3 = _a10[0], remove = _a10[1];
-      if (!add3) {
+      }) : isNodeStyleEventEmitter(target) ? nodeEventEmitterMethods.map(toCommonHandlerRegistry(target, eventName)) : isJQueryStyleEventEmitter(target) ? jqueryMethods.map(toCommonHandlerRegistry(target, eventName)) : [], 2), add4 = _a10[0], remove = _a10[1];
+      if (!add4) {
         if (isArrayLike_1.isArrayLike(target)) {
           return mergeMap_1.mergeMap(function(subTarget) {
             return fromEvent(subTarget, eventName, options);
           })(innerFrom_1.innerFrom(target));
         }
       }
-      if (!add3) {
+      if (!add4) {
         throw new TypeError("Invalid event target");
       }
       return new Observable_1.Observable(function(subscriber) {
@@ -83528,7 +83528,7 @@ var require_fromEvent = __commonJS({
           }
           return subscriber.next(1 < args.length ? args : args[0]);
         };
-        add3(handler);
+        add4(handler);
         return function() {
           return remove(handler);
         };
@@ -233930,8 +233930,8 @@ function addToExternrefTable0(obj) {
 function passArrayJsValueToWasm0(array, malloc) {
   const ptr = malloc(array.length * 4, 4) >>> 0;
   for (let i6 = 0; i6 < array.length; i6++) {
-    const add3 = addToExternrefTable0(array[i6]);
-    getDataViewMemory0().setUint32(ptr + 4 * i6, add3, true);
+    const add4 = addToExternrefTable0(array[i6]);
+    getDataViewMemory0().setUint32(ptr + 4 * i6, add4, true);
   }
   WASM_VECTOR_LEN = array.length;
   return ptr;
@@ -247568,9 +247568,17 @@ query OrderStatus($commitment: String!) {
        * order. Frontends can use `relayerFee` to approve the ERC-20 spend before
        * submitting the cancel transaction.
        *
+       * A cross-chain cancel is paid on the chain that receives the cancel
+       * transaction: the source chain for the source route, the destination chain
+       * for the destination route. When that chain is a testnet, the quote has no
+       * native value, since testnet hosts have no router to swap it into the fee
+       * token. The caller must first approve `relayerFee` of that host's fee token
+       * to that chain's IntentGateway.
+       *
        * @param order - The order to quote.
        * @param options - Choose the initiation side. Defaults to source-side cancellation.
-       * @returns `{ nativeValue }` — native token amount (wei) to send as `value`;
+       * @returns `{ nativeValue }` — native token amount (wei) to send as `value`,
+       *   or `0n` when the relayer fee must be paid in the fee token;
        *   `{ relayerFee }` — relayer incentive denominated in the chain's fee token.
        */
       async quoteCancelOrder(order, options = {}) {
@@ -247584,11 +247592,12 @@ query OrderStatus($commitment: String!) {
        *
        * Constructs the ISMP GET request the source gateway will dispatch, one
        * `_partialFills` key per leg, and calls `quoteNative` on the source host to
-       * obtain the dispatch fee.
+       * obtain the dispatch fee. Returns a zero `nativeValue` when the source is a
+       * testnet chain, leaving the relayer fee to be paid in its fee token.
        * Returns 0 for same-chain orders (no ISMP call needed).
        *
        * @param order - The order to quote.
-       * @returns The native token dispatch fee in wei.
+       * @returns The native token dispatch fee in wei and the relayer fee.
        */
       async quoteCancelFromSource(order) {
         const sourceStateMachine = normalizeStateMachineId(order.source);
@@ -247596,6 +247605,14 @@ query OrderStatus($commitment: String!) {
         if (sourceStateMachine === destStateMachine) {
           return { nativeValue: 0n, relayerFee: 0n };
         }
+        const feeInSourceFeeToken = await convertGasToFeeToken(
+          this.ctx,
+          _a6.SOURCE_GET_RESPONSE_GAS,
+          "source",
+          sourceStateMachine
+        );
+        const relayerFee = feeInSourceFeeToken * 1005n / 1000n;
+        if (TESTNET_CHAINS.has(sourceStateMachine)) return { nativeValue: 0n, relayerFee };
         const height = order.deadline + 1n;
         const destIntentGateway = this.ctx.dest.configService.getIntentGatewayAddress(destStateMachine);
         const commitment = this.orderId(order);
@@ -247604,20 +247621,13 @@ query OrderStatus($commitment: String!) {
         const getRequest = {
           source: sourceStateMachine,
           dest: destStateMachine,
-          from: this.ctx.source.configService.getIntentGatewayAddress(destStateMachine),
+          from: this.ctx.source.configService.getIntentGatewayAddress(sourceStateMachine),
           nonce: await this.ctx.source.getHostNonce(),
           height,
           keys: keys3,
           timeoutTimestamp: 0n,
           context
         };
-        const feeInSourceFeeToken = await convertGasToFeeToken(
-          this.ctx,
-          _a6.SOURCE_GET_RESPONSE_GAS,
-          "source",
-          sourceStateMachine
-        );
-        const relayerFee = feeInSourceFeeToken * 1005n / 1000n;
         const nativeValue = await this.ctx.source.quoteNative(getRequest, relayerFee) * 101n / 100n;
         return { nativeValue, relayerFee };
       }
@@ -247638,7 +247648,10 @@ query OrderStatus($commitment: String!) {
        *   cancellation. Same-chain orders always use the direct local route.
        * @yields {@link CancelEvent} objects describing each stage of the
        *   cancellation lifecycle. The caller signs or broadcasts the yielded
-       *   transaction, so its signer may differ from `order.user` after expiry.
+       *   transaction, and the gateway decides who may sign it. A same-chain cancel
+       *   or a cross-chain cancel from the destination accepts only `order.user`
+       *   through the deadline and any signer strictly after it. A cross-chain
+       *   cancel from the source accepts only `order.user`, before or after expiry.
        */
       async *cancelOrder(order, indexerClient, options = {}) {
         const sourceStateMachine = normalizeStateMachineId(order.source);
@@ -247858,11 +247871,13 @@ query OrderStatus($commitment: String!) {
        *
        * Estimates the relayer fee for delivering the refund POST request from the
        * destination chain back to the source chain, converts it to the destination
-       * fee token, and calls `quoteNative` on the destination host.
+       * fee token, and calls `quoteNative` on the destination host. Returns a zero
+       * `nativeValue` when the destination is a testnet chain, leaving the relayer
+       * fee to be paid in its fee token.
        * Returns 0 for same-chain orders.
        *
        * @param order - The order to quote.
-       * @returns The native token dispatch fee in wei.
+       * @returns The native token dispatch fee in wei and the relayer fee.
        */
       async quoteCancelFromDest(order) {
         const sourceStateMachine = normalizeStateMachineId(order.source);
@@ -247873,6 +247888,7 @@ query OrderStatus($commitment: String!) {
         const destIntentGateway = this.ctx.dest.configService.getIntentGatewayAddress(destStateMachine);
         const sourceIntentGateway = this.ctx.source.configService.getIntentGatewayAddress(sourceStateMachine);
         const relayerFee = await this.estimateRelayerFee(sourceStateMachine, destStateMachine);
+        if (TESTNET_CHAINS.has(destStateMachine)) return { nativeValue: 0n, relayerFee };
         const body = constructRefundEscrowRequestBody(order, order.user);
         const postRequest = {
           source: destStateMachine,
@@ -250232,6 +250248,8 @@ query QuotePessimistic($route: RouteInput!, $amountIn: BigInt!) {
        * order. Use `relayerFee` to approve the ERC-20 spend before submitting.
        * Same-chain orders use the direct local route for either `from` option and
        * return `{ nativeValue: 0n, relayerFee: 0n }`.
+       * When the chain receiving the cancel transaction is a testnet, `nativeValue` is `0n` and the caller
+       * approves `relayerFee` of that host's fee token to that chain's gateway.
        *
        * Delegates to {@link OrderCanceller.quoteCancelOrder}.
        *
@@ -254232,7 +254250,7 @@ var require_bn2 = __commonJS({
         }
         return this;
       };
-      BN3.prototype.add = function add3(num2) {
+      BN3.prototype.add = function add4(num2) {
         var res;
         if (num2.negative !== 0 && this.negative === 0) {
           num2.negative = 0;
@@ -256059,7 +256077,7 @@ var require_bn2 = __commonJS({
         }
         return this.m.sub(a6)._forceRed(this);
       };
-      Red.prototype.add = function add3(a6, b5) {
+      Red.prototype.add = function add4(a6, b5) {
         this._verify2(a6, b5);
         var res = a6.add(b5);
         if (res.cmp(this.m) >= 0) {
@@ -267070,7 +267088,7 @@ var require_namespace = __commonJS({
         return this.nested[name3].values;
       throw Error("no such enum: " + name3);
     };
-    Namespace.prototype.add = function add3(object) {
+    Namespace.prototype.add = function add4(object) {
       if (!(object instanceof Field6 && object.extend !== void 0 || object instanceof Type2 || object instanceof OneOf || object instanceof Enum3 || object instanceof Service || object instanceof Namespace))
         throw TypeError("object must be a valid nested object");
       if (!this.nested)
@@ -267450,7 +267468,7 @@ var require_service2 = __commonJS({
       });
       return this;
     };
-    Service.prototype.add = function add3(object) {
+    Service.prototype.add = function add4(object) {
       if (this.get(object.name))
         throw Error("duplicate name '" + object.name + "' in " + this);
       if (object instanceof Method2) {
@@ -268155,7 +268173,7 @@ var require_type2 = __commonJS({
     Type2.prototype.get = function get4(name3) {
       return this.fields[name3] || this.oneofs && this.oneofs[name3] || this.nested && this.nested[name3] || null;
     };
-    Type2.prototype.add = function add3(object) {
+    Type2.prototype.add = function add4(object) {
       if (this.get(object.name))
         throw Error("duplicate name '" + object.name + "' in " + this);
       if (object instanceof Field6 && object.extend === void 0) {
@@ -269066,7 +269084,7 @@ var require_oneof = __commonJS({
             oneof.parent.add(oneof.fieldsArray[i6]);
       }
     }
-    OneOf.prototype.add = function add3(field) {
+    OneOf.prototype.add = function add4(field) {
       if (!(field instanceof Field6))
         throw TypeError("field must be a Field");
       if (field.parent && field.parent !== this.parent)
@@ -269395,7 +269413,7 @@ var require_enum = __commonJS({
         keepComments ? this.comments : void 0
       ]);
     };
-    Enum3.prototype.add = function add3(name3, id2, comment, options) {
+    Enum3.prototype.add = function add4(name3, id2, comment, options) {
       if (!util7.isString(name3))
         throw TypeError("name must be a string");
       if (!util7.isInteger(id2))
@@ -273872,7 +273890,7 @@ var require_umd = __commonJS({
           return this.not().add(ONE2);
         };
         LongPrototype.neg = LongPrototype.negate;
-        LongPrototype.add = function add3(addend) {
+        LongPrototype.add = function add4(addend) {
           if (!isLong(addend)) addend = fromValue(addend);
           var a48 = this.high >>> 16;
           var a32 = this.high & 65535;
@@ -340232,6 +340250,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!) {
@@ -340296,6 +340343,44 @@ var OrderbookClient = class {
   async limits() {
     return this.request(LIMITS_QUERY, {});
   }
+  /** The public book across all solvers, restricted to the selected route. */
+  async snapshot(id2, filters = {}) {
+    const { book, serverInfo } = await this.request(SNAPSHOT_QUERY, {
+      id: id2,
+      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(id2, level) {
+    const found = [];
+    let after = null;
+    for (let page = 0; page < LEVEL_ORDER_PAGES; page++) {
+      const { book } = await this.request(LEVEL_ORDERS_QUERY, {
+        id: id2,
+        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) {
@@ -340484,16 +340569,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_SCALE2 : inputAmount * ORDERBOOK_SCALE2 / price;
+  const scaled2 = side === "BID" ? inputAmount * price / ORDERBOOK_SCALE2 : inputAmount * ORDERBOOK_SCALE2 / 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" ? divCeil2(outputAmount * ORDERBOOK_SCALE2, price) : divCeil2(outputAmount * price, ORDERBOOK_SCALE2);
+  const scaled2 = side === "BID" ? divCeil2(outputAmount * ORDERBOOK_SCALE2, price) : divCeil2(outputAmount * price, ORDERBOOK_SCALE2);
   const unit = inputDecimals >= 18 ? 1n : 10n ** BigInt(18 - inputDecimals);
-  return divCeil2(scaled, unit) * unit;
+  return divCeil2(scaled2, unit) * unit;
 }
 
 // src/orderbook/matching.ts
@@ -340751,6 +340836,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.
@@ -340805,16 +340898,16 @@ var LimitOrderService = class {
     if (!this.configService.getConfiguredChainIds().includes(getChainId3(request3.fillChain) ?? -1)) {
       throw new LimitOrderValidationError(`'${request3.fillChain}' is not a chain this filler is configured for`);
     }
-    const scaled = { amountIn: 0n, amountOut: 0n };
+    const scaled2 = { amountIn: 0n, amountOut: 0n };
     for (const name3 of ["amountIn", "amountOut"]) {
       try {
-        scaled[name3] = fromHuman(request3[name3] ?? "");
+        scaled2[name3] = fromHuman(request3[name3] ?? "");
       } catch (err) {
         throw new LimitOrderValidationError(
           `${name3} must be an amount in whole tokens, like "1000" or "1500.25"; ${err.message}`
         );
       }
-      if (scaled[name3] <= 0n) throw new LimitOrderValidationError(`${name3} must be greater than zero`);
+      if (scaled2[name3] <= 0n) throw new LimitOrderValidationError(`${name3} must be greater than zero`);
     }
     const sources = request3.acceptedSources ?? [];
     if (sources.length === 0) {
@@ -340861,7 +340954,7 @@ var LimitOrderService = class {
       );
     }
     const floor2 = limits.serverInfo.minOrderSizes.find((entry) => entry.symbol === request3.tokenOut);
-    if (floor2 && scaled.amountOut < BigInt(floor2.size)) {
+    if (floor2 && scaled2.amountOut < BigInt(floor2.size)) {
       throw new LimitOrderValidationError(
         `amountOut is below the orderbook's dust floor for ${request3.tokenOut} (${toHuman(BigInt(floor2.size))})`
       );
@@ -340871,7 +340964,7 @@ var LimitOrderService = class {
         throw new LimitOrderValidationError(`'${symbol3}' does not resolve to a token address on ${request3.fillChain}`);
       }
     }
-    return { amountIn: scaled.amountIn, amountOut: scaled.amountOut };
+    return { amountIn: scaled2.amountIn, amountOut: scaled2.amountOut };
   }
   /**
    * Refuses an order the wallet cannot pay out.
@@ -341397,6 +341490,459 @@ 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
+init_esm_shims();
+init_decimal();
+init_asset_registry();
+
+// src/data/inventory.ts
+init_esm_shims();
+var INVENTORY_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function inventoryOf(snapshot) {
+  if (snapshot.status !== "fresh") return null;
+  const held = {};
+  for (const chain2 of snapshot.chains) {
+    for (const asset of chain2.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, logger8, now = Date.now) {
+    this.store = store;
+    this.balances = balances;
+    this.logger = logger8;
+    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 latest2 = await this.store.latest();
+        this.lastTakenAt = latest2 ? parseUtc(latest2.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
+init_esm_shims();
+init_decimal();
+init_asset_registry();
+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 Decimal(order.price).div(ORDERBOOK_SCALE2.toString())
+  })).filter((edge) => edge.rate.isFinite() && edge.rate.gt(0));
+}
+function usdFactorsFrom(edges) {
+  const factors = /* @__PURE__ */ new Map();
+  for (const symbol3 of USD_STABLE_SYMBOLS) factors.set(symbol3, new Decimal(1));
+  const ordered = [...edges].sort((a6, b5) => a6.base.localeCompare(b5.base) || a6.quote.localeCompare(b5.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, symbol3, amount) {
+  const factor = factors.get(normalizeSymbol(symbol3));
+  return factor ? amount.mul(factor) : null;
+}
+
+// src/orderbook/profitability.ts
+var Decimal2 = 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 }
+};
+function isProfitPeriod(value) {
+  return value in PROFIT_PERIODS;
+}
+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 Decimal2(value).div(ORDERBOOK_SCALE2.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 add3(holdings, symbol3, amount) {
+  holdings.set(symbol3, (holdings.get(symbol3) ?? new Decimal2(0)).add(amount));
+}
+function apply3(holdings, trade, sign6) {
+  const base4 = trade.buying ? trade.baseAmount : trade.baseAmount.neg();
+  const quote = trade.buying ? trade.quoteAmount.neg() : trade.quoteAmount;
+  add3(holdings, trade.base, base4.mul(sign6));
+  add3(holdings, trade.quote, quote.mul(sign6));
+}
+var Sums = class {
+  constructor() {
+    this.change = /* @__PURE__ */ new Map();
+    this.boughtUsd = new Decimal2(0);
+    this.soldUsd = new Decimal2(0);
+    this.buys = 0;
+    this.sells = 0;
+  }
+};
+var BookLedger = class {
+  constructor(id2, base4, quote) {
+    this.id = id2;
+    this.base = base4;
+    this.quote = quote;
+    this.bought = new Decimal2(0);
+    this.boughtQuote = new Decimal2(0);
+    this.sold = new Decimal2(0);
+    this.soldQuote = new Decimal2(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 [symbol3, amount] of Object.entries(reading.balances)) {
+    const chains2 = reading.chains[symbol3];
+    if (!Number.isFinite(amount) || !chains2?.length) continue;
+    add3(held, normalizeSymbol(symbol3), new Decimal2(amount));
+    cover.set(normalizeSymbol(symbol3), [...chains2].sort().join(","));
+  }
+  return { held, cover };
+}
+function movedBetween(earlier, later) {
+  if (!earlier || !later) return null;
+  const moved = /* @__PURE__ */ new Map();
+  for (const [symbol3, cover] of later.cover) {
+    if (earlier.cover.get(symbol3) !== cover) continue;
+    const before = earlier.held.get(symbol3) ?? new Decimal2(0);
+    moved.set(symbol3, (later.held.get(symbol3) ?? new Decimal2(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 [symbol3, amount] of Object.entries(record.balances)) {
+    if (Number.isFinite(amount)) add3(recorded, normalizeSymbol(symbol3), new Decimal2(amount));
+  }
+  const held = new Map(recorded);
+  const after = record.at >= instant;
+  const [from32, to] = after ? [instant, record.at] : [record.at, instant];
+  const sign6 = after ? -1 : 1;
+  for (const trade of trades) {
+    if (trade.at >= from32 && trade.at < to) apply3(held, trade, sign6);
+  }
+  for (const outflow of outflows) {
+    if (outflow.at >= from32 && outflow.at < to) {
+      add3(held, normalizeSymbol(outflow.symbol), new Decimal2(outflow.amount).mul(-sign6));
+    }
+  }
+  const moved = movedBetween(readings.get(from32), readings.get(to));
+  if (moved) {
+    for (const [symbol3, amount] of moved) {
+      held.set(symbol3, (recorded.get(symbol3) ?? new Decimal2(0)).add(amount.mul(sign6)));
+    }
+  }
+  for (const [symbol3, amount] of held) if (amount.isNegative()) held.set(symbol3, new Decimal2(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((a6, b5) => a6.at - b5.at);
+}
+function bucketStarts(period, now, offset, firstAt) {
+  const { bucket, count } = PROFIT_PERIODS[period];
+  const last = bucketStart(now - offset, bucket);
+  const first3 = count === null ? bucketStart((firstAt ?? now) - offset, bucket) : shiftBucket(last, bucket, 1 - count);
+  const starts = [];
+  for (let start = first3; 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((a6, b5) => a6 - b5);
+}
+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 first3 = starts[0];
+  const books = /* @__PURE__ */ new Map();
+  const spelling2 = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    for (const symbol3 of Object.keys(record.balances)) {
+      if (!spelling2.has(normalizeSymbol(symbol3))) spelling2.set(normalizeSymbol(symbol3), symbol3);
+    }
+  }
+  for (const fill of fills) {
+    for (const symbol3 of [fill.base, fill.quote]) {
+      if (!spelling2.has(normalizeSymbol(symbol3))) spelling2.set(normalizeSymbol(symbol3), symbol3);
+    }
+  }
+  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 Decimal(rate.toString()) });
+    }
+  }
+  const factors = usdFactorsFrom(edges);
+  const priceOf = (symbol3) => {
+    const factor = factors.get(symbol3);
+    return factor ? new Decimal2(factor.toString()) : null;
+  };
+  const unpriced = /* @__PURE__ */ new Set();
+  const valueOf = (holdings) => {
+    let total = new Decimal2(0);
+    for (const [symbol3, amount] of holdings) {
+      if (amount.isZero()) continue;
+      const price = priceOf(symbol3);
+      if (price) total = total.add(amount.mul(price));
+      else unpriced.add(symbol3);
+    }
+    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 Decimal2(0);
+    for (const sum2 of [totals, sums]) {
+      apply3(sum2.change, trade, 1);
+      if (trade.buying) {
+        sum2.buys += 1;
+        sum2.boughtUsd = sum2.boughtUsd.add(volume);
+      } else {
+        sum2.sells += 1;
+        sum2.soldUsd = sum2.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 [symbol3, amount] of sums.change) {
+        if (moved.has(symbol3)) moved.set(symbol3, (moved.get(symbol3) ?? new Decimal2(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 from32 = first3 + offset;
+  const began = inventoryAt(from32, records, trades, outflows, readings);
+  const startInventory = began && {
+    at: from32,
+    source: began.record.live ? "balances" : "snapshot",
+    recordedAt: began.record.at,
+    usd: valueOf(began.held).toNumber(),
+    tokens: [...began.held].filter(([, amount]) => amount.gt(0)).map(([symbol3, amount]) => {
+      const price = priceOf(symbol3);
+      return {
+        symbol: spelling2.get(symbol3) ?? symbol3,
+        amount: amount.toNumber(),
+        usd: price ? amount.mul(price).toNumber() : null
+      };
+    }).sort((a6, b5) => (b5.usd ?? 0) - (a6.usd ?? 0) || a6.symbol.localeCompare(b5.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: spelling2.get(book.base) ?? book.base,
+      quote: spelling2.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((a6, b5) => (b5.profitUsd ?? 0) - (a6.profitUsd ?? 0) || a6.book.localeCompare(b5.book));
+  return {
+    period,
+    bucket,
+    from: from32,
+    to: now,
+    totals: figures(totals, from32, now),
+    series: starts.map((start, index3) => {
+      const sums = buckets.get(start) ?? new Sums();
+      const endsAt = index3 + 1 < starts.length ? starts[index3 + 1] + offset : now;
+      return { start: start + offset, ...figures(sums, start + offset, endsAt) };
+    }),
+    books: rows,
+    startInventory,
+    estimatedFills,
+    unpricedTokens: [...unpriced].map((symbol3) => spelling2.get(symbol3) ?? symbol3).sort()
+  };
+}
+
 // src/services/server/UiServer.ts
 init_Logger();
 
@@ -343639,6 +344185,55 @@ var UiServer = class {
       if (method !== "GET") return sendJson(res, 405, { error: "Method not allowed" });
       return this.handleLimitOrders(res, () => this.operator.limitOrders.books());
     }
+    if (path2 === "/api/analytics/profitability") {
+      if (this.mode !== "operator") return sendJson(res, 409, { error: "Filler is not running" });
+      if (method !== "GET") return sendJson(res, 405, { error: "Method not allowed" });
+      const params = new URL(req.url ?? "/", "http://localhost").searchParams;
+      const period = params.get("period") ?? "7d";
+      if (!isProfitPeriod(period)) return sendJson(res, 400, { error: "period must be 7d, 30d, 12w, 12m or all" });
+      const tz = Number(params.get("tz") ?? 0);
+      if (!Number.isInteger(tz) || Math.abs(tz) > 14 * 60) {
+        return sendJson(res, 400, { error: "tz must be a whole number of minutes" });
+      }
+      return this.handleLimitOrders(res, () => this.operator.limitOrders.profitability(period, tz));
+    }
+    if (path2 === "/api/orderbook/snapshot") {
+      if (this.mode !== "operator") return sendJson(res, 409, { error: "Filler is not running" });
+      if (method !== "GET") return sendJson(res, 405, { error: "Method not allowed" });
+      const params = new URL(req.url ?? "/", "http://localhost").searchParams;
+      const book = params.get("book")?.trim();
+      if (!book) return sendJson(res, 400, { error: "A book is required" });
+      return this.handleLimitOrders(
+        res,
+        () => this.operator.limitOrders.orderbookSnapshot(book, {
+          sourceChain: params.get("sourceChain") || void 0,
+          fillChain: params.get("fillChain") || void 0
+        })
+      );
+    }
+    if (path2 === "/api/orderbook/level-orders") {
+      if (this.mode !== "operator") return sendJson(res, 409, { error: "Filler is not running" });
+      if (method !== "GET") return sendJson(res, 405, { error: "Method not allowed" });
+      const params = new URL(req.url ?? "/", "http://localhost").searchParams;
+      const book = params.get("book")?.trim();
+      const side = params.get("side");
+      const fillChain = params.get("fillChain")?.trim();
+      const priceBucket = params.get("priceBucket")?.trim();
+      if (!book) return sendJson(res, 400, { error: "A book is required" });
+      if (side !== "BID" && side !== "ASK") return sendJson(res, 400, { error: "side must be BID or ASK" });
+      if (!fillChain) return sendJson(res, 400, { error: "A fill chain is required" });
+      if (!priceBucket || !/^\d+$/.test(priceBucket))
+        return sendJson(res, 400, { error: "priceBucket must be an integer" });
+      return this.handleLimitOrders(
+        res,
+        () => this.operator.limitOrders.orderbookLevelOrders(book, {
+          side,
+          fillChain,
+          priceBucket,
+          sourceChain: params.get("sourceChain") || void 0
+        })
+      );
+    }
     const limitOrderMatch = path2.match(/^\/api\/limit-orders\/([\w-]+)$/);
     if (limitOrderMatch) {
       if (this.mode !== "operator") return sendJson(res, 409, { error: "Filler is not running" });
@@ -345000,6 +345595,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) {
@@ -345030,6 +345626,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()
@@ -384432,7 +385029,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(
@@ -384602,7 +385204,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;
@@ -384629,6 +385232,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
@@ -384647,6 +385251,7 @@ var IntentFiller = class {
               commitment,
               bid: settledBid,
               amount: share.toString(),
+              amountIn: takenIn?.toString() ?? null,
               transactionHash: transactionHash ?? null
             });
           }
@@ -384799,45 +385404,6 @@ init_esm();
 init_Logger();
 init_asset_registry();
 init_decimal();
-
-// src/orderbook/usd.ts
-init_esm_shims();
-init_decimal();
-init_asset_registry();
-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 Decimal(order.price).div(ORDERBOOK_SCALE2.toString())
-  })).filter((edge) => edge.rate.isFinite() && edge.rate.gt(0));
-}
-function usdFactorsFrom(edges) {
-  const factors = /* @__PURE__ */ new Map();
-  for (const symbol3 of USD_STABLE_SYMBOLS) factors.set(symbol3, new Decimal(1));
-  const ordered = [...edges].sort((a6, b5) => a6.base.localeCompare(b5.base) || a6.quote.localeCompare(b5.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, symbol3, amount) {
-  const factor = factors.get(normalizeSymbol(symbol3));
-  return factor ? amount.mul(factor) : null;
-}
-
-// src/strategies/fx.ts
 function adjustDecimalsFloor(amount, fromDecimals, toDecimals) {
   if (fromDecimals === toDecimals) return amount;
   if (fromDecimals < toDecimals) return amount * BigInt(10 ** (toDecimals - fromDecimals));
@@ -385318,6 +385884,7 @@ var FXFiller = class _FXFiller {
             payout: toScaled(finalOutputAmount, outputDecimals),
             fillerOutputs,
             fillerInputs,
+            inputDecimals,
             fundingCalls: [...fundingCalls],
             partialFill,
             profit: totalProfit,
@@ -386812,9 +387379,10 @@ async function bootFiller(config5, options) {
   const activity = new ActivityRecorder(options.data.activity, options.loggers, { describeToken });
   activity.attach(intentFiller.monitor);
   const network = resolvedChains.some((chain2) => chainByChainId(chain2.chainId)?.network === "testnet") ? "testnet" : "mainnet";
+  const indexerUrl = config5.simplex.indexerUrl ?? DEFAULT_INDEXER_URLS[network];
   void backfillOrderSummaries({
     store: options.data.activity,
-    indexerUrl: config5.simplex.indexerUrl ?? DEFAULT_INDEXER_URLS[network],
+    indexerUrl,
     fillerAddress: runtimeSigner.address,
     describeToken,
     onUpdated: (rows) => {
@@ -386880,6 +387448,15 @@ async function bootFiller(config5, 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)) : [];
   logger8.info(
     {
@@ -386925,6 +387502,8 @@ async function bootFiller(config5, options) {
     rebalancingService,
     resolvedChains,
     fillerAddress: runtimeSigner.address,
+    indexerUrl,
+    describeToken,
     watchOnly: watchOnlyConfig,
     config: config5,
     configPath: options.configPath,
@@ -387208,10 +387787,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: id2, limitOrderId, amount, amountIn, filledAt } = fill;
+      const { book, base: base4, quote, side, price } = order;
+      return [{ id: id2, limitOrderId, book, base: base4, 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 }));
   }
@@ -387318,12 +387907,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(from32) {
+    const cutoff = sqliteDatetime(from32);
+    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();
   }
 };
 
@@ -387935,6 +388541,107 @@ var OrderScanner = class _OrderScanner {
   }
 };
 
+// src/data/indexer-inventory.ts
+init_esm_shims();
+init_esm();
+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 index3 = 0; index3 < wanted.length; index3 += BATCH) {
+        for (const reading of await this.read(wanted.slice(index3, index3 + 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, index3) => `r${index3}: 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 [index3, instant] of instants.entries()) {
+      const rows = body.data?.[`r${index3}`]?.nodes;
+      if (rows) readings.push(await this.readingOf(instant, rows));
+    }
+    return readings;
+  }
+  async readingOf(at, rows) {
+    const balances = {};
+    const chains2 = {};
+    for (const row of rows) {
+      const token = await this.describe(row.chain, row.tokenAddress);
+      if (!token) continue;
+      let amount;
+      try {
+        amount = Number(formatUnits(BigInt(row.balance), token.decimals));
+      } catch {
+        continue;
+      }
+      balances[token.symbol] = (balances[token.symbol] ?? 0) + amount;
+      chains2[token.symbol] = [...chains2[token.symbol] ?? [], row.chain];
+    }
+    return { at, balances, chains: chains2 };
+  }
+  /** A token's symbol and decimals, remembered once both are known. */
+  async describe(chain2, token) {
+    const key = `${chain2}:${token.toLowerCase()}`;
+    const known3 = this.described.get(key);
+    if (known3) return known3;
+    const { symbol: symbol3, decimals } = await this.options.describeToken(chain2, token);
+    if (!symbol3 || decimals === null) return null;
+    const description = { symbol: symbol3, decimals };
+    this.described.set(key, description);
+    return description;
+  }
+};
+
 // src/simplex.ts
 var EVENT_MAP = {
   newOrder: "order:detected",
@@ -387980,10 +388687,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: data4, balanceProvider } = this.runtime;
+    const [fills, snapshots, ledger] = await Promise.all([
+      data4.limitOrders.fillHistory(),
+      data4.inventory.since(/* @__PURE__ */ new Date(0)),
+      data4.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(request3) {
     const posted = await this.service.create(request3);
@@ -389074,6 +389837,40 @@ var SqliteBidStore = class {
   }
 };
 
+// src/data/sqlite/inventory.ts
+init_esm_shims();
+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(from32) {
+    const cutoff = from32.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
 init_esm_shims();
 init_Logger();
@@ -389147,12 +389944,17 @@ 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_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) {
@@ -389262,12 +390064,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));
@@ -389456,6 +390273,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");
   }
   /**