@whetstone-research/doppler-sdk 1.0.22 → 1.0.23

package/dist/evm/index.cjs

@@ -12377,120 +12377,16 @@ var DynamicAuction = class {
     return value;
   }
 };
-function getMulticall3Address(client) {
-  const multicall3Address = client.chain?.contracts?.multicall3?.address;
-  if (!multicall3Address || multicall3Address === viem.zeroAddress) {
-    throw new Error(
-      "Multicall3 address is not configured on this chain. Configure the viem chain multicall3 contract before previewing pending fees."
-    );
-  }
-  return multicall3Address;
-}
-async function callAggregate3(client, calls) {
-  const response = await client.call({
-    to: getMulticall3Address(client),
-    data: viem.encodeFunctionData({
-      abi: viem.multicall3Abi,
-      functionName: "aggregate3",
-      args: [calls]
-    })
-  });
-  if (!response.data) {
-    throw new Error("Multicall3 aggregate3 returned no data");
-  }
-  return viem.decodeFunctionResult({
-    abi: viem.multicall3Abi,
-    functionName: "aggregate3",
-    data: response.data
-  });
-}
-var PENDING_FEE_CALL_ORDER = [
-  "collectFees",
-  "getShares",
-  "getCumulatedFees0",
-  "getCumulatedFees1",
-  "getLastCumulatedFees0",
-  "getLastCumulatedFees1"
+var ABSENT_POOL_ERROR_ABI = [
+  { type: "error", name: "PoolNotFound", inputs: [] },
+  { type: "error", name: "PoolNotInitialized", inputs: [] }
 ];
-function createPendingFeePreviewCalls(target, poolId, beneficiary) {
-  return PENDING_FEE_CALL_ORDER.map((functionName) => ({
-    target,
-    allowFailure: true,
-    callData: viem.encodeFunctionData({
-      abi: feeClaimsInitializerAbi,
-      functionName,
-      args: functionName === "collectFees" || functionName === "getCumulatedFees0" || functionName === "getCumulatedFees1" ? [poolId] : [poolId, beneficiary]
-    })
-  }));
-}
-function calculatePendingFees(callResults) {
-  const preview = decodePendingFeePreview(callResults);
-  if (preview.cumulatedFees0 < preview.lastCumulatedFees0) {
-    throw new Error("Accumulated fees are below beneficiary checkpoint");
-  }
-  if (preview.cumulatedFees1 < preview.lastCumulatedFees1) {
-    throw new Error("Accumulated fees are below beneficiary checkpoint");
-  }
-  return {
-    fees0: (preview.cumulatedFees0 - preview.lastCumulatedFees0) * preview.shares / WAD,
-    fees1: (preview.cumulatedFees1 - preview.lastCumulatedFees1) * preview.shares / WAD
-  };
-}
-function decodePendingFeePreview(callResults) {
-  if (callResults.length !== PENDING_FEE_CALL_ORDER.length) {
-    throw new Error("Multicall3 aggregate3 returned an incomplete pool result");
-  }
-  for (const [index, result] of callResults.entries()) {
-    const functionName = PENDING_FEE_CALL_ORDER[index];
-    if (!result.success) {
-      throw new Error(`${functionName} call failed`);
-    }
-    if (!result.returnData || result.returnData === "0x") {
-      throw new Error(`${functionName} returned no data`);
-    }
-  }
-  viem.decodeFunctionResult({
-    abi: feeClaimsInitializerAbi,
-    functionName: "collectFees",
-    data: callResults[0].returnData
-  });
-  return {
-    shares: decodeUint256("getShares", callResults[1].returnData),
-    cumulatedFees0: decodeUint256(
-      "getCumulatedFees0",
-      callResults[2].returnData
-    ),
-    cumulatedFees1: decodeUint256(
-      "getCumulatedFees1",
-      callResults[3].returnData
-    ),
-    lastCumulatedFees0: decodeUint256(
-      "getLastCumulatedFees0",
-      callResults[4].returnData
-    ),
-    lastCumulatedFees1: decodeUint256(
-      "getLastCumulatedFees1",
-      callResults[5].returnData
-    )
-  };
-}
-function decodeUint256(functionName, data) {
-  const value = viem.decodeFunctionResult({
-    abi: feeClaimsInitializerAbi,
-    functionName,
-    data
-  });
-  if (typeof value !== "bigint") {
-    throw new Error(`${functionName} returned invalid data`);
-  }
-  return value;
-}
 async function findMulticurveInitializerForPool({
   client,
   tokenAddress,
   addresses
 }) {
-  const initializersToTry = getInitializerCandidates(addresses);
+  const initializersToTry = getMulticurveInitializerCandidates(addresses);
   if (initializersToTry.length === 0) {
     throw new Error(
       "No V4 multicurve initializer addresses configured for this chain"
@@ -12505,7 +12401,7 @@ async function findMulticurveInitializerForPool({
     try {
       stateData = await client.readContract({
         address: initializerAddress,
-        abi: kind === "dopplerHook" ? dopplerHookInitializerAbi : v4MulticurveInitializerAbi,
+        abi: getMulticurveInitializerAbi(kind),
         functionName: "getState",
         args: [tokenAddress]
       });
@@ -12519,21 +12415,14 @@ async function findMulticurveInitializerForPool({
       );
       continue;
     }
-    const parsedState = kind === "dopplerHook" ? parseDopplerHookInitializerState(stateData) : parseStandardInitializerState(stateData);
-    const { numeraire, status, poolKey, farTick } = parsedState;
-    if (poolKey.hooks !== viem.zeroAddress && poolKey.tickSpacing !== 0) {
-      return {
-        initializerAddress,
-        state: {
-          asset: tokenAddress,
-          numeraire,
-          fee: poolKey.fee,
-          tickSpacing: poolKey.tickSpacing,
-          status,
-          poolKey,
-          farTick: Number(farTick)
-        }
-      };
+    const discoveryResult = parseMulticurveInitializerDiscoveryResult({
+      tokenAddress,
+      initializerAddress,
+      kind,
+      stateData
+    });
+    if (isInitializedMulticurvePoolKey(discoveryResult.state.poolKey)) {
+      return discoveryResult;
     }
   }
   const notFoundError = new Error(
@@ -12557,7 +12446,7 @@ function parseMulticurvePoolKey(rawPoolKey) {
     hooks: poolKeyStruct.hooks ?? poolKeyStruct[4]
   };
 }
-function getInitializerCandidates(addresses) {
+function getMulticurveInitializerCandidates(addresses) {
   return [
     {
       address: addresses.v4MulticurveInitializer,
@@ -12579,6 +12468,50 @@ function getInitializerCandidates(addresses) {
     (entry) => Boolean(entry.address && entry.address !== viem.zeroAddress)
   );
 }
+function getMulticurveInitializerAbi(kind) {
+  return kind === "dopplerHook" ? dopplerHookInitializerAbi : v4MulticurveInitializerAbi;
+}
+function parseMulticurveInitializerDiscoveryResult({
+  tokenAddress,
+  initializerAddress,
+  kind,
+  stateData
+}) {
+  const parsedState = kind === "dopplerHook" ? parseDopplerHookInitializerState(stateData) : parseStandardInitializerState(stateData);
+  const { numeraire, status, poolKey, farTick } = parsedState;
+  return {
+    initializerAddress,
+    state: {
+      asset: tokenAddress,
+      numeraire,
+      fee: poolKey.fee,
+      tickSpacing: poolKey.tickSpacing,
+      status,
+      poolKey,
+      farTick: Number(farTick)
+    }
+  };
+}
+function isInitializedMulticurvePoolKey(poolKey) {
+  return poolKey.hooks !== viem.zeroAddress && poolKey.tickSpacing !== 0;
+}
+function isAbsentPoolRevertData(data) {
+  if (data === "0x") {
+    return false;
+  }
+  try {
+    const decodedError = viem.decodeErrorResult({
+      abi: ABSENT_POOL_ERROR_ABI,
+      data
+    });
+    return decodedError.errorName === "PoolNotFound" || decodedError.errorName === "PoolNotInitialized";
+  } catch (error) {
+    if (error instanceof Error) {
+      return false;
+    }
+    throw error;
+  }
+}
 function parseStandardInitializerState(stateData) {
   const state = stateData;
   return {
@@ -12704,6 +12637,288 @@ function readStructField(value, fieldName, tupleIndex) {
   }
   return 0;
 }
+function getMulticall3Address(client) {
+  const multicall3Address = client.chain?.contracts?.multicall3?.address;
+  if (!multicall3Address || multicall3Address === viem.zeroAddress) {
+    throw new Error(
+      "Multicall3 address is not configured on this chain. Configure the viem chain multicall3 contract before previewing pending fees."
+    );
+  }
+  return multicall3Address;
+}
+async function callAggregate3(client, calls) {
+  const response = await client.call({
+    to: getMulticall3Address(client),
+    data: viem.encodeFunctionData({
+      abi: viem.multicall3Abi,
+      functionName: "aggregate3",
+      args: [calls]
+    })
+  });
+  if (!response.data) {
+    throw new Error("Multicall3 aggregate3 returned no data");
+  }
+  return viem.decodeFunctionResult({
+    abi: viem.multicall3Abi,
+    functionName: "aggregate3",
+    data: response.data
+  });
+}
+var PENDING_FEE_CALL_ORDER = [
+  "collectFees",
+  "getShares",
+  "getCumulatedFees0",
+  "getCumulatedFees1",
+  "getLastCumulatedFees0",
+  "getLastCumulatedFees1"
+];
+var PENDING_FEE_PREVIEW_CALL_COUNT = PENDING_FEE_CALL_ORDER.length;
+function createPendingFeePreviewCalls(target, poolId, beneficiary) {
+  return PENDING_FEE_CALL_ORDER.map((functionName) => ({
+    target,
+    allowFailure: true,
+    callData: viem.encodeFunctionData({
+      abi: feeClaimsInitializerAbi,
+      functionName,
+      args: functionName === "collectFees" || functionName === "getCumulatedFees0" || functionName === "getCumulatedFees1" ? [poolId] : [poolId, beneficiary]
+    })
+  }));
+}
+function calculatePendingFees(callResults) {
+  const preview = decodePendingFeePreview(callResults);
+  if (preview.cumulatedFees0 < preview.lastCumulatedFees0) {
+    throw new Error("Accumulated fees are below beneficiary checkpoint");
+  }
+  if (preview.cumulatedFees1 < preview.lastCumulatedFees1) {
+    throw new Error("Accumulated fees are below beneficiary checkpoint");
+  }
+  return {
+    fees0: (preview.cumulatedFees0 - preview.lastCumulatedFees0) * preview.shares / WAD,
+    fees1: (preview.cumulatedFees1 - preview.lastCumulatedFees1) * preview.shares / WAD
+  };
+}
+function decodePendingFeePreview(callResults) {
+  if (callResults.length !== PENDING_FEE_CALL_ORDER.length) {
+    throw new Error("Multicall3 aggregate3 returned an incomplete pool result");
+  }
+  for (const [index, result] of callResults.entries()) {
+    const functionName = PENDING_FEE_CALL_ORDER[index];
+    if (!result.success) {
+      throw new Error(`${functionName} call failed`);
+    }
+    if (!result.returnData || result.returnData === "0x") {
+      throw new Error(`${functionName} returned no data`);
+    }
+  }
+  viem.decodeFunctionResult({
+    abi: feeClaimsInitializerAbi,
+    functionName: "collectFees",
+    data: callResults[0].returnData
+  });
+  return {
+    shares: decodeUint256("getShares", callResults[1].returnData),
+    cumulatedFees0: decodeUint256(
+      "getCumulatedFees0",
+      callResults[2].returnData
+    ),
+    cumulatedFees1: decodeUint256(
+      "getCumulatedFees1",
+      callResults[3].returnData
+    ),
+    lastCumulatedFees0: decodeUint256(
+      "getLastCumulatedFees0",
+      callResults[4].returnData
+    ),
+    lastCumulatedFees1: decodeUint256(
+      "getLastCumulatedFees1",
+      callResults[5].returnData
+    )
+  };
+}
+function decodeUint256(functionName, data) {
+  const value = viem.decodeFunctionResult({
+    abi: feeClaimsInitializerAbi,
+    functionName,
+    data
+  });
+  if (typeof value !== "bigint") {
+    throw new Error(`${functionName} returned invalid data`);
+  }
+  return value;
+}
+
+// src/evm/entities/auction/multicurve/multicurvePendingFeeReader.ts
+async function getPendingFeesForMulticurvePool({
+  client,
+  beneficiary,
+  poolContext
+}) {
+  const pendingFees = await getPendingFeesForDiscoveredMulticurvePools({
+    client,
+    beneficiary,
+    poolContexts: [poolContext]
+  });
+  const poolPendingFees = pendingFees[0];
+  if (!poolPendingFees) {
+    throw new Error("Pending fee preview returned no pool result");
+  }
+  return {
+    fees0: poolPendingFees.fees0,
+    fees1: poolPendingFees.fees1
+  };
+}
+async function getPendingFeesForMulticurveTokens({
+  client,
+  beneficiary,
+  tokenAddresses
+}) {
+  if (tokenAddresses.length === 0) {
+    return [];
+  }
+  const feeClient = client;
+  const poolContexts = await discoverMulticurveFeePoolContexts(
+    feeClient,
+    tokenAddresses
+  );
+  return getPendingFeesForDiscoveredMulticurvePools({
+    client: feeClient,
+    beneficiary,
+    poolContexts
+  });
+}
+async function discoverMulticurveFeePoolContexts(client, tokenAddresses) {
+  const chainId = await client.getChainId();
+  const addresses = getAddresses(chainId);
+  const initializers = getMulticurveInitializerCandidates(addresses);
+  if (initializers.length === 0) {
+    throw new Error(
+      "No V4 multicurve initializer addresses configured for this chain"
+    );
+  }
+  const discoveryContexts = createDiscoveryCallContexts(
+    tokenAddresses,
+    initializers
+  );
+  const discoveryResults = await callAggregate3(
+    client,
+    createDiscoveryCalls(discoveryContexts)
+  );
+  if (discoveryResults.length !== discoveryContexts.length) {
+    throw new Error(
+      "Multicall3 aggregate3 returned an incomplete initializer discovery result"
+    );
+  }
+  return tokenAddresses.map(
+    (tokenAddress, tokenIndex) => findInitializedPoolForToken({
+      tokenAddress,
+      initializers,
+      discoveryResults: discoveryResults.slice(
+        tokenIndex * initializers.length,
+        (tokenIndex + 1) * initializers.length
+      )
+    })
+  );
+}
+function createDiscoveryCallContexts(tokenAddresses, initializers) {
+  return tokenAddresses.flatMap(
+    (tokenAddress) => initializers.map((initializer) => ({
+      tokenAddress,
+      initializer
+    }))
+  );
+}
+function createDiscoveryCalls(contexts) {
+  return contexts.map(({ tokenAddress, initializer }) => ({
+    target: initializer.address,
+    allowFailure: true,
+    callData: viem.encodeFunctionData({
+      abi: getMulticurveInitializerAbi(initializer.kind),
+      functionName: "getState",
+      args: [tokenAddress]
+    })
+  }));
+}
+function findInitializedPoolForToken({
+  tokenAddress,
+  initializers,
+  discoveryResults
+}) {
+  for (const [index, result] of discoveryResults.entries()) {
+    const initializer = initializers[index];
+    if (!initializer) {
+      throw new Error(
+        "Multicall3 aggregate3 returned an incomplete initializer discovery result"
+      );
+    }
+    if (!result.success) {
+      if (isAbsentPoolRevertData(result.returnData)) {
+        continue;
+      }
+      throw new Error(
+        `${initializer.address} getState failed for token ${tokenAddress}`
+      );
+    }
+    if (!result.returnData || result.returnData === "0x") {
+      throw new Error(
+        `${initializer.address} getState returned no data for token ${tokenAddress}`
+      );
+    }
+    const discoveryResult = parseMulticurveInitializerDiscoveryResult({
+      tokenAddress,
+      initializerAddress: initializer.address,
+      kind: initializer.kind,
+      stateData: viem.decodeFunctionResult({
+        abi: getMulticurveInitializerAbi(initializer.kind),
+        functionName: "getState",
+        data: result.returnData
+      })
+    });
+    if (isInitializedMulticurvePoolKey(discoveryResult.state.poolKey)) {
+      assertPendingFeePreviewable(discoveryResult);
+      return discoveryResult;
+    }
+  }
+  throw new Error(
+    `Pool not found for token ${tokenAddress}. Tried initializers: ${initializers.map((initializer) => initializer.address).join(", ")}`
+  );
+}
+function assertPendingFeePreviewable(discoveryResult) {
+  const { asset, status } = discoveryResult.state;
+  if (status === 3 /* Exited */) {
+    throw new Error(
+      `Pending fee preview is only supported for initializer-side multicurve pools: ${asset}`
+    );
+  }
+  if (status !== 2 /* Locked */) {
+    throw new Error(`Multicurve pool is not locked or was migrated: ${asset}`);
+  }
+}
+async function getPendingFeesForDiscoveredMulticurvePools({
+  client,
+  beneficiary,
+  poolContexts
+}) {
+  for (const poolContext of poolContexts) {
+    assertPendingFeePreviewable(poolContext);
+  }
+  const previewCalls = poolContexts.flatMap(
+    ({ initializerAddress, state }) => createPendingFeePreviewCalls(
+      initializerAddress,
+      computePoolId(state.poolKey),
+      beneficiary
+    )
+  );
+  const previewResults = await callAggregate3(client, previewCalls);
+  return poolContexts.map(({ state }, index) => ({
+    tokenAddress: state.asset,
+    ...calculatePendingFees(
+      previewResults.slice(
+        index * PENDING_FEE_PREVIEW_CALL_COUNT,
+        (index + 1) * PENDING_FEE_PREVIEW_CALL_COUNT
+      )
+    )
+  }));
+}
 
 // src/evm/entities/auction/MulticurvePool.ts
 var MulticurvePool = class {
@@ -12782,21 +12997,11 @@ var MulticurvePool = class {
    * Preview pending fees for a beneficiary on an initializer-side multicurve pool.
    */
   async getPendingFees(beneficiary) {
-    const { initializerAddress, state } = await this.findInitializerForPool();
-    if (state.status === 3 /* Exited */) {
-      throw new Error(
-        "Pending fee preview is only supported for initializer-side multicurve pools"
-      );
-    }
-    if (state.status !== 2 /* Locked */) {
-      throw new Error("Multicurve pool is not locked or was migrated");
-    }
-    const poolId = computePoolId(state.poolKey);
-    const callResults = await callAggregate3(
-      this.rpc,
-      createPendingFeePreviewCalls(initializerAddress, poolId, beneficiary)
-    );
-    return calculatePendingFees(callResults);
+    return getPendingFeesForMulticurvePool({
+      client: this.rpc,
+      beneficiary,
+      poolContext: await this.findInitializerForPool()
+    });
   }
   /**
    * Get the numeraire address for this pool
@@ -12816,6 +13021,55 @@ var MulticurvePool = class {
   }
 };
 
+// src/evm/entities/auction/MulticurveFees.ts
+var MulticurveFees = class {
+  client;
+  tokenAddresses;
+  options;
+  constructor(client, _walletClient, tokenAddresses, options = {}) {
+    this.client = client;
+    this.tokenAddresses = [...tokenAddresses];
+    this.options = { ...options };
+  }
+  async getPendingFees(beneficiary, tokenAddressesOrOptions, options) {
+    const hasTokenAddressOverride = isTokenAddressList(tokenAddressesOrOptions);
+    const tokenAddresses = hasTokenAddressOverride ? tokenAddressesOrOptions : this.tokenAddresses;
+    const callOptions = hasTokenAddressOverride ? options : tokenAddressesOrOptions;
+    const tokenBatchSize = getTokenBatchSize(
+      callOptions?.tokenBatchSize ?? this.options.tokenBatchSize
+    );
+    if (!tokenBatchSize || tokenAddresses.length <= tokenBatchSize) {
+      return getPendingFeesForMulticurveTokens({
+        client: this.client,
+        beneficiary,
+        tokenAddresses
+      });
+    }
+    let pendingFees = [];
+    for (let index = 0; index < tokenAddresses.length; index += tokenBatchSize) {
+      const batchPendingFees = await getPendingFeesForMulticurveTokens({
+        client: this.client,
+        beneficiary,
+        tokenAddresses: tokenAddresses.slice(index, index + tokenBatchSize)
+      });
+      pendingFees = [...pendingFees, ...batchPendingFees];
+    }
+    return pendingFees;
+  }
+};
+function isTokenAddressList(value) {
+  return Array.isArray(value);
+}
+function getTokenBatchSize(tokenBatchSize) {
+  if (tokenBatchSize === void 0) {
+    return void 0;
+  }
+  if (!Number.isInteger(tokenBatchSize) || tokenBatchSize < 1) {
+    throw new Error("tokenBatchSize must be a positive integer");
+  }
+  return tokenBatchSize;
+}
+
 // src/evm/entities/auction/RehypeDopplerHook.ts
 var RehypeDopplerHook = class {
   client;
@@ -19058,6 +19312,7 @@ exports.MAX_TICK = MAX_TICK;
 exports.MIN_SQRT_RATIO = MIN_SQRT_RATIO;
 exports.MIN_TICK = MIN_TICK;
 exports.MulticurveBuilder = MulticurveBuilder;
+exports.MulticurveFees = MulticurveFees;
 exports.MulticurvePool = MulticurvePool;
 exports.NO_OP_ENABLED_CHAIN_IDS = NO_OP_ENABLED_CHAIN_IDS;
 exports.OPENING_AUCTION_FLAGS = OPENING_AUCTION_FLAGS;