@silentswap/react 0.0.79 → 0.0.80

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>;
 };

package/dist/hooks/silent/useBridgeExecution.js

@@ -582,7 +582,7 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
      */
     const executeEvmBridge = useCallback(async (sourceChainId, sourceTokenAddress, sourceAmount, usdcAmount, depositParams, evmSignerAddress, // EVM signer address (must match quote request signer, used for deposit calldata)
     evmSenderAddress, // Optional EVM sender address (used for bridge quotes, matches Svelte's s0x_sender)
-    provider) => {
+    provider, allowanceTarget) => {
         try {
             if (!walletClient || !connector) {
                 throw new Error('Wallet client and connector required for EVM bridge execution');
@@ -658,7 +658,7 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
                 // DeBridge will provide its own allowanceTarget from the response if needed.
                 try {
                     return await executeDebridgeBridge(sourceChainId, sourceTokenAddress, isSourceNative, bridgeUsdcAmount, depositCalldata, evmSignerAddress, // Use EVM signer address for deposit calldata
-                    '', // allowanceTarget not needed - approval handled before bridge execution
+                    allowanceTarget ?? '', // From solve phase; create-tx with enableEstimate:false is used for approval when needed
                     depositorAddress, // Pass environment-based depositor address
                     walletClient, connector, setCurrentStep, onStatus);
                 }
@@ -835,56 +835,63 @@ walletClient, connector, setCurrentStep, onStatus) {
     // For deBridge, we need to use the wallet account address, not the extracted sender address
     // This ensures the transaction can be properly executed by the connected wallet
     const evmUserForBridge = getWalletAccountAddress(walletClient);
+    // Match Svelte Form.svelte / silentswap.ts: do NOT send enableEstimate so the API returns the tx
+    // (with allowanceTarget/allowanceValue). Approve if needed and retry, then send. Same as Svelte.
+    const debridgeParams = {
+        account: evmUserForBridge,
+        srcChainId: sourceChainId,
+        dstChainId: NI_CHAIN_ID_AVALANCHE,
+        srcChainTokenIn: isSourceNative ? S0X_ADDR_EVM_ZERO : sourceTokenAddress,
+        dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
+        srcChainTokenInAmount: 'auto',
+        dstChainTokenOutAmount: `${BigInt(bridgeUsdcAmount)}`,
+        dstChainTokenOutRecipient: depositorAddress,
+        prependOperatingExpenses: true,
+        srcChainOrderAuthorityAddress: evmUserForBridge,
+        srcChainRefundAddress: evmUserForBridge,
+        dstChainOrderAuthorityAddress: evmUserForBridge,
+        dlnHook: JSON.stringify({
+            type: 'evm_transaction_call',
+            data: {
+                to: depositorAddress,
+                calldata: depositCalldata,
+                gas: 500_000,
+            },
+        }),
+        // omit enableEstimate so API returns tx with allowanceTarget (matches Svelte debridge_order call)
+    };
     while (retryCount < maxRetries) {
-        debridgeQuote = await fetchDebridgeOrder({
-            account: evmUserForBridge, // Use wallet account address (must match transaction sender)
-            srcChainId: sourceChainId,
-            dstChainId: NI_CHAIN_ID_AVALANCHE,
-            srcChainTokenIn: isSourceNative ? S0X_ADDR_EVM_ZERO : sourceTokenAddress,
-            dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
-            srcChainTokenInAmount: 'auto',
-            dstChainTokenOutAmount: `${BigInt(bridgeUsdcAmount)}`,
-            dstChainTokenOutRecipient: depositorAddress,
-            prependOperatingExpenses: true,
-            enableEstimate: true,
-            srcChainOrderAuthorityAddress: evmUserForBridge, // Use wallet account address (must match transaction sender)
-            srcChainRefundAddress: evmUserForBridge, // Use wallet account address (must match transaction sender)
-            dstChainOrderAuthorityAddress: evmUserForBridge, // Use wallet account address (must match transaction sender)
-            dlnHook: JSON.stringify({
-                type: 'evm_transaction_call',
-                data: {
-                    to: depositorAddress,
-                    calldata: depositCalldata,
-                    gas: 500_000,
-                },
-            }),
-        });
+        debridgeQuote = await fetchDebridgeOrder(debridgeParams);
         debridgeTx = debridgeQuote.tx;
         debridgeResponse = debridgeQuote;
-        // Check if approval is needed
-        const targetAllowance = debridgeTx.allowanceTarget || allowanceTarget;
+        // If approval needed, approve and retry (matches Svelte: "if(g_debridge.tx.allowanceTarget) { await approve_spender(...); continue; }")
+        // Prefer API response; use allowanceTarget param (from solve phase) as fallback when API omits it
+        const targetAllowance = debridgeTx?.allowanceTarget || allowanceTarget;
         if (targetAllowance && !isSourceNative) {
-            const allowanceValue = debridgeTx.allowanceValue;
-            if (!allowanceValue) {
+            const allowanceValue = debridgeTx?.allowanceValue;
+            if (debridgeTx?.allowanceTarget && !allowanceValue) {
                 throw new Error('DeBridge response missing allowance value');
             }
             setCurrentStep('Approving token spending');
             onStatus?.('Approving token spending');
-            // Switch to source chain for approval
             const { publicClient } = await ensureChainAndCreateClient(sourceChainId, walletClient, connector);
+            // Match Svelte: allowance(owner, spender) where owner is the wallet that sends approve (s0x_sender)
             const currentAllowance = (await publicClient.readContract({
                 address: sourceTokenAddress,
                 abi: erc20Abi,
                 functionName: 'allowance',
-                args: [evmSignerAddress, targetAllowance],
+                args: [evmUserForBridge, targetAllowance],
             }));
-            // Approve if needed
-            if (currentAllowance < BigInt(allowanceValue)) {
+            // Need approval: when API gave a value, use it; otherwise (fallback from param) approve if allowance is zero
+            const needsApproval = allowanceValue
+                ? currentAllowance < BigInt(allowanceValue)
+                : currentAllowance === 0n;
+            if (needsApproval) {
                 const hash = await walletClient.writeContract({
                     address: sourceTokenAddress,
                     abi: erc20Abi,
                     functionName: 'approve',
-                    args: [targetAllowance, BigInt(allowanceValue)],
+                    args: [targetAllowance, XG_UINT256_MAX],
                     account: walletClient.account,
                     chain: null,
                 });
@@ -893,9 +900,8 @@ walletClient, connector, setCurrentStep, onStatus) {
             retryCount++;
             continue;
         }
-        // Check price impact
+        // Check price impact (matches Svelte)
         const impactPercent = (100 * (debridgeQuote.usdPriceImpact ?? 0)) / (debridgeQuote.estimation.srcChainTokenIn.approximateUsdValue || 1);
-        // TODO: check negative impact
         if (impactPercent > X_MAX_IMPACT_PERCENT) {
             throw new Error(`Price impact across bridge too high: ${impactPercent.toFixed(2)}%`);
         }
@@ -904,11 +910,11 @@ walletClient, connector, setCurrentStep, onStatus) {
     if (!debridgeQuote) {
         throw new Error('Failed to get deBridge quote after approvals');
     }
-    setCurrentStep('Switching to source chain');
-    onStatus?.('Switching to source chain');
-    setCurrentStep('Sending bridge transaction');
-    onStatus?.('Sending bridge transaction');
-    // Send deBridge transaction
+    // Match Svelte: "Requesting deposit..." then ensure_chain + send (no separate "Switching"/"Sending" steps;
+    // sendTransactionAndWait does the chain switch and sets its own steps)
+    setCurrentStep('Requesting deposit...');
+    onStatus?.('Requesting deposit...');
+    // Send deBridge transaction (sendTransactionAndWait switches to sourceChainId and sends)
     console.log('Sending deBridge transaction:', {
         to: debridgeQuote.tx.to,
         value: debridgeQuote.tx.value,

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

@@ -1,136 +1,11 @@
-import type { SilentSwapClient } from '@silentswap/sdk';
-/**
- * Output stage enum matching Svelte's OutputStage (string values)
- */
-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"
-}
-/**
- * Deposit information
- */
-export type OrderDeposit = {
-    amount: string;
-    timestamp: number;
-    duration: number;
-    orderId?: string;
-    tx?: string;
-};
-/**
- * Output status information
- */
-export type OutputStatus = {
-    index: number;
-    stage: OutputStage;
-    timestamp: number;
-    recipient?: string;
-    asset?: {
-        caip19: string;
-        amount: string;
-        decimals: number;
-        priceUsd?: number;
-    };
-    txs?: OrderTransactions;
-};
-/**
- * Order transactions
- */
-export type OrderTransactions = {
-    RECEIPT?: {
-        chain: string;
-        txId: string;
-    };
-    REFUND?: {
-        chain: string;
-        txId: string;
-    };
-};
 /**
- * Order tracking status (matches Svelte's OrderStatus)
- */
-export type OrderStatus = {
-    priority?: string;
-    signer: string;
-    deposit?: OrderDeposit;
-    outputs: Array<{
-        stage: OutputStage;
-        timestamp: number;
-        asset: string;
-        value: string;
-        recipient: string;
-        txs?: OrderTransactions;
-        output?: {
-            caip19: string;
-            amount: string;
-            decimals: number;
-            priceUsd?: number;
-        };
-    }>;
-    metadata?: {
-        sourceAsset?: {
-            caip19: string;
-            amount: string;
-        };
-        sourceSender?: {
-            contactId: string;
-        };
-    };
-};
-/**
- * Status update types (matches Svelte's StatusUpdate)
- */
-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;
-    };
-};
-/**
- * JSON-RPC error type
+ * Order tracking via WebSocket — state and connections live in OrdersContext.
+ * This hook subscribes to tracking for (orderId, auth) and returns the state from context.
  */
+import type { SilentSwapClient } from '@silentswap/sdk';
+import { type OutputStage, type OrderDeposit, type OutputStatus, type OrderStatus } from '../../contexts/orderTrackingTypes.js';
+export { OutputStage, getStatusTextFromStage, getProgressFromStage, getOrderTrackingCacheKey, } from '../../contexts/orderTrackingTypes.js';
+export type { OrderDeposit, OutputStatus, OrderTransactions, OrderStatus, StatusUpdate, OrderTrackingState, OrderTrackingOptions, } from '../../contexts/orderTrackingTypes.js';
 export type JsonRpcError = {
     code: number;
     message: string;
@@ -143,7 +18,7 @@ export interface UseOrderTrackingOptions {
     onStatusUpdate?: (status: OrderStatus) => void;
     onError?: (error: Error) => void;
     onComplete?: () => void;
-    /** Fetch USD price for an asset when priceUsd is missing from WS response (matching Svelte k_asset.priceUsd()) */
+    /** Fetch USD price for an asset when priceUsd is missing from WS response */
     fetchAssetPrice?: (caip19: string) => Promise<number>;
 }
 export interface UseOrderTrackingReturn {
@@ -162,20 +37,4 @@ export interface UseOrderTrackingReturn {
     getStatusText: (stage: OutputStage) => string;
     getProgress: (stage: OutputStage) => number;
 }
-/**
- * Get human-readable status text from output stage
- */
-export declare function getStatusTextFromStage(stage: OutputStage): string;
-/**
- * Get progress value (0-1) from output stage
- */
-export declare function getProgressFromStage(stage: OutputStage): number;
-/**
- * React hook for tracking SilentSwap orders via WebSocket
- *
- * Uses a module-level singleton: one WebSocket per order, reused across
- * React lifecycle events (Strict Mode, re-renders, effect re-runs).
- * Reconnection matches Svelte ws_order_subscribe: immediate reconnect,
- * 5s delay if idle >90s, no exponential backoff.
- */
 export declare function useOrderTracking({ client, orderId: initialOrderId, viewingAuth: initialAuth, onStatusUpdate, onError, onComplete, fetchAssetPrice, }?: UseOrderTrackingOptions): UseOrderTrackingReturn;