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

package/dist/calldata/expect.d.ts

@@ -1,27 +0,0 @@
-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;
-    /** Selected backend quote key; only protocol identifiers with known semantics are compared. */
-    quoteKey?: string | Record<string, unknown>;
-    /** 小数滑点。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 fail comparison. */
-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

@@ -1,158 +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;
-    }
-};
-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();
-};
-/** Actual source payment may exceed local intent by at most 0.1%; lower payments fail comparison. */
-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 = [];
-    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 && !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,
-        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 || 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,88 +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) };
-    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

@@ -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/destination.d.ts

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

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

@@ -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;