@exponent-labs/market-three-math 0.9.18 → 0.9.19

package/src/swapV2.ts

@@ -16,6 +16,112 @@ function computeFlashFeeOut(ytValue: number, grossOut: number, lpFeeRate: number
   return Math.min(grossOut, Math.max(1, getFeeFromAmount(ytValue, lpFeeRate)))
 }
 
+function ceilNonNegative(value: number): number {
+  if (!Number.isFinite(value) || value <= 0) {
+    return 0
+  }
+
+  return Math.ceil(value)
+}
+
+function ytSyPriceFromSpot(currentPriceSpot: number, snapshot: EffSnap): number {
+  if (currentPriceSpot <= 0 || snapshot.syExchangeRate <= 0) {
+    return 0
+  }
+
+  const ptAssetPrice = Math.pow(currentPriceSpot, -snapshot.timeFactor)
+  if (!Number.isFinite(ptAssetPrice)) {
+    return 0
+  }
+
+  return Math.max(0, 1 - ptAssetPrice) / snapshot.syExchangeRate
+}
+
+function flashFeeBasisSy(ytAmount: number, ytSyPrice: number): number {
+  return ceilNonNegative(ytAmount * ytSyPrice)
+}
+
+function flashFeeBasisPt(ptOutGross: number, ytSyPrice: number, syExchangeRate: number): number {
+  return ceilNonNegative(ptOutGross * ytSyPrice * syExchangeRate)
+}
+
+function estimateExactOutGross(
+  targetNet: number,
+  maxGross: number,
+  lpFeeRate: number,
+  isFlashSwap: boolean,
+  ytSyPrice: number,
+  syExchangeRate: number,
+): number {
+  if (targetNet === 0 || maxGross === 0) {
+    return 0
+  }
+
+  const feeDelta = Math.max(0, lpFeeRate - 1)
+  const feeBasisPerGross = isFlashSwap ? Math.max(0, ytSyPrice * syExchangeRate) : 1
+  const netPerGross = 1 - feeDelta * feeBasisPerGross
+  if (!Number.isFinite(netPerGross) || netPerGross <= 0) {
+    return maxGross
+  }
+
+  const targetWithFeeFloor = isFlashSwap || feeDelta > 0 ? targetNet + 1 : targetNet
+  return Math.min(maxGross, ceilNonNegative(targetWithFeeFloor / netPerGross))
+}
+
+function solveExactOutGrossDirect(
+  targetNet: number,
+  minGross: number,
+  maxGross: number,
+  grossEstimate: number,
+  calculateNet: (gross: number) => number,
+): number {
+  if (targetNet === 0 || maxGross === 0) {
+    return 0
+  }
+
+  const correctionSteps = 64
+  let gross = Math.min(maxGross, Math.max(minGross, grossEstimate))
+  let net = calculateNet(gross)
+
+  for (let i = 0; i < correctionSteps; i++) {
+    if (net >= targetNet || gross >= maxGross) {
+      break
+    }
+    gross += 1
+    net = calculateNet(gross)
+  }
+
+  if (net < targetNet) {
+    let lo = gross
+    let hi = maxGross
+    if (calculateNet(hi) < targetNet) {
+      return maxGross
+    }
+    while (lo < hi) {
+      const mid = lo + Math.floor((hi - lo) / 2)
+      if (calculateNet(mid) >= targetNet) {
+        hi = mid
+      } else {
+        lo = mid + 1
+      }
+    }
+    gross = lo
+  }
+
+  for (let i = 0; i < correctionSteps; i++) {
+    if (gross === 0) {
+      break
+    }
+    const prevNet = calculateNet(gross - 1)
+    if (prevNet < targetNet) {
+      break
+    }
+    gross -= 1
+  }
+
+  return gross
+}
+
 function boundaryPrincipalRemainder(
   computedGrossOut: number,
   fullOutgoingPrincipal: number,
@@ -214,6 +320,8 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
       continue
     }
 
+    const ytSyPrice = ytSyPriceFromSpot(currentPriceSpot, snapshot)
+
     if (args.direction === SwapDirection.PtToSy) {
       // PT -> SY swap
 
@@ -265,14 +373,10 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
       }
 
       // Fees in token_out (SY)
-      // For flash swaps, fee is based on YT value = (pt - sy × sy_exchange_rate) / sy_exchange_rate (in SY terms)
       if (syOutGrossU64 > 0 || syRemainderAtBoundary > 0) {
         let totalFeeOut: number
         if (args.isCurrentFlashSwap) {
-          const syOutBase = syOutGrossU64 * args.syExchangeRate
-          const ytValueBase = ptInSegment - syOutBase
-          const ytValueSy = ytValueBase / args.syExchangeRate
-          totalFeeOut = getFeeFromAmount(Math.max(0, Math.floor(ytValueSy)), lpFeeRate)
+          totalFeeOut = computeFlashFeeOut(flashFeeBasisSy(ptInSegment, ytSyPrice), syOutGrossU64, lpFeeRate)
         } else {
           totalFeeOut = getFeeFromAmount(syOutGrossU64, lpFeeRate)
         }
@@ -393,12 +497,13 @@ export function simulateSwap(marketState: MarketThreeState, args: SwapArgs): Swa
 
       if (ptOutGrossU64 > 0 || ptRemainderAtBoundary > 0) {
         // Fees in token_out (PT)
-        // For flash swaps, fee is based on YT value = pt - sy × sy_exchange_rate
         let totalFeeOut: number
         if (args.isCurrentFlashSwap) {
-          const syInBase = syInSegmentU64 * args.syExchangeRate
-          const ytValue = ptOutGrossU64 - syInBase
-          totalFeeOut = computeFlashFeeOut(Math.max(0, Math.floor(ytValue)), ptOutGrossU64, lpFeeRate)
+          totalFeeOut = computeFlashFeeOut(
+            flashFeeBasisPt(ptOutGrossU64, ytSyPrice, args.syExchangeRate),
+            ptOutGrossU64,
+            lpFeeRate,
+          )
         } else {
           totalFeeOut = getFeeFromAmount(ptOutGrossU64, lpFeeRate)
         }
@@ -481,6 +586,7 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
   let currentLeftBoundaryKey = ticksWrapper.currentTickKey
   let activeLiquidityU64 = ticksWrapper.currentPrefixSum
   let activeLiquidityF64 = Number(activeLiquidityU64)
+  const ytSyPrice = ytSyPriceFromSpot(currentPriceSpot, snapshot)
 
   const lpFeeRate = calculateFeeRate(configurationOptions.lnFeeRateRoot, secondsRemaining)
   const protocolFeeBps = configurationOptions.treasuryFeeBps
@@ -517,7 +623,7 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
   let iterations = 0
   const MAX_ITERATIONS = 1000
 
-  while (amountOutLeft > 2 && iterations < MAX_ITERATIONS) {
+  while (amountOutLeft > 0 && iterations < MAX_ITERATIONS) {
     iterations++
 
     const rightBoundaryKeyOpt = ticksWrapper.successorKey(currentLeftBoundaryKey)
@@ -671,6 +777,7 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
         cEffOld,
         lpFeeRate,
         args.isCurrentFlashSwap,
+        ytSyPrice,
       )
 
       const ptOutNetBoundaryActual = Math.max(0, boundarySegment.ptOutGrossActual - boundarySegment.totalFeeOut)
@@ -745,6 +852,7 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
           cEffOld,
           lpFeeRate,
           args.isCurrentFlashSwap,
+          ytSyPrice,
         )
       const ptOutNetBoundaryActual =
         ptOutNetBoundaryEffectiveSeed ?? Math.max(0, boundarySegment.ptOutGrossActual - boundarySegment.totalFeeOut)
@@ -755,20 +863,35 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
     }
 
     const targetNet = Math.min(amountOutLeft, ptOutNetBoundaryEffective)
+    const maxGross = ptOutGrossBoundaryU64
+    const minGross = Math.min(targetNet, maxGross)
+    const usedPrecomputedSegment = precomputedBoundarySegment !== null
     const grossCandidate = precomputedBoundarySegment
-      ? ptOutGrossBoundaryU64
-      : findGrossForTargetNet(targetNet, Math.min(targetNet, ptOutGrossBoundaryU64), ptOutGrossBoundaryU64, (gross) =>
-          calculateNetPtOut(
-            gross,
-            lTradeF64,
-            currentPriceSpot,
-            duToLeft,
-            anchorULeft,
+      ? maxGross
+      : solveExactOutGrossDirect(
+          targetNet,
+          minGross,
+          maxGross,
+          estimateExactOutGross(
+            targetNet,
+            maxGross,
             lpFeeRate,
             args.isCurrentFlashSwap,
-            snapshot,
-            cEffOld,
+            ytSyPrice,
+            snapshot.syExchangeRate,
           ),
+          (gross) =>
+            calculateNetPtOut(
+              gross,
+              lTradeF64,
+              currentPriceSpot,
+              duToLeft,
+              anchorULeft,
+              lpFeeRate,
+              args.isCurrentFlashSwap,
+              snapshot,
+              ytSyPrice,
+            ),
         )
 
     const segment =
@@ -783,6 +906,7 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
         cEffOld,
         lpFeeRate,
         args.isCurrentFlashSwap,
+        ytSyPrice,
       )
 
     let syInSegmentU64 = segment.syInSegmentU64
@@ -794,20 +918,41 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
       throw new Error("Insufficient SY budget for exact-out trade")
     }
 
-    const netActual = segment.ptOutGrossActual - segment.totalFeeOut
-    if (netActual < 0) {
+    const reachesLeftBoundary =
+      Math.abs(snapshot.getEffectivePrice(segment.spotPriceNew) - cEffLeft) <= eps ||
+      segment.ptOutGrossActual === ptOutGrossBoundaryU64
+    const rawNetActual = segment.ptOutGrossActual - segment.totalFeeOut
+    if (rawNetActual < 0) {
       throw new Error("Exact-out net underflow")
     }
-    if (netActual > amountOutLeft) {
-      throw new Error("Exact-out net exceeded remaining target")
+    if (rawNetActual === 0 && !reachesLeftBoundary) {
+      throw new Error("Exact-out segment produced no PT output")
+    }
+    if (rawNetActual < targetNet && !reachesLeftBoundary) {
+      throw new Error("Exact-out segment under-delivered target")
+    }
+    const netActual = Math.min(rawNetActual, targetNet)
+    const exactOutRoundingSurplus = rawNetActual - netActual
+    if (exactOutRoundingSurplus > 0 && !usedPrecomputedSegment && grossCandidate > 0) {
+      const prevNetActual = calculateNetPtOut(
+        grossCandidate - 1,
+        lTradeF64,
+        currentPriceSpot,
+        duToLeft,
+        anchorULeft,
+        lpFeeRate,
+        args.isCurrentFlashSwap,
+        snapshot,
+        ytSyPrice,
+      )
+      if (prevNetActual >= targetNet) {
+        throw new Error("Exact-out gross candidate is not minimal")
+      }
     }
     amountOutLeft -= netActual
     amountOutAccum += netActual
     amountInConsumed += syInSegmentU64
 
-    const reachesLeftBoundary =
-      Math.abs(snapshot.getEffectivePrice(segment.spotPriceNew) - cEffLeft) <= eps ||
-      segment.ptOutGrossActual === ptOutGrossBoundaryU64
     const ptRemainderAtBoundary = boundaryPrincipalRemainder(
       segment.ptOutGrossActual,
       Number(principalPt),
@@ -818,7 +963,7 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
       ptRemainderAtBoundary,
       protocolFeeBps,
     )
-    feeLpOutU64 += lpFeeOut
+    feeLpOutU64 += lpFeeOut + exactOutRoundingSurplus
     feeProtocolOutU64 += protocolFeeOut
     boundaryRemainderChargedOutToken += ptRemainderAtBoundary
 
@@ -832,7 +977,7 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
 
     const cEffNew = snapshot.getEffectivePrice(currentPriceSpot)
     if (
-      amountOutLeft > 2 &&
+      amountOutLeft > 0 &&
       (Math.abs(cEffNew - cEffLeft) <= eps || segment.ptOutGrossActual === ptOutGrossBoundaryU64)
     ) {
       const crossed = crossOneBoundary(ticksWrapper, SwapDirection.SyToPt, currentLeftBoundaryKey, {
@@ -849,7 +994,7 @@ export function simulateSwapExactOut(marketState: MarketThreeState, args: SwapEx
     }
   }
 
-  if (amountOutLeft > 2) {
+  if (amountOutLeft !== 0) {
     throw new Error("Insufficient PT output for exact-out trade")
   }
 
@@ -905,120 +1050,6 @@ function computeKappaAndLTrade(
   return lTradeF64
 }
 
-function findGrossForTargetNet(
-  targetNet: number,
-  minGross: number,
-  maxGross: number,
-  calculateNet: (gross: number) => number,
-): number {
-  const MAX_INTERPOLATION_STEPS = 6
-  const MAX_LOCAL_ADJUST_STEPS = 24
-  const MAX_BINARY_FALLBACK_STEPS = 12
-
-  if (minGross >= maxGross) {
-    return minGross
-  }
-
-  let left = minGross
-  let leftNet = calculateNet(left)
-  if (leftNet >= targetNet) {
-    return left
-  }
-
-  let right = maxGross
-  let rightNet = calculateNet(right)
-  if (rightNet <= targetNet) {
-    return right
-  }
-
-  for (let i = 0; i < MAX_INTERPOLATION_STEPS; i++) {
-    if (right <= left + 1) {
-      return left
-    }
-    if (rightNet <= leftNet) {
-      break
-    }
-
-    const span = right - left
-    const targetDelta = Math.max(0, targetNet - leftNet)
-    const denominator = rightNet - leftNet
-    if (denominator === 0) {
-      break
-    }
-
-    const estimatedOffset = Number((BigInt(targetDelta) * BigInt(span)) / BigInt(denominator))
-    let estimate = left + estimatedOffset
-    if (estimate <= left) {
-      estimate = left + 1
-    }
-    if (estimate >= right) {
-      estimate = right - 1
-    }
-
-    const estimateNet = calculateNet(estimate)
-    if (estimateNet === targetNet) {
-      return estimate
-    }
-    if (estimateNet < targetNet) {
-      left = estimate
-      leftNet = estimateNet
-    } else {
-      right = estimate
-      rightNet = estimateNet
-    }
-  }
-
-  let best = left
-  for (let i = 0; i < MAX_LOCAL_ADJUST_STEPS; i++) {
-    if (best >= right) {
-      break
-    }
-    const next = best + 1
-    if (next > right) {
-      break
-    }
-    const nextNet = calculateNet(next)
-    if (nextNet > targetNet) {
-      break
-    }
-    best = next
-    if (nextNet === targetNet) {
-      return best
-    }
-  }
-
-  if (right <= best + 1) {
-    return best
-  }
-
-  let low = best
-  let high = right
-  let bestGross = best
-  let steps = 0
-
-  while (low <= high && steps < MAX_BINARY_FALLBACK_STEPS) {
-    steps += 1
-    const mid = low + Math.floor((high - low) / 2)
-    const net = calculateNet(mid)
-
-    if (net === targetNet) {
-      return mid
-    }
-
-    if (net < targetNet) {
-      bestGross = mid
-      low = mid + 1
-    } else {
-      if (mid === 0) {
-        break
-      }
-      high = mid - 1
-    }
-  }
-
-  return bestGross
-}
-
 function calculateNetPtOut(
   grossCandidate: number,
   lTradeF64: number,
@@ -1028,7 +1059,7 @@ function calculateNetPtOut(
   lpFeeRate: number,
   isCurrentFlashSwap: boolean,
   snapshot: EffSnap,
-  cEffOld: number,
+  ytSyPrice: number,
 ): number {
   const duCandidate = grossCandidate / lTradeF64
   const duClamped = Math.min(duCandidate, duToLeft)
@@ -1040,13 +1071,11 @@ function calculateNetPtOut(
   const ptOutGrossActual = Math.max(0, Math.floor(lTradeF64 * (currentPriceSpot - spotPriceNew)))
 
   const totalFeeOut = isCurrentFlashSwap
-    ? (() => {
-        const cEffNew = snapshot.getEffectivePrice(spotPriceNew)
-        const syInSegmentF = lTradeF64 * (cEffNew - cEffOld)
-        const syInBase = Math.ceil(syInSegmentF) * snapshot.syExchangeRate
-        const ytValue = ptOutGrossActual - syInBase
-        return computeFlashFeeOut(Math.max(0, Math.floor(ytValue)), ptOutGrossActual, lpFeeRate)
-      })()
+    ? computeFlashFeeOut(
+        flashFeeBasisPt(ptOutGrossActual, ytSyPrice, snapshot.syExchangeRate),
+        ptOutGrossActual,
+        lpFeeRate,
+      )
     : getFeeFromAmount(ptOutGrossActual, lpFeeRate)
 
   return Math.max(0, ptOutGrossActual - totalFeeOut)
@@ -1062,6 +1091,7 @@ function calculateSwapSegment(
   cEffOld: number,
   lpFeeRate: number,
   isCurrentFlashSwap: boolean,
+  ytSyPrice: number,
 ): {
   spotPriceNew: number
   syInSegmentU64: number
@@ -1081,9 +1111,11 @@ function calculateSwapSegment(
   const ptOutGrossActual = Math.max(0, Math.floor(lTradeF64 * (currentPriceSpot - spotPriceNew)))
 
   const normalFee = getFeeFromAmount(ptOutGrossActual, lpFeeRate)
-  const syInBase = Math.ceil(syInSegmentF) * snapshot.syExchangeRate
-  const ytValue = ptOutGrossActual - syInBase
-  const flashFee = computeFlashFeeOut(Math.max(0, Math.floor(ytValue)), ptOutGrossActual, lpFeeRate)
+  const flashFee = computeFlashFeeOut(
+    flashFeeBasisPt(ptOutGrossActual, ytSyPrice, snapshot.syExchangeRate),
+    ptOutGrossActual,
+    lpFeeRate,
+  )
   const totalFeeOut = isCurrentFlashSwap ? flashFee : normalFee
 
   return {

package/src/tickTree.ts

@@ -0,0 +1,119 @@
+import type { Tick, Ticks } from "@exponent-labs/exponent-fetcher"
+
+const SENTINEL_TICK_INDEX = 0
+
+type TickTreeNode = {
+  left: number
+  right: number
+  parent: number
+  colorOrFree: number
+}
+
+type TreeTick = Tick & {
+  treeNode?: TickTreeNode
+  isInitialized?: boolean
+}
+
+const asTreeTick = (tick: Tick | null | undefined): TreeTick | null | undefined => tick as TreeTick | null | undefined
+
+export const isLiveTick = (tick: Tick | null | undefined): tick is Tick => {
+  const treeTick = asTreeTick(tick)
+  if (!treeTick) {
+    return false
+  }
+  if (treeTick.isInitialized != null) {
+    return treeTick.isInitialized
+  }
+  if (treeTick.apyBasePoints > 0) {
+    return true
+  }
+
+  return (
+    treeTick.impliedRate > 0 ||
+    treeTick.liquidityGross !== 0n ||
+    treeTick.principalShareSupply !== 0n ||
+    treeTick.principalPt !== 0n ||
+    treeTick.principalSy !== 0n ||
+    treeTick.frozenLiquidity !== 0n
+  )
+}
+
+export const successorTickIdx = (ticks: Ticks, tickIdx: number): number | null => {
+  const tick = asTreeTick(ticks.ticksTree[tickIdx - 1])
+  if (!isLiveTick(tick)) {
+    return null
+  }
+
+  const node = tick.treeNode
+  if (node) {
+    let right = node.right
+    if (right !== SENTINEL_TICK_INDEX) {
+      while (asTreeTick(ticks.ticksTree[right - 1])?.treeNode?.left) {
+        right = asTreeTick(ticks.ticksTree[right - 1])!.treeNode!.left
+      }
+      return isLiveTick(ticks.ticksTree[right - 1]) ? right : null
+    }
+
+    let cursor = tickIdx
+    let parent = node.parent
+    while (parent !== SENTINEL_TICK_INDEX && cursor === asTreeTick(ticks.ticksTree[parent - 1])?.treeNode?.right) {
+      cursor = parent
+      parent = asTreeTick(ticks.ticksTree[parent - 1])?.treeNode?.parent ?? SENTINEL_TICK_INDEX
+    }
+
+    return parent !== SENTINEL_TICK_INDEX && isLiveTick(ticks.ticksTree[parent - 1]) ? parent : null
+  }
+
+  let best: { tickIdx: number; key: number } | null = null
+  for (let index = 0; index < ticks.ticksTree.length; index++) {
+    const candidate = ticks.ticksTree[index]
+    if (!isLiveTick(candidate) || candidate.apyBasePoints <= tick.apyBasePoints) {
+      continue
+    }
+    if (!best || candidate.apyBasePoints < best.key) {
+      best = { tickIdx: index + 1, key: candidate.apyBasePoints }
+    }
+  }
+
+  return best?.tickIdx ?? null
+}
+
+export const predecessorTickIdx = (ticks: Ticks, tickIdx: number): number | null => {
+  const tick = asTreeTick(ticks.ticksTree[tickIdx - 1])
+  if (!isLiveTick(tick)) {
+    return null
+  }
+
+  const node = tick.treeNode
+  if (node) {
+    let left = node.left
+    if (left !== SENTINEL_TICK_INDEX) {
+      while (asTreeTick(ticks.ticksTree[left - 1])?.treeNode?.right) {
+        left = asTreeTick(ticks.ticksTree[left - 1])!.treeNode!.right
+      }
+      return isLiveTick(ticks.ticksTree[left - 1]) ? left : null
+    }
+
+    let cursor = tickIdx
+    let parent = node.parent
+    while (parent !== SENTINEL_TICK_INDEX && cursor === asTreeTick(ticks.ticksTree[parent - 1])?.treeNode?.left) {
+      cursor = parent
+      parent = asTreeTick(ticks.ticksTree[parent - 1])?.treeNode?.parent ?? SENTINEL_TICK_INDEX
+    }
+
+    return parent !== SENTINEL_TICK_INDEX && isLiveTick(ticks.ticksTree[parent - 1]) ? parent : null
+  }
+
+  let best: { tickIdx: number; key: number } | null = null
+  for (let index = 0; index < ticks.ticksTree.length; index++) {
+    const candidate = ticks.ticksTree[index]
+    if (!isLiveTick(candidate) || candidate.apyBasePoints >= tick.apyBasePoints) {
+      continue
+    }
+    if (!best || candidate.apyBasePoints > best.key) {
+      best = { tickIdx: index + 1, key: candidate.apyBasePoints }
+    }
+  }
+
+  return best?.tickIdx ?? null
+}

package/src/utils.ts

@@ -4,6 +4,8 @@
  */
 import { Tick, Ticks } from "@exponent-labs/exponent-fetcher"
 
+import { isLiveTick, predecessorTickIdx, successorTickIdx } from "./tickTree"
+
 const SECONDS_PER_YEAR = 365 * 24 * 60 * 60
 // const BASE_POINTS = 10000
 
@@ -117,7 +119,7 @@ export function getSuccessorTickKey(ticks: Ticks, currentTickKey: number): numbe
   let minKey: number | null = null
 
   for (const tick of ticks.ticksTree) {
-    if (tick.apyBasePoints > currentTickKey) {
+    if (isLiveTick(tick) && tick.apyBasePoints > currentTickKey) {
       if (minKey === null || tick.apyBasePoints < minKey) {
         minKey = tick.apyBasePoints
       }
@@ -132,19 +134,7 @@ export function getSuccessorTickKey(ticks: Ticks, currentTickKey: number): numbe
  * This is almost equivalent to the Rust successor_idx method
  */
 export function getSuccessorTickIdxByIdx(ticks: Ticks, tickIdx: number): number | null {
-  //TODO Refactor to make it more CPU efficient
-  const tick = ticks.ticksTree.at(tickIdx - 1) ?? null
-
-  if (!tick) return null
-
-  // Find ticks with apyBasePoints greater than tickIdx
-  const successorTicks = ticks.ticksTree
-    .filter((t) => t.apyBasePoints > tick.apyBasePoints)
-    .sort((a, b) => a.apyBasePoints - b.apyBasePoints)
-
-  const successorTick = successorTicks.at(0) ?? null
-
-  return !!successorTick ? ticks.ticksTree.indexOf(successorTick) + 1 : null
+  return successorTickIdx(ticks, tickIdx)
 }
 
 /**
@@ -152,19 +142,7 @@ export function getSuccessorTickIdxByIdx(ticks: Ticks, tickIdx: number): number
  * This is the inverse of getSuccessorTickIdxByIdx - finds the tick with the largest apyBasePoints that is still less than the current tick
  */
 export function getPredecessorTickIdxByIdx(ticks: Ticks, tickIdx: number): number | null {
-  //TODO Refactor to make it more CPU efficient
-  const tick = ticks.ticksTree.at(tickIdx - 1) ?? null
-
-  if (!tick) return null
-
-  // Find ticks with apyBasePoints less than current tick
-  const predecessorTicks = ticks.ticksTree
-    .filter((t) => t.apyBasePoints < tick.apyBasePoints)
-    .sort((a, b) => b.apyBasePoints - a.apyBasePoints) // Sort descending to get the largest that's still less
-
-  const predecessorTick = predecessorTicks.at(0) ?? null
-
-  return !!predecessorTick ? ticks.ticksTree.indexOf(predecessorTick) + 1 : null
+  return predecessorTickIdx(ticks, tickIdx)
 }
 
 /**
@@ -178,7 +156,7 @@ export function getPredecessorTickKey(ticks: Ticks, currentTickKey: number): num
   let maxKey: number | null = null
 
   for (const tick of ticks.ticksTree) {
-    if (tick.apyBasePoints < currentTickKey) {
+    if (isLiveTick(tick) && tick.apyBasePoints < currentTickKey) {
       if (maxKey === null || tick.apyBasePoints > maxKey) {
         maxKey = tick.apyBasePoints
       }

package/src/utilsV2.ts

@@ -5,6 +5,8 @@
  */
 import { Tick, Ticks } from "@exponent-labs/exponent-fetcher"
 
+import { isLiveTick } from "./tickTree"
+
 const SECONDS_PER_YEAR = 365 * 24 * 60 * 60
 const TICK_KEY_BASE_POINTS = 1_000_000
 const PRECISE_NUMBER_DENOM = 1_000_000_000_000_000_000n
@@ -74,7 +76,7 @@ export class TicksWrapper {
 
     // Build map from apyBasePoints -> Tick
     for (const tick of this.baseTicksTree) {
-      if (tick.apyBasePoints > 0) {
+      if (isLiveTick(tick)) {
         this.ticksByKey.set(tick.apyBasePoints, tick)
       }
     }
@@ -91,7 +93,7 @@ export class TicksWrapper {
     // In Rust, currentTick is stored as 1-based index into the ticks tree
     // We need to find the corresponding key (apyBasePoints)
     const currentTickFromArray = this.baseTicksTree[ticks.currentTick - 1]
-    if (currentTickFromArray && currentTickFromArray.apyBasePoints > 0) {
+    if (isLiveTick(currentTickFromArray)) {
       this.currentTickKey = currentTickFromArray.apyBasePoints
     } else {
       // Fallback: find tick with spot price closest to currentSpotPrice