@hyperbridge/sdk 2.4.2 → 2.5.0

package/dist/node/intents-helpers.js

@@ -1,9 +1,10 @@
-import { encodeAbiParameters, encodeFunctionData, decodeFunctionData, decodeAbiParameters, numberToBytes, bytesToBigInt } from 'viem';
+import { keccak256, toHex, encodeAbiParameters, encodeFunctionData, decodeFunctionData, decodeAbiParameters, numberToBytes, bytesToBigInt, recoverAddress, parseAbiParameters, concat, encodePacked, pad } from 'viem';
 import '@polkadot/api';
 import { hexToU8a, u8aToHex } from '@polkadot/util';
 import '@polkadot/util-crypto';
 import { Struct, Vector, u8, Bytes } from 'scale-ts';
 import 'p-queue';
+import { privateKeyToAccount } from 'viem/accounts';
 
 // src/protocols/intents/decode-utils.ts
 
@@ -1918,6 +1919,387 @@ function decodeUserOpScale(hex) {
     signature: u8aToHex(new Uint8Array(decoded.signature))
   };
 }
+var SELECT_SOLVER_TYPEHASH = keccak256(toHex("SelectSolver(bytes32 commitment,address solver)"));
+var PACKED_USEROP_TYPEHASH = keccak256(
+  toHex(
+    "PackedUserOperation(address sender,uint256 nonce,bytes initCode,bytes callData,bytes32 accountGasLimits,uint256 preVerificationGas,bytes32 gasFees,bytes paymasterAndData)"
+  )
+);
+var DOMAIN_TYPEHASH = keccak256(
+  toHex("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
+);
+var CryptoUtils = class _CryptoUtils {
+  /**
+   * @param ctx - Shared IntentsV2 context; used to access the bundler URL for
+   *   JSON-RPC calls.
+   */
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /**
+   * Computes an EIP-712 domain separator for a given contract.
+   *
+   * @param contractName - Human-readable name of the contract (e.g. `"IntentGateway"`).
+   * @param version - Version string (e.g. `"2"`).
+   * @param chainId - Chain ID of the network the contract is deployed on.
+   * @param contractAddress - Address of the verifying contract.
+   * @returns The 32-byte domain separator as a hex string.
+   */
+  static getDomainSeparator(contractName, version, chainId, contractAddress) {
+    return keccak256(
+      encodeAbiParameters(parseAbiParameters("bytes32, bytes32, bytes32, uint256, address"), [
+        DOMAIN_TYPEHASH,
+        keccak256(toHex(contractName)),
+        keccak256(toHex(version)),
+        chainId,
+        contractAddress
+      ])
+    );
+  }
+  /**
+   * Signs a `SelectSolver` EIP-712 message with a session key.
+   *
+   * The session key authorises the selection of a specific solver for the
+   * given order commitment. The resulting signature is appended to the
+   * solver's UserOperation signature before bundle submission.
+   *
+   * @param commitment - The order commitment (bytes32) being fulfilled.
+   * @param solverAddress - Address of the solver account selected to fill the order.
+   * @param domainSeparator - EIP-712 domain separator for the IntentGatewayV2 contract.
+   * @param privateKey - Hex-encoded private key of the session key that signs the message.
+   * @returns The ECDSA signature as a hex string, or `null` if signing fails.
+   */
+  static async signSolverSelection(commitment, solverAddress, domainSeparator, privateKey) {
+    const account = privateKeyToAccount(privateKey);
+    const structHash = keccak256(
+      encodeAbiParameters(
+        [{ type: "bytes32" }, { type: "bytes32" }, { type: "address" }],
+        [SELECT_SOLVER_TYPEHASH, commitment, solverAddress]
+      )
+    );
+    const digest = keccak256(concat(["0x1901", domainSeparator, structHash]));
+    const signature = await account.sign({ hash: digest });
+    return signature;
+  }
+  /**
+   * Computes the EIP-712 hash of a `PackedUserOperation` as defined by
+   * ERC-4337 EntryPoint v0.8.
+   *
+   * @param userOp - The packed UserOperation to hash.
+   * @param entryPoint - Address of the EntryPoint v0.8 contract.
+   * @param chainId - Chain ID of the network on which the operation will execute.
+   * @returns The UserOperation hash as a hex string.
+   */
+  static computeUserOpHash(userOp, entryPoint, chainId) {
+    const structHash = _CryptoUtils.getPackedUserStructHash(userOp);
+    const domainSeparator = _CryptoUtils.getDomainSeparator("ERC4337", "1", chainId, entryPoint);
+    return keccak256(
+      encodePacked(["bytes1", "bytes1", "bytes32", "bytes32"], ["0x19", "0x01", domainSeparator, structHash])
+    );
+  }
+  /**
+   * Derives the ERC-4337 nonce key that binds a bid UserOperation to its
+   * order and session key: the lower 192 bits of
+   * `keccak256(commitment ‖ sessionKey)`. `SolverAccount` rejects bid
+   * operations whose nonce key differs — this is what lets the solver sign
+   * the plain userOpHash while staying committed to the order and to the
+   * session key it bid against.
+   *
+   * @param commitment - The order commitment (`order.id`).
+   * @param sessionKey - The order's session key address (`order.session`).
+   * @returns The 192-bit nonce key as a bigint (pass to `EntryPoint.getNonce`).
+   */
+  static bidNonceKey(commitment, sessionKey) {
+    return BigInt(keccak256(encodePacked(["bytes32", "address"], [commitment, sessionKey]))) & (1n << 192n) - 1n;
+  }
+  /**
+   * Builds the EIP-712 typed-data payload whose digest is the EntryPoint v0.8
+   * `userOpHash` (i.e. `hashTypedData(packedUserOpTypedData(...)) ===
+   * computeUserOpHash(...)`). Signing this typed data is bit-identical to
+   * signing the raw userOpHash, but keeps the full operation visible to
+   * signing infrastructure (hardware wallets, MPC/TEE policy engines) instead
+   * of an opaque 32-byte digest.
+   *
+   * @param userOp - The packed UserOperation to sign (signature field ignored).
+   * @param entryPoint - Address of the EntryPoint v0.8 contract.
+   * @param chainId - Chain ID of the network on which the operation will execute.
+   * @returns A viem `TypedDataDefinition` for the operation.
+   */
+  static packedUserOpTypedData(userOp, entryPoint, chainId) {
+    return {
+      domain: {
+        name: "ERC4337",
+        version: "1",
+        chainId,
+        verifyingContract: entryPoint
+      },
+      types: {
+        PackedUserOperation: [
+          { name: "sender", type: "address" },
+          { name: "nonce", type: "uint256" },
+          { name: "initCode", type: "bytes" },
+          { name: "callData", type: "bytes" },
+          { name: "accountGasLimits", type: "bytes32" },
+          { name: "preVerificationGas", type: "uint256" },
+          { name: "gasFees", type: "bytes32" },
+          { name: "paymasterAndData", type: "bytes" }
+        ]
+      },
+      primaryType: "PackedUserOperation",
+      message: {
+        sender: userOp.sender,
+        nonce: userOp.nonce,
+        initCode: userOp.initCode,
+        callData: userOp.callData,
+        accountGasLimits: userOp.accountGasLimits,
+        preVerificationGas: userOp.preVerificationGas,
+        gasFees: userOp.gasFees,
+        paymasterAndData: userOp.paymasterAndData
+      }
+    };
+  }
+  /**
+   * Computes the EIP-712 struct hash of a `PackedUserOperation`.
+   *
+   * Hashes dynamic fields (`initCode`, `callData`, `paymasterAndData`) before
+   * ABI-encoding so the final hash is a fixed-length 32-byte value.
+   *
+   * @param userOp - The packed UserOperation to hash.
+   * @returns The struct hash as a 32-byte hex string.
+   */
+  static getPackedUserStructHash(userOp) {
+    return keccak256(
+      encodeAbiParameters(
+        parseAbiParameters("bytes32, address, uint256, bytes32, bytes32, bytes32, uint256, bytes32, bytes32"),
+        [
+          PACKED_USEROP_TYPEHASH,
+          userOp.sender,
+          userOp.nonce,
+          keccak256(userOp.initCode),
+          keccak256(userOp.callData),
+          userOp.accountGasLimits,
+          userOp.preVerificationGas,
+          userOp.gasFees,
+          keccak256(userOp.paymasterAndData)
+        ]
+      )
+    );
+  }
+  /**
+   * Packs `verificationGasLimit` and `callGasLimit` into the ERC-4337
+   * `accountGasLimits` bytes32 field.
+   *
+   * The high 16 bytes hold `verificationGasLimit` and the low 16 bytes hold
+   * `callGasLimit`, matching the EntryPoint v0.8 packed representation.
+   *
+   * @param verificationGasLimit - Gas limit for the account verification step.
+   * @param callGasLimit - Gas limit for the main execution call.
+   * @returns A 32-byte hex string with both limits packed.
+   */
+  static packGasLimits(verificationGasLimit, callGasLimit) {
+    const verificationGasHex = pad(toHex(verificationGasLimit), { size: 16 });
+    const callGasHex = pad(toHex(callGasLimit), { size: 16 });
+    return concat([verificationGasHex, callGasHex]);
+  }
+  /**
+   * Packs `maxPriorityFeePerGas` and `maxFeePerGas` into the ERC-4337
+   * `gasFees` bytes32 field.
+   *
+   * The high 16 bytes hold `maxPriorityFeePerGas` and the low 16 bytes hold
+   * `maxFeePerGas`, matching the EntryPoint v0.8 packed representation.
+   *
+   * @param maxPriorityFeePerGas - Maximum tip per gas (EIP-1559).
+   * @param maxFeePerGas - Maximum total fee per gas (EIP-1559).
+   * @returns A 32-byte hex string with both fee values packed.
+   */
+  static packGasFees(maxPriorityFeePerGas, maxFeePerGas) {
+    const priorityFeeHex = pad(toHex(maxPriorityFeePerGas), { size: 16 });
+    const maxFeeHex = pad(toHex(maxFeePerGas), { size: 16 });
+    return concat([priorityFeeHex, maxFeeHex]);
+  }
+  /**
+   * Unpacks the `accountGasLimits` bytes32 field back into its constituent
+   * gas limits.
+   *
+   * @param accountGasLimits - The packed 32-byte gas limits field from a `PackedUserOperation`.
+   * @returns Object with `verificationGasLimit` and `callGasLimit` as bigints.
+   */
+  static unpackGasLimits(accountGasLimits) {
+    const hex = accountGasLimits.slice(2);
+    const verificationGasLimit = BigInt(`0x${hex.slice(0, 32)}`);
+    const callGasLimit = BigInt(`0x${hex.slice(32, 64)}`);
+    return { verificationGasLimit, callGasLimit };
+  }
+  /**
+   * Unpacks the `gasFees` bytes32 field back into its constituent fee values.
+   *
+   * @param gasFees - The packed 32-byte gas fees field from a `PackedUserOperation`.
+   * @returns Object with `maxPriorityFeePerGas` and `maxFeePerGas` as bigints.
+   */
+  static unpackGasFees(gasFees) {
+    const hex = gasFees.slice(2);
+    const maxPriorityFeePerGas = BigInt(`0x${hex.slice(0, 32)}`);
+    const maxFeePerGas = BigInt(`0x${hex.slice(32, 64)}`);
+    return { maxPriorityFeePerGas, maxFeePerGas };
+  }
+  /**
+   * Converts a packed `PackedUserOperation` into the JSON object format
+   * expected by ERC-4337 bundler JSON-RPC endpoints.
+   *
+   * Unpacks `accountGasLimits` and `gasFees`, separates optional factory and
+   * paymaster fields, and converts all numeric fields to hex strings.
+   *
+   * @param userOp - The packed UserOperation to convert.
+   * @returns A plain object safe to pass as the first element of bundler RPC params.
+   */
+  static prepareBundlerCall(userOp) {
+    const { verificationGasLimit, callGasLimit } = _CryptoUtils.unpackGasLimits(userOp.accountGasLimits);
+    const { maxPriorityFeePerGas, maxFeePerGas } = _CryptoUtils.unpackGasFees(userOp.gasFees);
+    const hasFactory = userOp.initCode && userOp.initCode !== "0x" && userOp.initCode.length > 2;
+    const factory = hasFactory ? `0x${userOp.initCode.slice(2, 42)}` : void 0;
+    const factoryData = hasFactory ? `0x${userOp.initCode.slice(42)}` : void 0;
+    const hasPaymaster = userOp.paymasterAndData && userOp.paymasterAndData !== "0x" && userOp.paymasterAndData.length > 2;
+    const pmHex = hasPaymaster ? userOp.paymasterAndData.slice(2) : "";
+    const paymaster = hasPaymaster ? `0x${pmHex.slice(0, 40)}` : void 0;
+    const paymasterVerificationGasLimit = hasPaymaster ? BigInt(`0x${pmHex.slice(40, 72)}`) : void 0;
+    const paymasterPostOpGasLimit = hasPaymaster ? BigInt(`0x${pmHex.slice(72, 104)}`) : void 0;
+    const paymasterData = hasPaymaster ? `0x${pmHex.slice(104)}` : void 0;
+    const userOpBundler = {
+      sender: userOp.sender,
+      nonce: toHex(userOp.nonce),
+      callData: userOp.callData,
+      callGasLimit: toHex(callGasLimit),
+      verificationGasLimit: toHex(verificationGasLimit),
+      preVerificationGas: toHex(userOp.preVerificationGas),
+      maxFeePerGas: toHex(maxFeePerGas),
+      maxPriorityFeePerGas: toHex(maxPriorityFeePerGas),
+      signature: userOp.signature
+    };
+    if (factory) {
+      userOpBundler.factory = factory;
+      userOpBundler.factoryData = factoryData || "0x";
+    }
+    if (paymaster) {
+      userOpBundler.paymaster = paymaster;
+      userOpBundler.paymasterData = paymasterData || "0x";
+      userOpBundler.paymasterVerificationGasLimit = toHex(paymasterVerificationGasLimit);
+      userOpBundler.paymasterPostOpGasLimit = toHex(paymasterPostOpGasLimit);
+    }
+    return userOpBundler;
+  }
+  /**
+   * Sends a JSON-RPC request to the configured ERC-4337 bundler endpoint.
+   *
+   * @param method - The JSON-RPC method name (one of {@link BundlerMethod}).
+   * @param params - Array of parameters for the RPC call.
+   * @returns Resolves with the `result` field of the bundler's JSON-RPC response,
+   *   typed as `T`.
+   * @throws If the bundler URL is not configured or the bundler returns an error.
+   */
+  async sendBundler(method, params = []) {
+    if (!this.ctx.bundlerUrl) {
+      throw new Error("Bundler URL not configured");
+    }
+    const response = await fetch(this.ctx.bundlerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
+    });
+    const result = await response.json();
+    if (result.error) {
+      throw new Error(`Bundler error: ${result.error.message || JSON.stringify(result.error)}`);
+    }
+    return result.result;
+  }
+  /**
+   * Sends multiple JSON-RPC requests to the bundler in a single HTTP call
+   * using JSON-RPC 2.0 batch syntax.  Results are returned in the same order
+   * as the input `requests` array.
+   *
+   * @throws If the bundler URL is not configured, the HTTP call fails, or any
+   *   individual response contains an error.
+   */
+  async sendBundlerBatch(requests) {
+    if (!this.ctx.bundlerUrl) {
+      throw new Error("Bundler URL not configured");
+    }
+    const body = requests.map((r, i) => ({
+      jsonrpc: "2.0",
+      id: i + 1,
+      method: r.method,
+      params: r.params
+    }));
+    const response = await fetch(this.ctx.bundlerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    const results = await response.json();
+    results.sort((a, b) => a.id - b.id);
+    return results.map((r) => {
+      if (r.error) {
+        throw new Error(`Bundler error: ${r.error.message || JSON.stringify(r.error)}`);
+      }
+      return r.result;
+    });
+  }
+  /**
+   * Encodes a list of calls into ERC-7821 `execute` calldata using
+   * single-batch mode (`ERC7821_BATCH_MODE`).
+   *
+   * @param calls - Ordered list of calls to batch; each specifies a `target`
+   *   address, ETH `value`, and `data`.
+   * @returns ABI-encoded calldata for the ERC-7821 `execute(bytes32,bytes)` function.
+   */
+  encodeERC7821Execute(calls) {
+    const executionData = encodeAbiParameters(
+      [{ type: "tuple[]", components: erc7281_default.ABI[1].components }],
+      [calls.map((call) => ({ target: call.target, value: call.value, data: call.data }))]
+    );
+    return encodeFunctionData({
+      abi: erc7281_default.ABI,
+      functionName: "execute",
+      args: [ERC7821_BATCH_MODE, executionData]
+    });
+  }
+  /**
+   * Decodes ERC-7821 `execute` calldata back into its constituent calls.
+   *
+   * Returns `null` if the calldata does not match the expected `execute`
+   * function signature or cannot be decoded.
+   *
+   * @param callData - Hex-encoded calldata previously produced by
+   *   {@link encodeERC7821Execute} or an equivalent encoder.
+   * @returns Array of decoded {@link ERC7821Call} objects, or `null` on failure.
+   */
+  decodeERC7821Execute(callData) {
+    try {
+      const decoded = decodeFunctionData({
+        abi: erc7281_default.ABI,
+        data: callData
+      });
+      if (decoded?.functionName !== "execute" || !decoded.args || decoded.args.length < 2) {
+        return null;
+      }
+      const executionData = decoded.args[1];
+      const [calls] = decodeAbiParameters(
+        [{ type: "tuple[]", components: erc7281_default.ABI[1].components }],
+        executionData
+      );
+      return calls.map((call) => ({
+        target: call.target,
+        value: call.value,
+        data: call.data
+      }));
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/protocols/intents/phantom-aggregation.ts
+var ENTRY_POINT_V08_ADDRESS = "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108";
 var injectedFetch;
 function setAggregationFetch(fetchImpl) {
   injectedFetch = fetchImpl;
@@ -1991,13 +2373,101 @@ function extractFillData(callData, gatewayAddress) {
   }
   return null;
 }
+var FILL_ORDER_INPUT = FILL_ORDER_ABI.find(
+  (item) => item?.type === "function" && item?.name === "fillOrder"
+)?.inputs?.[0];
+function orderCommitmentFromDecoded(order) {
+  try {
+    if (!FILL_ORDER_INPUT) return null;
+    return keccak256(encodeAbiParameters([FILL_ORDER_INPUT], [order]));
+  } catch {
+    return null;
+  }
+}
+var BID_COMMITMENT_BYTES = 32;
+var SOLVER_SIGNATURE_BYTES = 65;
+function splitBidSignature(signature) {
+  const raw = signature.replace(/^0x/, "");
+  const commitmentChars = BID_COMMITMENT_BYTES * 2;
+  const end = commitmentChars + SOLVER_SIGNATURE_BYTES * 2;
+  if (raw.length < end) return null;
+  return {
+    commitment: `0x${raw.slice(0, commitmentChars)}`,
+    solverSignature: `0x${raw.slice(commitmentChars, end)}`
+  };
+}
+var recoverBidSignerViem = async (userOp, entryPoint, chainId, solverSignature) => {
+  try {
+    const userOpHash = CryptoUtils.computeUserOpHash(userOp, entryPoint, chainId);
+    return await recoverAddress({ hash: userOpHash, signature: solverSignature });
+  } catch {
+    return null;
+  }
+};
+var DELEGATION_INDICATOR_PREFIX = "0xef0100";
+async function isDelegatedToSolverAccount(evmRpcUrl, account, solverAccount) {
+  const response = await rpcCall(evmRpcUrl, {
+    id: 1,
+    jsonrpc: "2.0",
+    method: "eth_getCode",
+    params: [account, "latest"]
+  });
+  const code = typeof response.result === "string" ? response.result.toLowerCase() : "";
+  if (!code.startsWith(DELEGATION_INDICATOR_PREFIX)) return false;
+  return `0x${code.slice(DELEGATION_INDICATOR_PREFIX.length)}` === solverAccount.toLowerCase();
+}
+function evmChainId(chain) {
+  const [prefix, id] = chain.split("-");
+  if (prefix !== "EVM" || !id || !/^\d+$/.test(id)) return null;
+  return BigInt(id);
+}
+async function isVerifiedSolverBid(params) {
+  const { userOp, commitment, sessionKey, chainId, solverAccount, evmRpcUrl, recoverSigner, bidNonceKey, logger } = params;
+  const solver = userOp.sender;
+  const parsed = splitBidSignature(userOp.signature);
+  if (!parsed) {
+    logger?.warn({ solver, commitment }, "Rejecting phantom bid: malformed userOp signature");
+    return false;
+  }
+  if (parsed.commitment.toLowerCase() !== commitment.toLowerCase()) {
+    logger?.warn(
+      { solver, commitment, signedFor: parsed.commitment },
+      "Rejecting phantom bid: signed for another order"
+    );
+    return false;
+  }
+  if (BigInt(userOp.nonce) >> 64n !== bidNonceKey(commitment, sessionKey)) {
+    logger?.warn({ solver, commitment }, "Rejecting phantom bid: nonce does not bind order and session key");
+    return false;
+  }
+  const signer = await recoverSigner(userOp, ENTRY_POINT_V08_ADDRESS, chainId, parsed.solverSignature);
+  if (!signer || signer.toLowerCase() !== solver.toLowerCase()) {
+    logger?.warn({ solver, commitment, signer }, "Rejecting phantom bid: signature does not recover to the sender");
+    return false;
+  }
+  if (!await isDelegatedToSolverAccount(evmRpcUrl, solver, solverAccount)) {
+    logger?.warn({ solver, commitment, solverAccount }, "Rejecting phantom bid: sender is not a delegated solver");
+    return false;
+  }
+  return true;
+}
 async function fetchBidsForOrder(nodeUrl, commitment) {
-  const data = await rpcCall(nodeUrl, { id: 1, jsonrpc: "2.0", method: "intents_getBidsForOrder", params: [commitment] });
+  const data = await rpcCall(nodeUrl, {
+    id: 1,
+    jsonrpc: "2.0",
+    method: "intents_getBidsForOrder",
+    params: [commitment]
+  });
   return Array.isArray(data.result) ? data.result : [];
 }
 async function ethCallUint(evmRpcUrl, to, data) {
   try {
-    const result = await rpcCall(evmRpcUrl, { id: 1, jsonrpc: "2.0", method: "eth_call", params: [{ to, data }, "latest"] });
+    const result = await rpcCall(evmRpcUrl, {
+      id: 1,
+      jsonrpc: "2.0",
+      method: "eth_call",
+      params: [{ to, data }, "latest"]
+    });
     if (result.error || !result.result || result.result === "0x") return 0n;
     return BigInt(result.result);
   } catch {
@@ -2033,14 +2503,23 @@ function toAddress(token) {
   return `0x${addr}`;
 }
 async function aggregatePhantomBids(params) {
-  const { nodeUrl, evmRpcUrls, chain, gatewayAddress, commitment, yieldVaults, logger } = params;
+  const { nodeUrl, evmRpcUrls, chain, gatewayAddress, commitment, yieldVaults, solverAccount, logger } = params;
   const extractFill = params.extractFill ?? extractFillData;
+  const recoverSigner = params.recoverSigner ?? recoverBidSignerViem;
+  const bidNonceKey = params.bidNonceKey ?? CryptoUtils.bidNonceKey;
+  const orderCommitment = params.orderCommitment ?? orderCommitmentFromDecoded;
   const destUrl = evmRpcUrls[chain];
   if (!destUrl) return null;
+  const chainId = evmChainId(chain);
+  if (!solverAccount || chainId === null) {
+    logger?.warn({ chain, commitment }, "Cannot verify phantom bids: no SolverAccount or chain id for chain");
+    return null;
+  }
   const bids = await fetchBidsForOrder(nodeUrl, commitment);
   if (bids.length === 0) return null;
   const quotes = [];
   const lpBalances = [];
+  const countedSolvers = /* @__PURE__ */ new Set();
   for (const bid of bids) {
     if (!bid.user_op) continue;
     try {
@@ -2048,6 +2527,34 @@ async function aggregatePhantomBids(params) {
       const solver = decoded.sender;
       const fillData = extractFill(decoded.callData, gatewayAddress);
       if (!fillData) continue;
+      const decodedCommitment = orderCommitment(fillData.order);
+      if (!decodedCommitment || decodedCommitment.toLowerCase() !== commitment.toLowerCase()) {
+        logger?.warn({ solver, commitment }, "Rejecting phantom bid: calldata order is not the indexed order");
+        continue;
+      }
+      const sessionKey = fillData.order?.session;
+      if (!sessionKey) {
+        logger?.warn({ solver, commitment }, "Rejecting phantom bid: order carries no session key");
+        continue;
+      }
+      const verified = await isVerifiedSolverBid({
+        userOp: decoded,
+        commitment,
+        sessionKey,
+        chainId,
+        solverAccount,
+        evmRpcUrl: destUrl,
+        recoverSigner,
+        bidNonceKey,
+        logger
+      });
+      if (!verified) continue;
+      const normalizedSolver = solver.toLowerCase();
+      if (countedSolvers.has(normalizedSolver)) {
+        logger?.warn({ solver, commitment }, "Skipping phantom bid: solver already counted for this order");
+        continue;
+      }
+      countedSolvers.add(normalizedSolver);
       const outputTokenAddress = toAddress(fillData.outputToken);
       const weight = await getTotalSolverBalance(destUrl, chain, outputTokenAddress, solver, yieldVaults);
       quotes.push({ price: fillData.solverAmount, weight });
@@ -2057,16 +2564,16 @@ async function aggregatePhantomBids(params) {
     }
   }
   if (quotes.length === 0) return null;
-  const sortedPrices = quotes.map((q) => q.price).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const medianPrice = weightedMedian(quotes);
   return {
-    lowestPrice: sortedPrices[0],
-    highestPrice: sortedPrices[sortedPrices.length - 1],
-    medianPrice: weightedMedian(quotes),
+    lowestPrice: medianPrice,
+    highestPrice: medianPrice,
+    medianPrice,
     bidCount: quotes.length,
     lpBalances
   };
 }
 
-export { FILL_ORDER_ABI, IntentGatewayV2_default as IntentGatewayV2, aggregatePhantomBids, decodeERC7821ExecuteBatch, decodeUserOpScale, encodeERC7821ExecuteBatch, encodeUserOpScale, extractFillData, fetchBidsForOrder, setAggregationFetch, weightedMedian };
+export { ENTRY_POINT_V08_ADDRESS, FILL_ORDER_ABI, IntentGatewayV2_default as IntentGatewayV2, aggregatePhantomBids, decodeERC7821ExecuteBatch, decodeUserOpScale, encodeERC7821ExecuteBatch, encodeUserOpScale, extractFillData, fetchBidsForOrder, orderCommitmentFromDecoded, recoverBidSignerViem, setAggregationFetch, splitBidSignature, weightedMedian };
 //# sourceMappingURL=intents-helpers.js.map
 //# sourceMappingURL=intents-helpers.js.map