@obolnetwork/obol-sdk 2.6.0 → 2.7.0

package/dist/cjs/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@obolnetwork/obol-sdk",
-    "version": "2.6.0",
+    "version": "2.7.0",
     "description": "A package for creating Distributed Validators using the Obol API.",
     "bugs": {
         "url": "https://github.com/obolnetwork/obol-sdk/issues"

package/dist/cjs/src/exits/exit.js

@@ -416,5 +416,87 @@ class Exit {
             return validNonDuplicateBlobs;
         });
     }
+    /**
+     * Recombines exit blobs into a single exit blob.
+     *
+     * This method aggregates partial exit signatures from multiple operators into a single exit blob.
+     * It ensures that the signatures are properly ordered and aggregated according to the operator indices.
+     *
+     * @param exitBlob - The existing exit blob data containing partial exit signatures
+     *
+     * @returns Promise resolving to a single exit blob with aggregated signatures
+     *
+     * @throws {Error} When no valid signatures are found for aggregation
+     * @throws {Error} When signature length is invalid
+     * @throws {Error} When signature parsing fails
+     *
+     * @example
+     * ```typescript
+     * const aggregatedExitBlob = await exit.recombineExitBlobs(existingBlobData);
+     * ```
+     */
+    recombineExitBlobs(exitBlob) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, bls_1.init)('herumi');
+            // Map to store signatures by their share index (matching Go's map[int]tbls.Signature)
+            const signaturesByIndex = new Map();
+            // Extract signatures from shares_exit_data (equivalent to er.Signatures in Go)
+            if (!exitBlob.shares_exit_data || exitBlob.shares_exit_data.length === 0) {
+                throw new Error('No shares exit data available for aggregation');
+            }
+            const signaturesMap = exitBlob.shares_exit_data[0] || {};
+            for (const [sigIdxStr, sigData] of Object.entries(signaturesMap)) {
+                const sigStr = sigData.partial_exit_signature;
+                if (!sigStr || sigStr.length === 0) {
+                    // ignore, the associated share index didn't push a partial signature yet
+                    continue;
+                }
+                if (sigStr.length < 2) {
+                    throw new Error(`Signature string has invalid size: ${sigStr.length}`);
+                }
+                // Remove 0x prefix and ensure it's 96 bytes (192 hex chars)
+                const cleanSigStr = sigStr.startsWith('0x')
+                    ? sigStr.substring(2)
+                    : sigStr;
+                if (cleanSigStr.length !== 192) {
+                    throw new Error(`Invalid signature length. Expected 192 hex chars (96 bytes), got ${cleanSigStr.length}`);
+                }
+                try {
+                    const sigBytes = (0, ssz_1.fromHexString)(cleanSigStr);
+                    // Convert string index to number and add 1 (matching Go's sigIdx+1)
+                    const sigIdx = parseInt(sigIdxStr, 10);
+                    signaturesByIndex.set(sigIdx + 1, sigBytes);
+                }
+                catch (err) {
+                    throw new Error(`Invalid partial signature: ${String(err)}`);
+                }
+            }
+            if (signaturesByIndex.size === 0) {
+                throw new Error('No valid signatures found for aggregation');
+            }
+            // Sort by index and extract signatures in correct order
+            const sortedIndices = Array.from(signaturesByIndex.keys()).sort((a, b) => a - b);
+            const rawSignatures = sortedIndices.map(idx => {
+                const signature = signaturesByIndex.get(idx);
+                if (signature === undefined) {
+                    throw new Error(`Missing signature for index ${idx}`);
+                }
+                return signature;
+            });
+            // Aggregate signatures (equivalent to tbls.ThresholdAggregate in Go)
+            // Note: @chainsafe/bls doesn't have explicit threshold aggregation, but ordering should be preserved
+            const fullSig = (0, bls_1.aggregateSignatures)(rawSignatures);
+            return {
+                public_key: exitBlob.public_key,
+                signed_exit_message: {
+                    message: {
+                        epoch: exitBlob.epoch,
+                        validator_index: exitBlob.validator_index,
+                    },
+                    signature: '0x' + Buffer.from(fullSig).toString('hex'),
+                },
+            };
+        });
+    }
 }
 exports.Exit = Exit;

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

@@ -44,7 +44,7 @@ const verificationHelpers = __importStar(require("../../src/exits/verificationHe
 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;
@@ -323,6 +323,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 = (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/esm/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@obolnetwork/obol-sdk",
-    "version": "2.6.0",
+    "version": "2.7.0",
     "description": "A package for creating Distributed Validators using the Obol API.",
     "bugs": {
         "url": "https://github.com/obolnetwork/obol-sdk/issues"

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

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { ENR } from '@chainsafe/discv5';
 import * as elliptic from 'elliptic';
-import { init, verify } from '@chainsafe/bls';
+import { init, verify, aggregateSignatures } from '@chainsafe/bls';
 import { ByteVectorType, ContainerType, fromHexString, ListCompositeType, UintNumberType, } from '@chainsafe/ssz';
 import { getCapellaFork, getGenesisValidatorsRoot } from './ethUtils';
 import { computeDomain, signingRoot } from './verificationHelpers';
@@ -390,4 +390,86 @@ export class Exit {
             return validNonDuplicateBlobs;
         });
     }
+    /**
+     * Recombines exit blobs into a single exit blob.
+     *
+     * This method aggregates partial exit signatures from multiple operators into a single exit blob.
+     * It ensures that the signatures are properly ordered and aggregated according to the operator indices.
+     *
+     * @param exitBlob - The existing exit blob data containing partial exit signatures
+     *
+     * @returns Promise resolving to a single exit blob with aggregated signatures
+     *
+     * @throws {Error} When no valid signatures are found for aggregation
+     * @throws {Error} When signature length is invalid
+     * @throws {Error} When signature parsing fails
+     *
+     * @example
+     * ```typescript
+     * const aggregatedExitBlob = await exit.recombineExitBlobs(existingBlobData);
+     * ```
+     */
+    recombineExitBlobs(exitBlob) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield init('herumi');
+            // Map to store signatures by their share index (matching Go's map[int]tbls.Signature)
+            const signaturesByIndex = new Map();
+            // Extract signatures from shares_exit_data (equivalent to er.Signatures in Go)
+            if (!exitBlob.shares_exit_data || exitBlob.shares_exit_data.length === 0) {
+                throw new Error('No shares exit data available for aggregation');
+            }
+            const signaturesMap = exitBlob.shares_exit_data[0] || {};
+            for (const [sigIdxStr, sigData] of Object.entries(signaturesMap)) {
+                const sigStr = sigData.partial_exit_signature;
+                if (!sigStr || sigStr.length === 0) {
+                    // ignore, the associated share index didn't push a partial signature yet
+                    continue;
+                }
+                if (sigStr.length < 2) {
+                    throw new Error(`Signature string has invalid size: ${sigStr.length}`);
+                }
+                // Remove 0x prefix and ensure it's 96 bytes (192 hex chars)
+                const cleanSigStr = sigStr.startsWith('0x')
+                    ? sigStr.substring(2)
+                    : sigStr;
+                if (cleanSigStr.length !== 192) {
+                    throw new Error(`Invalid signature length. Expected 192 hex chars (96 bytes), got ${cleanSigStr.length}`);
+                }
+                try {
+                    const sigBytes = fromHexString(cleanSigStr);
+                    // Convert string index to number and add 1 (matching Go's sigIdx+1)
+                    const sigIdx = parseInt(sigIdxStr, 10);
+                    signaturesByIndex.set(sigIdx + 1, sigBytes);
+                }
+                catch (err) {
+                    throw new Error(`Invalid partial signature: ${String(err)}`);
+                }
+            }
+            if (signaturesByIndex.size === 0) {
+                throw new Error('No valid signatures found for aggregation');
+            }
+            // Sort by index and extract signatures in correct order
+            const sortedIndices = Array.from(signaturesByIndex.keys()).sort((a, b) => a - b);
+            const rawSignatures = sortedIndices.map(idx => {
+                const signature = signaturesByIndex.get(idx);
+                if (signature === undefined) {
+                    throw new Error(`Missing signature for index ${idx}`);
+                }
+                return signature;
+            });
+            // Aggregate signatures (equivalent to tbls.ThresholdAggregate in Go)
+            // Note: @chainsafe/bls doesn't have explicit threshold aggregation, but ordering should be preserved
+            const fullSig = aggregateSignatures(rawSignatures);
+            return {
+                public_key: exitBlob.public_key,
+                signed_exit_message: {
+                    message: {
+                        epoch: exitBlob.epoch,
+                        validator_index: exitBlob.validator_index,
+                    },
+                    signature: '0x' + Buffer.from(fullSig).toString('hex'),
+                },
+            };
+        });
+    }
 }

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/types/src/exits/exit.d.ts

@@ -1,4 +1,4 @@
-import type { ProviderType, ExitClusterConfig, ExitValidationPayload, ExitValidationBlob, SignedExitValidationMessage, ExistingExitValidationBlobData } from '../types';
+import type { ProviderType, ExitClusterConfig, ExitValidationPayload, ExitValidationBlob, SignedExitValidationMessage, ExistingExitValidationBlobData, FullExitBlob } from '../types';
 /**
  * Exit validation and verification class for Obol distributed validators.
  *
@@ -177,4 +177,24 @@ export declare class Exit {
      * ```
      */
     validateExitBlobs(clusterConfig: ExitClusterConfig, exitsPayload: ExitValidationPayload, beaconNodeApiUrl: string, existingBlobData: ExistingExitValidationBlobData | null): Promise<ExitValidationBlob[]>;
+    /**
+     * Recombines exit blobs into a single exit blob.
+     *
+     * This method aggregates partial exit signatures from multiple operators into a single exit blob.
+     * It ensures that the signatures are properly ordered and aggregated according to the operator indices.
+     *
+     * @param exitBlob - The existing exit blob data containing partial exit signatures
+     *
+     * @returns Promise resolving to a single exit blob with aggregated signatures
+     *
+     * @throws {Error} When no valid signatures are found for aggregation
+     * @throws {Error} When signature length is invalid
+     * @throws {Error} When signature parsing fails
+     *
+     * @example
+     * ```typescript
+     * const aggregatedExitBlob = await exit.recombineExitBlobs(existingBlobData);
+     * ```
+     */
+    recombineExitBlobs(exitBlob: ExistingExitValidationBlobData): Promise<FullExitBlob>;
 }

package/dist/types/src/types.d.ts

@@ -332,17 +332,52 @@ export interface ExitValidationPayload {
  * Represents the data structure for an already existing exit blob for exit validation.
  */
 export interface ExistingExitValidationBlobData {
-    /** The public key of the validator to exit. */
+    /**
+     * The BLS public key of the validator in hex format
+     */
     public_key: string;
-    /** The epoch at which the validator wishes to exit. */
+    /**
+     * The epoch number when the exit is scheduled to occur
+     */
     epoch: string;
-    /** The index of the validator in the beacon chain. */
+    /**
+     * The unique index of the validator in the beacon chain
+     */
     validator_index: string;
-    /** Collection of partial exit signatures from different shares. */
+    /**
+     * Array of distributed validator shares exit data, where each share contains
+     * the partial exit signature from each operator in the cluster
+     */
     shares_exit_data: Array<Record<string, {
         partial_exit_signature: string;
     }>>;
 }
+export interface FullExitBlob {
+    /**
+     * The signed voluntary exit message containing the exit details and signature
+     */
+    signed_exit_message: {
+        /**
+         * The voluntary exit message details
+         */
+        message: {
+            /**
+             * The epoch number when the validator exit will be processed
+             */
+            epoch: string;
+            /**
+             * The unique index of the validator requesting to exit
+             */
+            validator_index: string;
+        };
+        /**
+         * The BLS12-381 hex-encoded signature of the exit message
+         */
+        signature: string;
+    };
+    /** The public key of the validator to exit. */
+    public_key: string;
+}
 /**
  * Generic HTTP request function type.
  * Args:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obolnetwork/obol-sdk",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "A package for creating Distributed Validators using the Obol API.",
   "bugs": {
     "url": "https://github.com/obolnetwork/obol-sdk/issues"

package/src/exits/exit.ts

@@ -1,6 +1,6 @@
 import { ENR } from '@chainsafe/discv5';
 import * as elliptic from 'elliptic';
-import { init, verify } from '@chainsafe/bls';
+import { init, verify, aggregateSignatures } from '@chainsafe/bls';
 import {
   ByteVectorType,
   ContainerType,
@@ -16,6 +16,7 @@ import type {
   ExitValidationMessage,
   SignedExitValidationMessage,
   ExistingExitValidationBlobData,
+  FullExitBlob,
 } from '../types';
 import { getCapellaFork, getGenesisValidatorsRoot } from './ethUtils';
 import { computeDomain, signingRoot } from './verificationHelpers';
@@ -561,4 +562,100 @@ export class Exit {
 
     return validNonDuplicateBlobs;
   }
+
+  /**
+   * Recombines exit blobs into a single exit blob.
+   *
+   * This method aggregates partial exit signatures from multiple operators into a single exit blob.
+   * It ensures that the signatures are properly ordered and aggregated according to the operator indices.
+   *
+   * @param exitBlob - The existing exit blob data containing partial exit signatures
+   *
+   * @returns Promise resolving to a single exit blob with aggregated signatures
+   *
+   * @throws {Error} When no valid signatures are found for aggregation
+   * @throws {Error} When signature length is invalid
+   * @throws {Error} When signature parsing fails
+   *
+   * @example
+   * ```typescript
+   * const aggregatedExitBlob = await exit.recombineExitBlobs(existingBlobData);
+   * ```
+   */
+  async recombineExitBlobs(
+    exitBlob: ExistingExitValidationBlobData,
+  ): Promise<FullExitBlob> {
+    await init('herumi');
+
+    // Map to store signatures by their share index (matching Go's map[int]tbls.Signature)
+    const signaturesByIndex = new Map<number, Uint8Array>();
+
+    // Extract signatures from shares_exit_data (equivalent to er.Signatures in Go)
+    if (!exitBlob.shares_exit_data || exitBlob.shares_exit_data.length === 0) {
+      throw new Error('No shares exit data available for aggregation');
+    }
+    const signaturesMap = exitBlob.shares_exit_data[0] || {};
+    for (const [sigIdxStr, sigData] of Object.entries(signaturesMap)) {
+      const sigStr = sigData.partial_exit_signature;
+
+      if (!sigStr || sigStr.length === 0) {
+        // ignore, the associated share index didn't push a partial signature yet
+        continue;
+      }
+
+      if (sigStr.length < 2) {
+        throw new Error(`Signature string has invalid size: ${sigStr.length}`);
+      }
+
+      // Remove 0x prefix and ensure it's 96 bytes (192 hex chars)
+      const cleanSigStr = sigStr.startsWith('0x')
+        ? sigStr.substring(2)
+        : sigStr;
+      if (cleanSigStr.length !== 192) {
+        throw new Error(
+          `Invalid signature length. Expected 192 hex chars (96 bytes), got ${cleanSigStr.length}`,
+        );
+      }
+
+      try {
+        const sigBytes = fromHexString(cleanSigStr);
+        // Convert string index to number and add 1 (matching Go's sigIdx+1)
+        const sigIdx = parseInt(sigIdxStr, 10);
+        signaturesByIndex.set(sigIdx + 1, sigBytes);
+      } catch (err) {
+        throw new Error(`Invalid partial signature: ${String(err)}`);
+      }
+    }
+
+    if (signaturesByIndex.size === 0) {
+      throw new Error('No valid signatures found for aggregation');
+    }
+
+    // Sort by index and extract signatures in correct order
+    const sortedIndices = Array.from(signaturesByIndex.keys()).sort(
+      (a, b) => a - b,
+    );
+    const rawSignatures = sortedIndices.map(idx => {
+      const signature = signaturesByIndex.get(idx);
+      if (signature === undefined) {
+        throw new Error(`Missing signature for index ${idx}`);
+      }
+      return signature;
+    });
+
+    // Aggregate signatures (equivalent to tbls.ThresholdAggregate in Go)
+    // Note: @chainsafe/bls doesn't have explicit threshold aggregation, but ordering should be preserved
+    const fullSig = aggregateSignatures(rawSignatures);
+
+    return {
+      public_key: exitBlob.public_key,
+      signed_exit_message: {
+        message: {
+          epoch: exitBlob.epoch,
+          validator_index: exitBlob.validator_index,
+        },
+        signature: '0x' + Buffer.from(fullSig).toString('hex'),
+      },
+    };
+  }
 }

package/src/types.ts

@@ -448,19 +448,54 @@ export interface ExitValidationPayload {
  * Represents the data structure for an already existing exit blob for exit validation.
  */
 export interface ExistingExitValidationBlobData {
-  /** The public key of the validator to exit. */
+  /**
+   * The BLS public key of the validator in hex format
+   */
   public_key: string;
-
-  /** The epoch at which the validator wishes to exit. */
+  /**
+   * The epoch number when the exit is scheduled to occur
+   */
   epoch: string;
-
-  /** The index of the validator in the beacon chain. */
+  /**
+   * The unique index of the validator in the beacon chain
+   */
   validator_index: string;
-
-  /** Collection of partial exit signatures from different shares. */
+  /**
+   * Array of distributed validator shares exit data, where each share contains
+   * the partial exit signature from each operator in the cluster
+   */
   shares_exit_data: Array<Record<string, { partial_exit_signature: string }>>;
 }
 
+// ExitBlob is an exit message alongside its BLS12-381 hex-encoded signature.
+export interface FullExitBlob {
+  /**
+   * The signed voluntary exit message containing the exit details and signature
+   */
+  signed_exit_message: {
+    /**
+     * The voluntary exit message details
+     */
+    message: {
+      /**
+       * The epoch number when the validator exit will be processed
+       */
+      epoch: string;
+      /**
+       * The unique index of the validator requesting to exit
+       */
+      validator_index: string;
+    };
+    /**
+     * The BLS12-381 hex-encoded signature of the exit message
+     */
+    signature: string;
+  };
+
+  /** The public key of the validator to exit. */
+  public_key: string;
+}
+
 /**
  * Generic HTTP request function type.
  * Args: