@hyperbridge/sdk 2.4.0 → 2.5.0

package/dist/node/index.cjs

@@ -2490,30 +2490,30 @@ var handlerV2_default = { ABI: ABI2 };
 function tronAddress(base58) {
   return `0x${tronweb.TronWeb.address.toHex(base58).slice(2)}`;
 }
-var Chains = /* @__PURE__ */ ((Chains3) => {
-  Chains3["BSC_CHAPEL"] = "EVM-97";
-  Chains3["GNOSIS_CHIADO"] = "EVM-10200";
-  Chains3["HYPERBRIDGE_GARGANTUA"] = "KUSAMA-4009";
-  Chains3["SEPOLIA"] = "EVM-11155111";
-  Chains3["MAINNET"] = "EVM-1";
-  Chains3["BSC_MAINNET"] = "EVM-56";
-  Chains3["ARBITRUM_MAINNET"] = "EVM-42161";
-  Chains3["ARBITRUM_SEPOLIA"] = "EVM-421614";
-  Chains3["BASE_MAINNET"] = "EVM-8453";
-  Chains3["BASE_SEPOLIA"] = "EVM-84532";
-  Chains3["OPTIMISM_MAINNET"] = "EVM-10";
-  Chains3["OPTIMISM_SEPOLIA"] = "EVM-11155420";
-  Chains3["GNOSIS_MAINNET"] = "EVM-100";
-  Chains3["SONEIUM_MAINNET"] = "EVM-1868";
-  Chains3["POLYGON_MAINNET"] = "EVM-137";
-  Chains3["POLKADOT_HUB_MAINNET"] = "EVM-420420419";
-  Chains3["POLYGON_AMOY"] = "EVM-80002";
-  Chains3["POLKADOT_ASSET_HUB_PASEO"] = "EVM-420420417";
-  Chains3["TRON_MAINNET"] = "EVM-728126428";
-  Chains3["TRON_NILE"] = "EVM-3448148188";
-  Chains3["PHAROS_MAINNET"] = "EVM-688600";
-  Chains3["PHAROS_ATLANTIC"] = "EVM-688689";
-  return Chains3;
+var Chains = /* @__PURE__ */ ((Chains2) => {
+  Chains2["BSC_CHAPEL"] = "EVM-97";
+  Chains2["GNOSIS_CHIADO"] = "EVM-10200";
+  Chains2["HYPERBRIDGE_GARGANTUA"] = "KUSAMA-4009";
+  Chains2["SEPOLIA"] = "EVM-11155111";
+  Chains2["MAINNET"] = "EVM-1";
+  Chains2["BSC_MAINNET"] = "EVM-56";
+  Chains2["ARBITRUM_MAINNET"] = "EVM-42161";
+  Chains2["ARBITRUM_SEPOLIA"] = "EVM-421614";
+  Chains2["BASE_MAINNET"] = "EVM-8453";
+  Chains2["BASE_SEPOLIA"] = "EVM-84532";
+  Chains2["OPTIMISM_MAINNET"] = "EVM-10";
+  Chains2["OPTIMISM_SEPOLIA"] = "EVM-11155420";
+  Chains2["GNOSIS_MAINNET"] = "EVM-100";
+  Chains2["SONEIUM_MAINNET"] = "EVM-1868";
+  Chains2["POLYGON_MAINNET"] = "EVM-137";
+  Chains2["POLKADOT_HUB_MAINNET"] = "EVM-420420419";
+  Chains2["POLYGON_AMOY"] = "EVM-80002";
+  Chains2["POLKADOT_ASSET_HUB_PASEO"] = "EVM-420420417";
+  Chains2["TRON_MAINNET"] = "EVM-728126428";
+  Chains2["TRON_NILE"] = "EVM-3448148188";
+  Chains2["PHAROS_MAINNET"] = "EVM-688600";
+  Chains2["PHAROS_ATLANTIC"] = "EVM-688689";
+  return Chains2;
 })(Chains || {});
 var polkadotAssetHubPaseo = viem.defineChain({
   id: 420420417,
@@ -2704,7 +2704,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x3bdB532d91F165BeFad5542700205f5BB5152a82",
+      SolverAccount: "0xfCd233b937D7622AAc63ced3C9A1A12F4a6B64E3",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
@@ -2720,6 +2720,7 @@ var chainConfigs = {
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
       CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
+      SimplexPaymaster: "0xD4340d7466e040626383cb9cda9307ba8E081149",
       Usdt0Oft: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee"
     },
     rpcEnvKey: "ETH_MAINNET",
@@ -2759,7 +2760,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x3bdB532d91F165BeFad5542700205f5BB5152a82",
+      SolverAccount: "0xfCd233b937D7622AAc63ced3C9A1A12F4a6B64E3",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x10ED43C718714eb63d5aA57B78B54704E256024E",
@@ -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",
@@ -2815,7 +2817,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x3bdB532d91F165BeFad5542700205f5BB5152a82",
+      SolverAccount: "0xfCd233b937D7622AAc63ced3C9A1A12F4a6B64E3",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
@@ -2831,6 +2833,7 @@ var chainConfigs = {
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
       CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
+      SimplexPaymaster: "0x7281Bccb4f0BCE44F3B8542d1fC5e51c2F5fC08C",
       Usdt0Oft: "0x14E4A1B13bf7F943c8ff7C51fb60FA964A298D92"
     },
     rpcEnvKey: "ARBITRUM_MAINNET",
@@ -2872,7 +2875,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x3bdB532d91F165BeFad5542700205f5BB5152a82",
+      SolverAccount: "0xfCd233b937D7622AAc63ced3C9A1A12F4a6B64E3",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24",
@@ -2885,6 +2888,7 @@ var chainConfigs = {
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
       CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
+      SimplexPaymaster: "0x15b3B03C870c7ef252029c35A12d3b339F5c8d7f",
       AerodromeRouter: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
       UniswapV4PositionManager: "0x7c5f5a4bbd8fd63184577525326123b519429bdc",
       UniswapV4PoolManager: "0x498581ff718922c3f8e6a244956af099b2652b2b",
@@ -2931,7 +2935,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x3bdB532d91F165BeFad5542700205f5BB5152a82",
+      SolverAccount: "0xfCd233b937D7622AAc63ced3C9A1A12F4a6B64E3",
       TokenGateway: "0x8b536105b6Fae2aE9199f5146D3C57Dfe53b614E",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0xd2f9496824951D5237cC71245D659E48d0d5f9E8",
@@ -2947,6 +2951,7 @@ var chainConfigs = {
       Permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
       EntryPointV08: "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108",
       CirclePaymaster: "0x0578cFB241215b77442a541325d6A4E6dFE700Ec",
+      SimplexPaymaster: "0xe99acFe0f5fC4C8ea54A187D8D3b05f136150095",
       Usdt0Oft: "0x6BA10300f0DC58B7a1e4c0e41f5daBb7D7829e13"
     },
     rpcEnvKey: "POLYGON_MAINNET",
@@ -3042,7 +3047,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x3bdB532d91F165BeFad5542700205f5BB5152a82",
+      SolverAccount: "0xfCd233b937D7622AAc63ced3C9A1A12F4a6B64E3",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0x4A7b5Da61326A6379179b40d00F57E5bbDC962c2",
@@ -3077,7 +3082,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x3bdB532d91F165BeFad5542700205f5BB5152a82",
+      SolverAccount: "0xfCd233b937D7622AAc63ced3C9A1A12F4a6B64E3",
       TokenGateway: "0xFd413e3AFe560182C4471F4d143A96d3e259B6dE",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       UniswapRouter02: "0xB2e26652e4BAd1e56055A051f922E06760cA0BFE",
@@ -3232,7 +3237,7 @@ var chainConfigs = {
     },
     addresses: {
       IntentGateway: "0xAe041F7B0CB581876832830baeB6a2Aa2a3C9716",
-      SolverAccount: "0x3bdB532d91F165BeFad5542700205f5BB5152a82",
+      SolverAccount: "0xfCd233b937D7622AAc63ced3C9A1A12F4a6B64E3",
       Host: "0x620128E2B19193d6Bd244a3AC8D3bBa0541B19c3",
       Calldispatcher: "0xE2C7e576E26E0bE7aC97c6fE925bcDAbD87c4bEd"
     },
@@ -5118,6 +5123,24 @@ var ChainConfigService = class {
   getAssetAddress(chain, symbol) {
     return this.getConfig(chain)?.assets?.[symbol];
   }
+  /**
+   * Resolves configured token metadata from an address on a specific chain.
+   * This is used by SDK helpers that accept token addresses rather than caller-
+   * supplied symbols or decimals.
+   */
+  getAssetMetadataByAddress(chain, address) {
+    const config = this.getConfig(chain);
+    if (!config?.assets) return;
+    const normalizedAddress = address.toLowerCase();
+    for (const [symbol, configuredAddress] of Object.entries(config.assets)) {
+      if (configuredAddress.toLowerCase() !== normalizedAddress) continue;
+      return {
+        symbol,
+        address: configuredAddress,
+        decimals: config.tokenDecimals?.[symbol]
+      };
+    }
+  }
   getUsdtAsset(chain) {
     return this.getConfig(chain)?.assets?.USDT ?? "0x";
   }
@@ -5224,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;
   }
@@ -7044,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";
@@ -7357,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.
@@ -7791,7 +7834,7 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    */
   async sendExtrinsicWithRetries(extrinsic, maxRetries, timeoutMs) {
     const keyPair = this.getKeyPair();
-    let baseTip = 500000000000n;
+    const baseTip = 1000000000n;
     let attempt = 0;
     while (attempt < maxRetries) {
       const currentTip = baseTip * BigInt(2 ** attempt);
@@ -8104,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 {
@@ -9256,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;
@@ -9403,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;
 }
@@ -9410,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));
     }
   }
@@ -11461,6 +11565,82 @@ query OrderStatus($commitment: String!) {
     }
   }
 }`;
+var LATEST_PHANTOM_ORDER_PRICE_SNAPSHOT = `
+query LatestPhantomOrderPriceSnapshot($tokenA: String!, $tokenB: String!) {
+  phantomOrderPriceSnapshots(
+    filter: {
+      and: [
+        { tokenA: { equalTo: $tokenA } }
+        { tokenB: { equalTo: $tokenB } }
+        { medianPrice: { isNull: false } }
+      ]
+    }
+    orderBy: BLOCK_NUMBER_DESC
+    first: 1
+  ) {
+    nodes {
+      commitment
+      tokenA
+      tokenB
+      standardAmount
+      blockNumber
+      medianPrice
+      lowestPrice
+      highestPrice
+      bidCount
+      snapshotTime
+    }
+  }
+}`;
+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(
@@ -11522,6 +11702,29 @@ async function queryAssetTeleported(params) {
 function queryGetRequest(params) {
   return _queryGetRequestInternal(params);
 }
+async function _queryLatestPhantomOrderPriceSnapshot(params) {
+  const response = await params.queryClient.request(
+    LATEST_PHANTOM_ORDER_PRICE_SNAPSHOT,
+    {
+      tokenA: params.tokenA.toLowerCase(),
+      tokenB: params.tokenB.toLowerCase()
+    }
+  );
+  const snapshot = response.phantomOrderPriceSnapshots.nodes[0];
+  if (!snapshot?.medianPrice) return;
+  return {
+    commitment: snapshot.commitment,
+    tokenA: snapshot.tokenA,
+    tokenB: snapshot.tokenB,
+    standardAmount: BigInt(snapshot.standardAmount),
+    blockNumber: BigInt(snapshot.blockNumber),
+    medianPrice: BigInt(snapshot.medianPrice),
+    lowestPrice: snapshot.lowestPrice === null ? void 0 : BigInt(snapshot.lowestPrice),
+    highestPrice: snapshot.highestPrice === null ? void 0 : BigInt(snapshot.highestPrice),
+    bidCount: snapshot.bidCount,
+    snapshotTime: new Date(snapshot.snapshotTime)
+  };
+}
 async function _queryTokenGatewayAssetTeleportedInternal(params) {
   const { commitmentHash, queryClient: client, logger = DEFAULT_LOGGER } = params;
   const response = await retryPromise(
@@ -12022,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) => {
@@ -12035,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) => {
@@ -12048,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();
@@ -15218,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,
@@ -15234,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,
@@ -15259,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,
@@ -15268,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)
@@ -15288,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 };
   }
 };
 
@@ -15631,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.
@@ -15640,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 }
@@ -15671,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,
@@ -15687,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],
@@ -15705,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
@@ -15715,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
@@ -15746,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,
@@ -15779,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);
@@ -15810,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
@@ -15829,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(
@@ -15840,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: {
@@ -15849,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],
@@ -15870,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;
       }
     }
@@ -15889,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);
@@ -15929,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);
@@ -15958,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) {
@@ -15992,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,
@@ -16035,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,
@@ -16052,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);
       }
@@ -16082,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)}`
       );
@@ -16090,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(
@@ -17310,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 {
@@ -17321,15 +17910,67 @@ var UnsupportedIntentQuoteStrategyError = class extends Error {
 var UnsupportedIntentQuotePairError = class extends Error {
   constructor(params) {
     super(
-      `No Uniswap v4 pool config found for ${params.tokenIn.symbol ?? params.tokenIn.address} -> ${params.tokenOut.symbol ?? params.tokenOut.address} on ${params.source} -> ${params.destination}`
+      `No ${params.quoteSource ?? "Uniswap v4 pool config"} found for ${params.tokenIn} -> ${params.tokenOut} on ${params.source} -> ${params.destination}`
     );
     this.name = "UnsupportedIntentQuotePairError";
   }
 };
+var PhantomSnapshotUnavailableError = class extends Error {
+  constructor(tokenA, tokenB) {
+    super(`No Phantom order price snapshot found for ${tokenA} -> ${tokenB}`);
+    this.name = "PhantomSnapshotUnavailableError";
+  }
+};
+var InvalidPhantomSnapshotError = class extends Error {
+  constructor(commitment, reason) {
+    super(`Invalid Phantom order price snapshot ${commitment}: ${reason}`);
+    this.name = "InvalidPhantomSnapshotError";
+  }
+};
+var BPS_DENOMINATOR = 10000n;
+function validateQuoteParams(params) {
+  const hasAmountIn = params.amountIn !== void 0;
+  const hasAmountOut = params.amountOut !== void 0;
+  if (hasAmountIn === hasAmountOut) throw new Error("Provide exactly one of amountIn or amountOut");
+  if (params.amountIn !== void 0 && params.amountIn <= 0n) throw new Error("amountIn must be greater than zero");
+  if (params.amountOut !== void 0 && params.amountOut <= 0n) throw new Error("amountOut must be greater than zero");
+  if (params.tokenIn.toLowerCase() === params.tokenOut.toLowerCase()) {
+    throw new Error("tokenIn and tokenOut cannot be the same");
+  }
+}
+async function readProtocolFeeBps(chainConfigService, source) {
+  const gatewayAddress = chainConfigService.getIntentGatewayAddress(source.stateMachineId);
+  if (!gatewayAddress || gatewayAddress === "0x" || gatewayAddress === viem.zeroAddress) {
+    throw new Error(`IntentGatewayV2 is not configured for chain ${source.stateMachineId}`);
+  }
+  const gatewayParams = await source.client.readContract({
+    address: gatewayAddress,
+    abi: IntentGatewayV2_default.ABI,
+    functionName: "params"
+  });
+  const protocolFeeBps = Array.isArray(gatewayParams) ? BigInt(gatewayParams[4]) : BigInt(gatewayParams.protocolFeeBps ?? 0);
+  if (protocolFeeBps < 0n || protocolFeeBps >= BPS_DENOMINATOR) {
+    throw new Error(`Invalid IntentGateway protocol fee: ${protocolFeeBps} bps`);
+  }
+  return protocolFeeBps;
+}
+function deductProtocolFee(amount, protocolFeeBps) {
+  if (protocolFeeBps <= 0n) return amount;
+  const fee = amount * protocolFeeBps / BPS_DENOMINATOR;
+  return amount - fee;
+}
+function grossUpForProtocolFee(netAmount, protocolFeeBps) {
+  if (protocolFeeBps <= 0n) return netAmount;
+  if (protocolFeeBps >= BPS_DENOMINATOR) throw new Error("protocolFeeBps must be less than 10,000");
+  return divCeil(netAmount * BPS_DENOMINATOR, BPS_DENOMINATOR - protocolFeeBps);
+}
+function divCeil(numerator, denominator) {
+  if (denominator <= 0n) throw new Error("denominator must be greater than zero");
+  return (numerator + denominator - 1n) / denominator;
+}
 
 // src/protocols/intents/quote/uniswapV4.ts
 var UNISWAP_INTENT_QUOTE_CHAIN = "EVM-8453" /* BASE_MAINNET */;
-var BPS_DENOMINATOR = 10000n;
 var UniswapV4IntentQuoteStrategy = class {
   constructor(chainConfigService) {
     this.chainConfigService = chainConfigService;
@@ -17337,10 +17978,10 @@ var UniswapV4IntentQuoteStrategy = class {
   chainConfigService;
   baseQuoteClient;
   async quote(params, source, destination) {
-    this.validateQuoteParams(params);
-    const protocolFeeBps = await this.readProtocolFeeBps(source.client, source.stateMachineId);
+    validateQuoteParams(params);
+    const protocolFeeBps = await readProtocolFeeBps(this.chainConfigService, source);
     const quoteClient = this.resolveQuoteClient(source, destination);
-    const poolConfig = this.resolvePoolConfig(params, source.stateMachineId, UNISWAP_INTENT_QUOTE_CHAIN);
+    const poolConfig = this.resolvePoolConfig(params, source.stateMachineId, destination.stateMachineId);
     return params.amountIn !== void 0 ? this.quoteExactInput({ params, client: quoteClient, protocolFeeBps, poolConfig }) : this.quoteExactOutput({ params, client: quoteClient, protocolFeeBps, poolConfig });
   }
   resolveQuoteClient(source, destination) {
@@ -17356,34 +17997,11 @@ var UniswapV4IntentQuoteStrategy = class {
     this.baseQuoteClient = baseQuoteClient;
     return baseQuoteClient;
   }
-  validateQuoteParams(params) {
-    const hasAmountIn = params.amountIn !== void 0;
-    const hasAmountOut = params.amountOut !== void 0;
-    if (hasAmountIn === hasAmountOut) throw new Error("Provide exactly one of amountIn or amountOut");
-    if (hasAmountIn && params.amountIn <= 0n) throw new Error("amountIn must be greater than zero");
-    if (hasAmountOut && params.amountOut <= 0n) throw new Error("amountOut must be greater than zero");
-    if (params.tokenIn.address.toLowerCase() === params.tokenOut.address.toLowerCase()) {
-      throw new Error("tokenIn and tokenOut cannot be the same");
-    }
-  }
-  async readProtocolFeeBps(client, chain) {
-    const gatewayAddress = this.chainConfigService.getIntentGatewayAddress(chain);
-    if (!gatewayAddress || gatewayAddress === "0x" || gatewayAddress === viem.zeroAddress) {
-      throw new Error(`IntentGatewayV2 is not configured for chain ${chain}`);
-    }
-    const gatewayParams = await client.readContract({
-      address: gatewayAddress,
-      abi: IntentGatewayV2_default.ABI,
-      functionName: "params"
-    });
-    if (isGatewayParamsTuple(gatewayParams)) return BigInt(gatewayParams[4]);
-    return BigInt(gatewayParams.protocolFeeBps ?? 0);
-  }
   resolvePoolConfig(params, source, destination) {
     const override = params.uniswapV4?.poolKey;
     if (override) {
       const poolKey = normalizePoolKey(override);
-      const tokenInForQuote = viem.getAddress(override.currencyIn ?? params.tokenIn.address);
+      const tokenInForQuote = viem.getAddress(override.currencyIn ?? params.tokenIn);
       if (tokenInForQuote !== poolKey.currency0 && tokenInForQuote !== poolKey.currency1) {
         throw new Error(
           `Input currency ${tokenInForQuote} is not part of the override pool (${poolKey.currency0}, ${poolKey.currency1}). For cross-chain quotes pass uniswapV4.poolKey.currencyIn with the Base-side input currency address.`
@@ -17391,11 +18009,11 @@ var UniswapV4IntentQuoteStrategy = class {
       }
       return {
         poolKey,
-        quoterAddress: this.resolveQuoterAddress(destination, override.quoterAddress),
+        quoterAddress: this.resolveQuoterAddress(UNISWAP_INTENT_QUOTE_CHAIN, override.quoterAddress),
         tokenInForQuote
       };
     }
-    const poolConfig = this.resolveConfiguredPool(params, destination);
+    const poolConfig = this.resolveConfiguredPool(params, source, destination, UNISWAP_INTENT_QUOTE_CHAIN);
     if (poolConfig) return poolConfig;
     throw new UnsupportedIntentQuotePairError({
       source,
@@ -17404,12 +18022,12 @@ var UniswapV4IntentQuoteStrategy = class {
       tokenOut: params.tokenOut
     });
   }
-  resolveConfiguredPool(params, chain) {
-    for (const pool of this.chainConfigService.getUniswapV4PoolConfigs(chain)) {
-      const resolvedPool = this.resolveConfiguredPoolTokens(chain, pool);
+  resolveConfiguredPool(params, sourceChain, destinationChain, quoteChain) {
+    for (const pool of this.chainConfigService.getUniswapV4PoolConfigs(quoteChain)) {
+      const resolvedPool = this.resolveConfiguredPoolTokens(quoteChain, pool);
       if (!resolvedPool) continue;
-      const tokenInForQuote = matchPoolToken(params.tokenIn, resolvedPool);
-      const tokenOutForQuote = matchPoolToken(params.tokenOut, resolvedPool);
+      const tokenInForQuote = this.matchPoolToken(params.tokenIn, sourceChain, resolvedPool);
+      const tokenOutForQuote = this.matchPoolToken(params.tokenOut, destinationChain, resolvedPool);
       if (!tokenInForQuote || !tokenOutForQuote || tokenInForQuote.symbol === tokenOutForQuote.symbol) continue;
       const { currency0, currency1 } = sortCurrencies(resolvedPool[0].address, resolvedPool[1].address);
       return {
@@ -17420,7 +18038,7 @@ var UniswapV4IntentQuoteStrategy = class {
           tickSpacing: pool.tickSpacing,
           hooks: viem.getAddress(pool.hooks ?? viem.zeroAddress)
         },
-        quoterAddress: this.resolveQuoterAddress(chain),
+        quoterAddress: this.resolveQuoterAddress(quoteChain),
         tokenInForQuote: tokenInForQuote.address
       };
     }
@@ -17443,8 +18061,18 @@ var UniswapV4IntentQuoteStrategy = class {
     if (!address || address === "0x") return null;
     return { symbol, address: viem.getAddress(address) };
   }
+  matchPoolToken(tokenAddress, orderChain, poolTokens) {
+    const addressMatch = poolTokens.find(
+      (poolToken) => poolToken.address.toLowerCase() === tokenAddress.toLowerCase()
+    );
+    if (addressMatch) return addressMatch;
+    const metadata = this.chainConfigService.getAssetMetadataByAddress(orderChain, tokenAddress);
+    if (!metadata) return null;
+    return poolTokens.find((poolToken) => poolToken.symbol === metadata.symbol) ?? null;
+  }
   async quoteExactInput(args) {
     const amountIn = args.params.amountIn;
+    if (amountIn === void 0) throw new Error("amountIn is required for an exact-input quote");
     const swapAmountIn = deductProtocolFee(amountIn, args.protocolFeeBps);
     const amountOut = await this.readV4QuoteExactInput(args.client, args.poolConfig, swapAmountIn);
     return {
@@ -17462,6 +18090,7 @@ var UniswapV4IntentQuoteStrategy = class {
   }
   async quoteExactOutput(args) {
     const amountOut = args.params.amountOut;
+    if (amountOut === void 0) throw new Error("amountOut is required for an exact-output quote");
     const swapAmountIn = await this.readV4QuoteExactOutput(args.client, args.poolConfig, amountOut);
     const amountIn = grossUpForProtocolFee(swapAmountIn, args.protocolFeeBps);
     return {
@@ -17540,34 +18169,133 @@ function sortCurrencies(tokenIn, tokenOut) {
   const output = viem.getAddress(tokenOut);
   return BigInt(input) < BigInt(output) ? { currency0: input, currency1: output } : { currency0: output, currency1: input };
 }
-function matchPoolToken(token, poolTokens) {
-  const tokenAddress = token.address.toLowerCase();
-  const addressMatch = poolTokens.find((poolToken) => poolToken.address.toLowerCase() === tokenAddress);
-  if (addressMatch) return addressMatch;
-  const tokenSymbol = token.symbol?.toUpperCase();
-  if (!tokenSymbol) return null;
-  return poolTokens.find((poolToken) => poolToken.symbol.toUpperCase() === tokenSymbol) ?? null;
-}
 function getZeroForOne(tokenIn, poolKey) {
   return viem.getAddress(tokenIn).toLowerCase() === viem.getAddress(poolKey.currency0).toLowerCase();
 }
-function isGatewayParamsTuple(value) {
-  return Array.isArray(value);
-}
-function deductProtocolFee(amount, protocolFeeBps) {
-  if (protocolFeeBps <= 0n) return amount;
-  const fee = amount * protocolFeeBps / BPS_DENOMINATOR;
-  return amount - fee;
-}
-function grossUpForProtocolFee(netAmount, protocolFeeBps) {
-  if (protocolFeeBps <= 0n) return netAmount;
-  return divCeil(netAmount * BPS_DENOMINATOR, BPS_DENOMINATOR - protocolFeeBps);
+
+// src/protocols/intents/quote/phantomSnapshot.ts
+var PHANTOM_INTENT_QUOTE_CHAIN = "EVM-8453" /* BASE_MAINNET */;
+var BASE_SNAPSHOT_ASSET_BY_ORDER_ASSET = {
+  USDC: "USDC",
+  USDT: "USDC",
+  cNGN: "cNGN"
+};
+var SUPPORTED_BASE_SNAPSHOT_PAIRS = /* @__PURE__ */ new Set(["USDC:cNGN", "cNGN:USDC"]);
+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.pairResolver.resolve(params, source.stateMachineId, destination.stateMachineId);
+    if (!pair) {
+      throw new UnsupportedIntentQuotePairError({
+        source: source.stateMachineId,
+        destination: destination.stateMachineId,
+        tokenIn: params.tokenIn,
+        tokenOut: params.tokenOut,
+        quoteSource: "Phantom snapshot pair"
+      });
+    }
+    const queryClient = this.getQueryClient();
+    const [protocolFeeBps, snapshot] = await Promise.all([
+      readProtocolFeeBps(this.chainConfigService, source),
+      _queryLatestPhantomOrderPriceSnapshot({
+        tokenA: pair.tokenA,
+        tokenB: pair.tokenB,
+        queryClient
+      })
+    ]);
+    if (!snapshot) throw new PhantomSnapshotUnavailableError(pair.tokenA, pair.tokenB);
+    this.validateSnapshot(snapshot);
+    return this.quoteSnapshot(params, protocolFeeBps, snapshot);
+  }
+  quoteSnapshot(params, protocolFeeBps, snapshot) {
+    if (params.amountIn !== void 0) {
+      const netAmountIn2 = deductProtocolFee(params.amountIn, protocolFeeBps);
+      const amountOut = netAmountIn2 * snapshot.medianPrice / snapshot.standardAmount;
+      if (amountOut <= 0n) {
+        throw new InvalidPhantomSnapshotError(snapshot.commitment, "quote rounds down to zero output");
+      }
+      return this.buildResult("EXACT_INPUT", params.amountIn, amountOut, protocolFeeBps, snapshot);
+    }
+    if (params.amountOut === void 0) throw new Error("Quote amount is missing after validation");
+    const netAmountIn = divCeil(params.amountOut * snapshot.standardAmount, snapshot.medianPrice);
+    const amountIn = grossUpForProtocolFee(netAmountIn, protocolFeeBps);
+    return this.buildResult("EXACT_OUTPUT", amountIn, params.amountOut, protocolFeeBps, snapshot);
+  }
+  buildResult(tradeType, amountIn, amountOut, protocolFeeBps, snapshot) {
+    return {
+      strategy: "phantom_snapshot",
+      tradeType,
+      amountIn,
+      amountOut,
+      quoteMetadata: {
+        quoteChain: PHANTOM_INTENT_QUOTE_CHAIN,
+        commitment: snapshot.commitment,
+        tokenA: snapshot.tokenA,
+        tokenB: snapshot.tokenB,
+        standardAmount: snapshot.standardAmount,
+        medianPrice: snapshot.medianPrice,
+        lowestPrice: snapshot.lowestPrice,
+        highestPrice: snapshot.highestPrice,
+        blockNumber: snapshot.blockNumber,
+        snapshotTime: snapshot.snapshotTime,
+        bidCount: snapshot.bidCount,
+        protocolFeeBps
+      }
+    };
+  }
+  validateSnapshot(snapshot) {
+    if (snapshot.standardAmount <= 0n) {
+      throw new InvalidPhantomSnapshotError(snapshot.commitment, "standardAmount must be greater than zero");
+    }
+    if (snapshot.medianPrice <= 0n) {
+      throw new InvalidPhantomSnapshotError(snapshot.commitment, "medianPrice must be greater than zero");
+    }
+    if (snapshot.bidCount <= 0) {
+      throw new InvalidPhantomSnapshotError(snapshot.commitment, "bidCount must be greater than zero");
+    }
+    if (Number.isNaN(snapshot.snapshotTime.getTime())) {
+      throw new InvalidPhantomSnapshotError(snapshot.commitment, "snapshotTime is invalid");
+    }
+  }
+};
+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;
+    return { tokenA: tokenIn.address, tokenB: tokenOut.address };
+  }
+  resolveBaseSnapshotToken(chain, tokenAddress) {
+    const orderAsset = this.chainConfigService.getAssetMetadataByAddress(chain, tokenAddress)?.symbol;
+    if (!orderAsset) return;
+    const snapshotAsset = BASE_SNAPSHOT_ASSET_BY_ORDER_ASSET[orderAsset];
+    if (!snapshotAsset) return;
+    const address = this.chainConfigService.getAssetAddress(PHANTOM_INTENT_QUOTE_CHAIN, snapshotAsset);
+    if (!isConfiguredAddress(address)) return;
+    return { symbol: snapshotAsset, address };
+  }
+};
+function isSupportedSnapshotPair(tokenA, tokenB) {
+  return SUPPORTED_BASE_SNAPSHOT_PAIRS.has(`${tokenA}:${tokenB}`);
 }
-function divCeil(numerator, denominator) {
-  return (numerator + denominator - 1n) / denominator;
+function isConfiguredAddress(address) {
+  return Boolean(address && address !== "0x" && !/^0x0{40}$/i.test(address));
 }
 
 // src/protocols/intents/IntentGateway.ts
+var CROSS_CHAIN_ORDER_FEE_GAS_BUMP = 600000n;
 var IntentGateway = class _IntentGateway {
   /** EVM chain on which orders are placed and escrowed. */
   source;
@@ -17595,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.
    *
@@ -17638,7 +18368,12 @@ 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,
+        () => this.requireIndexer().queryClient
+      ),
       uniswap_v4: new UniswapV4IntentQuoteStrategy(dest.configService)
     };
   }
@@ -17688,37 +18423,69 @@ var IntentGateway = class _IntentGateway {
   /**
    * Quotes an intent between this gateway's source and destination chains.
    *
-   * `strategy` defaults to `uniswap_v4`, currently the only supported
-   * strategy. Provide exactly one of `amountIn` or `amountOut`.
+   * Uses the latest directional Phantom order price snapshot from the attached
+   * indexer by default. Pass `strategy: "uniswap_v4"` only when explicitly
+   * requesting a Uniswap quote. Provide exactly one of `amountIn` or `amountOut`.
    *
-   * The Uniswap quote strategy always prices against the configured Base
-   * pool, regardless of this gateway's destination chain. Returned
+   * Both built-in strategies resolve their canonical market on Base,
+   * regardless of this gateway's destination chain. Returned
    * `amountIn`/`amountOut` already account for the gateway's protocol fee
    * (`quoteMetadata.protocolFeeBps`), which the gateway deducts from order
-   * inputs; apply only your own slippage tolerance before placing the order.
+   * inputs; use the returned amounts directly when placing the order.
    *
    * @param params - Token pair, amount, and optional strategy/pool overrides.
    * @returns The quoted amounts plus strategy-specific metadata.
    * @throws {UnsupportedIntentQuoteStrategyError} For unknown strategies.
-   * @throws {UnsupportedIntentQuotePairError} When no pool is configured for the pair.
+   * @throws {UnsupportedIntentQuotePairError} When the selected strategy does not support the pair.
+   * @throws {PhantomSnapshotUnavailableError} When an eligible cNGN pair has no snapshot.
    */
   async quoteIntent(params) {
-    const strategy = params.strategy ?? "uniswap_v4";
+    const source = { stateMachineId: this.source.config.stateMachineId, client: this.source.client };
+    const destination = { stateMachineId: this.dest.config.stateMachineId, client: this.dest.client };
+    const strategy = params.strategy ?? "phantom_snapshot";
     const handler = this.quoteStrategies[strategy];
     if (!handler) throw new UnsupportedIntentQuoteStrategyError(strategy);
-    return handler.quote(
-      { ...params, strategy },
-      { stateMachineId: this.source.config.stateMachineId, client: this.source.client },
-      { stateMachineId: this.dest.config.stateMachineId, client: this.dest.client }
-    );
+    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 `order.fees`
-   *    with a 1% buffer and the wei cost with a 2% buffer for the `value` field.
+   * 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 }`.
    *    The caller must sign the transaction and pass it back via `gen.next(signedTx)`.
    * 3. Yields `ORDER_PLACED` with the finalised order and transaction hash once
@@ -17726,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:
@@ -17740,20 +18507,28 @@ 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
       });
       if (estimate.totalGasCostWei === 0n || estimate.totalGasInFeeToken === 0n) {
         throw new Error("Gas estimation failed");
       }
+      const isSameChain = this.source.config.stateMachineId === this.dest.config.stateMachineId;
       value = estimate.totalGasCostWei + estimate.totalGasCostWei * 2n / 100n;
-      order.fees = estimate.totalGasInFeeToken + estimate.totalGasInFeeToken * 1n / 100n;
+      const crossChainFeeBump = isSameChain ? 0n : await convertGasToFeeToken(
+        this.ctx,
+        CROSS_CHAIN_ORDER_FEE_GAS_BUMP,
+        "source",
+        this.source.config.stateMachineId
+      );
+      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");
@@ -17864,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 {
@@ -18132,7 +18914,9 @@ var IntentGateway = class _IntentGateway {
   }
   requireIndexer() {
     if (!this.indexer) {
-      throw new Error("IntentGateway: call withQueryClient(queryClient) before using indexer-backed methods");
+      throw new Error(
+        "IntentGateway: call withQueryClient(queryClient) before using indexer-backed methods or Phantom quotes"
+      );
     }
     return this.indexer;
   }
@@ -22667,6 +23451,7 @@ exports.IntentGateway = IntentGateway;
 exports.IntentGatewayABI = ABI3;
 exports.IntentOrderStatus = IntentOrderStatus;
 exports.IntentsCoprocessor = IntentsCoprocessor;
+exports.InvalidPhantomSnapshotError = InvalidPhantomSnapshotError;
 exports.IsmpClient = IsmpClient;
 exports.MOCK_ADDRESS = MOCK_ADDRESS;
 exports.ORDER_V2_PARAM_TYPE = ORDER_V2_PARAM_TYPE;
@@ -22674,6 +23459,7 @@ exports.OrderStatus = OrderStatus;
 exports.OrderStatusChecker = OrderStatusChecker;
 exports.PACKED_USEROP_TYPEHASH = PACKED_USEROP_TYPEHASH;
 exports.PLACE_ORDER_SELECTOR = PLACE_ORDER_SELECTOR;
+exports.PhantomSnapshotUnavailableError = PhantomSnapshotUnavailableError;
 exports.PharosChain = PharosChain;
 exports.PolkadotHubChain = PolkadotHubChain;
 exports.REQUEST_COMMITMENTS_SLOT = REQUEST_COMMITMENTS_SLOT;
@@ -22743,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;