@rabby-wallet/rabby-bridge 0.0.13-alpha.1 → 0.0.14-alpha.0

package/README.md

@@ -20,10 +20,10 @@ See [reachable route discovery](tests/fixtures/route-discovery-20261104/README.m
 
 ## Validation rollout
 
-The first rollout enforces Router/Spender allowlists and observes local calldata
-validation. No provider API or RPC requests are made. `buildTx` and
-`getQuoteListWithTx` keep the original backend transaction when source, destination
-or receiver checks fail or cannot be completed; `onError` receives those observations.
+Router/Spender allowlists and required calldata checks are always enforced.
+Reported calldata failures block: `validateBridgeTx` and `buildTx` throw
+`InvalidBridgeCalldataError`, and `getQuoteListWithTx` filters the failed quote.
+No provider API or RPC requests are made.
 
 ```ts
 const quotes = await getQuoteListWithTx(aggregatorId, {
@@ -33,7 +33,7 @@ const quotes = await getQuoteListWithTx(aggregatorId, {
 ```
 
 - Quotes and transactions come from the existing backend flow, including Relay
-  and Socket, in both modes. The SDK no longer accepts `providerClient` or exposes
+  and Socket. The SDK no longer accepts `providerClient` or exposes
   a direct-provider client/fetch adapter.
 - Router/Spender mismatches, unsupported source chains/aggregators,
   missing required slippage, missing backend results and backend request failures
@@ -42,7 +42,7 @@ const quotes = await getQuoteListWithTx(aggregatorId, {
   checked locally. Missing source fields and mismatches are reported.
 - Socket quote IDs (including CCTP), RFQ outer/vault IDs and Relay multicall
   request IDs are compared locally when a selected quote provides a matching
-  identifier. Mismatches are reported without blocking or changing field flags;
+  identifier. Mismatches block without changing the three field flags;
   missing/unrecognized keys are skipped. See the [binding limits](src/calldata/README.md).
 - Known destination tokens, minimum amounts and chains are compared. Unknown
   destination paths remain unverified and are reported with available method,
@@ -50,7 +50,7 @@ const quotes = await getQuoteListWithTx(aggregatorId, {
 - Locally derivable final receivers are compared. External order data is skipped
   without a provider request; a skipped receiver is never counted as verified.
 - Parse failures, known mismatches and unexpected missing fields are reported with
-  `blocking: false`, including when `lite` is omitted or false.
+  `pass: false, blocking: true`.
 - Relay and Socket RFQ/CCTP external destination fields are skipped rather than
   fetched. LayerSwap uses its local receiver; no background order lookup runs.
   Skipping an external receiver does not claim order-hash or provider verification.
@@ -61,16 +61,15 @@ const quotes = await getQuoteListWithTx(aggregatorId, {
   Actual mismatches retain their existing error codes. Repeated failures are not
   deduplicated, sampled or rate-limited by the SDK.
 
-`validateBridgeQuote` also accepts `{ lite, onError }` as its fourth argument;
-`validateBridgeTx` accepts it after the optional expectation as its sixth argument.
-`lite` retains its legacy missing-spender behavior; it no longer selects strict
-calldata enforcement and never skips a missing Router allowlist.
+`validateBridgeTx` accepts `{ onError }` after the optional expectation as its sixth
+argument. A missing Router allowlist or an approval address without a configured
+spender is rejected.
 
 `validateBridgeTx` now returns `BridgeValidationResult` instead of `true`:
 
 ```ts
 const result = validateBridgeTx(aggregatorId, chainId, bridgeId, tx, expectation);
-// result.pass === result.routerPass
+// Throws on required-check failures; otherwise result.pass is true.
 // result.fromPass / result.toPass / result.receiverPass
 // result.unverifiedFields / result.errors
 ```
@@ -79,12 +78,13 @@ The three field flags are true only when all required local comparisons for that
 group succeeded. False means a failure or an incomplete check; `errors` and
 `unverifiedFields` distinguish them. Known skipped fields can leave `errors` empty
 while a field flag is false. Without an expectation, field flags are false.
-They do not contribute to `pass` in this rollout. Router rejection still throws
+Validation rejects reportable failures, not every false field flag: known skipped
+fields remain allowed. Router rejection still throws
 `InvalidBridgeContractError`; its sanitized detail carries `pass: false`,
 `routerPass: false` and `blocking: true`.
 
-Raw decode/calldata-check results retain `ok: false` on failure. Observation
-details include all five pass flags, path diagnostics, `lite` and `blocking: false`.
+Raw decode/calldata-check results retain `ok: false` on failure. Failure
+details include all five pass flags, path diagnostics and `blocking`.
 These are failure-event/path counts, not distinct user counts or a denominator for
 all successful transactions. See error reporting below for failures that still throw.
 
@@ -103,7 +103,9 @@ legacy `reason` fields remain available.
 - Thrown SDK errors extend `BridgeError`. Use `error.toJSON()` for a report.
 - `onError` receives failures filtered from `getQuote` / `getQuoteListWithTx`,
   plus local validation failures and unexpected missing fields from transaction checks.
-  Directly thrown errors are handled by the caller, avoiding duplicate reporting.
+  Calldata failures are reported once before throwing; do not report those
+  errors again in a caller's catch when an `onError` reporter is supplied.
+  Other directly thrown errors are handled by the caller.
   Reporting callback failures do not affect validation or quote filtering.
 
 ```ts
@@ -138,17 +140,19 @@ reports merely because a known local limitation prevents verification.
 
 Use `toBridgeErrorReport(resultOrError)` to convert a calldata check,
 transaction validation result, detailed decode result or exception into a report.
-A transaction with `pass: true` can still produce an observation report when its
-`errors` are nonempty. Results without reportable failures return `undefined`,
+Results without reportable failures return `undefined`,
 including known skipped destination fields.
 The `onError` callback and `BridgeError.toJSON()` use the same
 runtime allowlist. Do not upload the entire check, exception, parsed transaction,
 request parameters or quote response.
 
 ```ts
-const check = validateBridgeTx(aggregatorId, chainId, bridgeId, tx, expectation);
-const report = toBridgeErrorReport(check);
-if (report) reportToBusiness(report);
+try {
+  validateBridgeTx(aggregatorId, chainId, bridgeId, tx, expectation);
+} catch (error) {
+  reportToBusiness(toBridgeErrorReport(error));
+  throw error;
+}
 ```
 
 Reports can retain recognized aggregator/bridge/method labels, source/destination

package/dist/calldata/chains.js

@@ -23,11 +23,12 @@ export const evmChainId = (chain) => {
     return CHAIN_IDS[chainEnum ? CHAIN_ENUM_TO_SERVER_ID[chainEnum] : chain.toLowerCase()];
 };
 export const sourceChainMismatch = (expected, actual) => {
-    if (actual === undefined)
+    const expectedId = evmChainId(expected);
+    if (actual === undefined || expectedId === undefined)
         return false;
     try {
         return (typeof actual === 'number' && !Number.isSafeInteger(actual)) ||
-            evmChainId(expected) === undefined || BigInt(actual) !== evmChainId(expected);
+            BigInt(actual) !== expectedId;
     }
     catch {
         return true;

package/dist/calldata/destination.js

@@ -4,6 +4,7 @@ import { isZeroWord, readSelector } from './hex.js';
 import { NATIVE_TOKEN, WRAPPED_NATIVE_TOKENS, subtractFees } from './protocols.js';
 import { calldataDiagnostics } from './diagnostics.js';
 import { ALLOWANCE_HOLDER, HYPEREVM_LIFI_ROUTER, readLifiSwap, readSettlerSwap } from './destinationSwap.js';
+import { AVALANCHE_UNIVERSAL_ROUTER, readUniversalRouterSwap } from './destinationUniswap.js';
 export const destinationCall = {
     name: 'call', kind: 'tuple', components: [
         { name: 'target', kind: 'address' }, { name: 'data', kind: 'bytes' }, { name: 'value', kind: 'uint' },
@@ -47,6 +48,7 @@ const ACROSS_MESSAGE_HANDLERS = {
     143: '0xec41f75c686e376ab2a4f18bde263ab5822c4511',
     999: '0x5e7840e06faccb6d1c3b5f5e0d1d3d07f2829bba',
     4663: '0xa8ad2e87e2043711d8bec77e8bc3e2683c0ab6bd',
+    9745: '0x5e7840e06faccb6d1c3b5f5e0d1d3d07f2829bba',
     43114: '0x9610954acdca5ff7905f051a040ce33fe613c60e',
 };
 const readAcrossMessage = (parsed, message) => {
@@ -88,8 +90,8 @@ const readAcrossMessage = (parsed, message) => {
     const lifiRouter = parsed.destinationChainId === 999n ? HYPEREVM_LIFI_ROUTER : undefined;
     const possibleRefundTokens = new Set();
     const refundReceivers = [];
-    for (const raw of calls) {
-        const call = asRecord(raw);
+    for (let index = 0; index < calls.length; index++) {
+        const call = asRecord(calls[index]);
         const target = asString(call.target);
         const data = asString(call.callData);
         const value = asBigint(call.value);
@@ -151,6 +153,20 @@ const readAcrossMessage = (parsed, message) => {
             const drain = decodeCall([{ name: 'token', kind: 'address' }, { name: 'receiver', kind: 'address' }], data);
             const token = asString(drain.token);
             const amount = balances.get(token) ?? 0n;
+            if (parsed.destinationChainId === 43114n && asString(drain.receiver) === AVALANCHE_UNIVERSAL_ROUTER) {
+                if (index + 1 >= calls.length)
+                    return parsed;
+                const next = asRecord(calls[index + 1]);
+                if (asString(next.target) !== AVALANCHE_UNIVERSAL_ROUTER || asBigint(next.value) !== 0n)
+                    return parsed;
+                const swap = readUniversalRouterSwap(asString(next.callData), handler);
+                if (!swap || swap.inputToken !== token || swap.inputAmount !== amount)
+                    return parsed;
+                balances.set(token, 0n);
+                balances.set(swap.outputToken, (balances.get(swap.outputToken) ?? 0n) + swap.minOutputAmount);
+                index++;
+                continue;
+            }
             if (possibleRefundTokens.delete(token))
                 refundReceivers.push(asString(drain.receiver));
             if (amount > 0n)

package/dist/calldata/destinationSwap.js

@@ -5,7 +5,9 @@ import { methods as lifiSwaps } from './lifi/swap/index.js';
 export const ALLOWANCE_HOLDER = '0x0000000000001ff3684f28c67538d4d072c22734';
 // Reviewed deployments, not dynamic registry lookups. Evidence and renewal limits:
 // tests/fixtures/route-discovery-20261104/evidence/base-settler-verification.json
+// tests/fixtures/reported-20261111-evidence.json (Ethereum)
 const SETTLERS = {
+    1: '0xaddc26a3854feabfd20d6bf658254088d83a425a',
     8453: '0x7d6839415693801e94cdc4a7d732c9a3fdbbd1d7',
     999: '0xf58d4122251f2ace689f257eaf2688883e30fc6e',
 };
@@ -52,7 +54,8 @@ export const readSettlerSwap = (data, chain, recipient, balances) => {
     // These reviewed actions cannot mutate/zeroize slippage. CHECK_SLIPPAGE, SELECT
     // and unreviewed actions must not bypass the final enforced transfer to Handler.
     if (!actions.length || readSelector(actions[0]) !== '0xc1fb425e' ||
-        actions.slice(1).some((action) => !['0x38c9c147', '0x8d68a156', '0x5f80abae'].includes(readSelector(action) ?? '')))
+        actions.slice(1).some((action) => !['0x38c9c147', '0x8d68a156', '0x5f80abae'].includes(readSelector(action) ?? '') &&
+            !(chain === 1n && readSelector(action) === '0xf61460f9')))
         return undefined;
     const funding = decodeCall([
         { name: 'recipient', kind: 'address' }, { name: 'token', kind: 'address' },
@@ -64,8 +67,8 @@ export const readSettlerSwap = (data, chain, recipient, balances) => {
         return undefined;
     let inputAmount = asBigint(args.amount);
     const maxUint256 = (1n << 256n) - 1n;
-    // shortcut: only HyperEVM's reviewed 100%-balance encoding; review other ratios before support.
-    if (chain === 999n && inputAmount > maxUint256 - 1000000n) {
+    // shortcut: only reviewed Ethereum/HyperEVM 100%-balance encoding; review other ratios before support.
+    if ((chain === 1n || chain === 999n) && inputAmount > maxUint256 - 1000000n) {
         if (inputAmount !== maxUint256)
             return undefined;
         inputAmount = balances?.get(asString(args.token)) ?? 0n;

package/dist/calldata/destinationUniswap.d.ts

@@ -0,0 +1,7 @@
+export declare const AVALANCHE_UNIVERSAL_ROUTER = "0x661e93cca42afacb172121ef892830ca3b70f08d";
+export declare const readUniversalRouterSwap: (data: string, recipient: string) => {
+    inputToken: string;
+    inputAmount: bigint;
+    outputToken: string;
+    minOutputAmount: bigint;
+} | undefined;

package/dist/calldata/destinationUniswap.js

@@ -0,0 +1,57 @@
+import { asArray, asBigint, asRecord, asString, decodeCall, decodeParameters } from './abi.js';
+import { readSelector } from './hex.js';
+import { isNative, NATIVE_TOKEN } from './protocols.js';
+// Reviewed UniversalRouter v2.1.2; see reported-20261111-evidence.json.
+export const AVALANCHE_UNIVERSAL_ROUTER = '0x661e93cca42afacb172121ef892830ca3b70f08d';
+export const readUniversalRouterSwap = (data, recipient) => {
+    if (readSelector(data) !== '0x24856bc3')
+        return undefined;
+    const execution = decodeCall([
+        { name: 'commands', kind: 'bytes' },
+        { name: 'inputs', kind: 'array', item: { name: 'input', kind: 'bytes' } },
+    ], data);
+    const inputs = asArray(execution.inputs);
+    // No optional/reverting commands or unrelated transfers may bypass the payout.
+    if (asString(execution.commands) !== '0x10' || inputs.length !== 1)
+        return undefined;
+    const plan = decodeParameters([
+        { name: 'actions', kind: 'bytes' },
+        { name: 'params', kind: 'array', item: { name: 'param', kind: 'bytes' } },
+    ], asString(inputs[0]));
+    const params = asArray(plan.params).map(asString);
+    if (asString(plan.actions) !== '0x070b0e' || params.length !== 3)
+        return undefined;
+    const swap = asRecord(decodeParameters([{ name: 'swap', kind: 'tuple', components: [
+                { name: 'currencyIn', kind: 'address' },
+                { name: 'path', kind: 'array', item: { name: 'hop', kind: 'tuple', components: [
+                            { name: 'intermediateCurrency', kind: 'address' }, { name: 'fee', kind: 'uint' },
+                            { name: 'tickSpacing', kind: 'uint' }, { name: 'hooks', kind: 'address' }, { name: 'hookData', kind: 'bytes' },
+                        ] } },
+                { name: 'minHopPriceX36', kind: 'array', item: { name: 'price', kind: 'uint' } },
+                { name: 'amountIn', kind: 'uint' }, { name: 'amountOutMinimum', kind: 'uint' },
+            ] }], params[0]).swap);
+    const path = asArray(swap.path).map(asRecord);
+    const prices = asArray(swap.minHopPriceX36);
+    // shortcut: one ERC20 hop without hooks; review additional V4 plans before support.
+    if (path.length !== 1 || prices.length > 1)
+        return undefined;
+    const hop = path[0];
+    const inputToken = asString(swap.currencyIn), outputToken = asString(hop.intermediateCurrency);
+    const inputAmount = asBigint(swap.amountIn), minOutputAmount = asBigint(swap.amountOutMinimum);
+    if (isNative(inputToken) || isNative(outputToken) || inputToken === outputToken ||
+        asString(hop.hooks) !== NATIVE_TOKEN || asString(hop.hookData) !== '0x' ||
+        asBigint(hop.fee) > 1000000n || asBigint(hop.tickSpacing) <= 0n || asBigint(hop.tickSpacing) > 32767n ||
+        inputAmount <= 0n || inputAmount >= (1n << 128n) || minOutputAmount <= 0n || minOutputAmount >= (1n << 128n))
+        return undefined;
+    const settle = decodeParameters([
+        { name: 'currency', kind: 'address' }, { name: 'amount', kind: 'uint' }, { name: 'payerIsUser', kind: 'bool' },
+    ], params[1]);
+    const take = decodeParameters([
+        { name: 'currency', kind: 'address' }, { name: 'recipient', kind: 'address' }, { name: 'amount', kind: 'uint' },
+    ], params[2]);
+    // OPEN_DELTA (0) settles the swap's debt from Router and takes all output back to Handler.
+    if (asString(settle.currency) !== inputToken || asBigint(settle.amount) !== 0n || settle.payerIsUser !== false ||
+        asString(take.currency) !== outputToken || asString(take.recipient) !== recipient || asBigint(take.amount) !== 0n)
+        return undefined;
+    return { inputToken, inputAmount, outputToken, minOutputAmount };
+};

package/dist/calldata/expect.d.ts

@@ -10,6 +10,8 @@ export type BridgeCallExpectation = {
     toTokenRawAmount?: string;
     /** Selected backend quote key; only protocol identifiers with known semantics are compared. */
     quoteKey?: string | Record<string, unknown>;
+    /** Relay `protocol.v2.orderData` captured with the transaction being signed. */
+    orderData?: unknown;
     /** 小数滑点。0.01 表示 1%。 */
     slippage?: string | number;
 };
@@ -21,7 +23,7 @@ export type CompareMask = {
     receiver: boolean;
 };
 export declare const knownCompare: (parsed: ParsedBridgeCall) => CompareMask;
-/** Actual source payment may exceed local intent by at most 0.1%; lower payments fail comparison. */
+/** Source payment is capped at 100.1% of local intent; smaller payments are allowed. */
 export declare const sourceAmountMatches: (actual: bigint | undefined, expected: bigint) => boolean;
 export declare const expectationFailures: (parsed: ParsedBridgeCall, expectation: BridgeCallExpectation, chainId: string, mask: CompareMask) => BridgeErrorDefinition[];
 export declare const finishCheck: (aggregatorId: string, parsed: ParsedBridgeCall, structural: BridgeErrorDefinition | undefined, expectation: BridgeCallExpectation | undefined, chainId: string, mask: CompareMask) => BridgeCheck;

package/dist/calldata/expect.js

@@ -55,9 +55,9 @@ const selectedQuoteIdentifier = (quoteKey) => {
     const match = /^(0x[0-9a-f]{64})(?::[^:]+)?$/i.exec(key.quote_id);
     return match?.[1].toLowerCase();
 };
-/** Actual source payment may exceed local intent by at most 0.1%; lower payments fail comparison. */
-export const sourceAmountMatches = (actual, expected) => actual !== undefined && expected >= 0n && actual >= expected && (actual - expected) * 1000n <= expected;
-/** Allow a 5% relative difference from the quote's slippage-adjusted minimum. */
+/** Source payment is capped at 100.1% of local intent; smaller payments are allowed. */
+export const sourceAmountMatches = (actual, expected) => actual !== undefined && actual >= 0n && expected >= 0n && actual * 1000n <= expected * 1001n;
+/** Allow up to 5% below the slippage-adjusted minimum; higher guarantees always pass. */
 const minReceiveMatches = (minReceive, quoted, slippage) => {
     if (minReceive <= 0n || quoted <= 0n || slippage < 0 || slippage >= 1) {
         return false;
@@ -67,11 +67,7 @@ const minReceiveMatches = (minReceive, quoted, slippage) => {
     if (minimum <= 0n) {
         return false;
     }
-    if (minReceive === minimum) {
-        return true;
-    }
-    const difference = minReceive > minimum ? minReceive - minimum : minimum - minReceive;
-    return difference * 20n <= minimum;
+    return minReceive * 20n >= minimum * 19n;
 };
 export const expectationFailures = (parsed, expectation, chainId, mask) => {
     const reasons = [];
@@ -116,9 +112,12 @@ export const expectationFailures = (parsed, expectation, chainId, mask) => {
             reasons.push(BRIDGE_ERRORS.MIN_RECEIVE_MISMATCH);
         }
     }
-    if (mask.receiver && !sameToken(parsed.receiver, expectation.userAddress, chainId)) {
+    if (mask.receiver && !parsed.fixedReceiver && !sameToken(parsed.receiver, expectation.userAddress, chainId)) {
         reasons.push(BRIDGE_ERRORS.RECEIVER_MISMATCH);
     }
+    if (parsed.refundRecipients?.some((recipient) => recipient.toLowerCase() !== expectation.userAddress.toLowerCase())) {
+        reasons.push(BRIDGE_ERRORS.REFUND_RECIPIENT_MISMATCH);
+    }
     return reasons;
 };
 export const finishCheck = (aggregatorId, parsed, structural, expectation, chainId, mask) => {
@@ -148,7 +147,7 @@ export const finishCheck = (aggregatorId, parsed, structural, expectation, chain
         minOutputAmount: mask.toAmount && expectation?.toTokenRawAmount !== undefined,
         receiver: mask.receiver,
     }).filter(([, checked]) => !expectation || !checked).map(([field]) => field);
-    if (expectation?.toChainId && (parsed.destinationChainId === undefined || evmChainId(expectation.toChainId) === undefined)) {
+    if (expectation?.toChainId && parsed.destinationChainId === undefined) {
         unverifiedFields.push('destinationChainId');
     }
     if (errors.length) {

package/dist/calldata/lifi/across/acrossV4Erc20Min.js

@@ -19,6 +19,7 @@ export const startBridgeTokensViaAcrossV4ERC20Min = {
             sourceAmount: asBigint(args.inputAmount),
             destinationChainId: asBigint(parameters.destinationChainId),
             receiver: accountFromBytes32(asString(parameters.receiver)),
+            refundRecipients: [accountFromBytes32(asString(parameters.depositor))],
             outputToken: accountFromBytes32(asString(parameters.receivingAssetId)),
             minOutputAmount: asBigint(parameters.outputAmount),
         };

package/dist/calldata/lifi/across/acrossV4NativeMin.js

@@ -15,6 +15,7 @@ export const startBridgeTokensViaAcrossV4NativeMin = {
             sourceAmount: value,
             destinationChainId: asBigint(parameters.destinationChainId),
             receiver: accountFromBytes32(asString(parameters.receiver)),
+            refundRecipients: [accountFromBytes32(asString(parameters.depositor))],
             outputToken: accountFromBytes32(asString(parameters.receivingAssetId)),
             minOutputAmount: asBigint(parameters.outputAmount),
         };

package/dist/calldata/lifi/params.js

@@ -164,6 +164,7 @@ export const applyBridgeData = (method, raw) => {
 };
 export const applyAcrossData = (parsed, raw) => {
     const data = asRecord(raw);
+    parsed.refundRecipients = [accountFromBytes32(asString(data.refundAddress))];
     parsed.receiver = accountFromBytes32(asString(data.receiverAddress));
     parsed.outputToken = accountFromBytes32(asString(data.receivingAssetId));
     parsed.minOutputAmount = asBigint(data.outputAmount);
@@ -258,6 +259,7 @@ export const applyPolymerData = (parsed, raw) => {
 };
 export const applyLifiIntentData = (parsed, raw) => {
     const data = asRecord(raw);
+    parsed.refundRecipients = [asString(data.depositAndRefundAddress)];
     parsed.receiver = accountFromBytes32(asString(data.recipient));
     parsed.outputToken = accountFromBytes32(asString(data.outputToken));
     parsed.minOutputAmount = (parsed.bridgeAmount ?? 0n) * asBigint(data.outputAmountMultiplier) / 10n ** 18n;

package/dist/calldata/protocols.js

@@ -16,7 +16,7 @@ export const isNative = (token) => token === NATIVE_TOKEN || token.toLowerCase()
 // Circle CCTP domains and Wormhole IDs are different namespaces from EVM chain IDs.
 export const CCTP_CHAINS = {
     0: 1n, 1: 43114n, 2: 10n, 3: 42161n, 6: 8453n, 7: 137n,
-    10: 130n, 11: 59144n, 13: 146n, 15: 143n, 19: 999n,
+    10: 130n, 11: 59144n, 13: 146n, 15: 143n, 19: 999n, 21: 57073n,
 };
 export const WORMHOLE_CHAINS = {
     2: 1n, 4: 56n, 5: 137n, 6: 43114n, 23: 42161n, 24: 10n,
@@ -48,6 +48,7 @@ export const CCTP_USDC = {
     146: '0x29219dd400f2bf60e5a23d13be72b486d4038894',
     999: '0xb88339cb7199b77e23db6e890353e22632ba630f',
     59144: '0x176211869ca2b568f2a7d4ee941e073a821ee1ff',
+    57073: '0x2d270e6886d130d724215a266106e6832161eaed',
 };
 export const subtractFees = (amount, ...fees) => {
     const total = fees.reduce((sum, fee) => sum + fee, 0n);

package/dist/calldata/relay/calls.d.ts

@@ -3,7 +3,7 @@ import type { ParsedBridgeCall } from '../types.js';
 export declare const callTuple: AbiParam;
 export declare const callsParam: AbiParam;
 export declare const requestIdFromMetadata: (metadata: string) => string | undefined;
-export declare const relayCall: (method: string, metadata: string, value: bigint, source?: {
+export declare const relayCall: (method: string, metadata: string, value: bigint, calls: AbiValue, source?: {
     token?: string;
     amount?: bigint;
 }) => ParsedBridgeCall;

package/dist/calldata/relay/calls.js

@@ -2,6 +2,7 @@ import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
 import { asBigint, asRecord, asString } from '../abi.js';
 import { isZeroWord } from '../hex.js';
 import { NATIVE_TOKEN } from '../protocols.js';
+import { nestedRelayOrder } from './nestedDeposit.js';
 export const callTuple = {
     name: 'call',
     kind: 'tuple',
@@ -25,13 +26,16 @@ export const requestIdFromMetadata = (metadata) => {
     const requestId = `0x${body.slice(0, 64)}`;
     return isZeroWord(requestId) ? undefined : requestId;
 };
-export const relayCall = (method, metadata, value, source) => ({
+export const relayCall = (method, metadata, value, calls, source) => ({
     aggregatorId: 'relay',
     method,
     kind: 'deposit',
     requestId: requestIdFromMetadata(metadata),
     sourceToken: source?.token ?? (value > 0n ? NATIVE_TOKEN : undefined),
     sourceAmount: source?.amount && source.amount > 0n ? source.amount : value,
+    ...nestedRelayOrder(calls, method === 'transferAndMulticall' && value === 0n && source?.token && source.amount !== undefined
+        ? { token: source.token, amount: source.amount }
+        : method === 'multicall' && value > 0n ? { token: NATIVE_TOKEN, amount: value } : undefined),
 });
 const amountOf = (record) => {
     const amount = record.amount ?? record.value;

package/dist/calldata/relay/index.js

@@ -10,6 +10,7 @@ import { permit3009TransferAndMulticallSigned } from './permit3009TransferAndMul
 import { permitTransferAndMulticall } from './permitTransferAndMulticall.js';
 import { permitTransferAndMulticallLegacy } from './permitTransferAndMulticallLegacy.js';
 import { transferAndMulticall } from './transferAndMulticall.js';
+import { getBridgeRouter } from '../../list.js';
 import { relayFailure } from './validate.js';
 import { BRIDGE_ERRORS } from '../../errors/index.js';
 const METHODS = [
@@ -37,6 +38,8 @@ export const validateRelay = (data, value, expectation, chainId = '') => {
     if (!hit.ok) {
         return { ...hit, aggregatorId: 'relay' };
     }
-    return finishCheck('relay', hit.parsed, expectation && hit.parsed.depositor !== undefined && hit.parsed.depositor !== expectation.userAddress.toLowerCase()
-        ? BRIDGE_ERRORS.DEPOSITOR_MISMATCH : relayFailure(hit.parsed), expectation, chainId, relayCompareMask(hit.parsed));
+    return finishCheck('relay', hit.parsed, hit.parsed.innerTarget && chainId && hit.parsed.innerTarget !== getBridgeRouter('relay', chainId)
+        ? BRIDGE_ERRORS.RELAY_CANONICAL_DEPOSITORY_MISMATCH
+        : expectation && hit.parsed.depositor !== undefined && hit.parsed.depositor !== expectation.userAddress.toLowerCase()
+            ? BRIDGE_ERRORS.DEPOSITOR_MISMATCH : relayFailure(hit.parsed), expectation, chainId, relayCompareMask(hit.parsed));
 };

package/dist/calldata/relay/multicall.js

@@ -10,6 +10,6 @@ export const multicall = {
             { name: 'nftRecipient', kind: 'address' },
             { name: 'metadata', kind: 'bytes' },
         ], data);
-        return relayCall('multicall', asString(args.metadata), value);
+        return relayCall('multicall', asString(args.metadata), value, args.calls);
     },
 };

package/dist/calldata/relay/nestedDeposit.d.ts

@@ -0,0 +1,8 @@
+import { type AbiValue } from '../abi.js';
+import type { ParsedBridgeCall } from '../types.js';
+export declare const relayFundingRouter: (method: string, target: string) => string | undefined;
+/** Read one final deposit from actual calls, never from metadata or signatures. */
+export declare const nestedRelayOrder: (rawCalls: AbiValue, funding?: {
+    token: string;
+    amount: bigint;
+}) => Pick<ParsedBridgeCall, "orderId" | "depositor" | "innerTarget" | "bridgeToken" | "bridgeAmount" | "bridgeReceiver"> | undefined;

package/dist/calldata/relay/nestedDeposit.js

@@ -0,0 +1,107 @@
+import { depositErc20 } from './depositErc20.js';
+import { depositErc20Allowance } from './depositErc20Allowance.js';
+import { depositNative } from './depositNative.js';
+import { asArray, asBigint, asRecord, asString, decodeCall } from '../abi.js';
+import { BRIDGE_ROUTER_WHITELIST } from '../../list.js';
+import { isZeroWord, readSelector } from '../hex.js';
+import { NATIVE_TOKEN } from '../protocols.js';
+const DEPOSITORIES = new Set(Object.values(BRIDGE_ROUTER_WHITELIST.relay));
+// shortcut: reviewed v3.2 cleanup wrappers only; review new deployments before adding them.
+const PROXY_ROUTERS = {
+    '0x5567954cd026cebfe486062cb75848e0f1c12e58': '0x0729e2a4716d9f7dd17858d5d504426d228697f7',
+    '0xe4dfbd5e6784db1058124e2c87554c0591f0fb7b': '0x6328ea02d28131e58b28e55c6258258a30d90e05',
+};
+const ROUTERS = new Set(Object.values(PROXY_ROUTERS));
+export const relayFundingRouter = (method, target) => method === 'transferAndMulticall' ? PROXY_ROUTERS[target]
+    : method === 'multicall' && ROUTERS.has(target) ? target : undefined;
+const CLEANUP_NATIVE = '0x5d1fe6a2';
+const CLEANUP_ERC20 = '0x73b7bb2f';
+/** Read one final deposit from actual calls, never from metadata or signatures. */
+export const nestedRelayOrder = (rawCalls, funding) => {
+    try {
+        const calls = asArray(rawCalls).map(asRecord);
+        if (!calls.length)
+            return undefined;
+        // Multiple deposit/cleanup calls cannot be bound to a single backend order.
+        if (calls.slice(0, -1).some((call) => DEPOSITORIES.has(asString(call.target)) ||
+            (ROUTERS.has(asString(call.target)) && [CLEANUP_NATIVE, CLEANUP_ERC20].includes(readSelector(asString(call.callData)) ?? ''))))
+            return undefined;
+        const last = calls[calls.length - 1];
+        if (last.allowFailure !== false)
+            return undefined;
+        let target = asString(last.target), data = asString(last.callData);
+        const wrapper = ROUTERS.has(target) ? target : undefined;
+        let value = asBigint(last.value);
+        let token;
+        let nativeCleanup = false;
+        let cleanupAmount;
+        if (ROUTERS.has(target)) {
+            if (value !== 0n)
+                return undefined;
+            if (readSelector(data) === CLEANUP_NATIVE) {
+                const args = decodeCall([{ name: 'amount', kind: 'uint' }, { name: 'to', kind: 'address' }, { name: 'data', kind: 'bytes' }], data);
+                target = asString(args.to);
+                data = asString(args.data);
+                value = asBigint(args.amount);
+                cleanupAmount = value;
+                nativeCleanup = true;
+            }
+            else if (readSelector(data) === CLEANUP_ERC20) {
+                const args = decodeCall([
+                    { name: 'tokens', kind: 'array', item: { name: 'token', kind: 'address' } },
+                    { name: 'tos', kind: 'array', item: { name: 'to', kind: 'address' } },
+                    { name: 'datas', kind: 'array', item: { name: 'data', kind: 'bytes' } },
+                    { name: 'amounts', kind: 'array', item: { name: 'amount', kind: 'uint' } },
+                ], data);
+                if (Object.values(args).some((items) => asArray(items).length !== 1))
+                    return undefined;
+                target = asString(asArray(args.tos)[0]);
+                data = asString(asArray(args.datas)[0]);
+                token = asString(asArray(args.tokens)[0]);
+                cleanupAmount = asBigint(asArray(args.amounts)[0]);
+            }
+            else
+                return undefined;
+        }
+        if (!DEPOSITORIES.has(target))
+            return undefined;
+        const method = [depositNative, depositErc20, depositErc20Allowance].find((item) => item.selector === readSelector(data));
+        if (!method || (nativeCleanup && method !== depositNative) || (token && method === depositNative))
+            return undefined;
+        const parsed = method.decode(data, value);
+        if (isZeroWord(parsed.orderId) || (token && token !== parsed.sourceToken))
+            return undefined;
+        const result = { orderId: parsed.orderId, depositor: parsed.depositor, innerTarget: target };
+        if (!funding || funding.amount <= 0n || funding.token !== parsed.sourceToken)
+            return result;
+        // shortcut: only one approval before deposit; add funding analysis before supporting swaps/other calls.
+        const prefix = calls.slice(0, -1);
+        if (prefix.length > 1)
+            return result;
+        let approved;
+        if (prefix.length) {
+            const call = prefix[0];
+            if (funding.token === NATIVE_TOKEN || call.allowFailure !== false ||
+                asString(call.target) !== funding.token || asBigint(call.value) !== 0n ||
+                readSelector(asString(call.callData)) !== '0x095ea7b3')
+                return result;
+            const args = decodeCall([{ name: 'spender', kind: 'address' }, { name: 'amount', kind: 'uint' }], asString(call.callData));
+            if (asString(args.spender) !== target)
+                return result;
+            approved = asBigint(args.amount);
+        }
+        // Zero cleanup means all remaining balance; here the full input is still on Router.
+        const amount = cleanupAmount === 0n ? funding.amount : cleanupAmount;
+        const depositAmount = method === depositErc20Allowance ? amount ?? approved
+            : nativeCleanup ? amount : parsed.sourceAmount;
+        if (depositAmount !== funding.amount ||
+            (cleanupAmount !== undefined && amount !== funding.amount) ||
+            (method !== depositNative && value !== 0n))
+            return result;
+        return { ...result, bridgeToken: funding.token, bridgeAmount: funding.amount, bridgeReceiver: wrapper };
+    }
+    catch {
+        // Unknown or malformed calls leave the order unresolved for the signing check.
+        return undefined;
+    }
+};

package/dist/calldata/relay/permit2TransferAndMulticall.js

@@ -35,7 +35,7 @@ export const permit2TransferAndMulticall = {
         ], data);
         const source = firstPositive(asArray(asRecord(args.permit).permitted));
         return {
-            ...relayCall('permit2TransferAndMulticall', asString(args.metadata), value, source),
+            ...relayCall('permit2TransferAndMulticall', asString(args.metadata), value, args.calls, source),
             depositor: asString(args.user),
         };
     },

package/dist/calldata/relay/permit3009TransferAndMulticall.js

@@ -32,7 +32,7 @@ const decodePermits = (name, selector, tail) => ({
         ], data);
         const source = firstPositive(asArray(args.permits));
         const tokens = asArray(args.tokens).map((token) => asString(token));
-        return relayCall(name, asString(args.metadata), value, {
+        return relayCall(name, asString(args.metadata), value, args.calls, {
             token: tokens[0] ?? source.token,
             amount: source.amount,
         });

package/dist/calldata/relay/permit3009TransferAndMulticallSigned.js

@@ -32,7 +32,7 @@ export const permit3009TransferAndMulticallSigned = {
         ], data);
         const source = firstPositive(asArray(args.permits));
         const tokens = asArray(args.tokens).map((token) => asString(token));
-        return relayCall('permit3009TransferAndMulticallSigned', asString(args.metadata), value, {
+        return relayCall('permit3009TransferAndMulticallSigned', asString(args.metadata), value, args.calls, {
             token: tokens[0] ?? source.token,
             amount: source.amount,
         });

package/dist/calldata/relay/permitTransferAndMulticall.js

@@ -29,6 +29,6 @@ export const permitTransferAndMulticall = {
             { name: 'metadata', kind: 'bytes' },
         ], data);
         const source = firstPositive(asArray(args.permits));
-        return relayCall('permitTransferAndMulticall', asString(args.metadata), value, source);
+        return relayCall('permitTransferAndMulticall', asString(args.metadata), value, args.calls, source);
     },
 };

package/dist/calldata/relay/permitTransferAndMulticallLegacy.js

@@ -30,6 +30,6 @@ export const permitTransferAndMulticallLegacy = {
             { name: 'metadata', kind: 'bytes' },
         ], data);
         const source = firstPositive(asArray(args.permits));
-        return relayCall('permitTransferAndMulticallLegacy', asString(args.metadata), value, source);
+        return relayCall('permitTransferAndMulticallLegacy', asString(args.metadata), value, args.calls, source);
     },
 };