@yodlpay/payment-decoder 1.3.0 → 1.3.2

package/dist/index.js

@@ -44,9 +44,11 @@ async function detectChain(hash, clients) {
 }
 
 // src/decode-utils.ts
+import { tokenlist } from "@yodlpay/tokenlists";
 import {
   decodeEventLog,
-  erc20Abi,
+  erc20Abi as erc20Abi2,
+  getAddress,
   isAddressEqual
 } from "viem";
 
@@ -113,7 +115,13 @@ function isExpectedDecodeError(error) {
 }
 
 // src/utils.ts
-import { hexToString } from "viem";
+import { getTokenByAddress } from "@yodlpay/tokenlists";
+import {
+  erc20Abi,
+  getContract,
+  hexToString
+} from "viem";
+import { z } from "zod";
 function decodeMemo(memo) {
   if (!memo || memo === "0x") return "";
   try {
@@ -122,6 +130,27 @@ function decodeMemo(memo) {
     return "";
   }
 }
+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, chainId, client) {
+  try {
+    return getTokenByAddress(address, chainId);
+  } catch {
+    const token = getContract({ address, abi: erc20Abi, client });
+    const [name, symbol, decimals] = await Promise.all([
+      token.read.name(),
+      token.read.symbol(),
+      token.read.decimals()
+    ]);
+    return {
+      chainId,
+      address,
+      name: erc20String.parse(name),
+      symbol: erc20String.parse(symbol),
+      decimals: erc20Decimals.parse(decimals)
+    };
+  }
+}
 
 // src/decode-utils.ts
 function* matchingEvents(logs, options) {
@@ -204,7 +233,7 @@ function decodeSwapFromLogs(logs) {
 function extractTokenTransfers(logs) {
   return collectEventsFromLogs(
     logs,
-    { abi: erc20Abi, eventName: "Transfer", context: "ERC20 Transfer" },
+    { abi: erc20Abi2, eventName: "Transfer", context: "ERC20 Transfer" },
     (decoded, log) => {
       const args = decoded.args;
       return {
@@ -216,13 +245,71 @@ function extractTokenTransfers(logs) {
     }
   );
 }
+function isKnownToken(address) {
+  return tokenlist.some((t) => isAddressEqual(t.address, address));
+}
+function transferSignature(t) {
+  return `${getAddress(t.from)}:${getAddress(t.to)}:${t.amount}`;
+}
+function areMirrorTransfers(a, b) {
+  if (a.length !== b.length) return false;
+  const counts = /* @__PURE__ */ new Map();
+  for (const t of a) {
+    const key = transferSignature(t);
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  for (const t of b) {
+    const key = transferSignature(t);
+    const count = counts.get(key);
+    if (!count) return false;
+    if (count === 1) counts.delete(key);
+    else counts.set(key, count - 1);
+  }
+  return counts.size === 0;
+}
+function detectMirrorTokens(allTransfers) {
+  const mirrors = /* @__PURE__ */ new Map();
+  const byToken = /* @__PURE__ */ new Map();
+  for (const t of allTransfers) {
+    const key = getAddress(t.token);
+    const group = byToken.get(key);
+    group ? group.push(t) : byToken.set(key, [t]);
+  }
+  const tokens = [...byToken.keys()];
+  for (const [i, tokenA] of tokens.entries()) {
+    if (mirrors.has(tokenA)) continue;
+    const transfersA = byToken.get(tokenA) ?? [];
+    for (const tokenB of tokens.slice(i + 1)) {
+      if (mirrors.has(tokenB)) continue;
+      const transfersB = byToken.get(tokenB) ?? [];
+      if (!areMirrorTransfers(transfersA, transfersB)) continue;
+      if (isKnownToken(tokenB) && !isKnownToken(tokenA)) {
+        mirrors.set(tokenA, tokenB);
+      } else {
+        mirrors.set(tokenB, tokenA);
+      }
+    }
+  }
+  return mirrors;
+}
 function findInputTransfer(transfers, sender) {
   const fromSender = transfers.filter((t) => isAddressEqual(t.from, sender));
   if (fromSender.length === 0) return void 0;
-  const largest = fromSender.reduce(
-    (max, t) => t.amount > max.amount ? t : max
+  const maxAmount = fromSender.reduce(
+    (max, t) => t.amount > max ? t.amount : max,
+    0n
   );
-  return { token: largest.token, amount: largest.amount };
+  let candidates = fromSender.filter((t) => t.amount === maxAmount);
+  if (candidates.length > 1) {
+    const mirrors = detectMirrorTokens(transfers);
+    const filtered = candidates.filter(
+      (t) => !mirrors.has(getAddress(t.token))
+    );
+    if (filtered.length > 0) candidates = filtered;
+  }
+  const result = candidates.find((t) => isKnownToken(t.token)) ?? candidates[0];
+  if (!result) return void 0;
+  return { token: result.token, amount: result.amount };
 }
 function toBlockTimestamp(block) {
   return new Date(Number(block.timestamp) * 1e3);
@@ -245,20 +332,20 @@ import { decodeFunctionData, toFunctionSelector } from "viem";
 // src/validation.ts
 import { chains as chains2 } from "@yodlpay/tokenlists";
 import { isAddress, isHex } from "viem";
-import { z } from "zod";
+import { z as z2 } from "zod";
 var validChainIds = chains2.map((c) => c.id);
-var txHashSchema = z.string().regex(/^0x[a-fA-F0-9]{64}$/, "Invalid transaction hash").transform((val) => val);
-var chainIdSchema = z.coerce.number().int().refine((id) => validChainIds.includes(id), {
+var txHashSchema = z2.string().regex(/^0x[a-fA-F0-9]{64}$/, "Invalid transaction hash").transform((val) => val);
+var chainIdSchema = z2.coerce.number().int().refine((id) => validChainIds.includes(id), {
   message: `Chain ID must be one of: ${validChainIds.join(", ")}`
 });
-var ArgsSchema = z.union([
-  z.tuple([txHashSchema, chainIdSchema]),
-  z.tuple([txHashSchema])
+var ArgsSchema = z2.union([
+  z2.tuple([txHashSchema, chainIdSchema]),
+  z2.tuple([txHashSchema])
 ]);
-var WebhooksSchema = z.array(
-  z.object({
-    webhookAddress: z.string().refine((val) => isAddress(val)),
-    payload: z.array(z.string().refine((val) => isHex(val)))
+var WebhooksSchema = z2.array(
+  z2.object({
+    webhookAddress: z2.string().refine((val) => isAddress(val)),
+    payload: z2.array(z2.string().refine((val) => isHex(val)))
   }).transform((webhook) => ({
     ...webhook,
     memo: webhook.payload[0] ? decodeMemo(webhook.payload[0]) : ""
@@ -296,7 +383,7 @@ function extractEmbeddedParams(data) {
 }
 
 // src/relay-bridge.ts
-import { getRouter, getTokenByAddress } from "@yodlpay/tokenlists";
+import { getRouter } from "@yodlpay/tokenlists";
 import {
   decodeEventLog as decodeEventLog2,
   isAddressEqual as isAddressEqual2
@@ -330,15 +417,15 @@ async function fetchRelayRequest(hash) {
 }
 
 // src/relay-bridge.ts
-function calculateOutputAmountGross(inputAmount, inputToken, inputChainId, outputToken, outputChainId) {
-  const { decimals: inputDecimals } = getTokenByAddress(
-    inputToken,
-    inputChainId
-  );
-  const { decimals: outputDecimals } = getTokenByAddress(
-    outputToken,
-    outputChainId
-  );
+async function calculateOutputAmountGross(inputAmount, inputToken, inputChainId, outputToken, outputChainId, clients) {
+  const [{ decimals: inputDecimals }, { decimals: outputDecimals }] = await Promise.all([
+    resolveToken(inputToken, inputChainId, getClient(clients, inputChainId)),
+    resolveToken(
+      outputToken,
+      outputChainId,
+      getClient(clients, outputChainId)
+    )
+  ]);
   const decimalDiff = inputDecimals - outputDecimals;
   if (decimalDiff === 0) return inputAmount;
   if (decimalDiff > 0) return inputAmount / 10n ** BigInt(decimalDiff);
@@ -362,7 +449,7 @@ async function extractSenderFromSource(sourceReceipt, sourceProvider, sourceHash
   const sourceTx = await sourceProvider.getTransaction({ hash: sourceHash });
   return sourceTx.from;
 }
-function resolveBridgeTokens(sourceReceipt, destReceipt, yodlEvent, sender, inputAmountGross, inputChainId, outputChainId) {
+async function resolveBridgeTokens(sourceReceipt, destReceipt, yodlEvent, sender, inputAmountGross, inputChainId, outputChainId, clients) {
   const sourceTransfers = extractTokenTransfers(sourceReceipt.logs);
   const inputTransfer = findInputTransfer(sourceTransfers, sender);
   const tokenIn = inputTransfer?.token;
@@ -379,12 +466,13 @@ function resolveBridgeTokens(sourceReceipt, destReceipt, yodlEvent, sender, inpu
   if (swapEvent !== void 0) {
     tokenOutAmountGross = swapEvent.tokenOutAmount;
   } else if (inputAmountGross > 0n && tokenIn && tokenOut) {
-    tokenOutAmountGross = calculateOutputAmountGross(
+    tokenOutAmountGross = await calculateOutputAmountGross(
       inputAmountGross,
       tokenIn,
       inputChainId,
       tokenOut,
-      outputChainId
+      outputChainId,
+      clients
     );
   }
   return {
@@ -437,14 +525,15 @@ async function decodeBridgePayment(hash, clients) {
     destProvider.getTransaction({ hash: destinationTxHash }),
     extractSenderFromSource(sourceReceipt, sourceProvider, sourceTxHash)
   ]);
-  const tokens = resolveBridgeTokens(
+  const tokens = await resolveBridgeTokens(
     sourceReceipt,
     destReceipt,
     yodlEvent,
     sender,
     inputAmountGross,
     sourceChainId,
-    destinationChainId
+    destinationChainId,
+    clients
   );
   const bridge = {
     sourceChainId,
@@ -504,14 +593,23 @@ async function decodePayment(hash, chainId, clients, cachedReceipt) {
 }
 
 // src/yodl-payment.ts
-import { getTokenByAddress as getTokenByAddress2 } from "@yodlpay/tokenlists";
 import {
   formatUnits,
   zeroAddress
 } from "viem";
-function buildTokenInfo(params) {
-  const inToken = getTokenByAddress2(params.tokenIn, params.inChainId);
-  const outToken = getTokenByAddress2(params.tokenOut, params.outChainId);
+async function buildTokenInfo(params, clients) {
+  const [inToken, outToken] = await Promise.all([
+    resolveToken(
+      params.tokenIn,
+      params.inChainId,
+      getClient(clients, params.inChainId)
+    ),
+    resolveToken(
+      params.tokenOut,
+      params.outChainId,
+      getClient(clients, params.outChainId)
+    )
+  ]);
   return {
     tokenIn: {
       ...inToken,
@@ -533,19 +631,22 @@ function buildTokenInfo(params) {
     }
   };
 }
-function extractTokenInfo(paymentInfo, chainId, txHash) {
+async function extractTokenInfo(paymentInfo, chainId, txHash, clients) {
   switch (paymentInfo.type) {
     case "direct": {
       return {
-        ...buildTokenInfo({
-          tokenIn: paymentInfo.token,
-          tokenInAmount: paymentInfo.amount,
-          tokenOut: paymentInfo.token,
-          tokenOutAmountGross: paymentInfo.amount,
-          tokenOutAmountNet: paymentInfo.amount,
-          inChainId: chainId,
-          outChainId: chainId
-        }),
+        ...await buildTokenInfo(
+          {
+            tokenIn: paymentInfo.token,
+            tokenInAmount: paymentInfo.amount,
+            tokenOut: paymentInfo.token,
+            tokenOutAmountGross: paymentInfo.amount,
+            tokenOutAmountNet: paymentInfo.amount,
+            inChainId: chainId,
+            outChainId: chainId
+          },
+          clients
+        ),
         sourceChainId: chainId,
         sourceTxHash: txHash,
         destinationChainId: chainId,
@@ -555,15 +656,18 @@ function extractTokenInfo(paymentInfo, chainId, txHash) {
     }
     case "swap": {
       return {
-        ...buildTokenInfo({
-          tokenIn: paymentInfo.tokenIn,
-          tokenInAmount: paymentInfo.tokenInAmount,
-          tokenOut: paymentInfo.token,
-          tokenOutAmountGross: paymentInfo.tokenOutAmount,
-          tokenOutAmountNet: paymentInfo.amount,
-          inChainId: chainId,
-          outChainId: chainId
-        }),
+        ...await buildTokenInfo(
+          {
+            tokenIn: paymentInfo.tokenIn,
+            tokenInAmount: paymentInfo.tokenInAmount,
+            tokenOut: paymentInfo.token,
+            tokenOutAmountGross: paymentInfo.tokenOutAmount,
+            tokenOutAmountNet: paymentInfo.amount,
+            inChainId: chainId,
+            outChainId: chainId
+          },
+          clients
+        ),
         sourceChainId: chainId,
         sourceTxHash: txHash,
         destinationChainId: chainId,
@@ -573,15 +677,18 @@ function extractTokenInfo(paymentInfo, chainId, txHash) {
     }
     case "bridge": {
       return {
-        ...buildTokenInfo({
-          tokenIn: paymentInfo.tokenIn,
-          tokenInAmount: paymentInfo.tokenInAmount,
-          tokenOut: paymentInfo.tokenOut,
-          tokenOutAmountGross: paymentInfo.tokenOutAmountGross,
-          tokenOutAmountNet: paymentInfo.amount,
-          inChainId: paymentInfo.sourceChainId,
-          outChainId: paymentInfo.destinationChainId
-        }),
+        ...await buildTokenInfo(
+          {
+            tokenIn: paymentInfo.tokenIn,
+            tokenInAmount: paymentInfo.tokenInAmount,
+            tokenOut: paymentInfo.tokenOut,
+            tokenOutAmountGross: paymentInfo.tokenOutAmountGross,
+            tokenOutAmountNet: paymentInfo.amount,
+            inChainId: paymentInfo.sourceChainId,
+            outChainId: paymentInfo.destinationChainId
+          },
+          clients
+        ),
         sourceChainId: paymentInfo.sourceChainId,
         sourceTxHash: paymentInfo.sourceTxHash,
         destinationChainId: paymentInfo.destinationChainId,
@@ -601,7 +708,12 @@ async function decodeYodlPayment(txHash, chainId, clients, cachedReceipt) {
   const firstWebhook = paymentInfo.webhooks[0];
   const processorAddress = firstWebhook?.webhookAddress ?? zeroAddress;
   const processorMemo = firstWebhook?.memo ?? "";
-  const tokenInfo = extractTokenInfo(paymentInfo, chainId, txHash);
+  const tokenInfo = await extractTokenInfo(
+    paymentInfo,
+    chainId,
+    txHash,
+    clients
+  );
   return {
     senderAddress: paymentInfo.sender,
     receiverAddress: paymentInfo.receiver,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@yodlpay/payment-decoder",
-	"version": "1.3.0",
+	"version": "1.3.2",
 	"description": "Decode Yodl payment hashes into structured payment data",
 	"keywords": [
 		"yodl",
@@ -38,8 +38,8 @@
 		"prepublishOnly": "bun run build"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.3.14",
-		"@relayprotocol/relay-sdk": "^5.1.0",
+		"@biomejs/biome": "^2.4.4",
+		"@relayprotocol/relay-sdk": "^5.2.0",
 		"@semantic-release/changelog": "^6.0.3",
 		"@semantic-release/git": "^10.0.1",
 		"@types/bun": "latest",
@@ -48,7 +48,7 @@
 		"zod": "^4.3.6"
 	},
 	"dependencies": {
-		"@yodlpay/tokenlists": "^1.1.7"
+		"@yodlpay/tokenlists": "^1.1.12"
 	},
 	"peerDependencies": {
 		"typescript": "^5",