@hyperbridge/sdk 2.7.2 → 2.8.2

package/dist/node/intents-helpers.js

@@ -1,6 +1,6 @@
 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 { hexToU8a, u8aToHex, stringToU8a, isHex, u8aToString } from '@polkadot/util';
 import '@polkadot/util-crypto';
 import { Struct, Vector, u8, Bytes } from 'scale-ts';
 import 'p-queue';
@@ -1608,6 +1608,24 @@ var ABI2 = [
             internalType: "uint256"
           }
         ]
+      },
+      {
+        name: "predispatchCall",
+        type: "bytes",
+        indexed: false,
+        internalType: "bytes"
+      },
+      {
+        name: "outputCall",
+        type: "bytes",
+        indexed: false,
+        internalType: "bytes"
+      },
+      {
+        name: "graffiti",
+        type: "bytes32",
+        indexed: false,
+        internalType: "bytes32"
       }
     ],
     anonymous: false
@@ -2338,6 +2356,49 @@ async function rpcCall(url, payload) {
   throw 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`);
+  }
+  const bytes = [DECLARATION_VERSION, chains.length];
+  for (const chain of chains) {
+    const encoded = stringToU8a(chain);
+    if (encoded.length === 0 || encoded.length > 255) {
+      throw new Error(`Invalid state machine id in source chain declaration: ${chain}`);
+    }
+    bytes.push(encoded.length, ...encoded);
+  }
+  return u8aToHex(new Uint8Array(bytes));
+}
+function decodeAcceptedSourceChains(paymasterAndData) {
+  if (!paymasterAndData || !isHex(paymasterAndData)) return null;
+  const bytes = hexToU8a(paymasterAndData);
+  if (bytes.length < 2 || bytes[0] !== DECLARATION_VERSION) return null;
+  const count = bytes[1];
+  const chains = [];
+  let offset = 2;
+  for (let entry = 0; entry < count; entry++) {
+    if (offset >= bytes.length) return null;
+    const length = bytes[offset];
+    offset += 1;
+    if (length === 0 || offset + length > bytes.length) return null;
+    chains.push(u8aToString(bytes.subarray(offset, offset + length)));
+    offset += length;
+  }
+  if (offset !== bytes.length) return null;
+  return chains;
+}
+function zipFillLegs(assets, outputs) {
+  return assets.map((asset, index) => {
+    const rawAmount = outputs[index]?.amount;
+    return {
+      outputToken: asset.token,
+      solverAmount: rawAmount === void 0 || rawAmount === null ? 0n : BigInt(rawAmount.toString())
+    };
+  });
+}
 function weightedMedian(entries) {
   const sorted = [...entries].sort((a, b) => a.price < b.price ? -1 : a.price > b.price ? 1 : 0);
   const totalWeight = sorted.reduce((acc, e) => e.weight > 0n ? acc + e.weight : acc, 0n);
@@ -2363,10 +2424,10 @@ function extractFillData(callData, gatewayAddress) {
       if (decoded.functionName !== "fillOrder" || !decoded.args || decoded.args.length < 2) continue;
       const order = decoded.args[0];
       const options = decoded.args[1];
-      const outputToken = order?.output?.assets?.[0]?.token;
+      const assets = order?.output?.assets;
       const outputs = options?.outputs;
-      if (!outputToken || !outputs?.length) continue;
-      return { order, options, outputToken, solverAmount: outputs[0].amount };
+      if (!assets?.length || !outputs?.length) continue;
+      return { order, options, legs: zipFillLegs(assets, outputs) };
     } catch {
       continue;
     }
@@ -2484,13 +2545,25 @@ async function getTotalSolverBalance(evmRpcUrl, chain, token, solver, yieldVault
   );
   return vaultBalances.reduce((acc, b) => acc + b, raw);
 }
-async function sweepSolverLiquidity(evmRpcUrls, yieldVaults, solver) {
+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);
+      cache.set(key, pending);
+    }
+    return pending;
+  };
+}
+async function sweepSolverLiquidity(evmRpcUrls, yieldVaults, solver, getBalance) {
   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 getTotalSolverBalance(url, chain, token, solver, yieldVaults);
+      const balance = await getBalance(url, chain, token, solver);
       if (balance === 0n) continue;
       balances.push({ solver, chain, tokenAddress: token, balance });
     }
@@ -2517,7 +2590,8 @@ async function aggregatePhantomBids(params) {
   }
   const bids = await fetchBidsForOrder(nodeUrl, commitment);
   if (bids.length === 0) return null;
-  const quotes = [];
+  const getBalance = params.getBalance ?? memoizedSolverBalance(yieldVaults);
+  const quotesByLeg = /* @__PURE__ */ new Map();
   const lpBalances = [];
   const countedSolvers = /* @__PURE__ */ new Set();
   for (const bid of bids) {
@@ -2555,25 +2629,52 @@ async function aggregatePhantomBids(params) {
         continue;
       }
       countedSolvers.add(normalizedSolver);
-      const outputTokenAddress = toAddress(fillData.outputToken);
-      const weight = await getTotalSolverBalance(destUrl, chain, outputTokenAddress, solver, yieldVaults);
-      quotes.push({ price: fillData.solverAmount, weight });
-      lpBalances.push(...await sweepSolverLiquidity(evmRpcUrls, yieldVaults, solver));
+      const acceptedSources = decodeAcceptedSourceChains(decoded.paymasterAndData);
+      const quotedLegs = [...fillData.legs.entries()].filter(([, leg]) => leg.solverAmount !== 0n);
+      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))
+      );
+      for (const [position, [legIndex, leg]] of quotedLegs.entries()) {
+        const weight = weights[position];
+        const entry = quotesByLeg.get(legIndex) ?? { outputToken: leg.outputToken, quotes: [], bidders: [] };
+        entry.quotes.push({ price: leg.solverAmount, weight });
+        entry.bidders.push({ solver: normalizedSolver, weight, acceptedSources });
+        quotesByLeg.set(legIndex, entry);
+      }
+      lpBalances.push(...await sweepSolverLiquidity(evmRpcUrls, yieldVaults, solver, getBalance));
     } catch (err) {
       logger?.warn({ err, filler: bid.filler }, "Failed to process bid for price snapshot");
     }
   }
-  if (quotes.length === 0) return null;
-  const medianPrice = weightedMedian(quotes);
-  return {
-    lowestPrice: medianPrice,
-    highestPrice: medianPrice,
-    medianPrice,
-    bidCount: quotes.length,
-    lpBalances
-  };
+  if (quotesByLeg.size === 0) return null;
+  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 };
 }
 
-export { ENTRY_POINT_V08_ADDRESS, FILL_ORDER_ABI, IntentGatewayV2_default as IntentGatewayV2, aggregatePhantomBids, decodeERC7821ExecuteBatch, decodeUserOpScale, encodeERC7821ExecuteBatch, encodeUserOpScale, extractFillData, fetchBidsForOrder, orderCommitmentFromDecoded, recoverBidSignerViem, setAggregationFetch, splitBidSignature, weightedMedian };
+export { ENTRY_POINT_V08_ADDRESS, FILL_ORDER_ABI, IntentGatewayV2_default as IntentGatewayV2, aggregatePhantomBids, decodeAcceptedSourceChains, decodeERC7821ExecuteBatch, decodeUserOpScale, encodeAcceptedSourceChains, encodeERC7821ExecuteBatch, encodeUserOpScale, extractFillData, fetchBidsForOrder, memoizedSolverBalance, orderCommitmentFromDecoded, recoverBidSignerViem, setAggregationFetch, splitBidSignature, weightedMedian, zipFillLegs };
 //# sourceMappingURL=intents-helpers.js.map
 //# sourceMappingURL=intents-helpers.js.map