@hyperbridge/sdk 2.8.3 → 2.8.4

package/dist/node/index.cjs

@@ -5250,11 +5250,21 @@ var ChainConfigService = class {
    * it, so a new asset is added once in `chain.ts` and nowhere else.
    */
   getAssetBySymbol(chain, symbol) {
-    const assets = this.getConfig(chain)?.assets;
+    return this.getAssetMetadataBySymbol(chain, symbol)?.address;
+  }
+  /** Resolves a configured token symbol case-insensitively on a specific chain. */
+  getAssetMetadataBySymbol(chain, symbol) {
+    const config = this.getConfig(chain);
+    const assets = config?.assets;
     if (!assets) return void 0;
     const target = symbol.trim().toUpperCase();
     for (const [key, address] of Object.entries(assets)) {
-      if (key.toUpperCase() === target) return address;
+      if (key.toUpperCase() !== target) continue;
+      return {
+        symbol: key,
+        address,
+        decimals: config.tokenDecimals?.[key]
+      };
     }
     return void 0;
   }
@@ -7825,6 +7835,7 @@ var HYPERBRIDGE_TYPES_BUNDLE = {
 };
 var BASE_TIP = 1000000000n;
 var HTTP_CONNECT_TIMEOUT_MS = 2e4;
+var INCLUSION_TIMEOUT_MS = 2e4;
 var PHANTOM_POLL_INTERVAL_MS = 15e3;
 var GARGANTUA_PHANTOM_POLL_INTERVAL_MS = 6e3;
 function rejectAfter(ms, message) {
@@ -8043,14 +8054,16 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
   /**
    * Signs and sends an extrinsic. Submissions are serialised through {@link submissionQueue} so
    * concurrent calls never collide on the substrate account nonce — each extrinsic reaches a block
-   * (or is confirmed still pooled and returned as `pending`) before the next is signed; auto-nonce
-   * via `system.accountNextIndex` counts pooled extrinsics, so a pending one is never re-used.
+   * (or is confirmed still pooled and returned as `pending`) before the next is signed. The
+   * auto-nonce is the account's on-chain nonce, so a still-pooled extrinsic does not advance it: a
+   * submission signed behind a pending one bounces off it (1013/1014) and is reported as pending
+   * too, rather than landing as a second copy.
    *
    * The extrinsic is built rather than passed in because the api it is built on decides where it
    * is signed and sent: a websocket that is down when the queue reaches this submission diverts it
    * to {@link sendViaHttp}, which needs the call bound to the HTTP api instead.
    */
-  async signAndSendExtrinsic(build, maxRetries = 3, timeoutMs = 3e4) {
+  async signAndSendExtrinsic(build, maxRetries = 3, timeoutMs = INCLUSION_TIMEOUT_MS) {
     const result = await this.submissionQueue.add(async () => {
       if (!this.api.isConnected) {
         try {
@@ -8088,36 +8101,72 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    * Signs and sends an extrinsic, handling status updates and errors.
    * Implements retry logic with progressive tip increases for stuck transactions.
    *
-   * A retry only happens when the previous attempt verifiably went nowhere. Once an attempt's
-   * extrinsic is known to be pooled (`pending`), re-signing the same call would race our own
-   * submission: the copy either bounces off the pool (1014, same nonce below the replacement
-   * priority bump) or — if the original lands first, freeing the nonce — executes as a duplicate
-   * and fails on-chain (e.g. `BidNotFound` for a retraction). Neither can succeed, so the pending
-   * result is returned for the caller to confirm later.
+   * Two kinds of failure are retried, and the difference is the nonce.
+   *
+   * An attempt that verifiably went nowhere (rejected before the pool, dropped, invalid) leaves
+   * the account nonce free, so the next attempt simply re-signs with the auto-nonce.
+   *
+   * An attempt that reached the pool and was still there when the watch timed out (`stalled`) is
+   * retried as a *replacement*: the same nonce it was signed with, and double the tip. Substrate's
+   * pool evicts a pooled extrinsic in favour of a higher-priority one at the same (account, nonce),
+   * so exactly one of the two can ever execute. This matters for a bid, which is worth nothing once
+   * its window closes — waiting out a stalled extrinsic usually means not bidding at all.
+   *
+   * Re-signing without pinning the nonce is what must never happen here. The auto-nonce is read
+   * from on-chain state, so it is only the stalled extrinsic's nonce for as long as that extrinsic
+   * stays out of a block — and a stall is precisely the case where it may land at any moment. Once
+   * it does, an unpinned retry takes the *next* nonce and both execute: a duplicate `placeBid` that
+   * fails on-chain, and a second `retractBid` that pulls the bid just placed. When the signed nonce
+   * cannot be read, the stalled result is returned rather than guessed at.
+   *
+   * A rejection that bounced off a copy already pooled (1013/1014) is likewise left alone: that
+   * copy is in flight and its outcome is unknown here, so the `pending` result goes back to the
+   * caller to confirm later.
    */
   async sendExtrinsicWithRetries(extrinsic, maxRetries, timeoutMs) {
     const keyPair = this.getKeyPair();
     let attempt = 0;
+    let nonce;
+    let stalled;
     while (attempt < maxRetries) {
       const currentTip = BASE_TIP * BigInt(2 ** attempt);
       attempt++;
       try {
-        const result = await this.sendWithTimeout(extrinsic, keyPair, currentTip, timeoutMs);
-        if (result.success || result.pending || result.error?.includes("Dispatch error")) {
+        const result = await this.sendWithTimeout(extrinsic, keyPair, currentTip, timeoutMs, nonce);
+        if (result.success || result.error?.includes("Dispatch error")) {
           return result;
         }
+        if (result.stalled) {
+          stalled = result;
+          nonce ??= this.signedNonce(extrinsic);
+          if (nonce === void 0) return result;
+          continue;
+        }
+        if (result.pending) return stalled ?? result;
       } catch (err) {
-        return {
+        return stalled ?? {
           success: false,
           error: err instanceof Error ? err.message : "Unknown error"
         };
       }
     }
-    return {
+    return stalled ?? {
       success: false,
       error: `Transaction failed after ${maxRetries} attempts`
     };
   }
+  /**
+   * The nonce an extrinsic was signed with, or undefined if it carries no readable one — which is
+   * the case before it has ever been signed, and for a stub api in tests.
+   */
+  signedNonce(extrinsic) {
+    try {
+      const nonce = extrinsic.nonce?.toNumber?.();
+      return typeof nonce === "number" && Number.isFinite(nonce) ? nonce : void 0;
+    } catch {
+      return void 0;
+    }
+  }
   /**
    * Classifies a submission rejection. Codes 1013 ("already imported") and 1014 ("priority is
    * too low") both mean a copy of this account+nonce is already in the pool — almost always our
@@ -8135,10 +8184,15 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
    *
    * A timeout is only a failure when the extrinsic never made it into the transaction pool.
    * Once a pool-entry status (Future/Ready/Broadcast/Retracted) has been seen, the extrinsic is
-   * in flight and may well execute after the watch is abandoned — the result is then `pending`,
-   * telling the caller to confirm the outcome later instead of re-signing the same call.
+   * in flight and may well execute after the watch is abandoned — the result is then `pending`
+   * and `stalled`, telling the caller to replace it under the same nonce or confirm it later,
+   * never to re-sign the same call under a fresh one.
+   *
+   * `nonce` pins the submission to a specific account nonce, which is what makes a retry a pool
+   * replacement rather than a second extrinsic queued behind the first. Left undefined on the
+   * first attempt, where the api's auto-nonce is correct.
    */
-  async sendWithTimeout(extrinsic, keyPair, tip, timeoutMs) {
+  async sendWithTimeout(extrinsic, keyPair, tip, timeoutMs, nonce) {
     return new Promise((resolve) => {
       let resolved = false;
       let unsubscribe = null;
@@ -8152,12 +8206,13 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
           resolve({
             success: false,
             pending: enteredPool || void 0,
+            stalled: enteredPool || void 0,
             extrinsicHash: enteredPool ? extrinsic.hash.toHex() : void 0,
             error: `Transaction timed out after ${timeoutMs}ms${enteredPool ? " while in the transaction pool" : ""}`
           });
         }
       }, timeoutMs);
-      extrinsic.signAndSend(keyPair, { tip }, (result) => {
+      extrinsic.signAndSend(keyPair, nonce === void 0 ? { tip } : { tip, nonce }, (result) => {
         if (resolved) return;
         if (result.status.isFuture || result.status.isReady || result.status.isBroadcast || result.status.isRetracted) {
           enteredPool = true;
@@ -11994,52 +12049,85 @@ query LatestPhantomOrderPriceSnapshot($tokenA: String!, $tokenB: String!) {
     }
   }
 }`;
-var LATEST_PHANTOM_ORDER_LIQUIDITY_SNAPSHOT = `
-query LatestPhantomOrderLiquiditySnapshot($tokenA: String!, $tokenB: String!) {
-  phantomOrderPriceSnapshots(
+var AVAILABLE_LIQUIDITY = `
+query AvailableLiquidity(
+  $poolId: String!
+  $sourceChain: String!
+  $destinationChain: String!
+  $direction: String!
+) {
+  poolChainLiquidities(
     filter: {
       and: [
-        { tokenA: { equalTo: $tokenA } }
-        { tokenB: { equalTo: $tokenB } }
+        { poolId: { equalToInsensitive: $poolId } }
+        { chain: { equalTo: $destinationChain } }
+        { direction: { equalTo: $direction } }
       ]
     }
-    orderBy: SNAPSHOT_TIME_DESC
     first: 1
   ) {
     nodes {
-      commitment
-      tokenA
-      tokenB
-      snapshotTime
+      depth
+      bidCount
+      unrestrictedDepth
+      unrestrictedBidCount
+      lastUpdatedAt
+    }
+  }
+  poolRoutes(
+    filter: {
+      and: [
+        { poolId: { equalToInsensitive: $poolId } }
+        { sourceChain: { equalTo: $sourceChain } }
+        { chain: { equalTo: $destinationChain } }
+        { direction: { equalTo: $direction } }
+      ]
+    }
+    first: 1
+  ) {
+    nodes {
+      depth
+      bidCount
+      lastUpdatedAt
     }
   }
 }`;
-var LIQUIDITY_PROVIDER_BALANCES = `
-query LiquidityProviderBalanceAggregates($commitment: String!, $tokenAddress: String!) {
-  liquidityProviderBalances(
+var BUY_AND_SELL_RATES = `
+query BuyAndSellRates(
+  $poolId: String!
+  $directChain: String!
+  $directDirection: String!
+  $reverseChain: String!
+  $reverseDirection: String!
+) {
+  direct: poolChainLiquidities(
     filter: {
       and: [
-        { commitment: { equalTo: $commitment } }
-        { tokenAddress: { equalTo: $tokenAddress } }
+        { poolId: { equalToInsensitive: $poolId } }
+        { chain: { equalTo: $directChain } }
+        { direction: { equalTo: $directDirection } }
       ]
     }
+    first: 1
   ) {
-    aggregates {
-      sum {
-        balance
-      }
-      distinctCount {
-        providerId
-      }
+    nodes {
+      rate
+      lastUpdatedAt
     }
-    groupedAggregates(groupBy: [CHAIN, TOKEN_ADDRESS]) {
-      keys
-      sum {
-        balance
-      }
-      distinctCount {
-        providerId
-      }
+  }
+  reverse: poolChainLiquidities(
+    filter: {
+      and: [
+        { poolId: { equalToInsensitive: $poolId } }
+        { chain: { equalTo: $reverseChain } }
+        { direction: { equalTo: $reverseDirection } }
+      ]
+    }
+    first: 1
+  ) {
+    nodes {
+      rate
+      lastUpdatedAt
     }
   }
 }`;
@@ -18183,178 +18271,191 @@ var OrderStatusChecker = class {
     return true;
   }
 };
-var COMMITMENT_PATTERN = /^0x[0-9a-f]{64}$/i;
+
+// src/protocols/intents/liquidity-pool.ts
+function sortPoolSymbols(symbolA, symbolB) {
+  return symbolA.toLowerCase() <= symbolB.toLowerCase() ? [symbolA, symbolB] : [symbolB, symbolA];
+}
+function poolSlug(symbolA, symbolB) {
+  return sortPoolSymbols(symbolA, symbolB).join("-");
+}
+function resolveLiquidityPool(symbolA, symbolB) {
+  const [token0Symbol, token1Symbol] = sortPoolSymbols(symbolA, symbolB);
+  return {
+    poolId: `${token0Symbol}-${token1Symbol}`,
+    token0Symbol,
+    token1Symbol
+  };
+}
+
+// src/protocols/intents/LiquidityEngine.ts
+var INDEXER_FIXED_POINT_DECIMALS = 18;
+var POOL_RATE_SCALE = 10n ** 18n;
+var SELL = "SELL";
+var BUY = "BUY";
+var USD_STABLE_SYMBOLS = /* @__PURE__ */ new Set(["USDC", "USDT"]);
 var LiquidityEngine = class {
-  /**
-   * @param queryClient - Nexus GraphQL client attached to the gateway.
-   * @param chainConfigService - Resolves token decimals for formatted results.
-   */
-  constructor(queryClient, chainConfigService) {
+  constructor(queryClient) {
     this.queryClient = queryClient;
-    this.chainConfigService = chainConfigService;
   }
   queryClient;
-  chainConfigService;
   /**
-   * Retrieves the newest directional Phantom snapshot for a pair and its
-   * indexed output-token liquidity.
+   * Returns liquidity reachable from one source chain on one destination.
    *
-   * 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.
+   * The caller resolves chain-specific token addresses through chain
+   * configuration; this layer only maps those configured symbols onto the
+   * indexer's canonical pool and route fields.
    *
-   * @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");
+   * Destination, unrestricted, and explicit-route capacity are returned as
+   * separate values so callers can apply their own source-chain policy.
+   *
+   * @returns `undefined` only when the indexer has not published a destination
+   * pool sample yet.
+   */
+  async getAvailableLiquidity(params) {
+    const pool = resolveLiquidityPool(params.source.symbol, params.destination.symbol);
+    const direction = params.source.symbol.toLowerCase() === pool.token0Symbol.toLowerCase() ? SELL : BUY;
+    const variables = {
+      poolId: pool.poolId,
+      sourceChain: params.source.chain,
+      destinationChain: params.destination.chain,
+      direction
+    };
+    const response = await this.queryClient.request(AVAILABLE_LIQUIDITY, variables);
+    if (!response?.poolChainLiquidities?.nodes || !response?.poolRoutes?.nodes) {
+      throw new InvalidLiquidityIndexerResponseError("liquidity connections are missing");
     }
-    const { totalLiquidity, providerCount, liquidityByChain } = await this.querySnapshotLiquidityAggregates({
-      commitment,
-      tokenAddress: tokenOut
-    });
+    const chainLiquidity = response.poolChainLiquidities.nodes[0];
+    if (!chainLiquidity) return void 0;
+    const route = response.poolRoutes.nodes[0];
     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)
-      }))
+      sourceChain: params.source.chain,
+      destinationChain: params.destination.chain,
+      tokenAddress: normalizeEvmAddress(params.destination.address, "destination token"),
+      updatedAt: readIndexerDate(chainLiquidity.lastUpdatedAt, "destination lastUpdatedAt"),
+      destination: readLiquiditySlice(chainLiquidity.depth, chainLiquidity.bidCount, "destination"),
+      unrestricted: readLiquiditySlice(
+        chainLiquidity.unrestrictedDepth,
+        chainLiquidity.unrestrictedBidCount,
+        "unrestricted"
+      ),
+      explicitRoute: route ? {
+        ...readLiquiditySlice(route.depth, route.bidCount, "explicit route"),
+        updatedAt: readIndexerDate(route.lastUpdatedAt, "route lastUpdatedAt")
+      } : null
     };
   }
   /**
-   * Requests server-side sums and distinct provider counts for one immutable
-   * snapshot/output-token pair, including chain-level aggregate groups.
+   * Returns chain-specific buy and sell rates in less-valued quote-token units
+   * per one base token.
    *
-   * `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}`
-        )
-      };
+   * The requested direction is read on the destination chain; its reverse is
+   * read on the source chain. This mirrors where each direction's output token
+   * must be delivered for a cross-chain trade.
+   */
+  async getBuyAndSellRates(params) {
+    const pool = resolveLiquidityPool(params.tokenInSymbol, params.tokenOutSymbol);
+    const directDirection = params.tokenInSymbol.toLowerCase() === pool.token0Symbol.toLowerCase() ? SELL : BUY;
+    const reverseDirection = directDirection === SELL ? BUY : SELL;
+    const response = await this.queryClient.request(BUY_AND_SELL_RATES, {
+      poolId: pool.poolId,
+      directChain: params.destinationChain,
+      directDirection,
+      reverseChain: params.sourceChain,
+      reverseDirection
     });
-    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 };
+    if (!response?.direct?.nodes || !response?.reverse?.nodes) {
+      throw new InvalidLiquidityIndexerResponseError("rate connections are missing");
+    }
+    const direct = readIndexedRate(response.direct.nodes[0], "direct rate");
+    const reverse = readIndexedRate(response.reverse.nodes[0], "reverse rate");
+    if (!direct && !reverse) return void 0;
+    const quoteTokenSymbol = resolveQuoteTokenSymbol(
+      params.tokenInSymbol,
+      params.tokenOutSymbol,
+      direct?.scaledRate,
+      reverse?.scaledRate
+    );
+    const quoteIsTokenOut = quoteTokenSymbol === params.tokenOutSymbol;
+    const buy = quoteIsTokenOut ? direct : reverse;
+    const sell = quoteIsTokenOut ? reverse : direct;
+    return {
+      baseTokenSymbol: quoteIsTokenOut ? params.tokenInSymbol : params.tokenOutSymbol,
+      quoteTokenSymbol,
+      sourceChain: params.sourceChain,
+      destinationChain: params.destinationChain,
+      buyRate: buy ? viem.formatUnits(buy.scaledRate, INDEXER_FIXED_POINT_DECIMALS) : null,
+      sellRate: sell ? viem.formatUnits(reciprocalRate(sell.scaledRate, "sell rate"), INDEXER_FIXED_POINT_DECIMALS) : null,
+      buyRateUpdatedAt: buy?.updatedAt ?? null,
+      sellRateUpdatedAt: sell?.updatedAt ?? null
+    };
   }
-  /** 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 InvalidLiquidityIndexerResponseError = class extends Error {
+  constructor(reason) {
+    super(`Invalid liquidity indexer response: ${reason}`);
+    this.name = "InvalidLiquidityIndexerResponseError";
   }
 };
-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";
+var UnsupportedLiquidityAssetError = class extends Error {
+  constructor(chain, asset) {
+    super(`No configured liquidity asset found for ${asset} on ${chain}`);
+    this.name = "UnsupportedLiquidityAssetError";
+  }
+};
+var UnsupportedLiquidityChainError = class extends Error {
+  constructor(chainId) {
+    super(`No configured liquidity chain found for chain ID ${chainId}`);
+    this.name = "UnsupportedLiquidityChainError";
   }
 };
-function parseSnapshotBigInt(value, commitment, field) {
+function readLiquiditySlice(depth, providerCount, label) {
+  if (!Number.isSafeInteger(providerCount) || providerCount < 0) {
+    throw new InvalidLiquidityIndexerResponseError(`${label} provider count is invalid`);
+  }
+  return { totalLiquidity: formatIndexerAmount(depth, `${label} depth`), providerCount };
+}
+function formatIndexerAmount(value, label) {
   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`);
+    if (amount < 0n) throw new Error();
+    return viem.formatUnits(amount, INDEXER_FIXED_POINT_DECIMALS);
+  } catch {
+    throw new InvalidLiquidityIndexerResponseError(`${label} is not a non-negative 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 readIndexerDate(value, label) {
+  const date = new Date(dateStringtoTimestamp(value));
+  if (Number.isNaN(date.getTime())) throw new InvalidLiquidityIndexerResponseError(`${label} is invalid`);
+  return date;
 }
-function normalizeIndexedLiquidityAddress(address, commitment, field) {
+function readIndexedRate(node, label) {
+  if (!node) return void 0;
   try {
-    return normalizeEvmAddress(address, field);
-  } catch {
-    throw new InvalidAvailableLiquiditySnapshotError(commitment, `${field} is not a valid EVM address`);
+    const scaledRate = BigInt(node.rate);
+    if (scaledRate <= 0n) throw new Error();
+    return {
+      scaledRate,
+      updatedAt: readIndexerDate(node.lastUpdatedAt, `${label} lastUpdatedAt`)
+    };
+  } catch (error) {
+    if (error instanceof InvalidLiquidityIndexerResponseError) throw error;
+    throw new InvalidLiquidityIndexerResponseError(`${label} is not a positive integer`);
   }
 }
+function resolveQuoteTokenSymbol(tokenInSymbol, tokenOutSymbol, directRate, reverseRate) {
+  const inputIsUsdStable = USD_STABLE_SYMBOLS.has(tokenInSymbol);
+  const outputIsUsdStable = USD_STABLE_SYMBOLS.has(tokenOutSymbol);
+  if (inputIsUsdStable !== outputIsUsdStable) return inputIsUsdStable ? tokenOutSymbol : tokenInSymbol;
+  if (directRate !== void 0) return directRate >= POOL_RATE_SCALE ? tokenOutSymbol : tokenInSymbol;
+  if (reverseRate !== void 0) return reverseRate >= POOL_RATE_SCALE ? tokenInSymbol : tokenOutSymbol;
+  throw new InvalidLiquidityIndexerResponseError("cannot orient an empty rate pair");
+}
+function reciprocalRate(rate, label) {
+  const reciprocal = POOL_RATE_SCALE * POOL_RATE_SCALE / rate;
+  if (reciprocal <= 0n) throw new InvalidLiquidityIndexerResponseError(`${label} reciprocal underflowed`);
+  return reciprocal;
+}
 
 // src/protocols/intents/quote/types.ts
 var UnsupportedIntentQuoteStrategyError = class extends Error {
@@ -18779,8 +18880,6 @@ 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.
    *
@@ -18824,7 +18923,6 @@ 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,
@@ -18904,33 +19002,62 @@ var IntentGateway = class _IntentGateway {
     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.
+   * Returns indexed destination liquidity and its source-routing slices.
    *
-   * 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.
+   * Destination, unrestricted, and explicit-route capacity come exclusively
+   * from the indexer's pair-centric liquidity entities. The SDK does not decide
+   * whether unrestricted bidders cover the source chain. Amounts reflect the
+   * latest rolling sample; they are not reservations or fill guarantees.
    *
    * 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
+    const sourceStateMachineId = getConfigByStateMachineId(this.source.config.stateMachineId)?.stateMachineId;
+    const destinationStateMachineId = getConfigByStateMachineId(this.dest.config.stateMachineId)?.stateMachineId;
+    if (!sourceStateMachineId) throw new UnsupportedLiquidityChainError(this.source.config.stateMachineId);
+    if (!destinationStateMachineId) throw new UnsupportedLiquidityChainError(this.dest.config.stateMachineId);
+    const sourceToken = this.source.configService.getAssetMetadataByAddress(sourceStateMachineId, params.tokenIn);
+    const destinationToken = this.dest.configService.getAssetMetadataByAddress(
+      destinationStateMachineId,
+      params.tokenOut
+    );
+    if (!sourceToken) throw new UnsupportedLiquidityAssetError(sourceStateMachineId, params.tokenIn);
+    if (!destinationToken) throw new UnsupportedLiquidityAssetError(destinationStateMachineId, params.tokenOut);
+    return new LiquidityEngine(queryClient).getAvailableLiquidity({
+      source: {
+        chain: sourceStateMachineId,
+        ...sourceToken
+      },
+      destination: {
+        chain: destinationStateMachineId,
+        ...destinationToken
+      }
+    });
+  }
+  /**
+   * Returns chain-specific buy and sell rates in less-valued quote-token units
+   * without requiring token addresses. Symbols are matched case-insensitively;
+   * chain IDs are numeric IDs for chains configured in the SDK.
+   */
+  async queryBuyAndSellRates(params) {
+    const { queryClient } = this.requireIndexer();
+    const sourceChain = chainConfigs[params.sourceChainId]?.stateMachineId;
+    const destinationChain = chainConfigs[params.destinationChainId]?.stateMachineId;
+    if (!sourceChain) throw new UnsupportedLiquidityChainError(params.sourceChainId);
+    if (!destinationChain) throw new UnsupportedLiquidityChainError(params.destinationChainId);
+    const sourceToken = this.source.configService.getAssetMetadataBySymbol(sourceChain, params.tokenInSymbol);
+    const destinationToken = this.dest.configService.getAssetMetadataBySymbol(
+      destinationChain,
+      params.tokenOutSymbol
+    );
+    if (!sourceToken) throw new UnsupportedLiquidityAssetError(sourceChain, params.tokenInSymbol);
+    if (!destinationToken) throw new UnsupportedLiquidityAssetError(destinationChain, params.tokenOutSymbol);
+    return new LiquidityEngine(queryClient).getBuyAndSellRates({
+      sourceChain,
+      destinationChain,
+      tokenInSymbol: sourceToken.symbol,
+      tokenOutSymbol: destinationToken.symbol
     });
   }
   /**
@@ -24049,10 +24176,12 @@ exports.EvmLanguage = EvmLanguage;
 exports.HyperClientStatus = HyperClientStatus;
 exports.HyperFungibleToken = HyperFungibleToken;
 exports.HyperFungibleTokenABI = HyperFungibleTokenABI;
+exports.INCLUSION_TIMEOUT_MS = INCLUSION_TIMEOUT_MS;
 exports.IntentGateway = IntentGateway;
 exports.IntentGatewayABI = ABI3;
 exports.IntentOrderStatus = IntentOrderStatus;
 exports.IntentsCoprocessor = IntentsCoprocessor;
+exports.InvalidLiquidityIndexerResponseError = InvalidLiquidityIndexerResponseError;
 exports.InvalidPhantomSnapshotError = InvalidPhantomSnapshotError;
 exports.IsmpClient = IsmpClient;
 exports.MOCK_ADDRESS = MOCK_ADDRESS;
@@ -24082,6 +24211,8 @@ exports.TronChain = TronChain;
 exports.USE_ETHERSCAN_CHAINS = USE_ETHERSCAN_CHAINS;
 exports.UnsupportedIntentQuotePairError = UnsupportedIntentQuotePairError;
 exports.UnsupportedIntentQuoteStrategyError = UnsupportedIntentQuoteStrategyError;
+exports.UnsupportedLiquidityAssetError = UnsupportedLiquidityAssetError;
+exports.UnsupportedLiquidityChainError = UnsupportedLiquidityChainError;
 exports.WrappedHyperFungibleTokenABI = WrappedHyperFungibleTokenABI;
 exports.__test = __test;
 exports.adjustDecimals = adjustDecimals;
@@ -24145,6 +24276,7 @@ exports.pharosAtlantic = pharosAtlantic;
 exports.pharosMainnet = pharosMainnet;
 exports.polkadotAssetHubPaseo = polkadotAssetHubPaseo;
 exports.polkadotHubMainnet = polkadotHubMainnet;
+exports.poolSlug = poolSlug;
 exports.postRequestCommitment = postRequestCommitment;
 exports.queryAssetTeleported = queryAssetTeleported;
 exports.queryGetRequest = queryGetRequest;
@@ -24153,6 +24285,7 @@ exports.quoteUniswap = quoteUniswap;
 exports.requestCommitmentKey = requestCommitmentKey;
 exports.responseCommitmentKey = responseCommitmentKey;
 exports.retryPromise = retryPromise;
+exports.sortPoolSymbols = sortPoolSymbols;
 exports.teleport = teleport;
 exports.teleportDot = teleportDot;
 exports.transformOrderForContract = transformOrderForContract;