@yodlpay/payment-decoder 1.3.4 → 1.3.6

package/dist/index.d.ts

@@ -84,6 +84,8 @@ interface DecodeBridgeOptions {
     includeAcross?: boolean;
     /** Receipt of the fill (destination) tx, used for Across fill-side lookups. */
     fillReceipt?: TransactionReceipt;
+    /** Receipt of the source tx, used to skip re-fetching when hash is the source. */
+    sourceReceipt?: TransactionReceipt;
 }
 declare function decodeBridgePayment(hash: Hex, clients: ChainClients, options?: DecodeBridgeOptions): Promise<Extract<PaymentInfo, {
     type: "bridge";
@@ -107,6 +109,10 @@ interface DecodedYodlEvent {
  */
 declare function decodeYodlFromLogs(logs: readonly Log[], routerAddress: Address): DecodedYodlEvent | undefined;
 
+declare function decodePayment(hash: Hex, chainId: number, clients: ChainClients, cachedReceipt?: TransactionReceipt): Promise<PaymentInfo>;
+
+declare function decodeYodlPayment(txHash: Hex, chainId: number, clients: ChainClients, cachedReceipt?: TransactionReceipt): Promise<YodlPayment>;
+
 declare class NoBridgeFoundError extends Error {
     constructor(message?: string);
 }
@@ -114,8 +120,4 @@ declare class NoYodlEventError extends Error {
     constructor(message?: string);
 }
 
-declare function decodePayment(hash: Hex, chainId: number, clients: ChainClients, cachedReceipt?: TransactionReceipt): Promise<PaymentInfo>;
-
-declare function decodeYodlPayment(txHash: Hex, chainId: number, clients: ChainClients, cachedReceipt?: TransactionReceipt): Promise<YodlPayment>;
-
 export { type BridgeInfo, type ChainClients, type DecodedYodlEvent, NoBridgeFoundError, NoYodlEventError, type PaymentEvent, type PaymentInfo, type ServiceProvider, type SwapInfo, type TokenInInfo, type TokenOutInfo, type Webhook, type YodlPayment, createClients, decodeBridgePayment, decodePayment, decodeYodlFromLogs, decodeYodlPayment, detectChain };

package/dist/index.js

@@ -1,18 +1,7 @@
-// src/across-bridge.ts
-import { parseDepositLogs, parseFillLogs } from "@across-protocol/app-sdk";
-import { getRouter as getRouter2 } from "@yodlpay/tokenlists";
-
-// src/across-client.ts
-import { isHash } from "viem";
-import { z } from "zod";
+// src/bridges/bridge-payment.ts
+import { parseDepositLogs as parseDepositLogs2, parseFillLogs as parseFillLogs2 } from "@across-protocol/app-sdk";
 
 // src/errors.ts
-import {
-  AbiDecodingDataSizeTooSmallError,
-  AbiEventSignatureEmptyTopicsError,
-  AbiEventSignatureNotFoundError,
-  DecodeLogTopicsMismatch
-} from "viem";
 var ExpectedDecodeError = class extends Error {
   constructor(message = "Expected decode error") {
     super(message);
@@ -31,141 +20,37 @@ var NoYodlEventError = class extends Error {
     this.name = "NoYodlEventError";
   }
 };
-function isExpectedDecodeError(error) {
-  return error instanceof AbiEventSignatureNotFoundError || error instanceof AbiEventSignatureEmptyTopicsError || error instanceof AbiDecodingDataSizeTooSmallError || error instanceof DecodeLogTopicsMismatch;
-}
 
-// src/across-client.ts
-var ACROSS_API = "https://app.across.to/api/deposit/status";
-var ACROSS_TIMEOUT_MS = 8e3;
-var chainId = z.union([
-  z.number().int().positive(),
-  z.string().regex(/^\d+$/).transform(Number)
-]).pipe(z.number().int().positive());
-var txHash = z.string().refine((v) => isHash(v));
-var nullableTxHash = txHash.nullish().transform((v) => v ?? null);
-var depositId = z.union([
-  z.string().regex(/^\d+$/),
-  z.number().int().nonnegative().transform((v) => String(v))
-]);
-var AcrossDepositStatusSchema = z.object({
-  status: z.enum(["filled", "pending", "expired", "refunded"]),
-  originChainId: chainId,
-  destinationChainId: chainId,
-  depositId,
-  depositTxnRef: txHash.optional(),
-  depositTxHash: txHash.optional(),
-  fillTxnRef: nullableTxHash,
-  fillTx: nullableTxHash,
-  actionsSucceeded: z.boolean().nullish().transform((v) => v ?? null)
-}).transform((d) => {
-  const depositTxnRef = d.depositTxnRef ?? d.depositTxHash;
-  if (!depositTxnRef) {
-    throw new Error("Missing depositTxnRef and depositTxHash");
-  }
-  return {
-    status: d.status,
-    originChainId: d.originChainId,
-    destinationChainId: d.destinationChainId,
-    depositId: d.depositId,
-    depositTxnRef,
-    fillTxnRef: d.fillTxnRef ?? d.fillTx,
-    actionsSucceeded: d.actionsSucceeded
-  };
-});
-async function fetchAcrossDepositByDepositId(originChainId, depositId2) {
-  const url = new URL(ACROSS_API);
-  url.searchParams.set("originChainId", String(originChainId));
-  url.searchParams.set("depositId", depositId2);
-  return fetchAcrossDeposit(url);
-}
-async function fetchAcrossDeposit(url) {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), ACROSS_TIMEOUT_MS);
-  let response;
-  try {
-    response = await fetch(url, { signal: controller.signal });
-  } catch (error) {
-    const message = error instanceof Error && error.name === "AbortError" ? `Across API request timed out after ${ACROSS_TIMEOUT_MS}ms` : "Across API request failed";
-    throw new Error(message, { cause: error });
-  } finally {
-    clearTimeout(timeout);
-  }
-  if (response.status === 404) throw new NoBridgeFoundError();
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    const kind = response.status === 429 || response.status >= 500 ? "temporary error" : "error";
-    throw new Error(
-      `Across API ${kind} (${response.status})${body ? ` - ${body}` : ""}`
-    );
-  }
-  const data = await response.json().catch(() => {
-    throw new Error("Across API returned invalid JSON");
-  });
-  const result = AcrossDepositStatusSchema.safeParse(data);
-  if (!result.success) {
-    throw new Error(
-      `Across API response validation failed: ${result.error.message}`
-    );
-  }
-  return result.data;
-}
-async function fetchAcrossDepositByTx(hash) {
-  const url = new URL(ACROSS_API);
-  url.searchParams.set("depositTxnRef", hash);
-  return fetchAcrossDeposit(url);
-}
+// src/bridges/across-bridge.ts
+import { parseDepositLogs, parseFillLogs } from "@across-protocol/app-sdk";
+import { getRouter as getRouter2 } from "@yodlpay/tokenlists";
 
-// src/decode-utils.ts
+// src/core/decode-utils.ts
 import { tokenlist } from "@yodlpay/tokenlists";
 import {
-  decodeEventLog,
   erc20Abi as erc20Abi2,
   getAddress,
-  isAddressEqual
+  isAddressEqual,
+  parseEventLogs
 } from "viem";
 
 // src/abi.ts
 import { getRouterAbi } from "@yodlpay/tokenlists";
+import { parseAbi } from "viem";
 var yodlAbi = getRouterAbi("0.8");
-var relaySwapAbi = [
-  {
-    type: "event",
-    name: "Swap",
-    inputs: [
-      { name: "sender", type: "address", indexed: true },
-      { name: "recipient", type: "address", indexed: true },
-      { name: "inputToken", type: "address", indexed: false },
-      { name: "outputToken", type: "address", indexed: false },
-      { name: "inputAmount", type: "uint256", indexed: false },
-      { name: "outputAmount", type: "uint256", indexed: false }
-    ]
-  }
-];
-var entryPointAbi = [
-  {
-    type: "event",
-    name: "UserOperationEvent",
-    inputs: [
-      { name: "userOpHash", type: "bytes32", indexed: true },
-      { name: "sender", type: "address", indexed: true },
-      { name: "paymaster", type: "address", indexed: true },
-      { name: "nonce", type: "uint256", indexed: false },
-      { name: "success", type: "bool", indexed: false },
-      { name: "actualGasCost", type: "uint256", indexed: false },
-      { name: "actualGasUsed", type: "uint256", indexed: false }
-    ]
-  }
-];
+var relaySwapAbi = parseAbi([
+  "event Swap(address indexed sender, address indexed recipient, address inputToken, address outputToken, uint256 inputAmount, uint256 outputAmount)"
+]);
 
 // src/utils.ts
 import { getTokenByAddress } from "@yodlpay/tokenlists";
 import {
   erc20Abi,
   getContract,
-  hexToString
+  hexToString,
+  stringify
 } from "viem";
-import { z as z2 } from "zod";
+import { z } from "zod";
 function decodeMemo(memo) {
   if (!memo || memo === "0x") return "";
   try {
@@ -174,8 +59,8 @@ function decodeMemo(memo) {
     return "";
   }
 }
-var erc20String = z2.string().max(64).transform((s) => s.replace(/\p{Cc}/gu, ""));
-var erc20Decimals = z2.number().int().nonnegative().max(36);
+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) {
   try {
     return getTokenByAddress(address, chainId2);
@@ -196,98 +81,56 @@ async function resolveToken(address, chainId2, client) {
   }
 }
 
-// src/decode-utils.ts
-function* matchingEvents(logs, options) {
-  const { abi, eventName, address, context } = options;
-  for (const log of logs) {
-    if (address && !isAddressEqual(log.address, address)) {
-      continue;
-    }
-    try {
-      const decoded = decodeEventLog({
-        abi,
-        data: log.data,
-        topics: log.topics
-      });
-      if (decoded.eventName === eventName) {
-        yield { decoded, log };
-      }
-    } catch (error) {
-      if (!isExpectedDecodeError(error)) {
-        const contextStr = context ? ` (${context})` : "";
-        console.warn(
-          `[payment-decoder] Unexpected error decoding ${eventName}${contextStr}:`,
-          error
-        );
-      }
-    }
-  }
-}
-function findEventInLogs(logs, options, transform) {
-  for (const { decoded, log } of matchingEvents(logs, options)) {
-    return transform(decoded, log);
-  }
-  return void 0;
-}
-function collectEventsFromLogs(logs, options, transform) {
-  const results = [];
-  for (const { decoded, log } of matchingEvents(logs, options)) {
-    results.push(transform(decoded, log));
-  }
-  return results;
-}
+// src/core/decode-utils.ts
 function decodeYodlFromLogs(logs, routerAddress) {
-  return findEventInLogs(
-    logs,
-    {
-      abi: yodlAbi,
-      eventName: "Yodl",
-      address: routerAddress,
-      context: "Yodl event"
-    },
-    (decoded, log) => {
-      const args = decoded.args;
-      return {
-        sender: args.sender,
-        receiver: args.receiver,
-        token: args.token,
-        amount: args.amount,
-        memo: decodeMemo(args.memo),
-        logIndex: log.logIndex ?? 0
-      };
-    }
-  );
+  const parsed = parseEventLogs({
+    abi: yodlAbi,
+    logs: logs.filter((l) => isAddressEqual(l.address, routerAddress)),
+    eventName: "Yodl",
+    strict: true
+  });
+  const first = parsed[0];
+  if (!first) return void 0;
+  const args = first.args;
+  return {
+    sender: args.sender,
+    receiver: args.receiver,
+    token: args.token,
+    amount: args.amount,
+    memo: decodeMemo(args.memo),
+    logIndex: first.logIndex ?? 0
+  };
 }
 function decodeSwapFromLogs(logs) {
-  return findEventInLogs(
-    logs,
-    { abi: relaySwapAbi, eventName: "Swap", context: "Relay Swap" },
-    (decoded) => {
-      const args = decoded.args;
-      return {
-        tokenIn: args.inputToken,
-        tokenOut: args.outputToken,
-        tokenInAmount: args.inputAmount,
-        tokenOutAmount: args.outputAmount,
-        service: "relay"
-      };
-    }
-  );
+  const parsed = parseEventLogs({
+    abi: relaySwapAbi,
+    logs: [...logs],
+    eventName: "Swap",
+    strict: true
+  });
+  const first = parsed[0];
+  if (!first) return void 0;
+  return {
+    tokenIn: first.args.inputToken,
+    tokenOut: first.args.outputToken,
+    tokenInAmount: first.args.inputAmount,
+    tokenOutAmount: first.args.outputAmount,
+    service: "relay"
+  };
 }
 function extractTokenTransfers(logs) {
-  return collectEventsFromLogs(
-    logs,
-    { abi: erc20Abi2, eventName: "Transfer", context: "ERC20 Transfer" },
-    (decoded, log) => {
-      const args = decoded.args;
-      return {
-        token: log.address,
-        from: args.from,
-        to: args.to,
-        amount: args.value
-      };
-    }
-  );
+  const parsed = parseEventLogs({
+    abi: erc20Abi2,
+    logs: [...logs],
+    eventName: "Transfer",
+    strict: false
+  });
+  return parsed.flatMap((log) => {
+    if (!log.args) return [];
+    const { from, to, value } = log.args;
+    if (!from || !to || value === void 0) return [];
+    return [{ token: log.address, from, to, amount: value }];
+  });
 }
 function isKnownToken(address) {
   return tokenlist.some((t) => isAddressEqual(t.address, address));
@@ -418,12 +261,12 @@ function buildPaymentEvent(yodlEvent, webhooks, blockTimestamp, senderOverride)
   };
 }
 
-// src/embedded-params.ts
+// src/core/embedded-params.ts
 import { decodeFunctionData, toFunctionSelector } from "viem";
 
 // src/validation.ts
-import { isAddress, isHex } from "viem";
-import { z as z3 } from "zod";
+import { isAddress, isHash, isHex } from "viem";
+import { z as z2 } from "zod";
 
 // src/chains.ts
 import { chains as allChains } from "@yodlpay/tokenlists";
@@ -431,25 +274,25 @@ var chains = allChains.filter((c) => !c.testnet);
 
 // src/validation.ts
 var validChainIds = chains.map((c) => c.id);
-var txHashSchema = z3.string().regex(/^0x[a-fA-F0-9]{64}$/, "Invalid transaction hash").transform((val) => val);
-var chainIdSchema = z3.coerce.number().int().refine((id) => validChainIds.includes(id), {
+var txHashSchema = z2.string().refine((val) => isHash(val), "Invalid transaction hash");
+var chainIdSchema = z2.coerce.number().int().refine((id) => validChainIds.includes(id), {
   message: `Chain ID must be one of: ${validChainIds.join(", ")}`
 });
-var ArgsSchema = z3.union([
-  z3.tuple([txHashSchema, chainIdSchema]),
-  z3.tuple([txHashSchema])
+var ArgsSchema = z2.union([
+  z2.tuple([txHashSchema, chainIdSchema]),
+  z2.tuple([txHashSchema])
 ]);
-var WebhooksSchema = z3.array(
-  z3.object({
-    webhookAddress: z3.string().refine((val) => isAddress(val)),
-    payload: z3.array(z3.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]) : ""
   }))
 ).catch([]);
 
-// src/embedded-params.ts
+// src/core/embedded-params.ts
 function getYodlSelector() {
   const yodlFunction = yodlAbi.find(
     (i) => i.type === "function" && i.name === "yodlWithToken"
@@ -479,13 +322,96 @@ function extractEmbeddedParams(data) {
   return [];
 }
 
-// src/relay-bridge.ts
+// src/bridges/across-client.ts
+import { isHash as isHash2 } from "viem";
+import { z as z3 } from "zod";
+var ACROSS_API = "https://app.across.to/api/deposit/status";
+var ACROSS_TIMEOUT_MS = 8e3;
+var chainId = z3.union([
+  z3.number().int().positive(),
+  z3.string().regex(/^\d+$/).transform(Number)
+]).pipe(z3.number().int().positive());
+var txHash = z3.string().refine((v) => isHash2(v));
+var nullableTxHash = txHash.nullish().transform((v) => v ?? null);
+var depositId = z3.union([
+  z3.string().regex(/^\d+$/),
+  z3.number().int().nonnegative().transform((v) => String(v))
+]);
+var AcrossDepositStatusSchema = z3.object({
+  status: z3.enum(["filled", "pending", "expired", "refunded"]),
+  originChainId: chainId,
+  destinationChainId: chainId,
+  depositId,
+  depositTxnRef: txHash.optional(),
+  depositTxHash: txHash.optional(),
+  fillTxnRef: nullableTxHash,
+  fillTx: nullableTxHash,
+  actionsSucceeded: z3.boolean().nullish().transform((v) => v ?? null)
+}).transform((d) => {
+  const depositTxnRef = d.depositTxnRef ?? d.depositTxHash;
+  if (!depositTxnRef) {
+    throw new Error("Missing depositTxnRef and depositTxHash");
+  }
+  return {
+    status: d.status,
+    originChainId: d.originChainId,
+    destinationChainId: d.destinationChainId,
+    depositId: d.depositId,
+    depositTxnRef,
+    fillTxnRef: d.fillTxnRef ?? d.fillTx,
+    actionsSucceeded: d.actionsSucceeded
+  };
+});
+async function fetchAcrossDepositByDepositId(originChainId, depositId2) {
+  const url = new URL(ACROSS_API);
+  url.searchParams.set("originChainId", String(originChainId));
+  url.searchParams.set("depositId", depositId2);
+  return fetchAcrossDeposit(url);
+}
+async function fetchAcrossDeposit(url) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), ACROSS_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(url, { signal: controller.signal });
+  } catch (error) {
+    const message = error instanceof Error && error.name === "AbortError" ? `Across API request timed out after ${ACROSS_TIMEOUT_MS}ms` : "Across API request failed";
+    throw new Error(message, { cause: error });
+  } finally {
+    clearTimeout(timeout);
+  }
+  if (response.status === 404) throw new NoBridgeFoundError();
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    const kind = response.status === 429 || response.status >= 500 ? "temporary error" : "error";
+    throw new Error(
+      `Across API ${kind} (${response.status})${body ? ` - ${body}` : ""}`
+    );
+  }
+  const data = await response.json().catch(() => {
+    throw new Error("Across API returned invalid JSON");
+  });
+  const result = AcrossDepositStatusSchema.safeParse(data);
+  if (!result.success) {
+    throw new Error(
+      `Across API response validation failed: ${result.error.message}`
+    );
+  }
+  return result.data;
+}
+async function fetchAcrossDepositByTx(hash) {
+  const url = new URL(ACROSS_API);
+  url.searchParams.set("depositTxnRef", hash);
+  return fetchAcrossDeposit(url);
+}
+
+// src/bridges/relay-bridge.ts
 import { getRouter } from "@yodlpay/tokenlists";
 import {
-  decodeEventLog as decodeEventLog2,
-  isAddressEqual as isAddressEqual2
+  isAddressEqual as isAddressEqual2,
+  parseEventLogs as parseEventLogs2
 } from "viem";
-import { entryPoint08Address } from "viem/account-abstraction";
+import { entryPoint08Abi, entryPoint08Address } from "viem/account-abstraction";
 
 // src/clients.ts
 import {
@@ -503,7 +429,7 @@ function createClients() {
   for (const chain of chains) {
     clients[chain.id] = createPublicClient({
       chain,
-      transport: http(rpcOverrides[chain.id])
+      transport: http(rpcOverrides[chain.id], { batch: true })
     });
   }
   return clients;
@@ -533,7 +459,7 @@ async function detectChain(hash, clients) {
   return found.value;
 }
 
-// src/relay-client.ts
+// src/bridges/relay-client.ts
 var RELAY_API = "https://api.relay.link";
 async function getRelayRequests(params) {
   const url = new URL(`${RELAY_API}/requests/v2`);
@@ -557,7 +483,7 @@ async function fetchRelayRequest(hash) {
   return request;
 }
 
-// src/relay-bridge.ts
+// src/bridges/relay-bridge.ts
 async function calculateOutputAmountGross(inputAmount, inputToken, inputChainId, outputToken, outputChainId, clients) {
   const [{ decimals: inputDecimals }, { decimals: outputDecimals }] = await Promise.all([
     resolveToken(inputToken, inputChainId, getClient(clients, inputChainId)),
@@ -572,23 +498,18 @@ async function calculateOutputAmountGross(inputAmount, inputToken, inputChainId,
   if (decimalDiff > 0) return inputAmount / 10n ** BigInt(decimalDiff);
   return inputAmount * 10n ** BigInt(-decimalDiff);
 }
-async function extractSenderFromSource(sourceReceipt, sourceProvider, sourceHash) {
-  for (const log of sourceReceipt.logs) {
-    if (!isAddressEqual2(log.address, entryPoint08Address)) continue;
-    try {
-      const decoded = decodeEventLog2({
-        abi: entryPointAbi,
-        data: log.data,
-        topics: log.topics
-      });
-      if (decoded.eventName === "UserOperationEvent") {
-        return decoded.args.sender;
-      }
-    } catch {
-    }
+function extractSenderFromSource(sourceReceipt) {
+  const userOps = parseEventLogs2({
+    abi: entryPoint08Abi,
+    logs: sourceReceipt.logs.filter(
+      (l) => isAddressEqual2(l.address, entryPoint08Address)
+    ),
+    eventName: "UserOperationEvent"
+  });
+  if (userOps[0]) {
+    return userOps[0].args.sender;
   }
-  const sourceTx = await sourceProvider.getTransaction({ hash: sourceHash });
-  return sourceTx.from;
+  return sourceReceipt.from;
 }
 async function resolveBridgeTokens(sourceReceipt, destReceipt, yodlEvent, sender, inputAmountGross, inputChainId, outputChainId, clients) {
   const sourceTransfers = extractTokenTransfers(sourceReceipt.logs);
@@ -639,7 +560,7 @@ function parseRelayResponse(request) {
     inputAmountGross: BigInt(data?.metadata?.currencyIn?.amount ?? 0)
   };
 }
-async function decodeRelayBridgePayment(hash, clients) {
+async function decodeRelayBridgePayment(hash, clients, options = {}) {
   const request = await fetchRelayRequest(hash);
   const {
     sourceChainId,
@@ -654,9 +575,12 @@ async function decodeRelayBridgePayment(hash, clients) {
     throw new NoBridgeFoundError();
   }
   const { address: routerAddress } = getRouter(destinationChainId);
+  const hashLower = hash.toLowerCase();
+  const cachedDestReceipt = options.fillReceipt && destinationTxHash.toLowerCase() === hashLower ? options.fillReceipt : void 0;
+  const cachedSourceReceipt = options.sourceReceipt && sourceTxHash.toLowerCase() === hashLower ? options.sourceReceipt : void 0;
   const [destReceipt, sourceReceipt] = await Promise.all([
-    destProvider.getTransactionReceipt({ hash: destinationTxHash }),
-    sourceProvider.getTransactionReceipt({ hash: sourceTxHash })
+    cachedDestReceipt ?? destProvider.getTransactionReceipt({ hash: destinationTxHash }),
+    cachedSourceReceipt ?? sourceProvider.getTransactionReceipt({ hash: sourceTxHash })
   ]);
   const yodlEvent = decodeYodlFromLogs(destReceipt.logs, routerAddress);
   if (!yodlEvent) {
@@ -664,10 +588,10 @@ async function decodeRelayBridgePayment(hash, clients) {
       "No Yodl event found in destination transaction"
     );
   }
-  const [destBlock, destTx, sender] = await Promise.all([
+  const sender = extractSenderFromSource(sourceReceipt);
+  const [destBlock, destTx] = await Promise.all([
     destProvider.getBlock({ blockNumber: destReceipt.blockNumber }),
-    destProvider.getTransaction({ hash: destinationTxHash }),
-    extractSenderFromSource(sourceReceipt, sourceProvider, sourceTxHash)
+    destProvider.getTransaction({ hash: destinationTxHash })
   ]);
   const tokens = await resolveBridgeTokens(
     sourceReceipt,
@@ -696,30 +620,27 @@ async function decodeRelayBridgePayment(hash, clients) {
   return { type: "bridge", ...payment, ...bridge };
 }
 
-// src/across-bridge.ts
-async function resolveAcrossStatus(hash, fillReceipt) {
-  try {
-    return await fetchAcrossDepositByTx(hash);
-  } catch (error) {
-    if (!(error instanceof NoBridgeFoundError) || !fillReceipt) {
-      throw error;
+// src/bridges/across-bridge.ts
+async function resolveAcrossStatus(hash, fillReceipt, cachedFillLog) {
+  const fillLog = cachedFillLog !== void 0 ? cachedFillLog : fillReceipt ? parseFillLogs(fillReceipt.logs) : null;
+  if (fillLog) {
+    const status = await fetchAcrossDepositByDepositId(
+      Number(fillLog.originChainId),
+      String(fillLog.depositId)
+    );
+    if (status.fillTxnRef?.toLowerCase() === hash.toLowerCase()) {
+      return status;
     }
+    return await fetchAcrossDepositByTx(hash);
   }
-  const fillLog = parseFillLogs(fillReceipt.logs);
-  if (!fillLog) {
-    throw new NoBridgeFoundError();
-  }
-  const status = await fetchAcrossDepositByDepositId(
-    Number(fillLog.originChainId),
-    String(fillLog.depositId)
-  );
-  if (status.fillTxnRef !== hash) {
-    throw new NoBridgeFoundError();
-  }
-  return status;
+  return await fetchAcrossDepositByTx(hash);
 }
-async function decodeAcrossBridgePayment(hash, clients, fillReceipt) {
-  const status = await resolveAcrossStatus(hash, fillReceipt);
+async function decodeAcrossBridgePayment(hash, clients, options = {}) {
+  const status = await resolveAcrossStatus(
+    hash,
+    options.fillReceipt,
+    options.parsedFillLog
+  );
   if (status.status !== "filled" || !status.fillTxnRef) {
     throw new NoBridgeFoundError();
   }
@@ -736,18 +657,21 @@ async function decodeAcrossBridgePayment(hash, clients, fillReceipt) {
     throw new NoBridgeFoundError();
   }
   const { address: routerAddress } = getRouter2(destinationChainId);
+  const hashLower = hash.toLowerCase();
+  const cachedDestReceipt = options.fillReceipt && destinationTxHash.toLowerCase() === hashLower ? options.fillReceipt : void 0;
+  const cachedSourceReceipt = options.sourceReceipt && sourceTxHash.toLowerCase() === hashLower ? options.sourceReceipt : void 0;
   const [sourceReceipt, destReceipt] = await Promise.all([
-    sourceProvider.getTransactionReceipt({ hash: sourceTxHash }),
-    destProvider.getTransactionReceipt({ hash: destinationTxHash })
+    cachedSourceReceipt ?? sourceProvider.getTransactionReceipt({ hash: sourceTxHash }),
+    cachedDestReceipt ?? destProvider.getTransactionReceipt({ hash: destinationTxHash })
   ]);
   const yodlEvent = decodeYodlFromLogs(destReceipt.logs, routerAddress);
   if (!yodlEvent) {
     throw new NoBridgeFoundError();
   }
-  const [destBlock, destTx, sender] = await Promise.all([
+  const sender = extractSenderFromSource(sourceReceipt);
+  const [destBlock, destTx] = await Promise.all([
     destProvider.getBlock({ blockNumber: destReceipt.blockNumber }),
-    destProvider.getTransaction({ hash: destinationTxHash }),
-    extractSenderFromSource(sourceReceipt, sourceProvider, sourceTxHash)
+    destProvider.getTransaction({ hash: destinationTxHash })
   ]);
   const depositLog = parseDepositLogs(sourceReceipt.logs);
   const depositData = depositLog && depositLog.depositId === BigInt(status.depositId) ? {
@@ -805,12 +729,25 @@ async function decodeAcrossBridgePayment(hash, clients, fillReceipt) {
   return { type: "bridge", ...payment, ...bridge };
 }
 
-// src/bridge-payment.ts
+// src/bridges/bridge-payment.ts
 async function decodeBridgePayment(hash, clients, options = {}) {
   const includeAcross = options.includeAcross ?? true;
+  const parsedFillLog = options.fillReceipt ? parseFillLogs2(options.fillReceipt.logs) : null;
+  const parsedDepositLog = options.sourceReceipt ? parseDepositLogs2(options.sourceReceipt.logs) : null;
+  const hasAcrossEvents = !!(parsedFillLog || parsedDepositLog);
+  if (includeAcross && hasAcrossEvents) {
+    return await decodeAcrossBridgePayment(hash, clients, {
+      fillReceipt: options.fillReceipt,
+      sourceReceipt: options.sourceReceipt,
+      parsedFillLog
+    });
+  }
   let relayError;
   try {
-    return await decodeRelayBridgePayment(hash, clients);
+    return await decodeRelayBridgePayment(hash, clients, {
+      fillReceipt: options.fillReceipt,
+      sourceReceipt: options.sourceReceipt
+    });
   } catch (error) {
     relayError = error;
     if (!includeAcross) {
@@ -818,7 +755,10 @@ async function decodeBridgePayment(hash, clients, options = {}) {
     }
   }
   try {
-    return await decodeAcrossBridgePayment(hash, clients, options.fillReceipt);
+    return await decodeAcrossBridgePayment(hash, clients, {
+      fillReceipt: options.fillReceipt,
+      sourceReceipt: options.sourceReceipt
+    });
   } catch (acrossError) {
     if (!(relayError instanceof NoBridgeFoundError) && !(acrossError instanceof NoBridgeFoundError)) {
       throw new Error("Both Relay and Across bridge decoders failed", {
@@ -835,8 +775,9 @@ async function decodeBridgePayment(hash, clients, options = {}) {
   }
 }
 
-// src/payment-decoder.ts
+// src/core/payment-decoder.ts
 import { getRouter as getRouter3 } from "@yodlpay/tokenlists";
+import { isAddressEqual as isAddressEqual3 } from "viem";
 async function tryDecodeBridge(hash, clients, options = {}) {
   try {
     return await decodeBridgePayment(hash, clients, options);
@@ -851,24 +792,42 @@ async function decodePayment(hash, chainId2, clients, cachedReceipt) {
   const provider = getClient(clients, chainId2);
   const receipt = cachedReceipt ?? await provider.getTransactionReceipt({ hash });
   const { address: routerAddress } = getRouter3(chainId2);
-  const [block, tx] = await Promise.all([
-    provider.getBlock({ blockNumber: receipt.blockNumber }),
-    provider.getTransaction({ hash })
-  ]);
   const yodlEvent = decodeYodlFromLogs(receipt.logs, routerAddress);
   const swapLogs = yodlEvent ? receipt.logs.filter((l) => (l.logIndex ?? 0) < yodlEvent.logIndex) : receipt.logs;
   const swapEvent = decodeSwapFromLogs(swapLogs);
   if (yodlEvent) {
-    const blockTimestamp = toBlockTimestamp(block);
-    const webhooks = extractEmbeddedParams(tx.input);
-    const paymentEvent = buildPaymentEvent(yodlEvent, webhooks, blockTimestamp);
     if (swapEvent) {
-      return { type: "swap", ...paymentEvent, ...swapEvent };
+      const [block2, tx2] = await Promise.all([
+        provider.getBlock({ blockNumber: receipt.blockNumber }),
+        provider.getTransaction({ hash })
+      ]);
+      const paymentEvent2 = buildPaymentEvent(
+        yodlEvent,
+        extractEmbeddedParams(tx2.input),
+        toBlockTimestamp(block2)
+      );
+      return { type: "swap", ...paymentEvent2, ...swapEvent };
     }
-    const bridgeResult2 = await tryDecodeBridge(hash, clients, {
-      fillReceipt: receipt
-    });
-    if (bridgeResult2) return bridgeResult2;
+    const effectiveSender = extractSenderFromSource(receipt);
+    const isSameChainPayment = isAddressEqual3(
+      effectiveSender,
+      yodlEvent.sender
+    );
+    if (!isSameChainPayment) {
+      const bridgeResult2 = await tryDecodeBridge(hash, clients, {
+        fillReceipt: receipt
+      });
+      if (bridgeResult2) return bridgeResult2;
+    }
+    const [block, tx] = await Promise.all([
+      provider.getBlock({ blockNumber: receipt.blockNumber }),
+      provider.getTransaction({ hash })
+    ]);
+    const paymentEvent = buildPaymentEvent(
+      yodlEvent,
+      extractEmbeddedParams(tx.input),
+      toBlockTimestamp(block)
+    );
     const inferredSwap = inferSwapFromTransfers(
       swapLogs,
       yodlEvent.sender,
@@ -879,18 +838,26 @@ async function decodePayment(hash, chainId2, clients, cachedReceipt) {
     }
     return { type: "direct", ...paymentEvent };
   }
-  const bridgeResult = await tryDecodeBridge(hash, clients);
+  const bridgeResult = await tryDecodeBridge(hash, clients, {
+    sourceReceipt: receipt
+  });
   if (bridgeResult) return bridgeResult;
   throw new NoYodlEventError();
 }
 
-// src/yodl-payment.ts
+// src/core/yodl-payment.ts
 import {
   formatUnits,
+  isAddressEqual as isAddressEqual4,
   zeroAddress
 } from "viem";
 async function buildTokenInfo(params, clients) {
-  const [inToken, outToken] = await Promise.all([
+  const sameToken = isAddressEqual4(params.tokenIn, params.tokenOut) && params.inChainId === params.outChainId;
+  const [inToken, outToken] = sameToken ? await resolveToken(
+    params.tokenIn,
+    params.inChainId,
+    getClient(clients, params.inChainId)
+  ).then((t) => [t, t]) : await Promise.all([
     resolveToken(
       params.tokenIn,
       params.inChainId,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@yodlpay/payment-decoder",
-	"version": "1.3.4",
+	"version": "1.3.6",
 	"description": "Decode Yodl payment hashes into structured payment data",
 	"keywords": [
 		"yodl",
@@ -38,8 +38,8 @@
 		"prepublishOnly": "bun run build"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.4.4",
-		"@relayprotocol/relay-sdk": "^5.2.0",
+		"@biomejs/biome": "^2.4.8",
+		"@relayprotocol/relay-sdk": "^5.2.1",
 		"@semantic-release/changelog": "^6.0.3",
 		"@semantic-release/git": "^10.0.1",
 		"@types/bun": "latest",
@@ -49,7 +49,7 @@
 	},
 	"dependencies": {
 		"@across-protocol/app-sdk": "^0.5.0",
-		"@yodlpay/tokenlists": "^1.1.12"
+		"@yodlpay/tokenlists": "^1.1.13"
 	},
 	"peerDependencies": {
 		"typescript": "^5",