@obolnetwork/obol-sdk 2.4.5 → 2.5.0

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: true,
+        },
+        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/services.js

@@ -11,15 +11,16 @@ import { isValidClusterLock } from './verification/common.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 const validateClusterLock = (lock) => __awaiter(void 0, void 0, void 0, function* () {
+export const validateClusterLock = (lock, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const isLockValid = yield isValidClusterLock(lock);
+        const isLockValid = yield isValidClusterLock(lock, safeRpcUrl);
         return isLockValid;
     }
     catch (err) {

package/dist/esm/src/utils.js

@@ -59,10 +59,10 @@ export const isContractAvailable = (contractAddress, provider, bytecode) => __aw
     }
     return !!code && code !== '0x' && code !== '0x0';
 });
-export const getProvider = (chainId) => {
-    const rpcUrl = PROVIDER_MAP[chainId];
-    if (!rpcUrl || rpcUrl === 'undefined') {
+export const getProvider = (chainId, rpcUrl) => {
+    const resolvedRpcUrl = rpcUrl !== null && rpcUrl !== void 0 ? rpcUrl : PROVIDER_MAP[chainId];
+    if (chainId && (!resolvedRpcUrl || resolvedRpcUrl === 'undefined')) {
         throw new Error(`No provider configured for ${FORK_NAMES[chainId]}`);
     }
-    return new ethers.JsonRpcProvider(rpcUrl);
+    return new ethers.JsonRpcProvider(resolvedRpcUrl);
 };

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

@@ -100,7 +100,7 @@ export const clusterLockHash = (clusterLock) => {
 };
 // Lock verification
 // cluster-definition signatures verification
-const validatePOSTConfigHashSigner = (address, signature, configHash, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+const validatePOSTConfigHashSigner = (address, signature, configHash, chainId, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const data = signCreatorConfigHashPayload({ creator_config_hash: configHash }, chainId);
         return yield validateAddressSignature({
@@ -108,13 +108,14 @@ const validatePOSTConfigHashSigner = (address, signature, configHash, chainId) =
             token: signature,
             data,
             chainId,
+            safeRpcUrl,
         });
     }
     catch (err) {
         throw err;
     }
 });
-const validatePUTConfigHashSigner = (address, signature, configHash, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+const validatePUTConfigHashSigner = (address, signature, configHash, chainId, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const data = signOperatorConfigHashPayload({ operator_config_hash: configHash }, chainId);
         return yield validateAddressSignature({
@@ -122,13 +123,14 @@ const validatePUTConfigHashSigner = (address, signature, configHash, chainId) =>
             token: signature,
             data,
             chainId,
+            safeRpcUrl,
         });
     }
     catch (err) {
         throw err;
     }
 });
-const validateEnrSigner = (address, signature, payload, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+const validateEnrSigner = (address, signature, payload, chainId, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const data = signEnrPayload({ enr: payload }, chainId);
         return yield validateAddressSignature({
@@ -136,18 +138,19 @@ const validateEnrSigner = (address, signature, payload, chainId) => __awaiter(vo
             token: signature,
             data,
             chainId,
+            safeRpcUrl,
         });
     }
     catch (err) {
         throw err;
     }
 });
-const verifyDefinitionSignatures = (clusterDefinition, definitionType) => __awaiter(void 0, void 0, void 0, function* () {
+const verifyDefinitionSignatures = (clusterDefinition, definitionType, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     if (definitionType === DefinitionFlow.Charon) {
         return true;
     }
     else {
-        const isPOSTConfigHashSignerValid = yield validatePOSTConfigHashSigner(clusterDefinition.creator.address, clusterDefinition.creator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version]);
+        const isPOSTConfigHashSignerValid = yield validatePOSTConfigHashSigner(clusterDefinition.creator.address, clusterDefinition.creator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version], safeRpcUrl);
         if (!isPOSTConfigHashSignerValid) {
             return false;
         }
@@ -155,8 +158,8 @@ const verifyDefinitionSignatures = (clusterDefinition, definitionType) => __awai
             return true;
         }
         for (const operator of clusterDefinition.operators) {
-            const isPUTConfigHashSignerValid = yield validatePUTConfigHashSigner(operator.address, operator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version]);
-            const isENRSignerValid = yield validateEnrSigner(operator.address, operator.enr_signature, operator.enr, FORK_MAPPING[clusterDefinition.fork_version]);
+            const isPUTConfigHashSignerValid = yield validatePUTConfigHashSigner(operator.address, operator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version], safeRpcUrl);
+            const isENRSignerValid = yield validateEnrSigner(operator.address, operator.enr_signature, operator.enr, FORK_MAPPING[clusterDefinition.fork_version], safeRpcUrl);
             if (!isPUTConfigHashSignerValid || !isENRSignerValid) {
                 return false;
             }
@@ -287,13 +290,13 @@ const verifyLockData = (clusterLock) => __awaiter(void 0, void 0, void 0, functi
     }
     return false;
 });
-export const isValidClusterLock = (clusterLock) => __awaiter(void 0, void 0, void 0, function* () {
+export const isValidClusterLock = (clusterLock, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const definitionType = definitionFlow(clusterLock.cluster_definition);
         if (definitionType == null) {
             return false;
         }
-        const isValidDefinitionData = yield verifyDefinitionSignatures(clusterLock.cluster_definition, definitionType);
+        const isValidDefinitionData = yield verifyDefinitionSignatures(clusterLock.cluster_definition, definitionType, safeRpcUrl);
         if (!isValidDefinitionData) {
             return false;
         }

package/dist/esm/src/verification/signature-validator.js

@@ -14,9 +14,9 @@ import Safe from '@safe-global/protocol-kit';
 import { PROVIDER_MAP } from '../constants';
 import { hashTypedData } from '@safe-global/protocol-kit/dist/src/utils';
 import { isContractAvailable, getProvider } from '../utils';
-export const validateAddressSignature = ({ address, token, data, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+export const validateAddressSignature = ({ address, token, data, chainId, safeRpcUrl, }) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const provider = getProvider(chainId); // [TODO Hanan], should expect it from signer.provider, or passed in client
+        const provider = getProvider(chainId, safeRpcUrl);
         if (provider) {
             const contractAddress = yield isContractAvailable(address, provider);
             if (contractAddress) {
@@ -25,6 +25,7 @@ export const validateAddressSignature = ({ address, token, data, chainId, }) =>
                     data: data,
                     address,
                     chainId,
+                    safeRpcUrl,
                 });
             }
         }
@@ -46,11 +47,11 @@ export const validateEOASignature = ({ token, data, address, }) => {
         throw err;
     }
 };
-export const validateSmartContractSignature = ({ token, data, address, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+export const validateSmartContractSignature = ({ token, data, address, chainId, safeRpcUrl, }) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const provider = PROVIDER_MAP[chainId];
+        const safeProvider = safeRpcUrl !== null && safeRpcUrl !== void 0 ? safeRpcUrl : PROVIDER_MAP[chainId];
         const protocolKit = yield Safe.init({
-            provider,
+            provider: safeProvider,
             safeAddress: address,
         });
         const messageHash = hashTypedData(data);

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;

package/dist/esm/test/fixtures.js

@@ -170,22 +170,6 @@ export const clusterLockV1X7 = {
     ],
 };
 // v1.8.0
-export const clusterConfigV1X8 = {
-    name: 'testSDK',
-    operators: [
-        { address: '0xC35CfCd67b9C27345a54EDEcC1033F2284148c81' },
-        { address: '0x33807D6F1DCe44b9C599fFE03640762A6F08C496' },
-        { address: '0xc6e76F72Ea672FAe05C357157CfC37720F0aF26f' },
-        { address: '0xf6fF1a7A14D01e86a175bA958d3B6C75f2213966' },
-    ],
-    validators: [
-        {
-            fee_recipient_address: '0x3CD4958e76C317abcEA19faDd076348808424F99',
-            withdrawal_address: '0xE0C5ceA4D3869F156717C66E188Ae81C80914a6e',
-        },
-    ],
-    deposit_amounts: ['8000000000', '16000000000', '8000000000'],
-};
 export const clusterLockV1X8 = {
     cluster_definition: {
         name: 'xxxx',
@@ -507,6 +491,40 @@ export const clusterLockWithSafe = {
         '0x4067921a5257efe4ceb103f2129faaa7a502781157b3b54e5efca559c558c2b43b89f30962e87df88fbf62250049a31888fcd62735d54b7553e5dc75c3b6ae0901',
     ],
 };
+export const clusterConfigV1X10 = {
+    name: 'testSDK',
+    operators: [
+        { address: '0xC35CfCd67b9C27345a54EDEcC1033F2284148c81' },
+        { address: '0x33807D6F1DCe44b9C599fFE03640762A6F08C496' },
+        { address: '0xc6e76F72Ea672FAe05C357157CfC37720F0aF26f' },
+        { address: '0xf6fF1a7A14D01e86a175bA958d3B6C75f2213966' },
+    ],
+    validators: [
+        {
+            fee_recipient_address: '0x3CD4958e76C317abcEA19faDd076348808424F99',
+            withdrawal_address: '0xE0C5ceA4D3869F156717C66E188Ae81C80914a6e',
+        },
+    ],
+    deposit_amounts: ['8000000000', '32000000000', '8000000000'],
+    compounding: true,
+    target_gas_limit: 36000000,
+    consensus_protocol: '',
+};
+export const soloClusterConfigV1X10 = {
+    name: 'testSDK',
+    operators: [
+        { address: '' },
+        { address: '' },
+        { address: '' },
+        { address: '' },
+    ],
+    validators: [
+        {
+            fee_recipient_address: '0x3CD4958e76C317abcEA19faDd076348808424F99',
+            withdrawal_address: '0xE0C5ceA4D3869F156717C66E188Ae81C80914a6e',
+        },
+    ],
+};
 export const clusterLockV1X10 = {
     cluster_definition: {
         name: 'test',
@@ -771,3 +789,93 @@ export const clusterLockWithCompoundingWithdrawals = {
         '0x3e2548c3c35df90bd7af34f9cc439e7ec4e4fa5619f74ca393bde8e05942dfde0c2e5d95249f478533fe11581b794e5de55446452e4dd1648c33b319a987461701',
     ],
 };
+export const clusterLockWithCompoundingWithdrawalss = {
+    cluster_definition: {
+        name: 'test v1.10.0',
+        creator: {
+            address: '0xc6e76F72Ea672FAe05C357157CfC37720F0aF26f',
+            config_signature: '0x62b609c3a56439fe60785895d60a36912b85d50c14a41fce36795c65d6263bb207467a4d4be7dc292bfd1c636332b1c409feaec6ce2ae9488ae1ad622264a7a81c',
+        },
+        operators: [
+            {
+                address: '0xc6e76F72Ea672FAe05C357157CfC37720F0aF26f',
+                enr: 'enr:-HW4QLlrtMjFLGkFT1bwdGbvZQlH8hLi0M2g44JAxEYP3BZmYpcsy9Q56HPPD87fMucjvLv4-obEFacpsg0ehRilbHeAgmlkgnY0iXNlY3AyNTZrMaEDRaa5o2aSgqyFq_ERZcQTztrOij1mFtXX1bJuVI6ieak',
+                config_signature: '0x58c31787cf1f9680f736713f4ce039c8bf69467e5128edb2888d380451bd757367665c1ba04dc7656eb0b77eac39f776780710e603372f2a41bd40f4d297c7fa1c',
+                enr_signature: '0x4df48b8fc16deb2441022a019b72976524f4ce3dd674ee70561fb9eb52985d3b0d9528532d3e5be7a44548be27e9e96c5358b9f6756c7c7a97e2126f9c2c9b071b',
+            },
+            {
+                address: '0xa084D9095BcBdFe8014B68fa52D73DCeb16C5129',
+                enr: 'enr:-Iu4QNbiUUUwT18LynBbVPJhNxvzQsaSpUr40mQTWscnZaqKb6vAlvV8j-eDDR3E0wjMQumGRbGm2IAb5_k4bVWJiVGAgmlkgnY0gmlwhH8AAAGJc2VjcDI1NmsxoQPOiodUji0ohgJb5sNK1hgv8g6xO5_znZz3NkkBkyYyKIN0Y3CCDhqDdWRwgg4u',
+                config_signature: '0xc76b2f067a65c9cc6110ab99471b03f47545581e79164758114c98825d5440891843790ce92ca24ee7b3568b839cc88c2b3824587f8f260fca15bb852f69a3af1c',
+                enr_signature: '0x49e2a07424e412ed904fd47381c36203cb8c5575a31ba260b3f8420dc89a86fc0d7fbc087160a60690be2f6fb212423d467e212494992ab9a72f10319779a2cc1c',
+            },
+            {
+                address: '0xb1D2740Ee055693FE21bbCfc780729472C3f6B84',
+                enr: 'enr:-Iu4QJyserRukhG0Vgi2csu7GjpHYUGufNEbZ8Q7ZBrcZUb0KqpL5QzHonkh1xxHlxatTxrIcX_IS5J3SEWR_sa0ptGAgmlkgnY0gmlwhH8AAAGJc2VjcDI1NmsxoQMAUgEqczOjevyculnUIofhCj0DkgJudErM7qCYIvIkzIN0Y3CCDhqDdWRwgg4u',
+                config_signature: '0x8b0cea21e065d25faa3b9d3b9e8f497d3c2d8baf800a1c5ecbde64c041745b7e15131d28f7ab917bdcead3225dda16987f2fd160546e087987cbb483bd187cb11b',
+                enr_signature: '0x805f38269379087168900a37569f1108b9d4253a03c2650a4e8d69228cb4cc616b94988e4b218a8d47113063270c4a894e873a5070c7ef0f4d44ee3359eec51b1b',
+            },
+            {
+                address: '0x69D39e2d0Fb6fb80CCd5d49a75416cB7d1BC6DB6',
+                enr: 'enr:-HW4QKJTwXC6Chw6zbnA3HFZi6Jo0DkIgjKy4eUBpsSOGnAeWE6ChEjEyk_6R6Qrm7jI-iqfs3_HYxiKde8vFgvHHrCAgmlkgnY0iXNlY3AyNTZrMaECfFKQH4spdZCHqrKVz1Q02xYla6J_RQECDNNYBRWdzv8',
+                config_signature: '0x9e21c2308738fb17b38d1850b83312c25306c0bcbd575e0417e311d5fc1697807291328a299859df70ac3efb402207067dbb0559bc4fef4e6ca2fd77fa4c2a321c',
+                enr_signature: '0x3a6590600b2dc27b042aabd3fa4654f1064b42e8f850d1fac13394a6786463be2a2727623e4e9e98453113f7024e73d652d1c6288ef82ede7acbb08e25ff00751b',
+            },
+        ],
+        uuid: '34036642-9d45-4b6f-817d-f8d5aa0110d4',
+        version: 'v1.10.0',
+        timestamp: '2025-04-03T17:27:27.767Z',
+        num_validators: 1,
+        threshold: 3,
+        validators: [
+            {
+                fee_recipient_address: '0xc6e76F72Ea672FAe05C357157CfC37720F0aF26f',
+                withdrawal_address: '0xc6e76F72Ea672FAe05C357157CfC37720F0aF26f',
+            },
+        ],
+        dkg_algorithm: 'default',
+        fork_version: '0x10000910',
+        deposit_amounts: ['32000000000'],
+        consensus_protocol: 'abft',
+        target_gas_limit: 30000000,
+        compounding: true,
+        config_hash: '0xe6d2e8fe49d722f55ced8a028c62ffbde16a05bc74d7d9703b675ecc8c820b4b',
+        definition_hash: '0xb5d81494f98df23cdff33909888080054f1068c11bbee5ec39aeb95edfa3b37c',
+    },
+    distributed_validators: [
+        {
+            distributed_public_key: '0x8368525a657df38fd3d774a08f1a54f008ae3340e8441a2bbb2d2051a9a8f46d4eeb8610bbc088e7402cba6b138c7b70',
+            public_shares: [
+                '0xae455c727456238fadd7b84ded0f0fb700d0e2fa028fff34e3fc73d0279ee9a5aa9843f8af00c9518ea781d8d823cc0d',
+                '0x91a7cfa9682464dff7324c0907fdff41df3f2643fd97d30559d82fbbfa354dae1e3f9176d8562b5ab47d3460240004cb',
+                '0xac8c0ffdb9ea7ce63bbed67122123c86ffa669a5027da5f96ab85b68c3a491253ebf0308cf4e237ea4eaf8543064c8a8',
+                '0x85385ef7cf1b1d9cd648ceb45e92516ef9612c9830b0abf808ea7996ad9369764bb9ac27c3cd730497e12e394ab48d16',
+            ],
+            builder_registration: {
+                message: {
+                    fee_recipient: '0xc6e76f72ea672fae05c357157cfc37720f0af26f',
+                    gas_limit: 30000000,
+                    timestamp: 1742213400,
+                    pubkey: '0x8368525a657df38fd3d774a08f1a54f008ae3340e8441a2bbb2d2051a9a8f46d4eeb8610bbc088e7402cba6b138c7b70',
+                },
+                signature: '0xb73c4d55c17bdbbb53790fee3294ef2c69b2a6e4c700eb30603e437308005edacbe76591f917aa82cfcf60da2d669ccd101ae9b3dc4b1ae61ab7ad1794620adbdc0b4ea5f91fc5e790833537c610a57ccdc4c95ca53cb6dedec2be2ad8acf266',
+            },
+            partial_deposit_data: [
+                {
+                    pubkey: '0x8368525a657df38fd3d774a08f1a54f008ae3340e8441a2bbb2d2051a9a8f46d4eeb8610bbc088e7402cba6b138c7b70',
+                    withdrawal_credentials: '0x020000000000000000000000c6e76f72ea672fae05c357157cfc37720f0af26f',
+                    amount: '32000000000',
+                    signature: '0xa7c5c2417f5afd089b87df0eff10855b748d621749879b6087c8a1dbfcbb95aa79a2c8f4d637ecb283426b9c5af07c30080c19a245ea614ff3f609a92994e9a29f3c0f8c4bf1a4e7ef58615ff80586b40e36859c9fd935b68ae55670e29ea5d7',
+                },
+            ],
+        },
+    ],
+    signature_aggregate: '0x8b9f884ab3ab89d63f49437cae09e2b77757787f2c54bb52bc51df1d565bc6d63ef9fc4e0ea76bd72a58618651b827a611d8e96de238fad4616420b4cd393ad62428ac9db2e01a4e8dd8ae835845e7530f9e1b3b4ebf5ba2da3c77aec70d06b2',
+    lock_hash: '0xaf6b0d989fdd82f7f9683d62b9f797af129f9afae2a4b453a0bef1814b21ae5d',
+    node_signatures: [
+        '0xc059b3920fc107a909feb16217c7372911c5cb386954ed899b5d8e782d6d71e17a5dde1c2d4825b7c2b5edd63b4eb9c306afd4afd5dbce3f8db9c13d06d6cebf01',
+        '0x051a72e5f2a66a85aabd635a210350f82924350170981575f3cb67e7699791d7118ab7c284f10b52f3604a89aa0bc43ad2d2537a7b19b109610324926475d30900',
+        '0xa28a23de3703c3eeb9a091d4f47302a96079759baf1afca428cbd298b46c40fe103df0006dfd5a0ffd15ee7c5fa436d70d7a03d4537dd8292a6152734e5f689601',
+        '0x992ab5c73d30d10cc5c8f6d462ba387fd5a698e206b0dfdd0224d17117f85a2077fcaa62fd6d5170ff678249288fcd82877e2987ed5564df5dbd9d51370871c800',
+    ],
+};

package/dist/esm/test/incentives.test.js

@@ -120,7 +120,7 @@ describe('Client.incentives', () => {
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
         const result = yield clientInstance.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index);
         expect(result).toBe(true);
-        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(clientInstance.incentives.chainId, mockIncentivesData.contract_address, mockIncentivesData.index, {});
+        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(mockIncentivesData.contract_address, mockIncentivesData.index, {});
     }));
     test('isClaimed should return false when incentive is not claimed', () => __awaiter(void 0, void 0, void 0, function* () {
         jest
@@ -147,7 +147,7 @@ describe('Client.incentives', () => {
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
         const result = yield clientWithoutSigner.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index);
         expect(result).toBe(true);
-        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(clientWithoutSigner.incentives.chainId, mockIncentivesData.contract_address, mockIncentivesData.index, provider);
+        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(mockIncentivesData.contract_address, mockIncentivesData.index, provider);
     }));
     test('getIncentivesByAddress should make the correct API request', () => __awaiter(void 0, void 0, void 0, function* () {
         const mockAddress = '0x1234567890abcdef1234567890abcdef12345678';