@obolnetwork/obol-sdk 1.0.12 → 1.0.14

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

@@ -0,0 +1,166 @@
+import { UintNumberType } from '@chainsafe/ssz/lib/type/uint';
+import { strToUint8Array } from '../utils';
+import { builderRegistrationContainer, depositDataContainer, newCreatorContainerType, newOperatorContainerType, validatorsContainerType } from './sszTypes';
+import { ByteListType, ByteVectorType, ContainerType, ListCompositeType, fromHexString } from '@chainsafe/ssz';
+import { verifyBuilderRegistration, verifyDepositData, verifyNodeSignatures } 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 clusterDefinitionContainerTypeV1X7 = (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 hashClusterDefinitionV1X7 = (cluster, configOnly) => {
+    const definitionType = clusterDefinitionContainerTypeV1X7(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 dvContainerTypeV1X7 = 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 clusterLockContainerTypeV1X7 = () => {
+    return new ContainerType({
+        cluster_definition: clusterDefinitionContainerTypeV1X7(false),
+        distributed_validators: new ListCompositeType(dvContainerTypeV1X7, 65536),
+    });
+};
+/**
+ * @param cluster The published cluster lock
+ * @returns The lock hash in of the corresponding cluster
+ */
+export const hashClusterLockV1X7 = (cluster) => {
+    const lockType = clusterLockContainerTypeV1X7();
+    const val = lockType.defaultValue();
+    // Check if we can replace with definition_hash
+    val.cluster_definition = hashClusterDefinitionV1X7(cluster.cluster_definition, false);
+    val.distributed_validators = cluster.distributed_validators.map((dValidator) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        return {
+            distributed_public_key: fromHexString(dValidator.distributed_public_key),
+            public_shares: dValidator.public_shares.map((publicShare) => fromHexString(publicShare)),
+            deposit_data: {
+                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),
+            },
+            builder_registration: {
+                message: {
+                    fee_recipient: fromHexString((_e = dValidator.builder_registration) === null || _e === void 0 ? void 0 : _e.message.fee_recipient),
+                    gas_limit: (_f = dValidator.builder_registration) === null || _f === void 0 ? void 0 : _f.message.gas_limit,
+                    timestamp: (_g = dValidator.builder_registration) === null || _g === void 0 ? void 0 : _g.message.timestamp,
+                    pubkey: fromHexString((_h = dValidator.builder_registration) === null || _h === void 0 ? void 0 : _h.message.pubkey),
+                },
+                signature: fromHexString((_j = dValidator.builder_registration) === null || _j === void 0 ? void 0 : _j.signature),
+            },
+        };
+    });
+    return '0x' + Buffer.from(lockType.hashTreeRoot(val).buffer).toString('hex');
+};
+// DV verification
+export const verifyDVV1X7 = (clusterLock) => {
+    var _a, _b;
+    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
+        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(distributedPublicKey));
+        builderRegistrationAndDepositDataMessages.push(depositDataMsg);
+        blsSignatures.push(fromHexString((_a = validator.deposit_data) === null || _a === void 0 ? void 0 : _a.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((_b = validator.builder_registration) === null || _b === void 0 ? void 0 : _b.signature));
+    }
+    // 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/esm/src/verification/v1.8.0.js

@@ -0,0 +1,176 @@
+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 } from '@chainsafe/ssz';
+import { verifyBuilderRegistration, verifyDepositData, verifyNodeSignatures } 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 clusterDefinitionContainerTypeV1X8 = (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),
+    };
+    if (!configOnly) {
+        returnedContainerType = Object.assign(Object.assign({}, returnedContainerType), { config_hash: new ByteVectorType(32) });
+    }
+    return new ContainerType(returnedContainerType);
+};
+export const hashClusterDefinitionV1X8 = (cluster, configOnly) => {
+    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),
+                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),
+        };
+    });
+    val.deposit_amounts = cluster.deposit_amounts.map((amount) => {
+        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,
+});
+/**
+ * @returns SSZ Containerized type of cluster lock
+ */
+const clusterLockContainerTypeV1X8 = () => {
+    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) => {
+    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 => {
+        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 verifyDVV1X8 = (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));
+        }
+        // Deposit Data Verification
+        for (let j = 0; j < validator.partial_deposit_data.length; j++) {
+            const depositData = validator.partial_deposit_data[i];
+            const { isValidDepositData, depositDataMsg } = verifyDepositData(distributedPublicKey, 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 === null || depositData === void 0 ? void 0 : 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((_a = validator.builder_registration) === null || _a === void 0 ? void 0 : _a.signature));
+    }
+    // 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;
+};