@shogun-sdk/intents-sdk 1.0.2 → 1.1.1

package/src/core/sui/sdk.ts

@@ -1,13 +1,14 @@
 import type { SuiClient } from '@mysten/sui/client';
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
-
 import type { SuiConfig } from '../../config.js';
-import { OrderCreationError } from '../../errors/index.js';
-import type { PreparedOrder } from '../../types/intent.js';
-import { Order } from '../order.js';
 import { BaseSDK } from '../sdk.js';
 import { createSuiClient } from './client.js';
 import { getSuiOrderTransaction } from './order-transaction.js';
+import { getSuiCancelCrossChainOrder } from './cancel.js';
+import type { CrossChainOrderPrepared, SingleChainOrderPrepared } from '../../types/intent.js';
+import type { CrossChainOrder } from '../orders/cross-chain.js';
+import { fetchJWTToken, fetchSiweMessage } from '../../auth/siwe.js';
+import { ChainID } from '../../chains.js';
 
 /**
  * Sui-specific SDK implementation
@@ -17,10 +18,6 @@ import { getSuiOrderTransaction } from './order-transaction.js';
  * Supports cross-chain swaps from Sui to other supported chains.
  */
 export class SuiSDK extends BaseSDK {
-  protected override cancelOrderInternal(): Promise<string> {
-    throw new Error('Method not implemented.');
-  }
-
   /** Configuration for Sui connection and authentication */
   private readonly config: SuiConfig;
   /** Client for Sui RPC interactions and transaction handling */
@@ -60,6 +57,39 @@ export class SuiSDK extends BaseSDK {
     return Ed25519Keypair.fromSecretKey(this.config.privateKey);
   }
 
+  protected override prepareSingleChainOrder(): Promise<SingleChainOrderPrepared> {
+    throw new Error('Single-chain orders are not supported on Sui');
+  }
+
+  public async authenticate(token?: string): Promise<string> {
+    const wallet = await this.getUserAddress();
+
+    const response = await fetchSiweMessage({
+      chainId: ChainID.Sui,
+      wallet,
+    });
+
+    const message = response.data!;
+
+    const keypair = this.getKeyPair();
+
+    const messageBytes = new TextEncoder().encode(message);
+
+    const { signature } = await keypair.signPersonalMessage(messageBytes);
+
+    const jwt = await fetchJWTToken(
+      {
+        message,
+        signature,
+      },
+      token,
+    );
+
+    const newToken = jwt.data!;
+
+    return newToken;
+  }
+
   /**
    * Prepares a Sui order for submission
    *
@@ -73,27 +103,42 @@ export class SuiSDK extends BaseSDK {
    * @returns Promise resolving to a prepared order with Sui-specific data
    * @protected
    */
-  protected async prepareOrder(order: Order): Promise<PreparedOrder> {
-    try {
-      const signer = this.getKeyPair();
-
-      const transaction = await getSuiOrderTransaction(order);
-
-      const tx = await this.client.signAndExecuteTransaction({
-        signer,
-        transaction,
-      });
-
-      await this.client.waitForTransaction({ digest: tx.digest });
-
-      return {
-        order,
-        preparedData: {
-          transactionHash: tx.digest,
-        },
-      };
-    } catch (error) {
-      throw new OrderCreationError('Failed to prepare Sui order', error);
-    }
+  protected async prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared> {
+    const signer = this.getKeyPair();
+
+    const transaction = await getSuiOrderTransaction(order);
+
+    const tx = await this.client.signAndExecuteTransaction({
+      signer,
+      transaction,
+    });
+
+    await this.client.waitForTransaction({ digest: tx.digest });
+
+    return {
+      order,
+      preparedData: {
+        transactionHash: tx.digest,
+      },
+    };
+  }
+
+  public async cancelCrossChainOrder(orderId: string): Promise<string> {
+    const signer = this.getKeyPair();
+
+    const transaction = await getSuiCancelCrossChainOrder(orderId);
+
+    const sender = await this.getUserAddress();
+
+    transaction.setSender(sender);
+
+    const tx = await this.client.signAndExecuteTransaction({
+      signer,
+      transaction,
+    });
+
+    await this.client.waitForTransaction({ digest: tx.digest });
+
+    return tx.digest;
   }
 }

package/src/core/sui/validator.ts

@@ -25,8 +25,12 @@ export class SuiValidator extends BaseValidator {
     return 'Sui';
   }
 
-  public async chainSpecificValidation(): Promise<void> {
+  public async validateCrossChainOrderFeasability(): Promise<void> {
     // No chain-specific validation implemented for now for Sui
     return;
   }
+
+  override validateSingleChainOrderFeasability(): Promise<void> {
+    return Promise.resolve();
+  }
 }

package/src/errors/index.ts

@@ -32,29 +32,6 @@ export class BaseError extends Error {
   }
 }
 
-// Chain-specific error classes
-export class EVMError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, EVMError.prototype);
-  }
-}
-
-export class SolanaError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, SolanaError.prototype);
-  }
-}
-
-export class SuiError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, SuiError.prototype);
-  }
-}
-
-// Specific error types
 export class ValidationError extends BaseError {
   constructor(message: string, cause?: unknown) {
     super(message, cause);
@@ -62,13 +39,6 @@ export class ValidationError extends BaseError {
   }
 }
 
-export class OrderCreationError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, OrderCreationError.prototype);
-  }
-}
-
 export class NetworkError extends BaseError {
   constructor(message: string, cause?: unknown) {
     super(message, cause);
@@ -83,19 +53,13 @@ export class InsufficientBalanceError extends BaseError {
   }
 }
 
-export class CalculateAmountError extends BaseError {
-  constructor(message: string, cause?: unknown) {
-    super(message, cause);
-    Object.setPrototypeOf(this, CalculateAmountError.prototype);
-  }
-}
-
 export class InsufficientAllowanceError extends BaseError {
   constructor(message: string, cause?: unknown) {
     super(message, cause);
     Object.setPrototypeOf(this, InsufficientAllowanceError.prototype);
   }
 }
+
 export function handleError(error: unknown): BaseError {
   if (error instanceof BaseError) {
     return error;

package/src/index.ts

@@ -1,21 +1,43 @@
-export { ChainID, ChainType, SupportedChains } from './chains.js';
-export type { SupportedEvmChain } from './chains.js';
+export { ChainID, ChainType, SupportedChains, isSupportedChain, chainIdToChainTypeMap, isEvmChain } from './chains.js';
+export type { SupportedEvmChain, SupportedChain } from './chains.js';
 
 export type { EVMConfig, SolanaConfig, SuiConfig } from './config.js';
 export { EVMSDK } from './core/evm/sdk.js';
-export { Order } from './core/order.js';
 export { SolanaSDK } from './core/solana/sdk.js';
 export { SuiSDK } from './core/sui/sdk.js';
+export { CrossChainOrder } from './core/orders/cross-chain.js';
+export type { CreateCrossChainOrderParams } from './core/orders/cross-chain.js';
+export { SingleChainOrder } from './core/orders/single-chain.js';
+export type { CreateSingleChainOrderParams } from './core/orders/single-chain.js';
+
+export { fetchUserOrders } from './core/orders/api/fetch.js';
+export { AuctioneerAPI } from './core/orders/api/index.js';
+export { type FetchJWTParams, type FetchSiweMessageParams, fetchJWTToken, fetchSiweMessage } from './auth/siwe.js';
 export { ValidationError } from './errors/index.js';
-export {
-  calculateAmounts,
-  chainIdToDefiLlamaChainMap,
-  createDefiLlamaCoinKey,
-  getCoinFromResponse,
-  getTokensData,
-} from './utils/defillama.js';
+export { type ApiCrossChainOrder, type ApiResponse, type ApiSingleChainOrder, type ApiUserOrders, type ChainOrderStatus, isErrorApiResponse, isSuccessApiResponse } from './types/api.js';
+export { calculateAmounts, getCoinFromResponse, getTokensData } from './utils/defillama.js';
 export type { DefiLlamaCoinData, DefiLlamaTokensResponse } from './utils/defillama.js';
-export type { CreateOrderParams } from './types/intent.js';
-export { getEvmOrderTypedData, sendEvmRequest } from './core/evm/order-signature.js';
-export { getSolanaOrderInstructions, sendSolanaRequest } from './core/solana/order-instructions.js';
-export { getSuiOrderTransaction, sendSuiRequest } from './core/sui/order-transaction.js';
+export {
+  getCancelCrossChainOrderRawData,
+  getCancelSingleChainOrderRawData,
+  type CancelSingleChainOrderParams,
+  type CancelCrossChainOrderParams,
+  getInvalidateNoncesRawData,
+} from './core/evm/cancel-order.js';
+export { getEVMCrossChainOrderTypedData, getEVMSingleChainOrderTypedData } from './core/evm/order-signature.js';
+
+export {
+  getSolanaCrossChainOrderInstructions,
+  getSolanaSingleChainOrderInstructions,
+} from './core/solana/order-instructions.js';
+export {
+  cancelCrossChainOrderInstructionsAsBytes,
+  cancelSingleChainOrderInstructionsAsBytes,
+} from './core/solana/cancel-order.js';
+export { getSuiOrderTransaction } from './core/sui/order-transaction.js';
+export { getSuiCancelCrossChainOrder } from './core/sui/cancel.js';
+
+export { QuoteProvider } from './utils/quote/aggregator.js';
+export type { QuoteResponse } from './utils/quote/aggregator.js';
+
+export { CROSS_CHAIN_GUARD_ADDRESSES, SINGLE_CHAIN_GUARD_ADDRESSES, PERMIT2_ADDRESS } from './constants.js';

package/src/types/api.ts

@@ -1,9 +1,78 @@
-export type ApiResponse = {
-  success: boolean;
-  code: number;
+import type { ExtraTransfer } from '../core/orders/common.js';
 
-  data?: unknown;
+export type ChainOrderStatus = 'Auction' | 'NoBids' | 'Executing' | 'Fulfilled' | 'Cancelled' | 'Outdated';
+
+export type ApiCrossChainOrder = {
+  orderId: string;
+  // Flattened fields from the API response
+  user: string;
+  srcChainId: number;
+  tokenIn: string;
+  minStablecoinsAmount: string;
+  destChainId: number;
+  tokenOut: string;
+  amountOutMin: string;
+  destinationAddress: string;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+  executionDetailsHash: string;
+  amountIn: string;
+  // Cross-chain specific fields
+  executionDetails: string;
+  orderCreationTime: number;
+  orderStatus: ChainOrderStatus;
+  tokensInWereSwappedToStablecoins: boolean;
+  lockedStablecoins: string;
+  nonce?: string;
+  orderFulfillmentTimestamp?: number;
+  transactionHash?: string;
+  amountOut?: string;
+};
 
+export type ApiSingleChainOrder = {
+  orderId: string;
+  // Flattened fields from the API response
+  user: string;
+  chainId: number;
+  tokenIn: string;
+  tokenOut: string;
+  amountOutMin: string;
+  destinationAddress: string;
+  extraTransfers?: ExtraTransfer[];
+  deadline: number;
+  amountIn: string;
+  // Single-chain specific fields
+  orderCreationTime: number;
+  orderStatus: ChainOrderStatus;
+  nonce?: string;
+  orderFulfillmentTimestamp?: number;
+  transactionHash?: string;
+  amountOut?: string;
+};
+
+export type ApiUserOrders = {
+  singleChainLimitOrders: ApiSingleChainOrder[];
+  crossChainLimitOrders: ApiCrossChainOrder[];
+};
+
+export type ValidResponseData = ApiUserOrders | string | null;
+
+export type ApiResponse<T extends ValidResponseData = ValidResponseData> = {
+  success: boolean;
+  code: number;
+  data?: T;
   error?: unknown;
   extra_error_data?: unknown;
 };
+
+export function isSuccessApiResponse<T extends ValidResponseData>(
+  response: ApiResponse<T>,
+): response is ApiResponse<T> & { success: true; data: T } {
+  return response.success;
+}
+
+export function isErrorApiResponse<T extends ValidResponseData>(
+  response: ApiResponse<T>,
+): response is ApiResponse<T> & { success: false; error: unknown } {
+  return !response.success;
+}

package/src/types/intent.ts

@@ -1,35 +1,7 @@
 import type { SupportedChain } from '../chains.js';
-import type { ExtraTransfer, Order } from '../core/order.js';
-
-/**
- * Parameters for creating a cross-chain order
- * Used as input for the createOrder and createAndSendOrder methods
- */
-export type CreateOrderParams = {
-  /** Chain ID where tokens will be sent from */
-  sourceChainId: SupportedChain;
-  /** Token address on the source chain to be swapped */
-  sourceTokenAddress: string;
-  /** Amount of source tokens to swap, in smallest units (e.g., Wei for ETH) */
-  sourceTokenAmount: bigint;
-
-  /** Chain ID where tokens will be received */
-  destinationChainId: SupportedChain;
-  /** Token address on the destination chain to receive */
-  destinationTokenAddress: string;
-  /** Minimum amount of destination tokens to receive, in smallest units */
-  destinationTokenMinAmount?: bigint;
-  /** Recipient wallet address on the destination chain */
-  destinationAddress: string;
-
-  /** Minimum amount of stablecoins in the intermediate swap, in smallest units */
-  minStablecoinAmount?: bigint;
-  /** Timestamp (in seconds) after which the order expires */
-  deadline: number;
-
-  /** Extra Transfers */
-  extraTransfers?: ExtraTransfer[];
-};
+import type { CrossChainOrder } from '../core/orders/cross-chain.js';
+import type { ExtraTransfer } from '../core/orders/common.js';
+import type { SingleChainOrder } from '../core/orders/single-chain.js';
 
 /**
  * Details required to execute the order on the destination chain
@@ -48,15 +20,10 @@ export type ExecutionDetails = {
   extraTransfers?: ExtraTransfer[];
 };
 
-/** Hex string with 0x prefix, used for various hashes */
 export type Hash = `0x${string}`;
 /** Hash of execution details, used to verify order integrity across chains */
 export type ExecutionDetailsHash = Hash;
 
-/**
- * EVM-specific data required for prepared orders
- * Contains the signature and nonce for Permit2 allowance
- */
 export type EvmPreparedData = {
   /** Random nonce for Permit2 signature, prevents replay attacks */
   nonce: string;
@@ -64,19 +31,11 @@ export type EvmPreparedData = {
   signature: string | Hash;
 };
 
-/**
- * Sui-specific data required for prepared orders
- * Contains the transaction hash of the order creation transaction
- */
 export type SuiPreparedData = {
   /** Transaction hash of the successful order creation transaction */
   transactionHash: string;
 };
 
-/**
- * Solana-specific data required for prepared orders
- * Contains the public key of the created order account
- */
 export type SolanaPreparedData = {
   /** Public key of the created order account on Solana */
   orderPubkey: string;
@@ -101,13 +60,12 @@ export type SourceChainData = {
   deadline: number;
   /** Hash of execution details for cross-chain verification */
   executionDetailsHash: ExecutionDetailsHash;
+  stopLossMaxOut?: bigint;
+  takeProfitMinOut?: bigint;
+  extraTransfers?: ExtraTransfer[];
 };
 
-/**
- * Complete user intent request sent to the auctioneer service
- * Contains all the information needed to execute the cross-chain swap
- */
-export type UserIntentRequest = {
+export type CrossChainUserIntentRequest = {
   /** Generic data common to all chains */
   genericData: SourceChainData;
   /** JSON-stringified execution details for the destination chain */
@@ -123,21 +81,42 @@ export type UserIntentRequest = {
   };
 };
 
-/**
- * Union type of all chain-specific prepared data
- * The actual type depends on the source chain
- */
+export type SingleChainUserIntentRequest = {
+  genericData: SingleChainOrder;
+  chainSpecificData: {
+    EVM?: EvmPreparedData;
+    Solana?: SolanaPreparedData;
+    Sui?: SolanaPreparedData;
+  };
+};
+
 export type ChainPreparedData = EvmPreparedData | SuiPreparedData | SolanaPreparedData;
 
-/**
- * Fully prepared order ready for submission to the auctioneer
- * Contains both the order details and chain-specific prepared data
- */
-export type PreparedOrder = {
-  /** The original order with all cross-chain details */
-  order: Order;
-  /** Chain-specific data needed for order execution */
+export type CrossChainOrderPrepared = {
+  order: CrossChainOrder;
   preparedData: ChainPreparedData;
-  /** Hash related to the start order execution */
-  // txHash: string // TODO: Think if we need this
+};
+
+export type SingleChainEVMPreparedData = {
+  nonce: string;
+  signature: string | Hash;
+};
+
+export type SingleChainSolanaPreparedData = {
+  secretNumber: string;
+  orderPubkey: string;
+};
+
+export type SingleChainSuiPreparedData = {
+  transactionHash: string;
+};
+
+export type SingleChainPreparedData =
+  | SingleChainEVMPreparedData
+  | SingleChainSolanaPreparedData
+  | SingleChainSuiPreparedData;
+
+export type SingleChainOrderPrepared = {
+  order: SingleChainOrder;
+  preparedData: SingleChainPreparedData;
 };

package/src/utils/base-validator.ts

@@ -1,4 +1,5 @@
-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 { ValidationError } from '../errors/index.js';
 import type { IChainValidator } from './order-validator.js';
 
@@ -11,26 +12,43 @@ export abstract class BaseValidator implements IChainValidator {
   abstract isValidTokenAddress(tokenAddress: string): boolean;
   abstract isValidAmount(amount: bigint): boolean;
   protected abstract getChainName(): string;
-  abstract chainSpecificValidation(order: OrderInput): Promise<void>;
+  abstract validateCrossChainOrderFeasability(order: CreateCrossChainOrderParams & { user: string }): Promise<void>;
+  abstract validateSingleChainOrderFeasability(order: CreateSingleChainOrderParams & { user: string }): Promise<void>;
 
   /**
    * Validate source chain specific parameters of the order
    */
-  async validateSourceChain(order: OrderInput): Promise<void> {
-    this.validateAddress(order.user);
+  async validateSourceChain(order: CreateCrossChainOrderParams & { user: string }): Promise<void> {
     this.validateTokenAddress(order.sourceTokenAddress);
     this.validateAmount(order.sourceTokenAmount);
-    this.validateAmount(order.minStablecoinAmount);
-    await this.chainSpecificValidation(order);
+    this.validateAmount(order.minStablecoinAmount ?? 1n);
+    await this.validateCrossChainOrderFeasability({ ...order, user: order.user });
+  }
+
+  async validateSingleChainOrder(order: CreateSingleChainOrderParams & { user: string }): Promise<void> {
+    this.validateTokenAddress(order.tokenIn);
+    this.validateTokenAddress(order.tokenOut);
+    this.validateAmount(order.amountIn);
+    this.validateAmount(order.amountOutMin ?? 1n);
+
+    if (order.stopLossMaxOut) {
+      this.validateAmount(order.stopLossMaxOut);
+    }
+
+    if (order.takeProfitMinOut) {
+      this.validateAmount(order.takeProfitMinOut);
+    }
+
+    await this.validateSingleChainOrderFeasability(order);
   }
 
   /**
    * Validate destination chain specific parameters of the order
    */
-  validateDestinationChain(order: OrderInput): void {
+  validateDestinationChain(order: CreateCrossChainOrderParams): void {
     this.validateAddress(order.destinationAddress);
     this.validateTokenAddress(order.destinationTokenAddress);
-    this.validateAmount(order.destinationTokenMinAmount);
+    this.validateAmount(order.destinationTokenMinAmount ?? 1n);
 
     if (order.extraTransfers) {
       for (const extraTransfer of order.extraTransfers) {

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);