@obolnetwork/obol-sdk 2.11.13 → 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,13 @@ __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,
   signCreatorConfigHashPayload: () => signCreatorConfigHashPayload,
@@ -164,6 +170,7 @@ __export(index_exports, {
   signingRoot: () => signingRoot,
   validateAddressSignature: () => validateAddressSignature,
   validateClusterLock: () => validateClusterLock,
+  validateDepositDataStructure: () => validateDepositDataStructure,
   validateEOASignature: () => validateEOASignature,
   validateSmartContractSignature: () => validateSmartContractSignature,
   verifyBuilderRegistration: () => verifyBuilderRegistration,
@@ -176,7 +183,7 @@ var import_uuid = require("uuid");
 // package.json
 var package_default = {
   name: "@obolnetwork/obol-sdk",
-  version: "2.11.13",
+  version: "2.12.1",
   description: "A package for creating Distributed Validators using the Obol API.",
   bugs: {
     url: "https://github.com/obolnetwork/obol-sdk/issues"
@@ -660,9 +667,22 @@ 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_ssz6 = require("@chainsafe/ssz");
+var import_ssz7 = require("@chainsafe/ssz");
 var import_elliptic = __toESM(require("elliptic"));
 var semver = __toESM(require("semver"));
 
@@ -777,6 +797,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
@@ -4933,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(
@@ -4944,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;
@@ -4959,28 +4995,395 @@ function blsVerifyMultiple(pubkeys, messages, signature) {
 function blsAggregateSignatures(signatures) {
   return ls.Signature.toBytes(ls.aggregateSignatures(signatures));
 }
+function lagrangeCoeffAtZero(shareIndex, indices) {
+  const { Fr } = bls12_381.fields;
+  let num = BigInt(1);
+  let den = BigInt(1);
+  for (const j of indices) {
+    if (j === shareIndex) continue;
+    num = Fr.mul(num, Fr.neg(j));
+    den = Fr.mul(den, Fr.sub(shareIndex, j));
+  }
+  return Fr.mul(num, Fr.inv(den));
+}
+function blsRecoverWithIndices(shares, indices) {
+  try {
+    let recovered = bls12_381.G1.Point.ZERO;
+    for (let i = 0; i < shares.length; i++) {
+      const point = bls12_381.G1.Point.fromBytes(shares[i]);
+      const coeff = lagrangeCoeffAtZero(indices[i], indices);
+      recovered = recovered.add(point.multiply(coeff));
+    }
+    return recovered.toBytes();
+  } catch (e) {
+    return null;
+  }
+}
+function blsRecoverDistributedPubkeyFromShares(pubshares, threshold) {
+  if (threshold <= 0 || pubshares.length < threshold) return null;
+  const selected = pubshares.slice(0, threshold);
+  const indices = selected.map((_, i) => BigInt(i + 1));
+  return blsRecoverWithIndices(selected, indices);
+}
+function blsVerifyExtraShares(pubshares, threshold, distributedPubkey) {
+  if (threshold <= 0 || pubshares.length < threshold) return false;
+  try {
+    const baseShares = pubshares.slice(0, threshold - 1);
+    const baseIndices = baseShares.map((_, i) => BigInt(i + 1));
+    for (let i = threshold; i < pubshares.length; i++) {
+      const shares = [...baseShares, pubshares[i]];
+      const indices = [...baseIndices, BigInt(i + 1)];
+      const recovered = blsRecoverWithIndices(shares, indices);
+      if (!recovered || recovered.length !== distributedPubkey.length || !recovered.every((b, j) => b === distributedPubkey[j])) {
+        return false;
+      }
+    }
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/verification/parallelPool.ts
+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 workerPathByFile = /* @__PURE__ */ new Map();
+function loadWorkerThreads() {
+  if (workerThreadsCache !== void 0) return workerThreadsCache;
+  try {
+    workerThreadsCache = require("worker_threads");
+  } catch (e) {
+    workerThreadsCache = null;
+  }
+  return workerThreadsCache;
+}
+function loadOs() {
+  if (osCache !== void 0) return osCache;
+  try {
+    osCache = require("os");
+  } catch (e) {
+    osCache = null;
+  }
+  return osCache;
+}
+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 fs = require("fs");
+  const candidates = [
+    path.join(__dirname, filename),
+    path.join(__dirname, "verification", filename)
+  ];
+  try {
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) {
+        workerPathByFile.set(filename, candidate);
+        return candidate;
+      }
+    }
+  } catch (e) {
+  }
+  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);
+  const out = [];
+  for (let i = 0; i < arr.length; i += size) {
+    out.push(arr.slice(i, i + size));
+  }
+  return out;
+}
+function verifySharesSync(shares, distributedKeys, threshold) {
+  for (let i = 0; i < shares.length; i++) {
+    const sharesBytes = shares[i].map((s) => (0, import_ssz2.fromHexString)(s));
+    const dkBytes = (0, import_ssz2.fromHexString)(distributedKeys[i]);
+    const recovered = blsRecoverDistributedPubkeyFromShares(
+      sharesBytes,
+      threshold
+    );
+    if (!recovered) return false;
+    if (recovered.length !== dkBytes.length) return false;
+    for (let j = 0; j < recovered.length; j++) {
+      if (recovered[j] !== dkBytes[j]) return false;
+    }
+    if (!blsVerifyExtraShares(sharesBytes, threshold, dkBytes)) {
+      return false;
+    }
+  }
+  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) => {
+      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(false);
+      }, WORKER_TIMEOUT_MS);
+      worker.once("message", (msg) => {
+        finish(msg === true);
+      });
+      worker.once("error", () => {
+        finish(false);
+      });
+      worker.once("exit", (code2) => {
+        if (code2 !== 0) finish(false);
+      });
+    });
+  });
+}
+function poolSize(itemCount, minPerWorker) {
+  const wt = loadWorkerThreads();
+  const os = loadOs();
+  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)),
+    numCpus
+  );
+  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;
+    if (shares.length === 0) return true;
+    const { numWorkers, wt, workerFile } = poolSize(
+      shares.length,
+      MIN_VALIDATORS_PER_WORKER
+    );
+    if (wt === null || workerFile === null || shares.length < MIN_PARALLEL_VALIDATORS || numWorkers < 2) {
+      return verifySharesSync(shares, distributedKeys, threshold);
+    }
+    const shareChunks = chunkArrays(shares, numWorkers);
+    const keyChunks = chunkArrays(distributedKeys, numWorkers);
+    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)
+    );
+  });
+}
+function verifyBatchParallel(pubkeys, messages, signatures) {
+  return __async(this, null, function* () {
+    if (pubkeys.length !== messages.length || pubkeys.length !== signatures.length) {
+      return false;
+    }
+    if (pubkeys.length === 0) return true;
+    const { numWorkers, wt, workerFile } = poolSize(
+      pubkeys.length,
+      MIN_PAIRS_PER_WORKER
+    );
+    if (wt === null || workerFile === null || pubkeys.length < MIN_PARALLEL_BATCH_PAIRS || numWorkers < 2) {
+      return blsVerifyMultiple(
+        pubkeys,
+        messages,
+        blsAggregateSignatures(signatures)
+      );
+    }
+    const pkChunks = chunkArrays(pubkeys, numWorkers);
+    const msgChunks = chunkArrays(messages, numWorkers);
+    const sigChunks = chunkArrays(signatures, numWorkers);
+    return yield runWorkerChunks(
+      wt,
+      workerFile,
+      pkChunks.map((pks, i) => ({
+        mode: "verifyBatch",
+        pubkeys: pks,
+        messages: msgChunks[i],
+        signatures: sigChunks[i]
+      }))
+    );
+  });
+}
+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);
+      });
+    });
+  });
+}
 
 // src/verification/v1.6.0.ts
 var clusterDefinitionContainerTypeV1X6 = (configOnly) => {
   let returnedContainerType = {
-    uuid: new import_ssz2.ByteListType(64),
-    name: new import_ssz2.ByteListType(256),
-    version: new import_ssz2.ByteListType(16),
-    timestamp: new import_ssz2.ByteListType(32),
+    uuid: new import_ssz3.ByteListType(64),
+    name: new import_ssz3.ByteListType(256),
+    version: new import_ssz3.ByteListType(16),
+    timestamp: new import_ssz3.ByteListType(32),
     num_validators: new import_uint.UintNumberType(8),
     threshold: new import_uint.UintNumberType(8),
-    dkg_algorithm: new import_ssz2.ByteListType(32),
-    fork_version: new import_ssz2.ByteVectorType(4),
-    operators: new import_ssz2.ListCompositeType(newOperatorContainerType(configOnly), 256),
+    dkg_algorithm: new import_ssz3.ByteListType(32),
+    fork_version: new import_ssz3.ByteVectorType(4),
+    operators: new import_ssz3.ListCompositeType(newOperatorContainerType(configOnly), 256),
     creator: newCreatorContainerType(configOnly),
-    validators: new import_ssz2.ListCompositeType(validatorsContainerType, 65536)
+    validators: new import_ssz3.ListCompositeType(validatorsContainerType, 65536)
   };
   if (!configOnly) {
     returnedContainerType = __spreadProps(__spreadValues({}, returnedContainerType), {
-      config_hash: new import_ssz2.ByteVectorType(32)
+      config_hash: new import_ssz3.ByteVectorType(32)
     });
   }
-  return new import_ssz2.ContainerType(returnedContainerType);
+  return new import_ssz3.ContainerType(returnedContainerType);
 };
 var hashClusterDefinitionV1X6 = (cluster, configOnly) => {
   const definitionType = clusterDefinitionContainerTypeV1X6(configOnly);
@@ -4992,44 +5395,44 @@ var hashClusterDefinitionV1X6 = (cluster, configOnly) => {
   val.num_validators = cluster.num_validators;
   val.threshold = cluster.threshold;
   val.dkg_algorithm = strToUint8Array(cluster.dkg_algorithm);
-  val.fork_version = (0, import_ssz2.fromHexString)(cluster.fork_version);
+  val.fork_version = (0, import_ssz3.fromHexString)(cluster.fork_version);
   val.operators = cluster.operators.map((operator) => {
-    return configOnly ? { address: (0, import_ssz2.fromHexString)(operator.address) } : {
-      address: (0, import_ssz2.fromHexString)(operator.address),
+    return configOnly ? { address: (0, import_ssz3.fromHexString)(operator.address) } : {
+      address: (0, import_ssz3.fromHexString)(operator.address),
       enr: strToUint8Array(operator.enr),
-      config_signature: (0, import_ssz2.fromHexString)(operator.config_signature),
-      enr_signature: (0, import_ssz2.fromHexString)(operator.enr_signature)
+      config_signature: (0, import_ssz3.fromHexString)(operator.config_signature),
+      enr_signature: (0, import_ssz3.fromHexString)(operator.enr_signature)
     };
   });
-  val.creator = configOnly ? { address: (0, import_ssz2.fromHexString)(cluster.creator.address) } : {
-    address: (0, import_ssz2.fromHexString)(cluster.creator.address),
-    config_signature: (0, import_ssz2.fromHexString)(
+  val.creator = configOnly ? { address: (0, import_ssz3.fromHexString)(cluster.creator.address) } : {
+    address: (0, import_ssz3.fromHexString)(cluster.creator.address),
+    config_signature: (0, import_ssz3.fromHexString)(
       cluster.creator.config_signature
     )
   };
   val.validators = cluster.validators.map((validator) => {
     return {
-      fee_recipient_address: (0, import_ssz2.fromHexString)(validator.fee_recipient_address),
-      withdrawal_address: (0, import_ssz2.fromHexString)(validator.withdrawal_address)
+      fee_recipient_address: (0, import_ssz3.fromHexString)(validator.fee_recipient_address),
+      withdrawal_address: (0, import_ssz3.fromHexString)(validator.withdrawal_address)
     };
   });
   if (!configOnly) {
-    val.config_hash = (0, import_ssz2.fromHexString)(cluster.config_hash);
+    val.config_hash = (0, import_ssz3.fromHexString)(cluster.config_hash);
   }
   return val;
 };
-var dvContainerTypeV1X6 = new import_ssz2.ContainerType({
-  distributed_public_key: new import_ssz2.ByteVectorType(48),
-  public_shares: new import_ssz2.ListCompositeType(new import_ssz2.ByteVectorType(48), 256),
-  pubkey: new import_ssz2.ByteVectorType(48),
-  withdrawal_credentials: new import_ssz2.ByteVectorType(32),
+var dvContainerTypeV1X6 = new import_ssz3.ContainerType({
+  distributed_public_key: new import_ssz3.ByteVectorType(48),
+  public_shares: new import_ssz3.ListCompositeType(new import_ssz3.ByteVectorType(48), 256),
+  pubkey: new import_ssz3.ByteVectorType(48),
+  withdrawal_credentials: new import_ssz3.ByteVectorType(32),
   amount: new import_uint.UintNumberType(8),
-  signature: new import_ssz2.ByteVectorType(96)
+  signature: new import_ssz3.ByteVectorType(96)
 });
 var clusterLockContainerTypeV1X6 = () => {
-  return new import_ssz2.ContainerType({
+  return new import_ssz3.ContainerType({
     cluster_definition: clusterDefinitionContainerTypeV1X6(false),
-    distributed_validators: new import_ssz2.ListCompositeType(dvContainerTypeV1X6, 65536)
+    distributed_validators: new import_ssz3.ListCompositeType(dvContainerTypeV1X6, 65536)
   });
 };
 var hashClusterLockV1X6 = (cluster) => {
@@ -5043,65 +5446,77 @@ var hashClusterLockV1X6 = (cluster) => {
     (dValidator) => {
       var _a6, _b2, _c, _d;
       return {
-        distributed_public_key: (0, import_ssz2.fromHexString)(
+        distributed_public_key: (0, import_ssz3.fromHexString)(
           dValidator.distributed_public_key
         ),
         public_shares: dValidator.public_shares.map(
-          (publicShare) => (0, import_ssz2.fromHexString)(publicShare)
+          (publicShare) => (0, import_ssz3.fromHexString)(publicShare)
         ),
-        pubkey: (0, import_ssz2.fromHexString)((_a6 = dValidator.deposit_data) == null ? void 0 : _a6.pubkey),
-        withdrawal_credentials: (0, import_ssz2.fromHexString)(
+        pubkey: (0, import_ssz3.fromHexString)((_a6 = dValidator.deposit_data) == null ? void 0 : _a6.pubkey),
+        withdrawal_credentials: (0, import_ssz3.fromHexString)(
           (_b2 = dValidator.deposit_data) == null ? void 0 : _b2.withdrawal_credentials
         ),
         amount: parseInt((_c = dValidator.deposit_data) == null ? void 0 : _c.amount),
-        signature: (0, import_ssz2.fromHexString)((_d = dValidator.deposit_data) == null ? void 0 : _d.signature)
+        signature: (0, import_ssz3.fromHexString)((_d = dValidator.deposit_data) == null ? void 0 : _d.signature)
       };
     }
   );
   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;
+  for (const validator of validators) {
+    if (validator.public_shares.length !== operatorCount) {
+      return false;
+    }
+    const uniqueShareCount = new Set(validator.public_shares).size;
+    if (uniqueShareCount !== validator.public_shares.length) {
+      return false;
+    }
+  }
+  const allShares = validators.map((v) => v.public_shares);
+  const allDKs = validators.map((v) => v.distributed_public_key);
+  if (!(yield verifySharesBinding(allShares, allDKs, threshold))) {
+    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;
     const distributedPublicKey = validator.distributed_public_key;
-    for (const element of validatorPublicShares) {
-      pubShares.push((0, import_ssz2.fromHexString)(element));
+    if (validatorPublicShares.length !== operatorCount) {
+      return false;
     }
-    const { isValidDepositData, depositDataMsg } = verifyDepositData(
+    const normalizedShares = validatorPublicShares.map((s) => s.toLowerCase());
+    if (new Set(normalizedShares).size !== normalizedShares.length) {
+      return false;
+    }
+    const validatorPublicSharesBytes = validatorPublicShares.map(
+      (share) => (0, import_ssz3.fromHexString)(share)
+    );
+    for (const share of validatorPublicSharesBytes) {
+      pubShares.push(share);
+    }
+    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_ssz2.fromHexString)(validator.distributed_public_key));
-    builderRegistrationAndDepositDataMessages.push(depositDataMsg);
-    blsSignatures.push(
-      (0, import_ssz2.fromHexString)((_a6 = validator.deposit_data) == null ? void 0 : _a6.signature)
-    );
+    if (!depositCheck) return false;
+    blsChecks.push(depositCheck);
   }
-  const aggregateBLSSignature = blsAggregateSignatures(blsSignatures);
-  if (!blsVerifyMultiple(
-    pubKeys,
-    builderRegistrationAndDepositDataMessages,
-    aggregateBLSSignature
-  )) {
+  if (!(yield verifyBlsChecksParallel(blsChecks))) {
     return false;
   }
-  if (!blsVerifyAggregate(
+  if (!(yield verifyAggregateParallel(
     pubShares,
-    (0, import_ssz2.fromHexString)(clusterLock.lock_hash),
-    (0, import_ssz2.fromHexString)(clusterLock.signature_aggregate)
-  )) {
+    (0, import_ssz3.fromHexString)(clusterLock.lock_hash),
+    (0, import_ssz3.fromHexString)(clusterLock.signature_aggregate)
+  ))) {
     return false;
   }
   return true;
@@ -5109,27 +5524,27 @@ var verifyDVV1X6 = (clusterLock) => __async(null, null, function* () {
 
 // src/verification/v1.7.0.ts
 var import_uint2 = require("@chainsafe/ssz/lib/type/uint.js");
-var import_ssz3 = require("@chainsafe/ssz");
+var import_ssz4 = require("@chainsafe/ssz");
 var clusterDefinitionContainerTypeV1X7 = (configOnly) => {
   let returnedContainerType = {
-    uuid: new import_ssz3.ByteListType(64),
-    name: new import_ssz3.ByteListType(256),
-    version: new import_ssz3.ByteListType(16),
-    timestamp: new import_ssz3.ByteListType(32),
+    uuid: new import_ssz4.ByteListType(64),
+    name: new import_ssz4.ByteListType(256),
+    version: new import_ssz4.ByteListType(16),
+    timestamp: new import_ssz4.ByteListType(32),
     num_validators: new import_uint2.UintNumberType(8),
     threshold: new import_uint2.UintNumberType(8),
-    dkg_algorithm: new import_ssz3.ByteListType(32),
-    fork_version: new import_ssz3.ByteVectorType(4),
-    operators: new import_ssz3.ListCompositeType(newOperatorContainerType(configOnly), 256),
+    dkg_algorithm: new import_ssz4.ByteListType(32),
+    fork_version: new import_ssz4.ByteVectorType(4),
+    operators: new import_ssz4.ListCompositeType(newOperatorContainerType(configOnly), 256),
     creator: newCreatorContainerType(configOnly),
-    validators: new import_ssz3.ListCompositeType(validatorsContainerType, 65536)
+    validators: new import_ssz4.ListCompositeType(validatorsContainerType, 65536)
   };
   if (!configOnly) {
     returnedContainerType = __spreadProps(__spreadValues({}, returnedContainerType), {
-      config_hash: new import_ssz3.ByteVectorType(32)
+      config_hash: new import_ssz4.ByteVectorType(32)
     });
   }
-  return new import_ssz3.ContainerType(returnedContainerType);
+  return new import_ssz4.ContainerType(returnedContainerType);
 };
 var hashClusterDefinitionV1X7 = (cluster, configOnly) => {
   const definitionType = clusterDefinitionContainerTypeV1X7(configOnly);
@@ -5141,42 +5556,42 @@ var hashClusterDefinitionV1X7 = (cluster, configOnly) => {
   val.num_validators = cluster.num_validators;
   val.threshold = cluster.threshold;
   val.dkg_algorithm = strToUint8Array(cluster.dkg_algorithm);
-  val.fork_version = (0, import_ssz3.fromHexString)(cluster.fork_version);
+  val.fork_version = (0, import_ssz4.fromHexString)(cluster.fork_version);
   val.operators = cluster.operators.map((operator) => {
-    return configOnly ? { address: (0, import_ssz3.fromHexString)(operator.address) } : {
-      address: (0, import_ssz3.fromHexString)(operator.address),
+    return configOnly ? { address: (0, import_ssz4.fromHexString)(operator.address) } : {
+      address: (0, import_ssz4.fromHexString)(operator.address),
       enr: strToUint8Array(operator.enr),
-      config_signature: (0, import_ssz3.fromHexString)(operator.config_signature),
-      enr_signature: (0, import_ssz3.fromHexString)(operator.enr_signature)
+      config_signature: (0, import_ssz4.fromHexString)(operator.config_signature),
+      enr_signature: (0, import_ssz4.fromHexString)(operator.enr_signature)
     };
   });
-  val.creator = configOnly ? { address: (0, import_ssz3.fromHexString)(cluster.creator.address) } : {
-    address: (0, import_ssz3.fromHexString)(cluster.creator.address),
-    config_signature: (0, import_ssz3.fromHexString)(
+  val.creator = configOnly ? { address: (0, import_ssz4.fromHexString)(cluster.creator.address) } : {
+    address: (0, import_ssz4.fromHexString)(cluster.creator.address),
+    config_signature: (0, import_ssz4.fromHexString)(
       cluster.creator.config_signature
     )
   };
   val.validators = cluster.validators.map((validator) => {
     return {
-      fee_recipient_address: (0, import_ssz3.fromHexString)(validator.fee_recipient_address),
-      withdrawal_address: (0, import_ssz3.fromHexString)(validator.withdrawal_address)
+      fee_recipient_address: (0, import_ssz4.fromHexString)(validator.fee_recipient_address),
+      withdrawal_address: (0, import_ssz4.fromHexString)(validator.withdrawal_address)
     };
   });
   if (!configOnly) {
-    val.config_hash = (0, import_ssz3.fromHexString)(cluster.config_hash);
+    val.config_hash = (0, import_ssz4.fromHexString)(cluster.config_hash);
   }
   return val;
 };
-var dvContainerTypeV1X7 = new import_ssz3.ContainerType({
-  distributed_public_key: new import_ssz3.ByteVectorType(48),
-  public_shares: new import_ssz3.ListCompositeType(new import_ssz3.ByteVectorType(48), 256),
+var dvContainerTypeV1X7 = new import_ssz4.ContainerType({
+  distributed_public_key: new import_ssz4.ByteVectorType(48),
+  public_shares: new import_ssz4.ListCompositeType(new import_ssz4.ByteVectorType(48), 256),
   deposit_data: depositDataContainer,
   builder_registration: builderRegistrationContainer
 });
 var clusterLockContainerTypeV1X7 = () => {
-  return new import_ssz3.ContainerType({
+  return new import_ssz4.ContainerType({
     cluster_definition: clusterDefinitionContainerTypeV1X7(false),
-    distributed_validators: new import_ssz3.ListCompositeType(dvContainerTypeV1X7, 65536)
+    distributed_validators: new import_ssz4.ListCompositeType(dvContainerTypeV1X7, 65536)
   });
 };
 var hashClusterLockV1X7 = (cluster) => {
@@ -5190,34 +5605,34 @@ var hashClusterLockV1X7 = (cluster) => {
     (dValidator) => {
       var _a6, _b2, _c, _d, _e, _f, _g, _h, _i;
       return {
-        distributed_public_key: (0, import_ssz3.fromHexString)(
+        distributed_public_key: (0, import_ssz4.fromHexString)(
           dValidator.distributed_public_key
         ),
         public_shares: dValidator.public_shares.map(
-          (publicShare) => (0, import_ssz3.fromHexString)(publicShare)
+          (publicShare) => (0, import_ssz4.fromHexString)(publicShare)
         ),
         deposit_data: {
-          pubkey: (0, import_ssz3.fromHexString)((_a6 = dValidator.deposit_data) == null ? void 0 : _a6.pubkey),
-          withdrawal_credentials: (0, import_ssz3.fromHexString)(
+          pubkey: (0, import_ssz4.fromHexString)((_a6 = dValidator.deposit_data) == null ? void 0 : _a6.pubkey),
+          withdrawal_credentials: (0, import_ssz4.fromHexString)(
             (_b2 = dValidator.deposit_data) == null ? void 0 : _b2.withdrawal_credentials
           ),
           amount: parseInt((_c = dValidator.deposit_data) == null ? void 0 : _c.amount),
-          signature: (0, import_ssz3.fromHexString)(
+          signature: (0, import_ssz4.fromHexString)(
             (_d = dValidator.deposit_data) == null ? void 0 : _d.signature
           )
         },
         builder_registration: {
           message: {
-            fee_recipient: (0, import_ssz3.fromHexString)(
+            fee_recipient: (0, import_ssz4.fromHexString)(
               (_e = dValidator.builder_registration) == null ? void 0 : _e.message.fee_recipient
             ),
             gas_limit: (_f = dValidator.builder_registration) == null ? void 0 : _f.message.gas_limit,
             timestamp: (_g = dValidator.builder_registration) == null ? void 0 : _g.message.timestamp,
-            pubkey: (0, import_ssz3.fromHexString)(
+            pubkey: (0, import_ssz4.fromHexString)(
               (_h = dValidator.builder_registration) == null ? void 0 : _h.message.pubkey
             )
           },
-          signature: (0, import_ssz3.fromHexString)(
+          signature: (0, import_ssz4.fromHexString)(
             (_i = dValidator.builder_registration) == null ? void 0 : _i.signature
           )
         }
@@ -5227,63 +5642,69 @@ 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;
+  for (const validator of validators) {
+    if (validator.public_shares.length !== operatorCount) {
+      return false;
+    }
+    const uniqueShareCount = new Set(validator.public_shares).size;
+    if (uniqueShareCount !== validator.public_shares.length) {
+      return false;
+    }
+  }
+  const allShares = validators.map((v) => v.public_shares);
+  const allDKs = validators.map((v) => v.distributed_public_key);
+  if (!(yield verifySharesBinding(allShares, allDKs, threshold))) {
+    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;
     const distributedPublicKey = validator.distributed_public_key;
-    for (const element of validatorPublicShares) {
-      pubShares.push((0, import_ssz3.fromHexString)(element));
+    if (validatorPublicShares.length !== operatorCount) {
+      return false;
     }
-    const { isValidDepositData, depositDataMsg } = verifyDepositData(
+    const normalizedShares = validatorPublicShares.map((s) => s.toLowerCase());
+    if (new Set(normalizedShares).size !== normalizedShares.length) {
+      return false;
+    }
+    const validatorPublicSharesBytes = validatorPublicShares.map(
+      (share) => (0, import_ssz4.fromHexString)(share)
+    );
+    for (const share of validatorPublicSharesBytes) {
+      pubShares.push(share);
+    }
+    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)(distributedPublicKey));
-    builderRegistrationAndDepositDataMessages.push(depositDataMsg);
-    blsSignatures.push(
-      (0, import_ssz3.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_ssz3.fromHexString)(distributedPublicKey));
-    builderRegistrationAndDepositDataMessages.push(builderRegistrationMsg);
-    blsSignatures.push(
-      (0, import_ssz3.fromHexString)((_b2 = validator.builder_registration) == null ? void 0 : _b2.signature)
-    );
+    if (!builderCheck) return false;
+    blsChecks.push(builderCheck);
   }
-  const aggregateBLSSignature = blsAggregateSignatures(blsSignatures);
-  if (!blsVerifyMultiple(
-    pubKeys,
-    builderRegistrationAndDepositDataMessages,
-    aggregateBLSSignature
-  )) {
+  if (!(yield verifyBlsChecksParallel(blsChecks))) {
     return false;
   }
   if (!verifyNodeSignatures(clusterLock)) {
     return false;
   }
-  if (!blsVerifyAggregate(
+  if (!(yield verifyAggregateParallel(
     pubShares,
-    (0, import_ssz3.fromHexString)(clusterLock.lock_hash),
-    (0, import_ssz3.fromHexString)(clusterLock.signature_aggregate)
-  )) {
+    (0, import_ssz4.fromHexString)(clusterLock.lock_hash),
+    (0, import_ssz4.fromHexString)(clusterLock.signature_aggregate)
+  ))) {
     return false;
   }
   return true;
@@ -13708,31 +14129,31 @@ var ENR = class _ENR extends BaseENR {
 
 // src/verification/v1.8.0.ts
 var import_uint3 = require("@chainsafe/ssz/lib/type/uint.js");
-var import_ssz4 = require("@chainsafe/ssz");
+var import_ssz5 = require("@chainsafe/ssz");
 var clusterDefinitionContainerTypeV1X8 = (configOnly) => {
   let returnedContainerType = {
-    uuid: new import_ssz4.ByteListType(64),
-    name: new import_ssz4.ByteListType(256),
-    version: new import_ssz4.ByteListType(16),
-    timestamp: new import_ssz4.ByteListType(32),
+    uuid: new import_ssz5.ByteListType(64),
+    name: new import_ssz5.ByteListType(256),
+    version: new import_ssz5.ByteListType(16),
+    timestamp: new import_ssz5.ByteListType(32),
     num_validators: new import_uint3.UintNumberType(8),
     threshold: new import_uint3.UintNumberType(8),
-    dkg_algorithm: new import_ssz4.ByteListType(32),
-    fork_version: new import_ssz4.ByteVectorType(4),
-    operators: new import_ssz4.ListCompositeType(newOperatorContainerType(configOnly), 256),
+    dkg_algorithm: new import_ssz5.ByteListType(32),
+    fork_version: new import_ssz5.ByteVectorType(4),
+    operators: new import_ssz5.ListCompositeType(newOperatorContainerType(configOnly), 256),
     creator: newCreatorContainerType(configOnly),
-    validators: new import_ssz4.ListCompositeType(validatorsContainerType, 65536),
-    deposit_amounts: new import_ssz4.ListBasicType(
+    validators: new import_ssz5.ListCompositeType(validatorsContainerType, 65536),
+    deposit_amounts: new import_ssz5.ListBasicType(
       new import_uint3.UintNumberType(8),
       256
     )
   };
   if (!configOnly) {
     returnedContainerType = __spreadProps(__spreadValues({}, returnedContainerType), {
-      config_hash: new import_ssz4.ByteVectorType(32)
+      config_hash: new import_ssz5.ByteVectorType(32)
     });
   }
-  return new import_ssz4.ContainerType(returnedContainerType);
+  return new import_ssz5.ContainerType(returnedContainerType);
 };
 var hashClusterDefinitionV1X8 = (cluster, configOnly) => {
   const definitionType = clusterDefinitionContainerTypeV1X8(configOnly);
@@ -13744,25 +14165,25 @@ var hashClusterDefinitionV1X8 = (cluster, configOnly) => {
   val.num_validators = cluster.num_validators;
   val.threshold = cluster.threshold;
   val.dkg_algorithm = strToUint8Array(cluster.dkg_algorithm);
-  val.fork_version = (0, import_ssz4.fromHexString)(cluster.fork_version);
+  val.fork_version = (0, import_ssz5.fromHexString)(cluster.fork_version);
   val.operators = cluster.operators.map((operator) => {
-    return configOnly ? { address: (0, import_ssz4.fromHexString)(operator.address) } : {
-      address: (0, import_ssz4.fromHexString)(operator.address),
+    return configOnly ? { address: (0, import_ssz5.fromHexString)(operator.address) } : {
+      address: (0, import_ssz5.fromHexString)(operator.address),
       enr: strToUint8Array(operator.enr),
-      config_signature: (0, import_ssz4.fromHexString)(operator.config_signature),
-      enr_signature: (0, import_ssz4.fromHexString)(operator.enr_signature)
+      config_signature: (0, import_ssz5.fromHexString)(operator.config_signature),
+      enr_signature: (0, import_ssz5.fromHexString)(operator.enr_signature)
     };
   });
-  val.creator = configOnly ? { address: (0, import_ssz4.fromHexString)(cluster.creator.address) } : {
-    address: (0, import_ssz4.fromHexString)(cluster.creator.address),
-    config_signature: (0, import_ssz4.fromHexString)(
+  val.creator = configOnly ? { address: (0, import_ssz5.fromHexString)(cluster.creator.address) } : {
+    address: (0, import_ssz5.fromHexString)(cluster.creator.address),
+    config_signature: (0, import_ssz5.fromHexString)(
       cluster.creator.config_signature
     )
   };
   val.validators = cluster.validators.map((validator) => {
     return {
-      fee_recipient_address: (0, import_ssz4.fromHexString)(validator.fee_recipient_address),
-      withdrawal_address: (0, import_ssz4.fromHexString)(validator.withdrawal_address)
+      fee_recipient_address: (0, import_ssz5.fromHexString)(validator.fee_recipient_address),
+      withdrawal_address: (0, import_ssz5.fromHexString)(validator.withdrawal_address)
     };
   });
   if (cluster.deposit_amounts) {
@@ -13771,20 +14192,20 @@ var hashClusterDefinitionV1X8 = (cluster, configOnly) => {
     });
   }
   if (!configOnly) {
-    val.config_hash = (0, import_ssz4.fromHexString)(cluster.config_hash);
+    val.config_hash = (0, import_ssz5.fromHexString)(cluster.config_hash);
   }
   return val;
 };
-var dvContainerTypeV1X8 = new import_ssz4.ContainerType({
-  distributed_public_key: new import_ssz4.ByteVectorType(48),
-  public_shares: new import_ssz4.ListCompositeType(new import_ssz4.ByteVectorType(48), 256),
-  partial_deposit_data: new import_ssz4.ListCompositeType(depositDataContainer, 256),
+var dvContainerTypeV1X8 = new import_ssz5.ContainerType({
+  distributed_public_key: new import_ssz5.ByteVectorType(48),
+  public_shares: new import_ssz5.ListCompositeType(new import_ssz5.ByteVectorType(48), 256),
+  partial_deposit_data: new import_ssz5.ListCompositeType(depositDataContainer, 256),
   builder_registration: builderRegistrationContainer
 });
 var clusterLockContainerTypeV1X8 = () => {
-  return new import_ssz4.ContainerType({
+  return new import_ssz5.ContainerType({
     cluster_definition: clusterDefinitionContainerTypeV1X8(false),
-    distributed_validators: new import_ssz4.ListCompositeType(dvContainerTypeV1X8, 65536)
+    distributed_validators: new import_ssz5.ListCompositeType(dvContainerTypeV1X8, 65536)
   });
 };
 var hashClusterLockV1X8 = (cluster) => {
@@ -13798,35 +14219,35 @@ var hashClusterLockV1X8 = (cluster) => {
     (dValidator) => {
       var _a6, _b2, _c, _d, _e;
       return {
-        distributed_public_key: (0, import_ssz4.fromHexString)(
+        distributed_public_key: (0, import_ssz5.fromHexString)(
           dValidator.distributed_public_key
         ),
         public_shares: dValidator.public_shares.map(
-          (publicShare) => (0, import_ssz4.fromHexString)(publicShare)
+          (publicShare) => (0, import_ssz5.fromHexString)(publicShare)
         ),
         // should be fixed
         partial_deposit_data: dValidator.partial_deposit_data.map((depositData) => {
           return {
-            pubkey: (0, import_ssz4.fromHexString)(depositData.pubkey),
-            withdrawal_credentials: (0, import_ssz4.fromHexString)(
+            pubkey: (0, import_ssz5.fromHexString)(depositData.pubkey),
+            withdrawal_credentials: (0, import_ssz5.fromHexString)(
               depositData.withdrawal_credentials
             ),
             amount: parseInt(depositData.amount),
-            signature: (0, import_ssz4.fromHexString)(depositData.signature)
+            signature: (0, import_ssz5.fromHexString)(depositData.signature)
           };
         }),
         builder_registration: {
           message: {
-            fee_recipient: (0, import_ssz4.fromHexString)(
+            fee_recipient: (0, import_ssz5.fromHexString)(
               (_a6 = dValidator.builder_registration) == null ? void 0 : _a6.message.fee_recipient
             ),
             gas_limit: (_b2 = dValidator.builder_registration) == null ? void 0 : _b2.message.gas_limit,
             timestamp: (_c = dValidator.builder_registration) == null ? void 0 : _c.message.timestamp,
-            pubkey: (0, import_ssz4.fromHexString)(
+            pubkey: (0, import_ssz5.fromHexString)(
               (_d = dValidator.builder_registration) == null ? void 0 : _d.message.pubkey
             )
           },
-          signature: (0, import_ssz4.fromHexString)(
+          signature: (0, import_ssz5.fromHexString)(
             (_e = dValidator.builder_registration) == null ? void 0 : _e.signature
           )
         }
@@ -13836,18 +14257,44 @@ 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;
+  for (const validator of validators) {
+    if (validator.public_shares.length !== operatorCount) {
+      return false;
+    }
+    const uniqueShareCount = new Set(validator.public_shares).size;
+    if (uniqueShareCount !== validator.public_shares.length) {
+      return false;
+    }
+  }
+  const allShares = validators.map((v) => v.public_shares);
+  const allDKs = validators.map((v) => v.distributed_public_key);
+  if (!(yield verifySharesBinding(allShares, allDKs, threshold))) {
+    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;
     const distributedPublicKey = validator.distributed_public_key;
-    for (const element of validatorPublicShares) {
-      pubShares.push((0, import_ssz4.fromHexString)(element));
+    if (validatorPublicShares.length !== operatorCount) {
+      return false;
+    }
+    const normalizedShares = validatorPublicShares.map((s) => s.toLowerCase());
+    if (new Set(normalizedShares).size !== normalizedShares.length) {
+      return false;
+    }
+    const validatorPublicSharesBytes = validatorPublicShares.map(
+      (share) => (0, import_ssz5.fromHexString)(share)
+    );
+    for (const share of validatorPublicSharesBytes) {
+      pubShares.push(share);
     }
     const depositAmounts = clusterLock.cluster_definition.deposit_amounts;
     if (!!depositAmounts && depositAmounts !== null) {
@@ -13858,52 +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_ssz4.fromHexString)(distributedPublicKey));
-      builderRegistrationAndDepositDataMessages.push(depositDataMsg);
-      blsSignatures.push((0, import_ssz4.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_ssz4.fromHexString)(distributedPublicKey));
-    builderRegistrationAndDepositDataMessages.push(builderRegistrationMsg);
-    blsSignatures.push(
-      (0, import_ssz4.fromHexString)((_a6 = validator.builder_registration) == null ? void 0 : _a6.signature)
+      forkVersion,
+      builderDomain
     );
+    if (!builderCheck) return false;
+    blsChecks.push(builderCheck);
   }
-  const aggregateBLSSignature = blsAggregateSignatures(blsSignatures);
-  if (!blsVerifyMultiple(
-    pubKeys,
-    builderRegistrationAndDepositDataMessages,
-    aggregateBLSSignature
-  )) {
+  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)
-  )) {
+    (0, import_ssz5.fromHexString)(clusterLock.lock_hash),
+    (0, import_ssz5.fromHexString)(clusterLock.signature_aggregate)
+  ))) {
     return false;
   }
   return true;
@@ -13983,34 +14416,34 @@ var validateSmartContractSignature = (_0) => __async(null, [_0], function* ({
 
 // src/verification/v1.10.0.ts
 var import_uint4 = require("@chainsafe/ssz/lib/type/uint.js");
-var import_ssz5 = require("@chainsafe/ssz");
+var import_ssz6 = require("@chainsafe/ssz");
 var clusterDefinitionContainerTypeV1X10 = (configOnly) => {
   let returnedContainerType = {
-    uuid: new import_ssz5.ByteListType(64),
-    name: new import_ssz5.ByteListType(256),
-    version: new import_ssz5.ByteListType(16),
-    timestamp: new import_ssz5.ByteListType(32),
+    uuid: new import_ssz6.ByteListType(64),
+    name: new import_ssz6.ByteListType(256),
+    version: new import_ssz6.ByteListType(16),
+    timestamp: new import_ssz6.ByteListType(32),
     num_validators: new import_uint4.UintNumberType(8),
     threshold: new import_uint4.UintNumberType(8),
-    dkg_algorithm: new import_ssz5.ByteListType(32),
-    fork_version: new import_ssz5.ByteVectorType(4),
-    operators: new import_ssz5.ListCompositeType(newOperatorContainerType(configOnly), 256),
+    dkg_algorithm: new import_ssz6.ByteListType(32),
+    fork_version: new import_ssz6.ByteVectorType(4),
+    operators: new import_ssz6.ListCompositeType(newOperatorContainerType(configOnly), 256),
     creator: newCreatorContainerType(configOnly),
-    validators: new import_ssz5.ListCompositeType(validatorsContainerType, 65536),
-    deposit_amounts: new import_ssz5.ListBasicType(
+    validators: new import_ssz6.ListCompositeType(validatorsContainerType, 65536),
+    deposit_amounts: new import_ssz6.ListBasicType(
       new import_uint4.UintNumberType(8),
       256
     ),
-    consensus_protocol: new import_ssz5.ByteListType(256),
+    consensus_protocol: new import_ssz6.ByteListType(256),
     target_gas_limit: new import_uint4.UintNumberType(8),
-    compounding: new import_ssz5.BooleanType()
+    compounding: new import_ssz6.BooleanType()
   };
   if (!configOnly) {
     returnedContainerType = __spreadProps(__spreadValues({}, returnedContainerType), {
-      config_hash: new import_ssz5.ByteVectorType(32)
+      config_hash: new import_ssz6.ByteVectorType(32)
     });
   }
-  return new import_ssz5.ContainerType(returnedContainerType);
+  return new import_ssz6.ContainerType(returnedContainerType);
 };
 var hashClusterDefinitionV1X10 = (cluster, configOnly) => {
   const definitionType = clusterDefinitionContainerTypeV1X10(configOnly);
@@ -14022,25 +14455,25 @@ var hashClusterDefinitionV1X10 = (cluster, configOnly) => {
   val.num_validators = cluster.num_validators;
   val.threshold = cluster.threshold;
   val.dkg_algorithm = strToUint8Array(cluster.dkg_algorithm);
-  val.fork_version = (0, import_ssz5.fromHexString)(cluster.fork_version);
+  val.fork_version = (0, import_ssz6.fromHexString)(cluster.fork_version);
   val.operators = cluster.operators.map((operator) => {
-    return configOnly ? { address: (0, import_ssz5.fromHexString)(operator.address) } : {
-      address: (0, import_ssz5.fromHexString)(operator.address),
+    return configOnly ? { address: (0, import_ssz6.fromHexString)(operator.address) } : {
+      address: (0, import_ssz6.fromHexString)(operator.address),
       enr: strToUint8Array(operator.enr),
-      config_signature: (0, import_ssz5.fromHexString)(operator.config_signature),
-      enr_signature: (0, import_ssz5.fromHexString)(operator.enr_signature)
+      config_signature: (0, import_ssz6.fromHexString)(operator.config_signature),
+      enr_signature: (0, import_ssz6.fromHexString)(operator.enr_signature)
     };
   });
-  val.creator = configOnly ? { address: (0, import_ssz5.fromHexString)(cluster.creator.address) } : {
-    address: (0, import_ssz5.fromHexString)(cluster.creator.address),
-    config_signature: (0, import_ssz5.fromHexString)(
+  val.creator = configOnly ? { address: (0, import_ssz6.fromHexString)(cluster.creator.address) } : {
+    address: (0, import_ssz6.fromHexString)(cluster.creator.address),
+    config_signature: (0, import_ssz6.fromHexString)(
       cluster.creator.config_signature
     )
   };
   val.validators = cluster.validators.map((validator) => {
     return {
-      fee_recipient_address: (0, import_ssz5.fromHexString)(validator.fee_recipient_address),
-      withdrawal_address: (0, import_ssz5.fromHexString)(validator.withdrawal_address)
+      fee_recipient_address: (0, import_ssz6.fromHexString)(validator.fee_recipient_address),
+      withdrawal_address: (0, import_ssz6.fromHexString)(validator.withdrawal_address)
     };
   });
   if (cluster.deposit_amounts) {
@@ -14058,20 +14491,20 @@ var hashClusterDefinitionV1X10 = (cluster, configOnly) => {
     val.compounding = cluster.compounding;
   }
   if (!configOnly) {
-    val.config_hash = (0, import_ssz5.fromHexString)(cluster.config_hash);
+    val.config_hash = (0, import_ssz6.fromHexString)(cluster.config_hash);
   }
   return val;
 };
-var dvContainerTypeV1X10 = new import_ssz5.ContainerType({
-  distributed_public_key: new import_ssz5.ByteVectorType(48),
-  public_shares: new import_ssz5.ListCompositeType(new import_ssz5.ByteVectorType(48), 256),
-  partial_deposit_data: new import_ssz5.ListCompositeType(depositDataContainer, 256),
+var dvContainerTypeV1X10 = new import_ssz6.ContainerType({
+  distributed_public_key: new import_ssz6.ByteVectorType(48),
+  public_shares: new import_ssz6.ListCompositeType(new import_ssz6.ByteVectorType(48), 256),
+  partial_deposit_data: new import_ssz6.ListCompositeType(depositDataContainer, 256),
   builder_registration: builderRegistrationContainer
 });
 var clusterLockContainerTypeV1X10 = () => {
-  return new import_ssz5.ContainerType({
+  return new import_ssz6.ContainerType({
     cluster_definition: clusterDefinitionContainerTypeV1X10(false),
-    distributed_validators: new import_ssz5.ListCompositeType(dvContainerTypeV1X10, 65536)
+    distributed_validators: new import_ssz6.ListCompositeType(dvContainerTypeV1X10, 65536)
   });
 };
 var hashClusterLockV1X10 = (cluster) => {
@@ -14085,35 +14518,35 @@ var hashClusterLockV1X10 = (cluster) => {
     (dValidator) => {
       var _a6, _b2, _c, _d, _e;
       return {
-        distributed_public_key: (0, import_ssz5.fromHexString)(
+        distributed_public_key: (0, import_ssz6.fromHexString)(
           dValidator.distributed_public_key
         ),
         public_shares: dValidator.public_shares.map(
-          (publicShare) => (0, import_ssz5.fromHexString)(publicShare)
+          (publicShare) => (0, import_ssz6.fromHexString)(publicShare)
         ),
         // should be fixed
         partial_deposit_data: dValidator.partial_deposit_data.map((depositData) => {
           return {
-            pubkey: (0, import_ssz5.fromHexString)(depositData.pubkey),
-            withdrawal_credentials: (0, import_ssz5.fromHexString)(
+            pubkey: (0, import_ssz6.fromHexString)(depositData.pubkey),
+            withdrawal_credentials: (0, import_ssz6.fromHexString)(
               depositData.withdrawal_credentials
             ),
             amount: parseInt(depositData.amount),
-            signature: (0, import_ssz5.fromHexString)(depositData.signature)
+            signature: (0, import_ssz6.fromHexString)(depositData.signature)
           };
         }),
         builder_registration: {
           message: {
-            fee_recipient: (0, import_ssz5.fromHexString)(
+            fee_recipient: (0, import_ssz6.fromHexString)(
               (_a6 = dValidator.builder_registration) == null ? void 0 : _a6.message.fee_recipient
             ),
             gas_limit: (_b2 = dValidator.builder_registration) == null ? void 0 : _b2.message.gas_limit,
             timestamp: (_c = dValidator.builder_registration) == null ? void 0 : _c.message.timestamp,
-            pubkey: (0, import_ssz5.fromHexString)(
+            pubkey: (0, import_ssz6.fromHexString)(
               (_d = dValidator.builder_registration) == null ? void 0 : _d.message.pubkey
             )
           },
-          signature: (0, import_ssz5.fromHexString)(
+          signature: (0, import_ssz6.fromHexString)(
             (_e = dValidator.builder_registration) == null ? void 0 : _e.signature
           )
         }
@@ -14272,8 +14705,8 @@ var computeSigningRoot = (sszObjectRoot, domain) => {
 };
 var computeDepositMsgRoot = (msg) => {
   const depositMsgVal = depositMessageType.defaultValue();
-  depositMsgVal.pubkey = (0, import_ssz6.fromHexString)(msg.pubkey);
-  depositMsgVal.withdrawal_credentials = (0, import_ssz6.fromHexString)(
+  depositMsgVal.pubkey = (0, import_ssz7.fromHexString)(msg.pubkey);
+  depositMsgVal.withdrawal_credentials = (0, import_ssz7.fromHexString)(
     msg.withdrawal_credentials
   );
   depositMsgVal.amount = parseInt(msg.amount);
@@ -14287,16 +14720,16 @@ var computeForkDataRoot = (currentVersion, genesisValidatorsRoot) => {
 };
 var computebuilderRegistrationMsgRoot = (msg) => {
   const builderRegistrationMsgVal = builderRegistrationMessageType.defaultValue();
-  builderRegistrationMsgVal.fee_recipient = (0, import_ssz6.fromHexString)(msg.fee_recipient);
+  builderRegistrationMsgVal.fee_recipient = (0, import_ssz7.fromHexString)(msg.fee_recipient);
   builderRegistrationMsgVal.gas_limit = msg.gas_limit;
   builderRegistrationMsgVal.timestamp = msg.timestamp;
-  builderRegistrationMsgVal.pubkey = (0, import_ssz6.fromHexString)(msg.pubkey);
+  builderRegistrationMsgVal.pubkey = (0, import_ssz7.fromHexString)(msg.pubkey);
   return Buffer.from(
     builderRegistrationMessageType.hashTreeRoot(builderRegistrationMsgVal).buffer
   );
 };
-var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = (0, import_ssz6.fromHexString)(GENESIS_VALIDATOR_ROOT)) => {
-  const forkVersion = (0, import_ssz6.fromHexString)(
+var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = (0, import_ssz7.fromHexString)(GENESIS_VALIDATOR_ROOT)) => {
+  const forkVersion = (0, import_ssz7.fromHexString)(
     lockForkVersion.substring(2, lockForkVersion.length)
   );
   const forkDataRoot = computeForkDataRoot(forkVersion, genesisValidatorsRoot);
@@ -14305,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_ssz6.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_ssz6.fromHexString)(depositData.pubkey),
-    depositDataRoot,
-    (0, import_ssz6.fromHexString)(depositData.signature)
+    (0, import_ssz7.fromHexString)(depositData.pubkey),
+    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_ssz6.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,
@@ -14360,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;
@@ -14401,6 +14875,12 @@ var verifyLockData = (clusterLock) => __async(null, null, function* () {
   }
   return false;
 });
+var hasUniqueDistributedKeys = (clusterLock) => {
+  const dvKeys = clusterLock.distributed_validators.map(
+    (v) => v.distributed_public_key.toLowerCase()
+  );
+  return new Set(dvKeys).size === dvKeys.length;
+};
 var isValidClusterLock = (clusterLock, safeRpcUrl) => __async(null, null, function* () {
   try {
     const definitionType = definitionFlow(clusterLock.cluster_definition);
@@ -14421,6 +14901,9 @@ var isValidClusterLock = (clusterLock, safeRpcUrl) => __async(null, null, functi
     if (clusterLockHash(clusterLock) !== clusterLock.lock_hash) {
       return false;
     }
+    if (!hasUniqueDistributedKeys(clusterLock)) {
+      return false;
+    }
     const isValidLockData = yield verifyLockData(clusterLock);
     if (!isValidLockData) {
       return false;
@@ -18086,7 +18569,7 @@ var Incentives = class {
 
 // src/exits/exit.ts
 var elliptic2 = __toESM(require("elliptic"));
-var import_ssz8 = require("@chainsafe/ssz");
+var import_ssz9 = require("@chainsafe/ssz");
 
 // src/exits/ethUtils.ts
 function getCapellaFork(fork_version) {
@@ -18123,15 +18606,15 @@ function getGenesisValidatorsRoot(beaconNodeApiUrl) {
 }
 
 // src/exits/verificationHelpers.ts
-var import_ssz7 = require("@chainsafe/ssz");
+var import_ssz8 = require("@chainsafe/ssz");
 var GENESIS_VALIDATOR_ROOT_HEX_STRING = "0x0000000000000000000000000000000000000000000000000000000000000000";
-var ForkDataType = new import_ssz7.ContainerType({
-  currentVersion: new import_ssz7.ByteVectorType(4),
-  genesisValidatorsRoot: new import_ssz7.ByteVectorType(32)
+var ForkDataType = new import_ssz8.ContainerType({
+  currentVersion: new import_ssz8.ByteVectorType(4),
+  genesisValidatorsRoot: new import_ssz8.ByteVectorType(32)
 });
-var SigningRootType = new import_ssz7.ContainerType({
-  objectRoot: new import_ssz7.ByteVectorType(32),
-  domain: new import_ssz7.ByteVectorType(32)
+var SigningRootType = new import_ssz8.ContainerType({
+  objectRoot: new import_ssz8.ByteVectorType(32),
+  domain: new import_ssz8.ByteVectorType(32)
 });
 function computeForkDataRoot2(currentVersion, genesisValidatorsRoot) {
   const forkDataVal = ForkDataType.defaultValue();
@@ -18140,7 +18623,7 @@ function computeForkDataRoot2(currentVersion, genesisValidatorsRoot) {
   return Buffer.from(ForkDataType.hashTreeRoot(forkDataVal).buffer);
 }
 function computeDomain2(domainType, forkVersionString, genesisValidatorsRootOverride) {
-  const forkVersionBytes = (0, import_ssz7.fromHexString)(
+  const forkVersionBytes = (0, import_ssz8.fromHexString)(
     forkVersionString.substring(2, forkVersionString.length)
   );
   if (forkVersionBytes.length !== 4) {
@@ -18149,7 +18632,7 @@ function computeDomain2(domainType, forkVersionString, genesisValidatorsRootOver
   if (domainType.length !== 4) {
     throw new Error("Domain type must be 4 bytes");
   }
-  const actualGenesisValidatorsRoot = genesisValidatorsRootOverride != null ? genesisValidatorsRootOverride : (0, import_ssz7.fromHexString)(GENESIS_VALIDATOR_ROOT_HEX_STRING.substring(2));
+  const actualGenesisValidatorsRoot = genesisValidatorsRootOverride != null ? genesisValidatorsRootOverride : (0, import_ssz8.fromHexString)(GENESIS_VALIDATOR_ROOT_HEX_STRING.substring(2));
   if (actualGenesisValidatorsRoot.length !== 32) {
     throw new Error("genesisValidatorsRoot must be 32 bytes");
   }
@@ -18181,25 +18664,25 @@ function signingRoot2(domain, messageBuffer) {
 
 // src/exits/exit.ts
 var DOMAIN_VOLUNTARY_EXIT = "0x04000000";
-var SSZExitMessageType = new import_ssz8.ContainerType({
-  epoch: new import_ssz8.UintNumberType(8),
-  validator_index: new import_ssz8.UintNumberType(8)
+var SSZExitMessageType = new import_ssz9.ContainerType({
+  epoch: new import_ssz9.UintNumberType(8),
+  validator_index: new import_ssz9.UintNumberType(8)
 });
-var SSZPartialExitsPayloadType = new import_ssz8.ContainerType({
-  partial_exits: new import_ssz8.ListCompositeType(
-    new import_ssz8.ContainerType({
-      public_key: new import_ssz8.ByteVectorType(48),
-      signed_exit_message: new import_ssz8.ContainerType({
-        message: new import_ssz8.ContainerType({
-          epoch: new import_ssz8.UintNumberType(8),
-          validator_index: new import_ssz8.UintNumberType(8)
+var SSZPartialExitsPayloadType = new import_ssz9.ContainerType({
+  partial_exits: new import_ssz9.ListCompositeType(
+    new import_ssz9.ContainerType({
+      public_key: new import_ssz9.ByteVectorType(48),
+      signed_exit_message: new import_ssz9.ContainerType({
+        message: new import_ssz9.ContainerType({
+          epoch: new import_ssz9.UintNumberType(8),
+          validator_index: new import_ssz9.UintNumberType(8)
         }),
-        signature: new import_ssz8.ByteVectorType(96)
+        signature: new import_ssz9.ByteVectorType(96)
       })
     }),
     65536
   ),
-  share_idx: new import_ssz8.UintNumberType(8)
+  share_idx: new import_ssz9.UintNumberType(8)
 });
 var Exit = class _Exit {
   /**
@@ -18242,7 +18725,7 @@ var Exit = class _Exit {
   static computeExitPayloadRoot(exits) {
     const sszValue = SSZPartialExitsPayloadType.defaultValue();
     sszValue.partial_exits = exits.partial_exits.map((pe) => ({
-      public_key: (0, import_ssz8.fromHexString)(pe.public_key),
+      public_key: (0, import_ssz9.fromHexString)(pe.public_key),
       signed_exit_message: {
         message: {
           epoch: _Exit.safeParseInt(pe.signed_exit_message.message.epoch),
@@ -18250,7 +18733,7 @@ var Exit = class _Exit {
             pe.signed_exit_message.message.validator_index
           )
         },
-        signature: (0, import_ssz8.fromHexString)(pe.signed_exit_message.signature)
+        signature: (0, import_ssz9.fromHexString)(pe.signed_exit_message.signature)
       }
     }));
     sszValue.share_idx = exits.share_idx;
@@ -18300,18 +18783,18 @@ var Exit = class _Exit {
         signedExitMessage.message
       );
       const exitDomain = computeDomain2(
-        (0, import_ssz8.fromHexString)(DOMAIN_VOLUNTARY_EXIT),
+        (0, import_ssz9.fromHexString)(DOMAIN_VOLUNTARY_EXIT),
         capellaForkVersionString,
-        (0, import_ssz8.fromHexString)(genesisValidatorsRootString)
+        (0, import_ssz9.fromHexString)(genesisValidatorsRootString)
       );
       const messageSigningRoot = signingRoot2(
         exitDomain,
         partialExitMessageBuffer
       );
       return blsVerify(
-        (0, import_ssz8.fromHexString)(publicShareKey),
+        (0, import_ssz9.fromHexString)(publicShareKey),
         messageSigningRoot,
-        (0, import_ssz8.fromHexString)(signedExitMessage.signature)
+        (0, import_ssz9.fromHexString)(signedExitMessage.signature)
       );
     });
   }
@@ -18614,7 +19097,7 @@ var Exit = class _Exit {
           );
         }
         try {
-          const sigBytes = (0, import_ssz8.fromHexString)(cleanSigStr);
+          const sigBytes = (0, import_ssz9.fromHexString)(cleanSigStr);
           const sigIdx = parseInt(sigIdxStr, 10);
           signaturesByIndex.set(sigIdx + 1, sigBytes);
         } catch (err) {
@@ -19358,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;
   }
@@ -19959,6 +20443,7 @@ var Client = class extends Base {
   CONFIG_VERSION,
   CONFLICT_ERROR_MSG,
   Client,
+  ClusterLockValidationTimeoutError,
   ConflictError,
   CreatorConfigHashSigningTypes,
   CreatorTypedMessage,
@@ -19999,8 +20484,13 @@ var Client = class extends Base {
   TermsAndConditionsSigningTypes,
   UnsupportedChainError,
   blsVerify,
+  builderBlsCheck,
+  builderDomainForFork,
   clusterConfigOrDefinitionHash,
   clusterLockHash,
+  depositBlsCheck,
+  depositDomainForFork,
+  hasUniqueDistributedKeys,
   isChainSupportedForSplitters,
   isValidClusterLock,
   signCreatorConfigHashPayload,
@@ -20009,6 +20499,7 @@ var Client = class extends Base {
   signingRoot,
   validateAddressSignature,
   validateClusterLock,
+  validateDepositDataStructure,
   validateEOASignature,
   validateSmartContractSignature,
   verifyBuilderRegistration,