Volatility-Based LP Ranges: Fisher Transform for Concentrated Liquidity

interface PricePoint {
  price: number
  timestamp: number
}
 
function computeReturns(prices: PricePoint[]): number[] {
  return prices
    .slice(1)
    .map((p, i) => (p.price - prices[i].price) / prices[i].price)
}
 
function computeRealizedVolatility(prices: PricePoint[]): number {
  const returns = computeReturns(prices)
  const mean = returns.reduce((a, b) => a + b, 0) / returns.length
  const variance =
    returns.reduce((acc, r) => acc + Math.pow(r - mean, 2), 0) / returns.length
  const stdDev = Math.sqrt(variance)
 
  // Scale from per-minute to hourly volatility
  // sqrt(60) because volatility scales with sqrt of time
  return stdDev * Math.sqrt(60)
}

function fisherTransform(values: number[]): number[] {
  // First, normalize values to the [-1, 1] range
  const min = Math.min(...values)
  const max = Math.max(...values)
  const range = max - min
 
  return values.map((v) => {
    // Normalize to [-1, 1]
    let normalized = 2 * ((v - min) / range) - 1
    // Clamp to avoid infinity at ±1
    normalized = Math.max(-0.999, Math.min(0.999, normalized))
    // Fisher Transform: arctanh
    return 0.5 * Math.log((1 + normalized) / (1 - normalized))
  })
}
 
function inverseFisher(value: number): number {
  // Convert back from Fisher space to normalized space
  return (Math.exp(2 * value) - 1) / (Math.exp(2 * value) + 1)
}

interface VolatilityCone {
  currentPrice: number
  hourlyVol: number
  lower: number // Lower price bound at confidence level
  upper: number // Upper price bound at confidence level
  confidence: number // e.g., 0.95
  timeHorizonHours: number
}
 
function buildVolatilityCone(
  prices: PricePoint[],
  currentPrice: number,
  timeHorizonHours: number = 4,
  confidence: number = 0.95
): VolatilityCone {
  const returns = computeReturns(prices)
 
  // Apply Fisher Transform to normalize the returns distribution
  const fisherReturns = fisherTransform(returns)
 
  // Now standard deviation is meaningful
  const fisherMean =
    fisherReturns.reduce((a, b) => a + b, 0) / fisherReturns.length
  const fisherStd = Math.sqrt(
    fisherReturns.reduce((a, r) => a + Math.pow(r - fisherMean, 2), 0) /
      fisherReturns.length
  )
 
  // Z-score for desired confidence level (1.96 for 95%)
  const zScore =
    confidence === 0.95 ? 1.96 : confidence === 0.99 ? 2.576 : 1.645
 
  // Project over time horizon (volatility scales with sqrt of time)
  const scaledStd = fisherStd * Math.sqrt(timeHorizonHours * 60) // Scale from per-minute
 
  // Compute bounds in Fisher space, then convert back
  const fisherUpper = fisherMean + zScore * scaledStd
  const fisherLower = fisherMean - zScore * scaledStd
 
  // Convert Fisher bounds back to price deviation
  const upperDev = inverseFisher(fisherUpper)
  const lowerDev = inverseFisher(fisherLower)
 
  // Raw hourly volatility for reference
  const hourlyVol = computeRealizedVolatility(prices)
 
  return {
    currentPrice,
    hourlyVol,
    lower: currentPrice * (1 + lowerDev),
    upper: currentPrice * (1 + upperDev),
    confidence,
    timeHorizonHours,
  }
}

function calculatePriceROC(
  prices: PricePoint[],
  lookbackMinutes: number = 60
): number {
  if (prices.length < lookbackMinutes) return Infinity // Not enough data
 
  const current = prices[prices.length - 1].price
  const past = prices[prices.length - lookbackMinutes].price
  return (current - past) / past
}
 
function calculateVolatilityROC(
  prices: PricePoint[],
  windowMinutes: number = 60
): number {
  if (prices.length < windowMinutes * 2) return Infinity
 
  const recentPrices = prices.slice(-windowMinutes)
  const priorPrices = prices.slice(-windowMinutes * 2, -windowMinutes)
 
  const recentVol = computeRealizedVolatility(recentPrices)
  const priorVol = computeRealizedVolatility(priorPrices)
 
  if (priorVol === 0) return Infinity
  return (recentVol - priorVol) / priorVol
}
 
interface EntryAssessment {
  favorable: boolean
  priceROC: number
  volROC: number
  reason: string
}
 
function assessEntryConditions(
  prices: PricePoint[],
  priceRocThreshold: number = 0.01, // 1% price change
  volRocThreshold: number = 0.05 // 5% volatility change
): EntryAssessment {
  const priceROC = calculatePriceROC(prices)
  const volROC = calculateVolatilityROC(prices)
 
  const priceStable = Math.abs(priceROC) <= priceRocThreshold
  const volStable = Math.abs(volROC) <= volRocThreshold
  const favorable = priceStable && volStable
 
  return {
    favorable,
    priceROC,
    volROC,
    reason: favorable
      ? 'Price consolidating, volatility stable'
      : !priceStable
        ? `Price moving too fast (ROC: ${(priceROC * 100).toFixed(2)}%)`
        : `Volatility shifting (ROC: ${(volROC * 100).toFixed(2)}%)`,
  }
}

function priceToTick(price: number, tickSpacing: number): number {
  // Whirlpool tick formula: tick = log(price) / log(1.0001)
  const rawTick = Math.log(price) / Math.log(1.0001)
  // Snap to nearest valid tick (must be multiple of tickSpacing)
  return Math.round(rawTick / tickSpacing) * tickSpacing
}
 
function coneToPositionParams(
  cone: VolatilityCone,
  tickSpacing: number
): { tickLower: number; tickUpper: number; buffer: number } {
  // Base ticks from the cone
  const rawTickLower = priceToTick(cone.lower, tickSpacing)
  const rawTickUpper = priceToTick(cone.upper, tickSpacing)
 
  // Adaptive buffer: tighter cones need proportionally more buffer
  // to avoid immediate out-of-range events
  const rangeTicks = rawTickUpper - rawTickLower
  const bufferTicks = Math.max(
    tickSpacing * 2, // Minimum 2 tick spacings
    Math.round(rangeTicks * 0.1) // 10% of range as buffer
  )
 
  return {
    tickLower: rawTickLower - bufferTicks,
    tickUpper: rawTickUpper + bufferTicks,
    buffer: bufferTicks,
  }
}

import { fork, ChildProcess } from 'child_process'
 
class DriftHedgeManager {
  private worker: ChildProcess
 
  constructor(workerPath: string) {
    this.worker = fork(workerPath)
    this.worker.on('exit', (code) => {
      // Auto-restart on crash, reconstruct state from on-chain data
      console.log(`Drift worker exited with code ${code}, restarting...`)
      this.worker = fork(workerPath)
      this.reconstructState()
    })
  }
 
  async openShort(solAmount: number): Promise<{ txSignature: string }> {
    return this.sendCommand({
      action: 'open',
      size: solAmount,
      direction: 'short',
    })
  }
 
  async getPosition(): Promise<{
    size: number
    unrealizedPnl: number
    fundingAccrued: number
  }> {
    return this.sendCommand({ action: 'query_status' })
  }
 
  private sendCommand<T>(command: HedgeCommand): Promise<T> {
    return new Promise((resolve, reject) => {
      const timeout = setTimeout(
        () => reject(new Error('Drift worker timeout')),
        30_000
      )
 
      const handler = (msg: any) => {
        clearTimeout(timeout)
        this.worker.off('message', handler)
        if (msg.status === 'error') reject(new Error(msg.message))
        else resolve(msg as T)
      }
 
      this.worker.on('message', handler)
      this.worker.send(command)
    })
  }
}

interface LPSession {
  id: string
  openedAt: Date
  closedAt: Date | null
  // Entry conditions (what the market looked like when we entered)
  entryPrice: number
  entryVolatility: number
  entryPriceROC: number
  entryFisherValue: number
  // Position parameters
  tickLower: number
  tickUpper: number
  initialLiquidityUsd: number
  // Outcomes
  feesEarnedUsd: number
  impermanentLossUsd: number
  hedgePnlUsd: number
  gasCostUsd: number
  netPnlUsd: number
  timeInRangePercent: number
  rebalanceCount: number
}
 
// Query: compare sessions by entry conditions
// "Do positions opened during low-ROC conditions actually perform better?"
async function compareByEntryCondition(db: Pool): Promise<void> {
  const result = await db.query(`
    SELECT
      CASE WHEN entry_price_roc < 0.01 THEN 'low_roc' ELSE 'high_roc' END as condition,
      AVG(net_pnl_usd / initial_liquidity_usd * 100) as avg_return_pct,
      AVG(time_in_range_percent) as avg_time_in_range,
      AVG(fees_earned_usd / initial_liquidity_usd * 100) as avg_fee_pct,
      COUNT(*) as session_count
    FROM lp_sessions
    WHERE closed_at IS NOT NULL
    GROUP BY condition
  `)
  // Result: low_roc positions earn ~30% more net yield
}