Meteora

Traditional AMM (Raydium):
Liquidity uniformly distributed across 0 - infinity price range
+----------------------------+
|                            |
|  Uniform distribution,     |
|  low efficiency            |
+----------------------------+
  $0        $100       $1000

Meteora DLMM:
Liquidity concentrated in effective price range
              +--+
              |  | <- Concentrated liquidity
              |  |
--------------+--+------------
  $0     $95 $100 $105   $1000
         +- effective range -+

Result: Same funds, 100+ times deeper liquidity

// Meteora divides prices into multiple Bins (price buckets)
Each Bin represents a price range:

Bin ID: ...  98    99    100   101   102  ...
Price:  ... $99.5 $100  $100.5 $101 $101.5 ...
       -----+-----+-----+-----+-----+-----
       Liquidity: 0   500  2000  1500  300   0

Current Price = Active Bin = Bin #100

Trading Logic:
- Buy -> Consumes current Bin, price moves up
- Sell -> Consumes current Bin, price moves down
- Bin depleted -> Price jumps to next Bin

// Fee calculation formula (simplified)
Base Fee = 0.01%  // During low volatility
Volatility Factor = Recent price volatility magnitude

Dynamic Fee = Base Fee x (1 + Volatility Factor)

Examples:
- Stable market (volatility < 0.1%): Fee 0.01%
- Normal market (volatility 0.5%): Fee 0.015%
- High volatility market (volatility 2%): Fee 0.03%

Advantages:
- Higher fees during high volatility compensate LP impermanent loss
- Lower fees during low volatility attract trading volume
- Automatically balances LP returns and trader costs

import { Meteora } from '@meteora-ag/meteora-sdk'
import { Connection, PublicKey } from '@solana/web3.js'

const connection = new Connection('https://api.mainnet-beta.solana.com')
const meteora = new Meteora({ connection })

// Select liquidity pool (SOL/USDC DLMM)
const poolAddress = new PublicKey('Meteora_Pool_Address')
const pool = await meteora.getPool(poolAddress)

console.log('Pool Info:')
console.log('Current Price:', pool.currentPrice)
console.log('Total Liquidity:', pool.totalLiquidity)
console.log('24h Fees:', pool.fees24h)

// Add liquidity to a specific price range
const addLiquidityTx = await meteora.addLiquidity({
  pool: poolAddress,
  amountA: 10, // 10 SOL
  amountB: 2500, // $2500 USDC
  lowerPrice: 240, // Lower bound $240
  upperPrice: 260, // Upper bound $260
  slippage: 0.5, // 0.5% slippage tolerance
})

console.log('Liquidity added successfully:', addLiquidityTx.signature)

// Get LP position info
const positions = await meteora.getUserPositions(wallet.publicKey)
console.log('My positions:', positions)

import { Meteora } from '@meteora-ag/meteora-sdk'

const meteora = new Meteora({ connection })

// Get quote
const quote = await meteora.getQuote({
  inputMint: SOL_MINT,
  outputMint: USDC_MINT,
  amount: 10 * 1e9, // 10 SOL
  slippage: 0.5,
})

console.log('Trade Quote:')
console.log('Input:', quote.inputAmount / 1e9, 'SOL')
console.log('Output:', quote.outputAmount / 1e6, 'USDC')
console.log('Price Impact:', quote.priceImpact, '%')
console.log('Fee:', quote.fee / 1e6, 'USDC')

// Execute trade
const swapTx = await meteora.swap({
  inputMint: SOL_MINT,
  outputMint: USDC_MINT,
  amount: 10 * 1e9,
  slippage: 0.5,
  wallet: wallet.publicKey,
})

console.log('Trade successful:', swapTx.signature)

// Query trade route
const route = await meteora.findBestRoute({
  inputMint: SOL_MINT,
  outputMint: BONK_MINT,
  amount: 10 * 1e9,
})

console.log('Optimal route:', route.path)
// Possible output: ['SOL', 'USDC', 'BONK'] (multi-hop route)

import { Meteora } from '@meteora-ag/meteora-sdk'

const meteora = new Meteora({ connection })

// Strategy 1: Narrow range, high yield
// Suitable for stablecoin pairs (USDC/USDT)
const narrowRangeTx = await meteora.addLiquidity({
  pool: USDC_USDT_POOL,
  amountA: 10000, // $10k USDC
  amountB: 10000, // $10k USDT
  lowerPrice: 0.998, // Lower bound $0.998
  upperPrice: 1.002, // Upper bound $1.002
})

// Advantages:
// - Narrow price range (0.4%), extremely high capital efficiency
// - Stablecoins rarely move outside the range
// - Expected APR: 20-50%+

// Strategy 2: Wide range, stable yield
// Suitable for LST pairs (SOL/mSOL)
const wideRangeTx = await meteora.addLiquidity({
  pool: SOL_MSOL_POOL,
  amountA: 100, // 100 SOL
  amountB: 90, // 90 mSOL
  lowerPrice: 0.95, // Lower bound 0.95
  upperPrice: 1.05, // Upper bound 1.05
})

// Advantages:
// - Wide price range (10%), price rarely leaves
// - Low impermanent loss risk
// - Expected APR: 10-20%

// Strategy 3: Dynamic rebalancing
// Monitor price, auto-adjust range
setInterval(async () => {
  const pool = await meteora.getPool(SOL_USDC_POOL)
  const currentPrice = pool.currentPrice
  const positions = await meteora.getUserPositions(wallet.publicKey)

  for (const pos of positions) {
    // If price approaches range boundary, readjust
    if (currentPrice < pos.lowerPrice * 1.05 || currentPrice > pos.upperPrice * 0.95) {
      // Remove old position
      await meteora.removeLiquidity({ positionId: pos.id })

      // Create new position (centered on current price)
      await meteora.addLiquidity({
        pool: SOL_USDC_POOL,
        amountA: pos.amountA,
        amountB: pos.amountB,
        lowerPrice: currentPrice * 0.95,
        upperPrice: currentPrice * 1.05,
      })

      console.log('Position rebalanced')
    }
  }
}, 3600000) // Check every hour

import { Meteora } from '@meteora-ag/meteora-sdk'

const meteora = new Meteora({ connection })
const pool = await meteora.getPool(SOL_USDC_POOL)

// Get historical data
const analytics = await meteora.getPoolAnalytics({
  pool: SOL_USDC_POOL,
  period: '7d', // 7-day data
})

console.log('Pool Analytics:')
console.log('Volume (7d):', analytics.volume7d, 'USDC')
console.log('Fees (7d):', analytics.fees7d, 'USDC')
console.log('TVL:', analytics.tvl, 'USDC')
console.log('APR:', analytics.apr, '%')
console.log('Daily Avg Trades:', analytics.txCount / 7)

// Liquidity distribution
const distribution = await meteora.getLiquidityDistribution(SOL_USDC_POOL)

console.log('Liquidity Distribution:')
distribution.bins.forEach((bin, index) => {
  if (bin.liquidity > 0) {
    console.log(`Price $${bin.price}: ${bin.liquidity} USDC`)
  }
})

// Calculate expected returns
const myPosition = positions[0]
const estimatedFees = (myPosition.liquidity / analytics.tvl) * analytics.fees7d
const estimatedAPR = (estimatedFees / myPosition.totalValue) * (365 / 7) * 100

console.log('My estimated annualized return:', estimatedAPR, '%')