@obolnetwork/obol-sdk 1.0.12 → 1.0.13

package/src/verification/v1.8.0.ts

@@ -0,0 +1,281 @@
+import { type UintNumberByteLen, UintNumberType } from '@chainsafe/ssz/lib/type/uint'
+import { strToUint8Array } from '../utils'
+import { builderRegistrationContainer, type creatorAddressWrapperType, type creatorContainerType, depositDataContainer, newCreatorContainerType, newOperatorContainerType, type operatorAddressWrapperType, type operatorContainerType, validatorsContainerType } from './sszTypes'
+import { ByteListType, ByteVectorType, ContainerType, ListBasicType, ListCompositeType, fromHexString } from '@chainsafe/ssz'
+import { type ValueOfFields } from '@chainsafe/ssz/lib/view/container'
+import { type ClusterDefintion, type ClusterLock, type DepositData } from '../types'
+import { verifyBuilderRegistration, verifyDepositData, verifyNodeSignatures } from './common'
+import { aggregateSignatures, verifyAggregate, verifyMultiple } from '@chainsafe/bls'
+
+// cluster defintion
+type DefinitionFieldsV1X8 = {
+    uuid: ByteListType
+    name: ByteListType
+    version: ByteListType
+    timestamp: ByteListType
+    num_validators: UintNumberType
+    threshold: UintNumberType
+    dkg_algorithm: ByteListType
+    fork_version: ByteVectorType
+    operators: ListCompositeType<
+        typeof operatorContainerType | typeof operatorAddressWrapperType
+    >
+    creator: typeof creatorContainerType | typeof creatorAddressWrapperType
+    validators: ListCompositeType<typeof validatorsContainerType>
+    deposit_amounts: ListBasicType<UintNumberType>
+    config_hash?: ByteVectorType
+}
+
+type DefinitionContainerTypeV1X8 = ContainerType<DefinitionFieldsV1X8>
+
+/**
+ * Returns the containerized cluster definition
+ * @param cluster ClusterDefinition to calculate the type from
+ * @returns SSZ Containerized type of cluster input
+ */
+export const clusterDefinitionContainerTypeV1X8 = (
+    configOnly: boolean,
+): DefinitionContainerTypeV1X8 => {
+    let returnedContainerType: any = {
+        uuid: new ByteListType(64),
+        name: new ByteListType(256),
+        version: new ByteListType(16),
+        timestamp: new ByteListType(32),
+        num_validators: new UintNumberType(8 as UintNumberByteLen),
+        threshold: new UintNumberType(8 as UintNumberByteLen),
+        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 as UintNumberByteLen),
+            256,
+        ),
+    }
+
+    if (!configOnly) {
+        returnedContainerType = {
+            ...returnedContainerType,
+            config_hash: new ByteVectorType(32),
+        }
+    }
+
+    return new ContainerType(returnedContainerType)
+}
+
+export const hashClusterDefinitionV1X8 = (
+    cluster: ClusterDefintion,
+    configOnly: boolean,
+): ValueOfFields<DefinitionFieldsV1X8> => {
+    const definitionType = clusterDefinitionContainerTypeV1X8(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 as string),
+                config_signature: fromHexString(operator.config_signature as string),
+                enr_signature: fromHexString(operator.enr_signature as string),
+            }
+    })
+    val.creator = configOnly
+        ? { address: fromHexString(cluster.creator.address) }
+        : {
+            address: fromHexString(cluster.creator.address),
+            config_signature: fromHexString(cluster.creator.config_signature as string),
+        }
+    val.validators = cluster.validators.map((validator) => {
+        return {
+            fee_recipient_address: fromHexString(validator.fee_recipient_address),
+            withdrawal_address: fromHexString(validator.withdrawal_address),
+        }
+    })
+    val.deposit_amounts = (cluster.deposit_amounts as string[]).map((amount: string) => {
+        return parseInt(amount)
+    })
+
+    if (!configOnly) {
+        val.config_hash = fromHexString(cluster.config_hash)
+    }
+    return val
+}
+
+// cluster lock
+
+const dvContainerTypeV1X8 = 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,
+})
+
+type LockContainerTypeV1X8 = ContainerType<{
+    cluster_definition: DefinitionContainerTypeV1X8
+    distributed_validators: ListCompositeType<typeof dvContainerTypeV1X8>
+}>
+
+/**
+ * @returns SSZ Containerized type of cluster lock
+ */
+const clusterLockContainerTypeV1X8 = (): LockContainerTypeV1X8 => {
+    return new ContainerType({
+        cluster_definition: clusterDefinitionContainerTypeV1X8(false),
+        distributed_validators: new ListCompositeType(dvContainerTypeV1X8, 65536),
+    })
+}
+
+/**
+ * @param cluster The published cluster lock
+ * @returns The lock hash in of the corresponding cluster
+ */
+export const hashClusterLockV1X8 = (cluster: ClusterLock): string => {
+    const lockType = clusterLockContainerTypeV1X8()
+
+    const val = lockType.defaultValue()
+
+    // Check if we can replace with definition_hash
+    val.cluster_definition = hashClusterDefinitionV1X8(
+        cluster.cluster_definition,
+        false,
+    )
+    val.distributed_validators = cluster.distributed_validators.map(dValidator => {
+        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 as DepositData[]).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(
+                        dValidator.builder_registration?.message.fee_recipient as string,
+                    ),
+                    gas_limit: dValidator.builder_registration?.message.gas_limit as number,
+                    timestamp: dValidator.builder_registration?.message.timestamp as number,
+                    pubkey: fromHexString(dValidator.builder_registration?.message.pubkey as string),
+                },
+                signature: fromHexString(dValidator.builder_registration?.signature as string),
+            },
+        }
+    })
+
+    return '0x' + Buffer.from(lockType.hashTreeRoot(val).buffer).toString('hex')
+}
+
+// DV verification
+export const verifyDVV1X8 = (clusterLock: ClusterLock): boolean => {
+    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))
+        }
+
+        // Deposit Data Verification
+        for (let j = 0; j < (validator.partial_deposit_data as DepositData[]).length; j++) {
+            const depositData = (validator.partial_deposit_data as DepositData[])[i]
+            const { isValidDepositData, depositDataMsg } = verifyDepositData(
+                distributedPublicKey,
+                depositData as Partial<DepositData>,
+                clusterLock.cluster_definition.validators[i].withdrawal_address,
+                clusterLock.cluster_definition.fork_version
+            )
+
+            if (
+                !isValidDepositData
+            ) {
+                return false
+            }
+
+            pubKeys.push(fromHexString(distributedPublicKey))
+            builderRegistrationAndDepositDataMessages.push(depositDataMsg)
+            blsSignatures.push(fromHexString(depositData?.signature))
+        }
+
+        // Builder Registration Verification
+        const { isValidBuilderRegistration, builderRegistrationMsg } = verifyBuilderRegistration(
+            validator,
+            clusterLock.cluster_definition.validators[i].fee_recipient_address,
+            clusterLock.cluster_definition.fork_version
+        )
+
+        if (
+            !isValidBuilderRegistration
+        ) {
+            return false
+        }
+
+        pubKeys.push(fromHexString(distributedPublicKey))
+        builderRegistrationAndDepositDataMessages.push(builderRegistrationMsg)
+        blsSignatures.push(
+            fromHexString(validator.builder_registration?.signature as string),
+        )
+    }
+
+    // BLS signatures verification
+    const aggregateBLSSignature = aggregateSignatures(blsSignatures)
+
+    if (
+        !verifyMultiple(
+            pubKeys,
+            builderRegistrationAndDepositDataMessages,
+            aggregateBLSSignature,
+        )
+    ) {
+        return false
+    }
+
+    // Node Signatures verification
+    if (
+        !verifyNodeSignatures(
+            clusterLock
+        )
+    ) {
+        return false
+    }
+
+    // signature_aggregate verification
+    if (
+        !verifyAggregate(
+            pubShares,
+            fromHexString(clusterLock.lock_hash),
+            fromHexString(clusterLock.signature_aggregate),
+        )
+    ) {
+        return false
+    }
+
+    return true
+}

package/dist/cjs/src/hash.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clusterLockHash = exports.clusterDefinitionContainerType = exports.validatorsContainerType = exports.creatorContainerType = exports.operatorContainerType = exports.hashClusterDefinition = exports.clusterConfigOrDefinitionHash = void 0;
-const ssz_1 = require("@chainsafe/ssz");
-const utils_js_1 = require("./utils.js");
-//cluster-definition
-/**
- * @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
- */
-const clusterConfigOrDefinitionHash = (cluster, configOnly) => {
-    const definitionType = (0, exports.clusterDefinitionContainerType)(configOnly);
-    const val = (0, exports.hashClusterDefinition)(cluster, configOnly);
-    return ('0x' + Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex'));
-};
-exports.clusterConfigOrDefinitionHash = clusterConfigOrDefinitionHash;
-const hashClusterDefinition = (cluster, configOnly) => {
-    const definitionType = (0, exports.clusterDefinitionContainerType)(configOnly);
-    const val = definitionType.defaultValue();
-    //order should be same as charon https://github.com/ObolNetwork/charon/blob/d00b31e6465a260a43ce40f15c47fb5a5b009042/cluster/ssz.go#L285
-    val.uuid = (0, utils_js_1.strToUint8Array)(cluster.uuid);
-    val.name = (0, utils_js_1.strToUint8Array)(cluster.name);
-    val.version = (0, utils_js_1.strToUint8Array)(cluster.version);
-    val.timestamp = (0, utils_js_1.strToUint8Array)(cluster.timestamp);
-    val.num_validators = cluster.num_validators;
-    val.threshold = cluster.threshold;
-    val.dkg_algorithm = (0, utils_js_1.strToUint8Array)(cluster.dkg_algorithm);
-    val.fork_version = (0, ssz_1.fromHexString)(cluster.fork_version);
-    val.operators = cluster.operators.map((operator) => {
-        return configOnly
-            ? { address: (0, ssz_1.fromHexString)(operator.address) }
-            : {
-                address: (0, ssz_1.fromHexString)(operator.address),
-                enr: (0, utils_js_1.strToUint8Array)(operator.enr),
-                config_signature: (0, ssz_1.fromHexString)(operator.config_signature),
-                enr_signature: (0, ssz_1.fromHexString)(operator.enr_signature),
-            };
-    });
-    val.creator = configOnly
-        ? { address: (0, ssz_1.fromHexString)(cluster.creator.address) }
-        : {
-            address: (0, ssz_1.fromHexString)(cluster.creator.address),
-            config_signature: (0, ssz_1.fromHexString)(cluster.creator.config_signature),
-        };
-    val.validators = cluster.validators.map((validator) => {
-        return {
-            fee_recipient_address: (0, ssz_1.fromHexString)(validator.fee_recipient_address),
-            withdrawal_address: (0, ssz_1.fromHexString)(validator.withdrawal_address),
-        };
-    });
-    if (!configOnly) {
-        val.config_hash = (0, ssz_1.fromHexString)(cluster.config_hash);
-    }
-    return val;
-};
-exports.hashClusterDefinition = hashClusterDefinition;
-const operatorAddressWrapperType = new ssz_1.ContainerType({
-    address: new ssz_1.ByteVectorType(20),
-});
-const creatorAddressWrapperType = new ssz_1.ContainerType({
-    address: new ssz_1.ByteVectorType(20),
-});
-exports.operatorContainerType = new ssz_1.ContainerType({
-    address: new ssz_1.ByteVectorType(20),
-    enr: new ssz_1.ByteListType(1024), // This needs to be dynamic, since ENRs do not have a fixed length.
-    config_signature: new ssz_1.ByteVectorType(65),
-    enr_signature: new ssz_1.ByteVectorType(65),
-});
-exports.creatorContainerType = new ssz_1.ContainerType({
-    address: new ssz_1.ByteVectorType(20),
-    config_signature: new ssz_1.ByteVectorType(65),
-});
-exports.validatorsContainerType = new ssz_1.ContainerType({
-    fee_recipient_address: new ssz_1.ByteVectorType(20),
-    withdrawal_address: new ssz_1.ByteVectorType(20),
-});
-const newCreatorContainerType = (configOnly) => {
-    return configOnly ? creatorAddressWrapperType : exports.creatorContainerType;
-};
-const newOperatorContainerType = (configOnly) => {
-    return configOnly ? operatorAddressWrapperType : exports.operatorContainerType;
-};
-/**
- * @param configOnly a boolean to indicate config hash or definition hash
- * @returns SSZ Containerized type of cluster definition
- */
-const clusterDefinitionContainerType = (configOnly) => {
-    let returnedContainerType = {
-        uuid: new ssz_1.ByteListType(64),
-        name: new ssz_1.ByteListType(256),
-        version: new ssz_1.ByteListType(16),
-        timestamp: new ssz_1.ByteListType(32),
-        num_validators: new ssz_1.UintNumberType(8),
-        threshold: new ssz_1.UintNumberType(8),
-        dkg_algorithm: new ssz_1.ByteListType(32),
-        fork_version: new ssz_1.ByteVectorType(4),
-        operators: new ssz_1.ListCompositeType(newOperatorContainerType(configOnly), 256),
-        creator: newCreatorContainerType(configOnly),
-        validators: new ssz_1.ListCompositeType(exports.validatorsContainerType, 65536),
-    };
-    if (!configOnly) {
-        returnedContainerType = Object.assign(Object.assign({}, returnedContainerType), { config_hash: new ssz_1.ByteVectorType(32) });
-    }
-    return new ssz_1.ContainerType(returnedContainerType);
-};
-exports.clusterDefinitionContainerType = clusterDefinitionContainerType;
-//cluster-lock
-/**
- * @param cluster The published cluster lock
- * @returns The lock hash in of the corresponding cluster
- */
-const clusterLockHash = (cluster) => {
-    const lockType = clusterLockContainerType();
-    const val = lockType.defaultValue();
-    //Check if we can replace with definition_hash 
-    val.cluster_definition = (0, exports.hashClusterDefinition)(cluster.cluster_definition, false);
-    val.distributed_validators = cluster.distributed_validators.map(dVaidator => {
-        return {
-            distributed_public_key: (0, ssz_1.fromHexString)(dVaidator.distributed_public_key),
-            public_shares: dVaidator.public_shares.map(publicShare => (0, ssz_1.fromHexString)(publicShare)),
-            deposit_data: {
-                pubkey: (0, ssz_1.fromHexString)(dVaidator.deposit_data.pubkey),
-                withdrawal_credentials: (0, ssz_1.fromHexString)(dVaidator.deposit_data.withdrawal_credentials),
-                amount: parseInt(dVaidator.deposit_data.amount),
-                signature: (0, ssz_1.fromHexString)(dVaidator.deposit_data.signature),
-            },
-            builder_registration: {
-                message: {
-                    fee_recipient: (0, ssz_1.fromHexString)(dVaidator.builder_registration.message.fee_recipient),
-                    gas_limit: dVaidator.builder_registration.message.gas_limit,
-                    timestamp: dVaidator.builder_registration.message.timestamp,
-                    pubkey: (0, ssz_1.fromHexString)(dVaidator.builder_registration.message.pubkey),
-                },
-                signature: (0, ssz_1.fromHexString)(dVaidator.builder_registration.signature),
-            },
-        };
-    });
-    return '0x' + Buffer.from(lockType.hashTreeRoot(val).buffer).toString('hex');
-};
-exports.clusterLockHash = clusterLockHash;
-const depositDataContainer = new ssz_1.ContainerType({
-    pubkey: new ssz_1.ByteVectorType(48),
-    withdrawal_credentials: new ssz_1.ByteVectorType(32),
-    amount: new ssz_1.UintNumberType(8),
-    signature: new ssz_1.ByteVectorType(96),
-});
-const builderRegistrationMessageContainer = new ssz_1.ContainerType({
-    fee_recipient: new ssz_1.ByteVectorType(20),
-    gas_limit: new ssz_1.UintNumberType(8),
-    timestamp: new ssz_1.UintNumberType(8),
-    pubkey: new ssz_1.ByteVectorType(48),
-});
-const builderRegistrationContainer = new ssz_1.ContainerType({
-    message: builderRegistrationMessageContainer,
-    signature: new ssz_1.ByteVectorType(96),
-});
-const dvContainerType = new ssz_1.ContainerType({
-    distributed_public_key: new ssz_1.ByteVectorType(48),
-    public_shares: new ssz_1.ListCompositeType(new ssz_1.ByteVectorType(48), 256),
-    deposit_data: depositDataContainer,
-    builder_registration: builderRegistrationContainer,
-});
-/**
- * @returns SSZ Containerized type of cluster lock
- */
-const clusterLockContainerType = () => {
-    return new ssz_1.ContainerType({
-        cluster_definition: (0, exports.clusterDefinitionContainerType)(false),
-        distributed_validators: new ssz_1.ListCompositeType(dvContainerType, 65536),
-    });
-};

package/dist/esm/src/hash.js

@@ -1,165 +0,0 @@
-import { ContainerType, ByteVectorType, UintNumberType, ListCompositeType, ByteListType, fromHexString, } from '@chainsafe/ssz';
-import { strToUint8Array } from './utils.js';
-//cluster-definition
-/**
- * @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) => {
-    const definitionType = clusterDefinitionContainerType(configOnly);
-    const val = hashClusterDefinition(cluster, configOnly);
-    return ('0x' + Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex'));
-};
-export const hashClusterDefinition = (cluster, configOnly) => {
-    const definitionType = clusterDefinitionContainerType(configOnly);
-    const val = definitionType.defaultValue();
-    //order should be same as charon https://github.com/ObolNetwork/charon/blob/d00b31e6465a260a43ce40f15c47fb5a5b009042/cluster/ssz.go#L285
-    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;
-};
-const operatorAddressWrapperType = new ContainerType({
-    address: new ByteVectorType(20),
-});
-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),
-});
-const newCreatorContainerType = (configOnly) => {
-    return configOnly ? creatorAddressWrapperType : creatorContainerType;
-};
-const newOperatorContainerType = (configOnly) => {
-    return configOnly ? operatorAddressWrapperType : operatorContainerType;
-};
-/**
- * @param configOnly a boolean to indicate config hash or definition hash
- * @returns SSZ Containerized type of cluster definition
- */
-export const clusterDefinitionContainerType = (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);
-};
-//cluster-lock
-/**
- * @param cluster The published cluster lock
- * @returns The lock hash in of the corresponding cluster
- */
-export const clusterLockHash = (cluster) => {
-    const lockType = clusterLockContainerType();
-    const val = lockType.defaultValue();
-    //Check if we can replace with definition_hash 
-    val.cluster_definition = hashClusterDefinition(cluster.cluster_definition, false);
-    val.distributed_validators = cluster.distributed_validators.map(dVaidator => {
-        return {
-            distributed_public_key: fromHexString(dVaidator.distributed_public_key),
-            public_shares: dVaidator.public_shares.map(publicShare => fromHexString(publicShare)),
-            deposit_data: {
-                pubkey: fromHexString(dVaidator.deposit_data.pubkey),
-                withdrawal_credentials: fromHexString(dVaidator.deposit_data.withdrawal_credentials),
-                amount: parseInt(dVaidator.deposit_data.amount),
-                signature: fromHexString(dVaidator.deposit_data.signature),
-            },
-            builder_registration: {
-                message: {
-                    fee_recipient: fromHexString(dVaidator.builder_registration.message.fee_recipient),
-                    gas_limit: dVaidator.builder_registration.message.gas_limit,
-                    timestamp: dVaidator.builder_registration.message.timestamp,
-                    pubkey: fromHexString(dVaidator.builder_registration.message.pubkey),
-                },
-                signature: fromHexString(dVaidator.builder_registration.signature),
-            },
-        };
-    });
-    return '0x' + Buffer.from(lockType.hashTreeRoot(val).buffer).toString('hex');
-};
-const depositDataContainer = new ContainerType({
-    pubkey: new ByteVectorType(48),
-    withdrawal_credentials: new ByteVectorType(32),
-    amount: new UintNumberType(8),
-    signature: new ByteVectorType(96),
-});
-const builderRegistrationMessageContainer = new ContainerType({
-    fee_recipient: new ByteVectorType(20),
-    gas_limit: new UintNumberType(8),
-    timestamp: new UintNumberType(8),
-    pubkey: new ByteVectorType(48),
-});
-const builderRegistrationContainer = new ContainerType({
-    message: builderRegistrationMessageContainer,
-    signature: new ByteVectorType(96),
-});
-const dvContainerType = new ContainerType({
-    distributed_public_key: new ByteVectorType(48),
-    public_shares: new ListCompositeType(new ByteVectorType(48), 256),
-    deposit_data: depositDataContainer,
-    builder_registration: builderRegistrationContainer,
-});
-/**
- * @returns SSZ Containerized type of cluster lock
- */
-const clusterLockContainerType = () => {
-    return new ContainerType({
-        cluster_definition: clusterDefinitionContainerType(false),
-        distributed_validators: new ListCompositeType(dvContainerType, 65536),
-    });
-};

package/dist/types/src/hash.d.ts

@@ -1,56 +0,0 @@
-import { ContainerType, ByteVectorType, UintNumberType, ListCompositeType, ByteListType } from '@chainsafe/ssz';
-import { ValueOfFields } from '@chainsafe/ssz/lib/view/container.js';
-import { ClusterDefintion, ClusterLock } from './types.js';
-/**
- * @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 declare const clusterConfigOrDefinitionHash: (cluster: ClusterDefintion, configOnly: boolean) => string;
-export declare const hashClusterDefinition: (cluster: ClusterDefintion, configOnly: boolean) => ValueOfFields<DefinitionFields>;
-declare const operatorAddressWrapperType: ContainerType<{
-    address: ByteVectorType;
-}>;
-declare const creatorAddressWrapperType: ContainerType<{
-    address: ByteVectorType;
-}>;
-export declare const operatorContainerType: ContainerType<{
-    address: ByteVectorType;
-    enr: ByteListType;
-    config_signature: ByteVectorType;
-    enr_signature: ByteVectorType;
-}>;
-export declare const creatorContainerType: ContainerType<{
-    address: ByteVectorType;
-    config_signature: ByteVectorType;
-}>;
-export declare const validatorsContainerType: ContainerType<{
-    fee_recipient_address: ByteVectorType;
-    withdrawal_address: ByteVectorType;
-}>;
-type DefinitionFields = {
-    uuid: ByteListType;
-    name: ByteListType;
-    version: ByteListType;
-    timestamp: ByteListType;
-    num_validators: UintNumberType;
-    threshold: UintNumberType;
-    dkg_algorithm: ByteListType;
-    fork_version: ByteVectorType;
-    operators: ListCompositeType<typeof operatorContainerType | typeof operatorAddressWrapperType>;
-    creator: typeof creatorContainerType | typeof creatorAddressWrapperType;
-    validators: ListCompositeType<typeof validatorsContainerType>;
-    config_hash?: ByteVectorType;
-};
-export type DefinitionContainerType = ContainerType<DefinitionFields>;
-/**
- * @param configOnly a boolean to indicate config hash or definition hash
- * @returns SSZ Containerized type of cluster definition
- */
-export declare const clusterDefinitionContainerType: (configOnly: boolean) => DefinitionContainerType;
-/**
- * @param cluster The published cluster lock
- * @returns The lock hash in of the corresponding cluster
- */
-export declare const clusterLockHash: (cluster: ClusterLock) => string;
-export {};

package/dist/types/src/verify.d.ts

@@ -1,4 +0,0 @@
-/// <reference types="node" />
-import { ClusterLock } from "./types.js";
-export declare const signingRoot: (domain: Uint8Array, messageBuffer: Buffer) => Uint8Array;
-export declare const isValidClusterLock: (clusterLock: ClusterLock) => Promise<boolean>;