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

package/dist/types.d.ts

@@ -1,5 +1,9 @@
-import { PublicClient, WalletClient, Address } from 'viem';
+import { base, baseSepolia, ink, unichain } from 'viem/chains';
+import { SupportedChainId } from './addresses.js';
+import { WalletClient, Address } from 'viem';
 
+type SupportedChain = typeof base | typeof baseSepolia | typeof ink | typeof unichain | typeof baseSepolia;
+type SupportedPublicClient = unknown;
 interface StandardTokenConfig {
     type?: 'standard';
     name: string;
@@ -26,7 +30,7 @@ interface StaticPoolConfig {
     fee: number;
     numPositions?: number;
     maxShareToBeSold?: bigint;
-    lockableBeneficiaries?: LockableBeneficiaryData[];
+    beneficiaries?: BeneficiaryData[];
 }
 interface DynamicAuctionConfig {
     duration: number;
@@ -41,21 +45,29 @@ interface DynamicAuctionConfig {
 interface VestingConfig {
     duration: number;
     cliffDuration: number;
+    recipients?: Address[];
+    amounts?: bigint[];
 }
-interface GovernanceConfig {
-    initialVotingDelay?: number;
-    initialVotingPeriod?: number;
-    initialProposalThreshold?: bigint;
-}
-interface NoOpGovernance {
-    noOp: true;
+declare const NO_OP_ENABLED_CHAIN_IDS: readonly [8453, 84532, 130, 1301, 10143, 143];
+type NoOpEnabledChainId = (typeof NO_OP_ENABLED_CHAIN_IDS)[number];
+/**
+ * Check if a chain supports no-op governance
+ */
+declare function isNoOpEnabledChain(chainId: number): chainId is NoOpEnabledChainId;
+type GovernanceDefault = {
+    type: 'default';
+};
+interface GovernanceCustom {
+    type: 'custom';
+    initialVotingDelay: number;
+    initialVotingPeriod: number;
+    initialProposalThreshold: bigint;
 }
-type GovernanceOption = GovernanceConfig | NoOpGovernance;
+type GovernanceNoOp = {
+    type: 'noOp';
+};
+type GovernanceOption<C extends SupportedChainId> = GovernanceDefault | GovernanceCustom | (C extends NoOpEnabledChainId ? GovernanceNoOp : never);
 interface BeneficiaryData {
-    address: Address;
-    percentage: number;
-}
-interface LockableBeneficiaryData {
     beneficiary: Address;
     shares: bigint;
 }
@@ -74,6 +86,15 @@ interface LockablePoolState {
     totalTokensOnBondingCurve: bigint;
     status: LockablePoolStatus;
 }
+interface MulticurvePoolState {
+    asset: Address;
+    numeraire: Address;
+    fee: number;
+    tickSpacing: number;
+    status: LockablePoolStatus;
+    poolKey: V4PoolKey;
+    farTick: number;
+}
 type MigrationConfig = {
     type: 'uniswapV2';
 } | {
@@ -84,22 +105,26 @@ type MigrationConfig = {
     type: 'uniswapV4';
     fee: number;
     tickSpacing: number;
-    streamableFees: {
+    streamableFees?: {
         lockDuration: number;
         beneficiaries: BeneficiaryData[];
     };
+} | {
+    type: 'noOp';
 };
-interface CreateStaticAuctionParams {
+interface CreateStaticAuctionParams<C extends SupportedChainId = SupportedChainId> {
     token: TokenConfig;
     sale: SaleConfig;
     pool: StaticPoolConfig;
     vesting?: VestingConfig;
-    governance: GovernanceOption;
+    governance: GovernanceOption<C>;
     migration: MigrationConfig;
     integrator?: Address;
     userAddress: Address;
+    modules?: ModuleAddressOverrides;
+    gas?: bigint;
 }
-interface CreateDynamicAuctionParams {
+interface CreateDynamicAuctionParams<C extends SupportedChainId = SupportedChainId> {
     token: TokenConfig;
     sale: SaleConfig;
     auction: DynamicAuctionConfig;
@@ -108,12 +133,14 @@ interface CreateDynamicAuctionParams {
         tickSpacing: number;
     };
     vesting?: VestingConfig;
-    governance: GovernanceOption;
+    governance: GovernanceOption<C>;
     migration: MigrationConfig;
     integrator?: Address;
     userAddress: Address;
     startTimeOffset?: number;
     blockTimestamp?: number;
+    gas?: bigint;
+    modules?: ModuleAddressOverrides;
 }
 interface PriceRange {
     startPrice: number;
@@ -123,6 +150,140 @@ interface TickRange {
     startTick: number;
     endTick: number;
 }
+/**
+ * Market cap range in USD for price configurations.
+ * Used to define start and end market caps for bonding curves.
+ */
+interface MarketCapRange {
+    /** Starting market cap in USD (e.g., 100_000 for $100k) */
+    start: number;
+    /** Ending market cap in USD (e.g., 10_000_000 for $10M) */
+    end: number;
+}
+/**
+ * Base configuration for market cap-based tick calculations.
+ * Used by builder methods to convert market caps to ticks.
+ */
+interface MarketCapConfig {
+    /** Target market cap range in USD */
+    marketCap: MarketCapRange;
+    /** Price of numeraire in USD (e.g., 3000 for ETH at $3000) */
+    numerairePrice: number;
+    /**
+     * Token supply override. If not provided, inferred from saleConfig.initialSupply.
+     * Must include decimals (e.g., parseEther('1000000000') for 1B tokens).
+     */
+    tokenSupply?: bigint;
+    /** Token decimals (default: 18) */
+    tokenDecimals?: number;
+    /** Numeraire decimals (default: 18) */
+    numeraireDecimals?: number;
+}
+/**
+ * Market cap configuration for V3 Static Auctions.
+ * Extends base config with V3-specific parameters.
+ */
+interface StaticAuctionMarketCapConfig extends MarketCapConfig {
+    /** Fee tier in basis points (e.g., 10000 for 1%). Default: 10000 */
+    fee?: number;
+    /** Number of liquidity positions. Default: 15 */
+    numPositions?: number;
+    /** Maximum share of tokens to sell per position (WAD). Default: 35% */
+    maxShareToBeSold?: bigint;
+}
+/**
+ * Market cap range for V4 Dynamic Auctions (Dutch auctions).
+ * Uses start/min because price descends from start to minimum.
+ */
+interface DynamicMarketCapRange {
+    /** Starting market cap in USD - auction begins here (e.g., 500_000 for $500k) */
+    start: number;
+    /** Minimum market cap in USD - floor price the auction descends to (e.g., 50_000 for $50k) */
+    min: number;
+}
+/**
+ * Market cap configuration for V4 Dynamic Auctions.
+ * Uses start/min (not start/end) because Dutch auctions descend from start to minimum.
+ */
+interface DynamicAuctionMarketCapConfig {
+    /** Target market cap range (start = launch price, min = floor price) */
+    marketCap: DynamicMarketCapRange;
+    /** Price of numeraire in USD (e.g., 3000 for ETH at $3000) */
+    numerairePrice: number;
+    /**
+     * Token supply override. If not provided, inferred from saleConfig.initialSupply.
+     * Must include decimals (e.g., parseEther('1000000000') for 1B tokens).
+     */
+    tokenSupply?: bigint;
+    /** Token decimals (default: 18) */
+    tokenDecimals?: number;
+    /** Numeraire decimals (default: 18) */
+    numeraireDecimals?: number;
+    /** Minimum proceeds required for successful auction */
+    minProceeds: bigint;
+    /** Maximum proceeds cap for the auction */
+    maxProceeds: bigint;
+    /** Auction duration in seconds. Default: 7 days */
+    duration?: number;
+    /** Epoch length in seconds. Default: 3600 (1 hour) */
+    epochLength?: number;
+    /** Gamma (tick decay per epoch). Auto-calculated if not provided */
+    gamma?: number;
+    /** Number of price discovery slugs. Default: 5 */
+    numPdSlugs?: number;
+}
+/**
+ * Result of market cap parameter validation.
+ */
+interface MarketCapValidationResult {
+    /** Whether all parameters are within normal bounds */
+    valid: boolean;
+    /** Warning messages for unusual but technically valid values */
+    warnings: string[];
+}
+/**
+ * Curve configuration for Multicurve pools using market cap ranges.
+ * Each curve defines a market cap range and liquidity distribution.
+ */
+interface MulticurveMarketCapRangeCurve {
+    /** Market cap range for this curve */
+    marketCap: {
+        /** Start market cap in USD (for the first curve, this is the launch price) */
+        start: number;
+        /** End market cap in USD */
+        end: number;
+    };
+    /** Number of liquidity positions in this curve */
+    numPositions: number;
+    /** Share of total supply allocated to this curve (WAD, e.g., parseEther('0.3') = 30%) */
+    shares: bigint;
+}
+/**
+ * Market cap-based configuration for Multicurve pools.
+ * No tick math required - just specify market caps in USD.
+ */
+interface MulticurveMarketCapCurvesConfig {
+    /** Price of numeraire in USD (e.g., 3000 for ETH at $3000) */
+    numerairePrice: number;
+    /**
+     * Array of curves defining market cap ranges and liquidity distribution.
+     * The first curve's marketCap.start is the launch price.
+     * Curves must be contiguous (no gaps allowed).
+     */
+    curves: MulticurveMarketCapRangeCurve[];
+    /** Token supply override */
+    tokenSupply?: bigint;
+    /** Token decimals (default: 18) */
+    tokenDecimals?: number;
+    /** Numeraire decimals (default: 18) */
+    numeraireDecimals?: number;
+    /** Fee tier (default: FEE_TIERS.LOW) */
+    fee?: number;
+    /** Tick spacing (derived from fee if not provided) */
+    tickSpacing?: number;
+    /** Optional beneficiaries for fee streaming */
+    beneficiaries?: BeneficiaryData[];
+}
 interface StaticAuctionBuildConfig {
     name: string;
     symbol: string;
@@ -172,7 +333,7 @@ interface DynamicAuctionBuildConfig {
     useGovernance?: boolean;
 }
 interface DopplerSDKConfig {
-    publicClient: PublicClient;
+    publicClient: SupportedPublicClient;
     walletClient?: WalletClient;
     chainId: number;
 }
@@ -212,7 +373,84 @@ interface LockableV3InitializerParams {
     tickUpper: number;
     numPositions: number;
     maxShareToBeSold: bigint;
-    beneficiaries: LockableBeneficiaryData[];
+    beneficiaries: BeneficiaryData[];
+}
+interface MulticurveCurve {
+    tickLower: number;
+    tickUpper: number;
+    numPositions: number;
+    shares: bigint;
+}
+type MulticurveMarketCapPreset = 'low' | 'medium' | 'high';
+interface V4PoolKey {
+    currency0: Address;
+    currency1: Address;
+    fee: number;
+    tickSpacing: number;
+    hooks: Address;
+}
+interface MulticurveBundleExactOutResult {
+    asset: Address;
+    poolKey: V4PoolKey;
+    amountIn: bigint;
+    gasEstimate: bigint;
+}
+interface MulticurveBundleExactInResult {
+    asset: Address;
+    poolKey: V4PoolKey;
+    amountOut: bigint;
+    gasEstimate: bigint;
+}
+interface CreateMulticurveParams<C extends SupportedChainId = SupportedChainId> {
+    token: TokenConfig;
+    sale: SaleConfig;
+    pool: {
+        fee: number;
+        tickSpacing: number;
+        curves: MulticurveCurve[];
+        beneficiaries?: BeneficiaryData[];
+    };
+    schedule?: {
+        startTime: number;
+    };
+    vesting?: VestingConfig;
+    governance: GovernanceOption<C>;
+    migration: MigrationConfig;
+    integrator?: Address;
+    userAddress: Address;
+    modules?: ModuleAddressOverrides;
+    gas?: bigint;
+}
+interface CreateParams {
+    initialSupply: bigint;
+    numTokensToSell: bigint;
+    numeraire: Address;
+    tokenFactory: Address;
+    tokenFactoryData: `0x${string}`;
+    governanceFactory: Address;
+    governanceFactoryData: `0x${string}`;
+    poolInitializer: Address;
+    poolInitializerData: `0x${string}`;
+    liquidityMigrator: Address;
+    liquidityMigratorData: `0x${string}`;
+    integrator: Address;
+    salt: `0x${string}`;
+}
+interface ModuleAddressOverrides {
+    airlock?: Address;
+    tokenFactory?: Address;
+    v3Initializer?: Address;
+    lockableV3Initializer?: Address;
+    v4Initializer?: Address;
+    v4MulticurveInitializer?: Address;
+    v4ScheduledMulticurveInitializer?: Address;
+    governanceFactory?: Address;
+    poolManager?: Address;
+    dopplerDeployer?: Address;
+    v2Migrator?: Address;
+    v3Migrator?: Address;
+    v4Migrator?: Address;
+    noOpMigrator?: Address;
 }
 
-export { type BeneficiaryData, type CreateDynamicAuctionParams, type CreateStaticAuctionParams, type Doppler404TokenConfig, type DopplerSDKConfig, type DynamicAuctionBuildConfig, type DynamicAuctionConfig, type GovernanceConfig, type GovernanceOption, type HookInfo, type LockableBeneficiaryData, type LockablePoolState, LockablePoolStatus, type LockableV3InitializerParams, type MigrationConfig, type NoOpGovernance, type PoolInfo, type PriceRange, type QuoteResult, type SaleConfig, type StandardTokenConfig, type StaticAuctionBuildConfig, type StaticPoolConfig, type TickRange, type TokenConfig, type VestingConfig };
+export { type BeneficiaryData, type CreateDynamicAuctionParams, type CreateMulticurveParams, type CreateParams, type CreateStaticAuctionParams, type Doppler404TokenConfig, type DopplerSDKConfig, type DynamicAuctionBuildConfig, type DynamicAuctionConfig, type DynamicAuctionMarketCapConfig, type DynamicMarketCapRange, type GovernanceCustom, type GovernanceDefault, type GovernanceNoOp, type GovernanceOption, type HookInfo, type LockablePoolState, LockablePoolStatus, type LockableV3InitializerParams, type MarketCapConfig, type MarketCapRange, type MarketCapValidationResult, type MigrationConfig, type ModuleAddressOverrides, type MulticurveBundleExactInResult, type MulticurveBundleExactOutResult, type MulticurveCurve, type MulticurveMarketCapCurvesConfig, type MulticurveMarketCapPreset, type MulticurveMarketCapRangeCurve, type MulticurvePoolState, NO_OP_ENABLED_CHAIN_IDS, type NoOpEnabledChainId, type PoolInfo, type PriceRange, type QuoteResult, type SaleConfig, type StandardTokenConfig, type StaticAuctionBuildConfig, type StaticAuctionMarketCapConfig, type StaticPoolConfig, type SupportedChain, SupportedChainId, type SupportedPublicClient, type TickRange, type TokenConfig, type V4PoolKey, type VestingConfig, isNoOpEnabledChain };

package/dist/types.js

@@ -1,13 +1,22 @@
 'use strict';
 
-var chunk2N5JZSZ4_js = require('./chunk-2N5JZSZ4.js');
-require('./chunk-KEXKKQVW.js');
+var chunkOKNM7ODQ_js = require('./chunk-OKNM7ODQ.js');
+require('./chunk-YYUOLM6U.js');
+require('./chunk-CVHPLURA.js');
 
 
 
 Object.defineProperty(exports, "LockablePoolStatus", {
   enumerable: true,
-  get: function () { return chunk2N5JZSZ4_js.LockablePoolStatus; }
+  get: function () { return chunkOKNM7ODQ_js.LockablePoolStatus; }
+});
+Object.defineProperty(exports, "NO_OP_ENABLED_CHAIN_IDS", {
+  enumerable: true,
+  get: function () { return chunkOKNM7ODQ_js.NO_OP_ENABLED_CHAIN_IDS; }
+});
+Object.defineProperty(exports, "isNoOpEnabledChain", {
+  enumerable: true,
+  get: function () { return chunkOKNM7ODQ_js.isNoOpEnabledChain; }
 });
 //# sourceMappingURL=types.js.map
 //# sourceMappingURL=types.js.map

package/dist/types.mjs

@@ -1,4 +1,5 @@
-export { LockablePoolStatus } from './chunk-IHBIBFZK.mjs';
-import './chunk-LOROXNH3.mjs';
+export { LockablePoolStatus, NO_OP_ENABLED_CHAIN_IDS, isNoOpEnabledChain } from './chunk-OZ6DGBRL.mjs';
+import './chunk-AW3WR2D3.mjs';
+import './chunk-FPAI4QYW.mjs';
 //# sourceMappingURL=types.mjs.map
 //# sourceMappingURL=types.mjs.map

package/dist/utils/airlock.d.mts

@@ -0,0 +1,11 @@
+import { Address } from 'viem';
+import { BeneficiaryData } from '../types.mjs';
+import 'viem/chains';
+import '../addresses.mjs';
+
+declare const getAirlockOwner: (publicClient: unknown) => Promise<Address>;
+declare const DEFAULT_AIRLOCK_BENEFICIARY_SHARES: bigint;
+declare const createAirlockBeneficiary: (owner: Address, shares?: bigint) => BeneficiaryData;
+declare const getAirlockBeneficiary: (publicClient: unknown, shares?: bigint) => Promise<BeneficiaryData>;
+
+export { DEFAULT_AIRLOCK_BENEFICIARY_SHARES, createAirlockBeneficiary, getAirlockBeneficiary, getAirlockOwner };

package/dist/utils/airlock.d.ts

@@ -0,0 +1,11 @@
+import { Address } from 'viem';
+import { BeneficiaryData } from '../types.js';
+import 'viem/chains';
+import '../addresses.js';
+
+declare const getAirlockOwner: (publicClient: unknown) => Promise<Address>;
+declare const DEFAULT_AIRLOCK_BENEFICIARY_SHARES: bigint;
+declare const createAirlockBeneficiary: (owner: Address, shares?: bigint) => BeneficiaryData;
+declare const getAirlockBeneficiary: (publicClient: unknown, shares?: bigint) => Promise<BeneficiaryData>;
+
+export { DEFAULT_AIRLOCK_BENEFICIARY_SHARES, createAirlockBeneficiary, getAirlockBeneficiary, getAirlockOwner };

package/dist/utils/airlock.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var chunkBIQQ53O2_js = require('../chunk-BIQQ53O2.js');
+require('../chunk-YYUOLM6U.js');
+require('../chunk-CVHPLURA.js');
+
+
+
+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=airlock.js.map
+//# sourceMappingURL=airlock.js.map

package/dist/utils/airlock.js.map

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

package/dist/utils/airlock.mjs

@@ -0,0 +1,5 @@
+export { DEFAULT_AIRLOCK_BENEFICIARY_SHARES, createAirlockBeneficiary, getAirlockBeneficiary, getAirlockOwner } from '../chunk-M4WMHD3X.mjs';
+import '../chunk-AW3WR2D3.mjs';
+import '../chunk-FPAI4QYW.mjs';
+//# sourceMappingURL=airlock.mjs.map
+//# sourceMappingURL=airlock.mjs.map

package/dist/utils/airlock.mjs.map

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

package/dist/utils/balanceDelta.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Decode a Uniswap V4 BalanceDelta (int256) value into separate int128 deltas.
+ * The upper 128 bits represent amount0, the lower 128 bits represent amount1.
+ */
+declare function decodeBalanceDelta(delta: bigint): {
+    amount0: bigint;
+    amount1: bigint;
+};
+
+export { decodeBalanceDelta };

package/dist/utils/balanceDelta.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Decode a Uniswap V4 BalanceDelta (int256) value into separate int128 deltas.
+ * The upper 128 bits represent amount0, the lower 128 bits represent amount1.
+ */
+declare function decodeBalanceDelta(delta: bigint): {
+    amount0: bigint;
+    amount1: bigint;
+};
+
+export { decodeBalanceDelta };

package/dist/utils/balanceDelta.js

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

package/dist/utils/balanceDelta.js.map

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

package/dist/utils/balanceDelta.mjs

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

package/dist/utils/balanceDelta.mjs.map

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

package/dist/utils/computeOptimalGamma.d.mts

@@ -0,0 +1,7 @@
+/**
+ * Compute optimal gamma parameter based on price range and time parameters
+ * Gamma determines how much the price can move per epoch during the sale.
+ */
+declare function computeOptimalGamma(startTick: number, endTick: number, duration: number, epochLength: number, tickSpacing: number): number;
+
+export { computeOptimalGamma };

package/dist/utils/computeOptimalGamma.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compute optimal gamma parameter based on price range and time parameters
+ * Gamma determines how much the price can move per epoch during the sale.
+ */
+declare function computeOptimalGamma(startTick: number, endTick: number, duration: number, epochLength: number, tickSpacing: number): number;
+
+export { computeOptimalGamma };

package/dist/utils/computeOptimalGamma.js

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

package/dist/utils/computeOptimalGamma.js.map

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

package/dist/utils/computeOptimalGamma.mjs

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

package/dist/utils/computeOptimalGamma.mjs.map

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

package/dist/utils/index.d.mts

@@ -1,2 +1,13 @@
 export { MAX_SQRT_RATIO, MAX_TICK, MIN_SQRT_RATIO, MIN_TICK, Q96, getNearestUsableTick, getSqrtRatioAtTick, getTickAtSqrtRatio, priceToSqrtPriceX96, priceToTick, sqrtPriceX96ToPrice, tickToPrice } from './tickMath.mjs';
 export { calculateFDV, calculateGamma, calculateMarketCap, calculateTickRange, calculateTokensToSell, estimatePriceAtEpoch, estimateSlippage, formatTickAsPrice } from './priceHelpers.mjs';
+export { TokenAddressHookConfig, TokenAddressMiningParams, TokenAddressMiningResult, TokenVariant, mineTokenAddress } from './tokenAddressMiner.mjs';
+export { DEFAULT_AIRLOCK_BENEFICIARY_SHARES, createAirlockBeneficiary, getAirlockBeneficiary, getAirlockOwner } from './airlock.mjs';
+export { decodeBalanceDelta } from './balanceDelta.mjs';
+export { computePoolId } from './poolKey.mjs';
+export { computeOptimalGamma } from './computeOptimalGamma.mjs';
+export { isToken0Expected } from './isToken0Expected.mjs';
+export { applyTickOffsets, isToken1, marketCapRangeToTicks, marketCapRangeToTicksForCurve, marketCapToTick, marketCapToTokenPrice, ratioToTick, tickToMarketCap, tokenPriceToRatio, transformTicksForAuction, validateMarketCapParameters } from './marketCapHelpers.mjs';
+export { MarketCapRange, MarketCapValidationResult } from '../types.mjs';
+import 'viem';
+import 'viem/chains';
+import '../addresses.mjs';

package/dist/utils/index.d.ts

@@ -1,2 +1,13 @@
 export { MAX_SQRT_RATIO, MAX_TICK, MIN_SQRT_RATIO, MIN_TICK, Q96, getNearestUsableTick, getSqrtRatioAtTick, getTickAtSqrtRatio, priceToSqrtPriceX96, priceToTick, sqrtPriceX96ToPrice, tickToPrice } from './tickMath.js';
 export { calculateFDV, calculateGamma, calculateMarketCap, calculateTickRange, calculateTokensToSell, estimatePriceAtEpoch, estimateSlippage, formatTickAsPrice } from './priceHelpers.js';
+export { TokenAddressHookConfig, TokenAddressMiningParams, TokenAddressMiningResult, TokenVariant, mineTokenAddress } from './tokenAddressMiner.js';
+export { DEFAULT_AIRLOCK_BENEFICIARY_SHARES, createAirlockBeneficiary, getAirlockBeneficiary, getAirlockOwner } from './airlock.js';
+export { decodeBalanceDelta } from './balanceDelta.js';
+export { computePoolId } from './poolKey.js';
+export { computeOptimalGamma } from './computeOptimalGamma.js';
+export { isToken0Expected } from './isToken0Expected.js';
+export { applyTickOffsets, isToken1, marketCapRangeToTicks, marketCapRangeToTicksForCurve, marketCapToTick, marketCapToTokenPrice, ratioToTick, tickToMarketCap, tokenPriceToRatio, transformTicksForAuction, validateMarketCapParameters } from './marketCapHelpers.js';
+export { MarketCapRange, MarketCapValidationResult } from '../types.js';
+import 'viem';
+import 'viem/chains';
+import '../addresses.js';