@obolnetwork/obol-sdk 2.12.6 → 2.13.0

package/dist/cjs/src/index.js

@@ -186,7 +186,7 @@ var import_uuid = require("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"
@@ -484,7 +484,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";
@@ -720,7 +720,7 @@ var Base = class {
 };
 
 // src/verification/common.ts
-var import_ssz7 = require("@chainsafe/ssz");
+var import_ssz8 = require("@chainsafe/ssz");
 var import_elliptic = __toESM(require("elliptic"));
 var semver = __toESM(require("semver"));
 
@@ -784,10 +784,25 @@ var operatorContainerType = new import_ssz.ContainerType({
   config_signature: new import_ssz.ByteVectorType(65),
   enr_signature: new import_ssz.ByteVectorType(65)
 });
+var k1SignatureListType = new import_ssz.ListCompositeType(
+  new import_ssz.ByteVectorType(65),
+  32
+);
+var operatorContainerTypeV1X11 = new import_ssz.ContainerType({
+  address: new import_ssz.ByteVectorType(20),
+  enr: new import_ssz.ByteListType(1024),
+  // This needs to be dynamic, since ENRs do not have a fixed length.
+  config_signature: k1SignatureListType,
+  enr_signature: k1SignatureListType
+});
 var creatorContainerType = new import_ssz.ContainerType({
   address: new import_ssz.ByteVectorType(20),
   config_signature: new import_ssz.ByteVectorType(65)
 });
+var creatorContainerTypeV1X11 = new import_ssz.ContainerType({
+  address: new import_ssz.ByteVectorType(20),
+  config_signature: k1SignatureListType
+});
 var validatorsContainerType = new import_ssz.ContainerType({
   fee_recipient_address: new import_ssz.ByteVectorType(20),
   withdrawal_address: new import_ssz.ByteVectorType(20)
@@ -795,9 +810,15 @@ var validatorsContainerType = new import_ssz.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 import_ssz.ContainerType({
   pubkey: new import_ssz.ByteVectorType(48),
   withdrawal_credentials: new import_ssz.ByteVectorType(32),
@@ -14613,6 +14634,165 @@ var hashClusterLockV1X10 = (cluster) => {
 };
 var verifyDVV1X10 = verifyDVV1X8;
 
+// src/verification/v1.11.0.ts
+var import_uint5 = require("@chainsafe/ssz/lib/type/uint.js");
+var import_ssz7 = require("@chainsafe/ssz");
+var splitK1SignatureList = (signature) => {
+  const bytes = (0, import_ssz7.fromHexString)(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 import_ssz7.ByteListType(64),
+    name: new import_ssz7.ByteListType(256),
+    version: new import_ssz7.ByteListType(16),
+    timestamp: new import_ssz7.ByteListType(32),
+    num_validators: new import_uint5.UintNumberType(8),
+    threshold: new import_uint5.UintNumberType(8),
+    dkg_algorithm: new import_ssz7.ByteListType(32),
+    fork_version: new import_ssz7.ByteVectorType(4),
+    operators: new import_ssz7.ListCompositeType(
+      newOperatorContainerTypeV1X11(configOnly),
+      256
+    ),
+    creator: newCreatorContainerTypeV1X11(configOnly),
+    validators: new import_ssz7.ListCompositeType(validatorsContainerType, 65536),
+    deposit_amounts: new import_ssz7.ListBasicType(
+      new import_uint5.UintNumberType(8),
+      256
+    ),
+    consensus_protocol: new import_ssz7.ByteListType(256),
+    target_gas_limit: new import_uint5.UintNumberType(8),
+    compounding: new import_ssz7.BooleanType()
+  };
+  if (!configOnly) {
+    returnedContainerType = __spreadProps(__spreadValues({}, returnedContainerType), {
+      config_hash: new import_ssz7.ByteVectorType(32)
+    });
+  }
+  return new import_ssz7.ContainerType(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 = (0, import_ssz7.fromHexString)(cluster.fork_version);
+  val.operators = cluster.operators.map((operator) => {
+    return configOnly ? { address: (0, import_ssz7.fromHexString)(operator.address) } : {
+      address: (0, import_ssz7.fromHexString)(operator.address),
+      enr: strToUint8Array(operator.enr),
+      config_signature: splitK1SignatureList(
+        operator.config_signature
+      ),
+      enr_signature: splitK1SignatureList(operator.enr_signature)
+    };
+  });
+  val.creator = configOnly ? { address: (0, import_ssz7.fromHexString)(cluster.creator.address) } : {
+    address: (0, import_ssz7.fromHexString)(cluster.creator.address),
+    config_signature: splitK1SignatureList(
+      cluster.creator.config_signature
+    )
+  };
+  val.validators = cluster.validators.map((validator) => {
+    return {
+      fee_recipient_address: (0, import_ssz7.fromHexString)(validator.fee_recipient_address),
+      withdrawal_address: (0, import_ssz7.fromHexString)(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 = (0, import_ssz7.fromHexString)(cluster.config_hash);
+  }
+  return val;
+};
+var dvContainerTypeV1X11 = new import_ssz7.ContainerType({
+  distributed_public_key: new import_ssz7.ByteVectorType(48),
+  public_shares: new import_ssz7.ListCompositeType(new import_ssz7.ByteVectorType(48), 256),
+  partial_deposit_data: new import_ssz7.ListCompositeType(depositDataContainer, 256),
+  builder_registration: builderRegistrationContainer
+});
+var clusterLockContainerTypeV1X11 = () => {
+  return new import_ssz7.ContainerType({
+    cluster_definition: clusterDefinitionContainerTypeV1X11(false),
+    distributed_validators: new import_ssz7.ListCompositeType(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: (0, import_ssz7.fromHexString)(
+          dValidator.distributed_public_key
+        ),
+        public_shares: dValidator.public_shares.map(
+          (publicShare) => (0, import_ssz7.fromHexString)(publicShare)
+        ),
+        partial_deposit_data: dValidator.partial_deposit_data.map((depositData) => {
+          return {
+            pubkey: (0, import_ssz7.fromHexString)(depositData.pubkey),
+            withdrawal_credentials: (0, import_ssz7.fromHexString)(
+              depositData.withdrawal_credentials
+            ),
+            amount: parseInt(depositData.amount),
+            signature: (0, import_ssz7.fromHexString)(depositData.signature)
+          };
+        }),
+        builder_registration: {
+          message: {
+            fee_recipient: (0, import_ssz7.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_ssz7.fromHexString)(
+              (_d = dValidator.builder_registration) == null ? void 0 : _d.message.pubkey
+            )
+          },
+          signature: (0, import_ssz7.fromHexString)(
+            (_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;
@@ -14637,6 +14817,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) => {
@@ -14662,6 +14847,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* () {
@@ -14761,8 +14949,8 @@ var computeSigningRoot = (sszObjectRoot, domain) => {
 };
 var computeDepositMsgRoot = (msg) => {
   const depositMsgVal = depositMessageType.defaultValue();
-  depositMsgVal.pubkey = (0, import_ssz7.fromHexString)(msg.pubkey);
-  depositMsgVal.withdrawal_credentials = (0, import_ssz7.fromHexString)(
+  depositMsgVal.pubkey = (0, import_ssz8.fromHexString)(msg.pubkey);
+  depositMsgVal.withdrawal_credentials = (0, import_ssz8.fromHexString)(
     msg.withdrawal_credentials
   );
   depositMsgVal.amount = parseInt(msg.amount);
@@ -14776,16 +14964,16 @@ var computeForkDataRoot = (currentVersion, genesisValidatorsRoot) => {
 };
 var computebuilderRegistrationMsgRoot = (msg) => {
   const builderRegistrationMsgVal = builderRegistrationMessageType.defaultValue();
-  builderRegistrationMsgVal.fee_recipient = (0, import_ssz7.fromHexString)(msg.fee_recipient);
+  builderRegistrationMsgVal.fee_recipient = (0, import_ssz8.fromHexString)(msg.fee_recipient);
   builderRegistrationMsgVal.gas_limit = msg.gas_limit;
   builderRegistrationMsgVal.timestamp = msg.timestamp;
-  builderRegistrationMsgVal.pubkey = (0, import_ssz7.fromHexString)(msg.pubkey);
+  builderRegistrationMsgVal.pubkey = (0, import_ssz8.fromHexString)(msg.pubkey);
   return Buffer.from(
     builderRegistrationMessageType.hashTreeRoot(builderRegistrationMsgVal).buffer
   );
 };
-var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = (0, import_ssz7.fromHexString)(GENESIS_VALIDATOR_ROOT)) => {
-  const forkVersion = (0, import_ssz7.fromHexString)(
+var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = (0, import_ssz8.fromHexString)(GENESIS_VALIDATOR_ROOT)) => {
+  const forkVersion = (0, import_ssz8.fromHexString)(
     lockForkVersion.substring(2, lockForkVersion.length)
   );
   const forkDataRoot = computeForkDataRoot(forkVersion, genesisValidatorsRoot);
@@ -14794,10 +14982,10 @@ var computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = (0, im
   domain.set(forkDataRoot.subarray(0, 28), 4);
   return domain;
 };
-var depositDomainForFork = (forkVersion) => computeDomain((0, import_ssz7.fromHexString)(DOMAIN_DEPOSIT), forkVersion);
-var builderDomainForFork = (forkVersion) => computeDomain((0, import_ssz7.fromHexString)(DOMAIN_APPLICATION_BUILDER), forkVersion);
+var depositDomainForFork = (forkVersion) => computeDomain((0, import_ssz8.fromHexString)(DOMAIN_DEPOSIT), forkVersion);
+var builderDomainForFork = (forkVersion) => computeDomain((0, import_ssz8.fromHexString)(DOMAIN_APPLICATION_BUILDER), forkVersion);
 var validateDepositDataStructure = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding, precomputedDepositDomain) => {
-  const depositDomain = precomputedDepositDomain != null ? precomputedDepositDomain : computeDomain((0, import_ssz7.fromHexString)(DOMAIN_DEPOSIT), forkVersion);
+  const depositDomain = precomputedDepositDomain != null ? precomputedDepositDomain : computeDomain((0, import_ssz8.fromHexString)(DOMAIN_DEPOSIT), forkVersion);
   const withdrawalPrefix = compounding ? "0x02" : "0x01";
   const expectedWithdrawalCredentials = withdrawalPrefix + "0".repeat(22) + withdrawalAddress.toLowerCase().slice(2);
   if (expectedWithdrawalCredentials !== depositData.withdrawal_credentials) {
@@ -14824,9 +15012,9 @@ var depositBlsCheck = (distributedPublicKey, depositData, withdrawalAddress, for
   );
   if (!valid || !depositData.signature || !depositData.pubkey) return null;
   return {
-    pubkey: (0, import_ssz7.fromHexString)(depositData.pubkey),
+    pubkey: (0, import_ssz8.fromHexString)(depositData.pubkey),
     message: message2,
-    signature: (0, import_ssz7.fromHexString)(depositData.signature)
+    signature: (0, import_ssz8.fromHexString)(depositData.signature)
   };
 };
 var verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, forkVersion, compounding) => {
@@ -14841,15 +15029,15 @@ var verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, f
     return { isValidDepositData: false, depositDataMsg: message2 };
   }
   const isValidDepositData = blsVerify(
-    (0, import_ssz7.fromHexString)(depositData.pubkey),
+    (0, import_ssz8.fromHexString)(depositData.pubkey),
     message2,
-    (0, import_ssz7.fromHexString)(depositData.signature)
+    (0, import_ssz8.fromHexString)(depositData.signature)
   );
   return { isValidDepositData, depositDataMsg: message2 };
 };
 var verifyBuilderRegistration = (validator, feeRecipientAddress, forkVersion, precomputedBuilderDomain) => {
   var _a6;
-  const builderDomain = precomputedBuilderDomain != null ? precomputedBuilderDomain : computeDomain((0, import_ssz7.fromHexString)(DOMAIN_APPLICATION_BUILDER), forkVersion);
+  const builderDomain = precomputedBuilderDomain != null ? precomputedBuilderDomain : computeDomain((0, import_ssz8.fromHexString)(DOMAIN_APPLICATION_BUILDER), forkVersion);
   if (validator.distributed_public_key !== ((_a6 = validator.builder_registration) == null ? void 0 : _a6.message.pubkey)) {
     return {
       isValidBuilderRegistration: false,
@@ -14885,9 +15073,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: (0, import_ssz7.fromHexString)(validator.distributed_public_key),
+    pubkey: (0, import_ssz8.fromHexString)(validator.distributed_public_key),
     message: builderRegistrationMsg,
-    signature: (0, import_ssz7.fromHexString)(sig)
+    signature: (0, import_ssz8.fromHexString)(sig)
   };
 };
 var verifyNodeSignatures = (clusterLock) => {
@@ -14929,6 +15117,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) => {
@@ -18628,7 +18819,7 @@ var Incentives = class {
 
 // src/exits/exit.ts
 var elliptic2 = __toESM(require("elliptic"));
-var import_ssz9 = require("@chainsafe/ssz");
+var import_ssz10 = require("@chainsafe/ssz");
 
 // src/exits/ethUtils.ts
 function getCapellaFork(fork_version) {
@@ -18665,15 +18856,15 @@ function getGenesisValidatorsRoot(beaconNodeApiUrl) {
 }
 
 // src/exits/verificationHelpers.ts
-var import_ssz8 = require("@chainsafe/ssz");
+var import_ssz9 = require("@chainsafe/ssz");
 var GENESIS_VALIDATOR_ROOT_HEX_STRING = "0x0000000000000000000000000000000000000000000000000000000000000000";
-var ForkDataType = new import_ssz8.ContainerType({
-  currentVersion: new import_ssz8.ByteVectorType(4),
-  genesisValidatorsRoot: new import_ssz8.ByteVectorType(32)
+var ForkDataType = new import_ssz9.ContainerType({
+  currentVersion: new import_ssz9.ByteVectorType(4),
+  genesisValidatorsRoot: new import_ssz9.ByteVectorType(32)
 });
-var SigningRootType = new import_ssz8.ContainerType({
-  objectRoot: new import_ssz8.ByteVectorType(32),
-  domain: new import_ssz8.ByteVectorType(32)
+var SigningRootType = new import_ssz9.ContainerType({
+  objectRoot: new import_ssz9.ByteVectorType(32),
+  domain: new import_ssz9.ByteVectorType(32)
 });
 function computeForkDataRoot2(currentVersion, genesisValidatorsRoot) {
   const forkDataVal = ForkDataType.defaultValue();
@@ -18682,7 +18873,7 @@ function computeForkDataRoot2(currentVersion, genesisValidatorsRoot) {
   return Buffer.from(ForkDataType.hashTreeRoot(forkDataVal).buffer);
 }
 function computeDomain2(domainType, forkVersionString, genesisValidatorsRootOverride) {
-  const forkVersionBytes = (0, import_ssz8.fromHexString)(
+  const forkVersionBytes = (0, import_ssz9.fromHexString)(
     forkVersionString.substring(2, forkVersionString.length)
   );
   if (forkVersionBytes.length !== 4) {
@@ -18691,7 +18882,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_ssz8.fromHexString)(GENESIS_VALIDATOR_ROOT_HEX_STRING.substring(2));
+  const actualGenesisValidatorsRoot = genesisValidatorsRootOverride != null ? genesisValidatorsRootOverride : (0, import_ssz9.fromHexString)(GENESIS_VALIDATOR_ROOT_HEX_STRING.substring(2));
   if (actualGenesisValidatorsRoot.length !== 32) {
     throw new Error("genesisValidatorsRoot must be 32 bytes");
   }
@@ -18723,25 +18914,25 @@ function signingRoot2(domain, messageBuffer) {
 
 // src/exits/exit.ts
 var DOMAIN_VOLUNTARY_EXIT = "0x04000000";
-var SSZExitMessageType = new import_ssz9.ContainerType({
-  epoch: new import_ssz9.UintNumberType(8),
-  validator_index: new import_ssz9.UintNumberType(8)
+var SSZExitMessageType = new import_ssz10.ContainerType({
+  epoch: new import_ssz10.UintNumberType(8),
+  validator_index: new import_ssz10.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)
+var SSZPartialExitsPayloadType = new import_ssz10.ContainerType({
+  partial_exits: new import_ssz10.ListCompositeType(
+    new import_ssz10.ContainerType({
+      public_key: new import_ssz10.ByteVectorType(48),
+      signed_exit_message: new import_ssz10.ContainerType({
+        message: new import_ssz10.ContainerType({
+          epoch: new import_ssz10.UintNumberType(8),
+          validator_index: new import_ssz10.UintNumberType(8)
         }),
-        signature: new import_ssz9.ByteVectorType(96)
+        signature: new import_ssz10.ByteVectorType(96)
       })
     }),
     65536
   ),
-  share_idx: new import_ssz9.UintNumberType(8)
+  share_idx: new import_ssz10.UintNumberType(8)
 });
 var Exit = class _Exit {
   /**
@@ -18784,7 +18975,7 @@ var Exit = class _Exit {
   static computeExitPayloadRoot(exits) {
     const sszValue = SSZPartialExitsPayloadType.defaultValue();
     sszValue.partial_exits = exits.partial_exits.map((pe) => ({
-      public_key: (0, import_ssz9.fromHexString)(pe.public_key),
+      public_key: (0, import_ssz10.fromHexString)(pe.public_key),
       signed_exit_message: {
         message: {
           epoch: _Exit.safeParseInt(pe.signed_exit_message.message.epoch),
@@ -18792,7 +18983,7 @@ var Exit = class _Exit {
             pe.signed_exit_message.message.validator_index
           )
         },
-        signature: (0, import_ssz9.fromHexString)(pe.signed_exit_message.signature)
+        signature: (0, import_ssz10.fromHexString)(pe.signed_exit_message.signature)
       }
     }));
     sszValue.share_idx = exits.share_idx;
@@ -18842,18 +19033,18 @@ var Exit = class _Exit {
         signedExitMessage.message
       );
       const exitDomain = computeDomain2(
-        (0, import_ssz9.fromHexString)(DOMAIN_VOLUNTARY_EXIT),
+        (0, import_ssz10.fromHexString)(DOMAIN_VOLUNTARY_EXIT),
         capellaForkVersionString,
-        (0, import_ssz9.fromHexString)(genesisValidatorsRootString)
+        (0, import_ssz10.fromHexString)(genesisValidatorsRootString)
       );
       const messageSigningRoot = signingRoot2(
         exitDomain,
         partialExitMessageBuffer
       );
       return blsVerify(
-        (0, import_ssz9.fromHexString)(publicShareKey),
+        (0, import_ssz10.fromHexString)(publicShareKey),
         messageSigningRoot,
-        (0, import_ssz9.fromHexString)(signedExitMessage.signature)
+        (0, import_ssz10.fromHexString)(signedExitMessage.signature)
       );
     });
   }
@@ -19156,7 +19347,7 @@ var Exit = class _Exit {
           );
         }
         try {
-          const sigBytes = (0, import_ssz9.fromHexString)(cleanSigStr);
+          const sigBytes = (0, import_ssz10.fromHexString)(cleanSigStr);
           const sigIdx = parseInt(sigIdxStr, 10);
           signaturesByIndex.set(sigIdx + 1, sigBytes);
         } catch (err) {
@@ -20390,7 +20581,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,
    * );
    * ```