@yodlpay/payment-decoder 1.3.6 → 1.3.8

package/dist/index.js

@@ -30,8 +30,9 @@ import { tokenlist } from "@yodlpay/tokenlists";
 import {
   erc20Abi as erc20Abi2,
   getAddress,
-  isAddressEqual,
-  parseEventLogs
+  isAddressEqual as isAddressEqual2,
+  parseEventLogs,
+  zeroAddress as zeroAddress2
 } from "viem";
 
 // src/abi.ts
@@ -41,6 +42,9 @@ var yodlAbi = getRouterAbi("0.8");
 var relaySwapAbi = parseAbi([
   "event Swap(address indexed sender, address indexed recipient, address inputToken, address outputToken, uint256 inputAmount, uint256 outputAmount)"
 ]);
+var fundsMovementAbi = parseAbi([
+  "event FundsMovement(address from, address to, address currency, uint256 amount, bytes metadata)"
+]);
 
 // src/utils.ts
 import { getTokenByAddress } from "@yodlpay/tokenlists";
@@ -48,9 +52,17 @@ import {
   erc20Abi,
   getContract,
   hexToString,
-  stringify
+  isAddressEqual,
+  stringify,
+  zeroAddress
 } from "viem";
 import { z } from "zod";
+
+// src/chains.ts
+import { chains as allChains } from "@yodlpay/tokenlists";
+var chains = allChains.filter((c) => !c.testnet);
+
+// src/utils.ts
 function decodeMemo(memo) {
   if (!memo || memo === "0x") return "";
   try {
@@ -62,6 +74,19 @@ function decodeMemo(memo) {
 var erc20String = z.string().max(64).transform((s) => s.replace(/\p{Cc}/gu, ""));
 var erc20Decimals = z.number().int().nonnegative().max(36);
 async function resolveToken(address, chainId2, client) {
+  if (isAddressEqual(address, zeroAddress)) {
+    const chain = chains.find((c) => c.id === chainId2);
+    if (!chain) {
+      throw new Error(`Native token requested for unknown chainId ${chainId2}`);
+    }
+    return {
+      chainId: chainId2,
+      address,
+      name: chain.nativeCurrency.name,
+      symbol: chain.nativeCurrency.symbol,
+      decimals: chain.nativeCurrency.decimals
+    };
+  }
   try {
     return getTokenByAddress(address, chainId2);
   } catch {
@@ -85,7 +110,7 @@ async function resolveToken(address, chainId2, client) {
 function decodeYodlFromLogs(logs, routerAddress) {
   const parsed = parseEventLogs({
     abi: yodlAbi,
-    logs: logs.filter((l) => isAddressEqual(l.address, routerAddress)),
+    logs: logs.filter((l) => isAddressEqual2(l.address, routerAddress)),
     eventName: "Yodl",
     strict: true
   });
@@ -132,8 +157,22 @@ function extractTokenTransfers(logs) {
     return [{ token: log.address, from, to, amount: value }];
   });
 }
+function extractFundsMovements(logs) {
+  const parsed = parseEventLogs({
+    abi: fundsMovementAbi,
+    logs: [...logs],
+    eventName: "FundsMovement",
+    strict: false
+  });
+  return parsed.flatMap((log) => {
+    if (!log.args) return [];
+    const { from, to, currency, amount } = log.args;
+    if (!from || !to || !currency || amount === void 0) return [];
+    return [{ emitter: log.address, from, to, currency, amount }];
+  });
+}
 function isKnownToken(address) {
-  return tokenlist.some((t) => isAddressEqual(t.address, address));
+  return tokenlist.some((t) => isAddressEqual2(t.address, address));
 }
 function transferSignature(t) {
   return `${getAddress(t.from)}:${getAddress(t.to)}:${t.amount}`;
@@ -180,7 +219,7 @@ function detectMirrorTokens(allTransfers) {
   return mirrors;
 }
 function findInputTransfer(transfers, sender) {
-  const fromSender = transfers.filter((t) => isAddressEqual(t.from, sender));
+  const fromSender = transfers.filter((t) => isAddressEqual2(t.from, sender));
   if (fromSender.length === 0) return void 0;
   const maxAmount = fromSender.reduce(
     (max, t) => t.amount > max ? t.amount : max,
@@ -200,52 +239,68 @@ function findInputTransfer(transfers, sender) {
 }
 function inferSwapFromTransfers(logs, sender, yodlToken) {
   const transfers = extractTokenTransfers(logs);
+  const tokenOutAmount = transfers.filter(
+    (t) => isAddressEqual2(t.to, sender) && isAddressEqual2(t.token, yodlToken)
+  ).reduce((sum, t) => sum + t.amount, 0n);
+  if (tokenOutAmount === 0n) return void 0;
   const outgoingDifferentToken = transfers.filter(
-    (t) => isAddressEqual(t.from, sender) && !isAddressEqual(t.token, yodlToken)
+    (t) => isAddressEqual2(t.from, sender) && !isAddressEqual2(t.token, yodlToken)
   );
-  if (outgoingDifferentToken.length === 0) return void 0;
-  const byToken = /* @__PURE__ */ new Map();
-  for (const t of outgoingDifferentToken) {
-    const key = getAddress(t.token);
-    const existing = byToken.get(key);
-    if (existing) {
-      existing.gross += t.amount;
-    } else {
-      byToken.set(key, { token: t.token, gross: t.amount, refund: 0n });
+  if (outgoingDifferentToken.length > 0) {
+    const byToken = /* @__PURE__ */ new Map();
+    for (const t of outgoingDifferentToken) {
+      const key = getAddress(t.token);
+      const existing = byToken.get(key);
+      if (existing) {
+        existing.gross += t.amount;
+      } else {
+        byToken.set(key, { token: t.token, gross: t.amount, refund: 0n });
+      }
     }
-  }
-  const incomingNonYodl = transfers.filter(
-    (t) => isAddressEqual(t.to, sender) && !isAddressEqual(t.token, yodlToken)
-  );
-  for (const t of incomingNonYodl) {
-    const key = getAddress(t.token);
-    const existing = byToken.get(key);
-    if (existing) {
-      existing.refund += t.amount;
+    const incomingNonYodl = transfers.filter(
+      (t) => isAddressEqual2(t.to, sender) && !isAddressEqual2(t.token, yodlToken)
+    );
+    for (const t of incomingNonYodl) {
+      const key = getAddress(t.token);
+      const existing = byToken.get(key);
+      if (existing) {
+        existing.refund += t.amount;
+      }
+    }
+    let tokenIn;
+    let tokenInAmount = 0n;
+    for (const { token, gross, refund } of byToken.values()) {
+      const net = gross - refund;
+      if (net > tokenInAmount) {
+        tokenIn = token;
+        tokenInAmount = net;
+      }
     }
+    if (tokenIn && tokenInAmount > 0n) {
+      return {
+        tokenIn,
+        tokenOut: yodlToken,
+        tokenInAmount,
+        tokenOutAmount
+      };
+    }
+    return void 0;
   }
-  let tokenIn;
-  let tokenInAmount = 0n;
-  for (const { token, gross, refund } of byToken.values()) {
-    const net = gross - refund;
-    if (net > tokenInAmount) {
-      tokenIn = token;
-      tokenInAmount = net;
+  let nativeInAmount = 0n;
+  for (const movement of extractFundsMovements(logs)) {
+    if (!isAddressEqual2(movement.currency, zeroAddress2)) continue;
+    if (isAddressEqual2(movement.from, sender)) {
+      nativeInAmount += movement.amount;
+    }
+    if (isAddressEqual2(movement.to, sender)) {
+      nativeInAmount -= movement.amount;
     }
   }
-  if (!tokenIn || tokenInAmount <= 0n) return void 0;
-  const incomingYodlToken = transfers.filter(
-    (t) => isAddressEqual(t.to, sender) && isAddressEqual(t.token, yodlToken)
-  );
-  const tokenOutAmount = incomingYodlToken.reduce(
-    (sum, t) => sum + t.amount,
-    0n
-  );
-  if (tokenOutAmount === 0n) return void 0;
+  if (nativeInAmount <= 0n) return void 0;
   return {
-    tokenIn,
+    tokenIn: zeroAddress2,
     tokenOut: yodlToken,
-    tokenInAmount,
+    tokenInAmount: nativeInAmount,
     tokenOutAmount
   };
 }
@@ -267,12 +322,6 @@ import { decodeFunctionData, toFunctionSelector } from "viem";
 // src/validation.ts
 import { isAddress, isHash, isHex } from "viem";
 import { z as z2 } from "zod";
-
-// src/chains.ts
-import { chains as allChains } from "@yodlpay/tokenlists";
-var chains = allChains.filter((c) => !c.testnet);
-
-// src/validation.ts
 var validChainIds = chains.map((c) => c.id);
 var txHashSchema = z2.string().refine((val) => isHash(val), "Invalid transaction hash");
 var chainIdSchema = z2.coerce.number().int().refine((id) => validChainIds.includes(id), {
@@ -408,8 +457,10 @@ async function fetchAcrossDepositByTx(hash) {
 // src/bridges/relay-bridge.ts
 import { getRouter } from "@yodlpay/tokenlists";
 import {
-  isAddressEqual as isAddressEqual2,
-  parseEventLogs as parseEventLogs2
+  isAddress as isAddress2,
+  isAddressEqual as isAddressEqual3,
+  parseEventLogs as parseEventLogs2,
+  zeroAddress as zeroAddress3
 } from "viem";
 import { entryPoint08Abi, entryPoint08Address } from "viem/account-abstraction";
 
@@ -502,7 +553,7 @@ function extractSenderFromSource(sourceReceipt) {
   const userOps = parseEventLogs2({
     abi: entryPoint08Abi,
     logs: sourceReceipt.logs.filter(
-      (l) => isAddressEqual2(l.address, entryPoint08Address)
+      (l) => isAddressEqual3(l.address, entryPoint08Address)
     ),
     eventName: "UserOperationEvent"
   });
@@ -552,12 +603,15 @@ function parseRelayResponse(request) {
   if (!inTx?.hash || !inTx?.chainId || !outTx?.hash || !outTx?.chainId) {
     throw new NoBridgeFoundError();
   }
+  const rawInputToken = data?.metadata?.currencyIn?.currency?.address;
+  const inputToken = rawInputToken && isAddress2(rawInputToken) ? rawInputToken : void 0;
   return {
     sourceChainId: inTx.chainId,
     sourceTxHash: inTx.hash,
     destinationChainId: outTx.chainId,
     destinationTxHash: outTx.hash,
-    inputAmountGross: BigInt(data?.metadata?.currencyIn?.amount ?? 0)
+    inputAmountGross: BigInt(data?.metadata?.currencyIn?.amount ?? 0),
+    inputToken
   };
 }
 async function decodeRelayBridgePayment(hash, clients, options = {}) {
@@ -567,7 +621,8 @@ async function decodeRelayBridgePayment(hash, clients, options = {}) {
     sourceTxHash,
     destinationChainId,
     destinationTxHash,
-    inputAmountGross
+    inputAmountGross,
+    inputToken
   } = parseRelayResponse(request);
   const destProvider = clients[destinationChainId];
   const sourceProvider = clients[sourceChainId];
@@ -593,16 +648,33 @@ async function decodeRelayBridgePayment(hash, clients, options = {}) {
     destProvider.getBlock({ blockNumber: destReceipt.blockNumber }),
     destProvider.getTransaction({ hash: destinationTxHash })
   ]);
-  const tokens = await resolveBridgeTokens(
-    sourceReceipt,
-    destReceipt,
-    yodlEvent,
-    sender,
-    inputAmountGross,
-    sourceChainId,
-    destinationChainId,
-    clients
-  );
+  let tokens;
+  try {
+    tokens = await resolveBridgeTokens(
+      sourceReceipt,
+      destReceipt,
+      yodlEvent,
+      sender,
+      inputAmountGross,
+      sourceChainId,
+      destinationChainId,
+      clients
+    );
+  } catch (error) {
+    if (error instanceof ExpectedDecodeError && inputToken && isAddressEqual3(inputToken, zeroAddress3) && inputAmountGross > 0n) {
+      const swapEvent = decodeSwapFromLogs(destReceipt.logs);
+      const tokenOutAmountGross = swapEvent ? swapEvent.tokenOutAmount : yodlEvent.amount;
+      tokens = {
+        tokenIn: inputToken,
+        tokenInAmount: inputAmountGross,
+        tokenOut: yodlEvent.token,
+        tokenOutAmount: yodlEvent.amount,
+        tokenOutAmountGross
+      };
+    } else {
+      throw error;
+    }
+  }
   const bridge = {
     sourceChainId,
     sourceTxHash,
@@ -777,7 +849,7 @@ async function decodeBridgePayment(hash, clients, options = {}) {
 
 // src/core/payment-decoder.ts
 import { getRouter as getRouter3 } from "@yodlpay/tokenlists";
-import { isAddressEqual as isAddressEqual3 } from "viem";
+import { isAddressEqual as isAddressEqual4 } from "viem";
 async function tryDecodeBridge(hash, clients, options = {}) {
   try {
     return await decodeBridgePayment(hash, clients, options);
@@ -809,7 +881,7 @@ async function decodePayment(hash, chainId2, clients, cachedReceipt) {
       return { type: "swap", ...paymentEvent2, ...swapEvent };
     }
     const effectiveSender = extractSenderFromSource(receipt);
-    const isSameChainPayment = isAddressEqual3(
+    const isSameChainPayment = isAddressEqual4(
       effectiveSender,
       yodlEvent.sender
     );
@@ -848,11 +920,11 @@ async function decodePayment(hash, chainId2, clients, cachedReceipt) {
 // src/core/yodl-payment.ts
 import {
   formatUnits,
-  isAddressEqual as isAddressEqual4,
-  zeroAddress
+  isAddressEqual as isAddressEqual5,
+  zeroAddress as zeroAddress4
 } from "viem";
 async function buildTokenInfo(params, clients) {
-  const sameToken = isAddressEqual4(params.tokenIn, params.tokenOut) && params.inChainId === params.outChainId;
+  const sameToken = isAddressEqual5(params.tokenIn, params.tokenOut) && params.inChainId === params.outChainId;
   const [inToken, outToken] = sameToken ? await resolveToken(
     params.tokenIn,
     params.inChainId,
@@ -965,7 +1037,7 @@ async function decodeYodlPayment(txHash2, chainId2, clients, cachedReceipt) {
     cachedReceipt
   );
   const firstWebhook = paymentInfo.webhooks[0];
-  const processorAddress = firstWebhook?.webhookAddress ?? zeroAddress;
+  const processorAddress = firstWebhook?.webhookAddress ?? zeroAddress4;
   const processorMemo = firstWebhook?.memo ?? "";
   const tokenInfo = await extractTokenInfo(
     paymentInfo,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@yodlpay/payment-decoder",
-	"version": "1.3.6",
+	"version": "1.3.8",
 	"description": "Decode Yodl payment hashes into structured payment data",
 	"keywords": [
 		"yodl",