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

package/dist/chunk-TKSHYEYA.mjs

@@ -0,0 +1,1706 @@
+import { computeOptimalGamma } from './chunk-MNJ5OYPE.mjs';
+import { isToken0Expected } from './chunk-NNNCVFOH.mjs';
+import { MIN_TICK, MAX_TICK } from './chunk-KDT76YQE.mjs';
+import { airlockAbi, bundlerAbi } from './chunk-OTG75GVH.mjs';
+import { DEFAULT_V3_MAX_SHARE_TO_BE_SOLD, DEFAULT_V3_NUM_POSITIONS, DEFAULT_V4_YEARLY_MINT_RATE, DEFAULT_V3_INITIAL_VOTING_DELAY, DEFAULT_V3_INITIAL_VOTING_PERIOD, DEFAULT_V3_INITIAL_PROPOSAL_THRESHOLD, ZERO_ADDRESS, DEFAULT_CREATE_GAS_LIMIT, DEFAULT_PD_SLUGS, DEFAULT_V4_INITIAL_VOTING_DELAY, DEFAULT_V4_INITIAL_VOTING_PERIOD, DEFAULT_V4_INITIAL_PROPOSAL_THRESHOLD, TICK_SPACINGS, DEFAULT_V3_YEARLY_MINT_RATE, WAD, FLAG_MASK } from './chunk-QKO2FZGN.mjs';
+import { getAddresses, CHAIN_IDS } from './chunk-AW3WR2D3.mjs';
+import { DopplerBytecodeBaseMainnet, DopplerBytecode, DopplerDN404Bytecode, DERC20Bytecode } from './chunk-4TROGENW.mjs';
+import { encodeAbiParameters, decodeEventLog, toHex, zeroAddress, keccak256, encodePacked, getAddress } from 'viem';
+
+var MAX_UINT128 = (1n << 128n) - 1n;
+var DopplerFactory = class {
+  constructor(publicClient, walletClient, chainId) {
+    this.multicurveBundlerSupport = /* @__PURE__ */ new Map();
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.chainId = chainId;
+  }
+  /**
+   * Set a custom migration data encoder function
+   * @param encoder Custom function to encode migration data
+   * @returns The factory instance for method chaining
+   */
+  withCustomMigrationEncoder(encoder) {
+    this.customMigrationEncoder = encoder;
+    return this;
+  }
+  async encodeCreateStaticAuctionParams(params) {
+    this.validateStaticAuctionParams(params);
+    const addresses = getAddresses(this.chainId);
+    const hasBeneficiaries = params.pool.beneficiaries && params.pool.beneficiaries.length > 0;
+    let poolInitializerData;
+    if (hasBeneficiaries) {
+      const sortedBeneficiaries = params.pool.beneficiaries.slice().sort((a, b) => {
+        const aAddr = a.beneficiary.toLowerCase();
+        const bAddr = b.beneficiary.toLowerCase();
+        return aAddr < bAddr ? -1 : aAddr > bAddr ? 1 : 0;
+      });
+      poolInitializerData = encodeAbiParameters(
+        [
+          {
+            type: "tuple",
+            components: [
+              { type: "uint24", name: "fee" },
+              { type: "int24", name: "tickLower" },
+              { type: "int24", name: "tickUpper" },
+              { type: "uint16", name: "numPositions" },
+              { type: "uint256", name: "maxShareToBeSold" },
+              {
+                type: "tuple[]",
+                name: "beneficiaries",
+                components: [
+                  { type: "address", name: "beneficiary" },
+                  { type: "uint96", name: "shares" }
+                ]
+              }
+            ]
+          }
+        ],
+        [{
+          fee: params.pool.fee,
+          tickLower: params.pool.startTick,
+          tickUpper: params.pool.endTick,
+          numPositions: params.pool.numPositions ?? DEFAULT_V3_NUM_POSITIONS,
+          maxShareToBeSold: params.pool.maxShareToBeSold ?? DEFAULT_V3_MAX_SHARE_TO_BE_SOLD,
+          beneficiaries: sortedBeneficiaries.map((b) => ({
+            beneficiary: b.beneficiary,
+            shares: b.shares
+          }))
+        }]
+      );
+    } else {
+      poolInitializerData = encodeAbiParameters(
+        [
+          {
+            type: "tuple",
+            components: [
+              { type: "uint24", name: "fee" },
+              { type: "int24", name: "tickLower" },
+              { type: "int24", name: "tickUpper" },
+              { type: "uint16", name: "numPositions" },
+              { type: "uint256", name: "maxShareToBeSold" }
+            ]
+          }
+        ],
+        [{
+          fee: params.pool.fee,
+          tickLower: params.pool.startTick,
+          tickUpper: params.pool.endTick,
+          numPositions: params.pool.numPositions ?? DEFAULT_V3_NUM_POSITIONS,
+          maxShareToBeSold: params.pool.maxShareToBeSold ?? DEFAULT_V3_MAX_SHARE_TO_BE_SOLD
+        }]
+      );
+    }
+    const liquidityMigratorData = this.encodeMigrationData(params.migration);
+    let tokenFactoryData;
+    if (this.isDoppler404Token(params.token)) {
+      const token404 = params.token;
+      const baseURI = token404.baseURI;
+      const unit = token404.unit !== void 0 ? BigInt(token404.unit) : 1000n;
+      tokenFactoryData = encodeAbiParameters(
+        [
+          { type: "string" },
+          { type: "string" },
+          { type: "string" },
+          { type: "uint256" }
+        ],
+        [
+          params.token.name,
+          params.token.symbol,
+          baseURI,
+          unit
+        ]
+      );
+    } else {
+      const tokenStd = params.token;
+      const vestingDuration = params.vesting?.duration ?? BigInt(0);
+      const yearlyMintRate = tokenStd.yearlyMintRate ?? DEFAULT_V4_YEARLY_MINT_RATE;
+      let vestingRecipients = [];
+      let vestingAmounts = [];
+      if (params.vesting) {
+        if (params.vesting.recipients && params.vesting.amounts) {
+          vestingRecipients = params.vesting.recipients;
+          vestingAmounts = params.vesting.amounts;
+        } else {
+          vestingRecipients = [params.userAddress];
+          vestingAmounts = [params.sale.initialSupply - params.sale.numTokensToSell];
+        }
+      }
+      tokenFactoryData = encodeAbiParameters(
+        [
+          { type: "string" },
+          { type: "string" },
+          { type: "uint256" },
+          { type: "uint256" },
+          { type: "address[]" },
+          { type: "uint256[]" },
+          { type: "string" }
+        ],
+        [
+          tokenStd.name,
+          tokenStd.symbol,
+          yearlyMintRate,
+          BigInt(vestingDuration),
+          vestingRecipients,
+          vestingAmounts,
+          tokenStd.tokenURI
+        ]
+      );
+    }
+    const useNoOpGovernance = params.governance.type === "noOp";
+    const governanceFactoryData = useNoOpGovernance ? "0x" : encodeAbiParameters(
+      [
+        { type: "string" },
+        { type: "uint48" },
+        { type: "uint32" },
+        { type: "uint256" }
+      ],
+      [
+        params.token.name,
+        params.governance.type === "custom" ? params.governance.initialVotingDelay : DEFAULT_V3_INITIAL_VOTING_DELAY,
+        params.governance.type === "custom" ? params.governance.initialVotingPeriod : DEFAULT_V3_INITIAL_VOTING_PERIOD,
+        params.governance.type === "custom" ? params.governance.initialProposalThreshold : DEFAULT_V3_INITIAL_PROPOSAL_THRESHOLD
+      ]
+    );
+    const governanceFactoryAddress = (() => {
+      if (useNoOpGovernance) {
+        const resolved2 = params.modules?.governanceFactory ?? (addresses.noOpGovernanceFactory ?? ZERO_ADDRESS);
+        if (!resolved2 || resolved2 === ZERO_ADDRESS) {
+          throw new Error("No-op governance requested, but no-op governanceFactory is not configured on this chain. Provide a governanceFactory override or use a supported chain.");
+        }
+        return resolved2;
+      }
+      const resolved = params.modules?.governanceFactory ?? addresses.governanceFactory;
+      if (!resolved || resolved === ZERO_ADDRESS) {
+        throw new Error("Standard governance requested but governanceFactory is not deployed on this chain.");
+      }
+      return resolved;
+    })();
+    const resolvedTokenFactory = params.modules?.tokenFactory ?? (this.isDoppler404Token(params.token) ? addresses.doppler404Factory : addresses.tokenFactory);
+    if (!resolvedTokenFactory || resolvedTokenFactory === ZERO_ADDRESS) {
+      throw new Error("Token factory address not configured. Provide an explicit address via builder.withTokenFactory(...) or ensure chain config includes a valid factory.");
+    }
+    const baseCreateParams = {
+      initialSupply: params.sale.initialSupply,
+      numTokensToSell: params.sale.numTokensToSell,
+      numeraire: params.sale.numeraire,
+      tokenFactory: resolvedTokenFactory,
+      tokenFactoryData,
+      governanceFactory: governanceFactoryAddress,
+      governanceFactoryData,
+      poolInitializer: (() => {
+        if (hasBeneficiaries) {
+          const lockableInitializer = params.modules?.lockableV3Initializer ?? addresses.lockableV3Initializer;
+          if (!lockableInitializer) {
+            throw new Error("Lockable V3 initializer address not configured on this chain. Required when using beneficiaries.");
+          }
+          return lockableInitializer;
+        }
+        return params.modules?.v3Initializer ?? addresses.v3Initializer;
+      })(),
+      poolInitializerData,
+      liquidityMigrator: this.getMigratorAddress(params.migration, params.modules),
+      liquidityMigratorData,
+      integrator: params.integrator ?? ZERO_ADDRESS
+    };
+    const minedCreateParams = await this.mineTokenOrder({
+      params,
+      baseCreateParams,
+      addresses
+    });
+    return minedCreateParams;
+  }
+  /**
+   * Simulate a static auction creation and return predicted addresses.
+   * Useful for pre-buy flows (bundle) to know the token/pool before sending.
+   */
+  async simulateCreateStaticAuction(params) {
+    const createParams = await this.encodeCreateStaticAuctionParams(params);
+    const addresses = getAddresses(this.chainId);
+    const airlockAddress = params.modules?.airlock ?? addresses.airlock;
+    const { request, result } = await this.publicClient.simulateContract({
+      address: airlockAddress,
+      abi: airlockAbi,
+      functionName: "create",
+      args: [{ ...createParams }],
+      account: this.walletClient?.account
+    });
+    const simResult = result;
+    const gasEstimate = await this.resolveCreateGasEstimate({
+      request,
+      address: airlockAddress,
+      createParams,
+      account: this.walletClient?.account ?? params.userAddress
+    });
+    if (!simResult || !Array.isArray(simResult) || simResult.length < 2) {
+      throw new Error("Failed to simulate static auction create");
+    }
+    return {
+      createParams,
+      asset: simResult[0],
+      pool: simResult[1],
+      gasEstimate,
+      execute: () => this.createStaticAuction(params, { _createParams: createParams })
+    };
+  }
+  /**
+   * Create a new static auction (using Uniswap V3 for initial liquidity)
+   * @param params Configuration for the static auction
+   * @returns The address of the created pool and token
+   */
+  async createStaticAuction(params, options) {
+    const createParams = options?._createParams ?? await this.encodeCreateStaticAuctionParams(params);
+    const addresses = getAddresses(this.chainId);
+    if (!this.walletClient) {
+      throw new Error("Wallet client required for write operations");
+    }
+    const airlockAddress = params.modules?.airlock ?? addresses.airlock;
+    const { request, result } = await this.publicClient.simulateContract({
+      address: airlockAddress,
+      abi: airlockAbi,
+      functionName: "create",
+      args: [{ ...createParams }],
+      account: this.walletClient.account
+    });
+    const simResult = result;
+    const gasEstimate = await this.resolveCreateGasEstimate({
+      request,
+      address: airlockAddress,
+      createParams,
+      account: this.walletClient.account
+    });
+    const gasOverride = params.gas ?? gasEstimate ?? DEFAULT_CREATE_GAS_LIMIT;
+    const hash = await this.walletClient.writeContract({ ...request, gas: gasOverride });
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash, confirmations: 2 });
+    if (simResult && Array.isArray(simResult) && simResult.length >= 2) {
+      return {
+        tokenAddress: simResult[0],
+        // asset
+        poolAddress: simResult[1],
+        // pool
+        transactionHash: hash
+      };
+    }
+    const createEvent = receipt.logs.find((log) => {
+      try {
+        const decoded = decodeEventLog({
+          abi: airlockAbi,
+          data: log.data,
+          topics: log.topics
+        });
+        return decoded.eventName === "Create";
+      } catch {
+        return false;
+      }
+    });
+    if (createEvent) {
+      const decoded = decodeEventLog({
+        abi: airlockAbi,
+        data: createEvent.data,
+        topics: createEvent.topics
+      });
+      if (decoded.eventName === "Create") {
+        return {
+          poolAddress: decoded.args.poolOrHook,
+          tokenAddress: decoded.args.asset,
+          transactionHash: hash
+        };
+      }
+    }
+    throw new Error("Failed to get pool and token addresses from transaction");
+  }
+  /**
+   * Generate a random salt based on user address
+   */
+  generateRandomSalt(account) {
+    const array = new Uint8Array(32);
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      crypto.getRandomValues(array);
+    } else {
+      const timestamp = Date.now();
+      const timestampBytes = new Uint8Array(8);
+      for (let i = 0; i < 8; i++) {
+        timestampBytes[i] = timestamp >> i * 8 & 255;
+      }
+      for (let i = 0; i < 32; i++) {
+        if (i < 8) {
+          array[i] = timestampBytes[i];
+        } else {
+          array[i] = i;
+        }
+      }
+    }
+    if (account) {
+      const addressBytes = account.slice(2).padStart(40, "0");
+      for (let i = 0; i < 20; i++) {
+        const addressByte = parseInt(
+          addressBytes.slice(i * 2, (i + 1) * 2),
+          16
+        );
+        array[i] ^= addressByte;
+      }
+    }
+    return `0x${Array.from(array).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+  }
+  /**
+   * Iteratively mine a salt that ensures the newly created token sorts after the numeraire.
+   * This mirrors the legacy SDK behaviour so tick configuration can assume the numeraire is token0.
+   */
+  async mineTokenOrder(args) {
+    const { params, baseCreateParams, addresses } = args;
+    const airlockAddress = params.modules?.airlock ?? addresses.airlock;
+    if (!airlockAddress || airlockAddress === ZERO_ADDRESS) {
+      throw new Error("Airlock address not configured. Provide an explicit address via modules.airlock or ensure chain config includes a valid airlock.");
+    }
+    const accountForSimulation = this.walletClient?.account ?? params.userAddress;
+    const numeraireBigInt = BigInt(params.sale.numeraire);
+    let attempt = 0n;
+    const maxAttempts = 256n;
+    let salt = this.generateRandomSalt(params.userAddress);
+    while (attempt < maxAttempts) {
+      const createParams = { ...baseCreateParams, salt };
+      const { result } = await this.publicClient.simulateContract({
+        address: airlockAddress,
+        abi: airlockAbi,
+        functionName: "create",
+        args: [{ ...createParams }],
+        account: accountForSimulation
+      });
+      const simResult = result;
+      if (!simResult || !Array.isArray(simResult) || simResult.length < 2) {
+        throw new Error("Failed to simulate static auction create while mining token ordering");
+      }
+      const tokenAddress = simResult[0];
+      if (BigInt(tokenAddress) > numeraireBigInt) {
+        return createParams;
+      }
+      attempt += 1n;
+      const incrementedAccount = toHex(BigInt(params.userAddress) + attempt);
+      salt = this.generateRandomSalt(incrementedAccount);
+    }
+    throw new Error("Token mining exceeded iteration limit while trying to force token order. Try again or provide a different user address.");
+  }
+  async encodeCreateDynamicAuctionParams(params) {
+    this.validateDynamicAuctionParams(params);
+    const addresses = getAddresses(this.chainId);
+    const gamma = params.auction.gamma ?? computeOptimalGamma(
+      params.auction.startTick,
+      params.auction.endTick,
+      params.auction.duration,
+      params.auction.epochLength,
+      params.pool.tickSpacing
+    );
+    let blockTimestamp;
+    if (params.blockTimestamp !== void 0) {
+      blockTimestamp = params.blockTimestamp;
+    } else {
+      const latestBlock = await this.publicClient.getBlock({ blockTag: "latest" });
+      blockTimestamp = Number(latestBlock.timestamp);
+    }
+    const startTimeOffset = params.startTimeOffset ?? 30;
+    const startTime = blockTimestamp + startTimeOffset;
+    const endTime = blockTimestamp + params.auction.duration + startTimeOffset;
+    const dopplerData = {
+      minimumProceeds: params.auction.minProceeds,
+      maximumProceeds: params.auction.maxProceeds,
+      startingTime: BigInt(startTime),
+      endingTime: BigInt(endTime),
+      startingTick: params.auction.startTick,
+      endingTick: params.auction.endTick,
+      epochLength: BigInt(params.auction.epochLength),
+      gamma,
+      isToken0: false,
+      // Will be determined during mining
+      numPDSlugs: BigInt(params.auction.numPdSlugs ?? DEFAULT_PD_SLUGS),
+      fee: params.pool.fee,
+      tickSpacing: params.pool.tickSpacing
+    };
+    if (this.isDoppler404Token(params.token)) {
+      if (!addresses.doppler404Factory || addresses.doppler404Factory === ZERO_ADDRESS) {
+        throw new Error("Doppler404 factory address not configured for this chain");
+      }
+    }
+    const vestingDuration = params.vesting?.duration ?? BigInt(0);
+    const tokenFactoryData = this.isDoppler404Token(params.token) ? (() => {
+      const t = params.token;
+      return {
+        name: t.name,
+        symbol: t.symbol,
+        baseURI: t.baseURI,
+        unit: t.unit !== void 0 ? BigInt(t.unit) : 1000n
+      };
+    })() : (() => {
+      const t = params.token;
+      let vestingRecipients = [];
+      let vestingAmounts = [];
+      if (params.vesting) {
+        if (params.vesting.recipients && params.vesting.amounts) {
+          vestingRecipients = params.vesting.recipients;
+          vestingAmounts = params.vesting.amounts;
+        } else {
+          vestingRecipients = [params.userAddress];
+          vestingAmounts = [params.sale.initialSupply - params.sale.numTokensToSell];
+        }
+      }
+      return {
+        name: t.name,
+        symbol: t.symbol,
+        initialSupply: params.sale.initialSupply,
+        airlock: addresses.airlock,
+        yearlyMintRate: t.yearlyMintRate ?? DEFAULT_V4_YEARLY_MINT_RATE,
+        vestingDuration: BigInt(vestingDuration),
+        recipients: vestingRecipients,
+        amounts: vestingAmounts,
+        tokenURI: t.tokenURI
+      };
+    })();
+    const resolvedTokenFactoryDyn = params.modules?.tokenFactory ?? (this.isDoppler404Token(params.token) ? addresses.doppler404Factory : addresses.tokenFactory);
+    if (!resolvedTokenFactoryDyn || resolvedTokenFactoryDyn === ZERO_ADDRESS) {
+      throw new Error("Token factory address not configured. Provide an explicit address via builder.withTokenFactory(...) or ensure chain config includes a valid factory.");
+    }
+    const [salt, hookAddress, tokenAddress, poolInitializerData, encodedTokenFactoryData] = this.mineHookAddress({
+      airlock: params.modules?.airlock ?? addresses.airlock,
+      poolManager: params.modules?.poolManager ?? addresses.poolManager,
+      deployer: params.modules?.dopplerDeployer ?? addresses.dopplerDeployer,
+      initialSupply: params.sale.initialSupply,
+      numTokensToSell: params.sale.numTokensToSell,
+      numeraire: params.sale.numeraire,
+      tokenFactory: resolvedTokenFactoryDyn,
+      tokenFactoryData,
+      poolInitializer: params.modules?.v4Initializer ?? addresses.v4Initializer,
+      poolInitializerData: dopplerData,
+      tokenVariant: this.isDoppler404Token(params.token) ? "doppler404" : "standard"
+    });
+    const liquidityMigratorData = this.encodeMigrationData(params.migration);
+    const useNoOpGovernance = params.governance.type === "noOp";
+    const governanceFactoryData = useNoOpGovernance ? "0x" : encodeAbiParameters(
+      [
+        { type: "string" },
+        { type: "uint48" },
+        { type: "uint32" },
+        { type: "uint256" }
+      ],
+      [
+        params.token.name,
+        params.governance.type === "custom" ? params.governance.initialVotingDelay : DEFAULT_V4_INITIAL_VOTING_DELAY,
+        params.governance.type === "custom" ? params.governance.initialVotingPeriod : DEFAULT_V4_INITIAL_VOTING_PERIOD,
+        params.governance.type === "custom" ? params.governance.initialProposalThreshold : DEFAULT_V4_INITIAL_PROPOSAL_THRESHOLD
+      ]
+    );
+    const governanceFactoryAddress = (() => {
+      if (useNoOpGovernance) {
+        const resolved2 = params.modules?.governanceFactory ?? (addresses.noOpGovernanceFactory ?? ZERO_ADDRESS);
+        if (!resolved2 || resolved2 === ZERO_ADDRESS) {
+          throw new Error("No-op governance requested, but no-op governanceFactory is not configured on this chain. Provide a governanceFactory override or use a supported chain.");
+        }
+        return resolved2;
+      }
+      const resolved = params.modules?.governanceFactory ?? addresses.governanceFactory;
+      if (!resolved || resolved === ZERO_ADDRESS) {
+        throw new Error("Standard governance requested but governanceFactory is not deployed on this chain.");
+      }
+      return resolved;
+    })();
+    const createParams = {
+      initialSupply: params.sale.initialSupply,
+      numTokensToSell: params.sale.numTokensToSell,
+      numeraire: params.sale.numeraire,
+      tokenFactory: resolvedTokenFactoryDyn,
+      tokenFactoryData: encodedTokenFactoryData,
+      governanceFactory: governanceFactoryAddress,
+      governanceFactoryData,
+      poolInitializer: params.modules?.v4Initializer ?? addresses.v4Initializer,
+      poolInitializerData,
+      liquidityMigrator: this.getMigratorAddress(params.migration, params.modules),
+      liquidityMigratorData,
+      integrator: params.integrator ?? ZERO_ADDRESS,
+      salt
+    };
+    return { createParams, hookAddress, tokenAddress };
+  }
+  /**
+   * Create a new dynamic auction (using Uniswap V4 hook for gradual Dutch auction)
+   * @param params Configuration for the dynamic auction
+   * @returns The address of the created hook and token
+   */
+  async createDynamicAuction(params, options) {
+    const addresses = getAddresses(this.chainId);
+    let createParams;
+    let hookAddress;
+    let tokenAddress;
+    if (options?._createParams) {
+      createParams = options._createParams;
+    } else {
+      const encoded = await this.encodeCreateDynamicAuctionParams(params);
+      createParams = encoded.createParams;
+      hookAddress = encoded.hookAddress;
+      tokenAddress = encoded.tokenAddress;
+    }
+    if (!this.walletClient) {
+      throw new Error("Wallet client required for write operations");
+    }
+    const airlockAddress = params.modules?.airlock ?? addresses.airlock;
+    const { request, result } = await this.publicClient.simulateContract({
+      address: airlockAddress,
+      abi: airlockAbi,
+      functionName: "create",
+      args: [{ ...createParams }],
+      account: this.walletClient.account
+    });
+    const simResult = result;
+    const gasEstimate = await this.resolveCreateGasEstimate({
+      request,
+      address: airlockAddress,
+      createParams,
+      account: this.walletClient.account
+    });
+    const gasOverride = params.gas ?? gasEstimate ?? DEFAULT_CREATE_GAS_LIMIT;
+    const hash = await this.walletClient.writeContract({ ...request, gas: gasOverride });
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    let actualHookAddress = hookAddress ?? "";
+    let actualTokenAddress = tokenAddress ?? "";
+    if (simResult && Array.isArray(simResult) && simResult.length >= 2) {
+      actualTokenAddress = simResult[0];
+      actualHookAddress = simResult[1];
+    } else {
+      const createEvent = receipt.logs.find((log) => {
+        try {
+          const decoded = decodeEventLog({
+            abi: airlockAbi,
+            data: log.data,
+            topics: log.topics
+          });
+          return decoded.eventName === "Create";
+        } catch {
+          return false;
+        }
+      });
+      if (createEvent) {
+        const decoded = decodeEventLog({
+          abi: airlockAbi,
+          data: createEvent.data,
+          topics: createEvent.topics
+        });
+        if (decoded.eventName === "Create") {
+          actualHookAddress = decoded.args.poolOrHook;
+          actualTokenAddress = decoded.args.asset;
+        }
+      }
+    }
+    const poolId = this.computePoolId({
+      currency0: actualTokenAddress < params.sale.numeraire ? actualTokenAddress : params.sale.numeraire,
+      currency1: actualTokenAddress < params.sale.numeraire ? params.sale.numeraire : actualTokenAddress,
+      fee: params.pool.fee,
+      tickSpacing: params.pool.tickSpacing,
+      hooks: actualHookAddress
+    });
+    return {
+      hookAddress: actualHookAddress,
+      tokenAddress: actualTokenAddress,
+      poolId,
+      transactionHash: hash
+    };
+  }
+  /**
+   * Simulate a dynamic auction creation and return predicted addresses and poolId.
+   * Useful for clients that need the hook/token/poolId before submitting the tx.
+   */
+  async simulateCreateDynamicAuction(params) {
+    const { createParams } = await this.encodeCreateDynamicAuctionParams(params);
+    const addresses = getAddresses(this.chainId);
+    const airlockAddress = params.modules?.airlock ?? addresses.airlock;
+    const { request, result } = await this.publicClient.simulateContract({
+      address: airlockAddress,
+      abi: airlockAbi,
+      functionName: "create",
+      args: [{ ...createParams }],
+      account: this.walletClient?.account
+    });
+    const simResult = result;
+    const gasEstimate = await this.resolveCreateGasEstimate({
+      request,
+      address: airlockAddress,
+      createParams,
+      account: this.walletClient?.account ?? params.userAddress
+    });
+    if (!simResult || !Array.isArray(simResult) || simResult.length < 2) {
+      throw new Error("Failed to simulate dynamic auction create");
+    }
+    const tokenAddress = simResult[0];
+    const hookAddress = simResult[1];
+    const poolId = this.computePoolId({
+      currency0: tokenAddress < params.sale.numeraire ? tokenAddress : params.sale.numeraire,
+      currency1: tokenAddress < params.sale.numeraire ? params.sale.numeraire : tokenAddress,
+      fee: params.pool.fee,
+      tickSpacing: params.pool.tickSpacing,
+      hooks: hookAddress
+    });
+    return {
+      createParams,
+      hookAddress,
+      tokenAddress,
+      poolId,
+      gasEstimate,
+      execute: () => this.createDynamicAuction(params, { _createParams: createParams })
+    };
+  }
+  async resolveCreateGasEstimate(args) {
+    const { request, address, createParams, account } = args;
+    const gasFromRequest = request && typeof request === "object" && "gas" in request ? request.gas : void 0;
+    if (gasFromRequest) {
+      return gasFromRequest;
+    }
+    try {
+      const estimated = await this.publicClient.estimateContractGas({
+        address,
+        abi: airlockAbi,
+        functionName: "create",
+        args: [{ ...createParams }],
+        account
+      });
+      return estimated;
+    } catch {
+      return void 0;
+    }
+  }
+  isDoppler404Token(token) {
+    return token.type === "doppler404";
+  }
+  /**
+   * Encode migration data based on the MigrationConfig
+   * This replaces the manual encoding methods from the old SDKs
+   */
+  encodeMigrationData(config) {
+    if (this.customMigrationEncoder) {
+      return this.customMigrationEncoder(config);
+    }
+    switch (config.type) {
+      case "uniswapV2":
+        return "0x";
+      case "noOp":
+        return "0x";
+      case "uniswapV3":
+        const expectedSpacing = TICK_SPACINGS[config.fee];
+        if (expectedSpacing !== void 0 && config.tickSpacing === expectedSpacing) {
+          return "0x";
+        }
+        return encodeAbiParameters(
+          [
+            { type: "uint24" },
+            // fee
+            { type: "int24" }
+            // tickSpacing
+          ],
+          [config.fee, config.tickSpacing]
+        );
+      case "uniswapV4":
+        const streamableFees = config.streamableFees;
+        if (!streamableFees) {
+          return "0x";
+        }
+        const beneficiaryData = [...streamableFees.beneficiaries].sort((a, b) => {
+          const addrA = a.beneficiary.toLowerCase();
+          const addrB = b.beneficiary.toLowerCase();
+          return addrA < addrB ? -1 : addrA > addrB ? 1 : 0;
+        });
+        return encodeAbiParameters(
+          [
+            { type: "uint24" },
+            // fee
+            { type: "int24" },
+            // tickSpacing
+            { type: "uint32" },
+            // lockDuration (0 if no streamableFees)
+            {
+              type: "tuple[]",
+              components: [
+                { type: "address", name: "beneficiary" },
+                { type: "uint96", name: "shares" }
+              ]
+            }
+          ],
+          [
+            config.fee,
+            config.tickSpacing,
+            streamableFees.lockDuration,
+            beneficiaryData
+          ]
+        );
+      default:
+        throw new Error("Unknown migration type");
+    }
+  }
+  /**
+   * Encode create params for Uniswap V4 Multicurve initializer/migrator flow
+   */
+  encodeCreateMulticurveParams(params) {
+    if (!params.pool || params.pool.curves.length === 0) {
+      throw new Error("Multicurve pool must include at least one curve");
+    }
+    const normalizedCurves = this.normalizeMulticurveCurves(params.pool.curves, params.pool.tickSpacing);
+    const addresses = getAddresses(this.chainId);
+    const sortedBeneficiaries = (params.pool.beneficiaries ?? []).slice().sort((a, b) => {
+      const aAddr = a.beneficiary.toLowerCase();
+      const bAddr = b.beneficiary.toLowerCase();
+      return aAddr < bAddr ? -1 : aAddr > bAddr ? 1 : 0;
+    });
+    const useScheduledInitializer = params.schedule !== void 0;
+    let scheduleStartTime;
+    if (useScheduledInitializer) {
+      scheduleStartTime = Number(params.schedule.startTime);
+      if (!Number.isFinite(scheduleStartTime) || !Number.isInteger(scheduleStartTime)) {
+        throw new Error("Scheduled multicurve startTime must be an integer number of seconds since Unix epoch");
+      }
+      if (scheduleStartTime < 0) {
+        throw new Error("Scheduled multicurve startTime cannot be negative");
+      }
+      const UINT32_MAX = 4294967295;
+      if (scheduleStartTime > UINT32_MAX) {
+        throw new Error("Scheduled multicurve startTime must fit within uint32 (seconds since Unix epoch up to year 2106)");
+      }
+    }
+    const poolInitializerTupleComponents = [
+      { name: "fee", type: "uint24" },
+      { name: "tickSpacing", type: "int24" },
+      {
+        name: "curves",
+        type: "tuple[]",
+        components: [
+          { type: "int24", name: "tickLower" },
+          { type: "int24", name: "tickUpper" },
+          { type: "uint16", name: "numPositions" },
+          { type: "uint256", name: "shares" }
+        ]
+      },
+      {
+        name: "beneficiaries",
+        type: "tuple[]",
+        components: [
+          { type: "address", name: "beneficiary" },
+          { type: "uint96", name: "shares" }
+        ]
+      }
+    ];
+    if (useScheduledInitializer) {
+      poolInitializerTupleComponents.push({ name: "startingTime", type: "uint32" });
+    }
+    const baseInitializerParams = {
+      fee: params.pool.fee,
+      tickSpacing: params.pool.tickSpacing,
+      curves: normalizedCurves.map((c) => ({
+        tickLower: c.tickLower,
+        tickUpper: c.tickUpper,
+        numPositions: c.numPositions,
+        shares: c.shares
+      })),
+      beneficiaries: sortedBeneficiaries.map((b) => ({
+        beneficiary: b.beneficiary,
+        shares: b.shares
+      }))
+    };
+    const poolInitializerValue = useScheduledInitializer ? { ...baseInitializerParams, startingTime: scheduleStartTime } : baseInitializerParams;
+    const poolInitializerData = encodeAbiParameters(
+      [{ type: "tuple", components: poolInitializerTupleComponents }],
+      [poolInitializerValue]
+    );
+    let tokenFactoryData;
+    if (this.isDoppler404Token(params.token)) {
+      const token404 = params.token;
+      const unit = token404.unit !== void 0 ? BigInt(token404.unit) : 1000n;
+      tokenFactoryData = encodeAbiParameters(
+        [{ type: "string" }, { type: "string" }, { type: "string" }, { type: "uint256" }],
+        [token404.name, token404.symbol, token404.baseURI, unit]
+      );
+    } else {
+      const tokenStd = params.token;
+      const vestingDuration = params.vesting?.duration ?? BigInt(0);
+      const yearlyMintRate = tokenStd.yearlyMintRate ?? DEFAULT_V3_YEARLY_MINT_RATE;
+      let vestingRecipients = [];
+      let vestingAmounts = [];
+      if (params.vesting) {
+        if (params.vesting.recipients && params.vesting.amounts) {
+          vestingRecipients = params.vesting.recipients;
+          vestingAmounts = params.vesting.amounts;
+        } else {
+          vestingRecipients = [params.userAddress];
+          vestingAmounts = [params.sale.initialSupply - params.sale.numTokensToSell];
+        }
+      }
+      tokenFactoryData = encodeAbiParameters(
+        [{ type: "string" }, { type: "string" }, { type: "uint256" }, { type: "uint256" }, { type: "address[]" }, { type: "uint256[]" }, { type: "string" }],
+        [tokenStd.name, tokenStd.symbol, yearlyMintRate, BigInt(vestingDuration), vestingRecipients, vestingAmounts, tokenStd.tokenURI]
+      );
+    }
+    const useNoOpGovernance = params.governance.type === "noOp";
+    const governanceFactoryData = useNoOpGovernance ? "0x" : encodeAbiParameters(
+      [{ type: "string" }, { type: "uint48" }, { type: "uint32" }, { type: "uint256" }],
+      [
+        params.token.name,
+        params.governance.type === "custom" ? params.governance.initialVotingDelay : DEFAULT_V4_INITIAL_VOTING_DELAY,
+        params.governance.type === "custom" ? params.governance.initialVotingPeriod : DEFAULT_V4_INITIAL_VOTING_PERIOD,
+        params.governance.type === "custom" ? params.governance.initialProposalThreshold : DEFAULT_V4_INITIAL_PROPOSAL_THRESHOLD
+      ]
+    );
+    const salt = this.generateRandomSalt(params.userAddress);
+    const resolvedTokenFactory = params.modules?.tokenFactory ?? (this.isDoppler404Token(params.token) ? addresses.doppler404Factory : addresses.tokenFactory);
+    if (!resolvedTokenFactory || resolvedTokenFactory === ZERO_ADDRESS) {
+      throw new Error("Token factory address not configured. Provide an explicit address or ensure chain config includes a valid factory.");
+    }
+    const resolvedInitializer = (() => {
+      if (useScheduledInitializer) {
+        return params.modules?.v4ScheduledMulticurveInitializer ?? addresses.v4ScheduledMulticurveInitializer;
+      }
+      return params.modules?.v4MulticurveInitializer ?? addresses.v4MulticurveInitializer;
+    })();
+    if (!resolvedInitializer || resolvedInitializer === ZERO_ADDRESS) {
+      throw new Error(
+        useScheduledInitializer ? "Scheduled multicurve initializer address not configured on this chain. Override via builder or update chain config." : "Multicurve initializer address not configured on this chain. Override via builder or update chain config."
+      );
+    }
+    const hasBeneficiaries = params.pool.beneficiaries && params.pool.beneficiaries.length > 0;
+    let liquidityMigratorData;
+    let resolvedMigrator;
+    if (hasBeneficiaries) {
+      liquidityMigratorData = "0x";
+      resolvedMigrator = params.modules?.noOpMigrator ?? addresses.noOpMigrator;
+      if (!resolvedMigrator || resolvedMigrator === ZERO_ADDRESS) {
+        throw new Error("NoOpMigrator address not configured on this chain. Override via modules.noOpMigrator or update chain config.");
+      }
+    } else {
+      liquidityMigratorData = this.encodeMigrationData(params.migration);
+      resolvedMigrator = this.getMigratorAddress(params.migration, params.modules);
+      if (!resolvedMigrator || resolvedMigrator === ZERO_ADDRESS) {
+        throw new Error("Migrator address not configured on this chain. Override via builder or update chain config.");
+      }
+    }
+    const governanceFactoryAddress = (() => {
+      if (useNoOpGovernance) {
+        const resolved2 = params.modules?.governanceFactory ?? (addresses.noOpGovernanceFactory ?? ZERO_ADDRESS);
+        if (!resolved2 || resolved2 === ZERO_ADDRESS) {
+          throw new Error("No-op governance requested, but no-op governanceFactory is not configured on this chain.");
+        }
+        return resolved2;
+      }
+      const resolved = params.modules?.governanceFactory ?? addresses.governanceFactory;
+      if (!resolved || resolved === ZERO_ADDRESS) {
+        throw new Error("Standard governance requested but governanceFactory is not deployed on this chain.");
+      }
+      return resolved;
+    })();
+    const createParams = {
+      initialSupply: params.sale.initialSupply,
+      numTokensToSell: params.sale.numTokensToSell,
+      numeraire: params.sale.numeraire,
+      tokenFactory: resolvedTokenFactory,
+      tokenFactoryData,
+      governanceFactory: governanceFactoryAddress,
+      governanceFactoryData,
+      poolInitializer: resolvedInitializer,
+      poolInitializerData,
+      liquidityMigrator: resolvedMigrator,
+      liquidityMigratorData,
+      integrator: params.integrator ?? ZERO_ADDRESS,
+      salt
+    };
+    return createParams;
+  }
+  async simulateCreateMulticurve(params) {
+    const createParams = this.encodeCreateMulticurveParams(params);
+    const addresses = getAddresses(this.chainId);
+    const airlockAddress = params.modules?.airlock ?? addresses.airlock;
+    const { request, result } = await this.publicClient.simulateContract({
+      address: airlockAddress,
+      abi: airlockAbi,
+      functionName: "create",
+      args: [{ ...createParams }],
+      account: this.walletClient?.account
+    });
+    const simResult = result;
+    const gasEstimate = await this.resolveCreateGasEstimate({
+      request,
+      address: airlockAddress,
+      createParams,
+      account: this.walletClient?.account ?? params.userAddress
+    });
+    if (!simResult || !Array.isArray(simResult) || simResult.length < 2) {
+      throw new Error("Failed to simulate multicurve create");
+    }
+    return {
+      createParams,
+      asset: simResult[0],
+      pool: simResult[1],
+      gasEstimate,
+      execute: () => this.createMulticurve(params, { _createParams: createParams })
+    };
+  }
+  async createMulticurve(params, options) {
+    const createParams = options?._createParams ?? this.encodeCreateMulticurveParams(params);
+    const addresses = getAddresses(this.chainId);
+    if (!this.walletClient) throw new Error("Wallet client required for write operations");
+    const airlockAddress = params.modules?.airlock ?? addresses.airlock;
+    const { request, result } = await this.publicClient.simulateContract({
+      address: airlockAddress,
+      abi: airlockAbi,
+      functionName: "create",
+      args: [{ ...createParams }],
+      account: this.walletClient.account
+    });
+    const simResult = result;
+    const gasEstimate = await this.resolveCreateGasEstimate({
+      request,
+      address: airlockAddress,
+      createParams,
+      account: this.walletClient.account
+    });
+    const gas = params.gas ?? gasEstimate ?? DEFAULT_CREATE_GAS_LIMIT;
+    const hash = await this.walletClient.writeContract({ ...request, gas });
+    await this.publicClient.waitForTransactionReceipt({ hash, confirmations: 2 });
+    if (simResult && Array.isArray(simResult) && simResult.length >= 2) {
+      return { tokenAddress: simResult[0], poolAddress: simResult[1], transactionHash: hash };
+    }
+    throw new Error("Failed to get pool/token addresses from multicurve create");
+  }
+  /**
+   * Normalize user-provided multicurve positions and ensure they satisfy SDK constraints
+   */
+  normalizeMulticurveCurves(curves, tickSpacing) {
+    if (tickSpacing <= 0) {
+      throw new Error("Tick spacing must be positive");
+    }
+    if (!curves.length) {
+      throw new Error("Multicurve pool must include at least one curve");
+    }
+    let totalShares = 0n;
+    let mostPositiveTickUpper;
+    const sanitizedCurves = curves.map((curve) => {
+      const sanitized = { ...curve };
+      if (!Number.isFinite(sanitized.tickLower) || !Number.isFinite(sanitized.tickUpper)) {
+        throw new Error("Multicurve ticks must be finite numbers");
+      }
+      if (sanitized.tickLower >= sanitized.tickUpper) {
+        throw new Error("Multicurve curve tickLower must be less than tickUpper");
+      }
+      if (sanitized.tickLower <= 0 || sanitized.tickUpper <= 0) {
+        console.warn("Warning: Using negative or zero ticks in multicurve configuration. Please verify this is intentional before proceeding.");
+      }
+      if (!Number.isInteger(sanitized.numPositions) || sanitized.numPositions <= 0) {
+        throw new Error("Multicurve curve numPositions must be a positive integer");
+      }
+      if (sanitized.shares <= 0n) {
+        throw new Error("Multicurve curve shares must be positive");
+      }
+      totalShares += sanitized.shares;
+      if (totalShares > WAD) {
+        throw new Error("Total multicurve shares cannot exceed 100% (1e18)");
+      }
+      if (mostPositiveTickUpper === void 0 || sanitized.tickUpper > mostPositiveTickUpper) {
+        mostPositiveTickUpper = sanitized.tickUpper;
+      }
+      return sanitized;
+    });
+    if (totalShares === WAD) {
+      return sanitizedCurves;
+    }
+    const missingShare = WAD - totalShares;
+    if (missingShare <= 0n) {
+      return sanitizedCurves;
+    }
+    const fallbackTickLower = mostPositiveTickUpper;
+    if (fallbackTickLower === void 0) {
+      throw new Error("Unable to determine fallback multicurve tick range");
+    }
+    const fallbackTickUpper = this.roundMaxTickDown(tickSpacing);
+    const fallbackCurve = {
+      // Extend from the most positive user tick out to the maximum supported tick bucket
+      tickLower: fallbackTickLower,
+      tickUpper: fallbackTickUpper,
+      numPositions: sanitizedCurves[sanitizedCurves.length - 1]?.numPositions ?? 1,
+      shares: missingShare
+    };
+    return [...sanitizedCurves, fallbackCurve];
+  }
+  roundMaxTickDown(tickSpacing) {
+    if (tickSpacing <= 0) {
+      throw new Error("Tick spacing must be positive");
+    }
+    const rounded = Math.floor(MAX_TICK / tickSpacing) * tickSpacing;
+    return rounded;
+  }
+  validateStaticAuctionParams(params) {
+    if (!params.token.name || params.token.name.trim().length === 0) {
+      throw new Error("Token name is required");
+    }
+    if (!params.token.symbol || params.token.symbol.trim().length === 0) {
+      throw new Error("Token symbol is required");
+    }
+    if (params.pool.startTick >= params.pool.endTick) {
+      throw new Error("Start tick must be less than end tick");
+    }
+    const tickSpacing = TICK_SPACINGS[params.pool.fee];
+    if (tickSpacing === void 0) {
+      throw new Error(`Unsupported fee tier ${params.pool.fee} for static auctions`);
+    }
+    if (params.pool.startTick < MIN_TICK || params.pool.endTick > MAX_TICK) {
+      throw new Error(`Ticks must be within the allowed range (${MIN_TICK} to ${MAX_TICK})`);
+    }
+    const startTickAligned = params.pool.startTick % tickSpacing === 0;
+    const endTickAligned = params.pool.endTick % tickSpacing === 0;
+    if (!startTickAligned || !endTickAligned) {
+      throw new Error(`Pool ticks must be multiples of tick spacing ${tickSpacing} for fee tier ${params.pool.fee}`);
+    }
+    if (params.sale.initialSupply <= BigInt(0)) {
+      throw new Error("Initial supply must be positive");
+    }
+    if (params.sale.numTokensToSell <= BigInt(0)) {
+      throw new Error("Number of tokens to sell must be positive");
+    }
+    if (params.sale.numTokensToSell > params.sale.initialSupply) {
+      throw new Error("Cannot sell more tokens than initial supply");
+    }
+    if (params.vesting) {
+      if (params.vesting.recipients && params.vesting.amounts) {
+        if (params.vesting.recipients.length !== params.vesting.amounts.length) {
+          throw new Error("Vesting recipients and amounts arrays must have the same length");
+        }
+        if (params.vesting.recipients.length === 0) {
+          throw new Error("Vesting recipients array cannot be empty");
+        }
+        const totalVested = params.vesting.amounts.reduce((sum, amt) => sum + amt, BigInt(0));
+        const availableForVesting = params.sale.initialSupply - params.sale.numTokensToSell;
+        if (totalVested > availableForVesting) {
+          throw new Error(`Total vesting amount (${totalVested}) exceeds available tokens (${availableForVesting})`);
+        }
+      } else {
+        const vestedAmount = params.sale.initialSupply - params.sale.numTokensToSell;
+        if (vestedAmount <= BigInt(0)) {
+          throw new Error("No tokens available for vesting");
+        }
+      }
+    }
+    if (params.migration.type === "uniswapV4" && params.migration.streamableFees) {
+      const beneficiaries = params.migration.streamableFees.beneficiaries;
+      if (beneficiaries.length === 0) {
+        throw new Error("At least one beneficiary is required for V4 migration");
+      }
+      const totalShares = beneficiaries.reduce((sum, b) => sum + b.shares, 0n);
+      if (totalShares !== WAD) {
+        throw new Error(`Beneficiary shares must sum to ${WAD} (100%), but got ${totalShares}`);
+      }
+    }
+    if (params.pool.beneficiaries && params.pool.beneficiaries.length > 0) {
+      const beneficiaries = params.pool.beneficiaries;
+      const totalShares = beneficiaries.reduce((sum, b) => sum + b.shares, 0n);
+      if (totalShares !== WAD) {
+        throw new Error(`Pool beneficiary shares must sum to ${WAD} (100%), but got ${totalShares}`);
+      }
+      for (const b of beneficiaries) {
+        if (b.shares <= 0n) {
+          throw new Error("Each beneficiary must have positive shares");
+        }
+      }
+    }
+  }
+  /**
+   * Validate dynamic auction parameters
+   */
+  validateDynamicAuctionParams(params) {
+    if (!params.token.name || params.token.name.trim().length === 0) {
+      throw new Error("Token name is required");
+    }
+    if (!params.token.symbol || params.token.symbol.trim().length === 0) {
+      throw new Error("Token symbol is required");
+    }
+    const isToken0 = isToken0Expected(params.sale.numeraire);
+    if (isToken0 && params.auction.startTick <= params.auction.endTick) {
+      throw new Error("Start tick must be greater than end tick if base token is currency0");
+    }
+    if (!isToken0 && params.auction.startTick >= params.auction.endTick) {
+      throw new Error("Start tick must be less than end tick if base token is currency1");
+    }
+    if (params.sale.initialSupply <= BigInt(0)) {
+      throw new Error("Initial supply must be positive");
+    }
+    if (params.sale.numTokensToSell <= BigInt(0)) {
+      throw new Error("Number of tokens to sell must be positive");
+    }
+    if (params.sale.numTokensToSell > params.sale.initialSupply) {
+      throw new Error("Cannot sell more tokens than initial supply");
+    }
+    if (params.auction.duration <= 0) {
+      throw new Error("Auction duration must be positive");
+    }
+    if (params.auction.epochLength <= 0) {
+      throw new Error("Epoch length must be positive");
+    }
+    if (params.pool.tickSpacing <= 0) {
+      throw new Error("Tick spacing must be positive");
+    }
+    if (params.auction.duration % params.auction.epochLength !== 0) {
+      throw new Error("Epoch length must divide total duration evenly");
+    }
+    if (params.auction.gamma !== void 0) {
+      if (params.auction.gamma % params.pool.tickSpacing !== 0) {
+        throw new Error("Gamma must be divisible by tick spacing");
+      }
+    }
+    if (params.migration.type === "uniswapV4" && params.migration.streamableFees) {
+      const beneficiaries = params.migration.streamableFees.beneficiaries;
+      if (beneficiaries.length === 0) {
+        throw new Error("At least one beneficiary is required for V4 migration");
+      }
+      const totalShares = beneficiaries.reduce((sum, b) => sum + b.shares, 0n);
+      if (totalShares !== WAD) {
+        throw new Error(`Beneficiary shares must sum to ${WAD} (100%), but got ${totalShares}`);
+      }
+    }
+  }
+  /**
+   * Get the airlock contract address for the current chain
+   */
+  getAirlockAddress() {
+    const addresses = getAddresses(this.chainId);
+    return addresses.airlock;
+  }
+  /**
+   * Get the appropriate initializer address based on auction type
+   */
+  getInitializerAddress(isStatic) {
+    const addresses = getAddresses(this.chainId);
+    return isStatic ? addresses.v3Initializer : addresses.v4Initializer;
+  }
+  /**
+   * Get the Bundler contract address for the current chain
+   * Used to perform atomic create + swap ("bundle") flows for static auctions
+   */
+  getBundlerAddress() {
+    const addresses = getAddresses(this.chainId);
+    const addr = addresses.bundler;
+    if (!addr || addr === zeroAddress) {
+      throw new Error("Bundler address not configured for this chain");
+    }
+    return addr;
+  }
+  /**
+   * Get the appropriate migrator address based on migration config
+   * Allows override via ModuleAddressOverrides when provided in params.
+   */
+  getMigratorAddress(config, overrides) {
+    const addresses = getAddresses(this.chainId);
+    switch (config.type) {
+      case "uniswapV2":
+        return overrides?.v2Migrator ?? addresses.v2Migrator;
+      case "uniswapV3":
+        return overrides?.v3Migrator ?? addresses.v3Migrator;
+      case "uniswapV4":
+        return overrides?.v4Migrator ?? addresses.v4Migrator;
+      case "noOp": {
+        const noOpAddress = overrides?.noOpMigrator ?? addresses.noOpMigrator;
+        if (!noOpAddress) {
+          throw new Error("NoOpMigrator not configured on this chain. Provide override via modules.noOpMigrator or update chain config.");
+        }
+        return noOpAddress;
+      }
+      default:
+        throw new Error("Unknown migration type");
+    }
+  }
+  // computeTicks moved to builders. No longer needed here.
+  // computeOptimalGamma moved to utils.
+  // -----------------------------
+  // Bundler helpers (Static/V3)
+  // -----------------------------
+  /**
+   * Simulate a bundle with exact input on Uniswap V3 as part of create
+   * Returns the expected output amount for the provided exact input.
+   */
+  async simulateBundleExactInput(createParams, params) {
+    const bundler = this.getBundlerAddress();
+    const { result } = await this.publicClient.simulateContract({
+      address: bundler,
+      abi: bundlerAbi,
+      functionName: "simulateBundleExactIn",
+      args: [
+        { ...createParams },
+        {
+          tokenIn: params.tokenIn,
+          tokenOut: params.tokenOut,
+          amountIn: params.amountIn,
+          fee: params.fee,
+          sqrtPriceLimitX96: params.sqrtPriceLimitX96
+        }
+      ]
+    });
+    return result;
+  }
+  /**
+   * Simulate a bundle with exact output on Uniswap V3 as part of create
+   * Returns the required input amount for the provided exact output.
+   */
+  async simulateBundleExactOutput(createParams, params) {
+    const bundler = this.getBundlerAddress();
+    const { result } = await this.publicClient.simulateContract({
+      address: bundler,
+      abi: bundlerAbi,
+      functionName: "simulateBundleExactOut",
+      args: [
+        { ...createParams },
+        {
+          tokenIn: params.tokenIn,
+          tokenOut: params.tokenOut,
+          amount: params.amount,
+          fee: params.fee,
+          sqrtPriceLimitX96: params.sqrtPriceLimitX96
+        }
+      ]
+    });
+    return result;
+  }
+  // Bundler helpers (Multicurve/V4)
+  async simulateMulticurveBundleExactOut(createParams, params) {
+    const bundler = this.getBundlerAddress();
+    await this.ensureMulticurveBundlerSupport(bundler);
+    const exactAmountOut = params?.exactAmountOut ?? 0n;
+    this.ensureUint128(exactAmountOut, "exactAmountOut", { allowZero: true });
+    const hookData = "0x";
+    const { result } = await this.publicClient.simulateContract({
+      address: bundler,
+      abi: bundlerAbi,
+      functionName: "simulateMulticurveBundleExactOut",
+      args: [
+        { ...createParams },
+        exactAmountOut,
+        hookData
+      ]
+    });
+    const { asset, poolKey, amount, gasEstimate } = this.parseMulticurveBundleResult(result);
+    return {
+      asset,
+      poolKey,
+      amountIn: amount,
+      gasEstimate
+    };
+  }
+  async simulateMulticurveBundleExactIn(createParams, params) {
+    const bundler = this.getBundlerAddress();
+    await this.ensureMulticurveBundlerSupport(bundler);
+    if (params.exactAmountIn === void 0) {
+      throw new Error("exactAmountIn is required for multicurve bundle simulations");
+    }
+    const exactAmountIn = params.exactAmountIn;
+    this.ensureUint128(exactAmountIn, "exactAmountIn");
+    const hookData = "0x";
+    const { result } = await this.publicClient.simulateContract({
+      address: bundler,
+      abi: bundlerAbi,
+      functionName: "simulateMulticurveBundleExactIn",
+      args: [
+        { ...createParams },
+        exactAmountIn,
+        hookData
+      ]
+    });
+    const { asset, poolKey, amount, gasEstimate } = this.parseMulticurveBundleResult(result);
+    return {
+      asset,
+      poolKey,
+      amountOut: amount,
+      gasEstimate
+    };
+  }
+  /**
+   * Execute an atomic create + swap bundle through the Bundler
+   * commands/inputs are Universal Router encoded values (e.g., from doppler-router)
+   */
+  async bundle(createParams, commands, inputs, options) {
+    if (!this.walletClient) {
+      throw new Error("Wallet client required for write operations");
+    }
+    const bundler = this.getBundlerAddress();
+    const { request } = await this.publicClient.simulateContract({
+      address: bundler,
+      abi: bundlerAbi,
+      functionName: "bundle",
+      args: [
+        { ...createParams },
+        commands,
+        inputs
+      ],
+      account: this.walletClient.account,
+      value: options?.value ?? 0n
+    });
+    const gas = options?.gas ?? void 0;
+    const tx = await this.walletClient.writeContract(gas ? { ...request, gas } : request);
+    return tx;
+  }
+  ensureUint128(value, paramName, options = {}) {
+    const { allowZero = false } = options;
+    if (value < 0n) {
+      throw new Error(`${paramName} cannot be negative`);
+    }
+    if (!allowZero && value === 0n) {
+      throw new Error(`${paramName} must be greater than zero`);
+    }
+    if (value > MAX_UINT128) {
+      throw new Error(`${paramName} exceeds uint128 range`);
+    }
+  }
+  parseMulticurveBundleResult(result) {
+    let asset;
+    let poolKeyRaw;
+    let amount;
+    let gasEstimate;
+    if (Array.isArray(result)) {
+      if (result.length < 4) {
+        throw new Error("Unexpected multicurve bundle simulation result shape");
+      }
+      asset = result[0];
+      poolKeyRaw = result[1];
+      amount = result[2];
+      gasEstimate = result[3];
+    } else if (result && typeof result === "object") {
+      const obj = result;
+      asset = obj.asset;
+      poolKeyRaw = obj.poolKey;
+      amount = obj.amountIn ?? obj.amountOut ?? obj.amount;
+      gasEstimate = obj.gasEstimate;
+    } else {
+      throw new Error("Unexpected multicurve bundle simulation result format");
+    }
+    if (asset === void 0 || poolKeyRaw === void 0 || amount === void 0 || gasEstimate === void 0) {
+      throw new Error("Incomplete multicurve bundle simulation result");
+    }
+    return {
+      asset,
+      poolKey: this.normalizePoolKey(poolKeyRaw),
+      amount,
+      gasEstimate
+    };
+  }
+  normalizePoolKey(value) {
+    if (Array.isArray(value)) {
+      const [currency0, currency1, feeRaw, tickSpacingRaw, hooks] = value;
+      const feeValue = Number(feeRaw);
+      const tickSpacingValue = Number(tickSpacingRaw);
+      if (!Number.isFinite(feeValue) || !Number.isFinite(tickSpacingValue)) {
+        throw new Error("Invalid pool key numeric fields in multicurve bundle simulation result");
+      }
+      return {
+        currency0,
+        currency1,
+        fee: feeValue,
+        tickSpacing: tickSpacingValue,
+        hooks
+      };
+    }
+    if (value && typeof value === "object") {
+      const { currency0, currency1, fee, tickSpacing, hooks } = value;
+      const feeValue = Number(fee);
+      const tickSpacingValue = Number(tickSpacing);
+      if (!Number.isFinite(feeValue) || !Number.isFinite(tickSpacingValue)) {
+        throw new Error("Invalid pool key numeric fields in multicurve bundle simulation result");
+      }
+      return {
+        currency0,
+        currency1,
+        fee: feeValue,
+        tickSpacing: tickSpacingValue,
+        hooks
+      };
+    }
+    throw new Error("Unable to normalize PoolKey from multicurve bundle simulation result");
+  }
+  /**
+   * Mines a salt and hook address with the appropriate flags
+   * 
+   * This method iterates through possible salt values to find a combination that:
+   * - Produces a hook address with required Doppler flags
+   * - Maintains proper token ordering relative to numeraire
+   * - Ensures deterministic deployment addresses
+   * 
+   * @param params - Parameters for hook address mining
+   * @returns Tuple of [salt, hook address, token address, pool data, token data]
+   * @throws {Error} If no valid salt can be found within the search limit
+   * @private
+   */
+  mineHookAddress(params) {
+    getAddresses(this.chainId);
+    const isToken0 = isToken0Expected(params.numeraire);
+    const {
+      minimumProceeds,
+      maximumProceeds,
+      startingTime,
+      endingTime,
+      startingTick,
+      endingTick,
+      epochLength,
+      gamma,
+      numPDSlugs,
+      fee,
+      tickSpacing
+    } = params.poolInitializerData;
+    const poolInitializerData = encodeAbiParameters(
+      [
+        { type: "uint256" },
+        { type: "uint256" },
+        { type: "uint256" },
+        { type: "uint256" },
+        { type: "int24" },
+        { type: "int24" },
+        { type: "uint256" },
+        { type: "int24" },
+        { type: "bool" },
+        { type: "uint256" },
+        { type: "uint24" },
+        { type: "int24" }
+      ],
+      [
+        minimumProceeds,
+        maximumProceeds,
+        startingTime,
+        endingTime,
+        startingTick,
+        endingTick,
+        epochLength,
+        gamma,
+        isToken0,
+        numPDSlugs,
+        fee,
+        tickSpacing
+      ]
+    );
+    const isBase = this.chainId === CHAIN_IDS.BASE;
+    const { poolManager, numTokensToSell, poolInitializer } = params;
+    const hookInitHashData = encodeAbiParameters(
+      [
+        { type: "address" },
+        { type: "uint256" },
+        { type: "uint256" },
+        { type: "uint256" },
+        { type: "uint256" },
+        { type: "uint256" },
+        { type: "int24" },
+        { type: "int24" },
+        { type: "uint256" },
+        { type: "int24" },
+        { type: "bool" },
+        { type: "uint256" },
+        { type: "address" },
+        { type: "uint24" }
+      ],
+      [
+        poolManager,
+        numTokensToSell,
+        minimumProceeds,
+        maximumProceeds,
+        startingTime,
+        endingTime,
+        startingTick,
+        endingTick,
+        epochLength,
+        gamma,
+        isToken0,
+        numPDSlugs,
+        poolInitializer,
+        fee
+      ]
+    );
+    const hookInitHash = keccak256(
+      encodePacked(
+        ["bytes", "bytes"],
+        [isBase ? DopplerBytecodeBaseMainnet : DopplerBytecode, hookInitHashData]
+      )
+    );
+    const tokenFactoryData = params.tokenVariant === "doppler404" ? (() => {
+      const t = params.tokenFactoryData;
+      return encodeAbiParameters(
+        [
+          { type: "string" },
+          { type: "string" },
+          { type: "string" },
+          { type: "uint256" }
+        ],
+        [t.name, t.symbol, t.baseURI, t.unit ?? 1000n]
+      );
+    })() : (() => {
+      const {
+        name,
+        symbol,
+        yearlyMintRate,
+        vestingDuration,
+        recipients,
+        amounts,
+        tokenURI
+      } = params.tokenFactoryData;
+      return encodeAbiParameters(
+        [
+          { type: "string" },
+          { type: "string" },
+          { type: "uint256" },
+          { type: "uint256" },
+          { type: "address[]" },
+          { type: "uint256[]" },
+          { type: "string" }
+        ],
+        [
+          name,
+          symbol,
+          yearlyMintRate,
+          vestingDuration,
+          recipients,
+          amounts,
+          tokenURI
+        ]
+      );
+    })();
+    const { airlock, initialSupply } = params;
+    let tokenInitHash;
+    if (params.tokenVariant === "doppler404") {
+      const { name, symbol, baseURI } = params.tokenFactoryData;
+      const { airlock: airlock2, initialSupply: initialSupply2 } = params;
+      const initHashData = encodeAbiParameters(
+        [
+          { type: "string" },
+          { type: "string" },
+          { type: "uint256" },
+          { type: "address" },
+          { type: "address" },
+          { type: "string" }
+        ],
+        [
+          name,
+          symbol,
+          initialSupply2,
+          airlock2,
+          airlock2,
+          baseURI
+        ]
+      );
+      tokenInitHash = keccak256(
+        encodePacked(["bytes", "bytes"], [DopplerDN404Bytecode, initHashData])
+      );
+    } else {
+      const { name, symbol, yearlyMintRate, vestingDuration, recipients, amounts, tokenURI } = params.tokenFactoryData;
+      const { airlock: airlock2, initialSupply: initialSupply2 } = params;
+      const initHashData = encodeAbiParameters(
+        [
+          { type: "string" },
+          { type: "string" },
+          { type: "uint256" },
+          { type: "address" },
+          { type: "address" },
+          { type: "uint256" },
+          { type: "uint256" },
+          { type: "address[]" },
+          { type: "uint256[]" },
+          { type: "string" }
+        ],
+        [
+          name,
+          symbol,
+          initialSupply2,
+          airlock2,
+          airlock2,
+          yearlyMintRate,
+          vestingDuration,
+          recipients,
+          amounts,
+          tokenURI
+        ]
+      );
+      tokenInitHash = keccak256(
+        encodePacked(["bytes", "bytes"], [params.customDerc20Bytecode ?? DERC20Bytecode, initHashData])
+      );
+    }
+    const flags = BigInt(
+      1 << 13 | // BEFORE_INITIALIZE_FLAG
+      1 << 12 | // AFTER_INITIALIZE_FLAG
+      1 << 11 | // BEFORE_ADD_LIQUIDITY_FLAG
+      1 << 7 | // BEFORE_SWAP_FLAG
+      1 << 6 | // AFTER_SWAP_FLAG
+      1 << 5
+      // BEFORE_DONATE_FLAG
+    );
+    for (let salt = BigInt(0); salt < BigInt(1e6); salt++) {
+      const saltBytes = `0x${salt.toString(16).padStart(64, "0")}`;
+      const hook = this.computeCreate2Address(
+        saltBytes,
+        hookInitHash,
+        params.deployer
+      );
+      const hookBigInt = BigInt(hook);
+      if (tokenInitHash) {
+        const token = this.computeCreate2Address(
+          saltBytes,
+          tokenInitHash,
+          params.tokenFactory
+        );
+        const tokenBigInt = BigInt(token);
+        const numeraireBigInt = BigInt(params.numeraire);
+        if ((hookBigInt & FLAG_MASK) === flags && (isToken0 && tokenBigInt < numeraireBigInt || !isToken0 && tokenBigInt > numeraireBigInt)) {
+          return [saltBytes, hook, token, poolInitializerData, tokenFactoryData];
+        }
+      }
+    }
+    throw new Error("AirlockMiner: could not find salt");
+  }
+  /**
+   * Computes the CREATE2 address for a contract deployment
+   * @param salt - The salt used for deployment
+   * @param initCodeHash - Hash of the initialization code
+   * @param deployer - Address of the deploying contract
+   * @returns The computed contract address
+   * @private
+   */
+  computeCreate2Address(salt, initCodeHash, deployer) {
+    const encoded = encodePacked(
+      ["bytes1", "address", "bytes32", "bytes32"],
+      ["0xff", deployer, salt, initCodeHash]
+    );
+    return getAddress(`0x${keccak256(encoded).slice(-40)}`);
+  }
+  /**
+   * Compute V4 pool ID from pool key components
+   */
+  computePoolId(poolKey) {
+    const encoded = encodeAbiParameters(
+      [
+        { type: "address" },
+        { type: "address" },
+        { type: "uint24" },
+        { type: "int24" },
+        { type: "address" }
+      ],
+      [
+        poolKey.currency0,
+        poolKey.currency1,
+        poolKey.fee,
+        poolKey.tickSpacing,
+        poolKey.hooks
+      ]
+    );
+    return keccak256(encoded);
+  }
+  async ensureMulticurveBundlerSupport(bundler) {
+    if (this.multicurveBundlerSupport.get(bundler)) {
+      return;
+    }
+    const client = this.publicClient;
+    if (!client || typeof client.getBytecode !== "function") {
+      this.multicurveBundlerSupport.set(bundler, true);
+      return;
+    }
+    const bytecode = await client.getBytecode({ address: bundler });
+    const supports = Boolean(bytecode && MULTICURVE_BUNDLER_SELECTORS.every((selector) => bytecode.includes(selector.slice(2))));
+    if (!supports) {
+      throw new Error(
+        `Bundler at ${bundler} does not support multicurve bundling. Ensure the Doppler Bundler has been upgraded and update chain addresses.`
+      );
+    }
+    this.multicurveBundlerSupport.set(bundler, true);
+  }
+};
+var MULTICURVE_BUNDLER_SELECTORS = ["0xe2e9faa1", "0x07087b06"];
+
+export { DopplerFactory };
+//# sourceMappingURL=chunk-TKSHYEYA.mjs.map
+//# sourceMappingURL=chunk-TKSHYEYA.mjs.map