@obolnetwork/obol-sdk 2.12.6 → 2.13.0

package/dist/browser/src/index.js

@@ -98,7 +98,7 @@ import { v4 as uuidv4 } from "uuid";
 // package.json
 var package_default = {
   name: "@obolnetwork/obol-sdk",
-  version: "2.12.6",
+  version: "2.13.0",
   description: "A package for creating Distributed Validators using the Obol API.",
   bugs: {
     url: "https://github.com/obolnetwork/obol-sdk/issues"
@@ -396,7 +396,7 @@ var signEnrPayload = (payload, chainId) => {
   };
 };
 var DKG_ALGORITHM = "default";
-var CONFIG_VERSION = "v1.10.0";
+var CONFIG_VERSION = "v1.11.0";
 var SDK_VERSION = package_default.version;
 var DOMAIN_APPLICATION_BUILDER = "00000001";
 var DOMAIN_DEPOSIT = "03000000";
@@ -632,7 +632,7 @@ var Base = class {
 };
 
 // src/verification/common.ts
-import { fromHexString as fromHexString6 } from "@chainsafe/ssz";
+import { fromHexString as fromHexString7 } from "@chainsafe/ssz";
 import elliptic from "elliptic";
 import * as semver from "semver";
 
@@ -688,6 +688,7 @@ import {
   ByteListType,
   ByteVectorType,
   ContainerType,
+  ListCompositeType,
   UintNumberType
 } from "@chainsafe/ssz";
 var operatorAddressWrapperType = new ContainerType({
@@ -703,10 +704,25 @@ var operatorContainerType = new ContainerType({
   config_signature: new ByteVectorType(65),
   enr_signature: new ByteVectorType(65)
 });
+var k1SignatureListType = new ListCompositeType(
+  new ByteVectorType(65),
+  32
+);
+var operatorContainerTypeV1X11 = new ContainerType({
+  address: new ByteVectorType(20),
+  enr: new ByteListType(1024),
+  // This needs to be dynamic, since ENRs do not have a fixed length.
+  config_signature: k1SignatureListType,
+  enr_signature: k1SignatureListType
+});
 var creatorContainerType = new ContainerType({
   address: new ByteVectorType(20),
   config_signature: new ByteVectorType(65)
 });
+var creatorContainerTypeV1X11 = new ContainerType({
+  address: new ByteVectorType(20),
+  config_signature: k1SignatureListType
+});
 var validatorsContainerType = new ContainerType({
   fee_recipient_address: new ByteVectorType(20),
   withdrawal_address: new ByteVectorType(20)
@@ -714,9 +730,15 @@ var validatorsContainerType = new ContainerType({
 var newCreatorContainerType = (configOnly) => {
   return configOnly ? creatorAddressWrapperType : creatorContainerType;
 };
+var newCreatorContainerTypeV1X11 = (configOnly) => {
+  return configOnly ? creatorAddressWrapperType : creatorContainerTypeV1X11;
+};
 var newOperatorContainerType = (configOnly) => {
   return configOnly ? operatorAddressWrapperType : operatorContainerType;
 };
+var newOperatorContainerTypeV1X11 = (configOnly) => {
+  return configOnly ? operatorAddressWrapperType : operatorContainerTypeV1X11;
+};
 var depositDataContainer = new ContainerType({
   pubkey: new ByteVectorType(48),
   withdrawal_credentials: new ByteVectorType(32),
@@ -758,7 +780,7 @@ import {
   ByteListType as ByteListType2,
   ByteVectorType as ByteVectorType2,
   ContainerType as ContainerType2,
-  ListCompositeType,
+  ListCompositeType as ListCompositeType2,
   fromHexString as fromHexString2
 } from "@chainsafe/ssz";
 
@@ -5626,9 +5648,9 @@ var clusterDefinitionContainerTypeV1X6 = (configOnly) => {
     threshold: new UintNumberType2(8),
     dkg_algorithm: new ByteListType2(32),
     fork_version: new ByteVectorType2(4),
-    operators: new ListCompositeType(newOperatorContainerType(configOnly), 256),
+    operators: new ListCompositeType2(newOperatorContainerType(configOnly), 256),
     creator: newCreatorContainerType(configOnly),
-    validators: new ListCompositeType(validatorsContainerType, 65536)
+    validators: new ListCompositeType2(validatorsContainerType, 65536)
   };
   if (!configOnly) {
     returnedContainerType = __spreadProps(__spreadValues({}, returnedContainerType), {
@@ -5675,7 +5697,7 @@ var hashClusterDefinitionV1X6 = (cluster, configOnly) => {
 };
 var dvContainerTypeV1X6 = new ContainerType2({
   distributed_public_key: new ByteVectorType2(48),
-  public_shares: new ListCompositeType(new ByteVectorType2(48), 256),
+  public_shares: new ListCompositeType2(new ByteVectorType2(48), 256),
   pubkey: new ByteVectorType2(48),
   withdrawal_credentials: new ByteVectorType2(32),
   amount: new UintNumberType2(8),
@@ -5684,7 +5706,7 @@ var dvContainerTypeV1X6 = new ContainerType2({
 var clusterLockContainerTypeV1X6 = () => {
   return new ContainerType2({
     cluster_definition: clusterDefinitionContainerTypeV1X6(false),
-    distributed_validators: new ListCompositeType(dvContainerTypeV1X6, 65536)
+    distributed_validators: new ListCompositeType2(dvContainerTypeV1X6, 65536)
   });
 };
 var hashClusterLockV1X6 = (cluster) => {
@@ -5782,7 +5804,7 @@ import {
   ByteListType as ByteListType3,
   ByteVectorType as ByteVectorType3,
   ContainerType as ContainerType3,
-  ListCompositeType as ListCompositeType2,
+  ListCompositeType as ListCompositeType3,
   fromHexString as fromHexString3
 } from "@chainsafe/ssz";
 var clusterDefinitionContainerTypeV1X7 = (configOnly) => {
@@ -5795,9 +5817,9 @@ var clusterDefinitionContainerTypeV1X7 = (configOnly) => {
     threshold: new UintNumberType3(8),
     dkg_algorithm: new ByteListType3(32),
     fork_version: new ByteVectorType3(4),
-    operators: new ListCompositeType2(newOperatorContainerType(configOnly), 256),
+    operators: new ListCompositeType3(newOperatorContainerType(configOnly), 256),
     creator: newCreatorContainerType(configOnly),
-    validators: new ListCompositeType2(validatorsContainerType, 65536)
+    validators: new ListCompositeType3(validatorsContainerType, 65536)
   };
   if (!configOnly) {
     returnedContainerType = __spreadProps(__spreadValues({}, returnedContainerType), {
@@ -5844,14 +5866,14 @@ var hashClusterDefinitionV1X7 = (cluster, configOnly) => {
 };
 var dvContainerTypeV1X7 = new ContainerType3({
   distributed_public_key: new ByteVectorType3(48),
-  public_shares: new ListCompositeType2(new ByteVectorType3(48), 256),
+  public_shares: new ListCompositeType3(new ByteVectorType3(48), 256),
   deposit_data: depositDataContainer,
   builder_registration: builderRegistrationContainer
 });
 var clusterLockContainerTypeV1X7 = () => {
   return new ContainerType3({
     cluster_definition: clusterDefinitionContainerTypeV1X7(false),
-    distributed_validators: new ListCompositeType2(dvContainerTypeV1X7, 65536)
+    distributed_validators: new ListCompositeType3(dvContainerTypeV1X7, 65536)
   });
 };
 var hashClusterLockV1X7 = (cluster) => {
@@ -15431,7 +15453,7 @@ import {
   ByteVectorType as ByteVectorType4,
   ContainerType as ContainerType4,
   ListBasicType,
-  ListCompositeType as ListCompositeType3,
+  ListCompositeType as ListCompositeType4,
   fromHexString as fromHexString4
 } from "@chainsafe/ssz";
 var clusterDefinitionContainerTypeV1X8 = (configOnly) => {
@@ -15444,9 +15466,9 @@ var clusterDefinitionContainerTypeV1X8 = (configOnly) => {
     threshold: new UintNumberType4(8),
     dkg_algorithm: new ByteListType4(32),
     fork_version: new ByteVectorType4(4),
-    operators: new ListCompositeType3(newOperatorContainerType(configOnly), 256),
+    operators: new ListCompositeType4(newOperatorContainerType(configOnly), 256),
     creator: newCreatorContainerType(configOnly),
-    validators: new ListCompositeType3(validatorsContainerType, 65536),
+    validators: new ListCompositeType4(validatorsContainerType, 65536),
     deposit_amounts: new ListBasicType(
       new UintNumberType4(8),
       256
@@ -15502,14 +15524,14 @@ var hashClusterDefinitionV1X8 = (cluster, configOnly) => {
 };
 var dvContainerTypeV1X8 = new ContainerType4({
   distributed_public_key: new ByteVectorType4(48),
-  public_shares: new ListCompositeType3(new ByteVectorType4(48), 256),
-  partial_deposit_data: new ListCompositeType3(depositDataContainer, 256),
+  public_shares: new ListCompositeType4(new ByteVectorType4(48), 256),
+  partial_deposit_data: new ListCompositeType4(depositDataContainer, 256),
   builder_registration: builderRegistrationContainer
 });
 var clusterLockContainerTypeV1X8 = () => {
   return new ContainerType4({
     cluster_definition: clusterDefinitionContainerTypeV1X8(false),
-    distributed_validators: new ListCompositeType3(dvContainerTypeV1X8, 65536)
+    distributed_validators: new ListCompositeType4(dvContainerTypeV1X8, 65536)
   });
 };
 var hashClusterLockV1X8 = (cluster) => {
@@ -15730,7 +15752,7 @@ import {
   ByteVectorType as ByteVectorType5,
   ContainerType as ContainerType5,
   ListBasicType as ListBasicType2,
-  ListCompositeType as ListCompositeType4,
+  ListCompositeType as ListCompositeType5,
   fromHexString as fromHexString5,
   BooleanType
 } from "@chainsafe/ssz";
@@ -15744,9 +15766,9 @@ var clusterDefinitionContainerTypeV1X10 = (configOnly) => {
     threshold: new UintNumberType5(8),
     dkg_algorithm: new ByteListType5(32),
     fork_version: new ByteVectorType5(4),
-    operators: new ListCompositeType4(newOperatorContainerType(configOnly), 256),
+    operators: new ListCompositeType5(newOperatorContainerType(configOnly), 256),
     creator: newCreatorContainerType(configOnly),
-    validators: new ListCompositeType4(validatorsContainerType, 65536),
+    validators: new ListCompositeType5(validatorsContainerType, 65536),
     deposit_amounts: new ListBasicType2(
       new UintNumberType5(8),
       256
@@ -15814,14 +15836,14 @@ var hashClusterDefinitionV1X10 = (cluster, configOnly) => {
 };
 var dvContainerTypeV1X10 = new ContainerType5({
   distributed_public_key: new ByteVectorType5(48),
-  public_shares: new ListCompositeType4(new ByteVectorType5(48), 256),
-  partial_deposit_data: new ListCompositeType4(depositDataContainer, 256),
+  public_shares: new ListCompositeType5(new ByteVectorType5(48), 256),
+  partial_deposit_data: new ListCompositeType5(depositDataContainer, 256),
   builder_registration: builderRegistrationContainer
 });
 var clusterLockContainerTypeV1X10 = () => {
   return new ContainerType5({
     cluster_definition: clusterDefinitionContainerTypeV1X10(false),
-    distributed_validators: new ListCompositeType4(dvContainerTypeV1X10, 65536)
+    distributed_validators: new ListCompositeType5(dvContainerTypeV1X10, 65536)
   });
 };
 var hashClusterLockV1X10 = (cluster) => {
@@ -15874,6 +15896,175 @@ var hashClusterLockV1X10 = (cluster) => {
 };
 var verifyDVV1X10 = verifyDVV1X8;
 
+// src/verification/v1.11.0.ts
+import {
+  UintNumberType as UintNumberType6
+} from "@chainsafe/ssz/lib/type/uint.js";
+import {
+  ByteListType as ByteListType6,
+  ByteVectorType as ByteVectorType6,
+  ContainerType as ContainerType6,
+  ListBasicType as ListBasicType3,
+  ListCompositeType as ListCompositeType6,
+  fromHexString as fromHexString6,
+  BooleanType as BooleanType2
+} from "@chainsafe/ssz";
+var splitK1SignatureList = (signature) => {
+  const bytes = fromHexString6(signature);
+  if (bytes.length === 0) return [];
+  if (bytes.length % 65 !== 0) {
+    throw new Error("Signature length must be a multiple of 65 bytes");
+  }
+  const chunks = [];
+  for (let i = 0; i < bytes.length; i += 65) {
+    chunks.push(bytes.slice(i, i + 65));
+  }
+  return chunks;
+};
+var clusterDefinitionContainerTypeV1X11 = (configOnly) => {
+  let returnedContainerType = {
+    uuid: new ByteListType6(64),
+    name: new ByteListType6(256),
+    version: new ByteListType6(16),
+    timestamp: new ByteListType6(32),
+    num_validators: new UintNumberType6(8),
+    threshold: new UintNumberType6(8),
+    dkg_algorithm: new ByteListType6(32),
+    fork_version: new ByteVectorType6(4),
+    operators: new ListCompositeType6(
+      newOperatorContainerTypeV1X11(configOnly),
+      256
+    ),
+    creator: newCreatorContainerTypeV1X11(configOnly),
+    validators: new ListCompositeType6(validatorsContainerType, 65536),
+    deposit_amounts: new ListBasicType3(
+      new UintNumberType6(8),
+      256
+    ),
+    consensus_protocol: new ByteListType6(256),
+    target_gas_limit: new UintNumberType6(8),
+    compounding: new BooleanType2()
+  };
+  if (!configOnly) {
+    returnedContainerType = __spreadProps(__spreadValues({}, returnedContainerType), {
+      config_hash: new ByteVectorType6(32)
+    });
+  }
+  return new ContainerType6(returnedContainerType);
+};
+var hashClusterDefinitionV1X11 = (cluster, configOnly) => {
+  const definitionType = clusterDefinitionContainerTypeV1X11(configOnly);
+  const val = definitionType.defaultValue();
+  val.uuid = strToUint8Array(cluster.uuid);
+  val.name = strToUint8Array(cluster.name);
+  val.version = strToUint8Array(cluster.version);
+  val.timestamp = strToUint8Array(cluster.timestamp);
+  val.num_validators = cluster.num_validators;
+  val.threshold = cluster.threshold;
+  val.dkg_algorithm = strToUint8Array(cluster.dkg_algorithm);
+  val.fork_version = fromHexString6(cluster.fork_version);
+  val.operators = cluster.operators.map((operator) => {
+    return configOnly ? { address: fromHexString6(operator.address) } : {
+      address: fromHexString6(operator.address),
+      enr: strToUint8Array(operator.enr),
+      config_signature: splitK1SignatureList(
+        operator.config_signature
+      ),
+      enr_signature: splitK1SignatureList(operator.enr_signature)
+    };
+  });
+  val.creator = configOnly ? { address: fromHexString6(cluster.creator.address) } : {
+    address: fromHexString6(cluster.creator.address),
+    config_signature: splitK1SignatureList(
+      cluster.creator.config_signature
+    )
+  };
+  val.validators = cluster.validators.map((validator) => {
+    return {
+      fee_recipient_address: fromHexString6(validator.fee_recipient_address),
+      withdrawal_address: fromHexString6(validator.withdrawal_address)
+    };
+  });
+  if (cluster.deposit_amounts) {
+    val.deposit_amounts = cluster.deposit_amounts.map((amount) => {
+      return parseInt(amount);
+    });
+  }
+  if (cluster.consensus_protocol) {
+    val.consensus_protocol = strToUint8Array(cluster.consensus_protocol);
+  }
+  if (cluster.target_gas_limit) {
+    val.target_gas_limit = cluster.target_gas_limit;
+  }
+  if (cluster.compounding) {
+    val.compounding = cluster.compounding;
+  }
+  if (!configOnly) {
+    val.config_hash = fromHexString6(cluster.config_hash);
+  }
+  return val;
+};
+var dvContainerTypeV1X11 = new ContainerType6({
+  distributed_public_key: new ByteVectorType6(48),
+  public_shares: new ListCompositeType6(new ByteVectorType6(48), 256),
+  partial_deposit_data: new ListCompositeType6(depositDataContainer, 256),
+  builder_registration: builderRegistrationContainer
+});
+var clusterLockContainerTypeV1X11 = () => {
+  return new ContainerType6({
+    cluster_definition: clusterDefinitionContainerTypeV1X11(false),
+    distributed_validators: new ListCompositeType6(dvContainerTypeV1X11, 65536)
+  });
+};
+var hashClusterLockV1X11 = (cluster) => {
+  const lockType = clusterLockContainerTypeV1X11();
+  const val = lockType.defaultValue();
+  val.cluster_definition = hashClusterDefinitionV1X11(
+    cluster.cluster_definition,
+    false
+  );
+  val.distributed_validators = cluster.distributed_validators.map(
+    (dValidator) => {
+      var _a6, _b2, _c, _d, _e;
+      return {
+        distributed_public_key: fromHexString6(
+          dValidator.distributed_public_key
+        ),
+        public_shares: dValidator.public_shares.map(
+          (publicShare) => fromHexString6(publicShare)
+        ),
+        partial_deposit_data: dValidator.partial_deposit_data.map((depositData) => {
+          return {
+            pubkey: fromHexString6(depositData.pubkey),
+            withdrawal_credentials: fromHexString6(
+              depositData.withdrawal_credentials
+            ),
+            amount: parseInt(depositData.amount),
+            signature: fromHexString6(depositData.signature)
+          };
+        }),
+        builder_registration: {
+          message: {
+            fee_recipient: fromHexString6(
+              (_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: fromHexString6(
+              (_d = dValidator.builder_registration) == null ? void 0 : _d.message.pubkey
+            )
+          },
+          signature: fromHexString6(
+            (_e = dValidator.builder_registration) == null ? void 0 : _e.signature
+          )
+        }
+      };
+    }
+  );
+  return "0x" + Buffer.from(lockType.hashTreeRoot(val).buffer).toString("hex");
+};
+var verifyDVV1X11 = verifyDVV1X8;
+
 // src/verification/common.ts
 var clusterConfigOrDefinitionHash = (cluster, configOnly) => {
   let definitionType, val;
@@ -15898,6 +16089,11 @@ var clusterConfigOrDefinitionHash = (cluster, configOnly) => {
     const x = "0x" + Buffer.from(definitionType.hashTreeRoot(val).buffer).toString("hex");
     return x;
   }
+  if (semver.eq(cluster.version, "v1.11.0")) {
+    definitionType = clusterDefinitionContainerTypeV1X11(configOnly);
+    val = hashClusterDefinitionV1X11(cluster, configOnly);
+    return "0x" + Buffer.from(definitionType.hashTreeRoot(val).buffer).toString("hex");
+  }
   throw new Error("unsupported version");
 };
 var clusterLockHash = (clusterLock) => {
@@ -15923,6 +16119,9 @@ var clusterLockHash = (clusterLock) => {
   if (semver.eq(clusterLock.cluster_definition.version, "v1.10.0")) {
     return hashClusterLockV1X10(clusterLock);
   }
+  if (semver.eq(clusterLock.cluster_definition.version, "v1.11.0")) {
+    return hashClusterLockV1X11(clusterLock);
+  }
   throw new Error("unsupported version");
 };
 var validatePOSTConfigHashSigner = (address, signature, configHash, chainId, safeRpcUrl) => __async(null, null, function* () {
@@ -16022,8 +16221,8 @@ var computeSigningRoot = (sszObjectRoot, domain) => {
 };
 var computeDepositMsgRoot = (msg) => {
   const depositMsgVal = depositMessageType.defaultValue();
-  depositMsgVal.pubkey = fromHexString6(msg.pubkey);
-  depositMsgVal.withdrawal_credentials = fromHexString6(
+  depositMsgVal.pubkey = fromHexString7(msg.pubkey);
+  depositMsgVal.withdrawal_credentials = fromHexString7(
     msg.withdrawal_credentials
   );
   depositMsgVal.amount = parseInt(msg.amount);
@@ -16037,16 +16236,16 @@ var computeForkDataRoot = (currentVersion, genesisValidatorsRoot) => {
 };
 var computebuilderRegistrationMsgRoot = (msg) => {
   const builderRegistrationMsgVal = builderRegistrationMessageType.defaultValue();
-  builderRegistrationMsgVal.fee_recipient = fromHexString6(msg.fee_recipient);
+  builderRegistrationMsgVal.fee_recipient = fromHexString7(msg.fee_recipient);
   builderRegistrationMsgVal.gas_limit = msg.gas_limit;
   builderRegistrationMsgVal.timestamp = msg.timestamp;
-  builderRegistrationMsgVal.pubkey = fromHexString6(msg.pubkey);
+  builderRegistrationMsgVal.pubkey = fromHexString7(msg.pubkey);
   return Buffer.from(
     builderRegistrationMessageType.hashTreeRoot(builderRegistrationMsgVal).buffer
   );
 };
-var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = fromHexString6(GENESIS_VALIDATOR_ROOT)) => {
-  const forkVersion = fromHexString6(
+var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = fromHexString7(GENESIS_VALIDATOR_ROOT)) => {
+  const forkVersion = fromHexString7(
     lockForkVersion.substring(2, lockForkVersion.length)
   );
   const forkDataRoot = computeForkDataRoot(forkVersion, genesisValidatorsRoot);
@@ -16055,10 +16254,10 @@ var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = fromHe
   domain.set(forkDataRoot.subarray(0, 28), 4);
   return domain;
 };
-var depositDomainForFork = (forkVersion) => computeDomain(fromHexString6(DOMAIN_DEPOSIT), forkVersion);
-var builderDomainForFork = (forkVersion) => computeDomain(fromHexString6(DOMAIN_APPLICATION_BUILDER), forkVersion);
+var depositDomainForFork = (forkVersion) => computeDomain(fromHexString7(DOMAIN_DEPOSIT), forkVersion);
+var builderDomainForFork = (forkVersion) => computeDomain(fromHexString7(DOMAIN_APPLICATION_BUILDER), forkVersion);
 var validateDepositDataStructure = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding, precomputedDepositDomain) => {
-  const depositDomain = precomputedDepositDomain != null ? precomputedDepositDomain : computeDomain(fromHexString6(DOMAIN_DEPOSIT), forkVersion);
+  const depositDomain = precomputedDepositDomain != null ? precomputedDepositDomain : computeDomain(fromHexString7(DOMAIN_DEPOSIT), forkVersion);
   const withdrawalPrefix = compounding ? "0x02" : "0x01";
   const expectedWithdrawalCredentials = withdrawalPrefix + "0".repeat(22) + withdrawalAddress.toLowerCase().slice(2);
   if (expectedWithdrawalCredentials !== depositData.withdrawal_credentials) {
@@ -16085,9 +16284,9 @@ var depositBlsCheck = (distributedPublicKey, depositData, withdrawalAddress, for
   );
   if (!valid || !depositData.signature || !depositData.pubkey) return null;
   return {
-    pubkey: fromHexString6(depositData.pubkey),
+    pubkey: fromHexString7(depositData.pubkey),
     message: message2,
-    signature: fromHexString6(depositData.signature)
+    signature: fromHexString7(depositData.signature)
   };
 };
 var verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding) => {
@@ -16102,15 +16301,15 @@ var verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, f
     return { isValidDepositData: false, depositDataMsg: message2 };
   }
   const isValidDepositData = blsVerify(
-    fromHexString6(depositData.pubkey),
+    fromHexString7(depositData.pubkey),
     message2,
-    fromHexString6(depositData.signature)
+    fromHexString7(depositData.signature)
   );
   return { isValidDepositData, depositDataMsg: message2 };
 };
 var verifyBuilderRegistration = (validator, feeRecipientAddress, forkVersion, precomputedBuilderDomain) => {
   var _a6;
-  const builderDomain = precomputedBuilderDomain != null ? precomputedBuilderDomain : computeDomain(fromHexString6(DOMAIN_APPLICATION_BUILDER), forkVersion);
+  const builderDomain = precomputedBuilderDomain != null ? precomputedBuilderDomain : computeDomain(fromHexString7(DOMAIN_APPLICATION_BUILDER), forkVersion);
   if (validator.distributed_public_key !== ((_a6 = validator.builder_registration) == null ? void 0 : _a6.message.pubkey)) {
     return {
       isValidBuilderRegistration: false,
@@ -16146,9 +16345,9 @@ var builderBlsCheck = (validator, feeRecipientAddress, forkVersion, precomputedB
   const sig = (_a6 = validator.builder_registration) == null ? void 0 : _a6.signature;
   if (!isValidBuilderRegistration || !sig) return null;
   return {
-    pubkey: fromHexString6(validator.distributed_public_key),
+    pubkey: fromHexString7(validator.distributed_public_key),
     message: builderRegistrationMsg,
-    signature: fromHexString6(sig)
+    signature: fromHexString7(sig)
   };
 };
 var verifyNodeSignatures = (clusterLock) => {
@@ -16190,6 +16389,9 @@ var verifyLockData = (clusterLock) => __async(null, null, function* () {
   if (semver.eq(clusterLock.cluster_definition.version, "v1.10.0")) {
     return yield verifyDVV1X10(clusterLock);
   }
+  if (semver.eq(clusterLock.cluster_definition.version, "v1.11.0")) {
+    return yield verifyDVV1X11(clusterLock);
+  }
   return false;
 });
 var hasUniqueDistributedKeys = (clusterLock) => {
@@ -19896,11 +20098,11 @@ var Incentives = class {
 // src/exits/exit.ts
 import * as elliptic2 from "elliptic";
 import {
-  ByteVectorType as ByteVectorType7,
-  ContainerType as ContainerType7,
-  fromHexString as fromHexString8,
-  ListCompositeType as ListCompositeType5,
-  UintNumberType as UintNumberType6
+  ByteVectorType as ByteVectorType8,
+  ContainerType as ContainerType8,
+  fromHexString as fromHexString9,
+  ListCompositeType as ListCompositeType7,
+  UintNumberType as UintNumberType7
 } from "@chainsafe/ssz";
 
 // src/exits/ethUtils.ts
@@ -19938,15 +20140,15 @@ function getGenesisValidatorsRoot(beaconNodeApiUrl) {
 }
 
 // src/exits/verificationHelpers.ts
-import { ContainerType as ContainerType6, ByteVectorType as ByteVectorType6, fromHexString as fromHexString7 } from "@chainsafe/ssz";
+import { ContainerType as ContainerType7, ByteVectorType as ByteVectorType7, fromHexString as fromHexString8 } from "@chainsafe/ssz";
 var GENESIS_VALIDATOR_ROOT_HEX_STRING = "0x0000000000000000000000000000000000000000000000000000000000000000";
-var ForkDataType = new ContainerType6({
-  currentVersion: new ByteVectorType6(4),
-  genesisValidatorsRoot: new ByteVectorType6(32)
+var ForkDataType = new ContainerType7({
+  currentVersion: new ByteVectorType7(4),
+  genesisValidatorsRoot: new ByteVectorType7(32)
 });
-var SigningRootType = new ContainerType6({
-  objectRoot: new ByteVectorType6(32),
-  domain: new ByteVectorType6(32)
+var SigningRootType = new ContainerType7({
+  objectRoot: new ByteVectorType7(32),
+  domain: new ByteVectorType7(32)
 });
 function computeForkDataRoot2(currentVersion, genesisValidatorsRoot) {
   const forkDataVal = ForkDataType.defaultValue();
@@ -19955,7 +20157,7 @@ function computeForkDataRoot2(currentVersion, genesisValidatorsRoot) {
   return Buffer.from(ForkDataType.hashTreeRoot(forkDataVal).buffer);
 }
 function computeDomain2(domainType, forkVersionString, genesisValidatorsRootOverride) {
-  const forkVersionBytes = fromHexString7(
+  const forkVersionBytes = fromHexString8(
     forkVersionString.substring(2, forkVersionString.length)
   );
   if (forkVersionBytes.length !== 4) {
@@ -19964,7 +20166,7 @@ function computeDomain2(domainType, forkVersionString, genesisValidatorsRootOver
   if (domainType.length !== 4) {
     throw new Error("Domain type must be 4 bytes");
   }
-  const actualGenesisValidatorsRoot = genesisValidatorsRootOverride != null ? genesisValidatorsRootOverride : fromHexString7(GENESIS_VALIDATOR_ROOT_HEX_STRING.substring(2));
+  const actualGenesisValidatorsRoot = genesisValidatorsRootOverride != null ? genesisValidatorsRootOverride : fromHexString8(GENESIS_VALIDATOR_ROOT_HEX_STRING.substring(2));
   if (actualGenesisValidatorsRoot.length !== 32) {
     throw new Error("genesisValidatorsRoot must be 32 bytes");
   }
@@ -19996,25 +20198,25 @@ function signingRoot2(domain, messageBuffer) {
 
 // src/exits/exit.ts
 var DOMAIN_VOLUNTARY_EXIT = "0x04000000";
-var SSZExitMessageType = new ContainerType7({
-  epoch: new UintNumberType6(8),
-  validator_index: new UintNumberType6(8)
+var SSZExitMessageType = new ContainerType8({
+  epoch: new UintNumberType7(8),
+  validator_index: new UintNumberType7(8)
 });
-var SSZPartialExitsPayloadType = new ContainerType7({
-  partial_exits: new ListCompositeType5(
-    new ContainerType7({
-      public_key: new ByteVectorType7(48),
-      signed_exit_message: new ContainerType7({
-        message: new ContainerType7({
-          epoch: new UintNumberType6(8),
-          validator_index: new UintNumberType6(8)
+var SSZPartialExitsPayloadType = new ContainerType8({
+  partial_exits: new ListCompositeType7(
+    new ContainerType8({
+      public_key: new ByteVectorType8(48),
+      signed_exit_message: new ContainerType8({
+        message: new ContainerType8({
+          epoch: new UintNumberType7(8),
+          validator_index: new UintNumberType7(8)
         }),
-        signature: new ByteVectorType7(96)
+        signature: new ByteVectorType8(96)
       })
     }),
     65536
   ),
-  share_idx: new UintNumberType6(8)
+  share_idx: new UintNumberType7(8)
 });
 var Exit = class _Exit {
   /**
@@ -20057,7 +20259,7 @@ var Exit = class _Exit {
   static computeExitPayloadRoot(exits) {
     const sszValue = SSZPartialExitsPayloadType.defaultValue();
     sszValue.partial_exits = exits.partial_exits.map((pe) => ({
-      public_key: fromHexString8(pe.public_key),
+      public_key: fromHexString9(pe.public_key),
       signed_exit_message: {
         message: {
           epoch: _Exit.safeParseInt(pe.signed_exit_message.message.epoch),
@@ -20065,7 +20267,7 @@ var Exit = class _Exit {
             pe.signed_exit_message.message.validator_index
           )
         },
-        signature: fromHexString8(pe.signed_exit_message.signature)
+        signature: fromHexString9(pe.signed_exit_message.signature)
       }
     }));
     sszValue.share_idx = exits.share_idx;
@@ -20115,18 +20317,18 @@ var Exit = class _Exit {
         signedExitMessage.message
       );
       const exitDomain = computeDomain2(
-        fromHexString8(DOMAIN_VOLUNTARY_EXIT),
+        fromHexString9(DOMAIN_VOLUNTARY_EXIT),
         capellaForkVersionString,
-        fromHexString8(genesisValidatorsRootString)
+        fromHexString9(genesisValidatorsRootString)
       );
       const messageSigningRoot = signingRoot2(
         exitDomain,
         partialExitMessageBuffer
       );
       return blsVerify(
-        fromHexString8(publicShareKey),
+        fromHexString9(publicShareKey),
         messageSigningRoot,
-        fromHexString8(signedExitMessage.signature)
+        fromHexString9(signedExitMessage.signature)
       );
     });
   }
@@ -20429,7 +20631,7 @@ var Exit = class _Exit {
           );
         }
         try {
-          const sigBytes = fromHexString8(cleanSigStr);
+          const sigBytes = fromHexString9(cleanSigStr);
           const sigIdx = parseInt(sigIdxStr, 10);
           signaturesByIndex.set(sigIdx + 1, sigBytes);
         } catch (err) {
@@ -21663,7 +21865,7 @@ var Client = class extends Base {
    * @example
    * ```typescript
    * const updatedDef = await client.acceptClusterDefinition(
-   *   { enr: "enr:-LK4Q...", version: "v1.10.0" },
+   *   { enr: "enr:-LK4Q...", version: "v1.11.0" },
    *   configHash,
    * );
    * ```