liquid-sdk 1.0.0 → 1.2.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,
@@ -36,13 +39,28 @@ __export(index_exports, {
   LiquidSDK: () => LiquidSDK,
   LiquidSniperAuctionV2Abi: () => LiquidSniperAuctionV2Abi,
   LiquidSniperUtilV2Abi: () => LiquidSniperUtilV2Abi,
+  LiquidTokenAbi: () => LiquidTokenAbi,
+  LiquidUniv4EthDevBuyAbi: () => LiquidUniv4EthDevBuyAbi,
   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 +106,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 = [
@@ -709,6 +873,52 @@ var LiquidLpLockerAbi = [
   }
 ];
 
+// src/abis/LiquidToken.ts
+var LiquidTokenAbi = [
+  {
+    type: "function",
+    name: "updateImage",
+    inputs: [{ name: "image_", type: "string" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "updateMetadata",
+    inputs: [{ name: "metadata_", type: "string" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "updateAdmin",
+    inputs: [{ name: "admin_", type: "address" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "UpdateImage",
+    inputs: [{ name: "image", type: "string", indexed: false }],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "UpdateMetadata",
+    inputs: [{ name: "metadata", type: "string", indexed: false }],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "UpdateAdmin",
+    inputs: [
+      { name: "oldAdmin", type: "address", indexed: false },
+      { name: "newAdmin", type: "address", indexed: false }
+    ],
+    anonymous: false
+  }
+];
+
 // src/abis/ERC20.ts
 var ERC20Abi = [
   {
@@ -792,7 +1002,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 +1026,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 +1044,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 +1146,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 +1158,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 +1192,7 @@ var LiquidSDK = class {
         this.buildDevBuyExtension(params.devBuy)
       );
     }
+    this.validateDeploymentConfig(deploymentConfig);
     const msgValue = deploymentConfig.extensionConfigs.reduce(
       (sum, ext) => sum + ext.msgValue,
       0n
@@ -902,7 +1211,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 +1224,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 +1379,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 +1418,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 +1547,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 +1581,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 +1597,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 +1613,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",
@@ -1338,12 +1647,347 @@ var LiquidSDK = class {
       args: [poolId]
     });
   }
+  // ── Token Metadata Updates ──────────────────────────────────────────
+  /**
+   * Update a token's image. Must be called by the token admin.
+   */
+  async updateImage(tokenAddress, newImage) {
+    if (!this.walletClient?.account) {
+      throw new Error("walletClient with account required for updateImage");
+    }
+    return await this.walletClient.writeContract({
+      address: tokenAddress,
+      abi: LiquidTokenAbi,
+      functionName: "updateImage",
+      args: [newImage],
+      chain: import_chains2.base,
+      account: this.walletClient.account
+    });
+  }
+  /**
+   * Update a token's metadata. Must be called by the token admin.
+   */
+  async updateMetadata(tokenAddress, newMetadata) {
+    if (!this.walletClient?.account) {
+      throw new Error("walletClient with account required for updateMetadata");
+    }
+    return await this.walletClient.writeContract({
+      address: tokenAddress,
+      abi: LiquidTokenAbi,
+      functionName: "updateMetadata",
+      args: [newMetadata],
+      chain: import_chains2.base,
+      account: this.walletClient.account
+    });
+  }
+  // ── Token Discovery ─────────────────────────────────────────────────
+  /**
+   * Get all tokens deployed by a specific address by querying TokenCreated events.
+   * @param deployer - The address that deployed the tokens (msgSender)
+   * @param fromBlock - Starting block to search from (defaults to 0n)
+   * @param toBlock - Ending block to search to (defaults to 'latest')
+   */
+  async getDeployedTokens(deployer, fromBlock, toBlock) {
+    const logs = await this.publicClient.getLogs({
+      address: ADDRESSES.FACTORY,
+      event: (0, import_viem2.parseAbiItem)(
+        "event TokenCreated(address msgSender, address indexed tokenAddress, address indexed tokenAdmin, string tokenImage, string tokenName, string tokenSymbol, string tokenMetadata, string tokenContext, int24 startingTick, address poolHook, bytes32 poolId, address pairedToken, address locker, address mevModule, uint256 extensionsSupply, address[] extensions)"
+      ),
+      fromBlock: fromBlock ?? 0n,
+      toBlock: toBlock ?? "latest"
+    });
+    return logs.filter((log) => {
+      const sender = log.args.msgSender;
+      return sender && (0, import_viem2.getAddress)(sender) === (0, import_viem2.getAddress)(deployer);
+    }).map((log) => {
+      const args = log.args;
+      return {
+        msgSender: args.msgSender,
+        tokenAddress: args.tokenAddress,
+        tokenAdmin: args.tokenAdmin,
+        tokenImage: args.tokenImage,
+        tokenName: args.tokenName,
+        tokenSymbol: args.tokenSymbol,
+        tokenMetadata: args.tokenMetadata,
+        tokenContext: args.tokenContext,
+        startingTick: args.startingTick,
+        poolHook: args.poolHook,
+        poolId: args.poolId,
+        pairedToken: args.pairedToken,
+        locker: args.locker,
+        mevModule: args.mevModule,
+        extensionsSupply: args.extensionsSupply,
+        extensions: args.extensions
+      };
+    });
+  }
 };
+
+// src/abis/LiquidUniv4EthDevBuy.ts
+var LiquidUniv4EthDevBuyAbi = [
+  {
+    type: "constructor",
+    inputs: [
+      { name: "factory_", type: "address" },
+      { name: "weth_", type: "address" },
+      { name: "universalRouter_", type: "address" },
+      { name: "permit2_", type: "address" }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "factory",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "weth",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "universalRouter",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "permit2",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "receiveTokens",
+    inputs: [
+      {
+        name: "deploymentConfig",
+        type: "tuple",
+        components: [
+          {
+            name: "tokenConfig",
+            type: "tuple",
+            components: [
+              { name: "tokenAdmin", type: "address" },
+              { name: "name", type: "string" },
+              { name: "symbol", type: "string" },
+              { name: "salt", type: "bytes32" },
+              { name: "image", type: "string" },
+              { name: "metadata", type: "string" },
+              { name: "context", type: "string" },
+              { name: "originatingChainId", type: "uint256" }
+            ]
+          },
+          {
+            name: "poolConfig",
+            type: "tuple",
+            components: [
+              { name: "hook", type: "address" },
+              { name: "pairedToken", type: "address" },
+              { name: "tickIfToken0IsLiquid", type: "int24" },
+              { name: "tickSpacing", type: "int24" },
+              { name: "poolData", type: "bytes" }
+            ]
+          },
+          {
+            name: "lockerConfig",
+            type: "tuple",
+            components: [
+              { name: "locker", type: "address" },
+              { name: "rewardAdmins", type: "address[]" },
+              { name: "rewardRecipients", type: "address[]" },
+              { name: "rewardBps", type: "uint16[]" },
+              { name: "tickLower", type: "int24[]" },
+              { name: "tickUpper", type: "int24[]" },
+              { name: "positionBps", type: "uint16[]" },
+              { name: "lockerData", type: "bytes" }
+            ]
+          },
+          {
+            name: "mevModuleConfig",
+            type: "tuple",
+            components: [
+              { name: "mevModule", type: "address" },
+              { name: "mevModuleData", type: "bytes" }
+            ]
+          },
+          {
+            name: "extensionConfigs",
+            type: "tuple[]",
+            components: [
+              { name: "extension", type: "address" },
+              { name: "msgValue", type: "uint256" },
+              { name: "extensionBps", type: "uint16" },
+              { name: "extensionData", type: "bytes" }
+            ]
+          }
+        ]
+      },
+      {
+        name: "tokenPoolKey",
+        type: "tuple",
+        components: [
+          { name: "currency0", type: "address" },
+          { name: "currency1", type: "address" },
+          { name: "fee", type: "uint24" },
+          { name: "tickSpacing", type: "int24" },
+          { name: "hooks", type: "address" }
+        ]
+      },
+      { name: "token", type: "address" },
+      { name: "extensionSupply", type: "uint256" },
+      { name: "extensionIndex", type: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "payable"
+  },
+  {
+    type: "function",
+    name: "supportsInterface",
+    inputs: [{ name: "interfaceId", type: "bytes4" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "pure"
+  },
+  {
+    type: "event",
+    name: "EthDevBuy",
+    inputs: [
+      { name: "token", type: "address", indexed: true },
+      { name: "user", type: "address", indexed: true },
+      { name: "ethAmount", type: "uint256", indexed: false },
+      { name: "tokenAmount", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  { type: "error", name: "InvalidEthDevBuyPercentage", inputs: [] },
+  { type: "error", name: "InvalidMsgValue", inputs: [] },
+  { type: "error", name: "InvalidPairedTokenPoolKey", inputs: [] },
+  { type: "error", name: "ReentrancyGuardReentrantCall", inputs: [] },
+  { type: "error", name: "Unauthorized", inputs: [] }
+];
+
+// 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,
@@ -1357,7 +2001,22 @@ var LiquidSDK = class {
   LiquidSDK,
   LiquidSniperAuctionV2Abi,
   LiquidSniperUtilV2Abi,
+  LiquidTokenAbi,
+  LiquidUniv4EthDevBuyAbi,
   LiquidVaultAbi,
-  TOKEN
+  POOL_POSITIONS,
+  TOKEN,
+  createDefaultPositions,
+  createPositions,
+  createPositionsUSD,
+  describePositions,
+  encodeDynamicFeePoolData,
+  encodeSniperAuctionData,
+  encodeStaticFeePoolData,
+  getTickFromMarketCapETH,
+  getTickFromMarketCapStable,
+  getTickFromMarketCapUSD,
+  marketCapFromTickETH,
+  marketCapFromTickUSD
 });
 //# sourceMappingURL=index.js.map