@hyperbridge/simplex 0.16.6 → 0.16.8

package/dist/bin/simplex.js

@@ -70714,13 +70714,13 @@ var require_ponyfill_es2018 = __commonJS({
       }
       function convertReadableWritablePair(pair, context) {
         assertDictionary(pair, context);
-        const readable = pair === null || pair === void 0 ? void 0 : pair.readable;
-        assertRequiredField(readable, "readable", "ReadableWritablePair");
-        assertReadableStream(readable, `${context} has member 'readable' that`);
+        const readable2 = pair === null || pair === void 0 ? void 0 : pair.readable;
+        assertRequiredField(readable2, "readable", "ReadableWritablePair");
+        assertReadableStream(readable2, `${context} has member 'readable' that`);
         const writable = pair === null || pair === void 0 ? void 0 : pair.writable;
         assertRequiredField(writable, "writable", "ReadableWritablePair");
         assertWritableStream(writable, `${context} has member 'writable' that`);
-        return { readable, writable };
+        return { readable: readable2, writable };
       }
       class ReadableStream2 {
         constructor(rawUnderlyingSource = {}, rawStrategy = {}) {
@@ -71399,7 +71399,7 @@ var require_ponyfill_es2018 = __commonJS({
         if (controller._finishPromise !== void 0) {
           return controller._finishPromise;
         }
-        const readable = stream4._readable;
+        const readable2 = stream4._readable;
         controller._finishPromise = newPromise((resolve11, reject) => {
           controller._finishPromise_resolve = resolve11;
           controller._finishPromise_reject = reject;
@@ -71407,15 +71407,15 @@ var require_ponyfill_es2018 = __commonJS({
         const cancelPromise = controller._cancelAlgorithm(reason);
         TransformStreamDefaultControllerClearAlgorithms(controller);
         uponPromise(cancelPromise, () => {
-          if (readable._state === "errored") {
-            defaultControllerFinishPromiseReject(controller, readable._storedError);
+          if (readable2._state === "errored") {
+            defaultControllerFinishPromiseReject(controller, readable2._storedError);
           } else {
-            ReadableStreamDefaultControllerError(readable._readableStreamController, reason);
+            ReadableStreamDefaultControllerError(readable2._readableStreamController, reason);
             defaultControllerFinishPromiseResolve(controller);
           }
           return null;
         }, (r7) => {
-          ReadableStreamDefaultControllerError(readable._readableStreamController, r7);
+          ReadableStreamDefaultControllerError(readable2._readableStreamController, r7);
           defaultControllerFinishPromiseReject(controller, r7);
           return null;
         });
@@ -71426,7 +71426,7 @@ var require_ponyfill_es2018 = __commonJS({
         if (controller._finishPromise !== void 0) {
           return controller._finishPromise;
         }
-        const readable = stream4._readable;
+        const readable2 = stream4._readable;
         controller._finishPromise = newPromise((resolve11, reject) => {
           controller._finishPromise_resolve = resolve11;
           controller._finishPromise_reject = reject;
@@ -71434,15 +71434,15 @@ var require_ponyfill_es2018 = __commonJS({
         const flushPromise = controller._flushAlgorithm();
         TransformStreamDefaultControllerClearAlgorithms(controller);
         uponPromise(flushPromise, () => {
-          if (readable._state === "errored") {
-            defaultControllerFinishPromiseReject(controller, readable._storedError);
+          if (readable2._state === "errored") {
+            defaultControllerFinishPromiseReject(controller, readable2._storedError);
           } else {
-            ReadableStreamDefaultControllerClose(readable._readableStreamController);
+            ReadableStreamDefaultControllerClose(readable2._readableStreamController);
             defaultControllerFinishPromiseResolve(controller);
           }
           return null;
         }, (r7) => {
-          ReadableStreamDefaultControllerError(readable._readableStreamController, r7);
+          ReadableStreamDefaultControllerError(readable2._readableStreamController, r7);
           defaultControllerFinishPromiseReject(controller, r7);
           return null;
         });
@@ -214220,6 +214220,12 @@ function userOperationLogs(logs, entryPoint, userOpHash) {
   while (start >= 0 && !isBoundary(logs[start])) start--;
   return logs.slice(start + 1, end);
 }
+function escrowSlot(commitment, leg) {
+  const byCommitment = keccak2563(
+    encodeAbiParameters2([{ type: "bytes32" }, { type: "uint256" }], [commitment, ESCROW_MAPPING_SLOT])
+  );
+  return keccak2563(encodeAbiParameters2([{ type: "uint256" }, { type: "bytes32" }], [BigInt(leg), byCommitment]));
+}
 function destinationStateMachine(order) {
   return isHex3(order.destination) ? hexToString2(order.destination) : order.destination;
 }
@@ -214231,13 +214237,19 @@ function describeError(error) {
   if (graphqlErrors?.length) return graphqlErrors.map((e4) => e4.message).join("; ");
   return error instanceof Error ? error.message : String(error);
 }
+function sameSymbol(a6, b5) {
+  return a6.toLowerCase() === b5.toLowerCase();
+}
 function findBook(books, tokenA, tokenB) {
   const book = books.find(
-    (b5) => b5.base === tokenA && b5.quote === tokenB || b5.base === tokenB && b5.quote === tokenA
+    (b5) => sameSymbol(b5.base, tokenA) && sameSymbol(b5.quote, tokenB) || sameSymbol(b5.base, tokenB) && sameSymbol(b5.quote, tokenA)
   );
   if (!book) throw new OrderbookRequestError(`no book trades ${tokenA} for ${tokenB}`);
   return book;
 }
+function optionalBigInt(value) {
+  return value === null ? null : BigInt(value);
+}
 function parseRate(raw) {
   return {
     side: raw.side,
@@ -214282,24 +214294,32 @@ function toRoute(tokenIn, tokenOut) {
 function requiredInput(side, amountOut, rate) {
   return side === "BID" ? divCeil(amountOut * ORDERBOOK_SCALE, rate) : divCeil(amountOut * rate, ORDERBOOK_SCALE);
 }
-function buildQuote(tradeType, amountIn, amountOut, quote, tokenIn, tokenOut) {
-  if (quote.rate === null) throw new OrderbookRequestError("the orderbook served a fillable quote with no rate");
-  const [base32, quoteToken] = quote.side === "BID" ? [tokenIn, tokenOut] : [tokenOut, tokenIn];
+function swapQuoteTotals(quote) {
+  const worstFill = quote.fills.at(-1);
+  if (quote.fillable && !worstFill)
+    throw new OrderbookRequestError("the orderbook served a fillable quote with no fills");
   return {
-    tradeType,
-    amountIn,
-    amountOut,
-    quoteMetadata: {
-      sourceChain: tokenIn.chain,
-      destinationChain: tokenOut.chain,
-      route: quote.route,
-      side: quote.side,
-      baseTokenSymbol: base32.symbol,
-      quoteTokenSymbol: quoteToken.symbol,
-      rate: format(quote.rate),
-      maxFillableIn: fromOrderbookAmount(quote.maxFillableIn, tokenIn.decimals),
-      orderCount: quote.fills.length
-    }
+    side: quote.side,
+    amountIn: quote.amountIn,
+    amountOut: quote.fills.reduce((total, fill) => total + fill.amountOut, 0n),
+    fillable: quote.fillable,
+    maxFillableIn: quote.maxFillableIn,
+    worstIn: worstFill?.amountIn ?? 0n,
+    worstOut: worstFill?.amountOut ?? 0n
+  };
+}
+function levelQuoteTotals(quote) {
+  if (quote.fillable && quote.rate === null) {
+    throw new OrderbookRequestError("the orderbook served a fillable quote with no rate");
+  }
+  return {
+    side: quote.side,
+    amountIn: quote.amountIn,
+    amountOut: quote.amountOut,
+    fillable: quote.fillable,
+    maxFillableIn: quote.maxFillableIn,
+    worstIn: quote.amountIn,
+    worstOut: quote.amountOut
   };
 }
 function toOrderbookAmount(amount, decimals) {
@@ -214385,7 +214405,7 @@ function encodePhantomBidDeclaration(declaration) {
   }
   return u8aToHex(new Uint8Array(bytes4));
 }
-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, GasEstimator, OrderStatusChecker, ORDERBOOK_URLS, ORDERBOOK_DECIMALS, ORDERBOOK_SCALE, OrderbookRequestError, RATE_FIELDS, TOP_OF_BOOK_QUERY, ROUTE_LIQUIDITY_QUERY, QUOTE_QUERY, HyperFxOrderbook, UnsupportedLiquidityAssetError, UnsupportedLiquidityChainError, OrderbookQuoteNotConvergedError, InsufficientOrderbookLiquidityError, MAX_EXACT_OUTPUT_ROUNDS, OrderbookMarket, ORDER_FEE_GAS_PRICE_BUMP_POLICY, 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, 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, ORDER_FEE_GAS_PRICE_BUMP_POLICY, 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";
@@ -227805,6 +227825,10 @@ query OrderStatus($commitment: String!) {
     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";
+    SELECTED_BID_SIGNATURE_BYTES = 32 + 65 + 65;
+    BID_PVG_HEADROOM_PERCENT = 10n;
+    ESCROW_MAPPING_SLOT = 9n;
     GasEstimator = class {
       /**
        * @param ctx - Shared IntentsV2 context providing the source and destination
@@ -227883,6 +227907,7 @@ query OrderStatus($commitment: String!) {
           assetsForOverrides.push({ token: feeTokenAsBytes32, amount: 0n });
         }
         const isSameChain = souceStateMachineId === destStateMachineId;
+        const commitment = orderCommitment(order);
         const [stateOverridesResult, crossChainFees] = await Promise.all([
           this.ctx.bundlerUrl ? this.buildStateOverride({
             accountAddress: solverAccountAddress,
@@ -227890,7 +227915,16 @@ query OrderStatus($commitment: String!) {
             outputAssets: assetsForOverrides,
             spenderAddress: intentGatewayV2Address,
             intentGatewayV2Address,
-            entryPointAddress
+            entryPointAddress,
+            // A fee quote runs before the order is placed, so nothing is escrowed under
+            // its commitment yet. Cross-chain fills release escrow on the source chain.
+            escrow: isSameChain ? {
+              commitment,
+              inputs: order.inputs.map((input) => ({
+                token: normalizeAddressForEvmBytes32(input.token),
+                amount: input.amount
+              }))
+            } : void 0
           }) : Promise.resolve({ viem: [], bundler: {} }),
           isSameChain ? Promise.resolve({ postRequestFee: 0n, relayerFeeInSourceFeeToken: 0n }) : this.estimateCrossChainFees(
             sourceFeeToken,
@@ -227919,10 +227953,8 @@ query OrderStatus($commitment: String!) {
         const maxFeeBumpPercent = params.maxFeePerGasBumpPercent ?? 10;
         let maxPriorityFeePerGas = gasPrice + gasPrice * BigInt(priorityFeeBumpPercent) / 100n;
         let maxFeePerGas = gasPrice + gasPrice * BigInt(maxFeeBumpPercent) / 100n;
-        const orderForEstimation = { ...order, session: solverAccountAddress };
-        const commitment = orderCommitment(orderForEstimation);
         await assertGatewayRelease(this.ctx.dest.client, intentGatewayV2Address);
-        const fillOrderCalldata = encodeFillOrder(transformOrderForContract(orderForEstimation), fillOptions);
+        const fillOrderCalldata = encodeFillOrder(transformOrderForContract(order), fillOptions);
         let callGasLimit = 500000n;
         let verificationGasLimit = 100000n;
         let preVerificationGas = 100000n;
@@ -227934,7 +227966,7 @@ query OrderStatus($commitment: String!) {
               ...params.prependCalls ?? [],
               { target: intentGatewayV2Address, value: totalNativeValue, data: fillOrderCalldata }
             ]);
-            const accountGasLimits = CryptoUtils.packGasLimits(100000n, callGasLimit);
+            const accountGasLimits = CryptoUtils.packGasLimits(0n, 0n);
             const gasFees = CryptoUtils.packGasFees(maxPriorityFeePerGas, maxFeePerGas);
             const nonce = 0n;
             const preliminaryUserOp = {
@@ -227943,7 +227975,7 @@ query OrderStatus($commitment: String!) {
               initCode: "0x",
               callData,
               accountGasLimits,
-              preVerificationGas: 100000n,
+              preVerificationGas: 0n,
               gasFees,
               paymasterAndData: "0x",
               signature: "0x"
@@ -228073,6 +228105,53 @@ query OrderStatus($commitment: String!) {
           inputs
         };
       }
+      /**
+       * 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.
+       *
+       * On an L2, `preVerificationGas` also pays the L1 data fee for the op's bytes, a fixed
+       * amount of wei that the bundler converts to gas at the price the op pays. A bundler
+       * admits an op priced at its `maxFeePerGas`, but bundles it at the base fee plus its
+       * priority fee, where the same wei costs more gas. An op sized only for admission is
+       * accepted and then skipped in every bundle until it expires. The estimate is taken
+       * at the bundle's price: the latest base fee plus the op's priority fee, capped at its
+       * `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.
+       *
+       * @param params - The bid's fields as they will be signed.
+       * @returns The `preVerificationGas` to sign, with {@link BID_PVG_HEADROOM_PERCENT} added.
+       * @throws If no bundler is configured or the bundler rejects the estimate.
+       */
+      async estimateBidPreVerificationGas(params) {
+        const { solverAccount, maxFeePerGas, maxPriorityFeePerGas } = params;
+        const latestBlock = await this.ctx.dest.client.getBlock({ blockTag: "latest" });
+        const baseFeePerGas = latestBlock.baseFeePerGas;
+        const bundlePrice = baseFeePerGas == null || baseFeePerGas + maxPriorityFeePerGas > maxFeePerGas ? maxFeePerGas : baseFeePerGas + maxPriorityFeePerGas;
+        const priorityFee = maxPriorityFeePerGas < bundlePrice ? maxPriorityFeePerGas : bundlePrice;
+        const userOp = {
+          sender: solverAccount,
+          nonce: params.nonce,
+          initCode: "0x",
+          callData: params.callData,
+          accountGasLimits: CryptoUtils.packGasLimits(params.verificationGasLimit, params.callGasLimit),
+          // Bundlers return a non-zero preVerificationGas as given rather than estimating it.
+          preVerificationGas: 0n,
+          gasFees: CryptoUtils.packGasFees(priorityFee, bundlePrice),
+          paymasterAndData: params.paymasterAndData ?? "0x",
+          signature: `0x${"ff".repeat(SELECTED_BID_SIGNATURE_BYTES)}`
+        };
+        const estimate = await this.crypto.sendBundler(
+          BundlerMethod.ETH_ESTIMATE_USER_OPERATION_GAS,
+          [
+            CryptoUtils.prepareBundlerCall(userOp),
+            params.entryPointAddress,
+            { [solverAccount]: { code: BID_PVG_ESTIMATION_ACCOUNT_CODE } }
+          ]
+        );
+        return BigInt(estimate.preVerificationGas) * (100n + BID_PVG_HEADROOM_PERCENT) / 100n;
+      }
       /**
        * Estimates the cross-chain ISMP POST request fee (the relayer fee for the
        * RedeemEscrow message), in both the source and destination fee tokens.
@@ -228125,20 +228204,38 @@ query OrderStatus($commitment: String!) {
        * @returns An object with `viem` and `bundler` state-override collections.
        */
       async buildStateOverride(params) {
-        const { accountAddress, chain: chain2, outputAssets, spenderAddress, intentGatewayV2Address, entryPointAddress } = params;
-        const testValue = toHex3(maxUint2563 / 2n, { size: 32 });
+        const {
+          accountAddress,
+          chain: chain2,
+          outputAssets,
+          spenderAddress,
+          intentGatewayV2Address,
+          entryPointAddress,
+          escrow
+        } = params;
+        const testValue = toHex3(2n ** 128n, { size: 32 });
         const viemOverrides = [];
         const bundlerOverrides = {};
         if (intentGatewayV2Address) {
           const paramsSlot5 = pad4(toHex3(5n), { size: 32 });
           const dispatcherAddress = this.ctx.dest.configService.getCalldispatcherAddress(chain2);
           const newSlot5Value = "0x" + "0".repeat(22) + "00" + dispatcherAddress.slice(2).toLowerCase();
+          const gatewayDiffs = [{ slot: paramsSlot5, value: newSlot5Value }];
+          for (const [leg, input] of (escrow?.inputs ?? []).entries()) {
+            gatewayDiffs.push({
+              slot: escrowSlot(escrow.commitment, leg),
+              value: toHex3(input.amount, { size: 32 })
+            });
+          }
+          const releasesNative = escrow?.inputs.some((input) => bytes32ToBytes20(input.token) === ADDRESS_ZERO2);
           viemOverrides.push({
             address: intentGatewayV2Address,
-            stateDiff: [{ slot: paramsSlot5, value: newSlot5Value }]
+            ...releasesNative ? { balance: 2n ** 128n } : {},
+            stateDiff: gatewayDiffs
           });
           bundlerOverrides[intentGatewayV2Address] = {
-            stateDiff: { [paramsSlot5]: newSlot5Value }
+            ...releasesNative ? { balance: testValue } : {},
+            stateDiff: Object.fromEntries(gatewayDiffs.map(({ slot, value }) => [slot, value]))
           };
         }
         if (entryPointAddress) {
@@ -228174,6 +228271,25 @@ query OrderStatus($commitment: String!) {
             bundlerOverrides[result.address] = { stateDiff: result.bundlerStateDiffs };
           }
         }
+        if (intentGatewayV2Address && escrow) {
+          const gatewayBalances = await Promise.all(
+            escrow.inputs.map((input) => this.tokenBalanceSlot(input.token, intentGatewayV2Address, chain2))
+          );
+          for (const override of gatewayBalances) {
+            if (!override) continue;
+            const existing = viemOverrides.find((entry) => entry.address === override.address && entry.stateDiff);
+            if (existing) existing.stateDiff.push({ slot: override.slot, value: testValue });
+            else
+              viemOverrides.push({
+                address: override.address,
+                stateDiff: [{ slot: override.slot, value: testValue }]
+              });
+            bundlerOverrides[override.address] = {
+              ...bundlerOverrides[override.address],
+              stateDiff: { ...bundlerOverrides[override.address]?.stateDiff, [override.slot]: testValue }
+            };
+          }
+        }
         const solverAccountContract = this.ctx.dest.configService.getSolverAccountAddress(chain2);
         if (solverAccountContract) {
           try {
@@ -228196,6 +228312,21 @@ query OrderStatus($commitment: String!) {
         }
         return { viem: viemOverrides, bundler: bundlerOverrides };
       }
+      /**
+       * The balance slot of `holder` in an ERC-20 token, for overriding. `null` for the native
+       * token or when the slot cannot be discovered.
+       */
+      async tokenBalanceSlot(tokenHex, holder, chain2) {
+        const tokenAddress = bytes32ToBytes20(tokenHex);
+        if (tokenAddress === ADDRESS_ZERO2) return null;
+        try {
+          const balanceData = "0x70a08231" + bytes20ToBytes32(holder).slice(2);
+          const slot = await getOrFetchStorageSlot(this.ctx.dest.client, chain2, tokenAddress, balanceData);
+          return slot ? { address: tokenAddress, slot } : null;
+        } catch {
+          return null;
+        }
+      }
       /**
        * Resolves the balance and allowance storage slot overrides for a single
        * ERC-20 token in parallel.  Returns `null` for native-ETH tokens or when
@@ -228328,14 +228459,20 @@ query TopOfBook($tokenA: String!, $tokenB: String!, $fillChain: String!, $source
 query RouteLiquidity($route: RouteInput!) {
   books { id base quote }
   routeLiquidity(route: $route) {
-    route bestRate depthIn depthOut availableLiquidity maxFillableIn orderCount solverCount
+    route bestRate slippageBps depthIn depthOut availableLiquidity maxFillableIn orderCount solverCount
   }
 }`;
     QUOTE_QUERY = `
 query Quote($route: RouteInput!, $amountIn: BigInt!) {
   quote(route: $route, amountIn: $amountIn) {
-    route side amountIn amountOut rate fillable depth maxFillableIn
-    fills { orderRate amountOut advertisedSize }
+    route side amountIn slippageBps fillable maxFillableIn
+    fills { advertisedSize orderRate amountIn amountOut }
+  }
+}`;
+    QUOTE_PESSIMISTIC_QUERY = `
+query QuotePessimistic($route: RouteInput!, $amountIn: BigInt!) {
+  quotePessimistic(route: $route, amountIn: $amountIn) {
+    route side amountIn amountOut rate priceBucket slippageBps fillable maxFillableIn
   }
 }`;
     HyperFxOrderbook = class {
@@ -228365,8 +228502,9 @@ query Quote($route: RouteInput!, $amountIn: BigInt!) {
         return {
           route: raw.route,
           book,
-          side: book.base === route.tokenIn ? "BID" : "ASK",
-          bestRate: raw.bestRate === null ? null : BigInt(raw.bestRate),
+          side: sameSymbol(book.base, route.tokenIn) ? "BID" : "ASK",
+          bestRate: optionalBigInt(raw.bestRate),
+          slippageBps: raw.slippageBps,
           depthIn: BigInt(raw.depthIn),
           depthOut: BigInt(raw.depthOut),
           availableLiquidity: BigInt(raw.availableLiquidity),
@@ -228375,7 +228513,10 @@ query Quote($route: RouteInput!, $amountIn: BigInt!) {
           solverCount: raw.solverCount
         };
       }
-      /** The clearing price for `amountIn` (1e18 tokenIn) on a route, which may combine several solvers' orders. */
+      /**
+       * The optimistic quote for `amountIn` (1e18 tokenIn) on a route: the route's orders, best price
+       * first, each taking what it can at its own price. The fills' `amountOut`s sum to the output.
+       */
       async quote(route, amountIn) {
         const { quote: raw } = await this.request(QUOTE_QUERY, {
           route,
@@ -228385,18 +228526,39 @@ query Quote($route: RouteInput!, $amountIn: BigInt!) {
           route: raw.route,
           side: raw.side,
           amountIn: BigInt(raw.amountIn),
-          amountOut: BigInt(raw.amountOut),
-          rate: raw.rate === null ? null : BigInt(raw.rate),
+          slippageBps: raw.slippageBps,
           fillable: raw.fillable,
-          depth: BigInt(raw.depth),
           maxFillableIn: BigInt(raw.maxFillableIn),
           fills: raw.fills.map((fill) => ({
+            advertisedSize: BigInt(fill.advertisedSize),
             orderRate: BigInt(fill.orderRate),
-            amountOut: BigInt(fill.amountOut),
-            advertisedSize: BigInt(fill.advertisedSize)
+            amountIn: BigInt(fill.amountIn),
+            amountOut: BigInt(fill.amountOut)
           }))
         };
       }
+      /**
+       * The pessimistic quote for `amountIn` (1e18 tokenIn) on a route: one price, from the first level
+       * deep enough to fill the whole trade by itself, at which every order in it fills; the route's
+       * worst price when no one level can but its levels together can.
+       */
+      async quotePessimistic(route, amountIn) {
+        const { quotePessimistic: raw } = await this.request(
+          QUOTE_PESSIMISTIC_QUERY,
+          { route, amountIn: amountIn.toString() }
+        );
+        return {
+          route: raw.route,
+          side: raw.side,
+          amountIn: BigInt(raw.amountIn),
+          amountOut: BigInt(raw.amountOut),
+          rate: optionalBigInt(raw.rate),
+          priceBucket: optionalBigInt(raw.priceBucket),
+          slippageBps: raw.slippageBps,
+          fillable: raw.fillable,
+          maxFillableIn: BigInt(raw.maxFillableIn)
+        };
+      }
       async request(query3, variables) {
         try {
           return await this.client.request(query3, variables);
@@ -228431,18 +228593,6 @@ query Quote($route: RouteInput!, $amountIn: BigInt!) {
         this.name = "OrderbookQuoteNotConvergedError";
       }
     };
-    InsufficientOrderbookLiquidityError = class extends Error {
-      constructor(route, maxFillableIn) {
-        super(
-          `The HyperFX orderbook cannot fill ${route.tokenIn} -> ${route.tokenOut} on ${route.sourceChain} -> ${route.destinationChain}; max fillable input is ${maxFillableIn} raw units`
-        );
-        __publicField(this, "route");
-        __publicField(this, "maxFillableIn");
-        this.route = route;
-        this.maxFillableIn = maxFillableIn;
-        this.name = "InsufficientOrderbookLiquidityError";
-      }
-    };
     MAX_EXACT_OUTPUT_ROUNDS = 16;
     OrderbookMarket = class {
       constructor(configService, orderbook) {
@@ -228452,26 +228602,67 @@ query Quote($route: RouteInput!, $amountIn: BigInt!) {
         this.orderbook = orderbook;
       }
       async quoteIntent(params, sourceChain, destinationChain) {
+        const orderbook = this.orderbook();
+        if (!params.optimistic) {
+          const { quote: quote2, tokenIn: tokenIn2, tokenOut: tokenOut2 } = await this.priceIntent(
+            params,
+            sourceChain,
+            destinationChain,
+            (route, amountIn) => orderbook.quotePessimistic(route, amountIn),
+            levelQuoteTotals
+          );
+          return {
+            route: quote2.route,
+            side: quote2.side,
+            amountIn: fromOrderbookAmount(quote2.amountIn, tokenIn2.decimals),
+            amountOut: fromOrderbookAmount(quote2.amountOut, tokenOut2.decimals),
+            rate: quote2.rate,
+            priceBucket: quote2.priceBucket,
+            slippageBps: quote2.slippageBps,
+            fillable: quote2.fillable,
+            maxFillableIn: fromOrderbookAmount(quote2.maxFillableIn, tokenIn2.decimals)
+          };
+        }
+        const { quote, tokenIn, tokenOut } = await this.priceIntent(
+          params,
+          sourceChain,
+          destinationChain,
+          (route, amountIn) => orderbook.quote(route, amountIn),
+          swapQuoteTotals
+        );
+        return {
+          route: quote.route,
+          side: quote.side,
+          amountIn: fromOrderbookAmount(quote.amountIn, tokenIn.decimals),
+          slippageBps: quote.slippageBps,
+          fillable: quote.fillable,
+          maxFillableIn: fromOrderbookAmount(quote.maxFillableIn, tokenIn.decimals),
+          legs: quote.fills.map((fill) => ({
+            advertisedSize: fromOrderbookAmount(fill.advertisedSize, tokenOut.decimals),
+            orderRate: fill.orderRate,
+            amountIn: fromOrderbookAmount(fill.amountIn, tokenIn.decimals),
+            amountOut: fromOrderbookAmount(fill.amountOut, tokenOut.decimals)
+          }))
+        };
+      }
+      /**
+       * The orderbook's quote for an exact input, or for the input found to deliver
+       * an exact output, with the assets it trades. A route that cannot fill the
+       * trade answers with an unfillable quote rather than an error.
+       */
+      async priceIntent(params, sourceChain, destinationChain, price, totals) {
         validateQuoteParams(params);
         const tokenIn = this.assetByAddress(sourceChain, params.tokenIn);
         const tokenOut = this.assetByAddress(destinationChain, params.tokenOut);
         const route = toRoute(tokenIn, tokenOut);
         if (params.amountIn !== void 0) {
-          const quote2 = await this.orderbook().quote(route, toOrderbookAmount(params.amountIn, tokenIn.decimals));
-          const amountOut2 = quote2.fillable ? fromOrderbookAmount(quote2.amountOut, tokenOut.decimals) : 0n;
-          if (amountOut2 === 0n) throw this.insufficient(route, quote2.maxFillableIn, tokenIn);
-          return buildQuote("EXACT_INPUT", params.amountIn, amountOut2, quote2, tokenIn, tokenOut);
+          const quote2 = await price(route, toOrderbookAmount(params.amountIn, tokenIn.decimals));
+          totals(quote2);
+          return { quote: quote2, tokenIn, tokenOut };
         }
-        const amountOut = params.amountOut;
-        const quote = await this.quoteExactOutput(route, toOrderbookAmount(amountOut, tokenOut.decimals), tokenIn);
-        return buildQuote(
-          "EXACT_OUTPUT",
-          fromOrderbookAmount(quote.amountIn, tokenIn.decimals),
-          amountOut,
-          quote,
-          tokenIn,
-          tokenOut
-        );
+        const targetOut = toOrderbookAmount(params.amountOut, tokenOut.decimals);
+        const quote = await this.quoteExactOutput(route, targetOut, tokenIn, price, totals);
+        return { quote, tokenIn, tokenOut };
       }
       async availableLiquidity(params, sourceChain, destinationChain) {
         const tokenIn = this.assetByAddress(sourceChain, params.tokenIn);
@@ -228524,22 +228715,29 @@ query Quote($route: RouteInput!, $amountIn: BigInt!) {
       }
       /**
        * The orderbook only quotes an input amount, so an output is priced by
-       * guessing the input from the best rate and raising it at each clearing
-       * price until the quote delivers `targetOut`.
+       * guessing the input from the best rate, then keeping the part of each quote
+       * filled better than its worst rate and re-pricing the rest of `targetOut` at
+       * the input-to-output ratio that part filled at, until a quote delivers it.
+       * That ratio is the orderbook's own, with the protocol fee already taken off.
+       *
+       * An output the route cannot deliver is answered by quoting an input past its
+       * `maxFillableIn`, which the orderbook serves as unfillable: the smallest such
+       * input guessed from the best rate, or one raw unit when no order serves it.
        */
-      async quoteExactOutput(route, targetOut, tokenIn) {
-        const orderbook = this.orderbook();
-        const liquidity = await orderbook.routeLiquidity(route);
-        if (liquidity.bestRate === null) throw this.insufficient(route, 0n, tokenIn);
+      async quoteExactOutput(route, targetOut, tokenIn, price, totals) {
+        const liquidity = await this.orderbook().routeLiquidity(route);
         const inputUnit = toOrderbookAmount(1n, tokenIn.decimals);
-        let amountIn = roundUpTo(requiredInput(liquidity.side, targetOut, liquidity.bestRate), inputUnit);
+        let amountIn = liquidity.bestRate === null ? inputUnit : roundUpTo(requiredInput(liquidity.side, targetOut, liquidity.bestRate), inputUnit);
         let lastAmountIn = amountIn;
         for (let round2 = 0; round2 < MAX_EXACT_OUTPUT_ROUNDS; round2++) {
-          if (amountIn > liquidity.maxFillableIn) throw this.insufficient(route, liquidity.maxFillableIn, tokenIn);
-          const quote = await orderbook.quote(route, amountIn);
-          if (quote.fillable && quote.amountOut >= targetOut) return quote;
+          const served = await price(route, amountIn);
+          const quote = totals(served);
+          if (quote.fillable && quote.amountOut >= targetOut) return served;
+          if (!quote.fillable && amountIn > liquidity.maxFillableIn) return served;
           lastAmountIn = amountIn;
-          const next = quote.rate === null ? amountIn : roundUpTo(requiredInput(quote.side, targetOut, quote.rate), inputUnit);
+          const betterIn = quote.amountIn - quote.worstIn;
+          const betterOut = quote.amountOut - quote.worstOut;
+          const next = quote.fillable && quote.worstOut > 0n ? betterIn + roundUpTo(divCeil((targetOut - betterOut) * quote.worstIn, quote.worstOut), inputUnit) : amountIn;
           amountIn = next > amountIn ? next : amountIn + inputUnit;
         }
         throw new OrderbookQuoteNotConvergedError(
@@ -228548,9 +228746,6 @@ query Quote($route: RouteInput!, $amountIn: BigInt!) {
           fromOrderbookAmount(lastAmountIn, tokenIn.decimals)
         );
       }
-      insufficient(route, maxFillableIn, tokenIn) {
-        return new InsufficientOrderbookLiquidityError(route, fromOrderbookAmount(maxFillableIn, tokenIn.decimals));
-      }
       assetByAddress(chain2, address) {
         const resolvedChain = resolveChain(chain2);
         return withDecimals(
@@ -228709,22 +228904,6 @@ query Quote($route: RouteInput!, $amountIn: BigInt!) {
         this.orderbook = typeof orderbook === "string" ? new HyperFxOrderbook(orderbook) : orderbook;
         return this;
       }
-      /**
-       * Quotes an intent between this gateway's source and destination chains from
-       * the HyperFX orderbook. Provide exactly one of `amountIn` or `amountOut`, in
-       * raw token units.
-       *
-       * An exact-input quote is the orderbook's clearing price for `amountIn`,
-       * which may combine several solvers' orders. An exact-output quote finds the
-       * smallest input whose clearing price delivers `amountOut`. A cross-chain
-       * route only counts orders whose solvers accept the source chain.
-       *
-       * The orderbook's rates already carry the gateway protocol fee, so the
-       * returned amounts can be placed as the order's inputs and outputs directly.
-       *
-       * @throws {InsufficientOrderbookLiquidityError} When the route cannot fill the amount.
-       * @throws {OrderbookRequestError} When the orderbook is unreachable or trades no book for the pair.
-       */
       async quoteIntent(params) {
         return this.market.quoteIntent(params, this.source.config.stateMachineId, this.dest.config.stateMachineId);
       }
@@ -229139,6 +229318,16 @@ query Quote($route: RouteInput!, $amountIn: BigInt!) {
       async estimateFillOrder(params) {
         return this.gasEstimator.estimateFillOrder(params);
       }
+      /**
+       * Asks the bundler for the `preVerificationGas` of a bid as it will be signed, priced at
+       * the gas price its bundle pays. Call it with the final calldata and `paymasterAndData`,
+       * before {@link prepareSubmitBid} signs the op.
+       *
+       * Delegates to {@link GasEstimator.estimateBidPreVerificationGas}.
+       */
+      async estimateBidPreVerificationGas(params) {
+        return this.gasEstimator.estimateBidPreVerificationGas(params);
+      }
       /**
        * Quotes the solver fee for an order using the same policy {@link execute} /
        * {@link executeBest} apply when `order.fees` is `0n`.
@@ -229954,6 +230143,7 @@ var init_external_links = __esm({
   "src/config/external-links.json"() {
     external_links_default = {
       hyperfxApp: "https://app.hyperfx.finance",
+      alchemyDashboard: "https://dashboard.alchemy.com/",
       hyperbridgeExplorers: {
         mainnet: "https://nexus.statescan.io",
         testnet: "https://gargantua.statescan.io"
@@ -229987,12 +230177,58 @@ function chainByChainId(chainId) {
 function chainByAlchemySubdomain(subdomain) {
   return INIT_CHAINS.find((chain2) => chain2.alchemySubdomain === subdomain);
 }
-var CHAIN_NATIVE_SYMBOLS, INIT_CHAINS, HYPERBRIDGE_WS_DEFAULTS;
+var FREE_RPC_URLS, CHAIN_NATIVE_SYMBOLS, INIT_CHAINS, HYPERBRIDGE_WS_DEFAULTS;
 var init_chains2 = __esm({
   "src/cli/init/chains.ts"() {
     "use strict";
     init_esm_shims();
     init_external_links();
+    FREE_RPC_URLS = {
+      1: [
+        "https://mainnet.gateway.tenderly.co",
+        "https://rpc.mevblocker.io",
+        "https://ethereum-rpc.publicnode.com",
+        "https://ethereum.public.blockpi.network/v1/rpc/public",
+        "https://eth.blockrazor.xyz",
+        "https://eth.api.pocket.network",
+        "https://ethereum-public.nodies.app",
+        "https://eth-mainnet.public.blastapi.io",
+        "https://public-eth.nownodes.io"
+      ],
+      56: [
+        "https://bsc-rpc.publicnode.com",
+        "https://public-bsc-mainnet.fastnode.io",
+        "https://public-bsc.nownodes.io",
+        "https://bsc.blockrazor.xyz",
+        "https://rpc-bsc.48.club",
+        "https://bsc.api.pocket.network"
+      ],
+      137: [
+        "https://polygon-bor-rpc.publicnode.com",
+        "https://polygon.drpc.org",
+        "https://polygon.gateway.tenderly.co",
+        "https://rpc.private.mev-x.com/polygon",
+        "https://poly.api.pocket.network"
+      ],
+      8453: [
+        "https://base-rpc.publicnode.com",
+        "https://base.gateway.tenderly.co",
+        "https://base.public.blockpi.network/v1/rpc/public",
+        "https://base.rpc.blxrbdn.com",
+        "https://rpc.baseazul.dev",
+        "https://mainnet.base.org",
+        "https://base-public.nodies.app"
+      ],
+      42161: [
+        "https://arbitrum-one-rpc.publicnode.com",
+        "https://arbitrum.gateway.tenderly.co",
+        "https://arbitrum.drpc.org",
+        "https://public-arb-mainnet.fastnode.io",
+        "https://arb-one.api.pocket.network",
+        "https://arbitrum-one-public.nodies.app",
+        "https://arb1.arbitrum.io/rpc"
+      ]
+    };
     CHAIN_NATIVE_SYMBOLS = {
       1: "ETH",
       56: "BNB",
@@ -230017,7 +230253,8 @@ var init_chains2 = __esm({
         label: "Ethereum",
         network: "mainnet",
         alchemySubdomain: "eth-mainnet",
-        explorerUrl: external_links_default.chainExplorers.ethereum
+        explorerUrl: external_links_default.chainExplorers.ethereum,
+        defaultRpcUrls: FREE_RPC_URLS[1]
       },
       {
         chainId: 42161,
@@ -230025,7 +230262,8 @@ var init_chains2 = __esm({
         label: "Arbitrum",
         network: "mainnet",
         alchemySubdomain: "arb-mainnet",
-        explorerUrl: external_links_default.chainExplorers.arbitrum
+        explorerUrl: external_links_default.chainExplorers.arbitrum,
+        defaultRpcUrls: FREE_RPC_URLS[42161]
       },
       {
         chainId: 8453,
@@ -230033,7 +230271,8 @@ var init_chains2 = __esm({
         label: "Base",
         network: "mainnet",
         alchemySubdomain: "base-mainnet",
-        explorerUrl: external_links_default.chainExplorers.base
+        explorerUrl: external_links_default.chainExplorers.base,
+        defaultRpcUrls: FREE_RPC_URLS[8453]
       },
       {
         chainId: 137,
@@ -230041,7 +230280,8 @@ var init_chains2 = __esm({
         label: "Polygon",
         network: "mainnet",
         alchemySubdomain: "polygon-mainnet",
-        explorerUrl: external_links_default.chainExplorers.polygon
+        explorerUrl: external_links_default.chainExplorers.polygon,
+        defaultRpcUrls: FREE_RPC_URLS[137]
       },
       {
         chainId: 56,
@@ -230049,7 +230289,8 @@ var init_chains2 = __esm({
         label: "BNB Chain",
         network: "mainnet",
         alchemySubdomain: "bnb-mainnet",
-        explorerUrl: external_links_default.chainExplorers.bnb
+        explorerUrl: external_links_default.chainExplorers.bnb,
+        defaultRpcUrls: FREE_RPC_URLS[56]
       },
       {
         chainId: 11155111,
@@ -295054,12 +295295,12 @@ var init_lib3 = __esm({
         return Promise.resolve(ab);
       }
       stream() {
-        const readable = new Readable3();
-        readable._read = function() {
+        const readable2 = new Readable3();
+        readable2._read = function() {
         };
-        readable.push(this[BUFFER]);
-        readable.push(null);
-        return readable;
+        readable2.push(this[BUFFER]);
+        readable2.push(null);
+        return readable2;
       }
       toString() {
         return "[object Blob]";
@@ -316113,6 +316354,19 @@ async function collectRpcUrls(state, prefill) {
   for (const chain2 of state.chains) {
     const existing = prefillRpcFor(chain2.meta.chainId, prefill);
     const derived2 = alchemy.candidate(chain2.meta.chainId);
+    const bundled = chain2.meta.defaultRpcUrls;
+    if (!existing?.length && !derived2 && bundled?.length) {
+      const usePublic = guard(
+        await confirm({
+          message: `Use ${bundled.length} public RPC endpoints for ${chain2.meta.label}?`,
+          initialValue: true
+        })
+      );
+      if (usePublic) {
+        chain2.rpcUrls = [...bundled];
+        continue;
+      }
+    }
     let url2;
     if (existing?.length) {
       url2 = await askRpcUrl(chain2.meta, existing[0]);
@@ -316290,6 +316544,22 @@ async function stepBundlers(state, prefill) {
       for (const chain2 of alchemyChains) chain2.bundlerUrl = chain2.rpcUrls[0];
     }
   }
+  const alchemyCapable = state.chains.filter((chain2) => !chain2.bundlerUrl && chain2.meta.alchemySubdomain);
+  if (alchemyCapable.length > 0) {
+    const useKey = guard(
+      await confirm({
+        message: `Configure the bundler for ${alchemyCapable.map((c6) => c6.meta.label).join(", ")} from one Alchemy API key?`,
+        initialValue: true
+      })
+    );
+    if (useKey) {
+      const apiKey = await askSecret("Alchemy API key");
+      for (const chain2 of alchemyCapable) {
+        const url2 = deriveAlchemyRpc(apiKey, chain2.meta.chainId);
+        if (url2) chain2.bundlerUrl = url2;
+      }
+    }
+  }
   const pimlico = new ProviderDerivation({
     detect: (url2) => parsePimlicoUrl(url2)?.apiKey ?? null,
     derive: derivePimlicoBundler,
@@ -319025,14 +319295,16 @@ var LimitOrderService = class {
     }
   }
   /**
-   * The pairs an order can be written against, and the smallest payout each token may carry.
+   * The pairs an order can be written against, the smallest payout each token may carry, and
+   * the tokens the orderbook registers on each chain.
    *
    * The orderbook lists the books; `resolveBook` refuses a request naming anything else, so the
-   * operator is offered exactly these and no combination of symbols they could not post.
+   * operator is offered exactly these and no combination of symbols they could not post. The
+   * chains do the same for the source chains an order can accept.
    */
   async books() {
     const limits = await this.limits();
-    return { books: limits.books, minOrderSizes: limits.serverInfo.minOrderSizes };
+    return { books: limits.books, minOrderSizes: limits.serverInfo.minOrderSizes, chains: limits.chains ?? [] };
   }
   /**
    * Reads `serverInfo` and `books`, reusing the last read for {@link LIMITS_TTL_MS}.
@@ -319114,6 +319386,18 @@ var LimitOrderService = class {
         );
       }
     }
+    if (book.base !== book.quote) {
+      const input = normalizeSymbol(request3.tokenIn);
+      const lacking = sources.filter((source) => {
+        const listed = limits.chains?.find((chain2) => chain2.id === source);
+        return listed && !listed.tokens.some((token) => normalizeSymbol(token.symbol) === input);
+      });
+      if (lacking.length > 0) {
+        throw new LimitOrderValidationError(
+          `The orderbook has no ${request3.tokenIn} on ${lacking.join(", ")}, so swaps from there cannot pay this order`
+        );
+      }
+    }
     if (ttlSecs < limits.serverInfo.minOrderTtlSecs) {
       throw new LimitOrderValidationError(
         `ttlSecs must be at least the orderbook's minimum of ${limits.serverInfo.minOrderTtlSecs}; got ${ttlSecs}`
@@ -320776,7 +321060,7 @@ var NotificationService = class extends EventEmitter6 {
           title: "Swap filled",
           body: swapBody(event),
           tag: `simplex-swap-${id2}`,
-          url: "./orders"
+          url: "./history"
         }).catch((error) => this.logger.error({ err: error }, "Could not publish swap notification"));
       }
     };
@@ -320969,6 +321253,7 @@ init_chains2();
 init_alchemy();
 init_prompt_utils();
 init_state();
+init_defaults8();
 init_Logger();
 var logger2 = getLogger("setup");
 async function defaultRpcRequest(url2, method, params) {
@@ -321015,6 +321300,18 @@ async function handleSetupRequest(server, setup, req, res, path2, method) {
     };
     return sendJson(res, 200, defaults3);
   }
+  if (endpoint === "orderbook") {
+    if (method !== "GET") return sendJson(res, 405, { error: "Method not allowed" });
+    const url2 = DEFAULT_ORDERBOOK_URLS.mainnet;
+    try {
+      const { books } = await new OrderbookClient(url2, DEFAULT_ORDERBOOK_TIMEOUT_MS).limits();
+      const orderbook = { url: url2, books };
+      return sendJson(res, 200, orderbook);
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      return sendJson(res, 502, { error: `Could not read the orderbook's markets: ${reason}` });
+    }
+  }
   if (method !== "POST") return sendJson(res, 405, { error: "Method not allowed" });
   let body;
   try {
@@ -323326,14 +323623,10 @@ var RATE_LIMIT_RPC_CODES = /* @__PURE__ */ new Set([-32005, -32097, -32016, 429]
 var RATE_LIMIT_SUSPENSION_MS = 5 * 6e4;
 var SCAN_BUDGET = {
   timeoutMs: 5e3,
-  retryCount: 1,
-  retryDelayMs: 500,
   deadlineMs: 12e3
 };
 var CONFIRMATION_BUDGET = {
   timeoutMs: 1e4,
-  retryCount: 1,
-  retryDelayMs: 500,
   deadlineMs: 3e4
 };
 var MALFORMED_RESPONSE_SUSPENSION_MS = 3e4;
@@ -323425,8 +323718,14 @@ var _QuorumPublicClient = class _QuorumPublicClient {
         chain: chain2,
         transport: http(url2, {
           timeout: budget.timeoutMs,
-          retryCount: budget.retryCount,
-          retryDelay: budget.retryDelayMs
+          // No transport-level retry. viem's retry sleeps for the provider's
+          // `Retry-After` verbatim and uncapped, which reaches the socket
+          // before {@link suspensionMsFor} can apply its clamp — and even
+          // without that header, retrying inside the task is what makes a
+          // task's worst case (timeout, backoff, timeout) approach the
+          // deadline that is supposed to bound it. One attempt per endpoint
+          // per call; `retryPromise` above the quorum owns the retry policy.
+          retryCount: 0
         })
       })
     );
@@ -323440,11 +323739,10 @@ var _QuorumPublicClient = class _QuorumPublicClient {
     return this.rpcUrls.filter((url2) => (_QuorumPublicClient.benchedUntil.get(url2) ?? 0) > now);
   }
   /**
-   * The endpoints this call queries — everyone not benched — and the quorum
-   * bar for exactly that set. A benched endpoint is dropped outright: it
-   * answers nothing while throttled, so counting it could only fail calls the
-   * remaining endpoints agree on. With every endpoint benched, everyone is
-   * queried again; there is nobody left to prefer.
+   * The endpoints this call queries: everyone not benched. A benched endpoint is
+   * dropped outright: it answers nothing while throttled, so asking it could only
+   * cost a request. With every endpoint benched, everyone is queried again; there
+   * is nobody left to prefer.
    */
   participants() {
     const now = Date.now();
@@ -323452,12 +323750,7 @@ var _QuorumPublicClient = class _QuorumPublicClient {
     const active = all7.filter(({ idx }) => (_QuorumPublicClient.benchedUntil.get(this.rpcUrls[idx]) ?? 0) <= now);
     const allBenched = active.length === 0;
     const queried = allBenched ? all7 : active;
-    return {
-      queried,
-      skipped: all7.length - queried.length,
-      threshold: quorumThreshold(queried.length),
-      allBenched
-    };
+    return { queried, skipped: all7.length - queried.length, allBenched };
   }
   /**
    * Records a task failure against its endpoint. Only the failures
@@ -323502,17 +323795,21 @@ var _QuorumPublicClient = class _QuorumPublicClient {
    * retries would otherwise stall every confirmation poll). Stragglers settle
    * out of band and are ignored. `tryDecide` returns undefined to keep
    * waiting; once every task has settled, `finalize` must decide (it throws
-   * the QuorumError when the full response set still has no quorum). Early
-   * exit never weakens the trust model — a decision still requires the same
-   * quorum, it just doesn't wait for votes it no longer needs.
+   * the QuorumError when the full response set still has no quorum).
+   *
+   * Both are handed the bar: the BFT threshold over the endpoints that have not
+   * failed, answered or still out. A failure lowers it rather than counting
+   * against it. Counting the pending endpoints keeps an early decision to a bar
+   * no lower than the full response set would get, so a vote it did not wait for
+   * could never have reversed it.
    *
    * `deadlineMs` bounds the other direction: when the bar is NOT reachable
    * from the fast responders, the call used to wait out every straggler, and
    * the caller's own retry loop multiplied that into minutes of a chain not
    * being scanned at all, silently. At the deadline the outstanding endpoints
    * are treated as failures — named in the QuorumError, so the operator sees
-   * which ones held the call up — and `finalize` decides on the rest. The
-   * trust model is untouched: a decision still needs the same quorum.
+   * which ones held the call up — and `finalize` decides over the endpoints
+   * that answered.
    */
   settleUntilQuorum(tasks, tryDecide, finalize) {
     return new Promise((resolve11, reject) => {
@@ -323530,13 +323827,14 @@ var _QuorumPublicClient = class _QuorumPublicClient {
       const evaluate = () => {
         if (done) return;
         try {
-          const early = tryDecide(fulfilled);
+          const threshold = quorumThreshold(tasks.length - failures.length);
+          const early = tryDecide(fulfilled, threshold);
           if (early !== void 0) {
             finish(() => resolve11(early));
             return;
           }
           if (outstanding === 0) {
-            const value = finalize(fulfilled, failures);
+            const value = finalize(fulfilled, failures, threshold);
             finish(() => resolve11(value));
           }
         } catch (error) {
@@ -323554,7 +323852,7 @@ var _QuorumPublicClient = class _QuorumPublicClient {
           error: new Error(`no answer within the ${this.deadlineMs}ms quorum deadline`)
         }));
         try {
-          const value = finalize(fulfilled, [...failures, ...stragglers]);
+          const value = finalize(fulfilled, [...failures, ...stragglers], quorumThreshold(fulfilled.length));
           finish(() => resolve11(value));
         } catch (error) {
           finish(() => reject(error));
@@ -323581,22 +323879,22 @@ var _QuorumPublicClient = class _QuorumPublicClient {
     });
   }
   /**
-   * Highest block head backed by a full quorum. Throws {@link QuorumError}
-   * when fewer than `threshold` endpoints respond.
+   * Highest block head backed by a quorum of the endpoints that answer. Throws
+   * {@link QuorumError} when none do.
    */
   async getBlockNumber() {
-    const { queried, skipped, threshold, allBenched } = this.participants();
+    const { queried, skipped, allBenched } = this.participants();
     return this.settleUntilQuorum(
       queried.map(({ idx, client }) => ({ idx, task: client.getBlockNumber() })),
       // Early exit as soon as a quorum is satisfiable. Late voters could
       // only raise the reported head; the earlier (lower) head is
       // conservative for every consumer (fewer confirmations counted,
       // smaller scan windows).
-      (fulfilled) => this.quorumHead(
+      (fulfilled, threshold) => this.quorumHead(
         fulfilled.map((f7) => f7.value),
         threshold
       ) ?? void 0,
-      (fulfilled, failures) => {
+      (fulfilled, failures, threshold) => {
         const head = this.quorumHead(
           fulfilled.map((f7) => f7.value),
           threshold
@@ -323637,7 +323935,7 @@ var _QuorumPublicClient = class _QuorumPublicClient {
       }
       return views;
     };
-    const { queried, skipped, threshold, allBenched } = this.participants();
+    const { queried, skipped, allBenched } = this.participants();
     return this.settleUntilQuorum(
       queried.map(({ idx, client }) => ({
         idx,
@@ -323656,8 +323954,8 @@ var _QuorumPublicClient = class _QuorumPublicClient {
       // Early exit only on a POSITIVE quorum: an agreeing inclusion group can
       // only grow, so the first satisfiable quorum is final. Not-found votes
       // never decide early — "not confirmed" needs the full response set.
-      (fulfilled) => aggregateConfirmations(toViews(fulfilled), threshold) ?? void 0,
-      (fulfilled, failures) => {
+      (fulfilled, threshold) => aggregateConfirmations(toViews(fulfilled), threshold) ?? void 0,
+      (fulfilled, failures, threshold) => {
         const confirmations = aggregateConfirmations(toViews(fulfilled), threshold);
         if (confirmations === null) {
           throw new QuorumError(
@@ -323686,7 +323984,7 @@ var _QuorumPublicClient = class _QuorumPublicClient {
       }
       return groups;
     };
-    const { queried, skipped, threshold, allBenched } = this.participants();
+    const { queried, skipped, allBenched } = this.participants();
     return this.settleUntilQuorum(
       queried.map(({ idx, client }) => ({
         idx,
@@ -323698,13 +323996,13 @@ var _QuorumPublicClient = class _QuorumPublicClient {
       // two disjoint groups can't both hold one), so the first satisfiable
       // agreement is final — no need to wait out stragglers that could
       // only join or lose.
-      (fulfilled) => {
+      (fulfilled, threshold) => {
         for (const group of groupOf(fulfilled).values()) {
           if (group.providerIdxs.length >= threshold) return group.result;
         }
         return void 0;
       },
-      (fulfilled, failures) => {
+      (fulfilled, failures, threshold) => {
         const groups = groupOf(fulfilled);
         for (const group of groups.values()) {
           if (group.providerIdxs.length >= threshold) return group.result;
@@ -328936,20 +329234,32 @@ var ContractInteractionService = class {
     } else {
       this.logger.warn({ reason: pmResult.reason }, "No paymaster for bid UserOp; relying on EntryPoint deposit");
     }
-    const userOp = await sdkHelper.prepareSubmitBid({
-      order,
-      fillOptions,
+    const bidGas = {
       solverAccount: solverAccountAddress,
-      solverSigner: sdkSigningAccount(this.signer),
       nonce,
       entryPointAddress,
       callGasLimit,
       verificationGasLimit: cachedEstimate.verificationGasLimit,
-      preVerificationGas: cachedEstimate.preVerificationGas,
       maxFeePerGas: cachedEstimate.maxFeePerGas,
       maxPriorityFeePerGas: cachedEstimate.maxPriorityFeePerGas,
       callData,
       paymasterAndData
+    };
+    let preVerificationGas = cachedEstimate.preVerificationGas;
+    try {
+      preVerificationGas = await sdkHelper.estimateBidPreVerificationGas(bidGas);
+    } catch (err) {
+      this.logger.warn(
+        { orderId: order.id, err, preVerificationGas: preVerificationGas.toString() },
+        "Could not estimate the bid's preVerificationGas; using the fill estimate's"
+      );
+    }
+    const userOp = await sdkHelper.prepareSubmitBid({
+      ...bidGas,
+      order,
+      fillOptions,
+      solverSigner: sdkSigningAccount(this.signer),
+      preVerificationGas
     });
     const encodedUserOp = encodeUserOpScale(userOp);
     this.logger.info(
@@ -328958,6 +329268,7 @@ var ContractInteractionService = class {
         solverAccount: solverAccountAddress,
         nonce: nonce.toString(),
         callGasLimit: callGasLimit.toString(),
+        preVerificationGas: preVerificationGas.toString(),
         maxFeePerGas: cachedEstimate.maxFeePerGas.toString()
       },
       "Prepared bid UserOp"
@@ -362304,8 +362615,15 @@ var IntentFiller = class {
     const evalDurationSec = (Date.now() - evalStartMs) / 1e3;
     this.monitor.emit("orderTiming", { orderId: order.id, phase: "evaluation", durationSec: evalDurationSec });
     if (validStrategies.length === 0) {
-      this.logger.warn({ orderId: order.id }, "No profitable strategy found for order");
-      this.monitor.emit("orderSkipped", { orderId: order.id, reason: "No profitable strategy" });
+      const priced = eligibleStrategies.some((s4) => s4 !== null);
+      this.logger.warn(
+        { orderId: order.id },
+        priced ? "No profitable strategy found for order" : "No strategy can fill this order"
+      );
+      this.monitor.emit("orderSkipped", {
+        orderId: order.id,
+        reason: priced ? "No profitable strategy" : "No strategy can fill this order"
+      });
       return null;
     }
     this.logger.info(
@@ -362732,10 +363050,6 @@ init_asset_registry();
 function limitOrderLegs(order) {
   return order.side === "BID" ? { input: order.base, output: order.quote } : { input: order.quote, output: order.base };
 }
-function availableOn(order) {
-  const available = BigInt(order.remaining) - BigInt(order.reserved);
-  return available > 0n ? available : 0n;
-}
 function matchLimitOrders(orders, incoming, resolve11, now = /* @__PURE__ */ new Date()) {
   const qualifying = orders.filter((order) => serves(order, incoming, resolve11, now)).map((order) => {
     const offer = offerFor({
@@ -362744,7 +363058,7 @@ function matchLimitOrders(orders, incoming, resolve11, now = /* @__PURE__ */ new
       price: BigInt(order.price),
       outputDecimals: incoming.outputDecimals
     });
-    const available = availableOn(order);
+    const available = BigInt(order.remaining);
     return { order, offer, available, payout: offer < available ? offer : available };
   }).filter((candidate) => candidate.offer >= incoming.requestedOutput && candidate.payout > 0n).sort(byBestOfferFirst);
   return qualifying;
@@ -362754,16 +363068,63 @@ function byBestOfferFirst(a6, b5) {
   if (a6.available !== b5.available) return a6.available > b5.available ? -1 : 1;
   return a6.order.id < b5.order.id ? -1 : 1;
 }
+function whyUnmatched(orders, incoming, resolve11, now = /* @__PURE__ */ new Date()) {
+  let furthest = -1;
+  for (const order of orders) {
+    const failed = firstFailed(order, incoming, resolve11, now);
+    furthest = Math.max(furthest, failed === null ? CHECKS.length : CHECKS.indexOf(failed));
+  }
+  const { source, destination, inputSymbol } = incoming;
+  if (furthest < CHECKS.length) {
+    switch (CHECKS[Math.max(furthest, 0)]) {
+      case "open":
+        return "no limit order is open";
+      case "chain":
+        return `no open limit order fills on ${destination}`;
+      case "input":
+        return `no limit order on ${destination} takes ${inputSymbol} in`;
+      case "output":
+        return `no limit order on ${destination} taking ${inputSymbol} in pays out the token this order asks for`;
+      case "source":
+        return `no limit order for this pair on ${destination} accepts swaps from ${source}`;
+    }
+  }
+  const priced = orders.filter((order) => firstFailed(order, incoming, resolve11, now) === null).map((order) => ({
+    order,
+    offer: offerFor({
+      side: order.side,
+      inputAmount: incoming.inputNet,
+      price: BigInt(order.price),
+      outputDecimals: incoming.outputDecimals
+    })
+  }));
+  if (priced.some(({ offer }) => offer >= incoming.requestedOutput)) {
+    return "the limit orders that meet its rate have nothing left to pay out";
+  }
+  const best = priced.reduce((a6, b5) => b5.offer > a6.offer ? b5 : a6);
+  const symbol3 = limitOrderLegs(best.order).output;
+  return `it asks for ${readable(incoming.requestedOutput)} ${symbol3}; the best limit order offers ${readable(best.offer)} ${symbol3}`;
+}
+var CHECKS = ["open", "chain", "input", "output", "source"];
 function serves(order, incoming, resolve11, now) {
-  if (order.status !== "open") return false;
-  if (order.expiresAt !== null && new Date(order.expiresAt) <= now) return false;
-  if (order.fillChain !== incoming.destination) return false;
+  return firstFailed(order, incoming, resolve11, now) === null;
+}
+function firstFailed(order, incoming, resolve11, now) {
+  if (order.status !== "open") return "open";
+  if (order.expiresAt !== null && new Date(order.expiresAt) <= now) return "open";
+  if (order.fillChain !== incoming.destination) return "chain";
   const legs = limitOrderLegs(order);
-  if (normalizeSymbol(legs.input) !== normalizeSymbol(incoming.inputSymbol)) return false;
+  if (normalizeSymbol(legs.input) !== normalizeSymbol(incoming.inputSymbol)) return "input";
   const outputToken = resolve11(legs.output, order.fillChain);
-  if (!outputToken || outputToken.toLowerCase() !== incoming.outputToken.toLowerCase()) return false;
-  if (incoming.source === incoming.destination) return true;
-  return order.acceptedSources.includes(incoming.source);
+  if (!outputToken || outputToken.toLowerCase() !== incoming.outputToken.toLowerCase()) return "output";
+  if (incoming.source === incoming.destination) return null;
+  return order.acceptedSources.includes(incoming.source) ? null : "source";
+}
+function readable(amount) {
+  const [whole, fraction] = toHuman(amount).split(".");
+  const grouped = whole.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  const cut = fraction?.slice(0, 6).replace(/0+$/, "");
+  return cut ? `${grouped}.${cut}` : grouped;
 }
 
 // src/orderbook/usd.ts
@@ -362907,15 +363268,20 @@ var FXFiller = class _FXFiller {
     }
     try {
       if (order.inputs.length !== order.output.assets.length) {
-        this.logger.debug(
-          { inputs: order.inputs.length, outputs: order.output.assets.length },
+        this.logger.info(
+          { orderId: order.id, inputs: order.inputs.length, outputs: order.output.assets.length },
           "Order input/output length mismatch or empty"
         );
         return false;
       }
       if ((await this.matchOrder(order)).length === 0) {
-        this.logger.debug(
-          { orderId: order.id, sourceChain: order.source, destChain: order.destination },
+        this.logger.info(
+          {
+            orderId: order.id,
+            sourceChain: order.source,
+            destChain: order.destination,
+            reason: await this.explainUnmatched(order)
+          },
           "No limit order matches this order"
         );
         return false;
@@ -363457,30 +363823,53 @@ var FXFiller = class _FXFiller {
    */
   async matchLeg(order, leg) {
     if (!this.limitOrders) return [];
+    const incoming = await this.incomingFor(order, leg);
+    if (!incoming) return [];
+    return matchLimitOrders(
+      await this.limitOrders.open(),
+      incoming,
+      (symbol3, chain2) => this.registry.getAddress(symbol3, chain2)
+    );
+  }
+  /** Why no limit order serves the order, leg by leg, for the line that says it was passed over. */
+  async explainUnmatched(order) {
+    if (!this.limitOrders) return "limit orders are not loaded";
+    const open2 = await this.limitOrders.open();
+    const reasons = [];
+    for (let leg = 0; leg < order.inputs.length; leg++) {
+      const incoming = await this.incomingFor(order, leg);
+      const reason = incoming ? whyUnmatched(open2, incoming, (symbol3, chain2) => this.registry.getAddress(symbol3, chain2)) : `its input token is not in the asset registry on ${order.source}`;
+      reasons.push(order.inputs.length > 1 ? `leg ${leg}: ${reason}` : reason);
+    }
+    return reasons.join("; ");
+  }
+  /**
+   * One leg as the matcher sees it, or null when its input token is not one the asset
+   * registry knows on the source chain.
+   *
+   * Amounts cross into the matcher at 1e18, the unit limit orders are kept in.
+   */
+  async incomingFor(order, leg) {
     const input = order.inputs[leg];
     const output3 = order.output.assets[leg];
-    if (!input || !output3) return [];
+    if (!input || !output3) return null;
     const inputToken = bytes32ToBytes20(input.token);
     const outputToken = bytes32ToBytes20(output3.token);
     const inputSymbol = this.registry.symbolFor(inputToken, order.source);
-    if (!inputSymbol) return [];
+    if (!inputSymbol) return null;
     const [inputDecimals, outputDecimals] = await Promise.all([
       this.contractService.getTokenDecimals(inputToken, order.source),
       this.contractService.getTokenDecimals(outputToken, order.destination)
     ]);
-    return matchLimitOrders(
-      await this.limitOrders.open(),
-      {
-        source: order.source,
-        destination: order.destination,
-        inputSymbol,
-        outputToken,
-        inputNet: toScaled(input.amount, inputDecimals),
-        requestedOutput: toScaled(output3.amount, outputDecimals),
-        outputDecimals
-      },
-      (symbol3, chain2) => this.registry.getAddress(symbol3, chain2)
-    );
+    return {
+      source: order.source,
+      destination: order.destination,
+      inputSymbol,
+      outputToken,
+      inputNet: toScaled(input.amount, inputDecimals),
+      requestedOutput: toScaled(output3.amount, outputDecimals),
+      outputDecimals
+    };
   }
   /**
    * The order's input in **USD**, or null when no limit order connects its input
@@ -364583,48 +364972,42 @@ async function bootFiller(config5, options) {
     assertPairSymbolsResolve(config5.pairs, assetRegistry, configuredChainNames);
   }
   const adminStrategies = [];
-  const strategies = [];
-  let confirmationPolicy;
-  let tradingPairs;
-  let engine;
-  if (config5.pairs?.length) {
-    tradingPairs = config5.pairs.map((pair) => ({ token0: pair.token0, token1: pair.token1 }));
-    tradingPairs.forEach((pair, pairIndex) => {
-      adminStrategies.push({
-        index: pairIndex,
-        pairIndex,
-        exotic: `${pair.token0}/${pair.token1}`,
-        token0: pair.token0,
-        token1: pair.token1,
-        sameToken: normalizeSymbol(pair.token0) === normalizeSymbol(pair.token1)
-      });
+  const tradingPairs = (config5.pairs ?? []).map((pair) => ({
+    token0: pair.token0,
+    token1: pair.token1
+  }));
+  tradingPairs.forEach((pair, pairIndex) => {
+    adminStrategies.push({
+      index: pairIndex,
+      pairIndex,
+      exotic: `${pair.token0}/${pair.token1}`,
+      token0: pair.token0,
+      token1: pair.token1,
+      sameToken: normalizeSymbol(pair.token0) === normalizeSymbol(pair.token1)
     });
-    confirmationPolicy = assertConfirmationCoverage(
-      config5.confirmationPolicies,
-      resolvedChains.map((c6) => c6.chainId)
-    );
-    const fundingVenues = vaultVenue ? [vaultVenue] : [];
-    engine = new FXFiller(
-      runtimeSigner,
-      configService,
-      chainClientManager,
-      contractService,
-      tradingPairs,
-      assetRegistry,
-      { confirmationPolicy, fundingVenues, limitOrders: options.data.limitOrders }
-    );
-    logger8.info("Hydrating funding venue state...");
-    await engine.initialise();
-    strategies.push(engine);
-  }
+  });
+  const confirmationPolicy = assertConfirmationCoverage(
+    config5.confirmationPolicies,
+    resolvedChains.map((c6) => c6.chainId)
+  );
+  const fundingVenues = vaultVenue ? [vaultVenue] : [];
+  const engine = new FXFiller(
+    runtimeSigner,
+    configService,
+    chainClientManager,
+    contractService,
+    tradingPairs,
+    assetRegistry,
+    { confirmationPolicy, fundingVenues, limitOrders: options.data.limitOrders }
+  );
+  logger8.info("Hydrating funding venue state...");
+  await engine.initialise();
+  const strategies = [engine];
   const haltControls = strategies.map((engine2, index3) => ({
     index: index3,
     isHalted: () => engine2.isHalted(),
     resetHalt: () => engine2.resetHalt()
   }));
-  if (vaultVenue) {
-    await vaultVenue.initialise(runtimeSigner.address);
-  }
   let rebalancingService;
   const rebalancingConfig = configService.getRebalancingConfig();
   if (rebalancingConfig?.triggerPercentage !== void 0 && rebalancingConfig?.baseBalances) {
@@ -365150,8 +365533,8 @@ var MemoryLimitOrderStore = class {
   async reserve(id2, amount) {
     const order = this.orders.get(id2);
     if (!order || order.status !== "open") return false;
+    if (BigInt(amount) > BigInt(order.remaining)) return false;
     const reserved = BigInt(order.reserved) + BigInt(amount);
-    if (reserved > BigInt(order.remaining)) return false;
     this.patch(id2, { reserved: reserved.toString() });
     return true;
   }
@@ -365232,6 +365615,8 @@ var MAX_BLOCK_RANGE = 1000n;
 var PUBLISH_CHUNK = 250;
 var yieldToConsumers = () => new Promise((resolve11) => setImmediate(resolve11));
 var STOP_DRAIN_TIMEOUT_MS = 5e3;
+var STALL_THRESHOLD_MS = 45e3;
+var STALL_REPORT_INTERVAL_MS = 6e4;
 var ChainScanner = class {
   constructor(target, loggers = defaultLoggerContext(), scanIntervalMs = DEFAULT_SCAN_INTERVAL_MS) {
     this.target = target;
@@ -365245,6 +365630,18 @@ var ChainScanner = class {
     this.errorHandler = () => {
     };
     this.stopped = false;
+    /**
+     * How far past the cursor the next pass reads, as `toBlock - fromBlock`:
+     * halved after a failed read, doubled after a good one, between 0 (one block)
+     * and {@link MAX_BLOCK_RANGE}.
+     *
+     * Free endpoints cap `eth_getLogs` ranges far below the full span — on
+     * Arbitrum three of seven refused 100 blocks — and the cursor never moves
+     * past a range it failed to read. At a fixed span a catch-up that outgrew
+     * those caps was stuck for good: the range only grew, so the capped endpoints
+     * never rejoined and the quorum never formed.
+     */
+    this.span = MAX_BLOCK_RANGE;
     this.logger = loggers.get("chain-scanner");
     this.quorumClient = new QuorumPublicClient(target.chainId, target.rpcUrls, loggers);
     if (this.quorumClient.size > 1) {
@@ -365287,8 +365684,9 @@ var ChainScanner = class {
     if (this.timer || this.stopped) return;
     this.logger.info({ chainId: this.target.chainId }, "Block scanner started");
     this.timer = setInterval(() => {
-      if (this.mutex.isLocked()) return;
+      if (this.mutex.isLocked()) return this.reportStall();
       void this.mutex.runExclusive(async () => {
+        this.pass = { phase: "head", startedAt: Date.now(), reportedAt: 0 };
         try {
           await this.scan();
         } catch (error) {
@@ -365302,10 +365700,66 @@ var ChainScanner = class {
             "Error in block scanner"
           );
           this.errorHandler(error);
+        } finally {
+          this.notePassEnd();
         }
       });
     }, this.scanIntervalMs);
   }
+  /**
+   * Records which await the current pass is sitting on, for the watchdog.
+   *
+   * A no-op when no pass is registered — `scan()` is driven directly by tests
+   * and by nothing else, so there is no watchdog to inform.
+   */
+  enter(phase) {
+    if (this.pass) this.pass.phase = phase;
+  }
+  /**
+   * Says that a pass has outlived the quorum budgets and names the phase it is
+   * stuck in, then repeats every {@link STALL_REPORT_INTERVAL_MS} until it ends.
+   *
+   * Observation only: the pass is left alone. Aborting it would need a cancel
+   * path through the quorum client that does not exist, and the cursor is safe
+   * either way — a pass that never completes never advances it.
+   */
+  reportStall() {
+    const pass = this.pass;
+    if (!pass) return;
+    const now = Date.now();
+    const heldMs = now - pass.startedAt;
+    if (heldMs < STALL_THRESHOLD_MS) return;
+    if (pass.reportedAt !== 0 && now - pass.reportedAt < STALL_REPORT_INTERVAL_MS) return;
+    pass.reportedAt = now;
+    this.logger.warn(
+      {
+        chainId: this.target.chainId,
+        phase: pass.phase,
+        heldMs,
+        cursor: this.cursor?.toString(),
+        rpcUrls: this.target.rpcUrls
+      },
+      "Block scan pass has outlived its budget \u2014 this chain is not being scanned"
+    );
+  }
+  /**
+   * Closes out a pass, and says so if the watchdog complained about it — without
+   * this the log shows a chain going quiet and never shows it coming back.
+   */
+  notePassEnd() {
+    const pass = this.pass;
+    this.pass = void 0;
+    if (!pass || pass.reportedAt === 0) return;
+    this.logger.warn(
+      {
+        chainId: this.target.chainId,
+        phase: pass.phase,
+        heldMs: Date.now() - pass.startedAt,
+        cursor: this.cursor?.toString()
+      },
+      "Block scan pass finished after outliving its budget \u2014 scanning has resumed"
+    );
+  }
   /**
    * Points this loop at different endpoints, keeping the cursor.
    *
@@ -365347,11 +365801,12 @@ var ChainScanner = class {
     }
     if (currentBlock <= this.cursor) return;
     const fromBlock = this.cursor + 1n;
-    const toBlock = fromBlock + MAX_BLOCK_RANGE > currentBlock ? currentBlock : fromBlock + MAX_BLOCK_RANGE;
+    const toBlock = fromBlock + this.span > currentBlock ? currentBlock : fromBlock + this.span;
     this.logger.debug(
       { chainId: this.target.chainId, fromBlock, toBlock, gap: Number(toBlock - fromBlock) },
       "Scanning blocks"
     );
+    this.enter("logs");
     let logs;
     try {
       logs = await retryPromise(
@@ -365373,6 +365828,7 @@ var ChainScanner = class {
       );
     } catch (error) {
       if (isBlockRangeError(error)) return;
+      this.narrow(toBlock - fromBlock);
       throw error;
     }
     if (this.stopped) return;
@@ -365383,6 +365839,7 @@ var ChainScanner = class {
         { chainId: this.target.chainId, fromBlock, toBlock, eventCount: placed.length },
         "Found OrderPlaced events in block scan"
       );
+      this.enter("publish-orders");
       await this.publishOrders(placed);
     }
     if (filled.length > 0) {
@@ -365390,10 +365847,36 @@ var ChainScanner = class {
         { chainId: this.target.chainId, fromBlock, toBlock, eventCount: filled.length },
         "Found OrderFilled events in block scan"
       );
+      this.enter("publish-fills");
       await this.publishFills(filled);
     }
     if (this.stopped) return;
     this.cursor = toBlock;
+    this.widen();
+  }
+  /**
+   * Halves the span below the range that just failed, so the next pass asks
+   * for something a range-capped endpoint will answer. Halving the attempted
+   * range rather than the span matters near the head, where a pass reads fewer
+   * blocks than the span allows.
+   */
+  narrow(attempted) {
+    const next = attempted / 2n;
+    if (next >= this.span) return;
+    this.span = next;
+    this.logger.warn(
+      { chainId: this.target.chainId, span: Number(next) },
+      "Narrowing the block scan range after a failed read"
+    );
+  }
+  /** Doubles the span back toward {@link MAX_BLOCK_RANGE} after a good read. */
+  widen() {
+    if (this.span >= MAX_BLOCK_RANGE) return;
+    const next = this.span === 0n ? 1n : this.span * 2n;
+    this.span = next > MAX_BLOCK_RANGE ? MAX_BLOCK_RANGE : next;
+    if (this.span === MAX_BLOCK_RANGE) {
+      this.logger.info({ chainId: this.target.chainId }, "Block scan range back to full");
+    }
   }
   async publishOrders(logs) {
     const rebuilt = reconstructOrdersFromLogs(logs, {
@@ -365762,7 +366245,7 @@ var LimitOrderController = class {
     ]);
     return { order, fills, bids };
   }
-  /** The pairs the orderbook lists, and the smallest payout each token may carry. */
+  /** The pairs the orderbook lists, the smallest payout each token may carry, and its tokens per chain. */
   books() {
     return this.service.books();
   }
@@ -365810,10 +366293,7 @@ var PairController = class {
    * the pair's symbols have to resolve before the market can be hydrated.
    */
   async add(pair, options) {
-    const { engine, tradingPairs, assetRegistry, adminStrategies, balanceTokens, config: config5 } = this.runtime;
-    if (!engine || !tradingPairs) {
-      throw new Error("No trading engine is running \u2014 this filler was started without pairs");
-    }
+    const { engine, assetRegistry, adminStrategies, balanceTokens, config: config5 } = this.runtime;
     const assets = options?.assets;
     const nextAssets = { ...config5.assets ?? {}, ...assets ?? {} };
     const nextPairs = [...this.pairs, pair];
@@ -365852,7 +366332,6 @@ var PairController = class {
   /** Closes a market. Orders already in flight against it still complete. */
   async remove(index3) {
     const { engine, tradingPairs, adminStrategies, config: config5 } = this.runtime;
-    if (!engine || !tradingPairs) throw new Error("No trading engine is running");
     if (index3 < 0 || index3 >= this.pairs.length) throw new Error(`Unknown pair ${index3}`);
     engine.removePair(tradingPairs[index3]);
     config5.pairs = this.pairs.filter((_5, i6) => i6 !== index3);
@@ -365864,7 +366343,7 @@ var PairController = class {
     await this.persist();
   }
   livePair(index3) {
-    const pair = this.runtime.tradingPairs?.[index3];
+    const pair = this.runtime.tradingPairs[index3];
     if (!pair) throw new Error(`Unknown pair ${index3}`);
     return pair;
   }
@@ -365956,9 +366435,9 @@ var ChainController = class {
         throw error;
       }
       const curve = confirmationPolicies[String(chainId)];
-      if (curve) this.runtime.confirmationPolicy?.add(chainId, curve);
-      else if (!this.runtime.confirmationPolicy?.has(chainId)) {
-        this.runtime.confirmationPolicy?.adopt(chainId, resolvedPolicy);
+      if (curve) this.runtime.confirmationPolicy.add(chainId, curve);
+      else if (!this.runtime.confirmationPolicy.has(chainId)) {
+        this.runtime.confirmationPolicy.adopt(chainId, resolvedPolicy);
       }
       this.runtime.resolvedChains.push(resolved);
       config5.chains = [...config5.chains, { rpcUrls: chain2.rpcUrls, bundlerUrl: chain2.bundlerUrl }];
@@ -365986,7 +366465,7 @@ var ChainController = class {
       await intentFiller.removeChain(chainId);
       if (this.ownsScanner) await this.scanner.removeChain(chainId);
       configService.removeChain(chainId);
-      this.runtime.confirmationPolicy?.remove(chainId);
+      this.runtime.confirmationPolicy.remove(chainId);
       this.runtime.chainClientManager.invalidate(chainKey);
       this.runtime.resolvedChains.splice(index3, 1);
       config5.chains = config5.chains.filter((_5, i6) => i6 !== index3);
@@ -367022,8 +367501,8 @@ var SqliteLimitOrderStore = class {
   async reserve(id2, amount) {
     const order = this.read(id2);
     if (!order || order.status !== "open") return false;
+    if (BigInt(amount) > BigInt(order.remaining)) return false;
     const reserved = BigInt(order.reserved) + BigInt(amount);
-    if (reserved > BigInt(order.remaining)) return false;
     const result = this.db.prepare(`
 				UPDATE limit_orders SET reserved = ?, updated_at = datetime('now')
 				WHERE id = ? AND reserved = ? AND status = 'open'