@hyperbridge/simplex 0.16.5 → 0.16.6

package/dist/index.d.cts

@@ -2733,9 +2733,10 @@ type CancelOrderResult = {
  * {@link OrderbookRequestError} because it could not get one.
  */
 declare class OrderbookClient {
-    private readonly url;
     private readonly requestTimeoutMs;
     private logger;
+    /** The configured endpoint, with `/graphql` if it was left off. */
+    private readonly url;
     constructor(url: string, requestTimeoutMs: number, loggers?: LoggerContext);
     /** The limits to validate against before posting, plus the books on offer. */
     limits(): Promise<OrderbookLimits>;
@@ -2844,6 +2845,13 @@ interface ReconcileReport {
  * orderbook's answer is then written back onto that row: an accepted order
  * carries its commitment, a rejected one carries the reason.
  */
+/**
+ * The configured ERC-4626 vaults' holdings, as `VaultFundingPlanner` reports them. A fill sources
+ * a payout shortfall from these, so they back a limit order as much as the wallet does.
+ */
+interface VaultHoldings {
+    getBalanceSnapshot(chain?: string): Promise<VaultBalancePosition[]>;
+}
 declare class LimitOrderService {
     private readonly store;
     private readonly client;
@@ -2855,12 +2863,16 @@ declare class LimitOrderService {
     private readonly delegationService?;
     /** Where a new order's nonce starts; tests pin it, production draws it at random. */
     private readonly startingNonce;
+    /** The configured ERC-4626 vaults, when the operator runs any. */
+    private readonly vaultBalances?;
     private logger;
     private cachedLimits?;
     private onEvent?;
     constructor(store: LimitOrderStore, client: OrderbookClient, contractService: ContractInteractionService, configService: FillerConfigService, assetRegistry: AssetRegistry, signer: Signer, defaultTtlSecs: number, delegationService?: DelegationService | undefined, loggers?: LoggerContext, 
     /** Where a new order's nonce starts; tests pin it, production draws it at random. */
-    startingNonce?: () => bigint);
+    startingNonce?: () => bigint, 
+    /** The configured ERC-4626 vaults, when the operator runs any. */
+    vaultBalances?: VaultHoldings | undefined);
     /**
      * Attaches the listener fill-driven changes are reported to. `Simplex` does
      * this after boot, the same way the filler is handed the service itself.
@@ -2896,6 +2908,16 @@ declare class LimitOrderService {
      */
     private withdraw;
     private signAndCancel;
+    /**
+     * 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.
+     */
+    books(): Promise<{
+        books: Book[];
+        minOrderSizes: TokenMinSize[];
+    }>;
     /**
      * Reads `serverInfo` and `books`, reusing the last read for {@link LIMITS_TTL_MS}.
      *
@@ -2915,15 +2937,30 @@ declare class LimitOrderService {
      * 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.
      */
     private assertWalletCanPay;
+    /**
+     * 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.
+     */
+    private vaultHoldings;
     /**
      * Works a limit order down by what a fill delivered, and puts the rest back on
      * the orderbook.
@@ -3794,6 +3831,11 @@ declare class LimitOrderController {
         fills: LimitOrderFill[];
         bids: StoredBid[];
     } | null>;
+    /** The pairs the orderbook lists, and the smallest payout each token may carry. */
+    books(): Promise<{
+        books: Book[];
+        minOrderSizes: TokenMinSize[];
+    }>;
     /** Creates the order, posts it, and reports what the orderbook made of it. */
     create(request: CreateLimitOrderRequest): Promise<PostedLimitOrder>;
     cancel(id: string): Promise<CancelledLimitOrder>;

package/dist/index.d.ts

@@ -2733,9 +2733,10 @@ type CancelOrderResult = {
  * {@link OrderbookRequestError} because it could not get one.
  */
 declare class OrderbookClient {
-    private readonly url;
     private readonly requestTimeoutMs;
     private logger;
+    /** The configured endpoint, with `/graphql` if it was left off. */
+    private readonly url;
     constructor(url: string, requestTimeoutMs: number, loggers?: LoggerContext);
     /** The limits to validate against before posting, plus the books on offer. */
     limits(): Promise<OrderbookLimits>;
@@ -2844,6 +2845,13 @@ interface ReconcileReport {
  * orderbook's answer is then written back onto that row: an accepted order
  * carries its commitment, a rejected one carries the reason.
  */
+/**
+ * The configured ERC-4626 vaults' holdings, as `VaultFundingPlanner` reports them. A fill sources
+ * a payout shortfall from these, so they back a limit order as much as the wallet does.
+ */
+interface VaultHoldings {
+    getBalanceSnapshot(chain?: string): Promise<VaultBalancePosition[]>;
+}
 declare class LimitOrderService {
     private readonly store;
     private readonly client;
@@ -2855,12 +2863,16 @@ declare class LimitOrderService {
     private readonly delegationService?;
     /** Where a new order's nonce starts; tests pin it, production draws it at random. */
     private readonly startingNonce;
+    /** The configured ERC-4626 vaults, when the operator runs any. */
+    private readonly vaultBalances?;
     private logger;
     private cachedLimits?;
     private onEvent?;
     constructor(store: LimitOrderStore, client: OrderbookClient, contractService: ContractInteractionService, configService: FillerConfigService, assetRegistry: AssetRegistry, signer: Signer, defaultTtlSecs: number, delegationService?: DelegationService | undefined, loggers?: LoggerContext, 
     /** Where a new order's nonce starts; tests pin it, production draws it at random. */
-    startingNonce?: () => bigint);
+    startingNonce?: () => bigint, 
+    /** The configured ERC-4626 vaults, when the operator runs any. */
+    vaultBalances?: VaultHoldings | undefined);
     /**
      * Attaches the listener fill-driven changes are reported to. `Simplex` does
      * this after boot, the same way the filler is handed the service itself.
@@ -2896,6 +2908,16 @@ declare class LimitOrderService {
      */
     private withdraw;
     private signAndCancel;
+    /**
+     * 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.
+     */
+    books(): Promise<{
+        books: Book[];
+        minOrderSizes: TokenMinSize[];
+    }>;
     /**
      * Reads `serverInfo` and `books`, reusing the last read for {@link LIMITS_TTL_MS}.
      *
@@ -2915,15 +2937,30 @@ declare class LimitOrderService {
      * 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.
      */
     private assertWalletCanPay;
+    /**
+     * 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.
+     */
+    private vaultHoldings;
     /**
      * Works a limit order down by what a fill delivered, and puts the rest back on
      * the orderbook.
@@ -3794,6 +3831,11 @@ declare class LimitOrderController {
         fills: LimitOrderFill[];
         bids: StoredBid[];
     } | null>;
+    /** The pairs the orderbook lists, and the smallest payout each token may carry. */
+    books(): Promise<{
+        books: Book[];
+        minOrderSizes: TokenMinSize[];
+    }>;
     /** Creates the order, posts it, and reports what the orderbook made of it. */
     create(request: CreateLimitOrderRequest): Promise<PostedLimitOrder>;
     cancel(id: string): Promise<CancelledLimitOrder>;

package/dist/index.js

@@ -2597,10 +2597,16 @@ var CANCEL_ORDER_MUTATION = `
 `;
 var OrderbookRequestError = class extends Error {
 };
+function graphqlEndpoint(url) {
+  const trimmed = url.trim();
+  if (trimmed.includes("?")) return trimmed;
+  const withoutTrailingSlash = trimmed.replace(/\/+$/, "");
+  return withoutTrailingSlash.endsWith("/graphql") ? withoutTrailingSlash : `${withoutTrailingSlash}/graphql`;
+}
 var OrderbookClient = class {
   constructor(url, requestTimeoutMs, loggers = defaultLoggerContext()) {
-    this.url = url;
     this.requestTimeoutMs = requestTimeoutMs;
+    this.url = graphqlEndpoint(url);
     this.logger = loggers.get("orderbook");
   }
   /** The limits to validate against before posting, plus the books on offer. */
@@ -2698,7 +2704,9 @@ var OrderbookClient = class {
       clearTimeout(timer);
     }
     if (!response.ok) {
-      throw new OrderbookRequestError(`Orderbook returned HTTP ${response.status} ${response.statusText}`);
+      throw new OrderbookRequestError(
+        `Orderbook at ${this.url} returned HTTP ${response.status} ${response.statusText}`
+      );
     }
     const body = await response.json().catch((err) => {
       throw new OrderbookRequestError(`Orderbook returned a body that is not JSON: ${describe(err)}`);
@@ -2813,7 +2821,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;
@@ -2823,6 +2831,7 @@ var LimitOrderService = class {
     this.defaultTtlSecs = defaultTtlSecs;
     this.delegationService = delegationService;
     this.startingNonce = startingNonce;
+    this.vaultBalances = vaultBalances;
     this.logger = loggers.get("limit-orders");
   }
   /**
@@ -2958,6 +2967,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}.
    *
@@ -3065,28 +3084,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(symbol, chain, payout) {
     const token = this.assetRegistry.getAddress(symbol, chain);
     if (!token) return;
     const decimals = await this.decimalsFor(symbol, token, chain);
-    const balance = toScaled(
+    const wallet = toScaled(
       await this.contractService.getTokenBalance(chain, token, this.signer.address),
       decimals
     );
-    if (balance < payout) {
+    const vaults = await this.vaultHoldings(token, chain);
+    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)} ${symbol} on ${chain}, which cannot pay out ${toHuman(payout)}`
+        `The wallet holds ${held} ${symbol} on ${chain}, 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, chain) {
+    if (!this.vaultBalances) return 0n;
+    let positions;
+    try {
+      positions = await this.vaultBalances.getBalanceSnapshot(chain);
+    } catch (err) {
+      this.logger.warn({ chain, 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 !== chain || 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.
@@ -23563,7 +23615,10 @@ async function bootFiller(config, options) {
     runtimeSigner,
     config.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(
@@ -24634,6 +24689,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(request) {
     const posted = await this.service.create(request);