@obolnetwork/obol-sdk 2.12.6 → 2.13.0

package/dist/cjs/src/verification/clusterLockValidationWorker.js

@@ -124,7 +124,7 @@ var ClusterLockValidationTimeoutError = class _ClusterLockValidationTimeoutError
 };
 
 // src/verification/common.ts
-var import_ssz7 = require("@chainsafe/ssz");
+var import_ssz8 = require("@chainsafe/ssz");
 var import_elliptic = __toESM(require("elliptic"));
 
 // src/types.ts
@@ -154,7 +154,7 @@ var import_ethers = require("ethers");
 // 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"
@@ -575,10 +575,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)
@@ -586,9 +601,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),
@@ -14343,6 +14364,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;
@@ -14367,6 +14547,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) => {
@@ -14392,6 +14577,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* () {
@@ -14491,8 +14679,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);
@@ -14506,16 +14694,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);
@@ -14524,10 +14712,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) {
@@ -14554,14 +14742,14 @@ 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 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,
@@ -14597,9 +14785,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) => {
@@ -14641,6 +14829,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) => {