@yodlpay/payment-decoder 1.3.3 → 1.3.5

package/dist/index.d.ts

@@ -41,10 +41,15 @@ interface BridgeInfo extends SwapInfo {
     destinationTxHash: Hex;
     tokenOutAmountGross: bigint;
 }
+interface InferredSwapInfo extends Omit<SwapInfo, "service"> {
+    service?: undefined;
+}
 type PaymentInfo = (PaymentEvent & {
     type: "direct";
 }) | (PaymentEvent & SwapInfo & {
     type: "swap";
+}) | (PaymentEvent & InferredSwapInfo & {
+    type: "swap";
 }) | (PaymentEvent & BridgeInfo & {
     type: "bridge";
 });
@@ -79,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";
@@ -102,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);
 }
@@ -109,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,4 @@
-// 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/errors.ts
-import {
-  AbiDecodingDataSizeTooSmallError,
-  AbiEventSignatureEmptyTopicsError,
-  AbiEventSignatureNotFoundError,
-  DecodeLogTopicsMismatch
-} from "viem";
 var ExpectedDecodeError = class extends Error {
   constructor(message = "Expected decode error") {
     super(message);
@@ -31,141 +17,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 +56,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 +78,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));
@@ -355,6 +195,57 @@ function findInputTransfer(transfers, sender) {
   if (!result) return void 0;
   return { token: result.token, amount: result.amount };
 }
+function inferSwapFromTransfers(logs, sender, yodlToken) {
+  const transfers = extractTokenTransfers(logs);
+  const outgoingDifferentToken = transfers.filter(
+    (t) => isAddressEqual(t.from, sender) && !isAddressEqual(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 });
+    }
+  }
+  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;
+    }
+  }
+  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 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;
+  return {
+    tokenIn,
+    tokenOut: yodlToken,
+    tokenInAmount,
+    tokenOutAmount
+  };
+}
 function toBlockTimestamp(block) {
   return new Date(Number(block.timestamp) * 1e3);
 }
@@ -367,33 +258,38 @@ function buildPaymentEvent(yodlEvent, webhooks, blockTimestamp, senderOverride)
   };
 }
 
-// src/embedded-params.ts
+// src/core/embedded-params.ts
 import { decodeFunctionData, toFunctionSelector } from "viem";
 
 // src/validation.ts
-import { chains } from "@yodlpay/tokenlists";
-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";
+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"
@@ -423,16 +319,98 @@ 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 { chains as chains2 } from "@yodlpay/tokenlists";
 import {
   createPublicClient,
   http
@@ -445,10 +423,10 @@ var rpcOverrides = {
 };
 function createClients() {
   const clients = {};
-  for (const chain of chains2) {
+  for (const chain of chains) {
     clients[chain.id] = createPublicClient({
       chain,
-      transport: http(rpcOverrides[chain.id])
+      transport: http(rpcOverrides[chain.id], { batch: true })
     });
   }
   return clients;
@@ -478,12 +456,10 @@ async function detectChain(hash, clients) {
   return found.value;
 }
 
-// src/relay-client.ts
-var MAINNET_RELAY_API = "https://api.relay.link";
-var TESTNET_RELAY_API = "https://api.testnets.relay.link";
-async function getRelayRequests(params, options) {
-  const baseUrl = options?.testnet ? TESTNET_RELAY_API : MAINNET_RELAY_API;
-  const url = new URL(`${baseUrl}/requests/v2`);
+// src/bridges/relay-client.ts
+var RELAY_API = "https://api.relay.link";
+async function getRelayRequests(params) {
+  const url = new URL(`${RELAY_API}/requests/v2`);
   for (const [key, value] of Object.entries(params)) {
     if (value !== void 0) {
       url.searchParams.set(key, String(value));
@@ -504,7 +480,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)),
@@ -520,19 +496,15 @@ async function calculateOutputAmountGross(inputAmount, inputToken, inputChainId,
   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 {
-    }
+  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;
@@ -586,7 +558,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,
@@ -601,9 +573,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) {
@@ -643,7 +618,7 @@ async function decodeRelayBridgePayment(hash, clients) {
   return { type: "bridge", ...payment, ...bridge };
 }
 
-// src/across-bridge.ts
+// src/bridges/across-bridge.ts
 async function resolveAcrossStatus(hash, fillReceipt) {
   try {
     return await fetchAcrossDepositByTx(hash);
@@ -660,13 +635,13 @@ async function resolveAcrossStatus(hash, fillReceipt) {
     Number(fillLog.originChainId),
     String(fillLog.depositId)
   );
-  if (status.fillTxnRef !== hash) {
+  if (!status.fillTxnRef || status.fillTxnRef.toLowerCase() !== hash.toLowerCase()) {
     throw new NoBridgeFoundError();
   }
   return status;
 }
-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);
   if (status.status !== "filled" || !status.fillTxnRef) {
     throw new NoBridgeFoundError();
   }
@@ -683,9 +658,12 @@ 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) {
@@ -752,12 +730,15 @@ 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;
   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) {
@@ -765,7 +746,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", {
@@ -782,7 +766,7 @@ async function decodeBridgePayment(hash, clients, options = {}) {
   }
 }
 
-// src/payment-decoder.ts
+// src/core/payment-decoder.ts
 import { getRouter as getRouter3 } from "@yodlpay/tokenlists";
 async function tryDecodeBridge(hash, clients, options = {}) {
   try {
@@ -798,32 +782,53 @@ 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 [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,
+      yodlEvent.token
+    );
+    if (inferredSwap) {
+      return { type: "swap", ...paymentEvent, ...inferredSwap };
+    }
     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,
   zeroAddress

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@yodlpay/payment-decoder",
-	"version": "1.3.3",
+	"version": "1.3.5",
 	"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",