@obolnetwork/obol-sdk 2.12.6 → 2.13.0

package/dist/esm/src/{chunk-GLSVKGK3.js → chunk-EITEAAK3.js}

@@ -40,7 +40,7 @@ var FORK_NAMES = {
 // 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"
@@ -323,7 +323,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";
@@ -8987,7 +8987,7 @@ var validateSmartContractSignature = (_0) => __async(null, [_0], function* ({
 });
 
 // src/verification/common.ts
-import { fromHexString as fromHexString5 } from "@chainsafe/ssz";
+import { fromHexString as fromHexString6 } from "@chainsafe/ssz";
 import elliptic from "elliptic";
 import * as semver from "semver";
 
@@ -9001,6 +9001,7 @@ import {
   ByteListType,
   ByteVectorType,
   ContainerType,
+  ListCompositeType,
   UintNumberType
 } from "@chainsafe/ssz";
 var operatorAddressWrapperType = new ContainerType({
@@ -9016,10 +9017,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)
@@ -9027,9 +9043,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),
@@ -9071,7 +9093,7 @@ import {
   ByteListType as ByteListType2,
   ByteVectorType as ByteVectorType2,
   ContainerType as ContainerType2,
-  ListCompositeType,
+  ListCompositeType as ListCompositeType2,
   fromHexString
 } from "@chainsafe/ssz";
 var clusterDefinitionContainerTypeV1X6 = (configOnly) => {
@@ -9084,9 +9106,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), {
@@ -9133,7 +9155,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),
@@ -9142,7 +9164,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) => {
@@ -9240,7 +9262,7 @@ import {
   ByteListType as ByteListType3,
   ByteVectorType as ByteVectorType3,
   ContainerType as ContainerType3,
-  ListCompositeType as ListCompositeType2,
+  ListCompositeType as ListCompositeType3,
   fromHexString as fromHexString2
 } from "@chainsafe/ssz";
 var clusterDefinitionContainerTypeV1X7 = (configOnly) => {
@@ -9253,9 +9275,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), {
@@ -9302,14 +9324,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) => {
@@ -9437,7 +9459,7 @@ import {
   ByteVectorType as ByteVectorType4,
   ContainerType as ContainerType4,
   ListBasicType,
-  ListCompositeType as ListCompositeType3,
+  ListCompositeType as ListCompositeType4,
   fromHexString as fromHexString3
 } from "@chainsafe/ssz";
 var clusterDefinitionContainerTypeV1X8 = (configOnly) => {
@@ -9450,9 +9472,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
@@ -9508,14 +9530,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) => {
@@ -9661,7 +9683,7 @@ import {
   ByteVectorType as ByteVectorType5,
   ContainerType as ContainerType5,
   ListBasicType as ListBasicType2,
-  ListCompositeType as ListCompositeType4,
+  ListCompositeType as ListCompositeType5,
   fromHexString as fromHexString4,
   BooleanType
 } from "@chainsafe/ssz";
@@ -9675,9 +9697,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
@@ -9745,14 +9767,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) => {
@@ -9805,6 +9827,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 fromHexString5,
+  BooleanType as BooleanType2
+} from "@chainsafe/ssz";
+var splitK1SignatureList = (signature) => {
+  const bytes = fromHexString5(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 = fromHexString5(cluster.fork_version);
+  val.operators = cluster.operators.map((operator) => {
+    return configOnly ? { address: fromHexString5(operator.address) } : {
+      address: fromHexString5(operator.address),
+      enr: strToUint8Array(operator.enr),
+      config_signature: splitK1SignatureList(
+        operator.config_signature
+      ),
+      enr_signature: splitK1SignatureList(operator.enr_signature)
+    };
+  });
+  val.creator = configOnly ? { address: fromHexString5(cluster.creator.address) } : {
+    address: fromHexString5(cluster.creator.address),
+    config_signature: splitK1SignatureList(
+      cluster.creator.config_signature
+    )
+  };
+  val.validators = cluster.validators.map((validator) => {
+    return {
+      fee_recipient_address: fromHexString5(validator.fee_recipient_address),
+      withdrawal_address: fromHexString5(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 = fromHexString5(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: fromHexString5(
+          dValidator.distributed_public_key
+        ),
+        public_shares: dValidator.public_shares.map(
+          (publicShare) => fromHexString5(publicShare)
+        ),
+        partial_deposit_data: dValidator.partial_deposit_data.map((depositData) => {
+          return {
+            pubkey: fromHexString5(depositData.pubkey),
+            withdrawal_credentials: fromHexString5(
+              depositData.withdrawal_credentials
+            ),
+            amount: parseInt(depositData.amount),
+            signature: fromHexString5(depositData.signature)
+          };
+        }),
+        builder_registration: {
+          message: {
+            fee_recipient: fromHexString5(
+              (_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: fromHexString5(
+              (_d = dValidator.builder_registration) == null ? void 0 : _d.message.pubkey
+            )
+          },
+          signature: fromHexString5(
+            (_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;
@@ -9829,6 +10020,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) => {
@@ -9854,6 +10050,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* () {
@@ -9953,8 +10152,8 @@ var computeSigningRoot = (sszObjectRoot, domain) => {
 };
 var computeDepositMsgRoot = (msg) => {
   const depositMsgVal = depositMessageType.defaultValue();
-  depositMsgVal.pubkey = fromHexString5(msg.pubkey);
-  depositMsgVal.withdrawal_credentials = fromHexString5(
+  depositMsgVal.pubkey = fromHexString6(msg.pubkey);
+  depositMsgVal.withdrawal_credentials = fromHexString6(
     msg.withdrawal_credentials
   );
   depositMsgVal.amount = parseInt(msg.amount);
@@ -9968,16 +10167,16 @@ var computeForkDataRoot = (currentVersion, genesisValidatorsRoot) => {
 };
 var computebuilderRegistrationMsgRoot = (msg) => {
   const builderRegistrationMsgVal = builderRegistrationMessageType.defaultValue();
-  builderRegistrationMsgVal.fee_recipient = fromHexString5(msg.fee_recipient);
+  builderRegistrationMsgVal.fee_recipient = fromHexString6(msg.fee_recipient);
   builderRegistrationMsgVal.gas_limit = msg.gas_limit;
   builderRegistrationMsgVal.timestamp = msg.timestamp;
-  builderRegistrationMsgVal.pubkey = fromHexString5(msg.pubkey);
+  builderRegistrationMsgVal.pubkey = fromHexString6(msg.pubkey);
   return Buffer.from(
     builderRegistrationMessageType.hashTreeRoot(builderRegistrationMsgVal).buffer
   );
 };
-var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = fromHexString5(GENESIS_VALIDATOR_ROOT)) => {
-  const forkVersion = fromHexString5(
+var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = fromHexString6(GENESIS_VALIDATOR_ROOT)) => {
+  const forkVersion = fromHexString6(
     lockForkVersion.substring(2, lockForkVersion.length)
   );
   const forkDataRoot = computeForkDataRoot(forkVersion, genesisValidatorsRoot);
@@ -9986,10 +10185,10 @@ var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = fromHe
   domain.set(forkDataRoot.subarray(0, 28), 4);
   return domain;
 };
-var depositDomainForFork = (forkVersion) => computeDomain(fromHexString5(DOMAIN_DEPOSIT), forkVersion);
-var builderDomainForFork = (forkVersion) => computeDomain(fromHexString5(DOMAIN_APPLICATION_BUILDER), forkVersion);
+var depositDomainForFork = (forkVersion) => computeDomain(fromHexString6(DOMAIN_DEPOSIT), forkVersion);
+var builderDomainForFork = (forkVersion) => computeDomain(fromHexString6(DOMAIN_APPLICATION_BUILDER), forkVersion);
 var validateDepositDataStructure = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding, precomputedDepositDomain) => {
-  const depositDomain = precomputedDepositDomain != null ? precomputedDepositDomain : computeDomain(fromHexString5(DOMAIN_DEPOSIT), forkVersion);
+  const depositDomain = precomputedDepositDomain != null ? precomputedDepositDomain : computeDomain(fromHexString6(DOMAIN_DEPOSIT), forkVersion);
   const withdrawalPrefix = compounding ? "0x02" : "0x01";
   const expectedWithdrawalCredentials = withdrawalPrefix + "0".repeat(22) + withdrawalAddress.toLowerCase().slice(2);
   if (expectedWithdrawalCredentials !== depositData.withdrawal_credentials) {
@@ -10016,9 +10215,9 @@ var depositBlsCheck = (distributedPublicKey, depositData, withdrawalAddress, for
   );
   if (!valid || !depositData.signature || !depositData.pubkey) return null;
   return {
-    pubkey: fromHexString5(depositData.pubkey),
+    pubkey: fromHexString6(depositData.pubkey),
     message: message2,
-    signature: fromHexString5(depositData.signature)
+    signature: fromHexString6(depositData.signature)
   };
 };
 var verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding) => {
@@ -10033,15 +10232,15 @@ var verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, f
     return { isValidDepositData: false, depositDataMsg: message2 };
   }
   const isValidDepositData = blsVerify(
-    fromHexString5(depositData.pubkey),
+    fromHexString6(depositData.pubkey),
     message2,
-    fromHexString5(depositData.signature)
+    fromHexString6(depositData.signature)
   );
   return { isValidDepositData, depositDataMsg: message2 };
 };
 var verifyBuilderRegistration = (validator, feeRecipientAddress, forkVersion, precomputedBuilderDomain) => {
   var _a6;
-  const builderDomain = precomputedBuilderDomain != null ? precomputedBuilderDomain : computeDomain(fromHexString5(DOMAIN_APPLICATION_BUILDER), forkVersion);
+  const builderDomain = precomputedBuilderDomain != null ? precomputedBuilderDomain : computeDomain(fromHexString6(DOMAIN_APPLICATION_BUILDER), forkVersion);
   if (validator.distributed_public_key !== ((_a6 = validator.builder_registration) == null ? void 0 : _a6.message.pubkey)) {
     return {
       isValidBuilderRegistration: false,
@@ -10077,9 +10276,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: fromHexString5(validator.distributed_public_key),
+    pubkey: fromHexString6(validator.distributed_public_key),
     message: builderRegistrationMsg,
-    signature: fromHexString5(sig)
+    signature: fromHexString6(sig)
   };
 };
 var verifyNodeSignatures = (clusterLock) => {
@@ -10121,6 +10320,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) => {
@@ -10242,4 +10444,4 @@ export {
 @scure/base/index.js:
   (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-GLSVKGK3.js.map
+//# sourceMappingURL=chunk-EITEAAK3.js.map