@hyperbridge/simplex 0.16.13 → 0.17.1

package/dist/bin/simplex.js

@@ -30656,7 +30656,8 @@ var init_asset_registry = __esm({
       ZARP: { resolve: (r7, chain2) => r7.getAssetBySymbol(chain2, "ZARP") },
       EURC: { resolve: (r7, chain2) => r7.getAssetBySymbol(chain2, "EURC") },
       XSGD: { resolve: (r7, chain2) => r7.getAssetBySymbol(chain2, "XSGD") },
-      TRYB: { resolve: (r7, chain2) => r7.getAssetBySymbol(chain2, "TRYB") }
+      TRYB: { resolve: (r7, chain2) => r7.getAssetBySymbol(chain2, "TRYB") },
+      BRIDGE: { resolve: (r7, chain2) => r7.getAssetBySymbol(chain2, "BRIDGE") }
     };
     USD_STABLE_SYMBOLS = /* @__PURE__ */ new Set(["USDC", "USDT", "DAI"]);
     ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
@@ -30755,7 +30756,7 @@ function assertPairSymbolsResolve(pairs, registry, chainNames) {
   const pairSymbols = new Set(pairs.flatMap((pair) => [pair.token0, pair.token1]));
   for (const pair of pairs) {
     for (const symbol3 of [pair.token0, pair.token1]) {
-      const resolvesSomewhere = chainNames.some((chainName) => registry.getAddress(symbol3, chainName) !== null);
+      const resolvesSomewhere = chainNames.some((chainName2) => registry.getAddress(symbol3, chainName2) !== null);
       if (!resolvesSomewhere) {
         throw new Error(
           `pairs.${pair.token0}/${pair.token1}: '${symbol3}' does not resolve to a deployed contract on any configured chain`
@@ -30763,15 +30764,15 @@ function assertPairSymbolsResolve(pairs, registry, chainNames) {
       }
     }
   }
-  for (const chainName of chainNames) {
+  for (const chainName2 of chainNames) {
     const addressOwner = /* @__PURE__ */ new Map();
     for (const symbol3 of pairSymbols) {
-      const address = registry.getAddress(symbol3, chainName)?.toLowerCase();
+      const address = registry.getAddress(symbol3, chainName2)?.toLowerCase();
       if (!address) continue;
       const owner = addressOwner.get(address);
       if (owner && normalizeSymbol(owner) !== normalizeSymbol(symbol3)) {
         throw new Error(
-          `assets: '${symbol3}' and '${owner}' both resolve to ${address} on ${chainName} \u2014 symbols must map to distinct contracts`
+          `assets: '${symbol3}' and '${owner}' both resolve to ${address} on ${chainName2} \u2014 symbols must map to distinct contracts`
         );
       }
       addressOwner.set(address, symbol3);
@@ -48802,11 +48803,11 @@ var init_esm2 = __esm({
     init_encodeFunctionData2();
     init_encodePacked2();
     init_parseEventLogs2();
-    init_isAddress2();
     init_defineChain2();
     init_concat2();
     init_isHex2();
     init_pad2();
+    init_slice2();
     init_fromBytes2();
     init_fromHex2();
     init_toBytes2();
@@ -48814,6 +48815,7 @@ var init_esm2 = __esm({
     init_keccak2562();
     init_toEventSelector2();
     init_toFunctionSelector2();
+    init_recoverAddress2();
     init_formatUnits2();
     init_parseUnits2();
   }
@@ -135098,21 +135100,21 @@ var init_upgrades = __esm({
 });
 
 // ../../node_modules/.pnpm/@polkadot+types-known@16.5.6/node_modules/@polkadot/types-known/util.js
-function withNames(chainName, specName, fn) {
-  return fn(chainName.toString(), specName.toString());
+function withNames(chainName2, specName, fn) {
+  return fn(chainName2.toString(), specName.toString());
 }
 function filterVersions(versions = [], specVersion) {
   return versions.filter(({ minmax: [min2, max3] }) => (min2 === void 0 || min2 === null || specVersion >= min2) && (max3 === void 0 || max3 === null || specVersion <= max3)).reduce((result, { types: types4 }) => ({ ...result, ...types4 }), {});
 }
-function getSpecExtensions({ knownTypes: knownTypes2 }, chainName, specName) {
-  return withNames(chainName, specName, (c6, s4) => ({
+function getSpecExtensions({ knownTypes: knownTypes2 }, chainName2, specName) {
+  return withNames(chainName2, specName, (c6, s4) => ({
     ...knownTypes2.typesBundle?.spec?.[s4]?.signedExtensions ?? {},
     ...knownTypes2.typesBundle?.chain?.[c6]?.signedExtensions ?? {}
   }));
 }
-function getSpecTypes({ knownTypes: knownTypes2 }, chainName, specName, specVersion) {
+function getSpecTypes({ knownTypes: knownTypes2 }, chainName2, specName, specVersion) {
   const _specVersion = bnToBn(specVersion).toNumber();
-  return withNames(chainName, specName, (c6, s4) => ({
+  return withNames(chainName2, specName, (c6, s4) => ({
     // The order here is always, based on -
     //   - spec then chain
     //   - typesBundle takes higher precedence
@@ -135126,23 +135128,23 @@ function getSpecTypes({ knownTypes: knownTypes2 }, chainName, specName, specVers
     ...knownTypes2.types ?? {}
   }));
 }
-function getSpecHasher({ knownTypes: knownTypes2 }, chainName, specName) {
-  return withNames(chainName, specName, (c6, s4) => knownTypes2.hasher || knownTypes2.typesBundle?.chain?.[c6]?.hasher || knownTypes2.typesBundle?.spec?.[s4]?.hasher || null);
+function getSpecHasher({ knownTypes: knownTypes2 }, chainName2, specName) {
+  return withNames(chainName2, specName, (c6, s4) => knownTypes2.hasher || knownTypes2.typesBundle?.chain?.[c6]?.hasher || knownTypes2.typesBundle?.spec?.[s4]?.hasher || null);
 }
-function getSpecRpc({ knownTypes: knownTypes2 }, chainName, specName) {
-  return withNames(chainName, specName, (c6, s4) => ({
+function getSpecRpc({ knownTypes: knownTypes2 }, chainName2, specName) {
+  return withNames(chainName2, specName, (c6, s4) => ({
     ...knownTypes2.typesBundle?.spec?.[s4]?.rpc ?? {},
     ...knownTypes2.typesBundle?.chain?.[c6]?.rpc ?? {}
   }));
 }
-function getSpecRuntime({ knownTypes: knownTypes2 }, chainName, specName) {
-  return withNames(chainName, specName, (c6, s4) => ({
+function getSpecRuntime({ knownTypes: knownTypes2 }, chainName2, specName) {
+  return withNames(chainName2, specName, (c6, s4) => ({
     ...knownTypes2.typesBundle?.spec?.[s4]?.runtime ?? {},
     ...knownTypes2.typesBundle?.chain?.[c6]?.runtime ?? {}
   }));
 }
-function getSpecAlias({ knownTypes: knownTypes2 }, chainName, specName) {
-  return withNames(chainName, specName, (c6, s4) => ({
+function getSpecAlias({ knownTypes: knownTypes2 }, chainName2, specName) {
+  return withNames(chainName2, specName, (c6, s4) => ({
     // as per versions, first spec, then chain then finally non-versioned
     ...knownTypes2.typesBundle?.spec?.[s4]?.alias ?? {},
     ...knownTypes2.typesBundle?.chain?.[c6]?.alias ?? {},
@@ -156390,7 +156392,7 @@ var require_isTime = __commonJS({
       hourFormat: "hour24",
       mode: "default"
     };
-    var formats = {
+    var formats2 = {
       hour24: {
         default: /^([01]?[0-9]|2[0-3]):([0-5][0-9])$/,
         withSeconds: /^([01]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$/,
@@ -156405,7 +156407,7 @@ var require_isTime = __commonJS({
     function isTime(input, options) {
       options = (0, _merge.default)(options, default_time_options);
       if (typeof input !== "string") return false;
-      return formats[options.hourFormat][options.mode].test(input);
+      return formats2[options.hourFormat][options.mode].test(input);
     }
     module2.exports = exports2.default;
     module2.exports.default = exports2.default;
@@ -234901,6 +234903,10 @@ function createSessionKeyStorage(options = {}) {
     listSessionKeys
   });
 }
+async function signTypedDigest(domainSeparator2, structHash, privateKey) {
+  const digest = keccak2563(concat3(["0x1901", domainSeparator2, structHash]));
+  return privateKeyToAccount(privateKey).sign({ hash: digest });
+}
 function encodeERC7821ExecuteBatch(calls) {
   const executionData = encodeAbiParameters2(
     [{ type: "tuple[]", components: erc7281_default.ABI[1].components }],
@@ -235162,6 +235168,9 @@ function cancelFromSourceContext(order, commitment) {
     ]
   );
 }
+function supportedReleases(stateMachineId) {
+  return TESTNET_CHAINS.has(stateMachineId) ? TESTNET_INTENTS_VERSIONS : [SUPPORTED_INTENTS_VERSION];
+}
 async function readContractVersion(client, address) {
   try {
     return await client.readContract({ address, abi: CONTRACT_VERSION_ABI, functionName: "version" });
@@ -235170,14 +235179,17 @@ async function readContractVersion(client, address) {
     throw error;
   }
 }
-async function supportsRateFills(client, gateway) {
-  return await readContractVersion(client, gateway) === SUPPORTED_INTENTS_VERSION;
+async function supportsRateFills(client, gateway, stateMachineId) {
+  const version17 = await readContractVersion(client, gateway);
+  return supportedReleases(stateMachineId).some((release) => release === version17);
 }
-async function assertGatewayRelease(client, gateway) {
+async function assertGatewayRelease(client, gateway, stateMachineId) {
+  const supported = supportedReleases(stateMachineId);
   const version17 = await readContractVersion(client, gateway);
-  if (version17 === SUPPORTED_INTENTS_VERSION) return;
+  if (supported.some((release) => release === version17)) return;
+  const required2 = supported.join(" or ");
   throw new Error(
-    version17 === void 0 ? `IntentGateway ${gateway} reports no version(); this SDK requires release ${SUPPORTED_INTENTS_VERSION}` : `IntentGateway ${gateway} reports release ${String(version17)}; this SDK requires release ${SUPPORTED_INTENTS_VERSION}`
+    version17 === void 0 ? `IntentGateway ${gateway} reports no version(); this SDK requires release ${required2}` : `IntentGateway ${gateway} reports release ${String(version17)}; this SDK requires release ${required2}`
   );
 }
 function isCanonicalEvmToken(token) {
@@ -235219,6 +235231,40 @@ function decodeFillOrder(data4) {
     return null;
   }
 }
+function readSelectionFormat(client, chainId, gateway) {
+  const key = `${chainId}:${gateway.toLowerCase()}`;
+  const cached = formats.get(key);
+  if (cached) return cached;
+  const format2 = client.readContract({ address: gateway, abi: ABI3, functionName: "SELECT_SOLVER_TYPEHASH" }).then((typehash) => {
+    switch (typehash.toLowerCase()) {
+      case SELECT_SOLVER_TYPEHASH:
+        return "userOpHash";
+      case LEGACY_SELECT_SOLVER_TYPEHASH:
+        return "address";
+      default:
+        throw new Error(
+          `IntentGatewayV2 ${gateway} on chain ${chainId} has unknown SELECT_SOLVER_TYPEHASH ${typehash}`
+        );
+    }
+  });
+  formats.set(key, format2);
+  format2.catch(() => {
+    if (formats.get(key) === format2) formats.delete(key);
+  });
+  return format2;
+}
+function refreshSelectionFormat(client, chainId, gateway, stale) {
+  const key = `${chainId}:${gateway.toLowerCase()}`;
+  if (formats.get(key) === stale) formats.delete(key);
+  return readSelectionFormat(client, chainId, gateway);
+}
+async function selectionOffStateDiff(client, gateway) {
+  const word = await client.getStorageAt({ address: gateway, slot: SELECTION_PARAMS_SLOT });
+  return {
+    slot: SELECTION_PARAMS_SLOT,
+    value: toHex3(hexToBigInt2(word ?? "0x0") & SOLVER_SELECTION_CLEARED, { size: 32 })
+  };
+}
 function userOperationLogs(logs, entryPoint, userOpHash) {
   const [beforeExecution, userOperationEvent] = ENTRY_POINT_EVENT_ABI.map((event) => toEventSelector2(event));
   const isBoundary = (log4) => log4.address.toLowerCase() === entryPoint.toLowerCase() && (log4.topics[0] === beforeExecution || log4.topics[0] === userOperationEvent);
@@ -235237,6 +235283,82 @@ function userOperationLogs(logs, entryPoint, userOpHash) {
   while (start >= 0 && !isBoundary(logs[start])) start--;
   return logs.slice(start + 1, end);
 }
+async function rundlerRequest(bundlerUrl, method, unsupported) {
+  if (unsupported.has(bundlerUrl)) return null;
+  try {
+    const response = await fetch(bundlerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params: [] })
+    });
+    const { result, error } = await response.json();
+    if (error) {
+      if (error.code !== void 0 && UNSUPPORTED_REQUEST_CODES.has(error.code)) {
+        unsupported.add(bundlerUrl);
+      }
+      return null;
+    }
+    return result ?? null;
+  } catch {
+    return null;
+  }
+}
+async function fetchRundlerPriorityFee(bundlerUrl) {
+  const result = await rundlerRequest(
+    bundlerUrl,
+    BundlerMethod.RUNDLER_MAX_PRIORITY_FEE_PER_GAS,
+    bundlersWithoutRundlerFees
+  );
+  try {
+    return result == null ? null : BigInt(result);
+  } catch {
+    return null;
+  }
+}
+async function fetchRundlerSuggestedFees(bundlerUrl) {
+  const result = await rundlerRequest(
+    bundlerUrl,
+    BundlerMethod.RUNDLER_GET_USER_OPERATION_GAS_PRICE,
+    bundlersWithoutRundlerGasPrice
+  );
+  const suggested = result?.suggested;
+  if (suggested?.maxFeePerGas == null || suggested.maxPriorityFeePerGas == null) return null;
+  try {
+    return {
+      maxFeePerGas: BigInt(suggested.maxFeePerGas),
+      maxPriorityFeePerGas: BigInt(suggested.maxPriorityFeePerGas)
+    };
+  } catch {
+    return null;
+  }
+}
+async function rundlerUserOperationFees(bundlerUrl, fees4, params) {
+  const { baseFeePerGas, priorityFeeBumpPercent, maxFeeBumpPercent } = params;
+  const suggested = await fetchRundlerSuggestedFees(bundlerUrl);
+  if (suggested) {
+    return {
+      maxFeePerGas: suggested.maxFeePerGas + suggested.maxFeePerGas * maxFeeBumpPercent / 100n,
+      maxPriorityFeePerGas: suggested.maxPriorityFeePerGas + suggested.maxPriorityFeePerGas * priorityFeeBumpPercent / 100n
+    };
+  }
+  const rundlerPriorityFee = await fetchRundlerPriorityFee(bundlerUrl);
+  if (rundlerPriorityFee === null) return fees4;
+  return applyRundlerPriorityFee(fees4, {
+    rundlerPriorityFee,
+    baseFeePerGas,
+    priorityFeeBumpPercent,
+    maxFeeBumpPercent
+  });
+}
+function applyRundlerPriorityFee(fees4, params) {
+  const { rundlerPriorityFee, baseFeePerGas, priorityFeeBumpPercent, maxFeeBumpPercent } = params;
+  const priorityFloor = rundlerPriorityFee + rundlerPriorityFee * priorityFeeBumpPercent / 100n;
+  const maxFeeFloor = baseFeePerGas + baseFeePerGas * maxFeeBumpPercent / 100n + priorityFloor;
+  return {
+    maxPriorityFeePerGas: fees4.maxPriorityFeePerGas > priorityFloor ? fees4.maxPriorityFeePerGas : priorityFloor,
+    maxFeePerGas: fees4.maxFeePerGas > maxFeeFloor ? fees4.maxFeePerGas : maxFeeFloor
+  };
+}
 function escrowSlot(commitment, leg) {
   const byCommitment = keccak2563(
     encodeAbiParameters2([{ type: "bytes32" }, { type: "uint256" }], [commitment, ESCROW_MAPPING_SLOT])
@@ -235422,7 +235544,7 @@ function encodePhantomBidDeclaration(declaration) {
   }
   return u8aToHex(new Uint8Array(bytes5));
 }
-var import_merge_race, __defProp3, __getOwnPropNames2, __esm2, __export2, node_exports, wasm, full_path, __dirname$1, cachedTextDecoder, cachedUint8ArrayMemory0, WASM_VECTOR_LEN, cachedTextEncoder, encodeString5, cachedDataViewMemory0, KeccakMergeFinalization, KeccakMerge, wasmPath, wasmBytes2, bindings, wasmModule, wasmInstance, __wasm, init_node11, RequestStatus, TimeoutStatus, IntentOrderStatus, ABI, evmHost_default, ABI2, handlerV2_default, polkadotAssetHubPaseo, polkadotHubMainnet, pharosMainnet, pharosAtlantic, tronNile, chainConfigs, configsByStateMachineId, getConfigByStateMachineId, getChainId3, getViemChain, hyperbridgeAddress, ABI3, IntentGatewayV2_default, ChainConfigService, ABI4, uniswapRouterV2_default, chains, DEFAULT_ADDRESS, EvmChain, REQUEST_COMMITMENTS_SLOT, RESPONSE_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, STATE_COMMITMENTS_SLOT, MISSING_CONSENSUS_UPDATE_TIME_MESSAGE, MissingConsensusUpdateTimeError, TokenBucket, BATCHES_NOT_SUPPORTED_CODE, TOO_BIG_BATCH_REQUEST_CODE, DEFAULT_MAX_BATCH_SIZE, _endpoint2, _headers3, _limiter, _maxBatchSize, _batchingSupported, _pending2, _flushTimer, _flushing, _nextId, __BatchingHttpProvider_instances, scheduleFlush_fn, flushNow_fn, flush_fn, post_fn, settleBatch_fn, settle_fn, handleBatchRefusal_fn, requeue_fn, _a5, BatchingHttpProvider, OFFCHAIN_BID_PREFIX, HYPERBRIDGE_TYPES_BUNDLE, BASE_TIP, HTTP_CONNECT_TIMEOUT_MS, INCLUSION_TIMEOUT_MS, DEFAULT_RPC_MAX_RPS, rpcLimiters, BidCodec, PackedUserOperationCodec, IntentsCoprocessor, ReviveContractInfo, ReviveAccountType, ReviveAccountInfo, H256, EvmStateProof, SubstrateHashing, SubstrateStateMachineProof, BasicProof, LeafIndexAndPos, MmrProof, ConsensusStateId, ConsensusMessage, FraudProofMessage, StateMachine, StateMachineId, StateMachineHeight, Proof, PostRequest, PostResponse, GetRequest, StorageValue, GetResponse, Request3, Response2, RequestMessage, RequestResponse, ResponseMessage, TimeoutMessage, GetRequestsWithProof, Message, DEFAULT_CHILD_STORAGE_PREFIX, PharosProofNodeCodec, SiblingLeftmostLeafProofCodec, NonExistenceProofCodec, AccountProofDataCodec, PharosStateProof, DEFAULT_POLL_INTERVAL, ADDRESS_ZERO2, DEFAULT_GRAFFITI, DEFAULT_LOGGER, REQUEST_STATUS_WEIGHTS, TIMEOUT_STATUS_WEIGHTS, COMBINED_STATUS_WEIGHTS, CHAIN_ID_TO_COINGECKO_NATIVE, TESTNET_CHAINS, ORDER_STATUS, loadDriver, detectEnvironment, STORAGE_KEYS, LEGACY_STORAGE_KEYS, ABI5, uniswapV3Quoter_default, UNISWAP_V4_QUOTER_ABI, ABI6, universalRouter_default, PERMIT2_ABI, UniswapQuoteEngine, COMMON_FEE_TIERS, Swap, ABI7, erc7281_default, DEFAULT_GRAFFITI2, ERC7821_BATCH_MODE, BundlerMethod, SELECT_SOLVER_TYPEHASH, PACKED_USEROP_TYPEHASH, DOMAIN_TYPEHASH, CryptoUtils, FEE_TOKEN_CACHE_TTL_MS, OrderPlacer, TOKEN_KEYED_GATEWAY_ABI, keyingByClient, PARTIAL_FILLS_SLOT, USED_USEROPS_STORAGE_KEY, OrderExecutor, _a6, OrderCanceller, FILL_ORDER_SELECTOR, SUPPORTED_INTENTS_VERSION, CONTRACT_VERSION_ABI, CANONICAL_EVM_TOKEN, ENTRY_POINT_EVENT_ABI, BidImpl, BidManager, RELAYER_MESSAGE_GAS, NO_BUNDLER_FILL_GAS_BASE, NO_BUNDLER_FILL_GAS_PER_OUTPUT, NO_BUNDLER_PAYMASTER_VERIFICATION_GAS, NO_BUNDLER_PAYMASTER_POST_OP_GAS, BID_PVG_ESTIMATION_ACCOUNT_CODE, SELECTED_BID_SIGNATURE_BYTES, BID_PVG_HEADROOM_PERCENT, ESCROW_MAPPING_SLOT, GasEstimator, OrderStatusChecker, ORDERBOOK_URLS, ORDERBOOK_DECIMALS, ORDERBOOK_SCALE, OrderbookRequestError, RATE_FIELDS, TOP_OF_BOOK_QUERY, ROUTE_LIQUIDITY_QUERY, QUOTE_QUERY, QUOTE_PESSIMISTIC_QUERY, HyperFxOrderbook, UnsupportedLiquidityAssetError, UnsupportedLiquidityChainError, OrderbookQuoteNotConvergedError, MAX_EXACT_OUTPUT_ROUNDS, OrderbookMarket, ETHEREUM_ORDER_FEE_GAS_PRICE_BUMP_PERCENT, DEFAULT_ORDER_FEE_GAS_PRICE_BUMP_PERCENT, IntentGateway, DECLARATION_V1, DECLARATION_V2, PAYMASTER_ADDRESS_BYTES, PAYMASTER_GAS_LIMIT_BYTES, PAYMASTER_DATA_OFFSET, PERMIT2_DATA_BYTES, PERMIT2_SPONSORSHIP_BYTES, MAX_DECLARED_ENTRIES, MAX_TOKEN_ID_BYTES, TeleportParams, MultiAccount;
+var import_merge_race, __defProp3, __getOwnPropNames2, __esm2, __export2, node_exports, wasm, full_path, __dirname$1, cachedTextDecoder, cachedUint8ArrayMemory0, WASM_VECTOR_LEN, cachedTextEncoder, encodeString5, cachedDataViewMemory0, KeccakMergeFinalization, KeccakMerge, wasmPath, wasmBytes2, bindings, wasmModule, wasmInstance, __wasm, init_node11, RequestStatus, TimeoutStatus, IntentOrderStatus, ABI, evmHost_default, ABI2, handlerV2_default, polkadotAssetHubPaseo, polkadotHubMainnet, pharosMainnet, pharosAtlantic, tronNile, ENTRY_POINT_V08, ENTRY_POINT_V09, KNOWN_ENTRY_POINTS, chainConfigs, configsByStateMachineId, getConfigByStateMachineId, getChainId3, getViemChain, hyperbridgeAddress, ABI3, IntentGatewayV2_default, ChainConfigService, ABI4, uniswapRouterV2_default, chains, DEFAULT_ADDRESS, EvmChain, REQUEST_COMMITMENTS_SLOT, RESPONSE_COMMITMENTS_SLOT, REQUEST_RECEIPTS_SLOT, STATE_COMMITMENTS_SLOT, MISSING_CONSENSUS_UPDATE_TIME_MESSAGE, MissingConsensusUpdateTimeError, TokenBucket, BATCHES_NOT_SUPPORTED_CODE, TOO_BIG_BATCH_REQUEST_CODE, DEFAULT_MAX_BATCH_SIZE, _endpoint2, _headers3, _limiter, _maxBatchSize, _batchingSupported, _pending2, _flushTimer, _flushing, _nextId, __BatchingHttpProvider_instances, scheduleFlush_fn, flushNow_fn, flush_fn, post_fn, settleBatch_fn, settle_fn, handleBatchRefusal_fn, requeue_fn, _a5, BatchingHttpProvider, OFFCHAIN_BID_PREFIX, HYPERBRIDGE_TYPES_BUNDLE, BASE_TIP, HTTP_CONNECT_TIMEOUT_MS, INCLUSION_TIMEOUT_MS, DEFAULT_RPC_MAX_RPS, rpcLimiters, BidCodec, PackedUserOperationCodec, IntentsCoprocessor, ReviveContractInfo, ReviveAccountType, ReviveAccountInfo, H256, EvmStateProof, SubstrateHashing, SubstrateStateMachineProof, BasicProof, LeafIndexAndPos, MmrProof, ConsensusStateId, ConsensusMessage, FraudProofMessage, StateMachine, StateMachineId, StateMachineHeight, Proof, PostRequest, PostResponse, GetRequest, StorageValue, GetResponse, Request3, Response2, RequestMessage, RequestResponse, ResponseMessage, TimeoutMessage, GetRequestsWithProof, Message, DEFAULT_CHILD_STORAGE_PREFIX, PharosProofNodeCodec, SiblingLeftmostLeafProofCodec, NonExistenceProofCodec, AccountProofDataCodec, PharosStateProof, DEFAULT_POLL_INTERVAL, ADDRESS_ZERO2, DEFAULT_GRAFFITI, DEFAULT_LOGGER, REQUEST_STATUS_WEIGHTS, TIMEOUT_STATUS_WEIGHTS, COMBINED_STATUS_WEIGHTS, CHAIN_ID_TO_COINGECKO_NATIVE, TESTNET_CHAINS, ORDER_STATUS, loadDriver, detectEnvironment, STORAGE_KEYS, LEGACY_STORAGE_KEYS, ABI5, uniswapV3Quoter_default, UNISWAP_V4_QUOTER_ABI, ABI6, universalRouter_default, PERMIT2_ABI, UniswapQuoteEngine, COMMON_FEE_TIERS, Swap, ABI7, erc7281_default, DEFAULT_GRAFFITI2, ERC7821_BATCH_MODE, BundlerMethod, SELECT_SOLVER_TYPEHASH, LEGACY_SELECT_SOLVER_TYPEHASH, PACKED_USEROP_TYPEHASH, DOMAIN_TYPEHASH, CryptoUtils, FEE_TOKEN_CACHE_TTL_MS, OrderPlacer, TOKEN_KEYED_GATEWAY_ABI, keyingByClient, PARTIAL_FILLS_SLOT, USED_USEROPS_STORAGE_KEY, OrderExecutor, _a6, OrderCanceller, FILL_ORDER_SELECTOR, SUPPORTED_INTENTS_VERSION, TESTNET_INTENTS_VERSIONS, CONTRACT_VERSION_ABI, CANONICAL_EVM_TOKEN, formats, SELECTION_PARAMS_SLOT, SOLVER_SELECTION_CLEARED, SELECTION_FORMAT_BY_ENTRY_POINT, ENTRY_POINT_EVENT_ABI, BidImpl, BidManager, UNSUPPORTED_REQUEST_CODES, bundlersWithoutRundlerFees, bundlersWithoutRundlerGasPrice, RELAYER_MESSAGE_GAS, NO_BUNDLER_FILL_GAS_BASE, NO_BUNDLER_FILL_GAS_PER_OUTPUT, NO_BUNDLER_PAYMASTER_VERIFICATION_GAS, NO_BUNDLER_PAYMASTER_POST_OP_GAS, BID_PVG_ESTIMATION_ACCOUNT_CODE, BID_PVG_ESTIMATION_PAYMASTER_CODE, SELECTED_BID_SIGNATURE_BYTES, BID_PVG_HEADROOM_PERCENT, ESCROW_MAPPING_SLOT, GasEstimator, OrderStatusChecker, ORDERBOOK_URLS, ORDERBOOK_DECIMALS, ORDERBOOK_SCALE, OrderbookRequestError, RATE_FIELDS, TOP_OF_BOOK_QUERY, ROUTE_LIQUIDITY_QUERY, QUOTE_QUERY, QUOTE_PESSIMISTIC_QUERY, HyperFxOrderbook, UnsupportedLiquidityAssetError, UnsupportedLiquidityChainError, OrderbookQuoteNotConvergedError, MAX_EXACT_OUTPUT_ROUNDS, OrderbookMarket, ETHEREUM_ORDER_FEE_GAS_PRICE_BUMP_PERCENT, DEFAULT_ORDER_FEE_GAS_PRICE_BUMP_PERCENT, IntentGateway, DECLARATION_V1, DECLARATION_V2, PAYMASTER_ADDRESS_BYTES, PAYMASTER_GAS_LIMIT_BYTES, PAYMASTER_DATA_OFFSET, PERMIT2_DATA_BYTES, PERMIT2_SPONSORSHIP_BYTES, MAX_DECLARED_ENTRIES, MAX_TOKEN_ID_BYTES, TeleportParams, MultiAccount;
 var init_node10 = __esm({
   "../sdk/dist/node/index.js"() {
     "use strict";
@@ -237775,6 +237897,9 @@ var init_node10 = __esm({
         default: { name: "Nile Tronscan", url: "https://nile.tronscan.org" }
       }
     });
+    ENTRY_POINT_V08 = "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108";
+    ENTRY_POINT_V09 = "0x433709009B8330FDa32311DF1C2AFA402eD8D009";
+    KNOWN_ENTRY_POINTS = [ENTRY_POINT_V09, ENTRY_POINT_V08];
     chainConfigs = {
       97: {
         chainId: 97,
@@ -237807,11 +237932,14 @@ var init_node10 = __esm({
           UniversalRouter: "0xcc6d5ece3d4a57245bf5a2f64f3ed9179b81f714",
           UniswapV3Quoter: "0x0000000000000000000000000000000000000000",
           UniswapV4Quoter: "0x0000000000000000000000000000000000000000",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
-          SolverAccount: "0xf98E484858F59C30e31D2695ac18F92bc7C7b799"
+          Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+          EntryPoint: "0x433709009B8330FDa32311DF1C2AFA402eD8D009",
+          SolverAccount: "0x7484C6Ff790b898bf7e6960Ffc82f63330445Dc2",
+          SimplexPaymaster: "0x9f4a6F1254f27373C2aca5bDd0e48FbA45EA3aeC"
         },
         rpcEnvKey: "BSC_CHAPEL",
         defaultRpcUrl: "https://bnb-testnet.api.onfinality.io/public",
+        bundlerUrl: "https://bundler.polytope.technology/bsc-chapel",
         consensusStateId: "BSC0",
         coingeckoId: "binance-smart-chain",
         popularTokens: [
@@ -237843,7 +237971,7 @@ var init_node10 = __esm({
           UniswapRouter02: "0x0000000000000000000000000000000000000000",
           UniswapV2Factory: "0x0000000000000000000000000000000000000000",
           UniswapV3Factory: "0x0000000000000000000000000000000000000000",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
         },
         rpcEnvKey: "GNOSIS_CHIADO",
         defaultRpcUrl: "https://gnosis-chiado-rpc.publicnode.com",
@@ -237883,7 +238011,7 @@ var init_node10 = __esm({
           UniswapV2Factory: "0x0000000000000000000000000000000000000000",
           UniswapV3Factory: "0x0000000000000000000000000000000000000000",
           Calldispatcher: "0xC7f13b6D03A0A7F3239d38897503E90553ABe155",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
         },
         rpcEnvKey: "SEPOLIA",
         defaultRpcUrl: "https://1rpc.io/sepolia",
@@ -237934,7 +238062,7 @@ var init_node10 = __esm({
         },
         addresses: {
           IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-          SolverAccount: "0x77c3394CA5881A74f18139AC87D0c11F8Faa90cC",
+          SolverAccount: "0xaAd062555800a97Af062795189e32a3CBd045612",
           TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
           Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
           UniswapRouter02: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
@@ -237948,13 +238076,14 @@ var init_node10 = __esm({
           UniswapV4StateView: "0x7ffe42c4a5deea5b0fec41c94c136cf115597227",
           Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x433709009B8330FDa32311DF1C2AFA402eD8D009",
           CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
           SimplexPaymaster: "0xD4340d7466e040626383cb9cda9307ba8E081149",
           Usdt0Oft: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee"
         },
         rpcEnvKey: "ETH_MAINNET",
         defaultRpcUrl: "https://eth-mainnet.g.alchemy.com/v2/demo",
+        bundlerUrl: "https://bundler.polytope.technology/ethereum",
         consensusStateId: "ETH0",
         coingeckoId: "ethereum",
         layerZeroEid: 30101,
@@ -237980,7 +238109,8 @@ var init_node10 = __esm({
           USDC: "0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d",
           USDT: "0x55d398326f99059ff775485246999027b3197955",
           EXT: "0x7C8c11ADb8EF7cd3CFa718008Ea048445C6E7209",
-          cNGN: "0xa8AEA66B361a8d53e8865c62D142167Af28Af058"
+          cNGN: "0xa8AEA66B361a8d53e8865c62D142167Af28Af058",
+          BRIDGE: "0x5b0c50fDd52ECC0d4c682c441eaBaD41FfDEABBB"
         },
         tokenDecimals: {
           USDC: 18,
@@ -237989,19 +238119,21 @@ var init_node10 = __esm({
           // Binance-pegged stables above. Every phantom standard_amount and pool rate divides
           // by this, so the divergence from its neighbours here is load-bearing, not a typo.
           cNGN: 6,
-          EXT: 18
+          EXT: 18,
+          BRIDGE: 18
         },
         tokenStorageSlots: {
           USDT: { balanceSlot: 1, allowanceSlot: 2 },
           USDC: { balanceSlot: 1, allowanceSlot: 2 },
           WETH: { balanceSlot: 3, allowanceSlot: 4 },
           DAI: { balanceSlot: 0, allowanceSlot: 0 },
-          cNGN: { balanceSlot: 201, allowanceSlot: 202 }
+          cNGN: { balanceSlot: 201, allowanceSlot: 202 },
           // custom upgradeable layout, as on Base
+          BRIDGE: { balanceSlot: 0, allowanceSlot: 1 }
         },
         addresses: {
           IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-          SolverAccount: "0x77c3394CA5881A74f18139AC87D0c11F8Faa90cC",
+          SolverAccount: "0xaAd062555800a97Af062795189e32a3CBd045612",
           TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
           Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
           UniswapRouter02: "0x10ED43C718714eb63d5aA57B78B54704E256024E",
@@ -238015,12 +238147,13 @@ var init_node10 = __esm({
           UniswapV4StateView: "0xd13dd3d6e93f276fafc9db9e6bb47c1180aee0c4",
           Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x433709009B8330FDa32311DF1C2AFA402eD8D009",
           SimplexPaymaster: "0xeD02f9f0df8F562B89cC5b25867Ad3C2d61252A9"
           // "Usdt0Oft": Not available on BSC
         },
         rpcEnvKey: "BSC_MAINNET",
         defaultRpcUrl: "https://bsc-rpc.publicnode.com",
+        bundlerUrl: "https://bundler.polytope.technology/bsc",
         consensusStateId: "BSC0",
         coingeckoId: "binance-smart-chain",
         erc4626Vaults: [
@@ -238062,7 +238195,7 @@ var init_node10 = __esm({
         },
         addresses: {
           IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-          SolverAccount: "0x77c3394CA5881A74f18139AC87D0c11F8Faa90cC",
+          SolverAccount: "0xaAd062555800a97Af062795189e32a3CBd045612",
           TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
           Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
           UniswapRouter02: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
@@ -238076,13 +238209,14 @@ var init_node10 = __esm({
           UniswapV4StateView: "0x76fd297e2d437cd7f76d50f01afe6160f86e9990",
           Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x433709009B8330FDa32311DF1C2AFA402eD8D009",
           CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
           SimplexPaymaster: "0x7281Bccb4f0BCE44F3B8542d1fC5e51c2F5fC08C",
           Usdt0Oft: "0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92"
         },
         rpcEnvKey: "ARBITRUM_MAINNET",
         defaultRpcUrl: "https://arbitrum-one.public.blastapi.io",
+        bundlerUrl: "https://bundler.polytope.technology/arbitrum",
         consensusStateId: "ETH0",
         coingeckoId: "arbitrum-one",
         layerZeroEid: 30110,
@@ -238136,7 +238270,7 @@ var init_node10 = __esm({
         },
         addresses: {
           IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-          SolverAccount: "0x77c3394CA5881A74f18139AC87D0c11F8Faa90cC",
+          SolverAccount: "0xaAd062555800a97Af062795189e32a3CBd045612",
           TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
           Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
           UniswapRouter02: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
@@ -238147,7 +238281,7 @@ var init_node10 = __esm({
           UniswapV4Quoter: "0x0d5e0f971ed27fbff6c2837bf31316121532048d",
           Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x433709009B8330FDa32311DF1C2AFA402eD8D009",
           CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
           SimplexPaymaster: "0x15b3B03C870c7ef252029c35A12d3b339F5c8d7f",
           AerodromeRouter: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
@@ -238158,6 +238292,7 @@ var init_node10 = __esm({
         },
         rpcEnvKey: "BASE_MAINNET",
         defaultRpcUrl: "https://base-mainnet.public.blastapi.io",
+        bundlerUrl: "https://bundler.polytope.technology/base",
         consensusStateId: "ETH0",
         coingeckoId: "base",
         layerZeroEid: 30184,
@@ -238186,7 +238321,8 @@ var init_node10 = __esm({
           cNGN: "0x52828daa48C1a9A06F37500882b42daf0bE04C3B",
           ZARP: "0xb755506531786C8aC63B756BaB1ac387bACB0C04",
           XSGD: "0xDC3326e71D45186F113a2F448984CA0e8D201995",
-          USDR: "0x3B5F2810fB2168FfA9C73160F97BF9f2461fFa5c"
+          USDR: "0x3B5F2810fB2168FfA9C73160F97BF9f2461fFa5c",
+          BRIDGE: "0x5b0c50fDd52ECC0d4c682c441eaBaD41FfDEABBB"
         },
         tokenDecimals: {
           USDC: 6,
@@ -238195,7 +238331,8 @@ var init_node10 = __esm({
           cNGN: 6,
           ZARP: 18,
           XSGD: 6,
-          USDR: 6
+          USDR: 6,
+          BRIDGE: 18
         },
         tokenStorageSlots: {
           USDT: { balanceSlot: 0, allowanceSlot: 1 },
@@ -238206,11 +238343,12 @@ var init_node10 = __esm({
           // custom upgradeable layout
           ZARP: { balanceSlot: 51, allowanceSlot: 52 },
           XSGD: { balanceSlot: 7, allowanceSlot: 8 },
-          USDR: { balanceSlot: 51, allowanceSlot: 52 }
+          USDR: { balanceSlot: 51, allowanceSlot: 52 },
+          BRIDGE: { balanceSlot: 0, allowanceSlot: 1 }
         },
         addresses: {
           IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-          SolverAccount: "0x77c3394CA5881A74f18139AC87D0c11F8Faa90cC",
+          SolverAccount: "0xaAd062555800a97Af062795189e32a3CBd045612",
           TokenGateway: "0x8b536105b6Fae2aE9199f5146D3C57Dfe53b614E",
           Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
           UniswapRouter02: "0xd2f9496824951D5237cC71245D659E48d0d5f9E8",
@@ -238224,13 +238362,14 @@ var init_node10 = __esm({
           UniswapV4StateView: "0x5ea1bd7974c8a611cbab0bdcafcb1d9cc9b3ba5a",
           Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x433709009B8330FDa32311DF1C2AFA402eD8D009",
           CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
           SimplexPaymaster: "0xe99acFe0f5fC4C8ea54A187D8D3b05f136150095",
           Usdt0Oft: "0x6BA10300f0DC58B7a1e4c0e41f5daBb7D7829e13"
         },
         rpcEnvKey: "POLYGON_MAINNET",
         defaultRpcUrl: "https://polygon-bor-rpc.publicnode.com",
+        bundlerUrl: "https://bundler.polytope.technology/polygon",
         consensusStateId: "POLY",
         coingeckoId: "polygon-pos",
         layerZeroEid: 30109,
@@ -238303,11 +238442,13 @@ var init_node10 = __esm({
           Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
           Calldispatcher: "0x876F1891982E260026630c233A4897160A281Fb8",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
-          SolverAccount: "0xf98E484858F59C30e31D2695ac18F92bc7C7b799"
+          EntryPoint: "0x433709009B8330FDa32311DF1C2AFA402eD8D009",
+          SolverAccount: "0x7484C6Ff790b898bf7e6960Ffc82f63330445Dc2",
+          SimplexPaymaster: "0x6085a14078B7d26259145a894140f7C8361e02ae"
         },
         rpcEnvKey: "POLYGON_AMOY",
         defaultRpcUrl: "https://rpc-amoy.polygon.technology",
+        bundlerUrl: "https://bundler.polytope.technology/polygon-amoy",
         consensusStateId: "POLY",
         coingeckoId: "polygon-pos"
       },
@@ -238336,7 +238477,7 @@ var init_node10 = __esm({
           UniswapV3Factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
           Calldispatcher: "0xC71251c8b3e7B02697A84363Eef6DcE8DfBdF333",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
           CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
           UniswapV4PositionManager: "0x3c3ea4b57a46241e54610e5f022e5c45859a1017",
           UniswapV4PoolManager: "0x9a13f98cb987694c9f086b1f5eb990eea8264ec3"
@@ -238370,7 +238511,7 @@ var init_node10 = __esm({
           // Mocked
           UniswapV2Factory: "0x0000000000000000000000000000000000000000",
           Calldispatcher: "0xC71251c8b3e7B02697A84363Eef6DcE8DfBdF333",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
         },
         defaultRpcUrl: "https://rpc.gnosischain.com",
         consensusStateId: "GNO0",
@@ -238395,7 +238536,7 @@ var init_node10 = __esm({
         addresses: {
           TokenGateway: "0xCe304770236f39F9911BfCC51afBdfF3b8635718",
           Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
           UniswapV4PositionManager: "0x1b35d13a2e2528f192637f14b05f0dc0e7deb566",
           UniswapV4PoolManager: "0x360e68faccca8ca495c1b759fd9eee466db9fb32"
         },
@@ -238421,7 +238562,7 @@ var init_node10 = __esm({
         addresses: {
           TokenGateway: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
           Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
         },
         defaultRpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
         consensusStateId: "ETH0",
@@ -238445,7 +238586,7 @@ var init_node10 = __esm({
         addresses: {
           TokenGateway: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
           Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
         },
         defaultRpcUrl: "https://sepolia.optimism.io",
         consensusStateId: "ETH0",
@@ -238469,7 +238610,7 @@ var init_node10 = __esm({
         addresses: {
           TokenGateway: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
           Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
         },
         defaultRpcUrl: "https://sepolia.base.org",
         consensusStateId: "ETH0",
@@ -238495,7 +238636,7 @@ var init_node10 = __esm({
           IntentGateway: "0x606ba811aa6cb424ce2108e8977c5284686f0d1f",
           TokenGateway: "0x1c1e5be83df4a54c7a2230c337e4a3e8b7354b1c",
           Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
         },
         defaultRpcUrl: "https://testnet-asset-hub-eth-rpc.polkadot.io",
         consensusStateId: "PAS0",
@@ -238519,7 +238660,7 @@ var init_node10 = __esm({
         },
         addresses: {
           IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-          SolverAccount: "0x77c3394CA5881A74f18139AC87D0c11F8Faa90cC",
+          SolverAccount: "0xaAd062555800a97Af062795189e32a3CBd045612",
           Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
           Calldispatcher: "0xE2C7e576E26E0bE7aC97c6fE925bcDAbD87c4bEd"
         },
@@ -239924,9 +240065,9 @@ var init_node10 = __esm({
                 internalType: "bytes32"
               },
               {
-                name: "solver",
-                type: "address",
-                internalType: "address"
+                name: "userOpHash",
+                type: "bytes32",
+                internalType: "bytes32"
               },
               {
                 name: "signature",
@@ -240972,8 +241113,8 @@ var init_node10 = __esm({
       getPopularTokens(chain2) {
         return this.getConfig(chain2)?.popularTokens ?? [];
       }
-      getEntryPointV08Address(chain2) {
-        return this.getConfig(chain2)?.addresses.EntryPointV08;
+      getEntryPointAddress(chain2) {
+        return this.getConfig(chain2)?.addresses.EntryPoint;
       }
       getCirclePaymasterAddress(chain2) {
         return this.getConfig(chain2)?.addresses.CirclePaymaster;
@@ -242053,7 +242194,7 @@ var init_node10 = __esm({
        * This is the only public way to construct an `EvmChain` — the constructor is private.
        *
        * @param rpcUrl - HTTP(S) RPC URL of the EVM node
-       * @param bundlerUrl - Optional ERC-4337 bundler URL for account abstraction support
+       * @param bundlerUrl - Optional ERC-4337 bundler URL; defaults to Hyperbridge's bundler for the chain
        * @returns A fully initialised `EvmChain` ready for use
        * @throws If the chain ID returned by the RPC is not a known Hyperbridge deployment
        *
@@ -242079,8 +242220,12 @@ var init_node10 = __esm({
       get host() {
         return this.params.host;
       }
+      /**
+       * The bundler given to this chain, or else the one Hyperbridge runs for it.
+       * Undefined on a chain Hyperbridge runs no bundler for.
+       */
       get bundlerUrl() {
-        return this.params.bundlerUrl;
+        return this.params.bundlerUrl ?? chainConfigs[this.params.chainId]?.bundlerUrl;
       }
       get config() {
         return {
@@ -243235,6 +243380,9 @@ Failed HTTP Request: ${JSON.stringify(
        * fails on-chain, and a second `retractBid` that pulls the bid just placed. When the signed nonce
        * cannot be read, the stalled result is returned rather than guessed at.
        *
+       * A stall in `Future` first fills the missing nonce below it ({@link fillNonceGap}), so the
+       * replacement can land.
+       *
        * A rejection that bounced off a copy already pooled (1013/1014) is likewise left alone: that
        * copy is in flight and its outcome is unknown here, so the `pending` result goes back to the
        * caller to confirm later.
@@ -243259,6 +243407,7 @@ Failed HTTP Request: ${JSON.stringify(
               stalled = result;
               nonce ?? (nonce = this.signedNonce(extrinsic));
               if (nonce === void 0) return result;
+              if (result.future) await this.fillNonceGap(keyPair, nonce, timeoutMs);
               continue;
             }
             if (result.pending) return stalled ?? result;
@@ -243298,19 +243447,6 @@ Failed HTTP Request: ${JSON.stringify(
         const inFlight = code === 1013 || code === 1014 || /already imported|already in the pool|priority is too low/i.test(err.message);
         return { success: false, pending: inFlight || void 0, error: err.message };
       }
-      /**
-       * Sends an extrinsic with a timeout.
-       *
-       * A timeout is only a failure when the extrinsic never made it into the transaction pool.
-       * Once a pool-entry status (Future/Ready/Broadcast/Retracted) has been seen, the extrinsic is
-       * in flight and may well execute after the watch is abandoned — the result is then `pending`
-       * and `stalled`, telling the caller to replace it under the same nonce or confirm it later,
-       * never to re-sign the same call under a fresh one.
-       *
-       * `nonce` pins the submission to a specific account nonce, which is what makes a retry a pool
-       * replacement rather than a second extrinsic queued behind the first. Left undefined on the
-       * first attempt, where the api's auto-nonce is correct.
-       */
       /**
        * The nonce the next submission signs with, or undefined when the node cannot be asked.
        *
@@ -243327,6 +243463,7 @@ Failed HTTP Request: ${JSON.stringify(
        * queued as future, or simply not counted yet — is covered by `lastPooledNonce` instead, which
        * is the highest nonce this instance has put into the pool. The two are combined rather than
        * trusted separately, so a burst never reuses a nonce and a restart still picks up the chain's.
+       * A nonce left missing by an extrinsic the node dropped is filled by {@link fillNonceGap}.
        */
       async nextNonce(api) {
         try {
@@ -243340,11 +243477,53 @@ Failed HTTP Request: ${JSON.stringify(
           return void 0;
         }
       }
+      /**
+       * A stall in `Future` means the node is missing a lower nonce of this account's, one whose
+       * extrinsic it dropped, and everything signed above that nonce waits behind it. This fills the
+       * lowest missing nonce, which `system_accountNextIndex` reports on the same node, with a
+       * `system.remark` rather than the next call, so the calls already pooled above it land in the
+       * order they were signed. One nonce per stall; a further gap shows up as the next `Future` stall.
+       *
+       * The remark carries no tip, so on any node or pool view that still holds a live call of ours at
+       * that nonce, the call outranks it and the remark only ever fills a real gap.
+       *
+       * It runs inside the submission queue, so it submits directly rather than enqueueing, and gives
+       * up after `timeoutMs` so a silent socket cannot hold the queue. A failure or timeout is logged
+       * and left to the next stall.
+       */
+      async fillNonceGap(keyPair, nonce, timeoutMs) {
+        const fill = async () => {
+          const accountNextIndex = this.api.rpc?.system?.accountNextIndex;
+          if (!accountNextIndex) return;
+          const missing = Number((await accountNextIndex(keyPair.address)).toString());
+          if (!Number.isFinite(missing) || missing >= nonce) return;
+          await this.api.tx.system.remark("0x").signAndSend(keyPair, { tip: 0n, nonce: missing });
+        };
+        try {
+          await Promise.race([fill(), rejectAfter(timeoutMs, `Timed out after ${timeoutMs}ms`)]);
+        } catch (err) {
+          console.warn(`Could not fill the nonce gap below ${nonce}:`, err);
+        }
+      }
+      /**
+       * Sends an extrinsic with a timeout.
+       *
+       * A timeout is only a failure when the extrinsic never made it into the transaction pool.
+       * Once a pool-entry status (Future/Ready/Broadcast/Retracted) has been seen, the extrinsic is
+       * in flight and may well execute after the watch is abandoned — the result is then `pending`
+       * and `stalled`, telling the caller to replace it under the same nonce or confirm it later,
+       * never to re-sign the same call under a fresh one.
+       *
+       * `nonce` pins the submission to a specific account nonce, which is what makes a retry a pool
+       * replacement rather than a second extrinsic queued behind the first. Left undefined on the
+       * first attempt, where the api's auto-nonce is correct.
+       */
       async sendWithTimeout(extrinsic, keyPair, tip, timeoutMs, nonce) {
         return new Promise((resolve12) => {
           let resolved = false;
           let unsubscribe = null;
           let enteredPool = false;
+          let inFuture = false;
           const timeoutId = setTimeout(() => {
             if (!resolved) {
               resolved = true;
@@ -243355,6 +243534,7 @@ Failed HTTP Request: ${JSON.stringify(
                 success: false,
                 pending: enteredPool || void 0,
                 stalled: enteredPool || void 0,
+                future: enteredPool && inFuture || void 0,
                 extrinsicHash: enteredPool ? extrinsic.hash.toHex() : void 0,
                 error: `Transaction timed out after ${timeoutMs}ms${enteredPool ? " while in the transaction pool" : ""}`
               });
@@ -243364,6 +243544,7 @@ Failed HTTP Request: ${JSON.stringify(
             if (resolved) return;
             if (result.status.isFuture || result.status.isReady || result.status.isBroadcast || result.status.isRetracted) {
               enteredPool = true;
+              inFuture = result.status.isFuture;
             }
             if (result.dispatchError && (result.status.isInBlock || result.status.isFinalized)) {
               resolved = true;
@@ -246654,12 +246835,13 @@ query OrderStatus($commitment: String!) {
       ETH_GET_USER_OPERATION_RECEIPT: "eth_getUserOperationReceipt",
       /** Estimates gas limits for a UserOperation before submission. */
       ETH_ESTIMATE_USER_OPERATION_GAS: "eth_estimateUserOperationGas",
-      /** Pimlico-specific method to fetch recommended EIP-1559 gas prices for UserOperations. */
-      PIMLICO_GET_USER_OPERATION_GAS_PRICE: "pimlico_getUserOperationGasPrice",
-      /** Alchemy (Rundler) method to fetch recommended priority fee for UserOperations. */
-      RUNDLER_MAX_PRIORITY_FEE_PER_GAS: "rundler_maxPriorityFeePerGas"
+      /** Rundler method returning the priority fee it requires of UserOperations. */
+      RUNDLER_MAX_PRIORITY_FEE_PER_GAS: "rundler_maxPriorityFeePerGas",
+      /** Rundler method returning the fees it requires and suggests for UserOperations. */
+      RUNDLER_GET_USER_OPERATION_GAS_PRICE: "rundler_getUserOperationGasPrice"
     };
-    SELECT_SOLVER_TYPEHASH = keccak2563(toHex3("SelectSolver(bytes32 commitment,address solver)"));
+    SELECT_SOLVER_TYPEHASH = keccak2563(toHex3("SelectSolver(bytes32 commitment,bytes32 userOpHash)"));
+    LEGACY_SELECT_SOLVER_TYPEHASH = keccak2563(toHex3("SelectSolver(bytes32 commitment,address solver)"));
     PACKED_USEROP_TYPEHASH = keccak2563(
       toHex3(
         "PackedUserOperation(address sender,uint256 nonce,bytes initCode,bytes callData,bytes32 accountGasLimits,uint256 preVerificationGas,bytes32 gasFees,bytes paymasterAndData)"
@@ -246698,29 +246880,50 @@ query OrderStatus($commitment: String!) {
         );
       }
       /**
-       * Signs a `SelectSolver` EIP-712 message with a session key.
+       * Signs `SelectSolver(bytes32 commitment,bytes32 userOpHash)` with the
+       * order's session key, for gateways whose `SELECT_SOLVER_TYPEHASH` is
+       * {@link SELECT_SOLVER_TYPEHASH}.
        *
-       * The session key authorises the selection of a specific solver for the
-       * given order commitment. The resulting signature is appended to the
-       * solver's UserOperation signature before bundle submission.
+       * The signature selects one bid UserOperation for the order and is appended
+       * to that operation's signature before it is sent to the bundler.
        *
-       * @param commitment - The order commitment (bytes32) being fulfilled.
-       * @param solverAddress - Address of the solver account selected to fill the order.
-       * @param domainSeparator - EIP-712 domain separator for the IntentGatewayV2 contract.
-       * @param privateKey - Hex-encoded private key of the session key that signs the message.
-       * @returns The ECDSA signature as a hex string, or `null` if signing fails.
+       * @param commitment - The order commitment.
+       * @param userOpHash - EntryPoint userOpHash of the selected bid UserOperation.
+       * @param domainSeparator - EIP-712 domain separator of the IntentGatewayV2 contract.
+       * @param privateKey - Private key of the order's session key.
+       * @returns The 65-byte ECDSA signature.
        */
-      static async signSolverSelection(commitment, solverAddress, domainSeparator2, privateKey) {
-        const account5 = privateKeyToAccount(privateKey);
+      static async signUserOpHashSelection(commitment, userOpHash, domainSeparator2, privateKey) {
+        const structHash = keccak2563(
+          encodeAbiParameters2(
+            [{ type: "bytes32" }, { type: "bytes32" }, { type: "bytes32" }],
+            [SELECT_SOLVER_TYPEHASH, commitment, userOpHash]
+          )
+        );
+        return signTypedDigest(domainSeparator2, structHash, privateKey);
+      }
+      /**
+       * Signs `SelectSolver(bytes32 commitment,address solver)` with the order's
+       * session key, for gateways whose `SELECT_SOLVER_TYPEHASH` is
+       * {@link LEGACY_SELECT_SOLVER_TYPEHASH}.
+       *
+       * The signature selects a solver account for the order and is appended to
+       * that solver's bid UserOperation signature before it is sent to the bundler.
+       *
+       * @param commitment - The order commitment.
+       * @param solverAddress - Address of the selected solver account.
+       * @param domainSeparator - EIP-712 domain separator of the IntentGatewayV2 contract.
+       * @param privateKey - Private key of the order's session key.
+       * @returns The 65-byte ECDSA signature.
+       */
+      static async signLegacySolverSelection(commitment, solverAddress, domainSeparator2, privateKey) {
         const structHash = keccak2563(
           encodeAbiParameters2(
             [{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }],
-            [SELECT_SOLVER_TYPEHASH, commitment, solverAddress]
+            [LEGACY_SELECT_SOLVER_TYPEHASH, commitment, solverAddress]
           )
         );
-        const digest = keccak2563(concat3(["0x1901", domainSeparator2, structHash]));
-        const signature = await account5.sign({ hash: digest });
-        return signature;
+        return signTypedDigest(domainSeparator2, structHash, privateKey);
       }
       /**
        * Computes the EIP-712 hash of a `PackedUserOperation` as defined by
@@ -247247,16 +247450,13 @@ query OrderStatus($commitment: String!) {
       }
       /**
        * Creates a closure that computes the deduplication hash key for a
-       * UserOperation, pre-bound to the order's destination chain and entry point.
+       * UserOperation, pre-bound to the destination chain.
        */
-      createUserOpHasher(order) {
-        const entryPointAddress = this.ctx.dest.configService.getEntryPointV08Address(
-          normalizeStateMachineId(order.destination)
-        );
+      createUserOpHasher() {
         const chainId = BigInt(
           this.ctx.dest.client.chain?.id ?? Number.parseInt(this.ctx.dest.config.stateMachineId.split("-")[1])
         );
-        return (userOp) => CryptoUtils.computeUserOpHash(userOp, entryPointAddress, chainId);
+        return (userOp) => CryptoUtils.computeUserOpHash(userOp, ENTRY_POINT_V08, chainId);
       }
       /**
        * Fetches bids from the coprocessor for a given order commitment.
@@ -247372,7 +247572,7 @@ query OrderStatus($commitment: String!) {
           return;
         }
         const usedUserOps = await this.loadUsedUserOps(commitment);
-        const userOpHashKey = this.createUserOpHasher(order);
+        const userOpHashKey = this.createUserOpHasher();
         const targetAssets = order.output.assets.map((a6) => ({ token: a6.token, amount: a6.amount }));
         let initial;
         try {
@@ -248236,7 +248436,8 @@ query OrderStatus($commitment: String!) {
     }, __publicField(_a6, "DEFAULT_MAX_RECOVERY_RESTARTS", 1), __publicField(_a6, "PROOF_FRESHNESS_MAX_RETRIES", 3), __publicField(_a6, "PROOF_FRESHNESS_BACKOFF_MS", 500), /** Gas budgets used to price cancellation delivery on the source chain. */
     __publicField(_a6, "SOURCE_GET_RESPONSE_GAS", 1000000n), __publicField(_a6, "REFUND_POST_GAS", 1000000n), _a6);
     FILL_ORDER_SELECTOR = "0x68ddf058";
-    SUPPORTED_INTENTS_VERSION = 3n;
+    SUPPORTED_INTENTS_VERSION = 4n;
+    TESTNET_INTENTS_VERSIONS = [3n, SUPPORTED_INTENTS_VERSION];
     CONTRACT_VERSION_ABI = [
       {
         type: "function",
@@ -248247,6 +248448,13 @@ query OrderStatus($commitment: String!) {
       }
     ];
     CANONICAL_EVM_TOKEN = /^0x0{24}[0-9a-fA-F]{40}$/;
+    formats = /* @__PURE__ */ new Map();
+    SELECTION_PARAMS_SLOT = pad4(toHex3(5n), { size: 32 });
+    SOLVER_SELECTION_CLEARED = maxUint2563 ^ 0xffn << 160n;
+    SELECTION_FORMAT_BY_ENTRY_POINT = /* @__PURE__ */ new Map([
+      [ENTRY_POINT_V09.toLowerCase(), "userOpHash"],
+      [ENTRY_POINT_V08.toLowerCase(), "address"]
+    ]);
     ENTRY_POINT_EVENT_ABI = [
       { type: "event", name: "BeforeExecution", inputs: [] },
       {
@@ -248281,6 +248489,8 @@ query OrderStatus($commitment: String!) {
         __publicField(this, "domainSeparator");
         /** Cached session-key signature over the `SelectSolver` message. */
         __publicField(this, "cachedSignature");
+        /** Cached result of {@link route}. */
+        __publicField(this, "cachedRoute");
         this.ctx = params.ctx;
         this.crypto = params.crypto;
         this.order = params.order;
@@ -248310,69 +248520,117 @@ query OrderStatus($commitment: String!) {
         );
       }
       /**
-       * Resolves the session key, signs the `SelectSolver` message for this bid's
-       * solver, and caches the signature. Signs at most once per bid.
+       * Finds the EntryPoint this bid's solver signed it for and checks that the
+       * destination gateway's selection format pairs with it, reading the format
+       * again before refusing a bid in case the gateway was upgraded since it was
+       * cached. Caches the result.
+       *
+       * @throws If the solver's signature recovers under no known EntryPoint, the
+       *   EntryPoint does not pair with the gateway's selection format, or the
+       *   format cannot be read.
+       */
+      async route() {
+        if (this.cachedRoute) return this.cachedRoute;
+        const chainId = this.chainId();
+        let signed;
+        for (const entryPoint of KNOWN_ENTRY_POINTS) {
+          const userOpHash = CryptoUtils.computeUserOpHash(this.userOp, entryPoint, chainId);
+          if (await this.signedBySolver(userOpHash)) {
+            signed = { entryPoint, userOpHash };
+            break;
+          }
+        }
+        if (!signed) {
+          throw new Error(`Bid from solver=${this.solverAddress} is not signed for a known EntryPoint`);
+        }
+        const pairsWith = SELECTION_FORMAT_BY_ENTRY_POINT.get(signed.entryPoint.toLowerCase());
+        const cached = readSelectionFormat(this.ctx.dest.client, chainId, this.intentGatewayV2Address);
+        let format2 = await cached;
+        if (pairsWith !== format2) {
+          format2 = await refreshSelectionFormat(this.ctx.dest.client, chainId, this.intentGatewayV2Address, cached);
+        }
+        if (pairsWith !== format2) {
+          throw new Error(
+            `Bid from solver=${this.solverAddress} is signed for EntryPoint ${signed.entryPoint}, which the destination gateway's ${format2} selection does not pair with`
+          );
+        }
+        this.cachedRoute = { ...signed, format: format2 };
+        return this.cachedRoute;
+      }
+      /**
+       * Whether the solver's signature in the bid, `signature[32:97]` after the order
+       * commitment, recovers to the solver over `userOpHash`.
+       */
+      async signedBySolver(userOpHash) {
+        try {
+          const recovered = await recoverAddress3({
+            hash: userOpHash,
+            signature: slice4(this.userOp.signature, 32, 97)
+          });
+          return recovered.toLowerCase() === this.solverAddress.toLowerCase();
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Resolves the session key, signs the `SelectSolver` message for this bid in
+       * the destination gateway's selection format, and caches the signature. Signs
+       * at most once per bid.
        *
-       * @throws If the session key is missing or signing fails.
+       * @throws If the bid cannot be routed, or the session key is missing.
        */
       async signSelection() {
         if (this.cachedSignature) return this.cachedSignature;
+        const { format: format2, userOpHash } = await this.route();
         const commitment = this.order.id;
         const sessionKeyAddress = this.order.session;
         const sessionKeyData = this.sessionPrivateKey ? { privateKey: this.sessionPrivateKey } : await this.ctx.sessionKeyStorage.getSessionKeyByAddress(sessionKeyAddress);
         if (!sessionKeyData) {
           throw new Error(`SessionKey not found for commitment: ${commitment}`);
         }
-        const signature = await CryptoUtils.signSolverSelection(
+        this.cachedSignature = format2 === "userOpHash" ? await CryptoUtils.signUserOpHashSelection(
+          commitment,
+          userOpHash,
+          this.domainSeparator,
+          sessionKeyData.privateKey
+        ) : await CryptoUtils.signLegacySolverSelection(
           commitment,
           this.solverAddress,
           this.domainSeparator,
           sessionKeyData.privateKey
         );
-        if (!signature) {
-          throw new Error("Failed to sign solver selection");
-        }
-        this.cachedSignature = signature;
-        return signature;
+        return this.cachedSignature;
       }
       /**
-       * Simulates this bid on-chain by batching the `select` and `fillOrder` calls
-       * via `eth_call` from the solver's account, using the IntentGatewayV2 ERC-7821
-       * batch-execute pattern.
+       * Simulates this bid on-chain with an `eth_call` of its calldata from the
+       * solver's account, after checking that the bid can be routed.
+       *
+       * The gateway's solver selection is turned off for the call with
+       * {@link selectionOffStateDiff} and no `select` is made: a gateway that selects
+       * by userOpHash checks the selection against the EntryPoint's current
+       * operation, which only exists inside a bundle. The session's selection is
+       * therefore not part of the simulation.
        *
        * The native value forwarded to the simulation is the sum of any native-token
        * (`address(0)`) output amounts plus the Hyperbridge dispatch fee.
        *
-       * @throws If the `eth_call` simulation reverts or errors.
+       * @throws If the bid cannot be routed, or the `eth_call` simulation reverts or errors.
        */
       async simulate() {
-        const signature = await this.signSelection();
-        const selectOptions = {
-          commitment: this.order.id,
-          solver: this.solverAddress,
-          signature
-        };
+        await this.route();
         const nativeOutputs = this.fillOptions.outputs.reduce(
           (acc, o6) => bytes32ToBytes20(o6.token) === ADDRESS_ZERO2 ? acc + o6.amount : acc,
           0n
         );
         const simulationValue = nativeOutputs + this.fillOptions.nativeDispatchFee;
-        const selectCalldata = encodeFunctionData2({
-          abi: ABI3,
-          functionName: "select",
-          args: [selectOptions]
-        });
-        const calls = [
-          { target: this.intentGatewayV2Address, value: 0n, data: selectCalldata },
-          { target: this.solverAddress, value: simulationValue, data: this.userOp.callData }
-        ];
-        const batchedCalldata = this.crypto.encodeERC7821Execute(calls);
         try {
+          const selectionOff = await selectionOffStateDiff(this.ctx.dest.client, this.intentGatewayV2Address);
           await this.ctx.dest.client.call({
             account: this.solverAddress,
             to: this.solverAddress,
-            data: batchedCalldata,
-            value: simulationValue
+            data: this.userOp.callData,
+            value: simulationValue,
+            stateOverride: [{ address: this.intentGatewayV2Address, stateDiff: [selectionOff] }]
           });
         } catch (e4) {
           throw new Error(`Simulation failed: ${e4 instanceof Error ? e4.message : String(e4)}`);
@@ -248381,31 +248639,29 @@ query OrderStatus($commitment: String!) {
       /**
        * Signs the `SelectSolver` message with the session key, appends it to the
        * solver's existing UserOp signature, and submits the UserOperation to the
-       * bundler. Waits for the receipt and reads `OrderFilled` / `PartialFill`
-       * logs to determine fill status.
+       * bundler on the EntryPoint the bid was signed for. Waits for the receipt and
+       * reads `OrderFilled` / `PartialFill` logs to determine fill status.
        *
        * @returns A {@link SelectBidResult} with the submitted UserOperation, its hash,
        *   the solver address, transaction hash, and fill status.
-       * @throws If the bundler is not configured, the session key is missing, or the
-       *   bundler rejects the UserOperation.
+       * @throws If the bundler is not configured, the bid cannot be routed, the
+       *   session key is missing, or the bundler rejects the UserOperation.
        */
       async execute() {
         const commitment = this.order.id;
         if (!this.ctx.bundlerUrl) {
           throw new Error("Bundler URL not configured");
         }
+        const { entryPoint } = await this.route();
         const sessionSignature = await this.signSelection();
         const finalSignature = concat3([this.userOp.signature, sessionSignature]);
         const signedUserOp = {
           ...this.userOp,
           signature: finalSignature
         };
-        const entryPointAddress = this.ctx.dest.configService.getEntryPointV08Address(
-          normalizeStateMachineId(this.order.destination)
-        );
         const userOpHash = await this.crypto.sendBundler(BundlerMethod.ETH_SEND_USER_OPERATION, [
           CryptoUtils.prepareBundlerCall(signedUserOp),
-          entryPointAddress
+          entryPoint
         ]);
         let txnHash;
         let fillStatus;
@@ -248431,7 +248687,7 @@ query OrderStatus($commitment: String!) {
           );
           const fills = parseEventLogs2({
             abi: ABI3,
-            logs: userOperationLogs(chainReceipt.logs, entryPointAddress, userOpHash),
+            logs: userOperationLogs(chainReceipt.logs, entryPoint, userOpHash),
             eventName: ["OrderFilled", "PartialFill"]
           }).filter(
             (event) => event.address.toLowerCase() === gateway.toLowerCase() && event.args.commitment.toLowerCase() === commitment.toLowerCase()
@@ -248483,12 +248739,15 @@ query OrderStatus($commitment: String!) {
        * Constructs a signed `PackedUserOperation` that a solver can submit to the
        * Hyperbridge coprocessor as a bid to fill an order.
        *
-       * The solver signs the operation as EntryPoint v0.8 EIP-712 typed data,
-       * whose digest is the plain userOpHash. The binding to the order lives in
-       * the operation itself: the 4337 nonce key must be the lower 192 bits of
-       * the order commitment (`SolverAccount` enforces this during validation),
-       * and the callData carries the order. This keeps the signed payload fully
-       * transparent to signing infrastructure instead of an opaque digest.
+       * The solver signs the operation as EIP-712 typed data for
+       * `entryPointAddress`, whose digest is that EntryPoint's userOpHash. It must
+       * be the EntryPoint the solver's `SolverAccount` accepts: the user's SDK
+       * recovers it from this signature and executes the bid there. The binding
+       * to the order lives in the operation itself: the 4337 nonce key must derive
+       * from the order commitment, the session key and the calldata
+       * (`SolverAccount` enforces this during validation), and the callData
+       * carries the order. This keeps the signed payload fully transparent to
+       * signing infrastructure instead of an opaque digest.
        *
        * @param options - Parameters describing the solver account, gas limits, fee
        *   market values, and pre-built `callData` for the fill operation.
@@ -248521,7 +248780,7 @@ query OrderStatus($commitment: String!) {
         }
         const chain2 = normalizeStateMachineId(order.destination);
         const gateway = this.ctx.dest.configService.getIntentGatewayAddress(chain2);
-        if (!await supportsRateFills(this.ctx.dest.client, gateway)) {
+        if (!await supportsRateFills(this.ctx.dest.client, gateway, chain2)) {
           throw new Error("Fills are not supported by the destination gateway");
         }
         const chainId = BigInt(
@@ -248561,6 +248820,11 @@ query OrderStatus($commitment: String!) {
        * silently dropped with a warning. The returned `Bid` instances are ready to
        * be ranked, simulated, and executed by the consumer.
        *
+       * A bid signed for no known EntryPoint, or for one the destination gateway's
+       * selection format does not pair with, is kept here and fails
+       * {@link Bid.simulate} and {@link Bid.execute}, so {@link selectAndExecuteBest}
+       * skips it.
+       *
        * @param order - The placed order the bids are competing to fill.
        * @param bids - Raw filler bids fetched from the coprocessor.
        * @param sessionPrivateKey - Optional session-key override; looked up from
@@ -248853,12 +249117,16 @@ query OrderStatus($commitment: String!) {
         }
       }
     };
+    UNSUPPORTED_REQUEST_CODES = /* @__PURE__ */ new Set([-32600, -32601, -32602]);
+    bundlersWithoutRundlerFees = /* @__PURE__ */ new Set();
+    bundlersWithoutRundlerGasPrice = /* @__PURE__ */ new Set();
     RELAYER_MESSAGE_GAS = 1000000n;
     NO_BUNDLER_FILL_GAS_BASE = 700000n;
     NO_BUNDLER_FILL_GAS_PER_OUTPUT = 150000n;
     NO_BUNDLER_PAYMASTER_VERIFICATION_GAS = 250000n;
     NO_BUNDLER_PAYMASTER_POST_OP_GAS = 100000n;
     BID_PVG_ESTIMATION_ACCOUNT_CODE = "0x60003560e01c631626ba7e1460145760206000f35b631626ba7e60e01b60005260206000f3";
+    BID_PVG_ESTIMATION_PAYMASTER_CODE = "0x604060005260606000f3";
     SELECTED_BID_SIGNATURE_BYTES = 32 + 65 + 65;
     BID_PVG_HEADROOM_PERCENT = 10n;
     ESCROW_MAPPING_SLOT = 9n;
@@ -248872,8 +249140,6 @@ query OrderStatus($commitment: String!) {
       constructor(ctx, crypto10) {
         __publicField(this, "ctx");
         __publicField(this, "crypto");
-        /** Call dispatchers read from a gateway, for chains whose config carries none. */
-        __publicField(this, "dispatchers", /* @__PURE__ */ new Map());
         this.ctx = ctx;
         this.crypto = crypto10;
       }
@@ -248894,8 +249160,9 @@ query OrderStatus($commitment: String!) {
        * **Bundler path:** constructs a mock `PackedUserOperation` signed by an
        * ephemeral keypair, applies state overrides, and calls
        * `eth_estimateUserOperationGas`. Gas limits are bumped by 5-10% for
-       * headroom. If the bundler is Pimlico, gas prices are refined with
-       * `pimlico_getUserOperationGasPrice`. If the bundler rejects the estimate,
+       * headroom. Fees are the rundler bundler's suggested fees raised by the bumps,
+       * or the chain's gas price raised to the priority fee it requires where it
+       * suggests none (see {@link rundlerUserOperationFees}). If the bundler rejects the estimate,
        * fixed gas limits are returned in its place, or the call throws when
        * `params.requireBundlerEstimate` is set.
        *
@@ -248930,7 +249197,7 @@ query OrderStatus($commitment: String!) {
         const souceStateMachineId = isHex3(order.source) ? hexToString2(order.source) : order.source;
         const destStateMachineId = isHex3(order.destination) ? hexToString2(order.destination) : order.destination;
         const intentGatewayV2Address = this.ctx.dest.configService.getIntentGatewayAddress(destStateMachineId);
-        const entryPointAddress = this.ctx.dest.configService.getEntryPointV08Address(destStateMachineId);
+        const entryPointAddress = this.ctx.dest.configService.getEntryPointAddress(destStateMachineId);
         const chainId = BigInt(Number.parseInt(destStateMachineId.split("-")[1]));
         const totalEthValue = quotedOutputs.filter((output3) => bytes32ToBytes20(output3.token) === ADDRESS_ZERO2).reduce((sum2, output3) => sum2 + output3.amount, 0n);
         const [sourceFeeToken, destFeeToken, gasPrice, latestBlock] = await Promise.all([
@@ -248992,7 +249259,7 @@ query OrderStatus($commitment: String!) {
         const maxFeeBumpPercent = params.maxFeePerGasBumpPercent ?? 10;
         let maxPriorityFeePerGas = gasPrice + gasPrice * BigInt(priorityFeeBumpPercent) / 100n;
         let maxFeePerGas = gasPrice + gasPrice * BigInt(maxFeeBumpPercent) / 100n;
-        await assertGatewayRelease(this.ctx.dest.client, intentGatewayV2Address);
+        await assertGatewayRelease(this.ctx.dest.client, intentGatewayV2Address, destStateMachineId);
         const fillOrderCalldata = encodeFillOrder(transformOrderForContract(order), fillOptions);
         let callGasLimit = 500000n;
         let verificationGasLimit = 100000n;
@@ -249001,6 +249268,7 @@ query OrderStatus($commitment: String!) {
         let paymasterPostOpGasLimit = 0n;
         if (this.ctx.bundlerUrl) {
           try {
+            if (!entryPointAddress) throw new Error(`No EntryPoint configured for ${destStateMachineId}`);
             const callData = this.crypto.encodeERC7821Execute([
               ...params.prependCalls ?? [],
               { target: intentGatewayV2Address, value: totalNativeValue, data: fillOrderCalldata }
@@ -249033,7 +249301,13 @@ query OrderStatus($commitment: String!) {
               chainId,
               intentGatewayV2Address
             );
-            const sessionSignature = await CryptoUtils.signSolverSelection(
+            const selectionFormat = await readSelectionFormat(this.ctx.dest.client, chainId, intentGatewayV2Address);
+            const sessionSignature = selectionFormat === "userOpHash" ? await CryptoUtils.signUserOpHashSelection(
+              commitment,
+              userOpHash,
+              domainSeparator2,
+              solverPrivateKey
+            ) : await CryptoUtils.signLegacySolverSelection(
               commitment,
               solverAccountAddress,
               domainSeparator2,
@@ -249044,45 +249318,19 @@ query OrderStatus($commitment: String!) {
               sessionSignature
             ]);
             const bundlerUserOp = CryptoUtils.prepareBundlerCall(preliminaryUserOp);
-            const bundlerUrlLower = this.ctx.bundlerUrl.toLowerCase();
-            const isPimlico = bundlerUrlLower.includes("pimlico.io");
-            const isAlchemy = bundlerUrlLower.includes("alchemy.com");
-            const bundlerRequests = [
+            const rundlerFeesRequest = rundlerUserOperationFees(
+              this.ctx.bundlerUrl,
+              { maxFeePerGas, maxPriorityFeePerGas },
               {
-                method: BundlerMethod.ETH_ESTIMATE_USER_OPERATION_GAS,
-                params: [bundlerUserOp, entryPointAddress, bundlerStateOverrides]
-              }
-            ];
-            if (isPimlico) {
-              bundlerRequests.push({
-                method: BundlerMethod.PIMLICO_GET_USER_OPERATION_GAS_PRICE,
-                params: []
-              });
-            }
-            if (isAlchemy) {
-              bundlerRequests.push({
-                method: BundlerMethod.RUNDLER_MAX_PRIORITY_FEE_PER_GAS,
-                params: []
-              });
-            }
-            let gasEstimate;
-            let pimlicoGasPrices = null;
-            let alchemyMaxPriorityFee = null;
-            try {
-              const batchResults = await this.crypto.sendBundlerBatch(bundlerRequests);
-              gasEstimate = batchResults[0];
-              if (isPimlico && batchResults.length > 1) {
-                pimlicoGasPrices = batchResults[1];
-              }
-              if (isAlchemy && batchResults.length > 1) {
-                alchemyMaxPriorityFee = batchResults[1];
+                baseFeePerGas,
+                priorityFeeBumpPercent: BigInt(priorityFeeBumpPercent),
+                maxFeeBumpPercent: BigInt(maxFeeBumpPercent)
               }
-            } catch {
-              gasEstimate = await this.crypto.sendBundler(
-                BundlerMethod.ETH_ESTIMATE_USER_OPERATION_GAS,
-                [bundlerUserOp, entryPointAddress, bundlerStateOverrides]
-              );
-            }
+            );
+            const gasEstimate = await this.crypto.sendBundler(
+              BundlerMethod.ETH_ESTIMATE_USER_OPERATION_GAS,
+              [bundlerUserOp, entryPointAddress, bundlerStateOverrides]
+            );
             callGasLimit = BigInt(gasEstimate.callGasLimit) * 160n / 100n;
             verificationGasLimit = BigInt(gasEstimate.verificationGasLimit) * 105n / 100n;
             preVerificationGas = BigInt(gasEstimate.preVerificationGas) * 105n / 100n;
@@ -249092,23 +249340,9 @@ query OrderStatus($commitment: String!) {
             if (gasEstimate.paymasterPostOpGasLimit) {
               paymasterPostOpGasLimit = BigInt(gasEstimate.paymasterPostOpGasLimit) * 105n / 100n;
             }
-            if (pimlicoGasPrices) {
-              const level = pimlicoGasPrices.fast ?? pimlicoGasPrices.standard ?? pimlicoGasPrices.slow ?? null;
-              if (level) {
-                const pimMaxFeePerGas = BigInt(level.maxFeePerGas);
-                const pimMaxPriorityFeePerGas = BigInt(level.maxPriorityFeePerGas);
-                maxFeePerGas = pimMaxFeePerGas + pimMaxFeePerGas * BigInt(maxFeeBumpPercent) / 100n;
-                maxPriorityFeePerGas = pimMaxPriorityFeePerGas + pimMaxPriorityFeePerGas * BigInt(priorityFeeBumpPercent) / 100n;
-              }
-            }
-            if (alchemyMaxPriorityFee) {
-              const rundlerPriorityFee = BigInt(alchemyMaxPriorityFee);
-              const isArbitrum = chainId === 42161n;
-              const alchemyPrioBump = isArbitrum ? 0n : 25n;
-              maxPriorityFeePerGas = rundlerPriorityFee + rundlerPriorityFee * alchemyPrioBump / 100n;
-              const bufferedBaseFee = baseFeePerGas + baseFeePerGas * 50n / 100n;
-              maxFeePerGas = bufferedBaseFee + maxPriorityFeePerGas;
-            }
+            const rundlerFees = await rundlerFeesRequest;
+            maxFeePerGas = rundlerFees.maxFeePerGas;
+            maxPriorityFeePerGas = rundlerFees.maxPriorityFeePerGas;
           } catch (e4) {
             if (params.requireBundlerEstimate) {
               throw new Error(`Bundler gas estimation failed: ${e4 instanceof Error ? e4.message : String(e4)}`, {
@@ -249149,27 +249383,6 @@ query OrderStatus($commitment: String!) {
           inputs
         };
       }
-      /**
-       * The call dispatcher the gateway on `chain` uses: the configured address, or the one
-       * the gateway reports when the chain's config carries none.
-       *
-       * {@link buildStateOverride} writes it back into the gateway's params slot. Without an
-       * address that value is 12 bytes instead of 32, and the bundler rejects the whole
-       * estimate as `Invalid params`.
-       */
-      async callDispatcher(chain2, gateway) {
-        const configured = this.ctx.dest.configService.getCalldispatcherAddress(chain2);
-        if (isAddress2(configured)) return configured;
-        const known3 = this.dispatchers.get(chain2);
-        if (known3) return known3;
-        const params = await this.ctx.dest.client.readContract({
-          abi: ABI3,
-          address: gateway,
-          functionName: "params"
-        });
-        this.dispatchers.set(chain2, params.dispatcher);
-        return params.dispatcher;
-      }
       /**
        * Asks the bundler for the `preVerificationGas` of the bid UserOperation that will
        * actually be signed, with every funding call, approval and signature byte in it.
@@ -249183,7 +249396,9 @@ query OrderStatus($commitment: String!) {
        * `maxFeePerGas`.
        *
        * The solver account's code is overridden with {@link BID_PVG_ESTIMATION_ACCOUNT_CODE}
-       * for the call, so only the bytes are priced and the fill itself is not simulated.
+       * and the paymaster's, if the bid has one, with {@link BID_PVG_ESTIMATION_PAYMASTER_CODE}
+       * for the call, so only the bytes are priced and neither the fill nor the paymaster's
+       * validation is simulated.
        *
        * @param params - The bid's fields as they will be signed.
        * @returns The `preVerificationGas` to sign, with {@link BID_PVG_HEADROOM_PERCENT} added.
@@ -249207,13 +249422,15 @@ query OrderStatus($commitment: String!) {
           paymasterAndData: params.paymasterAndData ?? "0x",
           signature: `0x${"ff".repeat(SELECTED_BID_SIGNATURE_BYTES)}`
         };
+        const stateOverride = {
+          [solverAccount]: { code: BID_PVG_ESTIMATION_ACCOUNT_CODE }
+        };
+        if (userOp.paymasterAndData.length >= 42) {
+          stateOverride[userOp.paymasterAndData.slice(0, 42)] = { code: BID_PVG_ESTIMATION_PAYMASTER_CODE };
+        }
         const estimate = await this.crypto.sendBundler(
           BundlerMethod.ETH_ESTIMATE_USER_OPERATION_GAS,
-          [
-            CryptoUtils.prepareBundlerCall(userOp),
-            params.entryPointAddress,
-            { [solverAccount]: { code: BID_PVG_ESTIMATION_ACCOUNT_CODE } }
-          ]
+          [CryptoUtils.prepareBundlerCall(userOp), params.entryPointAddress, stateOverride]
         );
         return BigInt(estimate.preVerificationGas) * (100n + BID_PVG_HEADROOM_PERCENT) / 100n;
       }
@@ -249261,9 +249478,8 @@ query OrderStatus($commitment: String!) {
        *   slots should be overridden.
        * @param params.spenderAddress - Address that needs allowance from the solver
        *   account (i.e. the IntentGatewayV2 contract).
-       * @param params.intentGatewayV2Address - If provided, overrides slot 5 of
-       *   IntentGatewayV2 with the call-dispatcher address so dispatch calls
-       *   succeed during estimation.
+       * @param params.intentGatewayV2Address - If provided, turns the gateway's
+       *   solver selection off with {@link selectionOffStateDiff}.
        * @param params.entryPointAddress - If provided, overrides the EntryPoint
        *   deposit mapping to give the solver account a large deposit.
        * @returns An object with `viem` and `bundler` state-override collections.
@@ -249282,10 +249498,7 @@ query OrderStatus($commitment: String!) {
         const viemOverrides = [];
         const bundlerOverrides = {};
         if (intentGatewayV2Address) {
-          const paramsSlot5 = pad4(toHex3(5n), { size: 32 });
-          const dispatcherAddress = await this.callDispatcher(chain2, intentGatewayV2Address);
-          const newSlot5Value = "0x" + "0".repeat(22) + "00" + dispatcherAddress.slice(2).toLowerCase();
-          const gatewayDiffs = [{ slot: paramsSlot5, value: newSlot5Value }];
+          const gatewayDiffs = [await selectionOffStateDiff(this.ctx.dest.client, intentGatewayV2Address)];
           for (const [leg, input] of (escrow?.inputs ?? []).entries()) {
             gatewayDiffs.push({
               slot: escrowSlot(escrow.commitment, leg),
@@ -249917,6 +250130,7 @@ query QuotePessimistic($route: RouteInput!, $amountIn: BigInt!) {
        *
        * The ERC-4337 bundler URL is read from `dest.bundlerUrl`, set when constructing
        * the destination chain via {@link EvmChain.create} or {@link EvmChainParams.bundlerUrl}.
+       * An `EvmChain` given none uses the bundler Hyperbridge runs for it.
        *
        * @param source - Source chain for order placement
        * @param dest - Destination chain for order fulfillment
@@ -250606,6 +250820,27 @@ query QuotePessimistic($route: RouteInput!, $amountIn: BigInt!) {
   }
 });
 
+// src/config/bundlers.ts
+function hyperbridgeBundlerUrl(chainId) {
+  return HYPERBRIDGE_BUNDLER_URLS[chainId];
+}
+var HYPERBRIDGE_BUNDLER_URLS;
+var init_bundlers = __esm({
+  "src/config/bundlers.ts"() {
+    "use strict";
+    init_esm_shims();
+    HYPERBRIDGE_BUNDLER_URLS = {
+      1: "https://bundler.polytope.technology/ethereum",
+      56: "https://bundler.polytope.technology/bsc",
+      97: "https://bundler.polytope.technology/bsc-chapel",
+      137: "https://bundler.polytope.technology/polygon",
+      8453: "https://bundler.polytope.technology/base",
+      42161: "https://bundler.polytope.technology/arbitrum",
+      80002: "https://bundler.polytope.technology/polygon-amoy"
+    };
+  }
+});
+
 // src/services/FillerConfigService.ts
 function validateRpcUrls(rpcUrls) {
   if (rpcUrls.length === 0) {
@@ -250685,7 +250920,7 @@ async function resolveChainConfigs(chains2, options = {}) {
           "RPC endpoint could not report its chainId at startup; keeping it for the quorum to judge per call"
         );
       }
-      return { chainId: first3.chainId, rpcUrls, bundlerUrl: chain2.bundlerUrl };
+      return { chainId: first3.chainId, rpcUrls, bundlerUrl: hyperbridgeBundlerUrl(first3.chainId) };
     })
   );
 }
@@ -250696,6 +250931,7 @@ var init_FillerConfigService = __esm({
     init_esm_shims();
     init_Logger();
     init_node10();
+    init_bundlers();
     DEFAULT_BLOCK_SCAN_INTERVAL_SECONDS = 3;
     MIN_BLOCK_SCAN_INTERVAL_SECONDS = 0.1;
     DEFAULT_MIN_ORDER_SIZE_USD = 20;
@@ -250764,12 +251000,6 @@ var init_FillerConfigService = __esm({
         }
         this.rpcOverrides.set(chainId, validateRpcUrls(rpcUrls));
       }
-      setBundlerUrl(chainId, bundlerUrl) {
-        if (!this.rpcOverrides.has(chainId)) {
-          throw new Error(`Chain ${chainId} is not configured`);
-        }
-        this.bundlerUrls.set(chainId, bundlerUrl);
-      }
       /** Replaces the rebalancing config at runtime; trigger checks read it live. */
       setRebalancing(rebalancing) {
         if (this.fillerConfig) this.fillerConfig.rebalancing = rebalancing;
@@ -250946,7 +251176,7 @@ var init_FillerConfigService = __esm({
         return this.fillerConfig?.substratePrivateKey;
       }
       getEntryPointAddress(chain2) {
-        return this.chainConfigService.getEntryPointV08Address(chain2);
+        return this.chainConfigService.getEntryPointAddress(chain2);
       }
       getSolverAccountContractAddress(chain2) {
         return this.chainConfigService.getSolverAccountAddress(chain2);
@@ -251140,9 +251370,6 @@ function validateConfig(config5, cliWatchOnly = false) {
     if (!Array.isArray(chain2.rpcUrls) || chain2.rpcUrls.length === 0 || chain2.rpcUrls.some((u6) => !u6)) {
       throw new Error("Each chain configuration must have rpcUrls (a non-empty array of strings)");
     }
-    if (!chain2.bundlerUrl) {
-      throw new Error("Each chain configuration must have bundlerUrl");
-    }
   }
   const concurrent = config5.simplex.maxConcurrentOrders;
   if (concurrent !== void 0) {
@@ -251390,7 +251617,7 @@ function nativeTokenSymbol(chainId) {
   return CHAIN_NATIVE_SYMBOLS[chainId] ?? "ETH";
 }
 function chainsForNetwork(network) {
-  return INIT_CHAINS.filter((chain2) => chain2.network === network);
+  return INIT_CHAINS.filter((chain2) => chain2.network === network && chain2.hyperbridgeBundlerUrl);
 }
 function chainByChainId(chainId) {
   return INIT_CHAINS.find((chain2) => chain2.chainId === chainId);
@@ -251404,6 +251631,7 @@ var init_chains2 = __esm({
     "use strict";
     init_esm_shims();
     init_external_links();
+    init_bundlers();
     FREE_RPC_URLS = {
       1: [
         "https://mainnet.gateway.tenderly.co",
@@ -251475,7 +251703,8 @@ var init_chains2 = __esm({
         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,
@@ -251484,7 +251713,8 @@ var init_chains2 = __esm({
         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,
@@ -251493,7 +251723,8 @@ var init_chains2 = __esm({
         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,
@@ -251502,7 +251733,8 @@ var init_chains2 = __esm({
         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,
@@ -251511,7 +251743,8 @@ var init_chains2 = __esm({
         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,
@@ -251543,7 +251776,8 @@ var init_chains2 = __esm({
         label: "Polygon Amoy",
         network: "testnet",
         alchemySubdomain: "polygon-amoy",
-        explorerUrl: external_links_default.chainExplorers.polygonAmoy
+        explorerUrl: external_links_default.chainExplorers.polygonAmoy,
+        hyperbridgeBundlerUrl: HYPERBRIDGE_BUNDLER_URLS[80002]
       },
       {
         chainId: 97,
@@ -251551,7 +251785,8 @@ var init_chains2 = __esm({
         label: "BSC Chapel",
         network: "testnet",
         alchemySubdomain: "bnb-testnet",
-        explorerUrl: external_links_default.chainExplorers.bnbChapel
+        explorerUrl: external_links_default.chainExplorers.bnbChapel,
+        hyperbridgeBundlerUrl: HYPERBRIDGE_BUNDLER_URLS[97]
       }
     ];
     HYPERBRIDGE_WS_DEFAULTS = {
@@ -251793,8 +252028,6 @@ function emitFillerToml(config5, options = {}) {
     push("[[chains]]");
     push("# List 2+ organisationally independent RPC providers to enable quorum log scanning.");
     push(kv("rpcUrls", chain2.rpcUrls));
-    push("# ERC-4337 bundler used to submit fill UserOperations on this chain.");
-    push(kv("bundlerUrl", chain2.bundlerUrl));
     push();
   });
   return `${out.join("\n").trimEnd()}
@@ -336725,9 +336958,6 @@ function parseAlchemyUrl(url2) {
   if (!match) return null;
   return { subdomain, apiKey: match[1] };
 }
-function isAlchemyUrl(url2) {
-  return parseAlchemyUrl(url2) !== null;
-}
 function deriveAlchemyRpc(apiKey, chainId) {
   const chain2 = chainByChainId(chainId);
   if (!chain2?.alchemySubdomain) return null;
@@ -337578,10 +337808,9 @@ var init_help_text = __esm({
     "use strict";
     init_esm_shims();
     WHY = {
-      chains: "Simplex listens for orders and fills only on the chains you pick. Each chain needs its own RPC, an ERC-4337 bundler, and funded balances (native gas + stablecoins).",
+      chains: "Simplex listens for orders and fills only on the chains you pick. Each chain needs its own RPC and funded balances (native gas + stablecoins); fills go through Hyperbridge's bundler.",
       rpc: "The RPC is used to scan order events, read balances and simulate fills. Use a premium endpoint with archive access (Alchemy, Infura, QuickNode) \u2014 free tiers rate-limit and break event scanning.",
       quorum: "Listing a second, organisationally independent RPC enables quorum log scanning: every event batch must match across providers, so one lying or compromised RPC can't feed you fake orders.",
-      bundler: "Fills execute as ERC-4337 UserOperations; the bundler submits them on-chain. Alchemy RPC endpoints double as bundlers, or use a dedicated provider like Pimlico.",
       signer: "This wallet signs every fill and holds your stablecoin float on each chain. It's the identity of your filler.",
       secretPhrase: "A secret phrase is a BIP-39 mnemonic of 12 to 24 English words. The filler signs with the wallet at m/44'/60'/0'/0/0 unless you pick another account index. The phrase is written to the config file in plain text, protected only by the file's permissions, the same as a private key.",
       substrateKey: "Solver-selection orders are won by submitting signed bids to Hyperbridge. This Substrate account signs those bid extrinsics and must hold BRIDGE tokens for fees \u2014 the fees are claimed back automatically after fills.",
@@ -337643,8 +337872,7 @@ function detectPrefillNetwork(prefill) {
   if (!prefill) return void 0;
   for (const chainId of prefill.chainIds) {
     if (chainId === null) continue;
-    const meta = chainsForNetwork("testnet").find((c6) => c6.chainId === chainId);
-    if (meta) return "testnet";
+    if (chainByChainId(chainId)?.network === "testnet") return "testnet";
   }
   return "mainnet";
 }
@@ -337838,118 +338066,6 @@ var init_chains3 = __esm({
   }
 });
 
-// src/cli/init/derive/pimlico.ts
-function parsePimlicoUrl(url2) {
-  let parsed;
-  try {
-    parsed = new URL(url2);
-  } catch {
-    return null;
-  }
-  if (parsed.protocol !== "https:") return null;
-  if (parsed.hostname !== "api.pimlico.io") return null;
-  const match = parsed.pathname.match(/^\/v2\/([^/]+)\/rpc$/);
-  if (!match) return null;
-  const chainId = Number(match[1]);
-  if (!Number.isInteger(chainId) || chainId <= 0) return null;
-  const apiKey = parsed.searchParams.get("apikey");
-  if (!apiKey) return null;
-  return { chainId, apiKey };
-}
-function derivePimlicoBundler(apiKey, chainId) {
-  return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=${encodeURIComponent(apiKey)}`;
-}
-var init_pimlico = __esm({
-  "src/cli/init/derive/pimlico.ts"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
-
-// src/cli/init/steps/bundlers.ts
-async function stepBundlers(state, prefill) {
-  why(WHY.bundler);
-  const alchemyChains = state.chains.filter((chain2) => {
-    if (chain2.bundlerUrl || !isAlchemyUrl(chain2.rpcUrls[0])) return false;
-    const existing = prefillBundlerFor(chain2.meta.chainId, prefill);
-    return !existing || existing === chain2.rpcUrls[0];
-  });
-  if (alchemyChains.length > 0) {
-    const reuse = guard(
-      await confirm({
-        message: `Reuse the Alchemy RPC as the ERC-4337 bundler for ${alchemyChains.map((c6) => c6.meta.label).join(", ")}?`,
-        initialValue: true
-      })
-    );
-    if (reuse) {
-      for (const chain2 of alchemyChains) chain2.bundlerUrl = chain2.rpcUrls[0];
-    }
-  }
-  const alchemyCapable = state.chains.filter((chain2) => !chain2.bundlerUrl && chain2.meta.alchemySubdomain);
-  if (alchemyCapable.length > 0) {
-    const useKey = guard(
-      await confirm({
-        message: `Configure the bundler for ${alchemyCapable.map((c6) => c6.meta.label).join(", ")} from one Alchemy API key?`,
-        initialValue: true
-      })
-    );
-    if (useKey) {
-      const apiKey = await askSecret("Alchemy API key");
-      for (const chain2 of alchemyCapable) {
-        const url2 = deriveAlchemyRpc(apiKey, chain2.meta.chainId);
-        if (url2) chain2.bundlerUrl = url2;
-      }
-    }
-  }
-  const pimlico = new ProviderDerivation({
-    detect: (url2) => parsePimlicoUrl(url2)?.apiKey ?? null,
-    derive: derivePimlicoBundler,
-    confirmMessage: (remaining) => `Pimlico key detected \u2014 derive bundler URLs for ${remaining} from the same key?`
-  });
-  for (const chain2 of state.chains) {
-    if (chain2.bundlerUrl) continue;
-    const existing = prefillBundlerFor(chain2.meta.chainId, prefill);
-    const derived2 = pimlico.candidate(chain2.meta.chainId);
-    const url2 = derived2 ? await askDerivedOrCustom(
-      `Bundler for ${chain2.meta.label}`,
-      derived2,
-      "Use the derived Pimlico URL",
-      () => askBundlerUrl(chain2.meta.label, existing)
-    ) : await askBundlerUrl(chain2.meta.label, existing);
-    chain2.bundlerUrl = url2;
-    const remaining = state.chains.filter((c6) => !c6.bundlerUrl);
-    await pimlico.offer(
-      url2,
-      remaining.map((c6) => c6.meta.label)
-    );
-  }
-}
-function prefillBundlerFor(chainId, prefill) {
-  if (!prefill) return void 0;
-  const index3 = prefill.chainIds.indexOf(chainId);
-  if (index3 === -1) return void 0;
-  return prefill.config.chains[index3]?.bundlerUrl || void 0;
-}
-function askBundlerUrl(label, initial) {
-  return askUrl(`ERC-4337 bundler URL for ${label}`, {
-    initial,
-    placeholder: "https://api.pimlico.io/v2/<chainId>/rpc?apikey=<your-key>",
-    required: "Bundler URL is required \u2014 fills are submitted through it"
-  });
-}
-var init_bundlers = __esm({
-  "src/cli/init/steps/bundlers.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_dist11();
-    init_alchemy();
-    init_pimlico();
-    init_derive_flow();
-    init_prompt_utils();
-    init_help_text();
-  }
-});
-
 // src/cli/init/steps/signer.ts
 async function stepSigner(state, prefill) {
   why(WHY.signer);
@@ -338431,7 +338547,7 @@ function assembleConfig(state) {
     // would otherwise shadow the fresh entry (last [[chains]] wins at load).
     chains: [
       ...state.passthroughChains,
-      ...state.chains.map((chain2) => ({ rpcUrls: chain2.rpcUrls, bundlerUrl: chain2.bundlerUrl ?? "" }))
+      ...state.chains.map((chain2) => ({ rpcUrls: chain2.rpcUrls }))
     ],
     rebalancing,
     vault: hasVault ? vault : void 0,
@@ -338453,10 +338569,7 @@ function chainComments(state) {
 function showSummary(state, outputPath) {
   const lines = [];
   for (const chain2 of state.chains) {
-    const bundlerHost = chain2.bundlerUrl ? new URL(chain2.bundlerUrl).hostname : "?";
-    lines.push(
-      `${chain2.meta.label}: ${chain2.rpcUrls.length} RPC${chain2.rpcUrls.length > 1 ? "s (quorum)" : ""}, bundler ${bundlerHost}`
-    );
+    lines.push(`${chain2.meta.label}: ${chain2.rpcUrls.length} RPC${chain2.rpcUrls.length > 1 ? "s (quorum)" : ""}`);
   }
   if (state.passthroughChains.length > 0) {
     lines.push(`+ ${state.passthroughChains.length} unmanaged chain(s) kept from the previous config`);
@@ -338548,7 +338661,6 @@ async function runInit(options) {
   const state = newWizardState();
   state.prefillConfig = prefill?.config;
   await stepChains(state, prefill);
-  await stepBundlers(state, prefill);
   await stepSigner(state, prefill);
   await stepHyperbridge(state, prefill);
   for (; ; ) {
@@ -338648,7 +338760,6 @@ var init_init3 = __esm({
     init_migrate_legacy();
     init_state();
     init_chains3();
-    init_bundlers();
     init_signer2();
     init_hyperbridge();
     init_finetune();
@@ -338938,6 +339049,7 @@ init_dist4();
 // src/services/server/UiServer.ts
 init_esm_shims();
 init_interpolated_curve();
+init_bundlers();
 init_asset_registry();
 init_pairs();
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -340701,6 +340813,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");
   }
   /**
@@ -340794,6 +340908,7 @@ var LimitOrderService = class {
           bookExpiresAt: null,
           bookPrice: null,
           orderNonce: order.orderNonce,
+          entryPoint: null,
           status: "cancelled",
           lastError: null
         }),
@@ -341060,24 +341175,32 @@ var LimitOrderService = class {
   async resize(remaining, delivered) {
     const id2 = remaining.id;
     const floor2 = await this.dustFloor(remaining);
-    if (BigInt(remaining.remaining) < floor2) {
+    for (let resigning = this.resigning.get(id2); resigning; resigning = this.resigning.get(id2)) await resigning;
+    const order = await this.store.setStatus(id2, "resizing", null, POSTABLE);
+    if (!order) return null;
+    if (BigInt(order.remaining) < floor2) {
       this.logger.info(
-        { id: id2, remaining: remaining.remaining, floor: floor2.toString() },
+        { id: id2, remaining: order.remaining, floor: floor2.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(id2, {
-        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(
+        id2,
+        {
+          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(id2, "resizing"));
+    const resized = await this.repost(order);
     if (resized) this.report({ kind: "resized", order: resized, delivered });
     return resized;
   }
@@ -341090,7 +341213,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);
@@ -341101,10 +341224,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;
   }
@@ -341147,7 +341273,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()]);
@@ -341174,7 +341302,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 {
@@ -341186,6 +341324,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.
@@ -341267,6 +341444,7 @@ var LimitOrderService = class {
       bookExpiresAt: null,
       bookPrice: null,
       orderNonce: order.orderNonce,
+      entryPoint: null,
       status: "expired",
       lastError: null
     });
@@ -341323,11 +341501,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(
@@ -341337,6 +341515,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
         },
@@ -341366,6 +341548,7 @@ var LimitOrderService = class {
           bookExpiresAt: null,
           bookPrice: null,
           orderNonce: orderNonce.toString(),
+          entryPoint: null,
           status: "open",
           lastError: message
         }),
@@ -341388,22 +341571,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 first3 = attempt.result;
     if (first3.kind !== "rejected" || first3.code !== "REPLAYED" && first3.code !== "ORDER_EXISTS") {
-      return { result: first3, orderNonce };
+      return { result: first3, orderNonce, entryPoint };
     }
     if (first3.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: first3.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(chain2) {
+    const entryPoint = this.configService.getEntryPointAddress(chain2);
+    if (!entryPoint) throw new LimitOrderValidationError(`No EntryPoint is configured for ${chain2}`);
+    return entryPoint;
   }
   /**
    * The entry the orderbook holds at `commitment`, if it holds one. A lookup that
@@ -341419,8 +341610,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) {
@@ -341430,7 +341621,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([
@@ -341445,10 +341636,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,
@@ -341479,6 +341666,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(a6, b5) {
+  return a6.toLowerCase() === b5.toLowerCase();
+}
 function sinceMs(updatedAt, now) {
   const written = Date.parse(`${updatedAt.replace(" ", "T")}Z`);
   return Number.isNaN(written) ? Number.POSITIVE_INFINITY : now.getTime() - written;
@@ -343388,8 +343581,6 @@ async function handleSetupRequest(server, setup, req, res, path2, method) {
         return sendJson(res, 200, await validateAlchemyKey(body, deps));
       case "validate-rpc":
         return sendJson(res, 200, await validateRpc(body, deps));
-      case "validate-bundler":
-        return sendJson(res, 200, await validateBundler(body, deps));
       case "validate-token":
         return sendJson(res, 200, await validateToken(body));
       case "derive-evm-address":
@@ -343422,9 +343613,7 @@ async function validateAlchemyKey(body, deps) {
       stateMachineId: meta.stateMachineId,
       label: meta.label,
       note: meta.note,
-      rpcUrl,
-      // Alchemy serves ERC-4337 bundler methods on the same endpoint.
-      bundlerUrl: rpcUrl
+      rpcUrl
     };
   });
   const probe = chains2.find((c6) => c6.rpcUrl);
@@ -343462,23 +343651,6 @@ async function validateRpc(body, deps) {
   );
   return { ok: results.every((r7) => !r7.error), results };
 }
-async function validateBundler(body, deps) {
-  const url2 = String(body.url ?? "").trim();
-  if (!url2) return { ok: false, warning: "Bundler URL is empty" };
-  try {
-    const entryPoints = await withTimeout3(
-      deps.rpcRequest(url2, "eth_supportedEntryPoints", []),
-      PROBE_TIMEOUT_MS,
-      "Bundler probe"
-    );
-    return { ok: true, entryPoints };
-  } catch (err) {
-    return {
-      ok: true,
-      warning: `Bundler did not answer eth_supportedEntryPoints: ${err instanceof Error ? err.message : err}`
-    };
-  }
-}
 async function validateToken(body) {
   const rpcUrl = String(body.rpcUrl ?? "").trim();
   const address = String(body.address ?? "").trim();
@@ -343616,7 +343788,6 @@ function maskToml(config5, chainLabels) {
   }
   for (const chain2 of masked.chains) {
     chain2.rpcUrls = chain2.rpcUrls.map(maskUrlKey);
-    chain2.bundlerUrl = maskUrlKey(chain2.bundlerUrl);
   }
   return emitFillerToml(masked, { chainComments: chainLabels });
 }
@@ -343690,12 +343861,7 @@ function openSseStream(req, res, clients) {
   res.once("close", cleanup);
   res.once("error", cleanup);
 }
-var OPERATOR_PROBES = [
-  "/api/setup/validate-token",
-  "/api/setup/validate-rpc",
-  "/api/setup/validate-bundler",
-  "/api/setup/validate-alchemy-key"
-];
+var OPERATOR_PROBES = ["/api/setup/validate-token", "/api/setup/validate-rpc", "/api/setup/validate-alchemy-key"];
 var LOGS_UNAVAILABLE = "Log capture is not enabled for this filler";
 var MAX_LOG_STREAM_QUEUE = 5e3;
 var MAX_LOG_PAGE = 2e3;
@@ -344145,9 +344311,6 @@ var UiServer = class {
           const body = JSON.parse(await readBody(req));
           if (path2 === "/api/setup/validate-rpc")
             return sendJson(res, 200, await validateRpc(body, this.deps));
-          if (path2 === "/api/setup/validate-bundler") {
-            return sendJson(res, 200, await validateBundler(body, this.deps));
-          }
           if (path2 === "/api/setup/validate-alchemy-key") {
             return sendJson(res, 200, await validateAlchemyKey(body, this.deps));
           }
@@ -344863,7 +345026,7 @@ var UiServer = class {
         stateMachineId: formatChainKey(chainId),
         label: chainLabel(chainId),
         rpcUrls: chain2.rpcUrls,
-        bundlerUrl: chain2.bundlerUrl,
+        bundlerUrl: hyperbridgeBundlerUrl(chainId) ?? "",
         watchOnly: globalWatchOnly ? watchOnly : Boolean(watchOnly?.[String(chainId)]),
         running: running.has(chainId)
       };
@@ -344910,11 +345073,11 @@ var UiServer = class {
         }
         const rpcUrls = (Array.isArray(row.rpcUrls) ? row.rpcUrls : []).map((url2) => String(url2).trim()).filter(Boolean);
         validateRpcUrls(rpcUrls);
-        const bundlerUrl = String(row.bundlerUrl ?? "").trim();
-        if (!bundlerUrl) {
-          throw new Error(`${chainLabel(chainId)} needs a bundler URL to submit fill UserOperations`);
+        const watchOnly = row.watchOnly === true;
+        if (!watchOnly && op.config.simplex.watchOnly !== true && !hyperbridgeBundlerUrl(chainId)) {
+          throw new Error(`Hyperbridge runs no bundler for ${chainLabel(chainId)}, so it can only be watched`);
         }
-        rows.push({ chainId, rpcUrls, bundlerUrl, watchOnly: row.watchOnly === true });
+        rows.push({ chainId, rpcUrls, watchOnly });
       }
     } catch (err) {
       return sendJson(res, 400, { error: err instanceof Error ? err.message : String(err) });
@@ -344946,7 +345109,7 @@ var UiServer = class {
     } catch (err) {
       return sendJson(res, 400, { error: err instanceof Error ? err.message : String(err) });
     }
-    op.config.chains = rows.map(({ rpcUrls, bundlerUrl }) => ({ rpcUrls, bundlerUrl }));
+    op.config.chains = rows.map(({ rpcUrls }) => ({ rpcUrls }));
     if (Object.keys(confirmationPolicies).length > 0) op.config.confirmationPolicies = confirmationPolicies;
     if (typeof op.config.simplex.watchOnly !== "boolean") {
       const perChain = Object.fromEntries(rows.filter((r7) => r7.watchOnly).map((r7) => [String(r7.chainId), true]));
@@ -349514,9 +349677,9 @@ var INTENT_GATEWAY_V2_ABI = [
             internalType: "bytes32"
           },
           {
-            name: "solver",
-            type: "address",
-            internalType: "address"
+            name: "userOpHash",
+            type: "bytes32",
+            internalType: "bytes32"
           },
           {
             name: "signature",
@@ -350904,10 +351067,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();
@@ -350967,11 +351133,20 @@ var ContractInteractionService = class {
     try {
       const chainIds = this.configService.getConfiguredChainIds();
       const chainNames = chainIds.map((id2) => `EVM-${id2}`);
-      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) {
@@ -351556,18 +351731,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(chain2) {
     const client = this.clientManager.getPublicClient(chain2);
-    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(chain2)]);
     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(chain2) {
+    const known3 = this.blockTimes.get(chain2);
+    if (known3) return known3;
+    const client = this.clientManager.getPublicClient(chain2);
+    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(chain2);
+      const fallback2 = declared ?? FALLBACK_BLOCK_TIME_SECONDS;
+      this.logger.warn(
+        { err, chain: chain2, seconds: fallback2 },
+        "Could not measure the block time; using the declared one"
+      );
+      return fallback2;
+    });
+    this.blockTimes.set(chain2, 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.
@@ -351751,6 +351967,8 @@ init_Logger();
 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;
@@ -351777,7 +351995,7 @@ var UserOpSender = class {
     let auth;
     let fees4;
     try {
-      fees4 = await this.getGasPrice(bundlerUrl, publicClient, chainId);
+      fees4 = await this.getGasPrice(bundlerUrl, publicClient);
       const gasForPrefund = gas ?? {
         verificationGasLimit: FALLBACK_VERIFICATION_GAS_LIMIT,
         callGasLimit: FALLBACK_CALL_GAS_LIMIT,
@@ -351931,31 +352149,27 @@ var UserOpSender = class {
     );
     return userOp;
   }
-  /** Mirrors the gas-price selection used by the delegation and fill paths. */
-  async getGasPrice(bundlerUrl, publicClient, chainId) {
-    const lower2 = bundlerUrl.toLowerCase();
-    if (lower2.includes("pimlico.io")) {
-      const res = await this.sendBundlerRpc(
-        bundlerUrl,
-        BundlerMethod.PIMLICO_GET_USER_OPERATION_GAS_PRICE,
-        []
-      );
-      return { maxFeePerGas: BigInt(res.fast.maxFeePerGas), maxPriorityFeePerGas: BigInt(res.fast.maxPriorityFeePerGas) };
-    }
-    if (lower2.includes("alchemy.com")) {
-      const [rundlerPriorityFee, latestBlock] = 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 isArbitrum = BigInt(chainId) === 42161n;
-      const prioBump = isArbitrum ? 0n : 25n;
-      const maxPriorityFeePerGas = BigInt(rundlerPriorityFee) + BigInt(rundlerPriorityFee) * 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 };
+  /**
+   * Prices the op for the rundler bundler, as the fill path does: its suggested fees, or the
+   * chain's gas price raised to the priority fee it requires where it suggests none.
+   */
+  async getGasPrice(bundlerUrl, publicClient) {
+    const [gasPrice, latestBlock] = await Promise.all([
+      publicClient.getGasPrice(),
+      publicClient.getBlock({ blockTag: "latest" })
+    ]);
+    return rundlerUserOperationFees(
+      bundlerUrl,
+      {
+        maxFeePerGas: gasPrice + gasPrice * MAX_FEE_BUMP_PERCENT / 100n,
+        maxPriorityFeePerGas: gasPrice + gasPrice * PRIORITY_FEE_BUMP_PERCENT / 100n
+      },
+      {
+        baseFeePerGas: latestBlock.baseFeePerGas ?? gasPrice,
+        priorityFeeBumpPercent: PRIORITY_FEE_BUMP_PERCENT,
+        maxFeeBumpPercent: MAX_FEE_BUMP_PERCENT
+      }
+    );
   }
   async sendBundlerRpc(bundlerUrl, method, params) {
     const response = await fetch(bundlerUrl, {
@@ -367374,8 +367588,8 @@ var validateBalanceForTransaction = async (params) => {
   }, operationContext);
   const balance = await balancePrepared.execute();
   if (BigInt(balance) < BigInt(amount)) {
-    const chainName = extractChainInfo(operationContext.chain).name;
-    throw createInsufficientTokenBalanceError(chainName, token, {
+    const chainName2 = extractChainInfo(operationContext.chain).name;
+    throw createInsufficientTokenBalanceError(chainName2, token, {
       balance: balance.toString(),
       amount,
       tokenAddress,
@@ -367390,8 +367604,8 @@ var validateNativeBalanceForTransaction = async (params) => {
   }, operationContext);
   const balance = await balancePrepared.execute();
   if (BigInt(balance) === 0n) {
-    const chainName = extractChainInfo(operationContext.chain).name;
-    throw createInsufficientGasError(chainName, {
+    const chainName2 = extractChainInfo(operationContext.chain).name;
+    throw createInsufficientGasError(chainName2, {
       balance: "0",
       walletAddress: operationContext.address
     });
@@ -386353,6 +386567,86 @@ init_FillerConfigService();
 init_filler_toml();
 init_defaults8();
 
+// src/services/bundler-preflight.ts
+init_esm_shims();
+init_chains2();
+init_interpolated_curve();
+init_Logger();
+var BUNDLER_PREFLIGHT_TIMEOUT_MS = 1e4;
+async function assertBundlersServeEntryPoint(chains2, configService, options = {}) {
+  const timeoutMs = options.timeoutMs ?? BUNDLER_PREFLIGHT_TIMEOUT_MS;
+  const logger8 = moduleLogger(configService.loggers, "bundler-preflight");
+  const failures = await Promise.all(
+    chains2.map(async ({ chainId, bundlerUrl }) => {
+      if (options.watchOnly?.[chainId] === true) return void 0;
+      if (!bundlerUrl?.trim()) {
+        return `Hyperbridge runs no bundler for ${chainName(chainId)}, so simplex cannot fill there; set it watch-only`;
+      }
+      const entryPoint = configService.getEntryPointAddress(formatChainKey(chainId));
+      if (!entryPoint) return void 0;
+      return checkBundler(chainId, bundlerUrl.trim(), entryPoint, timeoutMs, logger8);
+    })
+  );
+  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(url2) {
+  try {
+    return new URL(url2).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, logger8) {
+  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);
+    logger8.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/orderbook/lifecycle.ts
 init_esm_shims();
 init_Logger();
@@ -387178,8 +387472,8 @@ async function bootFiller(config5, options) {
   };
   const configService = new FillerConfigService(resolvedChains, fillerConfigForService, options.loggers);
   const chainConfigs2 = resolvedChains.map((chain2) => {
-    const chainName = `EVM-${chain2.chainId}`;
-    return configService.getChainConfig(chainName);
+    const chainName2 = `EVM-${chain2.chainId}`;
+    return configService.getChainConfig(chainName2);
   });
   let watchOnlyConfig;
   const globalWatchOnly = options.watchOnlyOverride === true || config5.simplex.watchOnly === true;
@@ -387217,6 +387511,8 @@ async function bootFiller(config5, 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]."
     );
   }
+  logger8.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) {
@@ -387407,10 +387703,10 @@ async function bootFiller(config5, options) {
   const token1 = {};
   for (const pair of config5.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);
     }
   }
@@ -387815,6 +388111,7 @@ var MemoryLimitOrderStore = class {
       status: "open",
       commitment: null,
       orderNonce: order.orderNonce ?? "0",
+      entryPoint: null,
       bookExpiresAt: null,
       bookPrice: null,
       lastError: null,
@@ -388457,7 +388754,7 @@ var OrderScanner = class _OrderScanner {
   async addChainNow(chain2) {
     if (this.closed) throw new Error("This OrderScanner is closed");
     const rpcUrls = validateRpcUrls(chain2.rpcUrls);
-    const chainId = chain2.chainId ?? (await resolveChainConfigs([{ rpcUrls, bundlerUrl: chain2.bundlerUrl ?? "" }], {
+    const chainId = chain2.chainId ?? (await resolveChainConfigs([{ rpcUrls }], {
       loggers: this.loggers,
       tolerateUnreachable: true
     }))[0].chainId;
@@ -388808,10 +389105,10 @@ var PairController = class {
     if (assets && Object.keys(assets).length > 0) config5.assets = nextAssets;
     if (normalizeSymbol(pair.token0) !== normalizeSymbol(pair.token1)) {
       for (const chain2 of this.runtime.resolvedChains) {
-        const chainName = formatChainKey(chain2.chainId);
-        const address = assetRegistry.getAddress(pair.token1, chainName);
+        const chainName2 = formatChainKey(chain2.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);
       }
     }
@@ -388890,10 +389187,7 @@ var ChainController = class {
   async add(chain2) {
     return this.serialise(async () => {
       validateRpcUrls(chain2.rpcUrls);
-      if (!chain2.bundlerUrl?.trim()) {
-        throw new Error("A bundler URL is required to submit fill UserOperations");
-      }
-      const [resolved] = await resolveChainConfigs([{ rpcUrls: chain2.rpcUrls, bundlerUrl: chain2.bundlerUrl }]);
+      const [resolved] = await resolveChainConfigs([{ rpcUrls: chain2.rpcUrls }]);
       const { chainId } = resolved;
       const { configService, config: config5, intentFiller } = this.runtime;
       if (configService.getConfiguredChainIds().includes(chainId)) {
@@ -388916,12 +389210,13 @@ 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 = chain2.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) {
-          await this.scanner.addChain({ rpcUrls: chain2.rpcUrls, bundlerUrl: chain2.bundlerUrl, chainId });
+          await this.scanner.addChain({ rpcUrls: chain2.rpcUrls, chainId });
         }
         this.runtime.chainClientManager.invalidate(formatChainKey(chainId));
         await intentFiller.addChain(configService.getChainConfig(formatChainKey(chainId)));
@@ -388938,7 +389233,7 @@ var ChainController = class {
         this.runtime.confirmationPolicy.adopt(chainId, resolvedPolicy);
       }
       this.runtime.resolvedChains.push(resolved);
-      config5.chains = [...config5.chains, { rpcUrls: chain2.rpcUrls, bundlerUrl: chain2.bundlerUrl }];
+      config5.chains = [...config5.chains, { rpcUrls: chain2.rpcUrls }];
       if (Object.keys(confirmationPolicies).length > 0) config5.confirmationPolicies = confirmationPolicies;
       this.syncWatchOnlyToConfig();
       await this.persist();
@@ -388983,9 +389278,7 @@ var ChainController = class {
       validateRpcUrls(rpcUrls);
       const index3 = this.runtime.resolvedChains.findIndex((chain2) => chain2.chainId === chainId);
       if (index3 < 0) throw new Error(`Chain ${chainId} is not configured`);
-      const [probed] = await resolveChainConfigs([
-        { rpcUrls, bundlerUrl: this.runtime.resolvedChains[index3].bundlerUrl ?? "" }
-      ]);
+      const [probed] = await resolveChainConfigs([{ rpcUrls }]);
       if (probed.chainId !== chainId) {
         throw new Error(`Those endpoints answer for chain ${probed.chainId}, not ${chainId}`);
       }
@@ -389004,17 +389297,6 @@ var ChainController = class {
       await this.persist();
     });
   }
-  async setBundlerUrl(chainId, bundlerUrl) {
-    return this.serialise(async () => {
-      if (!bundlerUrl?.trim()) throw new Error("A bundler URL is required");
-      const index3 = this.runtime.resolvedChains.findIndex((chain2) => chain2.chainId === chainId);
-      if (index3 < 0) throw new Error(`Chain ${chainId} is not configured`);
-      this.runtime.configService.setBundlerUrl(chainId, bundlerUrl);
-      this.runtime.resolvedChains[index3].bundlerUrl = bundlerUrl;
-      this.runtime.config.chains[index3].bundlerUrl = bundlerUrl;
-      await this.persist();
-    });
-  }
   /** Monitor without filling. Takes effect on the next order. */
   async setWatchOnly(chainId, watchOnly) {
     return this.serialise(async () => {
@@ -389023,6 +389305,10 @@ var ChainController = class {
           "Watch-only cannot be disabled: this solver was started without a signer. Restart with `signer` to fill."
         );
       }
+      if (!watchOnly) {
+        const chain2 = this.runtime.resolvedChains.find((resolved) => resolved.chainId === chainId);
+        if (chain2) await assertBundlersServeEntryPoint([chain2], this.runtime.configService);
+      }
       this.runtime.intentFiller.setWatchOnly(chainId, watchOnly);
       this.syncWatchOnlyToConfig();
       await this.persist();
@@ -389891,6 +390177,7 @@ var LIMIT_ORDER_COLUMNS = `
 	status,
 	commitment,
 	order_nonce as orderNonce,
+	entry_point as entryPoint,
 	book_expires_at as bookExpiresAt,
 	book_price as bookPrice,
 	last_error as lastError,
@@ -389927,6 +390214,7 @@ var SqliteLimitOrderStore = class {
 				status TEXT NOT NULL,
 				commitment TEXT,
 				order_nonce TEXT NOT NULL DEFAULT '0',
+				entry_point TEXT,
 				book_expires_at TEXT,
 				book_price TEXT,
 				last_error TEXT,
@@ -389951,6 +390239,10 @@ var SqliteLimitOrderStore = class {
 
 			CREATE INDEX IF NOT EXISTS idx_limit_order_fills_order ON limit_order_fills(limit_order_id);
 		`);
+    if (!columnNames(this.db, "limit_orders").has("entry_point")) {
+      this.db.exec("ALTER TABLE limit_orders ADD COLUMN entry_point TEXT");
+      this.logger.info({ column: "entry_point" }, "Migrated limit order storage schema");
+    }
     if (!columnNames(this.db, "limit_order_fills").has("amount_in")) {
       this.db.exec("ALTER TABLE limit_order_fills ADD COLUMN amount_in TEXT");
       this.logger.info({ column: "amount_in" }, "Migrated limit order fill schema");
@@ -390015,13 +390307,14 @@ var SqliteLimitOrderStore = class {
     const result = this.db.prepare(`
 				UPDATE limit_orders
 				SET commitment = ?, book_expires_at = ?, book_price = ?, order_nonce = ?,
-				    status = ?, last_error = ?, updated_at = datetime('now')
+				    entry_point = ?, status = ?, last_error = ?, updated_at = datetime('now')
 				WHERE id = ?${statusGuard(only)}
 			`).run(
       posting.commitment,
       posting.bookExpiresAt,
       posting.bookPrice,
       posting.orderNonce,
+      posting.entryPoint,
       posting.status,
       posting.lastError,
       id2,