@hyperbridge/simplex 0.16.13 → 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,
@@ -2859,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";
@@ -3060,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");
   }
   /**
@@ -3153,6 +3168,7 @@ var LimitOrderService = class {
           bookExpiresAt: null,
           bookPrice: null,
           orderNonce: order.orderNonce,
+          entryPoint: null,
           status: "cancelled",
           lastError: null
         }),
@@ -3419,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;
   }
@@ -3449,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);
@@ -3460,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;
   }
@@ -3506,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()]);
@@ -3533,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 {
@@ -3545,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.
@@ -3626,6 +3704,7 @@ var LimitOrderService = class {
       bookExpiresAt: null,
       bookPrice: null,
       orderNonce: order.orderNonce,
+      entryPoint: null,
       status: "expired",
       lastError: null
     });
@@ -3682,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(
@@ -3696,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
         },
@@ -3725,6 +3808,7 @@ var LimitOrderService = class {
           bookExpiresAt: null,
           bookPrice: null,
           orderNonce: orderNonce.toString(),
+          entryPoint: null,
           status: "open",
           lastError: message
         }),
@@ -3747,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
@@ -3778,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) {
@@ -3789,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([
@@ -3804,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,
@@ -3838,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;
@@ -4302,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";
@@ -17496,9 +17664,9 @@ var INTENT_GATEWAY_V2_ABI = [
             internalType: "bytes32"
           },
           {
-            name: "solver",
-            type: "address",
-            internalType: "address"
+            name: "userOpHash",
+            type: "bytes32",
+            internalType: "bytes32"
           },
           {
             name: "signature",
@@ -18887,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();
@@ -18950,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) {
@@ -19539,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.
@@ -19725,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;
@@ -19910,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")) {
@@ -19922,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, {
@@ -24481,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;
@@ -24520,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) {
@@ -24710,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);
     }
   }
@@ -25109,6 +25357,7 @@ var MemoryLimitOrderStore = class {
       status: "open",
       commitment: null,
       orderNonce: order.orderNonce ?? "0",
+      entryPoint: null,
       bookExpiresAt: null,
       bookPrice: null,
       lastError: null,
@@ -26094,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);
       }
     }
@@ -26202,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) {
@@ -26295,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;
@@ -26309,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();