liquid-sdk 1.0.0 → 1.1.0

package/dist/index.js

@@ -21,8 +21,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ADDRESSES: () => ADDRESSES,
+  DEFAULTS: () => DEFAULTS,
   DEFAULT_CHAIN: () => DEFAULT_CHAIN,
   DEFAULT_CHAIN_ID: () => DEFAULT_CHAIN_ID,
+  DEFAULT_RPC_URL: () => DEFAULT_RPC_URL,
+  DEFAULT_TRANCHES_USD: () => DEFAULT_TRANCHES_USD,
   ERC20Abi: () => ERC20Abi,
   EXTERNAL: () => EXTERNAL,
   FEE: () => FEE,
@@ -37,12 +40,25 @@ __export(index_exports, {
   LiquidSniperAuctionV2Abi: () => LiquidSniperAuctionV2Abi,
   LiquidSniperUtilV2Abi: () => LiquidSniperUtilV2Abi,
   LiquidVaultAbi: () => LiquidVaultAbi,
-  TOKEN: () => TOKEN
+  POOL_POSITIONS: () => POOL_POSITIONS,
+  TOKEN: () => TOKEN,
+  createDefaultPositions: () => createDefaultPositions,
+  createPositions: () => createPositions,
+  createPositionsUSD: () => createPositionsUSD,
+  describePositions: () => describePositions,
+  encodeDynamicFeePoolData: () => encodeDynamicFeePoolData,
+  encodeSniperAuctionData: () => encodeSniperAuctionData,
+  encodeStaticFeePoolData: () => encodeStaticFeePoolData,
+  getTickFromMarketCapETH: () => getTickFromMarketCapETH,
+  getTickFromMarketCapStable: () => getTickFromMarketCapStable,
+  getTickFromMarketCapUSD: () => getTickFromMarketCapUSD,
+  marketCapFromTickETH: () => marketCapFromTickETH,
+  marketCapFromTickUSD: () => marketCapFromTickUSD
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/client.ts
-var import_viem = require("viem");
+var import_viem2 = require("viem");
 var import_chains2 = require("viem/chains");
 
 // src/constants.ts
@@ -88,8 +104,154 @@ var TOKEN = {
   MAX_EXTENSIONS: 10,
   MAX_EXTENSION_BPS: 9e3
 };
+var POOL_POSITIONS = {
+  /** Single position, 100% of liquidity in one range */
+  Standard: [
+    {
+      tickLower: -230400,
+      // ~10 ETH / ~$20K
+      tickUpper: -12e4,
+      // ~$1.5B
+      positionBps: 1e4
+    }
+  ],
+  /** 3-tranche Liquid default (hardcoded for ~10 ETH start, ~$2070/ETH) */
+  Liquid: [
+    {
+      tickLower: -230400,
+      // ~$20K starting
+      tickUpper: -198600,
+      // ~$500K
+      positionBps: 4e3
+      // 40%
+    },
+    {
+      tickLower: -198600,
+      // ~$500K
+      tickUpper: -168600,
+      // ~$10M
+      positionBps: 5e3
+      // 50%
+    },
+    {
+      tickLower: -168600,
+      // ~$10M
+      tickUpper: -122600,
+      // ~$1B
+      positionBps: 1e3
+      // 10%
+    }
+  ]
+};
+var DEFAULTS = {
+  HOOK: ADDRESSES.HOOK_STATIC_FEE_V2,
+  TICK_SPACING: 200,
+  TICK_IF_TOKEN0_IS_LIQUID: -230400,
+  /** Static fee on buys (ETH → token): 1% (100 bps). Fees collected in ETH. */
+  PAIRED_FEE_BPS: 100,
+  /** Static fee on sells (token → ETH): 0%. No fees in liquid token. */
+  LIQUID_FEE_BPS: 0,
+  /** MEV module: Sniper Auction V2 */
+  MEV_MODULE: ADDRESSES.SNIPER_AUCTION_V2,
+  /** Sniper auction starting fee: 80% (800,000 uniBps) */
+  SNIPER_STARTING_FEE: 8e5,
+  /** Sniper auction ending fee: 40% (400,000 uniBps) */
+  SNIPER_ENDING_FEE: 4e5,
+  /** Sniper auction decay period: 32 seconds */
+  SNIPER_SECONDS_TO_DECAY: 32
+};
 var DEFAULT_CHAIN = import_chains.base;
 var DEFAULT_CHAIN_ID = 8453;
+var DEFAULT_RPC_URL = "https://base.drpc.org";
+
+// src/utils/encoding.ts
+var import_viem = require("viem");
+var PoolInitializationDataAbi = [
+  {
+    type: "tuple",
+    components: [
+      { name: "extension", type: "address" },
+      { name: "extensionData", type: "bytes" },
+      { name: "feeData", type: "bytes" }
+    ]
+  }
+];
+var StaticFeeInitAbi = [
+  { type: "uint24" },
+  { type: "uint24" }
+];
+var SniperAuctionInitAbi = [
+  {
+    type: "tuple",
+    components: [
+      { name: "startingFee", type: "uint24" },
+      { name: "endingFee", type: "uint24" },
+      { name: "secondsToDecay", type: "uint256" }
+    ]
+  }
+];
+function encodeStaticFeePoolData(liquidFeeBps, pairedFeeBps, extension = import_viem.zeroAddress, extensionData = "0x") {
+  const feeData = (0, import_viem.encodeAbiParameters)(StaticFeeInitAbi, [
+    liquidFeeBps * 100,
+    pairedFeeBps * 100
+  ]);
+  return (0, import_viem.encodeAbiParameters)(PoolInitializationDataAbi, [
+    {
+      extension,
+      extensionData,
+      feeData
+    }
+  ]);
+}
+var DynamicFeeInitAbi = [
+  { type: "uint24" },
+  // baseFee (uniBps)
+  { type: "uint24" },
+  // maxFee (uniBps)
+  { type: "uint256" },
+  // referenceTickFilterPeriod
+  { type: "uint256" },
+  // resetPeriod
+  { type: "int24" },
+  // resetTickFilter
+  { type: "uint256" },
+  // feeControlNumerator
+  { type: "uint24" }
+  // decayFilterBps
+];
+function encodeDynamicFeePoolData(config, extension = import_viem.zeroAddress, extensionData = "0x") {
+  const feeData = (0, import_viem.encodeAbiParameters)(DynamicFeeInitAbi, [
+    config.baseFeeBps * 100,
+    config.maxFeeBps * 100,
+    BigInt(config.referenceTickFilterPeriod),
+    BigInt(config.resetPeriod),
+    config.resetTickFilter,
+    config.feeControlNumerator,
+    config.decayFilterBps
+  ]);
+  return (0, import_viem.encodeAbiParameters)(PoolInitializationDataAbi, [
+    {
+      extension,
+      extensionData,
+      feeData
+    }
+  ]);
+}
+function encodeSniperAuctionData(config) {
+  if (config.startingFee <= config.endingFee) {
+    throw new Error("startingFee must be greater than endingFee");
+  }
+  if (config.secondsToDecay <= 0) {
+    throw new Error("secondsToDecay must be positive");
+  }
+  return (0, import_viem.encodeAbiParameters)(SniperAuctionInitAbi, [
+    {
+      startingFee: config.startingFee,
+      endingFee: config.endingFee,
+      secondsToDecay: BigInt(config.secondsToDecay)
+    }
+  ]);
+}
 
 // src/abis/LiquidFactory.ts
 var LiquidFactoryAbi = [
@@ -792,7 +954,7 @@ var LiquidSDK = class {
    * The paired token must be WETH for simple dev buys.
    */
   buildDevBuyExtension(devBuy) {
-    const extensionData = (0, import_viem.encodeAbiParameters)(
+    const extensionData = (0, import_viem2.encodeAbiParameters)(
       [
         {
           type: "tuple",
@@ -816,11 +978,11 @@ var LiquidSDK = class {
       [
         {
           pairedTokenPoolKey: {
-            currency0: import_viem.zeroAddress,
-            currency1: import_viem.zeroAddress,
+            currency0: import_viem2.zeroAddress,
+            currency1: import_viem2.zeroAddress,
             fee: 0,
             tickSpacing: 0,
-            hooks: import_viem.zeroAddress
+            hooks: import_viem2.zeroAddress
           },
           pairedTokenAmountOutMinimum: 0n,
           recipient: devBuy.recipient
@@ -834,6 +996,97 @@ var LiquidSDK = class {
       extensionData
     };
   }
+  // ── Validation ─────────────────────────────────────────────────
+  /**
+   * Validate a DeploymentConfig before sending to the contract.
+   * Catches common mistakes client-side with clear error messages.
+   */
+  validateDeploymentConfig(config) {
+    const { lockerConfig, extensionConfigs } = config;
+    const { tickSpacing } = config.poolConfig;
+    const posLen = lockerConfig.tickLower.length;
+    if (lockerConfig.tickUpper.length !== posLen || lockerConfig.positionBps.length !== posLen) {
+      throw new Error(
+        `tickLower (${posLen}), tickUpper (${lockerConfig.tickUpper.length}), and positionBps (${lockerConfig.positionBps.length}) arrays must be the same length`
+      );
+    }
+    if (posLen === 0) {
+      throw new Error("At least one position is required");
+    }
+    if (posLen > 7) {
+      throw new Error(`Maximum 7 positions allowed, got ${posLen}`);
+    }
+    const posBpsSum = lockerConfig.positionBps.reduce((s, b) => s + b, 0);
+    if (posBpsSum !== FEE.BPS) {
+      throw new Error(
+        `positionBps must sum to ${FEE.BPS} (100%), got ${posBpsSum}`
+      );
+    }
+    for (let i = 0; i < posLen; i++) {
+      if (lockerConfig.tickLower[i] >= lockerConfig.tickUpper[i]) {
+        throw new Error(
+          `Position ${i}: tickLower (${lockerConfig.tickLower[i]}) must be less than tickUpper (${lockerConfig.tickUpper[i]})`
+        );
+      }
+    }
+    for (let i = 0; i < posLen; i++) {
+      if (lockerConfig.tickLower[i] % tickSpacing !== 0) {
+        throw new Error(
+          `Position ${i}: tickLower (${lockerConfig.tickLower[i]}) is not a multiple of tickSpacing (${tickSpacing})`
+        );
+      }
+      if (lockerConfig.tickUpper[i] % tickSpacing !== 0) {
+        throw new Error(
+          `Position ${i}: tickUpper (${lockerConfig.tickUpper[i]}) is not a multiple of tickSpacing (${tickSpacing})`
+        );
+      }
+    }
+    const startingTick = config.poolConfig.tickIfToken0IsLiquid;
+    for (let i = 0; i < posLen; i++) {
+      if (lockerConfig.tickLower[i] < startingTick) {
+        throw new Error(
+          `Position ${i}: tickLower (${lockerConfig.tickLower[i]}) is below the starting tick (${startingTick})`
+        );
+      }
+    }
+    const touchesStart = lockerConfig.tickLower.some(
+      (t) => t === startingTick
+    );
+    if (!touchesStart) {
+      throw new Error(
+        `At least one position's tickLower must equal tickIfToken0IsLiquid (${startingTick})`
+      );
+    }
+    const rwdLen = lockerConfig.rewardAdmins.length;
+    if (lockerConfig.rewardRecipients.length !== rwdLen || lockerConfig.rewardBps.length !== rwdLen) {
+      throw new Error(
+        `rewardAdmins (${rwdLen}), rewardRecipients (${lockerConfig.rewardRecipients.length}), and rewardBps (${lockerConfig.rewardBps.length}) arrays must be the same length`
+      );
+    }
+    if (rwdLen === 0) {
+      throw new Error("At least one reward recipient is required");
+    }
+    const rwdBpsSum = lockerConfig.rewardBps.reduce((s, b) => s + b, 0);
+    if (rwdBpsSum !== FEE.BPS) {
+      throw new Error(
+        `rewardBps must sum to ${FEE.BPS} (100%), got ${rwdBpsSum}`
+      );
+    }
+    if (extensionConfigs.length > TOKEN.MAX_EXTENSIONS) {
+      throw new Error(
+        `Maximum ${TOKEN.MAX_EXTENSIONS} extensions allowed, got ${extensionConfigs.length}`
+      );
+    }
+    const extBpsSum = extensionConfigs.reduce(
+      (s, e) => s + e.extensionBps,
+      0
+    );
+    if (extBpsSum > TOKEN.MAX_EXTENSION_BPS) {
+      throw new Error(
+        `Total extensionBps (${extBpsSum}) exceeds maximum (${TOKEN.MAX_EXTENSION_BPS})`
+      );
+    }
+  }
   // ── Token Deployment ─────────────────────────────────────────────
   async deployToken(params) {
     if (!this.walletClient?.account) {
@@ -845,8 +1098,8 @@ var LiquidSDK = class {
         tokenAdmin: params.tokenAdmin ?? account,
         name: params.name,
         symbol: params.symbol,
-        salt: params.salt ?? (0, import_viem.keccak256)(
-          (0, import_viem.encodePacked)(
+        salt: params.salt ?? (0, import_viem2.keccak256)(
+          (0, import_viem2.encodePacked)(
             ["string", "string", "uint256"],
             [params.name, params.symbol, BigInt(Date.now())]
           )
@@ -857,25 +1110,32 @@ var LiquidSDK = class {
         originatingChainId: BigInt(DEFAULT_CHAIN_ID)
       },
       poolConfig: {
-        hook: params.hook ?? ADDRESSES.HOOK_DYNAMIC_FEE_V2,
+        hook: params.hook ?? DEFAULTS.HOOK,
         pairedToken: params.pairedToken ?? EXTERNAL.WETH,
-        tickIfToken0IsLiquid: params.tickIfToken0IsLiquid ?? -198720,
-        tickSpacing: params.tickSpacing ?? 60,
-        poolData: params.poolData ?? "0x"
+        tickIfToken0IsLiquid: params.tickIfToken0IsLiquid ?? DEFAULTS.TICK_IF_TOKEN0_IS_LIQUID,
+        tickSpacing: params.tickSpacing ?? DEFAULTS.TICK_SPACING,
+        poolData: params.poolData ?? encodeStaticFeePoolData(
+          DEFAULTS.LIQUID_FEE_BPS,
+          DEFAULTS.PAIRED_FEE_BPS
+        )
       },
       lockerConfig: {
         locker: params.locker ?? ADDRESSES.LP_LOCKER,
         rewardAdmins: params.rewardAdmins ?? [account],
         rewardRecipients: params.rewardRecipients ?? [account],
         rewardBps: params.rewardBps ?? [1e4],
-        tickLower: params.tickLower ?? [-887220],
-        tickUpper: params.tickUpper ?? [887220],
-        positionBps: params.positionBps ?? [1e4],
+        tickLower: params.tickLower ?? POOL_POSITIONS.Liquid.map((p) => p.tickLower),
+        tickUpper: params.tickUpper ?? POOL_POSITIONS.Liquid.map((p) => p.tickUpper),
+        positionBps: params.positionBps ?? POOL_POSITIONS.Liquid.map((p) => p.positionBps),
         lockerData: params.lockerData ?? "0x"
       },
       mevModuleConfig: {
-        mevModule: params.mevModule ?? ADDRESSES.MEV_BLOCK_DELAY,
-        mevModuleData: params.mevModuleData ?? "0x"
+        mevModule: params.mevModule ?? DEFAULTS.MEV_MODULE,
+        mevModuleData: params.mevModuleData ?? encodeSniperAuctionData({
+          startingFee: DEFAULTS.SNIPER_STARTING_FEE,
+          endingFee: DEFAULTS.SNIPER_ENDING_FEE,
+          secondsToDecay: DEFAULTS.SNIPER_SECONDS_TO_DECAY
+        })
       },
       extensionConfigs: [...params.extensions ?? []]
     };
@@ -884,6 +1144,7 @@ var LiquidSDK = class {
         this.buildDevBuyExtension(params.devBuy)
       );
     }
+    this.validateDeploymentConfig(deploymentConfig);
     const msgValue = deploymentConfig.extensionConfigs.reduce(
       (sum, ext) => sum + ext.msgValue,
       0n
@@ -902,7 +1163,7 @@ var LiquidSDK = class {
     });
     const tokenCreatedLog = receipt.logs.find((log) => {
       try {
-        const decoded2 = (0, import_viem.decodeEventLog)({
+        const decoded2 = (0, import_viem2.decodeEventLog)({
           abi: LiquidFactoryAbi,
           data: log.data,
           topics: log.topics
@@ -915,14 +1176,14 @@ var LiquidSDK = class {
     if (!tokenCreatedLog) {
       throw new Error("TokenCreated event not found in transaction receipt");
     }
-    const decoded = (0, import_viem.decodeEventLog)({
+    const decoded = (0, import_viem2.decodeEventLog)({
       abi: LiquidFactoryAbi,
       data: tokenCreatedLog.data,
       topics: tokenCreatedLog.topics
     });
     const args = decoded.args;
     return {
-      tokenAddress: (0, import_viem.getAddress)(args.tokenAddress),
+      tokenAddress: (0, import_viem2.getAddress)(args.tokenAddress),
       txHash,
       event: {
         msgSender: args.msgSender,
@@ -1070,7 +1331,7 @@ var LiquidSDK = class {
     if (!this.walletClient?.account) {
       throw new Error("walletClient with account required for claimFees");
     }
-    return this.walletClient.writeContract({
+    return await this.walletClient.writeContract({
       address: ADDRESSES.FEE_LOCKER,
       abi: LiquidFeeLockerAbi,
       functionName: "claim",
@@ -1109,7 +1370,7 @@ var LiquidSDK = class {
     if (!this.walletClient?.account) {
       throw new Error("walletClient with account required for claimVault");
     }
-    return this.walletClient.writeContract({
+    return await this.walletClient.writeContract({
       address: ADDRESSES.VAULT,
       abi: LiquidVaultAbi,
       functionName: "claim",
@@ -1238,7 +1499,7 @@ var LiquidSDK = class {
     if (!this.walletClient?.account) {
       throw new Error("walletClient with account required for claimAirdrop");
     }
-    return this.walletClient.writeContract({
+    return await this.walletClient.writeContract({
       address: ADDRESSES.AIRDROP_V2,
       abi: LiquidAirdropV2Abi,
       functionName: "claim",
@@ -1272,7 +1533,7 @@ var LiquidSDK = class {
       throw new Error("walletClient with account required for collectRewards");
     }
     const locker = lockerAddress ?? ADDRESSES.LP_LOCKER;
-    return this.walletClient.writeContract({
+    return await this.walletClient.writeContract({
       address: locker,
       abi: LiquidLpLockerAbi,
       functionName: "collectRewards",
@@ -1288,7 +1549,7 @@ var LiquidSDK = class {
       );
     }
     const locker = lockerAddress ?? ADDRESSES.LP_LOCKER;
-    return this.walletClient.writeContract({
+    return await this.walletClient.writeContract({
       address: locker,
       abi: LiquidLpLockerAbi,
       functionName: "collectRewardsWithoutUnlock",
@@ -1304,7 +1565,7 @@ var LiquidSDK = class {
       );
     }
     const locker = lockerAddress ?? ADDRESSES.LP_LOCKER;
-    return this.walletClient.writeContract({
+    return await this.walletClient.writeContract({
       address: locker,
       abi: LiquidLpLockerAbi,
       functionName: "updateRewardRecipient",
@@ -1339,11 +1600,122 @@ var LiquidSDK = class {
     });
   }
 };
+
+// src/utils/tick-math.ts
+var LOG_BASE = Math.log(1.0001);
+var DEFAULT_TICK_SPACING = 200;
+var TOTAL_SUPPLY = 1e11;
+function getTickFromMarketCapETH(marketCapETH, tickSpacing = DEFAULT_TICK_SPACING) {
+  if (marketCapETH <= 0) throw new Error("marketCapETH must be positive");
+  const price = marketCapETH / TOTAL_SUPPLY;
+  const rawTick = Math.log(price) / LOG_BASE;
+  return Math.floor(rawTick / tickSpacing) * tickSpacing;
+}
+function getTickFromMarketCapUSD(marketCapUSD, ethPriceUSD, tickSpacing = DEFAULT_TICK_SPACING) {
+  if (ethPriceUSD <= 0) throw new Error("ethPriceUSD must be positive");
+  return getTickFromMarketCapETH(marketCapUSD / ethPriceUSD, tickSpacing);
+}
+function marketCapFromTickETH(tick) {
+  const price = Math.pow(1.0001, tick);
+  return price * TOTAL_SUPPLY;
+}
+function marketCapFromTickUSD(tick, ethPriceUSD) {
+  return marketCapFromTickETH(tick) * ethPriceUSD;
+}
+function getTickFromMarketCapStable(marketCap, stableDecimals, tickSpacing = DEFAULT_TICK_SPACING) {
+  if (marketCap <= 0) throw new Error("marketCap must be positive");
+  const price = marketCap / Math.pow(10, 29 - stableDecimals);
+  const rawTick = Math.log(price) / LOG_BASE;
+  return Math.floor(rawTick / tickSpacing) * tickSpacing;
+}
+
+// src/utils/positions.ts
+var DEFAULT_TRANCHES_USD = [
+  { upperMarketCapUSD: 5e5, supplyPct: 40 },
+  { upperMarketCapUSD: 1e7, supplyPct: 50 },
+  { upperMarketCapUSD: 1e9, supplyPct: 10 }
+];
+function createPositions(startingMarketCapETH, tranches, tickSpacing = 200) {
+  if (tranches.length === 0) throw new Error("At least one tranche is required");
+  if (tranches.length > 7) throw new Error("Maximum 7 positions allowed");
+  const totalPct = tranches.reduce((sum, t) => sum + t.supplyPct, 0);
+  if (Math.abs(totalPct - 100) > 0.01) {
+    throw new Error(`Tranche percentages must sum to 100, got ${totalPct}`);
+  }
+  for (let i = 1; i < tranches.length; i++) {
+    if (tranches[i].upperMarketCapETH <= tranches[i - 1].upperMarketCapETH) {
+      throw new Error("Tranches must be ordered by ascending upperMarketCapETH");
+    }
+  }
+  const startingTick = getTickFromMarketCapETH(startingMarketCapETH, tickSpacing);
+  const tickLower = [];
+  const tickUpper = [];
+  const positionBps = [];
+  let prevTick = startingTick;
+  for (const tranche of tranches) {
+    const upperTick = getTickFromMarketCapETH(tranche.upperMarketCapETH, tickSpacing);
+    if (upperTick <= prevTick) {
+      throw new Error(
+        `Tranche upper market cap ${tranche.upperMarketCapETH} ETH resolves to tick ${upperTick}, which is not above previous tick ${prevTick}. Increase the market cap or reduce tick spacing.`
+      );
+    }
+    tickLower.push(prevTick);
+    tickUpper.push(upperTick);
+    positionBps.push(Math.round(tranche.supplyPct * 100));
+    prevTick = upperTick;
+  }
+  return { tickLower, tickUpper, positionBps };
+}
+function createPositionsUSD(startingMarketCapUSD, ethPriceUSD, tranches, tickSpacing = 200) {
+  if (ethPriceUSD <= 0) throw new Error("ethPriceUSD must be positive");
+  const ethTranches = tranches.map((t) => ({
+    upperMarketCapETH: t.upperMarketCapUSD / ethPriceUSD,
+    supplyPct: t.supplyPct
+  }));
+  return createPositions(
+    startingMarketCapUSD / ethPriceUSD,
+    ethTranches,
+    tickSpacing
+  );
+}
+function createDefaultPositions(startingMarketCapUSD, ethPriceUSD, tickSpacing = 200) {
+  const positions = createPositionsUSD(
+    startingMarketCapUSD,
+    ethPriceUSD,
+    DEFAULT_TRANCHES_USD,
+    tickSpacing
+  );
+  return {
+    ...positions,
+    tickIfToken0IsLiquid: positions.tickLower[0]
+  };
+}
+function describePositions(positions, ethPriceUSD) {
+  return positions.tickLower.map((_, i) => {
+    const lowerETH = Math.pow(1.0001, positions.tickLower[i]) * 1e11;
+    const upperETH = Math.pow(1.0001, positions.tickUpper[i]) * 1e11;
+    return {
+      index: i,
+      tickLower: positions.tickLower[i],
+      tickUpper: positions.tickUpper[i],
+      supplyPct: positions.positionBps[i] / 100,
+      marketCapLowerETH: lowerETH,
+      marketCapUpperETH: upperETH,
+      ...ethPriceUSD != null && {
+        marketCapLowerUSD: lowerETH * ethPriceUSD,
+        marketCapUpperUSD: upperETH * ethPriceUSD
+      }
+    };
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ADDRESSES,
+  DEFAULTS,
   DEFAULT_CHAIN,
   DEFAULT_CHAIN_ID,
+  DEFAULT_RPC_URL,
+  DEFAULT_TRANCHES_USD,
   ERC20Abi,
   EXTERNAL,
   FEE,
@@ -1358,6 +1730,19 @@ var LiquidSDK = class {
   LiquidSniperAuctionV2Abi,
   LiquidSniperUtilV2Abi,
   LiquidVaultAbi,
-  TOKEN
+  POOL_POSITIONS,
+  TOKEN,
+  createDefaultPositions,
+  createPositions,
+  createPositionsUSD,
+  describePositions,
+  encodeDynamicFeePoolData,
+  encodeSniperAuctionData,
+  encodeStaticFeePoolData,
+  getTickFromMarketCapETH,
+  getTickFromMarketCapStable,
+  getTickFromMarketCapUSD,
+  marketCapFromTickETH,
+  marketCapFromTickUSD
 });
 //# sourceMappingURL=index.js.map