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

package/dist/calldata/expect.js

@@ -0,0 +1,157 @@
+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;
+    }
+};
+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();
+};
+/** Source payment is capped at 100.1% of local intent; smaller payments are allowed. */
+export const sourceAmountMatches = (actual, expected) => actual !== undefined && actual >= 0n && expected >= 0n && actual * 1000n <= expected * 1001n;
+/** Allow up to 5% below the slippage-adjusted minimum; higher guarantees always pass. */
+const minReceiveMatches = (minReceive, quoted, slippage) => {
+    if (minReceive <= 0n || quoted <= 0n || slippage < 0 || slippage >= 1) {
+        return false;
+    }
+    const ratioScaled = BigInt(Math.round((1 - slippage) * Number(RATIO_SCALE)));
+    const minimum = (quoted * ratioScaled) / RATIO_SCALE;
+    if (minimum <= 0n) {
+        return false;
+    }
+    return minReceive * 20n >= minimum * 19n;
+};
+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);
+    }
+    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 && !parsed.fixedReceiver && !sameToken(parsed.receiver, expectation.userAddress, chainId)) {
+        reasons.push(BRIDGE_ERRORS.RECEIVER_MISMATCH);
+    }
+    if (parsed.refundRecipients?.some((recipient) => recipient.toLowerCase() !== expectation.userAddress.toLowerCase())) {
+        reasons.push(BRIDGE_ERRORS.REFUND_RECIPIENT_MISMATCH);
+    }
+    return reasons;
+};
+export const finishCheck = (aggregatorId, parsed, structural, expectation, chainId, mask) => {
+    mask = {
+        ...mask,
+        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;
+    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) {
+        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,88 @@
+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) };
+    const inputErrors = [];
+    if (sourceChainMismatch(chainId, tx.chainId))
+        inputErrors.push(BRIDGE_ERRORS.FROM_CHAIN_MISMATCH);
+    if (expectation && tx.from !== undefined &&
+        (typeof tx.from !== 'string' || tx.from.toLowerCase() !== expectation.userAddress.toLowerCase())) {
+        inputErrors.push(BRIDGE_ERRORS.FROM_ADDRESS_MISMATCH);
+    }
+    const validate = VALIDATORS[aggregatorId];
+    if (!validate) {
+        return {
+            ...bridgeFailure([...inputErrors, BRIDGE_ERRORS.UNSUPPORTED_CALLDATA_AGGREGATOR].map((error) => ({ ...error, ...context }))),
+            aggregatorId,
+        };
+    }
+    let value;
+    try {
+        value = txValue(tx);
+    }
+    catch (error) {
+        return { ...bridgeFailure([...inputErrors, ...asBridgeError(error, BRIDGE_ERRORS.INVALID_TRANSACTION_VALUE).errors]
+                .map((detail) => ({ ...detail, ...context }))), aggregatorId };
+    }
+    const check = validate(txCalldata(tx), value, expectation, chainId);
+    const errors = [...inputErrors, ...check.errors].map((error) => sanitizeBridgeError({ ...error, ...context }));
+    return { ...check, ...(errors.length ? bridgeFailure(errors) : {}), errors };
+};

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,27 @@
+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)),
+            refundRecipients: [accountFromBytes32(asString(parameters.depositor))],
+            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,23 @@
+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)),
+            refundRecipients: [accountFromBytes32(asString(parameters.depositor))],
+            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;

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

@@ -0,0 +1,3 @@
+export declare const methods: import("../../abi.js").CalldataMethod[];
+export declare const compare: (parsed: import("../../types.js").ParsedBridgeCall) => import("../../expect.js").CompareMask;
+export declare const check: (parsed: import("../../types.js").ParsedBridgeCall) => import("../../../errors/constants.js").BridgeErrorDefinition | undefined;

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

@@ -0,0 +1,26 @@
+import { BRIDGE_ERRORS, BridgeError } from '../../../errors/index.js';
+import { asRecord, asString } from '../../abi.js';
+import { accountFromBytes32 } from '../../hex.js';
+import { knownCompare } from '../../expect.js';
+import { lifiBridgeMethod } from '../method.js';
+import { bridgeShape } from '../shape.js';
+const allBridgeData = { name: 'allBridgeData', kind: 'tuple', components: [
+        { name: 'recipient', kind: 'bytes', size: 32 }, { name: 'fees', kind: 'uint' },
+        { name: 'receiveToken', kind: 'bytes', size: 32 }, { name: 'nonce', kind: 'uint' },
+        { name: 'messenger', kind: 'uint' }, { name: 'payFeeWithSendingAsset', kind: 'bool' },
+    ] };
+const fill = (parsed, args) => {
+    const data = asRecord(args.allBridgeData);
+    const receiver = accountFromBytes32(asString(data.recipient));
+    if (receiver !== parsed.receiver)
+        throw new BridgeError(BRIDGE_ERRORS.ALLBRIDGE_RECEIVER_MISMATCH);
+    parsed.receiver = receiver;
+    parsed.outputToken = accountFromBytes32(asString(data.receiveToken));
+    // The destination pool prices vUSD when redeeming; there is no signed output minimum.
+};
+export const methods = [
+    lifiBridgeMethod('startBridgeTokensViaAllBridge', '0x6a51e9a9', [allBridgeData], false, fill),
+    lifiBridgeMethod('swapAndStartBridgeTokensViaAllBridge', '0x63267469', [allBridgeData], true, fill),
+];
+export const compare = knownCompare;
+export const check = bridgeShape;

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

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

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

@@ -0,0 +1,10 @@
+import { knownCompare } from '../../expect.js';
+import { bridgeShape } from '../shape.js';
+import { lifiBridgeMethod } from '../method.js';
+import { applyCelerCircleData, celerCircleDataParam } from '../params.js';
+export const methods = [
+    lifiBridgeMethod('startBridgeTokensViaCelerCircleBridge', '0xe0a4201c', [celerCircleDataParam], false, (parsed, args) => applyCelerCircleData(parsed, args.celerCircleData)),
+    lifiBridgeMethod('swapAndStartBridgeTokensViaCelerCircleBridge', '0x4f3b0759', [celerCircleDataParam], true, (parsed, args) => applyCelerCircleData(parsed, args.celerCircleData)),
+];
+export const compare = knownCompare;
+export const check = bridgeShape;

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

@@ -0,0 +1,3 @@
+export declare const methods: import("../../abi.js").CalldataMethod[];
+export declare const compare: (parsed: import("../../types.js").ParsedBridgeCall) => import("../../expect.js").CompareMask;
+export declare const check: (parsed: import("../../types.js").ParsedBridgeCall) => import("../../../errors/constants.js").BridgeErrorDefinition | undefined;

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

@@ -0,0 +1,22 @@
+import { BRIDGE_ERRORS, BridgeError } from '../../../errors/index.js';
+import { asRecord, asString } from '../../abi.js';
+import { knownCompare } from '../../expect.js';
+import { lifiBridgeMethod } from '../method.js';
+import { bridgeShape } from '../shape.js';
+const centrifugeData = { name: 'centrifugeData', kind: 'tuple', components: [
+        { name: 'nativeFee', kind: 'uint' }, { name: 'refundRecipient', kind: 'address' },
+    ] };
+const fill = (parsed, args) => {
+    if (asString(asRecord(args.centrifugeData).refundRecipient) !== parsed.receiver) {
+        throw new BridgeError(BRIDGE_ERRORS.CENTRIFUGE_REFUND_RECIPIENT_MISMATCH);
+    }
+    parsed.minOutputAmount = parsed.bridgeAmount;
+    parsed.outputTokenReference = { protocol: 'centrifuge', token: parsed.bridgeToken,
+        destinationChainId: parsed.destinationChainId };
+};
+export const methods = [
+    lifiBridgeMethod('startBridgeTokensViaCentrifuge', '0x0315138f', [centrifugeData], false, fill),
+    lifiBridgeMethod('swapAndStartBridgeTokensViaCentrifuge', '0x8fd4d4dd', [centrifugeData], true, fill),
+];
+export const compare = knownCompare;
+export const check = bridgeShape;

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/frax/index.d.ts

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

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

@@ -0,0 +1,29 @@
+import { BRIDGE_ERRORS, BridgeError } from '../../../errors/index.js';
+import { asBigint, asRecord, asString } from '../../abi.js';
+import { knownCompare } from '../../expect.js';
+import { LAYERZERO_CHAINS } from '../../protocols.js';
+import { lifiBridgeMethod } from '../method.js';
+import { bridgeShape } from '../shape.js';
+const fraxData = { name: 'fraxData', kind: 'tuple', components: [
+        { name: 'oft', kind: 'address' }, { name: 'dstEid', kind: 'uint' },
+        { name: 'nativeFee', kind: 'uint' }, { name: 'refundRecipient', kind: 'address' },
+        { name: 'nonEVMReceiver', kind: 'bytes', size: 32 },
+    ] };
+const fill = (parsed, args) => {
+    const data = asRecord(args.fraxData);
+    const eid = asBigint(data.dstEid);
+    parsed.destinationChainRef = `layerzero:${eid}`;
+    parsed.destinationChainId = LAYERZERO_CHAINS[eid.toString()];
+    if (!/^0x0*$/.test(asString(data.nonEVMReceiver)))
+        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_NON_EVM_FRAX_RECEIVER);
+    const token = { protocol: 'frax', contract: asString(data.oft), token: parsed.bridgeToken,
+        destinationChainId: parsed.destinationChainId, destinationChainRef: parsed.destinationChainRef };
+    parsed.outputTokenReference = token;
+    parsed.outputAmountReference = { kind: 'dust', amount: parsed.bridgeAmount, token };
+};
+export const methods = [
+    lifiBridgeMethod('startBridgeTokensViaFrax', '0x678786ea', [fraxData], false, fill),
+    lifiBridgeMethod('swapAndStartBridgeTokensViaFrax', '0x07b8e4c7', [fraxData], true, fill),
+];
+export const compare = knownCompare;
+export const check = bridgeShape;

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

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

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

@@ -0,0 +1,22 @@
+import { asRecord, asString } from '../../abi.js';
+import { knownCompare } from '../../expect.js';
+import { lifiBridgeMethod } from '../method.js';
+import { bridgeShape } from '../shape.js';
+const gardenData = { name: 'gardenData', kind: 'tuple', components: [
+        { name: 'redeemer', kind: 'address' }, { name: 'refundAddress', kind: 'address' },
+        { name: 'timelock', kind: 'uint' }, { name: 'secretHash', kind: 'bytes', size: 32 },
+        { name: 'nonEvmReceiver', kind: 'bytes', size: 32 },
+    ] };
+const fill = (parsed, args) => {
+    parsed.requestId = asString(asRecord(args.gardenData).secretHash);
+    // Garden locks only the source HTLC; BridgeData's destination fields are event metadata.
+    delete parsed.receiver;
+    delete parsed.destinationChainId;
+    parsed.destinationChainRef = 'garden:offchain';
+};
+export const methods = [
+    lifiBridgeMethod('startBridgeTokensViaGarden', '0x5f9af35d', [gardenData], false, fill),
+    lifiBridgeMethod('swapAndStartBridgeTokensViaGarden', '0x76ad76fe', [gardenData], true, fill),
+];
+export const compare = knownCompare;
+export const check = bridgeShape;

package/dist/calldata/lifi/gaszip/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/gaszip/index.js

@@ -0,0 +1,15 @@
+import { bridgeShape } from '../shape.js';
+import { applyGasZipData, gasZipDataParam } from '../params.js';
+import { lifiBridgeMethod } from '../method.js';
+export const methods = [
+    lifiBridgeMethod('startBridgeTokensViaGasZip', '0xfc5f1003', [gasZipDataParam], false, (parsed, args) => applyGasZipData(parsed, args.gasZipData)),
+    lifiBridgeMethod('swapAndStartBridgeTokensViaGasZip', '0x606326ff', [gasZipDataParam], true, (parsed, args) => applyGasZipData(parsed, args.gasZipData)),
+];
+export const compare = (parsed) => ({
+    fromToken: parsed.sourceToken !== undefined,
+    fromAmount: parsed.sourceAmount !== undefined,
+    toToken: false,
+    toAmount: false,
+    receiver: true,
+});
+export const check = bridgeShape;

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

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