@hyperbridge/sdk 2.4.2 → 2.5.0

package/dist/node/index.cjs

@@ -2720,6 +2720,7 @@ var chainConfigs = {
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
       CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
+      SimplexPaymaster: "0xD4340d7466e040626383cb9cda9307ba8E081149",
       Usdt0Oft: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee"
     },
     rpcEnvKey: "ETH_MAINNET",
@@ -2773,7 +2774,8 @@ var chainConfigs = {
       UniswapV4StateView: "0xd13dd3d6e93f276fafc9db9e6bb47c1180aee0c4",
       Calldispatcher: "0xc71251c8b3e7b02697a84363eef6dce8dfbdf333",
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
-      EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108"
+      EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
+      SimplexPaymaster: "0xeD02f9f0df8F562B89cC5b25867Ad3C2d61252A9"
       // "Usdt0Oft": Not available on BSC
     },
     rpcEnvKey: "BSC_MAINNET",
@@ -2831,6 +2833,7 @@ var chainConfigs = {
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
       CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
+      SimplexPaymaster: "0x7281Bccb4f0BCE44F3B8542d1fC5e51c2F5fC08C",
       Usdt0Oft: "0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92"
     },
     rpcEnvKey: "ARBITRUM_MAINNET",
@@ -2885,6 +2888,7 @@ var chainConfigs = {
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
       CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
+      SimplexPaymaster: "0x15b3B03C870c7ef252029c35A12d3b339F5c8d7f",
       AerodromeRouter: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
       UniswapV4PositionManager: "0x7c5f5a4bbd8fd63184577525326123b519429bdc",
       UniswapV4PoolManager: "0x498581ff718922c3f8e6a244956af099b2652b2b",
@@ -2947,6 +2951,7 @@ var chainConfigs = {
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
       CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
+      SimplexPaymaster: "0xe99acFe0f5fC4C8ea54A187D8D3b05f136150095",
       Usdt0Oft: "0x6BA10300f0DC58B7a1e4c0e41f5daBb7D7829e13"
     },
     rpcEnvKey: "POLYGON_MAINNET",
@@ -5242,6 +5247,9 @@ var ChainConfigService = class {
   getCirclePaymasterAddress(chain) {
     return this.getConfig(chain)?.addresses.CirclePaymaster;
   }
+  getSimplexPaymasterAddress(chain) {
+    return this.getConfig(chain)?.addresses.SimplexPaymaster;
+  }
   getHyperbridgeAddress() {
     return hyperbridgeAddress;
   }
@@ -7062,6 +7070,16 @@ var ExpectedError = class _ExpectedError extends Error {
     return error instanceof _ExpectedError;
   }
 };
+var MISSING_CONSENSUS_UPDATE_TIME_MESSAGE = "Consensus update time not found";
+var MissingConsensusUpdateTimeError = class _MissingConsensusUpdateTimeError extends Error {
+  constructor(message = MISSING_CONSENSUS_UPDATE_TIME_MESSAGE, options) {
+    super(message, options);
+    this.name = "Hyperbridge/SDK/MissingConsensusUpdateTimeError";
+  }
+  static isError(error) {
+    return error instanceof _MissingConsensusUpdateTimeError || error instanceof Error && error.message.toLowerCase().includes(MISSING_CONSENSUS_UPDATE_TIME_MESSAGE.toLowerCase());
+  }
+};
 
 // src/configs/constants.ts
 var ISMP_PREFIX = ":child_storage:default:ISMPv2";
@@ -7375,8 +7393,15 @@ var SubstrateChain = class _SubstrateChain {
       id: stateMachineId,
       height: Number(stateMachineHeight.height)
     };
-    const updateTime = await this.rpcClient.call("ismp_queryStateMachineUpdateTime", [payload]);
-    return BigInt(updateTime);
+    try {
+      const updateTime = await this.rpcClient.call("ismp_queryStateMachineUpdateTime", [payload]);
+      return BigInt(updateTime);
+    } catch (error) {
+      if (MissingConsensusUpdateTimeError.isError(error)) {
+        throw new MissingConsensusUpdateTimeError(MISSING_CONSENSUS_UPDATE_TIME_MESSAGE, { cause: error });
+      }
+      throw error;
+    }
   }
   /**
    * Get the challenge period for a given state machine id.
@@ -8122,26 +8147,76 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     };
   }
   /**
-   * Subscribes to PhantomOrderRegistered events from the intents coprocessor pallet.
-   * Calls the callback for each new phantom order as blocks arrive.
-   * Returns an unsubscribe function to stop the subscription.
-   */
-  async subscribePhantomOrders(callback) {
-    const unsub = await this.api.query.system.events((records) => {
-      for (const { event } of records) {
-        if (event.section !== "intentsCoprocessor" || event.method !== "PhantomOrderRegistered") continue;
-        const [commitment, chain, createdAt, tokenA, tokenB, standardAmount] = event.data;
-        callback({
-          commitment: commitment.toHex(),
-          chain: new TextDecoder().decode(util.hexToU8a(chain.toHex())),
-          createdAt: createdAt.toNumber(),
-          tokenA: tokenA.toHex(),
-          tokenB: tokenB.toHex(),
-          standardAmount: BigInt(standardAmount.toString())
-        });
+   * Reads the PhantomOrderRegistered events emitted in a single block.
+   */
+  async getPhantomOrdersInBlock(blockNumber) {
+    const blockHash = await this.api.rpc.chain.getBlockHash(blockNumber);
+    const apiAt = await this.api.at(blockHash);
+    const records = await apiAt.query.system.events();
+    const orders = [];
+    for (const { event } of records) {
+      if (event.section !== "intentsCoprocessor" || event.method !== "PhantomOrderRegistered") continue;
+      const [commitment, chain, createdAt, tokenA, tokenB, standardAmount] = event.data;
+      orders.push({
+        commitment: commitment.toHex(),
+        chain: new TextDecoder().decode(util.hexToU8a(chain.toHex())),
+        createdAt: createdAt.toNumber(),
+        tokenA: tokenA.toHex(),
+        tokenB: tokenB.toHex(),
+        standardAmount: BigInt(standardAmount.toString())
+      });
+    }
+    return orders;
+  }
+  /**
+   * Polls for newly registered phantom orders, invoking the callback once per order.
+   *
+   * Each tick reads the current head and scans every block between the last one processed and that
+   * head, so the block cursor — not the connection — determines what has been seen. This replaced a
+   * system.events subscription, which was only as reliable as its socket: polkadot-js reconnects
+   * the transport but does not reliably re-establish storage subscriptions, and anything emitted
+   * while disconnected was lost silently. With a bid window measured in a handful of blocks, that
+   * meant silently missed bids.
+   *
+   * Scanning a block range is gap-free rather than merely self-healing: an outage delays orders but
+   * cannot drop them, because the cursor only advances past a block whose events were actually
+   * read. Recovery replays the backlog.
+   *
+   * Returns a function that stops polling.
+   */
+  pollPhantomOrders(callback, options = {}) {
+    const { intervalMs = 6e3, maxBlocksPerPoll = 500, lookbackBlocks = 0, onError } = options;
+    let cursor = null;
+    let inFlight = false;
+    let stopped = false;
+    const tick = async () => {
+      if (inFlight || stopped) return;
+      inFlight = true;
+      try {
+        const head = (await this.api.rpc.chain.getHeader()).number.toNumber();
+        if (cursor === null) {
+          cursor = Math.max(head - 1 - lookbackBlocks, -1);
+        }
+        if (head <= cursor) return;
+        const to = Math.min(head, cursor + maxBlocksPerPoll);
+        for (let blockNumber = cursor + 1; blockNumber <= to; blockNumber++) {
+          if (stopped) return;
+          const orders = await this.getPhantomOrdersInBlock(blockNumber);
+          for (const order of orders) callback(order);
+          cursor = blockNumber;
+        }
+      } catch (err) {
+        onError?.(err);
+      } finally {
+        inFlight = false;
       }
-    });
-    return unsub;
+    };
+    void tick();
+    const timer = setInterval(() => void tick(), intervalMs);
+    return () => {
+      stopped = true;
+      clearInterval(timer);
+    };
   }
 };
 var TronChain = class _TronChain {
@@ -9274,7 +9349,12 @@ function sleep(ms) {
 async function waitForChallengePeriod(chain, stateMachineHeight) {
   const challengePeriod = await chain.challengePeriod(stateMachineHeight.id);
   if (challengePeriod === BigInt(0)) return;
-  const updateTime = await chain.stateMachineUpdateTime(stateMachineHeight);
+  const updateTime = await retryPromise(() => chain.stateMachineUpdateTime(stateMachineHeight), {
+    maxRetries: 3,
+    backoffMs: 500,
+    logMessage: "Fetching consensus update time while waiting for the challenge period",
+    shouldRetry: (error) => !MissingConsensusUpdateTimeError.isError(error)
+  });
   let currentTimestamp = await chain.timestamp();
   let timeElapsed = currentTimestamp - updateTime;
   if (timeElapsed > challengePeriod) return;
@@ -9421,6 +9501,10 @@ function normalizeAddressForEvmBytes32(address) {
   if (address.length === 66) return address;
   return bytes20ToBytes32(address);
 }
+function normalizeEvmAddress(address, field = "address") {
+  if (!viem.isAddress(address)) throw new TypeError(`${field} must be a valid EVM address`);
+  return address.toLowerCase();
+}
 function normalizeAddressForStateMachine(address, stateMachineId) {
   return isEvmChain(normalizeStateMachineId(stateMachineId)) ? normalizeAddressForEvmBytes32(address) : address;
 }
@@ -9428,14 +9512,16 @@ var DEFAULT_LOGGER = consola.createConsola({
   level: consola.LogLevels.silent
 });
 async function retryPromise(operation, retryConfig) {
-  const { logger = DEFAULT_LOGGER, logMessage = "Retry operation failed" } = retryConfig;
+  const { logger = DEFAULT_LOGGER, logMessage = "Retry operation failed", shouldRetry } = retryConfig;
   let lastError;
   for (let i = 0; i < retryConfig.maxRetries; i++) {
     try {
       return await operation();
     } catch (error) {
+      if (shouldRetry && !shouldRetry(error)) throw error;
       logger.trace(`Retrying(${i}) > ${logMessage}`);
       lastError = error;
+      if (i === retryConfig.maxRetries - 1) break;
       await new Promise((resolve) => setTimeout(resolve, retryConfig.backoffMs * 2 ** i));
     }
   }
@@ -11506,6 +11592,55 @@ query LatestPhantomOrderPriceSnapshot($tokenA: String!, $tokenB: String!) {
     }
   }
 }`;
+var LATEST_PHANTOM_ORDER_LIQUIDITY_SNAPSHOT = `
+query LatestPhantomOrderLiquiditySnapshot($tokenA: String!, $tokenB: String!) {
+  phantomOrderPriceSnapshots(
+    filter: {
+      and: [
+        { tokenA: { equalTo: $tokenA } }
+        { tokenB: { equalTo: $tokenB } }
+      ]
+    }
+    orderBy: SNAPSHOT_TIME_DESC
+    first: 1
+  ) {
+    nodes {
+      commitment
+      tokenA
+      tokenB
+      snapshotTime
+    }
+  }
+}`;
+var LIQUIDITY_PROVIDER_BALANCES = `
+query LiquidityProviderBalanceAggregates($commitment: String!, $tokenAddress: String!) {
+  liquidityProviderBalances(
+    filter: {
+      and: [
+        { commitment: { equalTo: $commitment } }
+        { tokenAddress: { equalTo: $tokenAddress } }
+      ]
+    }
+  ) {
+    aggregates {
+      sum {
+        balance
+      }
+      distinctCount {
+        providerId
+      }
+    }
+    groupedAggregates(groupBy: [CHAIN, TOKEN_ADDRESS]) {
+      keys
+      sum {
+        balance
+      }
+      distinctCount {
+        providerId
+      }
+    }
+  }
+}`;
 var TOKEN_GATEWAY_ASSET_TELEPORTED_STATUS = `
 query TokenGatewayAssetTeleportedStatus($commitment: String!) {
   tokenGatewayAssetTeleportedV2s(
@@ -12090,6 +12225,7 @@ function createCancellationStorage(options = {}) {
       const decoded = decodeIProof(value);
       return decoded;
     }
+    if (key2.includes("postCommitment")) return value;
     throw new Error(`Unknown storage key type: ${key2}`);
   };
   const setItem = async (key2, value) => {
@@ -12103,6 +12239,10 @@ function createCancellationStorage(options = {}) {
       await baseStorage.setItem(key2, encoded);
       return;
     }
+    if (key2.includes("postCommitment") && typeof value === "string") {
+      await baseStorage.setItem(key2, value);
+      return;
+    }
     throw new Error(`Unknown storage key type: ${key2}`);
   };
   const removeItem = async (key2) => {
@@ -12116,11 +12256,25 @@ function createCancellationStorage(options = {}) {
   });
 }
 var STORAGE_KEYS = Object.freeze({
-  destProof: (orderId) => `cancel-order:${orderId}:destProof`,
-  getRequest: (orderId) => `cancel-order:${orderId}:getRequest`,
-  sourceProof: (orderId) => `cancel-order:${orderId}:sourceProof`,
-  postCommitment: (orderId) => `cancel-order:${orderId}:postCommitment`
+  destProof: (orderId, source, destination) => `cancel-order:${cancellationScope(orderId, source, destination)}:destProof`,
+  getRequest: (orderId, source, destination) => `cancel-order:${cancellationScope(orderId, source, destination)}:getRequest`,
+  sourceProof: (orderId, source, destination) => `cancel-order:${cancellationScope(orderId, source, destination)}:sourceProof`,
+  postCommitment: (orderId, source, destination) => `cancel-order:${cancellationScope(orderId, source, destination)}:postCommitment`
 });
+var LEGACY_STORAGE_KEYS = Object.freeze({
+  destProof: (orderId, source, destination) => `cancel-order:${legacyCancellationScope(orderId, source, destination)}:destProof`,
+  getRequest: (orderId, source, destination) => `cancel-order:${legacyCancellationScope(orderId, source, destination)}:getRequest`,
+  sourceProof: (orderId, source, destination) => `cancel-order:${legacyCancellationScope(orderId, source, destination)}:sourceProof`,
+  postCommitment: (orderId, source, destination) => `cancel-order:${legacyCancellationScope(orderId, source, destination)}:postCommitment`
+});
+function cancellationScope(orderId, source, destination) {
+  if (!source || !destination) return orderId;
+  return `${orderId}:${encodeURIComponent(normalizeStateMachineId(source))}:${encodeURIComponent(normalizeStateMachineId(destination))}`;
+}
+function legacyCancellationScope(orderId, source, destination) {
+  if (!source || !destination) return orderId;
+  return `${orderId}:${encodeURIComponent(source)}:${encodeURIComponent(destination)}`;
+}
 function createUsedUserOpsStorage(options = {}) {
   options.env ?? detectEnvironment();
   const driver = loadDriver({ options }) ?? inMemoryDriver__default.default();
@@ -15286,6 +15440,29 @@ async function convertFeeTokenToWei(ctx, feeTokenAmount, feeTokenIn, evmChainID)
 }
 
 // src/protocols/intents/OrderPlacer.ts
+function deriveCanonicalPlacedOrder(order, args) {
+  const canonicalOrder = {
+    ...order,
+    user: args.user,
+    source: args.source,
+    destination: args.destination,
+    deadline: args.deadline,
+    nonce: args.nonce,
+    fees: args.fees,
+    session: args.session,
+    predispatch: {
+      assets: args.predispatch.map((asset) => ({ ...asset })),
+      call: order.predispatch.call
+    },
+    inputs: args.inputs.map((asset) => ({ ...asset })),
+    output: {
+      beneficiary: args.beneficiary,
+      assets: args.outputs.map((asset) => ({ ...asset })),
+      call: order.output.call
+    }
+  };
+  return { ...canonicalOrder, id: orderCommitment(canonicalOrder) };
+}
 var OrderPlacer = class {
   /**
    * @param ctx - Shared IntentsV2 context providing the source chain client,
@@ -15302,17 +15479,16 @@ var OrderPlacer = class {
    * 1. Yields `{ to, data, sessionPrivateKey }` — the caller must sign a
    *    transaction sending `data` to `to` and pass the signed transaction back
    *    via `gen.next(signedTx)`.
-   * 2. Returns `{ order, transactionHash }` — the finalized order with its
-   *    on-chain `nonce`, `inputs`, and computed `id`, plus the placement
-   *    transaction hash.
+   * 2. Returns `{ order, transactionHash }` — the finalized order rebuilt from
+   *    the canonical `OrderPlaced` fields with its computed `id`, plus the
+   *    placement transaction hash.
    *
    * A fresh ephemeral session key is generated for every call. The key is
    * stored immediately (without a commitment) so it can be retrieved by
    * address, then updated with the commitment once the `OrderPlaced` event
-   * confirms the nonce.
+   * confirms the canonical order.
    *
-   * @param order - The order to place. `order.session` is mutated in-place
-   *   with the generated session key address before yielding.
+   * @param order - The order to place. It is not mutated.
    * @param graffiti - Optional bytes32 tag for orderflow attribution /
    *   revenue share. Defaults to {@link DEFAULT_GRAFFITI} (bytes32 zero).
    * @yields `{ to, data, sessionPrivateKey }` — target contract address,
@@ -15327,7 +15503,7 @@ var OrderPlacer = class {
     const account = accounts.privateKeyToAccount(privateKey);
     const sessionKeyAddress = account.address;
     const createdAt = Date.now();
-    order.session = sessionKeyAddress;
+    const placementOrder = { ...order, session: sessionKeyAddress };
     await this.ctx.sessionKeyStorage.setSessionKeyByAddress(sessionKeyAddress, {
       privateKey,
       address: sessionKeyAddress,
@@ -15336,7 +15512,7 @@ var OrderPlacer = class {
     const data = viem.encodeFunctionData({
       abi: ABI3,
       functionName: "placeOrder",
-      args: [transformOrderForContract(order), graffiti]
+      args: [transformOrderForContract(placementOrder), graffiti]
     });
     const intentGatewayAddress = this.ctx.source.configService.getIntentGatewayAddress(
       normalizeStateMachineId(order.source)
@@ -15356,20 +15532,15 @@ var OrderPlacer = class {
     if (!orderPlacedEvent) {
       throw new Error("OrderPlaced event not found in transaction receipt");
     }
-    order.nonce = orderPlacedEvent.args.nonce;
-    order.inputs = orderPlacedEvent.args.inputs.map((input) => ({
-      token: input.token,
-      amount: input.amount
-    }));
-    order.id = orderCommitment(order);
+    const finalizedOrder = deriveCanonicalPlacedOrder(placementOrder, orderPlacedEvent.args);
     const sessionKeyData = {
       privateKey,
       address: sessionKeyAddress,
-      commitment: order.id,
+      commitment: finalizedOrder.id,
       createdAt
     };
     await this.ctx.sessionKeyStorage.setSessionKeyByAddress(sessionKeyAddress, sessionKeyData);
-    return { order, receipt };
+    return { order: finalizedOrder, receipt };
   }
 };
 
@@ -15699,7 +15870,7 @@ var OrderExecutor = class {
     }
   }
 };
-var OrderCanceller = class {
+var OrderCanceller = class _OrderCanceller {
   /**
    * @param ctx - Shared IntentsV2 context providing the source and destination
    *   chain clients, config service, and cancellation storage.
@@ -15708,6 +15879,9 @@ var OrderCanceller = class {
     this.ctx = ctx;
   }
   ctx;
+  static DEFAULT_MAX_RECOVERY_RESTARTS = 1;
+  static PROOF_FRESHNESS_MAX_RETRIES = 3;
+  static PROOF_FRESHNESS_BACKOFF_MS = 500;
   logger = consola.createConsola({
     level: consola.LogLevels.info,
     formatOptions: { columns: 80, colors: true, compact: true, date: false }
@@ -15739,11 +15913,14 @@ var OrderCanceller = class {
    * @returns The native token dispatch fee in wei.
    */
   async quoteCancelFromSource(order) {
-    if (order.source === order.destination) return { nativeValue: 0n, relayerFee: 0n };
     const sourceStateMachine = normalizeStateMachineId(order.source);
+    const destStateMachine = normalizeStateMachineId(order.destination);
+    if (sourceStateMachine === destStateMachine) {
+      return { nativeValue: 0n, relayerFee: 0n };
+    }
     const height = order.deadline + 1n;
     const destIntentGateway = this.ctx.dest.configService.getIntentGatewayAddress(
-      normalizeStateMachineId(order.destination)
+      destStateMachine
     );
     const slotHash = await this.ctx.dest.client.readContract({
       abi: ABI3,
@@ -15755,8 +15932,8 @@ var OrderCanceller = class {
     const context = encodeWithdrawalRequest(order, order.user);
     const getRequest = {
       source: sourceStateMachine,
-      dest: normalizeStateMachineId(order.destination),
-      from: this.ctx.source.configService.getIntentGatewayAddress(normalizeStateMachineId(order.destination)),
+      dest: destStateMachine,
+      from: this.ctx.source.configService.getIntentGatewayAddress(destStateMachine),
       nonce: await this.ctx.source.getHostNonce(),
       height,
       keys: [key],
@@ -15773,7 +15950,9 @@ var OrderCanceller = class {
    * cancellation is complete.
    *
    * Delegates to `cancelOrderFromSource` or `cancelOrderFromDest` based on
-   * the `from` parameter.
+   * the `from` parameter. If Hyperbridge has pruned consensus data needed for
+   * source-side GET recovery, clears its stale checkpoint and restarts the
+   * source-side stream internally.
    *
    * @param order - The order to cancel.
    * @param indexerClient - Indexer client used to stream ISMP request status
@@ -15783,12 +15962,32 @@ var OrderCanceller = class {
    *   cancellation lifecycle.
    */
   async *cancelOrder(order, indexerClient, options = {}) {
-    const isSameChain = order.source === order.destination;
+    const sourceStateMachine = normalizeStateMachineId(order.source);
+    const destStateMachine = normalizeStateMachineId(order.destination);
+    const isSameChain = sourceStateMachine === destStateMachine;
     if (options.from === "destination" && !isSameChain) {
       yield* this.cancelOrderFromDest(order, indexerClient);
       return;
     }
-    yield* this.cancelOrderFromSource(order, indexerClient);
+    let recoveryRestarts = 0;
+    while (true) {
+      try {
+        yield* this.cancelOrderFromSource(order, indexerClient);
+        return;
+      } catch (error) {
+        if (!MissingConsensusUpdateTimeError.isError(error)) throw error;
+        if (recoveryRestarts >= _OrderCanceller.DEFAULT_MAX_RECOVERY_RESTARTS) {
+          throw new Error(
+            `Cancellation recovery stopped after ${recoveryRestarts} restart(s): Hyperbridge no longer retains a required consensus update.`
+          );
+        }
+        recoveryRestarts += 1;
+        this.logger.warn(
+          `Restarting cancellation recovery (${recoveryRestarts}/${_OrderCanceller.DEFAULT_MAX_RECOVERY_RESTARTS}) after a required consensus update was pruned`
+        );
+        await this.clearGetRecoveryCache(order);
+      }
+    }
   }
   /**
    * Async generator that cancels an order by initiating the cancel from the
@@ -15814,11 +16013,10 @@ var OrderCanceller = class {
    * @throws If the cancel transaction does not contain the expected on-chain event.
    */
   async *cancelOrderFromSource(order, indexerClient) {
-    const orderId = order.id;
-    const isSameChain = order.source === order.destination;
-    const intentGatewayAddress = this.ctx.source.configService.getIntentGatewayAddress(
-      normalizeStateMachineId(order.source)
-    );
+    const sourceStateMachine = normalizeStateMachineId(order.source);
+    const destStateMachine = normalizeStateMachineId(order.destination);
+    const isSameChain = sourceStateMachine === destStateMachine;
+    const intentGatewayAddress = this.ctx.source.configService.getIntentGatewayAddress(sourceStateMachine);
     if (isSameChain) {
       const data = viem.encodeFunctionData({
         abi: ABI3,
@@ -15847,18 +16045,37 @@ var OrderCanceller = class {
       };
       return;
     }
+    const storageKeys = this.recoveryStorageKeys(order);
+    const legacyStorageKeys = this.legacyRecoveryStorageKeys(order);
     const hyperbridge = indexerClient.hyperbridge;
-    const sourceStateMachine = normalizeStateMachineId(order.source);
     const sourceConsensusStateId = this.ctx.source.configService.getConsensusStateId(sourceStateMachine);
-    let destIProof = await this.ctx.cancellationStorage.getItem(STORAGE_KEYS.destProof(orderId));
+    let destIProof = await this.getRecoveryItem(
+      storageKeys.destProof,
+      legacyStorageKeys.map((keys) => keys.destProof)
+    );
     if (!destIProof) {
       destIProof = yield* this.fetchDestinationProof(order, indexerClient);
-      await this.ctx.cancellationStorage.setItem(STORAGE_KEYS.destProof(orderId), destIProof);
+      await this.ctx.cancellationStorage.setItem(storageKeys.destProof, destIProof);
     } else {
-      yield { status: "DESTINATION_FINALIZED", proof: destIProof };
+      let refreshed = false;
+      try {
+        await this.assertProofFresh(hyperbridge, destIProof);
+      } catch (error) {
+        if (!MissingConsensusUpdateTimeError.isError(error)) throw error;
+        await this.removeRecoveryItems(
+          storageKeys.destProof,
+          ...legacyStorageKeys.map((keys) => keys.destProof)
+        );
+        destIProof = yield* this.fetchDestinationProof(order, indexerClient);
+        await this.ctx.cancellationStorage.setItem(storageKeys.destProof, destIProof);
+        refreshed = true;
+      }
+      if (!refreshed) yield { status: "DESTINATION_FINALIZED", proof: destIProof };
     }
-    let getRequest = await this.ctx.cancellationStorage.getItem(
-      STORAGE_KEYS.getRequest(orderId)
+    await this.assertProofFresh(hyperbridge, destIProof);
+    let getRequest = await this.getRecoveryItem(
+      storageKeys.getRequest,
+      legacyStorageKeys.map((keys) => keys.getRequest)
     );
     if (!getRequest) {
       const quote = await this.quoteCancelFromSource(order);
@@ -15878,7 +16095,7 @@ var OrderCanceller = class {
       const request = events.find((e) => e.eventName === "GetRequestEvent");
       if (!request) throw new Error("GetRequest missing");
       getRequest = request.args;
-      await this.ctx.cancellationStorage.setItem(STORAGE_KEYS.getRequest(orderId), getRequest);
+      await this.ctx.cancellationStorage.setItem(storageKeys.getRequest, getRequest);
       yield {
         status: "CANCEL_STARTED",
         receipt
@@ -15897,8 +16114,9 @@ var OrderCanceller = class {
             metadata: statusUpdate.metadata
           };
           const sourceHeight = BigInt(statusUpdate.metadata.blockNumber);
-          let sourceIProof = await this.ctx.cancellationStorage.getItem(
-            STORAGE_KEYS.sourceProof(orderId)
+          let sourceIProof = await this.getRecoveryItem(
+            storageKeys.sourceProof,
+            legacyStorageKeys.map((keys) => keys.sourceProof)
           );
           if (!sourceIProof) {
             sourceIProof = await fetchSourceProof(
@@ -15908,8 +16126,9 @@ var OrderCanceller = class {
               sourceConsensusStateId,
               sourceHeight
             );
-            await this.ctx.cancellationStorage.setItem(STORAGE_KEYS.sourceProof(orderId), sourceIProof);
+            await this.ctx.cancellationStorage.setItem(storageKeys.sourceProof, sourceIProof);
           }
+          await this.assertProofFresh(hyperbridge, sourceIProof);
           await waitForChallengePeriod(hyperbridge, {
             height: sourceIProof.height,
             id: {
@@ -15917,6 +16136,10 @@ var OrderCanceller = class {
               consensusStateId: sourceConsensusStateId
             }
           });
+          await Promise.all([
+            this.assertProofFresh(hyperbridge, sourceIProof),
+            this.assertProofFresh(hyperbridge, destIProof)
+          ]);
           const getRequestMessage = {
             kind: "GetRequest",
             requests: [getRequest],
@@ -15938,9 +16161,12 @@ var OrderCanceller = class {
             status: "HYPERBRIDGE_FINALIZED",
             metadata: statusUpdate.metadata
           };
-          await this.ctx.cancellationStorage.removeItem(STORAGE_KEYS.destProof(orderId));
-          await this.ctx.cancellationStorage.removeItem(STORAGE_KEYS.getRequest(orderId));
-          await this.ctx.cancellationStorage.removeItem(STORAGE_KEYS.sourceProof(orderId));
+          await this.removeRecoveryItems(
+            storageKeys.destProof,
+            storageKeys.getRequest,
+            storageKeys.sourceProof,
+            ...legacyStorageKeys.flatMap((keys) => [keys.destProof, keys.getRequest, keys.sourceProof])
+          );
           return;
       }
     }
@@ -15957,9 +16183,11 @@ var OrderCanceller = class {
    * @returns The native token dispatch fee in wei.
    */
   async quoteCancelFromDest(order) {
-    if (order.source === order.destination) return { nativeValue: 0n, relayerFee: 0n };
-    const destStateMachine = normalizeStateMachineId(order.destination);
     const sourceStateMachine = normalizeStateMachineId(order.source);
+    const destStateMachine = normalizeStateMachineId(order.destination);
+    if (sourceStateMachine === destStateMachine) {
+      return { nativeValue: 0n, relayerFee: 0n };
+    }
     const destIntentGateway = this.ctx.dest.configService.getIntentGatewayAddress(destStateMachine);
     const sourceIntentGateway = this.ctx.source.configService.getIntentGatewayAddress(sourceStateMachine);
     const relayerFee = await this.estimateRelayerFee(sourceStateMachine, destStateMachine);
@@ -15997,11 +16225,13 @@ var OrderCanceller = class {
    * @throws If the cancel transaction does not contain a `PostRequestEvent`.
    */
   async *cancelOrderFromDest(order, indexerClient) {
-    const orderId = order.id;
+    const storageKeys = this.recoveryStorageKeys(order);
     const destStateMachine = normalizeStateMachineId(order.destination);
     const intentGatewayAddress = this.ctx.dest.configService.getIntentGatewayAddress(destStateMachine);
-    let commitment = await this.ctx.cancellationStorage.getItem(
-      STORAGE_KEYS.postCommitment(orderId)
+    const legacyStorageKeys = this.legacyRecoveryStorageKeys(order);
+    let commitment = await this.getRecoveryItem(
+      storageKeys.postCommitment,
+      legacyStorageKeys.map((keys) => keys.postCommitment)
     );
     if (!commitment) {
       const quote = await this.quoteCancelFromDest(order);
@@ -16026,7 +16256,7 @@ var OrderCanceller = class {
       if (!postEvent) throw new Error("PostRequestEvent not found in cancel transaction receipt");
       const postArgs = postEvent.args;
       commitment = postRequestCommitment(postArgs).commitment;
-      await this.ctx.cancellationStorage.setItem(STORAGE_KEYS.postCommitment(orderId), commitment);
+      await this.ctx.cancellationStorage.setItem(storageKeys.postCommitment, commitment);
     }
     const statusStream = indexerClient.postRequestStatusStream(commitment);
     for await (const statusUpdate of statusStream) {
@@ -16060,7 +16290,10 @@ var OrderCanceller = class {
           if (refundEvents.length === 0) {
             throw new Error("EscrowRefunded event not found in source-chain delivery receipt");
           }
-          await this.ctx.cancellationStorage.removeItem(STORAGE_KEYS.postCommitment(orderId));
+          await this.removeRecoveryItems(
+            storageKeys.postCommitment,
+            ...legacyStorageKeys.map((keys) => keys.postCommitment)
+          );
           yield {
             status: "CANCELLATION_COMPLETE",
             blockNumber: statusUpdate.metadata.blockNumber,
@@ -16103,7 +16336,7 @@ var OrderCanceller = class {
         const intentGatewayV2Address = this.ctx.dest.configService.getIntentGatewayAddress(
           this.ctx.dest.config.stateMachineId
         );
-        const orderId = order.id;
+        const orderId = this.orderId(order);
         const slotHash = await this.ctx.dest.client.readContract({
           abi: ABI3,
           address: intentGatewayV2Address,
@@ -16120,6 +16353,7 @@ var OrderCanceller = class {
         yield { status: "DESTINATION_FINALIZED", proof };
         return proof;
       } catch (e) {
+        if (MissingConsensusUpdateTimeError.isError(e)) throw e;
         lastFailedHeight = latestHeight;
         await sleep(1e4);
       }
@@ -16150,6 +16384,7 @@ var OrderCanceller = class {
       this.logger.info(`Unsigned GET ${commitment} submitted; waiting for Hyperbridge response receipt`);
       await sleep(3e4);
     } catch (error) {
+      if (MissingConsensusUpdateTimeError.isError(error)) throw error;
       this.logger.warn(
         `Unsigned GET submit failed for ${commitment}; polling response receipt before failing: ${String(error)}`
       );
@@ -16158,14 +16393,128 @@ var OrderCanceller = class {
       await this.pollDeliveredReceipt(hyperbridge, commitment);
       this.logger.info(`Confirmed Hyperbridge GET delivery for ${commitment}`);
     } catch (error) {
+      if (MissingConsensusUpdateTimeError.isError(error)) throw error;
       const message2 = `Failed to deliver GET request to Hyperbridge; no response receipt found for ${commitment}: ${String(error)}`;
       this.logger.error(message2);
       throw new Error(message2);
     }
   }
+  /** Verify that Hyperbridge still retains the consensus update for a proof. */
+  async assertProofFresh(hyperbridge, proof) {
+    await retryPromise(
+      () => hyperbridge.stateMachineUpdateTime({
+        height: proof.height,
+        id: {
+          stateId: parseStateMachineId(proof.stateMachine).stateId,
+          consensusStateId: proof.consensusStateId
+        }
+      }),
+      {
+        maxRetries: _OrderCanceller.PROOF_FRESHNESS_MAX_RETRIES,
+        backoffMs: _OrderCanceller.PROOF_FRESHNESS_BACKOFF_MS,
+        logger: this.logger,
+        logMessage: `Checking consensus update time for proof at height ${proof.height}`,
+        shouldRetry: (error) => !MissingConsensusUpdateTimeError.isError(error)
+      }
+    );
+  }
+  /**
+   * Drops the source-initiated GET recovery checkpoint after Hyperbridge prunes
+   * a consensus update required by that recovery attempt.
+   */
+  async clearGetRecoveryCache(order) {
+    const keys = this.recoveryStorageKeys(order);
+    const legacyStorageKeys = this.legacyRecoveryStorageKeys(order);
+    await this.removeRecoveryItems(
+      keys.destProof,
+      keys.sourceProof,
+      keys.getRequest,
+      ...legacyStorageKeys.flatMap((legacyKeys) => [
+        legacyKeys.destProof,
+        legacyKeys.sourceProof,
+        legacyKeys.getRequest
+      ])
+    );
+  }
+  /**
+   * Returns the pair-scoped storage keys used to resume cancellation recovery
+   * for an order.
+   *
+   * @param order - The order whose source/destination recovery state is stored.
+   */
+  recoveryStorageKeys(order) {
+    const orderId = this.orderId(order);
+    return {
+      destProof: STORAGE_KEYS.destProof(orderId, order.source, order.destination),
+      getRequest: STORAGE_KEYS.getRequest(orderId, order.source, order.destination),
+      sourceProof: STORAGE_KEYS.sourceProof(orderId, order.source, order.destination),
+      postCommitment: STORAGE_KEYS.postCommitment(orderId, order.source, order.destination)
+    };
+  }
+  /** Older SDK key shapes, checked once and migrated to the normalized pair-scoped key. */
+  legacyRecoveryStorageKeys(order) {
+    const orderId = this.orderId(order);
+    return [
+      {
+        destProof: LEGACY_STORAGE_KEYS.destProof(orderId, order.source, order.destination),
+        getRequest: LEGACY_STORAGE_KEYS.getRequest(orderId, order.source, order.destination),
+        sourceProof: LEGACY_STORAGE_KEYS.sourceProof(orderId, order.source, order.destination),
+        postCommitment: LEGACY_STORAGE_KEYS.postCommitment(orderId, order.source, order.destination)
+      },
+      {
+        destProof: LEGACY_STORAGE_KEYS.destProof(orderId),
+        getRequest: LEGACY_STORAGE_KEYS.getRequest(orderId),
+        sourceProof: LEGACY_STORAGE_KEYS.sourceProof(orderId),
+        postCommitment: LEGACY_STORAGE_KEYS.postCommitment(orderId)
+      }
+    ];
+  }
+  async getRecoveryItem(currentKey, legacyKeys) {
+    const current = await this.ctx.cancellationStorage.getItem(currentKey);
+    if (current) return current;
+    for (const legacyKey of new Set(legacyKeys)) {
+      if (legacyKey === currentKey) continue;
+      const legacy = await this.ctx.cancellationStorage.getItem(legacyKey);
+      if (!legacy) continue;
+      await this.ctx.cancellationStorage.setItem(currentKey, legacy);
+      await this.ctx.cancellationStorage.removeItem(legacyKey);
+      return legacy;
+    }
+    return null;
+  }
+  async removeRecoveryItems(...keys) {
+    await Promise.all(
+      [...new Set(keys)].map((key) => this.ctx.cancellationStorage.removeItem(key))
+    );
+  }
+  /**
+   * Returns the order identifier required to persist or clear recovery state.
+   *
+   * @param order - The order being cancelled.
+   * @throws If the order has no identifier.
+   */
+  orderId(order) {
+    if (!order.id) throw new Error("An order id is required to recover cancellation");
+    return order.id;
+  }
+  /**
+   * Reads the Hyperbridge response receipt for a GET request commitment.
+   *
+   * @param hyperbridge - Hyperbridge chain client used to query the receipt.
+   * @param commitment - Commitment of the GET request.
+   * @returns The receipt commitment when delivered, otherwise `undefined`.
+   */
   async queryDeliveredReceipt(hyperbridge, commitment) {
     return hyperbridge.queryResponseReceipt(commitment);
   }
+  /**
+   * Polls Hyperbridge until it records a response receipt for the GET request.
+   *
+   * @param hyperbridge - Hyperbridge chain client used to query the receipt.
+   * @param commitment - Commitment of the GET request.
+   * @returns The delivered response receipt commitment.
+   * @throws If no receipt is observed within the configured retry limit.
+   */
   async pollDeliveredReceipt(hyperbridge, commitment) {
     this.logger.info(`Polling Hyperbridge GET response receipt for ${commitment}`);
     return retryPromise(
@@ -17378,6 +17727,178 @@ var OrderStatusChecker = class {
     return true;
   }
 };
+var COMMITMENT_PATTERN = /^0x[0-9a-f]{64}$/i;
+var LiquidityEngine = class {
+  /**
+   * @param queryClient - Nexus GraphQL client attached to the gateway.
+   * @param chainConfigService - Resolves token decimals for formatted results.
+   */
+  constructor(queryClient, chainConfigService) {
+    this.queryClient = queryClient;
+    this.chainConfigService = chainConfigService;
+  }
+  queryClient;
+  chainConfigService;
+  /**
+   * Retrieves the newest directional Phantom snapshot for a pair and its
+   * indexed output-token liquidity.
+   *
+   * Nexus filters balances to the canonical output token, then aggregates them
+   * overall and by chain. The returned amounts are decimal strings: the total
+   * uses the canonical Base output-token decimals, while each chain group uses
+   * that chain's token decimals. They describe `snapshotTime`, not live
+   * reservations or fill guarantees.
+   *
+   * @param params - Canonical Phantom-market input and output token addresses.
+   * @returns The latest snapshot, or `undefined` if Nexus has no snapshot for
+   * the directional pair.
+   * @throws {InvalidAvailableLiquiditySnapshotError} If Nexus returns malformed
+   * or internally inconsistent snapshot data.
+   */
+  async getAvailableLiquiditySnapshot(params) {
+    const tokenIn = normalizeEvmAddress(params.tokenIn, "tokenIn");
+    const tokenOut = normalizeEvmAddress(params.tokenOut, "tokenOut");
+    const response = await this.queryClient.request(
+      LATEST_PHANTOM_ORDER_LIQUIDITY_SNAPSHOT,
+      { tokenA: tokenIn, tokenB: tokenOut }
+    );
+    const node = response?.phantomOrderPriceSnapshots?.nodes?.[0];
+    if (!node) return;
+    const commitment = node.commitment.toLowerCase();
+    if (!COMMITMENT_PATTERN.test(commitment)) {
+      throw new InvalidAvailableLiquiditySnapshotError(commitment || "<missing>", "commitment is not bytes32 hex");
+    }
+    if (node.tokenA.toLowerCase() !== tokenIn || node.tokenB.toLowerCase() !== tokenOut) {
+      throw new InvalidAvailableLiquiditySnapshotError(commitment, "snapshot token pair does not match the query");
+    }
+    const snapshotTime = new Date(dateStringtoTimestamp(node.snapshotTime));
+    if (Number.isNaN(snapshotTime.getTime())) {
+      throw new InvalidAvailableLiquiditySnapshotError(commitment, "snapshotTime is invalid");
+    }
+    const { totalLiquidity, providerCount, liquidityByChain } = await this.querySnapshotLiquidityAggregates({
+      commitment,
+      tokenAddress: tokenOut
+    });
+    return {
+      totalLiquidity: this.formatLiquidity(totalLiquidity, "EVM-8453" /* BASE_MAINNET */, tokenOut, commitment),
+      providerCount,
+      tokenAddress: tokenOut,
+      snapshotTime,
+      liquidityByChain: liquidityByChain.map((group) => ({
+        ...group,
+        totalLiquidity: this.formatLiquidity(group.totalLiquidity, group.chain, group.tokenAddress, commitment)
+      }))
+    };
+  }
+  /**
+   * Requests server-side sums and distinct provider counts for one immutable
+   * snapshot/output-token pair, including chain-level aggregate groups.
+   *
+   * `commitment` uniquely identifies the selected snapshot
+   */
+  async querySnapshotLiquidityAggregates(params) {
+    const response = await this.queryClient.request(
+      LIQUIDITY_PROVIDER_BALANCES,
+      { commitment: params.commitment, tokenAddress: params.tokenAddress }
+    );
+    const connection = response?.liquidityProviderBalances;
+    const aggregates = connection?.aggregates;
+    if (!connection || !aggregates) {
+      throw new InvalidAvailableLiquiditySnapshotError(
+        params.commitment,
+        "liquidityProviderBalances aggregates are missing"
+      );
+    }
+    const totalLiquidity = parseSnapshotBigInt(aggregates.sum.balance ?? "0", params.commitment, "total balance");
+    const providerCount = parseProviderCount(aggregates.distinctCount.providerId, params.commitment, "total");
+    const liquidityByChain = connection.groupedAggregates.map((group, index) => {
+      const [chain, tokenAddress] = group.keys;
+      if (!chain?.trim() || !tokenAddress) {
+        throw new InvalidAvailableLiquiditySnapshotError(
+          params.commitment,
+          `liquidity group ${index} has invalid keys`
+        );
+      }
+      const normalizedTokenAddress = normalizeIndexedLiquidityAddress(
+        tokenAddress,
+        params.commitment,
+        `liquidity group ${index} tokenAddress`
+      );
+      if (normalizedTokenAddress !== params.tokenAddress) {
+        throw new InvalidAvailableLiquiditySnapshotError(
+          params.commitment,
+          `liquidity group ${index} tokenAddress does not match the snapshot output token`
+        );
+      }
+      return {
+        chain: chain.trim(),
+        tokenAddress: normalizedTokenAddress,
+        totalLiquidity: parseSnapshotBigInt(
+          group.sum.balance ?? "0",
+          params.commitment,
+          `liquidity group ${index} balance`
+        ),
+        providerCount: parseProviderCount(
+          group.distinctCount.providerId,
+          params.commitment,
+          `liquidity group ${index}`
+        )
+      };
+    });
+    const groupedTotal = liquidityByChain.reduce((sum, group) => sum + group.totalLiquidity, 0n);
+    if (groupedTotal !== totalLiquidity) {
+      throw new InvalidAvailableLiquiditySnapshotError(
+        params.commitment,
+        "grouped liquidity does not match the total liquidity"
+      );
+    }
+    return { totalLiquidity, providerCount, liquidityByChain };
+  }
+  /** Formats a raw amount using the configured decimals for its chain/token. */
+  formatLiquidity(amount, chain, tokenAddress, commitment) {
+    const decimals = this.chainConfigService.getAssetMetadataByAddress(chain, tokenAddress)?.decimals;
+    if (decimals === void 0) {
+      throw new InvalidAvailableLiquiditySnapshotError(
+        commitment,
+        `token decimals are not configured for ${tokenAddress} on ${chain}`
+      );
+    }
+    return viem.formatUnits(amount, decimals);
+  }
+};
+var InvalidAvailableLiquiditySnapshotError = class extends Error {
+  /** Creates an error that identifies the invalid snapshot and field/reason. */
+  constructor(commitment, reason) {
+    super(`Invalid available-liquidity snapshot ${commitment}: ${reason}`);
+    this.name = "InvalidAvailableLiquiditySnapshotError";
+  }
+};
+function parseSnapshotBigInt(value, commitment, field) {
+  try {
+    const amount = BigInt(value);
+    if (amount < 0n) {
+      throw new InvalidAvailableLiquiditySnapshotError(commitment, `${field} cannot be negative`);
+    }
+    return amount;
+  } catch (error) {
+    if (error instanceof InvalidAvailableLiquiditySnapshotError) throw error;
+    throw new InvalidAvailableLiquiditySnapshotError(commitment, `${field} is not an integer`);
+  }
+}
+function parseProviderCount(value, commitment, field) {
+  const count = Number(value);
+  if (!Number.isSafeInteger(count) || count < 0) {
+    throw new InvalidAvailableLiquiditySnapshotError(commitment, `${field} provider count is invalid`);
+  }
+  return count;
+}
+function normalizeIndexedLiquidityAddress(address, commitment, field) {
+  try {
+    return normalizeEvmAddress(address, field);
+  } catch {
+    throw new InvalidAvailableLiquiditySnapshotError(commitment, `${field} is not a valid EVM address`);
+  }
+}
 
 // src/protocols/intents/quote/types.ts
 var UnsupportedIntentQuoteStrategyError = class extends Error {
@@ -17664,12 +18185,14 @@ var PhantomSnapshotIntentQuoteStrategy = class {
   constructor(chainConfigService, getQueryClient) {
     this.chainConfigService = chainConfigService;
     this.getQueryClient = getQueryClient;
+    this.pairResolver = new PhantomSnapshotPairResolver(chainConfigService);
   }
   chainConfigService;
   getQueryClient;
+  pairResolver;
   async quote(params, source, destination) {
     validateQuoteParams(params);
-    const pair = this.resolveBaseSnapshotPair(params, source.stateMachineId, destination.stateMachineId);
+    const pair = this.pairResolver.resolve(params, source.stateMachineId, destination.stateMachineId);
     if (!pair) {
       throw new UnsupportedIntentQuotePairError({
         source: source.stateMachineId,
@@ -17742,7 +18265,13 @@ var PhantomSnapshotIntentQuoteStrategy = class {
       throw new InvalidPhantomSnapshotError(snapshot.commitment, "snapshotTime is invalid");
     }
   }
-  resolveBaseSnapshotPair(params, sourceStateMachineId, destinationStateMachineId) {
+};
+var PhantomSnapshotPairResolver = class {
+  constructor(chainConfigService) {
+    this.chainConfigService = chainConfigService;
+  }
+  chainConfigService;
+  resolve(params, sourceStateMachineId, destinationStateMachineId) {
     const tokenIn = this.resolveBaseSnapshotToken(sourceStateMachineId, params.tokenIn);
     const tokenOut = this.resolveBaseSnapshotToken(destinationStateMachineId, params.tokenOut);
     if (!tokenIn || !tokenOut || !isSupportedSnapshotPair(tokenIn.symbol, tokenOut.symbol)) return;
@@ -17794,6 +18323,8 @@ var IntentGateway = class _IntentGateway {
   gasEstimator;
   /** Quote strategies for pricing orders before placement, keyed by strategy name. */
   quoteStrategies;
+  /** Resolves order tokens to canonical Phantom snapshot market pairs. */
+  phantomSnapshotPairResolver;
   /**
    * Private constructor — use {@link IntentGateway.create} instead.
    *
@@ -17837,6 +18368,7 @@ var IntentGateway = class _IntentGateway {
     this.bidManager = bidManager;
     this.gasEstimator = gasEstimator;
     this._crypto = crypto;
+    this.phantomSnapshotPairResolver = new PhantomSnapshotPairResolver(dest.configService);
     this.quoteStrategies = {
       phantom_snapshot: new PhantomSnapshotIntentQuoteStrategy(
         dest.configService,
@@ -17915,13 +18447,43 @@ var IntentGateway = class _IntentGateway {
     if (!handler) throw new UnsupportedIntentQuoteStrategyError(strategy);
     return handler.quote({ ...params, strategy }, source, destination);
   }
+  /**
+   * Returns the output-token liquidity measured in the latest directional
+   * Phantom snapshot for this gateway's source and destination.
+   *
+   * Pair resolution uses the same canonical Base market as {@link quoteIntent}.
+   * The snapshot itself determines the output token and chain to aggregate. The
+   * amount is in the token's smallest unit and reflects the indexer's
+   * `snapshotTime`; it is not a live reservation or fill guarantee.
+   *
+   * Requires a prior call to {@link withQueryClient}.
+   */
+  async queryAvailableLiquidity(params) {
+    const { queryClient } = this.requireIndexer();
+    const sourceStateMachineId = this.source.config.stateMachineId;
+    const destinationStateMachineId = this.dest.config.stateMachineId;
+    const pair = this.phantomSnapshotPairResolver.resolve(params, sourceStateMachineId, destinationStateMachineId);
+    if (!pair) {
+      throw new UnsupportedIntentQuotePairError({
+        source: sourceStateMachineId,
+        destination: destinationStateMachineId,
+        tokenIn: params.tokenIn,
+        tokenOut: params.tokenOut,
+        quoteSource: "Phantom snapshot pair"
+      });
+    }
+    return new LiquidityEngine(queryClient, this.dest.configService).getAvailableLiquiditySnapshot({
+      tokenIn: pair.tokenA,
+      tokenOut: pair.tokenB
+    });
+  }
   /**
    * Bidirectional async generator that orchestrates the full order lifecycle:
    * placement, fee estimation, bid collection, and execution.
    *
    * **Yield/receive protocol:**
-   * 1. If `order.fees` is unset or zero, estimates gas and sets same-chain
-   *    `order.fees` to twice the estimate. Cross-chain orders retain a 1% buffer
+   * 1. If `order.fees` is unset or zero, estimates gas on an internal copy and sets
+   *    same-chain fees to twice the estimate. Cross-chain orders retain a 1% buffer
    *    and include an additional 600k-gas fee uplift, while the wei cost used for
    *    the `value` field receives a 2% buffer.
    * 2. Yields `AWAITING_PLACE_ORDER` with `{ to, data, value, sessionPrivateKey }`.
@@ -17931,8 +18493,8 @@ var IntentGateway = class _IntentGateway {
    * 4. Delegates to {@link OrderExecutor.executeOrder} and forwards all
    *    subsequent status updates until the order is filled, exhausted, or fails.
    *
-   * @param order - The order to place and execute. `order.fees` may be 0; it
-   *   will be estimated automatically if so.
+   * @param order - The order to place and execute. It is not mutated. `order.fees`
+   *   may be 0; fees are estimated automatically if so.
    * @param graffiti - Optional bytes32 tag for orderflow attribution /
    *   revenue share. Defaults to {@link DEFAULT_GRAFFITI}.
    * @param options - Optional tuning parameters:
@@ -17945,10 +18507,11 @@ var IntentGateway = class _IntentGateway {
    *   estimation returns zero.
    */
   async *execute(order, graffiti = DEFAULT_GRAFFITI, options) {
+    const executionOrder = { ...order };
     let value;
-    if (!order.fees || order.fees === 0n) {
+    if (!executionOrder.fees || executionOrder.fees === 0n) {
       const estimate = await this.gasEstimator.estimateFillOrder({
-        order,
+        order: executionOrder,
         maxPriorityFeePerGasBumpPercent: options?.maxPriorityFeePerGasBumpPercent,
         maxFeePerGasBumpPercent: options?.maxFeePerGasBumpPercent
       });
@@ -17963,9 +18526,9 @@ var IntentGateway = class _IntentGateway {
         "source",
         this.source.config.stateMachineId
       );
-      order.fees = isSameChain ? estimate.totalGasInFeeToken * 2n : estimate.totalGasInFeeToken + (crossChainFeeBump + estimate.totalGasInFeeToken * 1n / 100n);
+      executionOrder.fees = isSameChain ? estimate.totalGasInFeeToken * 2n : estimate.totalGasInFeeToken + (crossChainFeeBump + estimate.totalGasInFeeToken * 1n / 100n);
     }
-    const placeOrderGen = this.orderPlacer.placeOrder(order, graffiti);
+    const placeOrderGen = this.orderPlacer.placeOrder(executionOrder, graffiti);
     const placeOrderFirst = await placeOrderGen.next();
     if (placeOrderFirst.done) {
       throw new Error("placeOrder generator completed without yielding");
@@ -18076,13 +18639,20 @@ var IntentGateway = class _IntentGateway {
     const gen = this.execute(order, graffiti, options);
     try {
       let input;
+      let finalizedOrder;
       while (true) {
         const { value, done } = await gen.next(input);
         input = void 0;
         if (done) break;
-        if (value.status === "BIDS_RECEIVED") {
+        if (value.status === "ORDER_PLACED") {
+          finalizedOrder = value.order;
           yield value;
-          input = await this.autoSelect(order, value.bids);
+        } else if (value.status === "BIDS_RECEIVED") {
+          if (!finalizedOrder) {
+            throw new Error("Received bids before the order was finalized");
+          }
+          yield value;
+          input = await this.autoSelect(finalizedOrder, value.bids);
         } else if (value.status === "AWAITING_PLACE_ORDER") {
           input = yield value;
         } else {
@@ -22959,6 +23529,7 @@ exports.hyperbridgeAddress = hyperbridgeAddress;
 exports.maxBigInt = maxBigInt;
 exports.normalizeAddressForEvmBytes32 = normalizeAddressForEvmBytes32;
 exports.normalizeAddressForStateMachine = normalizeAddressForStateMachine;
+exports.normalizeEvmAddress = normalizeEvmAddress;
 exports.normalizeEvmChainId = normalizeEvmChainId;
 exports.normalizeStateMachineId = normalizeStateMachineId;
 exports.orderCommitment = orderCommitment;