@yodlpay/payment-decoder 1.3.2 → 1.3.4

package/README.md

@@ -2,6 +2,8 @@
 
 Decode Yodl payment transaction hashes into structured payment data. Supports direct payments, swaps, and cross-chain bridges.
 
+Bridge discovery currently supports Relay (source + destination hashes) and Across source-chain deposits via Across status API.
+
 ## Installation
 
 ```bash

package/dist/index.d.ts

@@ -12,7 +12,7 @@ declare function detectChain(hash: Hex, clients: ChainClients): Promise<{
     receipt: TransactionReceipt;
 }>;
 
-type ServiceProvider = "relay";
+type ServiceProvider = "relay" | "across";
 interface Webhook {
     webhookAddress: Address;
     payload: readonly Hex[];
@@ -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";
 });
@@ -75,6 +80,15 @@ interface YodlPayment {
     blockTimestamp: Date;
 }
 
+interface DecodeBridgeOptions {
+    includeAcross?: boolean;
+    /** Receipt of the fill (destination) tx, used for Across fill-side lookups. */
+    fillReceipt?: TransactionReceipt;
+}
+declare function decodeBridgePayment(hash: Hex, clients: ChainClients, options?: DecodeBridgeOptions): Promise<Extract<PaymentInfo, {
+    type: "bridge";
+}>>;
+
 /**
  * Decoded Yodl event data from onchain logs.
  * Does not include blockTimestamp or webhooks — callers provide those.
@@ -102,18 +116,6 @@ declare class NoYodlEventError extends Error {
 
 declare function decodePayment(hash: Hex, chainId: number, clients: ChainClients, cachedReceipt?: TransactionReceipt): Promise<PaymentInfo>;
 
-/**
- * Decode a bridge transaction given any hash (source or destination).
- * Fetches bridge info from Relay, then decodes the Yodl event from the destination chain.
- * Extracts the original sender from the source chain's UserOperationEvent.
- *
- * SECURITY: Token data is extracted from onchain logs, not trusted from Relay.
- * Relay is only used for bridge discovery (hashes + chain IDs).
- */
-declare function decodeBridgePayment(hash: Hex, clients: ChainClients): Promise<Extract<PaymentInfo, {
-    type: "bridge";
-}>>;
-
 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,46 +1,119 @@
-// src/clients.ts
-import { chains } from "@yodlpay/tokenlists";
+// 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 {
-  createPublicClient,
-  http
+  AbiDecodingDataSizeTooSmallError,
+  AbiEventSignatureEmptyTopicsError,
+  AbiEventSignatureNotFoundError,
+  DecodeLogTopicsMismatch
 } from "viem";
-var rpcOverrides = {
-  137: "https://polygon-bor-rpc.publicnode.com"
-  // polygon-rpc.com is down
+var ExpectedDecodeError = class extends Error {
+  constructor(message = "Expected decode error") {
+    super(message);
+    this.name = "ExpectedDecodeError";
+  }
 };
-function createClients() {
-  const clients = {};
-  for (const chain of chains) {
-    clients[chain.id] = createPublicClient({
-      chain,
-      transport: http(rpcOverrides[chain.id])
-    });
+var NoBridgeFoundError = class extends Error {
+  constructor(message = "No bridge transaction found") {
+    super(message);
+    this.name = "NoBridgeFoundError";
   }
-  return clients;
+};
+var NoYodlEventError = class extends Error {
+  constructor(message = "No Yodl event found in logs") {
+    super(message);
+    this.name = "NoYodlEventError";
+  }
+};
+function isExpectedDecodeError(error) {
+  return error instanceof AbiEventSignatureNotFoundError || error instanceof AbiEventSignatureEmptyTopicsError || error instanceof AbiDecodingDataSizeTooSmallError || error instanceof DecodeLogTopicsMismatch;
 }
-function getClient(clients, chainId) {
-  const client = clients[chainId];
-  if (!client) throw new Error(`No client configured for chain ${chainId}`);
-  return client;
+
+// 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 detectChain(hash, clients) {
-  const entries = Object.entries(clients).map(([id, client]) => ({
-    chainId: Number(id),
-    client
-  }));
-  const results = await Promise.allSettled(
-    entries.map(async ({ chainId, client }) => {
-      const receipt = await client.getTransactionReceipt({ hash });
-      return { chainId, receipt };
-    })
-  );
-  const found = results.find(
-    (r) => r.status === "fulfilled"
-  );
-  if (!found) {
-    throw new Error(`Transaction ${hash} not found on any configured chain`);
+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);
   }
-  return found.value;
+  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/decode-utils.ts
@@ -85,35 +158,6 @@ var entryPointAbi = [
   }
 ];
 
-// src/errors.ts
-import {
-  AbiDecodingDataSizeTooSmallError,
-  AbiEventSignatureEmptyTopicsError,
-  AbiEventSignatureNotFoundError,
-  DecodeLogTopicsMismatch
-} from "viem";
-var ExpectedDecodeError = class extends Error {
-  constructor(message = "Expected decode error") {
-    super(message);
-    this.name = "ExpectedDecodeError";
-  }
-};
-var NoBridgeFoundError = class extends Error {
-  constructor(message = "No bridge transaction found") {
-    super(message);
-    this.name = "NoBridgeFoundError";
-  }
-};
-var NoYodlEventError = class extends Error {
-  constructor(message = "No Yodl event found in logs") {
-    super(message);
-    this.name = "NoYodlEventError";
-  }
-};
-function isExpectedDecodeError(error) {
-  return error instanceof AbiEventSignatureNotFoundError || error instanceof AbiEventSignatureEmptyTopicsError || error instanceof AbiDecodingDataSizeTooSmallError || error instanceof DecodeLogTopicsMismatch;
-}
-
 // src/utils.ts
 import { getTokenByAddress } from "@yodlpay/tokenlists";
 import {
@@ -121,7 +165,7 @@ import {
   getContract,
   hexToString
 } from "viem";
-import { z } from "zod";
+import { z as z2 } from "zod";
 function decodeMemo(memo) {
   if (!memo || memo === "0x") return "";
   try {
@@ -130,11 +174,11 @@ 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) {
+var erc20String = z2.string().max(64).transform((s) => s.replace(/\p{Cc}/gu, ""));
+var erc20Decimals = z2.number().int().nonnegative().max(36);
+async function resolveToken(address, chainId2, client) {
   try {
-    return getTokenByAddress(address, chainId);
+    return getTokenByAddress(address, chainId2);
   } catch {
     const token = getContract({ address, abi: erc20Abi, client });
     const [name, symbol, decimals] = await Promise.all([
@@ -143,7 +187,7 @@ async function resolveToken(address, chainId, client) {
       token.read.decimals()
     ]);
     return {
-      chainId,
+      chainId: chainId2,
       address,
       name: erc20String.parse(name),
       symbol: erc20String.parse(symbol),
@@ -311,6 +355,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);
 }
@@ -323,29 +418,31 @@ function buildPaymentEvent(yodlEvent, webhooks, blockTimestamp, senderOverride)
   };
 }
 
-// src/payment-decoder.ts
-import { getRouter as getRouter2 } from "@yodlpay/tokenlists";
-
 // src/embedded-params.ts
 import { decodeFunctionData, toFunctionSelector } from "viem";
 
 // src/validation.ts
-import { chains as chains2 } from "@yodlpay/tokenlists";
 import { isAddress, isHex } from "viem";
-import { z as z2 } from "zod";
-var validChainIds = chains2.map((c) => c.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), {
+import { z as z3 } 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), {
   message: `Chain ID must be one of: ${validChainIds.join(", ")}`
 });
-var ArgsSchema = z2.union([
-  z2.tuple([txHashSchema, chainIdSchema]),
-  z2.tuple([txHashSchema])
+var ArgsSchema = z3.union([
+  z3.tuple([txHashSchema, chainIdSchema]),
+  z3.tuple([txHashSchema])
 ]);
-var WebhooksSchema = z2.array(
-  z2.object({
-    webhookAddress: z2.string().refine((val) => isAddress(val)),
-    payload: z2.array(z2.string().refine((val) => isHex(val)))
+var WebhooksSchema = z3.array(
+  z3.object({
+    webhookAddress: z3.string().refine((val) => isAddress(val)),
+    payload: z3.array(z3.string().refine((val) => isHex(val)))
   }).transform((webhook) => ({
     ...webhook,
     memo: webhook.payload[0] ? decodeMemo(webhook.payload[0]) : ""
@@ -390,12 +487,56 @@ import {
 } from "viem";
 import { entryPoint08Address } from "viem/account-abstraction";
 
+// src/clients.ts
+import {
+  createPublicClient,
+  http
+} from "viem";
+var rpcOverrides = {
+  1: "https://ethereum-rpc.publicnode.com",
+  // eth.merkle.io is down
+  137: "https://polygon-bor-rpc.publicnode.com"
+  // polygon-rpc.com is down
+};
+function createClients() {
+  const clients = {};
+  for (const chain of chains) {
+    clients[chain.id] = createPublicClient({
+      chain,
+      transport: http(rpcOverrides[chain.id])
+    });
+  }
+  return clients;
+}
+function getClient(clients, chainId2) {
+  const client = clients[chainId2];
+  if (!client) throw new Error(`No client configured for chain ${chainId2}`);
+  return client;
+}
+async function detectChain(hash, clients) {
+  const entries = Object.entries(clients).map(([id, client]) => ({
+    chainId: Number(id),
+    client
+  }));
+  const results = await Promise.allSettled(
+    entries.map(async ({ chainId: chainId2, client }) => {
+      const receipt = await client.getTransactionReceipt({ hash });
+      return { chainId: chainId2, receipt };
+    })
+  );
+  const found = results.find(
+    (r) => r.status === "fulfilled"
+  );
+  if (!found) {
+    throw new Error(`Transaction ${hash} not found on any configured chain`);
+  }
+  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`);
+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));
@@ -498,7 +639,7 @@ function parseRelayResponse(request) {
     inputAmountGross: BigInt(data?.metadata?.currencyIn?.amount ?? 0)
   };
 }
-async function decodeBridgePayment(hash, clients) {
+async function decodeRelayBridgePayment(hash, clients) {
   const request = await fetchRelayRequest(hash);
   const {
     sourceChainId,
@@ -507,8 +648,11 @@ async function decodeBridgePayment(hash, clients) {
     destinationTxHash,
     inputAmountGross
   } = parseRelayResponse(request);
-  const destProvider = getClient(clients, destinationChainId);
-  const sourceProvider = getClient(clients, sourceChainId);
+  const destProvider = clients[destinationChainId];
+  const sourceProvider = clients[sourceChainId];
+  if (!destProvider || !sourceProvider) {
+    throw new NoBridgeFoundError();
+  }
   const { address: routerAddress } = getRouter(destinationChainId);
   const [destReceipt, sourceReceipt] = await Promise.all([
     destProvider.getTransactionReceipt({ hash: destinationTxHash }),
@@ -552,23 +696,161 @@ async function decodeBridgePayment(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;
+    }
+  }
+  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;
+}
+async function decodeAcrossBridgePayment(hash, clients, fillReceipt) {
+  const status = await resolveAcrossStatus(hash, fillReceipt);
+  if (status.status !== "filled" || !status.fillTxnRef) {
+    throw new NoBridgeFoundError();
+  }
+  if (status.actionsSucceeded === false) {
+    throw new NoBridgeFoundError();
+  }
+  const sourceChainId = status.originChainId;
+  const sourceTxHash = status.depositTxnRef;
+  const destinationChainId = status.destinationChainId;
+  const destinationTxHash = status.fillTxnRef;
+  const sourceProvider = clients[sourceChainId];
+  const destProvider = clients[destinationChainId];
+  if (!sourceProvider || !destProvider) {
+    throw new NoBridgeFoundError();
+  }
+  const { address: routerAddress } = getRouter2(destinationChainId);
+  const [sourceReceipt, destReceipt] = await Promise.all([
+    sourceProvider.getTransactionReceipt({ hash: sourceTxHash }),
+    destProvider.getTransactionReceipt({ hash: destinationTxHash })
+  ]);
+  const yodlEvent = decodeYodlFromLogs(destReceipt.logs, routerAddress);
+  if (!yodlEvent) {
+    throw new NoBridgeFoundError();
+  }
+  const [destBlock, destTx, sender] = await Promise.all([
+    destProvider.getBlock({ blockNumber: destReceipt.blockNumber }),
+    destProvider.getTransaction({ hash: destinationTxHash }),
+    extractSenderFromSource(sourceReceipt, sourceProvider, sourceTxHash)
+  ]);
+  const depositLog = parseDepositLogs(sourceReceipt.logs);
+  const depositData = depositLog && depositLog.depositId === BigInt(status.depositId) ? {
+    tokenIn: depositLog.inputToken,
+    inputAmount: depositLog.inputAmount,
+    outputAmount: depositLog.outputAmount
+  } : void 0;
+  const fillLog = parseFillLogs(destReceipt.logs, {
+    depositId: BigInt(status.depositId)
+  });
+  const fillOutputAmount = fillLog?.relayExecutionInfo?.updatedOutputAmount ?? fillLog?.outputAmount ?? 0n;
+  let tokens;
+  try {
+    tokens = await resolveBridgeTokens(
+      sourceReceipt,
+      destReceipt,
+      yodlEvent,
+      sender,
+      0n,
+      sourceChainId,
+      destinationChainId,
+      clients
+    );
+  } catch (error) {
+    if (error instanceof ExpectedDecodeError && depositData?.tokenIn && depositData.inputAmount > 0n) {
+      tokens = {
+        tokenIn: depositData.tokenIn,
+        tokenInAmount: depositData.inputAmount,
+        tokenOut: yodlEvent.token,
+        tokenOutAmount: yodlEvent.amount,
+        tokenOutAmountGross: fillOutputAmount > 0n ? fillOutputAmount : depositData.outputAmount > 0n ? depositData.outputAmount : yodlEvent.amount
+      };
+    } else {
+      throw error;
+    }
+  }
+  const tokenOutAmountGross = fillOutputAmount > 0n ? fillOutputAmount : depositData?.outputAmount && depositData.outputAmount > 0n ? depositData.outputAmount : tokens.tokenOutAmountGross > 0n ? tokens.tokenOutAmountGross : tokens.tokenOutAmount;
+  const bridge = {
+    sourceChainId,
+    sourceTxHash,
+    destinationChainId,
+    destinationTxHash,
+    ...tokens,
+    tokenIn: depositData?.tokenIn || tokens.tokenIn,
+    tokenInAmount: depositData?.inputAmount ?? tokens.tokenInAmount,
+    tokenOutAmountGross,
+    service: "across"
+  };
+  const payment = buildPaymentEvent(
+    yodlEvent,
+    extractEmbeddedParams(destTx.input),
+    toBlockTimestamp(destBlock),
+    sender
+  );
+  return { type: "bridge", ...payment, ...bridge };
+}
+
+// src/bridge-payment.ts
+async function decodeBridgePayment(hash, clients, options = {}) {
+  const includeAcross = options.includeAcross ?? true;
+  let relayError;
+  try {
+    return await decodeRelayBridgePayment(hash, clients);
+  } catch (error) {
+    relayError = error;
+    if (!includeAcross) {
+      throw error;
+    }
+  }
+  try {
+    return await decodeAcrossBridgePayment(hash, clients, options.fillReceipt);
+  } catch (acrossError) {
+    if (!(relayError instanceof NoBridgeFoundError) && !(acrossError instanceof NoBridgeFoundError)) {
+      throw new Error("Both Relay and Across bridge decoders failed", {
+        cause: { relayError, acrossError }
+      });
+    }
+    if (relayError instanceof NoBridgeFoundError && acrossError instanceof NoBridgeFoundError) {
+      throw acrossError;
+    }
+    if (acrossError instanceof NoBridgeFoundError) {
+      throw relayError;
+    }
+    throw acrossError;
+  }
+}
+
 // src/payment-decoder.ts
-async function tryDecodeBridge(hash, clients) {
+import { getRouter as getRouter3 } from "@yodlpay/tokenlists";
+async function tryDecodeBridge(hash, clients, options = {}) {
   try {
-    return await decodeBridgePayment(hash, clients);
+    return await decodeBridgePayment(hash, clients, options);
   } catch (error) {
-    if (!(error instanceof NoBridgeFoundError)) {
-      if (process.env.NODE_ENV === "development") {
-        console.warn("Unexpected error checking bridge info:", error);
-      }
+    if (error instanceof NoBridgeFoundError) {
+      return void 0;
     }
-    return void 0;
+    throw error;
   }
 }
-async function decodePayment(hash, chainId, clients, cachedReceipt) {
-  const provider = getClient(clients, chainId);
+async function decodePayment(hash, chainId2, clients, cachedReceipt) {
+  const provider = getClient(clients, chainId2);
   const receipt = cachedReceipt ?? await provider.getTransactionReceipt({ hash });
-  const { address: routerAddress } = getRouter2(chainId);
+  const { address: routerAddress } = getRouter3(chainId2);
   const [block, tx] = await Promise.all([
     provider.getBlock({ blockNumber: receipt.blockNumber }),
     provider.getTransaction({ hash })
@@ -583,8 +865,18 @@ async function decodePayment(hash, chainId, clients, cachedReceipt) {
     if (swapEvent) {
       return { type: "swap", ...paymentEvent, ...swapEvent };
     }
-    const bridgeResult2 = await tryDecodeBridge(hash, clients);
+    const bridgeResult2 = await tryDecodeBridge(hash, clients, {
+      fillReceipt: receipt
+    });
     if (bridgeResult2) return bridgeResult2;
+    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);
@@ -631,7 +923,7 @@ async function buildTokenInfo(params, clients) {
     }
   };
 }
-async function extractTokenInfo(paymentInfo, chainId, txHash, clients) {
+async function extractTokenInfo(paymentInfo, chainId2, txHash2, clients) {
   switch (paymentInfo.type) {
     case "direct": {
       return {
@@ -642,15 +934,15 @@ async function extractTokenInfo(paymentInfo, chainId, txHash, clients) {
             tokenOut: paymentInfo.token,
             tokenOutAmountGross: paymentInfo.amount,
             tokenOutAmountNet: paymentInfo.amount,
-            inChainId: chainId,
-            outChainId: chainId
+            inChainId: chainId2,
+            outChainId: chainId2
           },
           clients
         ),
-        sourceChainId: chainId,
-        sourceTxHash: txHash,
-        destinationChainId: chainId,
-        destinationTxHash: txHash,
+        sourceChainId: chainId2,
+        sourceTxHash: txHash2,
+        destinationChainId: chainId2,
+        destinationTxHash: txHash2,
         solver: null
       };
     }
@@ -663,15 +955,15 @@ async function extractTokenInfo(paymentInfo, chainId, txHash, clients) {
             tokenOut: paymentInfo.token,
             tokenOutAmountGross: paymentInfo.tokenOutAmount,
             tokenOutAmountNet: paymentInfo.amount,
-            inChainId: chainId,
-            outChainId: chainId
+            inChainId: chainId2,
+            outChainId: chainId2
           },
           clients
         ),
-        sourceChainId: chainId,
-        sourceTxHash: txHash,
-        destinationChainId: chainId,
-        destinationTxHash: txHash,
+        sourceChainId: chainId2,
+        sourceTxHash: txHash2,
+        destinationChainId: chainId2,
+        destinationTxHash: txHash2,
         solver: paymentInfo.service ?? null
       };
     }
@@ -698,10 +990,10 @@ async function extractTokenInfo(paymentInfo, chainId, txHash, clients) {
     }
   }
 }
-async function decodeYodlPayment(txHash, chainId, clients, cachedReceipt) {
+async function decodeYodlPayment(txHash2, chainId2, clients, cachedReceipt) {
   const paymentInfo = await decodePayment(
-    txHash,
-    chainId,
+    txHash2,
+    chainId2,
     clients,
     cachedReceipt
   );
@@ -710,8 +1002,8 @@ async function decodeYodlPayment(txHash, chainId, clients, cachedReceipt) {
   const processorMemo = firstWebhook?.memo ?? "";
   const tokenInfo = await extractTokenInfo(
     paymentInfo,
-    chainId,
-    txHash,
+    chainId2,
+    txHash2,
     clients
   );
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@yodlpay/payment-decoder",
-	"version": "1.3.2",
+	"version": "1.3.4",
 	"description": "Decode Yodl payment hashes into structured payment data",
 	"keywords": [
 		"yodl",
@@ -48,6 +48,7 @@
 		"zod": "^4.3.6"
 	},
 	"dependencies": {
+		"@across-protocol/app-sdk": "^0.5.0",
 		"@yodlpay/tokenlists": "^1.1.12"
 	},
 	"peerDependencies": {