@hyperbridge/simplex 0.16.13 → 0.17.0

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,40 @@ function userOperationLogs(logs, entryPoint, userOpHash) {
   while (start >= 0 && !isBoundary(logs[start])) start--;
   return logs.slice(start + 1, end);
 }
+async function fetchRundlerPriorityFee(bundlerUrl) {
+  if (bundlersWithoutRundlerFees.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: BundlerMethod.RUNDLER_MAX_PRIORITY_FEE_PER_GAS,
+        params: []
+      })
+    });
+    const { result, error } = await response.json();
+    if (error) {
+      if (error.code !== void 0 && UNSUPPORTED_REQUEST_CODES.has(error.code)) {
+        bundlersWithoutRundlerFees.add(bundlerUrl);
+      }
+      return null;
+    }
+    return result == null ? null : BigInt(result);
+  } catch {
+    return null;
+  }
+}
+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 +235502,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, 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 +237855,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,8 +237890,10 @@ 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",
@@ -237843,7 +237928,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 +237968,7 @@ var init_node10 = __esm({
           UniswapV2Factory: "0x0000000000000000000000000000000000000000",
           UniswapV3Factory: "0x0000000000000000000000000000000000000000",
           Calldispatcher: "0xC7f13b6D03A0A7F3239d38897503E90553ABe155",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
         },
         rpcEnvKey: "SEPOLIA",
         defaultRpcUrl: "https://1rpc.io/sepolia",
@@ -237934,7 +238019,7 @@ var init_node10 = __esm({
         },
         addresses: {
           IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-          SolverAccount: "0x77c3394CA5881A74f18139AC87D0c11F8Faa90cC",
+          SolverAccount: "0xaAd062555800a97Af062795189e32a3CBd045612",
           TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
           Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
           UniswapRouter02: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
@@ -237948,7 +238033,7 @@ var init_node10 = __esm({
           UniswapV4StateView: "0x7ffe42c4a5deea5b0fec41c94c136cf115597227",
           Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x433709009B8330FDa32311DF1C2AFA402eD8D009",
           CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
           SimplexPaymaster: "0xD4340d7466e040626383cb9cda9307ba8E081149",
           Usdt0Oft: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee"
@@ -237980,7 +238065,8 @@ var init_node10 = __esm({
           USDC: "0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d",
           USDT: "0x55d398326f99059ff775485246999027b3197955",
           EXT: "0x7C8c11ADb8EF7cd3CFa718008Ea048445C6E7209",
-          cNGN: "0xa8AEA66B361a8d53e8865c62D142167Af28Af058"
+          cNGN: "0xa8AEA66B361a8d53e8865c62D142167Af28Af058",
+          BRIDGE: "0x5b0c50fDd52ECC0d4c682c441eaBaD41FfDEABBB"
         },
         tokenDecimals: {
           USDC: 18,
@@ -237989,19 +238075,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,7 +238103,7 @@ var init_node10 = __esm({
           UniswapV4StateView: "0xd13dd3d6e93f276fafc9db9e6bb47c1180aee0c4",
           Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x433709009B8330FDa32311DF1C2AFA402eD8D009",
           SimplexPaymaster: "0xeD02f9f0df8F562B89cC5b25867Ad3C2d61252A9"
           // "Usdt0Oft": Not available on BSC
         },
@@ -238062,7 +238150,7 @@ var init_node10 = __esm({
         },
         addresses: {
           IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-          SolverAccount: "0x77c3394CA5881A74f18139AC87D0c11F8Faa90cC",
+          SolverAccount: "0xaAd062555800a97Af062795189e32a3CBd045612",
           TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
           Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
           UniswapRouter02: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
@@ -238076,7 +238164,7 @@ var init_node10 = __esm({
           UniswapV4StateView: "0x76fd297e2d437cd7f76d50f01afe6160f86e9990",
           Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x433709009B8330FDa32311DF1C2AFA402eD8D009",
           CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
           SimplexPaymaster: "0x7281Bccb4f0BCE44F3B8542d1fC5e51c2F5fC08C",
           Usdt0Oft: "0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92"
@@ -238136,7 +238224,7 @@ var init_node10 = __esm({
         },
         addresses: {
           IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-          SolverAccount: "0x77c3394CA5881A74f18139AC87D0c11F8Faa90cC",
+          SolverAccount: "0xaAd062555800a97Af062795189e32a3CBd045612",
           TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
           Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
           UniswapRouter02: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
@@ -238147,7 +238235,7 @@ var init_node10 = __esm({
           UniswapV4Quoter: "0x0d5e0f971ed27fbff6c2837bf31316121532048d",
           Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x433709009B8330FDa32311DF1C2AFA402eD8D009",
           CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
           SimplexPaymaster: "0x15b3B03C870c7ef252029c35A12d3b339F5c8d7f",
           AerodromeRouter: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
@@ -238186,7 +238274,8 @@ var init_node10 = __esm({
           cNGN: "0x52828daa48C1a9A06F37500882b42daf0bE04C3B",
           ZARP: "0xb755506531786C8aC63B756BaB1ac387bACB0C04",
           XSGD: "0xDC3326e71D45186F113a2F448984CA0e8D201995",
-          USDR: "0x3B5F2810fB2168FfA9C73160F97BF9f2461fFa5c"
+          USDR: "0x3B5F2810fB2168FfA9C73160F97BF9f2461fFa5c",
+          BRIDGE: "0x5b0c50fDd52ECC0d4c682c441eaBaD41FfDEABBB"
         },
         tokenDecimals: {
           USDC: 6,
@@ -238195,7 +238284,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 +238296,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,7 +238315,7 @@ var init_node10 = __esm({
           UniswapV4StateView: "0x5ea1bd7974c8a611cbab0bdcafcb1d9cc9b3ba5a",
           Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x433709009B8330FDa32311DF1C2AFA402eD8D009",
           CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
           SimplexPaymaster: "0xe99acFe0f5fC4C8ea54A187D8D3b05f136150095",
           Usdt0Oft: "0x6BA10300f0DC58B7a1e4c0e41f5daBb7D7829e13"
@@ -238303,8 +238394,9 @@ 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",
@@ -238336,7 +238428,7 @@ var init_node10 = __esm({
           UniswapV3Factory: "0x1F98431c8aD98523631AE4a59f267346ea31F984",
           Calldispatcher: "0xC71251c8b3e7B02697A84363Eef6DcE8DfBdF333",
           Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
           CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
           UniswapV4PositionManager: "0x3c3ea4b57a46241e54610e5f022e5c45859a1017",
           UniswapV4PoolManager: "0x9a13f98cb987694c9f086b1f5eb990eea8264ec3"
@@ -238370,7 +238462,7 @@ var init_node10 = __esm({
           // Mocked
           UniswapV2Factory: "0x0000000000000000000000000000000000000000",
           Calldispatcher: "0xC71251c8b3e7B02697A84363Eef6DcE8DfBdF333",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
         },
         defaultRpcUrl: "https://rpc.gnosischain.com",
         consensusStateId: "GNO0",
@@ -238395,7 +238487,7 @@ var init_node10 = __esm({
         addresses: {
           TokenGateway: "0xCe304770236f39F9911BfCC51afBdfF3b8635718",
           Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
           UniswapV4PositionManager: "0x1b35d13a2e2528f192637f14b05f0dc0e7deb566",
           UniswapV4PoolManager: "0x360e68faccca8ca495c1b759fd9eee466db9fb32"
         },
@@ -238421,7 +238513,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 +238537,7 @@ var init_node10 = __esm({
         addresses: {
           TokenGateway: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
           Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
         },
         defaultRpcUrl: "https://sepolia.optimism.io",
         consensusStateId: "ETH0",
@@ -238469,7 +238561,7 @@ var init_node10 = __esm({
         addresses: {
           TokenGateway: "0xFcDa26cA021d5535C3059547390E6cCd8De7acA6",
           Host: "0x9AA003594d59C62EE17A73A569Fd7B1DbdBd71E1",
-          EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+          EntryPoint: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
         },
         defaultRpcUrl: "https://sepolia.base.org",
         consensusStateId: "ETH0",
@@ -238495,7 +238587,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 +238611,7 @@ var init_node10 = __esm({
         },
         addresses: {
           IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-          SolverAccount: "0x77c3394CA5881A74f18139AC87D0c11F8Faa90cC",
+          SolverAccount: "0xaAd062555800a97Af062795189e32a3CBd045612",
           Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
           Calldispatcher: "0xE2C7e576E26E0bE7aC97c6fE925bcDAbD87c4bEd"
         },
@@ -239924,9 +240016,9 @@ var init_node10 = __esm({
                 internalType: "bytes32"
               },
               {
-                name: "solver",
-                type: "address",
-                internalType: "address"
+                name: "userOpHash",
+                type: "bytes32",
+                internalType: "bytes32"
               },
               {
                 name: "signature",
@@ -240972,8 +241064,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;
@@ -243235,6 +243327,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 +243354,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 +243394,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 +243410,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 +243424,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 +243481,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 +243491,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;
@@ -246659,7 +246787,8 @@ query OrderStatus($commitment: String!) {
       /** Alchemy (Rundler) method to fetch recommended priority fee for UserOperations. */
       RUNDLER_MAX_PRIORITY_FEE_PER_GAS: "rundler_maxPriorityFeePerGas"
     };
-    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 +246827,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 +247397,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 +247519,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 +248383,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 +248395,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 +248436,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 +248467,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 session key is missing or signing fails.
+       * @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 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 +248586,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 +248634,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 +248686,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 +248727,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 +248767,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 +249064,15 @@ query OrderStatus($commitment: String!) {
         }
       }
     };
+    UNSUPPORTED_REQUEST_CODES = /* @__PURE__ */ new Set([-32600, -32601, -32602]);
+    bundlersWithoutRundlerFees = /* @__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 +249086,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;
       }
@@ -248895,7 +249107,10 @@ query OrderStatus($commitment: String!) {
        * 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,
+       * `pimlico_getUserOperationGasPrice`, and if it is Alchemy, with
+       * `rundler_maxPriorityFeePerGas`. For any other bundler that answers
+       * `rundler_maxPriorityFeePerGas`, the fees are raised to at least that
+       * priority fee (see {@link applyRundlerPriorityFee}). 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 +249145,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 +249207,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 +249216,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 +249249,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,
@@ -249047,6 +249269,7 @@ query OrderStatus($commitment: String!) {
             const bundlerUrlLower = this.ctx.bundlerUrl.toLowerCase();
             const isPimlico = bundlerUrlLower.includes("pimlico.io");
             const isAlchemy = bundlerUrlLower.includes("alchemy.com");
+            const rundlerPriorityFeeRequest = isPimlico || isAlchemy ? Promise.resolve(null) : fetchRundlerPriorityFee(this.ctx.bundlerUrl);
             const bundlerRequests = [
               {
                 method: BundlerMethod.ETH_ESTIMATE_USER_OPERATION_GAS,
@@ -249102,13 +249325,27 @@ query OrderStatus($commitment: String!) {
               }
             }
             if (alchemyMaxPriorityFee) {
-              const rundlerPriorityFee = BigInt(alchemyMaxPriorityFee);
+              const rundlerPriorityFee2 = BigInt(alchemyMaxPriorityFee);
               const isArbitrum = chainId === 42161n;
               const alchemyPrioBump = isArbitrum ? 0n : 25n;
-              maxPriorityFeePerGas = rundlerPriorityFee + rundlerPriorityFee * alchemyPrioBump / 100n;
+              maxPriorityFeePerGas = rundlerPriorityFee2 + rundlerPriorityFee2 * alchemyPrioBump / 100n;
               const bufferedBaseFee = baseFeePerGas + baseFeePerGas * 50n / 100n;
               maxFeePerGas = bufferedBaseFee + maxPriorityFeePerGas;
             }
+            const rundlerPriorityFee = await rundlerPriorityFeeRequest;
+            if (rundlerPriorityFee !== null) {
+              const rundlerFees = applyRundlerPriorityFee(
+                { maxFeePerGas, maxPriorityFeePerGas },
+                {
+                  rundlerPriorityFee,
+                  baseFeePerGas,
+                  priorityFeeBumpPercent: BigInt(priorityFeeBumpPercent),
+                  maxFeeBumpPercent: BigInt(maxFeeBumpPercent)
+                }
+              );
+              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 +249386,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 +249399,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 +249425,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 +249481,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 +249501,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),
@@ -250946,7 +251162,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);
@@ -251398,7 +251614,7 @@ function chainByChainId(chainId) {
 function chainByAlchemySubdomain(subdomain) {
   return INIT_CHAINS.find((chain2) => chain2.alchemySubdomain === subdomain);
 }
-var FREE_RPC_URLS, CHAIN_NATIVE_SYMBOLS, INIT_CHAINS, HYPERBRIDGE_WS_DEFAULTS;
+var FREE_RPC_URLS, HYPERBRIDGE_BUNDLER_URLS, CHAIN_NATIVE_SYMBOLS, INIT_CHAINS, HYPERBRIDGE_WS_DEFAULTS;
 var init_chains2 = __esm({
   "src/cli/init/chains.ts"() {
     "use strict";
@@ -251450,6 +251666,13 @@ var init_chains2 = __esm({
         "https://arb1.arbitrum.io/rpc"
       ]
     };
+    HYPERBRIDGE_BUNDLER_URLS = {
+      1: "https://bundler.polytope.technology/ethereum",
+      56: "https://bundler.polytope.technology/bsc",
+      137: "https://bundler.polytope.technology/polygon",
+      8453: "https://bundler.polytope.technology/base",
+      42161: "https://bundler.polytope.technology/arbitrum"
+    };
     CHAIN_NATIVE_SYMBOLS = {
       1: "ETH",
       56: "BNB",
@@ -251475,7 +251698,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 +251708,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 +251718,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 +251728,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 +251738,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,
@@ -337581,7 +337809,7 @@ var init_help_text = __esm({
       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).",
       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.",
+      bundler: "Fills execute as ERC-4337 UserOperations; the bundler submits them on-chain. Hyperbridge runs no bundler for these chains, so use a provider such as 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.",
@@ -337868,6 +338096,10 @@ var init_pimlico = __esm({
 
 // src/cli/init/steps/bundlers.ts
 async function stepBundlers(state, prefill) {
+  for (const chain2 of state.chains) {
+    if (chain2.meta.hyperbridgeBundlerUrl) chain2.bundlerUrl = chain2.meta.hyperbridgeBundlerUrl;
+  }
+  if (state.chains.every((chain2) => chain2.bundlerUrl)) return;
   why(WHY.bundler);
   const alchemyChains = state.chains.filter((chain2) => {
     if (chain2.bundlerUrl || !isAlchemyUrl(chain2.rpcUrls[0])) return false;
@@ -338453,9 +338685,9 @@ function chainComments(state) {
 function showSummary(state, outputPath) {
   const lines = [];
   for (const chain2 of state.chains) {
-    const bundlerHost = chain2.bundlerUrl ? new URL(chain2.bundlerUrl).hostname : "?";
+    const bundlerHost2 = chain2.bundlerUrl ? new URL(chain2.bundlerUrl).hostname : "?";
     lines.push(
-      `${chain2.meta.label}: ${chain2.rpcUrls.length} RPC${chain2.rpcUrls.length > 1 ? "s (quorum)" : ""}, bundler ${bundlerHost}`
+      `${chain2.meta.label}: ${chain2.rpcUrls.length} RPC${chain2.rpcUrls.length > 1 ? "s (quorum)" : ""}, bundler ${bundlerHost2}`
     );
   }
   if (state.passthroughChains.length > 0) {
@@ -340701,6 +340933,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 +341028,7 @@ var LimitOrderService = class {
           bookExpiresAt: null,
           bookPrice: null,
           orderNonce: order.orderNonce,
+          entryPoint: null,
           status: "cancelled",
           lastError: null
         }),
@@ -341060,24 +341295,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 +341333,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 +341344,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 +341393,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 +341422,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 +341444,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 +341564,7 @@ var LimitOrderService = class {
       bookExpiresAt: null,
       bookPrice: null,
       orderNonce: order.orderNonce,
+      entryPoint: null,
       status: "expired",
       lastError: null
     });
@@ -341323,11 +341621,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 +341635,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 +341668,7 @@ var LimitOrderService = class {
           bookExpiresAt: null,
           bookPrice: null,
           orderNonce: orderNonce.toString(),
+          entryPoint: null,
           status: "open",
           lastError: message
         }),
@@ -341388,22 +341691,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 +341730,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 +341741,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 +341756,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 +341786,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;
@@ -343273,6 +343586,86 @@ init_pairs();
 init_interpolated_curve();
 init_asset_registry();
 init_FillerConfigService();
+
+// 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 void 0;
+      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/services/server/setup-api.ts
 init_wallet3();
 
 // src/services/substrate-key.ts
@@ -343471,6 +343864,23 @@ async function validateBundler(body, deps) {
       PROBE_TIMEOUT_MS,
       "Bundler probe"
     );
+    const chainId = Number(body.chainId);
+    const required2 = Number.isInteger(chainId) ? new ChainConfigService({}).getEntryPointAddress(formatChainKey(chainId)) : void 0;
+    if (!required2) return { ok: true, entryPoints };
+    if (!Array.isArray(entryPoints) || !entryPoints.every((address) => typeof address === "string")) {
+      return {
+        ok: true,
+        entryPoints,
+        warning: `Bundler's eth_supportedEntryPoints answer is not a list of addresses, so it could not be confirmed to support EntryPoint ${required2}, which this chain's solver account uses. Simplex will use it and warn.`
+      };
+    }
+    if (!servesEntryPoint(entryPoints, required2)) {
+      return {
+        ok: true,
+        entryPoints,
+        warning: `Bundler does not support EntryPoint ${required2}, which this chain's solver account uses; it lists ${describeEntryPoints(entryPoints)}. Simplex will refuse to use it.`
+      };
+    }
     return { ok: true, entryPoints };
   } catch (err) {
     return {
@@ -349514,9 +349924,9 @@ var INTENT_GATEWAY_V2_ABI = [
             internalType: "bytes32"
           },
           {
-            name: "solver",
-            type: "address",
-            internalType: "address"
+            name: "userOpHash",
+            type: "bytes32",
+            internalType: "bytes32"
           },
           {
             name: "signature",
@@ -350904,10 +351314,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 +351380,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 +351978,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 +352214,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;
@@ -351931,7 +352396,11 @@ var UserOpSender = class {
     );
     return userOp;
   }
-  /** Mirrors the gas-price selection used by the delegation and fill paths. */
+  /**
+   * Mirrors the gas-price selection used by the delegation and fill paths: Pimlico's and
+   * Alchemy's own pricing, otherwise the chain's gas price raised to the priority fee a
+   * rundler bundler requires, when the bundler gives one.
+   */
   async getGasPrice(bundlerUrl, publicClient, chainId) {
     const lower2 = bundlerUrl.toLowerCase();
     if (lower2.includes("pimlico.io")) {
@@ -351943,19 +352412,33 @@ var UserOpSender = class {
       return { maxFeePerGas: BigInt(res.fast.maxFeePerGas), maxPriorityFeePerGas: BigInt(res.fast.maxPriorityFeePerGas) };
     }
     if (lower2.includes("alchemy.com")) {
-      const [rundlerPriorityFee, latestBlock] = await Promise.all([
+      const [rundlerPriorityFee2, latestBlock2] = await Promise.all([
         this.sendBundlerRpc(bundlerUrl, BundlerMethod.RUNDLER_MAX_PRIORITY_FEE_PER_GAS, []),
         publicClient.getBlock({ blockTag: "latest" })
       ]);
-      const baseFeePerGas = latestBlock.baseFeePerGas ?? await publicClient.getGasPrice();
+      const baseFeePerGas = latestBlock2.baseFeePerGas ?? await publicClient.getGasPrice();
       const isArbitrum = BigInt(chainId) === 42161n;
       const prioBump = isArbitrum ? 0n : 25n;
-      const maxPriorityFeePerGas = BigInt(rundlerPriorityFee) + BigInt(rundlerPriorityFee) * prioBump / 100n;
+      const maxPriorityFeePerGas = BigInt(rundlerPriorityFee2) + BigInt(rundlerPriorityFee2) * prioBump / 100n;
       const bufferedBaseFee = baseFeePerGas + baseFeePerGas * 50n / 100n;
       return { maxFeePerGas: bufferedBaseFee + maxPriorityFeePerGas, maxPriorityFeePerGas };
     }
-    const gasPrice = await publicClient.getGasPrice();
-    return { maxFeePerGas: gasPrice + gasPrice * 10n / 100n, maxPriorityFeePerGas: gasPrice + gasPrice * 8n / 100n };
+    const [gasPrice, rundlerPriorityFee] = await Promise.all([
+      publicClient.getGasPrice(),
+      fetchRundlerPriorityFee(bundlerUrl)
+    ]);
+    const fees4 = {
+      maxFeePerGas: gasPrice + gasPrice * MAX_FEE_BUMP_PERCENT / 100n,
+      maxPriorityFeePerGas: gasPrice + gasPrice * PRIORITY_FEE_BUMP_PERCENT / 100n
+    };
+    if (rundlerPriorityFee === null) return fees4;
+    const latestBlock = await publicClient.getBlock({ blockTag: "latest" });
+    return applyRundlerPriorityFee(fees4, {
+      rundlerPriorityFee,
+      baseFeePerGas: latestBlock.baseFeePerGas ?? gasPrice,
+      priorityFeeBumpPercent: PRIORITY_FEE_BUMP_PERCENT,
+      maxFeeBumpPercent: MAX_FEE_BUMP_PERCENT
+    });
   }
   async sendBundlerRpc(bundlerUrl, method, params) {
     const response = await fetch(bundlerUrl, {
@@ -367374,8 +367857,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 +367873,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
     });
@@ -387178,8 +387661,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 +387700,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 +387892,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 +388300,7 @@ var MemoryLimitOrderStore = class {
       status: "open",
       commitment: null,
       orderNonce: order.orderNonce ?? "0",
+      entryPoint: null,
       bookExpiresAt: null,
       bookPrice: null,
       lastError: null,
@@ -388808,10 +389294,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);
       }
     }
@@ -388916,8 +389402,9 @@ var ChainController = class {
           `Chain ${chainId} cannot be added as filling: this solver was started without a signer. Restart with \`signer\` to fill.`
         );
       }
-      configService.addChain(resolved);
       const watchOnly = 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) {
@@ -389009,6 +389496,9 @@ var ChainController = class {
       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`);
+      await assertBundlersServeEntryPoint([{ chainId, bundlerUrl }], this.runtime.configService, {
+        watchOnly: this.runtime.intentFiller.getWatchOnly()
+      });
       this.runtime.configService.setBundlerUrl(chainId, bundlerUrl);
       this.runtime.resolvedChains[index3].bundlerUrl = bundlerUrl;
       this.runtime.config.chains[index3].bundlerUrl = bundlerUrl;
@@ -389023,6 +389513,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 +390385,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 +390422,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 +390447,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 +390515,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,