@obolnetwork/obol-sdk 2.6.0 → 2.8.0

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/index.ts

@@ -12,10 +12,10 @@ import {
   TermsAndConditionsSigningTypes,
   DEFAULT_BASE_VERSION,
   TERMS_AND_CONDITIONS_HASH,
-  AVAILABLE_SPLITTER_CHAINS,
   CHAIN_CONFIGURATION,
   DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
   OBOL_SDK_EMAIL,
+  isChainSupportedForSplitters,
 } from './constants.js';
 import { ConflictError } from './errors.js';
 import {
@@ -49,6 +49,7 @@ import {
 import { isContractAvailable } from './utils.js';
 import { Incentives } from './incentives/incentives.js';
 import { Exit } from './exits/exit.js';
+import { ObolSplits } from './splits/splits.js';
 export * from './types.js';
 export * from './services.js';
 export * from './verification/signature-validator.js';
@@ -56,6 +57,7 @@ export * from './verification/common.js';
 export * from './constants.js';
 export { Incentives } from './incentives/incentives.js';
 export { Exit } from './exits/exit.js';
+export { ObolSplits } from './splits/splits.js';
 
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.
@@ -78,6 +80,12 @@ export class Client extends Base {
    */
   public exit: Exit;
 
+  /**
+   * The splits module, responsible for managing splits.
+   * @type {ObolSplits}
+   */
+  public splits: ObolSplits;
+
   /**
    * The blockchain provider, used to interact with the network.
    * It can be null, undefined, or a valid provider instance and defaults to the Signer provider if Signer is passed.
@@ -112,6 +120,7 @@ export class Client extends Base {
       this.provider,
     );
     this.exit = new Exit(this.chainId, this.provider);
+    this.splits = new ObolSplits(this.signer, this.chainId, this.provider);
   }
 
   /**
@@ -205,28 +214,35 @@ export class Client extends Base {
     );
 
     // Check if we allow splitters on this chainId
-    if (!AVAILABLE_SPLITTER_CHAINS.includes(this.chainId)) {
+    if (!isChainSupportedForSplitters(this.chainId)) {
       throw new Error(
         `Splitter configuration is not supported on ${this.chainId} chain`,
       );
     }
 
+    const chainConfig = CHAIN_CONFIGURATION[this.chainId];
+    if (!chainConfig?.SPLITMAIN_ADDRESS) {
+      throw new Error(
+        `SPLITMAIN_ADDRESS is not configured for chain ${this.chainId}`,
+      );
+    }
+
     const checkSplitMainAddress = await isContractAvailable(
-      CHAIN_CONFIGURATION[this.chainId].SPLITMAIN_ADDRESS.address,
+      chainConfig.SPLITMAIN_ADDRESS.address,
       this.signer.provider as ProviderType,
-      CHAIN_CONFIGURATION[this.chainId].SPLITMAIN_ADDRESS.bytecode,
+      chainConfig.SPLITMAIN_ADDRESS.bytecode,
     );
 
     const checkMulticallAddress = await isContractAvailable(
-      CHAIN_CONFIGURATION[this.chainId].MULTICALL_ADDRESS.address,
+      chainConfig.MULTICALL_ADDRESS.address,
       this.signer.provider as ProviderType,
-      CHAIN_CONFIGURATION[this.chainId].MULTICALL_ADDRESS.bytecode,
+      chainConfig.MULTICALL_ADDRESS.bytecode,
     );
 
     const checkOWRFactoryAddress = await isContractAvailable(
-      CHAIN_CONFIGURATION[this.chainId].OWR_FACTORY_ADDRESS.address,
+      chainConfig.OWR_FACTORY_ADDRESS.address,
       this.signer.provider as ProviderType,
-      CHAIN_CONFIGURATION[this.chainId].OWR_FACTORY_ADDRESS.bytecode,
+      chainConfig.OWR_FACTORY_ADDRESS.bytecode,
     );
 
     if (
@@ -240,8 +256,7 @@ export class Client extends Base {
     }
 
     const retroActiveFundingRecipient = {
-      account:
-        CHAIN_CONFIGURATION[this.chainId].RETROACTIVE_FUNDING_ADDRESS.address,
+      account: chainConfig.RETROACTIVE_FUNDING_ADDRESS.address,
       percentAllocation: validatedPayload.ObolRAFSplit,
     };
 
@@ -320,16 +335,23 @@ export class Client extends Base {
     );
 
     // Check if we allow splitters on this chainId
-    if (!AVAILABLE_SPLITTER_CHAINS.includes(this.chainId)) {
+    if (!isChainSupportedForSplitters(this.chainId)) {
       throw new Error(
         `Splitter configuration is not supported on ${this.chainId} chain`,
       );
     }
 
+    const chainConfig = CHAIN_CONFIGURATION[this.chainId];
+    if (!chainConfig?.SPLITMAIN_ADDRESS) {
+      throw new Error(
+        `SPLITMAIN_ADDRESS is not configured for chain ${this.chainId}`,
+      );
+    }
+
     const checkSplitMainAddress = await isContractAvailable(
-      CHAIN_CONFIGURATION[this.chainId].SPLITMAIN_ADDRESS.address,
+      chainConfig.SPLITMAIN_ADDRESS.address,
       this.signer.provider as ProviderType,
-      CHAIN_CONFIGURATION[this.chainId].SPLITMAIN_ADDRESS.bytecode,
+      chainConfig.SPLITMAIN_ADDRESS.bytecode,
     );
 
     if (!checkSplitMainAddress) {
@@ -339,8 +361,7 @@ export class Client extends Base {
     }
 
     const retroActiveFundingRecipient = {
-      account:
-        CHAIN_CONFIGURATION[this.chainId].RETROACTIVE_FUNDING_ADDRESS.address,
+      account: chainConfig.RETROACTIVE_FUNDING_ADDRESS.address,
       percentAllocation: validatedPayload.ObolRAFSplit,
     };
 

package/src/schema.ts

@@ -2,8 +2,10 @@ import { ZeroAddress } from 'ethers';
 import {
   DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
   DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT,
+  PRINCIPAL_THRESHOLD,
 } from './constants';
 import { VALID_DEPOSIT_AMOUNTS, VALID_NON_COMPOUNDING_AMOUNTS } from './ajv';
+import { zeroAddress } from 'viem';
 
 export const operatorPayloadSchema = {
   type: 'object',
@@ -150,3 +152,81 @@ export const rewardsSplitterPayloadSchema = {
   validateRewardsSplitRecipients: true,
   required: ['splitRecipients', 'principalRecipient', 'etherAmount'],
 };
+
+export const ovmBaseSplitPayload = {
+  rewardSplitRecipients: {
+    type: 'array',
+    items: {
+      type: 'object',
+      properties: {
+        address: {
+          type: 'string',
+          pattern: '^0x[a-fA-F0-9]{40}$',
+        },
+        percentAllocation: { type: 'number' },
+      },
+      required: ['address', 'percentAllocation'],
+    },
+  },
+  OVMOwnerAddress: {
+    type: 'string',
+    pattern: '^0x[a-fA-F0-9]{40}$',
+  },
+  splitOwnerAddress: {
+    type: 'string',
+    pattern: '^0x[a-fA-F0-9]{40}$',
+    default: zeroAddress,
+  },
+  principalThreshold: {
+    type: 'number',
+    minimum: 16,
+    default: PRINCIPAL_THRESHOLD,
+  },
+  distributorFeePercent: {
+    type: 'number',
+    minimum: 0,
+    maximum: 10,
+    default: 0,
+  },
+};
+
+export const ovmRewardsSplitPayloadSchema = {
+  type: 'object',
+  properties: {
+    ...ovmBaseSplitPayload,
+    principalRecipient: {
+      type: 'string',
+      pattern: '^0x[a-fA-F0-9]{40}$',
+    },
+  },
+  validateOVMRewardsSplitRecipients: true,
+  required: ['rewardSplitRecipients', 'OVMOwnerAddress', 'principalRecipient'],
+};
+
+export const ovmTotalSplitPayloadSchema = {
+  type: 'object',
+  properties: {
+    ...ovmBaseSplitPayload,
+    principalSplitRecipients: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          address: {
+            type: 'string',
+            pattern: '^0x[a-fA-F0-9]{40}$',
+          },
+          percentAllocation: { type: 'number' },
+        },
+        required: ['address', 'percentAllocation'],
+      },
+    },
+  },
+  validateOVMRewardsSplitRecipients: true,
+  validateOVMTotalSplitRecipients: true,
+  required: [
+    'rewardSplitRecipients',
+    'principalSplitRecipients',
+    'OVMOwnerAddress',
+  ],
+};