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

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

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

@@ -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/polymer/index.js

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

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

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

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

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

package/dist/calldata/lifi/shape.js

@@ -0,0 +1,31 @@
+import { BRIDGE_ERRORS } from '../../errors/index.js';
+import { isZeroWord } from '../hex.js';
+export const bridgeShape = (parsed) => {
+    if (isZeroWord(parsed.receiver ?? parsed.bridgeReceiver)) {
+        return BRIDGE_ERRORS.MISSING_RECEIVER;
+    }
+    const hasDestination = (parsed.destinationChainId !== undefined && parsed.destinationChainId > 0n) ||
+        Boolean(parsed.destinationChainRef);
+    if (!hasDestination) {
+        return BRIDGE_ERRORS.MISSING_DESTINATION_CHAIN;
+    }
+    if (parsed.method.startsWith('swapAnd') && (parsed.sourceAmount ?? 0n) <= 0n) {
+        return BRIDGE_ERRORS.MISSING_SOURCE_AMOUNT;
+    }
+    if (parsed.sourceToken === undefined) {
+        return BRIDGE_ERRORS.MISSING_SOURCE_TOKEN;
+    }
+    return undefined;
+};
+export const swapShape = (parsed) => {
+    if (!parsed.receiver || isZeroWord(parsed.receiver)) {
+        return BRIDGE_ERRORS.MISSING_RECEIVER;
+    }
+    if (parsed.minOutputAmount === undefined) {
+        return BRIDGE_ERRORS.MISSING_MIN_OUTPUT;
+    }
+    if ((parsed.sourceAmount ?? 0n) <= 0n) {
+        return BRIDGE_ERRORS.MISSING_SOURCE_AMOUNT;
+    }
+    return undefined;
+};

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

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

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

@@ -0,0 +1,15 @@
+import { bridgeShape } from '../shape.js';
+import { applySquidData, squidDataParam } from '../params.js';
+import { lifiBridgeMethod } from '../method.js';
+export const methods = [
+    lifiBridgeMethod('startBridgeTokensViaSquid', '0x3f313808', [squidDataParam], false, (parsed, args) => applySquidData(parsed, args.squidData)),
+    lifiBridgeMethod('swapAndStartBridgeTokensViaSquid', '0xa8f66666', [squidDataParam], true, (parsed, args) => applySquidData(parsed, args.squidData)),
+];
+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/stargate/index.d.ts

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

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

@@ -0,0 +1,15 @@
+import { bridgeShape } from '../shape.js';
+import { applyStargateData, stargateDataParam } from '../params.js';
+import { lifiBridgeMethod } from '../method.js';
+export const methods = [
+    lifiBridgeMethod('startBridgeTokensViaStargate', '0x14d53077', [stargateDataParam], false, (parsed, args) => applyStargateData(parsed, args.stargateData)),
+    lifiBridgeMethod('swapAndStartBridgeTokensViaStargate', '0xa6010a66', [stargateDataParam], true, (parsed, args) => applyStargateData(parsed, args.stargateData)),
+];
+export const compare = () => ({
+    fromToken: true,
+    fromAmount: true,
+    toToken: false,
+    toAmount: true,
+    receiver: true,
+});
+export const check = bridgeShape;

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

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

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

@@ -0,0 +1,18 @@
+import { swapShape } from '../shape.js';
+import { lifiSwapMethod } from './swapMethod.js';
+export const methods = [
+    lifiSwapMethod('swapTokensSingleV3ERC20ToERC20', '0x4666fc80', false),
+    lifiSwapMethod('swapTokensSingleV3ERC20ToNative', '0x733214a3', false),
+    lifiSwapMethod('swapTokensSingleV3NativeToERC20', '0xaf7060fd', false),
+    lifiSwapMethod('swapTokensMultipleV3ERC20ToERC20', '0x5fd9ae2e', true),
+    lifiSwapMethod('swapTokensMultipleV3ERC20ToNative', '0x2c57e884', true),
+    lifiSwapMethod('swapTokensMultipleV3NativeToERC20', '0x736eac0b', true),
+];
+export const compare = () => ({
+    fromToken: true,
+    fromAmount: true,
+    toToken: true,
+    toAmount: true,
+    receiver: true,
+});
+export const check = swapShape;

package/dist/calldata/lifi/swap/swapMethod.d.ts

@@ -0,0 +1,2 @@
+import type { CalldataMethod } from '../../abi.js';
+export declare const lifiSwapMethod: (name: string, selector: string, multiple: boolean) => CalldataMethod;

package/dist/calldata/lifi/swap/swapMethod.js

@@ -0,0 +1,40 @@
+import { asArray, asBigint, asRecord, asString, decodeCall } from '../../abi.js';
+import { applyFirstSwap, swapDataArrayParam, swapDataParam } from '../swapData.js';
+const header = [
+    { name: 'transactionId', kind: 'bytes', size: 32 },
+    { name: 'integrator', kind: 'string' },
+    { name: 'referrer', kind: 'string' },
+    { name: 'receiver', kind: 'address' },
+    { name: 'minAmountOut', kind: 'uint' },
+];
+export const lifiSwapMethod = (name, selector, multiple) => ({
+    name,
+    selector,
+    decode(data, value) {
+        const args = decodeCall([...header, multiple ? swapDataArrayParam : swapDataParam], data);
+        const parsed = {
+            aggregatorId: 'lifi',
+            method: name,
+            kind: 'swap',
+            receiver: asString(args.receiver),
+            referrer: asString(args.referrer),
+            minOutputAmount: asBigint(args.minAmountOut),
+        };
+        if (multiple) {
+            applyFirstSwap(parsed, args.swapData);
+            const swaps = asArray(args.swapData).map(asRecord);
+            if (swaps.length)
+                parsed.outputToken = asString(swaps[swaps.length - 1].receivingAssetId);
+        }
+        else {
+            const swap = asRecord(args.swapData);
+            parsed.sourceToken = asString(swap.sendingAssetId);
+            parsed.sourceAmount = asBigint(swap.fromAmount);
+            parsed.outputToken = asString(swap.receivingAssetId);
+        }
+        if ((parsed.sourceAmount ?? 0n) === 0n && value > 0n) {
+            parsed.sourceAmount = value;
+        }
+        return parsed;
+    },
+});

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

@@ -0,0 +1,5 @@
+import { type AbiParam, type AbiValue } from '../abi.js';
+import type { ParsedBridgeCall } from '../types.js';
+export declare const swapDataArrayParam: AbiParam;
+export declare const swapDataParam: AbiParam;
+export declare const applyFirstSwap: (parsed: ParsedBridgeCall, raw: AbiValue) => void;

package/dist/calldata/lifi/swapData.js

@@ -0,0 +1,33 @@
+import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
+import { asArray, asBigint, asRecord, asString } from '../abi.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 swapDataArrayParam = {
+    name: 'swapData', kind: 'array',
+    item: { name: 'swap', kind: 'tuple', components: swapComponents },
+};
+export const swapDataParam = {
+    name: 'swapData', kind: 'tuple', components: swapComponents,
+};
+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);
+};

package/dist/calldata/match.d.ts

@@ -0,0 +1,3 @@
+import type { CalldataMethod } from './abi.js';
+import type { DecodeHit } from './types.js';
+export declare const matchMethod: (methods: CalldataMethod[], data: string, value: bigint) => DecodeHit;

package/dist/calldata/match.js

@@ -0,0 +1,21 @@
+import { BRIDGE_ERRORS, asBridgeError, bridgeFailure } from '../errors/index.js';
+import { readSelector } from './hex.js';
+import { resolveParsed } from './resolve.js';
+import { calldataDiagnostics } from './diagnostics.js';
+export const matchMethod = (methods, data, value) => {
+    const selector = readSelector(data);
+    const diagnostics = calldataDiagnostics(data);
+    if (!selector)
+        return bridgeFailure([{ ...(data && data !== '0x' ? BRIDGE_ERRORS.INVALID_SELECTOR : BRIDGE_ERRORS.MISSING_CALLDATA), ...diagnostics }]);
+    for (const method of methods) {
+        if (method.selector !== selector)
+            continue;
+        try {
+            return { ok: true, parsed: resolveParsed(method.decode(data, value)) };
+        }
+        catch (error) {
+            return { ...bridgeFailure(asBridgeError(error, BRIDGE_ERRORS.CALLDATA_DECODE_FAILED, { method: method.name, ...diagnostics }).errors), method: method.name };
+        }
+    }
+    return bridgeFailure([{ ...BRIDGE_ERRORS.UNSUPPORTED_METHOD, ...diagnostics }]);
+};

package/dist/calldata/mayan/destination.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedBridgeCall } from '../types.js';
+export declare const mayanDestination: (system: "cctp" | "wormhole", id: bigint, token?: string, normalizedAmount?: bigint) => Partial<ParsedBridgeCall>;

package/dist/calldata/mayan/destination.js

@@ -0,0 +1,13 @@
+import { CCTP_CHAINS, WORMHOLE_CHAINS } from '../protocols.js';
+export const mayanDestination = (system, id, token, normalizedAmount) => {
+    const destinationChainId = (system === 'cctp' ? CCTP_CHAINS : WORMHOLE_CHAINS)[id.toString()];
+    const destinationChainRef = `${system}:${id}`;
+    return {
+        destinationChainId, destinationChainRef,
+        outputToken: token,
+        outputAmountReference: token !== undefined && normalizedAmount !== undefined ? {
+            kind: 'normalized', amount: normalizedAmount, decimals: 8,
+            token: { protocol: 'token', token, destinationChainId, destinationChainRef },
+        } : undefined,
+    };
+};

package/dist/calldata/mayan/fastMctpBridge.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedBridgeCall } from '../types.js';
+export declare const FAST_MCTP_BRIDGE = "0xf58b6de8";
+export declare const decodeFastMctpBridge: (data: string, amountFloor?: bigint) => Partial<ParsedBridgeCall>;

package/dist/calldata/mayan/fastMctpBridge.js

@@ -0,0 +1,48 @@
+import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
+import { asBigint, asString, decodeCall } from '../abi.js';
+import { accountFromBytes32 } from '../hex.js';
+import { mayanDestination } from './destination.js';
+import { subtractFees } from '../protocols.js';
+export const FAST_MCTP_BRIDGE = '0xf58b6de8';
+export const decodeFastMctpBridge = (data, amountFloor) => {
+    const args = decodeCall([
+        { name: 'tokenIn', kind: 'address' },
+        { name: 'amountIn', kind: 'uint' },
+        { name: 'redeemFee', kind: 'uint' },
+        { name: 'circleMaxFee', kind: 'uint' },
+        { name: 'gasDrop', kind: 'uint' },
+        { name: 'destAddr', kind: 'bytes', size: 32 },
+        { name: 'destDomain', kind: 'uint' },
+        { name: 'referrerAddress', kind: 'bytes', size: 32 },
+        { name: 'referrerBps', kind: 'uint' },
+        { name: 'payloadType', kind: 'uint' },
+        { name: 'minFinalityThreshold', kind: 'uint' },
+        { name: 'customPayload', kind: 'bytes' },
+    ], data);
+    const destination = mayanDestination('cctp', asBigint(args.destDomain));
+    const token = { protocol: 'cctp', destinationChainId: destination.destinationChainId };
+    const payloadType = asBigint(args.payloadType);
+    if (payloadType !== 1n && payloadType !== 2n)
+        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_MAYAN_PROTOCOL_CALLDATA);
+    // FastMCTP.bridge hashes customPayload only for type 2; type 1 is a direct
+    // payout even when the unused bytes are nonempty (verified FastMCTP.sol).
+    const custom = payloadType === 2n;
+    const net = subtractFees(amountFloor ?? asBigint(args.amountIn), asBigint(args.redeemFee), asBigint(args.circleMaxFee));
+    const referrerBps = asBigint(args.referrerBps);
+    if (referrerBps > 100n)
+        throw new BridgeError(BRIDGE_ERRORS.INVALID_FASTMCTP_REFERRER_FEE);
+    // redeem caps the destination protocol fee at 100 bps; it is not fixed by the source deposit.
+    const minimum = net * (10000n - 100n - referrerBps) / 10000n;
+    return {
+        protocolMethod: 'bridge',
+        sourceToken: asString(args.tokenIn),
+        sourceAmount: asBigint(args.amountIn),
+        ...destination,
+        outputTokenReference: custom ? undefined : token,
+        minOutputAmount: custom ? undefined : minimum,
+        bridgeReceiver: accountFromBytes32(asString(args.destAddr)),
+        receiver: custom ? undefined : accountFromBytes32(asString(args.destAddr)),
+        destinationCallData: custom ? asString(args.customPayload) : undefined,
+        referrer: accountFromBytes32(asString(args.referrerAddress)),
+    };
+};

package/dist/calldata/mayan/fastMctpCreateOrder.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedBridgeCall } from '../types.js';
+export declare const FAST_MCTP_CREATE_ORDER = "0x2337e236";
+export declare const decodeFastMctpCreateOrder: (data: string) => Partial<ParsedBridgeCall>;

package/dist/calldata/mayan/fastMctpCreateOrder.js

@@ -0,0 +1,39 @@
+import { asBigint, asRecord, asString, decodeCall } from '../abi.js';
+import { accountFromBytes32 } from '../hex.js';
+import { mayanDestination } from './destination.js';
+const orderPayload = {
+    name: 'orderPayload',
+    kind: 'tuple',
+    components: [
+        { name: 'payloadType', kind: 'uint' },
+        { name: 'destAddr', kind: 'bytes', size: 32 },
+        { name: 'tokenOut', kind: 'bytes', size: 32 },
+        { name: 'amountOutMin', kind: 'uint' },
+        { name: 'gasDrop', kind: 'uint' },
+        { name: 'redeemFee', kind: 'uint' },
+        { name: 'refundFee', kind: 'uint' },
+        { name: 'deadline', kind: 'uint' },
+        { name: 'referrerAddr', kind: 'bytes', size: 32 },
+        { name: 'referrerBps', kind: 'uint' },
+    ],
+};
+export const FAST_MCTP_CREATE_ORDER = '0x2337e236';
+export const decodeFastMctpCreateOrder = (data) => {
+    const args = decodeCall([
+        { name: 'tokenIn', kind: 'address' },
+        { name: 'amountIn', kind: 'uint' },
+        { name: 'circleMaxFee', kind: 'uint' },
+        { name: 'destDomain', kind: 'uint' },
+        { name: 'minFinalityThreshold', kind: 'uint' },
+        orderPayload,
+    ], data);
+    const order = asRecord(args.orderPayload);
+    return {
+        protocolMethod: 'createOrder',
+        sourceToken: asString(args.tokenIn),
+        sourceAmount: asBigint(args.amountIn),
+        ...mayanDestination('cctp', asBigint(args.destDomain), accountFromBytes32(asString(order.tokenOut)), asBigint(order.amountOutMin)),
+        receiver: accountFromBytes32(asString(order.destAddr)),
+        referrer: accountFromBytes32(asString(order.referrerAddr)),
+    };
+};

package/dist/calldata/mayan/forward.d.ts

@@ -0,0 +1,8 @@
+import type { AbiParam } from '../abi.js';
+import type { ParsedBridgeCall } from '../types.js';
+export declare const permitParams: AbiParam;
+export declare const finishForward: (method: string, protocol: string, protocolData: string, source: {
+    token?: string;
+    amount?: bigint;
+    protocolAmount?: bigint;
+}) => ParsedBridgeCall;

package/dist/calldata/mayan/forward.js

@@ -0,0 +1,35 @@
+import { readMayanProtocol } from './readProtocol.js';
+import { innerCallDiagnostics } from '../diagnostics.js';
+export const permitParams = {
+    name: 'permitParams',
+    kind: 'tuple',
+    components: [
+        { name: 'value', kind: 'uint' },
+        { name: 'deadline', kind: 'uint' },
+        { name: 'v', kind: 'uint' },
+        { name: 'r', kind: 'bytes', size: 32 },
+        { name: 's', kind: 'bytes', size: 32 },
+    ],
+};
+export const finishForward = (method, protocol, protocolData, source) => {
+    const parsed = {
+        aggregatorId: 'mayan',
+        method,
+        kind: 'bridge',
+        innerTarget: protocol,
+        sourceToken: source.token,
+        sourceAmount: source.amount,
+        diagnostics: innerCallDiagnostics(protocolData, 'protocol'),
+    };
+    const order = readMayanProtocol(protocolData, source.protocolAmount ?? source.amount);
+    if (!order) {
+        return parsed;
+    }
+    const { sourceToken, sourceAmount, ...destination } = order;
+    Object.assign(parsed, destination);
+    parsed.sourceToken = parsed.sourceToken ?? order.sourceToken;
+    if ((parsed.sourceAmount ?? 0n) === 0n) {
+        parsed.sourceAmount = order.sourceAmount;
+    }
+    return parsed;
+};

package/dist/calldata/mayan/forwardERC20.d.ts

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

package/dist/calldata/mayan/forwardERC20.js

@@ -0,0 +1,19 @@
+import { asBigint, asString, decodeCall } from '../abi.js';
+import { finishForward, permitParams } from './forward.js';
+export const forwardERC20 = {
+    name: 'forwardERC20',
+    selector: '0xe4269fc4',
+    decode(data) {
+        const args = decodeCall([
+            { name: 'tokenIn', kind: 'address' },
+            { name: 'amountIn', kind: 'uint' },
+            permitParams,
+            { name: 'mayanProtocol', kind: 'address' },
+            { name: 'protocolData', kind: 'bytes' },
+        ], data);
+        return finishForward('forwardERC20', asString(args.mayanProtocol), asString(args.protocolData), {
+            token: asString(args.tokenIn),
+            amount: asBigint(args.amountIn),
+        });
+    },
+};

package/dist/calldata/mayan/forwardEth.d.ts

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

package/dist/calldata/mayan/forwardEth.js

@@ -0,0 +1,16 @@
+import { asString, decodeCall } from '../abi.js';
+import { finishForward } from './forward.js';
+export const forwardEth = {
+    name: 'forwardEth',
+    selector: '0xb0f584ff',
+    decode(data, value) {
+        const args = decodeCall([
+            { name: 'mayanProtocol', kind: 'address' },
+            { name: 'protocolData', kind: 'bytes' },
+        ], data);
+        return finishForward('forwardEth', asString(args.mayanProtocol), asString(args.protocolData), {
+            token: '0x0000000000000000000000000000000000000000',
+            amount: value,
+        });
+    },
+};

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

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

package/dist/calldata/mayan/index.js

@@ -0,0 +1,21 @@
+import { matchMethod } from '../match.js';
+import { finishCheck, knownCompare } from '../expect.js';
+import { forwardERC20 } from './forwardERC20.js';
+import { forwardEth } from './forwardEth.js';
+import { swapAndForwardERC20 } from './swapAndForwardERC20.js';
+import { swapAndForwardEth } from './swapAndForwardEth.js';
+import { mayanFailure } from './validate.js';
+const METHODS = [
+    forwardERC20,
+    forwardEth,
+    swapAndForwardERC20,
+    swapAndForwardEth,
+];
+export const decodeMayan = (data, value) => matchMethod(METHODS, data, value);
+export const validateMayan = (data, value, expectation, chainId = '') => {
+    const hit = decodeMayan(data, value);
+    if (!hit.ok) {
+        return { ...hit, aggregatorId: 'mayan' };
+    }
+    return finishCheck('mayan', hit.parsed, mayanFailure(hit.parsed), expectation, chainId, knownCompare(hit.parsed));
+};

package/dist/calldata/mayan/mctp.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedBridgeCall } from '../types.js';
+export declare const MCTP_BRIDGE_WITH_FEE = "0x2072197f";
+export declare const MCTP_CREATE_ORDER = "0x1c59b7fc";
+export declare const decodeMctpBridge: (data: string, amountFloor?: bigint) => Partial<ParsedBridgeCall>;
+export declare const decodeMctpOrder: (data: string) => Partial<ParsedBridgeCall>;

package/dist/calldata/mayan/mctp.js

@@ -0,0 +1,41 @@
+import { asBigint, asRecord, asString, decodeCall } from '../abi.js';
+import { accountFromBytes32 } from '../hex.js';
+import { subtractFees } from '../protocols.js';
+import { mayanDestination } from './destination.js';
+export const MCTP_BRIDGE_WITH_FEE = '0x2072197f';
+export const MCTP_CREATE_ORDER = '0x1c59b7fc';
+export const decodeMctpBridge = (data, amountFloor) => {
+    const a = decodeCall([
+        { name: 'tokenIn', kind: 'address' }, { name: 'amountIn', kind: 'uint' },
+        { name: 'redeemFee', kind: 'uint' }, { name: 'gasDrop', kind: 'uint' },
+        { name: 'destAddr', kind: 'bytes', size: 32 }, { name: 'destDomain', kind: 'uint' },
+        { name: 'payloadType', kind: 'uint' }, { name: 'customPayload', kind: 'bytes' },
+    ], data);
+    const destination = mayanDestination('cctp', asBigint(a.destDomain));
+    const custom = asString(a.customPayload) !== '0x';
+    return {
+        protocolMethod: 'bridgeWithFee', ...destination,
+        sourceToken: asString(a.tokenIn), sourceAmount: asBigint(a.amountIn),
+        bridgeReceiver: accountFromBytes32(asString(a.destAddr)),
+        receiver: custom ? undefined : accountFromBytes32(asString(a.destAddr)),
+        outputTokenReference: custom ? undefined : { protocol: 'cctp', destinationChainId: destination.destinationChainId },
+        minOutputAmount: custom ? undefined : subtractFees(amountFloor ?? asBigint(a.amountIn), asBigint(a.redeemFee)),
+        destinationCallData: custom ? asString(a.customPayload) : undefined,
+    };
+};
+const order = { name: 'params', kind: 'tuple', components: [
+        { name: 'tokenIn', kind: 'address' }, { name: 'amountIn', kind: 'uint' },
+        { name: 'gasDrop', kind: 'uint' }, { name: 'destAddr', kind: 'bytes', size: 32 },
+        { name: 'destChain', kind: 'uint' }, { name: 'tokenOut', kind: 'bytes', size: 32 },
+        { name: 'minAmountOut', kind: 'uint' }, { name: 'deadline', kind: 'uint' },
+        { name: 'redeemFee', kind: 'uint' }, { name: 'referrerAddr', kind: 'bytes', size: 32 },
+        { name: 'referrerBps', kind: 'uint' },
+    ] };
+export const decodeMctpOrder = (data) => {
+    const a = asRecord(decodeCall([order], data).params);
+    return {
+        protocolMethod: 'createOrder', sourceToken: asString(a.tokenIn), sourceAmount: asBigint(a.amountIn),
+        ...mayanDestination('wormhole', asBigint(a.destChain), accountFromBytes32(asString(a.tokenOut)), asBigint(a.minAmountOut)),
+        receiver: accountFromBytes32(asString(a.destAddr)), referrer: accountFromBytes32(asString(a.referrerAddr)),
+    };
+};

package/dist/calldata/mayan/readProtocol.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedBridgeCall } from '../types.js';
+export declare const readMayanProtocol: (protocolData: string, amountFloor?: bigint) => Partial<ParsedBridgeCall> | undefined;

package/dist/calldata/mayan/readProtocol.js

@@ -0,0 +1,29 @@
+import { BRIDGE_ERRORS, asBridgeError } from '../../errors/index.js';
+import { readSelector } from '../hex.js';
+import { innerCallDiagnostics } from '../diagnostics.js';
+import { FAST_MCTP_BRIDGE, decodeFastMctpBridge } from './fastMctpBridge.js';
+import { FAST_MCTP_CREATE_ORDER, decodeFastMctpCreateOrder } from './fastMctpCreateOrder.js';
+import { SWIFT_CREATE_ORDER, decodeSwiftCreateOrder } from './swiftCreateOrder.js';
+import { decodeMctpBridge, decodeMctpOrder, MCTP_BRIDGE_WITH_FEE, MCTP_CREATE_ORDER } from './mctp.js';
+export const readMayanProtocol = (protocolData, amountFloor) => {
+    const selector = readSelector(protocolData);
+    try {
+        if (selector === SWIFT_CREATE_ORDER) {
+            return decodeSwiftCreateOrder(protocolData);
+        }
+        if (selector === FAST_MCTP_CREATE_ORDER) {
+            return decodeFastMctpCreateOrder(protocolData);
+        }
+        if (selector === FAST_MCTP_BRIDGE) {
+            return decodeFastMctpBridge(protocolData, amountFloor);
+        }
+        if (selector === MCTP_BRIDGE_WITH_FEE)
+            return decodeMctpBridge(protocolData, amountFloor);
+        if (selector === MCTP_CREATE_ORDER)
+            return decodeMctpOrder(protocolData);
+    }
+    catch (error) {
+        throw asBridgeError(error, BRIDGE_ERRORS.CALLDATA_DECODE_FAILED, innerCallDiagnostics(protocolData, 'protocol'));
+    }
+    return undefined;
+};

package/dist/calldata/mayan/swapAndForwardERC20.d.ts

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

package/dist/calldata/mayan/swapAndForwardERC20.js

@@ -0,0 +1,24 @@
+import { asBigint, asString, decodeCall } from '../abi.js';
+import { finishForward, permitParams } from './forward.js';
+export const swapAndForwardERC20 = {
+    name: 'swapAndForwardERC20',
+    selector: '0x30dedc57',
+    decode(data) {
+        const args = decodeCall([
+            { name: 'tokenIn', kind: 'address' },
+            { name: 'amountIn', kind: 'uint' },
+            permitParams,
+            { name: 'swapProtocol', kind: 'address' },
+            { name: 'swapData', kind: 'bytes' },
+            { name: 'middleToken', kind: 'address' },
+            { name: 'minMiddleAmount', kind: 'uint' },
+            { name: 'mayanProtocol', kind: 'address' },
+            { name: 'mayanData', kind: 'bytes' },
+        ], data);
+        return finishForward('swapAndForwardERC20', asString(args.mayanProtocol), asString(args.mayanData), {
+            token: asString(args.tokenIn),
+            amount: asBigint(args.amountIn),
+            protocolAmount: asBigint(args.minMiddleAmount),
+        });
+    },
+};