@obolnetwork/obol-sdk 2.6.0 → 2.8.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',
+        });
+    }));
+});

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

@@ -19,7 +19,7 @@ import * as verificationHelpers from '../../src/exits/verificationHelpers';
 jest.mock('../../src/exits/ethUtils');
 jest.mock('@chainsafe/bls', () => {
     const actual = jest.requireActual('@chainsafe/bls');
-    return Object.assign(Object.assign({ __esModule: true }, actual), { init: jest.fn(), verify: jest.fn() });
+    return Object.assign(Object.assign({ __esModule: true }, actual), { init: jest.fn(), verify: jest.fn(), aggregateSignatures: jest.fn() });
 });
 // ENR and elliptic will be spied on, not fully mocked at module level for more flexibility
 const mockedEthUtils = ethUtils;
@@ -298,6 +298,77 @@ describe('exit', () => {
             yield expect(exit.validateExitBlobs(clusterConfigWithMissingShare, mockExitPayload, MOCK_BEACON_API_URL, mockExistingBlobData)).rejects.toThrow('Public share for operator index 0 not found for validator 0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd');
         }));
     });
-    // Add other tests for different scenarios: epoch mismatch, already exited, etc.
-    // Consider testing the case where getExistingBlobData throws an error
+    describe('recombineExitBlobs', () => {
+        it('should successfully recombine signatures into a single exit blob', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockExistingBlob = {
+                public_key: '0x' + '1234'.repeat(24),
+                epoch: '100',
+                validator_index: '200',
+                shares_exit_data: [
+                    {
+                        0: { partial_exit_signature: '0x' + 'a0'.repeat(96) },
+                        2: { partial_exit_signature: '0x' + 'a2'.repeat(96) }, // Note non-sequential indices
+                        1: { partial_exit_signature: '0x' + 'a1'.repeat(96) },
+                    },
+                ],
+            };
+            const expectedAggregatedSig = '0x' + 'ff'.repeat(96);
+            const expectedAggregatedSigBytes = fromHexString(expectedAggregatedSig);
+            mockedBls.aggregateSignatures.mockReturnValue(expectedAggregatedSigBytes);
+            const result = yield exit.recombineExitBlobs(mockExistingBlob);
+            expect(mockedBls.init).toHaveBeenCalledWith('herumi');
+            expect(mockedBls.aggregateSignatures).toHaveBeenCalledTimes(1);
+            const calls = mockedBls.aggregateSignatures.mock.calls;
+            const rawSignatures = calls[0][0];
+            // Check if signatures were passed in sorted order of operator index
+            expect(rawSignatures[0]).toEqual(fromHexString('a0'.repeat(96)));
+            expect(rawSignatures[1]).toEqual(fromHexString('a1'.repeat(96)));
+            expect(rawSignatures[2]).toEqual(fromHexString('a2'.repeat(96)));
+            expect(result).toEqual({
+                public_key: mockExistingBlob.public_key,
+                signed_exit_message: {
+                    message: {
+                        epoch: mockExistingBlob.epoch,
+                        validator_index: mockExistingBlob.validator_index,
+                    },
+                    signature: expectedAggregatedSig,
+                },
+            });
+        }));
+        it('should throw if no valid signatures are found', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockExistingBlob = {
+                public_key: '0x' + '1234'.repeat(24),
+                epoch: '100',
+                validator_index: '200',
+                shares_exit_data: [
+                    {
+                        0: { partial_exit_signature: '' }, // empty sig
+                    },
+                ],
+            };
+            yield expect(exit.recombineExitBlobs(mockExistingBlob)).rejects.toThrow('No valid signatures found for aggregation');
+        }));
+        it('should throw on invalid signature length', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockExistingBlob = {
+                public_key: '0x' + '1234'.repeat(24),
+                epoch: '100',
+                validator_index: '200',
+                shares_exit_data: [
+                    {
+                        0: { partial_exit_signature: '0x1234' },
+                    },
+                ],
+            };
+            yield expect(exit.recombineExitBlobs(mockExistingBlob)).rejects.toThrow('Invalid signature length');
+        }));
+        it('should handle empty shares_exit_data', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockExistingBlob = {
+                public_key: '0x' + '1234'.repeat(24),
+                epoch: '100',
+                validator_index: '200',
+                shares_exit_data: [],
+            };
+            yield expect(exit.recombineExitBlobs(mockExistingBlob)).rejects.toThrow('No shares exit data available for aggregation');
+        }));
+    });
 });

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 = {