@obolnetwork/obol-sdk 2.11.13 → 2.12.0

package/dist/cjs/src/index.js

@@ -156,6 +156,7 @@ __export(index_exports, {
   blsVerify: () => blsVerify,
   clusterConfigOrDefinitionHash: () => clusterConfigOrDefinitionHash,
   clusterLockHash: () => clusterLockHash,
+  hasUniqueDistributedKeys: () => hasUniqueDistributedKeys,
   isChainSupportedForSplitters: () => isChainSupportedForSplitters,
   isValidClusterLock: () => isValidClusterLock,
   signCreatorConfigHashPayload: () => signCreatorConfigHashPayload,
@@ -176,7 +177,7 @@ var import_uuid = require("uuid");
 // package.json
 var package_default = {
   name: "@obolnetwork/obol-sdk",
-  version: "2.11.13",
+  version: "2.12.0",
   description: "A package for creating Distributed Validators using the Obol API.",
   bugs: {
     url: "https://github.com/obolnetwork/obol-sdk/issues"
@@ -662,7 +663,7 @@ var UnsupportedChainError = class _UnsupportedChainError extends Error {
 };
 
 // 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,7 +778,7 @@ var signingRootType = new import_ssz.ContainerType({
 });
 
 // src/verification/v1.6.0.ts
-var import_ssz2 = require("@chainsafe/ssz");
+var import_ssz3 = require("@chainsafe/ssz");
 
 // node_modules/@noble/curves/node_modules/@noble/hashes/utils.js
 function isBytes(a) {
@@ -4959,28 +4960,248 @@ 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 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 WORKER_TIMEOUT_MS = 6e4;
+var workerThreadsCache;
+var osCache;
+var workerPathCache;
+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() {
+  if (workerPathCache !== void 0) return workerPathCache;
+  if (typeof __dirname === "undefined") return workerPathCache = null;
+  const path = require("path");
+  const candidate = path.join(__dirname, "lockWorker.js");
+  try {
+    const fs = require("fs");
+    if (!fs.existsSync(candidate)) return workerPathCache = null;
+  } catch (e) {
+    return workerPathCache = null;
+  }
+  return workerPathCache = candidate;
+}
+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 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();
+  const numCpus = os ? os.cpus().length : 1;
+  const numWorkers = Math.min(
+    MAX_WORKERS,
+    Math.max(1, Math.floor(itemCount / minPerWorker)),
+    numCpus
+  );
+  return { numWorkers, wt, workerFile };
+}
+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);
+    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 results.every(Boolean);
+  });
+}
+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);
+    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 results.every(Boolean);
+  });
+}
 
 // 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 +5213,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,18 +5264,18 @@ 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)
       };
     }
   );
@@ -5063,6 +5284,22 @@ var hashClusterLockV1X6 = (cluster) => {
 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 = [];
@@ -5071,8 +5308,18 @@ var verifyDVV1X6 = (clusterLock) => __async(null, null, function* () {
     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 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 { isValidDepositData, depositDataMsg } = verifyDepositData(
       distributedPublicKey,
@@ -5083,24 +5330,23 @@ var verifyDVV1X6 = (clusterLock) => __async(null, null, function* () {
     if (!isValidDepositData) {
       return false;
     }
-    pubKeys.push((0, import_ssz2.fromHexString)(validator.distributed_public_key));
+    pubKeys.push((0, import_ssz3.fromHexString)(validator.distributed_public_key));
     builderRegistrationAndDepositDataMessages.push(depositDataMsg);
     blsSignatures.push(
-      (0, import_ssz2.fromHexString)((_a6 = validator.deposit_data) == null ? void 0 : _a6.signature)
+      (0, import_ssz3.fromHexString)((_a6 = validator.deposit_data) == null ? void 0 : _a6.signature)
     );
   }
-  const aggregateBLSSignature = blsAggregateSignatures(blsSignatures);
-  if (!blsVerifyMultiple(
+  if (!(yield verifyBatchParallel(
     pubKeys,
     builderRegistrationAndDepositDataMessages,
-    aggregateBLSSignature
-  )) {
+    blsSignatures
+  ))) {
     return false;
   }
   if (!blsVerifyAggregate(
     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;
   }
@@ -5109,27 +5355,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 +5387,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 +5436,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
           )
         }
@@ -5229,6 +5475,22 @@ var hashClusterLockV1X7 = (cluster) => {
 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 = [];
@@ -5237,8 +5499,18 @@ var verifyDVV1X7 = (clusterLock) => __async(null, null, function* () {
     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 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 { isValidDepositData, depositDataMsg } = verifyDepositData(
       distributedPublicKey,
@@ -5249,10 +5521,10 @@ var verifyDVV1X7 = (clusterLock) => __async(null, null, function* () {
     if (!isValidDepositData) {
       return false;
     }
-    pubKeys.push((0, import_ssz3.fromHexString)(distributedPublicKey));
+    pubKeys.push((0, import_ssz4.fromHexString)(distributedPublicKey));
     builderRegistrationAndDepositDataMessages.push(depositDataMsg);
     blsSignatures.push(
-      (0, import_ssz3.fromHexString)((_a6 = validator.deposit_data) == null ? void 0 : _a6.signature)
+      (0, import_ssz4.fromHexString)((_a6 = validator.deposit_data) == null ? void 0 : _a6.signature)
     );
     const { isValidBuilderRegistration, builderRegistrationMsg } = verifyBuilderRegistration(
       validator,
@@ -5262,18 +5534,17 @@ var verifyDVV1X7 = (clusterLock) => __async(null, null, function* () {
     if (!isValidBuilderRegistration) {
       return false;
     }
-    pubKeys.push((0, import_ssz3.fromHexString)(distributedPublicKey));
+    pubKeys.push((0, import_ssz4.fromHexString)(distributedPublicKey));
     builderRegistrationAndDepositDataMessages.push(builderRegistrationMsg);
     blsSignatures.push(
-      (0, import_ssz3.fromHexString)((_b2 = validator.builder_registration) == null ? void 0 : _b2.signature)
+      (0, import_ssz4.fromHexString)((_b2 = validator.builder_registration) == null ? void 0 : _b2.signature)
     );
   }
-  const aggregateBLSSignature = blsAggregateSignatures(blsSignatures);
-  if (!blsVerifyMultiple(
+  if (!(yield verifyBatchParallel(
     pubKeys,
     builderRegistrationAndDepositDataMessages,
-    aggregateBLSSignature
-  )) {
+    blsSignatures
+  ))) {
     return false;
   }
   if (!verifyNodeSignatures(clusterLock)) {
@@ -5281,8 +5552,8 @@ var verifyDVV1X7 = (clusterLock) => __async(null, null, function* () {
   }
   if (!blsVerifyAggregate(
     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;
   }
@@ -13708,31 +13979,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 +14015,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 +14042,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 +14069,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
           )
         }
@@ -13838,6 +14109,22 @@ var hashClusterLockV1X8 = (cluster) => {
 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 = [];
@@ -13846,8 +14133,18 @@ var verifyDVV1X8 = (clusterLock) => __async(null, null, function* () {
     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) {
@@ -13870,9 +14167,9 @@ var verifyDVV1X8 = (clusterLock) => __async(null, null, function* () {
       if (!isValidDepositData) {
         return false;
       }
-      pubKeys.push((0, import_ssz4.fromHexString)(distributedPublicKey));
+      pubKeys.push((0, import_ssz5.fromHexString)(distributedPublicKey));
       builderRegistrationAndDepositDataMessages.push(depositDataMsg);
-      blsSignatures.push((0, import_ssz4.fromHexString)(depositData == null ? void 0 : depositData.signature));
+      blsSignatures.push((0, import_ssz5.fromHexString)(depositData == null ? void 0 : depositData.signature));
     }
     const { isValidBuilderRegistration, builderRegistrationMsg } = verifyBuilderRegistration(
       validator,
@@ -13882,18 +14179,17 @@ var verifyDVV1X8 = (clusterLock) => __async(null, null, function* () {
     if (!isValidBuilderRegistration) {
       return false;
     }
-    pubKeys.push((0, import_ssz4.fromHexString)(distributedPublicKey));
+    pubKeys.push((0, import_ssz5.fromHexString)(distributedPublicKey));
     builderRegistrationAndDepositDataMessages.push(builderRegistrationMsg);
     blsSignatures.push(
-      (0, import_ssz4.fromHexString)((_a6 = validator.builder_registration) == null ? void 0 : _a6.signature)
+      (0, import_ssz5.fromHexString)((_a6 = validator.builder_registration) == null ? void 0 : _a6.signature)
     );
   }
-  const aggregateBLSSignature = blsAggregateSignatures(blsSignatures);
-  if (!blsVerifyMultiple(
+  if (!(yield verifyBatchParallel(
     pubKeys,
     builderRegistrationAndDepositDataMessages,
-    aggregateBLSSignature
-  )) {
+    blsSignatures
+  ))) {
     return false;
   }
   if (!verifyNodeSignatures(clusterLock)) {
@@ -13901,8 +14197,8 @@ var verifyDVV1X8 = (clusterLock) => __async(null, null, function* () {
   }
   if (!blsVerifyAggregate(
     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;
   }
@@ -13983,34 +14279,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 +14318,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 +14354,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 +14381,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 +14568,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 +14583,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);
@@ -14307,7 +14603,7 @@ var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = (0, im
 };
 var verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding) => {
   const depositDomain = computeDomain(
-    (0, import_ssz6.fromHexString)(DOMAIN_DEPOSIT),
+    (0, import_ssz7.fromHexString)(DOMAIN_DEPOSIT),
     forkVersion
   );
   const withdrawalPrefix = compounding ? "0x02" : "0x01";
@@ -14324,16 +14620,16 @@ var verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, f
     return { isValidDepositData: false, depositDataMsg: depositDataRoot };
   }
   const isValidDepositData = blsVerify(
-    (0, import_ssz6.fromHexString)(depositData.pubkey),
+    (0, import_ssz7.fromHexString)(depositData.pubkey),
     depositDataRoot,
-    (0, import_ssz6.fromHexString)(depositData.signature)
+    (0, import_ssz7.fromHexString)(depositData.signature)
   );
   return { isValidDepositData, depositDataMsg: depositDataRoot };
 };
 var verifyBuilderRegistration = (validator, feeRecipientAddress, forkVersion) => {
   var _a6;
   const builderDomain = computeDomain(
-    (0, import_ssz6.fromHexString)(DOMAIN_APPLICATION_BUILDER),
+    (0, import_ssz7.fromHexString)(DOMAIN_APPLICATION_BUILDER),
     forkVersion
   );
   if (validator.distributed_public_key !== ((_a6 = validator.builder_registration) == null ? void 0 : _a6.message.pubkey)) {
@@ -14401,6 +14697,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 +14723,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 +18391,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 +18428,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 +18445,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 +18454,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 +18486,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 +18547,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 +18555,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 +18605,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 +18919,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) {
@@ -20001,6 +20306,7 @@ var Client = class extends Base {
   blsVerify,
   clusterConfigOrDefinitionHash,
   clusterLockHash,
+  hasUniqueDistributedKeys,
   isChainSupportedForSplitters,
   isValidClusterLock,
   signCreatorConfigHashPayload,