@obolnetwork/obol-sdk 1.0.12 → 1.0.14

package/dist/esm/src/{verify.js → verification/common.js}

@@ -7,72 +7,66 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import * as semver from 'semver';
-import { init, aggregateSignatures, verifyMultiple, verifyAggregate } from "@chainsafe/bls";
-import { ENR } from '@chainsafe/discv5';
-import { ByteVectorType, ContainerType, fromHexString } from '@chainsafe/ssz';
-import { UintNumberType } from '@chainsafe/ssz/lib/type/uint.js';
-import { SignTypedDataVersion, TypedDataUtils, } from '@metamask/eth-sig-util';
+import { fromHexString, } from '@chainsafe/ssz';
 import elliptic from 'elliptic';
+import { init, } from '@chainsafe/bls';
+import { FORK_MAPPING } from '../types.js';
+import * as semver from 'semver';
+import { clusterDefinitionContainerTypeV1X6, hashClusterDefinitionV1X6, hashClusterLockV1X6, verifyDVV1X6 } from './v1.6.0.js';
+import { clusterDefinitionContainerTypeV1X7, hashClusterDefinitionV1X7, hashClusterLockV1X7, verifyDVV1X7 } from './v1.7.0.js';
 import { ethers } from 'ethers';
-import { FORK_MAPPING } from "./types.js";
-import { clusterConfigOrDefinitionHash, clusterLockHash } from './hash.js';
-import { DOMAIN_APPLICATION_BUILDER, DOMAIN_DEPOSIT, DefinitionFlow, GENESIS_VALIDATOR_ROOT, signCreatorConfigHashPayload, signEnrPayload, signOperatorConfigHashPayload } from './constants.js';
-import { hexWithout0x } from './utils.js';
-const builderRegistrationMessageType = new ContainerType({
-    fee_recipient: new ByteVectorType(20),
-    gas_limit: new UintNumberType(8),
-    timestamp: new UintNumberType(8),
-    pubkey: new ByteVectorType(48),
-});
-//For domain computation that is used in deposit data and builder registration verification for dv
-const forkDataType = new ContainerType({
-    currentVersion: new ByteVectorType(4),
-    genesisValidatorsRoot: new ByteVectorType(32),
-});
-const depositMessageType = new ContainerType({
-    pubkey: new ByteVectorType(48),
-    withdrawal_credentials: new ByteVectorType(32),
-    amount: new UintNumberType(8),
-});
-const signingRootType = new ContainerType({
-    objectRoot: new ByteVectorType(32),
-    domain: new ByteVectorType(32),
-});
-const definitionFlow = (clusterDefinition) => {
-    if (clusterDefinition.creator.address &&
-        clusterDefinition.creator.config_signature &&
-        clusterDefinition.operators.every(operator => {
-            return (operator.address &&
-                operator.config_signature &&
-                operator.enr &&
-                operator.enr_signature);
-        })) {
-        return DefinitionFlow.Group;
+import { DOMAIN_APPLICATION_BUILDER, DOMAIN_DEPOSIT, DefinitionFlow, GENESIS_VALIDATOR_ROOT, signCreatorConfigHashPayload, signEnrPayload, signOperatorConfigHashPayload } from '../constants.js';
+import { SignTypedDataVersion, TypedDataUtils } from '@metamask/eth-sig-util';
+import { builderRegistrationMessageType, depositMessageType, forkDataType, signingRootType } from './sszTypes.js';
+import { definitionFlow, hexWithout0x } from '../utils.js';
+import { ENR } from '@chainsafe/discv5';
+import { clusterDefinitionContainerTypeV1X8, hashClusterDefinitionV1X8, hashClusterLockV1X8, verifyDVV1X8 } from './v1.8.0.js';
+// cluster-definition hash
+/**
+ * @param cluster The cluster configuration or the cluster definition
+ * @param configOnly a boolean to indicate config hash or definition hash
+ * @returns The config hash or the definition hash in of the corresponding cluster
+ */
+export const clusterConfigOrDefinitionHash = (cluster, configOnly) => {
+    let definitionType, val;
+    if (semver.eq(cluster.version, 'v1.6.0')) {
+        definitionType = clusterDefinitionContainerTypeV1X6(configOnly);
+        val = hashClusterDefinitionV1X6(cluster, configOnly);
+        return ('0x' + Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex'));
+    }
+    if (semver.eq(cluster.version, 'v1.7.0')) {
+        definitionType = clusterDefinitionContainerTypeV1X7(configOnly);
+        val = hashClusterDefinitionV1X7(cluster, configOnly);
+        return ('0x' + Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex'));
+    }
+    if (semver.eq(cluster.version, 'v1.8.0')) {
+        definitionType = clusterDefinitionContainerTypeV1X8(configOnly);
+        val = hashClusterDefinitionV1X8(cluster, configOnly);
+        return ('0x' + Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex'));
     }
-    else if (clusterDefinition.creator.address &&
-        clusterDefinition.creator.config_signature &&
-        clusterDefinition.operators.every(operator => {
-            return (!operator.address &&
-                !operator.config_signature &&
-                operator.enr &&
-                !operator.enr_signature);
-        })) {
-        return DefinitionFlow.Solo;
+    throw new Error('unsupported version');
+};
+// cluster-lock hash
+/**
+ * Returns the SSZ cluster lock hash of the given cluster lock object
+ * @param cluster The cluster lock whose lock hash needs to be calculated
+ * @returns The cluster lock hash in of the corresponding cluster lock
+ */
+export const clusterLockHash = (clusterLock) => {
+    if (semver.eq(clusterLock.cluster_definition.version, 'v1.6.0')) {
+        return hashClusterLockV1X6(clusterLock);
+    }
+    if (semver.eq(clusterLock.cluster_definition.version, 'v1.7.0')) {
+        return hashClusterLockV1X7(clusterLock);
     }
-    else if (!clusterDefinition.creator.address &&
-        !clusterDefinition.creator.config_signature &&
-        clusterDefinition.operators.every(operator => {
-            return (!operator.address &&
-                !operator.config_signature &&
-                operator.enr &&
-                !operator.enr_signature);
-        })) {
-        return DefinitionFlow.Charon;
+    if (semver.eq(clusterLock.cluster_definition.version, 'v1.8.0')) {
+        return hashClusterLockV1X8(clusterLock);
     }
-    return null;
+    // other versions
+    throw new Error('unsupported version');
 };
-//cluster-definition signatures verificatin
+// Lock verification
+// cluster-definition signatures verification
 const getPOSTConfigHashSigner = (signature, configHash, chainId) => {
     try {
         const sig = ethers.Signature.from(signature);
@@ -107,7 +101,7 @@ const getEnrSigner = (signature, payload, chainId) => {
     }
 };
 const verifyDefinitionSignatures = (clusterDefinition, definitionType) => {
-    if (definitionType === 'Charon-Command') {
+    if (definitionType === DefinitionFlow.Charon) {
         return true;
     }
     else {
@@ -115,10 +109,10 @@ const verifyDefinitionSignatures = (clusterDefinition, definitionType) => {
         if (configSigner !== clusterDefinition.creator.address.toLowerCase()) {
             return false;
         }
-        if (definitionType === 'LP-Solo') {
+        if (definitionType === DefinitionFlow.Solo) {
             return true;
         }
-        return clusterDefinition.operators.every(operator => {
+        return clusterDefinition.operators.every((operator) => {
             const configSigner = getPUTConfigHashSigner(operator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version]);
             const enrSigner = getEnrSigner(operator.enr_signature, operator.enr, FORK_MAPPING[clusterDefinition.fork_version]);
             if (configSigner !== operator.address.toLowerCase() ||
@@ -129,12 +123,12 @@ const verifyDefinitionSignatures = (clusterDefinition, definitionType) => {
         });
     }
 };
-//cluster-lock data verification 
+// cluster-lock data verification
 const computeSigningRoot = (sszObjectRoot, domain) => {
-    const val1 = signingRootType.defaultValue();
-    val1.objectRoot = sszObjectRoot;
-    val1.domain = domain;
-    return Buffer.from(signingRootType.hashTreeRoot(val1).buffer);
+    const signingRootDefaultValue = signingRootType.defaultValue();
+    signingRootDefaultValue.objectRoot = sszObjectRoot;
+    signingRootDefaultValue.domain = domain;
+    return Buffer.from(signingRootType.hashTreeRoot(signingRootDefaultValue).buffer);
 };
 const computeDepositMsgRoot = (msg) => {
     const depositMsgVal = depositMessageType.defaultValue();
@@ -158,7 +152,6 @@ const computebuilderRegistrationMsgRoot = (msg) => {
     return Buffer.from(builderRegistrationMessageType.hashTreeRoot(builderRegistrationMsgVal)
         .buffer);
 };
-// DV data verification
 const computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = fromHexString(GENESIS_VALIDATOR_ROOT)) => {
     const forkVersion = fromHexString(lockForkVersion.substring(2, lockForkVersion.length));
     const forkDataRoot = computeForkDataRoot(forkVersion, genesisValidatorsRoot);
@@ -167,27 +160,61 @@ const computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = from
     domain.set(forkDataRoot.subarray(0, 28), 4);
     return domain;
 };
-const verifyDepositData = (validator, withdrawalAddress) => {
+/**
+ * Verify deposit data withdrawal credintials and signature
+ * @param {string} forkVersion - fork version in definition file.
+ * @param {DistributedValidatorDto} validator - distributed validator.
+ * @param {string} withdrawalAddress - withdrawal address in definition file.
+ * @returns {boolean} - return if deposit data is valid.
+ */
+export const verifyDepositData = (distributedPublicKey, depositData, withdrawalAddress, forkVersion) => {
+    const depositDomain = computeDomain(fromHexString(DOMAIN_DEPOSIT), forkVersion);
     const eth1AddressWithdrawalPrefix = '0x01';
     if (eth1AddressWithdrawalPrefix +
         '0'.repeat(22) +
         withdrawalAddress.toLowerCase().slice(2) !==
-        validator.deposit_data.withdrawal_credentials) {
-        return false;
+        depositData.withdrawal_credentials) {
+        return { isValidDepositData: false, depositDataMsg: new Uint8Array(0) };
     }
-    if (validator.distributed_public_key !== validator.deposit_data.pubkey) {
-        return false;
+    if (distributedPublicKey !== depositData.pubkey) {
+        return { isValidDepositData: false, depositDataMsg: new Uint8Array(0) };
     }
-    return true;
+    const depositMessageBuffer = computeDepositMsgRoot(depositData);
+    const depositDataMessage = signingRoot(depositDomain, depositMessageBuffer);
+    return { isValidDepositData: true, depositDataMsg: depositDataMessage };
 };
-const verifyBuilderRegistration = (validator, feeRecipientAddress) => {
+export const verifyBuilderRegistration = (validator, feeRecipientAddress, forkVersion) => {
+    var _a;
+    const builderDomain = computeDomain(fromHexString(DOMAIN_APPLICATION_BUILDER), forkVersion);
     if (validator.distributed_public_key !==
-        validator.builder_registration.message.pubkey) {
-        return false;
+        ((_a = validator.builder_registration) === null || _a === void 0 ? void 0 : _a.message.pubkey)) {
+        return { isValidBuilderRegistration: false, builderRegistrationMsg: new Uint8Array(0) };
     }
     if (feeRecipientAddress.toLowerCase() !==
         validator.builder_registration.message.fee_recipient.toLowerCase()) {
-        return false;
+        return { isValidBuilderRegistration: false, builderRegistrationMsg: new Uint8Array(0) };
+    }
+    const builderRegistrationMessageBuffer = computebuilderRegistrationMsgRoot(validator.builder_registration.message);
+    const builderRegistrationMessage = signingRoot(builderDomain, builderRegistrationMessageBuffer);
+    return { isValidBuilderRegistration: true, builderRegistrationMsg: builderRegistrationMessage };
+};
+export const verifyNodeSignatures = (clusterLock) => {
+    const ec = new elliptic.ec('secp256k1');
+    const nodeSignatures = clusterLock.node_signatures;
+    const lockHashWithout0x = hexWithout0x(clusterLock.lock_hash);
+    // node(ENR) signatures
+    for (let i = 0; i < nodeSignatures.length; i++) {
+        const pubkey = ENR.decodeTxt(clusterLock.cluster_definition.operators[i].enr).publicKey.toString('hex');
+        const ENRsignature = {
+            r: nodeSignatures[i].slice(2, 66),
+            s: nodeSignatures[i].slice(66, 130),
+        };
+        const nodeSignatureVerification = ec
+            .keyFromPublic(pubkey, 'hex')
+            .verify(lockHashWithout0x, ENRsignature);
+        if (!nodeSignatureVerification) {
+            return false;
+        }
     }
     return true;
 };
@@ -195,81 +222,22 @@ export const signingRoot = (domain, messageBuffer) => {
     return computeSigningRoot(messageBuffer, domain);
 };
 const verifyLockData = (clusterLock) => __awaiter(void 0, void 0, void 0, function* () {
-    const ec = new elliptic.ec('secp256k1');
-    const validators = clusterLock.distributed_validators;
-    const nodeSignatures = clusterLock.node_signatures;
-    const depositDomain = computeDomain(fromHexString(DOMAIN_DEPOSIT), clusterLock.cluster_definition.fork_version);
-    const builderDomain = computeDomain(fromHexString(DOMAIN_APPLICATION_BUILDER), clusterLock.cluster_definition.fork_version);
-    const pubShares = [];
-    const pubKeys = [];
-    const builderRegistrationAndDepositDataMessages = [];
-    const blsSignatures = [];
     yield init('herumi');
-    for (let i = 0; i < validators.length; i++) {
-        const validator = validators[i];
-        const validatorPublicShares = validator['public_shares'];
-        for (const element of validatorPublicShares) {
-            pubShares.push(fromHexString(element));
-        }
-        //Deposit data signature
-        if (semver.gte(clusterLock.cluster_definition.version, 'v1.6.0')) {
-            if (!verifyDepositData(validator, clusterLock.cluster_definition.validators[i].withdrawal_address)) {
-                return false;
-            }
-            const depositMessageBuffer = computeDepositMsgRoot(validator.deposit_data);
-            const depositDataMessage = signingRoot(depositDomain, depositMessageBuffer);
-            pubKeys.push(fromHexString(validator.distributed_public_key));
-            builderRegistrationAndDepositDataMessages.push(depositDataMessage);
-            blsSignatures.push(fromHexString(validator.deposit_data.signature));
-        }
-        //Builder registration signature
-        if (semver.gte(clusterLock.cluster_definition.version, 'v1.7.0')) {
-            if (!verifyBuilderRegistration(validator, clusterLock.cluster_definition.validators[i].fee_recipient_address)) {
-                return false;
-            }
-            const builderRegistrationMessageBuffer = computebuilderRegistrationMsgRoot(validator.builder_registration.message);
-            const builderRegistrationMessage = signingRoot(builderDomain, builderRegistrationMessageBuffer);
-            pubKeys.push(fromHexString(validator.distributed_public_key));
-            builderRegistrationAndDepositDataMessages.push(builderRegistrationMessage);
-            blsSignatures.push(fromHexString(validator.builder_registration.signature));
-        }
-    }
-    if (blsSignatures.length &&
-        pubKeys.length &&
-        builderRegistrationAndDepositDataMessages.length) {
-        // verify all deposit data and builder registration bls signatures
-        const aggregateBLSSignature = aggregateSignatures(blsSignatures);
-        if (!verifyMultiple(pubKeys, builderRegistrationAndDepositDataMessages, aggregateBLSSignature)) {
-            return false;
-        }
+    if (semver.eq(clusterLock.cluster_definition.version, 'v1.6.0')) {
+        return verifyDVV1X6(clusterLock);
     }
-    if (semver.gte(clusterLock.cluster_definition.version, 'v1.7.0')) {
-        const lockHashWithout0x = hexWithout0x(clusterLock.lock_hash);
-        //node(ENR) signatures
-        for (let i = 0; i < nodeSignatures.length; i++) {
-            const pubkey = ENR.decodeTxt(clusterLock.cluster_definition.operators[i].enr).publicKey.toString('hex');
-            const ENRsignature = {
-                r: nodeSignatures[i].slice(2, 66),
-                s: nodeSignatures[i].slice(66, 130),
-            };
-            const nodeSignatureVerification = ec
-                .keyFromPublic(pubkey, 'hex')
-                .verify(lockHashWithout0x, ENRsignature);
-            if (!nodeSignatureVerification) {
-                return false;
-            }
-        }
+    if (semver.eq(clusterLock.cluster_definition.version, 'v1.7.0')) {
+        return verifyDVV1X7(clusterLock);
     }
-    //signature aggregate
-    if (!verifyAggregate(pubShares, fromHexString(clusterLock.lock_hash), fromHexString(clusterLock.signature_aggregate))) {
-        return false;
+    if (semver.eq(clusterLock.cluster_definition.version, 'v1.8.0')) {
+        return verifyDVV1X8(clusterLock);
     }
-    return true;
+    return false;
 });
 export const isValidClusterLock = (clusterLock) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const definitionType = definitionFlow(clusterLock.cluster_definition);
-        if (!definitionType) {
+        if (definitionType == null) {
             return false;
         }
         const isValidDefinitionData = verifyDefinitionSignatures(clusterLock.cluster_definition, definitionType);

package/dist/esm/src/verification/sszTypes.js

@@ -0,0 +1,64 @@
+import { ByteListType, ByteVectorType, ContainerType, UintNumberType } from '@chainsafe/ssz';
+export const operatorAddressWrapperType = new ContainerType({
+    address: new ByteVectorType(20),
+});
+export const creatorAddressWrapperType = new ContainerType({
+    address: new ByteVectorType(20),
+});
+export const operatorContainerType = 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: new ByteVectorType(65),
+    enr_signature: new ByteVectorType(65),
+});
+export const creatorContainerType = new ContainerType({
+    address: new ByteVectorType(20),
+    config_signature: new ByteVectorType(65),
+});
+export const validatorsContainerType = new ContainerType({
+    fee_recipient_address: new ByteVectorType(20),
+    withdrawal_address: new ByteVectorType(20),
+});
+export const newCreatorContainerType = (configOnly) => {
+    return configOnly ? creatorAddressWrapperType : creatorContainerType;
+};
+export const newOperatorContainerType = (configOnly) => {
+    return configOnly ? operatorAddressWrapperType : operatorContainerType;
+};
+// Lock
+export const depositDataContainer = new ContainerType({
+    pubkey: new ByteVectorType(48),
+    withdrawal_credentials: new ByteVectorType(32),
+    amount: new UintNumberType(8),
+    signature: new ByteVectorType(96),
+});
+export const builderRegistrationMessageContainer = new ContainerType({
+    fee_recipient: new ByteVectorType(20),
+    gas_limit: new UintNumberType(8),
+    timestamp: new UintNumberType(8),
+    pubkey: new ByteVectorType(48),
+});
+export const builderRegistrationContainer = new ContainerType({
+    message: builderRegistrationMessageContainer,
+    signature: new ByteVectorType(96),
+});
+export const builderRegistrationMessageType = new ContainerType({
+    fee_recipient: new ByteVectorType(20),
+    gas_limit: new UintNumberType(8),
+    timestamp: new UintNumberType(8),
+    pubkey: new ByteVectorType(48),
+});
+// For domain computation that is used in deposit data and builder registration verification for dv
+export const forkDataType = new ContainerType({
+    currentVersion: new ByteVectorType(4),
+    genesisValidatorsRoot: new ByteVectorType(32),
+});
+export const depositMessageType = new ContainerType({
+    pubkey: new ByteVectorType(48),
+    withdrawal_credentials: new ByteVectorType(32),
+    amount: new UintNumberType(8),
+});
+export const signingRootType = new ContainerType({
+    objectRoot: new ByteVectorType(32),
+    domain: new ByteVectorType(32),
+});

package/dist/esm/src/verification/v1.6.0.js

@@ -0,0 +1,142 @@
+import { UintNumberType } from '@chainsafe/ssz/lib/type/uint';
+import { strToUint8Array } from '../utils';
+import { newCreatorContainerType, newOperatorContainerType, validatorsContainerType } from './sszTypes';
+import { ByteListType, ByteVectorType, ContainerType, ListCompositeType, fromHexString } from '@chainsafe/ssz';
+import { verifyDepositData } from './common';
+import { aggregateSignatures, verifyAggregate, verifyMultiple } from '@chainsafe/bls';
+/**
+ * Returns the containerized cluster definition
+ * @param cluster ClusterDefinition to calculate the type from
+ * @returns SSZ Containerized type of cluster input
+ */
+export const clusterDefinitionContainerTypeV1X6 = (configOnly) => {
+    let returnedContainerType = {
+        uuid: new ByteListType(64),
+        name: new ByteListType(256),
+        version: new ByteListType(16),
+        timestamp: new ByteListType(32),
+        num_validators: new UintNumberType(8),
+        threshold: new UintNumberType(8),
+        dkg_algorithm: new ByteListType(32),
+        fork_version: new ByteVectorType(4),
+        operators: new ListCompositeType(newOperatorContainerType(configOnly), 256),
+        creator: newCreatorContainerType(configOnly),
+        validators: new ListCompositeType(validatorsContainerType, 65536),
+    };
+    if (!configOnly) {
+        returnedContainerType = Object.assign(Object.assign({}, returnedContainerType), { config_hash: new ByteVectorType(32) });
+    }
+    return new ContainerType(returnedContainerType);
+};
+export const hashClusterDefinitionV1X6 = (cluster, configOnly) => {
+    const definitionType = clusterDefinitionContainerTypeV1X6(configOnly);
+    const val = definitionType.defaultValue();
+    // order should be same as charon https://github.com/ObolNetwork/charon/blob/main/cluster/ssz.go#L276
+    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 = fromHexString(cluster.fork_version);
+    val.operators = cluster.operators.map(operator => {
+        return configOnly
+            ? { address: fromHexString(operator.address) }
+            : {
+                address: fromHexString(operator.address),
+                enr: strToUint8Array(operator.enr),
+                config_signature: fromHexString(operator.config_signature),
+                enr_signature: fromHexString(operator.enr_signature),
+            };
+    });
+    val.creator = configOnly
+        ? { address: fromHexString(cluster.creator.address) }
+        : {
+            address: fromHexString(cluster.creator.address),
+            config_signature: fromHexString(cluster.creator.config_signature),
+        };
+    val.validators = cluster.validators.map((validator) => {
+        return {
+            fee_recipient_address: fromHexString(validator.fee_recipient_address),
+            withdrawal_address: fromHexString(validator.withdrawal_address),
+        };
+    });
+    if (!configOnly) {
+        val.config_hash = fromHexString(cluster.config_hash);
+    }
+    return val;
+};
+// cluster lock
+const dvContainerTypeV1X6 = new ContainerType({
+    distributed_public_key: new ByteVectorType(48),
+    public_shares: new ListCompositeType(new ByteVectorType(48), 256),
+    pubkey: new ByteVectorType(48),
+    withdrawal_credentials: new ByteVectorType(32),
+    amount: new UintNumberType(8),
+    signature: new ByteVectorType(96),
+});
+/**
+ * @returns SSZ Containerized type of cluster lock
+ */
+const clusterLockContainerTypeV1X6 = () => {
+    return new ContainerType({
+        cluster_definition: clusterDefinitionContainerTypeV1X6(false),
+        distributed_validators: new ListCompositeType(dvContainerTypeV1X6, 65536),
+    });
+};
+/**
+ * @param cluster The published cluster lock
+ * @returns The lock hash in of the corresponding cluster
+ */
+export const hashClusterLockV1X6 = (cluster) => {
+    const lockType = clusterLockContainerTypeV1X6();
+    const val = lockType.defaultValue();
+    // Check if we can replace with definition_hash
+    val.cluster_definition = hashClusterDefinitionV1X6(cluster.cluster_definition, false);
+    val.distributed_validators = cluster.distributed_validators.map(dValidator => {
+        var _a, _b, _c, _d;
+        return {
+            distributed_public_key: fromHexString(dValidator.distributed_public_key),
+            public_shares: dValidator.public_shares.map(publicShare => fromHexString(publicShare)),
+            pubkey: fromHexString((_a = dValidator.deposit_data) === null || _a === void 0 ? void 0 : _a.pubkey),
+            withdrawal_credentials: fromHexString((_b = dValidator.deposit_data) === null || _b === void 0 ? void 0 : _b.withdrawal_credentials),
+            amount: parseInt((_c = dValidator.deposit_data) === null || _c === void 0 ? void 0 : _c.amount),
+            signature: fromHexString((_d = dValidator.deposit_data) === null || _d === void 0 ? void 0 : _d.signature),
+        };
+    });
+    return '0x' + Buffer.from(lockType.hashTreeRoot(val).buffer).toString('hex');
+};
+// DV verification
+export const verifyDVV1X6 = (clusterLock) => {
+    var _a;
+    const validators = clusterLock.distributed_validators;
+    const pubShares = [];
+    const pubKeys = [];
+    const builderRegistrationAndDepositDataMessages = [];
+    const blsSignatures = [];
+    for (let i = 0; i < validators.length; i++) {
+        const validator = validators[i];
+        const validatorPublicShares = validator.public_shares;
+        const distributedPublicKey = validator.distributed_public_key;
+        // Needed in signature_aggregate verification
+        for (const element of validatorPublicShares) {
+            pubShares.push(fromHexString(element));
+        }
+        const { isValidDepositData, depositDataMsg } = verifyDepositData(distributedPublicKey, validator.deposit_data, clusterLock.cluster_definition.validators[i].withdrawal_address, clusterLock.cluster_definition.fork_version);
+        if (!isValidDepositData) {
+            return false;
+        }
+        pubKeys.push(fromHexString(validator.distributed_public_key));
+        builderRegistrationAndDepositDataMessages.push(depositDataMsg);
+        blsSignatures.push(fromHexString((_a = validator.deposit_data) === null || _a === void 0 ? void 0 : _a.signature));
+    }
+    const aggregateBLSSignature = aggregateSignatures(blsSignatures);
+    if (!verifyMultiple(pubKeys, builderRegistrationAndDepositDataMessages, aggregateBLSSignature)) {
+        return false;
+    }
+    if (!verifyAggregate(pubShares, fromHexString(clusterLock.lock_hash), fromHexString(clusterLock.signature_aggregate))) {
+        return false;
+    }
+    return true;
+};