@hyperbridge/sdk 1.6.6 → 1.6.7

package/dist/node/index.js

@@ -15901,6 +15901,7 @@ var BidManager = class {
   async selectBid(order, bids, sessionPrivateKey) {
     const commitment = order.id;
     const sessionKeyAddress = order.session;
+    console.log(`[BidManager] selectBid called for commitment=${commitment}, received ${bids.length} bid(s)`);
     const sessionKeyData = sessionPrivateKey ? { privateKey: sessionPrivateKey } : await this.ctx.sessionKeyStorage.getSessionKeyByAddress(sessionKeyAddress);
     if (!sessionKeyData) {
       throw new Error("SessionKey not found for commitment: " + commitment);
@@ -15912,6 +15913,7 @@ var BidManager = class {
       throw new Error("IntentsCoprocessor required");
     }
     const sortedBids = await this.validateAndSortBids(bids, order);
+    console.log(`[BidManager] ${sortedBids.length}/${bids.length} bid(s) passed validation and sorting`);
     if (sortedBids.length === 0) {
       throw new Error("No valid bids found");
     }
@@ -15928,8 +15930,11 @@ var BidManager = class {
     );
     let selectedBid = null;
     let sessionSignature = null;
-    for (const bidWithOptions of sortedBids) {
+    console.log(`[BidManager] Simulating ${sortedBids.length} sorted bid(s) to find a valid one`);
+    for (let idx = 0; idx < sortedBids.length; idx++) {
+      const bidWithOptions = sortedBids[idx];
       const solverAddress2 = bidWithOptions.bid.userOp.sender;
+      console.log(`[BidManager] Simulating bid ${idx + 1}/${sortedBids.length} from solver=${solverAddress2}`);
       const signature = await this.crypto.signSolverSelection(
         commitment,
         solverAddress2,
@@ -15937,6 +15942,7 @@ var BidManager = class {
         sessionKeyData.privateKey
       );
       if (!signature) {
+        console.warn(`[BidManager] Bid ${idx + 1}: failed to sign solver selection, skipping`);
         continue;
       }
       const selectOptions = {
@@ -15946,22 +15952,19 @@ var BidManager = class {
       };
       try {
         await this.simulate(bidWithOptions.bid, selectOptions, intentGatewayV2Address);
+        console.log(`[BidManager] Bid ${idx + 1} from solver=${solverAddress2}: simulation PASSED`);
         selectedBid = bidWithOptions;
         sessionSignature = signature;
         break;
       } catch (err) {
-        console.debug(
-          "Bid simulation failed",
-          JSON.stringify({
-            commitment,
-            solver: solverAddress2,
-            error: err instanceof Error ? err.message : String(err)
-          })
+        console.warn(
+          `[BidManager] Bid ${idx + 1} from solver=${solverAddress2}: simulation FAILED: ${err instanceof Error ? err.message : String(err)}`
         );
         continue;
       }
     }
     if (!selectedBid || !sessionSignature) {
+      console.error(`[BidManager] All ${sortedBids.length} bid(s) failed simulation for commitment=${commitment}`);
       throw new Error("No bids passed simulation");
     }
     const solverAddress = selectedBid.bid.userOp.sender;
@@ -16039,13 +16042,16 @@ var BidManager = class {
     const outputs = order.output.assets;
     const decodedBids = this.decodeBids(bids);
     if (outputs.length <= 1) {
+      console.log(`[BidManager] Using single-output sorting (1 output asset)`);
       return this.sortSingleOutput(decodedBids, outputs[0]);
     }
     const chainId = this.ctx.dest.config.stateMachineId;
     const allStables = outputs.every((o) => this.isStableToken(bytes32ToBytes20(o.token), chainId));
     if (allStables) {
+      console.log(`[BidManager] Using all-stables sorting (${outputs.length} stable output assets)`);
       return this.sortAllStables(decodedBids, outputs, chainId);
     }
+    console.log(`[BidManager] Using mixed-output sorting (${outputs.length} output assets, some non-stable)`);
     return this.sortMixedOutputs(decodedBids, outputs, chainId);
   }
   decodeBids(bids) {
@@ -16054,8 +16060,11 @@ var BidManager = class {
       const fillOptions = this.decodeBidFillOptions(bid);
       if (fillOptions) {
         result.push({ bid, options: fillOptions });
+      } else {
+        console.warn(`[BidManager] Failed to decode fillOptions from bid by solver=${bid.userOp.sender}`);
       }
     }
+    console.log(`[BidManager] Decoded ${result.length}/${bids.length} bid(s) successfully`);
     return result;
   }
   decodeBidFillOptions(bid) {
@@ -16110,12 +16119,29 @@ var BidManager = class {
    * Filter bids whose first output amount < required, sort descending.
    */
   sortSingleOutput(decodedBids, requiredAsset) {
+    const requiredAmount = new Decimal3(requiredAsset.amount.toString());
+    console.log(
+      `[BidManager] sortSingleOutput: required token=${requiredAsset.token}, amount=${requiredAmount.toString()}`
+    );
     const validBids = [];
     for (const { bid, options } of decodedBids) {
       const bidOutput = options.outputs[0];
       const bidAmount = new Decimal3(bidOutput.amount.toString());
-      const requiredAmount = new Decimal3(requiredAsset.amount.toString());
-      if (bidAmount.lt(requiredAmount)) continue;
+      if (bidOutput.token.toLowerCase() !== requiredAsset.token.toLowerCase()) {
+        console.warn(
+          `[BidManager] Bid from solver=${bid.userOp.sender} REJECTED: token mismatch (bid=${bidOutput.token}, required=${requiredAsset.token})`
+        );
+        continue;
+      }
+      if (bidAmount.lt(requiredAmount)) {
+        console.warn(
+          `[BidManager] Bid from solver=${bid.userOp.sender} REJECTED: amount too low (bid=${bidAmount.toString()}, required=${requiredAmount.toString()}, shortfall=${requiredAmount.minus(bidAmount).toString()})`
+        );
+        continue;
+      }
+      console.log(
+        `[BidManager] Bid from solver=${bid.userOp.sender} ACCEPTED: amount=${bidAmount.toString()} (surplus=${bidAmount.minus(requiredAmount).toString()})`
+      );
       validBids.push({ bid, options, amount: bidOutput.amount });
     }
     validBids.sort((a, b) => {
@@ -16131,10 +16157,19 @@ var BidManager = class {
    */
   sortAllStables(decodedBids, orderOutputs, chainId) {
     const requiredUsd = this.computeStablesUsdValue(orderOutputs, chainId);
+    console.log(`[BidManager] sortAllStables: required USD value=${requiredUsd.toString()}`);
     const validBids = [];
     for (const { bid, options } of decodedBids) {
       const bidUsd = this.computeStablesUsdValue(options.outputs, chainId);
-      if (bidUsd === null || bidUsd.lt(requiredUsd)) continue;
+      if (bidUsd === null || bidUsd.lt(requiredUsd)) {
+        console.warn(
+          `[BidManager] Bid from solver=${bid.userOp.sender} REJECTED: USD value too low (bid=${bidUsd?.toString() ?? "null"}, required=${requiredUsd.toString()})`
+        );
+        continue;
+      }
+      console.log(
+        `[BidManager] Bid from solver=${bid.userOp.sender} ACCEPTED: USD value=${bidUsd.toString()}`
+      );
       validBids.push({ bid, options, usdValue: bidUsd });
     }
     validBids.sort((a, b) => b.usdValue.comparedTo(a.usdValue));
@@ -16148,13 +16183,22 @@ var BidManager = class {
   async sortMixedOutputs(decodedBids, orderOutputs, chainId) {
     const requiredUsd = await this.computeOutputsUsdValue(orderOutputs, chainId);
     if (requiredUsd === null) {
-      console.warn("BidManager: output tokens unpriceable, falling back to raw-amount sort");
+      console.warn("[BidManager] sortMixedOutputs: output tokens unpriceable, falling back to raw-amount sort");
       return this.sortByRawAmountFallback(decodedBids, orderOutputs);
     }
+    console.log(`[BidManager] sortMixedOutputs: required USD value=${requiredUsd.toString()}`);
     const validBids = [];
     for (const { bid, options } of decodedBids) {
       const bidUsd = await this.computeOutputsUsdValue(options.outputs, chainId);
-      if (bidUsd === null || bidUsd.lt(requiredUsd)) continue;
+      if (bidUsd === null || bidUsd.lt(requiredUsd)) {
+        console.warn(
+          `[BidManager] Bid from solver=${bid.userOp.sender} REJECTED: mixed USD value too low (bid=${bidUsd?.toString() ?? "unpriceable"}, required=${requiredUsd.toString()})`
+        );
+        continue;
+      }
+      console.log(
+        `[BidManager] Bid from solver=${bid.userOp.sender} ACCEPTED: mixed USD value=${bidUsd.toString()}`
+      );
       validBids.push({ bid, options, usdValue: bidUsd });
     }
     validBids.sort((a, b) => b.usdValue.comparedTo(a.usdValue));
@@ -16167,21 +16211,35 @@ var BidManager = class {
    * Remaining bids are sorted by total spread descending.
    */
   sortByRawAmountFallback(decodedBids, orderOutputs) {
+    console.log(`[BidManager] sortByRawAmountFallback: checking ${decodedBids.length} bid(s) against ${orderOutputs.length} required output(s)`);
     const validBids = [];
     for (const { bid, options } of decodedBids) {
       let valid = true;
       let totalSpread = new Decimal3(0);
+      let rejectReason = "";
       for (const required of orderOutputs) {
         const matching = options.outputs.find((o) => o.token.toLowerCase() === required.token.toLowerCase());
-        if (!matching || matching.amount < required.amount) {
+        if (!matching) {
           valid = false;
+          rejectReason = `missing output token=${required.token}`;
+          break;
+        }
+        if (matching.amount < required.amount) {
+          valid = false;
+          rejectReason = `token=${required.token} amount too low (bid=${matching.amount.toString()}, required=${required.amount.toString()})`;
           break;
         }
         totalSpread = totalSpread.plus(
           new Decimal3(matching.amount.toString()).minus(required.amount.toString())
         );
       }
-      if (!valid) continue;
+      if (!valid) {
+        console.warn(`[BidManager] Bid from solver=${bid.userOp.sender} REJECTED (fallback): ${rejectReason}`);
+        continue;
+      }
+      console.log(
+        `[BidManager] Bid from solver=${bid.userOp.sender} ACCEPTED (fallback): totalSpread=${totalSpread.toString()}`
+      );
       validBids.push({ bid, options, totalSpread });
     }
     validBids.sort((a, b) => b.totalSpread.comparedTo(a.totalSpread));
@@ -16426,7 +16484,7 @@ var GasEstimator = class {
           BundlerMethod.ETH_ESTIMATE_USER_OPERATION_GAS,
           [bundlerUserOp, entryPointAddress, bundlerStateOverrides]
         );
-        callGasLimit = BigInt(gasEstimate.callGasLimit) * 130n / 100n;
+        callGasLimit = BigInt(gasEstimate.callGasLimit) * 160n / 100n;
         verificationGasLimit = BigInt(gasEstimate.verificationGasLimit) * 105n / 100n;
         preVerificationGas = BigInt(gasEstimate.preVerificationGas) * 105n / 100n;
         if (this.ctx.bundlerUrl?.toLowerCase().includes("pimlico.io")) {
@@ -16746,6 +16804,9 @@ var IntentsV2 = class _IntentsV2 {
         maxPriorityFeePerGasBumpPercent: options?.maxPriorityFeePerGasBumpPercent,
         maxFeePerGasBumpPercent: options?.maxFeePerGasBumpPercent
       });
+      if (estimate.totalGasCostWei === 0n || estimate.totalGasInFeeToken === 0n) {
+        throw new Error("Gas estimation failed");
+      }
       feesInWei = estimate.totalGasCostWei + estimate.totalGasCostWei * 2n / 100n;
       order.fees = estimate.totalGasInFeeToken + estimate.totalGasInFeeToken * 1n / 100n;
     }