@shogun-sdk/intents-sdk 1.2.31 → 1.4.0

package/src/utils/quote/aggregator.ts

@@ -2,11 +2,18 @@ import { ChainID, isEvmChain, type SupportedEvmChain } from '../../chains.js';
 import { JupiterQuoteProvider } from './jupiter.js';
 import { type QuoteResponse as JupiterQuoteResponse } from '@jup-ag/api';
 import { ParaswapQuoteProvider, type SwapEstimateResult } from './paraswap.js';
-import { CROSS_CHAIN_TOKENS } from './stablecoins-tokens.js';
+import { CROSS_CHAIN_STABLES } from './stablecoins-tokens.js';
 import { AftermathQuoteProvider } from './aftermath.js';
 import type { RouterCompleteTradeRoute } from 'aftermath-ts-sdk';
-import { calculateAmounts } from '../defillama.js';
 import { LiquidSwapQuoteProvider, type LiquidSwapQuoteResponse } from './liquidswap.js';
+import { RaydiumQuoteProvider, type RaydiumPumpQuoteParams, type RaydiumQuoteResponse } from './raydium.js';
+import { PumpFunQuoteProvider } from './pumpfun/index.js';
+import { RelayQuoteProvider } from './relay.js';
+import { convertDecimals } from './pricing/decimals.js';
+import { estimateAmountOut, IntentNotViableError } from './pricing/estimate-amount-out.js';
+import { estimateExpensesInTokenOut } from './pricing/expenses.js';
+import { DEFAULT_COMMISSION_BPS, CROSS_CHAIN_COMMISSION_DENOMINATOR, EVM_CROSS_CHAIN_GAS_LIMIT } from './pricing/constants.js';
+import { compareAddresses } from './address.js';
 
 type SingleChainQuoteParams = {
   chainId: ChainID;
@@ -14,13 +21,15 @@ type SingleChainQuoteParams = {
   tokenIn: string;
   tokenOut: string;
   slippageBps?: number;
+  provider?: RouteProvider; // Optional provider override
 };
 
-export type RouteProvider = 'paraswap' | 'jupiter' | 'aftermath' | 'liquidswap';
+export type RouteProvider = 'paraswap' | 'jupiter' | 'aftermath' | 'liquidswap' | 'raydium' | 'pumpfun' | 'relay';
 
 export type Quote = {
   amountIn: bigint;
   amountOut: bigint;
+  amountOutMin?: bigint; // Optional, for quotes that provide a minimum guaranteed output
   amountOutUsd: number;
   amountInUsd: number;
   slippage: number;
@@ -29,7 +38,14 @@ export type Quote = {
   rawQuote: any;
 };
 
-export type QuoteParams = {
+export type SimpleQuote = {
+  amountIn: bigint;
+  amountOut: bigint;
+  amountOutMin?: bigint;
+  slippage: number;
+};
+
+export type IntentsQuoteParams = {
   sourceChainId: ChainID;
   destChainId: ChainID;
   amount: bigint;
@@ -37,7 +53,7 @@ export type QuoteParams = {
   tokenOut: string;
 };
 
-export type QuoteResponse = {
+export type QuoteResponseInternal = {
   amountInUsd: number;
   estimatedAmountInAsMinStablecoinAmount: bigint;
 
@@ -48,77 +64,119 @@ export type QuoteResponse = {
   estimatedAmountOutUsdReduced: number;
 };
 
-export class QuoteProvider {
-  private static readonly DEFAULT_BRIDGE_TOKEN = 'USDC';
-  private static readonly DEFAULT_BRIDGE_TOKEN_DECIMALS = 6;
-
-  public static async getQuoteFromDefillama(params: QuoteParams): Promise<QuoteResponse> {
-    const defillamaQuote = await calculateAmounts({
-      amountIn: params.amount,
-      tokenIn: params.tokenIn,
-      tokenOut: params.tokenOut,
-      destChainId: params.destChainId,
-      srcChainId: params.sourceChainId,
-    });
-
-    return {
-      amountInUsd: 0,
-      estimatedAmountOutUsd: 0,
-      estimatedAmountOutUsdReduced: 0,
-
-      estimatedAmountInAsMinStablecoinAmount: defillamaQuote.minStablecoinsAmount,
-      estimatedAmountOut: defillamaQuote.amountOut,
-      estimatedAmountOutReduced: defillamaQuote.amountOut,
-    };
-  }
+// Public response with metadata and derived fields
+export type QuoteResponse = QuoteResponseInternal & {
+  /** Metadata for source token */
+  tokenIn: {
+    address: string;
+    chainId: ChainID;
+  };
+
+  /** Metadata for destination token */
+  tokenOut: {
+    address: string;
+    chainId: ChainID;
+  };
+};
 
-  public static async getQuoteWithDefillamaFallback(params: QuoteParams): Promise<QuoteResponse> {
+export class QuoteProvider {
+  public static async getQuote(params: IntentsQuoteParams): Promise<QuoteResponse> {
     try {
       const quote = await this.getQuoteFromRouters(params);
-      return quote;
+      // Adapt QuoteResponseInternal to QuoteResponse by adding tokenIn and tokenOut metadata fields
+      return {
+        ...quote,
+        tokenIn: {
+          address: params.tokenIn,
+          chainId: params.sourceChainId,
+        },
+        tokenOut: {
+          address: params.tokenOut,
+          chainId: params.destChainId,
+        },
+      };
     } catch (e) {
-      const quote = await this.getQuoteFromDefillama(params);
-      return quote;
+      if (e instanceof IntentNotViableError) throw e;
+      console.error('Error getting quote from routers:', e);
+      throw new Error('Failed to get quote from routers');
     }
   }
 
-  public static async getQuote(params: QuoteParams): Promise<QuoteResponse> {
-    return this.getQuoteWithDefillamaFallback(params);
-  }
+  /**
+   * Get a quote for Solana with explicit provider selection
+   * @param params - Quote parameters including provider preference
+   * @returns Quote response
+   */
+  public static async getSolanaQuote(params: {
+    amount: bigint;
+    tokenIn: string;
+    tokenOut: string;
+    slippageBps?: number;
+    provider?: 'jupiter' | 'raydium' | 'pumpfun';
+  }): Promise<Quote> {
+    const singleChainParams: SingleChainQuoteParams = {
+      chainId: ChainID.Solana,
+      amount: params.amount,
+      tokenIn: params.tokenIn,
+      tokenOut: params.tokenOut,
+      slippageBps: params.slippageBps,
+      provider: params.provider,
+    };
 
-  private static async getQuoteFromRouters(params: QuoteParams): Promise<QuoteResponse> {
-    const bridgeTokenSymbol = QuoteProvider.DEFAULT_BRIDGE_TOKEN;
+    return this.getSingleChainQuote(singleChainParams);
+  }
 
-    const sourceBridgeToken = CROSS_CHAIN_TOKENS[bridgeTokenSymbol]?.[params.sourceChainId] || '';
-    const destBridgeToken = CROSS_CHAIN_TOKENS[bridgeTokenSymbol]?.[params.destChainId] || '';
+  private static async getQuoteFromRouters(params: IntentsQuoteParams): Promise<QuoteResponseInternal> {
+    const sourceStable = getStableForChain(params.sourceChainId);
+    const destStable = getStableForChain(params.destChainId);
 
+    //  Step 1: Get quote from tokenIn → bridge stable on source chain ---
     const sourceSingleChainQuoteParams: SingleChainQuoteParams = {
       chainId: params.sourceChainId,
       amount: params.amount,
       tokenIn: params.tokenIn,
-      tokenOut: sourceBridgeToken,
+      tokenOut: sourceStable.address,
     };
 
-    const sourceQuote = await this.getSingleChainQuote(sourceSingleChainQuoteParams);
+    const [sourceQuote, expenses] = await Promise.all([
+      this.getSingleChainQuote(sourceSingleChainQuoteParams),
+      estimateExpensesInTokenOut({
+        chainId: params.destChainId,
+        tokenOut: params.tokenOut,
+        gasLimit: EVM_CROSS_CHAIN_GAS_LIMIT,
+        getQuote: (p) => this.getSingleChainQuote(p),
+      }),
+    ]);
+
+    // Step 2: Normalize stable amount between source and destination ---
+    // Adjust for decimal difference between stables (e.g. 6 → 18)
+    const normalizedBridgeAmount = convertDecimals(
+      sourceQuote.amountOut,
+      sourceStable.decimals,
+      destStable.decimals,
+    );
 
+    // Step 3: Get quote from dest bridge stable → target token ---
     const destSingleChainQuoteParams: SingleChainQuoteParams = {
       chainId: params.destChainId,
-      amount: sourceQuote.amountOut,
-      tokenIn: destBridgeToken,
+      amount: normalizedBridgeAmount,
+      tokenIn: destStable.address,
       tokenOut: params.tokenOut,
     };
 
     const destQuote = await this.getSingleChainQuote(destSingleChainQuoteParams);
 
-    // Use weighted reduction instead of fixed percentage
-    const weightedReductionFactor = this.calculateWeightedReductionFactorForUsd(destQuote.amountOutUsd);
-
-    const estimatedAmountOutReduced = BigInt(Math.floor(Number(destQuote.amountOut) * weightedReductionFactor));
-    const estimatedAmountOutUsdReduced = destQuote.amountOutUsd * weightedReductionFactor;
-
-    const reducedAmountInUsd = this.calculateWeightedReductionFactorForUsd(sourceQuote.amountInUsd);
+    // Step 4: Compute stable min-amount with correct decimals ---
     const estimatedAmountInAsMinStablecoinAmount = BigInt(
-      Math.floor(reducedAmountInUsd * 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS),
+      Math.floor(sourceQuote.amountInUsd * 10 ** sourceStable.decimals),
+    );
+
+    const swapOutput = destQuote.amountOutMin ?? destQuote.amountOut;
+    const estimatedAmountOutReduced = estimateAmountOut(
+      swapOutput,
+      DEFAULT_COMMISSION_BPS,
+      expenses,
+      CROSS_CHAIN_COMMISSION_DENOMINATOR,
     );
 
     return {
@@ -127,16 +185,23 @@ export class QuoteProvider {
       amountInUsd: sourceQuote.amountInUsd,
       estimatedAmountInAsMinStablecoinAmount,
       estimatedAmountOutReduced,
-      estimatedAmountOutUsdReduced,
+      estimatedAmountOutUsdReduced: destQuote.amountOutUsd,
     };
   }
 
   public static async getSingleChainQuote(params: SingleChainQuoteParams): Promise<Quote> {
-    if (params.tokenIn.toLowerCase() === params.tokenOut.toLowerCase()) {
+    // Handle same-token case (self-swap)
+    if (compareAddresses(params.tokenIn, params.tokenOut)) {
       let amountUsd = 0;
 
-      if (params.tokenIn.toLowerCase() === CROSS_CHAIN_TOKENS.USDC![params.chainId].toLowerCase()) {
-        amountUsd = Number(params.amount) / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
+      // Pick correct stable for this chain
+      const stable = getStableForChain(params.chainId);
+      const stableAddress = stable.address;
+      const stableDecimals = stable.decimals;
+
+      // If it's the chain's stable token, derive USD value correctly
+      if (compareAddresses(params.tokenIn, stableAddress)) {
+        amountUsd = Number(params.amount) / 10 ** stableDecimals;
       }
 
       return {
@@ -146,27 +211,58 @@ export class QuoteProvider {
         amountInUsd: amountUsd,
         slippage: 0,
         priceImpact: 0,
-        provider: getProviderNameByChainId(params.chainId),
+        provider: params.provider || getProviderNameByChainId(params.chainId),
         rawQuote: null,
       };
     }
 
+    //  Hyperliquid
     if (params.chainId === ChainID.Hyperliquid) {
       const liquidSwapQuote = await QuoteProvider.getLiquidSwapQuote(params);
       return QuoteProvider.transformLiquidSwapQuote(liquidSwapQuote);
     }
 
+    // Solana (Jupiter / Raydium / Pumpfun)
     if (params.chainId === ChainID.Solana) {
-      const jupiterQuote = await QuoteProvider.getJupiterQuote(params);
-      return QuoteProvider.transformJupiterQuote(jupiterQuote);
+      if (params.provider === 'jupiter') {
+        const jupiterQuote = await QuoteProvider.getJupiterQuote(params);
+        return QuoteProvider.transformJupiterQuote(jupiterQuote);
+      } else if (params.provider === 'raydium') {
+        const raydiumQuote = await QuoteProvider.getRaydiumQuote(params);
+        return raydiumQuote;
+      } else if (params.provider === 'pumpfun') {
+        const pumpfunQuote = await QuoteProvider.getPumpFunQuote(params);
+        return pumpfunQuote;
+      } else {
+        try {
+          const jupiterQuote = await QuoteProvider.getJupiterQuote(params);
+          if (!jupiterQuote.quote) throw new Error('Jupiter quote failed');
+          return QuoteProvider.transformJupiterQuote(jupiterQuote);
+        } catch (error) {
+          console.warn('Jupiter quote failed, falling back to Raydium:', error);
+          try {
+            const raydiumQuote = await QuoteProvider.getRaydiumQuote(params);
+            return raydiumQuote;
+          } catch {
+            const pumpfunQuote = await QuoteProvider.getPumpFunQuote(params);
+            return pumpfunQuote;
+          }
+        }
+      }
     }
 
+    // Sui (Aftermath)
     if (params.chainId === ChainID.Sui) {
       const quote = await QuoteProvider.getAftermathQuote(params);
       return QuoteProvider.transformAftermathQuote({ quote, request: params });
     }
 
+    //  EVM chains (Paraswap)
     if (isEvmChain(params.chainId)) {
+      if (params.chainId === ChainID.MONAD) {
+        const relayQuote = await QuoteProvider.getRelayQuote(params);
+        return QuoteProvider.transformRelayQuote(relayQuote);
+      }
       const paraswapQuote = await QuoteProvider.getParaswapQuote(params);
       return QuoteProvider.transformParaswapQuote(paraswapQuote);
     }
@@ -176,8 +272,8 @@ export class QuoteProvider {
 
   static transformLiquidSwapQuote(liquidSwapQuote: LiquidSwapQuoteResponse): Quote {
     return {
-      amountIn: BigInt(liquidSwapQuote.amountIn),
-      amountOut: BigInt(liquidSwapQuote.amountOut),
+      amountIn: liquidSwapQuote.execution.details.amountIn,
+      amountOut: liquidSwapQuote.execution.details.amountOut,
       amountOutUsd: 0,
       amountInUsd: 0,
       slippage: 0,
@@ -211,7 +307,7 @@ export class QuoteProvider {
     return liquidSwapQuoter.getQuote({
       tokenIn: params.tokenIn,
       tokenOut: params.tokenOut,
-      amountIn: params.amount.toString(),
+      amountIn: params.amount,
     });
   }
 
@@ -223,7 +319,7 @@ export class QuoteProvider {
       tokenIn: params.tokenIn,
       tokenOut: params.tokenOut,
       swapMode: 'ExactIn',
-      slippageBps: params.slippageBps,
+      slippageBps: params.slippageBps ? params.slippageBps : 20, // Default 0.2% slippage
     });
   }
 
@@ -237,7 +333,15 @@ export class QuoteProvider {
       side: 'SELL',
     });
   }
+  protected static async getRelayQuote(params: SingleChainQuoteParams) {
+    const relayQuoter = new RelayQuoteProvider(params.chainId as SupportedEvmChain);
 
+    return relayQuoter.getSwapEstimation({
+      amount: BigInt(params.amount),
+      srcToken: params.tokenIn,
+      destToken: params.tokenOut,
+    });
+  }
   protected static async getAftermathQuote(params: SingleChainQuoteParams) {
     const aftermathQuoter = new AftermathQuoteProvider();
 
@@ -248,6 +352,36 @@ export class QuoteProvider {
     });
   }
 
+  //TODO: For Raydium and Pump we are applying slippage twice if there are 2 swaps (e.g., USDC -> SOL -> Token), should we just apply half and half on each swap?
+
+  protected static async getRaydiumQuote(params: SingleChainQuoteParams): Promise<Quote> {
+    const raydiumQuoter = new RaydiumQuoteProvider();
+    let request: RaydiumPumpQuoteParams = {
+      inputMint: params.tokenIn,
+      outputMint: params.tokenOut,
+      amount: params.amount.toString(),
+      slippageBps: params.slippageBps || 20, // Default 0.2% slippage
+    };
+    try {
+      return this.transformRaydiumQuote(await raydiumQuoter.getQuote(request));
+    } catch (e) {
+      console.log('Raydium AMM quote cannot find a route, trying with prebonded raydium');
+      return simpleQuoteToQuote(await raydiumQuoter.getQuotePrebonded(request), 'raydium');
+    }
+  }
+
+  protected static async getPumpFunQuote(params: SingleChainQuoteParams): Promise<Quote> {
+    const pumpfunQuoter = new PumpFunQuoteProvider();
+
+    let request: RaydiumPumpQuoteParams = {
+      inputMint: params.tokenIn,
+      outputMint: params.tokenOut,
+      amount: params.amount.toString(),
+      slippageBps: params.slippageBps || 20, // Default 0.2% slippage
+    };
+    return simpleQuoteToQuote(await pumpfunQuoter.getQuote(request), 'pumpfun');
+  }
+
   private static transformAftermathQuote({
     quote,
     request,
@@ -255,14 +389,18 @@ export class QuoteProvider {
     quote: RouterCompleteTradeRoute;
     request: SingleChainQuoteParams;
   }): Quote {
-    let amountUsd = 0;
+    const chainId = request.chainId;
+    const stable = getStableForChain(chainId);
+    const stableAddress = stable.address;
+    const stableDecimals = stable.decimals;
 
-    if (request.tokenIn === CROSS_CHAIN_TOKENS.USDC![request.chainId]) {
-      amountUsd = Number(quote.coinIn.amount) / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
-    }
+    let amountUsd = 0;
 
-    if (request.tokenOut === CROSS_CHAIN_TOKENS.USDC![request.chainId]) {
-      amountUsd = Number(quote.coinOut.amount) / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
+    // Determine if input or output token is the stablecoin
+    if (compareAddresses(request.tokenIn, stableAddress)) {
+      amountUsd = Number(quote.coinIn.amount) / 10 ** stableDecimals;
+    } else if (compareAddresses(request.tokenOut, stableAddress)) {
+      amountUsd = Number(quote.coinOut.amount) / 10 ** stableDecimals;
     }
 
     return {
@@ -289,24 +427,72 @@ export class QuoteProvider {
       rawQuote: paraswapQuote,
     };
   }
+  private static transformRelayQuote(data: any): Quote {
+    const relayQuote = data.quote;
+    // If details missing → fallback zero quote
+    if (!relayQuote || !relayQuote.details) {
+      return {
+        amountIn: 0n,
+        amountOut: 0n,
+        amountOutUsd: 0,
+        amountInUsd: 0,
+        slippage: 0,
+        priceImpact: 0,
+        provider: 'relay',
+        rawQuote: relayQuote,
+      };
+    }
+
+    const details = relayQuote.details;
+
+    const amountIn = details?.currencyIn?.amount ? BigInt(details.currencyIn.amount) : 0n;
+
+    const amountOut = details?.currencyOut?.amount ? BigInt(details.currencyOut.amount) : 0n;
+
+    const amountInUsd = details?.currencyIn?.amountUsd ? Number(details.currencyIn.amountUsd) : 0;
+
+    const amountOutUsd = details?.currencyOut?.amountUsd ? Number(details.currencyOut.amountUsd) : 0;
+
+    const slippage = details?.slippageTolerance?.origin?.percent ? Number(details.slippageTolerance.origin.percent) : 0;
+
+    const priceImpact = details?.totalImpact?.percent ? Number(details.totalImpact.percent) : 0;
+
+    return {
+      amountIn,
+      amountOut,
+      amountInUsd,
+      amountOutUsd,
+      slippage,
+      priceImpact,
+      provider: 'relay',
+      rawQuote: relayQuote,
+    };
+  }
 
-  private static transformJupiterQuote({ quote }: { quote: JupiterQuoteResponse }): Quote {
+  public static transformJupiterQuote({ quote }: { quote: JupiterQuoteResponse }): Quote {
     const amountIn = Number(quote.inAmount);
     const amountOut = Number(quote.outAmount);
+    const amountOutMin = Number(quote.otherAmountThreshold);
+
+    const chainId = ChainID.Solana; // Jupiter runs only on Solana
+    const stable = getStableForChain(chainId);
+    const stableAddress = stable.address;
+    const stableDecimals = stable.decimals;
+
     let amountUsd = 0;
     const priceImpact = quote.priceImpactPct ? Number(quote.priceImpactPct) * 100 : 0;
 
-    if (quote.outputMint === CROSS_CHAIN_TOKENS.USDC![ChainID.Solana]) {
-      amountUsd = amountOut / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
-    }
-
-    if (quote.inputMint === CROSS_CHAIN_TOKENS.USDC![ChainID.Solana]) {
-      amountUsd = amountIn / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
+    // Use stable decimals dynamically for USD conversions
+    if (compareAddresses(quote.outputMint, stableAddress)) {
+      amountUsd = amountOut / 10 ** stableDecimals;
+    } else if (compareAddresses(quote.inputMint, stableAddress)) {
+      amountUsd = amountIn / 10 ** stableDecimals;
     }
 
     return {
       amountIn: BigInt(amountIn),
       amountOut: BigInt(amountOut),
+      amountOutMin: BigInt(amountOutMin),
       amountOutUsd: amountUsd,
       amountInUsd: amountUsd,
       slippage: quote.slippageBps ? quote.slippageBps / 100 : 0,
@@ -315,17 +501,81 @@ export class QuoteProvider {
       rawQuote: quote,
     };
   }
+
+  private static transformRaydiumQuote(raydiumQuote: RaydiumQuoteResponse): Quote {
+    const amountIn = BigInt(raydiumQuote.data.inAmount);
+    const amountOut = BigInt(raydiumQuote.data.outAmount);
+
+    const chainId = ChainID.Solana; // Raydium runs on Solana
+    const stable = getStableForChain(chainId);
+    const stableAddress = stable.address;
+    const stableDecimals = stable.decimals;
+
+    let amountUsd = 0;
+    const priceImpact = Number(raydiumQuote.data.priceImpactPct) * 100;
+
+    // Determine if the input or output is the stablecoin (USDC/USDT)
+    if (compareAddresses(raydiumQuote.data.outputMint, stableAddress)) {
+      amountUsd = Number(amountOut) / 10 ** stableDecimals;
+    } else if (compareAddresses(raydiumQuote.data.inputMint, stableAddress)) {
+      amountUsd = Number(amountIn) / 10 ** stableDecimals;
+    }
+
+    return {
+      amountIn,
+      amountOut,
+      amountOutUsd: amountUsd,
+      amountInUsd: amountUsd,
+      slippage: raydiumQuote.data.slippageBps / 100,
+      priceImpact,
+      provider: 'raydium',
+      rawQuote: raydiumQuote,
+    };
+  }
 }
 
+function getStableForChain(chainId: ChainID) {
+  // Prefer USDC if available, else USDT
+  if (CROSS_CHAIN_STABLES.USDC?.[chainId]) {
+    return { symbol: 'USDC', ...CROSS_CHAIN_STABLES.USDC[chainId] };
+  }
+  if (CROSS_CHAIN_STABLES.USDT?.[chainId]) {
+    return { symbol: 'USDT', ...CROSS_CHAIN_STABLES.USDT[chainId] };
+  }
+  throw new Error(`No stablecoin found for chain ${chainId}`);
+}
 function getProviderNameByChainId(chainId: ChainID): RouteProvider {
   switch (chainId) {
     case ChainID.Sui:
       return 'aftermath';
     case ChainID.Solana:
-      return 'jupiter';
+      return 'jupiter'; // Primary provider, with Raydium and Pumpfun as fallbacks
     case ChainID.Hyperliquid:
       return 'liquidswap';
     default:
       return 'paraswap';
   }
 }
+
+export function quoteToSimpleQuote(quote: Quote): SimpleQuote {
+  return {
+    amountIn: quote.amountIn,
+    amountOut: quote.amountOut,
+    amountOutMin: quote.amountOutMin,
+    slippage: quote.slippage,
+  };
+}
+
+export function simpleQuoteToQuote(simpleQuote: SimpleQuote, provider: RouteProvider): Quote {
+  return {
+    amountIn: simpleQuote.amountIn,
+    amountOut: simpleQuote.amountOut,
+    amountOutMin: simpleQuote.amountOutMin,
+    slippage: simpleQuote.slippage,
+    amountInUsd: 0,
+    amountOutUsd: 0,
+    priceImpact: 0,
+    provider,
+    rawQuote: simpleQuote,
+  };
+}

package/src/utils/quote/liquidswap.ts

@@ -1,10 +1,12 @@
+import { formatUnits } from 'viem';
 import { ChainID } from '../../chains.js';
 import { isNativeEvmToken, WRAPPED_ETH_ADDRESSES } from '../../constants.js';
+import { CROSS_CHAIN_STABLES } from './stablecoins-tokens.js';
 
 type LiquidSwapQuoteParams = {
   tokenIn: string;
   tokenOut: string;
-  amountIn: string;
+  amountIn: bigint;
 };
 
 export type LiquidSwapQuoteResponse = {
@@ -12,31 +14,58 @@ export type LiquidSwapQuoteResponse = {
   amountIn: string;
   amountOut: string;
   averagePriceImpact: string;
+  execution: any;
 };
 
 const LIQUID_SWAP_API_URL = 'https://api.liqd.ag';
 
 export class LiquidSwapQuoteProvider {
-  public async getQuote(liquidSwapParams: LiquidSwapQuoteParams): Promise<LiquidSwapQuoteResponse> {
-    const params = { ...liquidSwapParams };
+  public async getQuote(params: LiquidSwapQuoteParams): Promise<LiquidSwapQuoteResponse> {
+    const chainId = ChainID.Hyperliquid;
+    let tokenIn = params.tokenIn;
+    let tokenOut = params.tokenOut;
 
-    if (isNativeEvmToken(params.tokenOut)) {
-      params.tokenOut = WRAPPED_ETH_ADDRESSES[ChainID.Hyperliquid];
+    // 1️ Wrap native tokens if needed
+    if (isNativeEvmToken(tokenIn)) {
+      tokenIn = WRAPPED_ETH_ADDRESSES[chainId];
     }
-
-    if (isNativeEvmToken(params.tokenIn)) {
-      params.tokenIn = WRAPPED_ETH_ADDRESSES[ChainID.Hyperliquid];
+    if (isNativeEvmToken(tokenOut)) {
+      tokenOut = WRAPPED_ETH_ADDRESSES[chainId];
     }
 
-    const url = `${LIQUID_SWAP_API_URL}/v2/route?tokenIn=${params.tokenIn}&tokenOut=${params.tokenOut}&amountIn=${params.amountIn}`;
+    // 2️Detect decimals
+    const tokenInDecimals = this.getTokenDecimals(tokenIn, chainId);
+
+    // 3️ Convert amountIn (wei → human)
+    const formattedAmountIn = formatUnits(BigInt(params.amountIn), tokenInDecimals);
+
+    // 4️ Build request URL — amountIn should still be in base units for API
+    const url = `${LIQUID_SWAP_API_URL}/v2/route?tokenIn=${tokenIn}&tokenOut=${tokenOut}&amountIn=${formattedAmountIn}`;
+
     const response = await fetch(url);
+    if (!response.ok) throw new Error('Failed to fetch quote from LiquidSwap API');
+
+    const data = await response.json();
 
-    if (!response.ok) {
-      throw new Error('Failed to fetch quote from LiquidSwap API');
+    return data;
+  }
+
+  private getTokenDecimals(addressOrSymbol: string, chainId: ChainID): number {
+    const lower = addressOrSymbol.toLowerCase();
+
+    // Match by address
+    for (const symbol in CROSS_CHAIN_STABLES) {
+      const stable = CROSS_CHAIN_STABLES[symbol]?.[chainId];
+      if (stable && stable.address.toLowerCase() === lower) {
+        return stable.decimals;
+      }
     }
 
-    const data: LiquidSwapQuoteResponse = await response.json();
+    // Match by symbol
+    const stableBySymbol = CROSS_CHAIN_STABLES[addressOrSymbol.toUpperCase()]?.[chainId];
+    if (stableBySymbol?.decimals) return stableBySymbol.decimals;
 
-    return data;
+    // Default fallback
+    return 18;
   }
 }

package/src/utils/quote/paraswap.ts

@@ -10,6 +10,8 @@ const rpcProvidersUrl: Record<SupportedEvmChain, string> = {
   [ChainID.Optimism]: 'https://optimism-rpc.publicnode.com',
   [ChainID.Base]: 'https://base-rpc.publicnode.com',
   [ChainID.Hyperliquid]: 'https://rpc.hyperliquid.xyz/evm',
+  [ChainID.BSC]: 'https://bsc-dataseed.ninicoin.io',
+  [ChainID.MONAD]: 'https://rpc4.monad.xyz',
 };
 
 export type ParaswapQuoteRequestParams = {