@hyperbridge/simplex 0.16.5 → 0.16.7

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;
         });
@@ -214231,13 +214231,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 +214288,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 +214399,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, 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";
@@ -228328,14 +228342,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 +228385,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 +228396,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 +228409,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 +228476,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 +228485,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 +228598,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 +228629,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 +228787,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);
       }
@@ -229954,6 +230016,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 +230050,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 +230126,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 +230135,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 +230144,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 +230153,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 +230162,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 +295168,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 +316227,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 +316417,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,
@@ -318650,10 +318793,16 @@ var CANCEL_ORDER_MUTATION = `
 `;
 var OrderbookRequestError2 = class extends Error {
 };
+function graphqlEndpoint(url2) {
+  const trimmed = url2.trim();
+  if (trimmed.includes("?")) return trimmed;
+  const withoutTrailingSlash = trimmed.replace(/\/+$/, "");
+  return withoutTrailingSlash.endsWith("/graphql") ? withoutTrailingSlash : `${withoutTrailingSlash}/graphql`;
+}
 var OrderbookClient = class {
   constructor(url2, requestTimeoutMs, loggers = defaultLoggerContext()) {
-    this.url = url2;
     this.requestTimeoutMs = requestTimeoutMs;
+    this.url = graphqlEndpoint(url2);
     this.logger = loggers.get("orderbook");
   }
   /** The limits to validate against before posting, plus the books on offer. */
@@ -318751,7 +318900,9 @@ var OrderbookClient = class {
       clearTimeout(timer);
     }
     if (!response.ok) {
-      throw new OrderbookRequestError2(`Orderbook returned HTTP ${response.status} ${response.statusText}`);
+      throw new OrderbookRequestError2(
+        `Orderbook at ${this.url} returned HTTP ${response.status} ${response.statusText}`
+      );
     }
     const body = await response.json().catch((err) => {
       throw new OrderbookRequestError2(`Orderbook returned a body that is not JSON: ${describe(err)}`);
@@ -318870,7 +319021,7 @@ var HEARTBEAT_TYPES = {
 var LimitOrderValidationError = class extends Error {
 };
 var LimitOrderService = class {
-  constructor(store, client, contractService, configService, assetRegistry, signer, defaultTtlSecs, delegationService, loggers = defaultLoggerContext(), startingNonce = initialOrderNonce) {
+  constructor(store, client, contractService, configService, assetRegistry, signer, defaultTtlSecs, delegationService, loggers = defaultLoggerContext(), startingNonce = initialOrderNonce, vaultBalances) {
     this.store = store;
     this.client = client;
     this.contractService = contractService;
@@ -318880,6 +319031,7 @@ var LimitOrderService = class {
     this.defaultTtlSecs = defaultTtlSecs;
     this.delegationService = delegationService;
     this.startingNonce = startingNonce;
+    this.vaultBalances = vaultBalances;
     this.logger = loggers.get("limit-orders");
   }
   /**
@@ -319015,6 +319167,18 @@ var LimitOrderService = class {
       throw err;
     }
   }
+  /**
+   * 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. 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, chains: limits.chains ?? [] };
+  }
   /**
    * Reads `serverInfo` and `books`, reusing the last read for {@link LIMITS_TTL_MS}.
    *
@@ -319095,6 +319259,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}`
@@ -319122,28 +319298,61 @@ var LimitOrderService = class {
    * balance on the fill chain, so the operator hears it while they are creating
    * the order.
    *
+   * A fill pays out of the wallet and then withdraws any shortfall from the
+   * configured ERC-4626 vaults in the same batch, so what those vaults hold of
+   * the payout token backs the order too and is counted here. Without it an
+   * operator who sweeps inventory into a vault is refused orders their filler
+   * would have filled.
+   *
    * Each order is checked against the whole balance, not against what is left of
    * it after the others. One balance backs every order resting on it — that is
    * what quoting both sides of a book is — and the orderbook says as much: it
    * advertises each entry at `min(quoted, balance)` rather than dividing the
    * balance between them. Whichever order fills first draws the inventory down,
    * and the rest are cut to what is left. Netting them here would refuse the
-   * second side of every book.
+   * second side of every book. Vault positions are counted the same way: the
+   * whole position, not what is left after reservations for fills in flight.
    */
   async assertWalletCanPay(symbol3, chain2, payout) {
     const token = this.assetRegistry.getAddress(symbol3, chain2);
     if (!token) return;
     const decimals = await this.decimalsFor(symbol3, token, chain2);
-    const balance = toScaled(
+    const wallet = toScaled(
       await this.contractService.getTokenBalance(chain2, token, this.signer.address),
       decimals
     );
-    if (balance < payout) {
+    const vaults = await this.vaultHoldings(token, chain2);
+    if (wallet + vaults < payout) {
+      const held = vaults > 0n ? `${toHuman(wallet)} in the wallet and ${toHuman(vaults)} in vaults` : toHuman(wallet);
       throw new LimitOrderValidationError(
-        `The wallet holds ${toHuman(balance)} ${symbol3} on ${chain2}, which cannot pay out ${toHuman(payout)}`
+        `The wallet holds ${held} ${symbol3} on ${chain2}, which cannot pay out ${toHuman(payout)}`
       );
     }
   }
+  /**
+   * What the configured vaults hold of `token` on `chain`, in scaled units.
+   *
+   * Zero when no vault is configured. A snapshot that cannot be read is also
+   * zero: the wallet alone then has to cover the order, which refuses one the
+   * filler might have managed rather than accepting one it could not.
+   */
+  async vaultHoldings(token, chain2) {
+    if (!this.vaultBalances) return 0n;
+    let positions;
+    try {
+      positions = await this.vaultBalances.getBalanceSnapshot(chain2);
+    } catch (err) {
+      this.logger.warn({ chain: chain2, token, err }, "Could not read vault balances; backing the order on the wallet alone");
+      return 0n;
+    }
+    const wanted = token.toLowerCase();
+    let total = 0n;
+    for (const position of positions) {
+      if (position.chain !== chain2 || position.asset.toLowerCase() !== wanted) continue;
+      total += toScaled(position.positionAssets, position.decimals);
+    }
+    return total;
+  }
   /**
    * Works a limit order down by what a fill delivered, and puts the rest back on
    * the orderbook.
@@ -320724,7 +320933,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"));
       }
     };
@@ -320917,6 +321126,7 @@ init_chains2();
 init_alchemy();
 init_prompt_utils();
 init_state();
+init_defaults8();
 init_Logger();
 var logger2 = getLogger("setup");
 async function defaultRpcRequest(url2, method, params) {
@@ -320963,6 +321173,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 {
@@ -321732,6 +321954,11 @@ var UiServer = class {
       if (method === "POST") return this.handleLimitOrderCreate(req, res);
       return sendJson(res, 405, { error: "Method not allowed" });
     }
+    if (path2 === "/api/orderbook/books") {
+      if (this.mode !== "operator") return sendJson(res, 409, { error: "Filler is not running" });
+      if (method !== "GET") return sendJson(res, 405, { error: "Method not allowed" });
+      return this.handleLimitOrders(res, () => this.operator.limitOrders.books());
+    }
     const limitOrderMatch = path2.match(/^\/api\/limit-orders\/([\w-]+)$/);
     if (limitOrderMatch) {
       if (this.mode !== "operator") return sendJson(res, 409, { error: "Filler is not running" });
@@ -323269,14 +323496,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;
@@ -323368,8 +323591,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
         })
       })
     );
@@ -323383,11 +323612,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();
@@ -323395,12 +323623,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
@@ -323445,17 +323668,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) => {
@@ -323473,13 +323700,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) {
@@ -323497,7 +323725,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));
@@ -323524,22 +323752,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
@@ -323580,7 +323808,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,
@@ -323599,8 +323827,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(
@@ -323629,7 +323857,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,
@@ -323641,13 +323869,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;
@@ -362247,8 +362475,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(
@@ -362697,16 +362932,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
@@ -362850,15 +363132,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;
@@ -363400,30 +363687,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
@@ -364615,7 +364925,10 @@ async function bootFiller(config5, options) {
     runtimeSigner,
     config5.orderbook.defaultTtlSecs ?? DEFAULT_LIMIT_ORDER_TTL_SECONDS,
     new DelegationService(chainClientManager, configService, runtimeSigner),
-    options.loggers
+    options.loggers,
+    initialOrderNonce,
+    // A fill withdraws a payout shortfall from the vaults, so what they hold backs an order too.
+    vaultVenue
   );
   intentFiller.setLimitOrderService(limitOrderService);
   const lifecycle = new LimitOrderLifecycle(
@@ -365172,6 +365485,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;
@@ -365185,6 +365500,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) {
@@ -365227,8 +365554,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) {
@@ -365242,10 +365570,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.
    *
@@ -365287,11 +365671,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(
@@ -365313,6 +365698,7 @@ var ChainScanner = class {
       );
     } catch (error) {
       if (isBlockRangeError(error)) return;
+      this.narrow(toBlock - fromBlock);
       throw error;
     }
     if (this.stopped) return;
@@ -365323,6 +365709,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) {
@@ -365330,10 +365717,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, {
@@ -365702,6 +366115,10 @@ var LimitOrderController = class {
     ]);
     return { order, fills, bids };
   }
+  /** The pairs the orderbook lists, the smallest payout each token may carry, and its tokens per chain. */
+  books() {
+    return this.service.books();
+  }
   /** Creates the order, posts it, and reports what the orderbook made of it. */
   async create(request3) {
     const posted = await this.service.create(request3);