@hyperbridge/sdk 2.8.6 → 2.8.8

package/dist/node/index.cjs

@@ -2808,7 +2808,7 @@ var chainConfigs = {
       // "Usdt0Oft": Not available on BSC
     },
     rpcEnvKey: "BSC_MAINNET",
-    defaultRpcUrl: "https://binance.llamarpc.com",
+    defaultRpcUrl: "https://bsc-rpc.publicnode.com",
     consensusStateId: "BSC0",
     coingeckoId: "binance-smart-chain",
     erc4626Vaults: [
@@ -8002,7 +8002,15 @@ var IntentsCoprocessor = class _IntentsCoprocessor {
     if (!this.httpApi) {
       const httpUrl = deriveHttpUrl(this.wsEndpoint());
       const api$1 = new api.ApiPromise({
-        provider: new api.HttpProvider(httpUrl),
+        // Response cache off (third argument, capacity 0). polkadot-js caches every request that
+        // names a block hash — `chain_getHeader(hash)`, `state_getRuntimeVersion(hash)`, storage
+        // reads at a hash — by storing the request promise itself, a rejected one included, for a
+        // 30s TTL that every hit refreshes. The phantom poll retries the block it failed on with
+        // identical parameters every tick, so one reset connection became the same rejection
+        // replayed from memory on every tick, faster than the TTL could lapse, and the node never
+        // saw a second request. The cache bought nothing here anyway: the poll reads each block
+        // once, and `api.at(hash)` reuses registries at the api layer regardless.
+        provider: new api.HttpProvider(httpUrl, {}, 0),
         typesBundle: HYPERBRIDGE_TYPES_BUNDLE,
         // A second connection to the node the ws api already reported on; its init warnings
         // would just be duplicates.
@@ -12093,40 +12101,17 @@ query AvailableLiquidity(
   }
 }`;
 var BUY_AND_SELL_RATES = `
-query BuyAndSellRates(
-  $poolId: String!
-  $directChain: String!
-  $directDirection: String!
-  $reverseChain: String!
-  $reverseDirection: String!
-) {
-  direct: poolChainLiquidities(
-    filter: {
-      and: [
-        { poolId: { equalToInsensitive: $poolId } }
-        { chain: { equalTo: $directChain } }
-        { direction: { equalTo: $directDirection } }
-      ]
-    }
-    first: 1
-  ) {
-    nodes {
-      rate
-      lastUpdatedAt
-    }
-  }
-  reverse: poolChainLiquidities(
-    filter: {
-      and: [
-        { poolId: { equalToInsensitive: $poolId } }
-        { chain: { equalTo: $reverseChain } }
-        { direction: { equalTo: $reverseDirection } }
-      ]
-    }
+query GetLiquidityPoolRate($poolId: String!) {
+  liquidityPools(
     first: 1
+    filter: { id: { equalToInsensitive: $poolId } }
   ) {
     nodes {
-      rate
+      id
+      token0Symbol
+      token1Symbol
+      sellRate
+      buyRate
       lastUpdatedAt
     }
   }
@@ -18338,29 +18323,29 @@ var LiquidityEngine = class {
     };
   }
   /**
-   * Returns chain-specific buy and sell rates in less-valued quote-token units
-   * per one base token.
+   * Returns the indexed pool's aggregate buy and sell rates in less-valued
+   * quote-token units per one base token.
    *
-   * 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.
+   * The indexer depth-weights fresh per-chain samples into the pool rates. The
+   * source and destination chains remain part of the result because they define
+   * the cross-chain route whose configured token symbols were resolved.
    */
   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
+      poolId: pool.poolId
     });
-    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 (!response?.liquidityPools?.nodes) {
+      throw new InvalidLiquidityIndexerResponseError("liquidity pool connection is missing");
+    }
+    const indexedPool = response.liquidityPools.nodes[0];
+    if (!indexedPool) return void 0;
+    validateIndexedPool(indexedPool, pool);
+    const sell = readIndexedRate(indexedPool.sellRate, indexedPool.lastUpdatedAt, "pool sell rate");
+    const buy = readIndexedRate(indexedPool.buyRate, indexedPool.lastUpdatedAt, "pool buy rate");
+    const inputIsToken0 = params.tokenInSymbol.toLowerCase() === pool.token0Symbol.toLowerCase();
+    const direct = inputIsToken0 ? sell : buy;
+    const reverse = inputIsToken0 ? buy : sell;
     if (!direct && !reverse) return void 0;
     const quoteTokenSymbol = resolveQuoteTokenSymbol(
       params.tokenInSymbol,
@@ -18369,17 +18354,17 @@ var LiquidityEngine = class {
       reverse?.scaledRate
     );
     const quoteIsTokenOut = quoteTokenSymbol === params.tokenOutSymbol;
-    const buy = quoteIsTokenOut ? direct : reverse;
-    const sell = quoteIsTokenOut ? reverse : direct;
+    const orientedBuy = quoteIsTokenOut ? direct : reverse;
+    const orientedSell = 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
+      buyRate: orientedBuy ? viem.formatUnits(orientedBuy.scaledRate, INDEXER_FIXED_POINT_DECIMALS) : null,
+      sellRate: orientedSell ? viem.formatUnits(reciprocalRate(orientedSell.scaledRate, "sell rate"), INDEXER_FIXED_POINT_DECIMALS) : null,
+      buyRateUpdatedAt: orientedBuy?.updatedAt ?? null,
+      sellRateUpdatedAt: orientedSell?.updatedAt ?? null
     };
   }
 };
@@ -18421,20 +18406,25 @@ function readIndexerDate(value, label) {
   if (Number.isNaN(date.getTime())) throw new InvalidLiquidityIndexerResponseError(`${label} is invalid`);
   return date;
 }
-function readIndexedRate(node, label) {
-  if (!node) return void 0;
+function readIndexedRate(value, lastUpdatedAt, label) {
+  if (value === null) return void 0;
   try {
-    const scaledRate = BigInt(node.rate);
+    const scaledRate = BigInt(value);
     if (scaledRate <= 0n) throw new Error();
     return {
       scaledRate,
-      updatedAt: readIndexerDate(node.lastUpdatedAt, `${label} lastUpdatedAt`)
+      updatedAt: readIndexerDate(lastUpdatedAt, `${label} lastUpdatedAt`)
     };
   } catch (error) {
     if (error instanceof InvalidLiquidityIndexerResponseError) throw error;
     throw new InvalidLiquidityIndexerResponseError(`${label} is not a positive integer`);
   }
 }
+function validateIndexedPool(indexedPool, expected) {
+  if (indexedPool.id.toLowerCase() !== expected.poolId.toLowerCase() || indexedPool.token0Symbol.toLowerCase() !== expected.token0Symbol.toLowerCase() || indexedPool.token1Symbol.toLowerCase() !== expected.token1Symbol.toLowerCase()) {
+    throw new InvalidLiquidityIndexerResponseError(`pool identity does not match ${expected.poolId}`);
+  }
+}
 function resolveQuoteTokenSymbol(tokenInSymbol, tokenOutSymbol, directRate, reverseRate) {
   const inputIsUsdStable = USD_STABLE_SYMBOLS.has(tokenInSymbol);
   const outputIsUsdStable = USD_STABLE_SYMBOLS.has(tokenOutSymbol);
@@ -18444,7 +18434,8 @@ function resolveQuoteTokenSymbol(tokenInSymbol, tokenOutSymbol, directRate, reve
   throw new InvalidLiquidityIndexerResponseError("cannot orient an empty rate pair");
 }
 function reciprocalRate(rate, label) {
-  const reciprocal = POOL_RATE_SCALE * POOL_RATE_SCALE / rate;
+  const numerator = POOL_RATE_SCALE * POOL_RATE_SCALE;
+  const reciprocal = (numerator + rate - 1n) / rate;
   if (reciprocal <= 0n) throw new InvalidLiquidityIndexerResponseError(`${label} reciprocal underflowed`);
   return reciprocal;
 }
@@ -18476,6 +18467,20 @@ var InvalidPhantomSnapshotError = class extends Error {
     this.name = "InvalidPhantomSnapshotError";
   }
 };
+var IndexedRateUnavailableError = class extends Error {
+  constructor(params) {
+    const route = params.source && params.destination && params.tokenIn && params.tokenOut ? ` for ${params.tokenIn} -> ${params.tokenOut} on ${params.source} -> ${params.destination}` : "";
+    const side = params.side ? ` ${params.side}` : "";
+    super(`No indexed${side} rate available${route}`);
+    this.name = "IndexedRateUnavailableError";
+  }
+};
+var InvalidIndexedRateError = class extends Error {
+  constructor(reason) {
+    super(`Invalid indexed intent rate: ${reason}`);
+    this.name = "InvalidIndexedRateError";
+  }
+};
 var BPS_DENOMINATOR = 10000n;
 function validateQuoteParams(params) {
   const hasAmountIn = params.amountIn !== void 0;
@@ -18842,6 +18847,128 @@ function isSupportedSnapshotPair(tokenA, tokenB) {
 function isConfiguredAddress(address) {
   return Boolean(address && address !== "0x" && !/^0x0{40}$/i.test(address));
 }
+var INDEXED_RATE_DECIMALS = 18;
+var INDEXED_RATE_SCALE = 10n ** BigInt(INDEXED_RATE_DECIMALS);
+var IndexedRateIntentQuoteStrategy = class {
+  constructor(chainConfigService, getQueryClient) {
+    this.chainConfigService = chainConfigService;
+    this.getQueryClient = getQueryClient;
+  }
+  chainConfigService;
+  getQueryClient;
+  async quote(params, source, destination) {
+    validateQuoteParams(params);
+    const sourceConfig = getConfigByStateMachineId(source.stateMachineId);
+    const destinationConfig = getConfigByStateMachineId(destination.stateMachineId);
+    if (!sourceConfig) throw new UnsupportedLiquidityChainError(source.stateMachineId);
+    if (!destinationConfig) throw new UnsupportedLiquidityChainError(destination.stateMachineId);
+    const tokenIn = this.resolveAsset(sourceConfig.stateMachineId, params.tokenIn);
+    const tokenOut = this.resolveAsset(destinationConfig.stateMachineId, params.tokenOut);
+    const [protocolFeeBps, rates] = await Promise.all([
+      readProtocolFeeBps(this.chainConfigService, source),
+      new LiquidityEngine(this.getQueryClient()).getBuyAndSellRates({
+        sourceChain: sourceConfig.stateMachineId,
+        destinationChain: destinationConfig.stateMachineId,
+        tokenInSymbol: tokenIn.symbol,
+        tokenOutSymbol: tokenOut.symbol
+      })
+    ]);
+    if (!rates) {
+      throw new IndexedRateUnavailableError({
+        source: sourceConfig.stateMachineId,
+        destination: destinationConfig.stateMachineId,
+        tokenIn: tokenIn.symbol,
+        tokenOut: tokenOut.symbol
+      });
+    }
+    const selectedRate = selectIndexedRate(rates, tokenIn.symbol, tokenOut.symbol);
+    return quoteWithIndexedRate(params, tokenIn, tokenOut, selectedRate, rates, protocolFeeBps);
+  }
+  resolveAsset(chain, address) {
+    const asset = this.chainConfigService.getAssetMetadataByAddress(chain, address);
+    if (!asset) throw new UnsupportedLiquidityAssetError(chain, address);
+    const { decimals } = asset;
+    if (decimals === void 0 || !Number.isSafeInteger(decimals) || decimals < 0) {
+      throw new InvalidIndexedRateError(`decimals are not configured for ${asset.symbol} on ${chain}`);
+    }
+    return { ...asset, decimals };
+  }
+};
+function selectIndexedRate(rates, tokenInSymbol, tokenOutSymbol) {
+  if (tokenInSymbol === rates.baseTokenSymbol && tokenOutSymbol === rates.quoteTokenSymbol) {
+    return readIndexedRate2(
+      "buy",
+      rates.buyRate,
+      rates.buyRateUpdatedAt,
+      rates,
+      tokenInSymbol,
+      tokenOutSymbol
+    );
+  }
+  if (tokenInSymbol === rates.quoteTokenSymbol && tokenOutSymbol === rates.baseTokenSymbol) {
+    return readIndexedRate2(
+      "sell",
+      rates.sellRate,
+      rates.sellRateUpdatedAt,
+      rates,
+      tokenInSymbol,
+      tokenOutSymbol
+    );
+  }
+  throw new InvalidIndexedRateError(
+    `indexed pair ${rates.baseTokenSymbol}/${rates.quoteTokenSymbol} does not match ${tokenInSymbol}/${tokenOutSymbol}`
+  );
+}
+function readIndexedRate2(side, rate, updatedAt, rates, tokenInSymbol, tokenOutSymbol) {
+  if (!rate || !updatedAt) {
+    throw new IndexedRateUnavailableError({
+      source: rates.sourceChain,
+      destination: rates.destinationChain,
+      tokenIn: tokenInSymbol,
+      tokenOut: tokenOutSymbol,
+      side
+    });
+  }
+  try {
+    const scaledRate = viem.parseUnits(rate, INDEXED_RATE_DECIMALS);
+    if (scaledRate <= 0n || Number.isNaN(updatedAt.getTime())) throw new Error();
+    return { side, rate, scaledRate, updatedAt };
+  } catch {
+    throw new InvalidIndexedRateError(`${side} rate or timestamp is invalid`);
+  }
+}
+function quoteWithIndexedRate(params, tokenIn, tokenOut, selectedRate, rates, protocolFeeBps) {
+  const inputUnit = 10n ** BigInt(tokenIn.decimals);
+  const outputUnit = 10n ** BigInt(tokenOut.decimals);
+  if (params.amountIn !== void 0) {
+    const netAmountIn2 = deductProtocolFee(params.amountIn, protocolFeeBps);
+    const amountOut = selectedRate.side === "buy" ? netAmountIn2 * selectedRate.scaledRate * outputUnit / (inputUnit * INDEXED_RATE_SCALE) : netAmountIn2 * outputUnit * INDEXED_RATE_SCALE / (inputUnit * selectedRate.scaledRate);
+    if (amountOut <= 0n) throw new InvalidIndexedRateError("quote rounds down to zero output");
+    return buildResult("EXACT_INPUT", params.amountIn, amountOut, selectedRate, rates, protocolFeeBps);
+  }
+  if (params.amountOut === void 0) throw new Error("Quote amount is missing after validation");
+  const netAmountIn = selectedRate.side === "buy" ? divCeil(params.amountOut * inputUnit * INDEXED_RATE_SCALE, selectedRate.scaledRate * outputUnit) : divCeil(params.amountOut * inputUnit * selectedRate.scaledRate, outputUnit * INDEXED_RATE_SCALE);
+  const amountIn = grossUpForProtocolFee(netAmountIn, protocolFeeBps);
+  return buildResult("EXACT_OUTPUT", amountIn, params.amountOut, selectedRate, rates, protocolFeeBps);
+}
+function buildResult(tradeType, amountIn, amountOut, selectedRate, rates, protocolFeeBps) {
+  return {
+    strategy: "indexed_rates",
+    tradeType,
+    amountIn,
+    amountOut,
+    quoteMetadata: {
+      sourceChain: rates.sourceChain,
+      destinationChain: rates.destinationChain,
+      baseTokenSymbol: rates.baseTokenSymbol,
+      quoteTokenSymbol: rates.quoteTokenSymbol,
+      rateSide: selectedRate.side,
+      rate: selectedRate.rate,
+      rateUpdatedAt: selectedRate.updatedAt,
+      protocolFeeBps
+    }
+  };
+}
 
 // src/protocols/intents/IntentGateway.ts
 var CROSS_CHAIN_ORDER_FEE_GAS_PRICE_BUMP_PERCENT = 10n;
@@ -18916,6 +19043,10 @@ var IntentGateway = class _IntentGateway {
     this.gasEstimator = gasEstimator;
     this._crypto = crypto;
     this.quoteStrategies = {
+      indexed_rates: new IndexedRateIntentQuoteStrategy(
+        dest.configService,
+        () => this.requireIndexer().queryClient
+      ),
       phantom_snapshot: new PhantomSnapshotIntentQuoteStrategy(
         dest.configService,
         () => this.requireIndexer().queryClient
@@ -18969,26 +19100,26 @@ var IntentGateway = class _IntentGateway {
   /**
    * Quotes an intent between this gateway's source and destination chains.
    *
-   * 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`.
+   * Uses the indexer's latest aggregate directional pool rate by default. Pass
+   * `strategy: "phantom_snapshot"` or `strategy: "uniswap_v4"` only when
+   * explicitly requesting a legacy quote source. Provide exactly one of
+   * `amountIn` or `amountOut`.
    *
-   * Both built-in strategies resolve their canonical market on Base,
-   * regardless of this gateway's destination chain. Returned
+   * The gateway's source and destination chains resolve the configured order
+   * tokens; the indexer supplies the depth-weighted pool rate. Returned
    * `amountIn`/`amountOut` already account for the gateway's protocol fee
-   * (`quoteMetadata.protocolFeeBps`), which the gateway deducts from order
-   * inputs; use the returned amounts directly when placing the order.
+   * (`quoteMetadata.protocolFeeBps`), which the gateway deducts from order inputs.
    *
    * @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 the selected strategy does not support the pair.
-   * @throws {PhantomSnapshotUnavailableError} When an eligible cNGN pair has no snapshot.
+   * @throws {IndexedRateUnavailableError} When the requested direction has no indexed rate.
    */
   async quoteIntent(params) {
     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 strategy = params.strategy ?? "indexed_rates";
     const handler = this.quoteStrategies[strategy];
     if (!handler) throw new UnsupportedIntentQuoteStrategyError(strategy);
     return handler.quote({ ...params, strategy }, source, destination);
@@ -19028,9 +19159,9 @@ var IntentGateway = class _IntentGateway {
     });
   }
   /**
-   * 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.
+   * Returns aggregate indexed pool buy and sell rates in less-valued quote-token
+   * units without requiring token addresses. Symbols are matched
+   * case-insensitively; chain IDs resolve configured token deployments.
    */
   async queryBuyAndSellRates(params) {
     const { queryClient } = this.requireIndexer();
@@ -19678,6 +19809,10 @@ function encodeAcceptedSourceChains(chains2) {
 function decodeAcceptedSourceChains(paymasterAndData) {
   return decodePhantomBidDeclaration(paymasterAndData).acceptedSources;
 }
+var UNISWAP_QUOTE_HAIRCUT_BPS = 30n;
+function applyUniswapQuoteHaircut(amount) {
+  return amount * (10000n - UNISWAP_QUOTE_HAIRCUT_BPS) / 10000n;
+}
 FILL_ORDER_ABI.find(
   (item) => item?.type === "function" && item?.name === "fillOrder"
 )?.inputs?.[0];
@@ -24169,10 +24304,12 @@ exports.HyperClientStatus = HyperClientStatus;
 exports.HyperFungibleToken = HyperFungibleToken;
 exports.HyperFungibleTokenABI = HyperFungibleTokenABI;
 exports.INCLUSION_TIMEOUT_MS = INCLUSION_TIMEOUT_MS;
+exports.IndexedRateUnavailableError = IndexedRateUnavailableError;
 exports.IntentGateway = IntentGateway;
 exports.IntentGatewayABI = ABI3;
 exports.IntentOrderStatus = IntentOrderStatus;
 exports.IntentsCoprocessor = IntentsCoprocessor;
+exports.InvalidIndexedRateError = InvalidIndexedRateError;
 exports.InvalidLiquidityIndexerResponseError = InvalidLiquidityIndexerResponseError;
 exports.InvalidPhantomSnapshotError = InvalidPhantomSnapshotError;
 exports.IsmpClient = IsmpClient;
@@ -24200,6 +24337,7 @@ exports.TeleportStatus = TeleportStatus;
 exports.TimeoutStatus = TimeoutStatus;
 exports.TokenGateway = TokenGateway;
 exports.TronChain = TronChain;
+exports.UNISWAP_QUOTE_HAIRCUT_BPS = UNISWAP_QUOTE_HAIRCUT_BPS;
 exports.USE_ETHERSCAN_CHAINS = USE_ETHERSCAN_CHAINS;
 exports.UnsupportedIntentQuotePairError = UnsupportedIntentQuotePairError;
 exports.UnsupportedIntentQuoteStrategyError = UnsupportedIntentQuoteStrategyError;
@@ -24208,6 +24346,7 @@ exports.UnsupportedLiquidityChainError = UnsupportedLiquidityChainError;
 exports.WrappedHyperFungibleTokenABI = WrappedHyperFungibleTokenABI;
 exports.__test = __test;
 exports.adjustDecimals = adjustDecimals;
+exports.applyUniswapQuoteHaircut = applyUniswapQuoteHaircut;
 exports.bytes20ToBytes32 = bytes20ToBytes32;
 exports.bytes32ToBytes20 = bytes32ToBytes20;
 exports.calculateAllowanceMappingLocation = calculateAllowanceMappingLocation;