@obolnetwork/obol-sdk 2.12.0 → 2.12.1

package/dist/browser/src/index.js

@@ -98,7 +98,7 @@ import { v4 as uuidv4 } from "uuid";
 // package.json
 var package_default = {
   name: "@obolnetwork/obol-sdk",
-  version: "2.12.0",
+  version: "2.12.1",
   description: "A package for creating Distributed Validators using the Obol API.",
   bugs: {
     url: "https://github.com/obolnetwork/obol-sdk/issues"
@@ -582,6 +582,19 @@ var UnsupportedChainError = class _UnsupportedChainError extends Error {
     Object.setPrototypeOf(this, _UnsupportedChainError.prototype);
   }
 };
+var ClusterLockValidationTimeoutError = class _ClusterLockValidationTimeoutError extends Error {
+  /**
+   * @param timeoutMs - Same value as SDK whole-lock validation worker timeout.
+   */
+  constructor(timeoutMs) {
+    super(
+      `Cluster lock validation exceeded worker time limit (${timeoutMs} ms). Retry later; this does not imply invalid lock data.`
+    );
+    this.timeoutMs = timeoutMs;
+    this.name = "ClusterLockValidationTimeoutError";
+    Object.setPrototypeOf(this, _ClusterLockValidationTimeoutError.prototype);
+  }
+};
 
 // src/verification/common.ts
 import { fromHexString as fromHexString6 } from "@chainsafe/ssz";
@@ -714,6 +727,9 @@ import {
   fromHexString as fromHexString2
 } from "@chainsafe/ssz";
 
+// src/verification/parallelPool.ts
+import { fromHexString } from "@chainsafe/ssz";
+
 // node_modules/@noble/curves/node_modules/@noble/hashes/utils.js
 function isBytes(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
@@ -5139,6 +5155,12 @@ function blsVerify(pubkey, message2, signature) {
     return false;
   }
 }
+function blsAggregatePublicKeys(pubkeys) {
+  if (pubkeys.length === 0) {
+    throw new Error("cannot aggregate empty pubkey set");
+  }
+  return ls.aggregatePublicKeys(pubkeys).toBytes();
+}
 function blsVerifyAggregate(pubkeys, message2, signature) {
   try {
     return ls.verify(
@@ -5150,6 +5172,13 @@ function blsVerifyAggregate(pubkeys, message2, signature) {
     return false;
   }
 }
+function blsVerifyWithAggregatedPubkey(aggregatedPubkey, message2, signature) {
+  try {
+    return ls.verify(signature, ls.hash(message2, ETH2_DST), aggregatedPubkey);
+  } catch (e) {
+    return false;
+  }
+}
 function blsVerifyMultiple(pubkeys, messages, signature) {
   try {
     if (pubkeys.length !== messages.length) return false;
@@ -5215,16 +5244,23 @@ function blsVerifyExtraShares(pubshares, threshold, distributedPubkey) {
 }
 
 // src/verification/parallelPool.ts
-import { fromHexString } from "@chainsafe/ssz";
 var MIN_PARALLEL_VALIDATORS = 50;
 var MIN_PARALLEL_BATCH_PAIRS = 100;
 var MAX_WORKERS = 8;
 var MIN_VALIDATORS_PER_WORKER = 25;
 var MIN_PAIRS_PER_WORKER = 50;
+var MIN_PARALLEL_AGGREGATE_KEYS = 400;
+var MIN_KEYS_PER_WORKER_AGG = 100;
+var MIN_VALIDATORS_FOR_VALIDATION_WORKER = 50;
+var VALIDATION_WORKER_TIMEOUT_MS = 12e4;
 var WORKER_TIMEOUT_MS = 6e4;
+var MAX_CONCURRENT_WORKERS_CAP = 8;
+function maxConcurrentWorkers(numWorkers) {
+  return Math.min(numWorkers, MAX_CONCURRENT_WORKERS_CAP);
+}
 var workerThreadsCache;
 var osCache;
-var workerPathCache;
+var workerPathByFile = /* @__PURE__ */ new Map();
 function loadWorkerThreads() {
   if (workerThreadsCache !== void 0) return workerThreadsCache;
   try {
@@ -5243,18 +5279,47 @@ function loadOs() {
   }
   return osCache;
 }
-function getWorkerPath() {
-  if (workerPathCache !== void 0) return workerPathCache;
-  if (typeof __dirname === "undefined") return workerPathCache = null;
+function getWorkerPath(filename) {
+  const cached = workerPathByFile.get(filename);
+  if (cached !== void 0) return cached;
+  if (typeof __dirname === "undefined") {
+    workerPathByFile.set(filename, null);
+    return null;
+  }
   const path = __require("path");
-  const candidate = path.join(__dirname, "lockWorker.js");
+  const fs = __require("fs");
+  const candidates = [
+    path.join(__dirname, filename),
+    path.join(__dirname, "verification", filename)
+  ];
   try {
-    const fs = __require("fs");
-    if (!fs.existsSync(candidate)) return workerPathCache = null;
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) {
+        workerPathByFile.set(filename, candidate);
+        return candidate;
+      }
+    }
   } catch (e) {
-    return workerPathCache = null;
   }
-  return workerPathCache = candidate;
+  workerPathByFile.set(filename, null);
+  return null;
+}
+function mapWithConcurrency(items, concurrency, fn) {
+  return __async(this, null, function* () {
+    const results = new Array(items.length);
+    let next = 0;
+    const runners = Array.from(
+      { length: Math.min(concurrency, items.length) },
+      () => __async(null, null, function* () {
+        while (next < items.length) {
+          const i = next++;
+          results[i] = yield fn(items[i], i);
+        }
+      })
+    );
+    yield Promise.all(runners);
+    return results;
+  });
 }
 function chunkArrays(arr, n) {
   const size = Math.ceil(arr.length / n);
@@ -5283,6 +5348,33 @@ function verifySharesSync(shares, distributedKeys, threshold) {
   }
   return true;
 }
+function runWorkerAggregatePubkeys(wt, workerFile, data) {
+  return __async(this, null, function* () {
+    return yield new Promise((resolve) => {
+      let settled = false;
+      const worker = new wt.Worker(workerFile, { workerData: data });
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        worker.terminate();
+        resolve(result);
+      };
+      const timer = setTimeout(() => {
+        finish(null);
+      }, WORKER_TIMEOUT_MS);
+      worker.once("message", (msg) => {
+        finish(msg instanceof Uint8Array ? msg : null);
+      });
+      worker.once("error", () => {
+        finish(null);
+      });
+      worker.once("exit", (code2) => {
+        if (code2 !== 0) finish(null);
+      });
+    });
+  });
+}
 function runWorker(wt, workerFile, data) {
   return __async(this, null, function* () {
     return yield new Promise((resolve) => {
@@ -5313,8 +5405,8 @@ function runWorker(wt, workerFile, data) {
 function poolSize(itemCount, minPerWorker) {
   const wt = loadWorkerThreads();
   const os = loadOs();
-  const workerFile = getWorkerPath();
-  const numCpus = os ? os.cpus().length : 1;
+  const workerFile = getWorkerPath("lockWorker.js");
+  const numCpus = os ? Math.max(1, os.cpus().length) : 1;
   const numWorkers = Math.min(
     MAX_WORKERS,
     Math.max(1, Math.floor(itemCount / minPerWorker)),
@@ -5322,6 +5414,18 @@ function poolSize(itemCount, minPerWorker) {
   );
   return { numWorkers, wt, workerFile };
 }
+function runWorkerChunks(wt, workerFile, chunks) {
+  return __async(this, null, function* () {
+    const results = yield mapWithConcurrency(
+      chunks,
+      maxConcurrentWorkers(chunks.length),
+      (data) => __async(null, null, function* () {
+        return yield runWorker(wt, workerFile, data);
+      })
+    );
+    return results.every(Boolean);
+  });
+}
 function verifySharesBinding(shares, distributedKeys, threshold) {
   return __async(this, null, function* () {
     if (shares.length !== distributedKeys.length) return false;
@@ -5335,19 +5439,26 @@ function verifySharesBinding(shares, distributedKeys, threshold) {
     }
     const shareChunks = chunkArrays(shares, numWorkers);
     const keyChunks = chunkArrays(distributedKeys, numWorkers);
-    const results = yield Promise.all(
-      shareChunks.map(
-        (chunk, i) => __async(null, null, function* () {
-          return yield runWorker(wt, workerFile, {
-            mode: "shareBinding",
-            shares: chunk,
-            distributedKeys: keyChunks[i],
-            threshold
-          });
-        })
-      )
+    return yield runWorkerChunks(
+      wt,
+      workerFile,
+      shareChunks.map((chunk, i) => ({
+        mode: "shareBinding",
+        shares: chunk,
+        distributedKeys: keyChunks[i],
+        threshold
+      }))
+    );
+  });
+}
+function verifyBlsChecksParallel(checks) {
+  return __async(this, null, function* () {
+    if (checks.length === 0) return true;
+    return yield verifyBatchParallel(
+      checks.map((c) => c.pubkey),
+      checks.map((c) => c.message),
+      checks.map((c) => c.signature)
     );
-    return results.every(Boolean);
   });
 }
 function verifyBatchParallel(pubkeys, messages, signatures) {
@@ -5370,19 +5481,84 @@ function verifyBatchParallel(pubkeys, messages, signatures) {
     const pkChunks = chunkArrays(pubkeys, numWorkers);
     const msgChunks = chunkArrays(messages, numWorkers);
     const sigChunks = chunkArrays(signatures, numWorkers);
-    const results = yield Promise.all(
-      pkChunks.map(
-        (pks, i) => __async(null, null, function* () {
-          return yield runWorker(wt, workerFile, {
-            mode: "verifyBatch",
-            pubkeys: pks,
-            messages: msgChunks[i],
-            aggregateSignature: blsAggregateSignatures(sigChunks[i])
-          });
-        })
-      )
+    return yield runWorkerChunks(
+      wt,
+      workerFile,
+      pkChunks.map((pks, i) => ({
+        mode: "verifyBatch",
+        pubkeys: pks,
+        messages: msgChunks[i],
+        signatures: sigChunks[i]
+      }))
     );
-    return results.every(Boolean);
+  });
+}
+function verifyAggregateParallel(pubkeys, message2, signature) {
+  return __async(this, null, function* () {
+    if (pubkeys.length === 0) return false;
+    const { numWorkers, wt, workerFile } = poolSize(
+      pubkeys.length,
+      MIN_KEYS_PER_WORKER_AGG
+    );
+    if (wt === null || workerFile === null || pubkeys.length < MIN_PARALLEL_AGGREGATE_KEYS || numWorkers < 2) {
+      return blsVerifyAggregate(pubkeys, message2, signature);
+    }
+    const pkChunks = chunkArrays(pubkeys, numWorkers);
+    const partials = yield mapWithConcurrency(
+      pkChunks,
+      maxConcurrentWorkers(pkChunks.length),
+      (chunk) => __async(null, null, function* () {
+        return yield runWorkerAggregatePubkeys(wt, workerFile, {
+          mode: "aggregatePubkeys",
+          pubkeys: chunk
+        });
+      })
+    );
+    if (partials.some((p) => p === null)) return false;
+    const aggregated = blsAggregatePublicKeys(partials);
+    return blsVerifyWithAggregatedPubkey(aggregated, message2, signature);
+  });
+}
+function validateClusterLockInWorker(lock, safeRpcUrl) {
+  return __async(this, null, function* () {
+    var _a6, _b2;
+    const n = (_b2 = (_a6 = lock.distributed_validators) == null ? void 0 : _a6.length) != null ? _b2 : 0;
+    if (n < MIN_VALIDATORS_FOR_VALIDATION_WORKER) return null;
+    const wt = loadWorkerThreads();
+    const workerFile = getWorkerPath("clusterLockValidationWorker.js");
+    if (wt === null || workerFile === null) return null;
+    return yield new Promise((resolve, reject) => {
+      let settled = false;
+      const worker = new wt.Worker(workerFile, {
+        workerData: { lock, safeRpcUrl }
+      });
+      let timer;
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        worker.terminate();
+        resolve(result);
+      };
+      timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        void worker.terminate();
+        reject(
+          new ClusterLockValidationTimeoutError(VALIDATION_WORKER_TIMEOUT_MS)
+        );
+      }, VALIDATION_WORKER_TIMEOUT_MS);
+      worker.once("message", (msg) => {
+        finish(msg === true);
+      });
+      worker.once("error", () => {
+        finish(null);
+      });
+      worker.once("exit", (code2) => {
+        if (code2 !== 0) finish(null);
+      });
+    });
   });
 }
 
@@ -5487,7 +5663,6 @@ var hashClusterLockV1X6 = (cluster) => {
   return "0x" + Buffer.from(lockType.hashTreeRoot(val).buffer).toString("hex");
 };
 var verifyDVV1X6 = (clusterLock) => __async(null, null, function* () {
-  var _a6;
   const validators = clusterLock.distributed_validators;
   const operatorCount = clusterLock.cluster_definition.operators.length;
   const threshold = clusterLock.cluster_definition.threshold;
@@ -5506,9 +5681,7 @@ var verifyDVV1X6 = (clusterLock) => __async(null, null, function* () {
     return false;
   }
   const pubShares = [];
-  const pubKeys = [];
-  const builderRegistrationAndDepositDataMessages = [];
-  const blsSignatures = [];
+  const blsChecks = [];
   for (let i = 0; i < validators.length; i++) {
     const validator = validators[i];
     const validatorPublicShares = validator.public_shares;
@@ -5526,33 +5699,23 @@ var verifyDVV1X6 = (clusterLock) => __async(null, null, function* () {
     for (const share of validatorPublicSharesBytes) {
       pubShares.push(share);
     }
-    const { isValidDepositData, depositDataMsg } = verifyDepositData(
+    const depositCheck = depositBlsCheck(
       distributedPublicKey,
       validator.deposit_data,
       clusterLock.cluster_definition.validators[i].withdrawal_address,
       clusterLock.cluster_definition.fork_version
     );
-    if (!isValidDepositData) {
-      return false;
-    }
-    pubKeys.push(fromHexString2(validator.distributed_public_key));
-    builderRegistrationAndDepositDataMessages.push(depositDataMsg);
-    blsSignatures.push(
-      fromHexString2((_a6 = validator.deposit_data) == null ? void 0 : _a6.signature)
-    );
+    if (!depositCheck) return false;
+    blsChecks.push(depositCheck);
   }
-  if (!(yield verifyBatchParallel(
-    pubKeys,
-    builderRegistrationAndDepositDataMessages,
-    blsSignatures
-  ))) {
+  if (!(yield verifyBlsChecksParallel(blsChecks))) {
     return false;
   }
-  if (!blsVerifyAggregate(
+  if (!(yield verifyAggregateParallel(
     pubShares,
     fromHexString2(clusterLock.lock_hash),
     fromHexString2(clusterLock.signature_aggregate)
-  )) {
+  ))) {
     return false;
   }
   return true;
@@ -5686,7 +5849,6 @@ var hashClusterLockV1X7 = (cluster) => {
   return "0x" + Buffer.from(lockType.hashTreeRoot(val).buffer).toString("hex");
 };
 var verifyDVV1X7 = (clusterLock) => __async(null, null, function* () {
-  var _a6, _b2;
   const validators = clusterLock.distributed_validators;
   const operatorCount = clusterLock.cluster_definition.operators.length;
   const threshold = clusterLock.cluster_definition.threshold;
@@ -5705,9 +5867,7 @@ var verifyDVV1X7 = (clusterLock) => __async(null, null, function* () {
     return false;
   }
   const pubShares = [];
-  const pubKeys = [];
-  const builderRegistrationAndDepositDataMessages = [];
-  const blsSignatures = [];
+  const blsChecks = [];
   for (let i = 0; i < validators.length; i++) {
     const validator = validators[i];
     const validatorPublicShares = validator.public_shares;
@@ -5725,49 +5885,33 @@ var verifyDVV1X7 = (clusterLock) => __async(null, null, function* () {
     for (const share of validatorPublicSharesBytes) {
       pubShares.push(share);
     }
-    const { isValidDepositData, depositDataMsg } = verifyDepositData(
+    const depositCheck = depositBlsCheck(
       distributedPublicKey,
       validator.deposit_data,
       clusterLock.cluster_definition.validators[i].withdrawal_address,
       clusterLock.cluster_definition.fork_version
     );
-    if (!isValidDepositData) {
-      return false;
-    }
-    pubKeys.push(fromHexString3(distributedPublicKey));
-    builderRegistrationAndDepositDataMessages.push(depositDataMsg);
-    blsSignatures.push(
-      fromHexString3((_a6 = validator.deposit_data) == null ? void 0 : _a6.signature)
-    );
-    const { isValidBuilderRegistration, builderRegistrationMsg } = verifyBuilderRegistration(
+    if (!depositCheck) return false;
+    blsChecks.push(depositCheck);
+    const builderCheck = builderBlsCheck(
       validator,
       clusterLock.cluster_definition.validators[i].fee_recipient_address,
       clusterLock.cluster_definition.fork_version
     );
-    if (!isValidBuilderRegistration) {
-      return false;
-    }
-    pubKeys.push(fromHexString3(distributedPublicKey));
-    builderRegistrationAndDepositDataMessages.push(builderRegistrationMsg);
-    blsSignatures.push(
-      fromHexString3((_b2 = validator.builder_registration) == null ? void 0 : _b2.signature)
-    );
+    if (!builderCheck) return false;
+    blsChecks.push(builderCheck);
   }
-  if (!(yield verifyBatchParallel(
-    pubKeys,
-    builderRegistrationAndDepositDataMessages,
-    blsSignatures
-  ))) {
+  if (!(yield verifyBlsChecksParallel(blsChecks))) {
     return false;
   }
   if (!verifyNodeSignatures(clusterLock)) {
     return false;
   }
-  if (!blsVerifyAggregate(
+  if (!(yield verifyAggregateParallel(
     pubShares,
     fromHexString3(clusterLock.lock_hash),
     fromHexString3(clusterLock.signature_aggregate)
-  )) {
+  ))) {
     return false;
   }
   return true;
@@ -15364,7 +15508,6 @@ var hashClusterLockV1X8 = (cluster) => {
   return "0x" + Buffer.from(lockType.hashTreeRoot(val).buffer).toString("hex");
 };
 var verifyDVV1X8 = (clusterLock) => __async(null, null, function* () {
-  var _a6;
   const validators = clusterLock.distributed_validators;
   const operatorCount = clusterLock.cluster_definition.operators.length;
   const threshold = clusterLock.cluster_definition.threshold;
@@ -15383,9 +15526,10 @@ var verifyDVV1X8 = (clusterLock) => __async(null, null, function* () {
     return false;
   }
   const pubShares = [];
-  const pubKeys = [];
-  const builderRegistrationAndDepositDataMessages = [];
-  const blsSignatures = [];
+  const blsChecks = [];
+  const forkVersion = clusterLock.cluster_definition.fork_version;
+  const depositDomain = depositDomainForFork(forkVersion);
+  const builderDomain = builderDomainForFork(forkVersion);
   for (let i = 0; i < validators.length; i++) {
     const validator = validators[i];
     const validatorPublicShares = validator.public_shares;
@@ -15412,51 +15556,38 @@ var verifyDVV1X8 = (clusterLock) => __async(null, null, function* () {
         return false;
       }
     }
-    for (const element of validator.partial_deposit_data) {
-      const depositData = element;
-      const { isValidDepositData, depositDataMsg } = verifyDepositData(
+    for (const depositData of validator.partial_deposit_data) {
+      const check = depositBlsCheck(
         distributedPublicKey,
         depositData,
         clusterLock.cluster_definition.validators[i].withdrawal_address,
-        clusterLock.cluster_definition.fork_version,
-        clusterLock.cluster_definition.compounding
+        forkVersion,
+        clusterLock.cluster_definition.compounding,
+        depositDomain
       );
-      if (!isValidDepositData) {
-        return false;
-      }
-      pubKeys.push(fromHexString4(distributedPublicKey));
-      builderRegistrationAndDepositDataMessages.push(depositDataMsg);
-      blsSignatures.push(fromHexString4(depositData == null ? void 0 : depositData.signature));
+      if (!check) return false;
+      blsChecks.push(check);
     }
-    const { isValidBuilderRegistration, builderRegistrationMsg } = verifyBuilderRegistration(
+    const builderCheck = builderBlsCheck(
       validator,
       clusterLock.cluster_definition.validators[i].fee_recipient_address,
-      clusterLock.cluster_definition.fork_version
-    );
-    if (!isValidBuilderRegistration) {
-      return false;
-    }
-    pubKeys.push(fromHexString4(distributedPublicKey));
-    builderRegistrationAndDepositDataMessages.push(builderRegistrationMsg);
-    blsSignatures.push(
-      fromHexString4((_a6 = validator.builder_registration) == null ? void 0 : _a6.signature)
+      forkVersion,
+      builderDomain
     );
+    if (!builderCheck) return false;
+    blsChecks.push(builderCheck);
   }
-  if (!(yield verifyBatchParallel(
-    pubKeys,
-    builderRegistrationAndDepositDataMessages,
-    blsSignatures
-  ))) {
+  if (!(yield verifyBlsChecksParallel(blsChecks))) {
     return false;
   }
   if (!verifyNodeSignatures(clusterLock)) {
     return false;
   }
-  if (!blsVerifyAggregate(
+  if (!(yield verifyAggregateParallel(
     pubShares,
     fromHexString4(clusterLock.lock_hash),
     fromHexString4(clusterLock.signature_aggregate)
-  )) {
+  ))) {
     return false;
   }
   return true;
@@ -15871,37 +16002,62 @@ var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = fromHe
   domain.set(forkDataRoot.subarray(0, 28), 4);
   return domain;
 };
-var verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding) => {
-  const depositDomain = computeDomain(
-    fromHexString6(DOMAIN_DEPOSIT),
-    forkVersion
-  );
+var depositDomainForFork = (forkVersion) => computeDomain(fromHexString6(DOMAIN_DEPOSIT), forkVersion);
+var builderDomainForFork = (forkVersion) => computeDomain(fromHexString6(DOMAIN_APPLICATION_BUILDER), forkVersion);
+var validateDepositDataStructure = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding, precomputedDepositDomain) => {
+  const depositDomain = precomputedDepositDomain != null ? precomputedDepositDomain : computeDomain(fromHexString6(DOMAIN_DEPOSIT), forkVersion);
   const withdrawalPrefix = compounding ? "0x02" : "0x01";
   const expectedWithdrawalCredentials = withdrawalPrefix + "0".repeat(22) + withdrawalAddress.toLowerCase().slice(2);
   if (expectedWithdrawalCredentials !== depositData.withdrawal_credentials) {
-    return { isValidDepositData: false, depositDataMsg: new Uint8Array(0) };
+    return { valid: false, message: new Uint8Array(0) };
   }
   if (distributedPublicKey !== depositData.pubkey) {
-    return { isValidDepositData: false, depositDataMsg: new Uint8Array(0) };
+    return { valid: false, message: new Uint8Array(0) };
   }
   const depositMessageBuffer = computeDepositMsgRoot(depositData);
-  const depositDataRoot = signingRoot(depositDomain, depositMessageBuffer);
+  const message2 = signingRoot(depositDomain, depositMessageBuffer);
   if (!depositData.signature) {
-    return { isValidDepositData: false, depositDataMsg: depositDataRoot };
+    return { valid: false, message: message2 };
+  }
+  return { valid: true, message: message2 };
+};
+var depositBlsCheck = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding, precomputedDepositDomain) => {
+  const { valid, message: message2 } = validateDepositDataStructure(
+    distributedPublicKey,
+    depositData,
+    withdrawalAddress,
+    forkVersion,
+    compounding,
+    precomputedDepositDomain
+  );
+  if (!valid || !depositData.signature || !depositData.pubkey) return null;
+  return {
+    pubkey: fromHexString6(depositData.pubkey),
+    message: message2,
+    signature: fromHexString6(depositData.signature)
+  };
+};
+var verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding) => {
+  const { valid, message: message2 } = validateDepositDataStructure(
+    distributedPublicKey,
+    depositData,
+    withdrawalAddress,
+    forkVersion,
+    compounding
+  );
+  if (!valid || !depositData.signature || !depositData.pubkey) {
+    return { isValidDepositData: false, depositDataMsg: message2 };
   }
   const isValidDepositData = blsVerify(
     fromHexString6(depositData.pubkey),
-    depositDataRoot,
+    message2,
     fromHexString6(depositData.signature)
   );
-  return { isValidDepositData, depositDataMsg: depositDataRoot };
+  return { isValidDepositData, depositDataMsg: message2 };
 };
-var verifyBuilderRegistration = (validator, feeRecipientAddress, forkVersion) => {
+var verifyBuilderRegistration = (validator, feeRecipientAddress, forkVersion, precomputedBuilderDomain) => {
   var _a6;
-  const builderDomain = computeDomain(
-    fromHexString6(DOMAIN_APPLICATION_BUILDER),
-    forkVersion
-  );
+  const builderDomain = precomputedBuilderDomain != null ? precomputedBuilderDomain : computeDomain(fromHexString6(DOMAIN_APPLICATION_BUILDER), forkVersion);
   if (validator.distributed_public_key !== ((_a6 = validator.builder_registration) == null ? void 0 : _a6.message.pubkey)) {
     return {
       isValidBuilderRegistration: false,
@@ -15926,6 +16082,22 @@ var verifyBuilderRegistration = (validator, feeRecipientAddress, forkVersion) =>
     builderRegistrationMsg: builderRegistrationMessage
   };
 };
+var builderBlsCheck = (validator, feeRecipientAddress, forkVersion, precomputedBuilderDomain) => {
+  var _a6;
+  const { isValidBuilderRegistration, builderRegistrationMsg } = verifyBuilderRegistration(
+    validator,
+    feeRecipientAddress,
+    forkVersion,
+    precomputedBuilderDomain
+  );
+  const sig = (_a6 = validator.builder_registration) == null ? void 0 : _a6.signature;
+  if (!isValidBuilderRegistration || !sig) return null;
+  return {
+    pubkey: fromHexString6(validator.distributed_public_key),
+    message: builderRegistrationMsg,
+    signature: fromHexString6(sig)
+  };
+};
 var verifyNodeSignatures = (clusterLock) => {
   const ec2 = new elliptic.ec("secp256k1");
   const nodeSignatures = clusterLock.node_signatures;
@@ -20945,8 +21117,9 @@ var EOA = class {
 // src/services.ts
 var validateClusterLock = (lock, safeRpcUrl) => __async(null, null, function* () {
   try {
-    const isLockValid = yield isValidClusterLock(lock, safeRpcUrl);
-    return isLockValid;
+    const inWorker = yield validateClusterLockInWorker(lock, safeRpcUrl);
+    if (inWorker !== null) return inWorker;
+    return yield isValidClusterLock(lock, safeRpcUrl);
   } catch (err) {
     throw err;
   }
@@ -21545,6 +21718,7 @@ export {
   CONFIG_VERSION,
   CONFLICT_ERROR_MSG,
   Client,
+  ClusterLockValidationTimeoutError,
   ConflictError,
   CreatorConfigHashSigningTypes,
   CreatorTypedMessage,
@@ -21585,8 +21759,12 @@ export {
   TermsAndConditionsSigningTypes,
   UnsupportedChainError,
   blsVerify,
+  builderBlsCheck,
+  builderDomainForFork,
   clusterConfigOrDefinitionHash,
   clusterLockHash,
+  depositBlsCheck,
+  depositDomainForFork,
   hasUniqueDistributedKeys,
   isChainSupportedForSplitters,
   isValidClusterLock,
@@ -21596,6 +21774,7 @@ export {
   signingRoot,
   validateAddressSignature,
   validateClusterLock,
+  validateDepositDataStructure,
   validateEOASignature,
   validateSmartContractSignature,
   verifyBuilderRegistration,