@obolnetwork/obol-sdk 2.7.0 → 2.8.0

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_ADDRESS
+            const configWithoutOVM = Object.assign({}, originalConfig);
+            delete configWithoutOVM.OVM_FACTORY_ADDRESS;
+            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);
+        });
+    });
+});