@silentswap/react 0.0.49 → 0.0.51

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/hooks/silent/useOrderSigning.js

@@ -35,7 +35,9 @@ export function useOrderSigning(walletClient, connector, client, setCurrentStep,
         if (!connector) {
             throw new Error('Connector required for chain switching');
         }
-        await ensureChain(NI_CHAIN_ID_AVALANCHE, walletClient, connector);
+        if (isDepositingDirectly) {
+            await ensureChain(NI_CHAIN_ID_AVALANCHE, walletClient, connector);
+        }
         return Promise.all(authorizations.map(async (auth) => ({
             ...auth,
             signature: await (async () => {

package/dist/hooks/useEgressEstimates.d.ts

@@ -1,4 +1,4 @@
-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;
@@ -10,7 +10,7 @@ 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;
 }
 /**
@@ -18,7 +18,7 @@ export interface UseEgressEstimatesOptions {
  * Matches the behavior of Svelte Form.svelte's fetch_live_estimate()
  */
 export declare function useEgressEstimates({ evmAddress, solAddress, tokenIn, inputAmount, destinations, splits, updateDestinationAmount, serviceFeeRate, overheadUsd, calculationDirection, setInputAmount, }: UseEgressEstimatesOptions): {
-    fetchEstimates: (direction?: "input-to-output" | "output-to-input") => Promise<any>;
+    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, 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,9 +26,9 @@ export function useEgressEstimates({ evmAddress, solAddress, tokenIn, inputAmoun
     /**
      * 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
@@ -75,7 +75,7 @@ export function useEgressEstimates({ evmAddress, solAddress, tokenIn, inputAmoun
             }
             // 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, tokenIn, inputAmoun
                 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, tokenIn, inputAmoun
             // 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, tokenIn, inputAmoun
             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

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,6 +1,6 @@
 import { useCallback, useRef, useState, useMemo } from 'react';
 import BigNumber from 'bignumber.js';
-import { parseEvmCaip19, parseSolanaCaip19, isEvmNativeToken, isSolanaNativeToken, isSolanaAsset, EVM_PHONY_ADDRESS, SB58_ADDR_SOL_PROGRAM_SYSTEM, } 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';
 /**
  * Hook for fetching both ingress and egress estimates in parallel
@@ -14,6 +14,7 @@ import { useQuote } from './useQuote.js';
  */
 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
@@ -56,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');
@@ -71,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');
             }
@@ -125,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) => {
@@ -152,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
@@ -184,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)
@@ -253,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;
@@ -326,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,
                     });
@@ -380,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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@silentswap/react",
   "type": "module",
-  "version": "0.0.49",
+  "version": "0.0.51",
   "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.49",
-    "@silentswap/ui-kit": "0.0.49",
+    "@silentswap/sdk": "0.0.51",
+    "@silentswap/ui-kit": "0.0.51",
     "@solana/codecs-strings": "^5.1.0",
     "@solana/kit": "^5.1.0",
     "@solana/rpc": "^5.1.0",