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

package/README.md

@@ -5,8 +5,138 @@ Minimal bridge SDK for Rabby:
 - enumerates supported bridge aggregators and chains
 - maintains per-chain spender/router allowlists
 - validates backend bridge quotes before returning them
-- does not implement calldata decoding
+- 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
+
+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.
 
 ## Test
 
 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
+
+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.
+
+```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,
+  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.
+
+`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.
+
+## Error reporting
+
+All stable error codes, stages and messages are defined in
+[`BRIDGE_ERRORS`](src/errors/constants.ts). Codes are explicit constants; callers
+must not classify errors by matching message text. Existing error classes and
+legacy `reason` fields remain available.
+
+- `decodeBridgeCalldataResult(aggregatorId, tx)` returns a detailed success/failure
+  result. The existing `decodeBridgeCalldata` still returns `null` on failure.
+- `validateBridgeCalldata` returns `errors`, plus `error_code` and `stage` on failure.
+  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`.
+  Directly thrown errors are handled by the caller, avoiding duplicate reporting.
+  Reporting callback failures do not affect validation or quote filtering.
+
+```ts
+import { BridgeError, getQuoteListWithTx } from '@rabby-wallet/rabby-bridge';
+
+try {
+  const quotes = await getQuoteListWithTx(aggregatorId, {
+    ...params,
+    onError: (report) => reportToBusiness(report),
+  }, api);
+} catch (error) {
+  if (error instanceof BridgeError) reportToBusiness(error.toJSON());
+  throw error;
+}
+```
+
+A report contains a primary `error_code` / `stage` and an `errors` list. The primary
+code is the first failure; inspect the list for every collected failure. Each detail
+contains its fixed message and available context: aggregator, chain, bridge,
+provider, operation, method, selector, nested protocol selector, missing fields or
+HTTP status. SDK reports omit wallet addresses, amounts, raw calldata, response
+bodies and arbitrary transport exception messages. Existing Error messages are
+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.
+
+### 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
+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 report = toBridgeErrorReport(check);
+if (report) reportToBusiness(report);
+```
+
+Reports can retain recognized aggregator/bridge/method labels, source/destination
+chains, outer/router/protocol selectors, call-data format and byte lengths, ABI
+failure offsets, bounded destination-call selectors/counts, unsupported command
+bytes/counts, static request categories and HTTP status. Nested diagnostics are
+collected where the parser knows the call layout; arbitrary payload bytes are not
+scanned for possible selectors. Destination selector lists are deduplicated and
+limited to 16 entries.
+
+Unknown labels become `unknown` or are omitted. Messages and stages are restored
+from the error-code catalogue, even if an error was modified after construction.
+Arbitrary properties are dropped, including wallet/receiver/refund addresses,
+token addresses, amounts, balances, approvals, transaction/order/quote/request IDs,
+signatures, full calldata, URL/query/header/body contents, raw exception messages
+and stack traces. Contract addresses and hashes are not reported either.
+
+These reports identify unsupported function families and failure stages. They
+intentionally cannot reconstruct or identify the original user's transaction.

package/dist/calldata/abi.d.ts

@@ -0,0 +1,29 @@
+import type { ParsedBridgeCall } from './types.js';
+export type AbiParam = {
+    name: string;
+    kind: 'address' | 'uint' | 'bool' | 'bytes' | 'string' | 'array' | 'tuple';
+    size?: number;
+    length?: number;
+    item?: AbiParam;
+    components?: AbiParam[];
+};
+export type AbiValue = string | bigint | boolean | AbiValue[] | {
+    [key: string]: AbiValue;
+};
+export declare const decodeCall: (params: AbiParam[], calldata: string) => {
+    [key: string]: AbiValue;
+};
+export declare const decodeParameters: (params: AbiParam[], data: string) => {
+    [key: string]: AbiValue;
+};
+export declare const asRecord: (value: AbiValue) => {
+    [key: string]: AbiValue;
+};
+export declare const asArray: (value: AbiValue) => AbiValue[];
+export declare const asBigint: (value: AbiValue) => bigint;
+export declare const asString: (value: AbiValue) => string;
+export type CalldataMethod = {
+    name: string;
+    selector: string;
+    decode: (data: string, value: bigint) => ParsedBridgeCall;
+};

package/dist/calldata/abi.js

@@ -0,0 +1,160 @@
+import { BRIDGE_ERRORS, BridgeError } from '../errors/index.js';
+import { toUtf8String, Utf8ErrorFuncs } from '@ethersproject/strings';
+import { bytesToHex, hexToBytes } from './hex.js';
+const isDynamic = (param) => {
+    if (param.kind === 'string') {
+        return true;
+    }
+    if (param.kind === 'bytes') {
+        return param.size === undefined;
+    }
+    if (param.kind === 'array') {
+        return param.length === undefined || isDynamic(param.item);
+    }
+    if (param.kind === 'tuple') {
+        return (param.components ?? []).some(isDynamic);
+    }
+    return false;
+};
+const staticWordCount = (param) => {
+    if (isDynamic(param)) {
+        return 1;
+    }
+    if (param.kind === 'tuple') {
+        return (param.components ?? []).reduce((sum, item) => sum + staticWordCount(item), 0);
+    }
+    if (param.kind === 'array') {
+        return (param.length ?? 0) * staticWordCount(param.item);
+    }
+    return 1;
+};
+const readWord = (buf, offset) => {
+    if (offset < 0 || offset + 32 > buf.length) {
+        throw new BridgeError(BRIDGE_ERRORS.ABI_WORD_OUT_OF_BOUNDS, { abiOffset: offset, abiBufferBytes: buf.length });
+    }
+    let value = 0n;
+    for (let index = 0; index < 32; index += 1) {
+        value = (value << 8n) + BigInt(buf[offset + index]);
+    }
+    return value;
+};
+const toAddress = (word) => {
+    if (word >= (1n << 160n))
+        throw new BridgeError(BRIDGE_ERRORS.INVALID_ABI_ADDRESS);
+    return `0x${word.toString(16).padStart(40, '0')}`;
+};
+const readByteLength = (buf, offset) => {
+    const length = readWord(buf, offset);
+    if (length > BigInt(buf.length)) {
+        throw new BridgeError(BRIDGE_ERRORS.ABI_BYTES_OUT_OF_BOUNDS, { abiOffset: offset, abiBufferBytes: buf.length });
+    }
+    return Number(length);
+};
+const readDynamicBytes = (buf, offset) => {
+    const length = readByteLength(buf, offset);
+    const start = offset + 32;
+    if (start + length > buf.length) {
+        throw new BridgeError(BRIDGE_ERRORS.ABI_BYTES_OUT_OF_BOUNDS, { abiOffset: offset, abiBufferBytes: buf.length });
+    }
+    return bytesToHex(buf.subarray(start, start + length));
+};
+const decodeSequence = (params, buf, base) => {
+    let cursor = base;
+    const locations = [];
+    for (const param of params) {
+        if (isDynamic(param)) {
+            const relative = readWord(buf, cursor);
+            if (relative > BigInt(buf.length)) {
+                throw new BridgeError(BRIDGE_ERRORS.ABI_OFFSET_OUT_OF_BOUNDS, { abiOffset: cursor, abiBufferBytes: buf.length });
+            }
+            locations.push(base + Number(relative));
+            cursor += 32;
+        }
+        else {
+            locations.push(cursor);
+            cursor += staticWordCount(param) * 32;
+        }
+    }
+    return params.map((param, index) => decodeAt(param, buf, locations[index]));
+};
+const decodeAt = (param, buf, offset) => {
+    switch (param.kind) {
+        case 'address':
+            return toAddress(readWord(buf, offset));
+        case 'uint':
+            return readWord(buf, offset);
+        case 'bool': {
+            const word = readWord(buf, offset);
+            if (word !== 0n && word !== 1n) {
+                throw new BridgeError(BRIDGE_ERRORS.INVALID_BOOL);
+            }
+            return word === 1n;
+        }
+        case 'bytes': {
+            if (param.size === undefined) {
+                return readDynamicBytes(buf, offset);
+            }
+            if (offset + 32 > buf.length) {
+                throw new BridgeError(BRIDGE_ERRORS.ABI_WORD_OUT_OF_BOUNDS, { abiOffset: offset, abiBufferBytes: buf.length });
+            }
+            return bytesToHex(buf.subarray(offset, offset + param.size));
+        }
+        case 'string':
+            return toUtf8String(readDynamicBytes(buf, offset), Utf8ErrorFuncs.replace).replace(/^\uFEFF/, '');
+        case 'tuple':
+            return decodeTuple(param.components ?? [], buf, offset);
+        case 'array': {
+            const item = param.item;
+            if (param.length === undefined) {
+                const length = readByteLength(buf, offset);
+                if (length > 2048) {
+                    throw new BridgeError(BRIDGE_ERRORS.ABI_ARRAY_TOO_LONG);
+                }
+                return decodeSequence(Array.from({ length }, () => item), buf, offset + 32);
+            }
+            return decodeSequence(Array.from({ length: param.length }, () => item), buf, offset);
+        }
+        default:
+            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_ABI_TYPE);
+    }
+};
+const decodeTuple = (components, buf, offset) => {
+    const values = decodeSequence(components, buf, offset);
+    return Object.fromEntries(components.map((component, index) => [component.name, values[index]]));
+};
+export const decodeCall = (params, calldata) => {
+    const bytes = hexToBytes(calldata);
+    if (bytes.length < 4) {
+        throw new BridgeError(BRIDGE_ERRORS.MISSING_SELECTOR);
+    }
+    const values = decodeSequence(params, bytes.subarray(4), 0);
+    return Object.fromEntries(params.map((param, index) => [param.name, values[index]]));
+};
+export const decodeParameters = (params, data) => {
+    const values = decodeSequence(params, hexToBytes(data), 0);
+    return Object.fromEntries(params.map((param, index) => [param.name, values[index]]));
+};
+export const asRecord = (value) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new BridgeError(BRIDGE_ERRORS.EXPECTED_TUPLE);
+    }
+    return value;
+};
+export const asArray = (value) => {
+    if (!Array.isArray(value)) {
+        throw new BridgeError(BRIDGE_ERRORS.EXPECTED_ARRAY);
+    }
+    return value;
+};
+export const asBigint = (value) => {
+    if (typeof value !== 'bigint') {
+        throw new BridgeError(BRIDGE_ERRORS.EXPECTED_UINT);
+    }
+    return value;
+};
+export const asString = (value) => {
+    if (typeof value !== 'string') {
+        throw new BridgeError(BRIDGE_ERRORS.EXPECTED_STRING);
+    }
+    return value;
+};

package/dist/calldata/across/deposit.d.ts

@@ -0,0 +1,2 @@
+import type { CalldataMethod } from '../abi.js';
+export declare const deposit: CalldataMethod;

package/dist/calldata/across/deposit.js

@@ -0,0 +1,36 @@
+import { applyAcrossMessage } from '../destination.js';
+import { asBigint, asString, decodeCall } from '../abi.js';
+import { accountFromBytes32 } from '../hex.js';
+const fields = [
+    { name: 'depositor', kind: 'bytes', size: 32 },
+    { name: 'recipient', kind: 'bytes', size: 32 },
+    { name: 'inputToken', kind: 'bytes', size: 32 },
+    { name: 'outputToken', kind: 'bytes', size: 32 },
+    { name: 'inputAmount', kind: 'uint' },
+    { name: 'outputAmount', kind: 'uint' },
+    { name: 'destinationChainId', kind: 'uint' },
+    { name: 'exclusiveRelayer', kind: 'bytes', size: 32 },
+    { name: 'quoteTimestamp', kind: 'uint' },
+    { name: 'fillDeadline', kind: 'uint' },
+    { name: 'exclusivityParameter', kind: 'uint' },
+    { name: 'message', kind: 'bytes' },
+];
+export const deposit = {
+    name: 'deposit',
+    selector: '0xad5425c6',
+    decode(data) {
+        const args = decodeCall(fields, data);
+        return applyAcrossMessage({
+            aggregatorId: 'across',
+            method: 'deposit',
+            kind: 'bridge',
+            depositor: accountFromBytes32(asString(args.depositor)),
+            sourceToken: accountFromBytes32(asString(args.inputToken)),
+            sourceAmount: asBigint(args.inputAmount),
+            destinationChainId: asBigint(args.destinationChainId),
+            receiver: accountFromBytes32(asString(args.recipient)),
+            outputToken: accountFromBytes32(asString(args.outputToken)),
+            minOutputAmount: asBigint(args.outputAmount),
+        }, asString(args.message));
+    },
+};

package/dist/calldata/across/depositNative.d.ts

@@ -0,0 +1,2 @@
+import type { CalldataMethod } from '../abi.js';
+export declare const depositNative: CalldataMethod;

package/dist/calldata/across/depositNative.js

@@ -0,0 +1,45 @@
+import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
+import { applyAcrossMessage } from '../destination.js';
+import { asBigint, asString, decodeCall } from '../abi.js';
+import { accountFromBytes32 } from '../hex.js';
+import { NATIVE_TOKEN } from '../protocols.js';
+const fields = [
+    { name: 'spokePool', kind: 'address' },
+    { name: 'depositor', kind: 'address' },
+    { name: 'recipient', kind: 'bytes', size: 32 },
+    { name: 'inputToken', kind: 'address' },
+    { name: 'inputAmount', kind: 'uint' },
+    { name: 'outputToken', kind: 'bytes', size: 32 },
+    { name: 'outputAmount', kind: 'uint' },
+    { name: 'destinationChainId', kind: 'uint' },
+    { name: 'exclusiveRelayer', kind: 'bytes', size: 32 },
+    { name: 'quoteTimestamp', kind: 'uint' },
+    { name: 'fillDeadline', kind: 'uint' },
+    { name: 'exclusivityParameter', kind: 'uint' },
+    { name: 'message', kind: 'bytes' },
+];
+export const depositNative = {
+    name: 'depositNative',
+    selector: '0x609ea081',
+    decode(data, value) {
+        const args = decodeCall(fields, data);
+        const inputAmount = asBigint(args.inputAmount);
+        if (inputAmount > 0n && value !== inputAmount)
+            throw new BridgeError(BRIDGE_ERRORS.ACROSS_NATIVE_VALUE_MISMATCH);
+        return applyAcrossMessage({
+            aggregatorId: 'across',
+            method: 'depositNative',
+            kind: 'bridge',
+            depositor: asString(args.depositor),
+            sourceToken: NATIVE_TOKEN,
+            sourceAmount: inputAmount > 0n ? inputAmount : value,
+            bridgeToken: asString(args.inputToken),
+            bridgeAmount: inputAmount > 0n ? inputAmount : value,
+            destinationChainId: asBigint(args.destinationChainId),
+            receiver: accountFromBytes32(asString(args.recipient)),
+            outputToken: accountFromBytes32(asString(args.outputToken)),
+            minOutputAmount: asBigint(args.outputAmount),
+            spokePool: asString(args.spokePool),
+        }, asString(args.message));
+    },
+};

package/dist/calldata/across/depositNow.d.ts

@@ -0,0 +1,2 @@
+import type { CalldataMethod } from '../abi.js';
+export declare const depositNow: CalldataMethod;

package/dist/calldata/across/depositNow.js

@@ -0,0 +1,35 @@
+import { applyAcrossMessage } from '../destination.js';
+import { asBigint, asString, decodeCall } from '../abi.js';
+import { accountFromBytes32 } from '../hex.js';
+const fields = [
+    { name: 'depositor', kind: 'bytes', size: 32 },
+    { name: 'recipient', kind: 'bytes', size: 32 },
+    { name: 'inputToken', kind: 'bytes', size: 32 },
+    { name: 'outputToken', kind: 'bytes', size: 32 },
+    { name: 'inputAmount', kind: 'uint' },
+    { name: 'outputAmount', kind: 'uint' },
+    { name: 'destinationChainId', kind: 'uint' },
+    { name: 'exclusiveRelayer', kind: 'bytes', size: 32 },
+    { name: 'fillDeadlineOffset', kind: 'uint' },
+    { name: 'exclusivityParameter', kind: 'uint' },
+    { name: 'message', kind: 'bytes' },
+];
+export const depositNow = {
+    name: 'depositNow',
+    selector: '0xea86bd46',
+    decode(data) {
+        const args = decodeCall(fields, data);
+        return applyAcrossMessage({
+            aggregatorId: 'across',
+            method: 'depositNow',
+            kind: 'bridge',
+            depositor: accountFromBytes32(asString(args.depositor)),
+            sourceToken: accountFromBytes32(asString(args.inputToken)),
+            sourceAmount: asBigint(args.inputAmount),
+            destinationChainId: asBigint(args.destinationChainId),
+            receiver: accountFromBytes32(asString(args.recipient)),
+            outputToken: accountFromBytes32(asString(args.outputToken)),
+            minOutputAmount: asBigint(args.outputAmount),
+        }, asString(args.message));
+    },
+};

package/dist/calldata/across/depositV3.d.ts

@@ -0,0 +1,2 @@
+import type { CalldataMethod } from '../abi.js';
+export declare const depositV3: CalldataMethod;

package/dist/calldata/across/depositV3.js

@@ -0,0 +1,35 @@
+import { applyAcrossMessage } from '../destination.js';
+import { asBigint, asString, decodeCall } from '../abi.js';
+const fields = [
+    { name: 'depositor', kind: 'address' },
+    { name: 'recipient', kind: 'address' },
+    { name: 'inputToken', kind: 'address' },
+    { name: 'outputToken', kind: 'address' },
+    { name: 'inputAmount', kind: 'uint' },
+    { name: 'outputAmount', kind: 'uint' },
+    { name: 'destinationChainId', kind: 'uint' },
+    { name: 'exclusiveRelayer', kind: 'address' },
+    { name: 'quoteTimestamp', kind: 'uint' },
+    { name: 'fillDeadline', kind: 'uint' },
+    { name: 'exclusivityParameter', kind: 'uint' },
+    { name: 'message', kind: 'bytes' },
+];
+export const depositV3 = {
+    name: 'depositV3',
+    selector: '0x7b939232',
+    decode(data) {
+        const args = decodeCall(fields, data);
+        return applyAcrossMessage({
+            aggregatorId: 'across',
+            method: 'depositV3',
+            kind: 'bridge',
+            depositor: asString(args.depositor),
+            sourceToken: asString(args.inputToken),
+            sourceAmount: asBigint(args.inputAmount),
+            destinationChainId: asBigint(args.destinationChainId),
+            receiver: asString(args.recipient),
+            outputToken: asString(args.outputToken),
+            minOutputAmount: asBigint(args.outputAmount),
+        }, asString(args.message));
+    },
+};

package/dist/calldata/across/depositV3Now.d.ts

@@ -0,0 +1,2 @@
+import type { CalldataMethod } from '../abi.js';
+export declare const depositV3Now: CalldataMethod;

package/dist/calldata/across/depositV3Now.js

@@ -0,0 +1,34 @@
+import { applyAcrossMessage } from '../destination.js';
+import { asBigint, asString, decodeCall } from '../abi.js';
+const fields = [
+    { name: 'depositor', kind: 'address' },
+    { name: 'recipient', kind: 'address' },
+    { name: 'inputToken', kind: 'address' },
+    { name: 'outputToken', kind: 'address' },
+    { name: 'inputAmount', kind: 'uint' },
+    { name: 'outputAmount', kind: 'uint' },
+    { name: 'destinationChainId', kind: 'uint' },
+    { name: 'exclusiveRelayer', kind: 'address' },
+    { name: 'fillDeadlineOffset', kind: 'uint' },
+    { name: 'exclusivityParameter', kind: 'uint' },
+    { name: 'message', kind: 'bytes' },
+];
+export const depositV3Now = {
+    name: 'depositV3Now',
+    selector: '0x7aef642c',
+    decode(data) {
+        const args = decodeCall(fields, data);
+        return applyAcrossMessage({
+            aggregatorId: 'across',
+            method: 'depositV3Now',
+            kind: 'bridge',
+            depositor: asString(args.depositor),
+            sourceToken: asString(args.inputToken),
+            sourceAmount: asBigint(args.inputAmount),
+            destinationChainId: asBigint(args.destinationChainId),
+            receiver: asString(args.recipient),
+            outputToken: asString(args.outputToken),
+            minOutputAmount: asBigint(args.outputAmount),
+        }, asString(args.message));
+    },
+};

package/dist/calldata/across/index.d.ts

@@ -0,0 +1,4 @@
+import type { BridgeCallExpectation } from '../expect.js';
+import type { BridgeCheck, DecodeHit } from '../types.js';
+export declare const decodeAcross: (data: string, value: bigint) => DecodeHit;
+export declare const validateAcross: (data: string, value: bigint, expectation?: BridgeCallExpectation, chainId?: string) => BridgeCheck;

package/dist/calldata/across/index.js

@@ -0,0 +1,31 @@
+import { matchMethod } from '../match.js';
+import { finishCheck } from '../expect.js';
+import { deposit } from './deposit.js';
+import { depositNative } from './depositNative.js';
+import { depositNow } from './depositNow.js';
+import { depositV3 } from './depositV3.js';
+import { depositV3Now } from './depositV3Now.js';
+import { swapAndBridge } from './swapAndBridge.js';
+import { acrossFailure } from './validate.js';
+const METHODS = [
+    depositV3,
+    deposit,
+    depositV3Now,
+    depositNow,
+    depositNative,
+    swapAndBridge,
+];
+export const decodeAcross = (data, value) => matchMethod(METHODS, data, value);
+export const validateAcross = (data, value, expectation, chainId = '') => {
+    const hit = decodeAcross(data, value);
+    if (!hit.ok) {
+        return { ...hit, aggregatorId: 'across' };
+    }
+    return finishCheck('across', hit.parsed, acrossFailure(hit.parsed, chainId, expectation?.userAddress), expectation, chainId, {
+        fromToken: true,
+        fromAmount: true,
+        toToken: true,
+        toAmount: true,
+        receiver: true,
+    });
+};

package/dist/calldata/across/swapAndBridge.d.ts

@@ -0,0 +1,2 @@
+import type { CalldataMethod } from '../abi.js';
+export declare const swapAndBridge: CalldataMethod;

package/dist/calldata/across/swapAndBridge.js

@@ -0,0 +1,70 @@
+import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
+import { applyAcrossMessage } from '../destination.js';
+import { asBigint, asRecord, asString, decodeCall } from '../abi.js';
+import { accountFromBytes32 } from '../hex.js';
+import { NATIVE_TOKEN } from '../protocols.js';
+const swapAndDepositData = {
+    name: 'swapAndDepositData',
+    kind: 'tuple',
+    components: [
+        {
+            name: 'submissionFees',
+            kind: 'tuple',
+            components: [
+                { name: 'amount', kind: 'uint' },
+                { name: 'recipient', kind: 'address' },
+            ],
+        },
+        {
+            name: 'depositData',
+            kind: 'tuple',
+            components: [
+                { name: 'inputToken', kind: 'address' },
+                { name: 'outputToken', kind: 'bytes', size: 32 },
+                { name: 'outputAmount', kind: 'uint' },
+                { name: 'depositor', kind: 'address' },
+                { name: 'recipient', kind: 'bytes', size: 32 },
+                { name: 'destinationChainId', kind: 'uint' },
+                { name: 'exclusiveRelayer', kind: 'bytes', size: 32 },
+                { name: 'quoteTimestamp', kind: 'uint' },
+                { name: 'fillDeadline', kind: 'uint' },
+                { name: 'exclusivityParameter', kind: 'uint' },
+                { name: 'message', kind: 'bytes' },
+            ],
+        },
+        { name: 'swapToken', kind: 'address' },
+        { name: 'exchange', kind: 'address' },
+        { name: 'transferType', kind: 'uint' },
+        { name: 'swapTokenAmount', kind: 'uint' },
+        { name: 'minExpectedInputTokenAmount', kind: 'uint' },
+        { name: 'routerCalldata', kind: 'bytes' },
+        { name: 'enableProportionalAdjustment', kind: 'bool' },
+        { name: 'spokePool', kind: 'address' },
+        { name: 'nonce', kind: 'uint' },
+    ],
+};
+export const swapAndBridge = {
+    name: 'swapAndBridge',
+    selector: '0x110560ad',
+    decode(data, value) {
+        const args = asRecord(decodeCall([swapAndDepositData], data).swapAndDepositData);
+        const depositData = asRecord(args.depositData);
+        const sourceAmount = asBigint(args.swapTokenAmount);
+        if (value > 0n && value !== sourceAmount)
+            throw new BridgeError(BRIDGE_ERRORS.ACROSS_SWAP_VALUE_MISMATCH);
+        return applyAcrossMessage({
+            aggregatorId: 'across',
+            method: 'swapAndBridge',
+            kind: 'bridge',
+            depositor: asString(depositData.depositor),
+            sourceToken: value > 0n ? NATIVE_TOKEN : asString(args.swapToken),
+            sourceAmount,
+            destinationChainId: asBigint(depositData.destinationChainId),
+            receiver: accountFromBytes32(asString(depositData.recipient)),
+            outputToken: accountFromBytes32(asString(depositData.outputToken)),
+            minOutputAmount: asBigint(depositData.outputAmount),
+            spokePool: asString(args.spokePool),
+            innerTarget: asString(args.exchange),
+        }, asString(depositData.message));
+    },
+};

package/dist/calldata/across/validate.d.ts

@@ -0,0 +1,3 @@
+import type { BridgeErrorDefinition } from '../../errors/index.js';
+import type { ParsedBridgeCall } from '../types.js';
+export declare const acrossFailure: (parsed: ParsedBridgeCall, chainId: string, expectedDepositor?: string) => BridgeErrorDefinition | undefined;