@hyperbridge/simplex 0.16.12 → 0.17.0

package/dist/index.js

@@ -574,7 +574,8 @@ var BUILTIN_ASSETS = {
   ZARP: { resolve: (r, chain) => r.getAssetBySymbol(chain, "ZARP") },
   EURC: { resolve: (r, chain) => r.getAssetBySymbol(chain, "EURC") },
   XSGD: { resolve: (r, chain) => r.getAssetBySymbol(chain, "XSGD") },
-  TRYB: { resolve: (r, chain) => r.getAssetBySymbol(chain, "TRYB") }
+  TRYB: { resolve: (r, chain) => r.getAssetBySymbol(chain, "TRYB") },
+  BRIDGE: { resolve: (r, chain) => r.getAssetBySymbol(chain, "BRIDGE") }
 };
 var USD_STABLE_SYMBOLS = /* @__PURE__ */ new Set(["USDC", "USDT", "DAI"]);
 function normalizeSymbol(symbol) {
@@ -712,7 +713,7 @@ function assertPairSymbolsResolve(pairs, registry, chainNames) {
   const pairSymbols = new Set(pairs.flatMap((pair) => [pair.token0, pair.token1]));
   for (const pair of pairs) {
     for (const symbol of [pair.token0, pair.token1]) {
-      const resolvesSomewhere = chainNames.some((chainName) => registry.getAddress(symbol, chainName) !== null);
+      const resolvesSomewhere = chainNames.some((chainName2) => registry.getAddress(symbol, chainName2) !== null);
       if (!resolvesSomewhere) {
         throw new Error(
           `pairs.${pair.token0}/${pair.token1}: '${symbol}' does not resolve to a deployed contract on any configured chain`
@@ -720,15 +721,15 @@ function assertPairSymbolsResolve(pairs, registry, chainNames) {
       }
     }
   }
-  for (const chainName of chainNames) {
+  for (const chainName2 of chainNames) {
     const addressOwner = /* @__PURE__ */ new Map();
     for (const symbol of pairSymbols) {
-      const address = registry.getAddress(symbol, chainName)?.toLowerCase();
+      const address = registry.getAddress(symbol, chainName2)?.toLowerCase();
       if (!address) continue;
       const owner = addressOwner.get(address);
       if (owner && normalizeSymbol(owner) !== normalizeSymbol(symbol)) {
         throw new Error(
-          `assets: '${symbol}' and '${owner}' both resolve to ${address} on ${chainName} \u2014 symbols must map to distinct contracts`
+          `assets: '${symbol}' and '${owner}' both resolve to ${address} on ${chainName2} \u2014 symbols must map to distinct contracts`
         );
       }
       addressOwner.set(address, symbol);
@@ -1433,7 +1434,7 @@ var FillerConfigService = class {
     return this.fillerConfig?.substratePrivateKey;
   }
   getEntryPointAddress(chain) {
-    return this.chainConfigService.getEntryPointV08Address(chain);
+    return this.chainConfigService.getEntryPointAddress(chain);
   }
   getSolverAccountContractAddress(chain) {
     return this.chainConfigService.getSolverAccountAddress(chain);
@@ -2482,6 +2483,13 @@ var FREE_RPC_URLS = {
     "https://arb1.arbitrum.io/rpc"
   ]
 };
+var HYPERBRIDGE_BUNDLER_URLS = {
+  1: "https://bundler.polytope.technology/ethereum",
+  56: "https://bundler.polytope.technology/bsc",
+  137: "https://bundler.polytope.technology/polygon",
+  8453: "https://bundler.polytope.technology/base",
+  42161: "https://bundler.polytope.technology/arbitrum"
+};
 var CHAIN_NATIVE_SYMBOLS = {
   1: "ETH",
   56: "BNB",
@@ -2510,7 +2518,8 @@ var INIT_CHAINS = [
     network: "mainnet",
     alchemySubdomain: "eth-mainnet",
     explorerUrl: external_links_default.chainExplorers.ethereum,
-    defaultRpcUrls: FREE_RPC_URLS[1]
+    defaultRpcUrls: FREE_RPC_URLS[1],
+    hyperbridgeBundlerUrl: HYPERBRIDGE_BUNDLER_URLS[1]
   },
   {
     chainId: 42161,
@@ -2519,7 +2528,8 @@ var INIT_CHAINS = [
     network: "mainnet",
     alchemySubdomain: "arb-mainnet",
     explorerUrl: external_links_default.chainExplorers.arbitrum,
-    defaultRpcUrls: FREE_RPC_URLS[42161]
+    defaultRpcUrls: FREE_RPC_URLS[42161],
+    hyperbridgeBundlerUrl: HYPERBRIDGE_BUNDLER_URLS[42161]
   },
   {
     chainId: 8453,
@@ -2528,7 +2538,8 @@ var INIT_CHAINS = [
     network: "mainnet",
     alchemySubdomain: "base-mainnet",
     explorerUrl: external_links_default.chainExplorers.base,
-    defaultRpcUrls: FREE_RPC_URLS[8453]
+    defaultRpcUrls: FREE_RPC_URLS[8453],
+    hyperbridgeBundlerUrl: HYPERBRIDGE_BUNDLER_URLS[8453]
   },
   {
     chainId: 137,
@@ -2537,7 +2548,8 @@ var INIT_CHAINS = [
     network: "mainnet",
     alchemySubdomain: "polygon-mainnet",
     explorerUrl: external_links_default.chainExplorers.polygon,
-    defaultRpcUrls: FREE_RPC_URLS[137]
+    defaultRpcUrls: FREE_RPC_URLS[137],
+    hyperbridgeBundlerUrl: HYPERBRIDGE_BUNDLER_URLS[137]
   },
   {
     chainId: 56,
@@ -2546,7 +2558,8 @@ var INIT_CHAINS = [
     network: "mainnet",
     alchemySubdomain: "bnb-mainnet",
     explorerUrl: external_links_default.chainExplorers.bnb,
-    defaultRpcUrls: FREE_RPC_URLS[56]
+    defaultRpcUrls: FREE_RPC_URLS[56],
+    hyperbridgeBundlerUrl: HYPERBRIDGE_BUNDLER_URLS[56]
   },
   {
     chainId: 11155111,
@@ -2615,6 +2628,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!) {
@@ -2679,6 +2721,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) {
@@ -2792,7 +2872,7 @@ function describe(err) {
 
 // src/orderbook/limit-orders.ts
 import { randomBytes, randomUUID } from "node:crypto";
-import { getChainId, MAX_DECLARED_ENTRIES } from "@hyperbridge/sdk";
+import { ENTRY_POINT_V08, getChainId, MAX_DECLARED_ENTRIES } from "@hyperbridge/sdk";
 
 // src/orderbook/amounts.ts
 import { keccak256, stringToBytes } from "viem";
@@ -2863,16 +2943,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
@@ -2993,6 +3073,8 @@ var LimitOrderService = class {
     this.delegationService = delegationService;
     this.startingNonce = startingNonce;
     this.vaultBalances = vaultBalances;
+    /** Re-signs in flight, by order id. A fill's resize waits one out rather than reposting alongside it. */
+    this.resigning = /* @__PURE__ */ new Map();
     this.logger = loggers.get("limit-orders");
   }
   /**
@@ -3086,6 +3168,7 @@ var LimitOrderService = class {
           bookExpiresAt: null,
           bookPrice: null,
           orderNonce: order.orderNonce,
+          entryPoint: null,
           status: "cancelled",
           lastError: null
         }),
@@ -3128,6 +3211,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.
@@ -3182,16 +3273,16 @@ var LimitOrderService = class {
     if (!this.configService.getConfiguredChainIds().includes(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) {
@@ -3238,7 +3329,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))})`
       );
@@ -3248,7 +3339,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.
@@ -3344,24 +3435,32 @@ var LimitOrderService = class {
   async resize(remaining, delivered) {
     const id = remaining.id;
     const floor = await this.dustFloor(remaining);
-    if (BigInt(remaining.remaining) < floor) {
+    for (let resigning = this.resigning.get(id); resigning; resigning = this.resigning.get(id)) await resigning;
+    const order = await this.store.setStatus(id, "resizing", null, POSTABLE);
+    if (!order) return null;
+    if (BigInt(order.remaining) < floor) {
       this.logger.info(
-        { id, remaining: remaining.remaining, floor: floor.toString() },
+        { id, remaining: order.remaining, floor: floor.toString() },
         "Limit order worked down past the dust floor; closing it"
       );
-      if (remaining.commitment) await this.withdraw(remaining.commitment);
-      const closed = await this.store.setPosting(id, {
-        commitment: null,
-        bookExpiresAt: null,
-        bookPrice: null,
-        orderNonce: remaining.orderNonce,
-        status: "filled",
-        lastError: null
-      });
+      if (order.commitment) await this.withdraw(order.commitment);
+      const closed = await this.store.setPosting(
+        id,
+        {
+          commitment: null,
+          bookExpiresAt: null,
+          bookPrice: null,
+          orderNonce: order.orderNonce,
+          entryPoint: null,
+          status: "filled",
+          lastError: null
+        },
+        POSTABLE
+      );
       if (closed) this.report({ kind: "filled", order: closed });
       return closed;
     }
-    const resized = await this.repost(await this.store.setStatus(id, "resizing"));
+    const resized = await this.repost(order);
     if (resized) this.report({ kind: "resized", order: resized, delivered });
     return resized;
   }
@@ -3374,7 +3473,7 @@ var LimitOrderService = class {
    */
   async repost(order) {
     if (!order) return null;
-    if (isLocal(order)) return this.store.setStatus(order.id, "open");
+    if (isLocal(order)) return this.store.setStatus(order.id, "open", null, POSTABLE);
     if (hasExpired(order.expiresAt, /* @__PURE__ */ new Date())) return this.retire(order);
     if (order.commitment) {
       const withdrawn = await this.withdraw(order.commitment);
@@ -3385,10 +3484,13 @@ var LimitOrderService = class {
           { id: order.id, commitment: order.commitment, err: message },
           "Could not clear the old entry; leaving the posting alone rather than adding a second"
         );
-        return this.store.setStatus(order.id, "open", message);
+        return this.store.setStatus(order.id, "open", message, POSTABLE);
       }
     }
-    await this.store.setStatus(order.id, "resizing");
+    if (!await this.store.setStatus(order.id, "resizing", null, POSTABLE)) {
+      this.logger.info({ id: order.id }, "Limit order closed while it was being reposted; leaving it closed");
+      return null;
+    }
     const nonce = (BigInt(order.orderNonce) + 1n).toString();
     return (await this.post({ ...order, commitment: null, orderNonce: nonce })).order;
   }
@@ -3431,7 +3533,9 @@ var LimitOrderService = class {
    * They drift apart when a request never got an answer or the process died
    * between two of them: an entry the orderbook still lists that nothing here
    * owns, an order here whose entry has gone, or an entry the orderbook has cut
-   * down because the solver cannot cover what it quoted.
+   * down because the solver cannot cover what it quoted. A posted op is also
+   * signed over one EntryPoint, so when the fill chain moves to another, every
+   * entry signed before the move is withdrawn and posted again.
    */
   async reconcile(now = /* @__PURE__ */ new Date()) {
     const [entries, live] = await Promise.all([this.postedOrders(), this.live()]);
@@ -3458,7 +3562,17 @@ var LimitOrderService = class {
     }
     for (const order of live) {
       if (isLocal(order)) continue;
-      if (order.commitment && found.has(order.commitment.toLowerCase())) continue;
+      if (order.commitment && found.has(order.commitment.toLowerCase())) {
+        try {
+          if (await this.resign(order)) report.reposted++;
+        } catch (err) {
+          this.logger.error(
+            { id: order.id, err },
+            "Could not sign the limit order again for its chain's EntryPoint"
+          );
+        }
+        continue;
+      }
       if (sinceMs(order.updatedAt, now) < POST_GRACE_MS) continue;
       this.logger.warn({ id: order.id }, "Limit order has no entry on the orderbook; posting it again");
       try {
@@ -3470,6 +3584,45 @@ var LimitOrderService = class {
     }
     return report;
   }
+  /**
+   * Withdraws a posting signed for an EntryPoint its fill chain no longer uses,
+   * and posts it again signed for the one it uses now. Answers whether a new
+   * posting landed.
+   *
+   * The row is read again and claimed out of `open` first: a fill can have worked
+   * it down or started its own repost since reconciliation listed it, and that
+   * write is the one to follow. A fill that lands once the claim is taken waits
+   * in `resize` for this to finish. The EntryPoint is only written with a posting
+   * that landed, so a pass cut short anywhere leaves a row the next pass still
+   * reads as stale, or as having no entry, and finishes the job.
+   */
+  async resign(listed) {
+    const entryPoint = this.configService.getEntryPointAddress(listed.fillChain);
+    if (!entryPoint || sameAddress(signedFor(listed), entryPoint)) return false;
+    const order = await this.store.get(listed.id);
+    if (!order || order.status !== "open" || order.commitment !== listed.commitment) return false;
+    if (sameAddress(signedFor(order), entryPoint) || this.resigning.has(order.id)) return false;
+    const resigned = this.signAgain(order, entryPoint);
+    this.resigning.set(
+      order.id,
+      resigned.catch(() => false)
+    );
+    try {
+      return await resigned;
+    } finally {
+      this.resigning.delete(order.id);
+    }
+  }
+  async signAgain(order, entryPoint) {
+    const claimed = await this.store.setStatus(order.id, "resizing", null, ["open"]);
+    if (!claimed) return false;
+    this.logger.warn(
+      { id: order.id, commitment: order.commitment, signedFor: signedFor(order), entryPoint },
+      "Limit order was signed for an EntryPoint its chain no longer uses; signing it again"
+    );
+    const posted = await this.repost(claimed);
+    return !!posted?.commitment && sameAddress(signedFor(posted), entryPoint);
+  }
   /**
    * Lowers every open order's `remaining` to what the solver's account will still
    * pay for it, and puts the order back on the book at that size.
@@ -3551,6 +3704,7 @@ var LimitOrderService = class {
       bookExpiresAt: null,
       bookPrice: null,
       orderNonce: order.orderNonce,
+      entryPoint: null,
       status: "expired",
       lastError: null
     });
@@ -3607,11 +3761,11 @@ var LimitOrderService = class {
   }
   /** Builds and submits the posting, then writes the orderbook's answer onto the row. */
   async post(order) {
-    const { result, orderNonce } = await this.submit(order);
+    const { result, orderNonce, entryPoint } = await this.submit(order);
     if (result.kind === "accepted" || result.kind === "unchanged") {
       const posted = result.order;
       this.logger.info(
-        { id: order.id, commitment: posted.commitment, price: posted.price },
+        { id: order.id, commitment: posted.commitment, price: posted.price, entryPoint },
         "Limit order posted to the orderbook"
       );
       const stored = await this.store.setPosting(
@@ -3621,6 +3775,10 @@ var LimitOrderService = class {
           bookExpiresAt: posted.expiresAt,
           bookPrice: posted.price,
           orderNonce: orderNonce.toString(),
+          // An entry the orderbook already held was signed by an earlier attempt,
+          // for whichever EntryPoint was current then. Recorded as unknown, which
+          // reconciliation reads as v0.8 and signs again once the chain is past it.
+          entryPoint: result.kind === "accepted" ? entryPoint : null,
           status: "open",
           lastError: null
         },
@@ -3650,6 +3808,7 @@ var LimitOrderService = class {
           bookExpiresAt: null,
           bookPrice: null,
           orderNonce: orderNonce.toString(),
+          entryPoint: null,
           status: "open",
           lastError: message
         }),
@@ -3672,22 +3831,30 @@ var LimitOrderService = class {
    * only the second one.
    */
   async submit(order) {
+    const entryPoint = this.entryPointFor(order.fillChain);
     const orderNonce = BigInt(order.orderNonce);
-    const attempt = await this.buildAndSubmit(order, orderNonce);
+    const attempt = await this.buildAndSubmit(order, orderNonce, entryPoint);
     const first = attempt.result;
     if (first.kind !== "rejected" || first.code !== "REPLAYED" && first.code !== "ORDER_EXISTS") {
-      return { result: first, orderNonce };
+      return { result: first, orderNonce, entryPoint };
     }
     if (first.code === "ORDER_EXISTS" && attempt.commitment) {
       const live = await this.entryAt(order, attempt.commitment);
       if (live) {
         this.logger.info({ id: order.id, commitment: live.commitment }, "This posting is already on the orderbook");
-        return { result: { kind: "unchanged", order: live }, orderNonce };
+        return { result: { kind: "unchanged", order: live }, orderNonce, entryPoint };
       }
     }
     this.logger.warn({ id: order.id, code: first.code }, "Orderbook has seen this op before; reposting on a new nonce");
     const retried = orderNonce + 1n;
-    return { result: (await this.buildAndSubmit(order, retried)).result, orderNonce: retried };
+    const { result } = await this.buildAndSubmit(order, retried, entryPoint);
+    return { result, orderNonce: retried, entryPoint };
+  }
+  /** The EntryPoint a posting on `chain` is signed for now. */
+  entryPointFor(chain) {
+    const entryPoint = this.configService.getEntryPointAddress(chain);
+    if (!entryPoint) throw new LimitOrderValidationError(`No EntryPoint is configured for ${chain}`);
+    return entryPoint;
   }
   /**
    * The entry the orderbook holds at `commitment`, if it holds one. A lookup that
@@ -3703,8 +3870,8 @@ var LimitOrderService = class {
     }
   }
   /** The orderbook's answer, and the commitment the op we sent hashes to. */
-  async buildAndSubmit(order, orderNonce) {
-    const { commitment, userOp } = await this.buildUserOp(order, orderNonce);
+  async buildAndSubmit(order, orderNonce, entryPoint) {
+    const { commitment, userOp } = await this.buildUserOp(order, orderNonce, entryPoint);
     try {
       return { result: await this.client.submitOrder(userOp), commitment };
     } catch (err) {
@@ -3714,7 +3881,7 @@ var LimitOrderService = class {
       throw err;
     }
   }
-  async buildUserOp(order, orderNonce) {
+  async buildUserOp(order, orderNonce, entryPointAddress) {
     const baseToken = this.assetRegistry.getAddress(order.base, order.fillChain);
     const quoteToken = this.assetRegistry.getAddress(order.quote, order.fillChain);
     const [baseDecimals, quoteDecimals] = await Promise.all([
@@ -3729,10 +3896,6 @@ var LimitOrderService = class {
       baseDecimals,
       quoteDecimals
     });
-    const entryPointAddress = this.configService.getEntryPointAddress(order.fillChain);
-    if (!entryPointAddress) {
-      throw new LimitOrderValidationError(`No EntryPoint is configured for ${order.fillChain}`);
-    }
     return this.contractService.prepareLimitOrderUserOp({
       fillChain: order.fillChain,
       entryPointAddress,
@@ -3763,6 +3926,12 @@ function hasExpired(expiresAt, now) {
   const at = Date.parse(expiresAt);
   return !Number.isNaN(at) && at <= now.getTime();
 }
+function signedFor(order) {
+  return order.entryPoint ?? ENTRY_POINT_V08;
+}
+function sameAddress(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
 function sinceMs(updatedAt, now) {
   const written = Date.parse(`${updatedAt.replace(" ", "T")}Z`);
   return Number.isNaN(written) ? Number.POSITIVE_INFINITY : now.getTime() - written;
@@ -3774,6 +3943,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
+import { Decimal as BaseDecimal } from "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
+import { Decimal as Decimal2 } from "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 Decimal2(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 Decimal2(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 = BaseDecimal.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 BaseDecimal(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);
@@ -3782,6 +4396,80 @@ async function patchRuntimeState(store, patch) {
   return next;
 }
 
+// src/services/bundler-preflight.ts
+var BUNDLER_PREFLIGHT_TIMEOUT_MS = 1e4;
+async function assertBundlersServeEntryPoint(chains, configService, options = {}) {
+  const timeoutMs = options.timeoutMs ?? BUNDLER_PREFLIGHT_TIMEOUT_MS;
+  const logger = moduleLogger(configService.loggers, "bundler-preflight");
+  const failures = await Promise.all(
+    chains.map(async ({ chainId, bundlerUrl }) => {
+      if (options.watchOnly?.[chainId] === true) return void 0;
+      if (!bundlerUrl?.trim()) return void 0;
+      const entryPoint = configService.getEntryPointAddress(formatChainKey(chainId));
+      if (!entryPoint) return void 0;
+      return checkBundler(chainId, bundlerUrl.trim(), entryPoint, timeoutMs, logger);
+    })
+  );
+  const messages = failures.filter((failure) => failure !== void 0);
+  if (messages.length > 0) throw new Error(messages.join("; "));
+}
+function servesEntryPoint(listed, entryPoint) {
+  return Array.isArray(listed) && listed.some((address) => String(address).toLowerCase() === entryPoint.toLowerCase());
+}
+function describeEntryPoints(listed) {
+  return Array.isArray(listed) && listed.length > 0 ? listed.map(String).join(", ") : "none";
+}
+function bundlerHost(url) {
+  try {
+    return new URL(url).host || "an unparseable URL";
+  } catch {
+    return "an unparseable URL";
+  }
+}
+function chainName(chainId) {
+  const label = chainByChainId(chainId)?.label;
+  return label ? `${label} (${formatChainKey(chainId)})` : formatChainKey(chainId);
+}
+async function checkBundler(chainId, bundlerUrl, entryPoint, timeoutMs, logger) {
+  const host = bundlerHost(bundlerUrl);
+  const subject = `Bundler ${host} for ${chainName(chainId)}`;
+  const signal = AbortSignal.timeout(timeoutMs);
+  let listed;
+  try {
+    listed = await supportedEntryPoints(bundlerUrl, signal);
+  } catch (err) {
+    const reason = signal.aborted ? `timed out after ${timeoutMs}ms` : errorReason(err);
+    logger.warn(
+      { chain: formatChainKey(chainId), bundler: host },
+      `${subject} did not answer eth_supportedEntryPoints: ${reason.split(bundlerUrl).join(host)}. Continuing without confirming it serves EntryPoint ${entryPoint}`
+    );
+    return void 0;
+  }
+  if (servesEntryPoint(listed, entryPoint)) return void 0;
+  return `${subject} does not support EntryPoint ${entryPoint}; it lists ${describeEntryPoints(listed)}`;
+}
+async function supportedEntryPoints(bundlerUrl, signal) {
+  const response = await fetch(bundlerUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_supportedEntryPoints", params: [] }),
+    signal
+  });
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  const json = await response.json();
+  if (json.error) throw new Error(json.error.message ?? JSON.stringify(json.error));
+  const { result } = json;
+  if (!Array.isArray(result) || !result.every((address) => typeof address === "string")) {
+    throw new Error("the result is not a list of addresses");
+  }
+  return result;
+}
+function errorReason(err) {
+  if (!(err instanceof Error)) return String(err);
+  const { cause } = err;
+  return cause instanceof Error ? `${err.message} (${cause.message})` : err.message;
+}
+
 // src/services/wallet/mpcvault.ts
 import { concatHex, keccak256 as keccak2562, padHex, toHex } from "viem";
 import * as grpc from "@grpc/grpc-js";
@@ -13045,6 +13733,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) {
@@ -13075,6 +13764,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()
@@ -15713,7 +16403,7 @@ var EVM_HOST = [
 ];
 
 // src/services/ContractInteractionService.ts
-import { Decimal as Decimal2 } from "decimal.js";
+import { Decimal as Decimal4 } from "decimal.js";
 
 // src/config/abis/IntentGatewayV2.ts
 var INTENT_GATEWAY_V2_ABI = [
@@ -16974,9 +17664,9 @@ var INTENT_GATEWAY_V2_ABI = [
             internalType: "bytes32"
           },
           {
-            name: "solver",
-            type: "address",
-            internalType: "address"
+            name: "userOpHash",
+            type: "bytes32",
+            internalType: "bytes32"
           },
           {
             name: "signature",
@@ -18355,7 +19045,7 @@ function describeShortfall(balances) {
 }
 
 // src/services/ContractInteractionService.ts
-Decimal2.config({ precision: 28, rounding: 4 });
+Decimal4.config({ precision: 28, rounding: 4 });
 var FUNDING_GAS_PER_CALL = 400000n;
 var DEBIT_ORDER_GAS = 60000n;
 function settles(budget) {
@@ -18365,10 +19055,13 @@ var LIMIT_ORDER_CALL_GAS_LIMIT = 500000n;
 var LIMIT_ORDER_VERIFICATION_GAS_LIMIT = 150000n;
 var LIMIT_ORDER_PRE_VERIFICATION_GAS = 50000n;
 var BID_DISCOVERY_PAD_SECONDS = 30;
+var BLOCK_TIME_SAMPLE_BLOCKS = 1000n;
+var FALLBACK_BLOCK_TIME_SECONDS = 2;
 var ContractInteractionService = class {
   constructor(clientManager, configService, signer, sharedCacheService) {
     this.clientManager = clientManager;
     this.sdkHelperCache = /* @__PURE__ */ new Map();
+    this.blockTimes = /* @__PURE__ */ new Map();
     this.logger = moduleLogger(configService.loggers, "contract-service");
     this.configService = configService;
     this.cacheService = sharedCacheService || new CacheService();
@@ -18428,11 +19121,20 @@ var ContractInteractionService = class {
     try {
       const chainIds = this.configService.getConfiguredChainIds();
       const chainNames = chainIds.map((id) => `EVM-${id}`);
-      for (const chainName of chainNames) {
+      await Promise.all(
+        chainNames.map(async (chainName2) => {
+          try {
+            await this.blockTimeSeconds(chainName2);
+          } catch (err) {
+            this.logger.warn({ err, chain: chainName2 }, "Could not measure the block time at startup");
+          }
+        })
+      );
+      for (const chainName2 of chainNames) {
         try {
-          await this.getFeeTokenWithDecimals(chainName);
+          await this.getFeeTokenWithDecimals(chainName2);
         } catch (err) {
-          this.logger.warn({ err, chain: chainName }, "Could not prewarm fee token decimals");
+          this.logger.warn({ err, chain: chainName2 }, "Could not prewarm fee token decimals");
         }
       }
       for (const destChain of chainNames) {
@@ -18696,7 +19398,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 Decimal2(0);
+    let inputUsdValue = new Decimal4(0);
     const inputs = order.inputs;
     const sourceUsdc = this.configService.getUsdcAsset(order.source).toLowerCase();
     const sourceUsdt = this.configService.getUsdtAsset(order.source).toLowerCase();
@@ -18705,7 +19407,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 Decimal2(formatUnits2(input.amount, decimals));
+      const tokenAmount = new Decimal4(formatUnits2(input.amount, decimals));
       inputUsdValue = inputUsdValue.plus(tokenAmount);
     }
     return inputUsdValue;
@@ -19017,18 +19719,59 @@ var ContractInteractionService = class {
    *
    * Operators configure seconds because that is the unit the risk is actually in, but the
    * contract compares against block numbers so `order.deadline` and this read the same
-   * clock. The conversion uses the chain's nominal block time; it is deliberately rounded
-   * up, since erring long costs a slightly stale quote while erring short silently drops
-   * winnable bids.
+   * clock. The conversion uses the chain's block time from {@link blockTimeSeconds}; it is
+   * deliberately rounded up, since erring long costs a slightly stale quote while erring
+   * short silently drops winnable bids.
    */
   async bidValidUntilBlock(chain) {
     const client = this.clientManager.getPublicClient(chain);
-    const currentBlock = await client.getBlockNumber();
-    const blockTimeMs = client.chain?.blockTime;
-    const blockTimeSec = blockTimeMs ? blockTimeMs / 1e3 : 2;
+    const [currentBlock, blockTimeSec] = await Promise.all([client.getBlockNumber(), this.blockTimeSeconds(chain)]);
     const windowSec = this.configService.getBidValiditySeconds() + BID_DISCOVERY_PAD_SECONDS;
     return currentBlock + BigInt(Math.ceil(windowSec / blockTimeSec));
   }
+  /**
+   * Seconds per block on `chain`. Measured once, when simplex starts ({@link initCache}), and
+   * kept until it stops. A chain with no measurement yet, because it was added later or its
+   * blocks could not be read at startup, is measured at its first bid.
+   *
+   * The nominal `Chain.blockTime` cannot be relied on alone: it goes stale when a chain
+   * speeds up (BSC makes a block every 0.45s against a declared 0.75s) and some chains
+   * declare none. Converting at a slower block time than the chain's ends a bid early, so
+   * the faster of the measured and the declared figure is used, and a stalled or idle
+   * stretch in the sample never shortens a bid.
+   *
+   * Blocks that cannot be read fall back to the declared figure, then to
+   * {@link FALLBACK_BLOCK_TIME_SECONDS}. That answer is not kept.
+   */
+  blockTimeSeconds(chain) {
+    const known = this.blockTimes.get(chain);
+    if (known) return known;
+    const client = this.clientManager.getPublicClient(chain);
+    const declaredMs = client.chain?.blockTime;
+    const declared = declaredMs ? declaredMs / 1e3 : void 0;
+    const seconds = this.measureBlockTimeSeconds(client).then((measured) => declared ? Math.min(measured, declared) : measured).catch((err) => {
+      this.blockTimes.delete(chain);
+      const fallback2 = declared ?? FALLBACK_BLOCK_TIME_SECONDS;
+      this.logger.warn(
+        { err, chain, seconds: fallback2 },
+        "Could not measure the block time; using the declared one"
+      );
+      return fallback2;
+    });
+    this.blockTimes.set(chain, seconds);
+    return seconds;
+  }
+  /** The average block time over the chain's last {@link BLOCK_TIME_SAMPLE_BLOCKS} blocks, in seconds. */
+  async measureBlockTimeSeconds(client) {
+    const head = await client.getBlock({ blockTag: "latest" });
+    const span = head.number < BLOCK_TIME_SAMPLE_BLOCKS ? head.number : BLOCK_TIME_SAMPLE_BLOCKS;
+    const tail = await client.getBlock({ blockNumber: head.number - span });
+    const measured = Number(head.timestamp - tail.timestamp) / Number(span);
+    if (!Number.isFinite(measured) || measured <= 0) {
+      throw new Error(`${span} blocks span ${head.timestamp - tail.timestamp}s`);
+    }
+    return measured;
+  }
   /**
    * Builds the signed, never-executed UserOperation that carries one limit order
    * to the HyperFX orderbook.
@@ -19203,11 +19946,18 @@ import { encodeFunctionData as encodeFunctionData3, erc20Abi as erc20Abi3, forma
 import { encodeERC7821ExecuteBatch as encodeERC7821ExecuteBatch3 } from "@hyperbridge/sdk";
 
 // src/services/UserOpSender.ts
-import { CryptoUtils as CryptoUtils2, BundlerMethod } from "@hyperbridge/sdk";
+import {
+  CryptoUtils as CryptoUtils2,
+  BundlerMethod,
+  applyRundlerPriorityFee,
+  fetchRundlerPriorityFee
+} from "@hyperbridge/sdk";
 import { toHex as toHex2 } from "viem";
 var FALLBACK_VERIFICATION_GAS_LIMIT = 250000n;
 var FALLBACK_CALL_GAS_LIMIT = 1500000n;
 var FALLBACK_PRE_VERIFICATION_GAS = 150000n;
+var PRIORITY_FEE_BUMP_PERCENT = 8n;
+var MAX_FEE_BUMP_PERCENT = 10n;
 var UserOpSender = class {
   constructor(clientManager, configService, signer) {
     this.clientManager = clientManager;
@@ -19388,7 +20138,11 @@ var UserOpSender = class {
     );
     return userOp;
   }
-  /** Mirrors the gas-price selection used by the delegation and fill paths. */
+  /**
+   * Mirrors the gas-price selection used by the delegation and fill paths: Pimlico's and
+   * Alchemy's own pricing, otherwise the chain's gas price raised to the priority fee a
+   * rundler bundler requires, when the bundler gives one.
+   */
   async getGasPrice(bundlerUrl, publicClient, chainId) {
     const lower = bundlerUrl.toLowerCase();
     if (lower.includes("pimlico.io")) {
@@ -19400,19 +20154,33 @@ var UserOpSender = class {
       return { maxFeePerGas: BigInt(res.fast.maxFeePerGas), maxPriorityFeePerGas: BigInt(res.fast.maxPriorityFeePerGas) };
     }
     if (lower.includes("alchemy.com")) {
-      const [rundlerPriorityFee, latestBlock] = await Promise.all([
+      const [rundlerPriorityFee2, latestBlock2] = await Promise.all([
         this.sendBundlerRpc(bundlerUrl, BundlerMethod.RUNDLER_MAX_PRIORITY_FEE_PER_GAS, []),
         publicClient.getBlock({ blockTag: "latest" })
       ]);
-      const baseFeePerGas = latestBlock.baseFeePerGas ?? await publicClient.getGasPrice();
+      const baseFeePerGas = latestBlock2.baseFeePerGas ?? await publicClient.getGasPrice();
       const isArbitrum = BigInt(chainId) === 42161n;
       const prioBump = isArbitrum ? 0n : 25n;
-      const maxPriorityFeePerGas = BigInt(rundlerPriorityFee) + BigInt(rundlerPriorityFee) * prioBump / 100n;
+      const maxPriorityFeePerGas = BigInt(rundlerPriorityFee2) + BigInt(rundlerPriorityFee2) * prioBump / 100n;
       const bufferedBaseFee = baseFeePerGas + baseFeePerGas * 50n / 100n;
       return { maxFeePerGas: bufferedBaseFee + maxPriorityFeePerGas, maxPriorityFeePerGas };
     }
-    const gasPrice = await publicClient.getGasPrice();
-    return { maxFeePerGas: gasPrice + gasPrice * 10n / 100n, maxPriorityFeePerGas: gasPrice + gasPrice * 8n / 100n };
+    const [gasPrice, rundlerPriorityFee] = await Promise.all([
+      publicClient.getGasPrice(),
+      fetchRundlerPriorityFee(bundlerUrl)
+    ]);
+    const fees = {
+      maxFeePerGas: gasPrice + gasPrice * MAX_FEE_BUMP_PERCENT / 100n,
+      maxPriorityFeePerGas: gasPrice + gasPrice * PRIORITY_FEE_BUMP_PERCENT / 100n
+    };
+    if (rundlerPriorityFee === null) return fees;
+    const latestBlock = await publicClient.getBlock({ blockTag: "latest" });
+    return applyRundlerPriorityFee(fees, {
+      rundlerPriorityFee,
+      baseFeePerGas: latestBlock.baseFeePerGas ?? gasPrice,
+      priorityFeeBumpPercent: PRIORITY_FEE_BUMP_PERCENT,
+      maxFeeBumpPercent: MAX_FEE_BUMP_PERCENT
+    });
   }
   async sendBundlerRpc(bundlerUrl, method, params) {
     const response = await fetch(bundlerUrl, {
@@ -19834,7 +20602,7 @@ var DelegationService = class {
 // src/services/RebalancingService.ts
 import { formatUnits as formatUnits3 } from "viem";
 import { parseStateMachineId as parseStateMachineId4 } from "@hyperbridge/sdk";
-import { Decimal as Decimal3 } from "decimal.js";
+import { Decimal as Decimal5 } from "decimal.js";
 
 // src/services/rebalancers/binance.ts
 import { Wallet as Wallet2 } from "@binance/wallet";
@@ -20998,7 +21766,7 @@ var RebalancingService = class {
         functionName: "balanceOf",
         args: [this.walletAddress]
       });
-      const balanceDecimal = new Decimal3(formatUnits3(balanceWei, Number(decimals)));
+      const balanceDecimal = new Decimal5(formatUnits3(balanceWei, Number(decimals)));
       return balanceDecimal.toNumber();
     } catch (error) {
       this.logger.error({ error, chain, asset }, "Failed to get current balance");
@@ -21031,7 +21799,7 @@ var RebalancingService = class {
 };
 
 // src/core/filler.ts
-import { Decimal as Decimal4 } from "decimal.js";
+import { Decimal as Decimal6 } from "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;
@@ -21587,7 +22355,7 @@ var IntentFiller = class {
           try {
             const stratValue = await strategy.getOrderUsdValue(order);
             if (stratValue != null) {
-              inputUsdValue = Decimal4.max(baseInputUsd, stratValue.inputUsd);
+              inputUsdValue = Decimal6.max(baseInputUsd, stratValue.inputUsd);
               valued = true;
               break;
             }
@@ -21835,7 +22603,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(
@@ -22005,7 +22778,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;
@@ -22032,6 +22806,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
@@ -22050,6 +22825,7 @@ var IntentFiller = class {
               commitment,
               bid: settledBid,
               amount: share.toString(),
+              amountIn: takenIn?.toString() ?? null,
               transactionHash: transactionHash ?? null
             });
           }
@@ -22201,44 +22977,7 @@ import {
   ADDRESS_ZERO as ADDRESS_ZERO2
 } from "@hyperbridge/sdk";
 import { formatUnits as formatUnits4 } from "viem";
-import { Decimal as Decimal6 } from "decimal.js";
-
-// src/orderbook/usd.ts
-import { Decimal as Decimal5 } from "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 Decimal5(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 Decimal5(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
+import { Decimal as Decimal7 } from "decimal.js";
 function adjustDecimalsFloor(amount, fromDecimals, toDecimals) {
   if (fromDecimals === toDecimals) return amount;
   if (fromDecimals < toDecimals) return amount * BigInt(10 ** (toDecimals - fromDecimals));
@@ -22286,7 +23025,7 @@ var FXFiller = class _FXFiller {
     this.maxConsecutiveClamps = configService.getMaxConsecutiveClamps();
     if (confirmationPolicy) {
       this.confirmationPolicy = {
-        getConfirmationBlocks: (chainId, amountUsd) => confirmationPolicy.getConfirmationBlocks(chainId, new Decimal6(amountUsd))
+        getConfirmationBlocks: (chainId, amountUsd) => confirmationPolicy.getConfirmationBlocks(chainId, new Decimal7(amountUsd))
       };
     }
   }
@@ -22622,17 +23361,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 Decimal6(0);
+          let sameAssetEdgeUsd = new Decimal7(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 Decimal6(formatUnits4(spread, outputDecimals)));
+            const spreadUsd = outputSymbol && usdValueOf(usdFactors, outputSymbol, new Decimal7(formatUnits4(spread, outputDecimals)));
             if (spreadUsd) sameAssetEdgeUsd = spreadUsd;
           }
-          const payoutSurplusUsd = new Decimal6(0);
+          const payoutSurplusUsd = new Decimal7(0);
           const { totalCostInSourceFeeToken, relayerFeeInSourceFeeToken, dispatchFee } = await this.contractService.estimateGasFillPost(order);
           if (sourceChain !== destChain && dispatchFee > 0n) {
             const feeToken = await this.contractService.getFeeTokenWithDecimals(destChain);
@@ -22719,6 +23458,7 @@ var FXFiller = class _FXFiller {
             payout: toScaled(finalOutputAmount, outputDecimals),
             fillerOutputs,
             fillerInputs,
+            inputDecimals,
             fundingCalls: [...fundingCalls],
             partialFill,
             profit: totalProfit,
@@ -22997,13 +23737,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 Decimal6(0);
+    let inputUsd = new Decimal7(0);
     for (const input of order.inputs) {
       const inputToken = bytes32ToBytes204(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 Decimal6(formatUnits4(input.amount, decimals)));
+      const legUsd = usdValueOf(factors, symbol, new Decimal7(formatUnits4(input.amount, decimals)));
       if (!legUsd) return null;
       inputUsd = inputUsd.plus(legUsd);
     }
@@ -23987,8 +24727,8 @@ async function bootFiller(config, options) {
   };
   const configService = new FillerConfigService(resolvedChains, fillerConfigForService, options.loggers);
   const chainConfigs = resolvedChains.map((chain) => {
-    const chainName = `EVM-${chain.chainId}`;
-    return configService.getChainConfig(chainName);
+    const chainName2 = `EVM-${chain.chainId}`;
+    return configService.getChainConfig(chainName2);
   });
   let watchOnlyConfig;
   const globalWatchOnly = options.watchOnlyOverride === true || config.simplex.watchOnly === true;
@@ -24026,6 +24766,8 @@ async function bootFiller(config, options) {
       "A signer is required unless every chain is watch-only: pass `signer` to Simplex.start (privateKeySigner, secretPhraseSigner, turnkeySigner, mpcVaultSigner, viemSigner, or your own Signer implementation). Running the binary? Configure it under [simplex.signer]."
     );
   }
+  logger.info("Checking each bundler serves its chain's EntryPoint...");
+  await assertBundlersServeEntryPoint(resolvedChains, configService, { watchOnly: watchOnlyConfig });
   const chainClientManager = new ChainClientManager(configService, options.signer);
   const runtimeSigner = chainClientManager.getSigner();
   if (options.signer) {
@@ -24188,9 +24930,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) => {
@@ -24215,10 +24958,10 @@ async function bootFiller(config, options) {
   const token1 = {};
   for (const pair of config.pairs ?? []) {
     if (normalizeSymbol(pair.token0) === normalizeSymbol(pair.token1)) continue;
-    for (const chainName of configuredChainNames) {
-      const address = assetRegistry.getAddress(pair.token1, chainName);
+    for (const chainName2 of configuredChainNames) {
+      const address = assetRegistry.getAddress(pair.token1, chainName2);
       if (!address) continue;
-      const list = token1[chainName] ?? (token1[chainName] = []);
+      const list = token1[chainName2] ?? (token1[chainName2] = []);
       if (!list.includes(address)) list.push(address);
     }
   }
@@ -24256,6 +24999,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(
     {
@@ -24301,6 +25053,8 @@ async function bootFiller(config, options) {
     rebalancingService,
     resolvedChains,
     fillerAddress: runtimeSigner.address,
+    indexerUrl,
+    describeToken,
     watchOnly: watchOnlyConfig,
     config,
     configPath: options.configPath,
@@ -24575,10 +25329,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 }));
   }
@@ -24593,6 +25357,7 @@ var MemoryLimitOrderStore = class {
       status: "open",
       commitment: null,
       orderNonce: order.orderNonce ?? "0",
+      entryPoint: null,
       bookExpiresAt: null,
       bookPrice: null,
       lastError: null,
@@ -24685,12 +25450,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();
   }
 };
 
@@ -25295,6 +26077,106 @@ var OrderScanner = class _OrderScanner {
   }
 };
 
+// src/data/indexer-inventory.ts
+import { formatUnits as formatUnits7 } from "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(formatUnits7(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",
@@ -25340,10 +26222,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);
@@ -25405,10 +26343,10 @@ var PairController = class {
     if (assets && Object.keys(assets).length > 0) config.assets = nextAssets;
     if (normalizeSymbol(pair.token0) !== normalizeSymbol(pair.token1)) {
       for (const chain of this.runtime.resolvedChains) {
-        const chainName = formatChainKey(chain.chainId);
-        const address = assetRegistry.getAddress(pair.token1, chainName);
+        const chainName2 = formatChainKey(chain.chainId);
+        const address = assetRegistry.getAddress(pair.token1, chainName2);
         if (!address) continue;
-        const list = balanceTokens[chainName] ?? (balanceTokens[chainName] = []);
+        const list = balanceTokens[chainName2] ?? (balanceTokens[chainName2] = []);
         if (!list.includes(address)) list.push(address);
       }
     }
@@ -25513,8 +26451,9 @@ var ChainController = class {
           `Chain ${chainId} cannot be added as filling: this solver was started without a signer. Restart with \`signer\` to fill.`
         );
       }
-      configService.addChain(resolved);
       const watchOnly = chain.watchOnly ?? (this.runtime.signerless || this.runtime.globalWatchOnly);
+      await assertBundlersServeEntryPoint([resolved], configService, { watchOnly: { [chainId]: watchOnly } });
+      configService.addChain(resolved);
       if (watchOnly) intentFiller.setWatchOnly(chainId, true);
       try {
         if (!inScanner) {
@@ -25606,6 +26545,9 @@ var ChainController = class {
       if (!bundlerUrl?.trim()) throw new Error("A bundler URL is required");
       const index = this.runtime.resolvedChains.findIndex((chain) => chain.chainId === chainId);
       if (index < 0) throw new Error(`Chain ${chainId} is not configured`);
+      await assertBundlersServeEntryPoint([{ chainId, bundlerUrl }], this.runtime.configService, {
+        watchOnly: this.runtime.intentFiller.getWatchOnly()
+      });
       this.runtime.configService.setBundlerUrl(chainId, bundlerUrl);
       this.runtime.resolvedChains[index].bundlerUrl = bundlerUrl;
       this.runtime.config.chains[index].bundlerUrl = bundlerUrl;
@@ -25620,6 +26562,10 @@ var ChainController = class {
           "Watch-only cannot be disabled: this solver was started without a signer. Restart with `signer` to fill."
         );
       }
+      if (!watchOnly) {
+        const chain = this.runtime.resolvedChains.find((resolved) => resolved.chainId === chainId);
+        if (chain) await assertBundlersServeEntryPoint([chain], this.runtime.configService);
+      }
       this.runtime.intentFiller.setWatchOnly(chainId, watchOnly);
       this.syncWatchOnlyToConfig();
       await this.persist();