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

package/dist/calldata/mayan/swapAndForwardEth.d.ts

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

package/dist/calldata/mayan/swapAndForwardEth.js

@@ -0,0 +1,23 @@
+import { asBigint, asString, decodeCall } from '../abi.js';
+import { finishForward } from './forward.js';
+export const swapAndForwardEth = {
+    name: 'swapAndForwardEth',
+    selector: '0xfa74fd43',
+    decode(data, value) {
+        const args = decodeCall([
+            { name: 'amountIn', kind: 'uint' },
+            { name: 'swapProtocol', kind: 'address' },
+            { name: 'swapData', kind: 'bytes' },
+            { name: 'middleToken', kind: 'address' },
+            { name: 'minMiddleAmount', kind: 'uint' },
+            { name: 'mayanProtocol', kind: 'address' },
+            { name: 'mayanData', kind: 'bytes' },
+        ], data);
+        const amount = asBigint(args.amountIn);
+        return finishForward('swapAndForwardEth', asString(args.mayanProtocol), asString(args.mayanData), {
+            token: '0x0000000000000000000000000000000000000000',
+            amount: amount > 0n ? amount : value,
+            protocolAmount: asBigint(args.minMiddleAmount),
+        });
+    },
+};

package/dist/calldata/mayan/swiftCreateOrder.d.ts

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

package/dist/calldata/mayan/swiftCreateOrder.js

@@ -0,0 +1,49 @@
+import { asBigint, asRecord, asString, decodeCall } from '../abi.js';
+import { accountFromBytes32 } from '../hex.js';
+import { mayanDestination } from './destination.js';
+const params = {
+    name: 'params',
+    kind: 'tuple',
+    components: [
+        { name: 'payloadType', kind: 'uint' },
+        { name: 'trader', kind: 'bytes', size: 32 },
+        { name: 'destAddr', kind: 'bytes', size: 32 },
+        { name: 'destChainId', kind: 'uint' },
+        { name: 'referrerAddr', kind: 'bytes', size: 32 },
+        { name: 'tokenOut', kind: 'bytes', size: 32 },
+        { name: 'minAmountOut', kind: 'uint' },
+        { name: 'gasDrop', kind: 'uint' },
+        { name: 'cancelFee', kind: 'uint' },
+        { name: 'refundFee', kind: 'uint' },
+        { name: 'deadline', kind: 'uint' },
+        { name: 'referrerBps', kind: 'uint' },
+        { name: 'auctionMode', kind: 'uint' },
+        { name: 'random', kind: 'bytes', size: 32 },
+    ],
+};
+export const SWIFT_CREATE_ORDER = '0xa3a30834';
+export const decodeSwiftCreateOrder = (data) => {
+    const args = decodeCall([
+        { name: 'tokenIn', kind: 'address' },
+        { name: 'amountIn', kind: 'uint' },
+        params,
+        { name: 'customPayload', kind: 'bytes' },
+    ], data);
+    const order = asRecord(args.params);
+    const customPayload = asString(args.customPayload);
+    const destination = mayanDestination('wormhole', asBigint(order.destChainId), accountFromBytes32(asString(order.tokenOut)), asBigint(order.minAmountOut));
+    if (customPayload !== '0x') {
+        delete destination.outputToken;
+        delete destination.outputAmountReference;
+    }
+    return {
+        protocolMethod: 'createOrderWithToken',
+        sourceToken: asString(args.tokenIn),
+        sourceAmount: asBigint(args.amountIn),
+        ...destination,
+        bridgeReceiver: accountFromBytes32(asString(order.destAddr)),
+        receiver: customPayload === '0x' ? accountFromBytes32(asString(order.destAddr)) : undefined,
+        destinationCallData: customPayload === '0x' ? undefined : customPayload,
+        referrer: accountFromBytes32(asString(order.referrerAddr)),
+    };
+};

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

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

package/dist/calldata/mayan/validate.js

@@ -0,0 +1,20 @@
+import { BRIDGE_ERRORS } from '../../errors/index.js';
+import { isZeroWord } from '../hex.js';
+export const mayanFailure = (parsed) => {
+    if (!parsed.protocolMethod) {
+        return BRIDGE_ERRORS.UNRECOGNIZED_MAYAN_PROTOCOL_CALLDATA;
+    }
+    if (parsed.destinationChainId === undefined && !parsed.destinationChainRef) {
+        return BRIDGE_ERRORS.MISSING_DESTINATION;
+    }
+    if (isZeroWord(parsed.receiver ?? parsed.bridgeReceiver)) {
+        return BRIDGE_ERRORS.MISSING_RECEIVER;
+    }
+    if ((parsed.sourceAmount ?? 0n) <= 0n) {
+        return BRIDGE_ERRORS.MISSING_SOURCE_AMOUNT;
+    }
+    if (parsed.protocolMethod !== 'bridge' && parsed.outputToken === undefined && !parsed.outputTokenReference && !parsed.destinationCallData) {
+        return BRIDGE_ERRORS.MISSING_OUTPUT_TOKEN;
+    }
+    return undefined;
+};

package/dist/calldata/protocols.d.ts

@@ -0,0 +1,9 @@
+export declare const NATIVE_TOKEN = "0x0000000000000000000000000000000000000000";
+export declare const WRAPPED_NATIVE_TOKENS: Record<string, string>;
+export declare const isNative: (token: string) => boolean;
+export declare const CCTP_CHAINS: Record<string, bigint>;
+export declare const WORMHOLE_CHAINS: Record<string, bigint>;
+export declare const LAYERZERO_CHAINS: Record<string, bigint>;
+export declare const CCIP_CHAINS: Record<string, bigint>;
+export declare const CCTP_USDC: Record<string, string>;
+export declare const subtractFees: (amount: bigint, ...fees: bigint[]) => bigint;

package/dist/calldata/protocols.js

@@ -0,0 +1,58 @@
+import { BRIDGE_ERRORS, BridgeError } from '../errors/index.js';
+export const NATIVE_TOKEN = '0x0000000000000000000000000000000000000000';
+export const WRAPPED_NATIVE_TOKENS = {
+    1: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+    10: '0x4200000000000000000000000000000000000006',
+    56: '0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c',
+    130: '0x4200000000000000000000000000000000000006',
+    137: '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270',
+    4663: '0x0bd7d308f8e1639fab988df18a8011f41eacad73',
+    8453: '0x4200000000000000000000000000000000000006',
+    42161: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1',
+    43114: '0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7',
+    57073: '0x4200000000000000000000000000000000000006',
+};
+export const isNative = (token) => token === NATIVE_TOKEN || token.toLowerCase() === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee';
+// Circle CCTP domains and Wormhole IDs are different namespaces from EVM chain IDs.
+export const CCTP_CHAINS = {
+    0: 1n, 1: 43114n, 2: 10n, 3: 42161n, 6: 8453n, 7: 137n,
+    10: 130n, 11: 59144n, 13: 146n, 15: 143n, 19: 999n, 21: 57073n,
+};
+export const WORMHOLE_CHAINS = {
+    2: 1n, 4: 56n, 5: 137n, 6: 43114n, 23: 42161n, 24: 10n,
+    30: 8453n, 38: 59144n, 44: 130n, 47: 999n, 48: 143n, 52: 146n,
+};
+// Mainnet endpoint IDs from LayerZero's network metadata; v1 and v2 IDs coexist.
+export const LAYERZERO_CHAINS = {
+    101: 1n, 30101: 1n, 102: 56n, 30102: 56n, 106: 43114n, 30106: 43114n,
+    109: 137n, 30109: 137n, 110: 42161n, 30110: 42161n, 111: 10n, 30111: 10n,
+    184: 8453n, 30184: 8453n, 183: 59144n, 30183: 59144n, 181: 5000n, 30181: 5000n,
+    320: 130n, 30320: 130n, 332: 146n, 30332: 146n, 340: 1868n, 30340: 1868n,
+    367: 999n, 30367: 999n, 370: 98866n, 30370: 98866n, 383: 9745n, 30383: 9745n,
+    390: 143n, 30390: 143n, 416: 4663n, 30416: 4663n,
+    255: 252n, 30255: 252n, 280: 1329n, 30280: 1329n,
+};
+export const CCIP_CHAINS = {
+    '5009297550715157269': 1n, '15971525489660198786': 8453n, '11344663589394136015': 56n,
+};
+// Canonical Circle USDC, not a symbol-based or quote-provided token mapping.
+export const CCTP_USDC = {
+    1: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    10: '0x0b2c639c533813f4aa9d7837caf62653d097ff85',
+    137: '0x3c499c542cef5e3811e1192ce70d8cc03d5c3359',
+    8453: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
+    42161: '0xaf88d065e77c8cc2239327c5edb3a432268e5831',
+    43114: '0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e',
+    130: '0x078d782b760474a361dda0af3839290b0ef57ad6',
+    143: '0x754704bc059f8c67012fed69bc8a327a5aafb603',
+    146: '0x29219dd400f2bf60e5a23d13be72b486d4038894',
+    999: '0xb88339cb7199b77e23db6e890353e22632ba630f',
+    59144: '0x176211869ca2b568f2a7d4ee941e073a821ee1ff',
+    57073: '0x2d270e6886d130d724215a266106e6832161eaed',
+};
+export const subtractFees = (amount, ...fees) => {
+    const total = fees.reduce((sum, fee) => sum + fee, 0n);
+    if (total > amount)
+        throw new BridgeError(BRIDGE_ERRORS.BRIDGE_FEES_EXCEED_THE_INPUT_AMOUNT);
+    return amount - total;
+};

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

@@ -0,0 +1,13 @@
+import { type AbiParam, type AbiValue } from '../abi.js';
+import type { ParsedBridgeCall } from '../types.js';
+export declare const callTuple: AbiParam;
+export declare const callsParam: AbiParam;
+export declare const requestIdFromMetadata: (metadata: string) => string | undefined;
+export declare const relayCall: (method: string, metadata: string, value: bigint, calls: AbiValue, source?: {
+    token?: string;
+    amount?: bigint;
+}) => ParsedBridgeCall;
+export declare const firstPositive: (values: AbiValue[]) => {
+    token?: string;
+    amount: bigint;
+};

package/dist/calldata/relay/calls.js

@@ -0,0 +1,58 @@
+import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
+import { asBigint, asRecord, asString } from '../abi.js';
+import { isZeroWord } from '../hex.js';
+import { NATIVE_TOKEN } from '../protocols.js';
+import { nestedRelayOrder } from './nestedDeposit.js';
+export const callTuple = {
+    name: 'call',
+    kind: 'tuple',
+    components: [
+        { name: 'target', kind: 'address' },
+        { name: 'allowFailure', kind: 'bool' },
+        { name: 'value', kind: 'uint' },
+        { name: 'callData', kind: 'bytes' },
+    ],
+};
+export const callsParam = {
+    name: 'calls',
+    kind: 'array',
+    item: callTuple,
+};
+export const requestIdFromMetadata = (metadata) => {
+    const body = metadata.toLowerCase().replace(/^0x/, '');
+    if (body.length < 64) {
+        return undefined;
+    }
+    const requestId = `0x${body.slice(0, 64)}`;
+    return isZeroWord(requestId) ? undefined : requestId;
+};
+export const relayCall = (method, metadata, value, calls, source) => ({
+    aggregatorId: 'relay',
+    method,
+    kind: 'deposit',
+    requestId: requestIdFromMetadata(metadata),
+    sourceToken: source?.token ?? (value > 0n ? NATIVE_TOKEN : undefined),
+    sourceAmount: source?.amount && source.amount > 0n ? source.amount : value,
+    ...nestedRelayOrder(calls, method === 'transferAndMulticall' && value === 0n && source?.token && source.amount !== undefined
+        ? { token: source.token, amount: source.amount }
+        : method === 'multicall' && value > 0n ? { token: NATIVE_TOKEN, amount: value } : undefined),
+});
+const amountOf = (record) => {
+    const amount = record.amount ?? record.value;
+    return asBigint(amount);
+};
+export const firstPositive = (values) => {
+    let amount = 0n;
+    let token;
+    for (const value of values) {
+        const record = asRecord(value);
+        amount += amountOf(record);
+        if (record.token) {
+            const current = asString(record.token);
+            if (token && token !== current)
+                throw new BridgeError(BRIDGE_ERRORS.MULTIPLE_SOURCE_ASSETS_ARE_NOT_SUPPORTED);
+            token = current;
+        }
+    }
+    return { token, amount };
+};

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

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

package/dist/calldata/relay/depositErc20.js

@@ -0,0 +1,22 @@
+import { asBigint, asString, decodeCall } from '../abi.js';
+export const depositErc20 = {
+    name: 'depositErc20',
+    selector: '0xe8017952',
+    decode(data) {
+        const args = decodeCall([
+            { name: 'depositor', kind: 'address' },
+            { name: 'token', kind: 'address' },
+            { name: 'amount', kind: 'uint' },
+            { name: 'id', kind: 'bytes', size: 32 },
+        ], data);
+        return {
+            aggregatorId: 'relay',
+            method: 'depositErc20',
+            kind: 'deposit',
+            sourceToken: asString(args.token),
+            sourceAmount: asBigint(args.amount),
+            orderId: asString(args.id),
+            depositor: asString(args.depositor),
+        };
+    },
+};

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

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

package/dist/calldata/relay/depositErc20Allowance.js

@@ -0,0 +1,20 @@
+import { asString, decodeCall } from '../abi.js';
+export const depositErc20Allowance = {
+    name: 'depositErc20Allowance',
+    selector: '0x5a1ee3ac',
+    decode(data) {
+        const args = decodeCall([
+            { name: 'depositor', kind: 'address' },
+            { name: 'token', kind: 'address' },
+            { name: 'id', kind: 'bytes', size: 32 },
+        ], data);
+        return {
+            aggregatorId: 'relay',
+            method: 'depositErc20Allowance',
+            kind: 'deposit',
+            sourceToken: asString(args.token),
+            orderId: asString(args.id),
+            depositor: asString(args.depositor),
+        };
+    },
+};

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

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

package/dist/calldata/relay/depositNative.js

@@ -0,0 +1,20 @@
+import { asString, decodeCall } from '../abi.js';
+export const depositNative = {
+    name: 'depositNative',
+    selector: '0x49290c1c',
+    decode(data, value) {
+        const args = decodeCall([
+            { name: 'depositor', kind: 'address' },
+            { name: 'id', kind: 'bytes', size: 32 },
+        ], data);
+        return {
+            aggregatorId: 'relay',
+            method: 'depositNative',
+            kind: 'deposit',
+            sourceToken: '0x0000000000000000000000000000000000000000',
+            sourceAmount: value,
+            orderId: asString(args.id),
+            depositor: asString(args.depositor),
+        };
+    },
+};

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

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

package/dist/calldata/relay/index.js

@@ -0,0 +1,45 @@
+import { matchMethod } from '../match.js';
+import { finishCheck } from '../expect.js';
+import { depositErc20 } from './depositErc20.js';
+import { depositErc20Allowance } from './depositErc20Allowance.js';
+import { depositNative } from './depositNative.js';
+import { multicall } from './multicall.js';
+import { permit2TransferAndMulticall } from './permit2TransferAndMulticall.js';
+import { permit3009TransferAndMulticall } from './permit3009TransferAndMulticall.js';
+import { permit3009TransferAndMulticallSigned } from './permit3009TransferAndMulticallSigned.js';
+import { permitTransferAndMulticall } from './permitTransferAndMulticall.js';
+import { permitTransferAndMulticallLegacy } from './permitTransferAndMulticallLegacy.js';
+import { transferAndMulticall } from './transferAndMulticall.js';
+import { getBridgeRouter } from '../../list.js';
+import { relayFailure } from './validate.js';
+import { BRIDGE_ERRORS } from '../../errors/index.js';
+const METHODS = [
+    depositErc20,
+    depositErc20Allowance,
+    depositNative,
+    multicall,
+    transferAndMulticall,
+    permit2TransferAndMulticall,
+    permit3009TransferAndMulticall,
+    permit3009TransferAndMulticallSigned,
+    permitTransferAndMulticall,
+    permitTransferAndMulticallLegacy,
+];
+export const decodeRelay = (data, value) => matchMethod(METHODS, data, value);
+const relayCompareMask = (parsed) => ({
+    fromToken: parsed.sourceToken !== undefined,
+    fromAmount: parsed.sourceAmount !== undefined && parsed.sourceToken !== undefined,
+    toToken: false,
+    toAmount: false,
+    receiver: false,
+});
+export const validateRelay = (data, value, expectation, chainId = '') => {
+    const hit = decodeRelay(data, value);
+    if (!hit.ok) {
+        return { ...hit, aggregatorId: 'relay' };
+    }
+    return finishCheck('relay', hit.parsed, hit.parsed.innerTarget && chainId && hit.parsed.innerTarget !== getBridgeRouter('relay', chainId)
+        ? BRIDGE_ERRORS.RELAY_CANONICAL_DEPOSITORY_MISMATCH
+        : expectation && hit.parsed.depositor !== undefined && hit.parsed.depositor !== expectation.userAddress.toLowerCase()
+            ? BRIDGE_ERRORS.DEPOSITOR_MISMATCH : relayFailure(hit.parsed), expectation, chainId, relayCompareMask(hit.parsed));
+};

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

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

package/dist/calldata/relay/multicall.js

@@ -0,0 +1,15 @@
+import { asString, decodeCall } from '../abi.js';
+import { callsParam, relayCall } from './calls.js';
+export const multicall = {
+    name: 'multicall',
+    selector: '0xcd6e13f7',
+    decode(data, value) {
+        const args = decodeCall([
+            callsParam,
+            { name: 'refundTo', kind: 'address' },
+            { name: 'nftRecipient', kind: 'address' },
+            { name: 'metadata', kind: 'bytes' },
+        ], data);
+        return relayCall('multicall', asString(args.metadata), value, args.calls);
+    },
+};

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

@@ -0,0 +1,8 @@
+import { type AbiValue } from '../abi.js';
+import type { ParsedBridgeCall } from '../types.js';
+export declare const relayFundingRouter: (method: string, target: string) => string | undefined;
+/** Read one final deposit from actual calls, never from metadata or signatures. */
+export declare const nestedRelayOrder: (rawCalls: AbiValue, funding?: {
+    token: string;
+    amount: bigint;
+}) => Pick<ParsedBridgeCall, "orderId" | "depositor" | "innerTarget" | "bridgeToken" | "bridgeAmount" | "bridgeReceiver"> | undefined;

package/dist/calldata/relay/nestedDeposit.js

@@ -0,0 +1,107 @@
+import { depositErc20 } from './depositErc20.js';
+import { depositErc20Allowance } from './depositErc20Allowance.js';
+import { depositNative } from './depositNative.js';
+import { asArray, asBigint, asRecord, asString, decodeCall } from '../abi.js';
+import { BRIDGE_ROUTER_WHITELIST } from '../../list.js';
+import { isZeroWord, readSelector } from '../hex.js';
+import { NATIVE_TOKEN } from '../protocols.js';
+const DEPOSITORIES = new Set(Object.values(BRIDGE_ROUTER_WHITELIST.relay));
+// shortcut: reviewed v3.2 cleanup wrappers only; review new deployments before adding them.
+const PROXY_ROUTERS = {
+    '0x5567954cd026cebfe486062cb75848e0f1c12e58': '0x0729e2a4716d9f7dd17858d5d504426d228697f7',
+    '0xe4dfbd5e6784db1058124e2c87554c0591f0fb7b': '0x6328ea02d28131e58b28e55c6258258a30d90e05',
+};
+const ROUTERS = new Set(Object.values(PROXY_ROUTERS));
+export const relayFundingRouter = (method, target) => method === 'transferAndMulticall' ? PROXY_ROUTERS[target]
+    : method === 'multicall' && ROUTERS.has(target) ? target : undefined;
+const CLEANUP_NATIVE = '0x5d1fe6a2';
+const CLEANUP_ERC20 = '0x73b7bb2f';
+/** Read one final deposit from actual calls, never from metadata or signatures. */
+export const nestedRelayOrder = (rawCalls, funding) => {
+    try {
+        const calls = asArray(rawCalls).map(asRecord);
+        if (!calls.length)
+            return undefined;
+        // Multiple deposit/cleanup calls cannot be bound to a single backend order.
+        if (calls.slice(0, -1).some((call) => DEPOSITORIES.has(asString(call.target)) ||
+            (ROUTERS.has(asString(call.target)) && [CLEANUP_NATIVE, CLEANUP_ERC20].includes(readSelector(asString(call.callData)) ?? ''))))
+            return undefined;
+        const last = calls[calls.length - 1];
+        if (last.allowFailure !== false)
+            return undefined;
+        let target = asString(last.target), data = asString(last.callData);
+        const wrapper = ROUTERS.has(target) ? target : undefined;
+        let value = asBigint(last.value);
+        let token;
+        let nativeCleanup = false;
+        let cleanupAmount;
+        if (ROUTERS.has(target)) {
+            if (value !== 0n)
+                return undefined;
+            if (readSelector(data) === CLEANUP_NATIVE) {
+                const args = decodeCall([{ name: 'amount', kind: 'uint' }, { name: 'to', kind: 'address' }, { name: 'data', kind: 'bytes' }], data);
+                target = asString(args.to);
+                data = asString(args.data);
+                value = asBigint(args.amount);
+                cleanupAmount = value;
+                nativeCleanup = true;
+            }
+            else if (readSelector(data) === CLEANUP_ERC20) {
+                const args = decodeCall([
+                    { name: 'tokens', kind: 'array', item: { name: 'token', kind: 'address' } },
+                    { name: 'tos', kind: 'array', item: { name: 'to', kind: 'address' } },
+                    { name: 'datas', kind: 'array', item: { name: 'data', kind: 'bytes' } },
+                    { name: 'amounts', kind: 'array', item: { name: 'amount', kind: 'uint' } },
+                ], data);
+                if (Object.values(args).some((items) => asArray(items).length !== 1))
+                    return undefined;
+                target = asString(asArray(args.tos)[0]);
+                data = asString(asArray(args.datas)[0]);
+                token = asString(asArray(args.tokens)[0]);
+                cleanupAmount = asBigint(asArray(args.amounts)[0]);
+            }
+            else
+                return undefined;
+        }
+        if (!DEPOSITORIES.has(target))
+            return undefined;
+        const method = [depositNative, depositErc20, depositErc20Allowance].find((item) => item.selector === readSelector(data));
+        if (!method || (nativeCleanup && method !== depositNative) || (token && method === depositNative))
+            return undefined;
+        const parsed = method.decode(data, value);
+        if (isZeroWord(parsed.orderId) || (token && token !== parsed.sourceToken))
+            return undefined;
+        const result = { orderId: parsed.orderId, depositor: parsed.depositor, innerTarget: target };
+        if (!funding || funding.amount <= 0n || funding.token !== parsed.sourceToken)
+            return result;
+        // shortcut: only one approval before deposit; add funding analysis before supporting swaps/other calls.
+        const prefix = calls.slice(0, -1);
+        if (prefix.length > 1)
+            return result;
+        let approved;
+        if (prefix.length) {
+            const call = prefix[0];
+            if (funding.token === NATIVE_TOKEN || call.allowFailure !== false ||
+                asString(call.target) !== funding.token || asBigint(call.value) !== 0n ||
+                readSelector(asString(call.callData)) !== '0x095ea7b3')
+                return result;
+            const args = decodeCall([{ name: 'spender', kind: 'address' }, { name: 'amount', kind: 'uint' }], asString(call.callData));
+            if (asString(args.spender) !== target)
+                return result;
+            approved = asBigint(args.amount);
+        }
+        // Zero cleanup means all remaining balance; here the full input is still on Router.
+        const amount = cleanupAmount === 0n ? funding.amount : cleanupAmount;
+        const depositAmount = method === depositErc20Allowance ? amount ?? approved
+            : nativeCleanup ? amount : parsed.sourceAmount;
+        if (depositAmount !== funding.amount ||
+            (cleanupAmount !== undefined && amount !== funding.amount) ||
+            (method !== depositNative && value !== 0n))
+            return result;
+        return { ...result, bridgeToken: funding.token, bridgeAmount: funding.amount, bridgeReceiver: wrapper };
+    }
+    catch {
+        // Unknown or malformed calls leave the order unresolved for the signing check.
+        return undefined;
+    }
+};

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

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

package/dist/calldata/relay/permit2TransferAndMulticall.js

@@ -0,0 +1,42 @@
+import { asArray, asRecord, asString, decodeCall } from '../abi.js';
+import { callsParam, firstPositive, relayCall } from './calls.js';
+const permit = {
+    name: 'permit',
+    kind: 'tuple',
+    components: [
+        {
+            name: 'permitted',
+            kind: 'array',
+            item: {
+                name: 'tokenPermissions',
+                kind: 'tuple',
+                components: [
+                    { name: 'token', kind: 'address' },
+                    { name: 'amount', kind: 'uint' },
+                ],
+            },
+        },
+        { name: 'nonce', kind: 'uint' },
+        { name: 'deadline', kind: 'uint' },
+    ],
+};
+export const permit2TransferAndMulticall = {
+    name: 'permit2TransferAndMulticall',
+    selector: '0x0a2b8f36',
+    decode(data, value) {
+        const args = decodeCall([
+            { name: 'user', kind: 'address' },
+            permit,
+            callsParam,
+            { name: 'refundTo', kind: 'address' },
+            { name: 'nftRecipient', kind: 'address' },
+            { name: 'metadata', kind: 'bytes' },
+            { name: 'permitSignature', kind: 'bytes' },
+        ], data);
+        const source = firstPositive(asArray(asRecord(args.permit).permitted));
+        return {
+            ...relayCall('permit2TransferAndMulticall', asString(args.metadata), value, args.calls, source),
+            depositor: asString(args.user),
+        };
+    },
+};

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

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

package/dist/calldata/relay/permit3009TransferAndMulticall.js

@@ -0,0 +1,41 @@
+import { asArray, asString, decodeCall } from '../abi.js';
+import { callsParam, firstPositive, relayCall } from './calls.js';
+const permits = {
+    name: 'permits',
+    kind: 'array',
+    item: {
+        name: 'permit',
+        kind: 'tuple',
+        components: [
+            { name: 'from', kind: 'address' },
+            { name: 'value', kind: 'uint' },
+            { name: 'validAfter', kind: 'uint' },
+            { name: 'validBefore', kind: 'uint' },
+            { name: 'v', kind: 'uint' },
+            { name: 'r', kind: 'bytes', size: 32 },
+            { name: 's', kind: 'bytes', size: 32 },
+        ],
+    },
+};
+const decodePermits = (name, selector, tail) => ({
+    name,
+    selector,
+    decode(data, value) {
+        const args = decodeCall([
+            permits,
+            { name: 'tokens', kind: 'array', item: { name: 'token', kind: 'address' } },
+            callsParam,
+            { name: 'refundTo', kind: 'address' },
+            { name: 'nftRecipient', kind: 'address' },
+            { name: 'metadata', kind: 'bytes' },
+            ...tail,
+        ], data);
+        const source = firstPositive(asArray(args.permits));
+        const tokens = asArray(args.tokens).map((token) => asString(token));
+        return relayCall(name, asString(args.metadata), value, args.calls, {
+            token: tokens[0] ?? source.token,
+            amount: source.amount,
+        });
+    },
+});
+export const permit3009TransferAndMulticall = decodePermits('permit3009TransferAndMulticall', '0xf80f00fb', []);

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

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