@obolnetwork/obol-sdk 2.11.3 → 2.11.5-rc.0

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

@@ -1,319 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-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 { DOMAIN_APPLICATION_BUILDER, DOMAIN_DEPOSIT, DefinitionFlow, GENESIS_VALIDATOR_ROOT, signCreatorConfigHashPayload, signEnrPayload, signOperatorConfigHashPayload, } from '../constants.js';
-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';
-import { validateAddressSignature } from './signature-validator.js';
-import { clusterDefinitionContainerTypeV1X10, hashClusterDefinitionV1X10, hashClusterLockV1X10, verifyDVV1X10, } from './v1.10.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'));
-    }
-    if (semver.eq(cluster.version, 'v1.10.0')) {
-        definitionType = clusterDefinitionContainerTypeV1X10(configOnly);
-        val = hashClusterDefinitionV1X10(cluster, configOnly);
-        const x = '0x' +
-            Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex');
-        return x;
-    }
-    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);
-    }
-    if (semver.eq(clusterLock.cluster_definition.version, 'v1.8.0')) {
-        if (clusterLock.cluster_definition.deposit_amounts === null &&
-            clusterLock.distributed_validators.some(distributedValidator => {
-                var _a;
-                return ((_a = distributedValidator.partial_deposit_data) === null || _a === void 0 ? void 0 : _a.length) !== 1 ||
-                    distributedValidator.partial_deposit_data[0].amount !== '32000000000';
-            })) {
-            throw new Error('mismatch between deposit_amounts and partial_deposit_data fields');
-        }
-        return hashClusterLockV1X8(clusterLock);
-    }
-    if (semver.eq(clusterLock.cluster_definition.version, 'v1.10.0')) {
-        // if (
-        //   clusterLock.cluster_definition.deposit_amounts === null &&
-        //   clusterLock.distributed_validators.some(
-        //     distributedValidator =>
-        //       distributedValidator.partial_deposit_data?.length !== 1 ||
-        //       distributedValidator.partial_deposit_data[0].amount !== '32000000000',
-        //   )
-        // ) {
-        //   throw new Error(
-        //     'mismatch between deposit_amounts and partial_deposit_data fields',
-        //   );
-        // }
-        return hashClusterLockV1X10(clusterLock);
-    }
-    // other versions
-    throw new Error('unsupported version');
-};
-// Lock verification
-// cluster-definition signatures verification
-const validatePOSTConfigHashSigner = (address, signature, configHash, chainId, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const data = signCreatorConfigHashPayload({ creator_config_hash: configHash }, chainId);
-        return yield validateAddressSignature({
-            address,
-            token: signature,
-            data,
-            chainId,
-            safeRpcUrl,
-        });
-    }
-    catch (err) {
-        throw err;
-    }
-});
-const validatePUTConfigHashSigner = (address, signature, configHash, chainId, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const data = signOperatorConfigHashPayload({ operator_config_hash: configHash }, chainId);
-        return yield validateAddressSignature({
-            address,
-            token: signature,
-            data,
-            chainId,
-            safeRpcUrl,
-        });
-    }
-    catch (err) {
-        throw err;
-    }
-});
-const validateEnrSigner = (address, signature, payload, chainId, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const data = signEnrPayload({ enr: payload }, chainId);
-        return yield validateAddressSignature({
-            address,
-            token: signature,
-            data,
-            chainId,
-            safeRpcUrl,
-        });
-    }
-    catch (err) {
-        throw err;
-    }
-});
-const verifyDefinitionSignatures = (clusterDefinition, definitionType, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
-    if (definitionType === DefinitionFlow.Charon) {
-        return true;
-    }
-    else {
-        const isPOSTConfigHashSignerValid = yield validatePOSTConfigHashSigner(clusterDefinition.creator.address, clusterDefinition.creator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version], safeRpcUrl);
-        if (!isPOSTConfigHashSignerValid) {
-            return false;
-        }
-        if (definitionType === DefinitionFlow.Solo) {
-            return true;
-        }
-        for (const operator of clusterDefinition.operators) {
-            const isPUTConfigHashSignerValid = yield validatePUTConfigHashSigner(operator.address, operator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version], safeRpcUrl);
-            const isENRSignerValid = yield validateEnrSigner(operator.address, operator.enr_signature, operator.enr, FORK_MAPPING[clusterDefinition.fork_version], safeRpcUrl);
-            if (!isPUTConfigHashSignerValid || !isENRSignerValid) {
-                return false;
-            }
-        }
-        return true;
-    }
-});
-// cluster-lock data verification
-const computeSigningRoot = (sszObjectRoot, domain) => {
-    const signingRootDefaultValue = signingRootType.defaultValue();
-    signingRootDefaultValue.objectRoot = sszObjectRoot;
-    signingRootDefaultValue.domain = domain;
-    return Buffer.from(signingRootType.hashTreeRoot(signingRootDefaultValue).buffer);
-};
-const computeDepositMsgRoot = (msg) => {
-    const depositMsgVal = depositMessageType.defaultValue();
-    depositMsgVal.pubkey = fromHexString(msg.pubkey);
-    depositMsgVal.withdrawal_credentials = fromHexString(msg.withdrawal_credentials);
-    depositMsgVal.amount = parseInt(msg.amount);
-    return Buffer.from(depositMessageType.hashTreeRoot(depositMsgVal).buffer);
-};
-const computeForkDataRoot = (currentVersion, genesisValidatorsRoot) => {
-    const forkDataVal = forkDataType.defaultValue();
-    forkDataVal.currentVersion = currentVersion;
-    forkDataVal.genesisValidatorsRoot = genesisValidatorsRoot;
-    return Buffer.from(forkDataType.hashTreeRoot(forkDataVal).buffer);
-};
-const computebuilderRegistrationMsgRoot = (msg) => {
-    const builderRegistrationMsgVal = builderRegistrationMessageType.defaultValue();
-    builderRegistrationMsgVal.fee_recipient = fromHexString(msg.fee_recipient);
-    builderRegistrationMsgVal.gas_limit = msg.gas_limit;
-    builderRegistrationMsgVal.timestamp = msg.timestamp;
-    builderRegistrationMsgVal.pubkey = fromHexString(msg.pubkey);
-    return Buffer.from(builderRegistrationMessageType.hashTreeRoot(builderRegistrationMsgVal)
-        .buffer);
-};
-const computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = fromHexString(GENESIS_VALIDATOR_ROOT)) => {
-    const forkVersion = fromHexString(lockForkVersion.substring(2, lockForkVersion.length));
-    const forkDataRoot = computeForkDataRoot(forkVersion, genesisValidatorsRoot);
-    const domain = new Uint8Array(32);
-    domain.set(domainType);
-    domain.set(forkDataRoot.subarray(0, 28), 4);
-    return domain;
-};
-/**
- * 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, compounding) => {
-    const depositDomain = computeDomain(fromHexString(DOMAIN_DEPOSIT), forkVersion);
-    const withdrawalPrefix = compounding ? '0x02' : '0x01';
-    const expectedWithdrawalCredentials = withdrawalPrefix +
-        '0'.repeat(22) +
-        withdrawalAddress.toLowerCase().slice(2);
-    if (expectedWithdrawalCredentials !== depositData.withdrawal_credentials) {
-        return { isValidDepositData: false, depositDataMsg: new Uint8Array(0) };
-    }
-    if (distributedPublicKey !== depositData.pubkey) {
-        return { isValidDepositData: false, depositDataMsg: new Uint8Array(0) };
-    }
-    const depositMessageBuffer = computeDepositMsgRoot(depositData);
-    const depositDataMessage = signingRoot(depositDomain, depositMessageBuffer);
-    return { isValidDepositData: true, depositDataMsg: depositDataMessage };
-};
-export const verifyBuilderRegistration = (validator, feeRecipientAddress, forkVersion) => {
-    var _a;
-    const builderDomain = computeDomain(fromHexString(DOMAIN_APPLICATION_BUILDER), forkVersion);
-    if (validator.distributed_public_key !==
-        ((_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 {
-            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;
-};
-export const signingRoot = (domain, messageBuffer) => {
-    return computeSigningRoot(messageBuffer, domain);
-};
-const verifyLockData = (clusterLock) => __awaiter(void 0, void 0, void 0, function* () {
-    yield init('herumi');
-    if (semver.eq(clusterLock.cluster_definition.version, 'v1.6.0')) {
-        return verifyDVV1X6(clusterLock);
-    }
-    if (semver.eq(clusterLock.cluster_definition.version, 'v1.7.0')) {
-        return verifyDVV1X7(clusterLock);
-    }
-    if (semver.eq(clusterLock.cluster_definition.version, 'v1.8.0')) {
-        return verifyDVV1X8(clusterLock);
-    }
-    if (semver.eq(clusterLock.cluster_definition.version, 'v1.10.0')) {
-        return verifyDVV1X10(clusterLock);
-    }
-    return false;
-});
-export const isValidClusterLock = (clusterLock, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const definitionType = definitionFlow(clusterLock.cluster_definition);
-        if (definitionType == null) {
-            return false;
-        }
-        const isValidDefinitionData = yield verifyDefinitionSignatures(clusterLock.cluster_definition, definitionType, safeRpcUrl);
-        if (!isValidDefinitionData) {
-            return false;
-        }
-        if (clusterConfigOrDefinitionHash(clusterLock.cluster_definition, false) !==
-            clusterLock.cluster_definition.definition_hash) {
-            return false;
-        }
-        if (clusterLockHash(clusterLock) !== clusterLock.lock_hash) {
-            return false;
-        }
-        const isValidLockData = yield verifyLockData(clusterLock);
-        if (!isValidLockData) {
-            return false;
-        }
-        return true;
-    }
-    catch (err) {
-        return false;
-    }
-});

package/dist/esm/src/verification/signature-validator.js

@@ -1,64 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-/* eslint-disable @typescript-eslint/restrict-template-expressions */
-import { ethers } from 'ethers';
-import { SignTypedDataVersion, TypedDataUtils, } from '@metamask/eth-sig-util';
-import Safe from '@safe-global/protocol-kit';
-import { PROVIDER_MAP } from '../constants';
-import { hashTypedData } from '@safe-global/protocol-kit/dist/src/utils';
-import { isContractAvailable, getProvider } from '../utils';
-export const validateAddressSignature = ({ address, token, data, chainId, safeRpcUrl, }) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const provider = getProvider(chainId, safeRpcUrl);
-        if (provider) {
-            const contractAddress = yield isContractAvailable(address, provider);
-            if (contractAddress) {
-                return yield validateSmartContractSignature({
-                    token,
-                    data: data,
-                    address,
-                    chainId,
-                    safeRpcUrl,
-                });
-            }
-        }
-        return validateEOASignature({ token, data, address });
-    }
-    catch (error) {
-        return validateEOASignature({ token, data, address });
-    }
-});
-export const validateEOASignature = ({ token, data, address, }) => {
-    try {
-        const sig = ethers.Signature.from(token);
-        const digest = TypedDataUtils.eip712Hash(data, SignTypedDataVersion.V4);
-        return (ethers.recoverAddress(digest, sig).toLowerCase() ===
-            address.toLocaleLowerCase());
-    }
-    catch (err) {
-        console.error(`validate EOA Signature error: ${err}`);
-        throw err;
-    }
-};
-export const validateSmartContractSignature = ({ token, data, address, chainId, safeRpcUrl, }) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const safeProvider = safeRpcUrl !== null && safeRpcUrl !== void 0 ? safeRpcUrl : PROVIDER_MAP[chainId];
-        const protocolKit = yield Safe.init({
-            provider: safeProvider,
-            safeAddress: address,
-        });
-        const messageHash = hashTypedData(data);
-        const isValidSignature = yield protocolKit.isValidSignature(messageHash, token);
-        return isValidSignature;
-    }
-    catch (err) {
-        throw new Error(`Error validating smart contract signature: ${err.message}`);
-    }
-});

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

@@ -1,64 +0,0 @@
-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/termsAndConditions.js

@@ -1,33 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import pdf from 'pdf-parse';
-import { ByteListType, ContainerType } from '@chainsafe/ssz';
-import { TERMS_AND_CONDITIONS_URL } from '../constants';
-import { strToUint8Array } from '../utils';
-export const hashTermsAndConditions = () => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        // read the pdf
-        const response = yield fetch(TERMS_AND_CONDITIONS_URL);
-        const pdfBuffarrayBuffer = yield response.arrayBuffer();
-        const pdfBuffer = Buffer.from(pdfBuffarrayBuffer);
-        const data = yield pdf(pdfBuffer);
-        // ssz hash
-        const termsType = new ContainerType({
-            terms_and_conditions_hash: new ByteListType(Number.MAX_SAFE_INTEGER),
-        });
-        const termsHasVal = termsType.defaultValue();
-        termsHasVal.terms_and_conditions_hash = strToUint8Array(data === null || data === void 0 ? void 0 : data.text.replace(/[^a-zA-Z0-9]/g, ''));
-        return ('0x' +
-            Buffer.from(termsType.hashTreeRoot(termsHasVal).buffer).toString('hex'));
-    }
-    catch (err) {
-        return null;
-    }
-});

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

@@ -1,140 +0,0 @@
-import { UintNumberType, } from '@chainsafe/ssz/lib/type/uint';
-import { strToUint8Array } from '../utils';
-import { builderRegistrationContainer, depositDataContainer, newCreatorContainerType, newOperatorContainerType, validatorsContainerType, } from './sszTypes';
-import { ByteListType, ByteVectorType, ContainerType, ListBasicType, ListCompositeType, fromHexString, BooleanType, } from '@chainsafe/ssz';
-import { verifyDVV1X8 } from './v1.8.0';
-/**
- * Returns the containerized cluster definition
- * @param cluster ClusterDefinition to calculate the type from
- * @returns SSZ Containerized type of cluster input
- */
-export const clusterDefinitionContainerTypeV1X10 = (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),
-        deposit_amounts: new ListBasicType(new UintNumberType(8), 256),
-        consensus_protocol: new ByteListType(256),
-        target_gas_limit: new UintNumberType(8),
-        compounding: new BooleanType(),
-    };
-    if (!configOnly) {
-        returnedContainerType = Object.assign(Object.assign({}, returnedContainerType), { config_hash: new ByteVectorType(32) });
-    }
-    return new ContainerType(returnedContainerType);
-};
-export const hashClusterDefinitionV1X10 = (cluster, configOnly) => {
-    const definitionType = clusterDefinitionContainerTypeV1X10(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 (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 = fromHexString(cluster.config_hash);
-    }
-    return val;
-};
-// cluster lock
-const dvContainerTypeV1X10 = new ContainerType({
-    distributed_public_key: new ByteVectorType(48),
-    public_shares: new ListCompositeType(new ByteVectorType(48), 256),
-    partial_deposit_data: new ListCompositeType(depositDataContainer, 256),
-    builder_registration: builderRegistrationContainer,
-});
-/**
- * @returns SSZ Containerized type of cluster lock
- */
-const clusterLockContainerTypeV1X10 = () => {
-    return new ContainerType({
-        cluster_definition: clusterDefinitionContainerTypeV1X10(false),
-        distributed_validators: new ListCompositeType(dvContainerTypeV1X10, 65536),
-    });
-};
-/**
- * @param cluster The published cluster lock
- * @returns The lock hash in of the corresponding cluster
- */
-export const hashClusterLockV1X10 = (cluster) => {
-    const lockType = clusterLockContainerTypeV1X10();
-    const val = lockType.defaultValue();
-    // Check if we can replace with definition_hash
-    val.cluster_definition = hashClusterDefinitionV1X10(cluster.cluster_definition, false);
-    val.distributed_validators = cluster.distributed_validators.map(dValidator => {
-        var _a, _b, _c, _d, _e;
-        return {
-            distributed_public_key: fromHexString(dValidator.distributed_public_key),
-            public_shares: dValidator.public_shares.map(publicShare => fromHexString(publicShare)),
-            // should be fixed
-            partial_deposit_data: dValidator.partial_deposit_data.map(depositData => {
-                return {
-                    pubkey: fromHexString(depositData.pubkey),
-                    withdrawal_credentials: fromHexString(depositData.withdrawal_credentials),
-                    amount: parseInt(depositData.amount),
-                    signature: fromHexString(depositData.signature),
-                };
-            }),
-            builder_registration: {
-                message: {
-                    fee_recipient: fromHexString((_a = dValidator.builder_registration) === null || _a === void 0 ? void 0 : _a.message.fee_recipient),
-                    gas_limit: (_b = dValidator.builder_registration) === null || _b === void 0 ? void 0 : _b.message.gas_limit,
-                    timestamp: (_c = dValidator.builder_registration) === null || _c === void 0 ? void 0 : _c.message.timestamp,
-                    pubkey: fromHexString((_d = dValidator.builder_registration) === null || _d === void 0 ? void 0 : _d.message.pubkey),
-                },
-                signature: fromHexString((_e = dValidator.builder_registration) === null || _e === void 0 ? void 0 : _e.signature),
-            },
-        };
-    });
-    return '0x' + Buffer.from(lockType.hashTreeRoot(val).buffer).toString('hex');
-};
-// DV verification
-export const verifyDVV1X10 = verifyDVV1X8;