@obolnetwork/obol-sdk 2.7.0 → 2.8.0

package/dist/esm/test/client/ajv.spec.js

@@ -0,0 +1,267 @@
+import { validatePayload } from '../../src/ajv';
+import { ovmRewardsSplitPayloadSchema, ovmTotalSplitPayloadSchema, } from '../../src/schema';
+import { TEST_ADDRESSES } from '../fixtures';
+describe('validatePayload - OVM Schemas', () => {
+    describe('ovmRewardsSplitPayloadSchema', () => {
+        const validRewardsSplitPayload = {
+            rewardSplitRecipients: [
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+            ],
+            OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+            splitOwnerAddress: TEST_ADDRESSES.SPLIT_OWNER,
+            principalRecipient: TEST_ADDRESSES.PRINCIPAL_RECIPIENT,
+            distributorFeePercent: 0,
+        };
+        it('should validate a valid rewards split payload', () => {
+            const result = validatePayload(validRewardsSplitPayload, ovmRewardsSplitPayloadSchema);
+            expect(result).toEqual(validRewardsSplitPayload);
+        });
+        it('should validate rewards split payload with default values', () => {
+            const payloadWithoutDefaults = {
+                rewardSplitRecipients: [
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+                ],
+                OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+                principalRecipient: TEST_ADDRESSES.PRINCIPAL_RECIPIENT,
+            };
+            const result = validatePayload(payloadWithoutDefaults, ovmRewardsSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payloadWithoutDefaults), { splitOwnerAddress: TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should throw error when rewardSplitRecipients total percentage is not 99%', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validRewardsSplitPayload), { rewardSplitRecipients: [
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 40 }, // Total: 90%
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmRewardsSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMRewardsSplitRecipients" keyword validation');
+        });
+        it('should throw error when rewardSplitRecipients total percentage exceeds 99%', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validRewardsSplitPayload), { rewardSplitRecipients: [
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 60 },
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 50 }, // Total: 110%
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmRewardsSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMRewardsSplitRecipients" keyword validation');
+        });
+        it('should throw error when rewardSplitRecipients is empty', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validRewardsSplitPayload), { rewardSplitRecipients: [] });
+            expect(() => validatePayload(invalidPayload, ovmRewardsSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMRewardsSplitRecipients" keyword validation');
+        });
+        it('should throw error when rewardSplitRecipients has invalid address format', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validRewardsSplitPayload), { rewardSplitRecipients: [
+                    { address: 'invalid-address', percentAllocation: 50 },
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmRewardsSplitPayloadSchema)).toThrow('Validation failed: /rewardSplitRecipients/0/address must match pattern');
+        });
+        it('should throw error when OVMOwnerAddress is missing', () => {
+            const invalidPayload = {
+                rewardSplitRecipients: validRewardsSplitPayload.rewardSplitRecipients,
+                principalRecipient: validRewardsSplitPayload.principalRecipient,
+            };
+            expect(() => validatePayload(invalidPayload, ovmRewardsSplitPayloadSchema)).toThrow("Validation failed:  must have required property 'OVMOwnerAddress'");
+        });
+        it('should throw error when principalRecipient is missing', () => {
+            const invalidPayload = {
+                rewardSplitRecipients: validRewardsSplitPayload.rewardSplitRecipients,
+                OVMOwnerAddress: validRewardsSplitPayload.OVMOwnerAddress,
+            };
+            expect(() => validatePayload(invalidPayload, ovmRewardsSplitPayloadSchema)).toThrow("Validation failed:  must have required property 'principalRecipient'");
+        });
+    });
+    describe('ovmTotalSplitPayloadSchema', () => {
+        const validTotalSplitPayload = {
+            rewardSplitRecipients: [
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+            ],
+            principalSplitRecipients: [
+                {
+                    address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                    percentAllocation: 60,
+                },
+                {
+                    address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                    percentAllocation: 40,
+                },
+            ],
+            OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+            splitOwnerAddress: TEST_ADDRESSES.SPLIT_OWNER,
+            distributorFeePercent: 0,
+        };
+        it('should validate a valid total split payload', () => {
+            const result = validatePayload(validTotalSplitPayload, ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(validTotalSplitPayload);
+        });
+        it('should validate total split payload with default values', () => {
+            const payloadWithoutDefaults = {
+                rewardSplitRecipients: [
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+                ],
+                principalSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 60,
+                    },
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 40,
+                    },
+                ],
+                OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+            };
+            const result = validatePayload(payloadWithoutDefaults, ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payloadWithoutDefaults), { splitOwnerAddress: TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should throw error when rewardSplitRecipients total percentage is not 99%', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { rewardSplitRecipients: [
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 40 }, // Total: 90%
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMRewardsSplitRecipients" keyword validation');
+        });
+        it('should throw error when principalSplitRecipients total percentage is not 100%', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 60,
+                    },
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 30,
+                    }, // Total: 90%
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMTotalSplitRecipients" keyword validation');
+        });
+        it('should throw error when principalSplitRecipients total percentage exceeds 100%', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 70,
+                    },
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 40,
+                    }, // Total: 110%
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMTotalSplitRecipients" keyword validation');
+        });
+        it('should throw error when principalSplitRecipients is empty', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalSplitRecipients: [] });
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMTotalSplitRecipients" keyword validation');
+        });
+        it('should throw error when principalSplitRecipients has invalid address format', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalSplitRecipients: [
+                    { address: 'invalid-address', percentAllocation: 60 },
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 40,
+                    },
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow('Validation failed: /principalSplitRecipients/0/address must match pattern');
+        });
+        it('should throw error when OVMOwnerAddress is missing', () => {
+            const invalidPayload = {
+                rewardSplitRecipients: validTotalSplitPayload.rewardSplitRecipients,
+                principalSplitRecipients: validTotalSplitPayload.principalSplitRecipients,
+            };
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow("Validation failed:  must have required property 'OVMOwnerAddress'");
+        });
+        it('should throw error when principalThreshold is less than 16', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalThreshold: 15 });
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow('Validation failed: /principalThreshold must be >= 16');
+        });
+        it('should validate when principalThreshold is exactly 16', () => {
+            const validPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalThreshold: 16 });
+            const result = validatePayload(validPayload, ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(validPayload);
+        });
+        it('should validate when principalThreshold is greater than 16', () => {
+            const validPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalThreshold: 20 });
+            const result = validatePayload(validPayload, ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(validPayload);
+        });
+    });
+    describe('Edge cases and boundary conditions', () => {
+        it('should handle decimal percentages correctly for rewards split', () => {
+            const payload = {
+                rewardSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.REWARD_RECIPIENT_1,
+                        percentAllocation: 49.5,
+                    },
+                    {
+                        address: TEST_ADDRESSES.REWARD_RECIPIENT_2,
+                        percentAllocation: 49.5,
+                    },
+                ],
+                OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+                principalRecipient: TEST_ADDRESSES.PRINCIPAL_RECIPIENT,
+            };
+            const result = validatePayload(payload, ovmRewardsSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payload), { splitOwnerAddress: TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should handle decimal percentages correctly for total split', () => {
+            const payload = {
+                rewardSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.REWARD_RECIPIENT_1,
+                        percentAllocation: 49.5,
+                    },
+                    {
+                        address: TEST_ADDRESSES.REWARD_RECIPIENT_2,
+                        percentAllocation: 49.5,
+                    },
+                ],
+                principalSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 60.5,
+                    },
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 39.5,
+                    },
+                ],
+                OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+            };
+            const result = validatePayload(payload, ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payload), { splitOwnerAddress: TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should handle single recipient with 99% allocation for rewards split', () => {
+            const payload = {
+                rewardSplitRecipients: [
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 99 },
+                ],
+                OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+                principalRecipient: TEST_ADDRESSES.PRINCIPAL_RECIPIENT,
+            };
+            const result = validatePayload(payload, ovmRewardsSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payload), { splitOwnerAddress: TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should handle single recipient with 100% allocation for total split', () => {
+            const payload = {
+                rewardSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.REWARD_RECIPIENT_1,
+                        percentAllocation: 49.5,
+                    },
+                    {
+                        address: TEST_ADDRESSES.REWARD_RECIPIENT_2,
+                        percentAllocation: 49.5,
+                    },
+                ],
+                principalSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 100,
+                    },
+                ],
+                OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+            };
+            const result = validatePayload(payload, ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payload), { splitOwnerAddress: TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+    });
+});

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

@@ -0,0 +1,393 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a, _b;
+import { ethers, JsonRpcProvider } from 'ethers';
+import { Client, validateClusterLock } from '../../src/index';
+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 { HttpResponse, http } from 'msw';
+import { setupServer } from 'msw/node';
+import { hashTermsAndConditions } from '../../src/verification/termsAndConditions';
+import * as utils from '../../src/utils';
+import * as splitsHelpers from '../../src/splits/splitHelpers';
+jest.setTimeout(20000);
+const mnemonic = (_b = (_a = ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) !== null && _b !== void 0 ? _b : '';
+const privateKey = ethers.Wallet.fromPhrase(mnemonic).privateKey;
+const provider = new JsonRpcProvider('https://ethereum-holesky.publicnode.com');
+const wallet = new ethers.Wallet(privateKey, provider);
+const mockSigner = wallet.connect(provider);
+/* eslint no-new: 0 */
+describe('Cluster Client', () => {
+    const mockConfigHash = '0x1f6c94e6c070393a68c1aa6073a21cb1fd57f0e14d2a475a2958990ab728c2fd';
+    const clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
+    test('createTermsAndConditions should return "successful authorization"', () => __awaiter(void 0, void 0, void 0, function* () {
+        clientInstance['request'] = jest
+            .fn()
+            .mockReturnValue(Promise.resolve({ message: 'successful authorization' }));
+        const isAuthorized = yield clientInstance.acceptObolLatestTermsAndConditions();
+        expect(isAuthorized).toEqual('successful authorization');
+    }));
+    test('createClusterDefinition should return config_hash', () => __awaiter(void 0, void 0, void 0, function* () {
+        clientInstance['request'] = jest
+            .fn()
+            .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
+        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(clusterLockV1X10.cluster_definition));
+        const clusterDefinition = yield clientInstance.acceptClusterDefinition({
+            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({}, clusterConfigV1X10), { operators: [] }));
+        }
+        catch (error) {
+            expect(error.message).toEqual('Validation failed: /operators must pass "validateUniqueAddresses" keyword validation, /operators must NOT have fewer than 4 items');
+        }
+    }));
+    // 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()
+            .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
+        const configHash = yield clientInstance.createClusterDefinition(Object.assign({}, clusterConfigV1X7));
+        expect(configHash).toEqual(mockConfigHash);
+    }));
+    test('createClusterDefinition should throw on not valid deposit_amounts ', () => __awaiter(void 0, void 0, void 0, function* () {
+        clientInstance['request'] = jest
+            .fn()
+            .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
+        try {
+            yield clientInstance.createClusterDefinition(Object.assign(Object.assign({}, clusterConfigV1X7), { deposit_amounts: ['34000000'] }));
+        }
+        catch (error) {
+            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* () {
+        clientInstance['request'] = jest
+            .fn()
+            .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(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 }) => {
+            // Check if the request contains specific headers
+            if (request.headers.get('User-Agent') === `Obol-SDK/${SDK_VERSION}`) {
+                return HttpResponse.json({ message: 'user-agent header exist' });
+            }
+        }));
+        server.listen();
+        class TestBase extends Base {
+            callProtectedRequest(endpoint, options) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return yield this['request'](endpoint, options);
+                });
+            }
+        }
+        const testBaseInstance = new TestBase({
+            baseUrl: 'http://testExample.com',
+        });
+        const result = yield testBaseInstance.callProtectedRequest('/test', {
+            method: 'GET',
+        });
+        expect(result === null || result === void 0 ? void 0 : result.message).toEqual('user-agent header exist');
+        server.close();
+    }));
+});
+describe('Cluster Client without a signer', () => {
+    const clientInstance = new Client({
+        baseUrl: 'https://obol-api-dev.gcp.obol.tech',
+        chainId: 17000,
+    });
+    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(clusterConfigV1X10);
+        }
+        catch (err) {
+            expect(err.message).toEqual('Signer is required in createClusterDefinition');
+        }
+    }));
+    test('acceptClusterDefinition should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield clientInstance.acceptClusterDefinition({
+                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');
+        }
+    }));
+    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(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(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 },
+        { version: 'v1.7.0', clusterLock: clusterLockV1X7 },
+        { version: 'v1.8.0', clusterLock: clusterLockV1X8 },
+        {
+            version: 'null deposit_amounts v1.8.0',
+            clusterLock: nullDepositAmountsClusterLockV1X8,
+        },
+        {
+            version: 'Cluster with safe address v1.8.0',
+            clusterLock: clusterLockWithSafe,
+        },
+        { version: 'v1.10.0', clusterLock: clusterLockV1X10 },
+        {
+            version: 'v1.10.0 with compunding withdrawals',
+            clusterLock: clusterLockWithCompoundingWithdrawals,
+        },
+    ])("$version: 'should return true on verified cluster lock'", ({ clusterLock }) => __awaiter(void 0, void 0, void 0, function* () {
+        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];
+        const isValidLock = yield validateClusterLock(Object.assign(Object.assign({}, nullDepositAmountsClusterLockV1X8), { distributed_validators: [
+                Object.assign(Object.assign({}, nullDepositAmountsClusterLockV1X8.distributed_validators[0]), { partial_deposit_data: [partialDeposit, partialDeposit] }),
+            ] }));
+        expect(isValidLock).toEqual(false);
+    }));
+    test('Finds the hash of the latest version of terms and conditions', () => __awaiter(void 0, void 0, void 0, function* () {
+        const termsAndConditionsHash = yield hashTermsAndConditions();
+        expect(termsAndConditionsHash).toEqual('0xd33721644e8f3afab1495a74abe3523cec12d48b8da6cb760972492ca3f1a273');
+    }));
+});
+describe('createObolRewardsSplit', () => {
+    let clientInstance, clientInstanceWithourSigner, mockSplitRecipients, mockPrincipalRecipient, mockEtherAmount;
+    beforeAll(() => {
+        jest
+            .spyOn(utils, 'isContractAvailable')
+            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
+        jest
+            .spyOn(splitsHelpers, 'predictSplitterAddress')
+            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xPredictedAddress'); }));
+        jest.spyOn(splitsHelpers, 'handleDeployOWRAndSplitter').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
+            return yield Promise.resolve({
+                withdrawal_address: '0xWithdrawalAddress',
+                fee_recipient_address: '0xFeeRecipientAddress',
+            });
+        }));
+        clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
+        clientInstanceWithourSigner = new Client({
+            baseUrl: 'https://obol-api-dev.gcp.obol.tech',
+            chainId: 17000,
+        });
+        mockSplitRecipients = [
+            {
+                account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
+                percentAllocation: 99,
+            },
+        ];
+        mockPrincipalRecipient = '0x86B8145c98e5BD25BA722645b15eD65f024a87EC';
+        mockEtherAmount = 64;
+    });
+    it('should throw an error if signer is not defined', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield expect(clientInstanceWithourSigner.createObolRewardsSplit({
+            splitRecipients: mockSplitRecipients,
+            principalRecipient: mockPrincipalRecipient,
+            etherAmount: mockEtherAmount,
+        })).rejects.toThrow('Signer is required in createObolRewardsSplit');
+    }));
+    it('should throw an error if chainId is not supported', () => __awaiter(void 0, void 0, void 0, function* () {
+        const unsupportedSplitterChainClient = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 100 }, mockSigner);
+        try {
+            yield unsupportedSplitterChainClient.createObolRewardsSplit({
+                splitRecipients: mockSplitRecipients,
+                principalRecipient: mockPrincipalRecipient,
+                etherAmount: mockEtherAmount,
+            });
+        }
+        catch (error) {
+            expect(error.message).toEqual('Splitter configuration is not supported on 100 chain');
+        }
+    }));
+    test('should throw an error on invalid recipients', () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield clientInstance.createObolRewardsSplit({
+                splitRecipients: [
+                    {
+                        account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
+                        percentAllocation: 22,
+                    },
+                ],
+                principalRecipient: mockPrincipalRecipient,
+                etherAmount: mockEtherAmount,
+            });
+        }
+        catch (error) {
+            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* () {
+        try {
+            yield clientInstance.createObolRewardsSplit({
+                splitRecipients: mockSplitRecipients,
+                principalRecipient: mockPrincipalRecipient,
+                etherAmount: mockEtherAmount,
+                ObolRAFSplit: 0.5,
+            });
+        }
+        catch (error) {
+            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* () {
+        const result = yield clientInstance.createObolRewardsSplit({
+            splitRecipients: mockSplitRecipients,
+            principalRecipient: mockPrincipalRecipient,
+            etherAmount: mockEtherAmount,
+        });
+        expect(result).toEqual({
+            withdrawal_address: '0xWithdrawalAddress',
+            fee_recipient_address: '0xFeeRecipientAddress',
+        });
+    }));
+});
+describe('createObolTotalSplit', () => {
+    let clientInstanceWithourSigner, mockSplitRecipients, clientInstance;
+    beforeAll(() => {
+        jest
+            .spyOn(utils, 'isContractAvailable')
+            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
+        jest
+            .spyOn(splitsHelpers, 'predictSplitterAddress')
+            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xPredictedAddress'); }));
+        jest
+            .spyOn(splitsHelpers, 'deploySplitterContract')
+            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xSplitterAddress'); }));
+        clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
+        clientInstanceWithourSigner = new Client({
+            baseUrl: 'https://obol-api-dev.gcp.obol.tech',
+            chainId: 17000,
+        });
+        mockSplitRecipients = [
+            {
+                account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
+                percentAllocation: 99.9,
+            },
+        ];
+    });
+    it('should throw an error if signer is not defined', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield expect(clientInstanceWithourSigner.createObolTotalSplit({
+            splitRecipients: mockSplitRecipients,
+        })).rejects.toThrow('Signer is required in createObolTotalSplit');
+    }));
+    it('should throw an error if chainId is not supported', () => __awaiter(void 0, void 0, void 0, function* () {
+        const unsupportedSplitterChainClient = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 100 }, mockSigner);
+        try {
+            yield unsupportedSplitterChainClient.createObolTotalSplit({
+                splitRecipients: mockSplitRecipients,
+            });
+        }
+        catch (error) {
+            expect(error.message).toEqual('Splitter configuration is not supported on 100 chain');
+        }
+    }));
+    test('should throw an error on invalid recipients', () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield clientInstance.createObolTotalSplit({
+                splitRecipients: [
+                    {
+                        account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
+                        percentAllocation: 22,
+                    },
+                ],
+            });
+        }
+        catch (error) {
+            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* () {
+        try {
+            yield clientInstance.createObolTotalSplit({
+                splitRecipients: mockSplitRecipients,
+                ObolRAFSplit: 0.05,
+            });
+        }
+        catch (error) {
+            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.1,
+        });
+        // 0xPredictedAddress and not 0xSplitterAddress since were mocking isContractAvailable response to be true
+        expect(result).toEqual({
+            withdrawal_address: '0xPredictedAddress',
+            fee_recipient_address: '0xPredictedAddress',
+        });
+    }));
+    it('should return the correct withdrawal and fee recipient addresses without passing ObolRAFSplit', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield clientInstance.createObolTotalSplit({
+            splitRecipients: mockSplitRecipients,
+        });
+        // 0xPredictedAddress and not 0xSplitterAddress since were mocking isContractAvailable response to be true
+        expect(result).toEqual({
+            withdrawal_address: '0xPredictedAddress',
+            fee_recipient_address: '0xPredictedAddress',
+        });
+    }));
+});