@obolnetwork/obol-sdk 2.4.6 → 2.5.1

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

@@ -38,7 +38,6 @@ const index_1 = require("../src/index");
 const fixtures_js_1 = require("./fixtures.js");
 const constants_1 = require("../src/constants");
 const base_1 = require("../src/base");
-const ajv_1 = require("../src/ajv");
 const msw_1 = require("msw");
 const node_1 = require("msw/node");
 const termsAndConditions_1 = require("../src/verification/termsAndConditions");
@@ -65,31 +64,31 @@ describe('Cluster Client', () => {
         clientInstance['request'] = jest
             .fn()
             .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
-        const configHash = yield clientInstance.createClusterDefinition(fixtures_js_1.clusterConfigV1X8);
+        const configHash = yield clientInstance.createClusterDefinition(fixtures_js_1.clusterConfigV1X10);
         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.clusterLockV1X8.cluster_definition));
+            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X10.cluster_definition));
         const clusterDefinition = yield clientInstance.acceptClusterDefinition({
-            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);
+            enr: fixtures_js_1.clusterLockV1X10.cluster_definition.operators[0].enr,
+            version: fixtures_js_1.clusterLockV1X10.cluster_definition.version,
+        }, fixtures_js_1.clusterLockV1X10.cluster_definition.config_hash);
+        expect(clusterDefinition).toEqual(fixtures_js_1.clusterLockV1X10.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.clusterConfigV1X8), { operators: [] }));
+            yield clientInstance.createClusterDefinition(Object.assign(Object.assign({}, fixtures_js_1.clusterConfigV1X10), { operators: [] }));
         }
         catch (error) {
-            expect(error.message).toEqual("Schema compilation errors', must NOT have fewer than 4 items");
+            expect(error.message).toEqual('Validation failed: /operators must pass "validateUniqueAddresses" keyword validation, /operators must NOT have fewer than 4 items');
         }
     }));
-    // cause we default to 32000000000
+    // cause we default to null
     test('createClusterDefinition should accept a configuration without deposit_amounts', () => __awaiter(void 0, void 0, void 0, function* () {
         clientInstance['request'] = jest
             .fn()
@@ -105,32 +104,27 @@ describe('Cluster Client', () => {
             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.clusterConfigV1X8), { operators: [] }), '');
-        }
-        catch (error) {
-            expect(error.message).toEqual('schema must be object or boolean');
+            expect(error.message).toEqual('Validation failed: /deposit_amounts/0 must be equal to one of the allowed values, /deposit_amounts must match "then" schema');
         }
     }));
     test('getClusterdefinition should return cluster definition if config hash exist', () => __awaiter(void 0, void 0, void 0, function* () {
-        var _a;
         clientInstance['request'] = jest
             .fn()
-            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X8.cluster_definition));
-        const clusterDefinition = yield clientInstance.getClusterDefinition(fixtures_js_1.clusterLockV1X8.cluster_definition.config_hash);
-        expect((_a = clusterDefinition.deposit_amounts) === null || _a === void 0 ? void 0 : _a.length).toEqual(fixtures_js_1.clusterLockV1X8.cluster_definition.deposit_amounts.length);
-        expect(clusterDefinition.config_hash).toEqual(fixtures_js_1.clusterLockV1X8.cluster_definition.config_hash);
+            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X10.cluster_definition));
+        const clusterDefinition = yield clientInstance.getClusterDefinition(fixtures_js_1.clusterLockV1X10.cluster_definition.config_hash);
+        expect(clusterDefinition.deposit_amounts).toBeDefined();
+        expect(clusterDefinition.config_hash).toEqual(fixtures_js_1.clusterLockV1X10.cluster_definition.config_hash);
+        // Test for new fields
+        expect(clusterDefinition.compounding).toBeDefined();
+        expect(clusterDefinition.target_gas_limit).toBeDefined();
+        expect(clusterDefinition.consensus_protocol).toBeDefined();
     }));
     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.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);
+            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X10));
+        const clusterLock = yield clientInstance.getClusterLock(fixtures_js_1.clusterLockV1X10.cluster_definition.config_hash);
+        expect(clusterLock.lock_hash).toEqual(fixtures_js_1.clusterLockV1X10.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 }) => {
@@ -170,7 +164,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.clusterConfigV1X8);
+            yield clientInstance.createClusterDefinition(fixtures_js_1.clusterConfigV1X10);
         }
         catch (err) {
             expect(err.message).toEqual('Signer is required in createClusterDefinition');
@@ -179,9 +173,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.clusterLockV1X8.cluster_definition.operators[0].enr,
-                version: fixtures_js_1.clusterLockV1X8.cluster_definition.version,
-            }, fixtures_js_1.clusterLockV1X8.cluster_definition.config_hash);
+                enr: fixtures_js_1.clusterLockV1X10.cluster_definition.operators[0].enr,
+                version: fixtures_js_1.clusterLockV1X10.cluster_definition.version,
+            }, fixtures_js_1.clusterLockV1X10.cluster_definition.config_hash);
         }
         catch (err) {
             expect(err.message).toEqual('Signer is required in acceptClusterDefinition');
@@ -190,16 +184,16 @@ 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.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);
+            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X10.cluster_definition));
+        const clusterDefinition = yield clientInstance.getClusterDefinition(fixtures_js_1.clusterLockV1X10.cluster_definition.config_hash);
+        expect(clusterDefinition.config_hash).toEqual(fixtures_js_1.clusterLockV1X10.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.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);
+            .mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X10));
+        const clusterLock = yield clientInstance.getClusterLock(fixtures_js_1.clusterLockV1X10.cluster_definition.config_hash);
+        expect(clusterLock.lock_hash).toEqual(fixtures_js_1.clusterLockV1X10.lock_hash);
     }));
     test.each([
         { version: 'v1.6.0', clusterLock: fixtures_js_1.clusterLockV1X6 },
@@ -306,7 +300,7 @@ describe('createObolRewardsSplit', () => {
             });
         }
         catch (error) {
-            expect(error.message).toEqual('Schema compilation errors\', must pass "validateSplitRecipients" keyword validation');
+            expect(error.message).toEqual('Validation failed:  must pass "validateRewardsSplitRecipients" keyword validation');
         }
     }));
     test('should throw an error if ObolRAFSplit is less than 1', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -319,7 +313,7 @@ describe('createObolRewardsSplit', () => {
             });
         }
         catch (error) {
-            expect(error.message).toEqual("Schema compilation errors', must be >= 1");
+            expect(error.message).toEqual('Validation failed:  must pass "validateRewardsSplitRecipients" keyword validation, /ObolRAFSplit must be >= 1');
         }
     }));
     it('should return the correct withdrawal and fee recipient addresses', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -386,7 +380,7 @@ describe('createObolTotalSplit', () => {
             });
         }
         catch (error) {
-            expect(error.message).toEqual('Schema compilation errors\', must pass "validateSplitRecipients" keyword validation');
+            expect(error.message).toEqual('Validation failed:  must pass "validateTotalSplitRecipients" keyword validation');
         }
     }));
     test('should throw an error if ObolRAFSplit is less than 0.1', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -397,13 +391,13 @@ describe('createObolTotalSplit', () => {
             });
         }
         catch (error) {
-            expect(error.message).toEqual("Schema compilation errors', must be >= 0.1");
+            expect(error.message).toEqual('Validation failed:  must pass "validateTotalSplitRecipients" keyword validation, /ObolRAFSplit must be >= 0.1');
         }
     }));
     it('should return the correct withdrawal and fee recipient addresses and ObolRAFSplit', () => __awaiter(void 0, void 0, void 0, function* () {
         const result = yield clientInstance.createObolTotalSplit({
             splitRecipients: mockSplitRecipients,
-            ObolRAFSplit: 0.5,
+            ObolRAFSplit: 0.1,
         });
         // 0xPredictedAddress and not 0xSplitterAddress since were mocking isContractAvailable response to be true
         expect(result).toEqual({

package/dist/esm/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@obolnetwork/obol-sdk",
-    "version": "2.4.6",
+    "version": "2.5.1",
     "description": "A package for creating Distributed Validators using the Obol API.",
     "bugs": {
         "url": "https://github.com/obolnetwork/obol-sdk/issues"
@@ -49,6 +49,8 @@
         "@safe-global/safe-core-sdk-types": "5.1.0",
         "@types/pdf-parse": "^1.1.4",
         "ajv": "^8.12.0",
+        "ajv-formats": "^3.0.1",
+        "ajv-keywords": "^5.1.0",
         "cross-fetch": "^3.1.5",
         "dotenv": "^16.4.7",
         "elliptic": "^6.5.4",

package/dist/esm/src/ajv.js

@@ -1,53 +1,79 @@
-import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import addKeywords from 'ajv-keywords';
 import { parseUnits } from 'ethers';
+import Ajv from 'ajv';
 import { DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT, DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT, } from './constants';
-const 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;
+export const VALID_DEPOSIT_AMOUNTS = [
+    parseUnits('1', 'gwei').toString(),
+    parseUnits('32', 'gwei').toString(),
+    parseUnits('8', 'gwei').toString(),
+    parseUnits('256', 'gwei').toString(),
+];
+export const VALID_NON_COMPOUNDING_AMOUNTS = [
+    parseUnits('1', 'gwei').toString(),
+    parseUnits('32', 'gwei').toString(),
+];
+// They dont see defaults set in schema
+const validateRewardsSplitRecipients = (_, data) => {
+    var _a;
+    const obolRAFSplit = (_a = data.ObolRAFSplit) !== null && _a !== void 0 ? _a : DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT;
+    const splitPercentage = data.splitRecipients.reduce((acc, curr) => acc + curr.percentAllocation, 0);
+    return splitPercentage + obolRAFSplit === 100;
+};
+const validateTotalSplitRecipients = (_, data) => {
+    var _a;
+    const obolRAFSplit = (_a = data.ObolRAFSplit) !== null && _a !== void 0 ? _a : DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT;
+    const splitPercentage = data.splitRecipients.reduce((acc, curr) => acc + curr.percentAllocation, 0);
+    return splitPercentage + obolRAFSplit === 100;
+};
+const validateUniqueAddresses = (_, operators) => {
+    if (!operators) {
+        return false;
     }
-    if (sum / minDeposit !== 32) {
+    if (operators.length < 4) {
         return false;
     }
-    else {
+    if (operators.every(op => op.address === '')) {
         return true;
     }
+    if (operators.some(op => op.address.length !== 42)) {
+        return false;
+    }
+    const addresses = operators.map(op => op.address);
+    const uniqueAddresses = new Set(addresses);
+    const isUnique = uniqueAddresses.size === addresses.length;
+    return isUnique;
 };
-const validateSplitRecipients = (_, data) => {
-    const splitPercentage = data.splitRecipients.reduce((acc, curr) => acc + curr.percentAllocation, 0);
-    const ObolRAFSplitParam = data.ObolRAFSplit
-        ? data.ObolRAFSplit
-        : 'principalRecipient' in data
-            ? DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT
-            : DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT;
-    return splitPercentage + ObolRAFSplitParam === 100;
-};
+const ajv = new Ajv({
+    allErrors: true,
+    useDefaults: true,
+    strict: false,
+    $data: true,
+});
+addFormats(ajv);
+addKeywords(ajv, ['patternRequired']);
+ajv.addKeyword({
+    keyword: 'validateRewardsSplitRecipients',
+    validate: validateRewardsSplitRecipients,
+    schemaType: 'boolean',
+});
+ajv.addKeyword({
+    keyword: 'validateTotalSplitRecipients',
+    validate: validateTotalSplitRecipients,
+    schemaType: 'boolean',
+});
+ajv.addKeyword({
+    keyword: 'validateUniqueAddresses',
+    validate: validateUniqueAddresses,
+    schemaType: 'boolean',
+});
 export function validatePayload(data, schema) {
     var _a;
-    const ajv = new Ajv();
-    ajv.addKeyword({
-        keyword: 'validDepositAmounts',
-        validate: validDepositAmounts,
-        errors: true,
-    });
-    ajv.addKeyword({
-        keyword: 'validateSplitRecipients',
-        validate: validateSplitRecipients,
-        errors: true,
-    });
     const validate = ajv.compile(schema);
-    const isValid = validate(data);
-    if (!isValid) {
-        throw new Error(`Schema compilation errors', ${(_a = validate.errors) === null || _a === void 0 ? void 0 : _a[0].message}`);
+    const valid = validate(data);
+    if (!valid) {
+        const errors = (_a = validate.errors) === null || _a === void 0 ? void 0 : _a.map(e => `${e.instancePath} ${e.message}`).join(', ');
+        throw new Error(`Validation failed: ${errors}`);
     }
-    return isValid;
+    return data;
 }

package/dist/esm/src/constants.js

@@ -77,7 +77,7 @@ export const signEnrPayload = (payload, chainId) => {
     };
 };
 export const DKG_ALGORITHM = 'default';
-export const CONFIG_VERSION = 'v1.8.0';
+export const CONFIG_VERSION = 'v1.10.0';
 export const SDK_VERSION = pjson.version;
 export const DOMAIN_APPLICATION_BUILDER = '00000001';
 export const DOMAIN_DEPOSIT = '03000000';

package/dist/esm/src/index.js

@@ -7,10 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { ZeroAddress } from 'ethers';
 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, DEFAULT_BASE_VERSION, TERMS_AND_CONDITIONS_HASH, AVAILABLE_SPLITTER_CHAINS, CHAIN_CONFIGURATION, DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT, DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT, OBOL_SDK_EMAIL, } 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, AVAILABLE_SPLITTER_CHAINS, CHAIN_CONFIGURATION, DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT, OBOL_SDK_EMAIL, } from './constants.js';
 import { ConflictError } from './errors.js';
 import { clusterConfigOrDefinitionHash } from './verification/common.js';
 import { validatePayload } from './ajv.js';
@@ -22,6 +21,7 @@ export * from './types.js';
 export * from './services.js';
 export * from './verification/signature-validator.js';
 export * from './verification/common.js';
+export * from './constants.js';
 export { Incentives } from './incentives.js';
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.
@@ -102,13 +102,13 @@ export class Client extends Base {
      * [createObolRewardsSplit](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L141)
      */
     // add the example reference
-    createObolRewardsSplit({ splitRecipients, principalRecipient, etherAmount, ObolRAFSplit = DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT, distributorFee = 0, controllerAddress = ZeroAddress, recoveryAddress = ZeroAddress, }) {
+    createObolRewardsSplit({ splitRecipients, principalRecipient, etherAmount, ObolRAFSplit = DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT, distributorFee, controllerAddress, recoveryAddress, }) {
         return __awaiter(this, void 0, void 0, function* () {
             // This method doesnt require T&C signature
             if (!this.signer) {
                 throw new Error('Signer is required in createObolRewardsSplit');
             }
-            validatePayload({
+            const validatedPayload = validatePayload({
                 splitRecipients,
                 principalRecipient,
                 etherAmount,
@@ -131,9 +131,9 @@ export class Client extends Base {
             }
             const retroActiveFundingRecipient = {
                 account: CHAIN_CONFIGURATION[this.chainId].RETROACTIVE_FUNDING_ADDRESS.address,
-                percentAllocation: ObolRAFSplit,
+                percentAllocation: validatedPayload.ObolRAFSplit,
             };
-            const copiedSplitRecipients = [...splitRecipients];
+            const copiedSplitRecipients = [...validatedPayload.splitRecipients];
             copiedSplitRecipients.push(retroActiveFundingRecipient);
             const { accounts, percentAllocations } = formatSplitRecipients(copiedSplitRecipients);
             const predictedSplitterAddress = yield predictSplitterAddress({
@@ -141,8 +141,8 @@ export class Client extends Base {
                 accounts,
                 percentAllocations,
                 chainId: this.chainId,
-                distributorFee,
-                controllerAddress,
+                distributorFee: validatedPayload.distributorFee,
+                controllerAddress: validatedPayload.controllerAddress,
             });
             const isSplitterDeployed = yield isContractAvailable(predictedSplitterAddress, this.signer.provider);
             const { withdrawal_address, fee_recipient_address } = yield handleDeployOWRAndSplitter({
@@ -151,12 +151,12 @@ export class Client extends Base {
                 predictedSplitterAddress,
                 accounts,
                 percentAllocations,
-                principalRecipient,
-                etherAmount,
+                principalRecipient: validatedPayload.principalRecipient,
+                etherAmount: validatedPayload.etherAmount,
                 chainId: this.chainId,
-                distributorFee,
-                controllerAddress,
-                recoveryAddress,
+                distributorFee: validatedPayload.distributorFee,
+                controllerAddress: validatedPayload.controllerAddress,
+                recoveryAddress: validatedPayload.recoveryAddress,
             });
             return { withdrawal_address, fee_recipient_address };
         });
@@ -175,13 +175,13 @@ export class Client extends Base {
      * [createObolTotalSplit](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L168)
      */
     // add the example reference
-    createObolTotalSplit({ splitRecipients, ObolRAFSplit = DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT, distributorFee = 0, controllerAddress = ZeroAddress, }) {
+    createObolTotalSplit({ splitRecipients, ObolRAFSplit, distributorFee, controllerAddress, }) {
         return __awaiter(this, void 0, void 0, function* () {
             // This method doesnt require T&C signature
             if (!this.signer) {
                 throw new Error('Signer is required in createObolTotalSplit');
             }
-            validatePayload({
+            const validatedPayload = validatePayload({
                 splitRecipients,
                 ObolRAFSplit,
                 distributorFee,
@@ -197,9 +197,9 @@ export class Client extends Base {
             }
             const retroActiveFundingRecipient = {
                 account: CHAIN_CONFIGURATION[this.chainId].RETROACTIVE_FUNDING_ADDRESS.address,
-                percentAllocation: ObolRAFSplit,
+                percentAllocation: validatedPayload.ObolRAFSplit,
             };
-            const copiedSplitRecipients = [...splitRecipients];
+            const copiedSplitRecipients = [...validatedPayload.splitRecipients];
             copiedSplitRecipients.push(retroActiveFundingRecipient);
             const { accounts, percentAllocations } = formatSplitRecipients(copiedSplitRecipients);
             const predictedSplitterAddress = yield predictSplitterAddress({
@@ -207,8 +207,8 @@ export class Client extends Base {
                 accounts,
                 percentAllocations,
                 chainId: this.chainId,
-                distributorFee,
-                controllerAddress,
+                distributorFee: validatedPayload.distributorFee,
+                controllerAddress: validatedPayload.controllerAddress,
             });
             const isSplitterDeployed = yield isContractAvailable(predictedSplitterAddress, this.signer.provider);
             if (!isSplitterDeployed) {
@@ -217,8 +217,8 @@ export class Client extends Base {
                     accounts,
                     percentAllocations,
                     chainId: this.chainId,
-                    distributorFee,
-                    controllerAddress,
+                    distributorFee: validatedPayload.distributorFee,
+                    controllerAddress: validatedPayload.controllerAddress,
                 });
                 return {
                     withdrawal_address: splitterAddress,
@@ -265,10 +265,8 @@ export class Client extends Base {
             if (!this.signer) {
                 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, deposit_amounts: newCluster.deposit_amounts
-                    ? newCluster.deposit_amounts
-                    : ['32000000000'] });
+            const validatedCluster = validatePayload(newCluster, definitionSchema);
+            const clusterConfig = Object.assign(Object.assign({}, validatedCluster), { fork_version: this.fork_version, dkg_algorithm: DKG_ALGORITHM, version: CONFIG_VERSION, uuid: uuidv4(), timestamp: new Date().toISOString(), threshold: Math.ceil((2 * validatedCluster.operators.length) / 3), num_validators: validatedCluster.validators.length });
             try {
                 const address = yield this.signer.getAddress();
                 clusterConfig.creator = { address };
@@ -307,12 +305,12 @@ export class Client extends Base {
             if (!this.signer) {
                 throw new Error('Signer is required in acceptClusterDefinition');
             }
-            validatePayload(operatorPayload, operatorPayloadSchema);
+            const validatedPayload = validatePayload(operatorPayload, operatorPayloadSchema);
             try {
                 const address = yield this.signer.getAddress();
                 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 operatorENRSignature = yield this.signer.signTypedData(Domain(this.chainId), EnrSigningTypes, { enr: validatedPayload.enr });
+                const operatorData = Object.assign(Object.assign({}, validatedPayload), { address, enr_signature: operatorENRSignature, fork_version: this.fork_version });
                 const clusterDefinition = yield this.request(`/${DEFAULT_BASE_VERSION}/definition/${configHash}`, {
                     method: 'PUT',
                     body: JSON.stringify(operatorData),

package/dist/esm/src/schema.js

@@ -1,37 +1,31 @@
+import { ZeroAddress } from 'ethers';
 import { DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT, DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT, } from './constants';
+import { VALID_DEPOSIT_AMOUNTS, VALID_NON_COMPOUNDING_AMOUNTS } from './ajv';
 export const operatorPayloadSchema = {
     type: 'object',
     properties: {
-        version: {
-            type: 'string',
-        },
-        enr: {
-            type: 'string',
-        },
+        version: { type: 'string' },
+        enr: { type: 'string' },
     },
     required: ['version', 'enr'],
 };
 export const definitionSchema = {
     type: 'object',
     properties: {
-        name: {
-            type: 'string',
-        },
+        name: { type: 'string' },
         operators: {
             type: 'array',
             minItems: 4,
-            uniqueItems: true,
             items: {
                 type: 'object',
                 properties: {
                     address: {
                         type: 'string',
-                        minLength: 42,
-                        maxLength: 42,
                     },
                 },
                 required: ['address'],
             },
+            validateUniqueAddresses: true,
         },
         validators: {
             type: 'array',
@@ -52,12 +46,39 @@ export const definitionSchema = {
             },
         },
         deposit_amounts: {
-            type: 'array',
+            type: ['array', 'null'],
             items: {
                 type: 'string',
                 pattern: '^[0-9]+$',
             },
-            validDepositAmounts: true,
+            if: {
+                $data: '1/compounding',
+            },
+            then: {
+                items: {
+                    enum: VALID_DEPOSIT_AMOUNTS,
+                },
+            },
+            else: {
+                items: {
+                    enum: VALID_NON_COMPOUNDING_AMOUNTS,
+                },
+            },
+            default: null,
+        },
+        compounding: {
+            type: 'boolean',
+            default: false,
+        },
+        target_gas_limit: {
+            type: 'number',
+            minimum: 1,
+            default: 36000000,
+        },
+        consensus_protocol: {
+            type: 'string',
+            enum: ['qbft', ''],
+            default: '',
         },
     },
     required: ['name', 'operators', 'validators'],
@@ -74,9 +95,7 @@ export const totalSplitterPayloadSchema = {
                         type: 'string',
                         pattern: '^0x[a-fA-F0-9]{40}$',
                     },
-                    percentAllocation: {
-                        type: 'number',
-                    },
+                    percentAllocation: { type: 'number' },
                 },
                 required: ['account', 'percentAllocation'],
             },
@@ -84,29 +103,37 @@ export const totalSplitterPayloadSchema = {
         ObolRAFSplit: {
             type: 'number',
             minimum: DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT,
+            default: DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT,
         },
         distributorFee: {
             type: 'number',
             maximum: 10,
             multipleOf: 0.01,
+            default: 0,
         },
         controllerAddress: {
             type: 'string',
             pattern: '^0x[a-fA-F0-9]{40}$',
+            default: ZeroAddress,
         },
-        validateSplitRecipients: true,
     },
+    validateTotalSplitRecipients: true,
     required: ['splitRecipients'],
 };
-export const rewardsSplitterPayloadSchema = Object.assign(Object.assign({}, totalSplitterPayloadSchema), { properties: Object.assign(Object.assign({}, totalSplitterPayloadSchema.properties), { ObolRAFSplit: {
+export const rewardsSplitterPayloadSchema = {
+    type: 'object',
+    properties: Object.assign(Object.assign({}, totalSplitterPayloadSchema.properties), { ObolRAFSplit: {
             type: 'number',
             minimum: DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
+            default: DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
         }, recoveryAddress: {
             type: 'string',
             pattern: '^0x[a-fA-F0-9]{40}$',
-        }, etherAmount: {
-            type: 'number',
-        }, principalRecipient: {
+            default: ZeroAddress,
+        }, etherAmount: { type: 'number' }, principalRecipient: {
             type: 'string',
             pattern: '^0x[a-fA-F0-9]{40}$',
-        } }), required: ['splitRecipients', 'principalRecipient', 'etherAmount'] });
+        } }),
+    validateRewardsSplitRecipients: true,
+    required: ['splitRecipients', 'principalRecipient', 'etherAmount'],
+};

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

@@ -141,6 +141,24 @@ export const verifyDVV1X8 = (clusterLock) => {
         for (const element of validatorPublicShares) {
             pubShares.push(fromHexString(element));
         }
+        // Check deposit amounts match exactly if they are defined
+        const depositAmounts = clusterLock.cluster_definition.deposit_amounts;
+        if (depositAmounts !== null) {
+            const partialDepositAmounts = validator.partial_deposit_data.map(d => d.amount);
+            if ((depositAmounts === null || depositAmounts === void 0 ? void 0 : depositAmounts.length) !== partialDepositAmounts.length) {
+                return false;
+            }
+            // Check that both arrays contain exactly the same elements
+            const sortedDepositAmounts = [...depositAmounts]
+                .map(Number)
+                .sort((a, b) => a - b);
+            const sortedPartialAmounts = [...partialDepositAmounts]
+                .map(Number)
+                .sort((a, b) => a - b);
+            if (!sortedDepositAmounts.every((amount, index) => amount === sortedPartialAmounts[index])) {
+                return false;
+            }
+        }
         // Deposit Data Verification
         for (const element of validator.partial_deposit_data) {
             const depositData = element;