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

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

@@ -0,0 +1,71 @@
+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,
+            refundRecipients: [asString(a.callValueRefundAddress), asString(a.excessFeeRefundAddress)],
+            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

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

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

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

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

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

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

package/dist/calldata/socket/swapAndBridge.js

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

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

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

@@ -0,0 +1,86 @@
+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;
+    /** Refund beneficiaries encoded in this transaction, independent of final delivery. */
+    refundRecipients?: string[];
+    /** Set when a fixed allowlisted contract satisfies the receiver check. */
+    fixedReceiver?: boolean;
+    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

@@ -0,0 +1,20 @@
+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;
+};