@hyperbridge/simplex 0.16.11 → 0.16.12

package/dist/index.cjs

@@ -1165,6 +1165,7 @@ var import_viem2 = require("viem");
 var import_sdk2 = require("@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");
@@ -1587,6 +1588,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);
@@ -1690,6 +1698,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 (!(0, import_viem2.isAddress)(user)) {
@@ -12861,6 +12875,7 @@ var CacheService = class {
       matchedLimitOrders: {},
       bidPlans: {},
       partialFills: {},
+      feeChecksWaived: {},
       feeTokens: {},
       tokenDecimals: {},
       solverSelection: {}
@@ -12900,6 +12915,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 {
@@ -13212,6 +13231,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];
@@ -18501,7 +18538,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");
@@ -18524,7 +18564,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"}`);
     }
   }
@@ -21679,6 +21719,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) => {
@@ -21688,7 +21745,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) {
@@ -21713,6 +21773,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.
    *
@@ -21726,6 +21803,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((0, import_sdk14.getChainId)(order.destination));
     if (!chainQueue) {
@@ -22297,11 +22383,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;
@@ -22317,6 +22405,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];
@@ -22560,17 +22657,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: (0, import_viem29.formatUnits)(order.fees, feeTokenDecimals),
-                fillGas: (0, import_viem29.formatUnits)(totalCostInSourceFeeToken, feeTokenDecimals),
-                relayerFee: (0, import_viem29.formatUnits)(relayerFeeInSourceFeeToken, feeTokenDecimals),
-                executionCost: (0, import_viem29.formatUnits)(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: (0, import_viem29.formatUnits)(order.fees, feeTokenDecimals),
+                  fillGas: (0, import_viem29.formatUnits)(totalCostInSourceFeeToken, feeTokenDecimals),
+                  relayerFee: (0, import_viem29.formatUnits)(relayerFeeInSourceFeeToken, feeTokenDecimals),
+                  executionCost: (0, import_viem29.formatUnits)(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(
@@ -22604,7 +22705,8 @@ var FXFiller = class _FXFiller {
               realizedSpreadProfit: (0, import_viem29.formatUnits)(realizedSpreadProfit, feeTokenDecimals),
               payoutSurplusUsd: payoutSurplusUsd.toString(),
               totalProfit,
-              profitable: totalProfit > 0
+              profitable: totalProfit > 0,
+              feeCheckWaived: !partialFill && order.fees < executionCost
             },
             "FX swap profitability evaluation"
           );
@@ -22636,6 +22738,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 }
         ]);
@@ -23877,6 +23980,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,