@obolnetwork/obol-sdk 2.4.5 → 2.5.0

package/dist/esm/test/methods.test.js

@@ -10,10 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var _a, _b;
 import { ethers, JsonRpcProvider } from 'ethers';
 import { Client, validateClusterLock } from '../src/index';
-import { clusterConfigV1X7, clusterConfigV1X8, clusterLockV1X10, clusterLockV1X6, clusterLockV1X7, clusterLockV1X8, clusterLockWithCompoundingWithdrawals, clusterLockWithSafe, nullDepositAmountsClusterLockV1X8, } from './fixtures.js';
+import { clusterConfigV1X7, clusterConfigV1X10, clusterLockV1X10, clusterLockV1X6, clusterLockV1X7, clusterLockV1X8, clusterLockWithCompoundingWithdrawals, clusterLockWithSafe, nullDepositAmountsClusterLockV1X8, } from './fixtures.js';
 import { SDK_VERSION } from '../src/constants';
 import { Base } from '../src/base';
-import { validatePayload } from '../src/ajv';
 import { HttpResponse, http } from 'msw';
 import { setupServer } from 'msw/node';
 import { hashTermsAndConditions } from '../src/verification/termsAndConditions';
@@ -40,31 +39,31 @@ describe('Cluster Client', () => {
         clientInstance['request'] = jest
             .fn()
             .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
-        const configHash = yield clientInstance.createClusterDefinition(clusterConfigV1X8);
+        const configHash = yield clientInstance.createClusterDefinition(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(clusterLockV1X8.cluster_definition));
+            .mockReturnValue(Promise.resolve(clusterLockV1X10.cluster_definition));
         const clusterDefinition = yield clientInstance.acceptClusterDefinition({
-            enr: clusterLockV1X8.cluster_definition.operators[0].enr,
-            version: clusterLockV1X8.cluster_definition.version,
-        }, clusterLockV1X8.cluster_definition.config_hash);
-        expect(clusterDefinition).toEqual(clusterLockV1X8.cluster_definition);
+            enr: clusterLockV1X10.cluster_definition.operators[0].enr,
+            version: clusterLockV1X10.cluster_definition.version,
+        }, clusterLockV1X10.cluster_definition.config_hash);
+        expect(clusterDefinition).toEqual(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({}, clusterConfigV1X8), { operators: [] }));
+            yield clientInstance.createClusterDefinition(Object.assign(Object.assign({}, 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()
@@ -80,32 +79,27 @@ describe('Cluster Client', () => {
             yield clientInstance.createClusterDefinition(Object.assign(Object.assign({}, 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 {
-            validatePayload(Object.assign(Object.assign({}, 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(clusterLockV1X8.cluster_definition));
-        const clusterDefinition = yield clientInstance.getClusterDefinition(clusterLockV1X8.cluster_definition.config_hash);
-        expect((_a = clusterDefinition.deposit_amounts) === null || _a === void 0 ? void 0 : _a.length).toEqual(clusterLockV1X8.cluster_definition.deposit_amounts.length);
-        expect(clusterDefinition.config_hash).toEqual(clusterLockV1X8.cluster_definition.config_hash);
+            .mockReturnValue(Promise.resolve(clusterLockV1X10.cluster_definition));
+        const clusterDefinition = yield clientInstance.getClusterDefinition(clusterLockV1X10.cluster_definition.config_hash);
+        expect(clusterDefinition.deposit_amounts).toBeDefined();
+        expect(clusterDefinition.config_hash).toEqual(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(clusterLockV1X8));
-        const clusterLock = yield clientInstance.getClusterLock(clusterLockV1X8.cluster_definition.config_hash);
-        expect(clusterLock.lock_hash).toEqual(clusterLockV1X8.lock_hash);
+            .mockReturnValue(Promise.resolve(clusterLockV1X10));
+        const clusterLock = yield clientInstance.getClusterLock(clusterLockV1X10.cluster_definition.config_hash);
+        expect(clusterLock.lock_hash).toEqual(clusterLockV1X10.lock_hash);
     }));
     test('request method should set user agent header', () => __awaiter(void 0, void 0, void 0, function* () {
         const server = setupServer(http.get('http://testexample.com/test', ({ request }) => {
@@ -140,9 +134,12 @@ describe('Cluster Client without a signer', () => {
     beforeAll(() => {
         jest.restoreAllMocks();
     });
+    beforeEach(() => {
+        jest.resetModules();
+    });
     test('createClusterDefinition should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
         try {
-            yield clientInstance.createClusterDefinition(clusterConfigV1X8);
+            yield clientInstance.createClusterDefinition(clusterConfigV1X10);
         }
         catch (err) {
             expect(err.message).toEqual('Signer is required in createClusterDefinition');
@@ -151,9 +148,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: clusterLockV1X8.cluster_definition.operators[0].enr,
-                version: clusterLockV1X8.cluster_definition.version,
-            }, clusterLockV1X8.cluster_definition.config_hash);
+                enr: clusterLockV1X10.cluster_definition.operators[0].enr,
+                version: clusterLockV1X10.cluster_definition.version,
+            }, clusterLockV1X10.cluster_definition.config_hash);
         }
         catch (err) {
             expect(err.message).toEqual('Signer is required in acceptClusterDefinition');
@@ -162,16 +159,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(clusterLockV1X8.cluster_definition));
-        const clusterDefinition = yield clientInstance.getClusterDefinition(clusterLockV1X8.cluster_definition.config_hash);
-        expect(clusterDefinition.config_hash).toEqual(clusterLockV1X8.cluster_definition.config_hash);
+            .mockReturnValue(Promise.resolve(clusterLockV1X10.cluster_definition));
+        const clusterDefinition = yield clientInstance.getClusterDefinition(clusterLockV1X10.cluster_definition.config_hash);
+        expect(clusterDefinition.config_hash).toEqual(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(clusterLockV1X8));
-        const clusterLock = yield clientInstance.getClusterLock(clusterLockV1X8.cluster_definition.config_hash);
-        expect(clusterLock.lock_hash).toEqual(clusterLockV1X8.lock_hash);
+            .mockReturnValue(Promise.resolve(clusterLockV1X10));
+        const clusterLock = yield clientInstance.getClusterLock(clusterLockV1X10.cluster_definition.config_hash);
+        expect(clusterLock.lock_hash).toEqual(clusterLockV1X10.lock_hash);
     }));
     test.each([
         { version: 'v1.6.0', clusterLock: clusterLockV1X6 },
@@ -194,6 +191,14 @@ describe('Cluster Client without a signer', () => {
         const isValidLock = yield validateClusterLock(clusterLock);
         expect(isValidLock).toEqual(true);
     }));
+    test('should return true on verified cluster lock with Safe wallet and safe rpc url', () => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.RPC_HOLESKY = undefined;
+        /* eslint-disable @typescript-eslint/no-var-requires */
+        const { validateClusterLock: validateLockWithRpcUrl, } = require('../src/index');
+        const safeRpcUrl = 'https://ethereum-holesky-rpc.publicnode.com';
+        const isValidLock = yield validateLockWithRpcUrl(clusterLockWithSafe, safeRpcUrl);
+        expect(isValidLock).toEqual(true);
+    }));
     test('validateCluster should return false for cluster with null deposit_amounts and incorrect partial_deposits', () => __awaiter(void 0, void 0, void 0, function* () {
         const partialDeposit = nullDepositAmountsClusterLockV1X8.distributed_validators[0]
             .partial_deposit_data[0];
@@ -270,7 +275,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* () {
@@ -283,7 +288,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* () {
@@ -350,7 +355,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* () {
@@ -361,13 +366,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/types/src/ajv.d.ts

@@ -1,2 +1,3 @@
-import { type ErrorObject } from 'ajv';
-export declare function validatePayload(data: any, schema: any): ErrorObject[] | undefined | null | boolean;
+export declare const VALID_DEPOSIT_AMOUNTS: string[];
+export declare const VALID_NON_COMPOUNDING_AMOUNTS: string[];
+export declare function validatePayload<T>(data: unknown, schema: object): T;

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

@@ -69,7 +69,7 @@ export declare const signEnrPayload: (payload: {
     enr: string;
 }, chainId: number) => TypedMessage<typeof ENRTypedMessage>;
 export declare const DKG_ALGORITHM = "default";
-export declare const CONFIG_VERSION = "v1.8.0";
+export declare const CONFIG_VERSION = "v1.10.0";
 export declare const SDK_VERSION: string;
 export declare const DOMAIN_APPLICATION_BUILDER = "00000001";
 export declare const DOMAIN_DEPOSIT = "03000000";

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

@@ -9,4 +9,4 @@ export declare const claimIncentivesFromMerkleDistributor: (incentivesData: {
 }) => Promise<{
     txHash: string;
 }>;
-export declare const isClaimedFromMerkleDistributor: (chainId: number, contractAddress: ETH_ADDRESS, index: number, provider: ProviderType | undefined | null) => Promise<boolean>;
+export declare const isClaimedFromMerkleDistributor: (contractAddress: ETH_ADDRESS, index: number, provider: ProviderType | undefined | null) => Promise<boolean>;

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

@@ -1,4 +1,4 @@
-import { type Incentives as IncentivesType, type ETH_ADDRESS, type ProviderType, type SignerType, type ClaimIncentivesResponse } from './types';
+import { type ClaimableIncentives, type ETH_ADDRESS, type ProviderType, type SignerType, type ClaimIncentivesResponse } from './types';
 /**
  * Incentives can be used for fetching and claiming Obol incentives.
  * @class
@@ -53,5 +53,5 @@ export declare class Incentives {
      * An example of how to use getIncentivesByAddress:
      * [obolClient](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L250)
      */
-    getIncentivesByAddress(address: string): Promise<IncentivesType>;
+    getIncentivesByAddress(address: string): Promise<ClaimableIncentives>;
 }

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

@@ -5,6 +5,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.

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

@@ -19,18 +19,16 @@ export declare const definitionSchema: {
         operators: {
             type: string;
             minItems: number;
-            uniqueItems: boolean;
             items: {
                 type: string;
                 properties: {
                     address: {
                         type: string;
-                        minLength: number;
-                        maxLength: number;
                     };
                 };
                 required: string[];
             };
+            validateUniqueAddresses: boolean;
         };
         validators: {
             type: string;
@@ -51,12 +49,39 @@ export declare const definitionSchema: {
             };
         };
         deposit_amounts: {
-            type: string;
+            type: string[];
             items: {
                 type: string;
                 pattern: string;
             };
-            validDepositAmounts: boolean;
+            if: {
+                $data: string;
+            };
+            then: {
+                items: {
+                    enum: string[];
+                };
+            };
+            else: {
+                items: {
+                    enum: string[];
+                };
+            };
+            default: null;
+        };
+        compounding: {
+            type: string;
+            default: boolean;
+        };
+        target_gas_limit: {
+            type: string;
+            minimum: number;
+            default: number;
+        };
+        consensus_protocol: {
+            type: string;
+            enum: string[];
+            default: string;
         };
     };
     required: string[];
@@ -83,29 +108,35 @@ export declare const totalSplitterPayloadSchema: {
         ObolRAFSplit: {
             type: string;
             minimum: number;
+            default: number;
         };
         distributorFee: {
             type: string;
             maximum: number;
             multipleOf: number;
+            default: number;
         };
         controllerAddress: {
             type: string;
             pattern: string;
+            default: string;
         };
-        validateSplitRecipients: boolean;
     };
+    validateTotalSplitRecipients: boolean;
     required: string[];
 };
 export declare const rewardsSplitterPayloadSchema: {
+    type: string;
     properties: {
         ObolRAFSplit: {
             type: string;
             minimum: number;
+            default: number;
         };
         recoveryAddress: {
             type: string;
             pattern: string;
+            default: string;
         };
         etherAmount: {
             type: string;
@@ -134,13 +165,14 @@ export declare const rewardsSplitterPayloadSchema: {
             type: string;
             maximum: number;
             multipleOf: number;
+            default: number;
         };
         controllerAddress: {
             type: string;
             pattern: string;
+            default: string;
         };
-        validateSplitRecipients: boolean;
     };
+    validateRewardsSplitRecipients: boolean;
     required: string[];
-    type: string;
 };

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

@@ -1,11 +1,12 @@
-import { type ClusterLock } from './types.js';
+import { type SafeRpcUrl, type ClusterLock } from './types.js';
 /**
  * Verifies Cluster Lock's validity.
  * @param lock - cluster lock
+ * @param safeRpcUrl - optional safeRpcUrl for safe wallet verification
  * @returns {Promise<{ result: boolean }> } boolean result to indicate if lock is valid
  * @throws on missing keys or values.
  *
  * An example of how to use validateClusterLock:
  * [validateClusterLock](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L127)
  */
-export declare const validateClusterLock: (lock: ClusterLock) => Promise<boolean>;
+export declare const validateClusterLock: (lock: ClusterLock, safeRpcUrl?: SafeRpcUrl) => Promise<boolean>;

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

@@ -1,4 +1,4 @@
-import { type ethers, type JsonRpcApiProvider, type JsonRpcProvider, type JsonRpcSigner, type Provider, type Signer } from 'ethers';
+import { type Wallet, type ethers, type JsonRpcApiProvider, type JsonRpcProvider, type JsonRpcSigner, type Provider, type Signer } from 'ethers';
 /**
  * Permitted ChainID's
  */
@@ -68,6 +68,12 @@ export type ClusterPayload = {
     validators: ClusterValidator[];
     /** The cluster partial deposits in gwei or 32000000000. */
     deposit_amounts?: string[] | null;
+    /** A withdrawal mechanism with 0x02 withdrawal credentials. */
+    compounding?: boolean;
+    /** The target gas limit where default is 36M. */
+    target_gas_limit?: number;
+    /** The consensus protocol e.g qbft. */
+    consensus_protocol?: string;
 };
 /**
  * Cluster definition data needed for dkg
@@ -95,7 +101,7 @@ export interface ClusterDefinition extends ClusterPayload {
     definition_hash?: string;
     /** The consensus protocol e.g qbft. */
     consensus_protocol?: string;
-    /** The target gas limit where default is 30M. */
+    /** The target gas limit where default is 36M. */
     target_gas_limit?: number;
     /** A withdrawal mechanism with 0x02 withdrawal credentials. */
     compounding?: boolean;
@@ -212,14 +218,14 @@ export type ClusterLock = {
     node_signatures?: string[];
 };
 /**
- * Incentives
+ * Claimable Obol Incentives
  */
-export type Incentives = {
+export type ClaimableIncentives = {
     /** Operator Address. */
     operator_address: string;
     /** The amount the recipient is entitled to. */
     amount: string;
-    /** The recipient’s index in the Merkle tree. */
+    /** The recipient's index in the Merkle tree. */
     index: number;
     /** The Merkle proof (an array of hashes) generated for the recipient. */
     merkle_proof: string[];
@@ -234,10 +240,14 @@ export type ETH_ADDRESS = string;
  * Provider Types
  */
 export type ProviderType = Provider | JsonRpcProvider | JsonRpcApiProvider | ethers.BrowserProvider;
+/**
+ * Safe Wallet Provider Types
+ */
+export type SafeRpcUrl = string;
 /**
  * Signer Types
  */
-export type SignerType = Signer | JsonRpcSigner;
+export type SignerType = Signer | JsonRpcSigner | Wallet;
 /**
  * claimIncentives Response
  */

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

@@ -6,4 +6,4 @@ export declare const strToUint8Array: (str: string) => Uint8Array;
 export declare const definitionFlow: (clusterDefinition: ClusterDefinition) => DefinitionFlow | null;
 export declare const findDeployedBytecode: (contractAddress: string, provider: ProviderType) => Promise<string>;
 export declare const isContractAvailable: (contractAddress: string, provider: ProviderType, bytecode?: string) => Promise<boolean>;
-export declare const getProvider: (chainId: number) => ethers.JsonRpcProvider;
+export declare const getProvider: (chainId: number, rpcUrl?: string) => ethers.JsonRpcProvider;

package/dist/types/src/verification/common.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { type ClusterDefinition, type ClusterLock, type DepositData, type DistributedValidator } from '../types.js';
+import { type ClusterDefinition, type ClusterLock, type DepositData, type DistributedValidator, type SafeRpcUrl } from '../types.js';
 /**
  * @param cluster The cluster configuration or the cluster definition
  * @param configOnly a boolean to indicate config hash or definition hash
@@ -29,4 +29,4 @@ export declare const verifyBuilderRegistration: (validator: DistributedValidator
 };
 export declare const verifyNodeSignatures: (clusterLock: ClusterLock) => boolean;
 export declare const signingRoot: (domain: Uint8Array, messageBuffer: Buffer) => Uint8Array;
-export declare const isValidClusterLock: (clusterLock: ClusterLock) => Promise<boolean>;
+export declare const isValidClusterLock: (clusterLock: ClusterLock, safeRpcUrl?: SafeRpcUrl) => Promise<boolean>;

package/dist/types/src/verification/signature-validator.d.ts

@@ -1,19 +1,22 @@
 import { type TypedMessage } from '@metamask/eth-sig-util';
 import { type EIP712TypedData } from '@safe-global/safe-core-sdk-types';
-export declare const validateAddressSignature: ({ address, token, data, chainId, }: {
+import { type SafeRpcUrl } from '../types';
+export declare const validateAddressSignature: ({ address, token, data, chainId, safeRpcUrl, }: {
     address: string;
     token: string;
     data: TypedMessage<any>;
     chainId: number;
+    safeRpcUrl?: string | undefined;
 }) => Promise<boolean>;
 export declare const validateEOASignature: ({ token, data, address, }: {
     token: string;
     data: TypedMessage<any>;
     address: string;
 }) => boolean;
-export declare const validateSmartContractSignature: ({ token, data, address, chainId, }: {
+export declare const validateSmartContractSignature: ({ token, data, address, chainId, safeRpcUrl, }: {
     token: string;
     data: EIP712TypedData;
     address: string;
     chainId: number;
+    safeRpcUrl?: string | undefined;
 }) => Promise<boolean>;

package/dist/types/test/fixtures.d.ts

@@ -99,17 +99,6 @@ export declare const clusterLockV1X7: {
     lock_hash: string;
     node_signatures: string[];
 };
-export declare const clusterConfigV1X8: {
-    name: string;
-    operators: {
-        address: string;
-    }[];
-    validators: {
-        fee_recipient_address: string;
-        withdrawal_address: string;
-    }[];
-    deposit_amounts: string[];
-};
 export declare const clusterLockV1X8: {
     cluster_definition: {
         name: string;
@@ -263,6 +252,30 @@ export declare const clusterLockWithSafe: {
     lock_hash: string;
     node_signatures: string[];
 };
+export declare const clusterConfigV1X10: {
+    name: string;
+    operators: {
+        address: string;
+    }[];
+    validators: {
+        fee_recipient_address: string;
+        withdrawal_address: string;
+    }[];
+    deposit_amounts: string[];
+    compounding: boolean;
+    target_gas_limit: number;
+    consensus_protocol: string;
+};
+export declare const soloClusterConfigV1X10: {
+    name: string;
+    operators: {
+        address: string;
+    }[];
+    validators: {
+        fee_recipient_address: string;
+        withdrawal_address: string;
+    }[];
+};
 export declare const clusterLockV1X10: {
     cluster_definition: {
         name: string;
@@ -371,3 +384,57 @@ export declare const clusterLockWithCompoundingWithdrawals: {
     lock_hash: string;
     node_signatures: string[];
 };
+export declare const clusterLockWithCompoundingWithdrawalss: {
+    cluster_definition: {
+        name: string;
+        creator: {
+            address: string;
+            config_signature: string;
+        };
+        operators: {
+            address: string;
+            enr: string;
+            config_signature: string;
+            enr_signature: string;
+        }[];
+        uuid: string;
+        version: string;
+        timestamp: string;
+        num_validators: number;
+        threshold: number;
+        validators: {
+            fee_recipient_address: string;
+            withdrawal_address: string;
+        }[];
+        dkg_algorithm: string;
+        fork_version: string;
+        deposit_amounts: string[];
+        consensus_protocol: string;
+        target_gas_limit: number;
+        compounding: boolean;
+        config_hash: string;
+        definition_hash: string;
+    };
+    distributed_validators: {
+        distributed_public_key: string;
+        public_shares: string[];
+        builder_registration: {
+            message: {
+                fee_recipient: string;
+                gas_limit: number;
+                timestamp: number;
+                pubkey: string;
+            };
+            signature: string;
+        };
+        partial_deposit_data: {
+            pubkey: string;
+            withdrawal_credentials: string;
+            amount: string;
+            signature: string;
+        }[];
+    }[];
+    signature_aggregate: string;
+    lock_hash: string;
+    node_signatures: string[];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obolnetwork/obol-sdk",
-  "version": "2.4.5",
+  "version": "2.5.0",
   "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",
@@ -56,7 +58,7 @@
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-n": "^16.6.2",
     "eslint-plugin-promise": "^6.1.1",
-    "ethers": "6.4.0",
+    "ethers": "^6.13.5",
     "nock": "^13.5.3",
     "pdf-parse": "^1.1.1",
     "semver": "^7.6.0",