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

package/dist/calldata/lifi/shape.js

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

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

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

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

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

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

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

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

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

@@ -1,40 +0,0 @@
-import { asArray, asBigint, asRecord, asString, decodeCall } from '../../abi.js';
-import { applyFirstSwap, swapDataArrayParam, swapDataParam } from '../params.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/match.d.ts

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

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

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

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

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

@@ -1,43 +0,0 @@
-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 custom = asString(args.customPayload) !== '0x';
-    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

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

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

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

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

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

package/dist/calldata/mayan/forwardERC20.js

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

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

package/dist/calldata/mayan/forwardEth.js

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

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

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

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

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

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

package/dist/calldata/mayan/readProtocol.js

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

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

package/dist/calldata/mayan/swapAndForwardERC20.js

@@ -1,24 +0,0 @@
-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),
-        });
-    },
-};

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

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

package/dist/calldata/mayan/swapAndForwardEth.js

@@ -1,23 +0,0 @@
-import { asBigint, asString, decodeCall } from '../abi.js';
-import { finishForward } from './forward.js';
-export const swapAndForwardEth = {
-    name: 'swapAndForwardEth',
-    selector: '0xfa74fd43',
-    decode(data, value) {
-        const args = decodeCall([
-            { name: 'amountIn', kind: 'uint' },
-            { 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);
-        const amount = asBigint(args.amountIn);
-        return finishForward('swapAndForwardEth', asString(args.mayanProtocol), asString(args.mayanData), {
-            token: '0x0000000000000000000000000000000000000000',
-            amount: amount > 0n ? amount : value,
-            protocolAmount: asBigint(args.minMiddleAmount),
-        });
-    },
-};

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

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

package/dist/calldata/mayan/swiftCreateOrder.js

@@ -1,49 +0,0 @@
-import { asBigint, asRecord, asString, decodeCall } from '../abi.js';
-import { accountFromBytes32 } from '../hex.js';
-import { mayanDestination } from './destination.js';
-const params = {
-    name: 'params',
-    kind: 'tuple',
-    components: [
-        { name: 'payloadType', kind: 'uint' },
-        { name: 'trader', kind: 'bytes', size: 32 },
-        { name: 'destAddr', kind: 'bytes', size: 32 },
-        { name: 'destChainId', kind: 'uint' },
-        { name: 'referrerAddr', kind: 'bytes', size: 32 },
-        { name: 'tokenOut', kind: 'bytes', size: 32 },
-        { name: 'minAmountOut', kind: 'uint' },
-        { name: 'gasDrop', kind: 'uint' },
-        { name: 'cancelFee', kind: 'uint' },
-        { name: 'refundFee', kind: 'uint' },
-        { name: 'deadline', kind: 'uint' },
-        { name: 'referrerBps', kind: 'uint' },
-        { name: 'auctionMode', kind: 'uint' },
-        { name: 'random', kind: 'bytes', size: 32 },
-    ],
-};
-export const SWIFT_CREATE_ORDER = '0xa3a30834';
-export const decodeSwiftCreateOrder = (data) => {
-    const args = decodeCall([
-        { name: 'tokenIn', kind: 'address' },
-        { name: 'amountIn', kind: 'uint' },
-        params,
-        { name: 'customPayload', kind: 'bytes' },
-    ], data);
-    const order = asRecord(args.params);
-    const customPayload = asString(args.customPayload);
-    const destination = mayanDestination('wormhole', asBigint(order.destChainId), accountFromBytes32(asString(order.tokenOut)), asBigint(order.minAmountOut));
-    if (customPayload !== '0x') {
-        delete destination.outputToken;
-        delete destination.outputAmountReference;
-    }
-    return {
-        protocolMethod: 'createOrderWithToken',
-        sourceToken: asString(args.tokenIn),
-        sourceAmount: asBigint(args.amountIn),
-        ...destination,
-        bridgeReceiver: accountFromBytes32(asString(order.destAddr)),
-        receiver: customPayload === '0x' ? accountFromBytes32(asString(order.destAddr)) : undefined,
-        destinationCallData: customPayload === '0x' ? undefined : customPayload,
-        referrer: accountFromBytes32(asString(order.referrerAddr)),
-    };
-};

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

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

package/dist/calldata/mayan/validate.js

@@ -1,20 +0,0 @@
-import { BRIDGE_ERRORS } from '../../errors/index.js';
-import { isZeroWord } from '../hex.js';
-export const mayanFailure = (parsed) => {
-    if (!parsed.protocolMethod) {
-        return BRIDGE_ERRORS.UNRECOGNIZED_MAYAN_PROTOCOL_CALLDATA;
-    }
-    if (parsed.destinationChainId === undefined && !parsed.destinationChainRef) {
-        return BRIDGE_ERRORS.MISSING_DESTINATION;
-    }
-    if (isZeroWord(parsed.receiver ?? parsed.bridgeReceiver)) {
-        return BRIDGE_ERRORS.MISSING_RECEIVER;
-    }
-    if ((parsed.sourceAmount ?? 0n) <= 0n) {
-        return BRIDGE_ERRORS.MISSING_SOURCE_AMOUNT;
-    }
-    if (parsed.protocolMethod !== 'bridge' && parsed.outputToken === undefined && !parsed.outputTokenReference && !parsed.destinationCallData) {
-        return BRIDGE_ERRORS.MISSING_OUTPUT_TOKEN;
-    }
-    return undefined;
-};