@silentswap/react 0.0.78 → 0.0.80

package/dist/contexts/orderTrackingConnection.js

@@ -0,0 +1,327 @@
+/**
+ * Order tracking WebSocket and cache logic.
+ * Lives in context via createOrderTrackingManager(); state updates go through setStateForKey.
+ */
+import { OutputStage, DEFAULT_ORDER_TRACKING_STATE, getStatusTextFromStage, getProgressFromStage, hasFinalizedOutput, isFullOrderStatus, getOrderTrackingCacheKey, buildOrderTrackingWsUrl, } from './orderTrackingTypes.js';
+const wsCache = new Map();
+const pendingCleanups = new Map();
+const statusCache = new Map();
+function buildFullState(key, status, isConnected, isLoading, error) {
+    const outputsList = status.outputs ?? [];
+    const numOutputs = outputsList.length || 1;
+    const newOutputs = [];
+    const newProgresses = [];
+    const newStatusTexts = [];
+    for (let index = 0; index < outputsList.length; index++) {
+        const output = outputsList[index];
+        const outputAsset = output.output ??
+            (output.asset
+                ? { caip19: output.asset, amount: output.value || '0', decimals: 0 }
+                : undefined);
+        newOutputs.push({
+            index,
+            stage: output.stage,
+            timestamp: output.timestamp,
+            recipient: output.recipient,
+            asset: outputAsset,
+            txs: output.txs,
+        });
+        newProgresses.push(getProgressFromStage(output.stage));
+        newStatusTexts.push(getStatusTextFromStage(output.stage));
+    }
+    const allFinalized = newOutputs.length > 0 && newOutputs.every((o) => o.stage === OutputStage.FINALIZED);
+    const completedTimestamp = outputsList.length > 0
+        ? outputsList.reduce((min, o) => (min == null || o.timestamp < min ? o.timestamp : min), null)
+        : null;
+    return {
+        isConnected,
+        isLoading,
+        error,
+        orderStatus: status,
+        deposit: status.deposit
+            ? {
+                amount: status.deposit.amount,
+                timestamp: status.deposit.timestamp,
+                duration: status.deposit.duration,
+                orderId: status.deposit.orderId,
+                tx: status.deposit.tx,
+            }
+            : null,
+        outputs: newOutputs.length ? newOutputs : [],
+        progresses: newProgresses.length ? newProgresses : new Array(numOutputs).fill(undefined),
+        statusTexts: newStatusTexts.length ? newStatusTexts : new Array(numOutputs).fill('Connecting'),
+        completedTimestamp: allFinalized ? completedTimestamp : null,
+        isComplete: allFinalized,
+    };
+}
+function applyFullStatus(getApi, key, status, cacheConn, isConnected, isLoading, error) {
+    const api = getApi();
+    const current = api.getStateForKey(key)?.orderStatus;
+    const currentFinalized = current && hasFinalizedOutput(current);
+    const incomingFinalized = hasFinalizedOutput(status);
+    if (currentFinalized && !incomingFinalized)
+        return;
+    if (cacheConn) {
+        cacheConn.initialStatus = status;
+        statusCache.set(getOrderTrackingCacheKey(cacheConn.orderId, cacheConn.auth), status);
+    }
+    const state = buildFullState(key, status, isConnected, isLoading, error);
+    api.setStateForKey(key, state);
+    api.getOptionsForKey(key)?.onStatusUpdate?.(status);
+}
+function submitRequest(conn, method, params, handler) {
+    if (conn.ws.readyState !== WebSocket.OPEN)
+        return -1;
+    const requestId = conn.requestCounter++;
+    const request = { jsonrpc: '2.0', id: requestId, method, params };
+    if (handler)
+        conn.responseHandlers.set(requestId, handler);
+    conn.ws.send(JSON.stringify(request));
+    return requestId;
+}
+export function createOrderTrackingManager(apiRef) {
+    const getApi = () => apiRef.current;
+    const reconnectTimeoutRef = { current: null };
+    function handleStatusUpdate(key, update, conn, getCurrentState) {
+        conn.statusUpdates.push(update);
+        const prev = getCurrentState() ?? DEFAULT_ORDER_TRACKING_STATE;
+        let next = { ...prev };
+        switch (update.type) {
+            case 'deposit':
+                next = {
+                    ...next,
+                    deposit: {
+                        amount: update.data.amount,
+                        timestamp: update.data.timestamp,
+                        duration: update.data.duration,
+                        orderId: update.data.orderId,
+                        tx: update.data.tx,
+                    },
+                };
+                break;
+            case 'stage': {
+                const idx = update.data.index;
+                const progress = getProgressFromStage(update.data.stage);
+                const statusText = getStatusTextFromStage(update.data.stage);
+                const newOutputs = [...(next.outputs || [])];
+                newOutputs[idx] = {
+                    ...newOutputs[idx],
+                    index: idx,
+                    stage: update.data.stage,
+                    timestamp: update.data.timestamp,
+                    ...(update.data.asset ? { asset: update.data.asset } : {}),
+                };
+                const newProgresses = [...(next.progresses || [])];
+                newProgresses[idx] = progress;
+                const newStatusTexts = [...(next.statusTexts || [])];
+                newStatusTexts[idx] = statusText;
+                next = {
+                    ...next,
+                    outputs: newOutputs,
+                    progresses: newProgresses,
+                    statusTexts: newStatusTexts,
+                };
+                const allOne = newProgresses.every((p) => (p ?? 0) >= 1);
+                if (allOne) {
+                    next = {
+                        ...next,
+                        isComplete: true,
+                        completedTimestamp: next.completedTimestamp ?? update.data.timestamp,
+                    };
+                    getApi().getOptionsForKey(key)?.onComplete?.();
+                }
+                break;
+            }
+            case 'transaction': {
+                const newOutputs = [...(next.outputs || [])];
+                if (newOutputs[update.data.index]) {
+                    const existingTxs = newOutputs[update.data.index].txs || {};
+                    newOutputs[update.data.index] = {
+                        ...newOutputs[update.data.index],
+                        txs: {
+                            ...existingTxs,
+                            [update.data.kind]: {
+                                txId: update.data.txId,
+                                chain: update.data.chain,
+                            },
+                        },
+                    };
+                }
+                next = { ...next, outputs: newOutputs };
+                break;
+            }
+            case 'error': {
+                const err = new Error(update.data.message || 'Order tracking error');
+                next = { ...next, error: err };
+                getApi().getOptionsForKey(key)?.onError?.(err);
+                break;
+            }
+        }
+        getApi().setStateForKey(key, next);
+    }
+    function connect(orderId, auth, key, options) {
+        const client = options.client;
+        const pendingCleanup = pendingCleanups.get(key);
+        if (pendingCleanup) {
+            clearTimeout(pendingCleanup);
+            pendingCleanups.delete(key);
+        }
+        if (reconnectTimeoutRef.current) {
+            clearTimeout(reconnectTimeoutRef.current);
+            reconnectTimeoutRef.current = null;
+        }
+        const cached = wsCache.get(key);
+        if (cached &&
+            (cached.ws.readyState === WebSocket.OPEN || cached.ws.readyState === WebSocket.CONNECTING)) {
+            if (cached.initialStatus) {
+                const status = cached.initialStatus;
+                applyFullStatus(getApi, key, status, cached, true, false, null);
+            }
+            return;
+        }
+        wsCache.delete(key);
+        const cachedStatus = statusCache.get(key);
+        if (cachedStatus) {
+            applyFullStatus(getApi, key, cachedStatus, null, false, false, null);
+        }
+        else {
+            getApi().setStateForKey(key, {
+                ...DEFAULT_ORDER_TRACKING_STATE,
+                isLoading: true,
+            });
+        }
+        const wsUrl = buildOrderTrackingWsUrl(client);
+        let ws;
+        try {
+            ws = new WebSocket(wsUrl);
+        }
+        catch (err) {
+            const e = err instanceof Error ? err : new Error('Failed to connect to order tracking');
+            getApi().setStateForKey(key, {
+                ...DEFAULT_ORDER_TRACKING_STATE,
+                error: e,
+                isLoading: false,
+            });
+            options.onError?.(e);
+            return;
+        }
+        const conn = {
+            ws,
+            orderId,
+            auth,
+            requestCounter: 0,
+            responseHandlers: new Map(),
+            lastReceived: 0,
+            reconnectTimeout: null,
+            initialStatus: null,
+            statusUpdates: [],
+        };
+        wsCache.set(key, conn);
+        ws.onopen = () => {
+            conn.lastReceived = Date.now();
+            const connectRequestId = submitRequest(conn, 'connect', { auth: { orderId, viewingAuth: auth } }, (rpcError, result) => {
+                if (rpcError) {
+                    const err = new Error(rpcError.message || 'Connection error');
+                    if (!getApi().isKeyActive(key))
+                        return;
+                    getApi().setStateForKey(key, {
+                        ...DEFAULT_ORDER_TRACKING_STATE,
+                        error: err,
+                        isLoading: false,
+                    });
+                    getApi().getOptionsForKey(key)?.onError?.(err);
+                    return;
+                }
+                if (!getApi().isKeyActive(key))
+                    return;
+                const status = result;
+                conn.statusUpdates = [];
+                applyFullStatus(getApi, key, status, conn, true, false, null);
+                if (connectRequestId >= 0) {
+                    conn.responseHandlers.set(connectRequestId, (statusError, statusResult) => {
+                        if (statusError) {
+                            const err = new Error(statusError.message || 'Status error');
+                            if (!getApi().isKeyActive(key))
+                                return;
+                            const prev = getApi().getStateForKey(key) ?? DEFAULT_ORDER_TRACKING_STATE;
+                            getApi().setStateForKey(key, { ...prev, error: err });
+                            getApi().getOptionsForKey(key)?.onError?.(err);
+                            return;
+                        }
+                        if (!getApi().isKeyActive(key))
+                            return;
+                        if (isFullOrderStatus(statusResult)) {
+                            applyFullStatus(getApi, key, statusResult, conn, true, false, null);
+                            return;
+                        }
+                        handleStatusUpdate(key, statusResult, conn, () => getApi().getStateForKey(key));
+                    });
+                }
+                getApi().getOptionsForKey(key)?.onStatusUpdate?.(status);
+            });
+        };
+        ws.onmessage = (event) => {
+            conn.lastReceived = Date.now();
+            try {
+                const response = JSON.parse(event.data);
+                if (response.jsonrpc !== '2.0' || typeof response.id !== 'number')
+                    return;
+                const handler = conn.responseHandlers.get(response.id);
+                if (handler)
+                    handler(response.error, response.result);
+            }
+            catch {
+                // ignore
+            }
+        };
+        ws.onerror = () => {
+            if (!getApi().isKeyActive(key))
+                return;
+            const prev = getApi().getStateForKey(key) ?? DEFAULT_ORDER_TRACKING_STATE;
+            getApi().setStateForKey(key, {
+                ...prev,
+                error: new Error('WebSocket connection error'),
+                isLoading: false,
+            });
+        };
+        ws.onclose = () => {
+            if (wsCache.get(key)?.ws === ws)
+                wsCache.delete(key);
+            conn.responseHandlers.clear();
+            conn.initialStatus = null;
+            conn.statusUpdates = [];
+            if (getApi().isKeyActive(key)) {
+                const prev = getApi().getStateForKey(key) ?? DEFAULT_ORDER_TRACKING_STATE;
+                getApi().setStateForKey(key, { ...prev, isConnected: false });
+                const idle = Date.now() - conn.lastReceived > 90_000;
+                if (idle) {
+                    reconnectTimeoutRef.current = setTimeout(() => {
+                        if (getApi().isKeyActive(key))
+                            connect(orderId, auth, key, getApi().getOptionsForKey(key) ?? {});
+                    }, 5000);
+                }
+                else {
+                    connect(orderId, auth, key, getApi().getOptionsForKey(key) ?? {});
+                }
+            }
+        };
+    }
+    function disconnect(orderId, auth) {
+        if (reconnectTimeoutRef.current) {
+            clearTimeout(reconnectTimeoutRef.current);
+            reconnectTimeoutRef.current = null;
+        }
+        const key = getOrderTrackingCacheKey(orderId, auth);
+        const ws = wsCache.get(key)?.ws;
+        if (ws) {
+            pendingCleanups.set(key, setTimeout(() => {
+                pendingCleanups.delete(key);
+                if (wsCache.get(key)?.ws === ws) {
+                    wsCache.delete(key);
+                    ws.close();
+                }
+            }, 500));
+        }
+    }
+    return { connect, disconnect };
+}

package/dist/contexts/orderTrackingTypes.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Shared types and helpers for order tracking (WebSocket + context).
+ * Used by orderTrackingConnection.ts and useOrderTracking.ts.
+ */
+import type { SilentSwapClient } from '@silentswap/sdk';
+export declare enum OutputStage {
+    NONE = "NONE",
+    INIT = "INIT",
+    FUNDED = "FUNDED",
+    REDEEMED = "REDEEMED",
+    IBC_SENT = "IBC_SENT",
+    IBC_RCVD = "IBC_RCVD",
+    BRIDGE_SENT = "BRIDGE_SENT",
+    BRIDGE_CFRM = "BRIDGE_CFRM",
+    BRIDGE_RCVD = "BRIDGE_RCVD",
+    SWAP_USDC_GAS = "SWAP_USDC_GAS",
+    SWAP_USDC_TRG = "SWAP_USDC_TRG",
+    LTRL_TRG_SENT = "LTRL_TRG_SENT",
+    LTRL_TRG_RCVD = "LTRL_TRG_RCVD",
+    SWAP_TRG_DST = "SWAP_TRG_DST",
+    XFER_TRG_DST = "XFER_TRG_DST",
+    REFUND_NATIVE = "REFUND_NATIVE",
+    FINALIZED = "FINALIZED"
+}
+export type OrderDeposit = {
+    amount: string;
+    timestamp: number;
+    duration: number;
+    orderId?: string;
+    tx?: string;
+};
+export type OrderTransactions = {
+    RECEIPT?: {
+        chain: string;
+        txId: string;
+    };
+    REFUND?: {
+        chain: string;
+        txId: string;
+    };
+};
+export type OutputStatus = {
+    index: number;
+    stage: OutputStage;
+    timestamp: number;
+    recipient?: string;
+    asset?: {
+        caip19: string;
+        amount: string;
+        decimals: number;
+        priceUsd?: number;
+    };
+    txs?: OrderTransactions;
+};
+export type IOutput = {
+    caip19: string;
+    amount: string;
+    decimals: number;
+    priceUsd?: number;
+};
+export type Outputs = Array<{
+    stage: OutputStage;
+    timestamp: number;
+    asset: string;
+    value: string;
+    recipient: string;
+    txs?: OrderTransactions;
+    output?: IOutput;
+}>;
+export type OrderStatus = {
+    priority?: string;
+    signer: string;
+    deposit?: OrderDeposit;
+    outputs: Outputs;
+    metadata?: {
+        sourceAsset?: {
+            caip19: string;
+            amount: string;
+        };
+        sourceSender?: {
+            contactId: string;
+        };
+    };
+};
+export type StatusUpdate = {
+    type: 'deposit';
+    data: OrderDeposit;
+} | {
+    type: 'stage';
+    data: {
+        orderId: string;
+        index: number;
+        stage: OutputStage;
+        timestamp: number;
+        asset?: {
+            caip19: string;
+            amount: string;
+            decimals: number;
+            priceUsd?: number;
+        };
+    };
+} | {
+    type: 'transaction';
+    data: {
+        orderId: string;
+        index: number;
+        chain: string;
+        txId: string;
+        kind: keyof OrderTransactions;
+    };
+} | {
+    type: 'error';
+    data: {
+        orderId: string;
+        message: string;
+        index?: number;
+    };
+};
+export type JsonRpcError = {
+    code: number;
+    message: string;
+    data?: unknown;
+};
+export type OrderTrackingState = {
+    isConnected: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    orderStatus: OrderStatus | null;
+    deposit: OrderDeposit | null;
+    outputs: OutputStatus[];
+    progresses: (number | undefined)[];
+    statusTexts: string[];
+    completedTimestamp: number | null;
+    isComplete: boolean;
+};
+export type OrderTrackingOptions = {
+    client?: SilentSwapClient;
+    onStatusUpdate?: (status: OrderStatus) => void;
+    onError?: (error: Error) => void;
+    onComplete?: () => void;
+    fetchAssetPrice?: (caip19: string) => Promise<number>;
+};
+export declare const DEFAULT_ORDER_TRACKING_STATE: OrderTrackingState;
+export declare function getStatusTextFromStage(stage: OutputStage): string;
+export declare function getProgressFromStage(stage: OutputStage): number;
+export declare function getOrderTrackingCacheKey(orderId: string, auth: string): string;
+export declare function hasFinalizedOutput(status: OrderStatus): boolean;
+export declare function isFullOrderStatus(result: unknown): result is OrderStatus;
+export declare function buildOrderTrackingWsUrl(client?: SilentSwapClient): string;

package/dist/contexts/orderTrackingTypes.js

@@ -0,0 +1,151 @@
+/**
+ * Shared types and helpers for order tracking (WebSocket + context).
+ * Used by orderTrackingConnection.ts and useOrderTracking.ts.
+ */
+export var OutputStage;
+(function (OutputStage) {
+    OutputStage["NONE"] = "NONE";
+    OutputStage["INIT"] = "INIT";
+    OutputStage["FUNDED"] = "FUNDED";
+    OutputStage["REDEEMED"] = "REDEEMED";
+    OutputStage["IBC_SENT"] = "IBC_SENT";
+    OutputStage["IBC_RCVD"] = "IBC_RCVD";
+    OutputStage["BRIDGE_SENT"] = "BRIDGE_SENT";
+    OutputStage["BRIDGE_CFRM"] = "BRIDGE_CFRM";
+    OutputStage["BRIDGE_RCVD"] = "BRIDGE_RCVD";
+    OutputStage["SWAP_USDC_GAS"] = "SWAP_USDC_GAS";
+    OutputStage["SWAP_USDC_TRG"] = "SWAP_USDC_TRG";
+    OutputStage["LTRL_TRG_SENT"] = "LTRL_TRG_SENT";
+    OutputStage["LTRL_TRG_RCVD"] = "LTRL_TRG_RCVD";
+    OutputStage["SWAP_TRG_DST"] = "SWAP_TRG_DST";
+    OutputStage["XFER_TRG_DST"] = "XFER_TRG_DST";
+    OutputStage["REFUND_NATIVE"] = "REFUND_NATIVE";
+    OutputStage["FINALIZED"] = "FINALIZED";
+})(OutputStage || (OutputStage = {}));
+export const DEFAULT_ORDER_TRACKING_STATE = {
+    isConnected: false,
+    isLoading: false,
+    error: null,
+    orderStatus: null,
+    deposit: null,
+    outputs: [],
+    progresses: [undefined],
+    statusTexts: ['Connecting'],
+    completedTimestamp: null,
+    isComplete: false,
+};
+export function getStatusTextFromStage(stage) {
+    switch (stage) {
+        case OutputStage.NONE:
+            return 'Uncertain state';
+        case OutputStage.INIT:
+            return 'Verifying deposit';
+        case OutputStage.FUNDED:
+            return 'Initializing';
+        case OutputStage.REDEEMED:
+            return 'Anonymizing';
+        case OutputStage.IBC_SENT:
+            return 'Moving';
+        case OutputStage.IBC_RCVD:
+            return 'Staging';
+        case OutputStage.BRIDGE_SENT:
+        case OutputStage.BRIDGE_CFRM:
+        case OutputStage.BRIDGE_RCVD:
+            return 'Bridging';
+        case OutputStage.SWAP_USDC_GAS:
+            return 'Fueling';
+        case OutputStage.SWAP_USDC_TRG:
+            return 'Swapping';
+        case OutputStage.LTRL_TRG_SENT:
+        case OutputStage.LTRL_TRG_RCVD:
+        case OutputStage.SWAP_TRG_DST:
+            return 'Finalizing';
+        case OutputStage.XFER_TRG_DST:
+        case OutputStage.REFUND_NATIVE:
+        case OutputStage.FINALIZED:
+            return 'Completed';
+        default:
+            return 'Processing';
+    }
+}
+export function getProgressFromStage(stage) {
+    switch (stage) {
+        case OutputStage.NONE:
+        case OutputStage.INIT:
+            return 0;
+        case OutputStage.FUNDED:
+            return 0.1;
+        case OutputStage.REDEEMED:
+            return 0.15;
+        case OutputStage.IBC_SENT:
+            return 0.25;
+        case OutputStage.IBC_RCVD:
+            return 0.35;
+        case OutputStage.BRIDGE_SENT:
+            return 0.5;
+        case OutputStage.BRIDGE_CFRM:
+            return 0.6;
+        case OutputStage.BRIDGE_RCVD:
+            return 0.7;
+        case OutputStage.SWAP_USDC_GAS:
+            return 0.8;
+        case OutputStage.SWAP_USDC_TRG:
+            return 0.9;
+        case OutputStage.LTRL_TRG_SENT:
+        case OutputStage.LTRL_TRG_RCVD:
+        case OutputStage.SWAP_TRG_DST:
+            return 0.95;
+        case OutputStage.XFER_TRG_DST:
+        case OutputStage.REFUND_NATIVE:
+        case OutputStage.FINALIZED:
+            return 1;
+        default:
+            return 0;
+    }
+}
+export function getOrderTrackingCacheKey(orderId, auth) {
+    return `${orderId}|${auth}`;
+}
+export function hasFinalizedOutput(status) {
+    return status.outputs?.some((o) => o.stage === OutputStage.FINALIZED) ?? false;
+}
+const STATUS_UPDATE_TYPES = ['deposit', 'stage', 'transaction', 'error'];
+export function isFullOrderStatus(result) {
+    if (typeof result !== 'object' || result === null)
+        return false;
+    const r = result;
+    const hasOutputs = Array.isArray(r.outputs) && r.outputs.length > 0;
+    const hasType = typeof r.type === 'string' && STATUS_UPDATE_TYPES.includes(r.type);
+    return hasOutputs && !hasType;
+}
+export function buildOrderTrackingWsUrl(client) {
+    let wsUrl;
+    if (typeof window !== 'undefined' && window.__WEBSOCKET_URL__) {
+        wsUrl = window.__WEBSOCKET_URL__;
+    }
+    else if (client) {
+        const baseUrl = client.baseUrl;
+        try {
+            const url = new URL(baseUrl);
+            wsUrl = `${url.protocol === 'https:' ? 'wss:' : 'ws:'}//${url.host}/websocket`;
+        }
+        catch {
+            wsUrl = baseUrl.replace(/^https?:\/\//, 'wss://').replace(/^http:\/\//, 'ws://') + '/websocket';
+        }
+    }
+    else if (typeof window !== 'undefined') {
+        wsUrl = `${window.location.protocol === 'https:' ? 'wss' : 'ws'}://${window.location.host}/websocket`;
+    }
+    else {
+        wsUrl = 'ws://localhost/websocket';
+    }
+    try {
+        const url = new URL(wsUrl);
+        const protocol = url.protocol === 'https:' || url.protocol === 'wss:' ? 'wss:' : 'ws:';
+        wsUrl = `${protocol}//${url.host}/websocket`;
+    }
+    catch {
+        wsUrl = wsUrl.split('?')[0].split('#')[0].replace(/\/+$/, '') + '/websocket';
+    }
+    return wsUrl;
+}

package/dist/hooks/silent/useBridgeExecution.d.ts

@@ -39,5 +39,5 @@ export interface BridgeExecutionResult {
 export declare function useBridgeExecution(walletClient: WalletClient | undefined, connector: Connector | undefined, solanaConnector: SolanaWalletConnector | undefined, solanaConnection: SolanaConnection | undefined, solanaRpcUrl: string | undefined, setCurrentStep: (step: string) => void, depositorAddress: Hex, onStatus?: (status: string) => void, bitcoinConnector?: BitcoinWalletConnector, bitcoinConnection?: BitcoinConnection): {
     executeSolanaBridge: (sourceAsset: string, sourceAmount: string, usdcAmount: string | undefined, solanaSenderAddress: string, evmSignerAddress: `0x${string}`, depositParams?: DepositParams<`${bigint}`>) => Promise<BridgeExecutionResult>;
     executeBitcoinBridge: (sourceAsset: string, sourceAmount: string, usdcAmount: string | undefined, bitcoinSenderAddress: string, evmSignerAddress: `0x${string}`, depositParams?: DepositParams<`${bigint}`>) => Promise<BridgeExecutionResult>;
-    executeEvmBridge: (sourceChainId: number, sourceTokenAddress: string, sourceAmount: string, usdcAmount: string | undefined, depositParams: DepositParams<`${bigint}`>, evmSignerAddress: `0x${string}`, evmSenderAddress?: `0x${string}`, provider?: "relay" | "debridge") => Promise<BridgeExecutionResult>;
+    executeEvmBridge: (sourceChainId: number, sourceTokenAddress: string, sourceAmount: string, usdcAmount: string | undefined, depositParams: DepositParams<`${bigint}`>, evmSignerAddress: `0x${string}`, evmSenderAddress?: `0x${string}`, provider?: "relay" | "debridge", allowanceTarget?: string) => Promise<BridgeExecutionResult>;
 };