@obolnetwork/obol-sdk 2.12.0 → 2.12.1

package/dist/cjs/src/index.js

@@ -114,6 +114,7 @@ __export(index_exports, {
   CONFIG_VERSION: () => CONFIG_VERSION,
   CONFLICT_ERROR_MSG: () => CONFLICT_ERROR_MSG,
   Client: () => Client,
+  ClusterLockValidationTimeoutError: () => ClusterLockValidationTimeoutError,
   ConflictError: () => ConflictError,
   CreatorConfigHashSigningTypes: () => CreatorConfigHashSigningTypes,
   CreatorTypedMessage: () => CreatorTypedMessage,
@@ -154,8 +155,12 @@ __export(index_exports, {
   TermsAndConditionsSigningTypes: () => TermsAndConditionsSigningTypes,
   UnsupportedChainError: () => UnsupportedChainError,
   blsVerify: () => blsVerify,
+  builderBlsCheck: () => builderBlsCheck,
+  builderDomainForFork: () => builderDomainForFork,
   clusterConfigOrDefinitionHash: () => clusterConfigOrDefinitionHash,
   clusterLockHash: () => clusterLockHash,
+  depositBlsCheck: () => depositBlsCheck,
+  depositDomainForFork: () => depositDomainForFork,
   hasUniqueDistributedKeys: () => hasUniqueDistributedKeys,
   isChainSupportedForSplitters: () => isChainSupportedForSplitters,
   isValidClusterLock: () => isValidClusterLock,
@@ -165,6 +170,7 @@ __export(index_exports, {
   signingRoot: () => signingRoot,
   validateAddressSignature: () => validateAddressSignature,
   validateClusterLock: () => validateClusterLock,
+  validateDepositDataStructure: () => validateDepositDataStructure,
   validateEOASignature: () => validateEOASignature,
   validateSmartContractSignature: () => validateSmartContractSignature,
   verifyBuilderRegistration: () => verifyBuilderRegistration,
@@ -177,7 +183,7 @@ var import_uuid = require("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"
@@ -661,6 +667,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
 var import_ssz7 = require("@chainsafe/ssz");
@@ -780,6 +799,9 @@ var signingRootType = new import_ssz.ContainerType({
 // src/verification/v1.6.0.ts
 var import_ssz3 = require("@chainsafe/ssz");
 
+// src/verification/parallelPool.ts
+var import_ssz2 = require("@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;
@@ -4934,6 +4956,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(
@@ -4945,6 +4973,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;
@@ -5010,16 +5045,23 @@ function blsVerifyExtraShares(pubshares, threshold, distributedPubkey) {
 }
 
 // src/verification/parallelPool.ts
-var import_ssz2 = require("@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 {
@@ -5038,18 +5080,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);
@@ -5078,6 +5149,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) => {
@@ -5108,8 +5206,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)),
@@ -5117,6 +5215,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;
@@ -5130,19 +5240,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) {
@@ -5165,19 +5282,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);
+      });
+    });
   });
 }
 
@@ -5282,7 +5464,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;
@@ -5301,9 +5482,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;
@@ -5321,33 +5500,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((0, import_ssz3.fromHexString)(validator.distributed_public_key));
-    builderRegistrationAndDepositDataMessages.push(depositDataMsg);
-    blsSignatures.push(
-      (0, import_ssz3.fromHexString)((_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,
     (0, import_ssz3.fromHexString)(clusterLock.lock_hash),
     (0, import_ssz3.fromHexString)(clusterLock.signature_aggregate)
-  )) {
+  ))) {
     return false;
   }
   return true;
@@ -5473,7 +5642,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;
@@ -5492,9 +5660,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;
@@ -5512,49 +5678,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((0, import_ssz4.fromHexString)(distributedPublicKey));
-    builderRegistrationAndDepositDataMessages.push(depositDataMsg);
-    blsSignatures.push(
-      (0, import_ssz4.fromHexString)((_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((0, import_ssz4.fromHexString)(distributedPublicKey));
-    builderRegistrationAndDepositDataMessages.push(builderRegistrationMsg);
-    blsSignatures.push(
-      (0, import_ssz4.fromHexString)((_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,
     (0, import_ssz4.fromHexString)(clusterLock.lock_hash),
     (0, import_ssz4.fromHexString)(clusterLock.signature_aggregate)
-  )) {
+  ))) {
     return false;
   }
   return true;
@@ -14107,7 +14257,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;
@@ -14126,9 +14275,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;
@@ -14155,51 +14305,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((0, import_ssz5.fromHexString)(distributedPublicKey));
-      builderRegistrationAndDepositDataMessages.push(depositDataMsg);
-      blsSignatures.push((0, import_ssz5.fromHexString)(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((0, import_ssz5.fromHexString)(distributedPublicKey));
-    builderRegistrationAndDepositDataMessages.push(builderRegistrationMsg);
-    blsSignatures.push(
-      (0, import_ssz5.fromHexString)((_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,
     (0, import_ssz5.fromHexString)(clusterLock.lock_hash),
     (0, import_ssz5.fromHexString)(clusterLock.signature_aggregate)
-  )) {
+  ))) {
     return false;
   }
   return true;
@@ -14601,37 +14738,62 @@ var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = (0, im
   domain.set(forkDataRoot.subarray(0, 28), 4);
   return domain;
 };
-var verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding) => {
-  const depositDomain = computeDomain(
-    (0, import_ssz7.fromHexString)(DOMAIN_DEPOSIT),
-    forkVersion
-  );
+var depositDomainForFork = (forkVersion) => computeDomain((0, import_ssz7.fromHexString)(DOMAIN_DEPOSIT), forkVersion);
+var builderDomainForFork = (forkVersion) => computeDomain((0, import_ssz7.fromHexString)(DOMAIN_APPLICATION_BUILDER), forkVersion);
+var validateDepositDataStructure = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding, precomputedDepositDomain) => {
+  const depositDomain = precomputedDepositDomain != null ? precomputedDepositDomain : computeDomain((0, import_ssz7.fromHexString)(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: (0, import_ssz7.fromHexString)(depositData.pubkey),
+    message: message2,
+    signature: (0, import_ssz7.fromHexString)(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(
     (0, import_ssz7.fromHexString)(depositData.pubkey),
-    depositDataRoot,
+    message2,
     (0, import_ssz7.fromHexString)(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(
-    (0, import_ssz7.fromHexString)(DOMAIN_APPLICATION_BUILDER),
-    forkVersion
-  );
+  const builderDomain = precomputedBuilderDomain != null ? precomputedBuilderDomain : computeDomain((0, import_ssz7.fromHexString)(DOMAIN_APPLICATION_BUILDER), forkVersion);
   if (validator.distributed_public_key !== ((_a6 = validator.builder_registration) == null ? void 0 : _a6.message.pubkey)) {
     return {
       isValidBuilderRegistration: false,
@@ -14656,6 +14818,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: (0, import_ssz7.fromHexString)(validator.distributed_public_key),
+    message: builderRegistrationMsg,
+    signature: (0, import_ssz7.fromHexString)(sig)
+  };
+};
 var verifyNodeSignatures = (clusterLock) => {
   const ec2 = new import_elliptic.default.ec("secp256k1");
   const nodeSignatures = clusterLock.node_signatures;
@@ -19663,8 +19841,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;
   }
@@ -20264,6 +20443,7 @@ var Client = class extends Base {
   CONFIG_VERSION,
   CONFLICT_ERROR_MSG,
   Client,
+  ClusterLockValidationTimeoutError,
   ConflictError,
   CreatorConfigHashSigningTypes,
   CreatorTypedMessage,
@@ -20304,8 +20484,12 @@ var Client = class extends Base {
   TermsAndConditionsSigningTypes,
   UnsupportedChainError,
   blsVerify,
+  builderBlsCheck,
+  builderDomainForFork,
   clusterConfigOrDefinitionHash,
   clusterLockHash,
+  depositBlsCheck,
+  depositDomainForFork,
   hasUniqueDistributedKeys,
   isChainSupportedForSplitters,
   isValidClusterLock,
@@ -20315,6 +20499,7 @@ var Client = class extends Base {
   signingRoot,
   validateAddressSignature,
   validateClusterLock,
+  validateDepositDataStructure,
   validateEOASignature,
   validateSmartContractSignature,
   verifyBuilderRegistration,