@shogun-sdk/intents-sdk 1.0.2 → 1.1.1

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

package/src/utils/quote/paraswap.ts

@@ -0,0 +1,87 @@
+import { constructSimpleSDK, type OptimalRate } from '@paraswap/sdk';
+import { ChainID, type SupportedEvmChain } from '../../chains.js';
+import { ChainProvider } from '../../core/evm/chain-provider.js';
+import { getContract, type Address } from 'viem';
+import { ERC20ABI } from '../../core/evm/abi/erc20.js';
+import { isNativeEvmToken, WRAPPED_ETH_ADDRESSES } from '../../constants.js';
+
+const rpcProvidersUrl: Record<SupportedEvmChain, string> = {
+  [ChainID.Arbitrum]: 'https://arbitrum-one-rpc.publicnode.com',
+  [ChainID.Optimism]: 'https://optimism-rpc.publicnode.com',
+  [ChainID.Base]: 'https://base-rpc.publicnode.com',
+  [ChainID.Hyperliquid]: 'https://rpc.hyperliquid.xyz/evm',
+};
+
+export type ParaswapQuoteRequestParams = {
+  srcToken: string;
+  destToken: string;
+  amount: bigint;
+  side: 'SELL' | 'BUY';
+};
+
+export type SwapEstimateResult = {
+  amountOut: bigint;
+  amountIn: bigint;
+  amountOutUsd: number;
+  amountInUsd: number;
+  quote: OptimalRate;
+};
+
+export class ParaswapQuoteProvider {
+  protected chainId: SupportedEvmChain;
+
+  constructor(chainId: SupportedEvmChain) {
+    this.chainId = chainId;
+  }
+
+  private async getTokenDecimals(tokenAddress: Address): Promise<number> {
+    const rpcUrl = rpcProvidersUrl[this.chainId];
+    const client = ChainProvider.getClient(this.chainId, rpcUrl);
+    const erc20Contract = getContract({
+      abi: ERC20ABI,
+      address: tokenAddress,
+      client,
+    });
+
+    return erc20Contract.read.decimals();
+  }
+
+  private async getQuote(paraswapParams: ParaswapQuoteRequestParams): Promise<OptimalRate> {
+    const params = { ...paraswapParams };
+    if (isNativeEvmToken(params.destToken)) {
+      params.destToken = WRAPPED_ETH_ADDRESSES[this.chainId];
+    }
+
+    const [srcTokenDecimals, destTokenDecimals] = await Promise.all([
+      this.getTokenDecimals(params.srcToken as Address),
+      this.getTokenDecimals(params.destToken as Address),
+    ]);
+
+    const sdk = constructSimpleSDK({ chainId: this.chainId, fetch: fetch });
+    return sdk.swap.getRate({
+      amount: params.amount.toString(),
+      destDecimals: destTokenDecimals,
+      destToken: params.destToken,
+      side: params.side,
+      srcDecimals: srcTokenDecimals,
+      srcToken: params.srcToken,
+    });
+  }
+
+  public async getSwapEstimation(params: ParaswapQuoteRequestParams): Promise<SwapEstimateResult> {
+    const optimalRate = await this.getQuote(params);
+    const amountOut = optimalRate.destAmount;
+    const amountIn = optimalRate.srcAmount;
+
+    const amountOutUsd = optimalRate.destUSD ?? 0;
+    const amountInUsd = optimalRate.srcUSD ?? 0;
+
+    return {
+      amountIn: BigInt(amountIn),
+      amountOut: BigInt(amountOut),
+      amountOutUsd: Number(amountOutUsd),
+      amountInUsd: Number(amountInUsd),
+      quote: optimalRate,
+    };
+  }
+}

package/src/utils/quote/stablecoins-tokens.ts

@@ -0,0 +1,22 @@
+import { ChainID } from '../../chains.js';
+
+export type QuoteParams = {
+  sourceChainId: ChainID;
+  destChainId: ChainID;
+  amount: number;
+  tokenIn: string;
+  tokenOut: string;
+  slippageBps?: number;
+};
+
+export const CROSS_CHAIN_TOKENS: Record<string, Record<ChainID, string>> = {
+  USDC: {
+    [ChainID.Solana]: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC on Solana
+    [ChainID.Base]: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
+    [ChainID.Arbitrum]: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // USDC on Arbitrum
+    [ChainID.Hyperliquid]: '0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb', // USDT on Hyperliquid (No USDC on Hyperliquid)
+    [ChainID.Sui]: '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC', // USDC on Sui
+    [ChainID.Optimism]: '0x7F5c764cBc14f9669B88837ca1490cCa17c31607', // USDC on Optimism
+  },
+  // Add more tokens as needed
+};