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

package/dist/calldata/across/validate.js

@@ -0,0 +1,30 @@
+import { BRIDGE_ERRORS } from '../../errors/index.js';
+import { getBridgeRouter } from '../../list.js';
+import { evmChainId } from '../chains.js';
+import { isZeroWord } from '../hex.js';
+export const acrossFailure = (parsed, chainId, expectedDepositor) => {
+    if (expectedDepositor && parsed.depositor?.toLowerCase() !== expectedDepositor.toLowerCase()) {
+        return BRIDGE_ERRORS.DEPOSITOR_MISMATCH;
+    }
+    if (parsed.destinationChainId === undefined || parsed.destinationChainId <= 0n) {
+        return BRIDGE_ERRORS.MISSING_DESTINATION_CHAIN;
+    }
+    if (isZeroWord(parsed.receiver ?? parsed.bridgeReceiver)) {
+        return BRIDGE_ERRORS.MISSING_RECEIVER;
+    }
+    if ((parsed.sourceAmount ?? 0n) <= 0n) {
+        return BRIDGE_ERRORS.MISSING_SOURCE_AMOUNT;
+    }
+    if (!parsed.spokePool) {
+        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();
+    if (expectedSpoke !== spoke) {
+        return BRIDGE_ERRORS.SPOKE_POOL_IS_NOT_IN_THE_ALLOWLIST;
+    }
+    return undefined;
+};

package/dist/calldata/chains.d.ts

@@ -0,0 +1,2 @@
+export declare const evmChainId: (chain: string) => bigint | undefined;
+export declare const sourceChainMismatch: (expected: string, actual?: string | number | bigint) => boolean;

package/dist/calldata/chains.js

@@ -0,0 +1,35 @@
+import { CHAIN_ENUM_TO_SERVER_ID, normalizeChainEnum } from '../chains.js';
+const CHAIN_IDS = {
+    eth: 1n, op: 10n, flr: 14n, cro: 25n, rsk: 30n, xdc: 50n, bsc: 56n,
+    xdai: 100n, fuse: 122n, uni: 130n, matic: 137n, monad: 143n, sonic: 146n,
+    manta: 169n, xlayer: 196n, opbnb: 204n, lens: 232n, frax: 252n, era: 324n,
+    stable: 988n, hyper: 999n, metis: 1088n, lisk: 1135n, sei: 1329n, story: 1514n,
+    gravity: 1625n, soneium: 1868n, swell: 1923n, ron: 2020n, abs: 2741n,
+    morph: 2818n, tempo: 4217n, megaeth: 4326n, hood: 4663n, world: 480n,
+    mnt: 5000n, arc: 5042n, cyber: 7560n, klay: 8217n, base: 8453n, plasma: 9745n,
+    ape: 33139n, mode: 34443n, arb: 42161n, celo: 42220n, hemi: 43111n, avax: 43114n,
+    zircuit: 48900n, sophon: 50104n, ink: 57073n, linea: 59144n, bob: 60808n,
+    bera: 80094n, blast: 81457n, plume: 98866n, taiko: 167000n, scrl: 534352n,
+    katana: 747474n, zora: 7777777n,
+    ethereum: 1n, optimism: 10n, gnosis: 100n, polygon: 137n, mantle: 5000n,
+    arbitrum: 42161n, avalanche: 43114n, fraxtal: 252n,
+};
+export const evmChainId = (chain) => {
+    if (/^\d+$/.test(chain)) {
+        const id = BigInt(chain);
+        return id > 0n ? id : undefined;
+    }
+    const chainEnum = normalizeChainEnum(chain);
+    return CHAIN_IDS[chainEnum ? CHAIN_ENUM_TO_SERVER_ID[chainEnum] : chain.toLowerCase()];
+};
+export const sourceChainMismatch = (expected, actual) => {
+    if (actual === undefined)
+        return false;
+    try {
+        return (typeof actual === 'number' && !Number.isSafeInteger(actual)) ||
+            evmChainId(expected) === undefined || BigInt(actual) !== evmChainId(expected);
+    }
+    catch {
+        return true;
+    }
+};

package/dist/calldata/destination.d.ts

@@ -0,0 +1,6 @@
+import { type AbiParam, type AbiValue } from './abi.js';
+import type { ParsedBridgeCall } from './types.js';
+export declare const destinationCall: AbiParam;
+export declare const readTransfer: (target: string, data: string, value: bigint) => Partial<ParsedBridgeCall> | undefined;
+export declare const readDestinationTransfers: (calls: AbiValue[]) => Partial<ParsedBridgeCall>;
+export declare const applyAcrossMessage: (parsed: ParsedBridgeCall, message: string) => ParsedBridgeCall;

package/dist/calldata/destination.js

@@ -0,0 +1,148 @@
+import { BRIDGE_ERRORS, BridgeError, asBridgeError } from '../errors/index.js';
+import { asArray, asBigint, asRecord, asString, decodeCall, decodeParameters } from './abi.js';
+import { isZeroWord, readSelector } from './hex.js';
+import { NATIVE_TOKEN, WRAPPED_NATIVE_TOKENS, subtractFees } from './protocols.js';
+import { calldataDiagnostics } from './diagnostics.js';
+export const destinationCall = {
+    name: 'call', kind: 'tuple', components: [
+        { name: 'target', kind: 'address' }, { name: 'data', kind: 'bytes' }, { name: 'value', kind: 'uint' },
+    ],
+};
+export const readTransfer = (target, data, value) => {
+    if (data === '0x' && value > 0n)
+        return { receiver: target, outputToken: NATIVE_TOKEN, minOutputAmount: value };
+    if (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) };
+};
+export const readDestinationTransfers = (calls) => {
+    const diagnostics = { destinationCallCount: calls.length,
+        destinationSelectors: [...new Set(calls.map((call) => calldataDiagnostics(asRecord(call).data).selector)
+                .filter((selector) => Boolean(selector)))].slice(0, 16) };
+    const transfers = calls.map((call) => {
+        const c = asRecord(call);
+        return readTransfer(asString(c.target), asString(c.data), asBigint(c.value));
+    });
+    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))
+        return { diagnostics };
+    return { ...first, diagnostics, minOutputAmount: transfers.reduce((sum, transfer) => sum + (transfer?.minOutputAmount ?? 0n), 0n) };
+};
+const instructions = {
+    name: 'instructions', kind: 'tuple', components: [
+        { name: 'calls', kind: 'array', item: { name: 'call', kind: 'tuple', components: [
+                    { name: 'target', kind: 'address' }, { name: 'callData', kind: 'bytes' }, { name: 'value', kind: 'uint' },
+                ] } },
+        { name: 'fallbackRecipient', kind: 'address' },
+    ],
+};
+const ACROSS_MESSAGE_HANDLERS = {
+    999: '0x5e7840e06faccb6d1c3b5f5e0d1d3d07f2829bba',
+    4663: '0xa8ad2e87e2043711d8bec77e8bc3e2683c0ab6bd',
+    43114: '0x9610954acdca5ff7905f051a040ce33fe613c60e',
+};
+const readAcrossMessage = (parsed, message) => {
+    if (message === '0x') {
+        const wrapped = WRAPPED_NATIVE_TOKENS[parsed.destinationChainId?.toString() ?? ''];
+        if (parsed.outputToken !== undefined && (wrapped === undefined || parsed.outputToken === wrapped)) {
+            parsed.bridgeOutputToken = parsed.outputToken;
+            parsed.outputTokenReference = { protocol: 'across-native', token: parsed.outputToken,
+                destinationChainId: parsed.destinationChainId, destinationContract: parsed.receiver };
+            delete parsed.outputToken;
+        }
+        return parsed;
+    }
+    const handler = parsed.receiver;
+    parsed.bridgeReceiver = handler;
+    parsed.bridgeOutputToken = parsed.outputToken;
+    parsed.bridgeOutputAmount = parsed.minOutputAmount;
+    parsed.destinationCallData = message;
+    parsed.diagnostics = { hasDestinationCall: true, destinationCalldataBytes: calldataDiagnostics(message).calldataBytes };
+    delete parsed.receiver;
+    delete parsed.outputToken;
+    delete parsed.minOutputAmount;
+    // Other message handlers can implement arbitrary destination logic.
+    const expectedHandler = ACROSS_MESSAGE_HANDLERS[parsed.destinationChainId?.toString() ?? ''] ??
+        '0x0f7ae28de1c8532170ad4ee566b5801485c13a0e';
+    if (handler !== expectedHandler)
+        return parsed;
+    const emitter = parsed.destinationChainId === 43114n
+        ? '0x25b15fc38d6a2c13feddd9cb51f184f7cf0d4c11' : '0xbf75133b48b0a42ab9374027902e83c5e2949034';
+    const args = asRecord(decodeParameters([instructions], message).instructions);
+    const calls = asArray(args.calls);
+    parsed.diagnostics.destinationCallCount = calls.length;
+    parsed.diagnostics.destinationSelectors = [...new Set(calls.map((call) => calldataDiagnostics(asRecord(call).callData).selector)
+            .filter((selector) => Boolean(selector)))].slice(0, 16);
+    const balances = new Map([[parsed.bridgeOutputToken, parsed.bridgeOutputAmount]]);
+    const payouts = [];
+    for (const raw of calls) {
+        const call = asRecord(raw);
+        const target = asString(call.target);
+        const data = asString(call.callData);
+        const value = asBigint(call.value);
+        const selector = readSelector(data);
+        // emitData is telemetry; its amounts are not an enforced receive floor.
+        if (selector === '0xd836083e' && target === emitter && value === 0n)
+            continue;
+        if (selector === '0xc41e8295' && target === handler) {
+            if (value !== 0n)
+                return parsed;
+            const nested = decodeCall([
+                { name: 'target', kind: 'address' }, { name: 'data', kind: 'bytes' }, { name: 'value', kind: 'uint' },
+                { name: 'replacements', kind: 'array', item: { name: 'replacement', kind: 'tuple', components: [
+                            { name: 'token', kind: 'address' }, { name: 'offset', kind: 'uint' },
+                        ] } },
+            ], data);
+            const token = asString(nested.target);
+            const replacements = asArray(nested.replacements).map(asRecord);
+            const withdrawal = asString(nested.data);
+            if (readSelector(withdrawal) !== '0x2e1a7d4d' || replacements.length !== 1 ||
+                asBigint(decodeCall([{ name: 'amount', kind: 'uint' }], withdrawal).amount) !== 0n ||
+                asBigint(nested.value) !== 0n ||
+                asString(replacements[0].token) !== token || asBigint(replacements[0].offset) !== 4n || !balances.has(token) ||
+                WRAPPED_NATIVE_TOKENS[parsed.destinationChainId?.toString() ?? ''] !== token)
+                return parsed;
+            balances.set(NATIVE_TOKEN, (balances.get(NATIVE_TOKEN) ?? 0n) + (balances.get(token) ?? 0n));
+            balances.set(token, 0n);
+            continue;
+        }
+        if (selector === '0xef8738d3' && target === handler) {
+            if (value !== 0n)
+                return parsed;
+            const drain = decodeCall([{ name: 'token', kind: 'address' }, { name: 'receiver', kind: 'address' }], data);
+            const token = asString(drain.token);
+            const amount = balances.get(token) ?? 0n;
+            if (amount > 0n)
+                payouts.push({ outputToken: token, minOutputAmount: amount, receiver: asString(drain.receiver) });
+            balances.set(token, 0n);
+            continue;
+        }
+        const transfer = readTransfer(target, data, value);
+        if (!transfer || !balances.has(transfer.outputToken))
+            return parsed;
+        const token = transfer.outputToken;
+        balances.set(token, subtractFees(balances.get(token) ?? 0n, transfer.minOutputAmount ?? 0n));
+    }
+    if (payouts.length === 1) {
+        const fallback = asString(args.fallbackRecipient);
+        if (!isZeroWord(fallback) && fallback !== payouts[0].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);
+        }
+        Object.assign(parsed, payouts[0]);
+    }
+    return parsed;
+};
+export const applyAcrossMessage = (parsed, message) => {
+    try {
+        return readAcrossMessage(parsed, message);
+    }
+    catch (error) {
+        throw asBridgeError(error, BRIDGE_ERRORS.CALLDATA_DECODE_FAILED, parsed.diagnostics);
+    }
+};

package/dist/calldata/diagnostics.d.ts

@@ -0,0 +1,4 @@
+import type { BridgeErrorContext } from '../errors/index.js';
+/** Inspect call structure only. Never retain arguments or scan arbitrary payloads for selectors. */
+export declare const calldataDiagnostics: (data: unknown) => BridgeErrorContext;
+export declare const innerCallDiagnostics: (data: string, layer: "router" | "protocol") => BridgeErrorContext;

package/dist/calldata/diagnostics.js

@@ -0,0 +1,18 @@
+/** Inspect call structure only. Never retain arguments or scan arbitrary payloads for selectors. */
+export const calldataDiagnostics = (data) => {
+    if (typeof data !== 'string')
+        return { calldataFormat: 'missing' };
+    const valid = /^0x(?:[0-9a-f]{2})*$/i.test(data);
+    const selector = /^0x[0-9a-f]{8}/i.test(data) ? data.slice(0, 10).toLowerCase() : undefined;
+    return {
+        selector,
+        calldataFormat: valid ? (data.length === 2 ? 'empty' : 'valid') : 'invalid',
+        ...(valid ? { calldataBytes: (data.length - 2) / 2 } : {}),
+    };
+};
+export const innerCallDiagnostics = (data, layer) => {
+    const { selector, calldataBytes } = calldataDiagnostics(data);
+    return layer === 'router'
+        ? { routerSelector: selector, routerCalldataBytes: calldataBytes }
+        : { protocolSelector: selector, protocolCalldataBytes: calldataBytes };
+};

package/dist/calldata/expect.d.ts

@@ -0,0 +1,25 @@
+import type { BridgeErrorDefinition } from '../errors/index.js';
+import type { BridgeCheck, ParsedBridgeCall } from './types.js';
+export type BridgeCallExpectation = {
+    userAddress: string;
+    fromTokenId: string;
+    fromTokenRawAmount: string;
+    toTokenId: string;
+    /** 目标链 id。目标币是原生币时，用它识别 `hood` 这类链 id，而不是源链 id。 */
+    toChainId?: string;
+    toTokenRawAmount?: string;
+    /** 小数滑点。0.01 表示 1%。 */
+    slippage?: string | number;
+};
+export type CompareMask = {
+    fromToken: boolean;
+    fromAmount: boolean;
+    toToken: boolean;
+    toAmount: boolean;
+    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. */
+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

@@ -0,0 +1,129 @@
+import { BRIDGE_ERRORS, bridgeFailure } from '../errors/index.js';
+import { evmChainId } from './chains.js';
+const NATIVE_ADDRESS = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+const RATIO_SCALE = 1000000n;
+export const knownCompare = (parsed) => ({
+    fromToken: parsed.sourceToken !== undefined,
+    fromAmount: parsed.sourceAmount !== undefined,
+    toToken: parsed.outputToken !== undefined,
+    toAmount: parsed.minOutputAmount !== undefined,
+    receiver: parsed.receiver !== undefined,
+});
+const isHexAddress = (value) => /^0x[0-9a-f]{40}$/i.test(value);
+const isNativeToken = (value, chainId) => {
+    const normalized = value.toLowerCase();
+    const network = evmChainId(normalized);
+    return (normalized === NATIVE_ADDRESS ||
+        normalized === ZERO_ADDRESS ||
+        normalized === chainId.toLowerCase() ||
+        (network !== undefined && network === evmChainId(chainId)));
+};
+const sameToken = (actual, expected, chainId) => {
+    if (!actual) {
+        return false;
+    }
+    if (isNativeToken(actual, chainId) && isNativeToken(expected, chainId)) {
+        return true;
+    }
+    if (!isHexAddress(actual) || !isHexAddress(expected)) {
+        return actual.toLowerCase() === expected.toLowerCase();
+    }
+    return actual.toLowerCase() === expected.toLowerCase();
+};
+const parseAmount = (amount) => {
+    try {
+        return BigInt(amount);
+    }
+    catch {
+        return undefined;
+    }
+};
+/** Actual source payment may exceed local intent by at most 0.1%; lower payments still reject. */
+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) => {
+    if (minReceive <= 0n || quoted <= 0n || slippage < 0 || slippage >= 1) {
+        return false;
+    }
+    const ratioScaled = BigInt(Math.round((1 - slippage) * Number(RATIO_SCALE)));
+    const minimum = (quoted * ratioScaled) / RATIO_SCALE;
+    if (minimum <= 0n) {
+        return false;
+    }
+    if (minReceive === minimum) {
+        return true;
+    }
+    const difference = minReceive > minimum ? minReceive - minimum : minimum - minReceive;
+    return difference * 20n <= minimum;
+};
+export const expectationFailures = (parsed, expectation, chainId, mask) => {
+    const reasons = [];
+    if (expectation.toChainId && parsed.destinationChainRef && parsed.destinationChainId === undefined) {
+        reasons.push(BRIDGE_ERRORS.TO_CHAIN_MISMATCH);
+    }
+    if (expectation.toChainId && parsed.destinationChainId !== undefined) {
+        const expectedChain = evmChainId(expectation.toChainId);
+        if (expectedChain !== undefined && parsed.destinationChainId !== expectedChain)
+            reasons.push(BRIDGE_ERRORS.TO_CHAIN_MISMATCH);
+    }
+    if (mask.fromToken && !sameToken(parsed.sourceToken, expectation.fromTokenId, chainId)) {
+        reasons.push(BRIDGE_ERRORS.FROM_TOKEN_MISMATCH);
+    }
+    if (mask.fromAmount) {
+        const expectedAmount = parseAmount(expectation.fromTokenRawAmount);
+        if (expectedAmount === undefined || !sourceAmountMatches(parsed.sourceAmount, expectedAmount)) {
+            reasons.push(BRIDGE_ERRORS.FROM_AMOUNT_MISMATCH);
+        }
+    }
+    if (mask.toToken &&
+        !sameToken(parsed.outputToken, expectation.toTokenId, expectation.toChainId || chainId)) {
+        reasons.push(BRIDGE_ERRORS.TO_TOKEN_MISMATCH);
+    }
+    if (mask.toAmount && expectation.toTokenRawAmount !== undefined) {
+        const quoted = parseAmount(expectation.toTokenRawAmount);
+        const slippage = Number(expectation.slippage);
+        if (quoted === undefined ||
+            parsed.minOutputAmount === undefined ||
+            !Number.isFinite(slippage) ||
+            !minReceiveMatches(parsed.minOutputAmount, quoted, slippage)) {
+            reasons.push(BRIDGE_ERRORS.MIN_RECEIVE_MISMATCH);
+        }
+    }
+    if (mask.receiver && !sameToken(parsed.receiver, expectation.userAddress, chainId)) {
+        reasons.push(BRIDGE_ERRORS.RECEIVER_MISMATCH);
+    }
+    return reasons;
+};
+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),
+    };
+    const expected = expectation
+        ? expectationFailures(parsed, expectation, chainId, mask)
+        : [];
+    const unsupportedCall = (parsed.hasDestinationCall || parsed.destinationCallData !== undefined) &&
+        (parsed.receiver === undefined ||
+            (parsed.outputToken === undefined && !parsed.outputTokenReference) ||
+            (parsed.minOutputAmount === undefined && !parsed.outputAmountReference));
+    const errors = [
+        ...(structural ? [structural] : []),
+        ...(unsupportedCall ? [BRIDGE_ERRORS.UNSUPPORTED_DESTINATION_CALL] : []),
+        ...expected,
+    ].map((error) => ({ ...error, ...parsed.diagnostics, aggregatorId, chainId, method: parsed.method,
+        hasDestinationCall: Boolean(parsed.hasDestinationCall || parsed.destinationCallData !== undefined) }));
+    const unverifiedFields = Object.entries({
+        sourceToken: mask.fromToken, sourceAmount: mask.fromAmount, outputToken: mask.toToken,
+        minOutputAmount: mask.toAmount && expectation?.toTokenRawAmount !== undefined,
+        receiver: mask.receiver,
+    }).filter(([, checked]) => !expectation || !checked).map(([field]) => field);
+    if (expectation?.toChainId && (parsed.destinationChainId === undefined || evmChainId(expectation.toChainId) === undefined)) {
+        unverifiedFields.push('destinationChainId');
+    }
+    if (errors.length) {
+        return { ...bridgeFailure(errors), aggregatorId, method: parsed.method, parsed, unverifiedFields };
+    }
+    return { ok: true, aggregatorId, method: parsed.method, parsed, unverifiedFields, errors: [] };
+};

package/dist/calldata/hex.d.ts

@@ -0,0 +1,6 @@
+export declare const normalizeHex: (value: string) => string;
+export declare const hexToBytes: (value: string) => Uint8Array;
+export declare const bytesToHex: (bytes: Uint8Array) => string;
+export declare const readSelector: (data: string) => string | null;
+export declare const isZeroWord: (value?: string) => boolean;
+export declare const accountFromBytes32: (word: string) => string;

package/dist/calldata/hex.js

@@ -0,0 +1,46 @@
+import { BRIDGE_ERRORS, BridgeError } from '../errors/index.js';
+const HEX = '0123456789abcdef';
+export const normalizeHex = (value) => {
+    const hex = value.startsWith('0x') || value.startsWith('0X') ? value.slice(2) : value;
+    if (hex.length % 2 !== 0 || /[^0-9a-fA-F]/.test(hex)) {
+        throw new BridgeError(BRIDGE_ERRORS.INVALID_HEX);
+    }
+    return hex.toLowerCase();
+};
+export const hexToBytes = (value) => {
+    const hex = normalizeHex(value);
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let index = 0; index < bytes.length; index += 1) {
+        bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+    }
+    return bytes;
+};
+export const bytesToHex = (bytes) => {
+    let hex = '0x';
+    for (const byte of bytes) {
+        hex += HEX[byte >> 4] + HEX[byte & 15];
+    }
+    return hex;
+};
+export const readSelector = (data) => {
+    try {
+        const hex = normalizeHex(data || '0x');
+        if (hex.length < 8 || /^0+$/.test(hex.slice(0, 8))) {
+            return null;
+        }
+        return `0x${hex.slice(0, 8)}`;
+    }
+    catch {
+        return null;
+    }
+};
+export const isZeroWord = (value) => {
+    return !value || /^0x0*$/i.test(value);
+};
+export const accountFromBytes32 = (word) => {
+    const body = word.toLowerCase().replace(/^0x/, '').padStart(64, '0');
+    if (body.slice(0, 24) === '0'.repeat(24)) {
+        return `0x${body.slice(24)}`;
+    }
+    return `0x${body}`;
+};

package/dist/calldata/index.d.ts

@@ -0,0 +1,20 @@
+import { BridgeError } from '../errors/index.js';
+import type { BridgeErrorDetail } from '../errors/index.js';
+import type { BridgeAggregatorId } from '../consts.js';
+import type { BridgeCallExpectation } from './expect.js';
+import type { BridgeCalldataTx, BridgeCheck, DecodeHit, ParsedBridgeCall } from './types.js';
+export declare const CALLDATA_AGGREGATORS: BridgeAggregatorId[];
+export declare class InvalidBridgeCalldataError extends BridgeError {
+    readonly aggregatorId: string;
+    readonly chainId: string;
+    readonly method: string | undefined;
+    readonly reason: string;
+    constructor(aggregatorId: string, chainId: string, method: string | undefined, reason: string, errors?: BridgeErrorDetail[]);
+}
+export declare const hasBridgeCalldata: (tx: BridgeCalldataTx) => boolean;
+/** Detailed decoding for callers that need failures instead of a nullable result. */
+export declare const decodeBridgeCalldataResult: (aggregatorId: string, tx: BridgeCalldataTx) => DecodeHit;
+export declare const decodeBridgeCalldata: (aggregatorId: string, tx: BridgeCalldataTx) => ParsedBridgeCall | null;
+export declare const validateBridgeCalldata: (aggregatorId: string, chainId: string, tx: BridgeCalldataTx, expectation?: BridgeCallExpectation) => BridgeCheck;
+export type { BridgeCallExpectation } from './expect.js';
+export type { BridgeCalldataTx, BridgeCheck, BridgeTokenReference, BridgeAmountReference, ParsedBridgeCall, DecodeHit } from './types.js';

package/dist/calldata/index.js

@@ -0,0 +1,85 @@
+import { BRIDGE_ERRORS, BridgeError, asBridgeError, bridgeFailure } from '../errors/index.js';
+import { decodeAcross, validateAcross } from './across/index.js';
+import { readSelector } from './hex.js';
+import { decodeLifi, validateLifi } from './lifi/index.js';
+import { decodeMayan, validateMayan } from './mayan/index.js';
+import { decodeRelay, validateRelay } from './relay/index.js';
+import { decodeSocket, validateSocket } from './socket/index.js';
+import { txCalldata, txValue } from './types.js';
+import { sourceChainMismatch } from './chains.js';
+import { calldataDiagnostics } from './diagnostics.js';
+import { sanitizeBridgeError } from '../errors/sanitize.js';
+const DECODERS = {
+    across: decodeAcross,
+    lifi: decodeLifi,
+    mayan: decodeMayan,
+    relay: decodeRelay,
+    socket: decodeSocket,
+};
+const VALIDATORS = {
+    across: validateAcross,
+    lifi: validateLifi,
+    mayan: validateMayan,
+    relay: validateRelay,
+    socket: validateSocket,
+};
+export const CALLDATA_AGGREGATORS = Object.keys(VALIDATORS);
+export class InvalidBridgeCalldataError extends BridgeError {
+    constructor(aggregatorId, chainId, method, reason, errors) {
+        super(BRIDGE_ERRORS.INVALID_CALLDATA, { aggregatorId, chainId, method }, errors);
+        this.aggregatorId = aggregatorId;
+        this.chainId = chainId;
+        this.method = method;
+        this.reason = reason;
+        this.message = `Invalid bridge calldata for ${aggregatorId} on ${chainId}: ${reason}`;
+        this.name = 'InvalidBridgeCalldataError';
+    }
+}
+export const hasBridgeCalldata = (tx) => {
+    return readSelector(txCalldata(tx)) !== null;
+};
+/** Detailed decoding for callers that need failures instead of a nullable result. */
+export const decodeBridgeCalldataResult = (aggregatorId, tx) => {
+    const context = { aggregatorId, ...calldataDiagnostics(tx.data || tx.input) };
+    const decode = DECODERS[aggregatorId];
+    if (!decode)
+        return bridgeFailure([{ ...BRIDGE_ERRORS.UNSUPPORTED_CALLDATA_AGGREGATOR, ...context }]);
+    let value;
+    try {
+        value = txValue(tx);
+    }
+    catch (error) {
+        return bridgeFailure(asBridgeError(error, BRIDGE_ERRORS.INVALID_TRANSACTION_VALUE, context).errors);
+    }
+    const hit = decode(txCalldata(tx), value);
+    return hit.ok ? hit : { ...hit, errors: hit.errors.map((error) => sanitizeBridgeError({ ...error, ...context })) };
+};
+export const decodeBridgeCalldata = (aggregatorId, tx) => {
+    const hit = decodeBridgeCalldataResult(aggregatorId, tx);
+    return hit.ok ? hit.parsed : null;
+};
+export const validateBridgeCalldata = (aggregatorId, chainId, tx, expectation) => {
+    const context = { aggregatorId, chainId, toChainId: expectation?.toChainId, ...calldataDiagnostics(tx.data || tx.input) };
+    if (sourceChainMismatch(chainId, tx.chainId))
+        return { ...bridgeFailure([{ ...BRIDGE_ERRORS.FROM_CHAIN_MISMATCH, ...context }]), aggregatorId };
+    if (expectation && tx.from !== undefined &&
+        (typeof tx.from !== 'string' || tx.from.toLowerCase() !== expectation.userAddress.toLowerCase())) {
+        return { ...bridgeFailure([{ ...BRIDGE_ERRORS.FROM_ADDRESS_MISMATCH, ...context }]), aggregatorId };
+    }
+    const validate = VALIDATORS[aggregatorId];
+    if (!validate) {
+        return {
+            ...bridgeFailure([{ ...BRIDGE_ERRORS.UNSUPPORTED_CALLDATA_AGGREGATOR, ...context }]),
+            aggregatorId,
+        };
+    }
+    let value;
+    try {
+        value = txValue(tx);
+    }
+    catch (error) {
+        return { ...bridgeFailure(asBridgeError(error, BRIDGE_ERRORS.INVALID_TRANSACTION_VALUE, context).errors), aggregatorId };
+    }
+    const check = validate(txCalldata(tx), value, expectation, chainId);
+    return { ...check, errors: check.errors.map((error) => sanitizeBridgeError({ ...error, ...context })) };
+};

package/dist/calldata/lifi/across/acrossV4Erc20Min.d.ts

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

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

@@ -0,0 +1,26 @@
+import { asBigint, asRecord, asString, decodeCall } from '../../abi.js';
+import { accountFromBytes32 } from '../../hex.js';
+import { acrossPackedParam } from '../params.js';
+export const startBridgeTokensViaAcrossV4ERC20Min = {
+    name: 'startBridgeTokensViaAcrossV4ERC20Min',
+    selector: '0x7260352d',
+    decode(data) {
+        const args = decodeCall([
+            acrossPackedParam,
+            { name: 'sendingAssetId', kind: 'bytes', size: 32 },
+            { name: 'inputAmount', kind: 'uint' },
+        ], data);
+        const parameters = asRecord(args.parameters);
+        return {
+            aggregatorId: 'lifi',
+            method: 'startBridgeTokensViaAcrossV4ERC20Min',
+            kind: 'bridge',
+            sourceToken: accountFromBytes32(asString(args.sendingAssetId)),
+            sourceAmount: asBigint(args.inputAmount),
+            destinationChainId: asBigint(parameters.destinationChainId),
+            receiver: accountFromBytes32(asString(parameters.receiver)),
+            outputToken: accountFromBytes32(asString(parameters.receivingAssetId)),
+            minOutputAmount: asBigint(parameters.outputAmount),
+        };
+    },
+};

package/dist/calldata/lifi/across/acrossV4NativeMin.d.ts

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

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

@@ -0,0 +1,22 @@
+import { asBigint, asRecord, asString, decodeCall } from '../../abi.js';
+import { accountFromBytes32 } from '../../hex.js';
+import { acrossPackedParam } from '../params.js';
+export const startBridgeTokensViaAcrossV4NativeMin = {
+    name: 'startBridgeTokensViaAcrossV4NativeMin',
+    selector: '0x72dd147e',
+    decode(data, value) {
+        const args = decodeCall([acrossPackedParam], data);
+        const parameters = asRecord(args.parameters);
+        return {
+            aggregatorId: 'lifi',
+            method: 'startBridgeTokensViaAcrossV4NativeMin',
+            kind: 'bridge',
+            sourceToken: '0x0000000000000000000000000000000000000000',
+            sourceAmount: value,
+            destinationChainId: asBigint(parameters.destinationChainId),
+            receiver: accountFromBytes32(asString(parameters.receiver)),
+            outputToken: accountFromBytes32(asString(parameters.receivingAssetId)),
+            minOutputAmount: asBigint(parameters.outputAmount),
+        };
+    },
+};

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

@@ -0,0 +1,6 @@
+import type { CalldataMethod } from '../../abi.js';
+import type { CompareMask } from '../../expect.js';
+import type { ParsedBridgeCall } from '../../types.js';
+export declare const methods: CalldataMethod[];
+export declare const compare: (parsed: ParsedBridgeCall) => CompareMask;
+export declare const check: (parsed: ParsedBridgeCall) => import("../../../index.js").BridgeErrorDefinition | undefined;

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

@@ -0,0 +1,19 @@
+import { bridgeShape } from '../shape.js';
+import { startBridgeTokensViaAcrossV4ERC20Min } from './acrossV4Erc20Min.js';
+import { startBridgeTokensViaAcrossV4NativeMin } from './acrossV4NativeMin.js';
+import { acrossDataParam, applyAcrossData } from '../params.js';
+import { lifiBridgeMethod } from '../method.js';
+export const methods = [
+    lifiBridgeMethod('startBridgeTokensViaAcrossV4', '0xa1f1ce43', [acrossDataParam], false, (parsed, args) => applyAcrossData(parsed, args.acrossData)),
+    lifiBridgeMethod('swapAndStartBridgeTokensViaAcrossV4', '0x1794958f', [acrossDataParam], true, (parsed, args) => applyAcrossData(parsed, args.acrossData)),
+    startBridgeTokensViaAcrossV4ERC20Min,
+    startBridgeTokensViaAcrossV4NativeMin,
+];
+export const compare = (parsed) => ({
+    fromToken: parsed.sourceToken !== undefined,
+    fromAmount: parsed.sourceAmount !== undefined,
+    toToken: true,
+    toAmount: true,
+    receiver: true,
+});
+export const check = bridgeShape;