@shogun-sdk/intents-sdk 1.2.6-test → 1.2.6-test.2

package/src/utils/quote/aggregator.ts

@@ -2,7 +2,7 @@ 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 { LiquidSwapQuoteProvider, type LiquidSwapQuoteResponse } from './liquidswap.js';
@@ -52,38 +52,32 @@ export type IntentsQuoteParams = {
 };
 
 export type QuoteResponseInternal = {
-  amountInUsd: number
-  estimatedAmountInAsMinStablecoinAmount: bigint
+  amountInUsd: number;
+  estimatedAmountInAsMinStablecoinAmount: bigint;
 
-  estimatedAmountOut: bigint
-  estimatedAmountOutUsd: number
+  estimatedAmountOut: bigint;
+  estimatedAmountOutUsd: number;
 
-  estimatedAmountOutReduced: bigint
-  estimatedAmountOutUsdReduced: number
-}
+  estimatedAmountOutReduced: bigint;
+  estimatedAmountOutUsdReduced: number;
+};
 
 // Public response with metadata and derived fields
 export type QuoteResponse = QuoteResponseInternal & {
-
-
   /** Metadata for source token */
   tokenIn: {
-    address: string
-    chainId: ChainID
-  }
+    address: string;
+    chainId: ChainID;
+  };
 
   /** Metadata for destination token */
   tokenOut: {
-    address: string
-    chainId: ChainID
-  }
-}
-
+    address: string;
+    chainId: ChainID;
+  };
+};
 
 export class QuoteProvider {
-  private static readonly DEFAULT_BRIDGE_TOKEN = 'USDC';
-  private static readonly DEFAULT_BRIDGE_TOKEN_DECIMALS = 6;
-
   public static async getQuote(params: IntentsQuoteParams): Promise<QuoteResponse> {
     try {
       const quote = await this.getQuoteFromRouters(params);
@@ -92,12 +86,12 @@ export class QuoteProvider {
         ...quote,
         tokenIn: {
           address: params.tokenIn,
-          chainId: params.sourceChainId
+          chainId: params.sourceChainId,
         },
         tokenOut: {
           address: params.tokenOut,
-          chainId: params.destChainId
-        }
+          chainId: params.destChainId,
+        },
       };
     } catch (e) {
       console.error('Error getting quote from routers:', e);
@@ -130,37 +124,38 @@ export class QuoteProvider {
   }
 
   private static async getQuoteFromRouters(params: IntentsQuoteParams): Promise<QuoteResponseInternal> {
-    const bridgeTokenSymbol = QuoteProvider.DEFAULT_BRIDGE_TOKEN;
-
-    const sourceBridgeToken = CROSS_CHAIN_TOKENS[bridgeTokenSymbol]?.[params.sourceChainId] || '';
-    const destBridgeToken = CROSS_CHAIN_TOKENS[bridgeTokenSymbol]?.[params.destChainId] || '';
+    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);
 
+    // Step 2: Normalize stable amount between source and destination ---
+    // Adjust for decimal difference between stables (e.g. 6 → 18)
+    const normalizedBridgeAmount = BigInt(
+      Math.floor((Number(sourceQuote.amountOut) / 10 ** sourceStable.decimals) * 10 ** 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 weightedReductionFactor = 0.999;
-
-    const estimatedAmountOutUsdReduced = destQuote.amountOutUsd;
-
+    // -Step 4: Compute stable min-amount with correct decimals ---
     const estimatedAmountInAsMinStablecoinAmount = BigInt(
-      Math.floor(sourceQuote.amountInUsd * 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS),
+      Math.floor(sourceQuote.amountInUsd * 10 ** sourceStable.decimals),
     );
 
     return {
@@ -169,16 +164,23 @@ export class QuoteProvider {
       amountInUsd: sourceQuote.amountInUsd,
       estimatedAmountInAsMinStablecoinAmount,
       estimatedAmountOutReduced: destQuote.amountOutMin || destQuote.amountOut,
-      estimatedAmountOutUsdReduced,
+      estimatedAmountOutUsdReduced: destQuote.amountOutUsd,
     };
   }
 
   public static async getSingleChainQuote(params: SingleChainQuoteParams): Promise<Quote> {
+    // Handle same-token case (self-swap)
     if (compareAddresses(params.tokenIn, params.tokenOut)) {
       let amountUsd = 0;
 
-      if (compareAddresses(params.tokenIn, CROSS_CHAIN_TOKENS.USDC![params.chainId])) {
-        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 {
@@ -193,13 +195,14 @@ export class QuoteProvider {
       };
     }
 
+    //  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) {
-      // Check if provider is explicitly specified
       if (params.provider === 'jupiter') {
         const jupiterQuote = await QuoteProvider.getJupiterQuote(params);
         return QuoteProvider.transformJupiterQuote(jupiterQuote);
@@ -210,18 +213,12 @@ export class QuoteProvider {
         const pumpfunQuote = await QuoteProvider.getPumpFunQuote(params);
         return pumpfunQuote;
       } else {
-        // Default: Try Jupiter first, fallback to Raydium and Pump 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;
+          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 Raydium first, then Pumpfun
           try {
             const raydiumQuote = await QuoteProvider.getRaydiumQuote(params);
             return raydiumQuote;
@@ -233,11 +230,13 @@ export class QuoteProvider {
       }
     }
 
+    // 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)) {
       const paraswapQuote = await QuoteProvider.getParaswapQuote(params);
       return QuoteProvider.transformParaswapQuote(paraswapQuote);
@@ -248,8 +247,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,
@@ -283,7 +282,7 @@ export class QuoteProvider {
     return liquidSwapQuoter.getQuote({
       tokenIn: params.tokenIn,
       tokenOut: params.tokenOut,
-      amountIn: params.amount.toString(),
+      amountIn: params.amount,
     });
   }
 
@@ -357,14 +356,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 (compareAddresses(request.tokenIn, CROSS_CHAIN_TOKENS.USDC![request.chainId])) {
-      amountUsd = Number(quote.coinIn.amount) / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
-    }
+    let amountUsd = 0;
 
-    if (compareAddresses(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 {
@@ -397,15 +400,19 @@ export class QuoteProvider {
     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 (compareAddresses(quote.outputMint, CROSS_CHAIN_TOKENS.USDC![ChainID.Solana])) {
-      amountUsd = amountOut / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
-    }
-
-    if (compareAddresses(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 {
@@ -425,15 +432,19 @@ export class QuoteProvider {
     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;
 
-    if (compareAddresses(raydiumQuote.data.outputMint, CROSS_CHAIN_TOKENS.USDC![ChainID.Solana])) {
-      amountUsd = Number(amountOut) / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
-    }
-
-    if (compareAddresses(raydiumQuote.data.inputMint, CROSS_CHAIN_TOKENS.USDC![ChainID.Solana])) {
-      amountUsd = Number(amountIn) / 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS;
+    // 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 {
@@ -449,6 +460,16 @@ export class QuoteProvider {
   }
 }
 
+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:

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/stablecoins-tokens.ts

@@ -9,15 +9,37 @@ export type QuoteParams = {
   slippageBps?: number;
 };
 
-export const CROSS_CHAIN_TOKENS: Record<string, Record<ChainID, string>> = {
+export const CROSS_CHAIN_STABLES: Record<string, Partial<Record<ChainID, { address: string; decimals: number }>>> = {
   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
-    [ChainID.BSC]: '0x55d398326f99059ff775485246999027b3197955', 
+    [ChainID.Solana]: {
+      address: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+      decimals: 6,
+    },
+    [ChainID.Base]: {
+      address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+      decimals: 6,
+    },
+    [ChainID.Arbitrum]: {
+      address: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+      decimals: 6,
+    },
+    [ChainID.Optimism]: {
+      address: '0x7F5c764cBc14f9669B88837ca1490cCa17c31607',
+      decimals: 6,
+    },
+    [ChainID.Sui]: {
+      address: '0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC',
+      decimals: 6,
+    },
+  },
+  USDT: {
+    [ChainID.Hyperliquid]: {
+      address: '0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb',
+      decimals: 6,
+    },
+    [ChainID.BSC]: {
+      address: '0x55d398326f99059ff775485246999027b3197955',
+      decimals: 18,
+    },
   },
-  // Add more tokens as needed
 };

package/dist/esm/core/evm/permit2-signature-transfer.js

@@ -1,15 +0,0 @@
-let SignatureTransfer;
-// Only use createRequire in Node (never in browsers)
-if (typeof process !== "undefined" && process.versions?.node) {
-    const { createRequire } = await import("module");
-    const require = createRequire(import.meta.url);
-    const pkg = require("@uniswap/permit2-sdk");
-    SignatureTransfer = pkg.SignatureTransfer;
-}
-else {
-    // Fallback for Vite / Vue / browser builds
-    const pkg = await import("@uniswap/permit2-sdk");
-    SignatureTransfer = pkg.SignatureTransfer;
-}
-export { SignatureTransfer };
-//# sourceMappingURL=permit2-signature-transfer.js.map

package/dist/esm/core/evm/permit2-signature-transfer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"permit2-signature-transfer.js","sourceRoot":"","sources":["../../../../src/core/evm/permit2-signature-transfer.ts"],"names":[],"mappings":"AAAA,IAAI,iBAAsB,CAAA;AAE1B,qDAAqD;AACrD,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC;IAC7D,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAA;IAChD,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IAC9C,MAAM,GAAG,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAA;IAC3C,iBAAiB,GAAG,GAAG,CAAC,iBAAiB,CAAA;AAC3C,CAAC;KAAM,CAAC;IACN,2CAA2C;IAC3C,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,sBAAsB,CAAC,CAAA;IAChD,iBAAiB,GAAI,GAAW,CAAC,iBAAiB,CAAA;AACpD,CAAC;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/dist/types/core/evm/permit2-signature-transfer.d.ts

@@ -1,3 +0,0 @@
-declare let SignatureTransfer: any;
-export { SignatureTransfer };
-//# sourceMappingURL=permit2-signature-transfer.d.ts.map

package/dist/types/core/evm/permit2-signature-transfer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"permit2-signature-transfer.d.ts","sourceRoot":"","sources":["../../../../src/core/evm/permit2-signature-transfer.ts"],"names":[],"mappings":"AAAA,QAAA,IAAI,iBAAiB,EAAE,GAAG,CAAA;AAc1B,OAAO,EAAE,iBAAiB,EAAE,CAAA"}

package/src/core/evm/permit2-signature-transfer.ts

@@ -1,15 +0,0 @@
-let SignatureTransfer: any
-
-// Only use createRequire in Node (never in browsers)
-if (typeof process !== "undefined" && process.versions?.node) {
-  const { createRequire } = await import("module")
-  const require = createRequire(import.meta.url)
-  const pkg = require("@uniswap/permit2-sdk")
-  SignatureTransfer = pkg.SignatureTransfer
-} else {
-  // Fallback for Vite / Vue / browser builds
-  const pkg = await import("@uniswap/permit2-sdk")
-  SignatureTransfer = (pkg as any).SignatureTransfer
-}
-
-export { SignatureTransfer }