@shogun-sdk/intents-sdk 1.2.4 → 1.2.6-test

package/src/utils/quote/aggregator.ts

@@ -5,8 +5,13 @@ 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';
+import { RaydiumQuoteProvider, type RaydiumPumpQuoteParams, type RaydiumQuoteResponse } from './raydium.js';
+import { PumpFunQuoteProvider } from './pumpfun/index.js';
+
+const compareAddresses = (firstAddress?: string, secondAddress?: string): boolean => {
+  return !!firstAddress && !!secondAddress && firstAddress.toLowerCase() === secondAddress.toLowerCase();
+};
 
 type SingleChainQuoteParams = {
   chainId: ChainID;
@@ -14,13 +19,15 @@ 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' | 'pumpfun';
 
 export type Quote = {
   amountIn: bigint;
   amountOut: bigint;
+  amountOutMin?: bigint; // Optional, for quotes that provide a minimum guaranteed output
   amountOutUsd: number;
   amountInUsd: number;
   slippage: number;
@@ -29,6 +36,13 @@ export type Quote = {
   rawQuote: any;
 };
 
+export type SimpleQuote = {
+  amountIn: bigint;
+  amountOut: bigint;
+  amountOutMin?: bigint;
+  slippage: number;
+};
+
 export type IntentsQuoteParams = {
   sourceChainId: ChainID;
   destChainId: ChainID;
@@ -37,56 +51,85 @@ export type IntentsQuoteParams = {
   tokenOut: string;
 };
 
-export type QuoteResponse = {
-  amountInUsd: number;
-  estimatedAmountInAsMinStablecoinAmount: bigint;
+export type QuoteResponseInternal = {
+  amountInUsd: number
+  estimatedAmountInAsMinStablecoinAmount: bigint
 
-  estimatedAmountOut: bigint;
-  estimatedAmountOutUsd: number;
+  estimatedAmountOut: bigint
+  estimatedAmountOutUsd: number
 
-  estimatedAmountOutReduced: bigint;
-  estimatedAmountOutUsdReduced: number;
-};
+  estimatedAmountOutReduced: bigint
+  estimatedAmountOutUsdReduced: number
+}
 
-export class QuoteProvider {
-  private static readonly DEFAULT_BRIDGE_TOKEN = 'USDC';
-  private static readonly DEFAULT_BRIDGE_TOKEN_DECIMALS = 6;
+// Public response with metadata and derived fields
+export type QuoteResponse = QuoteResponseInternal & {
 
-  public static async getQuoteFromDefillama(params: IntentsQuoteParams): 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,
+  /** Metadata for source token */
+  tokenIn: {
+    address: string
+    chainId: ChainID
+  }
 
-      estimatedAmountInAsMinStablecoinAmount: defillamaQuote.minStablecoinsAmount,
-      estimatedAmountOut: defillamaQuote.amountOut,
-      estimatedAmountOutReduced: defillamaQuote.amountOut,
-    };
+  /** Metadata for destination token */
+  tokenOut: {
+    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 getQuoteWithDefillamaFallback(params: IntentsQuoteParams): Promise<QuoteResponse> {
+  public static async getQuote(params: IntentsQuoteParams): Promise<QuoteResponse> {
     try {
       const quote = await this.getQuoteFromRouters(params);
-      return quote;
+      // Adapt QuoteResponseInternal to QuoteResponse by adding tokenIn and tokenOut metadata fields
+      return {
+        ...quote,
+        tokenIn: {
+          address: params.tokenIn,
+          chainId: params.sourceChainId
+        },
+        tokenOut: {
+          address: params.tokenOut,
+          chainId: params.destChainId
+        }
+      };
     } catch (e) {
-      const quote = await this.getQuoteFromDefillama(params);
-      return quote;
+      console.error('Error getting quote from routers:', e);
+      throw new Error('Failed to get quote from routers');
     }
   }
 
-  public static async getQuote(params: IntentsQuoteParams): Promise<QuoteResponse> {
-    return this.getQuoteWithDefillamaFallback(params);
+  /**
+   * 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' | 'pumpfun';
+  }): 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> {
+  private static async getQuoteFromRouters(params: IntentsQuoteParams): Promise<QuoteResponseInternal> {
     const bridgeTokenSymbol = QuoteProvider.DEFAULT_BRIDGE_TOKEN;
 
     const sourceBridgeToken = CROSS_CHAIN_TOKENS[bridgeTokenSymbol]?.[params.sourceChainId] || '';
@@ -110,15 +153,14 @@ export class QuoteProvider {
 
     const destQuote = await this.getSingleChainQuote(destSingleChainQuoteParams);
 
-    // Use weighted reduction instead of fixed percentage
-    const weightedReductionFactor = this.calculateWeightedReductionFactorForUsd(destQuote.amountOutUsd);
+    // // Use weighted reduction instead of fixed percentage
+    // const weightedReductionFactor = this.calculateWeightedReductionFactorForUsd(destQuote.amountOutUsd);
+    // const weightedReductionFactor = 0.999;
 
-    const estimatedAmountOutReduced = BigInt(Math.floor(Number(destQuote.amountOut) * weightedReductionFactor));
-    const estimatedAmountOutUsdReduced = destQuote.amountOutUsd * weightedReductionFactor;
+    const estimatedAmountOutUsdReduced = destQuote.amountOutUsd;
 
-    const reducedAmountInUsd = this.calculateWeightedReductionFactorForUsd(sourceQuote.amountInUsd);
     const estimatedAmountInAsMinStablecoinAmount = BigInt(
-      Math.floor(reducedAmountInUsd * 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS),
+      Math.floor(sourceQuote.amountInUsd * 10 ** this.DEFAULT_BRIDGE_TOKEN_DECIMALS),
     );
 
     return {
@@ -126,16 +168,16 @@ export class QuoteProvider {
       estimatedAmountOutUsd: destQuote.amountOutUsd,
       amountInUsd: sourceQuote.amountInUsd,
       estimatedAmountInAsMinStablecoinAmount,
-      estimatedAmountOutReduced,
+      estimatedAmountOutReduced: destQuote.amountOutMin || destQuote.amountOut,
       estimatedAmountOutUsdReduced,
     };
   }
 
   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 +188,7 @@ export class QuoteProvider {
         amountInUsd: amountUsd,
         slippage: 0,
         priceImpact: 0,
-        provider: getProviderNameByChainId(params.chainId),
+        provider: params.provider || getProviderNameByChainId(params.chainId),
         rawQuote: null,
       };
     }
@@ -157,8 +199,38 @@ 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 raydiumQuote;
+      } else if (params.provider === 'pumpfun') {
+        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;
+        } 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;
+          } catch {
+            const pumpfunQuote = await QuoteProvider.getPumpFunQuote(params);
+            return pumpfunQuote;
+          }
+        }
+      }
     }
 
     if (params.chainId === ChainID.Sui) {
@@ -223,7 +295,7 @@ export class QuoteProvider {
       tokenIn: params.tokenIn,
       tokenOut: params.tokenOut,
       swapMode: 'ExactIn',
-      slippageBps: params.slippageBps,
+      slippageBps: params.slippageBps ? params.slippageBps : 20, // Default 0.2% slippage
     });
   }
 
@@ -248,6 +320,36 @@ export class QuoteProvider {
     });
   }
 
+  //TODO: For Raydium and Pump we are applying slippage twice if there are 2 swaps (e.g., USDC -> SOL -> Token), should we just apply half and half on each swap?
+
+  protected static async getRaydiumQuote(params: SingleChainQuoteParams): Promise<Quote> {
+    const raydiumQuoter = new RaydiumQuoteProvider();
+    let request: RaydiumPumpQuoteParams = {
+      inputMint: params.tokenIn,
+      outputMint: params.tokenOut,
+      amount: params.amount.toString(),
+      slippageBps: params.slippageBps || 20, // Default 0.2% slippage
+    };
+    try {
+      return this.transformRaydiumQuote(await raydiumQuoter.getQuote(request));
+    } catch (e) {
+      console.log('Raydium AMM quote cannot find a route, trying with prebonded raydium');
+      return simpleQuoteToQuote(await raydiumQuoter.getQuotePrebonded(request), 'raydium');
+    }
+  }
+
+  protected static async getPumpFunQuote(params: SingleChainQuoteParams): Promise<Quote> {
+    const pumpfunQuoter = new PumpFunQuoteProvider();
+
+    let request: RaydiumPumpQuoteParams = {
+      inputMint: params.tokenIn,
+      outputMint: params.tokenOut,
+      amount: params.amount.toString(),
+      slippageBps: params.slippageBps || 20, // Default 0.2% slippage
+    };
+    return simpleQuoteToQuote(await pumpfunQuoter.getQuote(request), 'pumpfun');
+  }
+
   private static transformAftermathQuote({
     quote,
     request,
@@ -257,11 +359,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;
     }
 
@@ -290,23 +392,26 @@ export class QuoteProvider {
     };
   }
 
-  private static transformJupiterQuote({ quote }: { quote: JupiterQuoteResponse }): Quote {
+  public static transformJupiterQuote({ quote }: { quote: JupiterQuoteResponse }): Quote {
     const amountIn = Number(quote.inAmount);
     const amountOut = Number(quote.outAmount);
+    const amountOutMin = Number(quote.otherAmountThreshold);
+
     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;
     }
 
     return {
       amountIn: BigInt(amountIn),
       amountOut: BigInt(amountOut),
+      amountOutMin: BigInt(amountOutMin),
       amountOutUsd: amountUsd,
       amountInUsd: amountUsd,
       slippage: quote.slippageBps ? quote.slippageBps / 100 : 0,
@@ -315,6 +420,33 @@ export class QuoteProvider {
       rawQuote: quote,
     };
   }
+
+  private static transformRaydiumQuote(raydiumQuote: RaydiumQuoteResponse): Quote {
+    const amountIn = BigInt(raydiumQuote.data.inAmount);
+    const amountOut = BigInt(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 = 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;
+    }
+
+    return {
+      amountIn,
+      amountOut,
+      amountOutUsd: amountUsd,
+      amountInUsd: amountUsd,
+      slippage: raydiumQuote.data.slippageBps / 100,
+      priceImpact,
+      provider: 'raydium',
+      rawQuote: raydiumQuote,
+    };
+  }
 }
 
 function getProviderNameByChainId(chainId: ChainID): RouteProvider {
@@ -322,10 +454,33 @@ function getProviderNameByChainId(chainId: ChainID): RouteProvider {
     case ChainID.Sui:
       return 'aftermath';
     case ChainID.Solana:
-      return 'jupiter';
+      return 'jupiter'; // Primary provider, with Raydium and Pumpfun as fallbacks
     case ChainID.Hyperliquid:
       return 'liquidswap';
     default:
       return 'paraswap';
   }
 }
+
+export function quoteToSimpleQuote(quote: Quote): SimpleQuote {
+  return {
+    amountIn: quote.amountIn,
+    amountOut: quote.amountOut,
+    amountOutMin: quote.amountOutMin,
+    slippage: quote.slippage,
+  };
+}
+
+export function simpleQuoteToQuote(simpleQuote: SimpleQuote, provider: RouteProvider): Quote {
+  return {
+    amountIn: simpleQuote.amountIn,
+    amountOut: simpleQuote.amountOut,
+    amountOutMin: simpleQuote.amountOutMin,
+    slippage: simpleQuote.slippage,
+    amountInUsd: 0,
+    amountOutUsd: 0,
+    priceImpact: 0,
+    provider,
+    rawQuote: simpleQuote,
+  };
+}

package/src/utils/quote/paraswap.ts

@@ -10,6 +10,7 @@ const rpcProvidersUrl: Record<SupportedEvmChain, string> = {
   [ChainID.Optimism]: 'https://optimism-rpc.publicnode.com',
   [ChainID.Base]: 'https://base-rpc.publicnode.com',
   [ChainID.Hyperliquid]: 'https://rpc.hyperliquid.xyz/evm',
+  [ChainID.BSC]: 'https://bsc-dataseed.ninicoin.io',
 };
 
 export type ParaswapQuoteRequestParams = {

package/src/utils/quote/pumpfun/estimations.ts

@@ -0,0 +1,206 @@
+import type { BondingCurve, GlobalAccount } from './models.js';
+
+export const BPS_DEN = 10000n;
+
+export enum PreBondedTradeType {
+  BuyExactIn = 'BuyExactIn',
+  BuyExactOut = 'BuyExactOut',
+  SellExactIn = 'SellExactIn',
+  SellExactOut = 'SellExactOut',
+}
+
+class PreBondingError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'PreBondingError';
+  }
+}
+
+/**
+ * Calculate output amount for constant product AMM: (amount_in * y_out) / (x_in + amount_in)
+ */
+function cpAmountOut(amountIn: bigint, xIn: bigint, yOut: bigint): bigint {
+  if (xIn === 0n || yOut === 0n) {
+    throw new PreBondingError('Zero value for reserve');
+  }
+
+  const num = amountIn * yOut;
+  const den = xIn + amountIn;
+
+  return num / den;
+}
+
+/**
+ * Buy exact SOL in, get tokens out.
+ * Fee is deducted from SOL before the swap calculation.
+ */
+export function buyExactIn(curve: BondingCurve, solIn: bigint, feeBps: bigint): bigint {
+  if (curve.complete) {
+    throw new PreBondingError(`Pool not in fundraising state: ${JSON.stringify(curve)}`);
+  }
+  if (solIn === 0n) {
+    return 0n;
+  }
+
+  const vSol = curve.virtualSolReserves;
+  const vTok = curve.virtualTokenReserves;
+
+  // Deduct protocol + creator fee from input SOL
+  const fee = (solIn * feeBps) / BPS_DEN;
+  const effectiveSolIn = solIn - fee;
+
+  let out = cpAmountOut(effectiveSolIn, vSol, vTok);
+
+  // Observed rounding in buy path (+1)
+  out = out + 1n;
+
+  // Cap by real tokens available
+  return out < curve.realTokenReserves ? out : curve.realTokenReserves;
+}
+
+/**
+ * Sell exact tokens in, get SOL out.
+ * Fee is deducted from SOL output.
+ */
+export function sellExactIn(curve: BondingCurve, tokensIn: bigint, feeBps: bigint): bigint {
+  if (curve.complete) {
+    throw new PreBondingError(`Pool not in fundraising state: ${JSON.stringify(curve)}`);
+  }
+  if (tokensIn === 0n) {
+    return 0n;
+  }
+
+  const vTok = curve.virtualTokenReserves;
+  const vSol = curve.virtualSolReserves;
+
+  const gross = cpAmountOut(tokensIn, vTok, vSol);
+
+  // Deduct protocol + creator fee from output SOL
+  const fee = (gross * feeBps) / BPS_DEN;
+  let net = gross - fee;
+
+  // Cap by real SOL available
+  net = net < curve.realSolReserves ? net : curve.realSolReserves;
+
+  return net;
+}
+
+/**
+ * Buy exact tokens out, calculate required SOL in.
+ * This calculates the EXACT amount needed, but doesn't account for slippage buffer.
+ */
+export function buyExactOut(curve: BondingCurve, tokensOut: bigint, feeBps: bigint): bigint {
+  if (curve.complete) {
+    throw new PreBondingError(`Pool not in fundraising state: ${JSON.stringify(curve)}`);
+  }
+  if (tokensOut === 0n) {
+    return 0n;
+  }
+  if (tokensOut > curve.realTokenReserves) {
+    throw new PreBondingError('Insufficient liquidity: real_token cap');
+  }
+
+  const vSol = curve.virtualSolReserves;
+  const vTok = curve.virtualTokenReserves;
+
+  if (tokensOut >= vTok) {
+    throw new PreBondingError('Insufficient liquidity: tokens_out >= v_tok');
+  }
+
+  // Calculate effective SOL needed before fees: ceil((vSol * tokensOut) / (vTok - tokensOut))
+  const num = vSol * tokensOut;
+  const den = vTok - tokensOut;
+  const effIn = (num + den - 1n) / den; // ceiling division
+
+  const feeNum = BPS_DEN - feeBps;
+  if (feeNum === 0n) {
+    throw new PreBondingError('Invalid fee configuration');
+  }
+
+  // Calculate gross SOL including fees: ceil((effIn * BPS_DEN) / feeNum)
+  const grossIn = (effIn * BPS_DEN + feeNum - 1n) / feeNum;
+
+  return grossIn;
+}
+
+/**
+ * Sell exact SOL out, calculate required tokens in.
+ * This calculates the EXACT amount needed, but doesn't account for slippage buffer.
+ */
+export function sellExactOut(curve: BondingCurve, solOut: bigint, feeBps: bigint): bigint {
+  if (curve.complete) {
+    throw new PreBondingError(`Pool not in fundraising state: ${JSON.stringify(curve)}`);
+  }
+  if (solOut === 0n) {
+    return 0n;
+  }
+  if (solOut > curve.realSolReserves) {
+    throw new PreBondingError('Insufficient liquidity: real_sol cap');
+  }
+
+  const vTok = curve.virtualTokenReserves;
+  const vSol = curve.virtualSolReserves;
+
+  // fee_num = BPS_DEN - fee_bps
+  const feeNum = BPS_DEN - feeBps;
+  if (feeNum === 0n) {
+    throw new PreBondingError('Invalid fee configuration');
+  }
+
+  // Upper bound via continuous formula: gross = ceil((solOut * BPS_DEN) / feeNum)
+  const gross = (solOut * BPS_DEN + feeNum - 1n) / feeNum; // ceil
+  if (gross >= vSol) {
+    throw new PreBondingError('Insufficient liquidity: gross >= v_sol');
+  }
+
+  // hi = ceil((vTok * gross) / (vSol - gross))
+  const num = vTok * gross;
+  const den = vSol - gross;
+  let hi = (num + den - 1n) / den; // ceil
+  if (hi === 0n) {
+    hi = 1n;
+  }
+
+  // Monotonic binary search on sellExactIn using forward path (with real floors)
+  let lo = 0n;
+  let ans = hi;
+  while (lo <= hi) {
+    const mid = lo + (hi - lo) / 2n;
+    const got = sellExactIn(curve, mid, feeBps);
+    if (got >= solOut) {
+      ans = mid;
+      if (mid === 0n) break;
+      hi = mid - 1n;
+    } else {
+      lo = mid + 1n;
+    }
+  }
+
+  return ans;
+}
+
+export function estimatePumpFunPrebonded(
+  bondingCurve: BondingCurve,
+  globalAccount: GlobalAccount,
+  amount: bigint,
+  tradeType: PreBondedTradeType,
+): bigint {
+  if (bondingCurve.complete) {
+    throw new PreBondingError(`Pool not in fundraising state: ${JSON.stringify(bondingCurve)}`);
+  }
+
+  const totalFeeBps = globalAccount.feeBasisPoints + globalAccount.creatorFeeBasisPoints;
+
+  switch (tradeType) {
+    case PreBondedTradeType.BuyExactIn:
+      return buyExactIn(bondingCurve, amount, totalFeeBps);
+    case PreBondedTradeType.BuyExactOut:
+      return buyExactOut(bondingCurve, amount, totalFeeBps);
+    case PreBondedTradeType.SellExactIn:
+      return sellExactIn(bondingCurve, amount, totalFeeBps);
+    case PreBondedTradeType.SellExactOut:
+      return sellExactOut(bondingCurve, amount, totalFeeBps);
+    default:
+      throw new PreBondingError(`Invalid trade type: ${tradeType}`);
+  }
+}