@obolnetwork/obol-sdk 2.7.0 → 2.8.1

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',
+        });
+    }));
+});

package/dist/esm/test/fixtures.js

@@ -1,3 +1,15 @@
+import { ZeroAddress } from 'ethers';
+// Test address constants for OVM splits
+export const TEST_ADDRESSES = {
+    REWARD_RECIPIENT_1: '0x1234567890123456789012345678901234567890',
+    REWARD_RECIPIENT_2: '0x2345678901234567890123456789012345678901',
+    PRINCIPAL_RECIPIENT_1: '0x3456789012345678901234567890123456789012',
+    PRINCIPAL_RECIPIENT_2: '0x4567890123456789012345678901234567890123',
+    OVM_OWNER: '0x5678901234567890123456789012345678901234',
+    SPLIT_OWNER: '0x6789012345678901234567890123456789012345',
+    PRINCIPAL_RECIPIENT: '0x7890123456789012345678901234567890123456',
+    ZERO_ADDRESS: ZeroAddress,
+};
 export const enr = 'enr:-HW4QLlrtMjFLGkFT1bwdGbvZQlH8hLi0M2g44JAxEYP3BZmYpcsy9Q56HPPD87fMucjvLv4-obEFacpsg0ehRilbHeAgmlkgnY0iXNlY3AyNTZrMaEDRaa5o2aSgqyFq_ERZcQTztrOij1mFtXX1bJuVI6ieak';
 // v1.6.0
 export const clusterLockV1X6 = {

package/dist/esm/test/splits/splits.spec.js

@@ -0,0 +1,237 @@
+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());
+    });
+};
+import { Client } from '../../src';
+import { CHAIN_CONFIGURATION } from '../../src/constants';
+import { formatRecipientsForSplitV2, predictSplitV2Address, isSplitV2Deployed, deployOVMAndSplitV2, deployOVMContract, } from '../../src/splits/splitHelpers';
+import { isContractAvailable } from '../../src/utils';
+import { TEST_ADDRESSES } from '../fixtures';
+// Mock the split helpers
+jest.mock('../../src/splits/splitHelpers', () => ({
+    formatRecipientsForSplitV2: jest.fn(),
+    predictSplitV2Address: jest.fn(),
+    isSplitV2Deployed: jest.fn(),
+    deployOVMContract: jest.fn(),
+    deployOVMAndSplitV2: jest.fn(),
+}));
+// Mock the utils
+jest.mock('../../src/utils', () => ({
+    isContractAvailable: jest.fn(),
+}));
+// Mock the validation
+jest.mock('../../src/ajv', () => ({
+    validatePayload: jest.fn(data => data),
+}));
+// Type the mocked functions
+const mockFormatRecipientsForSplitV2 = formatRecipientsForSplitV2;
+const mockPredictSplitV2Address = predictSplitV2Address;
+const mockIsSplitV2Deployed = isSplitV2Deployed;
+const mockDeployOVMAndSplitV2 = deployOVMAndSplitV2;
+const mockDeployOVMContract = deployOVMContract;
+const mockIsContractAvailable = isContractAvailable;
+describe('ObolSplits', () => {
+    let client;
+    let mockSigner;
+    let mockProvider;
+    beforeEach(() => {
+        // Clear all mocks before each test
+        jest.clearAllMocks();
+        mockSigner = {
+            getAddress: jest
+                .fn()
+                .mockResolvedValue('0x1234567890123456789012345678901234567890'),
+            signTypedData: jest.fn().mockResolvedValue('0xsigned'),
+            provider: {
+                getCode: jest.fn().mockResolvedValue('0x123456'),
+            },
+        };
+        mockProvider = {
+            getCode: jest.fn().mockResolvedValue('0x123456'),
+        };
+        client = new Client({ chainId: 1 }, mockSigner, mockProvider);
+    });
+    describe('createValidatorManagerAndRewardsSplit', () => {
+        const mockRewardsSplitPayload = {
+            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 create rewards-only split successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock helper functions
+            mockFormatRecipientsForSplitV2.mockReturnValue([
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+                {
+                    address: '0xDe5aE4De36c966747Ea7DF13BD9589642e2B1D0d',
+                    percentAllocation: 1,
+                },
+            ]);
+            mockPredictSplitV2Address.mockResolvedValue('0xRewardsSplitAddress');
+            mockIsSplitV2Deployed.mockResolvedValue(false);
+            mockDeployOVMAndSplitV2.mockResolvedValue('0xOVMAddress');
+            mockIsContractAvailable.mockResolvedValue(true);
+            const result = yield client.splits.createValidatorManagerAndRewardsSplit(mockRewardsSplitPayload);
+            expect(result).toEqual({
+                withdrawal_address: '0xOVMAddress',
+                fee_recipient_address: '0xRewardsSplitAddress',
+            });
+            expect(mockFormatRecipientsForSplitV2).toHaveBeenCalled();
+            expect(mockPredictSplitV2Address).toHaveBeenCalled();
+            expect(mockIsSplitV2Deployed).toHaveBeenCalled();
+            expect(mockDeployOVMAndSplitV2).toHaveBeenCalled();
+        }));
+        it('should throw error when signer is not provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            const clientWithoutSigner = new Client({ chainId: 1 }, undefined, mockProvider);
+            yield expect(clientWithoutSigner.splits.createValidatorManagerAndRewardsSplit(mockRewardsSplitPayload)).rejects.toThrow('Signer is required in createValidatorManagerAndRewardsSplit');
+        }));
+        it('should throw error when chain is not supported', () => __awaiter(void 0, void 0, void 0, function* () {
+            const clientUnsupportedChain = new Client({ chainId: 999 }, mockSigner, mockProvider);
+            yield expect(clientUnsupportedChain.splits.createValidatorManagerAndRewardsSplit(mockRewardsSplitPayload)).rejects.toThrow('Splitter configuration is not supported on 999 chain');
+        }));
+        it('should throw error when OVM factory is not configured', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock chain configuration without OVM factory
+            const originalConfig = CHAIN_CONFIGURATION[1];
+            // Create a new config object without OVM_FACTORY_CONTRACT
+            const configWithoutOVM = Object.assign({}, originalConfig);
+            delete configWithoutOVM.OVM_FACTORY_CONTRACT;
+            CHAIN_CONFIGURATION[1] = configWithoutOVM;
+            yield expect(client.splits.createValidatorManagerAndRewardsSplit(mockRewardsSplitPayload)).rejects.toThrow('OVM contract factory is not configured for chain 1');
+            // Restore original config
+            CHAIN_CONFIGURATION[1] = originalConfig;
+        }));
+    });
+    describe('createValidatorManagerAndTotalSplit', () => {
+        const mockTotalSplitPayload = {
+            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 create total split successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock helper functions
+            mockFormatRecipientsForSplitV2
+                .mockReturnValueOnce([
+                // rewards recipients
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+                {
+                    address: '0xDe5aE4De36c966747Ea7DF13BD9589642e2B1D0d',
+                    percentAllocation: 1,
+                },
+            ])
+                .mockReturnValueOnce([
+                // principal recipients
+                {
+                    address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                    percentAllocation: 60,
+                },
+                {
+                    address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                    percentAllocation: 40,
+                },
+            ]);
+            mockPredictSplitV2Address
+                .mockResolvedValueOnce('0xRewardsSplitAddress')
+                .mockResolvedValueOnce('0xPrincipalSplitAddress');
+            mockIsSplitV2Deployed
+                .mockResolvedValueOnce(false) // rewards split not deployed
+                .mockResolvedValueOnce(false); // principal split not deployed
+            mockDeployOVMAndSplitV2.mockResolvedValue('0xOVMAddress');
+            mockIsContractAvailable.mockResolvedValue(true);
+            const result = yield client.splits.createValidatorManagerAndTotalSplit(mockTotalSplitPayload);
+            expect(result).toEqual({
+                withdrawal_address: '0xOVMAddress',
+                fee_recipient_address: '0xRewardsSplitAddress',
+            });
+            expect(mockFormatRecipientsForSplitV2).toHaveBeenCalledTimes(2);
+            expect(mockPredictSplitV2Address).toHaveBeenCalledTimes(2);
+            expect(mockIsSplitV2Deployed).toHaveBeenCalledTimes(2);
+            expect(mockDeployOVMAndSplitV2).toHaveBeenCalled();
+        }));
+        it('should handle case when both splits are already deployed', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock helper functions
+            mockFormatRecipientsForSplitV2
+                .mockReturnValueOnce([
+                // rewards recipients
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+                {
+                    address: '0xDe5aE4De36c966747Ea7DF13BD9589642e2B1D0d',
+                    percentAllocation: 1,
+                },
+            ])
+                .mockReturnValueOnce([
+                // principal recipients
+                {
+                    address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                    percentAllocation: 60,
+                },
+                {
+                    address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                    percentAllocation: 40,
+                },
+            ]);
+            mockPredictSplitV2Address
+                .mockResolvedValueOnce('0xRewardsSplitAddress')
+                .mockResolvedValueOnce('0xPrincipalSplitAddress');
+            mockIsSplitV2Deployed
+                .mockResolvedValueOnce(true) // rewards split deployed
+                .mockResolvedValueOnce(true); // principal split deployed
+            mockDeployOVMContract.mockResolvedValue('0xOVMAddress');
+            mockIsContractAvailable.mockResolvedValue(true);
+            const result = yield client.splits.createValidatorManagerAndTotalSplit(mockTotalSplitPayload);
+            expect(result).toEqual({
+                withdrawal_address: '0xOVMAddress',
+                fee_recipient_address: '0xRewardsSplitAddress',
+            });
+            expect(mockDeployOVMContract).toHaveBeenCalledWith({
+                OVMOwnerAddress: mockTotalSplitPayload.OVMOwnerAddress,
+                principalRecipient: '0xPrincipalSplitAddress',
+                rewardRecipient: '0xRewardsSplitAddress',
+                principalThreshold: mockTotalSplitPayload.principalThreshold,
+                signer: mockSigner,
+                chainId: 1,
+            });
+        }));
+        it('should throw error when signer is not provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            const clientWithoutSigner = new Client({ chainId: 1 }, undefined, mockProvider);
+            yield expect(clientWithoutSigner.splits.createValidatorManagerAndTotalSplit(mockTotalSplitPayload)).rejects.toThrow('Signer is required in createValidatorManagerAndTotalSplit');
+        }));
+        it('should throw error when chain is not supported', () => __awaiter(void 0, void 0, void 0, function* () {
+            const clientUnsupportedChain = new Client({ chainId: 999 }, mockSigner, mockProvider);
+            yield expect(clientUnsupportedChain.splits.createValidatorManagerAndTotalSplit(mockTotalSplitPayload)).rejects.toThrow('Splitter configuration is not supported on 999 chain');
+        }));
+    });
+    describe('constructor', () => {
+        it('should create Client instance with splits property', () => {
+            const testClient = new Client({ chainId: 1 }, mockSigner, mockProvider);
+            expect(testClient.splits).toBeDefined();
+            expect(testClient.splits.chainId).toBe(1);
+            expect(testClient.splits.provider).toBe(mockProvider);
+        });
+    });
+});