@hyperbridge/sdk 2.8.0 → 2.8.3

package/dist/node/intents-helpers.cjs

@@ -2041,6 +2041,12 @@ var CryptoUtils = class _CryptoUtils {
    * signing infrastructure (hardware wallets, MPC/TEE policy engines) instead
    * of an opaque 32-byte digest.
    *
+   * The payload must be a standard self-describing `eth_signTypedData_v4`
+   * payload — `EIP712Domain` listed in `types`, `chainId` as a JSON number —
+   * because some signing backends (e.g. MPC Vault) hash it server-side from
+   * the JSON rather than locally via viem. viem ignores both details when
+   * hashing, so the digest is unchanged for local signers.
+   *
    * @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.
@@ -2051,10 +2057,22 @@ var CryptoUtils = class _CryptoUtils {
       domain: {
         name: "ERC4337",
         version: "1",
-        chainId,
+        // Runtime number so JSON.stringify emits a canonical v4 numeric chainId for
+        // server-side hashers; viem's uint256 type mapping wants bigint but its
+        // runtime accepts numbers, hence the cast.
+        chainId: Number(chainId),
         verifyingContract: entryPoint
       },
+      // `as const`: viem derives the domain's TYPE from `types.EIP712Domain`, so the
+      // entries must stay string literals — widened `string` fields make viem's
+      // typed-data generics reject the payload at every call site.
       types: {
+        EIP712Domain: [
+          { name: "name", type: "string" },
+          { name: "version", type: "string" },
+          { name: "chainId", type: "uint256" },
+          { name: "verifyingContract", type: "address" }
+        ],
         PackedUserOperation: [
           { name: "sender", type: "address" },
           { name: "nonce", type: "uint256" },
@@ -2318,6 +2336,107 @@ var CryptoUtils = class _CryptoUtils {
   }
 };
 
+// src/protocols/intents/uniswap-v4-position.ts
+var Q96 = 1n << 96n;
+var MIN_TICK = -887272;
+var MAX_TICK = 887272;
+function word(data, index) {
+  const hex = data.startsWith("0x") ? data.slice(2) : data;
+  const start = index * 64;
+  if (hex.length < start + 64) throw new Error(`return data too short for word ${index}`);
+  return BigInt(`0x${hex.slice(start, start + 64)}`);
+}
+function asSigned(value, bits) {
+  const width = 1n << BigInt(bits);
+  const masked = value & width - 1n;
+  return masked >= width >> 1n ? masked - width : masked;
+}
+function addressFromWord(data, index) {
+  const hex = data.startsWith("0x") ? data.slice(2) : data;
+  return `0x${hex.slice(index * 64 + 24, (index + 1) * 64)}`.toLowerCase();
+}
+function getSqrtRatioAtTick(tick) {
+  if (!Number.isInteger(tick) || tick < MIN_TICK || tick > MAX_TICK) {
+    throw new Error(`tick out of range: ${tick}`);
+  }
+  const absTick = BigInt(Math.abs(tick));
+  let ratio = (absTick & 0x1n) !== 0n ? 0xfffcb933bd6fad37aa2d162d1a594001n : 0x100000000000000000000000000000000n;
+  const factors = [
+    [0x2n, 0xfff97272373d413259a46990580e213an],
+    [0x4n, 0xfff2e50f5f656932ef12357cf3c7fdccn],
+    [0x8n, 0xffe5caca7e10e4e61c3624eaa0941cd0n],
+    [0x10n, 0xffcb9843d60f6159c9db58835c926644n],
+    [0x20n, 0xff973b41fa98c081472e6896dfb254c0n],
+    [0x40n, 0xff2ea16466c96a3843ec78b326b52861n],
+    [0x80n, 0xfe5dee046a99a2a811c461f1969c3053n],
+    [0x100n, 0xfcbe86c7900a88aedcffc83b479aa3a4n],
+    [0x200n, 0xf987a7253ac413176f2b074cf7815e54n],
+    [0x400n, 0xf3392b0822b70005940c7a398e4b70f3n],
+    [0x800n, 0xe7159475a2c29b7443b29c7fa6e889d9n],
+    [0x1000n, 0xd097f3bdfd2022b8845ad8f792aa5825n],
+    [0x2000n, 0xa9f746462d870fdf8a65dc1f90e061e5n],
+    [0x4000n, 0x70d869a156d2a1b890bb3df62baf32f7n],
+    [0x8000n, 0x31be135f97d08fd981231505542fcfa6n],
+    [0x10000n, 0x9aa508b5b7a84e1c677de54f3e99bc9n],
+    [0x20000n, 0x5d6af8dedb81196699c329225ee604n],
+    [0x40000n, 0x2216e584f5fa1ea926041bedfe98n],
+    [0x80000n, 0x48a170391f7dc42444e8fa2n]
+  ];
+  for (const [bit, factor] of factors) {
+    if ((absTick & bit) !== 0n) ratio = ratio * factor >> 128n;
+  }
+  if (tick > 0) ratio = (1n << 256n) / ratio;
+  return (ratio >> 32n) + (ratio % (1n << 32n) === 0n ? 0n : 1n);
+}
+function positionTicks(info) {
+  return {
+    tickLower: Number(asSigned(info >> 8n, 24)),
+    tickUpper: Number(asSigned(info >> 32n, 24))
+  };
+}
+function getAmountsForLiquidity(params) {
+  let { sqrtRatioAX96, sqrtRatioBX96 } = params;
+  const { sqrtPriceX96, liquidity } = params;
+  if (sqrtRatioAX96 > sqrtRatioBX96) [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+  const amount0For = (from, to) => liquidity * Q96 * (to - from) / to / from;
+  const amount1For = (from, to) => liquidity * (to - from) / Q96;
+  if (sqrtPriceX96 <= sqrtRatioAX96) {
+    return { amount0: amount0For(sqrtRatioAX96, sqrtRatioBX96), amount1: 0n };
+  }
+  if (sqrtPriceX96 < sqrtRatioBX96) {
+    return {
+      amount0: amount0For(sqrtPriceX96, sqrtRatioBX96),
+      amount1: amount1For(sqrtRatioAX96, sqrtPriceX96)
+    };
+  }
+  return { amount0: 0n, amount1: amount1For(sqrtRatioAX96, sqrtRatioBX96) };
+}
+function decodePoolAndPositionInfo(data) {
+  const hex = data.startsWith("0x") ? data.slice(2) : data;
+  if (hex.length < 6 * 64) throw new Error("getPoolAndPositionInfo returned too little data");
+  const { tickLower, tickUpper } = positionTicks(word(data, 5));
+  return {
+    currency0: addressFromWord(data, 0),
+    currency1: addressFromWord(data, 1),
+    poolKeyEncoded: `0x${hex.slice(0, 5 * 64)}`,
+    tickLower,
+    tickUpper
+  };
+}
+function positionAmountOfToken(params) {
+  const { info, liquidity, sqrtPriceX96 } = params;
+  const outputToken = params.outputToken.toLowerCase();
+  if (outputToken !== info.currency0 && outputToken !== info.currency1) return 0n;
+  if (liquidity <= 0n || sqrtPriceX96 <= 0n) return 0n;
+  const { amount0, amount1 } = getAmountsForLiquidity({
+    sqrtPriceX96,
+    sqrtRatioAX96: getSqrtRatioAtTick(info.tickLower),
+    sqrtRatioBX96: getSqrtRatioAtTick(info.tickUpper),
+    liquidity
+  });
+  return outputToken === info.currency0 ? amount0 : amount1;
+}
+
 // src/protocols/intents/phantom-aggregation.ts
 var ENTRY_POINT_V08_ADDRESS = "0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108";
 var injectedFetch;
@@ -2331,6 +2450,14 @@ function rpcFetch() {
   }
   return f;
 }
+var PhantomRpcError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "PhantomRpcError";
+  }
+  cause;
+};
 async function rpcCall(url, payload) {
   let lastErr;
   for (let attempt = 0; attempt < 4; attempt++) {
@@ -2348,23 +2475,46 @@ async function rpcCall(url, payload) {
         }),
         timeout
       ]);
-      return await response.json();
+      const body = await response.json();
+      if (body?.error) {
+        lastErr = new Error(`rpc error: ${JSON.stringify(body.error).slice(0, 200)}`);
+        continue;
+      }
+      return body;
     } catch (err) {
       lastErr = err;
     } finally {
       if (timer) clearTimeout(timer);
     }
   }
-  throw lastErr;
+  throw new PhantomRpcError(`RPC call failed after 4 attempts: ${url}`, lastErr);
 }
 var FILL_ORDER_ABI = IntentGatewayV2_default.ABI;
-var DECLARATION_VERSION = 1;
-var MAX_DECLARED_CHAINS = 255;
-function encodeAcceptedSourceChains(chains) {
-  if (chains.length > MAX_DECLARED_CHAINS) {
-    throw new Error(`Cannot declare more than ${MAX_DECLARED_CHAINS} source chains`);
+var DECLARATION_V1 = 1;
+var DECLARATION_V2 = 2;
+var MAX_DECLARED_ENTRIES = 255;
+var MAX_TOKEN_ID_BYTES = 32;
+function tokenIdToBytes(tokenId) {
+  if (tokenId < 0n) throw new Error(`Uniswap V4 tokenId cannot be negative: ${tokenId}`);
+  const bytes = [];
+  let rest = tokenId;
+  while (rest > 0n) {
+    bytes.unshift(Number(rest & 0xffn));
+    rest >>= 8n;
   }
-  const bytes = [DECLARATION_VERSION, chains.length];
+  return bytes.length > 0 ? bytes : [0];
+}
+function encodePhantomBidDeclaration(declaration) {
+  const chains = declaration.acceptedSourceChains ?? [];
+  const positions = declaration.uniswapV4Positions ?? [];
+  if (chains.length > MAX_DECLARED_ENTRIES) {
+    throw new Error(`Cannot declare more than ${MAX_DECLARED_ENTRIES} source chains`);
+  }
+  if (positions.length > MAX_DECLARED_ENTRIES) {
+    throw new Error(`Cannot declare more than ${MAX_DECLARED_ENTRIES} Uniswap V4 positions`);
+  }
+  const version = positions.length > 0 ? DECLARATION_V2 : DECLARATION_V1;
+  const bytes = [version, chains.length];
   for (const chain of chains) {
     const encoded = util.stringToU8a(chain);
     if (encoded.length === 0 || encoded.length > 255) {
@@ -2372,25 +2522,59 @@ function encodeAcceptedSourceChains(chains) {
     }
     bytes.push(encoded.length, ...encoded);
   }
+  if (version === DECLARATION_V2) {
+    bytes.push(positions.length);
+    for (const tokenId of positions) {
+      const encoded = tokenIdToBytes(tokenId);
+      if (encoded.length > MAX_TOKEN_ID_BYTES) {
+        throw new Error(`Uniswap V4 tokenId exceeds uint256: ${tokenId}`);
+      }
+      bytes.push(encoded.length, ...encoded);
+    }
+  }
   return util.u8aToHex(new Uint8Array(bytes));
 }
-function decodeAcceptedSourceChains(paymasterAndData) {
-  if (!paymasterAndData || !util.isHex(paymasterAndData)) return null;
+function decodePhantomBidDeclaration(paymasterAndData) {
+  const absent = { acceptedSources: null, uniswapV4Positions: [] };
+  if (!paymasterAndData || !util.isHex(paymasterAndData)) return absent;
   const bytes = util.hexToU8a(paymasterAndData);
-  if (bytes.length < 2 || bytes[0] !== DECLARATION_VERSION) return null;
-  const count = bytes[1];
+  if (bytes.length < 2) return absent;
+  const version = bytes[0];
+  if (version !== DECLARATION_V1 && version !== DECLARATION_V2) return absent;
   const chains = [];
   let offset = 2;
-  for (let entry = 0; entry < count; entry++) {
-    if (offset >= bytes.length) return null;
+  for (let entry = 0; entry < bytes[1]; entry++) {
+    if (offset >= bytes.length) return absent;
     const length = bytes[offset];
     offset += 1;
-    if (length === 0 || offset + length > bytes.length) return null;
+    if (length === 0 || offset + length > bytes.length) return absent;
     chains.push(util.u8aToString(bytes.subarray(offset, offset + length)));
     offset += length;
   }
-  if (offset !== bytes.length) return null;
-  return chains;
+  const positions = [];
+  if (version === DECLARATION_V2) {
+    if (offset >= bytes.length) return absent;
+    const count = bytes[offset];
+    offset += 1;
+    for (let entry = 0; entry < count; entry++) {
+      if (offset >= bytes.length) return absent;
+      const length = bytes[offset];
+      offset += 1;
+      if (length === 0 || length > MAX_TOKEN_ID_BYTES || offset + length > bytes.length) return absent;
+      let tokenId = 0n;
+      for (const byte of bytes.subarray(offset, offset + length)) tokenId = tokenId << 8n | BigInt(byte);
+      positions.push(tokenId);
+      offset += length;
+    }
+  }
+  if (offset !== bytes.length) return absent;
+  return { acceptedSources: chains, uniswapV4Positions: positions };
+}
+function encodeAcceptedSourceChains(chains) {
+  return encodePhantomBidDeclaration({ acceptedSourceChains: chains });
+}
+function decodeAcceptedSourceChains(paymasterAndData) {
+  return decodePhantomBidDeclaration(paymasterAndData).acceptedSources;
 }
 function zipFillLegs(assets, outputs) {
   return assets.map((asset, index) => {
@@ -2475,17 +2659,46 @@ async function isDelegatedToSolverAccount(evmRpcUrl, account, solverAccount) {
     method: "eth_getCode",
     params: [account, "latest"]
   });
-  const code = typeof response.result === "string" ? response.result.toLowerCase() : "";
+  if (typeof response.result !== "string") {
+    throw new PhantomRpcError(`eth_getCode returned no code for ${account} on ${evmRpcUrl}`);
+  }
+  const code = response.result.toLowerCase();
   if (!code.startsWith(DELEGATION_INDICATOR_PREFIX)) return false;
   return `0x${code.slice(DELEGATION_INDICATOR_PREFIX.length)}` === solverAccount.toLowerCase();
 }
+function memoizedDelegationCheck() {
+  const cache = /* @__PURE__ */ new Map();
+  return (evmRpcUrl, account, solverAccount) => {
+    const key = `${evmRpcUrl}|${account.toLowerCase()}|${solverAccount.toLowerCase()}`;
+    let pending = cache.get(key);
+    if (!pending) {
+      pending = isDelegatedToSolverAccount(evmRpcUrl, account, solverAccount).catch((err) => {
+        cache.delete(key);
+        throw err;
+      });
+      cache.set(key, pending);
+    }
+    return pending;
+  };
+}
 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 {
+    userOp,
+    commitment,
+    sessionKey,
+    chainId,
+    solverAccount,
+    evmRpcUrl,
+    recoverSigner,
+    bidNonceKey,
+    isDelegated,
+    logger
+  } = params;
   const solver = userOp.sender;
   const parsed = splitBidSignature(userOp.signature);
   if (!parsed) {
@@ -2508,7 +2721,7 @@ async function isVerifiedSolverBid(params) {
     logger?.warn({ solver, commitment, signer }, "Rejecting phantom bid: signature does not recover to the sender");
     return false;
   }
-  if (!await isDelegatedToSolverAccount(evmRpcUrl, solver, solverAccount)) {
+  if (!await isDelegated(evmRpcUrl, solver, solverAccount)) {
     logger?.warn({ solver, commitment, solverAccount }, "Rejecting phantom bid: sender is not a delegated solver");
     return false;
   }
@@ -2524,18 +2737,17 @@ async function fetchBidsForOrder(nodeUrl, 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"]
-    });
-    if (result.error || !result.result || result.result === "0x") return 0n;
-    return BigInt(result.result);
-  } catch {
-    return 0n;
+  const result = await rpcCall(evmRpcUrl, {
+    id: 1,
+    jsonrpc: "2.0",
+    method: "eth_call",
+    params: [{ to, data }, "latest"]
+  });
+  if (result.result === "0x") return 0n;
+  if (typeof result.result !== "string") {
+    throw new PhantomRpcError(`eth_call returned no result for ${to} on ${evmRpcUrl}`);
   }
+  return BigInt(result.result);
 }
 async function getTotalSolverBalance(evmRpcUrl, chain, token, solver, yieldVaults) {
   const padded = solver.replace("0x", "").padStart(64, "0");
@@ -2547,27 +2759,104 @@ async function getTotalSolverBalance(evmRpcUrl, chain, token, solver, yieldVault
   );
   return vaultBalances.reduce((acc, b) => acc + b, raw);
 }
+var SELECTOR_OWNER_OF = "0x6352211e";
+var SELECTOR_POSITION_LIQUIDITY = "0x1efeed33";
+var SELECTOR_POOL_AND_POSITION_INFO = "0x7ba03aad";
+var SELECTOR_GET_SLOT0 = "0xc815641c";
+var uint256Arg = (value) => value.toString(16).padStart(64, "0");
+async function readV4Position(evmRpcUrl, contracts, tokenId, keccak, logger) {
+  const call = async (to, data) => {
+    const result = await rpcCall(evmRpcUrl, {
+      id: 1,
+      jsonrpc: "2.0",
+      method: "eth_call",
+      params: [{ to, data }, "latest"]
+    });
+    if (result.result === "0x") return null;
+    if (typeof result.result !== "string") {
+      throw new PhantomRpcError(`eth_call returned no result for ${to} on ${evmRpcUrl}`);
+    }
+    return result.result;
+  };
+  const arg = uint256Arg(tokenId);
+  const [ownerData, infoData, liquidityData] = await Promise.all([
+    call(contracts.positionManager, `${SELECTOR_OWNER_OF}${arg}`),
+    call(contracts.positionManager, `${SELECTOR_POOL_AND_POSITION_INFO}${arg}`),
+    call(contracts.positionManager, `${SELECTOR_POSITION_LIQUIDITY}${arg}`)
+  ]);
+  if (!ownerData) return null;
+  if (!infoData || !liquidityData) {
+    logger?.warn(
+      { tokenId: tokenId.toString(), positionManager: contracts.positionManager },
+      "Uniswap V4 position exists but its pool info or liquidity did not read back \u2014 check the configured PositionManager"
+    );
+    return null;
+  }
+  const info = decodePoolAndPositionInfo(infoData);
+  const slot0Data = await call(contracts.stateView, `${SELECTOR_GET_SLOT0}${keccak(info.poolKeyEncoded).slice(2)}`);
+  if (!slot0Data) {
+    logger?.warn(
+      { tokenId: tokenId.toString(), stateView: contracts.stateView, evmRpcUrl },
+      "Uniswap V4 slot0 read returned nothing for a live position \u2014 the configured StateView address is wrong"
+    );
+    return null;
+  }
+  return {
+    owner: `0x${ownerData.slice(-40)}`.toLowerCase(),
+    info,
+    liquidity: word(liquidityData, 0),
+    sqrtPriceX96: word(slot0Data, 0)
+  };
+}
+function memoizedV4Position(keccak, logger) {
+  const cache = /* @__PURE__ */ new Map();
+  return (evmRpcUrl, chain, contracts, tokenId) => {
+    const key = `${chain}|${tokenId}`;
+    let pending = cache.get(key);
+    if (!pending) {
+      pending = readV4Position(evmRpcUrl, contracts, tokenId, keccak, logger).catch((err) => {
+        cache.delete(key);
+        throw err;
+      });
+      cache.set(key, pending);
+    }
+    return pending;
+  };
+}
 function memoizedSolverBalance(yieldVaults) {
   const cache = /* @__PURE__ */ new Map();
   return (evmRpcUrl, chain, token, solver) => {
     const key = `${chain}|${token.toLowerCase()}|${solver.toLowerCase()}`;
     let pending = cache.get(key);
     if (!pending) {
-      pending = getTotalSolverBalance(evmRpcUrl, chain, token, solver, yieldVaults);
+      pending = getTotalSolverBalance(evmRpcUrl, chain, token, solver, yieldVaults).catch((err) => {
+        cache.delete(key);
+        throw err;
+      });
       cache.set(key, pending);
     }
     return pending;
   };
 }
-async function sweepSolverLiquidity(evmRpcUrls, yieldVaults, solver, getBalance) {
+async function sweepSolverLiquidity(evmRpcUrls, yieldVaults, solver, getBalance, positions) {
   const balances = [];
   for (const [chain, tokens] of Object.entries(yieldVaults)) {
     const url = evmRpcUrls[chain];
     if (!url) continue;
     for (const token of Object.keys(tokens)) {
       const balance = await getBalance(url, chain, token, solver);
-      if (balance === 0n) continue;
-      balances.push({ solver, chain, tokenAddress: token, balance });
+      const uniswapV4Balance = chain === positions.chain ? positions.states.reduce(
+        (total2, state) => total2 + positionAmountOfToken({
+          info: state.info,
+          liquidity: state.liquidity,
+          sqrtPriceX96: state.sqrtPriceX96,
+          outputToken: token
+        }),
+        0n
+      ) : 0n;
+      const total = balance + uniswapV4Balance;
+      if (total === 0n) continue;
+      balances.push({ solver, chain, tokenAddress: token, balance: total });
     }
   }
   return balances;
@@ -2578,6 +2867,24 @@ function toAddress(token) {
   return `0x${addr}`;
 }
 async function aggregatePhantomBids(params) {
+  const isDelegated = memoizedDelegationCheck();
+  let lastErr;
+  for (let attempt = 1; attempt <= AGGREGATION_ATTEMPTS; attempt++) {
+    try {
+      return await runAggregation(params, isDelegated);
+    } catch (err) {
+      lastErr = err;
+      params.logger?.warn(
+        { err, commitment: params.commitment, chain: params.chain, attempt, of: AGGREGATION_ATTEMPTS },
+        "Phantom aggregation attempt failed"
+      );
+      if (attempt < AGGREGATION_ATTEMPTS) await new Promise((resolve) => setTimeout(resolve, 250 * attempt));
+    }
+  }
+  throw lastErr;
+}
+var AGGREGATION_ATTEMPTS = 5;
+async function runAggregation(params, isDelegated) {
   const { nodeUrl, evmRpcUrls, chain, gatewayAddress, commitment, yieldVaults, solverAccount, logger } = params;
   const extractFill = params.extractFill ?? extractFillData;
   const recoverSigner = params.recoverSigner ?? recoverBidSignerViem;
@@ -2592,6 +2899,8 @@ async function aggregatePhantomBids(params) {
   }
   const bids = await fetchBidsForOrder(nodeUrl, commitment);
   if (bids.length === 0) return null;
+  const v4Contracts = params.uniswapV4?.[chain];
+  const readPosition = memoizedV4Position(params.keccak ?? viem.keccak256, logger);
   const getBalance = params.getBalance ?? memoizedSolverBalance(yieldVaults);
   const quotesByLeg = /* @__PURE__ */ new Map();
   const lpBalances = [];
@@ -2622,6 +2931,7 @@ async function aggregatePhantomBids(params) {
         evmRpcUrl: destUrl,
         recoverSigner,
         bidNonceKey,
+        isDelegated,
         logger
       });
       if (!verified) continue;
@@ -2631,12 +2941,39 @@ async function aggregatePhantomBids(params) {
         continue;
       }
       countedSolvers.add(normalizedSolver);
-      const acceptedSources = decodeAcceptedSourceChains(decoded.paymasterAndData);
+      const declaration = decodePhantomBidDeclaration(decoded.paymasterAndData);
+      const acceptedSources = declaration.acceptedSources;
       const quotedLegs = [...fillData.legs.entries()].filter(([, leg]) => leg.solverAmount !== 0n);
+      const declaredPositions = v4Contracts ? declaration.uniswapV4Positions : [];
+      const positions = (await Promise.all(
+        declaredPositions.map((tokenId) => readPosition(destUrl, chain, v4Contracts, tokenId))
+      )).filter((state, index) => {
+        if (!state) return false;
+        if (state.owner !== normalizedSolver) {
+          logger?.warn(
+            { solver, commitment, tokenId: declaredPositions[index].toString(), owner: state.owner },
+            "Ignoring declared Uniswap V4 position: not owned by the bidding solver"
+          );
+          return false;
+        }
+        return true;
+      });
       const weights = await Promise.all(
         // Price influence: the solver's liquidity in THIS leg's output token on the destination
         // chain, so a leg is weighted by the inventory that actually backs it.
-        quotedLegs.map(([, leg]) => getBalance(destUrl, chain, toAddress(leg.outputToken), solver))
+        quotedLegs.map(async ([, leg]) => {
+          const outputToken = toAddress(leg.outputToken);
+          const balance = await getBalance(destUrl, chain, outputToken, solver);
+          return positions.reduce(
+            (total, state) => total + positionAmountOfToken({
+              info: state.info,
+              liquidity: state.liquidity,
+              sqrtPriceX96: state.sqrtPriceX96,
+              outputToken
+            }),
+            balance
+          );
+        })
       );
       for (const [position, [legIndex, leg]] of quotedLegs.entries()) {
         const weight = weights[position];
@@ -2645,23 +2982,40 @@ async function aggregatePhantomBids(params) {
         entry.bidders.push({ solver: normalizedSolver, weight, acceptedSources });
         quotesByLeg.set(legIndex, entry);
       }
-      lpBalances.push(...await sweepSolverLiquidity(evmRpcUrls, yieldVaults, solver, getBalance));
+      lpBalances.push(
+        ...await sweepSolverLiquidity(evmRpcUrls, yieldVaults, solver, getBalance, {
+          chain,
+          states: positions
+        })
+      );
     } catch (err) {
+      if (err instanceof PhantomRpcError) throw err;
       logger?.warn({ err, filler: bid.filler }, "Failed to process bid for price snapshot");
     }
   }
   if (quotesByLeg.size === 0) return null;
-  const legs = [...quotesByLeg.entries()].sort(([a], [b]) => a - b).map(([legIndex, { outputToken, quotes, bidders }]) => {
-    const medianPrice = weightedMedian(quotes);
-    return {
-      legIndex,
-      outputToken,
-      lowestPrice: medianPrice,
-      highestPrice: medianPrice,
-      medianPrice,
-      bidCount: quotes.length,
-      bidders
-    };
+  const legs = [...quotesByLeg.entries()].sort(([a], [b]) => a - b).flatMap(([legIndex, { outputToken, quotes, bidders }]) => {
+    const backedQuotes = quotes.filter((quote) => quote.weight > 0n);
+    const backedBidders = bidders.filter((bidder) => bidder.weight > 0n);
+    if (backedQuotes.length === 0) {
+      logger?.warn(
+        { commitment, chain, legIndex, outputToken, quotes: quotes.length },
+        "Dropping phantom leg: no bidder holds the output token on this chain, so no quote is backed"
+      );
+      return [];
+    }
+    const medianPrice = weightedMedian(backedQuotes);
+    return [
+      {
+        legIndex,
+        outputToken,
+        lowestPrice: medianPrice,
+        highestPrice: medianPrice,
+        medianPrice,
+        bidCount: backedQuotes.length,
+        bidders: backedBidders
+      }
+    ];
   });
   return { legs, lpBalances };
 }
@@ -2672,9 +3026,11 @@ exports.IntentGatewayV2 = IntentGatewayV2_default;
 exports.aggregatePhantomBids = aggregatePhantomBids;
 exports.decodeAcceptedSourceChains = decodeAcceptedSourceChains;
 exports.decodeERC7821ExecuteBatch = decodeERC7821ExecuteBatch;
+exports.decodePhantomBidDeclaration = decodePhantomBidDeclaration;
 exports.decodeUserOpScale = decodeUserOpScale;
 exports.encodeAcceptedSourceChains = encodeAcceptedSourceChains;
 exports.encodeERC7821ExecuteBatch = encodeERC7821ExecuteBatch;
+exports.encodePhantomBidDeclaration = encodePhantomBidDeclaration;
 exports.encodeUserOpScale = encodeUserOpScale;
 exports.extractFillData = extractFillData;
 exports.fetchBidsForOrder = fetchBidsForOrder;