@hyperbridge/simplex 0.16.11 → 0.16.12

package/dist/index.d.cts

@@ -158,6 +158,11 @@ interface FillerConfig {
      * See `bidValiditySeconds` in filler-toml for why this bound matters.
      */
     bidValiditySeconds?: number;
+    /**
+     * Order size in USD below which `order.fees` must cover the execution cost.
+     * Defaults to 20. See `minOrderSizeUsd` in filler-toml.
+     */
+    minOrderSizeUsd?: number;
     /**
      * Overfill protection knobs. If omitted, defaults are used
      * (maxOverfillBps=500, maxConsecutiveClamps=3).
@@ -343,6 +348,11 @@ declare class FillerConfigService {
      * Hyperbridge-side retraction does not reach the destination chain.
      */
     getBidValiditySeconds(): number;
+    /**
+     * The order size, in USD, below which `order.fees` must cover the execution cost.
+     * Defaults to 20. An order at or above it is filled whatever fees it carries.
+     */
+    getMinOrderSizeUsd(): number;
     /** Ceiling bps above user-requested output. Default 500 (5%). */
     getMaxOverfillBps(): bigint;
     /** Consecutive clamped evaluations before the strategy halts. Default 3. */
@@ -1822,6 +1832,16 @@ interface FillerTomlConfig {
          * Configured in seconds but written on-chain in blocks, converted per destination chain.
          */
         bidValiditySeconds?: number;
+        /**
+         * The order size, in USD, below which `order.fees` must cover the execution cost
+         * (fill gas plus, cross-chain, the relayer fee). Defaults to 20.
+         *
+         * An order worth at least this much is filled whatever fees it carries: the margin
+         * in the limit order that prices it pays for the gas. On a smaller order that
+         * margin is too thin to, so the fees have to. Set to 0 to never check fees. An
+         * order nothing can put a dollar figure on is treated as below it.
+         */
+        minOrderSizeUsd?: number;
         /**
          * Remote access: an outbound SSH tunnel to a rendezvous relay so a phone's
          * SSH client can reach the local web UI. Off unless `enabled = true`; the
@@ -2113,6 +2133,17 @@ declare class CacheService {
     isPartialFill(orderId: string): boolean;
     setPartialFill(orderId: string, partial: boolean): void;
     clearPartialFill(orderId: string): void;
+    /**
+     * Whether the strategy's completed evaluation let a bid through without holding
+     * `order.fees` to the execution cost, because the order is at or above the
+     * operator's minimum size.
+     *
+     * Written and cleared the way {@link isPartialFill} is, for the same reason: the
+     * caller exempts such an order from its profit floor.
+     */
+    isFeeCheckWaived(orderId: string): boolean;
+    setFeeCheckWaived(orderId: string, waived: boolean): void;
+    clearFeeCheckWaived(orderId: string): void;
     getFeeTokenWithDecimals(chain: string): {
         address: HexString;
         decimals: number;
@@ -3320,6 +3351,13 @@ declare class IntentFiller {
     private verifyOrderOnSource;
     private handleNewOrder;
     private evaluateOrder;
+    /**
+     * The destination chain's latest block number, the clock `order.deadline` is read on.
+     *
+     * Null when the read fails. That is not an answer about the order, so evaluation goes
+     * on: the gas estimate simulates the same deadline check and refuses an expired order.
+     */
+    private destinationHead;
     /**
      * Whether the strategy's evaluation concluded in a deliberate partial fill.
      *
@@ -3330,6 +3368,12 @@ declare class IntentFiller {
      * and filled them.
      */
     private fillsPartially;
+    /**
+     * Whether the strategy's evaluation let a bid through without the fee check, because
+     * the order is at or above the operator's minimum size. Read from a flag the strategy
+     * sets only once it has an answer, as {@link fillsPartially} is.
+     */
+    private feeCheckWaived;
     private executeOrder;
     private handleOrderFilledOnChain;
     /**
@@ -3521,7 +3565,8 @@ declare class FXFiller implements FillerStrategy {
      * - Treat a payout below the ask as a partial fill, which only orders
      *   without output calldata and without an earlier partial fill allow.
      * - Cap each payout by the filler's balance plus funding-venue withdrawals,
-     *   then gate it on fees (full fills) and the same-asset spread.
+     *   then gate it on fees (full fills of orders below `minOrderSizeUsd`) and the
+     *   same-asset spread.
      * - Cache the resulting bids for later use in `executeOrder`.
      */
     calculateProfitability(order: Order): Promise<number>;

package/dist/index.d.ts

@@ -158,6 +158,11 @@ interface FillerConfig {
      * See `bidValiditySeconds` in filler-toml for why this bound matters.
      */
     bidValiditySeconds?: number;
+    /**
+     * Order size in USD below which `order.fees` must cover the execution cost.
+     * Defaults to 20. See `minOrderSizeUsd` in filler-toml.
+     */
+    minOrderSizeUsd?: number;
     /**
      * Overfill protection knobs. If omitted, defaults are used
      * (maxOverfillBps=500, maxConsecutiveClamps=3).
@@ -343,6 +348,11 @@ declare class FillerConfigService {
      * Hyperbridge-side retraction does not reach the destination chain.
      */
     getBidValiditySeconds(): number;
+    /**
+     * The order size, in USD, below which `order.fees` must cover the execution cost.
+     * Defaults to 20. An order at or above it is filled whatever fees it carries.
+     */
+    getMinOrderSizeUsd(): number;
     /** Ceiling bps above user-requested output. Default 500 (5%). */
     getMaxOverfillBps(): bigint;
     /** Consecutive clamped evaluations before the strategy halts. Default 3. */
@@ -1822,6 +1832,16 @@ interface FillerTomlConfig {
          * Configured in seconds but written on-chain in blocks, converted per destination chain.
          */
         bidValiditySeconds?: number;
+        /**
+         * The order size, in USD, below which `order.fees` must cover the execution cost
+         * (fill gas plus, cross-chain, the relayer fee). Defaults to 20.
+         *
+         * An order worth at least this much is filled whatever fees it carries: the margin
+         * in the limit order that prices it pays for the gas. On a smaller order that
+         * margin is too thin to, so the fees have to. Set to 0 to never check fees. An
+         * order nothing can put a dollar figure on is treated as below it.
+         */
+        minOrderSizeUsd?: number;
         /**
          * Remote access: an outbound SSH tunnel to a rendezvous relay so a phone's
          * SSH client can reach the local web UI. Off unless `enabled = true`; the
@@ -2113,6 +2133,17 @@ declare class CacheService {
     isPartialFill(orderId: string): boolean;
     setPartialFill(orderId: string, partial: boolean): void;
     clearPartialFill(orderId: string): void;
+    /**
+     * Whether the strategy's completed evaluation let a bid through without holding
+     * `order.fees` to the execution cost, because the order is at or above the
+     * operator's minimum size.
+     *
+     * Written and cleared the way {@link isPartialFill} is, for the same reason: the
+     * caller exempts such an order from its profit floor.
+     */
+    isFeeCheckWaived(orderId: string): boolean;
+    setFeeCheckWaived(orderId: string, waived: boolean): void;
+    clearFeeCheckWaived(orderId: string): void;
     getFeeTokenWithDecimals(chain: string): {
         address: HexString;
         decimals: number;
@@ -3320,6 +3351,13 @@ declare class IntentFiller {
     private verifyOrderOnSource;
     private handleNewOrder;
     private evaluateOrder;
+    /**
+     * The destination chain's latest block number, the clock `order.deadline` is read on.
+     *
+     * Null when the read fails. That is not an answer about the order, so evaluation goes
+     * on: the gas estimate simulates the same deadline check and refuses an expired order.
+     */
+    private destinationHead;
     /**
      * Whether the strategy's evaluation concluded in a deliberate partial fill.
      *
@@ -3330,6 +3368,12 @@ declare class IntentFiller {
      * and filled them.
      */
     private fillsPartially;
+    /**
+     * Whether the strategy's evaluation let a bid through without the fee check, because
+     * the order is at or above the operator's minimum size. Read from a flag the strategy
+     * sets only once it has an answer, as {@link fillsPartially} is.
+     */
+    private feeCheckWaived;
     private executeOrder;
     private handleOrderFilledOnChain;
     /**
@@ -3521,7 +3565,8 @@ declare class FXFiller implements FillerStrategy {
      * - Treat a payout below the ask as a partial fill, which only orders
      *   without output calldata and without an earlier partial fill allow.
      * - Cap each payout by the filler's balance plus funding-venue withdrawals,
-     *   then gate it on fees (full fills) and the same-asset spread.
+     *   then gate it on fees (full fills of orders below `minOrderSizeUsd`) and the
+     *   same-asset spread.
      * - Cache the resulting bids for later use in `executeOrder`.
      */
     calculateProfitability(order: Order): Promise<number>;

package/dist/index.js

@@ -1103,6 +1103,7 @@ import { isAddress as isAddress2 } from "viem";
 import { ChainConfigService, bytes32ToBytes20 } from "@hyperbridge/sdk";
 var DEFAULT_BLOCK_SCAN_INTERVAL_SECONDS = 3;
 var MIN_BLOCK_SCAN_INTERVAL_SECONDS = 0.1;
+var DEFAULT_MIN_ORDER_SIZE_USD = 20;
 function validateRpcUrls(rpcUrls) {
   if (rpcUrls.length === 0) {
     throw new Error("rpcUrls must contain at least one URL");
@@ -1525,6 +1526,13 @@ var FillerConfigService = class {
   getBidValiditySeconds() {
     return this.fillerConfig?.bidValiditySeconds ?? 300;
   }
+  /**
+   * The order size, in USD, below which `order.fees` must cover the execution cost.
+   * Defaults to 20. An order at or above it is filled whatever fees it carries.
+   */
+  getMinOrderSizeUsd() {
+    return this.fillerConfig?.minOrderSizeUsd ?? DEFAULT_MIN_ORDER_SIZE_USD;
+  }
   /** Ceiling bps above user-requested output. Default 500 (5%). */
   getMaxOverfillBps() {
     return BigInt(this.fillerConfig?.overfillProtection?.maxOverfillBps ?? 500);
@@ -1628,6 +1636,12 @@ function validateConfig(config, cliWatchOnly = false) {
       );
     }
   }
+  const minOrderSize = config.simplex.minOrderSizeUsd;
+  if (minOrderSize !== void 0) {
+    if (!Number.isFinite(minOrderSize) || minOrderSize < 0) {
+      throw new Error(`simplex.minOrderSizeUsd must be a number >= 0 (USD); got ${minOrderSize}`);
+    }
+  }
   if (config.allowlist) {
     for (const user of config.allowlist.users ?? []) {
       if (!isAddress2(user)) {
@@ -12806,6 +12820,7 @@ var CacheService = class {
       matchedLimitOrders: {},
       bidPlans: {},
       partialFills: {},
+      feeChecksWaived: {},
       feeTokens: {},
       tokenDecimals: {},
       solverSelection: {}
@@ -12845,6 +12860,10 @@ var CacheService = class {
     stalePartialIds.forEach((orderId) => {
       delete this.cacheData.partialFills[orderId];
     });
+    const staleWaivedIds = Object.entries(this.cacheData.feeChecksWaived).filter(([_, data]) => !this.isCacheValid(data.timestamp)).map(([orderId]) => orderId);
+    staleWaivedIds.forEach((orderId) => {
+      delete this.cacheData.feeChecksWaived[orderId];
+    });
   }
   getGasEstimate(orderId) {
     try {
@@ -13157,6 +13176,24 @@ var CacheService = class {
   clearPartialFill(orderId) {
     delete this.cacheData.partialFills[orderId];
   }
+  /**
+   * Whether the strategy's completed evaluation let a bid through without holding
+   * `order.fees` to the execution cost, because the order is at or above the
+   * operator's minimum size.
+   *
+   * Written and cleared the way {@link isPartialFill} is, for the same reason: the
+   * caller exempts such an order from its profit floor.
+   */
+  isFeeCheckWaived(orderId) {
+    const cache = this.cacheData.feeChecksWaived[orderId];
+    return cache !== void 0 && this.isCacheValid(cache.timestamp) && cache.waived;
+  }
+  setFeeCheckWaived(orderId, waived) {
+    this.cacheData.feeChecksWaived[orderId] = { waived, timestamp: Date.now() };
+  }
+  clearFeeCheckWaived(orderId) {
+    delete this.cacheData.feeChecksWaived[orderId];
+  }
   getFeeTokenWithDecimals(chain) {
     try {
       const cache = this.cacheData.feeTokens[chain];
@@ -18484,7 +18521,10 @@ var ContractInteractionService = class {
         order,
         prependCalls: void 0,
         maxPriorityFeePerGasBumpPercent: gasFeeBumpConfig?.maxPriorityFeePerGasBumpPercent,
-        maxFeePerGasBumpPercent: gasFeeBumpConfig?.maxFeePerGasBumpPercent
+        maxFeePerGasBumpPercent: gasFeeBumpConfig?.maxFeePerGasBumpPercent,
+        // No bid without the bundler's own figures: an op signed with the SDK's
+        // fixed fallback limits does not execute, so a failed estimate skips the order.
+        requireBundlerEstimate: true
       });
       this.logger.info({ orderId: order.id }, "Caching gas estimate");
       this.logger.info({ estimate }, "Estimate");
@@ -18507,7 +18547,7 @@ var ContractInteractionService = class {
         callGasLimit: estimate.callGasLimit
       };
     } catch (error) {
-      this.logger.error({ err: error }, "Error estimating gas, using generous fallback values");
+      this.logger.error({ err: error, orderId: order.id }, "Error estimating gas, not bidding on this order");
       throw new Error(`Failed to estimate gas: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
@@ -21675,6 +21715,23 @@ var IntentFiller = class {
       this.monitor.emit("orderSkipped", { orderId: order.id, reason: "watch-only" });
       return null;
     }
+    const destinationHead = await this.destinationHead(order);
+    if (destinationHead !== null && order.deadline <= destinationHead) {
+      this.logger.info(
+        {
+          orderId: order.id,
+          destChain: order.destination,
+          deadline: order.deadline.toString(),
+          head: destinationHead.toString()
+        },
+        "Skipping order: its deadline has passed on the destination chain"
+      );
+      this.monitor.emit("orderSkipped", {
+        orderId: order.id,
+        reason: "Order deadline has passed on the destination chain"
+      });
+      return null;
+    }
     const evalStartMs = Date.now();
     const eligibleStrategies = await Promise.all(
       this.strategies.map(async (strategy) => {
@@ -21684,7 +21741,10 @@ var IntentFiller = class {
       })
     );
     const fillsPartially = this.fillsPartially(order);
-    const validStrategies = eligibleStrategies.filter((s) => s !== null && (s.profitability > 0 || fillsPartially)).sort((a, b) => b.profitability - a.profitability);
+    const feeCheckWaived = this.feeCheckWaived(order);
+    const validStrategies = eligibleStrategies.filter(
+      (s) => s !== null && (s.profitability > 0 || fillsPartially || feeCheckWaived)
+    ).sort((a, b) => b.profitability - a.profitability);
     const evalDurationSec = (Date.now() - evalStartMs) / 1e3;
     this.monitor.emit("orderTiming", { orderId: order.id, phase: "evaluation", durationSec: evalDurationSec });
     if (validStrategies.length === 0) {
@@ -21709,6 +21769,23 @@ var IntentFiller = class {
     );
     return validStrategies[0];
   }
+  /**
+   * The destination chain's latest block number, the clock `order.deadline` is read on.
+   *
+   * Null when the read fails. That is not an answer about the order, so evaluation goes
+   * on: the gas estimate simulates the same deadline check and refuses an expired order.
+   */
+  async destinationHead(order) {
+    try {
+      return await this.chainClientManager.getPublicClient(order.destination).getBlockNumber();
+    } catch (err) {
+      this.logger.warn(
+        { orderId: order.id, destChain: order.destination, err },
+        "Could not read the destination head to check the order's deadline"
+      );
+      return null;
+    }
+  }
   /**
    * Whether the strategy's evaluation concluded in a deliberate partial fill.
    *
@@ -21722,6 +21799,15 @@ var IntentFiller = class {
     if (!order.id) return false;
     return this.contractService.cacheService.isPartialFill(order.id);
   }
+  /**
+   * Whether the strategy's evaluation let a bid through without the fee check, because
+   * the order is at or above the operator's minimum size. Read from a flag the strategy
+   * sets only once it has an answer, as {@link fillsPartially} is.
+   */
+  feeCheckWaived(order) {
+    if (!order.id) return false;
+    return this.contractService.cacheService.isFeeCheckWaived(order.id);
+  }
   executeOrder(order, bestStrategy, solverSelectionActive, inputUsdValue, profitUsd) {
     const chainQueue = this.chainQueues.get(getChainId3(order.destination));
     if (!chainQueue) {
@@ -22296,11 +22382,13 @@ var FXFiller = class _FXFiller {
    * - Treat a payout below the ask as a partial fill, which only orders
    *   without output calldata and without an earlier partial fill allow.
    * - Cap each payout by the filler's balance plus funding-venue withdrawals,
-   *   then gate it on fees (full fills) and the same-asset spread.
+   *   then gate it on fees (full fills of orders below `minOrderSizeUsd`) and the
+   *   same-asset spread.
    * - Cache the resulting bids for later use in `executeOrder`.
    */
   async calculateProfitability(order) {
     if (order.id) this.contractService.cacheService.clearPartialFill(order.id);
+    if (order.id) this.contractService.cacheService.clearFeeCheckWaived(order.id);
     if (this.halted) {
       this.logger.warn({ orderId: order.id }, "FXFiller halted \u2014 rejecting order");
       return 0;
@@ -22316,6 +22404,15 @@ var FXFiller = class _FXFiller {
       const plans = [];
       const plannedOn = /* @__PURE__ */ new Map();
       const spentOn = /* @__PURE__ */ new Map();
+      let atOrAboveMinSize;
+      const feeCheckWaived = async () => {
+        if (atOrAboveMinSize === void 0) {
+          const usd = await this.getOrderUsdValue(order);
+          atOrAboveMinSize = usd !== null && usd.inputUsd.gte(this.configService.getMinOrderSizeUsd());
+        }
+        return atOrAboveMinSize;
+      };
+      let feesWaived = false;
       for (let leg = 0; leg < order.inputs.length; leg++) {
         const input = order.inputs[leg];
         const output = order.output.assets[leg];
@@ -22559,17 +22656,21 @@ var FXFiller = class _FXFiller {
           const executionCost = totalCostInSourceFeeToken + relayerFeeInSourceFeeToken;
           const partialEdgeUsd = sameAssetEdgeUsd.plus(payoutSurplusUsd);
           if (!partialFill && order.fees < executionCost) {
-            this.logger.info(
-              {
-                orderId: order.id,
-                orderFees: formatUnits4(order.fees, feeTokenDecimals),
-                fillGas: formatUnits4(totalCostInSourceFeeToken, feeTokenDecimals),
-                relayerFee: formatUnits4(relayerFeeInSourceFeeToken, feeTokenDecimals),
-                executionCost: formatUnits4(executionCost, feeTokenDecimals)
-              },
-              "Skipping order: attached fees do not cover execution cost (fill gas + relayer fee)"
-            );
-            continue;
+            if (!await feeCheckWaived()) {
+              this.logger.info(
+                {
+                  orderId: order.id,
+                  orderFees: formatUnits4(order.fees, feeTokenDecimals),
+                  fillGas: formatUnits4(totalCostInSourceFeeToken, feeTokenDecimals),
+                  relayerFee: formatUnits4(relayerFeeInSourceFeeToken, feeTokenDecimals),
+                  executionCost: formatUnits4(executionCost, feeTokenDecimals),
+                  minOrderSizeUsd: this.configService.getMinOrderSizeUsd()
+                },
+                "Skipping order: attached fees do not cover execution cost (fill gas + relayer fee)"
+              );
+              continue;
+            }
+            feesWaived = true;
           }
           if (sameAsset && !sameAssetProfitable) {
             this.logger.info(
@@ -22603,7 +22704,8 @@ var FXFiller = class _FXFiller {
               realizedSpreadProfit: formatUnits4(realizedSpreadProfit, feeTokenDecimals),
               payoutSurplusUsd: payoutSurplusUsd.toString(),
               totalProfit,
-              profitable: totalProfit > 0
+              profitable: totalProfit > 0,
+              feeCheckWaived: !partialFill && order.fees < executionCost
             },
             "FX swap profitability evaluation"
           );
@@ -22635,6 +22737,7 @@ var FXFiller = class _FXFiller {
           plans[0].budget
         );
         this.contractService.cacheService.setPartialFill(order.id, plans[0].partialFill);
+        this.contractService.cacheService.setFeeCheckWaived(order.id, feesWaived);
         this.contractService.cacheService.setMatchedLimitOrder(order.id, [
           { limitOrderId: plans[0].limitOrderId, payout: plans[0].payout }
         ]);
@@ -23876,6 +23979,7 @@ async function bootFiller(config, options) {
     rebalancing: config.rebalancing,
     targetGasUnits: config.simplex.targetGasUnits,
     bidValiditySeconds: config.simplex.bidValiditySeconds,
+    minOrderSizeUsd: config.simplex.minOrderSizeUsd,
     blockScanIntervalSeconds: config.simplex.blockScanIntervalSeconds,
     gasFeeBump: config.simplex.gasFeeBump,
     overfillProtection: config.simplex.overfillProtection,