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

package/dist/calldata/mayan/fastMctpBridge.js

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

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

package/dist/calldata/protocols.d.ts

@@ -1,9 +0,0 @@
-export declare const NATIVE_TOKEN = "0x0000000000000000000000000000000000000000";
-export declare const WRAPPED_NATIVE_TOKENS: Record<string, string>;
-export declare const isNative: (token: string) => boolean;
-export declare const CCTP_CHAINS: Record<string, bigint>;
-export declare const WORMHOLE_CHAINS: Record<string, bigint>;
-export declare const LAYERZERO_CHAINS: Record<string, bigint>;
-export declare const CCIP_CHAINS: Record<string, bigint>;
-export declare const CCTP_USDC: Record<string, string>;
-export declare const subtractFees: (amount: bigint, ...fees: bigint[]) => bigint;

package/dist/calldata/protocols.js

@@ -1,57 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../errors/index.js';
-export const NATIVE_TOKEN = '0x0000000000000000000000000000000000000000';
-export const WRAPPED_NATIVE_TOKENS = {
-    1: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
-    10: '0x4200000000000000000000000000000000000006',
-    56: '0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c',
-    130: '0x4200000000000000000000000000000000000006',
-    137: '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270',
-    4663: '0x0bd7d308f8e1639fab988df18a8011f41eacad73',
-    8453: '0x4200000000000000000000000000000000000006',
-    42161: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1',
-    43114: '0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7',
-    57073: '0x4200000000000000000000000000000000000006',
-};
-export const isNative = (token) => token === NATIVE_TOKEN || token.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
-// Circle CCTP domains and Wormhole IDs are different namespaces from EVM chain IDs.
-export const CCTP_CHAINS = {
-    0: 1n, 1: 43114n, 2: 10n, 3: 42161n, 6: 8453n, 7: 137n,
-    10: 130n, 11: 59144n, 13: 146n, 15: 143n, 19: 999n,
-};
-export const WORMHOLE_CHAINS = {
-    2: 1n, 4: 56n, 5: 137n, 6: 43114n, 23: 42161n, 24: 10n,
-    30: 8453n, 38: 59144n, 44: 130n, 47: 999n, 48: 143n, 52: 146n,
-};
-// Mainnet endpoint IDs from LayerZero's network metadata; v1 and v2 IDs coexist.
-export const LAYERZERO_CHAINS = {
-    101: 1n, 30101: 1n, 102: 56n, 30102: 56n, 106: 43114n, 30106: 43114n,
-    109: 137n, 30109: 137n, 110: 42161n, 30110: 42161n, 111: 10n, 30111: 10n,
-    184: 8453n, 30184: 8453n, 183: 59144n, 30183: 59144n, 181: 5000n, 30181: 5000n,
-    320: 130n, 30320: 130n, 332: 146n, 30332: 146n, 340: 1868n, 30340: 1868n,
-    367: 999n, 30367: 999n, 370: 98866n, 30370: 98866n, 383: 9745n, 30383: 9745n,
-    390: 143n, 30390: 143n, 416: 4663n, 30416: 4663n,
-    255: 252n, 30255: 252n, 280: 1329n, 30280: 1329n,
-};
-export const CCIP_CHAINS = {
-    '5009297550715157269': 1n, '15971525489660198786': 8453n, '11344663589394136015': 56n,
-};
-// Canonical Circle USDC, not a symbol-based or quote-provided token mapping.
-export const CCTP_USDC = {
-    1: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-    10: '0x0b2c639c533813f4aa9d7837caf62653d097ff85',
-    137: '0x3c499c542cef5e3811e1192ce70d8cc03d5c3359',
-    8453: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
-    42161: '0xaf88d065e77c8cc2239327c5edb3a432268e5831',
-    43114: '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
-    130: '0x078d782b760474a361dda0af3839290b0ef57ad6',
-    143: '0x754704bc059f8c67012fed69bc8a327a5aafb603',
-    146: '0x29219dd400f2bf60e5a23d13be72b486d4038894',
-    999: '0xb88339cb7199b77e23db6e890353e22632ba630f',
-    59144: '0x176211869ca2b568f2a7d4ee941e073a821ee1ff',
-};
-export const subtractFees = (amount, ...fees) => {
-    const total = fees.reduce((sum, fee) => sum + fee, 0n);
-    if (total > amount)
-        throw new BridgeError(BRIDGE_ERRORS.BRIDGE_FEES_EXCEED_THE_INPUT_AMOUNT);
-    return amount - total;
-};

package/dist/calldata/relay/calls.d.ts

@@ -1,13 +0,0 @@
-import { type AbiParam, type AbiValue } from '../abi.js';
-import type { ParsedBridgeCall } from '../types.js';
-export declare const callTuple: AbiParam;
-export declare const callsParam: AbiParam;
-export declare const requestIdFromMetadata: (metadata: string) => string | undefined;
-export declare const relayCall: (method: string, metadata: string, value: bigint, source?: {
-    token?: string;
-    amount?: bigint;
-}) => ParsedBridgeCall;
-export declare const firstPositive: (values: AbiValue[]) => {
-    token?: string;
-    amount: bigint;
-};

package/dist/calldata/relay/calls.js

@@ -1,54 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
-import { asBigint, asRecord, asString } from '../abi.js';
-import { isZeroWord } from '../hex.js';
-import { NATIVE_TOKEN } from '../protocols.js';
-export const callTuple = {
-    name: 'call',
-    kind: 'tuple',
-    components: [
-        { name: 'target', kind: 'address' },
-        { name: 'allowFailure', kind: 'bool' },
-        { name: 'value', kind: 'uint' },
-        { name: 'callData', kind: 'bytes' },
-    ],
-};
-export const callsParam = {
-    name: 'calls',
-    kind: 'array',
-    item: callTuple,
-};
-export const requestIdFromMetadata = (metadata) => {
-    const body = metadata.toLowerCase().replace(/^0x/, '');
-    if (body.length < 64) {
-        return undefined;
-    }
-    const requestId = `0x${body.slice(0, 64)}`;
-    return isZeroWord(requestId) ? undefined : requestId;
-};
-export const relayCall = (method, metadata, value, source) => ({
-    aggregatorId: 'relay',
-    method,
-    kind: 'deposit',
-    requestId: requestIdFromMetadata(metadata),
-    sourceToken: source?.token ?? (value > 0n ? NATIVE_TOKEN : undefined),
-    sourceAmount: source?.amount && source.amount > 0n ? source.amount : value,
-});
-const amountOf = (record) => {
-    const amount = record.amount ?? record.value;
-    return asBigint(amount);
-};
-export const firstPositive = (values) => {
-    let amount = 0n;
-    let token;
-    for (const value of values) {
-        const record = asRecord(value);
-        amount += amountOf(record);
-        if (record.token) {
-            const current = asString(record.token);
-            if (token && token !== current)
-                throw new BridgeError(BRIDGE_ERRORS.MULTIPLE_SOURCE_ASSETS_ARE_NOT_SUPPORTED);
-            token = current;
-        }
-    }
-    return { token, amount };
-};

package/dist/calldata/relay/depositErc20.d.ts

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

package/dist/calldata/relay/depositErc20.js

@@ -1,22 +0,0 @@
-import { asBigint, asString, decodeCall } from '../abi.js';
-export const depositErc20 = {
-    name: 'depositErc20',
-    selector: '0xe8017952',
-    decode(data) {
-        const args = decodeCall([
-            { name: 'depositor', kind: 'address' },
-            { name: 'token', kind: 'address' },
-            { name: 'amount', kind: 'uint' },
-            { name: 'id', kind: 'bytes', size: 32 },
-        ], data);
-        return {
-            aggregatorId: 'relay',
-            method: 'depositErc20',
-            kind: 'deposit',
-            sourceToken: asString(args.token),
-            sourceAmount: asBigint(args.amount),
-            orderId: asString(args.id),
-            depositor: asString(args.depositor),
-        };
-    },
-};

package/dist/calldata/relay/depositErc20Allowance.d.ts

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

package/dist/calldata/relay/depositErc20Allowance.js

@@ -1,20 +0,0 @@
-import { asString, decodeCall } from '../abi.js';
-export const depositErc20Allowance = {
-    name: 'depositErc20Allowance',
-    selector: '0x5a1ee3ac',
-    decode(data) {
-        const args = decodeCall([
-            { name: 'depositor', kind: 'address' },
-            { name: 'token', kind: 'address' },
-            { name: 'id', kind: 'bytes', size: 32 },
-        ], data);
-        return {
-            aggregatorId: 'relay',
-            method: 'depositErc20Allowance',
-            kind: 'deposit',
-            sourceToken: asString(args.token),
-            orderId: asString(args.id),
-            depositor: asString(args.depositor),
-        };
-    },
-};

package/dist/calldata/relay/depositNative.d.ts

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