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

package/dist/calldata/lifi/index.js

@@ -0,0 +1,62 @@
+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';
+import { isNative } from '../protocols.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, hit.parsed.method.endsWith('ViaLayerSwap') && value !== (isNative(hit.parsed.sourceToken ?? '') ? hit.parsed.sourceAmount : 0n)
+        ? BRIDGE_ERRORS.LAYERSWAP_SOURCE_VALUE_MISMATCH : route.check(hit.parsed), expectation, chainId, route.compare(hit.parsed));
+};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,28 @@
+import { type AbiParam, type AbiValue } from '../abi.js';
+import type { ParsedBridgeCall } from '../types.js';
+export { applyFirstSwap, swapDataArrayParam, swapDataParam } from './swapData.js';
+export declare const bridgeDataParam: 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 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

@@ -0,0 +1,349 @@
+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';
+import { readLifiDestination } from './destination.js';
+import { swapDataParam } from './swapData.js';
+export { applyFirstSwap, swapDataArrayParam, swapDataParam } from './swapData.js';
+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 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 applyAcrossData = (parsed, raw) => {
+    const data = asRecord(raw);
+    parsed.refundRecipients = [accountFromBytes32(asString(data.refundAddress))];
+    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.refundRecipients = [asString(data.depositAndRefundAddress)];
+    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) {
+        const destination = readLifiDestination(parsed, data);
+        parsed.hasDestinationCall = true;
+        parsed.bridgeReceiver = accountFromBytes32(asString(data.dstCallReceiver));
+        parsed.bridgeOutputToken = parsed.outputToken;
+        parsed.bridgeOutputAmount = parsed.minOutputAmount;
+        delete parsed.receiver;
+        delete parsed.outputToken;
+        delete parsed.minOutputAmount;
+        // Unknown deployments and arbitrary calls remain unverified.
+        if (destination)
+            Object.assign(parsed, destination);
+    }
+    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);
+    if (asString(data.refundRecipient) !== parsed.receiver)
+        throw new BridgeError(BRIDGE_ERRORS.LAYERSWAP_REFUND_RECIPIENT_MISMATCH);
+    if (!/^0x0*$/.test(asString(data.nonEVMReceiver)))
+        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_LAYERSWAP_NON_EVM_RECEIVER);
+    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

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