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

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,86 +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 { isNative, NATIVE_TOKEN } from '../../protocols.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' || selector === '0x3345e738') {
-        const native = selector === '0x3345e738';
-        if (target !== '0x97caca78ac2a94c67643d07843f85afaa44a3ea5' || 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

@@ -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,33 +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}` };
-    // Stargate's one-byte bus command changes transport, not the recipient. Compose
-    // can execute arbitrary destination code and still needs a dedicated decoder.
-    const direct = legacy || (asString(a.composeMsg) === '0x' && ['0x', '0x01'].includes(asString(a.oftCmd)));
-    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,41 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError, 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'));
-        }
-        const protocol = readSocketBridge(callData, target, token, value, asString(hop.approvalSpender));
-        if (protocol.protocolMethod === 'receiveNative' && protocol.bridgeAmount !== amount) {
-            throw new BridgeError(BRIDGE_ERRORS.SOCKET_DEPOSIT_AMOUNT_MISMATCH, protocol.diagnostics);
-        }
-        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,
-            ...protocol,
-        };
-    },
-};

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,24 +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 (['receiveERC20', 'receiveNative'].includes(parsed.protocolMethod ?? '') && parsed.orderId !== parsed.quoteId) {
-        return BRIDGE_ERRORS.SOCKET_RFQ_QUOTE_ID_MISMATCH;
-    }
-    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;

package/dist/calldata/types.js

@@ -1,20 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../errors/index.js';
-export const txCalldata = (tx) => tx.data || tx.input || '0x';
-export const txValue = (tx) => {
-    const { value } = tx;
-    if (value === undefined || value === null || value === '') {
-        return 0n;
-    }
-    if (typeof value === 'number' && !Number.isSafeInteger(value))
-        throw new BridgeError(BRIDGE_ERRORS.INVALID_TRANSACTION_VALUE);
-    let amount;
-    try {
-        amount = BigInt(value);
-    }
-    catch {
-        throw new BridgeError(BRIDGE_ERRORS.INVALID_TRANSACTION_VALUE);
-    }
-    if (amount < 0n)
-        throw new BridgeError(BRIDGE_ERRORS.INVALID_TRANSACTION_VALUE);
-    return amount;
-};