@exponent-labs/market-three-math 0.1.8

package/src/withdrawLiquidity.ts

@@ -0,0 +1,240 @@
+import { LpPositionCLMM, MarketThree, Ticks } from "@exponent-labs/exponent-fetcher"
+
+import { getSuccessorTickByIdx } from "./utils"
+
+/**
+ * TypeScript version of project_anchor_shares_to_current_ticks from Rust
+ * Project anchor shares to current ticks, splitting as necessary based on tick splits
+ *
+ * This function handles the case where ticks have been split since the position was created.
+ * It recursively splits shares proportionally based on the spot price ranges.
+ *
+ * @param ticks - The ticks state containing the tick tree (must include lastSplitEpoch data)
+ * @param rootShares - The original share trackers to project
+ * @returns Array of projected principal shares
+ *
+ * Note: Requires TicksExtended with lastSplitEpoch and emissions data.
+ * The current exponent-fetcher deserializer would need to be updated to extract these fields.
+ */
+type ShareTracker = LpPositionCLMM["shareTrackers"][0]
+function projectAnchorSharesToCurrentTicks(ticks: Ticks, rootShares: ShareTracker[]): ShareTracker[] {
+  const SENTINEL = 0xffffffff // Sentinel value for tree traversal (matches Rust implementation)
+
+  const stack = [...rootShares] // Clone the trackers array
+  const newShares: ShareTracker[] = [] // This will hold the leaf shares
+
+  while (stack.length > 0) {
+    const principalShare = stack.pop()!
+
+    // Find the tick node for this share
+    const tickNode = ticks.ticksTree.at(principalShare.tickIdx - 1) ?? null
+
+    if (!tickNode) {
+      //? Tick node not found for tickIdx
+      continue
+    }
+
+    const lastSplitEpoch = tickNode.lastSplitEpoch
+
+    // Check if we need to split this share (if the tick has been split since this share was created)
+    if (principalShare.splitEpoch < lastSplitEpoch) {
+      const rightIndex = principalShare.rightTickIdx
+
+      if (rightIndex !== SENTINEL) {
+        // Find the successor tick (the split point)
+        const splitedIndex = getSuccessorTickByIdx(ticks, principalShare.tickIdx)
+
+        if (splitedIndex === null) {
+          //? No successor tick found for splitting
+          continue
+        }
+
+        const tickSpotPrice = tickNode.impliedRate
+        const rightTickNode = ticks.ticksTree.at(rightIndex - 1) ?? null
+        const splitedTickNode = ticks.ticksTree.at(splitedIndex - 1) ?? null
+
+        if (!rightTickNode || !splitedTickNode) {
+          //? Could not find right or split tick nodes
+          continue
+        }
+
+        // Calculate the proportions based on spot price ranges
+        const splitedFullRange = rightTickNode.impliedRate - tickSpotPrice
+        const currentSplitRange = splitedTickNode.impliedRate - tickSpotPrice
+
+        // Calculate how much LP share goes to the left portion
+        const leftShare = Math.floor(Number(principalShare.lpShare) * (currentSplitRange / splitedFullRange))
+
+        // Create new emission trackers with staged reset to 0
+        const newEmissions: ShareTracker["emissions"] = principalShare.emissions.map((tracker) => ({
+          staged: 0n,
+          lastSeenIndex: tracker.lastSeenIndex,
+        }))
+
+        // Calculate the migrated share (right portion)
+        const migratedShare = principalShare.lpShare - BigInt(leftShare)
+
+        // Update the current share to be the left portion
+        principalShare.lpShare = BigInt(leftShare)
+        principalShare.rightTickIdx = splitedIndex
+
+        // Push the right portion back onto the stack for further processing
+        stack.push({
+          tickIdx: splitedIndex,
+          rightTickIdx: rightIndex,
+          splitEpoch: principalShare.splitEpoch,
+          lpShare: migratedShare,
+          emissions: newEmissions,
+        })
+
+        // Update the split epoch to mark this share as processed
+        principalShare.splitEpoch = lastSplitEpoch
+      } else {
+        // Error: we have a split range but no right index
+        //? No right index for split range
+        continue
+      }
+    }
+
+    // Add the processed share to the result
+    newShares.push(principalShare)
+  }
+
+  // Reverse to maintain the original order (since we used a stack)
+  newShares.reverse()
+
+  return newShares
+}
+
+/**
+ * TypeScript version of update_lp_position_shares from Rust
+ * Recompute and update the LP position's share trackers to reflect current ticks state
+ *
+ * @param market - The market account containing emission indices
+ * @param ticks - The ticks state (must be TicksExtended with emission data)
+ * @param position - The LP position with share trackers to update
+ *
+ */
+function updateLpPositionShares(
+  marketEmissions: MarketThree["emissions"],
+  ticks: Ticks,
+  position: LpPositionCLMM,
+): LpPositionCLMM {
+  // Get market emission indices (last seen indices from market's emission trackers)
+  // Market has emissions.trackers array with lpShareIndex for each emission
+  const marketEmissionIndices: number[] = marketEmissions.trackers.map((tracker) => tracker.lpShareIndex)
+
+  // Project anchor shares to current ticks
+  // This handles tick splitting that may have occurred since the position was created
+  const recomputedShares = projectAnchorSharesToCurrentTicks(ticks, position.shareTrackers)
+
+  // Iterate through each share and update
+  for (const share of recomputedShares) {
+    const myShares = share.lpShare
+
+    // Find the tick node in the ticks tree
+    const tickNode = ticks.ticksTree.at(share.tickIdx - 1) ?? null
+
+    if (!tickNode) {
+      //? Tick node not found for provided tickIdx
+      continue
+    }
+
+    // Update tick emissions with market emission indices
+    // In Rust: node_mut.value.update_tick_emissions(market_emission_indices)
+    for (let i = 0; i < marketEmissionIndices.length; i++) {
+      if (tickNode.emissions[i]) {
+        tickNode.emissions[i].lastSeenIndex = marketEmissionIndices[i]
+      }
+    }
+
+    // Accrue fees and emissions when removing
+    // In Rust: share.accrue_fees_emissions_when_remove(&node_mut.value, my_shares)
+    // This updates the share's emission trackers based on the tick's emission state
+    // and the number of LP shares
+    for (let i = 0; i < share.emissions.length; i++) {
+      const shareTracker = share.emissions[i]
+      const tickTracker = tickNode.emissions[i]
+
+      if (shareTracker && tickTracker) {
+        // Calculate accrued emissions based on index difference and LP shares
+        const indexDelta = tickTracker.lastSeenIndex - shareTracker.lastSeenIndex
+        const accruedEmissions = Number(myShares) * indexDelta
+
+        // Update staged emissions
+        shareTracker.staged += BigInt(Math.floor(accruedEmissions))
+        shareTracker.lastSeenIndex = tickTracker.lastSeenIndex
+      }
+    }
+
+    // Update split epoch
+    share.splitEpoch = tickNode.lastSplitEpoch
+  }
+
+  return {
+    ...position,
+    shareTrackers: recomputedShares,
+  }
+}
+
+/**
+ * Calculate the total PT and SY amounts that would be removed from a position
+ * without actually modifying any state.
+ *
+ * TypeScript version based on Rust remove_liquidity logic
+ *
+ * @param position - The LP position to calculate removal amounts for
+ * @param ticks - The ticks data structure containing tick information
+ * @param liquidityToRemove - The amount of liquidity to remove (in L units)
+ * @returns Object with totalPtOut and totalSyOut
+ */
+function calculatePtSyRemoval(
+  position: LpPositionCLMM,
+  ticks: Ticks,
+  liquidityToRemove: bigint,
+): { totalPtOut: bigint; totalSyOut: bigint } {
+  let totalPtOut = 0n
+  let totalSyOut = 0n
+
+  for (const share of position.shareTrackers) {
+    const myShares = share.lpShare
+    const tickNode = ticks.ticksTree.at(share.tickIdx - 1) ?? null
+
+    if (!tickNode) {
+      //? Tick node not found for provided tickIdx
+      continue
+    }
+
+    const supply = tickNode.principalShareSupply
+
+    // Calculate burn shares: r = l_remove / pos.L
+    // burn_shares = my_shares * liquidity_to_remove / position.lp_balance
+    const burnShares = (myShares * liquidityToRemove) / position.lpBalance
+
+    // Calculate PT output for this tick
+    // pt_out = principal_pt * burn_shares / supply
+    const ptOut = (tickNode.principalPt * burnShares) / supply
+
+    // Calculate SY output for this tick
+    // sy_out = principal_sy * burn_shares / supply
+    const syOut = (tickNode.principalSy * burnShares) / supply
+
+    totalPtOut += ptOut
+    totalSyOut += syOut
+  }
+
+  return { totalPtOut, totalSyOut }
+}
+
+/**
+ * Returns the total PT and SY amounts that would be removed from a position
+ */
+export function getPtAndSyOnWithdrawLiquidity(
+  marketEmissions: MarketThree["emissions"],
+  ticks: Ticks,
+  position: LpPositionCLMM,
+  liquidityToRemove: bigint,
+): { totalPtOut: bigint; totalSyOut: bigint } {
+  const updatedPosition = updateLpPositionShares(marketEmissions, ticks, position)
+  return calculatePtSyRemoval(updatedPosition, ticks, liquidityToRemove)
+}

package/src/ytTrades.ts

@@ -0,0 +1,419 @@
+/**
+ * YT (Yield Token) trade simulations
+ *
+ * YT trades are multi-step operations that involve PT trades:
+ * - Buy YT: Strip SY → PT+YT, then sell PT back to pool
+ * - Sell YT: Merge PT+YT → SY, then buy PT from pool to repay
+ */
+import { bisectSearch2 } from "./bisect"
+import { simulateSwap } from "./swap"
+import { MarketThreeState, SwapDirection, SwapOutcome } from "./types"
+
+/**
+ * Helper function to convert PY to SY
+ * @param syExchangeRate - The SY exchange rate
+ * @param pyAmount - The PY (PT or YT) amount
+ * @returns The equivalent SY amount
+ */
+function pyToSy(syExchangeRate: number, pyAmount: number): number {
+  if (syExchangeRate <= 0) return 0
+  return Math.floor(pyAmount / syExchangeRate)
+}
+
+/**
+ * Helper function to convert SY to PY
+ * @param syExchangeRate - The SY exchange rate
+ * @param syAmount - The SY amount
+ * @returns The equivalent PY amount
+ */
+function syToPy(syExchangeRate: number, syAmount: number): number {
+  return Math.floor(syAmount * syExchangeRate)
+}
+
+export interface BuyYtSimulationArgs {
+  /** Amount of YT desired to buy */
+  ytOut: number
+  /** SY exchange rate */
+  syExchangeRate: number
+  /** Optional spot price limit (anti-sandwich) */
+  priceSpotLimit?: number
+}
+
+export interface BuyYtSimulationResult {
+  /** Amount of YT received */
+  ytOut: number
+  /** Net SY cost to the trader */
+  netSyCost: number
+  /** Amount of SY that needs to be stripped */
+  syToStrip: number
+  /** Amount of PT received from stripping */
+  ptFromStrip: number
+  /** Amount of SY received from selling PT */
+  syFromPtSale: number
+  /** LP fee charged */
+  lpFee: number
+  /** Protocol fee charged */
+  protocolFee: number
+  /** Final spot price after the trade */
+  finalSpotPrice: number
+}
+
+/**
+ * Simulates buying YT tokens
+ *
+ * Process:
+ * 1. Calculate how much SY to strip to get desired YT
+ * 2. Strip SY → PT + YT (PT amount ≈ YT amount)
+ * 3. Sell PT to the pool (PtToSy direction)
+ * 4. Net cost = SY stripped - SY received from PT sale
+ *
+ * @param marketState - Current market state
+ * @param args - Simulation arguments
+ * @returns Simulation result with net SY cost
+ */
+export function simulateBuyYt(marketState: MarketThreeState, args: BuyYtSimulationArgs): BuyYtSimulationResult {
+  const { ytOut, syExchangeRate, priceSpotLimit } = args
+
+  // Calculate how much SY needs to be stripped to get the desired YT
+  // Add 1 to counter-act the flooring function when converting from PY to SY
+  const syToStrip = pyToSy(syExchangeRate, ytOut) + 1
+
+  // Stripping gives approximately equal amounts of PT and YT
+  const ptFromStrip = ytOut
+
+  // Simulate selling the PT to get SY back
+  // Note: We use ytOut as the amount because PT out = YT out from the strip
+  const swapResult = simulateSwap(marketState, {
+    direction: SwapDirection.PtToSy,
+    amountIn: ytOut,
+    priceSpotLimit,
+    syExchangeRate,
+    isCurrentFlashSwap: true,
+  })
+
+  const syFromPtSale = swapResult.amountOut
+
+  // Net cost is the difference between what was stripped and what was received
+  const netSyCost = syToStrip - syFromPtSale
+
+  return {
+    ytOut,
+    netSyCost,
+    syToStrip,
+    ptFromStrip,
+    syFromPtSale,
+    lpFee: swapResult.lpFeeChargedOutToken,
+    protocolFee: swapResult.protocolFeeChargedOutToken,
+    finalSpotPrice: swapResult.finalSpotPrice,
+  }
+}
+
+export interface BuyYtWithSyInSimulationArgs {
+  /** Amount of SY to spend */
+  syIn: number
+  /** SY exchange rate */
+  syExchangeRate: number
+  /** Optional spot price limit (anti-sandwich) */
+  priceSpotLimit?: number
+}
+
+/**
+ * Simulates buying YT tokens given a SY input amount
+ *
+ * Process:
+ * 1. Strip syIn → PT + YT
+ * 2. Sell PT → get SY back (with price impact)
+ * 3. Strip SY again → more PT + YT
+ * 4. Repeat until convergence
+ * Total YT = YT₁ + YT₂ + YT₃ + ...
+ *
+ * Uses bisection search to find ytOut such that netSyCost = syIn
+ *
+ * @param marketState - Current market state
+ * @param args - Simulation arguments
+ * @returns Simulation result with calculated YT output
+ */
+export function simulateBuyYtWithSyIn(
+  marketState: MarketThreeState,
+  args: BuyYtWithSyInSimulationArgs,
+): BuyYtSimulationResult {
+  const { syIn, syExchangeRate, priceSpotLimit } = args
+
+  // Lower bound: Start very low since PT recycling allows buying much more YT than naive calculation
+  // The actual minimum depends on PT price (how much SY we get back from selling PT)
+  // If PT price is high (close to 1), we get most SY back, so we can buy much more YT
+  // Example: With 1000 SY and PT price 0.9:
+  //   - To get 5000 YT, strip 5000 SY → 5000 PT + 5000 YT
+  //   - Sell 5000 PT at 0.9 → 4500 SY back
+  //   - Net cost: 5000 - 4500 = 500 SY (way less than 1000!)
+  const minPossibleYt = 1
+
+  // Better initial upper bound estimate based on market liquidity
+  // Maximum possible YT is constrained by available PT liquidity in the market
+  const marketPtLiquidity = Number(marketState.financials.ptBalance)
+  const marketSyLiquidity = Number(marketState.financials.syBalance)
+
+  // Conservative estimate: we can't buy more YT than there's PT in the market
+  // High multiplier needed because PT recycling amplifies buying power dramatically
+  // Formula: ytOut ≈ syIn / (1 - ptPrice)
+  // Examples: PT@0.99 → 100x, PT@0.95 → 20x, PT@0.90 → 10x, PT@0.80 → 5x
+  const liquidityBasedMax = Math.min(
+    marketPtLiquidity * 0.9, // 90% of PT liquidity to be safe
+    syToPy(syExchangeRate, syIn) * 100, // 100x to handle PT prices up to 0.99
+  )
+
+  // Start with a reasonable initial guess (10x covers most realistic scenarios)
+  let maxPossibleYt = Math.min(syToPy(syExchangeRate, syIn) * 10, liquidityBasedMax)
+  let foundUpperBound = false
+  let lastValidCost = 0
+
+  // Use exponential search with better growth rate
+  for (let attempt = 0; attempt < 12; attempt++) {
+    try {
+      const syToStrip = pyToSy(syExchangeRate, maxPossibleYt) + 1
+
+      const swapResult = simulateSwap(marketState, {
+        direction: SwapDirection.PtToSy,
+        amountIn: maxPossibleYt,
+        priceSpotLimit,
+        syExchangeRate,
+        isCurrentFlashSwap: true,
+      })
+
+      const syFromPtSale = swapResult.amountOut
+      const netSyCost = syToStrip - syFromPtSale
+
+      // If this costs more than syIn, we found our upper bound
+      if (netSyCost > syIn) {
+        foundUpperBound = true
+        break
+      }
+
+      lastValidCost = netSyCost
+
+      // Use adaptive growth rate based on how far we are from target
+      const costRatio = syIn / Math.max(netSyCost, 1)
+      const growthFactor = attempt < 3 ? 2.0 : Math.min(1.5, 1 + costRatio * 0.3)
+
+      maxPossibleYt *= growthFactor
+
+      // Don't exceed liquidity constraints
+      if (maxPossibleYt > liquidityBasedMax) {
+        maxPossibleYt = liquidityBasedMax
+        foundUpperBound = true
+        break
+      }
+    } catch (error) {
+      // If simulation fails, we've exceeded market capacity
+      // Use last valid value with small buffer, ensuring it's > minPossibleYt
+      if (lastValidCost > 0) {
+        // Interpolate to find better upper bound
+        const estimatedMax = maxPossibleYt * 0.7 * (syIn / lastValidCost)
+        maxPossibleYt = Math.max(estimatedMax, minPossibleYt * 1.2)
+      } else {
+        // No valid cost yet, use a conservative upper bound
+        maxPossibleYt = Math.max(maxPossibleYt * 0.8, minPossibleYt * 1.5)
+      }
+      foundUpperBound = true
+      break
+    }
+  }
+
+  if (!foundUpperBound) {
+    throw new Error(`Could not find upper bound for YT amount. Market may have unusual price dynamics.`)
+  }
+
+  // Final safety check: ensure maxPossibleYt > minPossibleYt
+  if (maxPossibleYt <= minPossibleYt) {
+    maxPossibleYt = minPossibleYt * 2
+  }
+
+  // Use bisection search to find the ytOut that results in netSyCost = syIn
+  // Adaptive epsilon based on input size for better precision scaling
+  const adaptiveEpsilon = Math.max(0.01, syIn * 0.0001)
+
+  // Reduce max iterations since we have better bounds
+  const maxIterations = 10000
+
+  // Debug info for bounds validation
+  if (maxPossibleYt <= minPossibleYt) {
+    throw new Error(
+      `Invalid bisection bounds for buy YT. ` +
+        `Min: ${minPossibleYt}, Max: ${maxPossibleYt}, ` +
+        `SyIn: ${syIn}, SyExchangeRate: ${syExchangeRate}, ` +
+        `MarketPtBalance: ${marketPtLiquidity}, MarketSyBalance: ${marketSyLiquidity}`,
+    )
+  }
+
+  const ytOut = bisectSearch2(
+    (ytGuess: number) => {
+      // Calculate the cost for this ytGuess
+      const syToStrip = pyToSy(syExchangeRate, ytGuess) + 1
+
+      const swapResult = simulateSwap(marketState, {
+        direction: SwapDirection.PtToSy,
+        amountIn: ytGuess,
+        priceSpotLimit,
+        syExchangeRate,
+        isCurrentFlashSwap: true,
+      })
+
+      const syFromPtSale = swapResult.amountOut
+      const netSyCost = syToStrip - syFromPtSale
+
+      // Return the difference between actual cost and target syIn
+      return netSyCost - syIn
+    },
+    minPossibleYt,
+    maxPossibleYt,
+    adaptiveEpsilon,
+    maxIterations,
+  )
+
+  if (ytOut === null) {
+    throw new Error(
+      `Failed to converge on correct YT amount. ` +
+        `Search range: [${minPossibleYt}, ${maxPossibleYt}], ` +
+        `Epsilon: ${adaptiveEpsilon}`,
+    )
+  }
+
+  // Now calculate the full result with the found ytOut
+  return simulateBuyYt(marketState, {
+    ytOut,
+    syExchangeRate,
+    priceSpotLimit,
+  })
+}
+
+export interface SellYtSimulationArgs {
+  /** Amount of YT to sell */
+  ytIn: number
+  /** SY exchange rate */
+  syExchangeRate: number
+  /** Optional spot price limit (anti-sandwich) */
+  priceSpotLimit?: number
+}
+
+export interface SellYtSimulationResult {
+  /** Amount of YT sold */
+  ytIn: number
+  /** Net SY received by the trader */
+  netSyReceived: number
+  /** Amount of SY received from merging PT + YT */
+  syFromMerge: number
+  /** Amount of SY spent buying PT back */
+  sySpentOnPt: number
+  /** LP fee charged */
+  lpFee: number
+  /** Protocol fee charged */
+  protocolFee: number
+  /** Final spot price after the trade */
+  finalSpotPrice: number
+}
+
+/**
+ * Simulates selling YT tokens
+ *
+ * Process:
+ * 1. Merge PT + YT → SY (receive SY from the merge)
+ * 2. Buy PT from the pool to repay the borrowed PT (SyToPt direction)
+ * 3. Net received = SY from merge - SY spent on PT
+ *
+ * Note: The market must have at least 2x the YT amount in PT liquidity
+ * because the trader borrows PT, which is then bought back.
+ *
+ * @param marketState - Current market state
+ * @param args - Simulation arguments
+ * @returns Simulation result with net SY received
+ */
+export function simulateSellYt(marketState: MarketThreeState, args: SellYtSimulationArgs): SellYtSimulationResult {
+  const { ytIn, syExchangeRate, priceSpotLimit } = args
+
+  // Check if there's sufficient PT liquidity
+  // The market needs at least 2x the YT amount in PT
+  if (marketState.financials.ptBalance < ytIn * 2) {
+    throw new Error(
+      `Insufficient PT liquidity in the market. Required: ${ytIn * 2}, Available: ${marketState.financials.ptBalance}`,
+    )
+  }
+
+  // Merging PT + YT gives back the original SY
+  // The amount of PT needed equals ytIn (1:1 ratio)
+  const syFromMerge = pyToSy(syExchangeRate, ytIn)
+
+  const ptNeeded = ytIn
+
+  const upperBoundSwap = simulateSwap(marketState, {
+    direction: SwapDirection.SyToPt,
+    amountIn: syFromMerge,
+    priceSpotLimit,
+    syExchangeRate,
+    isCurrentFlashSwap: true,
+  })
+
+  // Check that we can buy enough PT from CLMM
+  if (upperBoundSwap.amountOut < ptNeeded) {
+    throw new Error(
+      `Cannot buy enough PT with available SY. Need ${ytIn} PT but can only afford ${upperBoundSwap.amountOut} PT`,
+    )
+  }
+
+  // Better initial bounds for bisection
+  // We know the upper bound from the check above, and we can estimate a better lower bound
+  // based on the current price
+  const estimatedLowerBound = Math.min(syFromMerge * 0.5, syFromMerge * 0.9) // Start from 50% of max, but not too close to upper
+
+  // Adaptive epsilon based on PT needed
+  const adaptiveEpsilon = Math.max(0.01, ptNeeded * 0.0001)
+
+  // Safety check: ensure lower bound is less than upper bound
+  const safeLowerBound = Math.min(estimatedLowerBound, syFromMerge * 0.95)
+  const safeUpperBound = syFromMerge
+
+  if (safeLowerBound >= safeUpperBound) {
+    throw new Error(`Invalid bisection bounds for sell YT. Lower: ${safeLowerBound}, Upper: ${safeUpperBound}`)
+  }
+
+  const syToSpend = bisectSearch2(
+    (syGuess: number) => {
+      const swapResult = simulateSwap(marketState, {
+        direction: SwapDirection.SyToPt,
+        amountIn: syGuess,
+        priceSpotLimit,
+        syExchangeRate,
+        isCurrentFlashSwap: true,
+      })
+
+      return swapResult.amountOut - ptNeeded
+    },
+    safeLowerBound,
+    safeUpperBound,
+    adaptiveEpsilon,
+    100, // Reduced iterations with better bounds
+  )
+
+  if (syToSpend === null) {
+    throw new Error("Failed to converge on correct SY amount using bisection search")
+  }
+
+  const swapResult = simulateSwap(marketState, {
+    direction: SwapDirection.SyToPt,
+    amountIn: syToSpend,
+    priceSpotLimit,
+    syExchangeRate,
+    isCurrentFlashSwap: true,
+  })
+
+  const netSyReceived = syFromMerge - swapResult.amountInConsumed
+
+  return {
+    ytIn,
+    netSyReceived,
+    syFromMerge,
+    sySpentOnPt: swapResult.amountInConsumed,
+    lpFee: swapResult.lpFeeChargedOutToken,
+    protocolFee: swapResult.protocolFeeChargedOutToken,
+    finalSpotPrice: swapResult.finalSpotPrice,
+  }
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "rootDir": "src",
+    "sourceMap": true,
+    "incremental": true /* Save .tsbuildinfo files to allow for incremental compilation of projects. */,
+    "composite": true /* Enable constraints that allow a TypeScript project to be used with project references. */,
+    "target": "ESNext" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    "module": "CommonJS" /* Specify what module code is generated. */,
+    "declaration": true /* Generate .d.ts files from TypeScript and JavaScript files in your project. */,
+    "outDir": "./build" /* Specify an output folder for all emitted files. */,
+    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  },
+  "include": ["src"],
+  "exclude": ["build", "node_modules", "**/*.test.ts"]
+}