@hyperbridge/sdk 2.8.16 → 2.8.18

package/dist/node/index.cjs

@@ -18788,20 +18788,27 @@ var ROUTE_LIQUIDITY_QUERY = `
 query RouteLiquidity($route: RouteInput!) {
   books { id base quote }
   routeLiquidity(route: $route) {
-    route bestRate depthIn depthOut availableLiquidity maxFillableIn orderCount solverCount
+    route bestRate slippageBps depthIn depthOut availableLiquidity maxFillableIn orderCount solverCount
   }
 }`;
 var QUOTE_QUERY = `
 query Quote($route: RouteInput!, $amountIn: BigInt!) {
   quote(route: $route, amountIn: $amountIn) {
-    route side amountIn amountOut rate fillable depth maxFillableIn
-    fills { orderRate amountOut advertisedSize }
+    route side amountIn slippageBps fillable maxFillableIn
+    fills { advertisedSize orderRate amountIn amountOut }
+  }
+}`;
+var QUOTE_PESSIMISTIC_QUERY = `
+query QuotePessimistic($route: RouteInput!, $amountIn: BigInt!) {
+  quotePessimistic(route: $route, amountIn: $amountIn) {
+    route side amountIn amountOut rate priceBucket slippageBps fillable maxFillableIn
   }
 }`;
 var ORDERBOOK_QUERIES = {
   topOfBook: TOP_OF_BOOK_QUERY,
   routeLiquidity: ROUTE_LIQUIDITY_QUERY,
-  quote: QUOTE_QUERY
+  quote: QUOTE_QUERY,
+  quotePessimistic: QUOTE_PESSIMISTIC_QUERY
 };
 var HyperFxOrderbook = class {
   client;
@@ -18830,8 +18837,9 @@ var HyperFxOrderbook = class {
     return {
       route: raw.route,
       book,
-      side: book.base === route.tokenIn ? "BID" : "ASK",
-      bestRate: raw.bestRate === null ? null : BigInt(raw.bestRate),
+      side: sameSymbol(book.base, route.tokenIn) ? "BID" : "ASK",
+      bestRate: optionalBigInt(raw.bestRate),
+      slippageBps: raw.slippageBps,
       depthIn: BigInt(raw.depthIn),
       depthOut: BigInt(raw.depthOut),
       availableLiquidity: BigInt(raw.availableLiquidity),
@@ -18840,7 +18848,10 @@ var HyperFxOrderbook = class {
       solverCount: raw.solverCount
     };
   }
-  /** The clearing price for `amountIn` (1e18 tokenIn) on a route, which may combine several solvers' orders. */
+  /**
+   * The optimistic quote for `amountIn` (1e18 tokenIn) on a route: the route's orders, best price
+   * first, each taking what it can at its own price. The fills' `amountOut`s sum to the output.
+   */
   async quote(route, amountIn) {
     const { quote: raw } = await this.request(QUOTE_QUERY, {
       route,
@@ -18850,18 +18861,39 @@ var HyperFxOrderbook = class {
       route: raw.route,
       side: raw.side,
       amountIn: BigInt(raw.amountIn),
-      amountOut: BigInt(raw.amountOut),
-      rate: raw.rate === null ? null : BigInt(raw.rate),
+      slippageBps: raw.slippageBps,
       fillable: raw.fillable,
-      depth: BigInt(raw.depth),
       maxFillableIn: BigInt(raw.maxFillableIn),
       fills: raw.fills.map((fill) => ({
+        advertisedSize: BigInt(fill.advertisedSize),
         orderRate: BigInt(fill.orderRate),
-        amountOut: BigInt(fill.amountOut),
-        advertisedSize: BigInt(fill.advertisedSize)
+        amountIn: BigInt(fill.amountIn),
+        amountOut: BigInt(fill.amountOut)
       }))
     };
   }
+  /**
+   * The pessimistic quote for `amountIn` (1e18 tokenIn) on a route: one price, from the first level
+   * deep enough to fill the whole trade by itself, at which every order in it fills; the route's
+   * worst price when no one level can but its levels together can.
+   */
+  async quotePessimistic(route, amountIn) {
+    const { quotePessimistic: raw } = await this.request(
+      QUOTE_PESSIMISTIC_QUERY,
+      { route, amountIn: amountIn.toString() }
+    );
+    return {
+      route: raw.route,
+      side: raw.side,
+      amountIn: BigInt(raw.amountIn),
+      amountOut: BigInt(raw.amountOut),
+      rate: optionalBigInt(raw.rate),
+      priceBucket: optionalBigInt(raw.priceBucket),
+      slippageBps: raw.slippageBps,
+      fillable: raw.fillable,
+      maxFillableIn: BigInt(raw.maxFillableIn)
+    };
+  }
   async request(query, variables) {
     try {
       return await this.client.request(query, variables);
@@ -18875,13 +18907,19 @@ function describeError(error) {
   if (graphqlErrors?.length) return graphqlErrors.map((e) => e.message).join("; ");
   return error instanceof Error ? error.message : String(error);
 }
+function sameSymbol(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
 function findBook(books, tokenA, tokenB) {
   const book = books.find(
-    (b) => b.base === tokenA && b.quote === tokenB || b.base === tokenB && b.quote === tokenA
+    (b) => sameSymbol(b.base, tokenA) && sameSymbol(b.quote, tokenB) || sameSymbol(b.base, tokenB) && sameSymbol(b.quote, tokenA)
   );
   if (!book) throw new OrderbookRequestError(`no book trades ${tokenA} for ${tokenB}`);
   return book;
 }
+function optionalBigInt(value) {
+  return value === null ? null : BigInt(value);
+}
 function parseRate(raw) {
   return {
     side: raw.side,
@@ -18923,18 +18961,6 @@ var OrderbookQuoteNotConvergedError = class extends Error {
   rounds;
   lastAmountIn;
 };
-var InsufficientOrderbookLiquidityError = class extends Error {
-  constructor(route, maxFillableIn) {
-    super(
-      `The HyperFX orderbook cannot fill ${route.tokenIn} -> ${route.tokenOut} on ${route.sourceChain} -> ${route.destinationChain}; max fillable input is ${maxFillableIn} raw units`
-    );
-    this.route = route;
-    this.maxFillableIn = maxFillableIn;
-    this.name = "InsufficientOrderbookLiquidityError";
-  }
-  route;
-  maxFillableIn;
-};
 
 // src/protocols/intents/orderbook/market.ts
 var MAX_EXACT_OUTPUT_ROUNDS = 16;
@@ -18946,26 +18972,67 @@ var OrderbookMarket = class {
   configService;
   orderbook;
   async quoteIntent(params, sourceChain, destinationChain) {
+    const orderbook = this.orderbook();
+    if (!params.optimistic) {
+      const { quote: quote2, tokenIn: tokenIn2, tokenOut: tokenOut2 } = await this.priceIntent(
+        params,
+        sourceChain,
+        destinationChain,
+        (route, amountIn) => orderbook.quotePessimistic(route, amountIn),
+        levelQuoteTotals
+      );
+      return {
+        route: quote2.route,
+        side: quote2.side,
+        amountIn: fromOrderbookAmount(quote2.amountIn, tokenIn2.decimals),
+        amountOut: fromOrderbookAmount(quote2.amountOut, tokenOut2.decimals),
+        rate: quote2.rate,
+        priceBucket: quote2.priceBucket,
+        slippageBps: quote2.slippageBps,
+        fillable: quote2.fillable,
+        maxFillableIn: fromOrderbookAmount(quote2.maxFillableIn, tokenIn2.decimals)
+      };
+    }
+    const { quote, tokenIn, tokenOut } = await this.priceIntent(
+      params,
+      sourceChain,
+      destinationChain,
+      (route, amountIn) => orderbook.quote(route, amountIn),
+      swapQuoteTotals
+    );
+    return {
+      route: quote.route,
+      side: quote.side,
+      amountIn: fromOrderbookAmount(quote.amountIn, tokenIn.decimals),
+      slippageBps: quote.slippageBps,
+      fillable: quote.fillable,
+      maxFillableIn: fromOrderbookAmount(quote.maxFillableIn, tokenIn.decimals),
+      legs: quote.fills.map((fill) => ({
+        advertisedSize: fromOrderbookAmount(fill.advertisedSize, tokenOut.decimals),
+        orderRate: fill.orderRate,
+        amountIn: fromOrderbookAmount(fill.amountIn, tokenIn.decimals),
+        amountOut: fromOrderbookAmount(fill.amountOut, tokenOut.decimals)
+      }))
+    };
+  }
+  /**
+   * The orderbook's quote for an exact input, or for the input found to deliver
+   * an exact output, with the assets it trades. A route that cannot fill the
+   * trade answers with an unfillable quote rather than an error.
+   */
+  async priceIntent(params, sourceChain, destinationChain, price, totals) {
     validateQuoteParams(params);
     const tokenIn = this.assetByAddress(sourceChain, params.tokenIn);
     const tokenOut = this.assetByAddress(destinationChain, params.tokenOut);
     const route = toRoute(tokenIn, tokenOut);
     if (params.amountIn !== void 0) {
-      const quote2 = await this.orderbook().quote(route, toOrderbookAmount(params.amountIn, tokenIn.decimals));
-      const amountOut2 = quote2.fillable ? fromOrderbookAmount(quote2.amountOut, tokenOut.decimals) : 0n;
-      if (amountOut2 === 0n) throw this.insufficient(route, quote2.maxFillableIn, tokenIn);
-      return buildQuote("EXACT_INPUT", params.amountIn, amountOut2, quote2, tokenIn, tokenOut);
+      const quote2 = await price(route, toOrderbookAmount(params.amountIn, tokenIn.decimals));
+      totals(quote2);
+      return { quote: quote2, tokenIn, tokenOut };
     }
-    const amountOut = params.amountOut;
-    const quote = await this.quoteExactOutput(route, toOrderbookAmount(amountOut, tokenOut.decimals), tokenIn);
-    return buildQuote(
-      "EXACT_OUTPUT",
-      fromOrderbookAmount(quote.amountIn, tokenIn.decimals),
-      amountOut,
-      quote,
-      tokenIn,
-      tokenOut
-    );
+    const targetOut = toOrderbookAmount(params.amountOut, tokenOut.decimals);
+    const quote = await this.quoteExactOutput(route, targetOut, tokenIn, price, totals);
+    return { quote, tokenIn, tokenOut };
   }
   async availableLiquidity(params, sourceChain, destinationChain) {
     const tokenIn = this.assetByAddress(sourceChain, params.tokenIn);
@@ -19018,22 +19085,29 @@ var OrderbookMarket = class {
   }
   /**
    * The orderbook only quotes an input amount, so an output is priced by
-   * guessing the input from the best rate and raising it at each clearing
-   * price until the quote delivers `targetOut`.
+   * guessing the input from the best rate, then keeping the part of each quote
+   * filled better than its worst rate and re-pricing the rest of `targetOut` at
+   * the input-to-output ratio that part filled at, until a quote delivers it.
+   * That ratio is the orderbook's own, with the protocol fee already taken off.
+   *
+   * An output the route cannot deliver is answered by quoting an input past its
+   * `maxFillableIn`, which the orderbook serves as unfillable: the smallest such
+   * input guessed from the best rate, or one raw unit when no order serves it.
    */
-  async quoteExactOutput(route, targetOut, tokenIn) {
-    const orderbook = this.orderbook();
-    const liquidity = await orderbook.routeLiquidity(route);
-    if (liquidity.bestRate === null) throw this.insufficient(route, 0n, tokenIn);
+  async quoteExactOutput(route, targetOut, tokenIn, price, totals) {
+    const liquidity = await this.orderbook().routeLiquidity(route);
     const inputUnit = toOrderbookAmount(1n, tokenIn.decimals);
-    let amountIn = roundUpTo(requiredInput(liquidity.side, targetOut, liquidity.bestRate), inputUnit);
+    let amountIn = liquidity.bestRate === null ? inputUnit : roundUpTo(requiredInput(liquidity.side, targetOut, liquidity.bestRate), inputUnit);
     let lastAmountIn = amountIn;
     for (let round = 0; round < MAX_EXACT_OUTPUT_ROUNDS; round++) {
-      if (amountIn > liquidity.maxFillableIn) throw this.insufficient(route, liquidity.maxFillableIn, tokenIn);
-      const quote = await orderbook.quote(route, amountIn);
-      if (quote.fillable && quote.amountOut >= targetOut) return quote;
+      const served = await price(route, amountIn);
+      const quote = totals(served);
+      if (quote.fillable && quote.amountOut >= targetOut) return served;
+      if (!quote.fillable && amountIn > liquidity.maxFillableIn) return served;
       lastAmountIn = amountIn;
-      const next = quote.rate === null ? amountIn : roundUpTo(requiredInput(quote.side, targetOut, quote.rate), inputUnit);
+      const betterIn = quote.amountIn - quote.worstIn;
+      const betterOut = quote.amountOut - quote.worstOut;
+      const next = quote.fillable && quote.worstOut > 0n ? betterIn + roundUpTo(divCeil((targetOut - betterOut) * quote.worstIn, quote.worstOut), inputUnit) : amountIn;
       amountIn = next > amountIn ? next : amountIn + inputUnit;
     }
     throw new OrderbookQuoteNotConvergedError(
@@ -19042,9 +19116,6 @@ var OrderbookMarket = class {
       fromOrderbookAmount(lastAmountIn, tokenIn.decimals)
     );
   }
-  insufficient(route, maxFillableIn, tokenIn) {
-    return new InsufficientOrderbookLiquidityError(route, fromOrderbookAmount(maxFillableIn, tokenIn.decimals));
-  }
   assetByAddress(chain, address) {
     const resolvedChain = resolveChain(chain);
     return withDecimals(
@@ -19089,24 +19160,32 @@ function toRoute(tokenIn, tokenOut) {
 function requiredInput(side, amountOut, rate) {
   return side === "BID" ? divCeil(amountOut * ORDERBOOK_SCALE, rate) : divCeil(amountOut * rate, ORDERBOOK_SCALE);
 }
-function buildQuote(tradeType, amountIn, amountOut, quote, tokenIn, tokenOut) {
-  if (quote.rate === null) throw new OrderbookRequestError("the orderbook served a fillable quote with no rate");
-  const [base3, quoteToken] = quote.side === "BID" ? [tokenIn, tokenOut] : [tokenOut, tokenIn];
+function swapQuoteTotals(quote) {
+  const worstFill = quote.fills.at(-1);
+  if (quote.fillable && !worstFill)
+    throw new OrderbookRequestError("the orderbook served a fillable quote with no fills");
   return {
-    tradeType,
-    amountIn,
-    amountOut,
-    quoteMetadata: {
-      sourceChain: tokenIn.chain,
-      destinationChain: tokenOut.chain,
-      route: quote.route,
-      side: quote.side,
-      baseTokenSymbol: base3.symbol,
-      quoteTokenSymbol: quoteToken.symbol,
-      rate: format(quote.rate),
-      maxFillableIn: fromOrderbookAmount(quote.maxFillableIn, tokenIn.decimals),
-      orderCount: quote.fills.length
-    }
+    side: quote.side,
+    amountIn: quote.amountIn,
+    amountOut: quote.fills.reduce((total, fill) => total + fill.amountOut, 0n),
+    fillable: quote.fillable,
+    maxFillableIn: quote.maxFillableIn,
+    worstIn: worstFill?.amountIn ?? 0n,
+    worstOut: worstFill?.amountOut ?? 0n
+  };
+}
+function levelQuoteTotals(quote) {
+  if (quote.fillable && quote.rate === null) {
+    throw new OrderbookRequestError("the orderbook served a fillable quote with no rate");
+  }
+  return {
+    side: quote.side,
+    amountIn: quote.amountIn,
+    amountOut: quote.amountOut,
+    fillable: quote.fillable,
+    maxFillableIn: quote.maxFillableIn,
+    worstIn: quote.amountIn,
+    worstOut: quote.amountOut
   };
 }
 function toOrderbookAmount(amount, decimals) {
@@ -19270,22 +19349,6 @@ var IntentGateway = class _IntentGateway {
     this.orderbook = typeof orderbook === "string" ? new HyperFxOrderbook(orderbook) : orderbook;
     return this;
   }
-  /**
-   * Quotes an intent between this gateway's source and destination chains from
-   * the HyperFX orderbook. Provide exactly one of `amountIn` or `amountOut`, in
-   * raw token units.
-   *
-   * An exact-input quote is the orderbook's clearing price for `amountIn`,
-   * which may combine several solvers' orders. An exact-output quote finds the
-   * smallest input whose clearing price delivers `amountOut`. A cross-chain
-   * route only counts orders whose solvers accept the source chain.
-   *
-   * The orderbook's rates already carry the gateway protocol fee, so the
-   * returned amounts can be placed as the order's inputs and outputs directly.
-   *
-   * @throws {InsufficientOrderbookLiquidityError} When the route cannot fill the amount.
-   * @throws {OrderbookRequestError} When the orderbook is unreachable or trades no book for the pair.
-   */
   async quoteIntent(params) {
     return this.market.quoteIntent(params, this.source.config.stateMachineId, this.dest.config.stateMachineId);
   }
@@ -24603,7 +24666,6 @@ exports.HyperFungibleToken = HyperFungibleToken;
 exports.HyperFungibleTokenABI = HyperFungibleTokenABI;
 exports.HyperFxOrderbook = HyperFxOrderbook;
 exports.INCLUSION_TIMEOUT_MS = INCLUSION_TIMEOUT_MS;
-exports.InsufficientOrderbookLiquidityError = InsufficientOrderbookLiquidityError;
 exports.IntentGateway = IntentGateway;
 exports.IntentGatewayABI = ABI3;
 exports.IntentOrderStatus = IntentOrderStatus;