@obolnetwork/obol-sdk 1.0.16 → 2.0.0

package/dist/cjs/test/methods.test.js

@@ -45,51 +45,72 @@ describe('Cluster Client', () => {
         clientInstance['request'] = jest
             .fn()
             .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
-        const configHash = yield clientInstance.createClusterDefinition(fixtures_js_1.clusterConfigV1X7);
+        const configHash = yield clientInstance.createClusterDefinition(fixtures_js_1.clusterConfigV1X8);
         expect(configHash).toEqual(mockConfigHash);
     }));
     test('acceptClusterDefinition should return cluster definition', () => __awaiter(void 0, void 0, void 0, function* () {
         clientInstance['request'] = jest
             .fn()
-            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X7.cluster_definition));
+            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X8.cluster_definition));
         const clusterDefinition = yield clientInstance.acceptClusterDefinition({
-            enr: fixtures_js_1.clusterLockV1X7.cluster_definition.operators[0].enr,
-            version: fixtures_js_1.clusterLockV1X7.cluster_definition.version,
-        }, fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
-        expect(clusterDefinition).toEqual(fixtures_js_1.clusterLockV1X7.cluster_definition);
+            enr: fixtures_js_1.clusterLockV1X8.cluster_definition.operators[0].enr,
+            version: fixtures_js_1.clusterLockV1X8.cluster_definition.version,
+        }, fixtures_js_1.clusterLockV1X8.cluster_definition.config_hash);
+        expect(clusterDefinition).toEqual(fixtures_js_1.clusterLockV1X8.cluster_definition);
     }));
     test('createClusterDefinition should throw an error on invalid operators', () => __awaiter(void 0, void 0, void 0, function* () {
         clientInstance['request'] = jest
             .fn()
             .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
         try {
-            yield clientInstance.createClusterDefinition(Object.assign(Object.assign({}, fixtures_js_1.clusterConfigV1X7), { operators: [] }));
+            yield clientInstance.createClusterDefinition(Object.assign(Object.assign({}, fixtures_js_1.clusterConfigV1X8), { operators: [] }));
         }
         catch (error) {
             expect(error.message).toEqual("Schema compilation errors', must NOT have fewer than 4 items");
         }
     }));
+    // cause we default to 32000000000
+    test('createClusterDefinition should accept a configuration without deposit_amounts', () => __awaiter(void 0, void 0, void 0, function* () {
+        clientInstance['request'] = jest
+            .fn()
+            .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
+        const configHash = yield clientInstance.createClusterDefinition(Object.assign({}, fixtures_js_1.clusterConfigV1X7));
+        expect(configHash).toEqual(mockConfigHash);
+    }));
+    test('createClusterDefinition should throw on not valid deposit_amounts ', () => __awaiter(void 0, void 0, void 0, function* () {
+        clientInstance['request'] = jest
+            .fn()
+            .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
+        try {
+            yield clientInstance.createClusterDefinition(Object.assign(Object.assign({}, fixtures_js_1.clusterConfigV1X7), { deposit_amounts: ['34000000'] }));
+        }
+        catch (error) {
+            expect(error.message).toEqual('Schema compilation errors\', must pass "validDepositAmounts" keyword validation');
+        }
+    }));
     test('validatePayload should throw an error on empty schema', () => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            (0, ajv_1.validatePayload)(Object.assign(Object.assign({}, fixtures_js_1.clusterConfigV1X7), { operators: [] }), '');
+            (0, ajv_1.validatePayload)(Object.assign(Object.assign({}, fixtures_js_1.clusterConfigV1X8), { operators: [] }), '');
         }
         catch (error) {
             expect(error.message).toEqual('schema must be object or boolean');
         }
     }));
     test('getClusterdefinition should return cluster definition if config hash exist', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _c;
         clientInstance['request'] = jest
             .fn()
-            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X7.cluster_definition));
-        const clusterDefinition = yield clientInstance.getClusterDefinition(fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
-        expect(clusterDefinition.config_hash).toEqual(fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
+            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X8.cluster_definition));
+        const clusterDefinition = yield clientInstance.getClusterDefinition(fixtures_js_1.clusterLockV1X8.cluster_definition.config_hash);
+        expect((_c = clusterDefinition.deposit_amounts) === null || _c === void 0 ? void 0 : _c.length).toEqual(fixtures_js_1.clusterLockV1X8.cluster_definition.deposit_amounts.length);
+        expect(clusterDefinition.config_hash).toEqual(fixtures_js_1.clusterLockV1X8.cluster_definition.config_hash);
     }));
     test('getClusterLock should return lockFile if exist', () => __awaiter(void 0, void 0, void 0, function* () {
         clientInstance['request'] = jest
             .fn()
-            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X7));
-        const clusterLock = yield clientInstance.getClusterLock(fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
-        expect(clusterLock.lock_hash).toEqual(fixtures_js_1.clusterLockV1X7.lock_hash);
+            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X8));
+        const clusterLock = yield clientInstance.getClusterLock(fixtures_js_1.clusterLockV1X8.cluster_definition.config_hash);
+        expect(clusterLock.lock_hash).toEqual(fixtures_js_1.clusterLockV1X8.lock_hash);
     }));
     test('request method should set user agent header', () => __awaiter(void 0, void 0, void 0, function* () {
         const server = (0, node_1.setupServer)(msw_1.http.get('http://testexample.com/test', ({ request }) => {
@@ -106,7 +127,9 @@ describe('Cluster Client', () => {
                 });
             }
         }
-        const testBaseInstance = new TestBase({ baseUrl: 'http://testExample.com' });
+        const testBaseInstance = new TestBase({
+            baseUrl: 'http://testExample.com',
+        });
         const result = yield testBaseInstance.callProtectedRequest('/test', {
             method: 'GET',
         });
@@ -121,7 +144,7 @@ describe('Cluster Client without a signer', () => {
     });
     test('createClusterDefinition should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            yield clientInstance.createClusterDefinition(fixtures_js_1.clusterConfigV1X7);
+            yield clientInstance.createClusterDefinition(fixtures_js_1.clusterConfigV1X8);
         }
         catch (err) {
             expect(err.message).toEqual('Signer is required in createClusterDefinition');
@@ -130,9 +153,9 @@ describe('Cluster Client without a signer', () => {
     test('acceptClusterDefinition should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
         try {
             yield clientInstance.acceptClusterDefinition({
-                enr: fixtures_js_1.clusterLockV1X7.cluster_definition.operators[0].enr,
-                version: fixtures_js_1.clusterLockV1X7.cluster_definition.version,
-            }, fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
+                enr: fixtures_js_1.clusterLockV1X8.cluster_definition.operators[0].enr,
+                version: fixtures_js_1.clusterLockV1X8.cluster_definition.version,
+            }, fixtures_js_1.clusterLockV1X8.cluster_definition.config_hash);
         }
         catch (err) {
             expect(err.message).toEqual('Signer is required in acceptClusterDefinition');
@@ -141,23 +164,27 @@ describe('Cluster Client without a signer', () => {
     test('getClusterdefinition should return cluster definition if config hash exist', () => __awaiter(void 0, void 0, void 0, function* () {
         clientInstance['request'] = jest
             .fn()
-            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X7.cluster_definition));
-        const clusterDefinition = yield clientInstance.getClusterDefinition(fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
-        expect(clusterDefinition.config_hash).toEqual(fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
+            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X8.cluster_definition));
+        const clusterDefinition = yield clientInstance.getClusterDefinition(fixtures_js_1.clusterLockV1X8.cluster_definition.config_hash);
+        expect(clusterDefinition.config_hash).toEqual(fixtures_js_1.clusterLockV1X8.cluster_definition.config_hash);
     }));
     test('getClusterLock should return lockFile if exist', () => __awaiter(void 0, void 0, void 0, function* () {
         clientInstance['request'] = jest
             .fn()
-            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X7));
-        const clusterLock = yield clientInstance.getClusterLock(fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
-        expect(clusterLock.lock_hash).toEqual(fixtures_js_1.clusterLockV1X7.lock_hash);
+            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X8));
+        const clusterLock = yield clientInstance.getClusterLock(fixtures_js_1.clusterLockV1X8.cluster_definition.config_hash);
+        expect(clusterLock.lock_hash).toEqual(fixtures_js_1.clusterLockV1X8.lock_hash);
     }));
-    test.each([{ version: 'v1.6.0', clusterLock: fixtures_js_1.clusterLockV1X6 }, { version: 'v1.7.0', clusterLock: fixtures_js_1.clusterLockV1X7 }, { version: 'v1.8.0', clusterLock: fixtures_js_1.clusterLockV1X8 }])('$version: \'should return true on verified cluster lock\'', (_a) => __awaiter(void 0, [_a], void 0, function* ({ clusterLock }) {
+    test.each([
+        { version: 'v1.6.0', clusterLock: fixtures_js_1.clusterLockV1X6 },
+        { version: 'v1.7.0', clusterLock: fixtures_js_1.clusterLockV1X7 },
+        { version: 'v1.8.0', clusterLock: fixtures_js_1.clusterLockV1X8 },
+    ])("$version: 'should return true on verified cluster lock'", ({ clusterLock }) => __awaiter(void 0, void 0, void 0, function* () {
         const isValidLock = yield (0, index_1.validateClusterLock)(clusterLock);
         expect(isValidLock).toEqual(true);
     }));
     test('Finds the hash of the latest version of terms and conditions', () => __awaiter(void 0, void 0, void 0, function* () {
         const termsAndConditionsHash = yield (0, termsAndConditions_1.hashTermsAndConditions)();
-        expect(termsAndConditionsHash).toEqual('0x0015d01710b4d864004320a4826f6846c2db12a7f056a126fa5ae16c0b5e2b65');
+        expect(termsAndConditionsHash).toEqual('0xd33721644e8f3afab1495a74abe3523cec12d48b8da6cb760972492ca3f1a273');
     }));
 });

package/dist/esm/package.json

@@ -1,11 +1,11 @@
 {
     "name": "@obolnetwork/obol-sdk",
-    "version": "1.0.16",
+    "version": "2.0.0",
     "description": "A package for creating Distributed Validators using the Obol API.",
     "bugs": {
         "url": "https://github.com/obolnetwork/obol-sdk/issues"
     },
-    "homepage": "https://docs.obol.tech/",
+    "homepage": "https://docs.obol.org/",
     "keywords": [
         "Obol",
         "Distributed Validators",
@@ -20,13 +20,15 @@
         "npm:publish": "npm publish --tag latest",
         "release": "release-it",
         "release:dry": "release-it --dry-run --no-npm",
-        "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
-        "lint-ci": "eslint \"{src,apps,libs,test}/**/*.ts\""
+        "lint": "eslint \"{src,test}/**/*.{js,ts}\" --fix",
+        "lint-ci": "eslint \"{src,test}/**/*.{js,ts}\"",
+        "prettier-ci": "prettier --check \"{src,test}/**/*.{js,ts}\"",
+        "prettier": "prettier --write \"{src,test}/**/*.{js,ts}\""
     },
     "main": "./dist/cjs/src/index.js",
     "module": "./dist/esm/src/index.js",
     "typings": "./dist/types/src/index.d.ts",
-    "author": "Obol Labs (https://obol.tech)",
+    "author": "Obol Labs (https://obol.org)",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/obolnetwork/obol-sdk.git"
@@ -65,15 +67,18 @@
         "@types/semver": "^7.5.8",
         "@types/uuid": "^9.0.1",
         "eslint": "^8.57.0",
+        "husky": "^9.0.11",
         "jest": "^28.1.3",
+        "lint-staged": "^15.2.2",
         "msw": "^2.2.1",
         "npm-run-all": "^4.1.5",
+        "prettier": "^3.2.5",
         "release-it": "^17.2.1",
         "ts-jest": "^28.0.8",
         "tsup": "^6.7.0",
         "typedoc": "^0.25.7",
         "typedoc-plugin-markdown": "^4.0.0-next.50",
-        "typescript": "^5.3.3"
+        "typescript": "~5.3.3"
     },
     "engines": {
         "node": ">= 16"

package/dist/esm/src/ajv.js

@@ -1,7 +1,34 @@
 import Ajv from 'ajv';
+import { parseUnits } from 'ethers';
+function validDepositAmounts(data, deposits) {
+    let sum = 0;
+    // from ether togwei is same as from gwei to wei
+    const maxDeposit = Number(parseUnits('32', 'gwei'));
+    const minDeposit = Number(parseUnits('1', 'gwei'));
+    for (const element of deposits) {
+        const amountInGWei = Number(element);
+        if (!Number.isInteger(amountInGWei) ||
+            amountInGWei > maxDeposit ||
+            amountInGWei < minDeposit) {
+            return false;
+        }
+        sum += amountInGWei;
+    }
+    if (sum / minDeposit !== 32) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}
 export function validatePayload(data, schema) {
     var _a;
     const ajv = new Ajv();
+    ajv.addKeyword({
+        keyword: 'validDepositAmounts',
+        validate: validDepositAmounts,
+        errors: true,
+    });
     const validate = ajv.compile(schema);
     const isValid = validate(data);
     if (!isValid) {

package/dist/esm/src/base.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 // src/resources/base.ts
-import { DEFAULT_BASE_URL, DEFAULT_CHAIN_ID, SDK_VERSION } from './constants.js';
+import { DEFAULT_BASE_URL, DEFAULT_CHAIN_ID, SDK_VERSION, } from './constants.js';
 import { FORK_MAPPING } from './types.js';
 export class Base {
     constructor({ baseUrl = DEFAULT_BASE_URL, chainId = DEFAULT_CHAIN_ID, }) {

package/dist/esm/src/constants.js

@@ -9,7 +9,7 @@ export const TermsAndConditionsSigningTypes = {
     TermsAndConditions: [
         { name: 'terms_and_conditions_hash', type: 'string' },
         { name: 'version', type: 'uint256' },
-    ]
+    ],
 };
 const EIP712Domain = [
     { name: 'name', type: 'string' },
@@ -73,7 +73,7 @@ export const signEnrPayload = (payload, chainId) => {
     };
 };
 export const DKG_ALGORITHM = 'default';
-export const CONFIG_VERSION = 'v1.7.0';
+export const CONFIG_VERSION = 'v1.8.0';
 export const SDK_VERSION = pjson.version;
 export const DOMAIN_APPLICATION_BUILDER = '00000001';
 export const DOMAIN_DEPOSIT = '03000000';
@@ -86,7 +86,11 @@ export var DefinitionFlow;
     DefinitionFlow["Charon"] = "Charon-Command";
 })(DefinitionFlow || (DefinitionFlow = {}));
 export const DEFAULT_BASE_URL = 'https://api.obol.tech';
+export const DEFAULT_BASE_VERSION = 'v1';
 export const DEFAULT_CHAIN_ID = 17000;
 export const ETHER_TO_GWEI = 10 ** 9;
 export const TERMS_AND_CONDITIONS_VERSION = 1;
-export const TERMS_AND_CONDITIONS_URL = (TERMS_AND_CONDITIONS_VERSION === 1) ? 'https://obol.tech/terms.pdf' : `https://obol.tech/${TERMS_AND_CONDITIONS_VERSION}/terms.pdf`;
+export const TERMS_AND_CONDITIONS_URL = TERMS_AND_CONDITIONS_VERSION === 1
+    ? 'https://obol.org/terms.pdf'
+    : `https://obol.org/${TERMS_AND_CONDITIONS_VERSION}/terms.pdf`;
+export const TERMS_AND_CONDITIONS_HASH = '0xd33721644e8f3afab1495a74abe3523cec12d48b8da6cb760972492ca3f1a273';

package/dist/esm/src/index.js

@@ -9,12 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { v4 as uuidv4 } from 'uuid';
 import { Base } from './base.js';
-import { CONFLICT_ERROR_MSG, CreatorConfigHashSigningTypes, Domain, DKG_ALGORITHM, CONFIG_VERSION, OperatorConfigHashSigningTypes, EnrSigningTypes, TERMS_AND_CONDITIONS_VERSION, TermsAndConditionsSigningTypes, } from './constants.js';
+import { CONFLICT_ERROR_MSG, CreatorConfigHashSigningTypes, Domain, DKG_ALGORITHM, CONFIG_VERSION, OperatorConfigHashSigningTypes, EnrSigningTypes, TERMS_AND_CONDITIONS_VERSION, TermsAndConditionsSigningTypes, DEFAULT_BASE_VERSION, TERMS_AND_CONDITIONS_HASH, } from './constants.js';
 import { ConflictError } from './errors.js';
 import { clusterConfigOrDefinitionHash } from './verification/common.js';
 import { validatePayload } from './ajv.js';
 import { definitionSchema, operatorPayloadSchema } from './schema.js';
-import { hashTermsAndConditions } from './verification/termsAndConditions.js';
 export * from './types.js';
 export * from './services.js';
 /**
@@ -49,18 +48,18 @@ export class Client extends Base {
                 throw new Error('Signer is required in acceptObolTermsAndConditions');
             }
             try {
-                const termsAndConditionsHash = yield hashTermsAndConditions();
+                const termsAndConditionsHash = TERMS_AND_CONDITIONS_HASH;
                 const address = yield this.signer.getAddress();
                 const termsAndConditionsPayload = {
                     address,
                     version: TERMS_AND_CONDITIONS_VERSION,
-                    terms_and_conditions_hash: termsAndConditionsHash
+                    terms_and_conditions_hash: termsAndConditionsHash,
                 };
                 const termsAndConditionsSignature = yield this.signer.signTypedData(Domain(), TermsAndConditionsSigningTypes, {
                     terms_and_conditions_hash: termsAndConditionsHash,
                     version: TERMS_AND_CONDITIONS_VERSION,
                 });
-                const termsAndConditionsResponse = yield this.request('/termsAndConditions', {
+                const termsAndConditionsResponse = yield this.request(`/${DEFAULT_BASE_VERSION}/termsAndConditions`, {
                     method: 'POST',
                     body: JSON.stringify(termsAndConditionsPayload),
                     headers: {
@@ -92,13 +91,15 @@ export class Client extends Base {
                 throw new Error('Signer is required in createClusterDefinition');
             }
             validatePayload(newCluster, definitionSchema);
-            const clusterConfig = Object.assign(Object.assign({}, newCluster), { fork_version: this.fork_version, dkg_algorithm: DKG_ALGORITHM, version: CONFIG_VERSION, uuid: uuidv4(), timestamp: new Date().toISOString(), threshold: Math.ceil((2 * newCluster.operators.length) / 3), num_validators: newCluster.validators.length });
+            const clusterConfig = Object.assign(Object.assign({}, newCluster), { fork_version: this.fork_version, dkg_algorithm: DKG_ALGORITHM, version: CONFIG_VERSION, uuid: uuidv4(), timestamp: new Date().toISOString(), threshold: Math.ceil((2 * newCluster.operators.length) / 3), num_validators: newCluster.validators.length, deposit_amounts: newCluster.deposit_amounts
+                    ? newCluster.deposit_amounts
+                    : ['32000000000'] });
             try {
                 const address = yield this.signer.getAddress();
                 clusterConfig.creator = { address };
                 clusterConfig.config_hash = clusterConfigOrDefinitionHash(clusterConfig, true);
                 const creatorConfigSignature = yield this.signer.signTypedData(Domain(this.chainId), CreatorConfigHashSigningTypes, { creator_config_hash: clusterConfig.config_hash });
-                const clusterDefinition = yield this.request('/v1/definition', {
+                const clusterDefinition = yield this.request(`/${DEFAULT_BASE_VERSION}/definition`, {
                     method: 'POST',
                     body: JSON.stringify(clusterConfig),
                     headers: {
@@ -137,7 +138,7 @@ export class Client extends Base {
                 const operatorConfigSignature = yield this.signer.signTypedData(Domain(this.chainId), OperatorConfigHashSigningTypes, { operator_config_hash: configHash });
                 const operatorENRSignature = yield this.signer.signTypedData(Domain(this.chainId), EnrSigningTypes, { enr: operatorPayload.enr });
                 const operatorData = Object.assign(Object.assign({}, operatorPayload), { address, enr_signature: operatorENRSignature, fork_version: this.fork_version });
-                const clusterDefinition = yield this.request(`/v1/definition/${configHash}`, {
+                const clusterDefinition = yield this.request(`/${DEFAULT_BASE_VERSION}/definition/${configHash}`, {
                     method: 'PUT',
                     body: JSON.stringify(operatorData),
                     headers: {
@@ -161,7 +162,7 @@ export class Client extends Base {
      */
     getClusterDefinition(configHash) {
         return __awaiter(this, void 0, void 0, function* () {
-            const clusterDefinition = yield this.request(`/dv/${configHash}`, {
+            const clusterDefinition = yield this.request(`/${DEFAULT_BASE_VERSION}/definition/${configHash}`, {
                 method: 'GET',
             });
             return clusterDefinition;
@@ -177,7 +178,7 @@ export class Client extends Base {
      */
     getClusterLock(configHash) {
         return __awaiter(this, void 0, void 0, function* () {
-            const lock = yield this.request(`/lock/configHash/${configHash}`, {
+            const lock = yield this.request(`/${DEFAULT_BASE_VERSION}/lock/configHash/${configHash}`, {
                 method: 'GET',
             });
             return lock;

package/dist/esm/src/schema.js

@@ -52,6 +52,14 @@ export const definitionSchema = {
                 required: ['fee_recipient_address', 'withdrawal_address'],
             },
         },
+        deposit_amounts: {
+            type: 'array',
+            items: {
+                type: 'string',
+                pattern: '^[0-9]+$',
+            },
+            validDepositAmounts: true,
+        },
     },
     required: ['name', 'operators', 'validators'],
 };

package/dist/esm/src/utils.js

@@ -8,7 +8,7 @@ export const strToUint8Array = (str) => {
 export const definitionFlow = (clusterDefinition) => {
     if (clusterDefinition.creator.address &&
         clusterDefinition.creator.config_signature &&
-        clusterDefinition.operators.every((operator) => {
+        clusterDefinition.operators.every(operator => {
             return (operator.address &&
                 operator.config_signature &&
                 operator.enr &&
@@ -18,7 +18,7 @@ export const definitionFlow = (clusterDefinition) => {
     }
     else if (clusterDefinition.creator.address &&
         clusterDefinition.creator.config_signature &&
-        clusterDefinition.operators.every((operator) => {
+        clusterDefinition.operators.every(operator => {
             return (!operator.address &&
                 !operator.config_signature &&
                 operator.enr &&
@@ -28,7 +28,7 @@ export const definitionFlow = (clusterDefinition) => {
     }
     else if (!clusterDefinition.creator.address &&
         !clusterDefinition.creator.config_signature &&
-        clusterDefinition.operators.every((operator) => {
+        clusterDefinition.operators.every(operator => {
             return (!operator.address &&
                 !operator.config_signature &&
                 operator.enr &&

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

@@ -7,20 +7,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { fromHexString, } from '@chainsafe/ssz';
+import { fromHexString } from '@chainsafe/ssz';
 import elliptic from 'elliptic';
-import { init, } from '@chainsafe/bls';
-import { FORK_MAPPING } from '../types.js';
+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 { clusterDefinitionContainerTypeV1X6, hashClusterDefinitionV1X6, hashClusterLockV1X6, verifyDVV1X6, } from './v1.6.0.js';
+import { clusterDefinitionContainerTypeV1X7, hashClusterDefinitionV1X7, hashClusterLockV1X7, verifyDVV1X7, } from './v1.7.0.js';
 import { ethers } from 'ethers';
-import { DOMAIN_APPLICATION_BUILDER, DOMAIN_DEPOSIT, DefinitionFlow, GENESIS_VALIDATOR_ROOT, signCreatorConfigHashPayload, signEnrPayload, signOperatorConfigHashPayload } from '../constants.js';
+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 { 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 { clusterDefinitionContainerTypeV1X8, hashClusterDefinitionV1X8, hashClusterLockV1X8, verifyDVV1X8, } from './v1.8.0.js';
 // cluster-definition hash
 /**
  * @param cluster The cluster configuration or the cluster definition
@@ -32,17 +32,20 @@ export const clusterConfigOrDefinitionHash = (cluster, configOnly) => {
     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'));
+        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'));
+        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'));
+        return ('0x' +
+            Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex'));
     }
     throw new Error('unsupported version');
 };
@@ -112,7 +115,7 @@ const verifyDefinitionSignatures = (clusterDefinition, definitionType) => {
         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() ||
@@ -188,15 +191,24 @@ export const verifyBuilderRegistration = (validator, feeRecipientAddress, forkVe
     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) };
+        return {
+            isValidBuilderRegistration: false,
+            builderRegistrationMsg: new Uint8Array(0),
+        };
     }
     if (feeRecipientAddress.toLowerCase() !==
         validator.builder_registration.message.fee_recipient.toLowerCase()) {
-        return { isValidBuilderRegistration: false, builderRegistrationMsg: new Uint8Array(0) };
+        return {
+            isValidBuilderRegistration: false,
+            builderRegistrationMsg: new Uint8Array(0),
+        };
     }
     const builderRegistrationMessageBuffer = computebuilderRegistrationMsgRoot(validator.builder_registration.message);
     const builderRegistrationMessage = signingRoot(builderDomain, builderRegistrationMessageBuffer);
-    return { isValidBuilderRegistration: true, builderRegistrationMsg: builderRegistrationMessage };
+    return {
+        isValidBuilderRegistration: true,
+        builderRegistrationMsg: builderRegistrationMessage,
+    };
 };
 export const verifyNodeSignatures = (clusterLock) => {
     const ec = new elliptic.ec('secp256k1');

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

@@ -1,4 +1,4 @@
-import { ByteListType, ByteVectorType, ContainerType, UintNumberType } from '@chainsafe/ssz';
+import { ByteListType, ByteVectorType, ContainerType, UintNumberType, } from '@chainsafe/ssz';
 export const operatorAddressWrapperType = new ContainerType({
     address: new ByteVectorType(20),
 });

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

@@ -23,7 +23,7 @@ export const hashTermsAndConditions = () => __awaiter(void 0, void 0, void 0, fu
             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);
+        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'));
     }

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

@@ -1,9 +1,9 @@
-import { UintNumberType } from '@chainsafe/ssz/lib/type/uint';
+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 { 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';
+import { aggregateSignatures, verifyAggregate, verifyMultiple, } from '@chainsafe/bls';
 /**
  * Returns the containerized cluster definition
  * @param cluster ClusterDefinition to calculate the type from
@@ -56,7 +56,7 @@ export const hashClusterDefinitionV1X6 = (cluster, configOnly) => {
             address: fromHexString(cluster.creator.address),
             config_signature: fromHexString(cluster.creator.config_signature),
         };
-    val.validators = cluster.validators.map((validator) => {
+    val.validators = cluster.validators.map(validator => {
         return {
             fee_recipient_address: fromHexString(validator.fee_recipient_address),
             withdrawal_address: fromHexString(validator.withdrawal_address),

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

@@ -1,9 +1,9 @@
-import { UintNumberType } from '@chainsafe/ssz/lib/type/uint';
+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';
+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
@@ -56,7 +56,7 @@ export const hashClusterDefinitionV1X7 = (cluster, configOnly) => {
             address: fromHexString(cluster.creator.address),
             config_signature: fromHexString(cluster.creator.config_signature),
         };
-    val.validators = cluster.validators.map((validator) => {
+    val.validators = cluster.validators.map(validator => {
         return {
             fee_recipient_address: fromHexString(validator.fee_recipient_address),
             withdrawal_address: fromHexString(validator.withdrawal_address),
@@ -92,11 +92,11 @@ export const hashClusterLockV1X7 = (cluster) => {
     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) => {
+    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)),
+            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),

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

@@ -1,9 +1,9 @@
-import { UintNumberType } from '@chainsafe/ssz/lib/type/uint';
+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';
+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
@@ -57,7 +57,7 @@ export const hashClusterDefinitionV1X8 = (cluster, configOnly) => {
             address: fromHexString(cluster.creator.address),
             config_signature: fromHexString(cluster.creator.config_signature),
         };
-    val.validators = cluster.validators.map((validator) => {
+    val.validators = cluster.validators.map(validator => {
         return {
             fee_recipient_address: fromHexString(validator.fee_recipient_address),
             withdrawal_address: fromHexString(validator.withdrawal_address),
@@ -140,8 +140,8 @@ export const verifyDVV1X8 = (clusterLock) => {
             pubShares.push(fromHexString(element));
         }
         // Deposit Data Verification
-        for (let j = 0; j < validator.partial_deposit_data.length; j++) {
-            const depositData = validator.partial_deposit_data[j];
+        for (const element of validator.partial_deposit_data) {
+            const depositData = element;
             const { isValidDepositData, depositDataMsg } = verifyDepositData(distributedPublicKey, depositData, clusterLock.cluster_definition.validators[i].withdrawal_address, clusterLock.cluster_definition.fork_version);
             if (!isValidDepositData) {
                 return false;