@shogun-sdk/intents-sdk 1.2.31 → 1.3.0

package/src/utils/quote/aggregator.ts

@@ -7,6 +7,11 @@ 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 RaydiumQuoteResponse } from './raydium.js';
+
+const compareAddresses = (firstAddress?: string, secondAddress?: string): boolean => {
+  return !!firstAddress && !!secondAddress && firstAddress.toLowerCase() === secondAddress.toLowerCase();
+};
 
 type SingleChainQuoteParams = {
   chainId: ChainID;
@@ -14,9 +19,10 @@ 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';
 
 export type Quote = {
   amountIn: bigint;
@@ -29,7 +35,7 @@ export type Quote = {
   rawQuote: any;
 };
 
-export type QuoteParams = {
+export type IntentsQuoteParams = {
   sourceChainId: ChainID;
   destChainId: ChainID;
   amount: bigint;
@@ -52,7 +58,7 @@ 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> {
+  public static async getQuoteFromDefillama(params: IntentsQuoteParams): Promise<QuoteResponse> {
     const defillamaQuote = await calculateAmounts({
       amountIn: params.amount,
       tokenIn: params.tokenIn,
@@ -72,7 +78,7 @@ export class QuoteProvider {
     };
   }
 
-  public static async getQuoteWithDefillamaFallback(params: QuoteParams): Promise<QuoteResponse> {
+  public static async getQuoteWithDefillamaFallback(params: IntentsQuoteParams): Promise<QuoteResponse> {
     try {
       const quote = await this.getQuoteFromRouters(params);
       return quote;
@@ -82,11 +88,35 @@ export class QuoteProvider {
     }
   }
 
-  public static async getQuote(params: QuoteParams): Promise<QuoteResponse> {
+  public static async getQuote(params: IntentsQuoteParams): Promise<QuoteResponse> {
     return this.getQuoteWithDefillamaFallback(params);
   }
 
-  private static async getQuoteFromRouters(params: QuoteParams): Promise<QuoteResponse> {
+  /**
+   * 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';
+  }): Promise<Quote> {
+    const singleChainParams: SingleChainQuoteParams = {
+      chainId: ChainID.Solana,
+      amount: params.amount,
+      tokenIn: params.tokenIn,
+      tokenOut: params.tokenOut,
+      slippageBps: params.slippageBps,
+      provider: params.provider,
+    };
+
+    return this.getSingleChainQuote(singleChainParams);
+  }
+
+  private static async getQuoteFromRouters(params: IntentsQuoteParams): Promise<QuoteResponse> {
     const bridgeTokenSymbol = QuoteProvider.DEFAULT_BRIDGE_TOKEN;
 
     const sourceBridgeToken = CROSS_CHAIN_TOKENS[bridgeTokenSymbol]?.[params.sourceChainId] || '';
@@ -132,10 +162,10 @@ export class QuoteProvider {
   }
 
   public static async getSingleChainQuote(params: SingleChainQuoteParams): Promise<Quote> {
-    if (params.tokenIn.toLowerCase() === params.tokenOut.toLowerCase()) {
+    if (compareAddresses(params.tokenIn, params.tokenOut)) {
       let amountUsd = 0;
 
-      if (params.tokenIn.toLowerCase() === CROSS_CHAIN_TOKENS.USDC![params.chainId].toLowerCase()) {
+      if (compareAddresses(params.tokenIn, CROSS_CHAIN_TOKENS.USDC![params.chainId])) {
         amountUsd = Number(params.amount) / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
       }
 
@@ -146,7 +176,7 @@ export class QuoteProvider {
         amountInUsd: amountUsd,
         slippage: 0,
         priceImpact: 0,
-        provider: getProviderNameByChainId(params.chainId),
+        provider: params.provider || getProviderNameByChainId(params.chainId),
         rawQuote: null,
       };
     }
@@ -157,8 +187,30 @@ export class QuoteProvider {
     }
 
     if (params.chainId === ChainID.Solana) {
-      const jupiterQuote = await QuoteProvider.getJupiterQuote(params);
-      return QuoteProvider.transformJupiterQuote(jupiterQuote);
+      // Check if provider is explicitly specified
+      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 QuoteProvider.transformRaydiumQuote(raydiumQuote);
+      } else {
+        // Default: Try Jupiter first, fallback to Raydium if it fails
+        try {
+          const jupiterQuote = await QuoteProvider.getJupiterQuote(params);
+          if(!jupiterQuote.quote) {
+            throw new Error('Jupiter quote failed');
+          }
+
+          const transformedQuote = QuoteProvider.transformJupiterQuote(jupiterQuote);
+          return transformedQuote;
+        } catch (error) {
+          console.warn('Jupiter quote failed, falling back to Raydium:', error);
+          const raydiumQuote = await QuoteProvider.getRaydiumQuote(params);
+          const transformedQuote = QuoteProvider.transformRaydiumQuote(raydiumQuote);
+          return transformedQuote;
+        }
+      }
     }
 
     if (params.chainId === ChainID.Sui) {
@@ -248,6 +300,17 @@ export class QuoteProvider {
     });
   }
 
+  protected static async getRaydiumQuote(params: SingleChainQuoteParams) {
+    const raydiumQuoter = new RaydiumQuoteProvider();
+
+    return raydiumQuoter.getQuote({
+      inputMint: params.tokenIn,
+      outputMint: params.tokenOut,
+      amount: params.amount.toString(),
+      slippageBps: params.slippageBps || 50, // Default 0.5% slippage
+    });
+  }
+
   private static transformAftermathQuote({
     quote,
     request,
@@ -257,11 +320,11 @@ export class QuoteProvider {
   }): Quote {
     let amountUsd = 0;
 
-    if (request.tokenIn === CROSS_CHAIN_TOKENS.USDC![request.chainId]) {
+    if (compareAddresses(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]) {
+    if (compareAddresses(request.tokenOut, CROSS_CHAIN_TOKENS.USDC![request.chainId])) {
       amountUsd = Number(quote.coinOut.amount) / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
     }
 
@@ -293,14 +356,15 @@ export class QuoteProvider {
   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]) {
+    if (compareAddresses(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]) {
+    if (compareAddresses(quote.inputMint, CROSS_CHAIN_TOKENS.USDC![ChainID.Solana])) {
       amountUsd = amountIn / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
     }
 
@@ -315,6 +379,32 @@ export class QuoteProvider {
       rawQuote: quote,
     };
   }
+
+  private static transformRaydiumQuote(raydiumQuote: RaydiumQuoteResponse): Quote {
+    const amountIn = Number(raydiumQuote.data.inAmount);
+    const amountOut = Number(raydiumQuote.data.outAmount);
+    let amountUsd = 0;
+    const priceImpact = Number(raydiumQuote.data.priceImpactPct) * 100;
+
+    if (compareAddresses(raydiumQuote.data.outputMint, CROSS_CHAIN_TOKENS.USDC![ChainID.Solana])) {
+      amountUsd = amountOut / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
+    }
+
+    if (compareAddresses(raydiumQuote.data.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: raydiumQuote.data.slippageBps / 100,
+      priceImpact,
+      provider: 'raydium',
+      rawQuote: raydiumQuote,
+    };
+  }
 }
 
 function getProviderNameByChainId(chainId: ChainID): RouteProvider {
@@ -322,7 +412,7 @@ function getProviderNameByChainId(chainId: ChainID): RouteProvider {
     case ChainID.Sui:
       return 'aftermath';
     case ChainID.Solana:
-      return 'jupiter';
+      return 'jupiter'; // Primary provider, with Raydium as fallback
     case ChainID.Hyperliquid:
       return 'liquidswap';
     default:

package/src/utils/quote/raydium.ts

@@ -0,0 +1,165 @@
+import { NATIVE_SOLANA_TOKEN_ADDRESS, WRAPPED_SOL_MINT_ADDRESS } from '../../constants.js';
+import { API_URLS } from '@raydium-io/raydium-sdk-v2';
+
+// Local implementation of compareAddresses function
+const compareAddresses = (firstAddress?: string, secondAddress?: string): boolean => {
+  return !!firstAddress && !!secondAddress && firstAddress.toLowerCase() === secondAddress.toLowerCase();
+};
+
+type RaydiumQuoteParams = {
+  inputMint: string;
+  outputMint: string;
+  amount: string;
+  slippageBps: number;
+};
+
+export type RaydiumQuoteResponse = {
+  success: boolean;
+  data: {
+    inputMint: string;
+    outputMint: string;
+    inAmount: string;
+    outAmount: string;
+    otherAmountThreshold: string;
+    swapMode: string;
+    slippageBps: number;
+    platformFee: null;
+    priceImpactPct: string;
+    routePlan: Array<{
+      swapInfo: {
+        ammKey: string;
+        label: string;
+        inputMint: string;
+        outputMint: string;
+        notEnoughLiquidity: boolean;
+        minInAmount: string;
+        minOutAmount: string;
+        priceImpactPct: string;
+        lpFee: {
+          amount: string;
+          mint: string;
+          pct: number;
+        };
+        platformFee: {
+          amount: string;
+          mint: string;
+          pct: number;
+        };
+      };
+      percent: number;
+    }>;
+  };
+};
+
+// Using API_URLS from Raydium SDK v2
+
+export class RaydiumQuoteProvider {
+  /**
+   * Get priority fee recommendations from Raydium API
+   * @returns Priority fee data with different tiers (vh, h, m)
+   */
+  public async getPriorityFee(): Promise<{
+    vh: number; // very high
+    h: number;  // high
+    m: number;  // medium
+  }> {
+    const url = new URL(API_URLS.PRIORITY_FEE, API_URLS.BASE_HOST);
+    const response = await fetch(url);
+    
+    if (!response.ok) {
+      throw new Error(`Failed to fetch priority fee from Raydium API: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    
+    if (!data.success) {
+      throw new Error('Raydium API returned unsuccessful response for priority fee');
+    }
+
+    return data.data.default;
+  }
+
+  public async getQuote(raydiumParams: RaydiumQuoteParams): Promise<RaydiumQuoteResponse> {
+    const params = { ...raydiumParams };
+
+    // Handle native SOL token mapping for Solana
+    if (compareAddresses(params.inputMint, NATIVE_SOLANA_TOKEN_ADDRESS)) {
+      params.inputMint = WRAPPED_SOL_MINT_ADDRESS;
+    }
+
+    if (compareAddresses(params.outputMint, NATIVE_SOLANA_TOKEN_ADDRESS)) {
+      params.outputMint = WRAPPED_SOL_MINT_ADDRESS;
+    }
+
+    const url = new URL('/compute/swap-base-in', API_URLS.SWAP_HOST);
+    url.searchParams.set('inputMint', params.inputMint);
+    url.searchParams.set('outputMint', params.outputMint);
+    url.searchParams.set('amount', params.amount);
+    url.searchParams.set('slippageBps', params.slippageBps.toString());
+    
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch quote from Raydium API: ${response.status} ${response.statusText}`);
+    }
+
+    const data: RaydiumQuoteResponse = await response.json();
+
+    if (!data.success) {
+      throw new Error('Raydium API returned unsuccessful response');
+    }
+
+    return data;
+  }
+
+  /**
+   * Get transaction data for executing a swap
+   * @param params - Transaction parameters
+   * @returns Serialized transaction data
+   */
+  public async getSwapTransaction(params: {
+    swapResponse: RaydiumQuoteResponse;
+    wallet: string;
+    txVersion: 'V0' | 'LEGACY';
+    wrapSol?: boolean;
+    unwrapSol?: boolean;
+    inputAccount?: string;
+    outputAccount?: string;
+    computeUnitPriceMicroLamports?: string;
+  }): Promise<{
+    id: string;
+    version: string;
+    success: boolean;
+    data: { transaction: string }[];
+  }> {
+    const url = new URL('/transaction/swap-base-in', API_URLS.SWAP_HOST);
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        computeUnitPriceMicroLamports: params.computeUnitPriceMicroLamports || '0',
+        swapResponse: params.swapResponse,
+        txVersion: params.txVersion,
+        wallet: params.wallet,
+        wrapSol: params.wrapSol || false,
+        unwrapSol: params.unwrapSol || false,
+        inputAccount: params.inputAccount,
+        outputAccount: params.outputAccount,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to get swap transaction from Raydium API: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    
+    if (!data.success) {
+      throw new Error('Raydium API returned unsuccessful response for swap transaction');
+    }
+
+    return data;
+  }
+}

package/src/utils/tokens/index.ts

@@ -0,0 +1,38 @@
+import { TOKEN_SEARCH_API_BASE_URL } from '../../constants.js';
+import type { TokenSearchParams, TokenSearchResponse } from '../../types/token-list.js';
+
+/**
+ * getTokenList
+ *
+ * High-level SDK function for token discovery.
+ * Supports cancellation via AbortController.
+ *
+ * Example:
+ * ```ts
+ * import { getTokenList } from "@shogun/sdk";
+ *
+ * const controller = new AbortController();
+ * const res = await getTokenList({ q: "usdc", networkId: 8453, signal: controller.signal });
+ *
+ * To cancel:
+ * controller.abort();
+ * ```
+ */
+export async function getTokenList(params: TokenSearchParams): Promise<TokenSearchResponse> {
+  const url = new URL(`${TOKEN_SEARCH_API_BASE_URL}/tokens/search`);
+
+  if (params.q) url.searchParams.append('q', params.q);
+  if (params.networkId) url.searchParams.append('networkId', String(params.networkId));
+  if (params.page) url.searchParams.append('page', String(params.page));
+  if (params.limit) url.searchParams.append('limit', String(params.limit));
+
+  const res = await fetch(url.toString(), {
+    signal: params.signal,
+  });
+
+  if (!res.ok) {
+    throw new Error(`Failed to fetch tokens: ${res.status} ${res.statusText}`);
+  }
+
+  return (await res.json()) as TokenSearchResponse;
+}

package/dist/esm/core/solana/cross-chain-limit-order.js

@@ -1,18 +0,0 @@
-import { createHash } from "crypto";
-/**
- * Generate execution details hash for cross-chain orders
- * @param destChainId Destination chain ID
- * @param destinationAddress Destination address on target chain
- * @param tokenOut Token address on destination chain
- * @param amountOutMin Minimum amount out
- */
-export function generateExecutionDetailsHash(destChainId, destinationAddress, tokenOut, amountOutMin) {
-    const executionDetails = JSON.stringify({
-        destChainId,
-        destinationAddress,
-        tokenOut,
-        amountOutMin,
-    });
-    return new Uint8Array(createHash('sha256').update(executionDetails).digest());
-}
-//# sourceMappingURL=cross-chain-limit-order.js.map

package/dist/esm/core/solana/cross-chain-limit-order.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cross-chain-limit-order.js","sourceRoot":"","sources":["../../../../src/core/solana/cross-chain-limit-order.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpC;;;;;;GAMG;AACH,MAAM,UAAU,4BAA4B,CAC1C,WAAmB,EACnB,kBAA0B,EAC1B,QAAgB,EAChB,YAAoB;IAEpB,MAAM,gBAAgB,GAAG,IAAI,CAAC,SAAS,CAAC;QACtC,WAAW;QACX,kBAAkB;QAClB,QAAQ;QACR,YAAY;KACb,CAAC,CAAC;IAEH,OAAO,IAAI,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;AAChF,CAAC"}

package/dist/types/core/solana/cross-chain-limit-order.d.ts

@@ -1,9 +0,0 @@
-/**
- * Generate execution details hash for cross-chain orders
- * @param destChainId Destination chain ID
- * @param destinationAddress Destination address on target chain
- * @param tokenOut Token address on destination chain
- * @param amountOutMin Minimum amount out
- */
-export declare function generateExecutionDetailsHash(destChainId: number, destinationAddress: string, tokenOut: string, amountOutMin: string): Uint8Array;
-//# sourceMappingURL=cross-chain-limit-order.d.ts.map

package/dist/types/core/solana/cross-chain-limit-order.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cross-chain-limit-order.d.ts","sourceRoot":"","sources":["../../../../src/core/solana/cross-chain-limit-order.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,MAAM,EAC1B,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,GACnB,UAAU,CASZ"}

package/src/core/solana/cross-chain-limit-order.ts

@@ -1,24 +0,0 @@
-import { createHash } from "crypto";
-
-/**
- * Generate execution details hash for cross-chain orders
- * @param destChainId Destination chain ID
- * @param destinationAddress Destination address on target chain
- * @param tokenOut Token address on destination chain
- * @param amountOutMin Minimum amount out
- */
-export function generateExecutionDetailsHash(
-  destChainId: number,
-  destinationAddress: string,
-  tokenOut: string,
-  amountOutMin: string,
-): Uint8Array {
-  const executionDetails = JSON.stringify({
-    destChainId,
-    destinationAddress,
-    tokenOut,
-    amountOutMin,
-  });
-  
-  return new Uint8Array(createHash('sha256').update(executionDetails).digest());
-}