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

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', '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>;

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

@@ -1,20 +0,0 @@
-import { asArray, asBigint, asRecord, asString, decodeCall, decodeParameters } from '../../abi.js';
-import { destinationCall, readDestinationTransfers } from '../../destination.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) => {
-    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);
-    return { protocolMethod: 'publishAndFund', destinationChainId: asBigint(a.destination),
-        destinationCallData: asString(a.route), ...readDestinationTransfers(asArray(r.calls)) };
-};

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

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

@@ -1,81 +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 { 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 !== '0x28b5a0e9c621a5badaa536219b3a228c8168cf5d' || 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);
-    if (selector === '0xc7c7f5b3' || selector === '0x2cdf0b95')
-        return readOft(data, target, token);
-    if (selector === '0x0c751e0b' || selector === '0x9be111d1')
-        return readSwapsXYZ(data);
-    if (selector === '0x823b01f9') {
-        if (target !== '0x97caca78ac2a94c67643d07843f85afaa44a3ea5' || spender !== target || value !== 0n) {
-            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_SOCKET_RFQ_TARGET_SPENDER_OR_VALUE);
-        }
-        const a = decodeCall([{ name: 'quoteId', kind: 'bytes', size: 32 }, { name: 'token', kind: 'address' }, { name: 'amount', kind: 'uint' }], data);
-        if (asString(a.token) !== token)
-            throw new BridgeError(BRIDGE_ERRORS.SOCKET_RFQ_TOKEN_DOES_NOT_MATCH_BRIDGE_ASSET);
-        return { protocolMethod: 'receiveERC20', orderId: asString(a.quoteId), bridgeToken: asString(a.token), bridgeAmount: 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

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

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

@@ -1,70 +0,0 @@
-import { asBigint, asString, decodeCall, decodeParameters } from '../../abi.js';
-import { NATIVE_TOKEN, isNative } from '../../protocols.js';
-import { readSelector } from '../../hex.js';
-export const readNativeBridge = (data, target, value) => {
-    const selector = readSelector(data);
-    if (selector === '0x679b6ded') {
-        const a = decodeCall([
-            { name: 'to', kind: 'address' }, { name: 'l2CallValue', kind: 'uint' }, { name: 'maxSubmissionCost', kind: 'uint' },
-            { name: 'excessFeeRefundAddress', kind: 'address' }, { name: 'callValueRefundAddress', kind: 'address' },
-            { name: 'gasLimit', kind: 'uint' }, { name: 'maxFeePerGas', kind: 'uint' }, { name: 'data', kind: 'bytes' },
-        ], data);
-        const destinationChainId = target === '0x4dbd4fc535ac27206064b68ffcf827b0a60bab3f' ? 42161n
-            : target === '0x1a07cc4bd17e0118bdb54d70990d2158abad7a2d' ? 4663n : undefined;
-        const callData = asString(a.data);
-        return { protocolMethod: 'createRetryableTicket', destinationChainId,
-            receiver: callData === '0x' ? asString(a.to) : undefined, bridgeReceiver: asString(a.to),
-            outputToken: callData === '0x' ? NATIVE_TOKEN : undefined,
-            minOutputAmount: callData === '0x' ? asBigint(a.l2CallValue) : undefined,
-            destinationCallData: callData === '0x' ? undefined : callData };
-    }
-    if (selector === '0xd2ce7d65') {
-        const a = decodeCall([
-            { name: 'token', kind: 'address' }, { name: 'to', kind: 'address' }, { name: 'amount', kind: 'uint' },
-            { name: 'maxGas', kind: 'uint' }, { name: 'gasPriceBid', kind: 'uint' }, { name: 'data', kind: 'bytes' },
-        ], data);
-        const ref = { protocol: 'arbitrum', contract: target, token: asString(a.token), destinationChainId: target === '0x72ce9c846789fdb6fc1f34ac4ad25dd9ef7031ef' ? 42161n : undefined };
-        return { protocolMethod: 'outboundTransfer', receiver: asString(a.to),
-            destinationChainId: ref.destinationChainId, outputTokenReference: ref, minOutputAmount: asBigint(a.amount) };
-    }
-    if (selector === '0x838b2520' || selector === '0x9a2ac6d5') {
-        const erc20 = selector === '0x838b2520';
-        const a = decodeCall([
-            ...(erc20 ? [{ name: 'localToken', kind: 'address' }, { name: 'remoteToken', kind: 'address' }] : []),
-            { name: 'to', kind: 'address' }, ...(erc20 ? [{ name: 'amount', kind: 'uint' }] : []),
-            { name: 'minGasLimit', kind: 'uint' }, { name: 'extraData', kind: 'bytes' },
-        ], data);
-        return { protocolMethod: erc20 ? 'depositERC20To' : 'depositETHTo',
-            destinationChainId: target === '0x3154cf16ccdb4c6d922629664174b904d80f2c35' ? 8453n : undefined,
-            receiver: asString(a.to), outputToken: erc20 ? asString(a.remoteToken) : NATIVE_TOKEN,
-            minOutputAmount: erc20 ? asBigint(a.amount) : value };
-    }
-    if (selector === '0x4faa8a26') {
-        const a = decodeCall([{ name: 'user', kind: 'address' }], data);
-        return { protocolMethod: 'depositEtherFor', destinationChainId: 137n, receiver: asString(a.user),
-            outputToken: '0x7ceb23fd6bc0add59e62ac25578270cff1b9f619', minOutputAmount: value };
-    }
-    if (selector === '0xe3dec8fb') {
-        const a = decodeCall([{ name: 'user', kind: 'address' }, { name: 'rootToken', kind: 'address' }, { name: 'depositData', kind: 'bytes' }], data);
-        const amount = asBigint(decodeParameters([{ name: 'amount', kind: 'uint' }], asString(a.depositData)).amount);
-        return { protocolMethod: 'depositFor', destinationChainId: 137n, receiver: asString(a.user), minOutputAmount: amount,
-            outputTokenReference: { protocol: 'polygon', contract: target, token: asString(a.rootToken), destinationChainId: 137n } };
-    }
-    if (selector === '0x8b9e4f93' || selector === '0xad58bdd1') {
-        const polygon = selector === '0x8b9e4f93';
-        const a = decodeCall([{ name: 'token', kind: 'address' }, { name: 'receiver', kind: 'address' }, { name: 'amount', kind: 'uint' }], data);
-        const token = asString(a.token);
-        const destinationChainId = polygon ? 137n : 100n;
-        let outputToken;
-        if (polygon && ['0x7d1afa7b718fb893db30a3abc0cfc608aacfebb0', '0x455e53cbb86018ac2b8092fdcd39d8444affc3f6'].includes(token))
-            outputToken = NATIVE_TOKEN;
-        if (!polygon && ['0x6b175474e89094c44da98b954eedeac495271d0f', '0xdc035d45d973e3ec169d2276ddab16f1e407384f'].includes(token))
-            outputToken = NATIVE_TOKEN;
-        if (!polygon && isNative(token))
-            outputToken = '0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1';
-        return { protocolMethod: polygon ? 'depositERC20ForUser' : 'relayTokens', destinationChainId,
-            receiver: asString(a.receiver), minOutputAmount: asBigint(a.amount), outputToken,
-            outputTokenReference: outputToken ? undefined : { protocol: polygon ? 'polygon' : 'gnosis', contract: target, token, destinationChainId } };
-    }
-    return undefined;
-};

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

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

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

@@ -1,31 +0,0 @@
-import { asBigint, asRecord, asString, decodeCall } from '../../abi.js';
-import { accountFromBytes32, readSelector } from '../../hex.js';
-import { LAYERZERO_CHAINS } from '../../protocols.js';
-const send = { name: 'send', kind: 'tuple', components: [
-        { name: 'dstEid', kind: 'uint' }, { name: 'to', kind: 'bytes', size: 32 },
-        { name: 'amountLD', kind: 'uint' }, { name: 'minAmountLD', kind: 'uint' },
-        { name: 'extraOptions', kind: 'bytes' }, { name: 'composeMsg', kind: 'bytes' }, { name: 'oftCmd', kind: 'bytes' },
-    ] };
-export const readOft = (data, target, token) => {
-    const legacy = readSelector(data) === '0x2cdf0b95';
-    const a = legacy ? decodeCall([
-        { name: 'from', kind: 'address' }, { name: 'dstEid', kind: 'uint' }, { name: 'to', kind: 'bytes', size: 32 },
-        { name: 'amountLD', kind: 'uint' }, { name: 'minAmountLD', kind: 'uint' },
-        { name: 'callParams', kind: 'tuple', components: [
-                { name: 'refundAddress', kind: 'address' }, { name: 'zroPaymentAddress', kind: 'address' }, { name: 'adapterParams', kind: 'bytes' },
-            ] },
-    ], data) : asRecord(decodeCall([send, { name: 'fee', kind: 'tuple', components: [
-                { name: 'nativeFee', kind: 'uint' }, { name: 'lzTokenFee', kind: 'uint' },
-            ] }, { name: 'refundAddress', kind: 'address' }], data).send);
-    const id = asBigint(a.dstEid);
-    const ref = { protocol: 'oft', contract: target, token,
-        destinationChainId: LAYERZERO_CHAINS[id.toString()], destinationChainRef: `layerzero:${id}` };
-    const direct = legacy || (asString(a.composeMsg) === '0x' && asString(a.oftCmd) === '0x');
-    return { protocolMethod: legacy ? 'sendFrom' : 'send', destinationChainId: ref.destinationChainId,
-        destinationChainRef: ref.destinationChainRef, bridgeReceiver: accountFromBytes32(asString(a.to)),
-        receiver: direct ? accountFromBytes32(asString(a.to)) : undefined,
-        outputTokenReference: direct ? ref : undefined,
-        outputAmountReference: direct ? { kind: 'decimals', amount: asBigint(a.minAmountLD), token: ref } : undefined,
-        destinationCallData: direct ? undefined : asString(a.composeMsg),
-    };
-};

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

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

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

@@ -1,62 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../../../errors/index.js';
-import { asArray, asBigint, asRecord, asString, decodeCall, decodeParameters } from '../../abi.js';
-import { accountFromBytes32, readSelector } from '../../hex.js';
-const swap = { name: 'swap', kind: 'tuple', components: [
-        { name: 'swapperId', kind: 'uint' }, { name: 'params', kind: 'tuple', components: [
-                { name: 'amountIn', kind: 'uint' }, { name: 'amountOut', kind: 'uint' }, { name: 'dustOut', kind: 'uint' },
-                { name: 'tokenIn', kind: 'address' }, { name: 'tokenOut', kind: 'address' }, { name: 'direction', kind: 'uint' },
-                { name: 'refund', kind: 'address' }, { name: 'additionalArgs', kind: 'bytes' },
-            ] },
-    ] };
-const instructions = { name: 'instructions', kind: 'tuple', components: [
-        swap, { name: 'target', kind: 'address' }, { name: 'paymentOperator', kind: 'address' }, { name: 'refund', kind: 'address' },
-        { name: 'executionFee', kind: 'uint' }, { name: 'payload', kind: 'bytes' }, { name: 'txId', kind: 'bytes', size: 32 },
-    ] };
-const fee = { name: 'fee', kind: 'tuple', components: [
-        { name: 'appId', kind: 'bytes', size: 4 }, { name: 'affiliateId', kind: 'bytes', size: 4 },
-        { name: 'bridgeFee', kind: 'uint' }, { name: 'deadline', kind: 'uint' }, { name: 'chainId', kind: 'uint' },
-        { name: 'fees', kind: 'array', item: { name: 'fee', kind: 'tuple', components: [
-                    { name: 'recipient', kind: 'address' }, { name: 'token', kind: 'address' }, { name: 'amount', kind: 'uint' },
-                ] } },
-    ] };
-export const readSwapsXYZ = (data) => {
-    const a = decodeCall([instructions, fee, { name: 'feeSignature', kind: 'bytes' },
-        ...(readSelector(data) === '0x0c751e0b' ? [{ name: 'executionSignature', kind: 'bytes' }] : [])], data);
-    const payload = asString(asRecord(a.instructions).payload);
-    if (readSelector(payload) !== '0x24856bc3')
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_SWAPS_XYZ_EXECUTION);
-    const commandData = decodeCall([{ name: 'commands', kind: 'bytes' },
-        { name: 'inputs', kind: 'array', item: { name: 'input', kind: 'bytes' } }], payload);
-    const commands = asString(commandData.commands).slice(2).match(/../g) ?? [];
-    const inputs = asArray(commandData.inputs);
-    if (commands.length !== inputs.length)
-        throw new BridgeError(BRIDGE_ERRORS.HYPERLANE_COMMAND_LENGTH_MISMATCH, { commandCount: commands.length });
-    let result;
-    for (let i = 0; i < commands.length; i += 1) {
-        const command = Number.parseInt(commands[i], 16);
-        if ([0, 1, 2, 3, 8].includes(command))
-            continue;
-        if (![4, 5].includes(command) || result)
-            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_HYPERLANE_OPERATION, { commandByte: command, commandCount: commands.length });
-        const p = decodeParameters([
-            { name: 'router', kind: 'address' }, { name: 'destination', kind: 'uint' }, { name: 'recipient', kind: 'bytes', size: 32 },
-            { name: 'amount', kind: 'uint' }, ...(command === 5 ? [{ name: 'targetRouter', kind: 'bytes', size: 32 }] : []),
-            { name: 'value', kind: 'uint' }, { name: 'token', kind: 'address' }, { name: 'approval', kind: 'uint' },
-        ], asString(inputs[i]));
-        const domain = asBigint(p.destination);
-        const ref = { protocol: 'hyperlane', contract: asString(p.router), token: asString(p.token),
-            destinationChainRef: `hyperlane:${domain}`,
-            destinationChainId: [1n, 56n, 42161n, 8453n].includes(domain) ? domain : undefined,
-            destinationContract: command === 5 ? accountFromBytes32(asString(p.targetRouter)) : undefined };
-        const amount = asBigint(p.amount);
-        if (amount === 1n << 255n)
-            throw new BridgeError(BRIDGE_ERRORS.HYPERLANE_BALANCE_AMOUNT_REQUIRES_EXECUTION_STATE);
-        result = { protocolMethod: `swaps-xyz/execute/${command === 5 ? 'transferRemoteTo' : 'transferRemote'}`,
-            destinationChainId: ref.destinationChainId, destinationChainRef: ref.destinationChainRef,
-            receiver: accountFromBytes32(asString(p.recipient)), outputTokenReference: ref,
-            outputAmountReference: { kind: 'scale', amount, token: ref } };
-    }
-    if (!result)
-        throw new BridgeError(BRIDGE_ERRORS.MISSING_HYPERLANE_TRANSFER);
-    return result;
-};

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

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

package/dist/calldata/socket/swapAndBridge.js

@@ -1,37 +0,0 @@
-import { BRIDGE_ERRORS, asBridgeError } from '../../errors/index.js';
-import { innerCallDiagnostics } from '../diagnostics.js';
-import { asBigint, asRecord, asString, decodeCall } from '../abi.js';
-import { subtractFees } from '../protocols.js';
-import { bridgeData, fee, input, swapData } from './params.js';
-import { readSocketBridge, spliceBridgeAmount } from './protocols/index.js';
-export const swapAndBridge = {
-    name: 'swapAndBridge', selector: '0x324012e2',
-    decode(data) {
-        const a = decodeCall([{ name: 'quoteId', kind: 'bytes', size: 32 }, { name: 'flags', kind: 'uint' },
-            input, fee, swapData, { name: 'swapCallData', kind: 'bytes' }, bridgeData,
-            { name: 'bridgeCallData', kind: 'bytes' }], data);
-        const source = asRecord(a.input);
-        const swap = asRecord(a.swapData);
-        const hop = asRecord(a.bridgeData);
-        const flags = asBigint(a.flags);
-        const amount = subtractFees(asBigint(swap.minOutput), (flags & 1n) !== 0n ? asBigint(asRecord(a.fee).amount) : 0n);
-        const value = asBigint(hop.value) + ((flags & 4n) !== 0n ? amount : 0n);
-        const token = asString(swap.outputToken);
-        const target = asString(hop.target);
-        const bridgeCallData = asString(a.bridgeCallData);
-        let callData;
-        try {
-            callData = spliceBridgeAmount(bridgeCallData, flags, amount);
-        }
-        catch (error) {
-            throw asBridgeError(error, BRIDGE_ERRORS.CALLDATA_DECODE_FAILED, innerCallDiagnostics(bridgeCallData, 'protocol'));
-        }
-        return {
-            aggregatorId: 'socket', method: 'swapAndBridge', kind: 'bridge', quoteId: asString(a.quoteId),
-            sourceToken: asString(source.inputToken), sourceAmount: asBigint(source.inputAmount), depositor: asString(source.user),
-            bridgeToken: token, bridgeAmount: amount,
-            referrer: asString(asRecord(a.fee).receiver), innerTarget: target,
-            ...readSocketBridge(callData, target, token, value, asString(hop.approvalSpender)),
-        };
-    },
-};

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

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

package/dist/calldata/socket/validate.js

@@ -1,21 +0,0 @@
-import { BRIDGE_ERRORS } from '../../errors/index.js';
-import { isZeroWord } from '../hex.js';
-export const socketFailure = (parsed, expectedUser) => {
-    if (expectedUser && parsed.depositor !== expectedUser.toLowerCase())
-        return BRIDGE_ERRORS.DEPOSITOR_MISMATCH;
-    if (parsed.method === 'exec') {
-        return BRIDGE_ERRORS.UNRECOGNIZED_SOCKET_ROUTER_CALLDATA;
-    }
-    if (!parsed.quoteId || isZeroWord(parsed.quoteId)) {
-        return BRIDGE_ERRORS.MISSING_QUOTE_ID;
-    }
-    if (!parsed.protocolMethod)
-        return BRIDGE_ERRORS.UNRECOGNIZED_SOCKET_BRIDGE_CALLDATA;
-    if (parsed.sourceToken === undefined) {
-        return BRIDGE_ERRORS.MISSING_SOURCE_TOKEN;
-    }
-    if ((parsed.sourceAmount ?? 0n) <= 0n) {
-        return BRIDGE_ERRORS.MISSING_SOURCE_AMOUNT;
-    }
-    return undefined;
-};

package/dist/calldata/types.d.ts

@@ -1,82 +0,0 @@
-import type { BridgeErrorCode, BridgeErrorStage, BridgeErrorDetail, BridgeErrorContext } from '../errors/index.js';
-import type { BridgeAggregatorId } from '../consts.js';
-export type BridgeTokenReference = {
-    protocol: 'token' | 'cctp' | 'oft' | 'frax' | 'ccip' | 'polygon' | 'gnosis' | 'arbitrum' | 'superset' | 'hyperlane' | 'across-native' | 'centrifuge';
-    contract?: string;
-    token?: string;
-    destinationChainId?: bigint;
-    destinationChainRef?: string;
-    destinationContract?: string;
-    tokenId?: string;
-};
-export type BridgeAmountReference = {
-    kind: 'decimals' | 'normalized' | 'dust' | 'scale' | 'fees';
-    amount: bigint;
-    token: BridgeTokenReference;
-    decimals?: number;
-    maxFee?: bigint;
-};
-export type ParsedBridgeCall = {
-    aggregatorId: BridgeAggregatorId;
-    method: string;
-    kind: 'bridge' | 'swap' | 'deposit';
-    sourceToken?: string;
-    sourceAmount?: bigint;
-    destinationChainId?: bigint;
-    destinationChainRef?: string;
-    receiver?: string;
-    outputToken?: string;
-    minOutputAmount?: bigint;
-    orderId?: string;
-    quoteId?: string;
-    referrer?: string;
-    protocolMethod?: string;
-    spokePool?: string;
-    innerTarget?: string;
-    depositor?: string;
-    bridgeToken?: string;
-    bridgeAmount?: bigint;
-    bridgeReceiver?: string;
-    bridgeOutputToken?: string;
-    bridgeOutputAmount?: bigint;
-    requestId?: string;
-    outputTokenReference?: BridgeTokenReference;
-    outputAmountReference?: BridgeAmountReference;
-    destinationCallData?: string;
-    hasDestinationCall?: boolean;
-    unresolvedFields?: string[];
-    /** Non-personal call structure retained for unsupported-path diagnostics. */
-    diagnostics?: BridgeErrorContext;
-};
-export type DecodeHit = {
-    ok: true;
-    parsed: ParsedBridgeCall;
-} | {
-    ok: false;
-    method?: string;
-    reason: string;
-    error_code: BridgeErrorCode;
-    stage: BridgeErrorStage;
-    errors: BridgeErrorDetail[];
-};
-export type BridgeCheck = {
-    ok: boolean;
-    aggregatorId: string;
-    method?: string;
-    reason?: string;
-    parsed?: ParsedBridgeCall;
-    unverifiedFields?: string[];
-    error_code?: BridgeErrorCode;
-    stage?: BridgeErrorStage;
-    errors: BridgeErrorDetail[];
-};
-export type BridgeCalldataTx = {
-    to?: string;
-    from?: string;
-    chainId?: string | number | bigint;
-    data?: string;
-    input?: string;
-    value?: string | number | bigint;
-};
-export declare const txCalldata: (tx: BridgeCalldataTx) => string;
-export declare const txValue: (tx: BridgeCalldataTx) => bigint;