@whetstone-research/doppler-sdk 0.0.1-alpha.8 → 0.0.1

package/dist/utils/marketCapHelpers.d.ts

@@ -0,0 +1,309 @@
+import { Address } from 'viem';
+import { MarketCapRange, MarketCapValidationResult } from '../types.js';
+import 'viem/chains';
+import '../addresses.js';
+
+/**
+ * Market cap conversion utilities for token launches
+ *
+ * These utilities convert between market cap (USD) and Uniswap ticks
+ * following the mathematical relationship:
+ *
+ *   Market Cap (USD) → Token Price (USD) → Ratio (numeraire/token) → Tick
+ *
+ * Based on reference implementation: plan/priceMultiCurve.py
+ */
+
+/**
+ * Convert market cap to token price
+ *
+ * @param marketCapUSD - Market capitalization in USD
+ * @param tokenSupply - Total token supply (as bigint with decimals, e.g., parseEther('1000000000'))
+ * @param tokenDecimals - Token decimals (default: 18)
+ * @returns Price of one token in USD
+ *
+ * @example
+ * ```ts
+ * // $1M market cap with 1B tokens (18 decimals)
+ * const price = marketCapToTokenPrice(1_000_000, parseEther('1000000000'))
+ * // Returns: 0.001 (each token is worth $0.001)
+ * ```
+ */
+declare function marketCapToTokenPrice(marketCapUSD: number, tokenSupply: bigint, tokenDecimals?: number): number;
+/**
+ * Convert token price to price ratio (numeraire per token)
+ *
+ * @param tokenPriceUSD - Price of one token in USD
+ * @param numerairePriceUSD - Price of numeraire (e.g., ETH) in USD
+ * @param tokenDecimals - Token decimals (default: 18)
+ * @param numeraireDecimals - Numeraire decimals (default: 18)
+ * @returns Price ratio adjusted for decimals
+ *
+ * @example
+ * ```ts
+ * // Token at $0.001, ETH at $3000, both 18 decimals
+ * const ratio = tokenPriceToRatio(0.001, 3000, 18, 18)
+ * // Returns: 3,000,000 (3M ETH wei per token wei at this ratio)
+ * ```
+ */
+declare function tokenPriceToRatio(tokenPriceUSD: number, numerairePriceUSD: number, tokenDecimals?: number, numeraireDecimals?: number): number;
+/**
+ * Convert ratio to tick using Uniswap's formula: tick = log(ratio) / log(1.0001)
+ *
+ * @param ratio - Price ratio (must be positive)
+ * @returns Raw tick value (before spacing adjustment)
+ *
+ * @example
+ * ```ts
+ * ratioToTick(1)       // Returns: 0
+ * ratioToTick(1.0001)  // Returns: ~1
+ * ratioToTick(Math.pow(1.0001, 1000)) // Returns: ~1000
+ * ```
+ */
+declare function ratioToTick(ratio: number): number;
+/**
+ * Determine if the new token will be token1 in the Uniswap pair
+ *
+ * Uniswap orders tokens by address (token0 < token1 in hex comparison).
+ * This affects how ticks are interpreted for price calculations.
+ *
+ * @param tokenAddress - Address of the new token
+ * @param numeraireAddress - Address of the numeraire (e.g., WETH)
+ * @returns true if token will be token1, false if token0
+ *
+ * @example
+ * ```ts
+ * isToken1('0xB000...', '0xA000...') // true (B > A)
+ * isToken1('0xA000...', '0xB000...') // false (A < B)
+ * ```
+ */
+declare function isToken1(tokenAddress: string, numeraireAddress: string): boolean;
+/**
+ * Complete conversion from market cap to usable tick
+ *
+ * This is the main entry point combining all conversion steps:
+ * 1. Market cap → Token price
+ * 2. Token price → Ratio
+ * 3. Ratio → Raw tick
+ * 4. Raw tick → Nearest usable tick (aligned to spacing)
+ * 5. Handle token ordering (negate if token is token1)
+ *
+ * **Important**: The returned tick includes token ordering adjustment.
+ * When the token is token1 (determined from numeraire address), the tick is NEGATED:
+ * - Higher market cap → smaller (more negative) tick
+ * - Lower market cap → larger (less negative) tick
+ *
+ * Builders apply additional transformations based on auction type.
+ * See builder implementations for auction-specific tick conventions.
+ *
+ * @param marketCapUSD - Target market cap in USD
+ * @param tokenSupply - Total token supply (with decimals, as bigint)
+ * @param numerairePriceUSD - Price of numeraire in USD (e.g., ETH = 3000)
+ * @param tokenDecimals - Token decimals (default: 18)
+ * @param numeraireDecimals - Numeraire decimals (default: 18)
+ * @param tickSpacing - Tick spacing of the pool (e.g., 60, 100)
+ * @param numeraire - Address of the numeraire token (e.g., WETH). Used to determine token ordering.
+ * @returns Nearest usable tick (negated when token is token1)
+ *
+ * @throws Error if calculated tick is out of bounds [-887272, 887272]
+ *
+ * @example
+ * ```ts
+ * // With WETH numeraire on Base:
+ * const tick = marketCapToTick(
+ *   1_000_000,             // $1M market cap
+ *   parseEther('1000000000'), // 1B tokens
+ *   3000,                  // ETH = $3000
+ *   18, 18,                // both 18 decimals
+ *   60,                    // tick spacing
+ *   '0x4200000000000000000000000000000000000006' // WETH address
+ * )
+ * // Returns negative tick (e.g., -149100) because token will be token1
+ * ```
+ */
+declare function marketCapToTick(marketCapUSD: number, tokenSupply: bigint, numerairePriceUSD: number, tokenDecimals: number | undefined, numeraireDecimals: number | undefined, tickSpacing: number, numeraire: Address): number;
+/**
+ * Convert a market cap range to tick range
+ *
+ * Used for V3 Static Auctions and V4 Dynamic Auctions where you need
+ * a start and end tick for the bonding curve.
+ *
+ * **Important**: This function applies token ordering via marketCapToTick
+ * (negates ticks when token is token1), then normalizes so startTick < endTick.
+ *
+ * Due to the negation + normalization:
+ * - When token is token1: both ticks are NEGATIVE
+ *   - startTick = more negative (corresponds to LOWER market cap)
+ *   - endTick = less negative (corresponds to HIGHER market cap)
+ * - When token is token0: both ticks are POSITIVE
+ *   - startTick = smaller positive (corresponds to LOWER market cap)
+ *   - endTick = larger positive (corresponds to HIGHER market cap)
+ *
+ * Builders apply additional transformations based on auction type semantics.
+ * See builder implementations for auction-specific tick handling.
+ *
+ * @param marketCapRange - Start and end market caps in USD (start < end required)
+ * @param tokenSupply - Total token supply (with decimals)
+ * @param numerairePriceUSD - Price of numeraire in USD
+ * @param tokenDecimals - Token decimals (default: 18)
+ * @param numeraireDecimals - Numeraire decimals (default: 18)
+ * @param tickSpacing - Tick spacing
+ * @param numeraire - Address of the numeraire token. Used to determine token ordering.
+ * @returns Object with startTick and endTick (startTick < endTick numerically)
+ *
+ * @throws Error if start >= end market cap or if ticks are out of bounds
+ *
+ * @example
+ * ```ts
+ * // With WETH numeraire on Base:
+ * const { startTick, endTick } = marketCapRangeToTicks(
+ *   { start: 500_000, end: 50_000_000 },  // $500k → $50M
+ *   parseEther('1000000000'),
+ *   3000,
+ *   18, 18,
+ *   60,
+ *   '0x4200000000000000000000000000000000000006' // WETH address
+ * )
+ * // Returns: startTick=-156080 (500k), endTick=-110020 (50M)
+ * // Note: startTick < endTick, but startTick corresponds to LOWER market cap
+ * ```
+ */
+declare function marketCapRangeToTicks(marketCapRange: MarketCapRange, tokenSupply: bigint, numerairePriceUSD: number, tokenDecimals: number | undefined, numeraireDecimals: number | undefined, tickSpacing: number, numeraire: Address): {
+    startTick: number;
+    endTick: number;
+};
+/**
+ * Transform ticks from marketCapRangeToTicks format to auction contract format.
+ *
+ * For range-based auctions (Static V3, Dynamic V4), the contracts expect ticks
+ * in a specific format based on token ordering. This function handles the
+ * negation and swapping required when the token is token1.
+ *
+ * @param rawStartTick - Start tick from marketCapRangeToTicks (lower market cap)
+ * @param rawEndTick - End tick from marketCapRangeToTicks (higher market cap)
+ * @param numeraire - Address of the numeraire token. Used to determine token ordering.
+ * @returns Transformed ticks ready for auction contract
+ *
+ * @example
+ * ```ts
+ * const { startTick: raw1, endTick: raw2 } = marketCapRangeToTicks(...)
+ * const { startTick, endTick } = transformTicksForAuction(raw1, raw2, WETH_ADDRESS)
+ * ```
+ */
+declare function transformTicksForAuction(rawStartTick: number, rawEndTick: number, numeraire: Address): {
+    startTick: number;
+    endTick: number;
+};
+/**
+ * Apply curvature offsets to a peg tick for Multicurve positions
+ *
+ * Multicurve positions are defined relative to a "peg" tick (starting market cap).
+ * Offsets define how far above/below the peg each curve extends.
+ *
+ * Token ordering (determined from numeraire address) affects how offsets are applied:
+ * - token1: tickLower = pegTick + offsetLower, tickUpper = pegTick + offsetUpper
+ * - token0: tickLower = pegTick - offsetUpper, tickUpper = pegTick - offsetLower
+ *
+ * @param pegTick - Base tick calculated from starting market cap
+ * @param offsetLower - Lower offset in ticks (distance from peg)
+ * @param offsetUpper - Upper offset in ticks (distance from peg)
+ * @param numeraire - Address of the numeraire token. Used to determine token ordering.
+ * @returns Tick range with offsets applied
+ *
+ * @example
+ * ```ts
+ * // Peg at -200000, curve from peg to 10000 ticks above (WETH numeraire)
+ * const { tickLower, tickUpper } = applyTickOffsets(
+ *   -200000, 0, 10000,
+ *   '0x4200000000000000000000000000000000000006'
+ * )
+ * // Returns: { tickLower: -200000, tickUpper: -190000 }
+ * ```
+ */
+declare function applyTickOffsets(pegTick: number, offsetLower: number, offsetUpper: number, numeraire: Address): {
+    tickLower: number;
+    tickUpper: number;
+};
+/**
+ * Convert a market cap range to tick range for Multicurve curves.
+ *
+ * Unlike range-based auctions, Multicurve curves use ticks directly without
+ * the negate-and-swap transformation. This function converts market cap
+ * bounds to the appropriate tick bounds based on token ordering.
+ *
+ * @param marketCapLower - Lower market cap bound in USD
+ * @param marketCapUpper - Upper market cap bound in USD
+ * @param tokenSupply - Total token supply (with decimals)
+ * @param numerairePriceUSD - Price of numeraire in USD
+ * @param tokenDecimals - Token decimals (default: 18)
+ * @param numeraireDecimals - Numeraire decimals (default: 18)
+ * @param tickSpacing - Tick spacing
+ * @param numeraire - Address of the numeraire token
+ * @returns Tick range { tickLower, tickUpper } where tickLower < tickUpper
+ *
+ * @example
+ * ```ts
+ * const { tickLower, tickUpper } = marketCapRangeToTicksForCurve(
+ *   500_000,    // $500k lower
+ *   1_000_000,  // $1M upper
+ *   parseEther('1000000000'),
+ *   3000,
+ *   18, 18,
+ *   60,
+ *   WETH_ADDRESS
+ * )
+ * ```
+ */
+declare function marketCapRangeToTicksForCurve(marketCapLower: number, marketCapUpper: number, tokenSupply: bigint, numerairePriceUSD: number, tokenDecimals: number | undefined, numeraireDecimals: number | undefined, tickSpacing: number, numeraire: Address): {
+    tickLower: number;
+    tickUpper: number;
+};
+/**
+ * Validate market cap parameters and return warnings for unusual values
+ *
+ * This doesn't prevent execution but helps catch potential mistakes:
+ * - Very small market caps (< $1,000)
+ * - Very large market caps (> $1 trillion)
+ * - Extreme token prices (< $0.000001 or > $1M)
+ *
+ * @param marketCap - Market cap value to validate
+ * @param tokenSupply - Token supply (with decimals)
+ * @param tokenDecimals - Token decimals (default: 18)
+ * @returns Validation result with warnings array
+ *
+ * @example
+ * ```ts
+ * const result = validateMarketCapParameters(500, parseEther('1000000'))
+ * if (result.warnings.length > 0) {
+ *   console.warn('Warnings:', result.warnings)
+ * }
+ * ```
+ */
+declare function validateMarketCapParameters(marketCap: number, tokenSupply: bigint, tokenDecimals?: number): MarketCapValidationResult;
+/**
+ * Calculate market cap from a tick (reverse conversion)
+ *
+ * Useful for displaying what market cap a given tick represents.
+ *
+ * @param tick - Uniswap tick value
+ * @param tokenSupply - Total token supply (with decimals)
+ * @param numerairePriceUSD - Price of numeraire in USD
+ * @param tokenDecimals - Token decimals (default: 18)
+ * @param numeraireDecimals - Numeraire decimals (default: 18)
+ * @param numeraire - Address of the numeraire token. Used to determine token ordering.
+ * @returns Market cap in USD
+ *
+ * @example
+ * ```ts
+ * const marketCap = tickToMarketCap(
+ *   -192100,
+ *   parseEther('1000000000'),
+ *   3000,
+ *   18, 18,
+ *   '0x4200000000000000000000000000000000000006' // WETH address
+ * )
+ * ```
+ */
+declare function tickToMarketCap(tick: number, tokenSupply: bigint, numerairePriceUSD: number, tokenDecimals: number | undefined, numeraireDecimals: number | undefined, numeraire: Address): number;
+
+export { MarketCapRange, MarketCapValidationResult, applyTickOffsets, isToken1, marketCapRangeToTicks, marketCapRangeToTicksForCurve, marketCapToTick, marketCapToTokenPrice, ratioToTick, tickToMarketCap, tokenPriceToRatio, transformTicksForAuction, validateMarketCapParameters };

package/dist/utils/marketCapHelpers.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var chunkAS64GWBX_js = require('../chunk-AS64GWBX.js');
+require('../chunk-HM25ZMO3.js');
+require('../chunk-P7KLEPVI.js');
+
+
+
+Object.defineProperty(exports, "applyTickOffsets", {
+  enumerable: true,
+  get: function () { return chunkAS64GWBX_js.applyTickOffsets; }
+});
+Object.defineProperty(exports, "isToken1", {
+  enumerable: true,
+  get: function () { return chunkAS64GWBX_js.isToken1; }
+});
+Object.defineProperty(exports, "marketCapRangeToTicks", {
+  enumerable: true,
+  get: function () { return chunkAS64GWBX_js.marketCapRangeToTicks; }
+});
+Object.defineProperty(exports, "marketCapRangeToTicksForCurve", {
+  enumerable: true,
+  get: function () { return chunkAS64GWBX_js.marketCapRangeToTicksForCurve; }
+});
+Object.defineProperty(exports, "marketCapToTick", {
+  enumerable: true,
+  get: function () { return chunkAS64GWBX_js.marketCapToTick; }
+});
+Object.defineProperty(exports, "marketCapToTokenPrice", {
+  enumerable: true,
+  get: function () { return chunkAS64GWBX_js.marketCapToTokenPrice; }
+});
+Object.defineProperty(exports, "ratioToTick", {
+  enumerable: true,
+  get: function () { return chunkAS64GWBX_js.ratioToTick; }
+});
+Object.defineProperty(exports, "tickToMarketCap", {
+  enumerable: true,
+  get: function () { return chunkAS64GWBX_js.tickToMarketCap; }
+});
+Object.defineProperty(exports, "tokenPriceToRatio", {
+  enumerable: true,
+  get: function () { return chunkAS64GWBX_js.tokenPriceToRatio; }
+});
+Object.defineProperty(exports, "transformTicksForAuction", {
+  enumerable: true,
+  get: function () { return chunkAS64GWBX_js.transformTicksForAuction; }
+});
+Object.defineProperty(exports, "validateMarketCapParameters", {
+  enumerable: true,
+  get: function () { return chunkAS64GWBX_js.validateMarketCapParameters; }
+});
+//# sourceMappingURL=marketCapHelpers.js.map
+//# sourceMappingURL=marketCapHelpers.js.map

package/dist/utils/marketCapHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"marketCapHelpers.js"}

package/dist/utils/marketCapHelpers.mjs

@@ -0,0 +1,5 @@
+export { applyTickOffsets, isToken1, marketCapRangeToTicks, marketCapRangeToTicksForCurve, marketCapToTick, marketCapToTokenPrice, ratioToTick, tickToMarketCap, tokenPriceToRatio, transformTicksForAuction, validateMarketCapParameters } from '../chunk-64AWG57M.mjs';
+import '../chunk-NNNCVFOH.mjs';
+import '../chunk-KDT76YQE.mjs';
+//# sourceMappingURL=marketCapHelpers.mjs.map
+//# sourceMappingURL=marketCapHelpers.mjs.map

package/dist/utils/marketCapHelpers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"marketCapHelpers.mjs"}

package/dist/utils/poolKey.d.mts

@@ -0,0 +1,17 @@
+import { Hex } from 'viem';
+import { V4PoolKey } from '../types.mjs';
+import 'viem/chains';
+import '../addresses.mjs';
+
+/**
+ * Computes the PoolId (bytes32) from a V4 PoolKey
+ *
+ * In Uniswap V4, a PoolId is computed as keccak256(abi.encode(poolKey))
+ * where poolKey contains: currency0, currency1, fee, tickSpacing, hooks
+ *
+ * @param poolKey - The V4 pool key containing currency0, currency1, fee, tickSpacing, and hooks
+ * @returns The computed PoolId as a bytes32 hex string
+ */
+declare function computePoolId(poolKey: V4PoolKey): Hex;
+
+export { computePoolId };

package/dist/utils/poolKey.d.ts

@@ -0,0 +1,17 @@
+import { Hex } from 'viem';
+import { V4PoolKey } from '../types.js';
+import 'viem/chains';
+import '../addresses.js';
+
+/**
+ * Computes the PoolId (bytes32) from a V4 PoolKey
+ *
+ * In Uniswap V4, a PoolId is computed as keccak256(abi.encode(poolKey))
+ * where poolKey contains: currency0, currency1, fee, tickSpacing, hooks
+ *
+ * @param poolKey - The V4 pool key containing currency0, currency1, fee, tickSpacing, and hooks
+ * @returns The computed PoolId as a bytes32 hex string
+ */
+declare function computePoolId(poolKey: V4PoolKey): Hex;
+
+export { computePoolId };

package/dist/utils/poolKey.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunkQ7YNBSVH_js = require('../chunk-Q7YNBSVH.js');
+
+
+
+Object.defineProperty(exports, "computePoolId", {
+  enumerable: true,
+  get: function () { return chunkQ7YNBSVH_js.computePoolId; }
+});
+//# sourceMappingURL=poolKey.js.map
+//# sourceMappingURL=poolKey.js.map

package/dist/utils/poolKey.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"poolKey.js"}

package/dist/utils/poolKey.mjs

@@ -0,0 +1,3 @@
+export { computePoolId } from '../chunk-ZH44DHVR.mjs';
+//# sourceMappingURL=poolKey.mjs.map
+//# sourceMappingURL=poolKey.mjs.map

package/dist/utils/poolKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"poolKey.mjs"}

package/dist/utils/priceHelpers.d.mts

@@ -25,11 +25,11 @@ declare function calculateTokensToSell(targetRaiseETH: number, avgPricePerToken:
  * Calculate gamma for dynamic auctions
  * @param startTick Starting tick
  * @param endTick Ending tick
- * @param durationDays Duration in days
- * @param epochLengthHours Epoch length in hours
+ * @param duration Duration in seconds
+ * @param epochLength Epoch length in seconds
  * @returns Gamma value
  */
-declare function calculateGamma(startTick: number, endTick: number, durationDays: number, epochLengthHours: number): number;
+declare function calculateGamma(startTick: number, endTick: number, duration: number, epochLength: number): number;
 /**
  * Estimate the price at a specific epoch in a dynamic auction
  * @param startTick Starting tick

package/dist/utils/priceHelpers.d.ts

@@ -25,11 +25,11 @@ declare function calculateTokensToSell(targetRaiseETH: number, avgPricePerToken:
  * Calculate gamma for dynamic auctions
  * @param startTick Starting tick
  * @param endTick Ending tick
- * @param durationDays Duration in days
- * @param epochLengthHours Epoch length in hours
+ * @param duration Duration in seconds
+ * @param epochLength Epoch length in seconds
  * @returns Gamma value
  */
-declare function calculateGamma(startTick: number, endTick: number, durationDays: number, epochLengthHours: number): number;
+declare function calculateGamma(startTick: number, endTick: number, duration: number, epochLength: number): number;
 /**
  * Estimate the price at a specific epoch in a dynamic auction
  * @param startTick Starting tick

package/dist/utils/priceHelpers.js

@@ -1,42 +1,41 @@
 'use strict';
 
-var chunkKPBCG4X2_js = require('../chunk-KPBCG4X2.js');
-require('../chunk-XG7K4R56.js');
-require('../chunk-KEXKKQVW.js');
+var chunkRW37KJ77_js = require('../chunk-RW37KJ77.js');
+require('../chunk-P7KLEPVI.js');
 
 
 
 Object.defineProperty(exports, "calculateFDV", {
   enumerable: true,
-  get: function () { return chunkKPBCG4X2_js.calculateFDV; }
+  get: function () { return chunkRW37KJ77_js.calculateFDV; }
 });
 Object.defineProperty(exports, "calculateGamma", {
   enumerable: true,
-  get: function () { return chunkKPBCG4X2_js.calculateGamma; }
+  get: function () { return chunkRW37KJ77_js.calculateGamma; }
 });
 Object.defineProperty(exports, "calculateMarketCap", {
   enumerable: true,
-  get: function () { return chunkKPBCG4X2_js.calculateMarketCap; }
+  get: function () { return chunkRW37KJ77_js.calculateMarketCap; }
 });
 Object.defineProperty(exports, "calculateTickRange", {
   enumerable: true,
-  get: function () { return chunkKPBCG4X2_js.calculateTickRange; }
+  get: function () { return chunkRW37KJ77_js.calculateTickRange; }
 });
 Object.defineProperty(exports, "calculateTokensToSell", {
   enumerable: true,
-  get: function () { return chunkKPBCG4X2_js.calculateTokensToSell; }
+  get: function () { return chunkRW37KJ77_js.calculateTokensToSell; }
 });
 Object.defineProperty(exports, "estimatePriceAtEpoch", {
   enumerable: true,
-  get: function () { return chunkKPBCG4X2_js.estimatePriceAtEpoch; }
+  get: function () { return chunkRW37KJ77_js.estimatePriceAtEpoch; }
 });
 Object.defineProperty(exports, "estimateSlippage", {
   enumerable: true,
-  get: function () { return chunkKPBCG4X2_js.estimateSlippage; }
+  get: function () { return chunkRW37KJ77_js.estimateSlippage; }
 });
 Object.defineProperty(exports, "formatTickAsPrice", {
   enumerable: true,
-  get: function () { return chunkKPBCG4X2_js.formatTickAsPrice; }
+  get: function () { return chunkRW37KJ77_js.formatTickAsPrice; }
 });
 //# sourceMappingURL=priceHelpers.js.map
 //# sourceMappingURL=priceHelpers.js.map

package/dist/utils/priceHelpers.mjs

@@ -1,5 +1,4 @@
-export { calculateFDV, calculateGamma, calculateMarketCap, calculateTickRange, calculateTokensToSell, estimatePriceAtEpoch, estimateSlippage, formatTickAsPrice } from '../chunk-AYPP5JEQ.mjs';
-import '../chunk-4K5GBNQV.mjs';
-import '../chunk-LOROXNH3.mjs';
+export { calculateFDV, calculateGamma, calculateMarketCap, calculateTickRange, calculateTokensToSell, estimatePriceAtEpoch, estimateSlippage, formatTickAsPrice } from '../chunk-CLEQO6GU.mjs';
+import '../chunk-KDT76YQE.mjs';
 //# sourceMappingURL=priceHelpers.mjs.map
 //# sourceMappingURL=priceHelpers.mjs.map

package/dist/utils/tickMath.d.mts

@@ -8,6 +8,7 @@ declare const MAX_TICK = 887272;
 declare const MIN_SQRT_RATIO = 4295128739n;
 declare const MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342n;
 declare const Q96: bigint;
+declare const Q192: bigint;
 /**
  * Get the sqrt ratio at a given tick
  * @param tick The tick value
@@ -16,12 +17,16 @@ declare const Q96: bigint;
 declare function getSqrtRatioAtTick(tick: number): bigint;
 /**
  * Get the tick at a given sqrt ratio
+ * Based on Uniswap v3 TickMath.sol with corrected BigInt handling
+ *
  * @param sqrtRatioX96 The sqrt price as a Q64.96 fixed point number
  * @returns The tick value
  */
 declare function getTickAtSqrtRatio(sqrtRatioX96: bigint): number;
 /**
  * Convert sqrtPriceX96 to a human-readable price
+ * Uses BigInt arithmetic throughout to avoid precision loss with Q96
+ *
  * @param sqrtPriceX96 The sqrt price as a Q64.96 fixed point number
  * @param decimals0 Decimals of token0
  * @param decimals1 Decimals of token1
@@ -31,6 +36,8 @@ declare function getTickAtSqrtRatio(sqrtRatioX96: bigint): number;
 declare function sqrtPriceX96ToPrice(sqrtPriceX96: bigint, decimals0: number, decimals1: number, token0IsBase?: boolean): number;
 /**
  * Convert a human-readable price to sqrtPriceX96
+ * Uses BigInt arithmetic throughout to avoid precision loss with Q96
+ *
  * @param price The price (token1/token0)
  * @param decimals0 Decimals of token0
  * @param decimals1 Decimals of token1
@@ -62,4 +69,4 @@ declare function priceToTick(price: number, decimals0: number, decimals1: number
  */
 declare function getNearestUsableTick(tick: number, tickSpacing: number): number;
 
-export { MAX_SQRT_RATIO, MAX_TICK, MIN_SQRT_RATIO, MIN_TICK, Q96, getNearestUsableTick, getSqrtRatioAtTick, getTickAtSqrtRatio, priceToSqrtPriceX96, priceToTick, sqrtPriceX96ToPrice, tickToPrice };
+export { MAX_SQRT_RATIO, MAX_TICK, MIN_SQRT_RATIO, MIN_TICK, Q192, Q96, getNearestUsableTick, getSqrtRatioAtTick, getTickAtSqrtRatio, priceToSqrtPriceX96, priceToTick, sqrtPriceX96ToPrice, tickToPrice };

package/dist/utils/tickMath.d.ts

@@ -8,6 +8,7 @@ declare const MAX_TICK = 887272;
 declare const MIN_SQRT_RATIO = 4295128739n;
 declare const MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342n;
 declare const Q96: bigint;
+declare const Q192: bigint;
 /**
  * Get the sqrt ratio at a given tick
  * @param tick The tick value
@@ -16,12 +17,16 @@ declare const Q96: bigint;
 declare function getSqrtRatioAtTick(tick: number): bigint;
 /**
  * Get the tick at a given sqrt ratio
+ * Based on Uniswap v3 TickMath.sol with corrected BigInt handling
+ *
  * @param sqrtRatioX96 The sqrt price as a Q64.96 fixed point number
  * @returns The tick value
  */
 declare function getTickAtSqrtRatio(sqrtRatioX96: bigint): number;
 /**
  * Convert sqrtPriceX96 to a human-readable price
+ * Uses BigInt arithmetic throughout to avoid precision loss with Q96
+ *
  * @param sqrtPriceX96 The sqrt price as a Q64.96 fixed point number
  * @param decimals0 Decimals of token0
  * @param decimals1 Decimals of token1
@@ -31,6 +36,8 @@ declare function getTickAtSqrtRatio(sqrtRatioX96: bigint): number;
 declare function sqrtPriceX96ToPrice(sqrtPriceX96: bigint, decimals0: number, decimals1: number, token0IsBase?: boolean): number;
 /**
  * Convert a human-readable price to sqrtPriceX96
+ * Uses BigInt arithmetic throughout to avoid precision loss with Q96
+ *
  * @param price The price (token1/token0)
  * @param decimals0 Decimals of token0
  * @param decimals1 Decimals of token1
@@ -62,4 +69,4 @@ declare function priceToTick(price: number, decimals0: number, decimals1: number
  */
 declare function getNearestUsableTick(tick: number, tickSpacing: number): number;
 
-export { MAX_SQRT_RATIO, MAX_TICK, MIN_SQRT_RATIO, MIN_TICK, Q96, getNearestUsableTick, getSqrtRatioAtTick, getTickAtSqrtRatio, priceToSqrtPriceX96, priceToTick, sqrtPriceX96ToPrice, tickToPrice };
+export { MAX_SQRT_RATIO, MAX_TICK, MIN_SQRT_RATIO, MIN_TICK, Q192, Q96, getNearestUsableTick, getSqrtRatioAtTick, getTickAtSqrtRatio, priceToSqrtPriceX96, priceToTick, sqrtPriceX96ToPrice, tickToPrice };