@shogun-sdk/intents-sdk 1.0.2 → 1.1.0

package/src/utils/defillama.ts

@@ -1,15 +1,10 @@
 import { ChainID, type SupportedChain } from '../chains.js';
-import {
-  isNativeTokenEvmAddress,
-  NATIVE_SOLANA_TOKEN_ADDRESS,
-  REDUCTION_FACTOR,
-  STABLECOIN_DECIMALS,
-  WRAPPED_SOL_MINT_ADDRESS,
-} from '../constants.js';
-import { CalculateAmountError } from '../errors/index.js';
+import { NATIVE_EVM_ETH_ADDRESSES, NATIVE_SOLANA_TOKEN_ADDRESS, WRAPPED_SOL_MINT_ADDRESS } from '../constants.js';
 import { Parsers } from './parsers.js';
+import { QuoteProvider } from './quote/aggregator.js';
 
 const TOKEN_PRICE_BASE_URL: string = 'https://coins.llama.fi/prices/current/';
+const STABLECOIN_DECIMALS = 6; // USDC/USDT typically use 6 decimals
 
 /**
  * Response structure from DefiLlama API for token prices
@@ -42,6 +37,7 @@ export const chainIdToDefiLlamaChainMap = {
   [ChainID.Arbitrum]: 'arbitrum',
   [ChainID.Base]: 'base',
   [ChainID.Optimism]: 'optimism',
+  [ChainID.Hyperliquid]: 'hyperliquid',
   [ChainID.Solana]: 'solana',
   [ChainID.Sui]: 'sui',
 } as const;
@@ -52,9 +48,6 @@ export const chainIdToDefiLlamaChainMap = {
  */
 export const createDefiLlamaCoinKey = (chainId: ChainID, tokenAddress: string): string => {
   const chainName = chainIdToDefiLlamaChainMap[chainId];
-  if (!chainName) {
-    throw new CalculateAmountError(`Unsupported chain ID for DefiLlama: ${chainId}`);
-  }
 
   return `${chainName}:${toDefiLlamaToken(tokenAddress)}`;
 };
@@ -71,7 +64,7 @@ export const getCoinFromResponse = (
   const coin = response.coins[key];
 
   if (!coin) {
-    throw new CalculateAmountError(`DefiLlama coin not found for ${key}`);
+    throw new Error(`DefiLlama coin not found for ${key}`);
   }
 
   return coin;
@@ -96,6 +89,12 @@ function toDefiLlamaToken(tokenAddress: string): string {
   return tokenAddress;
 }
 
+function isNativeTokenEvmAddress(tokenAddress: string): boolean {
+  const normalizedAddress = tokenAddress.toLowerCase();
+
+  return NATIVE_EVM_ETH_ADDRESSES.some((addr) => addr.toLowerCase() === normalizedAddress);
+}
+
 /**
  * Builds a comma-separated query string for DefiLlama API token requests
  *
@@ -104,8 +103,6 @@ function toDefiLlamaToken(tokenAddress: string): string {
  *
  * @param tokens - Array of [ChainID, token address] tuples to query
  * @returns Comma-separated string of DefiLlama coin keys
- *
- * @throws {CalculateAmountError} When any chain ID is not supported by DefiLlama
  */
 function buildTokensQueryString(tokens: Array<[ChainID, string]>): string {
   return tokens.map(([chainId, tokenAddress]) => createDefiLlamaCoinKey(chainId, tokenAddress)).join(',');
@@ -116,7 +113,6 @@ function buildTokensQueryString(tokens: Array<[ChainID, string]>): string {
  *
  * @param tokens Array of [ChainID, Token Address] tuples
  * @returns Promise resolving to DefiLlama tokens response
- * @throws {CalculateAmountError} If the request fails or response is invalid
  */
 export async function getTokensData(tokens: Array<[ChainID, string]>): Promise<DefiLlamaTokensResponse> {
   const tokensStr = buildTokensQueryString(tokens);
@@ -129,13 +125,9 @@ export async function getTokensData(tokens: Array<[ChainID, string]>): Promise<D
     },
   });
 
-  if (!response.ok) {
-    throw new CalculateAmountError(`Failed to fetch token prices: ${response.status} ${response.statusText}`);
-  }
-
-  const data: DefiLlamaTokensResponse = await response.json();
-  return data;
+  return response.json();
 }
+
 export async function calculateAmounts({
   srcChainId,
   tokenIn,
@@ -155,21 +147,14 @@ export async function calculateAmounts({
     [destChainId, tokenOut],
   ]);
 
-  // Get token data for input token
   const tokenInData = getCoinFromResponse(tokensResponse, srcChainId, tokenIn);
-  if (!tokenInData) {
-    throw new CalculateAmountError(`Token ${tokenIn} for chain ${srcChainId} not found in DefiLlama response`);
-  }
 
-  // Get token data for output token
   const tokenOutData = getCoinFromResponse(tokensResponse, destChainId, tokenOut);
-  if (!tokenOutData) {
-    throw new CalculateAmountError(`Token ${tokenOut} for chain ${destChainId} not found in DefiLlama response`);
-  }
 
   // Calculate 80% of the amount_in value as amount_out_min and min_stablecoins_amount
   const tokenInUsdAmount = Parsers.bigintToFloat(amountIn, tokenInData.decimals) * tokenInData.price;
-  const amountInUsdReduced = tokenInUsdAmount * REDUCTION_FACTOR;
+  const reductionFactor = QuoteProvider.calculateWeightedReductionFactorForUsd(tokenInUsdAmount);
+  const amountInUsdReduced = tokenInUsdAmount * reductionFactor;
   const amountOutReduced = amountInUsdReduced / tokenOutData.price;
 
   const amountOut = Parsers.floatToBigint(amountOutReduced, tokenOutData.decimals);

package/src/utils/order-validator.ts

@@ -1,6 +1,7 @@
 import { ChainType, chainIdToChainTypeMap, type SupportedChain } from '../chains.js';
 import { EvmValidator } from '../core/evm/validator.js';
-import type { OrderInput } from '../core/order.js';
+import type { CreateCrossChainOrderParams } from '../core/orders/cross-chain.js';
+import type { CreateSingleChainOrderParams } from '../core/orders/single-chain.js';
 import { SolanaValidator } from '../core/solana/validator.js';
 import { SuiValidator } from '../core/sui/validator.js';
 import { ValidationError } from '../errors/index.js';
@@ -21,19 +22,16 @@ export interface IDeadlineValidator {
   isValidDeadline(deadline: number): boolean;
 }
 
-export interface ICrossChainValidator {
-  isValidCrossChain(sourceChainId: SupportedChain, destinationChainId: SupportedChain): boolean;
-}
-
 export interface IChainValidator extends IAddressValidator, ITokenValidator, IAmountValidator {
-  validateSourceChain(order: OrderInput): Promise<void>;
-  validateDestinationChain(order: OrderInput): void;
+  validateSourceChain(order: CreateCrossChainOrderParams & { user: string }): Promise<void>;
+  validateDestinationChain(order: CreateCrossChainOrderParams): void;
+  validateSingleChainOrder(order: CreateSingleChainOrderParams & { user: string }): Promise<void>;
 }
 
 /**
  * CommonValidator - Handles validations shared across chains
  */
-export class CommonValidator implements IDeadlineValidator, ICrossChainValidator {
+export class CommonValidator implements IDeadlineValidator {
   isValidDeadline(deadline: number): boolean {
     return deadline > Math.floor(Date.now() / 1000);
   }
@@ -43,16 +41,6 @@ export class CommonValidator implements IDeadlineValidator, ICrossChainValidator
       throw new ValidationError('Deadline must be in the future');
     }
   }
-
-  isValidCrossChain(sourceChainId: SupportedChain, destinationChainId: SupportedChain): boolean {
-    return sourceChainId !== destinationChainId;
-  }
-
-  validateCrossChain(sourceChainId: SupportedChain, destinationChainId: SupportedChain): void {
-    if (!this.isValidCrossChain(sourceChainId, destinationChainId)) {
-      throw new ValidationError('Source and destination chains cannot be the same');
-    }
-  }
 }
 
 export class ValidatorFactory {
@@ -84,15 +72,13 @@ export class ValidatorFactory {
   }
 }
 
-export class OrderValidator {
+export class CrossChainOrderValidator {
   private readonly commonValidator = new CommonValidator();
 
-  async validateOrder(order: OrderInput): Promise<void> {
+  async validateOrder(order: CreateCrossChainOrderParams & { user: string }): Promise<void> {
     const sourceValidator = ValidatorFactory.getValidatorForChain(order.sourceChainId);
 
-    await sourceValidator.validateSourceChain(order);
-
-    // this.commonValidator.validateCrossChain(order.sourceChainId, order.destinationChainId);
+    await sourceValidator.validateSourceChain({ ...order, user: order.user });
 
     const destinationValidator = ValidatorFactory.getValidatorForChain(order.destinationChainId);
 
@@ -101,3 +87,15 @@ export class OrderValidator {
     this.commonValidator.validateDeadline(order.deadline);
   }
 }
+
+export class SingleChainOrderValidator {
+  private readonly commonValidator = new CommonValidator();
+
+  async validateOrder(order: CreateSingleChainOrderParams & { user: string }): Promise<void> {
+    this.commonValidator.validateDeadline(order.deadline);
+
+    const chainValidator = ValidatorFactory.getValidatorForChain(order.chainId);
+
+    chainValidator.validateSingleChainOrder(order);
+  }
+}

package/src/utils/parsers.ts

@@ -1,55 +1,30 @@
 /* eslint-disable @typescript-eslint/no-namespace */
 import { formatUnits, parseUnits } from 'viem';
-import { CalculateAmountError } from '../errors/index.js';
 
 export namespace Parsers {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   export function bigIntReplacer(_key: string, value: any): any {
-    return typeof value === 'bigint' ? value.toString() : value;
+    if (typeof value === 'bigint') {
+      return value.toString();
+    }
+
+    if (typeof value === 'string' && /^\d+n$/.test(value)) {
+      return value.slice(0, -1);
+    }
+
+    return value;
   }
 
-  /**
-   * Converts a bigint amount to a floating point USD value
-   * @param amount Amount in token's smallest unit
-   * @param decimals Number of decimal places for the token
-   * @returns USD value as number
-   */
   export function bigintToFloat(amount: bigint, decimals: number): number {
     const formatted = formatUnits(amount, decimals);
     const result = parseFloat(formatted);
 
-    if (!Number.isFinite(result)) {
-      throw new CalculateAmountError(`Conversion resulted in invalid number: ${formatted}`);
-    }
-
     return result;
   }
 
-  /**
-   * Converts a floating point USD value to bigint amount
-   * Uses viem's parseUnits for consistency and reliability
-   * @param usdValue USD value as number
-   * @param decimals Number of decimal places for the token
-   * @returns Amount in token's smallest unit
-   */
   export function floatToBigint(usdValue: number, decimals: number): bigint {
-    if (!Number.isFinite(usdValue) || usdValue < 0) {
-      throw new CalculateAmountError(`Invalid USD value: ${usdValue}`);
-    }
-
-    if (decimals < 0 || decimals > 77) {
-      throw new CalculateAmountError(`Invalid decimals: ${decimals}`);
-    }
-
-    // Convert to fixed-precision string to avoid floating point issues
     const valueString = usdValue.toFixed(decimals);
 
-    try {
-      return parseUnits(valueString, decimals);
-    } catch (error) {
-      throw new CalculateAmountError(
-        `Failed to convert ${usdValue} to bigint with ${decimals} decimals: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      );
-    }
+    return parseUnits(valueString, decimals);
   }
 }

package/src/utils/quote/aftermath.ts

@@ -0,0 +1,24 @@
+import { Aftermath } from 'aftermath-ts-sdk';
+
+export type AfterMathQuoteParams = {
+  amountIn: bigint;
+  tokenIn: string;
+  tokenOut: string;
+};
+export class AftermathQuoteProvider {
+  public async getQuote(params: AfterMathQuoteParams) {
+    const afSdk = new Aftermath('MAINNET');
+
+    await afSdk.init();
+
+    const router = afSdk.Router();
+
+    const quote = await router.getCompleteTradeRouteGivenAmountIn({
+      coinInAmount: params.amountIn,
+      coinInType: params.tokenIn,
+      coinOutType: params.tokenOut,
+    });
+
+    return quote;
+  }
+}

package/src/utils/quote/aggregator.ts

@@ -0,0 +1,331 @@
+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 { AftermathQuoteProvider } from './aftermath.js';
+import type { RouterCompleteTradeRoute } from 'aftermath-ts-sdk';
+import { calculateAmounts } from '../defillama.js';
+import { LiquidSwapQuoteProvider, type LiquidSwapQuoteResponse } from './liquidswap.js';
+
+type SingleChainQuoteParams = {
+  chainId: ChainID;
+  amount: bigint;
+  tokenIn: string;
+  tokenOut: string;
+  slippageBps?: number;
+};
+
+export type RouteProvider = 'paraswap' | 'jupiter' | 'aftermath' | 'liquidswap';
+
+export type Quote = {
+  amountIn: bigint;
+  amountOut: bigint;
+  amountOutUsd: number;
+  amountInUsd: number;
+  slippage: number;
+  priceImpact: number;
+  provider: RouteProvider;
+  rawQuote: any;
+};
+
+export type QuoteParams = {
+  sourceChainId: ChainID;
+  destChainId: ChainID;
+  amount: bigint;
+  tokenIn: string;
+  tokenOut: string;
+};
+
+export type QuoteResponse = {
+  amountInUsd: number;
+  estimatedAmountInAsMinStablecoinAmount: bigint;
+
+  estimatedAmountOut: bigint;
+  estimatedAmountOutUsd: number;
+
+  estimatedAmountOutReduced: bigint;
+  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 static async getQuoteWithDefillamaFallback(params: QuoteParams): Promise<QuoteResponse> {
+    try {
+      const quote = await this.getQuoteFromRouters(params);
+      return quote;
+    } catch (e) {
+      const quote = await this.getQuoteFromDefillama(params);
+      return quote;
+    }
+  }
+
+  public static async getQuote(params: QuoteParams): Promise<QuoteResponse> {
+    return this.getQuoteWithDefillamaFallback(params);
+  }
+
+  private static async getQuoteFromRouters(params: QuoteParams): Promise<QuoteResponse> {
+    const bridgeTokenSymbol = QuoteProvider.DEFAULT_BRIDGE_TOKEN;
+
+    const sourceBridgeToken = CROSS_CHAIN_TOKENS[bridgeTokenSymbol]?.[params.sourceChainId]!;
+    const destBridgeToken = CROSS_CHAIN_TOKENS[bridgeTokenSymbol]?.[params.destChainId]!;
+
+    const sourceSingleChainQuoteParams: SingleChainQuoteParams = {
+      chainId: params.sourceChainId,
+      amount: params.amount,
+      tokenIn: params.tokenIn,
+      tokenOut: sourceBridgeToken,
+    };
+
+    const sourceQuote = await this.getSingleChainQuote(sourceSingleChainQuoteParams);
+
+    const destSingleChainQuoteParams: SingleChainQuoteParams = {
+      chainId: params.destChainId,
+      amount: sourceQuote.amountOut,
+      tokenIn: destBridgeToken,
+      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);
+    const estimatedAmountInAsMinStablecoinAmount = BigInt(
+      Math.floor(reducedAmountInUsd * 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS),
+    );
+
+    return {
+      estimatedAmountOut: destQuote.amountOut,
+      estimatedAmountOutUsd: destQuote.amountOutUsd,
+      amountInUsd: sourceQuote.amountInUsd,
+      estimatedAmountInAsMinStablecoinAmount,
+      estimatedAmountOutReduced,
+      estimatedAmountOutUsdReduced,
+    };
+  }
+
+  public static async getSingleChainQuote(params: SingleChainQuoteParams): Promise<Quote> {
+    if (params.tokenIn.toLowerCase() === params.tokenOut.toLowerCase()) {
+      let amountUsd = 0;
+
+      if (params.tokenIn.toLowerCase() === CROSS_CHAIN_TOKENS.USDC![params.chainId].toLowerCase()) {
+        amountUsd = Number(params.amount) / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
+      }
+
+      return {
+        amountIn: params.amount,
+        amountOut: params.amount,
+        amountOutUsd: amountUsd,
+        amountInUsd: amountUsd,
+        slippage: 0,
+        priceImpact: 0,
+        provider: getProviderNameByChainId(params.chainId),
+        rawQuote: null,
+      };
+    }
+
+    if (params.chainId === ChainID.Hyperliquid) {
+      const liquidSwapQuote = await QuoteProvider.getLiquidSwapQuote(params);
+      return QuoteProvider.transformLiquidSwapQuote(liquidSwapQuote);
+    }
+
+    if (params.chainId === ChainID.Solana) {
+      const jupiterQuote = await QuoteProvider.getJupiterQuote(params);
+      return QuoteProvider.transformJupiterQuote(jupiterQuote);
+    }
+
+    if (params.chainId === ChainID.Sui) {
+      const quote = await QuoteProvider.getAftermathQuote(params);
+      return QuoteProvider.transformAftermathQuote({ quote, request: params });
+    }
+
+    if (isEvmChain(params.chainId)) {
+      const paraswapQuote = await QuoteProvider.getParaswapQuote(params);
+      return QuoteProvider.transformParaswapQuote(paraswapQuote);
+    }
+
+    throw new Error(`Unsupported chain for quote: ${params.chainId}`);
+  }
+
+  static transformLiquidSwapQuote(liquidSwapQuote: LiquidSwapQuoteResponse): Quote {
+    return {
+      amountIn: BigInt(liquidSwapQuote.amountIn),
+      amountOut: BigInt(liquidSwapQuote.amountOut),
+      amountOutUsd: 0,
+      amountInUsd: 0,
+      slippage: 0,
+      priceImpact: Number(liquidSwapQuote.averagePriceImpact),
+      provider: 'liquidswap',
+      rawQuote: liquidSwapQuote,
+    };
+  }
+
+  /**
+   * Calculates the weighted reduction factor for an amount in USD.
+   * For amounts <= $5, the reduction factor is 0.65.
+   */
+  public static calculateWeightedReductionFactorForUsd(amountUsd: number): number {
+    if (amountUsd <= 5) {
+      return 0.5;
+    } else if (amountUsd <= 10) {
+      return 0.65;
+    } else if (amountUsd <= 20) {
+      return 0.77;
+    } else if (amountUsd <= 30) {
+      return 0.9;
+    } else {
+      return 0.95;
+    }
+  }
+
+  protected static async getLiquidSwapQuote(params: SingleChainQuoteParams) {
+    const liquidSwapQuoter = new LiquidSwapQuoteProvider();
+
+    return liquidSwapQuoter.getQuote({
+      tokenIn: params.tokenIn,
+      tokenOut: params.tokenOut,
+      amountIn: params.amount.toString(),
+    });
+  }
+
+  protected static async getJupiterQuote(params: SingleChainQuoteParams) {
+    const jupiterQuoter = new JupiterQuoteProvider();
+
+    return jupiterQuoter.getQuote({
+      amount: params.amount,
+      tokenIn: params.tokenIn,
+      tokenOut: params.tokenOut,
+      swapMode: 'ExactIn',
+      slippageBps: params.slippageBps,
+    });
+  }
+
+  protected static async getParaswapQuote(params: SingleChainQuoteParams) {
+    const paraswapQuoter = new ParaswapQuoteProvider(params.chainId as SupportedEvmChain);
+
+    return paraswapQuoter.getSwapEstimation({
+      amount: BigInt(params.amount),
+      srcToken: params.tokenIn,
+      destToken: params.tokenOut,
+      side: 'SELL',
+    });
+  }
+
+  protected static async getAftermathQuote(params: SingleChainQuoteParams) {
+    const aftermathQuoter = new AftermathQuoteProvider();
+
+    return aftermathQuoter.getQuote({
+      amountIn: params.amount,
+      tokenIn: params.tokenIn,
+      tokenOut: params.tokenOut,
+    });
+  }
+
+  private static transformAftermathQuote({
+    quote,
+    request,
+  }: {
+    quote: RouterCompleteTradeRoute;
+    request: SingleChainQuoteParams;
+  }): Quote {
+    let amountUsd = 0;
+
+    if (request.tokenIn === CROSS_CHAIN_TOKENS.USDC![request.chainId]) {
+      amountUsd = Number(quote.coinIn.amount) / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
+    }
+
+    if (request.tokenOut === CROSS_CHAIN_TOKENS.USDC![request.chainId]) {
+      amountUsd = Number(quote.coinOut.amount) / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
+    }
+
+    return {
+      amountIn: quote.coinIn.amount,
+      amountOut: quote.coinOut.amount,
+      amountOutUsd: amountUsd,
+      amountInUsd: amountUsd,
+      slippage: quote.slippage ?? 0,
+      priceImpact: 0,
+      provider: 'aftermath',
+      rawQuote: quote,
+    };
+  }
+
+  private static transformParaswapQuote(paraswapQuote: SwapEstimateResult): Quote {
+    return {
+      amountIn: BigInt(paraswapQuote.amountIn),
+      amountOut: BigInt(paraswapQuote.amountOut),
+      amountOutUsd: paraswapQuote.amountOutUsd,
+      amountInUsd: paraswapQuote.amountInUsd,
+      slippage: 0, // Calculate from paraswap data if available
+      priceImpact: paraswapQuote.quote.maxImpact ? Number(paraswapQuote.quote.maxImpact) * 100 : 0,
+      provider: 'paraswap',
+      rawQuote: paraswapQuote,
+    };
+  }
+
+  private static transformJupiterQuote({ quote }: { quote: JupiterQuoteResponse }): Quote {
+    const amountIn = Number(quote.inAmount);
+    const amountOut = Number(quote.outAmount);
+    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;
+    }
+
+    return {
+      amountIn: BigInt(amountIn),
+      amountOut: BigInt(amountOut),
+      amountOutUsd: amountUsd,
+      amountInUsd: amountUsd,
+      slippage: quote.slippageBps ? quote.slippageBps / 100 : 0,
+      priceImpact,
+      provider: 'jupiter',
+      rawQuote: quote,
+    };
+  }
+}
+
+function getProviderNameByChainId(chainId: ChainID): RouteProvider {
+  switch (chainId) {
+    case ChainID.Sui:
+      return 'aftermath';
+    case ChainID.Solana:
+      return 'jupiter';
+    case ChainID.Hyperliquid:
+      return 'liquidswap';
+    default:
+      return 'paraswap';
+  }
+}

package/src/utils/quote/jupiter.ts

@@ -0,0 +1,39 @@
+import { createJupiterApiClient, SwapApi, type QuoteResponse } from '@jup-ag/api';
+
+export type JupiterQuoteParams = {
+  amount: bigint;
+  tokenIn: string;
+  tokenOut: string;
+  swapMode: 'ExactIn' | 'ExactOut';
+  slippageBps?: number;
+};
+
+const NATIVE_SOL = 'So11111111111111111111111111111111111111111';
+const WRAPPED_SOL = 'So11111111111111111111111111111111111111112';
+export class JupiterQuoteProvider {
+  public swapApi: SwapApi;
+
+  constructor() {
+    this.swapApi = createJupiterApiClient({ fetchApi: fetch });
+  }
+
+  public async getQuote(params: JupiterQuoteParams): Promise<{ quote: QuoteResponse }> {
+    if (params.tokenIn === NATIVE_SOL) {
+      params.tokenIn = WRAPPED_SOL;
+    }
+
+    if (params.tokenOut === NATIVE_SOL) {
+      params.tokenOut = WRAPPED_SOL;
+    }
+
+    const quote = await this.swapApi.quoteGet({
+      amount: Number(params.amount),
+      inputMint: params.tokenIn,
+      outputMint: params.tokenOut,
+      swapMode: params.swapMode,
+      slippageBps: params.slippageBps,
+    });
+
+    return { quote };
+  }
+}

package/src/utils/quote/liquidswap.ts

@@ -0,0 +1,42 @@
+import { ChainID } from '../../chains.js';
+import { isNativeEvmToken, WRAPPED_ETH_ADDRESSES } from '../../constants.js';
+
+type LiquidSwapQuoteParams = {
+  tokenIn: string;
+  tokenOut: string;
+  amountIn: string;
+};
+
+export type LiquidSwapQuoteResponse = {
+  success: boolean;
+  amountIn: string;
+  amountOut: string;
+  averagePriceImpact: string;
+};
+
+const LIQUID_SWAP_API_URL = 'https://api.liqd.ag';
+
+export class LiquidSwapQuoteProvider {
+  public async getQuote(liquidSwapParams: LiquidSwapQuoteParams): Promise<LiquidSwapQuoteResponse> {
+    const params = {...liquidSwapParams};
+    
+    if (isNativeEvmToken(params.tokenOut)) {
+      params.tokenOut = WRAPPED_ETH_ADDRESSES[ChainID.Hyperliquid];
+    }
+
+    if (isNativeEvmToken(params.tokenIn)) {
+      params.tokenIn = WRAPPED_ETH_ADDRESSES[ChainID.Hyperliquid];
+    }
+
+    const url = `${LIQUID_SWAP_API_URL}/v2/route?tokenIn=${params.tokenIn}&tokenOut=${params.tokenOut}&amountIn=${params.amountIn}`;
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error('Failed to fetch quote from LiquidSwap API');
+    }
+
+    const data: LiquidSwapQuoteResponse = await response.json();
+
+    return data;
+  }
+}