liquid-sdk 1.0.0 → 1.1.0

package/dist/index.mjs

@@ -1,11 +1,11 @@
 // src/client.ts
 import {
   decodeEventLog,
-  encodeAbiParameters,
+  encodeAbiParameters as encodeAbiParameters2,
   encodePacked,
   keccak256,
   getAddress,
-  zeroAddress
+  zeroAddress as zeroAddress2
 } from "viem";
 import { base as base2 } from "viem/chains";
 
@@ -52,8 +52,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 = base;
 var DEFAULT_CHAIN_ID = 8453;
+var DEFAULT_RPC_URL = "https://base.drpc.org";
+
+// src/utils/encoding.ts
+import { encodeAbiParameters, zeroAddress } from "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 = zeroAddress, extensionData = "0x") {
+  const feeData = encodeAbiParameters(StaticFeeInitAbi, [
+    liquidFeeBps * 100,
+    pairedFeeBps * 100
+  ]);
+  return 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 = zeroAddress, extensionData = "0x") {
+  const feeData = encodeAbiParameters(DynamicFeeInitAbi, [
+    config.baseFeeBps * 100,
+    config.maxFeeBps * 100,
+    BigInt(config.referenceTickFilterPeriod),
+    BigInt(config.resetPeriod),
+    config.resetTickFilter,
+    config.feeControlNumerator,
+    config.decayFilterBps
+  ]);
+  return 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 encodeAbiParameters(SniperAuctionInitAbi, [
+    {
+      startingFee: config.startingFee,
+      endingFee: config.endingFee,
+      secondsToDecay: BigInt(config.secondsToDecay)
+    }
+  ]);
+}
 
 // src/abis/LiquidFactory.ts
 var LiquidFactoryAbi = [
@@ -756,7 +902,7 @@ var LiquidSDK = class {
    * The paired token must be WETH for simple dev buys.
    */
   buildDevBuyExtension(devBuy) {
-    const extensionData = encodeAbiParameters(
+    const extensionData = encodeAbiParameters2(
       [
         {
           type: "tuple",
@@ -780,11 +926,11 @@ var LiquidSDK = class {
       [
         {
           pairedTokenPoolKey: {
-            currency0: zeroAddress,
-            currency1: zeroAddress,
+            currency0: zeroAddress2,
+            currency1: zeroAddress2,
             fee: 0,
             tickSpacing: 0,
-            hooks: zeroAddress
+            hooks: zeroAddress2
           },
           pairedTokenAmountOutMinimum: 0n,
           recipient: devBuy.recipient
@@ -798,6 +944,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) {
@@ -821,25 +1058,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 ?? []]
     };
@@ -848,6 +1092,7 @@ var LiquidSDK = class {
         this.buildDevBuyExtension(params.devBuy)
       );
     }
+    this.validateDeploymentConfig(deploymentConfig);
     const msgValue = deploymentConfig.extensionConfigs.reduce(
       (sum, ext) => sum + ext.msgValue,
       0n
@@ -1034,7 +1279,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",
@@ -1073,7 +1318,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",
@@ -1202,7 +1447,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",
@@ -1236,7 +1481,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",
@@ -1252,7 +1497,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",
@@ -1268,7 +1513,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",
@@ -1303,10 +1548,121 @@ 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
+      }
+    };
+  });
+}
 export {
   ADDRESSES,
+  DEFAULTS,
   DEFAULT_CHAIN,
   DEFAULT_CHAIN_ID,
+  DEFAULT_RPC_URL,
+  DEFAULT_TRANCHES_USD,
   ERC20Abi,
   EXTERNAL,
   FEE,
@@ -1321,6 +1677,19 @@ export {
   LiquidSniperAuctionV2Abi,
   LiquidSniperUtilV2Abi,
   LiquidVaultAbi,
-  TOKEN
+  POOL_POSITIONS,
+  TOKEN,
+  createDefaultPositions,
+  createPositions,
+  createPositionsUSD,
+  describePositions,
+  encodeDynamicFeePoolData,
+  encodeSniperAuctionData,
+  encodeStaticFeePoolData,
+  getTickFromMarketCapETH,
+  getTickFromMarketCapStable,
+  getTickFromMarketCapUSD,
+  marketCapFromTickETH,
+  marketCapFromTickUSD
 };
 //# sourceMappingURL=index.mjs.map