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

package/README.md

@@ -5,8 +5,170 @@ 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
+- 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 [offline provider evidence](src/providers/README.md) for retained historical fixtures and verification limits.
 
 ## 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.
+
+## Validation rollout
+
+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, {
+  ...params,
+  onError: (report) => reportToBusiness(report),
+}, api);
+```
+
+- Quotes and transactions come from the existing backend flow, including Relay
+  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
+  keep their original blocking behavior.
+- 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 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,
+  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
+  `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.
+- 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.
+
+`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);
+// Throws on required-check failures; otherwise result.pass is true.
+// 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.
+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. 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.
+
+## 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`,
+  plus local validation failures and unexpected missing fields from transaction checks.
+  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
+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` without producing
+reports merely because a known local limitation prevents verification.
+
+### Privacy-safe diagnostics
+
+Use `toBridgeErrorReport(resultOrError)` to convert a calldata check,
+transaction validation result, detailed decode result or exception into a report.
+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
+try {
+  validateBridgeTx(aggregatorId, chainId, bridgeId, tx, expectation);
+} catch (error) {
+  reportToBusiness(toBridgeErrorReport(error));
+  throw error;
+}
+```
+
+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;