@obolnetwork/obol-sdk 2.5.1 → 2.7.0

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

@@ -0,0 +1,399 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const exit_1 = require("../../src/exits/exit");
+const ethUtils = __importStar(require("../../src/exits/ethUtils"));
+const bls = __importStar(require("@chainsafe/bls"));
+const discv5_1 = require("@chainsafe/discv5");
+const elliptic = __importStar(require("elliptic"));
+const constants_1 = require("../../src/constants");
+const ssz_1 = require("@chainsafe/ssz");
+const verificationHelpers = __importStar(require("../../src/exits/verificationHelpers"));
+// --- Mocks ---
+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(), aggregateSignatures: jest.fn() });
+});
+// ENR and elliptic will be spied on, not fully mocked at module level for more flexibility
+const mockedEthUtils = ethUtils;
+const mockedBls = bls;
+// --- Test Data ---
+const MAINNET_BASE_FORK_VERSION = '0x00000000';
+const MAINNET_CAPELLA_FORK_VERSION = constants_1.CAPELLA_FORK_MAPPING[MAINNET_BASE_FORK_VERSION];
+const MOCK_GENESIS_ROOT = '0x0000000000000000000000000000000000000000000000000000000000000001';
+const MOCK_BEACON_API_URL = 'http://localhost:5052';
+const mockOperatorEnr = 'enr:-LK4QFo_n0dUm4PKejSOXf8JkSWq5EINV0XhG1zY00d22QpYdyxSAyQNsGkYQyKR5Ohe2kEkmS0nS31tuqVfXDNf_vEAhGV0aAgQD___2iXChwcEChAgAAAAADg__________g2V0aMfLCGgohEAcNlBpLdCgAAAQAdIaENsZS0CAAAABAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAIAAAAAAAAAAIAAAAAAAAAYAAAAAAAAAAAAAAAAAAAIQA___________gmlkgnY0gmlwhH8AAAGJc2VjcDI1NmsxoQPKwrO7sVJzX4B2vW1bTqWCpGA93R2aZqa2ZCrqSrh8CYN1ZHCCIyg';
+const mockOperatorPublicKeyHex = '03ca0aceeec549cd7f8076bd6d5b4ea582a4603ddd1d9a66a6b6642aeaa4ae1f09';
+const mockExitMessage = {
+    epoch: '1',
+    validator_index: '10',
+};
+const mockSignedExitMessage = {
+    message: mockExitMessage,
+    signature: '0x' + 'ab'.repeat(96),
+};
+const mockExitBlob = {
+    public_key: '0x' + 'cd'.repeat(48),
+    signed_exit_message: mockSignedExitMessage,
+};
+const mockExitPayload = {
+    partial_exits: [mockExitBlob],
+    share_idx: 1,
+    signature: '0x' + 'ef'.repeat(65),
+};
+// Make mockClusterConfig directly ExitClusterConfig for easier use in tests
+const mockClusterConfig = {
+    definition: {
+        operators: [{ enr: mockOperatorEnr }],
+        fork_version: MAINNET_BASE_FORK_VERSION,
+        threshold: 1,
+    },
+    distributed_validators: [
+        {
+            distributed_public_key: mockExitBlob.public_key,
+            public_shares: ['0x' + 'aa'.repeat(48)],
+        },
+    ],
+};
+const mockExistingBlobData = {
+    public_key: mockExitBlob.public_key,
+    epoch: mockExitMessage.epoch,
+    validator_index: mockExitMessage.validator_index,
+    shares_exit_data: [],
+};
+describe('exit', () => {
+    let enrDecodeTxtSpy;
+    let ecVerifySpy;
+    let keyFromPublicSpy;
+    let exit;
+    beforeEach(() => {
+        jest.resetAllMocks();
+        exit = new exit_1.Exit(1, null);
+        mockedBls.init.mockResolvedValue(undefined);
+        mockedBls.verify.mockReturnValue(true);
+        mockedEthUtils.getCapellaFork.mockResolvedValue(MAINNET_CAPELLA_FORK_VERSION);
+        mockedEthUtils.getGenesisValidatorsRoot.mockResolvedValue(MOCK_GENESIS_ROOT);
+        const mockDecodedENR = {
+            publicKey: Buffer.from(mockOperatorPublicKeyHex, 'hex'),
+        };
+        enrDecodeTxtSpy = jest
+            .spyOn(discv5_1.ENR, 'decodeTxt')
+            .mockReturnValue(mockDecodedENR);
+        ecVerifySpy = jest.fn().mockReturnValue(true);
+        keyFromPublicSpy = jest.spyOn(elliptic.ec.prototype, 'keyFromPublic');
+        keyFromPublicSpy.mockImplementation(function () {
+            return { verify: ecVerifySpy };
+        });
+    });
+    afterEach(() => {
+        if (enrDecodeTxtSpy)
+            enrDecodeTxtSpy.mockRestore();
+        jest.restoreAllMocks();
+    });
+    describe('verifyPartialExitSignature', () => {
+        const publicShareKey = mockClusterConfig.distributed_validators[0].public_shares[0];
+        it('should return true for a valid signature', () => __awaiter(void 0, void 0, void 0, function* () {
+            const isValid = yield exit.verifyPartialExitSignature(publicShareKey, mockSignedExitMessage, MAINNET_BASE_FORK_VERSION, MOCK_GENESIS_ROOT);
+            expect(isValid).toBe(true);
+            expect(mockedBls.init).toHaveBeenCalledWith('herumi');
+            expect(mockedBls.verify).toHaveBeenCalled();
+            expect(mockedEthUtils.getCapellaFork).toHaveBeenCalledWith(MAINNET_BASE_FORK_VERSION);
+        }));
+        it('should return false if BLS verification fails', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockedBls.verify.mockReturnValue(false);
+            const isValid = yield exit.verifyPartialExitSignature(publicShareKey, mockSignedExitMessage, MAINNET_BASE_FORK_VERSION, MOCK_GENESIS_ROOT);
+            expect(isValid).toBe(false);
+        }));
+        it('should throw if getCapellaFork returns null', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockedEthUtils.getCapellaFork.mockResolvedValue(null);
+            yield expect(exit.verifyPartialExitSignature(publicShareKey, mockSignedExitMessage, MAINNET_BASE_FORK_VERSION, MOCK_GENESIS_ROOT)).rejects.toThrow('Could not determine Capella fork version');
+        }));
+        it('should call computeDomain and signingRoot with correct parameters', () => __awaiter(void 0, void 0, void 0, function* () {
+            const computeDomainSpy = jest.spyOn(verificationHelpers, 'computeDomain');
+            const signingRootSpy = jest.spyOn(verificationHelpers, 'signingRoot');
+            yield exit.verifyPartialExitSignature(publicShareKey, mockSignedExitMessage, MAINNET_BASE_FORK_VERSION, MOCK_GENESIS_ROOT);
+            expect(computeDomainSpy).toHaveBeenCalledWith((0, ssz_1.fromHexString)('04000000'), MAINNET_CAPELLA_FORK_VERSION, (0, ssz_1.fromHexString)(MOCK_GENESIS_ROOT.substring(2)));
+            expect(signingRootSpy).toHaveBeenCalled();
+            computeDomainSpy.mockRestore();
+            signingRootSpy.mockRestore();
+        }));
+    });
+    describe('verifyExitPayloadSignature', () => {
+        it('should return true for a valid ECDSA signature', () => __awaiter(void 0, void 0, void 0, function* () {
+            const isValid = yield exit.verifyExitPayloadSignature(mockOperatorEnr, mockExitPayload);
+            expect(isValid).toBe(true);
+            expect(enrDecodeTxtSpy).toHaveBeenCalledWith(mockOperatorEnr);
+            expect(ecVerifySpy).toHaveBeenCalled();
+        }));
+        it('should return false if ECDSA verification fails', () => __awaiter(void 0, void 0, void 0, function* () {
+            ecVerifySpy.mockReturnValue(false);
+            const isValid = yield exit.verifyExitPayloadSignature(mockOperatorEnr, mockExitPayload);
+            expect(isValid).toBe(false);
+        }));
+        it('should throw if ENR is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+            enrDecodeTxtSpy.mockImplementation(() => {
+                throw new Error('Invalid ENR');
+            });
+            yield expect(exit.verifyExitPayloadSignature('invalid-enr', mockExitPayload)).rejects.toThrow('Invalid ENR string');
+        }));
+        it('should throw if signature hex is not 128 characters (excluding 0x)', () => __awaiter(void 0, void 0, void 0, function* () {
+            const payloadWithInvalidSig = Object.assign(Object.assign({}, mockExitPayload), { signature: '0x123456' });
+            yield expect(exit.verifyExitPayloadSignature(mockOperatorEnr, payloadWithInvalidSig)).rejects.toThrow('Invalid signature length');
+        }));
+    });
+    describe('validateExitBlobs', () => {
+        it('should successfully validate a new, valid exit blob', () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield exit.validateExitBlobs(mockClusterConfig, mockExitPayload, MOCK_BEACON_API_URL, null);
+            expect(result).toEqual([mockExitBlob]);
+            expect(ecVerifySpy).toHaveBeenCalled(); // Called by internal verifyExitPayloadSignature
+            expect(mockedBls.verify).toHaveBeenCalled(); // Called by internal verifyPartialExitSignature
+        }));
+        it('should throw if operatorIndex (from share_idx) is out of bounds', () => __awaiter(void 0, void 0, void 0, function* () {
+            const invalidPayload = Object.assign(Object.assign({}, mockExitPayload), { share_idx: 0 });
+            yield expect(exit.validateExitBlobs(mockClusterConfig, invalidPayload, MOCK_BEACON_API_URL, mockExistingBlobData)).rejects.toThrow('Invalid share_idx');
+            const invalidPayload2 = Object.assign(Object.assign({}, mockExitPayload), { share_idx: mockClusterConfig.definition.operators.length + 1 });
+            yield expect(exit.validateExitBlobs(mockClusterConfig, invalidPayload2, MOCK_BEACON_API_URL, mockExistingBlobData)).rejects.toThrow('Invalid share_idx');
+        }));
+        it('should throw if payload signature is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+            ecVerifySpy.mockReturnValue(false);
+            yield expect(exit.validateExitBlobs(mockClusterConfig, mockExitPayload, MOCK_BEACON_API_URL, mockExistingBlobData)).rejects.toThrow('Incorrect payload signature');
+        }));
+        it('should throw if getGenesisValidatorsRoot returns null', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockedEthUtils.getGenesisValidatorsRoot.mockResolvedValue(null);
+            yield expect(exit.validateExitBlobs(mockClusterConfig, mockExitPayload, MOCK_BEACON_API_URL, mockExistingBlobData)).rejects.toThrow('Could not retrieve genesis validators root');
+        }));
+        it('should throw if getCapellaFork returns null (unsupported network)', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockedEthUtils.getCapellaFork.mockResolvedValue(null);
+            yield expect(exit.validateExitBlobs(mockClusterConfig, mockExitPayload, MOCK_BEACON_API_URL, mockExistingBlobData)).rejects.toThrow('Unsupported network: Could not determine Capella fork');
+        }));
+        it('should throw if a public key in an exit blob is not found in cluster config', () => __awaiter(void 0, void 0, void 0, function* () {
+            const blobWithUnknownKey = Object.assign(Object.assign({}, mockExitBlob), { public_key: '0x' + 'deadbeef'.repeat(12) });
+            const payloadWithUnknownKey = Object.assign(Object.assign({}, mockExitPayload), { partial_exits: [blobWithUnknownKey] });
+            yield expect(exit.validateExitBlobs(mockClusterConfig, payloadWithUnknownKey, MOCK_BEACON_API_URL, null)).rejects.toThrow("Public key 0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef not found in the cluster's distributed validators.");
+        }));
+        it('should throw if a partial exit signature is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockedBls.verify.mockReturnValue(false);
+            yield expect(exit.validateExitBlobs(mockClusterConfig, mockExitPayload, MOCK_BEACON_API_URL, null)).rejects.toThrow('Invalid partial exit signature for validator 0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd by operator index 0.');
+        }));
+        it('should return an empty array if an exit blob has already been processed (epoch match)', () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield exit.validateExitBlobs(mockClusterConfig, mockExitPayload, MOCK_BEACON_API_URL, mockExistingBlobData);
+            expect(result).toEqual([]);
+        }));
+        it('should throw if an exit blob has been processed with a different validator index', () => __awaiter(void 0, void 0, void 0, function* () {
+            const existingBlobWithDifferentIndex = {
+                public_key: mockExitBlob.public_key,
+                epoch: mockExitMessage.epoch,
+                validator_index: (parseInt(mockExitMessage.validator_index, 10) + 1).toString(), // Different index
+                shares_exit_data: [],
+            };
+            yield expect(exit.validateExitBlobs(mockClusterConfig, mockExitPayload, MOCK_BEACON_API_URL, existingBlobWithDifferentIndex)).rejects.toThrow('Validator index mismatch for already processed exit for public key 0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd. Expected 11, got 10.');
+        }));
+        it('should throw if an exit blob has been processed with a higher epoch', () => __awaiter(void 0, void 0, void 0, function* () {
+            const existingBlobWithHigherEpoch = {
+                public_key: mockExitBlob.public_key,
+                epoch: (parseInt(mockExitMessage.epoch, 10) + 1).toString(), // Existing epoch is HIGHER (e.g. 2)
+                validator_index: mockExitMessage.validator_index,
+                shares_exit_data: [],
+            };
+            // currentExitBlob (from mockExitPayload) has mockExitMessage.epoch (e.g. '1')
+            yield expect(exit.validateExitBlobs(mockClusterConfig, mockExitPayload, MOCK_BEACON_API_URL, existingBlobWithHigherEpoch)).rejects.toThrow('New exit epoch 1 is not greater than existing exit epoch 2 for validator 0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd.');
+        }));
+        it('should successfully validate if an exit blob has been processed with a lower epoch', () => __awaiter(void 0, void 0, void 0, function* () {
+            const existingBlobWithLowerEpoch = {
+                public_key: mockExitBlob.public_key,
+                epoch: (parseInt(mockExitMessage.epoch, 10) - 1).toString(),
+                validator_index: mockExitMessage.validator_index,
+                shares_exit_data: [],
+            };
+            const result = yield exit.validateExitBlobs(mockClusterConfig, mockExitPayload, MOCK_BEACON_API_URL, existingBlobWithLowerEpoch);
+            expect(result).toEqual([mockExitBlob]);
+        }));
+        it('should throw on signature mismatch for existing blob with same epoch', () => __awaiter(void 0, void 0, void 0, function* () {
+            const operatorIndex = 0;
+            const operatorShareIndexString = String(operatorIndex);
+            const existingBlobWithDifferentSignature = {
+                public_key: mockExitBlob.public_key,
+                epoch: mockExitMessage.epoch,
+                validator_index: mockExitMessage.validator_index,
+                shares_exit_data: [
+                    {
+                        [operatorShareIndexString]: {
+                            partial_exit_signature: '0x' + 'different'.repeat(16),
+                        },
+                    },
+                ],
+            };
+            yield expect(exit.validateExitBlobs(mockClusterConfig, mockExitPayload, MOCK_BEACON_API_URL, existingBlobWithDifferentSignature)).rejects.toThrow('Signature mismatch for validator 0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd, operator index 0 at epoch 1.');
+        }));
+        it('should handle multiple blobs, some new, some already processed', () => __awaiter(void 0, void 0, void 0, function* () {
+            const anotherMockExitBlob = {
+                public_key: '0x' + '11'.repeat(48),
+                signed_exit_message: {
+                    message: { epoch: '2', validator_index: '20' },
+                    signature: '0x' + 'bb'.repeat(96),
+                },
+            };
+            const payloadWithTwoBlobs = Object.assign(Object.assign({}, mockExitPayload), { partial_exits: [mockExitBlob, anotherMockExitBlob] });
+            const clusterConfigWithTwoValidators = Object.assign(Object.assign({}, mockClusterConfig), { distributed_validators: [
+                    ...mockClusterConfig.distributed_validators,
+                    {
+                        distributed_public_key: anotherMockExitBlob.public_key,
+                        public_shares: ['0x' + 'cc'.repeat(48)],
+                    },
+                ] });
+            // Only the first blob has existing data, second is new
+            const existingBlobDataForFirstOnly = {
+                public_key: mockExitBlob.public_key,
+                epoch: mockExitMessage.epoch,
+                validator_index: mockExitMessage.validator_index,
+                shares_exit_data: [],
+            };
+            const result = yield exit.validateExitBlobs(clusterConfigWithTwoValidators, payloadWithTwoBlobs, MOCK_BEACON_API_URL, existingBlobDataForFirstOnly);
+            expect(result.length).toBe(1);
+            expect(result[0]).toEqual(anotherMockExitBlob);
+        }));
+        it('should throw if getGenesisValidatorsRoot itself throws an error', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockedEthUtils.getGenesisValidatorsRoot.mockRejectedValue(new Error('Beacon node unavailable'));
+            yield expect(exit.validateExitBlobs(mockClusterConfig, mockExitPayload, MOCK_BEACON_API_URL, mockExistingBlobData)).rejects.toThrow('Beacon node unavailable');
+        }));
+        // Additional test cases to match API service coverage
+        it('should handle public key format differences (with and without 0x prefix)', () => __awaiter(void 0, void 0, void 0, function* () {
+            const blobWithoutPrefix = Object.assign(Object.assign({}, mockExitBlob), { public_key: 'cd'.repeat(48) });
+            const payloadWithoutPrefix = Object.assign(Object.assign({}, mockExitPayload), { partial_exits: [blobWithoutPrefix] });
+            const clusterConfigWithoutPrefix = Object.assign(Object.assign({}, mockClusterConfig), { distributed_validators: [
+                    {
+                        distributed_public_key: '0x' + 'cd'.repeat(48), // With 0x prefix
+                        public_shares: ['0x' + 'aa'.repeat(48)],
+                    },
+                ] });
+            const result = yield exit.validateExitBlobs(clusterConfigWithoutPrefix, payloadWithoutPrefix, MOCK_BEACON_API_URL, null);
+            expect(result).toEqual([blobWithoutPrefix]);
+        }));
+        it('should handle public key case differences', () => __awaiter(void 0, void 0, void 0, function* () {
+            const blobWithUppercase = Object.assign(Object.assign({}, mockExitBlob), { public_key: '0x' + 'CD'.repeat(48) });
+            const payloadWithUppercase = Object.assign(Object.assign({}, mockExitPayload), { partial_exits: [blobWithUppercase] });
+            const clusterConfigWithLowercase = Object.assign(Object.assign({}, mockClusterConfig), { distributed_validators: [
+                    {
+                        distributed_public_key: '0x' + 'cd'.repeat(48), // Lowercase
+                        public_shares: ['0x' + 'aa'.repeat(48)],
+                    },
+                ] });
+            const result = yield exit.validateExitBlobs(clusterConfigWithLowercase, payloadWithUppercase, MOCK_BEACON_API_URL, null);
+            expect(result).toEqual([blobWithUppercase]);
+        }));
+        it('should throw if public share for operator index is not found', () => __awaiter(void 0, void 0, void 0, function* () {
+            const clusterConfigWithMissingShare = Object.assign(Object.assign({}, mockClusterConfig), { distributed_validators: [
+                    {
+                        distributed_public_key: mockExitBlob.public_key,
+                        public_shares: [], // Empty public shares array
+                    },
+                ] });
+            yield expect(exit.validateExitBlobs(clusterConfigWithMissingShare, mockExitPayload, MOCK_BEACON_API_URL, mockExistingBlobData)).rejects.toThrow('Public share for operator index 0 not found for validator 0xcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd');
+        }));
+    });
+    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 = (0, ssz_1.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((0, ssz_1.fromHexString)('a0'.repeat(96)));
+            expect(rawSignatures[1]).toEqual((0, ssz_1.fromHexString)('a1'.repeat(96)));
+            expect(rawSignatures[2]).toEqual((0, ssz_1.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/cjs/test/exit/verificationHelpers.spec.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const verificationHelpers_1 = require("../../src/exits/verificationHelpers");
+const constants_1 = require("../../src/constants"); // Assuming this contains fork versions
+const ssz_1 = require("@chainsafe/ssz");
+// Mock data similar to what's used in obol-api tests or common scenarios
+const DOMAIN_VOLUNTARY_EXIT_HEX = '0x04000000';
+const MAINNET_BASE_FORK_VERSION = '0x00000000';
+const MAINNET_CAPELLA_FORK_VERSION = constants_1.CAPELLA_FORK_MAPPING[MAINNET_BASE_FORK_VERSION]; // '0x03000000'
+// Sample SSZ Object Root (32 bytes, replace with a realistic one if available from other tests)
+const MOCK_SSZ_OBJECT_ROOT_HEX = '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+describe('verificationHelpers', () => {
+    describe('computeDomain', () => {
+        it('should compute a domain with default genesis root', () => {
+            const domainType = (0, ssz_1.fromHexString)(DOMAIN_VOLUNTARY_EXIT_HEX.substring(2));
+            const domain = (0, verificationHelpers_1.computeDomain)(domainType, MAINNET_CAPELLA_FORK_VERSION);
+            expect(domain).toBeInstanceOf(Uint8Array);
+            expect(domain.length).toBe(32);
+            // Add more specific expectation if a known domain value exists for these inputs
+        });
+        it('should compute a domain with a custom genesis root', () => {
+            const domainType = (0, ssz_1.fromHexString)(DOMAIN_VOLUNTARY_EXIT_HEX.substring(2));
+            const customGenesisRoot = (0, ssz_1.fromHexString)(MOCK_SSZ_OBJECT_ROOT_HEX.substring(2)); // Using a mock root
+            const domain = (0, verificationHelpers_1.computeDomain)(domainType, MAINNET_CAPELLA_FORK_VERSION, customGenesisRoot);
+            expect(domain).toBeInstanceOf(Uint8Array);
+            expect(domain.length).toBe(32);
+            // Add more specific expectation if a known domain value exists
+        });
+        it('should use GENESIS_VALIDATOR_ROOT_HEX_STRING when override is undefined', () => {
+            const domainType = (0, ssz_1.fromHexString)(DOMAIN_VOLUNTARY_EXIT_HEX.substring(2));
+            const domain1 = (0, verificationHelpers_1.computeDomain)(domainType, MAINNET_CAPELLA_FORK_VERSION);
+            const domain2 = (0, verificationHelpers_1.computeDomain)(domainType, MAINNET_CAPELLA_FORK_VERSION, (0, ssz_1.fromHexString)(verificationHelpers_1.GENESIS_VALIDATOR_ROOT_HEX_STRING.substring(2)));
+            expect(domain1).toEqual(domain2);
+        });
+        it('should throw an error for invalid fork version hex string (e.g. too short)', () => {
+            const domainType = (0, ssz_1.fromHexString)(DOMAIN_VOLUNTARY_EXIT_HEX.substring(2));
+            // Example of an invalid (too short) fork version string
+            const invalidForkVersion = '0x0300';
+            expect(() => (0, verificationHelpers_1.computeDomain)(domainType, invalidForkVersion)).toThrow();
+        });
+        it('should throw an error for invalid domainType (e.g. not 4 bytes)', () => {
+            const invalidDomainType = (0, ssz_1.fromHexString)('010203'); // 3 bytes
+            expect(() => (0, verificationHelpers_1.computeDomain)(invalidDomainType, MAINNET_CAPELLA_FORK_VERSION)).toThrow();
+        });
+    });
+    describe('signingRoot', () => {
+        it('should compute a signing root', () => {
+            const domainType = (0, ssz_1.fromHexString)(DOMAIN_VOLUNTARY_EXIT_HEX.substring(2));
+            const domain = (0, verificationHelpers_1.computeDomain)(domainType, MAINNET_CAPELLA_FORK_VERSION);
+            const messageBuffer = Buffer.from(MOCK_SSZ_OBJECT_ROOT_HEX.substring(2), 'hex');
+            const root = (0, verificationHelpers_1.signingRoot)(domain, messageBuffer);
+            expect(root).toBeInstanceOf(Uint8Array);
+            expect(root.length).toBe(32);
+            // Add more specific expectation if a known signing root value exists
+        });
+        it('should throw if domain is not 32 bytes', () => {
+            const invalidDomain = new Uint8Array(31); // Not 32 bytes
+            const messageBuffer = Buffer.from(MOCK_SSZ_OBJECT_ROOT_HEX.substring(2), 'hex');
+            expect(() => (0, verificationHelpers_1.signingRoot)(invalidDomain, messageBuffer)).toThrow();
+        });
+        it('should throw if messageBuffer is not 32 bytes', () => {
+            const domainType = (0, ssz_1.fromHexString)(DOMAIN_VOLUNTARY_EXIT_HEX.substring(2));
+            const domain = (0, verificationHelpers_1.computeDomain)(domainType, MAINNET_CAPELLA_FORK_VERSION);
+            const invalidMessageBuffer = Buffer.from('0102030405060708', 'hex'); // Not 32 bytes
+            expect(() => (0, verificationHelpers_1.signingRoot)(domain, invalidMessageBuffer)).toThrow();
+        });
+    });
+});

package/dist/cjs/test/{incentives.test.js → incentives/incentives.spec.js}

@@ -34,10 +34,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
-const index_1 = require("../src/index");
-const utils = __importStar(require("../src/utils"));
-const incentivesHelpers = __importStar(require("../src/incentiveHelpers"));
-const constants_1 = require("../src/constants");
+const index_1 = require("../../src/index");
+const utils = __importStar(require("../../src/utils"));
+const incentivesHelpers = __importStar(require("../../src/incentives/incentiveHelpers"));
+const constants_1 = require("../../src/constants");
 const globals_1 = require("@jest/globals");
 const mnemonic = (_b = (_a = ethers_1.ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) !== null && _b !== void 0 ? _b : '';
 const privateKey = ethers_1.ethers.Wallet.fromPhrase(mnemonic).privateKey;

package/dist/esm/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@obolnetwork/obol-sdk",
-    "version": "2.5.1",
+    "version": "2.7.0",
     "description": "A package for creating Distributed Validators using the Obol API.",
     "bugs": {
         "url": "https://github.com/obolnetwork/obol-sdk/issues"
@@ -15,7 +15,7 @@
         "compile": "tsc -b ./tsconfig.cjs.json ./tsconfig.esm.json ./tsconfig.types.json",
         "build:clean": "rm -rf ./dist",
         "build": "npm-run-all build:clean compile",
-        "test": "jest ./test/*.test.ts",
+        "test": "jest test/**/*.spec.ts --testPathIgnorePatterns=test/sdk-package/",
         "generate-typedoc": "typedoc",
         "npm:publish": "npm publish --tag latest",
         "release": "release-it",
@@ -130,7 +130,7 @@
             "^bn.js$": "<rootDir>/node_modules/bn.js",
             "^asn1.js$": "<rootDir>/node_modules/asn1.js",
             "^hash.js$": "<rootDir>/node_modules/hash.js",
-            "(.+)\\.js": "$1"
+            "^(\\.\\.?\\/.+)\\.js$": "$1"
         },
         "extensionsToTreatAsEsm": [
             ".ts"

package/dist/esm/src/constants.js

@@ -149,3 +149,15 @@ export const PROVIDER_MAP = {
     11155111: `${process.env.RPC_SEPOLIA}`, // Sepolia
     100: `${process.env.RPC_GNOSIS}`, // Gnosis
 };
+/**
+ * Maps base fork versions to their corresponding Capella fork versions.
+ * Example: Mainnet Capella fork version.
+ */
+export const CAPELLA_FORK_MAPPING = {
+    '0x00000000': '0x03000000', // Mainnet
+    '0x00001020': '0x03001020', // Goerli
+    '0x00000064': '0x03000064', // Gnosis
+    '0x90000069': '0x90000072', // Sepolia
+    '0x01017000': '0x04017000', // Holesky
+    '0x10000910': '0x40000910', // Hoodi
+};

package/dist/esm/src/exits/ethUtils.js

@@ -0,0 +1,52 @@
+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 { CAPELLA_FORK_MAPPING } from '../constants';
+/**
+ * Retrieves the Capella fork version for a given base fork version.
+ * @param fork_version - The base fork version string (e.g., '0x00000000' for mainnet).
+ * @returns A promise that resolves to the Capella fork version string, or null if not found.
+ */
+export function getCapellaFork(fork_version) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Ensure the CAPELLA_FORK_MAPPING uses the base fork_version as key
+        if (CAPELLA_FORK_MAPPING[fork_version]) {
+            return CAPELLA_FORK_MAPPING[fork_version];
+        }
+        return null;
+    });
+}
+/**
+ * Fetches the genesis validators root from a beacon node.
+ * @param beaconNodeApiUrl - The base URL of the beacon node API (e.g., http://localhost:5052).
+ * @returns A promise that resolves to the genesis_validators_root string, or null on error.
+ * @throws Will throw an error if the network corresponding to the fork_version is not supported or if the HTTP request fails.
+ */
+export function getGenesisValidatorsRoot(beaconNodeApiUrl) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const genesisEndpoint = `${beaconNodeApiUrl}/eth/v1/beacon/genesis`;
+        try {
+            const response = yield fetch(genesisEndpoint, {
+                method: 'GET',
+            });
+            const json = yield response.json();
+            if ((_a = json.data) === null || _a === void 0 ? void 0 : _a.genesis_validators_root) {
+                return json.data.genesis_validators_root;
+            }
+            console.error('Invalid response structure from genesis endpoint', json);
+            return null;
+        }
+        catch (e) {
+            console.error(`Error fetching genesis validators root from ${genesisEndpoint}:`, e);
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            throw new Error(`Failed to fetch genesis validators root: ${errorMessage}`);
+        }
+    });
+}