@obolnetwork/obol-sdk 2.11.3 → 2.11.5-rc.0

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

@@ -1,177 +0,0 @@
-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 } from '../../src/index';
-import * as utils from '../../src/utils';
-import * as incentivesHelpers from '../../src/incentives/incentiveHelpers';
-import { DEFAULT_BASE_VERSION } from '../../src/constants';
-import { jest, describe, beforeEach, test, expect } from '@jest/globals';
-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);
-const baseUrl = 'https://obol-api-dev.gcp.obol.tech';
-// Fix the type error by properly typing the mock function
-global.fetch = jest.fn();
-describe('Client.incentives', () => {
-    let clientInstance;
-    const mockIncentivesData = {
-        contract_address: '0x1234567890abcdef1234567890abcdef12345678',
-        index: 5,
-        operator_address: '0xabcdef1234567890abcdef1234567890abcdef12',
-        amount: '1000000000000000000',
-        merkle_proof: [
-            '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
-            '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
-        ],
-    };
-    beforeEach(() => {
-        jest.clearAllMocks();
-        clientInstance = new Client({ baseUrl, chainId: 17000 }, mockSigner);
-        global.fetch.mockReset();
-    });
-    test('claimIncentives should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
-        const clientWithoutSigner = new Client({
-            baseUrl,
-            chainId: 17000,
-        });
-        yield expect(clientWithoutSigner.incentives.claimIncentives(mockIncentivesData.operator_address)).rejects.toThrow('Signer is required in claimIncentives');
-    }));
-    test('claimIncentives should throw an error if contract is not available', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest
-            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
-            .mockResolvedValue(mockIncentivesData);
-        jest.spyOn(clientInstance.incentives, 'isClaimed').mockResolvedValue(false);
-        jest
-            .spyOn(utils, 'isContractAvailable')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(false); }));
-        yield expect(clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address)).rejects.toThrow(`Merkle Distributor contract is not available at address ${mockIncentivesData.contract_address}`);
-    }));
-    test('claimIncentives should return txHash on successful claim', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockTxHash = '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
-        jest
-            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
-            .mockResolvedValue(mockIncentivesData);
-        jest.spyOn(clientInstance.incentives, 'isClaimed').mockResolvedValue(false);
-        jest
-            .spyOn(utils, 'isContractAvailable')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-        jest
-            .spyOn(incentivesHelpers, 'claimIncentivesFromMerkleDistributor')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve({ txHash: mockTxHash }); }));
-        const result = yield clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address);
-        expect(result).toEqual({ txHash: mockTxHash });
-        expect(incentivesHelpers.claimIncentivesFromMerkleDistributor).toHaveBeenCalledWith({
-            signer: mockSigner,
-            contractAddress: mockIncentivesData.contract_address,
-            index: mockIncentivesData.index,
-            operatorAddress: mockIncentivesData.operator_address,
-            amount: mockIncentivesData.amount,
-            merkleProof: mockIncentivesData.merkle_proof,
-        });
-    }));
-    test('claimIncentives should return txHash as null when incentives are already claimed', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest
-            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
-            .mockResolvedValue(mockIncentivesData);
-        jest.spyOn(clientInstance.incentives, 'isClaimed').mockResolvedValue(true);
-        const result = yield clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address);
-        expect(result).toEqual({ txHash: null });
-        expect(incentivesHelpers.claimIncentivesFromMerkleDistributor).not.toHaveBeenCalled();
-    }));
-    test('claimIncentives should throw an error if no incentives found for address', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest
-            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
-            .mockRejectedValue(new Error('No incentives found for address'));
-        yield expect(clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address)).rejects.toThrow('Failed to claim incentives: No incentives found for address');
-    }));
-    test('claimIncentives should throw an error if helper function fails', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest
-            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
-            .mockResolvedValue(mockIncentivesData);
-        jest.spyOn(clientInstance.incentives, 'isClaimed').mockResolvedValue(false);
-        jest
-            .spyOn(utils, 'isContractAvailable')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-        jest
-            .spyOn(incentivesHelpers, 'claimIncentivesFromMerkleDistributor')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
-            throw new Error('Helper function error');
-        }));
-        yield expect(clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address)).rejects.toThrow('Failed to claim incentives: Helper function error');
-    }));
-    test('incentives should be initialized with the same chainId as client', () => {
-        const customChainId = 5;
-        const clientWithCustomChain = new Client({ baseUrl, chainId: customChainId }, mockSigner);
-        expect(clientWithCustomChain.incentives.chainId).toBe(customChainId);
-    });
-    test('isClaimed should return true when incentive is claimed', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest
-            .spyOn(incentivesHelpers, 'isClaimedFromMerkleDistributor')
-            .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(mockIncentivesData.contract_address, mockIncentivesData.index, {});
-    }));
-    test('isClaimed should return false when incentive is not claimed', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest
-            .spyOn(incentivesHelpers, 'isClaimedFromMerkleDistributor')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(false); }));
-        const result = yield clientInstance.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index);
-        expect(result).toBe(false);
-    }));
-    test('isClaimed should throw an error if helper function fails', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest
-            .spyOn(incentivesHelpers, 'isClaimedFromMerkleDistributor')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
-            throw new Error('Helper function error');
-        }));
-        yield expect(clientInstance.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index)).rejects.toThrow('Helper function error');
-    }));
-    test('isClaimed should work with a provider and a without signer', () => __awaiter(void 0, void 0, void 0, function* () {
-        const clientWithoutSigner = new Client({
-            baseUrl,
-            chainId: 17000,
-        }, undefined, provider);
-        jest
-            .spyOn(incentivesHelpers, 'isClaimedFromMerkleDistributor')
-            .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(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';
-        const mockIncentives = {
-            operator_address: '0x8c00157cae72c4ed6a1f8bfb60205601f0252e26',
-            amount: '100',
-            index: 1,
-            merkle_proof: ['hash1', 'hash2'],
-            contract_address: '0xContract',
-        };
-        global.fetch.mockResolvedValueOnce({
-            ok: true,
-            status: 200,
-            json: () => __awaiter(void 0, void 0, void 0, function* () { return mockIncentives; }),
-            headers: new Headers(),
-        });
-        const result = yield clientInstance.incentives.getIncentivesByAddress(mockAddress);
-        expect(result).toEqual(mockIncentives);
-        expect(global.fetch).toHaveBeenCalledWith(`${baseUrl}/${DEFAULT_BASE_VERSION}/address/incentives/holesky/${mockAddress}`, expect.objectContaining({ method: 'GET' }));
-    }));
-    test('getIncentivesByAddress should handle API errors', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockAddress = '0x1234567890abcdef1234567890abcdef12345678';
-        global.fetch.mockRejectedValue(new Error('Network error'));
-        yield expect(clientInstance.incentives.getIncentivesByAddress(mockAddress)).rejects.toThrow();
-        expect(global.fetch).toHaveBeenCalled();
-    }));
-});

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

@@ -1,400 +0,0 @@
-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, requestWithdrawalFromOVM, depositWithMulticall3, } 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(),
-    requestWithdrawalFromOVM: jest.fn(),
-    depositWithMulticall3: 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 mockRequestWithdrawalFromOVM = requestWithdrawalFromOVM;
-const mockdepositWithMulticall3 = depositWithMulticall3;
-const mockIsContractAvailable = isContractAvailable;
-describe('ObolSplits', () => {
-    let client;
-    let mockSigner;
-    let mockProvider;
-    beforeEach(() => {
-        // Clear all mocks before each test
-        jest.clearAllMocks();
-        // Reset the mock to not be called by default
-        mockRequestWithdrawalFromOVM.mockReset();
-        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('requestWithdrawal', () => {
-        const mockOVMAddress = '0x1234567890123456789012345678901234567890';
-        const mockPubKeys = [
-            '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
-        ];
-        const mockAmounts = ['32000000000']; // 32 ETH in gwei
-        it('should request withdrawal successfully', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockRequestWithdrawalFromOVM.mockResolvedValue({
-                txHash: '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
-            });
-            const result = yield client.splits.requestWithdrawal({
-                ovmAddress: mockOVMAddress,
-                pubKeys: mockPubKeys,
-                amounts: mockAmounts,
-                withdrawalFees: '1',
-            });
-            expect(result).toEqual({
-                txHash: '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
-            });
-            expect(mockRequestWithdrawalFromOVM).toHaveBeenCalledWith({
-                ovmAddress: mockOVMAddress,
-                pubKeys: mockPubKeys,
-                amounts: mockAmounts,
-                withdrawalFees: '1',
-                signer: mockSigner,
-            });
-        }));
-        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.requestWithdrawal({
-                ovmAddress: mockOVMAddress,
-                pubKeys: mockPubKeys,
-                amounts: mockAmounts,
-                withdrawalFees: '1',
-            })).rejects.toThrow('Signer is required in requestWithdrawal');
-        }));
-        // it('should throw error when amount is below minimum (1,000,000 gwei)', async () => {
-        //   await expect(
-        //     client.splits.requestWithdrawal({
-        //       ovmAddress: mockOVMAddress,
-        //       pubKeys: mockPubKeys,
-        //       amounts: ['500000'], // Below minimum of 1,000,000 gwei
-        //     }),
-        //   ).rejects.toThrow('Validation failed');
-        // });
-        it('should handle multiple validators withdrawal request', () => __awaiter(void 0, void 0, void 0, function* () {
-            const multiplePubKeys = [
-                '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
-                '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd',
-            ];
-            const multipleAmounts = [
-                '32000000000', // 32 ETH
-                '16000000000', // 16 ETH
-            ];
-            mockRequestWithdrawalFromOVM.mockResolvedValue({
-                txHash: '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
-            });
-            const result = yield client.splits.requestWithdrawal({
-                ovmAddress: mockOVMAddress,
-                pubKeys: multiplePubKeys,
-                amounts: multipleAmounts,
-                withdrawalFees: '1',
-            });
-            expect(result).toEqual({
-                txHash: '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
-            });
-            expect(mockRequestWithdrawalFromOVM).toHaveBeenCalledWith({
-                ovmAddress: mockOVMAddress,
-                pubKeys: multiplePubKeys,
-                amounts: multipleAmounts,
-                withdrawalFees: '1',
-                signer: mockSigner,
-            });
-        }));
-    });
-    describe('deposit', () => {
-        const mockOVMAddress = '0x1234567890123456789012345678901234567890';
-        const mockDeposits = [
-            {
-                pubkey: '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
-                withdrawal_credentials: '0x1234567890123456789012345678901234567890',
-                signature: '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
-                deposit_data_root: '0x1234567890123456789012345678901234567890123456789012345678901234',
-                amount: '32000000000000000000', // 32 ETH in wei
-            },
-        ];
-        beforeEach(() => {
-            mockdepositWithMulticall3.mockReset();
-        });
-        it('should successfully deposit to OVM with multicall3', () => __awaiter(void 0, void 0, void 0, function* () {
-            mockdepositWithMulticall3.mockResolvedValue({
-                txHashes: [
-                    '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
-                ],
-            });
-            const result = yield client.splits.deposit({
-                ovmAddress: mockOVMAddress,
-                deposits: mockDeposits,
-            });
-            expect(result).toEqual({
-                txHashes: [
-                    '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
-                ],
-            });
-            expect(mockdepositWithMulticall3).toHaveBeenCalledWith({
-                ovmAddress: mockOVMAddress,
-                deposits: mockDeposits,
-                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.deposit({
-                ovmAddress: mockOVMAddress,
-                deposits: mockDeposits,
-            })).rejects.toThrow('Signer is required in deposit');
-        }));
-        it('should handle multiple deposits', () => __awaiter(void 0, void 0, void 0, function* () {
-            const multipleDeposits = [
-                {
-                    pubkey: '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
-                    withdrawal_credentials: '0x1234567890123456789012345678901234567890',
-                    signature: '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
-                    deposit_data_root: '0x1234567890123456789012345678901234567890123456789012345678901234',
-                    amount: '32000000000000000000', // 32 ETH in wei
-                },
-                {
-                    pubkey: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd',
-                    withdrawal_credentials: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdef',
-                    signature: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd',
-                    deposit_data_root: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd',
-                    amount: '16000000000000000000', // 16 ETH in wei
-                },
-            ];
-            mockdepositWithMulticall3.mockResolvedValue({
-                txHashes: [
-                    '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
-                ],
-            });
-            const result = yield client.splits.deposit({
-                ovmAddress: mockOVMAddress,
-                deposits: multipleDeposits,
-            });
-            expect(result).toEqual({
-                txHashes: [
-                    '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
-                ],
-            });
-            expect(mockdepositWithMulticall3).toHaveBeenCalledWith({
-                ovmAddress: mockOVMAddress,
-                deposits: multipleDeposits,
-                signer: mockSigner,
-                chainId: 1,
-            });
-        }));
-    });
-    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);
-        });
-    });
-});