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

package/README.md

@@ -7,11 +7,10 @@ Minimal bridge SDK for Rabby:
 - validates backend bridge quotes before returning them
 - decodes source transactions for Across, LI.FI, Relay, Socket and Mayan
 - keeps chain-state-dependent output fields explicitly unverified, without RPC requests
-- validates Relay orders, three Socket routes and LI.FI LayerSwap through direct provider requests
+- performs local validation only; no direct-provider HTTP requests or RPC reads
 
 See [calldata parsing](src/calldata/README.md) for supported paths, integration and verification boundaries.
-See [direct provider integration](src/providers/README.md) for the shared extension/mobile
-transport interface, quote binding, application-fee constraints and signing checks.
+See [offline provider evidence](src/providers/README.md) for retained historical fixtures and verification limits.
 
 ## Test
 
@@ -19,50 +18,75 @@ Run `yarn test` to build the package and execute the Jest suite.
 
 See [reachable route discovery](tests/fixtures/route-discovery-20261104/README.md) for the latest parsing changes, fixture coverage and remaining verification limits.
 
-## Lite rollout
+## Validation rollout
 
-Pass `lite: true` to `getQuote`, `buildTx` or `getQuoteListWithTx` to observe new
-validation without letting it change the business decisions from `main`.
-The default is `false`, retaining strict behavior.
+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.
 
 ```ts
 const quotes = await getQuoteListWithTx(aggregatorId, {
   ...params,
-  lite: true,
   onError: (report) => reportToBusiness(report),
 }, api);
 ```
 
 - Quotes and transactions come from the existing backend flow, including Relay
-  and Socket. Provider quotes never replace the selected backend quote in lite mode.
-- Configured Router/Spender mismatches, unsupported source chains/aggregators,
+  and Socket, in both modes. 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
   keep their original blocking behavior.
-- Calldata parsing, intent comparison, missing-field checks, stricter missing
-  contract configuration and provider verification still run against the returned
-  transaction. Their failures are reported without discarding that quote/transaction.
-- No parser is reported as unsupported, including aggregators that strict mode
-  does not currently parse. It is never reported as a successful parse.
-- Relay/Socket verification uses available proof/cache for the selected transaction.
-  If that proof or client is missing, the original missing-proof error is reported;
-  dependent hash/order checks cannot complete. An unrelated fresh provider quote
-  is not fetched or used as evidence for the backend transaction.
-- LayerSwap lookup runs in the background in lite mode. Its result is reported
-  through `onError` and does not delay returning the backend transaction.
+- Source token, source amount, supplied sender/chain and protocol structure are
+  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;
+  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,
+  selector and nested-call diagnostics.
+- 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.
+- 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.
+- Known unresolved output token/minimum fields and Relay/Socket external
+  receiver/chain fields stay in `unverifiedFields` without producing reports.
+  Missing source fields, unknown receivers/paths and a missing expected amount
+  for a locally available minimum use `BRIDGE_UNVERIFIED_BRIDGE_FIELDS`.
+  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.
-Raw decode/calldata-check results remain truthful (`ok: false` on failure).
-Direct provider-client methods remain strict; use the high-level entry points for
-lite rollout decisions.
-
-Error codes and details are preserved. Lite observations carry `lite: true` and
-`blocking: false`; legacy failures carry `blocking: true` when reported by the
-high-level flow. Keep the callback installed while background checks are pending.
-Dependent checks still stop at their first unusable prerequisite, and independent
-stages may emit multiple reports. These are failure-event/path counts, not distinct
-user counts or a denominator for all successful transactions. No user identifiers
-are added. See error reporting below for catching failures that still throw.
+`lite` retains its legacy missing-spender behavior; it no longer selects strict
+calldata enforcement and never skips a missing Router allowlist.
+
+`validateBridgeTx` now returns `BridgeValidationResult` instead of `true`:
+
+```ts
+const result = validateBridgeTx(aggregatorId, chainId, bridgeId, tx, expectation);
+// result.pass === result.routerPass
+// result.fromPass / result.toPass / result.receiverPass
+// result.unverifiedFields / result.errors
+```
+
+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
+`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`.
+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.
 
 ## Error reporting
 
@@ -77,7 +101,8 @@ legacy `reason` fields remain available.
   Independent intent mismatches are collected together; decoding or dependent
   protocol operations stop at their first failure.
 - Thrown SDK errors extend `BridgeError`. Use `error.toJSON()` for a report.
-- `onError` receives failures filtered from `getQuote` / `getQuoteListWithTx`.
+- `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.
   Reporting callback failures do not affect validation or quote filtering.
 
@@ -106,19 +131,22 @@ retained for compatibility; prefer `toJSON()` for reporting.
 Stages distinguish input checks, contract allowlists, ABI decoding, protocol
 structure, intent comparison, provider requests, provider responses, transaction
 binding and completeness. Unexpected uncategorized failures use `BRIDGE_UNKNOWN`.
-Deferred chain-state output fields remain in `unverifiedFields`; they do not
-become errors merely because RPC validation is postponed.
+Deferred chain-state output fields remain in `unverifiedFields` without producing
+reports merely because a known local limitation prevents verification.
 
 ### Privacy-safe diagnostics
 
-Use `toBridgeErrorReport(resultOrError)` to convert a failed calldata check,
-detailed decode result or exception into a report. Passing a successful result
-returns `undefined`. The `onError` callback and `BridgeError.toJSON()` use the same
+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`,
+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 = validateBridgeCalldata(aggregatorId, chainId, tx, expectation);
+const check = validateBridgeTx(aggregatorId, chainId, bridgeId, tx, expectation);
 const report = toBridgeErrorReport(check);
 if (report) reportToBusiness(report);
 ```

package/dist/calldata/across/validate.js

@@ -2,6 +2,12 @@ import { BRIDGE_ERRORS } from '../../errors/index.js';
 import { getBridgeRouter } from '../../list.js';
 import { evmChainId } from '../chains.js';
 import { isZeroWord } from '../hex.js';
+// These chains use a Periphery as the outer router, separate from their canonical SpokePool.
+const SPOKE_POOLS = {
+    56: '0x4e8e101924ede233c13e2d8622dc8aed2872d505',
+    324: '0xe0b015e54d54fc84a6cb9b666099c46ade9335ff',
+    57073: '0xef684c38f94f48775959ecf2012d7e864ffb9dd4',
+};
 export const acrossFailure = (parsed, chainId, expectedDepositor) => {
     if (expectedDepositor && parsed.depositor?.toLowerCase() !== expectedDepositor.toLowerCase()) {
         return BRIDGE_ERRORS.DEPOSITOR_MISMATCH;
@@ -19,10 +25,8 @@ export const acrossFailure = (parsed, chainId, expectedDepositor) => {
         return undefined;
     }
     const spoke = parsed.spokePool.toLowerCase();
-    // BSC's configured outer router is a periphery, separate from its canonical SpokePool.
-    const expectedSpoke = evmChainId(chainId) === 56n
-        ? '0x4e8e101924ede233c13e2d8622dc8aed2872d505'
-        : getBridgeRouter('across', chainId)?.toLowerCase();
+    const expectedSpoke = SPOKE_POOLS[evmChainId(chainId)?.toString() ?? ''] ??
+        getBridgeRouter('across', chainId)?.toLowerCase();
     if (expectedSpoke !== spoke) {
         return BRIDGE_ERRORS.SPOKE_POOL_IS_NOT_IN_THE_ALLOWLIST;
     }

package/dist/calldata/destination.js

@@ -3,6 +3,7 @@ import { asArray, asBigint, asRecord, asString, decodeCall, decodeParameters } f
 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';
 export const destinationCall = {
     name: 'call', kind: 'tuple', components: [
         { name: 'target', kind: 'address' }, { name: 'data', kind: 'bytes' }, { name: 'value', kind: 'uint' },
@@ -11,7 +12,7 @@ export const destinationCall = {
 export const readTransfer = (target, data, value) => {
     if (data === '0x' && value > 0n)
         return { receiver: target, outputToken: NATIVE_TOKEN, minOutputAmount: value };
-    if (readSelector(data) !== '0xa9059cbb')
+    if (value !== 0n || readSelector(data) !== '0xa9059cbb')
         return undefined;
     const args = decodeCall([{ name: 'to', kind: 'address' }, { name: 'amount', kind: 'uint' }], data);
     return { receiver: asString(args.to), outputToken: target, minOutputAmount: asBigint(args.amount) };
@@ -27,8 +28,11 @@ export const readDestinationTransfers = (calls) => {
     if (!transfers.length || transfers.some((transfer) => !transfer))
         return { diagnostics };
     const first = transfers[0];
-    if (!transfers.every((transfer) => transfer !== undefined && transfer.receiver === first.receiver && transfer.outputToken === first.outputToken))
+    if (!transfers.every((transfer) => transfer?.receiver === first.receiver))
         return { diagnostics };
+    // Different assets can have one recipient without having one comparable output amount.
+    if (!transfers.every((transfer) => transfer?.outputToken === first.outputToken))
+        return { receiver: first.receiver, diagnostics };
     return { ...first, diagnostics, minOutputAmount: transfers.reduce((sum, transfer) => sum + (transfer?.minOutputAmount ?? 0n), 0n) };
 };
 const instructions = {
@@ -40,6 +44,7 @@ const instructions = {
     ],
 };
 const ACROSS_MESSAGE_HANDLERS = {
+    143: '0xec41f75c686e376ab2a4f18bde263ab5822c4511',
     999: '0x5e7840e06faccb6d1c3b5f5e0d1d3d07f2829bba',
     4663: '0xa8ad2e87e2043711d8bec77e8bc3e2683c0ab6bd',
     43114: '0x9610954acdca5ff7905f051a040ce33fe613c60e',
@@ -78,6 +83,11 @@ const readAcrossMessage = (parsed, message) => {
             .filter((selector) => Boolean(selector)))].slice(0, 16);
     const balances = new Map([[parsed.bridgeOutputToken, parsed.bridgeOutputAmount]]);
     const payouts = [];
+    const directTransfers = [];
+    const approvals = new Map();
+    const lifiRouter = parsed.destinationChainId === 999n ? HYPEREVM_LIFI_ROUTER : undefined;
+    const possibleRefundTokens = new Set();
+    const refundReceivers = [];
     for (const raw of calls) {
         const call = asRecord(raw);
         const target = asString(call.target);
@@ -87,6 +97,32 @@ const readAcrossMessage = (parsed, message) => {
         // emitData is telemetry; its amounts are not an enforced receive floor.
         if (selector === '0xd836083e' && target === emitter && value === 0n)
             continue;
+        if (selector === '0x095ea7b3' && value === 0n && balances.has(target)) {
+            const approval = decodeCall([{ name: 'spender', kind: 'address' }, { name: 'amount', kind: 'uint' }], data);
+            const amount = asBigint(approval.amount);
+            const spender = asString(approval.spender);
+            if ((spender !== ALLOWANCE_HOLDER && spender !== lifiRouter) ||
+                (amount > (balances.get(target) ?? 0n) && amount !== (1n << 256n) - 1n))
+                return parsed;
+            approvals.set(`${target}:${spender}`, amount);
+            continue;
+        }
+        if ((target === ALLOWANCE_HOLDER || target === lifiRouter) && value === 0n) {
+            const swap = target === ALLOWANCE_HOLDER
+                ? readSettlerSwap(data, parsed.destinationChainId, handler, balances)
+                : readLifiSwap(data, parsed.destinationChainId, target, handler);
+            const approvalKey = `${swap?.inputToken}:${target}`;
+            if (!swap || (approvals.get(approvalKey) ?? 0n) < swap.inputAmount ||
+                (balances.get(swap.inputToken) ?? 0n) < swap.inputAmount)
+                return parsed;
+            approvals.set(approvalKey, (approvals.get(approvalKey) ?? 0n) - swap.inputAmount);
+            balances.set(swap.inputToken, (balances.get(swap.inputToken) ?? 0n) - swap.inputAmount);
+            balances.set(swap.outputToken, (balances.get(swap.outputToken) ?? 0n) + swap.minOutputAmount);
+            // GenericSwapFacet returns unused input to Handler; its later payout must agree too.
+            if (target === lifiRouter)
+                possibleRefundTokens.add(swap.inputToken);
+            continue;
+        }
         if (selector === '0xc41e8295' && target === handler) {
             if (value !== 0n)
                 return parsed;
@@ -115,6 +151,8 @@ 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 (possibleRefundTokens.delete(token))
+                refundReceivers.push(asString(drain.receiver));
             if (amount > 0n)
                 payouts.push({ outputToken: token, minOutputAmount: amount, receiver: asString(drain.receiver) });
             balances.set(token, 0n);
@@ -125,16 +163,41 @@ const readAcrossMessage = (parsed, message) => {
             return parsed;
         const token = transfer.outputToken;
         balances.set(token, subtractFees(balances.get(token) ?? 0n, transfer.minOutputAmount ?? 0n));
+        directTransfers.push(transfer);
+    }
+    const fallback = asString(args.fallbackRecipient);
+    const hasDrain = payouts.length > 0;
+    // The Handler drains the original bridge asset to fallback even after successful calls.
+    const remaining = balances.get(parsed.bridgeOutputToken) ?? 0n;
+    if (!isZeroWord(fallback) && possibleRefundTokens.delete(parsed.bridgeOutputToken)) {
+        refundReceivers.push(fallback);
     }
-    if (payouts.length === 1) {
-        const fallback = asString(args.fallbackRecipient);
-        if (!isZeroWord(fallback) && fallback !== payouts[0].receiver) {
+    if (!isZeroWord(fallback) && remaining > 0n) {
+        payouts.push({ receiver: fallback, outputToken: parsed.bridgeOutputToken, minOutputAmount: remaining });
+        balances.set(parsed.bridgeOutputToken, 0n);
+    }
+    // Existing drain routes may contain explicit fee transfers; without a drain every
+    // direct transfer must agree on the recipient, and no tracked funds may be stranded.
+    const delivered = hasDrain
+        ? [...payouts, ...directTransfers.filter((transfer) => transfer.receiver === payouts[0].receiver)]
+        : [...directTransfers, ...payouts];
+    if (delivered.length && !possibleRefundTokens.size && [...balances.values()].every((amount) => amount === 0n)) {
+        const receiver = delivered[0].receiver;
+        if (!delivered.every((payout) => payout.receiver === receiver) ||
+            !refundReceivers.every((recipient) => recipient === receiver))
+            return parsed;
+        if (!isZeroWord(fallback) && fallback !== receiver) {
             throw new BridgeError(BRIDGE_ERRORS.ACROSS_FALLBACK_RECEIVER_MISMATCH);
         }
-        if (!isZeroWord(fallback) && parsed.bridgeOutputToken !== payouts[0].outputToken) {
-            throw new BridgeError(BRIDGE_ERRORS.ACROSS_FALLBACK_TOKEN_MISMATCH);
+        parsed.receiver = receiver;
+        const token = delivered[0].outputToken;
+        if (delivered.every((payout) => payout.outputToken === token) &&
+            (isZeroWord(fallback) || token === parsed.bridgeOutputToken)) {
+            parsed.outputToken = token;
+            parsed.minOutputAmount = delivered.reduce((sum, payout) => sum + (payout.minOutputAmount ?? 0n), 0n);
         }
-        Object.assign(parsed, payouts[0]);
+        // Different success/fallback assets do not invalidate a shared receiver, but
+        // neither asset nor a single minimum can be claimed for both outcomes.
     }
     return parsed;
 };

package/dist/calldata/destinationSwap.d.ts

@@ -0,0 +1,14 @@
+export declare const ALLOWANCE_HOLDER = "0x0000000000001ff3684f28c67538d4d072c22734";
+export declare const HYPEREVM_LIFI_ROUTER = "0x0a0758d937d1059c356d4714e57f5df0239bce1a";
+export declare const readLifiSwap: (data: string, chain: bigint | undefined, target: string, recipient: string) => {
+    inputToken: string;
+    inputAmount: bigint;
+    outputToken: string;
+    minOutputAmount: bigint;
+} | undefined;
+export declare const readSettlerSwap: (data: string, chain: bigint | undefined, recipient: string, balances?: ReadonlyMap<string, bigint>) => {
+    inputToken: string;
+    inputAmount: bigint;
+    outputToken: string;
+    minOutputAmount: bigint;
+} | undefined;

package/dist/calldata/destinationSwap.js

@@ -0,0 +1,80 @@
+import { asArray, asBigint, asRecord, asString, decodeCall } from './abi.js';
+import { readSelector } from './hex.js';
+import { isNative, NATIVE_TOKEN } from './protocols.js';
+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
+const SETTLERS = {
+    8453: '0x7d6839415693801e94cdc4a7d732c9a3fdbbd1d7',
+    999: '0xf58d4122251f2ace689f257eaf2688883e30fc6e',
+};
+export const HYPEREVM_LIFI_ROUTER = '0x0a0758d937d1059c356d4714e57f5df0239bce1a';
+export const readLifiSwap = (data, chain, target, recipient) => {
+    if (chain !== 999n || target !== HYPEREVM_LIFI_ROUTER || readSelector(data) !== '0x4666fc80')
+        return undefined;
+    const method = lifiSwaps.find((item) => item.selector === '0x4666fc80');
+    const parsed = method?.decode(data, 0n);
+    if (!parsed || parsed.receiver !== recipient)
+        return undefined;
+    const { sourceToken: inputToken, sourceAmount: inputAmount, outputToken, minOutputAmount } = parsed;
+    if (!inputToken || isNative(inputToken) || !outputToken || isNative(outputToken) ||
+        inputAmount === undefined || inputAmount <= 0n || minOutputAmount === undefined || minOutputAmount <= 0n)
+        return undefined;
+    return { inputToken, inputAmount, outputToken, minOutputAmount };
+};
+export const readSettlerSwap = (data, chain, recipient, balances) => {
+    if (readSelector(data) !== '0x2213bc0b')
+        return undefined;
+    const args = decodeCall([
+        { name: 'operator', kind: 'address' }, { name: 'token', kind: 'address' },
+        { name: 'amount', kind: 'uint' }, { name: 'target', kind: 'address' }, { name: 'data', kind: 'bytes' },
+    ], data);
+    const settler = SETTLERS[chain?.toString() ?? ''];
+    if (!settler || asString(args.target) !== settler || asString(args.operator) !== settler ||
+        isNative(asString(args.token)) || asBigint(args.amount) <= 0n)
+        return undefined;
+    const inner = asString(args.data);
+    if (readSelector(inner) !== '0x1fff991f')
+        return undefined;
+    const execution = decodeCall([
+        { name: 'slippage', kind: 'tuple', components: [
+                { name: 'recipient', kind: 'address' }, { name: 'buyToken', kind: 'address' }, { name: 'minAmountOut', kind: 'uint' },
+            ] },
+        { name: 'actions', kind: 'array', item: { name: 'action', kind: 'bytes' } },
+        { name: 'zid', kind: 'bytes', size: 32 },
+    ], inner);
+    const slippage = asRecord(execution.slippage);
+    if (asString(slippage.recipient) !== recipient || asString(slippage.buyToken) === NATIVE_TOKEN ||
+        asBigint(slippage.minAmountOut) <= 0n)
+        return undefined;
+    const actions = asArray(execution.actions).map(asString);
+    // 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) ?? '')))
+        return undefined;
+    const funding = decodeCall([
+        { name: 'recipient', kind: 'address' }, { name: 'token', kind: 'address' },
+        { name: 'amount', kind: 'uint' }, { name: 'nonce', kind: 'uint' },
+        { name: 'deadline', kind: 'uint' }, { name: 'signature', kind: 'bytes' },
+    ], actions[0]);
+    if (asString(funding.recipient) !== settler || asString(funding.token) !== asString(args.token) ||
+        asBigint(funding.amount) !== asBigint(args.amount) || asString(funding.signature) !== '0x')
+        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) {
+        if (inputAmount !== maxUint256)
+            return undefined;
+        inputAmount = balances?.get(asString(args.token)) ?? 0n;
+        if (inputAmount <= 0n)
+            return undefined;
+    }
+    return {
+        inputToken: asString(args.token), inputAmount,
+        outputToken: isNative(asString(slippage.buyToken)) ? NATIVE_TOKEN : asString(slippage.buyToken),
+        minOutputAmount: asBigint(slippage.minAmountOut),
+    };
+};

package/dist/calldata/expect.d.ts

@@ -8,6 +8,8 @@ export type BridgeCallExpectation = {
     /** 目标链 id。目标币是原生币时，用它识别 `hood` 这类链 id，而不是源链 id。 */
     toChainId?: string;
     toTokenRawAmount?: string;
+    /** Selected backend quote key; only protocol identifiers with known semantics are compared. */
+    quoteKey?: string | Record<string, unknown>;
     /** 小数滑点。0.01 表示 1%。 */
     slippage?: string | number;
 };
@@ -19,7 +21,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 still reject. */
+/** Actual source payment may exceed local intent by at most 0.1%; lower payments fail comparison. */
 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

@@ -39,7 +39,23 @@ const parseAmount = (amount) => {
         return undefined;
     }
 };
-/** Actual source payment may exceed local intent by at most 0.1%; lower payments still reject. */
+const selectedQuoteIdentifier = (quoteKey) => {
+    let key = quoteKey;
+    if (typeof key === 'string') {
+        try {
+            key = JSON.parse(key);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!key || typeof key !== 'object' || Array.isArray(key) || typeof key.quote_id !== 'string')
+        return undefined;
+    // Socket/Relay cache keys preserve the provider ID before a cache UUID suffix.
+    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. */
 const minReceiveMatches = (minReceive, quoted, slippage) => {
@@ -59,6 +75,16 @@ const minReceiveMatches = (minReceive, quoted, slippage) => {
 };
 export const expectationFailures = (parsed, expectation, chainId, mask) => {
     const reasons = [];
+    const quoteIdentifier = selectedQuoteIdentifier(expectation.quoteKey);
+    if (quoteIdentifier && parsed.aggregatorId === 'socket' && parsed.quoteId !== quoteIdentifier) {
+        reasons.push(BRIDGE_ERRORS.QUOTE_ID_MISMATCH);
+    }
+    // Relay direct deposits sign an order hash, distinct from the cache key's requestId.
+    if (quoteIdentifier && parsed.aggregatorId === 'relay' &&
+        !['depositNative', 'depositErc20', 'depositErc20Allowance'].includes(parsed.method) &&
+        parsed.requestId !== quoteIdentifier) {
+        reasons.push(BRIDGE_ERRORS.REQUEST_ID_MISMATCH);
+    }
     if (expectation.toChainId && parsed.destinationChainRef && parsed.destinationChainId === undefined) {
         reasons.push(BRIDGE_ERRORS.TO_CHAIN_MISMATCH);
     }
@@ -98,16 +124,19 @@ export const expectationFailures = (parsed, expectation, chainId, mask) => {
 export const finishCheck = (aggregatorId, parsed, structural, expectation, chainId, mask) => {
     mask = {
         ...mask,
-        toToken: mask.toToken && !(parsed.outputToken === undefined && parsed.outputTokenReference),
-        toAmount: mask.toAmount && !(parsed.minOutputAmount === undefined && parsed.outputAmountReference),
+        fromToken: mask.fromToken && parsed.sourceToken !== undefined,
+        fromAmount: mask.fromAmount && parsed.sourceAmount !== undefined,
+        toToken: mask.toToken && parsed.outputToken !== undefined,
+        toAmount: mask.toAmount && parsed.minOutputAmount !== undefined,
+        receiver: mask.receiver && parsed.receiver !== undefined,
     };
     const expected = expectation
         ? expectationFailures(parsed, expectation, chainId, mask)
         : [];
+    // A locally proven receiver is still useful when destination assets/amounts
+    // cannot be reduced to one outcome. Unknown execution/receivers remain check failures.
     const unsupportedCall = (parsed.hasDestinationCall || parsed.destinationCallData !== undefined) &&
-        (parsed.receiver === undefined ||
-            (parsed.outputToken === undefined && !parsed.outputTokenReference) ||
-            (parsed.minOutputAmount === undefined && !parsed.outputAmountReference));
+        parsed.receiver === undefined;
     const errors = [
         ...(structural ? [structural] : []),
         ...(unsupportedCall ? [BRIDGE_ERRORS.UNSUPPORTED_DESTINATION_CALL] : []),

package/dist/calldata/index.js

@@ -60,16 +60,17 @@ export const decodeBridgeCalldata = (aggregatorId, tx) => {
 };
 export const validateBridgeCalldata = (aggregatorId, chainId, tx, expectation) => {
     const context = { aggregatorId, chainId, toChainId: expectation?.toChainId, ...calldataDiagnostics(tx.data || tx.input) };
+    const inputErrors = [];
     if (sourceChainMismatch(chainId, tx.chainId))
-        return { ...bridgeFailure([{ ...BRIDGE_ERRORS.FROM_CHAIN_MISMATCH, ...context }]), aggregatorId };
+        inputErrors.push(BRIDGE_ERRORS.FROM_CHAIN_MISMATCH);
     if (expectation && tx.from !== undefined &&
         (typeof tx.from !== 'string' || tx.from.toLowerCase() !== expectation.userAddress.toLowerCase())) {
-        return { ...bridgeFailure([{ ...BRIDGE_ERRORS.FROM_ADDRESS_MISMATCH, ...context }]), aggregatorId };
+        inputErrors.push(BRIDGE_ERRORS.FROM_ADDRESS_MISMATCH);
     }
     const validate = VALIDATORS[aggregatorId];
     if (!validate) {
         return {
-            ...bridgeFailure([{ ...BRIDGE_ERRORS.UNSUPPORTED_CALLDATA_AGGREGATOR, ...context }]),
+            ...bridgeFailure([...inputErrors, BRIDGE_ERRORS.UNSUPPORTED_CALLDATA_AGGREGATOR].map((error) => ({ ...error, ...context }))),
             aggregatorId,
         };
     }
@@ -78,8 +79,10 @@ export const validateBridgeCalldata = (aggregatorId, chainId, tx, expectation) =
         value = txValue(tx);
     }
     catch (error) {
-        return { ...bridgeFailure(asBridgeError(error, BRIDGE_ERRORS.INVALID_TRANSACTION_VALUE, context).errors), aggregatorId };
+        return { ...bridgeFailure([...inputErrors, ...asBridgeError(error, BRIDGE_ERRORS.INVALID_TRANSACTION_VALUE).errors]
+                .map((detail) => ({ ...detail, ...context }))), aggregatorId };
     }
     const check = validate(txCalldata(tx), value, expectation, chainId);
-    return { ...check, errors: check.errors.map((error) => sanitizeBridgeError({ ...error, ...context })) };
+    const errors = [...inputErrors, ...check.errors].map((error) => sanitizeBridgeError({ ...error, ...context }));
+    return { ...check, ...(errors.length ? bridgeFailure(errors) : {}), errors };
 };

package/dist/calldata/lifi/destination.d.ts

@@ -0,0 +1,5 @@
+import { type AbiValue } from '../abi.js';
+import type { ParsedBridgeCall } from '../types.js';
+export declare const readLifiDestination: (parsed: ParsedBridgeCall, data: {
+    [key: string]: AbiValue;
+}) => Partial<ParsedBridgeCall> | undefined;

package/dist/calldata/lifi/destination.js

@@ -0,0 +1,40 @@
+import { asArray, asBigint, asRecord, asString, decodeCall } from '../abi.js';
+import { accountFromBytes32, readSelector } from '../hex.js';
+import { ALLOWANCE_HOLDER, readSettlerSwap } from '../destinationSwap.js';
+import { isNative } from '../protocols.js';
+// Base ReceiverOIF constructor binds these two contracts. No RPC or mutable
+// caller-supplied identity is used; see evidence/base-lifi-oif-verification.json.
+const BASE_OIF = '0xe6ee2a573047598b2452a879f2188b31d0442dbf';
+const BASE_EXECUTOR = '0x4dac9d1769b9b304cb04741dcdeb2fc14abdf110';
+const BASE_OUTPUT_SETTLER = '0x75220b7600c300005038432a0000f308e0000068';
+export const readLifiDestination = (parsed, data) => {
+    const receiver = accountFromBytes32(asString(data.recipient));
+    if (parsed.destinationChainId !== 8453n ||
+        accountFromBytes32(asString(data.dstCallReceiver)) !== BASE_OIF ||
+        accountFromBytes32(asString(data.outputSettler)) !== BASE_OUTPUT_SETTLER ||
+        asString(data.depositAndRefundAddress) !== receiver)
+        return undefined;
+    const swaps = asArray(data.dstCallSwapData);
+    // No generic call is trusted merely because ReceiverOIF/Executor will forward it.
+    if (swaps.length !== 1 || !parsed.outputToken || parsed.minOutputAmount === undefined)
+        return undefined;
+    const swap = asRecord(swaps[0]);
+    const input = asString(swap.sendingAssetId), amount = asBigint(swap.fromAmount);
+    const output = asString(swap.receivingAssetId), callTo = asString(swap.callTo), approval = asString(swap.approveTo);
+    if (input !== parsed.outputToken || isNative(input) || amount <= 0n || amount > parsed.minOutputAmount)
+        return undefined;
+    const callData = asString(swap.callData);
+    if (callTo === input && approval === BASE_EXECUTOR && output === input && readSelector(callData) === '0xa9059cbb') {
+        const transfer = decodeCall([{ name: 'to', kind: 'address' }, { name: 'amount', kind: 'uint' }], callData);
+        if (asString(transfer.to) !== receiver || asBigint(transfer.amount) !== amount)
+            return undefined;
+        // Executor sends any remaining input to the same receiver after this transfer.
+        return { receiver, outputToken: input, minOutputAmount: parsed.minOutputAmount };
+    }
+    if (callTo !== ALLOWANCE_HOLDER || approval !== ALLOWANCE_HOLDER)
+        return undefined;
+    const result = readSettlerSwap(callData, parsed.destinationChainId, BASE_EXECUTOR);
+    if (!result || result.inputToken !== input || result.inputAmount !== amount || result.outputToken !== output)
+        return undefined;
+    return { receiver, outputToken: output, minOutputAmount: result.minOutputAmount };
+};

package/dist/calldata/lifi/index.js

@@ -19,6 +19,7 @@ import * as relay from './relay/index.js';
 import * as squid from './squid/index.js';
 import * as stargate from './stargate/index.js';
 import * as swap from './swap/index.js';
+import { isNative } from '../protocols.js';
 const ROUTES = [
     across,
     allbridge,
@@ -56,5 +57,6 @@ export const validateLifi = (data, value, expectation, chainId = '') => {
             parsed: hit.parsed,
         };
     }
-    return finishCheck('lifi', hit.parsed, route.check(hit.parsed), expectation, chainId, route.compare(hit.parsed));
+    return finishCheck('lifi', hit.parsed, hit.parsed.method.endsWith('ViaLayerSwap') && value !== (isNative(hit.parsed.sourceToken ?? '') ? hit.parsed.sourceAmount : 0n)
+        ? BRIDGE_ERRORS.LAYERSWAP_SOURCE_VALUE_MISMATCH : route.check(hit.parsed), expectation, chainId, route.compare(hit.parsed));
 };

package/dist/calldata/lifi/params.d.ts

@@ -1,8 +1,7 @@
 import { type AbiParam, type AbiValue } from '../abi.js';
 import type { ParsedBridgeCall } from '../types.js';
+export { applyFirstSwap, swapDataArrayParam, swapDataParam } from './swapData.js';
 export declare const bridgeDataParam: AbiParam;
-export declare const swapDataArrayParam: AbiParam;
-export declare const swapDataParam: AbiParam;
 export declare const acrossDataParam: AbiParam;
 export declare const stargateDataParam: AbiParam;
 export declare const relayDepositoryDataParam: AbiParam;
@@ -11,7 +10,6 @@ export declare const gasZipDataParam: AbiParam;
 export declare const squidDataParam: AbiParam;
 export declare const acrossPackedParam: AbiParam;
 export declare const applyBridgeData: (method: string, raw: AbiValue) => ParsedBridgeCall;
-export declare const applyFirstSwap: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
 export declare const applyAcrossData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
 export declare const applyStargateData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
 export declare const applyRelayDepositoryData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;