@silentswap/react 0.0.48 → 0.0.50

package/dist/contexts/SilentSwapContext.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { type Connector } from 'wagmi';
 import { type WalletClient } from 'viem';
-import { ENVIRONMENT, type SilentSwapClient, type SilentSwapClientConfig, type AuthResponse, type QuoteResponse } from '@silentswap/sdk';
+import { ENVIRONMENT, type SilentSwapClient, type SilentSwapClientConfig, type AuthResponse, type QuoteResponse, type CalculationDirection } from '@silentswap/sdk';
 import { type ExecuteSwapParams, type SwapResult } from '../hooks/silent/useSilentQuote.js';
 import { type OutputStatus } from '../hooks/silent/useOrderTracking.js';
 import { type SolanaWalletConnector, type SolanaConnection } from '../hooks/silent/solana-transaction.js';
@@ -37,7 +37,7 @@ export interface SilentSwapContextType {
     serviceFeeRate: number;
     overheadUsd: number;
     egressEstimatesLoading: boolean;
-    fetchEstimates: (direction?: 'input-to-output' | 'output-to-input') => Promise<void>;
+    fetchEstimates: (direction?: CalculationDirection) => Promise<void>;
     handleNewSwap: () => void;
     solanaRpcUrl?: string;
 }

package/dist/contexts/SilentSwapContext.js

@@ -97,7 +97,6 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, sol
     const { fetchEstimates, isLoading: egressEstimatesLoading, egressQuotes: egressQuotesFromEstimates, ingressQuote: ingressQuoteFromEstimates, depositAmountUsd: depositAmountUsdFromEstimates, bridgeProviderFromQuote, usdcPrice: usdcPriceFromEstimates, } = useEgressEstimates({
         evmAddress,
         solAddress,
-        quoteAddress: effectiveQuoteAddress,
         tokenIn,
         inputAmount,
         destinations,

package/dist/hooks/useEgressEstimates.d.ts

@@ -1,9 +1,8 @@
-import { BridgeProvider, type AssetInfo } from '@silentswap/sdk';
+import { BridgeProvider, type AssetInfo, type CalculationDirection } from '@silentswap/sdk';
 import type { Destination } from './useSwap.js';
 export interface UseEgressEstimatesOptions {
     evmAddress: `0x${string}` | string | undefined;
     solAddress: string | undefined;
-    quoteAddress: string | undefined;
     tokenIn: AssetInfo | null;
     inputAmount: string;
     destinations: Destination[];
@@ -11,15 +10,15 @@ export interface UseEgressEstimatesOptions {
     updateDestinationAmount: (index: number, amount: string) => void;
     serviceFeeRate?: number;
     overheadUsd?: number;
-    calculationDirection?: 'input-to-output' | 'output-to-input';
+    calculationDirection?: CalculationDirection;
     setInputAmount?: (amount: string) => void;
 }
 /**
  * Hook to fetch egress estimates and calculate accurate output amounts
  * Matches the behavior of Svelte Form.svelte's fetch_live_estimate()
  */
-export declare function useEgressEstimates({ evmAddress, solAddress, quoteAddress, tokenIn, inputAmount, destinations, splits, updateDestinationAmount, serviceFeeRate, overheadUsd, calculationDirection, setInputAmount, }: UseEgressEstimatesOptions): {
-    fetchEstimates: (direction?: "input-to-output" | "output-to-input") => Promise<any>;
+export declare function useEgressEstimates({ evmAddress, solAddress, tokenIn, inputAmount, destinations, splits, updateDestinationAmount, serviceFeeRate, overheadUsd, calculationDirection, setInputAmount, }: UseEgressEstimatesOptions): {
+    fetchEstimates: (direction?: CalculationDirection) => Promise<any>;
     isLoading: boolean;
     error: Error | null;
     egressRates: number[];

package/dist/hooks/useEgressEstimates.js

@@ -1,13 +1,13 @@
 import { useState, useCallback, useRef, useMemo } from 'react';
 import { BigNumber } from 'bignumber.js';
 import { useOrderEstimates } from './useOrderEstimates.js';
-import { getAssetByCaip19, S_CAIP19_USDC_AVALANCHE } from '@silentswap/sdk';
+import { getAssetByCaip19, S_CAIP19_USDC_AVALANCHE, CALCULATION_DIRECTION_INPUT_TO_OUTPUT, CALCULATION_DIRECTION_OUTPUT_TO_INPUT, } from '@silentswap/sdk';
 import { usePrices } from './usePrices.js';
 /**
  * Hook to fetch egress estimates and calculate accurate output amounts
  * Matches the behavior of Svelte Form.svelte's fetch_live_estimate()
  */
-export function useEgressEstimates({ evmAddress, solAddress, quoteAddress, tokenIn, inputAmount, destinations, splits, updateDestinationAmount, serviceFeeRate = 0.01, overheadUsd = 0, calculationDirection = 'input-to-output', setInputAmount, }) {
+export function useEgressEstimates({ evmAddress, solAddress, tokenIn, inputAmount, destinations, splits, updateDestinationAmount, serviceFeeRate = 0.01, overheadUsd = 0, calculationDirection = CALCULATION_DIRECTION_INPUT_TO_OUTPUT, setInputAmount, }) {
     const { estimateOrder, isLoading, error } = useOrderEstimates({
         evmAddress: evmAddress,
         solAddress: solAddress,
@@ -26,18 +26,18 @@ export function useEgressEstimates({ evmAddress, solAddress, quoteAddress, token
     /**
      * Fetch egress estimates and calculate output amounts
      * This matches Svelte's fetch_live_estimate() function
-     * @param direction - Calculation direction: 'input-to-output' (normal) or 'output-to-input' (reverse)
+     * @param direction - Calculation direction: CALCULATION_DIRECTION_INPUT_TO_OUTPUT (normal) or CALCULATION_DIRECTION_OUTPUT_TO_INPUT (reverse)
      */
-    const fetchEstimates = useCallback(async (direction = 'input-to-output') => {
+    const fetchEstimates = useCallback(async (direction = CALCULATION_DIRECTION_INPUT_TO_OUTPUT) => {
         console.log('[EgressEstimates] Step 1: Starting fetchEstimates', { direction, tokenIn: tokenIn?.caip19, inputAmount, destinationsCount: destinations.length });
         // Validate all required inputs before proceeding
+        // Note: quoteAddress is not required for estimates - useOrderEstimates uses fallback addresses when needed
         if (!tokenIn ||
             !tokenIn.caip19 ||
             !inputAmount ||
             parseFloat(inputAmount) <= 0 ||
-            destinations.length === 0 ||
-            !quoteAddress) {
-            console.log('[EgressEstimates] Step 1: Validation failed - missing required inputs');
+            destinations.length === 0) {
+            console.log('[EgressEstimates] Step 1: Validation failed - missing required inputs', { tokenIn, inputAmount, destinations, splits });
             return;
         }
         const estimateKey = `${tokenIn.caip19}-${inputAmount}-${destinations.map((d) => d.asset).join(',')}-${splits.join(',')}`;
@@ -75,7 +75,7 @@ export function useEgressEstimates({ evmAddress, solAddress, quoteAddress, token
             }
             // Fetch estimates (both ingress and egress in parallel)
             // For reverse calculation (output-to-input), pass output amounts and use EXACT_OUTPUT
-            const effectiveDirection = direction || calculationDirection || 'input-to-output';
+            const effectiveDirection = direction || calculationDirection || CALCULATION_DIRECTION_INPUT_TO_OUTPUT;
             console.log('[EgressEstimates] Step 4: Calling estimateOrder', {
                 effectiveDirection,
                 sourceAsset: tokenIn.caip19,
@@ -83,7 +83,7 @@ export function useEgressEstimates({ evmAddress, solAddress, quoteAddress, token
                 destinationsCount: destinationAssets.length,
                 splits,
             });
-            const requestPromise = estimateOrder(fetchedUsdcPrice || 1, tokenIn, sourcePrice, inputAmount, destinationAssets, destinationPrices, splits, effectiveDirection, effectiveDirection === 'output-to-input'
+            const requestPromise = estimateOrder(fetchedUsdcPrice || 1, tokenIn, sourcePrice, inputAmount, destinationAssets, destinationPrices, splits, effectiveDirection, effectiveDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT
                 ? destinations.map((dest) => dest.amount) // Pass output amounts for reverse calculation
                 : undefined);
             // Store the in-flight request
@@ -108,9 +108,9 @@ export function useEgressEstimates({ evmAddress, solAddress, quoteAddress, token
             // Calculate deposit amount in USD (matches Svelte calculation - lines 173-177)
             // Note: This is the USD value after ingress retention, not the USDC amount
             let depositUsd;
-            // Handle reverse calculation: if direction is 'output-to-input', 
+            // Handle reverse calculation: if direction is CALCULATION_DIRECTION_OUTPUT_TO_INPUT, 
             // the estimate system calculated the required input amount
-            if (effectiveDirection === 'output-to-input' && result.calculatedInputAmount && setInputAmount) {
+            if (effectiveDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT && result.calculatedInputAmount && setInputAmount) {
                 console.log('[EgressEstimates] Step 7: Handling reverse calculation - updating input amount', {
                     calculatedInputAmount: result.calculatedInputAmount,
                 });
@@ -139,7 +139,7 @@ export function useEgressEstimates({ evmAddress, solAddress, quoteAddress, token
             const actionableUsd = depositUsd - serviceFeeUsd;
             // Update destination amounts (matches Svelte Form.svelte lines 217-229)
             // For reverse calculation, preserve user's manual changes
-            if (effectiveDirection === 'output-to-input') {
+            if (effectiveDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT) {
                 console.log('[EgressEstimates] Step 9: Reverse calculation - preserving user output amounts');
                 // Don't overwrite user's manual output changes
                 // The outputs are already set correctly
@@ -196,7 +196,6 @@ export function useEgressEstimates({ evmAddress, solAddress, quoteAddress, token
         estimateOrder,
         getPrice,
         updateDestinationAmount,
-        quoteAddress,
         serviceFeeRate,
         overheadUsd,
         calculationDirection,

package/dist/hooks/useOrderEstimates.d.ts

@@ -1,5 +1,5 @@
 import type { Estimate, RelayQuoteResponse, DeBridgeOrderResponse } from '@silentswap/sdk';
-import { type AssetInfo } from '@silentswap/sdk';
+import { type AssetInfo, type CalculationDirection } from '@silentswap/sdk';
 export interface OrderEstimateResult {
     ingressGasAmount: bigint;
     ingressRate: number;
@@ -31,7 +31,7 @@ export interface UseOrderEstimatesOptions {
  * Returns retention rates that account for bridge fees and slippage
  */
 export declare function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpactPercent, }?: UseOrderEstimatesOptions): {
-    estimateOrder: (usdcPrice: number, sourceAsset: AssetInfo, sourcePrice: number, sourceAmount: number | string, destinationAssets: AssetInfo[], destinationPrices: number[], splits: number[], calculationDirection?: "input-to-output" | "output-to-input", outputAmounts?: string[]) => Promise<OrderEstimateResult>;
+    estimateOrder: (usdcPrice: number, sourceAsset: AssetInfo, sourcePrice: number, sourceAmount: number | string, destinationAssets: AssetInfo[], destinationPrices: number[], splits: number[], calculationDirection?: CalculationDirection, outputAmounts?: string[]) => Promise<OrderEstimateResult>;
     isLoading: boolean;
     error: Error | null;
 };

package/dist/hooks/useOrderEstimates.js

@@ -1,10 +1,7 @@
 import { useCallback, useRef, useState, useMemo } from 'react';
 import BigNumber from 'bignumber.js';
-import { parseEvmCaip19, parseSolanaCaip19, isEvmNativeToken, isSolanaNativeToken, isSolanaAsset, } from '@silentswap/sdk';
+import { parseEvmCaip19, parseSolanaCaip19, isEvmNativeToken, isSolanaNativeToken, isSolanaAsset, EVM_PHONY_ADDRESS, SB58_ADDR_SOL_PROGRAM_SYSTEM, CALCULATION_DIRECTION_INPUT_TO_OUTPUT, CALCULATION_DIRECTION_OUTPUT_TO_INPUT, } from '@silentswap/sdk';
 import { useQuote } from './useQuote.js';
-// Fallback EVM address for egress quotes when evmAddress is not available
-// Egress quotes always start from Avalanche (EVM), so they require an EVM address
-const EVM_PHONY_ADDRESS_FALLBACK = '0x1111111111111111111111111111111111111111';
 /**
  * Hook for fetching both ingress and egress estimates in parallel
  * Matches the behavior of estimate_order() from silentswap-v2-ui/src/web3/estimate.ts
@@ -17,21 +14,30 @@ const EVM_PHONY_ADDRESS_FALLBACK = '0x1111111111111111111111111111111111111111';
  */
 export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpactPercent, } = {}) {
     const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
     // Determine address for ingress quotes based on source chain
     // For ingress, we need the address that matches the source chain (not sourceAsset)
     // For egress, we always start from Avalanche (EVM), so we can use evmAddress as default
     // But we'll create separate useQuote instances to handle this correctly
+    // Use fallback addresses when wallet is not connected to allow estimates without wallet
     const ingressAddress = useMemo(() => {
         if (sourceAsset) {
             // For ingress, address should match the source chain
-            return sourceAsset.caip19.includes('solana') ? solAddress : evmAddress;
+            // Use fallback addresses when wallet is not connected (for estimates without wallet)
+            if (sourceAsset.caip19.includes('solana')) {
+                return solAddress || SB58_ADDR_SOL_PROGRAM_SYSTEM;
+            }
+            else {
+                return evmAddress || EVM_PHONY_ADDRESS;
+            }
         }
-        return undefined;
+        // Default to EVM fallback if no source asset
+        return EVM_PHONY_ADDRESS;
     }, [sourceAsset, solAddress, evmAddress]);
     // For egress, we always start from Avalanche (EVM), so use EVM address
     // If evmAddress is undefined, use the phony EVM address as fallback
     // This ensures egress quotes always use an EVM address format (required for Avalanche origin)
-    const egressAddress = evmAddress || EVM_PHONY_ADDRESS_FALLBACK;
+    const egressAddress = evmAddress || EVM_PHONY_ADDRESS;
     // Initialize useQuote hooks - one for ingress (uses address based on source chain)
     // and one for egress (uses EVM address since egress always starts from Avalanche)
     const ingressQuote = useQuote({
@@ -39,7 +45,7 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
         maxImpactPercent,
     });
     const egressQuote = useQuote({
-        address: egressAddress, // Always an EVM address (either evmAddress or EVM_PHONY_ADDRESS_FALLBACK)
+        address: egressAddress, // Always an EVM address (either evmAddress or EVM_PHONY_ADDRESS)
         maxImpactPercent,
     });
     const { estimateLive: estimateLiveIngress, interpolateSamples: interpolate } = ingressQuote;
@@ -51,7 +57,7 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
      * Fetch both ingress and egress estimates in parallel
      * Matches estimate_order() from Svelte app
      */
-    const estimateOrder = useCallback(async (usdcPrice, sourceAsset, sourcePrice, sourceAmount, destinationAssets, destinationPrices, splits, calculationDirection = 'input-to-output', outputAmounts) => {
+    const estimateOrder = useCallback(async (usdcPrice, sourceAsset, sourcePrice, sourceAmount, destinationAssets, destinationPrices, splits, calculationDirection = CALCULATION_DIRECTION_INPUT_TO_OUTPUT, outputAmounts) => {
         // Validate inputs
         if (!sourceAsset) {
             throw new Error('sourceAsset is required');
@@ -66,7 +72,7 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
             throw new Error('All destinationAssets must have a valid caip19 property');
         }
         // For reverse calculation, validate output amounts
-        if (calculationDirection === 'output-to-input') {
+        if (calculationDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT) {
             if (!outputAmounts || outputAmounts.length !== destinationAssets.length) {
                 throw new Error('outputAmounts are required for reverse calculation');
             }
@@ -120,7 +126,7 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
                 // For reverse calculation, calculate total output USD value first
                 let totalOutputUsd = 0;
                 let calculatedInputAmount = undefined;
-                if (calculationDirection === 'output-to-input' && outputAmounts) {
+                if (calculationDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT && outputAmounts) {
                     console.log('[OrderEstimates] Step 4: Reverse calculation - calculating total output USD');
                     // Calculate total USD value of outputs
                     totalOutputUsd = destinationAssets.reduce((sum, destAsset, idx) => {
@@ -147,7 +153,7 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
                     // Ingress: source chain -> Avalanche (USDC)
                     // For reverse calculation, use EXACT_OUTPUT with calculated deposit USD
                     // For normal calculation, use EXACT_INPUT with source amount
-                    calculationDirection === 'output-to-input' && totalOutputUsd > 0
+                    calculationDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT && totalOutputUsd > 0
                         ? estimateLiveIngress('ingress', sourceAsset.caip19, sourceChainId, sourceTokenAddress, totalOutputUsd / sourcePrice, // Approximate input for quote (will be refined)
                         sourcePrice, abortController.signal, undefined, // recipientAddress (not needed for ingress)
                         true, // isReverseCalculation
@@ -179,7 +185,7 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
                         // For Solana destinations, use Solana address; for EVM, use EVM address
                         const recipientAddress = isDestSolana ? solAddress : evmAddress;
                         // For reverse calculation, use output amount directly with EXACT_OUTPUT
-                        if (calculationDirection === 'output-to-input' && outputAmounts && outputAmounts[idx]) {
+                        if (calculationDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT && outputAmounts && outputAmounts[idx]) {
                             const outputAmount = parseFloat(outputAmounts[idx]);
                             // Use EXACT_OUTPUT for egress: we know the output amount, calculate required USDC
                             // Pass the output amount directly (in human-readable format)
@@ -248,7 +254,7 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
                 const egressRetentions = [];
                 for (let idx = 0; idx < destinationAssets.length; idx++) {
                     const egressResult = egressResults[idx];
-                    if (calculationDirection === 'output-to-input' && outputAmounts && outputAmounts[idx]) {
+                    if (calculationDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT && outputAmounts && outputAmounts[idx]) {
                         // For reverse calculation, use output USD value for interpolation
                         const outputAmount = parseFloat(outputAmounts[idx]);
                         const destPrice = destinationPrices[idx] || 1;
@@ -321,7 +327,7 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
                     egressRetentions,
                 });
                 // For reverse calculation, extract calculated input amount from ingress result
-                if (calculationDirection === 'output-to-input' && ingressResult.calculatedInputAmount) {
+                if (calculationDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT && ingressResult.calculatedInputAmount) {
                     console.log('[OrderEstimates] Step 9: Reverse calculation - interpolating retention with calculated input', {
                         calculatedInputAmount: ingressResult.calculatedInputAmount,
                     });
@@ -375,19 +381,21 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
                 throw error;
             }
         })();
-        // Store the in-flight request
+        // Store the in-flight request and update loading state
         inFlightRequestRef.current = requestPromise;
+        setIsLoading(true);
         // Clear in-flight request when promise completes (success or error)
         requestPromise.finally(() => {
             if (inFlightRequestRef.current === requestPromise) {
                 inFlightRequestRef.current = null;
+                setIsLoading(false);
             }
         });
         return requestPromise;
     }, [estimateLiveIngress, estimateLiveEgress, interpolate, ingressAddress, egressAddress, sourceAsset, solAddress, evmAddress, maxImpactPercent]);
     return {
         estimateOrder,
-        isLoading: !!inFlightRequestRef.current,
+        isLoading,
         error,
     };
 }

package/dist/hooks/useQuote.js

@@ -1,9 +1,8 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 import BigNumber from 'bignumber.js';
-import { NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, S_CAIP19_USDC_AVALANCHE, X_MAX_IMPACT_PERCENT, getBridgeQuote as sdkGetBridgeQuote, interpolateSamples as sdkInterpolateSamples, fetchRelayQuote, fetchDebridgeOrder, normalizeAddress, getAssetByCaip19, N_DEBRIDGE_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_SOLANA, SB58_ADDR_SOL_PROGRAM_SYSTEM, S0X_ADDR_EVM_RELAY_LINK_DEAD, SB58_ADDR_SOL_RELAY_LINK_RECIPIENT, isSolanaAsset, } from '@silentswap/sdk';
+import { NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, S_CAIP19_USDC_AVALANCHE, X_MAX_IMPACT_PERCENT, getBridgeQuote as sdkGetBridgeQuote, interpolateSamples as sdkInterpolateSamples, fetchRelayQuote, fetchDebridgeOrder, normalizeAddress, getAssetByCaip19, N_DEBRIDGE_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_SOLANA, SB58_ADDR_SOL_PROGRAM_SYSTEM, S0X_ADDR_EVM_RELAY_LINK_DEAD, SB58_ADDR_SOL_RELAY_LINK_RECIPIENT, isSolanaAsset, EVM_PHONY_ADDRESS, } from '@silentswap/sdk';
 // Constants for estimateLive
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
-const EVM_PHONY_ADDRESS_FALLBACK = '0x1111111111111111111111111111111111111111';
 /**
  * Hook for getting optimized bridge quotes with retention rate tracking
  * Implements the same functionality as estimate.ts from the original app
@@ -208,14 +207,14 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT } =
                     // For EVM ingress, use EVM address (or phony if not available)
                     userAddress = normalizedAddress && normalizedAddress.startsWith('0x')
                         ? normalizedAddress
-                        : EVM_PHONY_ADDRESS_FALLBACK;
+                        : EVM_PHONY_ADDRESS;
                 }
             }
             else {
                 // For egress, origin is always Avalanche (EVM), so user must be EVM address
                 userAddress = normalizedAddress && normalizedAddress.startsWith('0x')
                     ? normalizedAddress
-                    : EVM_PHONY_ADDRESS_FALLBACK;
+                    : EVM_PHONY_ADDRESS;
             }
             // For Solana, use different chain IDs for different providers
             const relayChainId = isSolanaChain ? N_RELAY_CHAIN_ID_SOLANA : numericChainId;
@@ -274,7 +273,7 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT } =
                                         }),
                                     // For Solana ingress, set recipient to EVM phony address (for Avalanche destination)
                                     ...(isSolanaChain
-                                        ? { recipient: EVM_PHONY_ADDRESS_FALLBACK }
+                                        ? { recipient: EVM_PHONY_ADDRESS }
                                         : {}),
                                 }
                                 : {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@silentswap/react",
   "type": "module",
-  "version": "0.0.48",
+  "version": "0.0.50",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,8 +23,8 @@
   },
   "dependencies": {
     "@ensdomains/ensjs": "^4.2.0",
-    "@silentswap/sdk": "0.0.48",
-    "@silentswap/ui-kit": "0.0.48",
+    "@silentswap/sdk": "0.0.50",
+    "@silentswap/ui-kit": "0.0.50",
     "@solana/codecs-strings": "^5.1.0",
     "@solana/kit": "^5.1.0",
     "@solana/rpc": "^5.1.0",