Price = f(Supply)

x * y = k (constant)

// Returns: how many tokens you get per 1 SOL
exchangeRate = virtualTokenReserves / virtualSolReserves

getPrice(pool: PumpfunPool): number {
  if (pool.reserve0 === 0n || pool.reserve1 === 0n) {
    return 0;
  }
  // reserve0 = virtualSolReserves, reserve1 = virtualTokenReserves
  // Returns tokens per SOL (exchange rate)
  return bigIntDiv(pool.reserve1, pool.reserve0);
}

tokenPriceInSOL = virtualSolReserves / virtualTokenReserves
// Or simply: 1 / exchangeRate

// Classic AMM swap formula
tokens_out = (sol_in * virtualTokenReserves) / (virtualSolReserves + sol_in)

sol_out = (tokens_in * virtualSolReserves) / (virtualTokenReserves + tokens_in)

// How many tokens have been sold vs total available
bondingPercentage = (initialVirtualTokenReserves - currentVirtualTokenReserves) * 100 
                    / initialRealTokenReserves

bondedCriteria = 86000000000n; // ~86 SOL in lamports

async isBonded(pool: PumpfunPool): Promise<boolean> {
  if (pool.bonded) return true;
  if (pool.reserve0 >= this.bondedCriteria) return true;
  return false;
}

priceImpact = sol_in / (virtualSolReserves + sol_in)

sqrtPrice = sqrt(price) * 2^64

getPrice(pool: MeteoraDBCPool): number {
  const sqrtPrice = pool.extra?.sqrtPriceX64 ?? 0n;
  if (sqrtPrice === 0n) return 0;
  
  // Convert from Q64.64 fixed point
  return getPriceFromSqrtX(sqrtPrice, 64);
}

// Where getPriceFromSqrtX does:
function getPriceFromSqrtX(sqrtPrice: bigint, resolution: number): number {
  const price = (sqrtPrice * sqrtPrice) / (1n << BigInt(resolution * 2));
  return Number(price) / (2 ** resolution);
}

type Curve = Array<{
  sqrtPrice: bigint;   // Price at this point
  liquidity: bigint;   // Liquidity available
}>;

calculateQuoteVirtualReserve(pool: MeteoraDBCPool): bigint {
  const curve = pool.extra.curve;
  const nextSqrtPrice = pool.extra.sqrtPriceX64;
  const sqrtStartPrice = pool.extra.sqrtPriceStart;
  
  let totalAmount = 0n;
  
  for (let i = 0; i < curve.length; i++) {
    const currentPoint = curve[i];
    const lowerSqrtPrice = i === 0 
      ? sqrtStartPrice 
      : curve[i - 1].sqrtPrice;
    
    if (nextSqrtPrice > lowerSqrtPrice) {
      const upperSqrtPrice = nextSqrtPrice < currentPoint.sqrtPrice 
        ? nextSqrtPrice 
        : currentPoint.sqrtPrice;
      
      // Calculate delta amount for this segment
      const maxAmountIn = getDeltaAmountQuoteUnsigned(
        lowerSqrtPrice,
        upperSqrtPrice,
        currentPoint.liquidity
      );
      
      totalAmount += maxAmountIn;
    }
  }
  
  return totalAmount;
}

getDeltaAmountQuoteUnsigned(
  lowerSqrtPrice: bigint,
  upperSqrtPrice: bigint,
  liquidity: bigint
): bigint {
  // Δquote = L * (√P_upper - √P_lower) / 2^128
  const deltaSqrtPrice = upperSqrtPrice - lowerSqrtPrice;
  const prod = liquidity * deltaSqrtPrice;
  return prod >> BigInt(RESOLUTION * 2); // RESOLUTION = 64
}

bondingPercentage = (quoteReserve / migrationQuoteThreshold) * 100

// Bonding happens when virtualSolReserves reaches ~86 SOL
// Since it starts at 30 SOL, you need ~56 SOL of real purchases
const INITIAL_VIRTUAL_SOL = 30_000_000_000n; // 30 SOL
const BONDED_CRITERIA = 86_000_000_000n;     // 86 SOL

// Current progress (using virtual reserves)
const currentVirtualSol = pool.reserve0;
const progress = Number(currentVirtualSol - INITIAL_VIRTUAL_SOL) * 100 
                 / Number(BONDED_CRITERIA - INITIAL_VIRTUAL_SOL);

// Real SOL needed to bond
const solNeeded = BONDED_CRITERIA - currentVirtualSol;

// Current progress
const quoteReserve = calculateQuoteVirtualReserve(pool);
const progress = (quoteReserve * 100n) / migrationQuoteThreshold;

// SOL needed to bond
const solNeeded = migrationQuoteThreshold - quoteReserve;

// Current exchange rate (tokens per SOL)
const currentRate = virtualTokenReserves / virtualSolReserves;

// After your buy
const newSolReserves = virtualSolReserves + X;
const tokensReceived = (X * virtualTokenReserves) / newSolReserves;

// Your effective rate (tokens per SOL)
const effectiveRate = tokensReceived / X;

// Price impact (how much worse your rate is vs spot)
const priceImpact = (currentRate - effectiveRate) / currentRate;
// Or equivalently: X / (virtualSolReserves + X)

// Expected tokens at current spot rate (no slippage)
const expectedTokens = (solIn * virtualTokenReserves) / virtualSolReserves;

// Actual tokens (accounting for price impact)
const actualTokens = (solIn * virtualTokenReserves) / (virtualSolReserves + solIn);

// Slippage percentage
const slippage = (expectedTokens - actualTokens) / expectedTokens * 100;
// This equals: solIn / (virtualSolReserves + solIn) * 100

// Get SOL price from oracle
const solPriceUSD = 150; // example: $150 per SOL

// Token price in SOL
const tokenPriceInSOL = virtualSolReserves / virtualTokenReserves;

// Token price in USD
const tokenPriceUSD = tokenPriceInSOL * solPriceUSD;

# Get token details for a Pumpfun token (Fartcoin)
curl -X GET "https://demo-api.mobula.io/api/2/token/details?blockchain=solana&address=9BB6NFEcjBCtnNLFko2FqVQBq8HHM13kCyYcdQbgpump" \
  -H "Authorization: YOUR_API_KEY"

# Get token details for Wojak
curl -X GET "https://demo-api.mobula.io/api/2/token/details?blockchain=solana&address=8J69rbLTzWWgUJziFY8jeu5tDwEPBwUz4pKBMr5rpump" \
  -H "Authorization: YOUR_API_KEY"