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

package/dist/calldata/relay/depositNative.js

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

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

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

package/dist/calldata/relay/index.js

@@ -1,42 +0,0 @@
-import { matchMethod } from '../match.js';
-import { finishCheck } from '../expect.js';
-import { depositErc20 } from './depositErc20.js';
-import { depositErc20Allowance } from './depositErc20Allowance.js';
-import { depositNative } from './depositNative.js';
-import { multicall } from './multicall.js';
-import { permit2TransferAndMulticall } from './permit2TransferAndMulticall.js';
-import { permit3009TransferAndMulticall } from './permit3009TransferAndMulticall.js';
-import { permit3009TransferAndMulticallSigned } from './permit3009TransferAndMulticallSigned.js';
-import { permitTransferAndMulticall } from './permitTransferAndMulticall.js';
-import { permitTransferAndMulticallLegacy } from './permitTransferAndMulticallLegacy.js';
-import { transferAndMulticall } from './transferAndMulticall.js';
-import { relayFailure } from './validate.js';
-import { BRIDGE_ERRORS } from '../../errors/index.js';
-const METHODS = [
-    depositErc20,
-    depositErc20Allowance,
-    depositNative,
-    multicall,
-    transferAndMulticall,
-    permit2TransferAndMulticall,
-    permit3009TransferAndMulticall,
-    permit3009TransferAndMulticallSigned,
-    permitTransferAndMulticall,
-    permitTransferAndMulticallLegacy,
-];
-export const decodeRelay = (data, value) => matchMethod(METHODS, data, value);
-const relayCompareMask = (parsed) => ({
-    fromToken: parsed.sourceToken !== undefined,
-    fromAmount: parsed.sourceAmount !== undefined && parsed.sourceToken !== undefined,
-    toToken: false,
-    toAmount: false,
-    receiver: false,
-});
-export const validateRelay = (data, value, expectation, chainId = '') => {
-    const hit = decodeRelay(data, value);
-    if (!hit.ok) {
-        return { ...hit, aggregatorId: 'relay' };
-    }
-    return finishCheck('relay', hit.parsed, expectation && hit.parsed.depositor !== undefined && hit.parsed.depositor !== expectation.userAddress.toLowerCase()
-        ? BRIDGE_ERRORS.DEPOSITOR_MISMATCH : relayFailure(hit.parsed), expectation, chainId, relayCompareMask(hit.parsed));
-};

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

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

package/dist/calldata/relay/multicall.js

@@ -1,15 +0,0 @@
-import { asString, decodeCall } from '../abi.js';
-import { callsParam, relayCall } from './calls.js';
-export const multicall = {
-    name: 'multicall',
-    selector: '0xcd6e13f7',
-    decode(data, value) {
-        const args = decodeCall([
-            callsParam,
-            { name: 'refundTo', kind: 'address' },
-            { name: 'nftRecipient', kind: 'address' },
-            { name: 'metadata', kind: 'bytes' },
-        ], data);
-        return relayCall('multicall', asString(args.metadata), value);
-    },
-};

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

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

package/dist/calldata/relay/permit2TransferAndMulticall.js

@@ -1,42 +0,0 @@
-import { asArray, asRecord, asString, decodeCall } from '../abi.js';
-import { callsParam, firstPositive, relayCall } from './calls.js';
-const permit = {
-    name: 'permit',
-    kind: 'tuple',
-    components: [
-        {
-            name: 'permitted',
-            kind: 'array',
-            item: {
-                name: 'tokenPermissions',
-                kind: 'tuple',
-                components: [
-                    { name: 'token', kind: 'address' },
-                    { name: 'amount', kind: 'uint' },
-                ],
-            },
-        },
-        { name: 'nonce', kind: 'uint' },
-        { name: 'deadline', kind: 'uint' },
-    ],
-};
-export const permit2TransferAndMulticall = {
-    name: 'permit2TransferAndMulticall',
-    selector: '0x0a2b8f36',
-    decode(data, value) {
-        const args = decodeCall([
-            { name: 'user', kind: 'address' },
-            permit,
-            callsParam,
-            { name: 'refundTo', kind: 'address' },
-            { name: 'nftRecipient', kind: 'address' },
-            { name: 'metadata', kind: 'bytes' },
-            { name: 'permitSignature', kind: 'bytes' },
-        ], data);
-        const source = firstPositive(asArray(asRecord(args.permit).permitted));
-        return {
-            ...relayCall('permit2TransferAndMulticall', asString(args.metadata), value, source),
-            depositor: asString(args.user),
-        };
-    },
-};

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

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

package/dist/calldata/relay/permit3009TransferAndMulticall.js

@@ -1,41 +0,0 @@
-import { asArray, asString, decodeCall } from '../abi.js';
-import { callsParam, firstPositive, relayCall } from './calls.js';
-const permits = {
-    name: 'permits',
-    kind: 'array',
-    item: {
-        name: 'permit',
-        kind: 'tuple',
-        components: [
-            { name: 'from', kind: 'address' },
-            { name: 'value', kind: 'uint' },
-            { name: 'validAfter', kind: 'uint' },
-            { name: 'validBefore', kind: 'uint' },
-            { name: 'v', kind: 'uint' },
-            { name: 'r', kind: 'bytes', size: 32 },
-            { name: 's', kind: 'bytes', size: 32 },
-        ],
-    },
-};
-const decodePermits = (name, selector, tail) => ({
-    name,
-    selector,
-    decode(data, value) {
-        const args = decodeCall([
-            permits,
-            { name: 'tokens', kind: 'array', item: { name: 'token', kind: 'address' } },
-            callsParam,
-            { name: 'refundTo', kind: 'address' },
-            { name: 'nftRecipient', kind: 'address' },
-            { name: 'metadata', kind: 'bytes' },
-            ...tail,
-        ], data);
-        const source = firstPositive(asArray(args.permits));
-        const tokens = asArray(args.tokens).map((token) => asString(token));
-        return relayCall(name, asString(args.metadata), value, {
-            token: tokens[0] ?? source.token,
-            amount: source.amount,
-        });
-    },
-});
-export const permit3009TransferAndMulticall = decodePermits('permit3009TransferAndMulticall', '0xf80f00fb', []);

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

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

package/dist/calldata/relay/permit3009TransferAndMulticallSigned.js

@@ -1,40 +0,0 @@
-import { asArray, asString, decodeCall } from '../abi.js';
-import { callsParam, firstPositive, relayCall } from './calls.js';
-const permits = {
-    name: 'permits',
-    kind: 'array',
-    item: {
-        name: 'permit',
-        kind: 'tuple',
-        components: [
-            { name: 'from', kind: 'address' },
-            { name: 'value', kind: 'uint' },
-            { name: 'validAfter', kind: 'uint' },
-            { name: 'validBefore', kind: 'uint' },
-            { name: 'v', kind: 'uint' },
-            { name: 'r', kind: 'bytes', size: 32 },
-            { name: 's', kind: 'bytes', size: 32 },
-        ],
-    },
-};
-export const permit3009TransferAndMulticallSigned = {
-    name: 'permit3009TransferAndMulticallSigned',
-    selector: '0x745599f3',
-    decode(data, value) {
-        const args = decodeCall([
-            permits,
-            { name: 'tokens', kind: 'array', item: { name: 'token', kind: 'address' } },
-            callsParam,
-            { name: 'refundTo', kind: 'address' },
-            { name: 'nftRecipient', kind: 'address' },
-            { name: 'metadata', kind: 'bytes' },
-            { name: 'multicallSignatures', kind: 'array', item: { name: 'signature', kind: 'bytes' } },
-        ], data);
-        const source = firstPositive(asArray(args.permits));
-        const tokens = asArray(args.tokens).map((token) => asString(token));
-        return relayCall('permit3009TransferAndMulticallSigned', asString(args.metadata), value, {
-            token: tokens[0] ?? source.token,
-            amount: source.amount,
-        });
-    },
-};

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

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

package/dist/calldata/relay/permitTransferAndMulticall.js

@@ -1,34 +0,0 @@
-import { asArray, asString, decodeCall } from '../abi.js';
-import { callsParam, firstPositive, relayCall } from './calls.js';
-const permits = {
-    name: 'permits',
-    kind: 'array',
-    item: {
-        name: 'permit',
-        kind: 'tuple',
-        components: [
-            { name: 'token', kind: 'address' },
-            { name: 'owner', kind: 'address' },
-            { 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 permitTransferAndMulticall = {
-    name: 'permitTransferAndMulticall',
-    selector: '0xbd4967a9',
-    decode(data, value) {
-        const args = decodeCall([
-            permits,
-            callsParam,
-            { name: 'refundTo', kind: 'address' },
-            { name: 'nftRecipient', kind: 'address' },
-            { name: 'metadata', kind: 'bytes' },
-        ], data);
-        const source = firstPositive(asArray(args.permits));
-        return relayCall('permitTransferAndMulticall', asString(args.metadata), value, source);
-    },
-};

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

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

package/dist/calldata/relay/permitTransferAndMulticallLegacy.js

@@ -1,35 +0,0 @@
-import { asArray, asString, decodeCall } from '../abi.js';
-import { callsParam, firstPositive, relayCall } from './calls.js';
-const permits = {
-    name: 'permits',
-    kind: 'array',
-    item: {
-        name: 'permit',
-        kind: 'tuple',
-        components: [
-            { name: 'token', kind: 'address' },
-            { name: 'owner', kind: 'address' },
-            { name: 'value', kind: 'uint' },
-            { name: 'nonce', kind: 'uint' },
-            { name: 'deadline', kind: 'uint' },
-            { name: 'v', kind: 'uint' },
-            { name: 'r', kind: 'bytes', size: 32 },
-            { name: 's', kind: 'bytes', size: 32 },
-        ],
-    },
-};
-export const permitTransferAndMulticallLegacy = {
-    name: 'permitTransferAndMulticallLegacy',
-    selector: '0xfb68c293',
-    decode(data, value) {
-        const args = decodeCall([
-            permits,
-            callsParam,
-            { name: 'refundTo', kind: 'address' },
-            { name: 'nftRecipient', kind: 'address' },
-            { name: 'metadata', kind: 'bytes' },
-        ], data);
-        const source = firstPositive(asArray(args.permits));
-        return relayCall('permitTransferAndMulticallLegacy', asString(args.metadata), value, source);
-    },
-};

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

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

package/dist/calldata/relay/transferAndMulticall.js

@@ -1,26 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
-import { asArray, asBigint, asString, decodeCall } from '../abi.js';
-import { callsParam, relayCall } from './calls.js';
-export const transferAndMulticall = {
-    name: 'transferAndMulticall',
-    selector: '0xf9e4bab4',
-    decode(data, value) {
-        const args = decodeCall([
-            { name: 'tokens', kind: 'array', item: { name: 'token', kind: 'address' } },
-            { name: 'amounts', kind: 'array', item: { name: 'amount', kind: 'uint' } },
-            callsParam,
-            { name: 'refundTo', kind: 'address' },
-            { name: 'nftRecipient', kind: 'address' },
-            { name: 'metadata', kind: 'bytes' },
-        ], data);
-        const tokens = asArray(args.tokens).map((token) => asString(token));
-        const amounts = asArray(args.amounts).map((amount) => asBigint(amount));
-        if (tokens.length !== amounts.length || new Set(tokens).size > 1) {
-            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_SOURCE_ASSET_LIST);
-        }
-        return relayCall('transferAndMulticall', asString(args.metadata), value, {
-            token: tokens[0],
-            amount: amounts.reduce((sum, amount) => sum + amount, 0n),
-        });
-    },
-};

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

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

package/dist/calldata/relay/validate.js

@@ -1,18 +0,0 @@
-import { BRIDGE_ERRORS } from '../../errors/index.js';
-import { isZeroWord } from '../hex.js';
-const AMOUNT_OPTIONAL = new Set(['depositErc20Allowance', 'multicall']);
-export const relayFailure = (parsed) => {
-    if (isZeroWord(parsed.orderId) && isZeroWord(parsed.requestId)) {
-        return BRIDGE_ERRORS.MISSING_RELAY_ORDER_ID;
-    }
-    if (AMOUNT_OPTIONAL.has(parsed.method)) {
-        return undefined;
-    }
-    if ((parsed.sourceAmount ?? 0n) <= 0n) {
-        return BRIDGE_ERRORS.MISSING_SOURCE_AMOUNT;
-    }
-    if (parsed.sourceToken === undefined) {
-        return BRIDGE_ERRORS.MISSING_SOURCE_TOKEN;
-    }
-    return undefined;
-};

package/dist/calldata/resolve.d.ts

@@ -1,2 +0,0 @@
-import type { ParsedBridgeCall } from './types.js';
-export declare const resolveParsed: (parsed: ParsedBridgeCall) => ParsedBridgeCall;

package/dist/calldata/resolve.js

@@ -1,28 +0,0 @@
-import { CCTP_USDC, isNative } from './protocols.js';
-const tokenInfo = (reference) => {
-    if (reference.protocol === 'cctp' && reference.destinationChainId !== undefined) {
-        const token = CCTP_USDC[reference.destinationChainId.toString()];
-        if (token)
-            return { token, decimals: 6 };
-    }
-    if (reference.protocol === 'token' && reference.token && isNative(reference.token)) {
-        return { token: reference.token, decimals: 18 };
-    }
-    return undefined;
-};
-export const resolveParsed = (parsed) => {
-    const info = parsed.outputTokenReference ? tokenInfo(parsed.outputTokenReference) : undefined;
-    if (info)
-        parsed.outputToken = info.token;
-    const amount = parsed.outputAmountReference;
-    if (amount?.kind === 'normalized' && parsed.minOutputAmount === undefined) {
-        const metadata = tokenInfo(amount.token);
-        if (metadata) {
-            const sourceDecimals = Math.min(metadata.decimals, amount.decimals ?? 8);
-            parsed.minOutputAmount = amount.amount * 10n ** BigInt(metadata.decimals - sourceDecimals);
-        }
-    }
-    parsed.unresolvedFields = ['sourceToken', 'sourceAmount', 'outputToken', 'minOutputAmount', 'receiver']
-        .filter((field) => parsed[field] === undefined);
-    return parsed;
-};

package/dist/calldata/socket/bridge.d.ts

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

package/dist/calldata/socket/bridge.js

@@ -1,28 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
-import { asBigint, asRecord, asString, decodeCall } from '../abi.js';
-import { subtractFees } from '../protocols.js';
-import { bridgeData, fee, input } from './params.js';
-import { readSocketBridge } from './protocols/index.js';
-export const bridge = {
-    name: 'bridge', selector: '0xb18248d5',
-    decode(data) {
-        const a = decodeCall([{ name: 'quoteId', kind: 'bytes', size: 32 }, input, fee, bridgeData,
-            { name: 'bridgeCallData', kind: 'bytes' }], data);
-        const source = asRecord(a.input);
-        const hop = asRecord(a.bridgeData);
-        const target = asString(hop.target);
-        const token = asString(source.inputToken);
-        const amount = subtractFees(asBigint(source.inputAmount), asBigint(asRecord(a.fee).amount));
-        const protocol = readSocketBridge(asString(a.bridgeCallData), target, token, asBigint(hop.value), asString(hop.approvalSpender));
-        if (['receiveERC20', 'receiveNative', 'depositForBurn'].includes(protocol?.protocolMethod ?? '') && protocol?.bridgeAmount !== amount) {
-            throw new BridgeError(BRIDGE_ERRORS.SOCKET_DEPOSIT_AMOUNT_MISMATCH, protocol?.diagnostics);
-        }
-        return {
-            aggregatorId: 'socket', method: 'bridge', kind: 'bridge', quoteId: asString(a.quoteId),
-            sourceToken: token, sourceAmount: asBigint(source.inputAmount), depositor: asString(source.user),
-            bridgeToken: token, bridgeAmount: amount,
-            referrer: asString(asRecord(a.fee).receiver), innerTarget: target,
-            ...protocol,
-        };
-    },
-};

package/dist/calldata/socket/exec.d.ts

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

package/dist/calldata/socket/exec.js

@@ -1,71 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError, asBridgeError } from '../../errors/index.js';
-import { innerCallDiagnostics } from '../diagnostics.js';
-import { asBigint, asString, decodeCall } from '../abi.js';
-import { readSelector } from '../hex.js';
-import { bridge } from './bridge.js';
-import { swapAndBridge } from './swapAndBridge.js';
-import { isNative, NATIVE_TOKEN } from '../protocols.js';
-const readInner = (data, value) => {
-    const selector = readSelector(data);
-    if (selector === bridge.selector) {
-        return bridge.decode(data, value);
-    }
-    if (selector === swapAndBridge.selector) {
-        return swapAndBridge.decode(data, value);
-    }
-    return undefined;
-};
-export const exec = {
-    name: 'exec',
-    selector: '0x2213bc0b',
-    decode(data, value) {
-        const args = decodeCall([
-            { name: 'operator', kind: 'address' },
-            { name: 'token', kind: 'address' },
-            { name: 'amount', kind: 'uint' },
-            { name: 'target', kind: 'address' },
-            { name: 'data', kind: 'bytes' },
-        ], data);
-        const target = asString(args.target);
-        const diagnostics = innerCallDiagnostics(asString(args.data), 'router');
-        if (target !== '0x50cfe7c1938db66a1a6d2e86d36f39fbef3d5c4a' || asString(args.operator) !== target) {
-            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_SOCKET_OPERATOR_OR_ROUTER, diagnostics);
-        }
-        let inner;
-        try {
-            inner = readInner(asString(args.data), value);
-        }
-        catch (error) {
-            throw asBridgeError(error, BRIDGE_ERRORS.CALLDATA_DECODE_FAILED, diagnostics);
-        }
-        if (!inner) {
-            return {
-                aggregatorId: 'socket',
-                method: 'exec',
-                kind: 'bridge',
-                sourceToken: asString(args.token),
-                sourceAmount: asBigint(args.amount),
-                innerTarget: asString(args.target),
-                diagnostics,
-            };
-        }
-        const token = asString(args.token);
-        if (inner.sourceToken !== token && !(isNative(token) && isNative(inner.sourceToken ?? ''))) {
-            throw new BridgeError(BRIDGE_ERRORS.SOCKET_ALLOWANCE_TOKEN_MISMATCH, { ...inner.diagnostics, ...diagnostics });
-        }
-        if (!isNative(token) && asBigint(args.amount) !== inner.sourceAmount) {
-            throw new BridgeError(BRIDGE_ERRORS.SOCKET_ALLOWANCE_AMOUNT_MISMATCH, { ...inner.diagnostics, ...diagnostics });
-        }
-        if (['receiveERC20', 'receiveNative', 'depositForBurn'].includes(inner.protocolMethod ?? '') &&
-            value !== (isNative(token) ? inner.sourceAmount : 0n)) {
-            throw new BridgeError(BRIDGE_ERRORS.SOCKET_NATIVE_VALUE_MISMATCH, { ...inner.diagnostics, ...diagnostics });
-        }
-        return {
-            ...inner,
-            diagnostics: { ...inner.diagnostics, ...diagnostics },
-            sourceToken: isNative(inner.sourceToken ?? token) ? NATIVE_TOKEN : inner.sourceToken ?? token,
-            sourceAmount: inner.sourceAmount ?? asBigint(args.amount),
-            innerTarget: inner.innerTarget ?? asString(args.target),
-        };
-    },
-};

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

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

package/dist/calldata/socket/index.js

@@ -1,13 +0,0 @@
-import { matchMethod } from '../match.js';
-import { finishCheck, knownCompare } from '../expect.js';
-import { exec } from './exec.js';
-import { socketFailure } from './validate.js';
-const METHODS = [exec];
-export const decodeSocket = (data, value) => matchMethod(METHODS, data, value);
-export const validateSocket = (data, value, expectation, chainId = '') => {
-    const hit = decodeSocket(data, value);
-    if (!hit.ok) {
-        return { ...hit, aggregatorId: 'socket' };
-    }
-    return finishCheck('socket', hit.parsed, socketFailure(hit.parsed, expectation?.userAddress), expectation, chainId, knownCompare(hit.parsed));
-};

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

@@ -1,5 +0,0 @@
-import type { AbiParam } from '../abi.js';
-export declare const input: AbiParam;
-export declare const fee: AbiParam;
-export declare const swapData: AbiParam;
-export declare const bridgeData: AbiParam;

package/dist/calldata/socket/params.js

@@ -1,14 +0,0 @@
-export const input = { name: 'input', kind: 'tuple', components: [
-        { name: 'user', kind: 'address' }, { name: 'inputToken', kind: 'address' }, { name: 'inputAmount', kind: 'uint' },
-    ] };
-export const fee = { name: 'fee', kind: 'tuple', components: [
-        { name: 'receiver', kind: 'address' }, { name: 'amount', kind: 'uint' },
-    ] };
-export const swapData = { name: 'swapData', kind: 'tuple', components: [
-        { name: 'target', kind: 'address' }, { name: 'approvalSpender', kind: 'address' },
-        { name: 'outputToken', kind: 'address' }, { name: 'value', kind: 'uint' },
-        { name: 'minOutput', kind: 'uint' }, { name: 'returnDataWordOffset', kind: 'uint' },
-    ] };
-export const bridgeData = { name: 'bridgeData', kind: 'tuple', components: [
-        { name: 'target', kind: 'address' }, { name: 'approvalSpender', kind: 'address' }, { name: 'value', kind: 'uint' },
-    ] };

package/dist/calldata/socket/protocols/ccip.d.ts

@@ -1,2 +0,0 @@
-import type { ParsedBridgeCall } from '../../types.js';
-export declare const readCcip: (data: string, target: string) => Partial<ParsedBridgeCall>;

package/dist/calldata/socket/protocols/ccip.js

@@ -1,32 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../../../errors/index.js';
-import { asArray, asBigint, asRecord, asString, decodeCall, decodeParameters } from '../../abi.js';
-import { CCIP_CHAINS } from '../../protocols.js';
-const message = { name: 'message', kind: 'tuple', components: [
-        { name: 'receiver', kind: 'bytes' }, { name: 'data', kind: 'bytes' },
-        { name: 'tokenAmounts', kind: 'array', item: { name: 'tokenAmount', kind: 'tuple', components: [
-                    { name: 'token', kind: 'address' }, { name: 'amount', kind: 'uint' },
-                ] } },
-        { name: 'feeToken', kind: 'address' }, { name: 'extraArgs', kind: 'bytes' },
-    ] };
-export const readCcip = (data, target) => {
-    const a = decodeCall([{ name: 'destinationChainSelector', kind: 'uint' }, message], data);
-    const m = asRecord(a.message);
-    const amounts = asArray(m.tokenAmounts);
-    if (amounts.length !== 1)
-        throw new BridgeError(BRIDGE_ERRORS.CCIP_REQUIRES_ONE_BRIDGE_ASSET);
-    const token = asRecord(amounts[0]);
-    const ref = { protocol: 'ccip', contract: target, token: asString(token.token),
-        destinationChainId: CCIP_CHAINS[asBigint(a.destinationChainSelector).toString()],
-        destinationChainRef: `ccip:${asBigint(a.destinationChainSelector)}` };
-    const receiverData = asString(m.receiver);
-    const receiver = receiverData.length === 66
-        ? asString(decodeParameters([{ name: 'receiver', kind: 'address' }], receiverData).receiver) : undefined;
-    const extra = asString(m.extraArgs);
-    const direct = asString(m.data) === '0x' && (extra === '0x' || ['0x97a657c9', '0x181dcf10'].includes(extra.slice(0, 10)));
-    return { protocolMethod: 'ccipSend', destinationChainId: ref.destinationChainId,
-        destinationChainRef: ref.destinationChainRef, bridgeReceiver: receiver, receiver: direct ? receiver : undefined,
-        outputTokenReference: direct ? ref : undefined,
-        outputAmountReference: direct ? { kind: 'decimals', amount: asBigint(token.amount), token: ref } : undefined,
-        destinationCallData: direct ? undefined : asString(m.data),
-    };
-};

package/dist/calldata/socket/protocols/cctp.d.ts

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

package/dist/calldata/socket/protocols/cctp.js

@@ -1,24 +0,0 @@
-import { asBigint, asString, decodeCall } from '../../abi.js';
-import { accountFromBytes32 } from '../../hex.js';
-import { CCTP_CHAINS, CCTP_USDC, subtractFees } from '../../protocols.js';
-export const readCctp = (data) => {
-    const a = decodeCall([
-        { name: 'amount', kind: 'uint' }, { name: 'destinationDomain', kind: 'uint' },
-        { name: 'mintRecipient', kind: 'bytes', size: 32 }, { name: 'burnToken', kind: 'address' },
-        { name: 'destinationCaller', kind: 'bytes', size: 32 }, { name: 'maxFee', kind: 'uint' },
-        { name: 'minFinalityThreshold', kind: 'uint' },
-    ], data);
-    const id = asBigint(a.destinationDomain);
-    const destinationChainId = CCTP_CHAINS[id.toString()];
-    const receiver = accountFromBytes32(asString(a.mintRecipient));
-    const intermediary = receiver === '0x424a31a57f7c63918ecaa2fac38016a8af5a6ec2';
-    return { protocolMethod: 'depositForBurn', destinationChainId, destinationChainRef: `cctp:${id}`,
-        bridgeReceiver: receiver, receiver: intermediary ? undefined : receiver,
-        bridgeToken: asString(a.burnToken), bridgeAmount: asBigint(a.amount),
-        bridgeOutputToken: CCTP_USDC[destinationChainId?.toString() ?? ''],
-        bridgeOutputAmount: subtractFees(asBigint(a.amount), asBigint(a.maxFee)),
-        outputToken: CCTP_USDC[destinationChainId?.toString() ?? ''],
-        minOutputAmount: intermediary ? undefined : subtractFees(asBigint(a.amount), asBigint(a.maxFee)),
-        // ClaimExecutor's recipient and relay fee are signed on the destination, outside this calldata.
-    };
-};

package/dist/calldata/socket/protocols/eco.d.ts

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