@whetstone-research/doppler-sdk 1.0.34 → 1.0.35

package/dist/evm/index.cjs

@@ -7662,6 +7662,173 @@ function encodeRehypeDopplerHookMigratorCalldata(params) {
     ]
   );
 }
+var AirlockCreateReceiptError = class extends Error {
+  code;
+  expected;
+  actual;
+  constructor(code, options = {}) {
+    super(`Airlock Create receipt verification failed: ${code}`);
+    this.name = "AirlockCreateReceiptError";
+    this.code = code;
+    this.expected = options.expected;
+    this.actual = options.actual;
+  }
+};
+function addressesEqual(left, right) {
+  return left?.toLowerCase() === right.toLowerCase();
+}
+function decodeAirlockCreateLogs(receipt, expectedAirlock) {
+  const matches = [];
+  for (const log of receipt.logs) {
+    if (!addressesEqual(log.address, expectedAirlock)) continue;
+    try {
+      const decoded = viem.decodeEventLog({
+        abi: airlockAbi,
+        data: log.data,
+        topics: log.topics,
+        eventName: "Create"
+      });
+      const args = decoded.args;
+      matches.push({
+        airlock: log.address,
+        tokenAddress: args.asset,
+        numeraire: args.numeraire,
+        initializer: args.initializer,
+        poolOrHookAddress: args.poolOrHook,
+        logIndex: log.logIndex
+      });
+    } catch {
+    }
+  }
+  return matches;
+}
+function parseAirlockCreateReceipt({
+  receipt,
+  expectedAirlock
+}) {
+  const matches = decodeAirlockCreateLogs(receipt, expectedAirlock);
+  if (matches.length === 0) return null;
+  if (matches.length > 1) {
+    throw new AirlockCreateReceiptError("MULTIPLE_CREATE_EVENTS", {
+      expected: 1,
+      actual: matches.length
+    });
+  }
+  return {
+    ...matches[0],
+    transactionHash: receipt.transactionHash,
+    blockNumber: receipt.blockNumber
+  };
+}
+function assertAddressMatch(code, expected, actual) {
+  if (!addressesEqual(actual, expected)) {
+    throw new AirlockCreateReceiptError(code, { expected, actual });
+  }
+}
+function verifyPreparedCreateReceipt({
+  prepared,
+  receipt
+}) {
+  if (receipt.status !== "success") {
+    throw new AirlockCreateReceiptError("RECEIPT_FAILED", {
+      expected: "success",
+      actual: receipt.status
+    });
+  }
+  assertAddressMatch(
+    "WRONG_TRANSACTION_TARGET",
+    prepared.transaction.to,
+    receipt.to
+  );
+  assertAddressMatch(
+    "WRONG_TRANSACTION_SENDER",
+    prepared.account,
+    receipt.from
+  );
+  const receiptIdentity = parseAirlockCreateReceipt({
+    receipt,
+    expectedAirlock: prepared.airlock
+  });
+  if (!receiptIdentity) {
+    throw new AirlockCreateReceiptError("MISSING_CREATE_EVENT", {
+      expected: prepared.airlock,
+      actual: null
+    });
+  }
+  assertAddressMatch(
+    "TOKEN_MISMATCH",
+    prepared.prediction.tokenAddress,
+    receiptIdentity.tokenAddress
+  );
+  assertAddressMatch(
+    "NUMERAIRE_MISMATCH",
+    prepared.createParams.numeraire,
+    receiptIdentity.numeraire
+  );
+  assertAddressMatch(
+    "INITIALIZER_MISMATCH",
+    prepared.createParams.poolInitializer,
+    receiptIdentity.initializer
+  );
+  assertAddressMatch(
+    "POOL_OR_HOOK_MISMATCH",
+    prepared.prediction.poolOrHookAddress,
+    receiptIdentity.poolOrHookAddress
+  );
+  return {
+    receiptIdentity,
+    preparedIdentity: {
+      chainId: prepared.chainId,
+      tokenAddress: prepared.prediction.tokenAddress,
+      poolOrHookAddress: prepared.prediction.poolOrHookAddress,
+      governanceAddress: prepared.prediction.governanceAddress,
+      timelockAddress: prepared.prediction.timelockAddress,
+      migrationPoolAddress: prepared.prediction.migrationPoolAddress,
+      poolKey: prepared.prediction.poolKey,
+      poolId: prepared.prediction.poolId,
+      tokenIsCurrency0: prepared.prediction.tokenIsCurrency0
+    }
+  };
+}
+async function verifyPreparedCreateExecution({
+  prepared,
+  receipt,
+  publicClient
+}) {
+  const verified = verifyPreparedCreateReceipt({ prepared, receipt });
+  const transaction = await publicClient.getTransaction({
+    hash: receipt.transactionHash
+  });
+  if (transaction.hash.toLowerCase() !== receipt.transactionHash.toLowerCase()) {
+    throw new AirlockCreateReceiptError("TRANSACTION_HASH_MISMATCH", {
+      expected: receipt.transactionHash,
+      actual: transaction.hash
+    });
+  }
+  assertAddressMatch(
+    "WRONG_TRANSACTION_TARGET",
+    prepared.transaction.to,
+    transaction.to
+  );
+  assertAddressMatch(
+    "WRONG_TRANSACTION_SENDER",
+    prepared.account,
+    transaction.from
+  );
+  if (transaction.input.toLowerCase() !== prepared.transaction.data.toLowerCase()) {
+    throw new AirlockCreateReceiptError("TRANSACTION_INPUT_MISMATCH", {
+      expected: viem.keccak256(prepared.transaction.data),
+      actual: viem.keccak256(transaction.input)
+    });
+  }
+  if (transaction.value !== prepared.transaction.value) {
+    throw new AirlockCreateReceiptError("TRANSACTION_VALUE_MISMATCH", {
+      expected: prepared.transaction.value.toString(),
+      actual: transaction.value.toString()
+    });
+  }
+  return verified;
+}
 
 // src/evm/utils/marketCapHelpers.ts
 function getMaxTickRounded(tickSpacing) {
@@ -10617,25 +10784,45 @@ var DopplerFactory = class {
     }
     throw new Error("Unable to mine opening auction salt");
   }
-  async resolveCreateGasEstimate(args) {
+  isCreateGasRevert(error) {
+    if (error instanceof viem.ContractFunctionRevertedError || error instanceof viem.ExecutionRevertedError) {
+      return true;
+    }
+    if (!(error instanceof viem.BaseError)) return false;
+    return Boolean(
+      error.walk(
+        (cause) => cause instanceof viem.ContractFunctionRevertedError || cause instanceof viem.ExecutionRevertedError
+      )
+    );
+  }
+  async resolveInternalCreateGasEstimate(args) {
     const { request, address, createParams, account } = args;
-    const gasFromRequest = request && typeof request === "object" && "gas" in request ? request.gas : void 0;
-    if (gasFromRequest) {
-      return gasFromRequest;
+    let gasFromRequest;
+    if (request && typeof request === "object" && "gas" in request && typeof request.gas === "bigint") {
+      gasFromRequest = request.gas;
+    }
+    if (gasFromRequest !== void 0) {
+      return { status: "estimated", gas: gasFromRequest };
     }
     try {
-      const estimated = await this.publicClient.estimateContractGas({
-        address,
-        abi: airlockAbi,
-        functionName: "create",
-        args: [{ ...createParams }],
-        account
-      });
-      return estimated;
-    } catch {
-      return void 0;
+      const gas = await this.publicClient.estimateContractGas(
+        {
+          address,
+          abi: airlockAbi,
+          functionName: "create",
+          args: [{ ...createParams }],
+          account
+        }
+      );
+      return { status: "estimated", gas };
+    } catch (error) {
+      return this.isCreateGasRevert(error) ? { status: "reverted", error } : { status: "unavailable" };
     }
   }
+  async resolveCreateGasEstimate(args) {
+    const estimate = await this.resolveInternalCreateGasEstimate(args);
+    return estimate.status === "estimated" ? estimate.gas : void 0;
+  }
   isDoppler404Token(token) {
     return token.type === "doppler404";
   }
@@ -11391,86 +11578,157 @@ var DopplerFactory = class {
     };
     return createParams;
   }
-  async simulateCreateMulticurve(params) {
+  async resolveFinalMulticurveCreate(args) {
+    const { params, simulationAccount } = args;
     const addresses = getAddresses(this.chainId);
-    const createParams = this.encodeCreateMulticurveParams(params);
-    const airlockAddress = params.modules?.airlock ?? addresses.airlock;
-    const { request, result } = await this.publicClient.simulateContract({
-      address: airlockAddress,
+    const airlock = params.modules?.airlock ?? addresses.airlock;
+    const initialCreateParams = args.createParams ?? this.encodeCreateMulticurveParams(params);
+    const initialSimulation = await this.publicClient.simulateContract({
+      address: airlock,
       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
+      args: [{ ...initialCreateParams }],
+      account: simulationAccount
     });
-    if (!simResult || !Array.isArray(simResult) || simResult.length < 2) {
+    const initialResult = initialSimulation.result;
+    if (!initialResult || !Array.isArray(initialResult) || initialResult.length < 5) {
       throw new Error("Failed to simulate multicurve create");
     }
-    const tokenAddress = simResult[0];
-    const poolId = await this.computeMulticurvePoolId(params, tokenAddress);
-    const createParamsWithTimelock = this.withSimulationGovernanceTimelockExclusion({
-      createParams,
-      simResult,
-      token: params.token,
-      governance: params.governance,
-      modules: params.modules,
-      addresses
+    let createParams = initialCreateParams;
+    let request = initialSimulation.request;
+    let result = initialResult;
+    if (!args.createParams) {
+      const enrichedCreateParams = this.withSimulationGovernanceTimelockExclusion({
+        createParams,
+        simResult: initialResult,
+        token: params.token,
+        governance: params.governance,
+        modules: params.modules,
+        addresses
+      });
+      if (enrichedCreateParams.tokenFactoryData !== createParams.tokenFactoryData) {
+        createParams = enrichedCreateParams;
+        const finalSimulation = await this.publicClient.simulateContract({
+          address: airlock,
+          abi: airlockAbi,
+          functionName: "create",
+          args: [{ ...createParams }],
+          account: simulationAccount
+        });
+        const finalResult = finalSimulation.result;
+        if (!finalResult || !Array.isArray(finalResult) || finalResult.length < 5) {
+          throw new Error("Failed to simulate enriched multicurve create");
+        }
+        request = finalSimulation.request;
+        result = finalResult;
+      }
+    }
+    const tokenAddress = result[0];
+    const poolIdentity = await this.computeMulticurvePoolIdentity(
+      params,
+      tokenAddress
+    );
+    const prediction = {
+      tokenAddress,
+      poolOrHookAddress: result[1],
+      governanceAddress: result[2],
+      timelockAddress: result[3],
+      migrationPoolAddress: result[4],
+      ...poolIdentity
+    };
+    return { airlock, createParams, prediction, request };
+  }
+  async prepareCreateMulticurve(params, options) {
+    const resolved = await this.resolveFinalMulticurveCreate({
+      params,
+      simulationAccount: options.account
+    });
+    const internalGasEstimate = await this.resolveInternalCreateGasEstimate({
+      request: resolved.request,
+      address: resolved.airlock,
+      createParams: resolved.createParams,
+      account: options.account
     });
+    if (internalGasEstimate.status === "reverted") {
+      throw internalGasEstimate.error;
+    }
+    const gasEstimate = internalGasEstimate;
     return {
-      createParams: createParamsWithTimelock,
-      tokenAddress,
-      poolId,
+      chainId: this.chainId,
+      account: options.account,
+      airlock: resolved.airlock,
+      createParams: resolved.createParams,
+      prediction: resolved.prediction,
+      transaction: {
+        to: resolved.airlock,
+        data: viem.encodeFunctionData({
+          abi: airlockAbi,
+          functionName: "create",
+          args: [{ ...resolved.createParams }]
+        }),
+        value: 0n
+      },
+      gasEstimate
+    };
+  }
+  async simulateCreateMulticurve(params) {
+    const resolved = await this.resolveFinalMulticurveCreate({
+      params,
+      simulationAccount: this.walletClient?.account
+    });
+    const gasEstimate = await this.resolveCreateGasEstimate({
+      request: resolved.request,
+      address: resolved.airlock,
+      createParams: resolved.createParams,
+      account: this.walletClient?.account ?? params.userAddress
+    });
+    return {
+      createParams: resolved.createParams,
+      tokenAddress: resolved.prediction.tokenAddress,
+      poolId: resolved.prediction.poolId,
       gasEstimate,
       execute: () => this.createMulticurve(params, {
-        _createParams: createParamsWithTimelock
+        _createParams: resolved.createParams
       })
     };
   }
   async createMulticurve(params, options) {
-    const addresses = getAddresses(this.chainId);
-    if (!this.walletClient)
+    if (!this.walletClient) {
       throw new Error("Wallet client required for write operations");
-    const createParams = options?._createParams ?? (await this.simulateCreateMulticurve(params)).createParams;
-    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 resolved = await this.resolveFinalMulticurveCreate({
+      params,
+      simulationAccount: this.walletClient.account,
+      createParams: options?._createParams
     });
-    const simResult = result;
     const gasEstimate = await this.resolveCreateGasEstimate({
-      request,
-      address: airlockAddress,
-      createParams,
+      request: resolved.request,
+      address: resolved.airlock,
+      createParams: resolved.createParams,
       account: this.walletClient.account
     });
     const gas = params.gas ?? gasEstimate ?? DEFAULT_CREATE_GAS_LIMIT;
-    const hash = await this.walletClient.writeContract({ ...request, gas });
+    const hash = await this.walletClient.writeContract({
+      ...resolved.request,
+      gas
+    });
     const receipt = await this.publicClient.waitForTransactionReceipt({ hash, confirmations: 2 });
-    const actualAddresses = this.extractAddressesFromCreateEvent(receipt);
-    if (!actualAddresses) {
+    const createResult = parseAirlockCreateReceipt({
+      receipt,
+      expectedAirlock: resolved.airlock
+    });
+    if (!createResult) {
       throw new Error(
         "Failed to extract token address from Create event in transaction logs"
       );
     }
-    const actualTokenAddress = actualAddresses.tokenAddress;
-    if (simResult && Array.isArray(simResult) && simResult.length >= 1) {
-      const simulatedToken = simResult[0];
-      if (simulatedToken.toLowerCase() !== actualTokenAddress.toLowerCase()) {
-        console.warn(
-          `[DopplerSDK] Simulation predicted token ${simulatedToken} but actual is ${actualTokenAddress}. This may indicate state divergence between simulation and execution.`
-        );
-      }
+    const actualTokenAddress = createResult.tokenAddress;
+    if (resolved.prediction.tokenAddress.toLowerCase() !== actualTokenAddress.toLowerCase()) {
+      console.warn(
+        `[DopplerSDK] Simulation predicted token ${resolved.prediction.tokenAddress} but actual is ${actualTokenAddress}. This may indicate state divergence between simulation and execution.`
+      );
     }
-    const poolId = await this.computeMulticurvePoolId(
+    const { poolId } = await this.computeMulticurvePoolIdentity(
       params,
       actualTokenAddress
     );
@@ -12653,10 +12911,10 @@ var DopplerFactory = class {
     return viem.keccak256(encoded);
   }
   /**
-   * Compute the V4 poolId for a multicurve pool from the same pool-key fields
-   * the initializer will register on-chain.
+   * Compute the complete V4 multicurve pool identity from the same pool-key
+   * fields the initializer will register on-chain.
    */
-  async computeMulticurvePoolId(params, tokenAddress) {
+  async computeMulticurvePoolIdentity(params, tokenAddress) {
     const addresses = getAddresses(this.chainId);
     const initializerMode = this.resolveMulticurveInitializerMode(params);
     let hookAddress;
@@ -12686,16 +12944,18 @@ var DopplerFactory = class {
     }
     const numeraire = params.sale.numeraire;
     const tokenIsCurrency0 = BigInt(tokenAddress) < BigInt(numeraire);
-    const currency0 = tokenIsCurrency0 ? tokenAddress : numeraire;
-    const currency1 = tokenIsCurrency0 ? numeraire : tokenAddress;
-    const fee = initializerMode.type === "decay" || initializerMode.type === "rehype" && initializerMode.hookConfig ? DYNAMIC_FEE_FLAG : params.pool.fee;
-    return this.computePoolId({
-      currency0,
-      currency1,
-      fee,
+    const poolKey = {
+      currency0: tokenIsCurrency0 ? tokenAddress : numeraire,
+      currency1: tokenIsCurrency0 ? numeraire : tokenAddress,
+      fee: initializerMode.type === "decay" || initializerMode.type === "rehype" && initializerMode.hookConfig ? DYNAMIC_FEE_FLAG : params.pool.fee,
       tickSpacing: params.pool.tickSpacing,
       hooks: hookAddress
-    });
+    };
+    return {
+      poolKey,
+      poolId: this.computePoolId(poolKey),
+      tokenIsCurrency0
+    };
   }
   async ensureMulticurveBundlerSupport(bundler) {
     if (this.multicurveBundlerSupport.get(bundler)) {
@@ -20342,6 +20602,7 @@ var DopplerSDK = class {
 var VERSION = "1.0.0";
 
 exports.ADDRESSES = ADDRESSES;
+exports.AirlockCreateReceiptError = AirlockCreateReceiptError;
 exports.BASIS_POINTS = BASIS_POINTS;
 exports.CHAIN_IDS = CHAIN_IDS;
 exports.DAY_SECONDS = DAY_SECONDS;
@@ -20511,6 +20772,7 @@ exports.normalizeRehypeDopplerHookInitializerConfig = normalizeRehypeDopplerHook
 exports.openingAuctionAbi = openingAuctionAbi;
 exports.openingAuctionInitializerAbi = openingAuctionInitializerAbi;
 exports.openingAuctionPositionManagerAbi = openingAuctionPositionManagerAbi;
+exports.parseAirlockCreateReceipt = parseAirlockCreateReceipt;
 exports.poolManagerAbi = poolManagerAbi;
 exports.priceToSqrtPriceX96 = priceToSqrtPriceX96;
 exports.priceToTick = priceToTick;
@@ -20539,6 +20801,8 @@ exports.v4MulticurveInitializerAbi = v4MulticurveInitializerAbi;
 exports.v4MulticurveMigratorAbi = v4MulticurveMigratorAbi;
 exports.v4QuoterAbi = v4QuoterAbi;
 exports.validateMarketCapParameters = validateMarketCapParameters;
+exports.verifyPreparedCreateExecution = verifyPreparedCreateExecution;
+exports.verifyPreparedCreateReceipt = verifyPreparedCreateReceipt;
 exports.weth9Abi = weth9Abi;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map