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

package/dist/calldata/relay/permit3009TransferAndMulticallSigned.js

@@ -0,0 +1,40 @@
+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, args.calls, {
+            token: tokens[0] ?? source.token,
+            amount: source.amount,
+        });
+    },
+};

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

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

package/dist/calldata/relay/permitTransferAndMulticall.js

@@ -0,0 +1,34 @@
+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, args.calls, source);
+    },
+};

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

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

package/dist/calldata/relay/permitTransferAndMulticallLegacy.js

@@ -0,0 +1,35 @@
+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, args.calls, source);
+    },
+};

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

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

package/dist/calldata/relay/transferAndMulticall.js

@@ -0,0 +1,26 @@
+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, args.calls, {
+            token: tokens[0],
+            amount: amounts.reduce((sum, amount) => sum + amount, 0n),
+        });
+    },
+};

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

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

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

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

package/dist/calldata/resolve.js

@@ -0,0 +1,28 @@
+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/addresses.d.ts

@@ -0,0 +1,9 @@
+/** Source vault that receives every Socket RFQ deposit. Not the destination recipient. */
+export declare const SOCKET_RFQ_VAULT = "0x97caca78ac2a94c67643d07843f85afaa44a3ea5";
+/** Circle TokenMessenger V2 used by Socket CCTP. The same address on each EVM chain. */
+export declare const SOCKET_CCTP_MESSENGER = "0x28b5a0e9c621a5badaa536219b3a228c8168cf5d";
+/**
+ * Fixed destination mint recipient for Socket CCTP.
+ * The user's wallet is in a destination signature, not this field.
+ */
+export declare const SOCKET_CCTP_MINT_RECIPIENT = "0x424a31a57f7c63918ecaa2fac38016a8af5a6ec2";

package/dist/calldata/socket/addresses.js

@@ -0,0 +1,9 @@
+/** Source vault that receives every Socket RFQ deposit. Not the destination recipient. */
+export const SOCKET_RFQ_VAULT = '0x97caca78ac2a94c67643d07843f85afaa44a3ea5';
+/** Circle TokenMessenger V2 used by Socket CCTP. The same address on each EVM chain. */
+export const SOCKET_CCTP_MESSENGER = '0x28b5a0e9c621a5badaa536219b3a228c8168cf5d';
+/**
+ * Fixed destination mint recipient for Socket CCTP.
+ * The user's wallet is in a destination signature, not this field.
+ */
+export const SOCKET_CCTP_MINT_RECIPIENT = '0x424a31a57f7c63918ecaa2fac38016a8af5a6ec2';

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

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

package/dist/calldata/socket/bridge.js

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

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

package/dist/calldata/socket/exec.js

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,25 @@
+import { asBigint, asString, decodeCall } from '../../abi.js';
+import { accountFromBytes32 } from '../../hex.js';
+import { CCTP_CHAINS, CCTP_USDC, subtractFees } from '../../protocols.js';
+import { SOCKET_CCTP_MINT_RECIPIENT } from '../addresses.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 allowlisted = receiver === SOCKET_CCTP_MINT_RECIPIENT;
+    return { protocolMethod: 'depositForBurn', destinationChainId, destinationChainRef: `cctp:${id}`,
+        bridgeReceiver: receiver, receiver: allowlisted ? undefined : receiver, fixedReceiver: allowlisted,
+        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: allowlisted ? 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

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

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

@@ -0,0 +1,49 @@
+import { asArray, asBigint, asRecord, asString, decodeCall, decodeParameters } from '../../abi.js';
+import { destinationCall, readDestinationTransfers } from '../../destination.js';
+import { readSelector } from '../../hex.js';
+import { CCTP_USDC } from '../../protocols.js';
+import { SOCKET_CCTP_MESSENGER } from '../addresses.js';
+import { readCctp } from './cctp.js';
+const tokens = { name: 'tokens', kind: 'array', item: { name: 'token', kind: 'tuple', components: [
+            { name: 'token', kind: 'address' }, { name: 'amount', kind: 'uint' },
+        ] } };
+const reward = { name: 'reward', kind: 'tuple', components: [
+        { name: 'deadline', kind: 'uint' }, { name: 'creator', kind: 'address' }, { name: 'prover', kind: 'address' },
+        { name: 'nativeAmount', kind: 'uint' }, tokens,
+    ] };
+const route = { name: 'route', kind: 'tuple', components: [
+        { name: 'salt', kind: 'bytes', size: 32 }, { name: 'deadline', kind: 'uint' }, { name: 'portal', kind: 'address' },
+        { name: 'nativeAmount', kind: 'uint' }, tokens, { name: 'calls', kind: 'array', item: destinationCall },
+    ] };
+export const readEco = (data, target, spender, value) => {
+    const a = decodeCall([{ name: 'destination', kind: 'uint' }, { name: 'route', kind: 'bytes' }, reward,
+        { name: 'allowPartial', kind: 'bool' }], data);
+    const r = asRecord(decodeParameters([route], asString(a.route)).route);
+    const calls = asArray(r.calls).map(asRecord);
+    const parsed = {
+        protocolMethod: 'publishAndFund', destinationChainId: asBigint(a.destination),
+        destinationCallData: asString(a.route), ...readDestinationTransfers(calls),
+    };
+    // shortcut: the reviewed HyperEVM Portal's approve + CCTP route; review other compositions before support.
+    const portal = '0xec000769a73b70e16f361a442292500b3bcf4a85';
+    const assets = asArray(r.tokens).map(asRecord);
+    if (parsed.destinationChainId !== 999n || target !== portal || spender !== portal || value !== 0n ||
+        asString(r.portal) !== portal || asBigint(r.nativeAmount) !== 0n || assets.length !== 1 || calls.length !== 2)
+        return parsed;
+    const [approval, burn] = calls;
+    const token = CCTP_USDC['999'];
+    const amount = asBigint(assets[0].amount);
+    if (asString(assets[0].token) !== token || amount <= 0n || asString(approval.target) !== token ||
+        asBigint(approval.value) !== 0n || readSelector(asString(approval.data)) !== '0x095ea7b3' ||
+        asString(burn.target) !== SOCKET_CCTP_MESSENGER || asBigint(burn.value) !== 0n ||
+        readSelector(asString(burn.data)) !== '0x8e0250ee')
+        return parsed;
+    const approved = decodeCall([{ name: 'spender', kind: 'address' }, { name: 'amount', kind: 'uint' }], asString(approval.data));
+    const nested = readCctp(asString(burn.data));
+    if (asString(approved.spender) !== SOCKET_CCTP_MESSENGER || asBigint(approved.amount) !== amount ||
+        nested.bridgeToken !== token || nested.bridgeAmount !== amount || nested.fixedReceiver ||
+        nested.destinationChainId === undefined || !nested.receiver || !nested.outputToken)
+        return parsed;
+    return { ...parsed, destinationChainId: nested.destinationChainId, destinationChainRef: nested.destinationChainRef,
+        receiver: nested.receiver, outputToken: nested.outputToken, minOutputAmount: nested.minOutputAmount };
+};

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

@@ -0,0 +1,3 @@
+import type { ParsedBridgeCall } from '../../types.js';
+export declare const readSocketBridge: (data: string, target: string, token: string, value: bigint, spender: string) => Partial<ParsedBridgeCall>;
+export declare const spliceBridgeAmount: (data: string, flags: bigint, amount: bigint) => string;

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

@@ -0,0 +1,87 @@
+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 { isNative, NATIVE_TOKEN } from '../../protocols.js';
+import { SOCKET_CCTP_MESSENGER, SOCKET_RFQ_VAULT } from '../addresses.js';
+import { readCcip } from './ccip.js';
+import { readCctp } from './cctp.js';
+import { readEco } from './eco.js';
+import { readNativeBridge } from './native.js';
+import { readOft } from './oft.js';
+import { readSwapsXYZ } from './swapsXYZ.js';
+const decodeSocketBridge = (data, target, token, value, spender) => {
+    const selector = readSelector(data);
+    const native = readNativeBridge(data, target, value);
+    if (native)
+        return native;
+    if (selector === '0x96f4e9f9')
+        return readCcip(data, target);
+    if (selector === '0x8e0250ee') {
+        if (target !== SOCKET_CCTP_MESSENGER || spender !== target || value !== 0n) {
+            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_SOCKET_CCTP_TARGET_SPENDER_OR_VALUE);
+        }
+        const parsed = readCctp(data);
+        if (parsed.bridgeToken !== token)
+            throw new BridgeError(BRIDGE_ERRORS.SOCKET_CCTP_TOKEN_DOES_NOT_MATCH_BRIDGE_ASSET);
+        return parsed;
+    }
+    if (selector === '0xdf00f8fa')
+        return readEco(data, target, spender, value);
+    if (selector === '0xc7c7f5b3' || selector === '0x2cdf0b95')
+        return readOft(data, target, token);
+    if (selector === '0x0c751e0b' || selector === '0x9be111d1')
+        return readSwapsXYZ(data);
+    if (selector === '0x823b01f9' || selector === '0x3345e738') {
+        const native = selector === '0x3345e738';
+        if (target !== SOCKET_RFQ_VAULT || spender !== target ||
+            (native ? !isNative(token) : value !== 0n)) {
+            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_SOCKET_RFQ_TARGET_SPENDER_OR_VALUE);
+        }
+        const a = decodeCall([{ name: 'quoteId', kind: 'bytes', size: 32 },
+            ...(native ? [] : [{ name: 'token', kind: 'address' }, { name: 'amount', kind: 'uint' }])], data);
+        if (!native && asString(a.token) !== token)
+            throw new BridgeError(BRIDGE_ERRORS.SOCKET_RFQ_TOKEN_DOES_NOT_MATCH_BRIDGE_ASSET);
+        return { protocolMethod: native ? 'receiveNative' : 'receiveERC20', orderId: asString(a.quoteId),
+            bridgeToken: native ? NATIVE_TOKEN : asString(a.token), bridgeAmount: native ? value : asBigint(a.amount) };
+    }
+    return undefined;
+};
+export const readSocketBridge = (data, target, token, value, spender) => {
+    const diagnostics = innerCallDiagnostics(data, 'protocol');
+    try {
+        const parsed = decodeSocketBridge(data, target, token, value, spender);
+        return { ...parsed, diagnostics: { ...parsed?.diagnostics, ...diagnostics } };
+    }
+    catch (error) {
+        throw asBridgeError(error, BRIDGE_ERRORS.CALLDATA_DECODE_FAILED, diagnostics);
+    }
+};
+const word = (data, offset) => {
+    const raw = data.slice(2 + offset * 2, 2 + (offset + 32) * 2);
+    if (raw.length !== 64)
+        throw new BridgeError(BRIDGE_ERRORS.INVALID_BRIDGE_OFFSET);
+    const n = BigInt(`0x${raw}`);
+    if (n > BigInt(data.length / 2))
+        throw new BridgeError(BRIDGE_ERRORS.BRIDGE_OFFSET_EXCEEDS_CALLDATA);
+    return Number(n);
+};
+export const spliceBridgeAmount = (data, flags, amount) => {
+    if ((flags & 8n) === 0n)
+        return data;
+    const position = Number(flags >> 16n & 65535n);
+    const selector = readSelector(data);
+    let expected = {
+        '0xd2ce7d65': 68, '0xad58bdd1': 68, '0x8b9e4f93': 68,
+        '0x838b2520': 100, '0x8e0250ee': 4, '0x823b01f9': 68, '0x2cdf0b95': 100,
+    }[selector ?? ''];
+    if (selector === '0xc7c7f5b3')
+        expected = 4 + word(data, 4) + 64;
+    if (selector === '0x96f4e9f9') {
+        const message = 4 + word(data, 36);
+        expected = message + word(data, message + 64) + 64;
+    }
+    if (position !== expected || 2 + (position + 32) * 2 > data.length)
+        throw new BridgeError(BRIDGE_ERRORS.BRIDGE_SPLICE_DOES_NOT_TARGET_THE_INPUT_AMOUNT);
+    return data.slice(0, 2 + position * 2) + amount.toString(16).padStart(64, '0') + data.slice(2 + (position + 32) * 2);
+};

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

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