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

package/dist/calldata/across/deposit.js

@@ -1,36 +0,0 @@
-import { applyAcrossMessage } from '../destination.js';
-import { asBigint, asString, decodeCall } from '../abi.js';
-import { accountFromBytes32 } from '../hex.js';
-const fields = [
-    { name: 'depositor', kind: 'bytes', size: 32 },
-    { name: 'recipient', kind: 'bytes', size: 32 },
-    { name: 'inputToken', kind: 'bytes', size: 32 },
-    { name: 'outputToken', kind: 'bytes', size: 32 },
-    { name: 'inputAmount', kind: 'uint' },
-    { name: 'outputAmount', kind: 'uint' },
-    { name: 'destinationChainId', kind: 'uint' },
-    { name: 'exclusiveRelayer', kind: 'bytes', size: 32 },
-    { name: 'quoteTimestamp', kind: 'uint' },
-    { name: 'fillDeadline', kind: 'uint' },
-    { name: 'exclusivityParameter', kind: 'uint' },
-    { name: 'message', kind: 'bytes' },
-];
-export const deposit = {
-    name: 'deposit',
-    selector: '0xad5425c6',
-    decode(data) {
-        const args = decodeCall(fields, data);
-        return applyAcrossMessage({
-            aggregatorId: 'across',
-            method: 'deposit',
-            kind: 'bridge',
-            depositor: accountFromBytes32(asString(args.depositor)),
-            sourceToken: accountFromBytes32(asString(args.inputToken)),
-            sourceAmount: asBigint(args.inputAmount),
-            destinationChainId: asBigint(args.destinationChainId),
-            receiver: accountFromBytes32(asString(args.recipient)),
-            outputToken: accountFromBytes32(asString(args.outputToken)),
-            minOutputAmount: asBigint(args.outputAmount),
-        }, asString(args.message));
-    },
-};

package/dist/calldata/across/depositNative.d.ts

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

package/dist/calldata/across/depositNative.js

@@ -1,45 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
-import { applyAcrossMessage } from '../destination.js';
-import { asBigint, asString, decodeCall } from '../abi.js';
-import { accountFromBytes32 } from '../hex.js';
-import { NATIVE_TOKEN } from '../protocols.js';
-const fields = [
-    { name: 'spokePool', kind: 'address' },
-    { name: 'depositor', kind: 'address' },
-    { name: 'recipient', kind: 'bytes', size: 32 },
-    { name: 'inputToken', kind: 'address' },
-    { name: 'inputAmount', kind: 'uint' },
-    { name: 'outputToken', kind: 'bytes', size: 32 },
-    { name: 'outputAmount', kind: 'uint' },
-    { name: 'destinationChainId', kind: 'uint' },
-    { name: 'exclusiveRelayer', kind: 'bytes', size: 32 },
-    { name: 'quoteTimestamp', kind: 'uint' },
-    { name: 'fillDeadline', kind: 'uint' },
-    { name: 'exclusivityParameter', kind: 'uint' },
-    { name: 'message', kind: 'bytes' },
-];
-export const depositNative = {
-    name: 'depositNative',
-    selector: '0x609ea081',
-    decode(data, value) {
-        const args = decodeCall(fields, data);
-        const inputAmount = asBigint(args.inputAmount);
-        if (inputAmount > 0n && value !== inputAmount)
-            throw new BridgeError(BRIDGE_ERRORS.ACROSS_NATIVE_VALUE_MISMATCH);
-        return applyAcrossMessage({
-            aggregatorId: 'across',
-            method: 'depositNative',
-            kind: 'bridge',
-            depositor: asString(args.depositor),
-            sourceToken: NATIVE_TOKEN,
-            sourceAmount: inputAmount > 0n ? inputAmount : value,
-            bridgeToken: asString(args.inputToken),
-            bridgeAmount: inputAmount > 0n ? inputAmount : value,
-            destinationChainId: asBigint(args.destinationChainId),
-            receiver: accountFromBytes32(asString(args.recipient)),
-            outputToken: accountFromBytes32(asString(args.outputToken)),
-            minOutputAmount: asBigint(args.outputAmount),
-            spokePool: asString(args.spokePool),
-        }, asString(args.message));
-    },
-};

package/dist/calldata/across/depositNow.d.ts

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

package/dist/calldata/across/depositNow.js

@@ -1,35 +0,0 @@
-import { applyAcrossMessage } from '../destination.js';
-import { asBigint, asString, decodeCall } from '../abi.js';
-import { accountFromBytes32 } from '../hex.js';
-const fields = [
-    { name: 'depositor', kind: 'bytes', size: 32 },
-    { name: 'recipient', kind: 'bytes', size: 32 },
-    { name: 'inputToken', kind: 'bytes', size: 32 },
-    { name: 'outputToken', kind: 'bytes', size: 32 },
-    { name: 'inputAmount', kind: 'uint' },
-    { name: 'outputAmount', kind: 'uint' },
-    { name: 'destinationChainId', kind: 'uint' },
-    { name: 'exclusiveRelayer', kind: 'bytes', size: 32 },
-    { name: 'fillDeadlineOffset', kind: 'uint' },
-    { name: 'exclusivityParameter', kind: 'uint' },
-    { name: 'message', kind: 'bytes' },
-];
-export const depositNow = {
-    name: 'depositNow',
-    selector: '0xea86bd46',
-    decode(data) {
-        const args = decodeCall(fields, data);
-        return applyAcrossMessage({
-            aggregatorId: 'across',
-            method: 'depositNow',
-            kind: 'bridge',
-            depositor: accountFromBytes32(asString(args.depositor)),
-            sourceToken: accountFromBytes32(asString(args.inputToken)),
-            sourceAmount: asBigint(args.inputAmount),
-            destinationChainId: asBigint(args.destinationChainId),
-            receiver: accountFromBytes32(asString(args.recipient)),
-            outputToken: accountFromBytes32(asString(args.outputToken)),
-            minOutputAmount: asBigint(args.outputAmount),
-        }, asString(args.message));
-    },
-};

package/dist/calldata/across/depositV3.d.ts

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

package/dist/calldata/across/depositV3.js

@@ -1,35 +0,0 @@
-import { applyAcrossMessage } from '../destination.js';
-import { asBigint, asString, decodeCall } from '../abi.js';
-const fields = [
-    { name: 'depositor', kind: 'address' },
-    { name: 'recipient', kind: 'address' },
-    { name: 'inputToken', kind: 'address' },
-    { name: 'outputToken', kind: 'address' },
-    { name: 'inputAmount', kind: 'uint' },
-    { name: 'outputAmount', kind: 'uint' },
-    { name: 'destinationChainId', kind: 'uint' },
-    { name: 'exclusiveRelayer', kind: 'address' },
-    { name: 'quoteTimestamp', kind: 'uint' },
-    { name: 'fillDeadline', kind: 'uint' },
-    { name: 'exclusivityParameter', kind: 'uint' },
-    { name: 'message', kind: 'bytes' },
-];
-export const depositV3 = {
-    name: 'depositV3',
-    selector: '0x7b939232',
-    decode(data) {
-        const args = decodeCall(fields, data);
-        return applyAcrossMessage({
-            aggregatorId: 'across',
-            method: 'depositV3',
-            kind: 'bridge',
-            depositor: asString(args.depositor),
-            sourceToken: asString(args.inputToken),
-            sourceAmount: asBigint(args.inputAmount),
-            destinationChainId: asBigint(args.destinationChainId),
-            receiver: asString(args.recipient),
-            outputToken: asString(args.outputToken),
-            minOutputAmount: asBigint(args.outputAmount),
-        }, asString(args.message));
-    },
-};

package/dist/calldata/across/depositV3Now.d.ts

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

package/dist/calldata/across/depositV3Now.js

@@ -1,34 +0,0 @@
-import { applyAcrossMessage } from '../destination.js';
-import { asBigint, asString, decodeCall } from '../abi.js';
-const fields = [
-    { name: 'depositor', kind: 'address' },
-    { name: 'recipient', kind: 'address' },
-    { name: 'inputToken', kind: 'address' },
-    { name: 'outputToken', kind: 'address' },
-    { name: 'inputAmount', kind: 'uint' },
-    { name: 'outputAmount', kind: 'uint' },
-    { name: 'destinationChainId', kind: 'uint' },
-    { name: 'exclusiveRelayer', kind: 'address' },
-    { name: 'fillDeadlineOffset', kind: 'uint' },
-    { name: 'exclusivityParameter', kind: 'uint' },
-    { name: 'message', kind: 'bytes' },
-];
-export const depositV3Now = {
-    name: 'depositV3Now',
-    selector: '0x7aef642c',
-    decode(data) {
-        const args = decodeCall(fields, data);
-        return applyAcrossMessage({
-            aggregatorId: 'across',
-            method: 'depositV3Now',
-            kind: 'bridge',
-            depositor: asString(args.depositor),
-            sourceToken: asString(args.inputToken),
-            sourceAmount: asBigint(args.inputAmount),
-            destinationChainId: asBigint(args.destinationChainId),
-            receiver: asString(args.recipient),
-            outputToken: asString(args.outputToken),
-            minOutputAmount: asBigint(args.outputAmount),
-        }, asString(args.message));
-    },
-};

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

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

package/dist/calldata/across/index.js

@@ -1,31 +0,0 @@
-import { matchMethod } from '../match.js';
-import { finishCheck } from '../expect.js';
-import { deposit } from './deposit.js';
-import { depositNative } from './depositNative.js';
-import { depositNow } from './depositNow.js';
-import { depositV3 } from './depositV3.js';
-import { depositV3Now } from './depositV3Now.js';
-import { swapAndBridge } from './swapAndBridge.js';
-import { acrossFailure } from './validate.js';
-const METHODS = [
-    depositV3,
-    deposit,
-    depositV3Now,
-    depositNow,
-    depositNative,
-    swapAndBridge,
-];
-export const decodeAcross = (data, value) => matchMethod(METHODS, data, value);
-export const validateAcross = (data, value, expectation, chainId = '') => {
-    const hit = decodeAcross(data, value);
-    if (!hit.ok) {
-        return { ...hit, aggregatorId: 'across' };
-    }
-    return finishCheck('across', hit.parsed, acrossFailure(hit.parsed, chainId, expectation?.userAddress), expectation, chainId, {
-        fromToken: true,
-        fromAmount: true,
-        toToken: true,
-        toAmount: true,
-        receiver: true,
-    });
-};

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

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

package/dist/calldata/across/swapAndBridge.js

@@ -1,70 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
-import { applyAcrossMessage } from '../destination.js';
-import { asBigint, asRecord, asString, decodeCall } from '../abi.js';
-import { accountFromBytes32 } from '../hex.js';
-import { NATIVE_TOKEN } from '../protocols.js';
-const swapAndDepositData = {
-    name: 'swapAndDepositData',
-    kind: 'tuple',
-    components: [
-        {
-            name: 'submissionFees',
-            kind: 'tuple',
-            components: [
-                { name: 'amount', kind: 'uint' },
-                { name: 'recipient', kind: 'address' },
-            ],
-        },
-        {
-            name: 'depositData',
-            kind: 'tuple',
-            components: [
-                { name: 'inputToken', kind: 'address' },
-                { name: 'outputToken', kind: 'bytes', size: 32 },
-                { name: 'outputAmount', kind: 'uint' },
-                { name: 'depositor', kind: 'address' },
-                { name: 'recipient', kind: 'bytes', size: 32 },
-                { name: 'destinationChainId', kind: 'uint' },
-                { name: 'exclusiveRelayer', kind: 'bytes', size: 32 },
-                { name: 'quoteTimestamp', kind: 'uint' },
-                { name: 'fillDeadline', kind: 'uint' },
-                { name: 'exclusivityParameter', kind: 'uint' },
-                { name: 'message', kind: 'bytes' },
-            ],
-        },
-        { name: 'swapToken', kind: 'address' },
-        { name: 'exchange', kind: 'address' },
-        { name: 'transferType', kind: 'uint' },
-        { name: 'swapTokenAmount', kind: 'uint' },
-        { name: 'minExpectedInputTokenAmount', kind: 'uint' },
-        { name: 'routerCalldata', kind: 'bytes' },
-        { name: 'enableProportionalAdjustment', kind: 'bool' },
-        { name: 'spokePool', kind: 'address' },
-        { name: 'nonce', kind: 'uint' },
-    ],
-};
-export const swapAndBridge = {
-    name: 'swapAndBridge',
-    selector: '0x110560ad',
-    decode(data, value) {
-        const args = asRecord(decodeCall([swapAndDepositData], data).swapAndDepositData);
-        const depositData = asRecord(args.depositData);
-        const sourceAmount = asBigint(args.swapTokenAmount);
-        if (value > 0n && value !== sourceAmount)
-            throw new BridgeError(BRIDGE_ERRORS.ACROSS_SWAP_VALUE_MISMATCH);
-        return applyAcrossMessage({
-            aggregatorId: 'across',
-            method: 'swapAndBridge',
-            kind: 'bridge',
-            depositor: asString(depositData.depositor),
-            sourceToken: value > 0n ? NATIVE_TOKEN : asString(args.swapToken),
-            sourceAmount,
-            destinationChainId: asBigint(depositData.destinationChainId),
-            receiver: accountFromBytes32(asString(depositData.recipient)),
-            outputToken: accountFromBytes32(asString(depositData.outputToken)),
-            minOutputAmount: asBigint(depositData.outputAmount),
-            spokePool: asString(args.spokePool),
-            innerTarget: asString(args.exchange),
-        }, asString(depositData.message));
-    },
-};

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

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

package/dist/calldata/across/validate.js

@@ -1,30 +0,0 @@
-import { BRIDGE_ERRORS } from '../../errors/index.js';
-import { getBridgeRouter } from '../../list.js';
-import { evmChainId } from '../chains.js';
-import { isZeroWord } from '../hex.js';
-export const acrossFailure = (parsed, chainId, expectedDepositor) => {
-    if (expectedDepositor && parsed.depositor?.toLowerCase() !== expectedDepositor.toLowerCase()) {
-        return BRIDGE_ERRORS.DEPOSITOR_MISMATCH;
-    }
-    if (parsed.destinationChainId === undefined || parsed.destinationChainId <= 0n) {
-        return BRIDGE_ERRORS.MISSING_DESTINATION_CHAIN;
-    }
-    if (isZeroWord(parsed.receiver ?? parsed.bridgeReceiver)) {
-        return BRIDGE_ERRORS.MISSING_RECEIVER;
-    }
-    if ((parsed.sourceAmount ?? 0n) <= 0n) {
-        return BRIDGE_ERRORS.MISSING_SOURCE_AMOUNT;
-    }
-    if (!parsed.spokePool) {
-        return undefined;
-    }
-    const spoke = parsed.spokePool.toLowerCase();
-    // BSC's configured outer router is a periphery, separate from its canonical SpokePool.
-    const expectedSpoke = evmChainId(chainId) === 56n
-        ? '0x4e8e101924ede233c13e2d8622dc8aed2872d505'
-        : getBridgeRouter('across', chainId)?.toLowerCase();
-    if (expectedSpoke !== spoke) {
-        return BRIDGE_ERRORS.SPOKE_POOL_IS_NOT_IN_THE_ALLOWLIST;
-    }
-    return undefined;
-};

package/dist/calldata/chains.d.ts

@@ -1,2 +0,0 @@
-export declare const evmChainId: (chain: string) => bigint | undefined;
-export declare const sourceChainMismatch: (expected: string, actual?: string | number | bigint) => boolean;

package/dist/calldata/chains.js

@@ -1,35 +0,0 @@
-import { CHAIN_ENUM_TO_SERVER_ID, normalizeChainEnum } from '../chains.js';
-const CHAIN_IDS = {
-    eth: 1n, op: 10n, flr: 14n, cro: 25n, rsk: 30n, xdc: 50n, bsc: 56n,
-    xdai: 100n, fuse: 122n, uni: 130n, matic: 137n, monad: 143n, sonic: 146n,
-    manta: 169n, xlayer: 196n, opbnb: 204n, lens: 232n, frax: 252n, era: 324n,
-    stable: 988n, hyper: 999n, metis: 1088n, lisk: 1135n, sei: 1329n, story: 1514n,
-    gravity: 1625n, soneium: 1868n, swell: 1923n, ron: 2020n, abs: 2741n,
-    morph: 2818n, tempo: 4217n, megaeth: 4326n, hood: 4663n, world: 480n,
-    mnt: 5000n, arc: 5042n, cyber: 7560n, klay: 8217n, base: 8453n, plasma: 9745n,
-    ape: 33139n, mode: 34443n, arb: 42161n, celo: 42220n, hemi: 43111n, avax: 43114n,
-    zircuit: 48900n, sophon: 50104n, ink: 57073n, linea: 59144n, bob: 60808n,
-    bera: 80094n, blast: 81457n, plume: 98866n, taiko: 167000n, scrl: 534352n,
-    katana: 747474n, zora: 7777777n,
-    ethereum: 1n, optimism: 10n, gnosis: 100n, polygon: 137n, mantle: 5000n,
-    arbitrum: 42161n, avalanche: 43114n, fraxtal: 252n,
-};
-export const evmChainId = (chain) => {
-    if (/^\d+$/.test(chain)) {
-        const id = BigInt(chain);
-        return id > 0n ? id : undefined;
-    }
-    const chainEnum = normalizeChainEnum(chain);
-    return CHAIN_IDS[chainEnum ? CHAIN_ENUM_TO_SERVER_ID[chainEnum] : chain.toLowerCase()];
-};
-export const sourceChainMismatch = (expected, actual) => {
-    if (actual === undefined)
-        return false;
-    try {
-        return (typeof actual === 'number' && !Number.isSafeInteger(actual)) ||
-            evmChainId(expected) === undefined || BigInt(actual) !== evmChainId(expected);
-    }
-    catch {
-        return true;
-    }
-};

package/dist/calldata/destination.d.ts

@@ -1,6 +0,0 @@
-import { type AbiParam, type AbiValue } from './abi.js';
-import type { ParsedBridgeCall } from './types.js';
-export declare const destinationCall: AbiParam;
-export declare const readTransfer: (target: string, data: string, value: bigint) => Partial<ParsedBridgeCall> | undefined;
-export declare const readDestinationTransfers: (calls: AbiValue[]) => Partial<ParsedBridgeCall>;
-export declare const applyAcrossMessage: (parsed: ParsedBridgeCall, message: string) => ParsedBridgeCall;

package/dist/calldata/destination.js

@@ -1,148 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError, asBridgeError } from '../errors/index.js';
-import { asArray, asBigint, asRecord, asString, decodeCall, decodeParameters } from './abi.js';
-import { isZeroWord, readSelector } from './hex.js';
-import { NATIVE_TOKEN, WRAPPED_NATIVE_TOKENS, subtractFees } from './protocols.js';
-import { calldataDiagnostics } from './diagnostics.js';
-export const destinationCall = {
-    name: 'call', kind: 'tuple', components: [
-        { name: 'target', kind: 'address' }, { name: 'data', kind: 'bytes' }, { name: 'value', kind: 'uint' },
-    ],
-};
-export const readTransfer = (target, data, value) => {
-    if (data === '0x' && value > 0n)
-        return { receiver: target, outputToken: NATIVE_TOKEN, minOutputAmount: value };
-    if (readSelector(data) !== '0xa9059cbb')
-        return undefined;
-    const args = decodeCall([{ name: 'to', kind: 'address' }, { name: 'amount', kind: 'uint' }], data);
-    return { receiver: asString(args.to), outputToken: target, minOutputAmount: asBigint(args.amount) };
-};
-export const readDestinationTransfers = (calls) => {
-    const diagnostics = { destinationCallCount: calls.length,
-        destinationSelectors: [...new Set(calls.map((call) => calldataDiagnostics(asRecord(call).data).selector)
-                .filter((selector) => Boolean(selector)))].slice(0, 16) };
-    const transfers = calls.map((call) => {
-        const c = asRecord(call);
-        return readTransfer(asString(c.target), asString(c.data), asBigint(c.value));
-    });
-    if (!transfers.length || transfers.some((transfer) => !transfer))
-        return { diagnostics };
-    const first = transfers[0];
-    if (!transfers.every((transfer) => transfer !== undefined && transfer.receiver === first.receiver && transfer.outputToken === first.outputToken))
-        return { diagnostics };
-    return { ...first, diagnostics, minOutputAmount: transfers.reduce((sum, transfer) => sum + (transfer?.minOutputAmount ?? 0n), 0n) };
-};
-const instructions = {
-    name: 'instructions', kind: 'tuple', components: [
-        { name: 'calls', kind: 'array', item: { name: 'call', kind: 'tuple', components: [
-                    { name: 'target', kind: 'address' }, { name: 'callData', kind: 'bytes' }, { name: 'value', kind: 'uint' },
-                ] } },
-        { name: 'fallbackRecipient', kind: 'address' },
-    ],
-};
-const ACROSS_MESSAGE_HANDLERS = {
-    999: '0x5e7840e06faccb6d1c3b5f5e0d1d3d07f2829bba',
-    4663: '0xa8ad2e87e2043711d8bec77e8bc3e2683c0ab6bd',
-    43114: '0x9610954acdca5ff7905f051a040ce33fe613c60e',
-};
-const readAcrossMessage = (parsed, message) => {
-    if (message === '0x') {
-        const wrapped = WRAPPED_NATIVE_TOKENS[parsed.destinationChainId?.toString() ?? ''];
-        if (parsed.outputToken !== undefined && (wrapped === undefined || parsed.outputToken === wrapped)) {
-            parsed.bridgeOutputToken = parsed.outputToken;
-            parsed.outputTokenReference = { protocol: 'across-native', token: parsed.outputToken,
-                destinationChainId: parsed.destinationChainId, destinationContract: parsed.receiver };
-            delete parsed.outputToken;
-        }
-        return parsed;
-    }
-    const handler = parsed.receiver;
-    parsed.bridgeReceiver = handler;
-    parsed.bridgeOutputToken = parsed.outputToken;
-    parsed.bridgeOutputAmount = parsed.minOutputAmount;
-    parsed.destinationCallData = message;
-    parsed.diagnostics = { hasDestinationCall: true, destinationCalldataBytes: calldataDiagnostics(message).calldataBytes };
-    delete parsed.receiver;
-    delete parsed.outputToken;
-    delete parsed.minOutputAmount;
-    // Other message handlers can implement arbitrary destination logic.
-    const expectedHandler = ACROSS_MESSAGE_HANDLERS[parsed.destinationChainId?.toString() ?? ''] ??
-        '0x0f7ae28de1c8532170ad4ee566b5801485c13a0e';
-    if (handler !== expectedHandler)
-        return parsed;
-    const emitter = parsed.destinationChainId === 43114n
-        ? '0x25b15fc38d6a2c13feddd9cb51f184f7cf0d4c11' : '0xbf75133b48b0a42ab9374027902e83c5e2949034';
-    const args = asRecord(decodeParameters([instructions], message).instructions);
-    const calls = asArray(args.calls);
-    parsed.diagnostics.destinationCallCount = calls.length;
-    parsed.diagnostics.destinationSelectors = [...new Set(calls.map((call) => calldataDiagnostics(asRecord(call).callData).selector)
-            .filter((selector) => Boolean(selector)))].slice(0, 16);
-    const balances = new Map([[parsed.bridgeOutputToken, parsed.bridgeOutputAmount]]);
-    const payouts = [];
-    for (const raw of calls) {
-        const call = asRecord(raw);
-        const target = asString(call.target);
-        const data = asString(call.callData);
-        const value = asBigint(call.value);
-        const selector = readSelector(data);
-        // emitData is telemetry; its amounts are not an enforced receive floor.
-        if (selector === '0xd836083e' && target === emitter && value === 0n)
-            continue;
-        if (selector === '0xc41e8295' && target === handler) {
-            if (value !== 0n)
-                return parsed;
-            const nested = decodeCall([
-                { name: 'target', kind: 'address' }, { name: 'data', kind: 'bytes' }, { name: 'value', kind: 'uint' },
-                { name: 'replacements', kind: 'array', item: { name: 'replacement', kind: 'tuple', components: [
-                            { name: 'token', kind: 'address' }, { name: 'offset', kind: 'uint' },
-                        ] } },
-            ], data);
-            const token = asString(nested.target);
-            const replacements = asArray(nested.replacements).map(asRecord);
-            const withdrawal = asString(nested.data);
-            if (readSelector(withdrawal) !== '0x2e1a7d4d' || replacements.length !== 1 ||
-                asBigint(decodeCall([{ name: 'amount', kind: 'uint' }], withdrawal).amount) !== 0n ||
-                asBigint(nested.value) !== 0n ||
-                asString(replacements[0].token) !== token || asBigint(replacements[0].offset) !== 4n || !balances.has(token) ||
-                WRAPPED_NATIVE_TOKENS[parsed.destinationChainId?.toString() ?? ''] !== token)
-                return parsed;
-            balances.set(NATIVE_TOKEN, (balances.get(NATIVE_TOKEN) ?? 0n) + (balances.get(token) ?? 0n));
-            balances.set(token, 0n);
-            continue;
-        }
-        if (selector === '0xef8738d3' && target === handler) {
-            if (value !== 0n)
-                return parsed;
-            const drain = decodeCall([{ name: 'token', kind: 'address' }, { name: 'receiver', kind: 'address' }], data);
-            const token = asString(drain.token);
-            const amount = balances.get(token) ?? 0n;
-            if (amount > 0n)
-                payouts.push({ outputToken: token, minOutputAmount: amount, receiver: asString(drain.receiver) });
-            balances.set(token, 0n);
-            continue;
-        }
-        const transfer = readTransfer(target, data, value);
-        if (!transfer || !balances.has(transfer.outputToken))
-            return parsed;
-        const token = transfer.outputToken;
-        balances.set(token, subtractFees(balances.get(token) ?? 0n, transfer.minOutputAmount ?? 0n));
-    }
-    if (payouts.length === 1) {
-        const fallback = asString(args.fallbackRecipient);
-        if (!isZeroWord(fallback) && fallback !== payouts[0].receiver) {
-            throw new BridgeError(BRIDGE_ERRORS.ACROSS_FALLBACK_RECEIVER_MISMATCH);
-        }
-        if (!isZeroWord(fallback) && parsed.bridgeOutputToken !== payouts[0].outputToken) {
-            throw new BridgeError(BRIDGE_ERRORS.ACROSS_FALLBACK_TOKEN_MISMATCH);
-        }
-        Object.assign(parsed, payouts[0]);
-    }
-    return parsed;
-};
-export const applyAcrossMessage = (parsed, message) => {
-    try {
-        return readAcrossMessage(parsed, message);
-    }
-    catch (error) {
-        throw asBridgeError(error, BRIDGE_ERRORS.CALLDATA_DECODE_FAILED, parsed.diagnostics);
-    }
-};

package/dist/calldata/diagnostics.d.ts

@@ -1,4 +0,0 @@
-import type { BridgeErrorContext } from '../errors/index.js';
-/** Inspect call structure only. Never retain arguments or scan arbitrary payloads for selectors. */
-export declare const calldataDiagnostics: (data: unknown) => BridgeErrorContext;
-export declare const innerCallDiagnostics: (data: string, layer: "router" | "protocol") => BridgeErrorContext;

package/dist/calldata/diagnostics.js

@@ -1,18 +0,0 @@
-/** Inspect call structure only. Never retain arguments or scan arbitrary payloads for selectors. */
-export const calldataDiagnostics = (data) => {
-    if (typeof data !== 'string')
-        return { calldataFormat: 'missing' };
-    const valid = /^0x(?:[0-9a-f]{2})*$/i.test(data);
-    const selector = /^0x[0-9a-f]{8}/i.test(data) ? data.slice(0, 10).toLowerCase() : undefined;
-    return {
-        selector,
-        calldataFormat: valid ? (data.length === 2 ? 'empty' : 'valid') : 'invalid',
-        ...(valid ? { calldataBytes: (data.length - 2) / 2 } : {}),
-    };
-};
-export const innerCallDiagnostics = (data, layer) => {
-    const { selector, calldataBytes } = calldataDiagnostics(data);
-    return layer === 'router'
-        ? { routerSelector: selector, routerCalldataBytes: calldataBytes }
-        : { protocolSelector: selector, protocolCalldataBytes: calldataBytes };
-};

package/dist/calldata/expect.d.ts

@@ -1,25 +0,0 @@
-import type { BridgeErrorDefinition } from '../errors/index.js';
-import type { BridgeCheck, ParsedBridgeCall } from './types.js';
-export type BridgeCallExpectation = {
-    userAddress: string;
-    fromTokenId: string;
-    fromTokenRawAmount: string;
-    toTokenId: string;
-    /** 目标链 id。目标币是原生币时，用它识别 `hood` 这类链 id，而不是源链 id。 */
-    toChainId?: string;
-    toTokenRawAmount?: string;
-    /** 小数滑点。0.01 表示 1%。 */
-    slippage?: string | number;
-};
-export type CompareMask = {
-    fromToken: boolean;
-    fromAmount: boolean;
-    toToken: boolean;
-    toAmount: boolean;
-    receiver: boolean;
-};
-export declare const knownCompare: (parsed: ParsedBridgeCall) => CompareMask;
-/** Actual source payment may exceed local intent by at most 0.1%; lower payments still reject. */
-export declare const sourceAmountMatches: (actual: bigint | undefined, expected: bigint) => boolean;
-export declare const expectationFailures: (parsed: ParsedBridgeCall, expectation: BridgeCallExpectation, chainId: string, mask: CompareMask) => BridgeErrorDefinition[];
-export declare const finishCheck: (aggregatorId: string, parsed: ParsedBridgeCall, structural: BridgeErrorDefinition | undefined, expectation: BridgeCallExpectation | undefined, chainId: string, mask: CompareMask) => BridgeCheck;