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

package/dist/calldata/expect.js

@@ -1,129 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

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

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

@@ -1,26 +0,0 @@
-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

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

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

@@ -1,22 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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/frax/index.d.ts

@@ -1,4 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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;

package/dist/calldata/lifi/index.js

@@ -1,60 +0,0 @@
-import { BRIDGE_ERRORS, bridgeFailure } from '../../errors/index.js';
-import { finishCheck } from '../expect.js';
-import { matchMethod } from '../match.js';
-import * as across from './across/index.js';
-import * as allbridge from './allbridge/index.js';
-import * as celer from './celer/index.js';
-import * as centrifuge from './centrifuge/index.js';
-import * as frax from './frax/index.js';
-import * as gaszip from './gaszip/index.js';
-import * as garden from './garden/index.js';
-import * as intents from './intents/index.js';
-import * as layerswap from './layerswap/index.js';
-import * as mayan from './mayan/index.js';
-import * as m0 from './m0/index.js';
-import * as native from './native/index.js';
-import * as paxos from './paxos/index.js';
-import * as polymer from './polymer/index.js';
-import * as relay from './relay/index.js';
-import * as squid from './squid/index.js';
-import * as stargate from './stargate/index.js';
-import * as swap from './swap/index.js';
-const ROUTES = [
-    across,
-    allbridge,
-    centrifuge,
-    garden,
-    m0,
-    native,
-    frax,
-    stargate,
-    intents,
-    polymer,
-    layerswap,
-    mayan,
-    celer,
-    paxos,
-    relay,
-    gaszip,
-    squid,
-    swap,
-];
-const METHODS = ROUTES.flatMap((route) => route.methods);
-const routeFor = (method) => ROUTES.find((route) => route.methods.some((item) => item.name === method));
-export const decodeLifi = (data, value) => matchMethod(METHODS, data, value);
-export const validateLifi = (data, value, expectation, chainId = '') => {
-    const hit = decodeLifi(data, value);
-    if (!hit.ok) {
-        return { ...hit, aggregatorId: 'lifi' };
-    }
-    const route = routeFor(hit.parsed.method);
-    if (!route) {
-        return {
-            ...bridgeFailure([BRIDGE_ERRORS.UNSUPPORTED_METHOD]),
-            aggregatorId: 'lifi',
-            method: hit.parsed.method,
-            parsed: hit.parsed,
-        };
-    }
-    return finishCheck('lifi', hit.parsed, route.check(hit.parsed), expectation, chainId, route.compare(hit.parsed));
-};

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

@@ -1,4 +0,0 @@
-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/intents/index.js

@@ -1,10 +0,0 @@
-import { knownCompare } from '../../expect.js';
-import { bridgeShape } from '../shape.js';
-import { lifiBridgeMethod } from '../method.js';
-import { applyLifiIntentData, lifiIntentDataParam } from '../params.js';
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaLiFiIntentEscrowV2', '0x7dbcf1d9', [lifiIntentDataParam], false, (parsed, args) => applyLifiIntentData(parsed, args.lifiIntentData)),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaLiFiIntentEscrowV2', '0x6d21c5df', [lifiIntentDataParam], true, (parsed, args) => applyLifiIntentData(parsed, args.lifiIntentData)),
-];
-export const compare = knownCompare;
-export const check = bridgeShape;

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

@@ -1,4 +0,0 @@
-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;