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

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

@@ -1,10 +0,0 @@
-import { knownCompare } from '../../expect.js';
-import { bridgeShape } from '../shape.js';
-import { lifiBridgeMethod } from '../method.js';
-import { applyLayerSwapData, layerSwapDataParam } from '../params.js';
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaLayerSwap', '0xee9e98e0', [layerSwapDataParam], false, (parsed, args) => applyLayerSwapData(parsed, args.layerSwapData)),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaLayerSwap', '0x4c279d6b', [layerSwapDataParam], true, (parsed, args) => applyLayerSwapData(parsed, args.layerSwapData)),
-];
-export const compare = knownCompare;
-export const check = bridgeShape;

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

@@ -1,33 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../../../errors/index.js';
-import { asBigint, 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 m0Data = { name: 'm0Data', kind: 'tuple', components: [
-        { name: 'receiverAddress', kind: 'bytes', size: 32 }, { name: 'refundRecipient', kind: 'address' },
-        { name: 'orderOwner', kind: 'address' }, { name: 'tokenOut', kind: 'bytes', size: 32 },
-        { name: 'solver', kind: 'bytes', size: 32 }, { name: 'amountOut', kind: 'uint' },
-        { name: 'fillDeadline', kind: 'uint' },
-    ] };
-const fill = (parsed, args) => {
-    const data = asRecord(args.m0Data);
-    if ((parsed.destinationChainId ?? 0n) > 0xffffffffn)
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_NON_EVM_M0_DESTINATION);
-    const receiver = accountFromBytes32(asString(data.receiverAddress));
-    if (receiver !== parsed.receiver)
-        throw new BridgeError(BRIDGE_ERRORS.M0_RECEIVER_MISMATCH);
-    if (asString(data.refundRecipient) !== receiver || asString(data.orderOwner) !== receiver) {
-        throw new BridgeError(BRIDGE_ERRORS.M0_REFUND_RECIPIENT_MISMATCH);
-    }
-    parsed.receiver = receiver;
-    parsed.outputToken = accountFromBytes32(asString(data.tokenOut));
-    // Positive source-swap slippage scales amountOut up; the quoted amount remains its floor.
-    parsed.minOutputAmount = asBigint(data.amountOut);
-};
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaM0', '0x65782c4b', [m0Data], false, fill),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaM0', '0xb9eaf86d', [m0Data], true, fill),
-];
-export const compare = knownCompare;
-export const check = bridgeShape;

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

@@ -1,10 +0,0 @@
-import { knownCompare } from '../../expect.js';
-import { bridgeShape } from '../shape.js';
-import { applyMayanData, mayanDataParam } from '../params.js';
-import { lifiBridgeMethod } from '../method.js';
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaMayan', '0xb4875292', [mayanDataParam], false, (parsed, args) => applyMayanData(parsed, args.mayanData)),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaMayan', '0x80c65808', [mayanDataParam], true, (parsed, args) => applyMayanData(parsed, args.mayanData)),
-];
-export const compare = knownCompare;
-export const check = bridgeShape;

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

@@ -1,6 +0,0 @@
-import { type AbiParam, type AbiValue } from '../abi.js';
-import type { CalldataMethod } from '../abi.js';
-import type { ParsedBridgeCall } from '../types.js';
-export declare const lifiBridgeMethod: (name: string, selector: string, tail: AbiParam[], withSwap: boolean, fill?: (parsed: ParsedBridgeCall, args: {
-    [key: string]: AbiValue;
-}) => void) => CalldataMethod;

package/dist/calldata/lifi/method.js

@@ -1,16 +0,0 @@
-import { decodeCall } from '../abi.js';
-import { applyBridgeData, applyFirstSwap, bridgeDataParam, swapDataArrayParam } from './params.js';
-export const lifiBridgeMethod = (name, selector, tail, withSwap, fill) => ({
-    name,
-    selector,
-    decode(data) {
-        const params = [bridgeDataParam, ...(withSwap ? [swapDataArrayParam] : []), ...tail];
-        const args = decodeCall(params, data);
-        const parsed = applyBridgeData(name, args.bridgeData);
-        if (withSwap) {
-            applyFirstSwap(parsed, args.swapData);
-        }
-        fill?.(parsed, args);
-        return parsed;
-    },
-});

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

@@ -1,80 +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, NATIVE_TOKEN, isNative } from '../../protocols.js';
-import { lifiBridgeMethod } from '../method.js';
-import { bridgeShape } from '../shape.js';
-const polygon = (parsed) => {
-    parsed.destinationChainId = 137n;
-    parsed.minOutputAmount = parsed.bridgeAmount;
-    if (isNative(parsed.bridgeToken)) {
-        parsed.outputToken = '0x7ceb23fd6bc0add59e62ac25578270cff1b9f619';
-    }
-    else {
-        parsed.outputTokenReference = { protocol: 'polygon', token: parsed.bridgeToken, destinationChainId: 137n };
-    }
-};
-const gnosis = (parsed) => {
-    parsed.destinationChainId = 100n;
-    parsed.minOutputAmount = parsed.bridgeAmount;
-    if (['0x6b175474e89094c44da98b954eedeac495271d0f', '0xdc035d45d973e3ec169d2276ddab16f1e407384f'].includes(parsed.bridgeToken)) {
-        parsed.outputToken = NATIVE_TOKEN;
-    }
-    else if (isNative(parsed.bridgeToken)) {
-        parsed.outputToken = '0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1';
-    }
-    else {
-        parsed.outputTokenReference = { protocol: 'gnosis', token: parsed.bridgeToken, destinationChainId: 100n };
-    }
-};
-const megaETHData = { name: 'megaETHData', kind: 'tuple', components: [
-        { name: 'assetIdOnL2', kind: 'address' }, { name: 'l2Gas', kind: 'uint' },
-        { name: 'requiresDepositTo', kind: 'bool' },
-    ] };
-const megaETH = (parsed, args) => {
-    const data = asRecord(args.megaETHData);
-    parsed.destinationChainId = 4326n;
-    parsed.minOutputAmount = parsed.bridgeAmount;
-    if (isNative(parsed.bridgeToken))
-        parsed.outputToken = NATIVE_TOKEN;
-    else if (data.requiresDepositTo === false) {
-        const token = asString(data.assetIdOnL2);
-        if (isNative(token))
-            throw new BridgeError(BRIDGE_ERRORS.MISSING_MEGAETH_DESTINATION_TOKEN);
-        parsed.outputToken = token;
-    }
-    // Custom depositTo bridges choose their remote token outside this calldata.
-};
-const supersetData = {
-    name: 'supersetData', kind: 'tuple', components: [
-        { name: 'path', kind: 'bytes' }, { name: 'amountOutMin', kind: 'uint' },
-        { name: 'refundAddress', kind: 'address' }, { name: 'fallbackEoA', kind: 'address' },
-        { name: 'deadline', kind: 'uint' }, { name: 'toEid', kind: 'uint' },
-        { name: 'options', kind: 'bytes' }, { name: 'lzFee', kind: 'uint' },
-    ],
-};
-const superset = (parsed, args) => {
-    const data = asRecord(args.supersetData);
-    const path = asString(data.path).slice(2);
-    if (path.length < 64 || (path.length - 64) % 70 !== 0)
-        throw new BridgeError(BRIDGE_ERRORS.INVALID_SUPERSET_OMNI_TOKEN_PATH);
-    parsed.minOutputAmount = asBigint(data.amountOutMin);
-    parsed.destinationChainRef = `layerzero:${asBigint(data.toEid)}`;
-    parsed.destinationChainId = LAYERZERO_CHAINS[asBigint(data.toEid).toString()];
-    parsed.outputTokenReference = {
-        protocol: 'superset', tokenId: `0x${path.slice(-64)}`,
-        destinationChainId: parsed.destinationChainId, destinationChainRef: parsed.destinationChainRef,
-    };
-};
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaPolygonBridge', '0xaf62c7d6', [], false, polygon),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaPolygonBridge', '0xb4f37581', [], true, polygon),
-    lifiBridgeMethod('startBridgeTokensViaGnosisBridge', '0xf66fe519', [], false, gnosis),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaGnosisBridge', '0x7bf96e0a', [], true, gnosis),
-    lifiBridgeMethod('startBridgeTokensViaMegaETHBridge', '0x4213dfff', [megaETHData], false, megaETH),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaMegaETHBridge', '0x22256e89', [megaETHData], true, megaETH),
-    lifiBridgeMethod('startBridgeTokensViaSuperset', '0x0691ff78', [supersetData], false, superset),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaSuperset', '0xf26e657f', [supersetData], true, superset),
-];
-export const compare = knownCompare;
-export const check = bridgeShape;

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

@@ -1,30 +0,0 @@
-import { type AbiParam, type AbiValue } from '../abi.js';
-import type { ParsedBridgeCall } from '../types.js';
-export declare const bridgeDataParam: AbiParam;
-export declare const swapDataArrayParam: AbiParam;
-export declare const swapDataParam: AbiParam;
-export declare const acrossDataParam: AbiParam;
-export declare const stargateDataParam: AbiParam;
-export declare const relayDepositoryDataParam: AbiParam;
-export declare const mayanDataParam: AbiParam;
-export declare const gasZipDataParam: AbiParam;
-export declare const squidDataParam: AbiParam;
-export declare const acrossPackedParam: AbiParam;
-export declare const applyBridgeData: (method: string, raw: AbiValue) => ParsedBridgeCall;
-export declare const applyFirstSwap: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
-export declare const applyAcrossData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
-export declare const applyStargateData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
-export declare const applyRelayDepositoryData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
-export declare const applyMayanData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
-export declare const applyGasZipData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
-export declare const applySquidData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
-export declare const polymerDataParam: AbiParam;
-export declare const lifiIntentDataParam: AbiParam;
-export declare const layerSwapDataParam: AbiParam;
-export declare const applyPolymerData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
-export declare const applyLifiIntentData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
-export declare const celerCircleDataParam: AbiParam;
-export declare const paxosDataParam: AbiParam;
-export declare const applyPaxosData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
-export declare const applyLayerSwapData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;
-export declare const applyCelerCircleData: (parsed: ParsedBridgeCall, raw: AbiValue) => void;

package/dist/calldata/lifi/params.js

@@ -1,370 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
-import { innerCallDiagnostics } from '../diagnostics.js';
-import { asArray, asBigint, asRecord, asString, } from '../abi.js';
-import { accountFromBytes32 } from '../hex.js';
-import { readMayanProtocol } from '../mayan/readProtocol.js';
-import { LAYERZERO_CHAINS, subtractFees } from '../protocols.js';
-const swapComponents = [
-    { name: 'callTo', kind: 'address' },
-    { name: 'approveTo', kind: 'address' },
-    { name: 'sendingAssetId', kind: 'address' },
-    { name: 'receivingAssetId', kind: 'address' },
-    { name: 'fromAmount', kind: 'uint' },
-    { name: 'callData', kind: 'bytes' },
-    { name: 'requiresDeposit', kind: 'bool' },
-];
-export const bridgeDataParam = {
-    name: 'bridgeData',
-    kind: 'tuple',
-    components: [
-        { name: 'transactionId', kind: 'bytes', size: 32 },
-        { name: 'bridge', kind: 'string' },
-        { name: 'integrator', kind: 'string' },
-        { name: 'referrer', kind: 'address' },
-        { name: 'sendingAssetId', kind: 'address' },
-        { name: 'receiver', kind: 'address' },
-        { name: 'minAmount', kind: 'uint' },
-        { name: 'destinationChainId', kind: 'uint' },
-        { name: 'hasSourceSwaps', kind: 'bool' },
-        { name: 'hasDestinationCall', kind: 'bool' },
-    ],
-};
-export const swapDataArrayParam = {
-    name: 'swapData',
-    kind: 'array',
-    item: { name: 'swap', kind: 'tuple', components: swapComponents },
-};
-export const swapDataParam = {
-    name: 'swapData',
-    kind: 'tuple',
-    components: swapComponents,
-};
-export const acrossDataParam = {
-    name: 'acrossData',
-    kind: 'tuple',
-    components: [
-        { name: 'receiverAddress', kind: 'bytes', size: 32 },
-        { name: 'refundAddress', kind: 'bytes', size: 32 },
-        { name: 'sendingAssetId', kind: 'bytes', size: 32 },
-        { name: 'receivingAssetId', kind: 'bytes', size: 32 },
-        { name: 'outputAmount', kind: 'uint' },
-        { name: 'outputAmountMultiplier', kind: 'uint' },
-        { name: 'exclusiveRelayer', kind: 'bytes', size: 32 },
-        { name: 'quoteTimestamp', kind: 'uint' },
-        { name: 'fillDeadline', kind: 'uint' },
-        { name: 'exclusivityParameter', kind: 'uint' },
-        { name: 'message', kind: 'bytes' },
-    ],
-};
-export const stargateDataParam = {
-    name: 'stargateData',
-    kind: 'tuple',
-    components: [
-        { name: 'assetId', kind: 'uint' },
-        {
-            name: 'sendParams',
-            kind: 'tuple',
-            components: [
-                { name: 'dstEid', kind: 'uint' },
-                { name: 'to', kind: 'bytes', size: 32 },
-                { name: 'amountLD', kind: 'uint' },
-                { name: 'minAmountLD', kind: 'uint' },
-                { name: 'extraOptions', kind: 'bytes' },
-                { name: 'composeMsg', kind: 'bytes' },
-                { name: 'oftCmd', kind: 'bytes' },
-            ],
-        },
-        {
-            name: 'fee',
-            kind: 'tuple',
-            components: [
-                { name: 'nativeFee', kind: 'uint' },
-                { name: 'lzTokenFee', kind: 'uint' },
-            ],
-        },
-        { name: 'refundAddress', kind: 'address' },
-    ],
-};
-export const relayDepositoryDataParam = {
-    name: 'relayDepositoryData',
-    kind: 'tuple',
-    components: [
-        { name: 'orderId', kind: 'bytes', size: 32 },
-        { name: 'depositorAddress', kind: 'address' },
-    ],
-};
-export const mayanDataParam = {
-    name: 'mayanData',
-    kind: 'tuple',
-    components: [
-        { name: 'nonEVMReceiver', kind: 'bytes', size: 32 },
-        { name: 'mayanProtocol', kind: 'address' },
-        { name: 'protocolData', kind: 'bytes' },
-        { name: 'swapProtocol', kind: 'address' },
-        { name: 'swapData', kind: 'bytes' },
-        { name: 'middleToken', kind: 'address' },
-        { name: 'minMiddleAmount', kind: 'uint' },
-        { name: 'refundRecipient', kind: 'address' },
-        { name: 'mayanAmountIn', kind: 'uint' },
-    ],
-};
-export const gasZipDataParam = {
-    name: 'gasZipData',
-    kind: 'tuple',
-    components: [
-        { name: 'receiverAddress', kind: 'bytes', size: 32 },
-        { name: 'destinationChains', kind: 'uint' },
-    ],
-};
-export const squidDataParam = {
-    name: 'squidData',
-    kind: 'tuple',
-    components: [
-        { name: 'routeType', kind: 'uint' },
-        { name: 'destinationChain', kind: 'string' },
-        { name: 'destinationAddress', kind: 'string' },
-        { name: 'bridgedTokenSymbol', kind: 'string' },
-        { name: 'depositAssetId', kind: 'address' },
-        {
-            name: 'sourceCalls',
-            kind: 'array',
-            item: {
-                name: 'call',
-                kind: 'tuple',
-                components: [
-                    { name: 'callType', kind: 'uint' },
-                    { name: 'target', kind: 'address' },
-                    { name: 'value', kind: 'uint' },
-                    { name: 'callData', kind: 'bytes' },
-                    { name: 'payload', kind: 'bytes' },
-                ],
-            },
-        },
-        { name: 'payload', kind: 'bytes' },
-        { name: 'fee', kind: 'uint' },
-        { name: 'enableExpress', kind: 'bool' },
-    ],
-};
-export const acrossPackedParam = {
-    name: 'parameters',
-    kind: 'tuple',
-    components: [
-        { name: 'transactionId', kind: 'bytes', size: 8 },
-        { name: 'receiver', kind: 'bytes', size: 32 },
-        { name: 'depositor', kind: 'bytes', size: 32 },
-        { name: 'destinationChainId', kind: 'uint' },
-        { name: 'receivingAssetId', kind: 'bytes', size: 32 },
-        { name: 'outputAmount', kind: 'uint' },
-        { name: 'exclusiveRelayer', kind: 'bytes', size: 32 },
-        { name: 'quoteTimestamp', kind: 'uint' },
-        { name: 'fillDeadline', kind: 'uint' },
-        { name: 'exclusivityParameter', kind: 'uint' },
-        { name: 'message', kind: 'bytes' },
-    ],
-};
-export const applyBridgeData = (method, raw) => {
-    const data = asRecord(raw);
-    return {
-        aggregatorId: 'lifi',
-        method,
-        kind: 'bridge',
-        sourceToken: asString(data.sendingAssetId),
-        sourceAmount: asBigint(data.minAmount),
-        bridgeToken: asString(data.sendingAssetId),
-        bridgeAmount: asBigint(data.minAmount),
-        destinationChainId: asBigint(data.destinationChainId),
-        receiver: asString(data.receiver),
-        bridgeReceiver: asString(data.receiver),
-        referrer: asString(data.referrer),
-    };
-};
-export const applyFirstSwap = (parsed, raw) => {
-    const swaps = asArray(raw);
-    const deposits = swaps.map(asRecord).filter((swap) => swap.requiresDeposit === true);
-    const first = deposits[0] ?? swaps[0];
-    if (!first) {
-        return;
-    }
-    const swap = asRecord(first);
-    parsed.sourceToken = asString(swap.sendingAssetId);
-    if (deposits.some((deposit) => asString(deposit.sendingAssetId) !== parsed.sourceToken)) {
-        throw new BridgeError(BRIDGE_ERRORS.MULTIPLE_SOURCE_ASSETS_ARE_NOT_SUPPORTED);
-    }
-    parsed.sourceAmount = deposits.length
-        ? deposits.reduce((sum, deposit) => sum + asBigint(deposit.fromAmount), 0n)
-        : asBigint(swap.fromAmount);
-};
-export const applyAcrossData = (parsed, raw) => {
-    const data = asRecord(raw);
-    parsed.receiver = accountFromBytes32(asString(data.receiverAddress));
-    parsed.outputToken = accountFromBytes32(asString(data.receivingAssetId));
-    parsed.minOutputAmount = asBigint(data.outputAmount);
-};
-export const applyStargateData = (parsed, raw) => {
-    const send = asRecord(asRecord(raw).sendParams);
-    parsed.receiver = accountFromBytes32(asString(send.to));
-    parsed.minOutputAmount = asBigint(send.minAmountLD);
-};
-export const applyRelayDepositoryData = (parsed, raw) => {
-    parsed.orderId = asString(asRecord(raw).orderId);
-};
-export const applyMayanData = (parsed, raw) => {
-    const data = asRecord(raw);
-    const receiver = accountFromBytes32(asString(data.nonEVMReceiver));
-    if (!/^0x0*$/.test(receiver)) {
-        parsed.receiver = receiver;
-    }
-    parsed.innerTarget = asString(data.mayanProtocol);
-    parsed.diagnostics = innerCallDiagnostics(asString(data.protocolData), 'protocol');
-    const protocol = readMayanProtocol(asString(data.protocolData), asBigint(data.minMiddleAmount) > 0n ? asBigint(data.minMiddleAmount) : parsed.bridgeAmount);
-    if (!protocol)
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_MAYAN_PROTOCOL_CALLDATA, parsed.diagnostics);
-    const { sourceToken, sourceAmount, aggregatorId, method, kind, ...destination } = protocol;
-    Object.assign(parsed, destination);
-};
-export const applyGasZipData = (parsed, raw) => {
-    const data = asRecord(raw);
-    parsed.receiver = accountFromBytes32(asString(data.receiverAddress));
-    parsed.destinationChainRef = asBigint(data.destinationChains).toString();
-};
-export const applySquidData = (parsed, raw) => {
-    const data = asRecord(raw);
-    parsed.destinationChainRef = asString(data.destinationChain);
-    parsed.receiver = asString(data.destinationAddress);
-    parsed.sourceToken = asString(data.depositAssetId);
-};
-export const polymerDataParam = {
-    name: 'polymerData',
-    kind: 'tuple',
-    components: [
-        { name: 'polymerTokenFee', kind: 'uint' },
-        { name: 'maxCCTPFee', kind: 'uint' },
-        { name: 'nonEVMReceiver', kind: 'bytes', size: 32 },
-        { name: 'solanaReceiverATA', kind: 'bytes', size: 32 },
-        { name: 'minFinalityThreshold', kind: 'uint' },
-        { name: 'refundRecipient', kind: 'address' },
-        { name: 'hookData', kind: 'bytes' },
-    ],
-};
-export const lifiIntentDataParam = {
-    name: 'lifiIntentData',
-    kind: 'tuple',
-    components: [
-        { name: 'dstCallReceiver', kind: 'bytes', size: 32 },
-        { name: 'recipient', kind: 'bytes', size: 32 },
-        { name: 'depositAndRefundAddress', kind: 'address' },
-        { name: 'nonce', kind: 'uint' },
-        { name: 'expires', kind: 'uint' },
-        { name: 'fillDeadline', kind: 'uint' },
-        { name: 'inputOracle', kind: 'address' },
-        { name: 'outputOracle', kind: 'bytes', size: 32 },
-        { name: 'outputSettler', kind: 'bytes', size: 32 },
-        { name: 'outputToken', kind: 'bytes', size: 32 },
-        { name: 'outputAmountMultiplier', kind: 'uint' },
-        { name: 'dstCallSwapData', kind: 'array', item: swapDataParam },
-        { name: 'outputContext', kind: 'bytes' },
-    ],
-};
-export const layerSwapDataParam = {
-    name: 'layerSwapData',
-    kind: 'tuple',
-    components: [
-        { name: 'requestId', kind: 'bytes', size: 32 },
-        { name: 'depositoryReceiver', kind: 'address' },
-        { name: 'refundRecipient', kind: 'address' },
-        { name: 'nonEVMReceiver', kind: 'bytes', size: 32 },
-        { name: 'signature', kind: 'bytes' },
-        { name: 'deadline', kind: 'uint' },
-    ],
-};
-export const applyPolymerData = (parsed, raw) => {
-    const data = asRecord(raw);
-    parsed.outputTokenReference = { protocol: 'cctp', destinationChainId: parsed.destinationChainId };
-    parsed.minOutputAmount = subtractFees(parsed.bridgeAmount ?? 0n, asBigint(data.polymerTokenFee), asBigint(data.maxCCTPFee));
-    if (asString(data.hookData) !== '0x') {
-        parsed.destinationCallData = asString(data.hookData);
-        delete parsed.receiver;
-        delete parsed.outputTokenReference;
-        delete parsed.minOutputAmount;
-    }
-};
-export const applyLifiIntentData = (parsed, raw) => {
-    const data = asRecord(raw);
-    parsed.receiver = accountFromBytes32(asString(data.recipient));
-    parsed.outputToken = accountFromBytes32(asString(data.outputToken));
-    parsed.minOutputAmount = (parsed.bridgeAmount ?? 0n) * asBigint(data.outputAmountMultiplier) / 10n ** 18n;
-    if (asArray(data.dstCallSwapData).length) {
-        parsed.hasDestinationCall = true;
-        parsed.bridgeReceiver = accountFromBytes32(asString(data.dstCallReceiver));
-        // An arbitrary dstCallReceiver is not proof of a genuine ReceiverOIF execution.
-        delete parsed.receiver;
-        delete parsed.outputToken;
-        delete parsed.minOutputAmount;
-    }
-    parsed.orderId = asBigint(data.nonce).toString(16).padStart(64, '0');
-    parsed.orderId = `0x${parsed.orderId}`;
-};
-export const celerCircleDataParam = {
-    name: 'celerCircleData',
-    kind: 'tuple',
-    components: [
-        { name: 'maxFee', kind: 'uint' },
-        { name: 'minFinalityThreshold', kind: 'uint' },
-    ],
-};
-const paxosRouteParam = {
-    name: 'route',
-    kind: 'tuple',
-    components: [
-        { name: 'destEID', kind: 'uint' },
-        { name: 'offerAsset', kind: 'address' },
-        { name: 'wantAsset', kind: 'address' },
-    ],
-};
-export const paxosDataParam = {
-    name: 'paxosData',
-    kind: 'tuple',
-    components: [
-        {
-            name: 'quote',
-            kind: 'tuple',
-            components: [
-                paxosRouteParam,
-                { name: 'offerAmount', kind: 'uint' },
-                { name: 'receiver', kind: 'address' },
-                { name: 'protocolFee', kind: 'uint' },
-                { name: 'integratorFee', kind: 'uint' },
-                { name: 'integratorFeeReceiver', kind: 'address' },
-                { name: 'distributorCode', kind: 'bytes', size: 32 },
-                { name: 'deadline', kind: 'uint' },
-                { name: 'salt', kind: 'bytes', size: 32 },
-            ],
-        },
-        { name: 'signature', kind: 'bytes' },
-        { name: 'nativeFee', kind: 'uint' },
-        { name: 'refundRecipient', kind: 'address' },
-    ],
-};
-export const applyPaxosData = (parsed, raw) => {
-    const quote = asRecord(asRecord(raw).quote);
-    const route = asRecord(quote.route);
-    parsed.destinationChainRef = `layerzero:${asBigint(route.destEID)}`;
-    parsed.destinationChainId = LAYERZERO_CHAINS[asBigint(route.destEID).toString()];
-    parsed.outputToken = asString(route.wantAsset);
-    const offerAmount = asBigint(quote.offerAmount);
-    parsed.minOutputAmount = subtractFees(offerAmount, asBigint(quote.protocolFee), asBigint(quote.integratorFee));
-    const receiver = asString(quote.receiver);
-    parsed.receiver = receiver;
-};
-export const applyLayerSwapData = (parsed, raw) => {
-    const data = asRecord(raw);
-    parsed.orderId = asString(data.requestId);
-    // The LayerSwap signature binds bridgeData.receiver to this request ID.
-};
-export const applyCelerCircleData = (parsed, raw) => {
-    parsed.outputTokenReference = { protocol: 'cctp', destinationChainId: parsed.destinationChainId };
-    parsed.outputAmountReference = {
-        kind: 'fees', amount: parsed.bridgeAmount ?? 0n,
-        token: parsed.outputTokenReference, maxFee: asBigint(asRecord(raw).maxFee),
-    };
-};

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

@@ -1,10 +0,0 @@
-import { knownCompare } from '../../expect.js';
-import { bridgeShape } from '../shape.js';
-import { lifiBridgeMethod } from '../method.js';
-import { applyPaxosData, paxosDataParam } from '../params.js';
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaPaxosTransit', '0x5080ffe2', [paxosDataParam], false, (parsed, args) => applyPaxosData(parsed, args.paxosData)),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaPaxosTransit', '0x637f1d04', [paxosDataParam], true, (parsed, args) => applyPaxosData(parsed, args.paxosData)),
-];
-export const compare = knownCompare;
-export const check = bridgeShape;

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

@@ -1,10 +0,0 @@
-import { knownCompare } from '../../expect.js';
-import { bridgeShape } from '../shape.js';
-import { lifiBridgeMethod } from '../method.js';
-import { applyPolymerData, polymerDataParam } from '../params.js';
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaPolymerCCTP', '0xf434d6ca', [polymerDataParam], false, (parsed, args) => applyPolymerData(parsed, args.polymerData)),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaPolymerCCTP', '0x17917a4e', [polymerDataParam], true, (parsed, args) => applyPolymerData(parsed, args.polymerData)),
-];
-export const compare = knownCompare;
-export const check = bridgeShape;

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

@@ -1,15 +0,0 @@
-import { bridgeShape } from '../shape.js';
-import { applyRelayDepositoryData, relayDepositoryDataParam } from '../params.js';
-import { lifiBridgeMethod } from '../method.js';
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaRelayDepository', '0x092e8fa4', [relayDepositoryDataParam], false, (parsed, args) => applyRelayDepositoryData(parsed, args.relayDepositoryData)),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaRelayDepository', '0xa3443faa', [relayDepositoryDataParam], true, (parsed, args) => applyRelayDepositoryData(parsed, args.relayDepositoryData)),
-];
-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/shape.d.ts

@@ -1,4 +0,0 @@
-import type { BridgeErrorDefinition } from '../../errors/index.js';
-import type { ParsedBridgeCall } from '../types.js';
-export declare const bridgeShape: (parsed: ParsedBridgeCall) => BridgeErrorDefinition | undefined;
-export declare const swapShape: (parsed: ParsedBridgeCall) => BridgeErrorDefinition | undefined;