@hyperbridge/simplex 0.16.5 → 0.16.6

package/dist/bin/simplex.js

@@ -318650,10 +318650,16 @@ var CANCEL_ORDER_MUTATION = `
 `;
 var OrderbookRequestError2 = class extends Error {
 };
+function graphqlEndpoint(url2) {
+  const trimmed = url2.trim();
+  if (trimmed.includes("?")) return trimmed;
+  const withoutTrailingSlash = trimmed.replace(/\/+$/, "");
+  return withoutTrailingSlash.endsWith("/graphql") ? withoutTrailingSlash : `${withoutTrailingSlash}/graphql`;
+}
 var OrderbookClient = class {
   constructor(url2, requestTimeoutMs, loggers = defaultLoggerContext()) {
-    this.url = url2;
     this.requestTimeoutMs = requestTimeoutMs;
+    this.url = graphqlEndpoint(url2);
     this.logger = loggers.get("orderbook");
   }
   /** The limits to validate against before posting, plus the books on offer. */
@@ -318751,7 +318757,9 @@ var OrderbookClient = class {
       clearTimeout(timer);
     }
     if (!response.ok) {
-      throw new OrderbookRequestError2(`Orderbook returned HTTP ${response.status} ${response.statusText}`);
+      throw new OrderbookRequestError2(
+        `Orderbook at ${this.url} returned HTTP ${response.status} ${response.statusText}`
+      );
     }
     const body = await response.json().catch((err) => {
       throw new OrderbookRequestError2(`Orderbook returned a body that is not JSON: ${describe(err)}`);
@@ -318870,7 +318878,7 @@ var HEARTBEAT_TYPES = {
 var LimitOrderValidationError = class extends Error {
 };
 var LimitOrderService = class {
-  constructor(store, client, contractService, configService, assetRegistry, signer, defaultTtlSecs, delegationService, loggers = defaultLoggerContext(), startingNonce = initialOrderNonce) {
+  constructor(store, client, contractService, configService, assetRegistry, signer, defaultTtlSecs, delegationService, loggers = defaultLoggerContext(), startingNonce = initialOrderNonce, vaultBalances) {
     this.store = store;
     this.client = client;
     this.contractService = contractService;
@@ -318880,6 +318888,7 @@ var LimitOrderService = class {
     this.defaultTtlSecs = defaultTtlSecs;
     this.delegationService = delegationService;
     this.startingNonce = startingNonce;
+    this.vaultBalances = vaultBalances;
     this.logger = loggers.get("limit-orders");
   }
   /**
@@ -319015,6 +319024,16 @@ var LimitOrderService = class {
       throw err;
     }
   }
+  /**
+   * The pairs an order can be written against, and the smallest payout each token may carry.
+   *
+   * The orderbook lists the books; `resolveBook` refuses a request naming anything else, so the
+   * operator is offered exactly these and no combination of symbols they could not post.
+   */
+  async books() {
+    const limits = await this.limits();
+    return { books: limits.books, minOrderSizes: limits.serverInfo.minOrderSizes };
+  }
   /**
    * Reads `serverInfo` and `books`, reusing the last read for {@link LIMITS_TTL_MS}.
    *
@@ -319122,28 +319141,61 @@ var LimitOrderService = class {
    * balance on the fill chain, so the operator hears it while they are creating
    * the order.
    *
+   * A fill pays out of the wallet and then withdraws any shortfall from the
+   * configured ERC-4626 vaults in the same batch, so what those vaults hold of
+   * the payout token backs the order too and is counted here. Without it an
+   * operator who sweeps inventory into a vault is refused orders their filler
+   * would have filled.
+   *
    * Each order is checked against the whole balance, not against what is left of
    * it after the others. One balance backs every order resting on it — that is
    * what quoting both sides of a book is — and the orderbook says as much: it
    * advertises each entry at `min(quoted, balance)` rather than dividing the
    * balance between them. Whichever order fills first draws the inventory down,
    * and the rest are cut to what is left. Netting them here would refuse the
-   * second side of every book.
+   * second side of every book. Vault positions are counted the same way: the
+   * whole position, not what is left after reservations for fills in flight.
    */
   async assertWalletCanPay(symbol3, chain2, payout) {
     const token = this.assetRegistry.getAddress(symbol3, chain2);
     if (!token) return;
     const decimals = await this.decimalsFor(symbol3, token, chain2);
-    const balance = toScaled(
+    const wallet = toScaled(
       await this.contractService.getTokenBalance(chain2, token, this.signer.address),
       decimals
     );
-    if (balance < payout) {
+    const vaults = await this.vaultHoldings(token, chain2);
+    if (wallet + vaults < payout) {
+      const held = vaults > 0n ? `${toHuman(wallet)} in the wallet and ${toHuman(vaults)} in vaults` : toHuman(wallet);
       throw new LimitOrderValidationError(
-        `The wallet holds ${toHuman(balance)} ${symbol3} on ${chain2}, which cannot pay out ${toHuman(payout)}`
+        `The wallet holds ${held} ${symbol3} on ${chain2}, which cannot pay out ${toHuman(payout)}`
       );
     }
   }
+  /**
+   * What the configured vaults hold of `token` on `chain`, in scaled units.
+   *
+   * Zero when no vault is configured. A snapshot that cannot be read is also
+   * zero: the wallet alone then has to cover the order, which refuses one the
+   * filler might have managed rather than accepting one it could not.
+   */
+  async vaultHoldings(token, chain2) {
+    if (!this.vaultBalances) return 0n;
+    let positions;
+    try {
+      positions = await this.vaultBalances.getBalanceSnapshot(chain2);
+    } catch (err) {
+      this.logger.warn({ chain: chain2, token, err }, "Could not read vault balances; backing the order on the wallet alone");
+      return 0n;
+    }
+    const wanted = token.toLowerCase();
+    let total = 0n;
+    for (const position of positions) {
+      if (position.chain !== chain2 || position.asset.toLowerCase() !== wanted) continue;
+      total += toScaled(position.positionAssets, position.decimals);
+    }
+    return total;
+  }
   /**
    * Works a limit order down by what a fill delivered, and puts the rest back on
    * the orderbook.
@@ -321732,6 +321784,11 @@ var UiServer = class {
       if (method === "POST") return this.handleLimitOrderCreate(req, res);
       return sendJson(res, 405, { error: "Method not allowed" });
     }
+    if (path2 === "/api/orderbook/books") {
+      if (this.mode !== "operator") return sendJson(res, 409, { error: "Filler is not running" });
+      if (method !== "GET") return sendJson(res, 405, { error: "Method not allowed" });
+      return this.handleLimitOrders(res, () => this.operator.limitOrders.books());
+    }
     const limitOrderMatch = path2.match(/^\/api\/limit-orders\/([\w-]+)$/);
     if (limitOrderMatch) {
       if (this.mode !== "operator") return sendJson(res, 409, { error: "Filler is not running" });
@@ -364615,7 +364672,10 @@ async function bootFiller(config5, options) {
     runtimeSigner,
     config5.orderbook.defaultTtlSecs ?? DEFAULT_LIMIT_ORDER_TTL_SECONDS,
     new DelegationService(chainClientManager, configService, runtimeSigner),
-    options.loggers
+    options.loggers,
+    initialOrderNonce,
+    // A fill withdraws a payout shortfall from the vaults, so what they hold backs an order too.
+    vaultVenue
   );
   intentFiller.setLimitOrderService(limitOrderService);
   const lifecycle = new LimitOrderLifecycle(
@@ -365702,6 +365762,10 @@ var LimitOrderController = class {
     ]);
     return { order, fills, bids };
   }
+  /** The pairs the orderbook lists, and the smallest payout each token may carry. */
+  books() {
+    return this.service.books();
+  }
   /** Creates the order, posts it, and reports what the orderbook made of it. */
   async create(request3) {
     const posted = await this.service.create(request3);