@hyperbridge/sdk 2.8.18 → 2.8.19

package/dist/node/index.cjs

@@ -18264,6 +18264,16 @@ var NO_BUNDLER_FILL_GAS_BASE = 700000n;
 var NO_BUNDLER_FILL_GAS_PER_OUTPUT = 150000n;
 var NO_BUNDLER_PAYMASTER_VERIFICATION_GAS = 250000n;
 var NO_BUNDLER_PAYMASTER_POST_OP_GAS = 100000n;
+var BID_PVG_ESTIMATION_ACCOUNT_CODE = "0x60003560e01c631626ba7e1460145760206000f35b631626ba7e60e01b60005260206000f3";
+var SELECTED_BID_SIGNATURE_BYTES = 32 + 65 + 65;
+var BID_PVG_HEADROOM_PERCENT = 10n;
+var ESCROW_MAPPING_SLOT = 9n;
+function escrowSlot(commitment, leg) {
+  const byCommitment = viem.keccak256(
+    viem.encodeAbiParameters([{ type: "bytes32" }, { type: "uint256" }], [commitment, ESCROW_MAPPING_SLOT])
+  );
+  return viem.keccak256(viem.encodeAbiParameters([{ type: "uint256" }, { type: "bytes32" }], [BigInt(leg), byCommitment]));
+}
 var GasEstimator = class {
   /**
    * @param ctx - Shared IntentsV2 context providing the source and destination
@@ -18342,6 +18352,7 @@ var GasEstimator = class {
       assetsForOverrides.push({ token: feeTokenAsBytes32, amount: 0n });
     }
     const isSameChain = souceStateMachineId === destStateMachineId;
+    const commitment = orderCommitment(order);
     const [stateOverridesResult, crossChainFees] = await Promise.all([
       this.ctx.bundlerUrl ? this.buildStateOverride({
         accountAddress: solverAccountAddress,
@@ -18349,7 +18360,16 @@ var GasEstimator = class {
         outputAssets: assetsForOverrides,
         spenderAddress: intentGatewayV2Address,
         intentGatewayV2Address,
-        entryPointAddress
+        entryPointAddress,
+        // A fee quote runs before the order is placed, so nothing is escrowed under
+        // its commitment yet. Cross-chain fills release escrow on the source chain.
+        escrow: isSameChain ? {
+          commitment,
+          inputs: order.inputs.map((input) => ({
+            token: normalizeAddressForEvmBytes32(input.token),
+            amount: input.amount
+          }))
+        } : void 0
       }) : Promise.resolve({ viem: [], bundler: {} }),
       isSameChain ? Promise.resolve({ postRequestFee: 0n, relayerFeeInSourceFeeToken: 0n }) : this.estimateCrossChainFees(
         sourceFeeToken,
@@ -18378,10 +18398,8 @@ var GasEstimator = class {
     const maxFeeBumpPercent = params.maxFeePerGasBumpPercent ?? 10;
     let maxPriorityFeePerGas = gasPrice + gasPrice * BigInt(priorityFeeBumpPercent) / 100n;
     let maxFeePerGas = gasPrice + gasPrice * BigInt(maxFeeBumpPercent) / 100n;
-    const orderForEstimation = { ...order, session: solverAccountAddress };
-    const commitment = orderCommitment(orderForEstimation);
     await assertGatewayRelease(this.ctx.dest.client, intentGatewayV2Address);
-    const fillOrderCalldata = encodeFillOrder(transformOrderForContract(orderForEstimation), fillOptions);
+    const fillOrderCalldata = encodeFillOrder(transformOrderForContract(order), fillOptions);
     let callGasLimit = 500000n;
     let verificationGasLimit = 100000n;
     let preVerificationGas = 100000n;
@@ -18393,7 +18411,7 @@ var GasEstimator = class {
           ...params.prependCalls ?? [],
           { target: intentGatewayV2Address, value: totalNativeValue, data: fillOrderCalldata }
         ]);
-        const accountGasLimits = CryptoUtils.packGasLimits(100000n, callGasLimit);
+        const accountGasLimits = CryptoUtils.packGasLimits(0n, 0n);
         const gasFees = CryptoUtils.packGasFees(maxPriorityFeePerGas, maxFeePerGas);
         const nonce = 0n;
         const preliminaryUserOp = {
@@ -18402,7 +18420,7 @@ var GasEstimator = class {
           initCode: "0x",
           callData,
           accountGasLimits,
-          preVerificationGas: 100000n,
+          preVerificationGas: 0n,
           gasFees,
           paymasterAndData: "0x",
           signature: "0x"
@@ -18532,6 +18550,53 @@ var GasEstimator = class {
       inputs
     };
   }
+  /**
+   * Asks the bundler for the `preVerificationGas` of the bid UserOperation that will
+   * actually be signed, with every funding call, approval and signature byte in it.
+   *
+   * On an L2, `preVerificationGas` also pays the L1 data fee for the op's bytes, a fixed
+   * amount of wei that the bundler converts to gas at the price the op pays. A bundler
+   * admits an op priced at its `maxFeePerGas`, but bundles it at the base fee plus its
+   * priority fee, where the same wei costs more gas. An op sized only for admission is
+   * accepted and then skipped in every bundle until it expires. The estimate is taken
+   * at the bundle's price: the latest base fee plus the op's priority fee, capped at its
+   * `maxFeePerGas`.
+   *
+   * The solver account's code is overridden with {@link BID_PVG_ESTIMATION_ACCOUNT_CODE}
+   * for the call, so only the bytes are priced and the fill itself is not simulated.
+   *
+   * @param params - The bid's fields as they will be signed.
+   * @returns The `preVerificationGas` to sign, with {@link BID_PVG_HEADROOM_PERCENT} added.
+   * @throws If no bundler is configured or the bundler rejects the estimate.
+   */
+  async estimateBidPreVerificationGas(params) {
+    const { solverAccount, maxFeePerGas, maxPriorityFeePerGas } = params;
+    const latestBlock = await this.ctx.dest.client.getBlock({ blockTag: "latest" });
+    const baseFeePerGas = latestBlock.baseFeePerGas;
+    const bundlePrice = baseFeePerGas == null || baseFeePerGas + maxPriorityFeePerGas > maxFeePerGas ? maxFeePerGas : baseFeePerGas + maxPriorityFeePerGas;
+    const priorityFee = maxPriorityFeePerGas < bundlePrice ? maxPriorityFeePerGas : bundlePrice;
+    const userOp = {
+      sender: solverAccount,
+      nonce: params.nonce,
+      initCode: "0x",
+      callData: params.callData,
+      accountGasLimits: CryptoUtils.packGasLimits(params.verificationGasLimit, params.callGasLimit),
+      // Bundlers return a non-zero preVerificationGas as given rather than estimating it.
+      preVerificationGas: 0n,
+      gasFees: CryptoUtils.packGasFees(priorityFee, bundlePrice),
+      paymasterAndData: params.paymasterAndData ?? "0x",
+      signature: `0x${"ff".repeat(SELECTED_BID_SIGNATURE_BYTES)}`
+    };
+    const estimate = await this.crypto.sendBundler(
+      BundlerMethod.ETH_ESTIMATE_USER_OPERATION_GAS,
+      [
+        CryptoUtils.prepareBundlerCall(userOp),
+        params.entryPointAddress,
+        { [solverAccount]: { code: BID_PVG_ESTIMATION_ACCOUNT_CODE } }
+      ]
+    );
+    return BigInt(estimate.preVerificationGas) * (100n + BID_PVG_HEADROOM_PERCENT) / 100n;
+  }
   /**
    * Estimates the cross-chain ISMP POST request fee (the relayer fee for the
    * RedeemEscrow message), in both the source and destination fee tokens.
@@ -18584,20 +18649,38 @@ var GasEstimator = class {
    * @returns An object with `viem` and `bundler` state-override collections.
    */
   async buildStateOverride(params) {
-    const { accountAddress, chain, outputAssets, spenderAddress, intentGatewayV2Address, entryPointAddress } = params;
-    const testValue = viem.toHex(viem.maxUint256 / 2n, { size: 32 });
+    const {
+      accountAddress,
+      chain,
+      outputAssets,
+      spenderAddress,
+      intentGatewayV2Address,
+      entryPointAddress,
+      escrow
+    } = params;
+    const testValue = viem.toHex(2n ** 128n, { size: 32 });
     const viemOverrides = [];
     const bundlerOverrides = {};
     if (intentGatewayV2Address) {
       const paramsSlot5 = viem.pad(viem.toHex(5n), { size: 32 });
       const dispatcherAddress = this.ctx.dest.configService.getCalldispatcherAddress(chain);
       const newSlot5Value = "0x" + "0".repeat(22) + "00" + dispatcherAddress.slice(2).toLowerCase();
+      const gatewayDiffs = [{ slot: paramsSlot5, value: newSlot5Value }];
+      for (const [leg, input] of (escrow?.inputs ?? []).entries()) {
+        gatewayDiffs.push({
+          slot: escrowSlot(escrow.commitment, leg),
+          value: viem.toHex(input.amount, { size: 32 })
+        });
+      }
+      const releasesNative = escrow?.inputs.some((input) => bytes32ToBytes20(input.token) === ADDRESS_ZERO2);
       viemOverrides.push({
         address: intentGatewayV2Address,
-        stateDiff: [{ slot: paramsSlot5, value: newSlot5Value }]
+        ...releasesNative ? { balance: 2n ** 128n } : {},
+        stateDiff: gatewayDiffs
       });
       bundlerOverrides[intentGatewayV2Address] = {
-        stateDiff: { [paramsSlot5]: newSlot5Value }
+        ...releasesNative ? { balance: testValue } : {},
+        stateDiff: Object.fromEntries(gatewayDiffs.map(({ slot, value }) => [slot, value]))
       };
     }
     if (entryPointAddress) {
@@ -18628,6 +18711,25 @@ var GasEstimator = class {
         bundlerOverrides[result.address] = { stateDiff: result.bundlerStateDiffs };
       }
     }
+    if (intentGatewayV2Address && escrow) {
+      const gatewayBalances = await Promise.all(
+        escrow.inputs.map((input) => this.tokenBalanceSlot(input.token, intentGatewayV2Address, chain))
+      );
+      for (const override of gatewayBalances) {
+        if (!override) continue;
+        const existing = viemOverrides.find((entry) => entry.address === override.address && entry.stateDiff);
+        if (existing) existing.stateDiff.push({ slot: override.slot, value: testValue });
+        else
+          viemOverrides.push({
+            address: override.address,
+            stateDiff: [{ slot: override.slot, value: testValue }]
+          });
+        bundlerOverrides[override.address] = {
+          ...bundlerOverrides[override.address],
+          stateDiff: { ...bundlerOverrides[override.address]?.stateDiff, [override.slot]: testValue }
+        };
+      }
+    }
     const solverAccountContract = this.ctx.dest.configService.getSolverAccountAddress(chain);
     if (solverAccountContract) {
       try {
@@ -18650,6 +18752,21 @@ var GasEstimator = class {
     }
     return { viem: viemOverrides, bundler: bundlerOverrides };
   }
+  /**
+   * The balance slot of `holder` in an ERC-20 token, for overriding. `null` for the native
+   * token or when the slot cannot be discovered.
+   */
+  async tokenBalanceSlot(tokenHex, holder, chain) {
+    const tokenAddress = bytes32ToBytes20(tokenHex);
+    if (tokenAddress === ADDRESS_ZERO2) return null;
+    try {
+      const balanceData = "0x70a08231" /* BALANCE_OF */ + bytes20ToBytes32(holder).slice(2);
+      const slot = await getOrFetchStorageSlot(this.ctx.dest.client, chain, tokenAddress, balanceData);
+      return slot ? { address: tokenAddress, slot } : null;
+    } catch {
+      return null;
+    }
+  }
   /**
    * Resolves the balance and allowance storage slot overrides for a single
    * ERC-20 token in parallel.  Returns `null` for native-ETH tokens or when
@@ -19763,6 +19880,16 @@ var IntentGateway = class _IntentGateway {
   async estimateFillOrder(params) {
     return this.gasEstimator.estimateFillOrder(params);
   }
+  /**
+   * Asks the bundler for the `preVerificationGas` of a bid as it will be signed, priced at
+   * the gas price its bundle pays. Call it with the final calldata and `paymasterAndData`,
+   * before {@link prepareSubmitBid} signs the op.
+   *
+   * Delegates to {@link GasEstimator.estimateBidPreVerificationGas}.
+   */
+  async estimateBidPreVerificationGas(params) {
+    return this.gasEstimator.estimateBidPreVerificationGas(params);
+  }
   /**
    * Quotes the solver fee for an order using the same policy {@link execute} /
    * {@link executeBest} apply when `order.fees` is `0n`.