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

package/dist/utils/index.js

@@ -1,91 +1,181 @@
 'use strict';
 
-require('../chunk-DRBRT57F.js');
-var chunkKPBCG4X2_js = require('../chunk-KPBCG4X2.js');
-var chunkXG7K4R56_js = require('../chunk-XG7K4R56.js');
-require('../chunk-KEXKKQVW.js');
+require('../chunk-WTS75RUC.js');
+var chunkMGQSQCFG_js = require('../chunk-MGQSQCFG.js');
+var chunk4HM3ERBU_js = require('../chunk-4HM3ERBU.js');
+var chunkPCNXJAU5_js = require('../chunk-PCNXJAU5.js');
+var chunkAS64GWBX_js = require('../chunk-AS64GWBX.js');
+var chunkHM25ZMO3_js = require('../chunk-HM25ZMO3.js');
+var chunkQ7YNBSVH_js = require('../chunk-Q7YNBSVH.js');
+var chunkRW37KJ77_js = require('../chunk-RW37KJ77.js');
+var chunkP7KLEPVI_js = require('../chunk-P7KLEPVI.js');
+require('../chunk-JWEXGALU.js');
+var chunkBIQQ53O2_js = require('../chunk-BIQQ53O2.js');
+require('../chunk-YYUOLM6U.js');
+require('../chunk-CVHPLURA.js');
+require('../chunk-RVFSRYI5.js');
 
 
 
+Object.defineProperty(exports, "mineTokenAddress", {
+  enumerable: true,
+  get: function () { return chunkMGQSQCFG_js.mineTokenAddress; }
+});
+Object.defineProperty(exports, "decodeBalanceDelta", {
+  enumerable: true,
+  get: function () { return chunk4HM3ERBU_js.decodeBalanceDelta; }
+});
+Object.defineProperty(exports, "computeOptimalGamma", {
+  enumerable: true,
+  get: function () { return chunkPCNXJAU5_js.computeOptimalGamma; }
+});
+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; }
+});
+Object.defineProperty(exports, "isToken0Expected", {
+  enumerable: true,
+  get: function () { return chunkHM25ZMO3_js.isToken0Expected; }
+});
+Object.defineProperty(exports, "computePoolId", {
+  enumerable: true,
+  get: function () { return chunkQ7YNBSVH_js.computePoolId; }
+});
 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; }
 });
 Object.defineProperty(exports, "MAX_SQRT_RATIO", {
   enumerable: true,
-  get: function () { return chunkXG7K4R56_js.MAX_SQRT_RATIO; }
+  get: function () { return chunkP7KLEPVI_js.MAX_SQRT_RATIO; }
 });
 Object.defineProperty(exports, "MAX_TICK", {
   enumerable: true,
-  get: function () { return chunkXG7K4R56_js.MAX_TICK; }
+  get: function () { return chunkP7KLEPVI_js.MAX_TICK; }
 });
 Object.defineProperty(exports, "MIN_SQRT_RATIO", {
   enumerable: true,
-  get: function () { return chunkXG7K4R56_js.MIN_SQRT_RATIO; }
+  get: function () { return chunkP7KLEPVI_js.MIN_SQRT_RATIO; }
 });
 Object.defineProperty(exports, "MIN_TICK", {
   enumerable: true,
-  get: function () { return chunkXG7K4R56_js.MIN_TICK; }
+  get: function () { return chunkP7KLEPVI_js.MIN_TICK; }
 });
 Object.defineProperty(exports, "Q96", {
   enumerable: true,
-  get: function () { return chunkXG7K4R56_js.Q96; }
+  get: function () { return chunkP7KLEPVI_js.Q96; }
 });
 Object.defineProperty(exports, "getNearestUsableTick", {
   enumerable: true,
-  get: function () { return chunkXG7K4R56_js.getNearestUsableTick; }
+  get: function () { return chunkP7KLEPVI_js.getNearestUsableTick; }
 });
 Object.defineProperty(exports, "getSqrtRatioAtTick", {
   enumerable: true,
-  get: function () { return chunkXG7K4R56_js.getSqrtRatioAtTick; }
+  get: function () { return chunkP7KLEPVI_js.getSqrtRatioAtTick; }
 });
 Object.defineProperty(exports, "getTickAtSqrtRatio", {
   enumerable: true,
-  get: function () { return chunkXG7K4R56_js.getTickAtSqrtRatio; }
+  get: function () { return chunkP7KLEPVI_js.getTickAtSqrtRatio; }
 });
 Object.defineProperty(exports, "priceToSqrtPriceX96", {
   enumerable: true,
-  get: function () { return chunkXG7K4R56_js.priceToSqrtPriceX96; }
+  get: function () { return chunkP7KLEPVI_js.priceToSqrtPriceX96; }
 });
 Object.defineProperty(exports, "priceToTick", {
   enumerable: true,
-  get: function () { return chunkXG7K4R56_js.priceToTick; }
+  get: function () { return chunkP7KLEPVI_js.priceToTick; }
 });
 Object.defineProperty(exports, "sqrtPriceX96ToPrice", {
   enumerable: true,
-  get: function () { return chunkXG7K4R56_js.sqrtPriceX96ToPrice; }
+  get: function () { return chunkP7KLEPVI_js.sqrtPriceX96ToPrice; }
 });
 Object.defineProperty(exports, "tickToPrice", {
   enumerable: true,
-  get: function () { return chunkXG7K4R56_js.tickToPrice; }
+  get: function () { return chunkP7KLEPVI_js.tickToPrice; }
+});
+Object.defineProperty(exports, "DEFAULT_AIRLOCK_BENEFICIARY_SHARES", {
+  enumerable: true,
+  get: function () { return chunkBIQQ53O2_js.DEFAULT_AIRLOCK_BENEFICIARY_SHARES; }
+});
+Object.defineProperty(exports, "createAirlockBeneficiary", {
+  enumerable: true,
+  get: function () { return chunkBIQQ53O2_js.createAirlockBeneficiary; }
+});
+Object.defineProperty(exports, "getAirlockBeneficiary", {
+  enumerable: true,
+  get: function () { return chunkBIQQ53O2_js.getAirlockBeneficiary; }
+});
+Object.defineProperty(exports, "getAirlockOwner", {
+  enumerable: true,
+  get: function () { return chunkBIQQ53O2_js.getAirlockOwner; }
 });
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/utils/index.mjs

@@ -1,6 +1,16 @@
-import '../chunk-CYDWEPFL.mjs';
-export { calculateFDV, calculateGamma, calculateMarketCap, calculateTickRange, calculateTokensToSell, estimatePriceAtEpoch, estimateSlippage, formatTickAsPrice } from '../chunk-AYPP5JEQ.mjs';
-export { MAX_SQRT_RATIO, MAX_TICK, MIN_SQRT_RATIO, MIN_TICK, Q96, getNearestUsableTick, getSqrtRatioAtTick, getTickAtSqrtRatio, priceToSqrtPriceX96, priceToTick, sqrtPriceX96ToPrice, tickToPrice } from '../chunk-4K5GBNQV.mjs';
-import '../chunk-LOROXNH3.mjs';
+import '../chunk-5TL5V6UX.mjs';
+export { mineTokenAddress } from '../chunk-XUE3CIJ5.mjs';
+export { decodeBalanceDelta } from '../chunk-ECD4FV3A.mjs';
+export { computeOptimalGamma } from '../chunk-MNJ5OYPE.mjs';
+export { applyTickOffsets, isToken1, marketCapRangeToTicks, marketCapRangeToTicksForCurve, marketCapToTick, marketCapToTokenPrice, ratioToTick, tickToMarketCap, tokenPriceToRatio, transformTicksForAuction, validateMarketCapParameters } from '../chunk-64AWG57M.mjs';
+export { isToken0Expected } from '../chunk-NNNCVFOH.mjs';
+export { computePoolId } from '../chunk-ZH44DHVR.mjs';
+export { calculateFDV, calculateGamma, calculateMarketCap, calculateTickRange, calculateTokensToSell, estimatePriceAtEpoch, estimateSlippage, formatTickAsPrice } from '../chunk-CLEQO6GU.mjs';
+export { MAX_SQRT_RATIO, MAX_TICK, MIN_SQRT_RATIO, MIN_TICK, Q96, getNearestUsableTick, getSqrtRatioAtTick, getTickAtSqrtRatio, priceToSqrtPriceX96, priceToTick, sqrtPriceX96ToPrice, tickToPrice } from '../chunk-KDT76YQE.mjs';
+import '../chunk-OTG75GVH.mjs';
+export { DEFAULT_AIRLOCK_BENEFICIARY_SHARES, createAirlockBeneficiary, getAirlockBeneficiary, getAirlockOwner } from '../chunk-M4WMHD3X.mjs';
+import '../chunk-AW3WR2D3.mjs';
+import '../chunk-FPAI4QYW.mjs';
+import '../chunk-4TROGENW.mjs';
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map

package/dist/utils/isToken0Expected.d.mts

@@ -0,0 +1,13 @@
+import { Address } from 'viem';
+
+/**
+ * Determine token ordering based on numeraire address.
+ * Mining will find a salt such that token address is correctly ordered relative to numeraire.
+ * For numeraires > halfMaxUint160, token must be token0 (smaller address)
+ * For all other cases, token should be token1 (larger address)
+ * @param numeraire - Address of numeraire token
+ * @returns Whether base token address is expected to be generated as token0
+ */
+declare function isToken0Expected(numeraire: Address): boolean;
+
+export { isToken0Expected };

package/dist/utils/isToken0Expected.d.ts

@@ -0,0 +1,13 @@
+import { Address } from 'viem';
+
+/**
+ * Determine token ordering based on numeraire address.
+ * Mining will find a salt such that token address is correctly ordered relative to numeraire.
+ * For numeraires > halfMaxUint160, token must be token0 (smaller address)
+ * For all other cases, token should be token1 (larger address)
+ * @param numeraire - Address of numeraire token
+ * @returns Whether base token address is expected to be generated as token0
+ */
+declare function isToken0Expected(numeraire: Address): boolean;
+
+export { isToken0Expected };

package/dist/utils/isToken0Expected.js

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

package/dist/utils/isToken0Expected.js.map

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

package/dist/utils/isToken0Expected.mjs

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

package/dist/utils/isToken0Expected.mjs.map

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

package/dist/utils/marketCapHelpers.d.mts

@@ -0,0 +1,309 @@
+import { Address } from 'viem';
+import { MarketCapRange, MarketCapValidationResult } from '../types.mjs';
+import 'viem/chains';
+import '../addresses.mjs';
+
+/**
+ * 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 };