@obolnetwork/obol-sdk 2.5.1 → 2.7.0

package/src/exits/verificationHelpers.ts

@@ -0,0 +1,110 @@
+import { ContainerType, ByteVectorType, fromHexString } from '@chainsafe/ssz';
+
+// From obol-api/src/verification/common.ts
+export const GENESIS_VALIDATOR_ROOT_HEX_STRING =
+  '0x0000000000000000000000000000000000000000000000000000000000000000'; // Added 0x prefix
+
+const ForkDataType = new ContainerType({
+  currentVersion: new ByteVectorType(4),
+  genesisValidatorsRoot: new ByteVectorType(32),
+});
+
+const SigningRootType = new ContainerType({
+  objectRoot: new ByteVectorType(32),
+  domain: new ByteVectorType(32),
+});
+
+/**
+ * https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#compute_fork_data_root
+ * @param currentVersion - Uint8Array of the current fork version.
+ * @param genesisValidatorsRoot - Uint8Array of the genesis validators root.
+ * @returns Uint8Array - The 32-byte fork data root.
+ */
+function computeForkDataRoot(
+  currentVersion: Uint8Array,
+  genesisValidatorsRoot: Uint8Array,
+): Uint8Array {
+  const forkDataVal = ForkDataType.defaultValue();
+  forkDataVal.currentVersion = currentVersion;
+  forkDataVal.genesisValidatorsRoot = genesisValidatorsRoot;
+  return Buffer.from(ForkDataType.hashTreeRoot(forkDataVal).buffer);
+}
+
+/**
+ * Computes the domain for a given domain type, fork version, and genesis state.
+ * https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#compute_domain
+ * @param domainType - Uint8Array representing the domain type (e.g., DOMAIN_VOLUNTARY_EXIT).
+ * @param forkVersionString - Hex string of the fork version (e.g., Capella fork version).
+ * @param genesisValidatorsRootOverride - Optional Uint8Array to override the default genesis validators root.
+ * @returns Uint8Array - The 32-byte domain.
+ */
+export function computeDomain(
+  domainType: Uint8Array, // Should be 4 bytes
+  forkVersionString: string, // Hex string, e.g., '0x03000000'
+  genesisValidatorsRootOverride?: Uint8Array, // 32 bytes
+): Uint8Array {
+  const forkVersionBytes = fromHexString(
+    forkVersionString.substring(2, forkVersionString.length),
+  );
+
+  if (forkVersionBytes.length !== 4) {
+    throw new Error('Fork version must be 4 bytes');
+  }
+  if (domainType.length !== 4) {
+    throw new Error('Domain type must be 4 bytes');
+  }
+
+  const actualGenesisValidatorsRoot =
+    genesisValidatorsRootOverride ??
+    fromHexString(GENESIS_VALIDATOR_ROOT_HEX_STRING.substring(2));
+
+  if (actualGenesisValidatorsRoot.length !== 32) {
+    throw new Error('genesisValidatorsRoot must be 32 bytes');
+  }
+  const forkDataRoot = computeForkDataRoot(
+    forkVersionBytes,
+    actualGenesisValidatorsRoot,
+  );
+  const domain = new Uint8Array(32);
+  domain.set(domainType);
+  domain.set(forkDataRoot.subarray(0, 28), 4); // Set the remaining 28 bytes from forkDataRoot
+  return domain;
+}
+
+/**
+ * Computes the signing root for an SSZ object and a domain.
+ * https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/beacon-chain.md#compute_signing_root
+ * @param sszObjectRoot - Uint8Array of the hash tree root of the SSZ object.
+ * @param domain - Uint8Array of the domain.
+ * @returns Uint8Array - The 32-byte signing root.
+ */
+function computeSigningRoot(
+  sszObjectRoot: Uint8Array, // Should be 32 bytes
+  domain: Uint8Array, // Should be 32 bytes
+): Uint8Array {
+  if (sszObjectRoot.length !== 32) {
+    throw new Error('SSZ object root must be 32 bytes');
+  }
+  if (domain.length !== 32) {
+    throw new Error('Domain must be 32 bytes');
+  }
+
+  const val = SigningRootType.defaultValue();
+  val.objectRoot = sszObjectRoot;
+  val.domain = domain;
+  return Buffer.from(SigningRootType.hashTreeRoot(val).buffer);
+}
+
+/**
+ * Convenience wrapper for computeSigningRoot.
+ * @param domain - Uint8Array of the domain.
+ * @param messageBuffer - Buffer of the message (SSZ object root).
+ * @returns Uint8Array - The signing root.
+ */
+export function signingRoot(
+  domain: Uint8Array,
+  messageBuffer: Buffer, // Assumed to be the 32-byte sszObjectRoot
+): Uint8Array {
+  const sszObjectRootU8 = Uint8Array.from(messageBuffer);
+  return computeSigningRoot(sszObjectRootU8, domain);
+}

package/src/{incentiveHelpers.ts → incentives/incentiveHelpers.ts}

@@ -1,6 +1,6 @@
-import { type ProviderType, type SignerType, type ETH_ADDRESS } from './types';
+import { type ProviderType, type SignerType, type ETH_ADDRESS } from '../types';
 import { Contract } from 'ethers';
-import { MerkleDistributorABI } from './abi/MerkleDistributorWithDeadline';
+import { MerkleDistributorABI } from '../abi/MerkleDistributorWithDeadline';
 
 export const claimIncentivesFromMerkleDistributor = async (incentivesData: {
   signer: SignerType;

package/src/{incentives.ts → incentives/incentives.ts}

@@ -1,4 +1,4 @@
-import { isContractAvailable } from './utils';
+import { isContractAvailable } from '../utils';
 import {
   type ClaimableIncentives,
   type ETH_ADDRESS,
@@ -6,12 +6,12 @@ import {
   type ProviderType,
   type SignerType,
   type ClaimIncentivesResponse,
-} from './types';
+} from '../types';
 import {
   claimIncentivesFromMerkleDistributor,
   isClaimedFromMerkleDistributor,
 } from './incentiveHelpers';
-import { DEFAULT_BASE_VERSION } from './constants';
+import { DEFAULT_BASE_VERSION } from '../constants';
 
 /**
  * Incentives can be used for fetching and claiming Obol incentives.

package/src/index.ts

@@ -45,15 +45,17 @@ import {
   handleDeployOWRAndSplitter,
   predictSplitterAddress,
   getOWRTranches,
-} from './splitHelpers.js';
+} from './splits/splitHelpers.js';
 import { isContractAvailable } from './utils.js';
-import { Incentives } from './incentives.js';
+import { Incentives } from './incentives/incentives.js';
+import { Exit } from './exits/exit.js';
 export * from './types.js';
 export * from './services.js';
 export * from './verification/signature-validator.js';
 export * from './verification/common.js';
 export * from './constants.js';
-export { Incentives } from './incentives.js';
+export { Incentives } from './incentives/incentives.js';
+export { Exit } from './exits/exit.js';
 
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.
@@ -70,6 +72,12 @@ export class Client extends Base {
    */
   public incentives: Incentives;
 
+  /**
+   * The exit module, responsible for managing exit validation.
+   * @type {Exit}
+   */
+  public exit: Exit;
+
   /**
    * 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.
@@ -103,6 +111,7 @@ export class Client extends Base {
       this.request.bind(this),
       this.provider,
     );
+    this.exit = new Exit(this.chainId, this.provider);
   }
 
   /**
@@ -341,6 +350,7 @@ export class Client extends Base {
     const { accounts, percentAllocations } = formatSplitRecipients(
       copiedSplitRecipients,
     );
+
     const predictedSplitterAddress = await predictSplitterAddress({
       signer: this.signer,
       accounts,
@@ -555,4 +565,20 @@ export class Client extends Base {
     );
     return lock;
   }
+
+  /**
+   * @param lockHash - The configuration hash in cluster-definition
+   * @returns {Promise<ClusterLock>} The matched cluster details (lock) from DB
+   * @throws On not found cluster definition or lock.
+   *
+   */
+  async getClusterLockByHash(lockHash: string): Promise<ClusterLock> {
+    const lock: ClusterLock = await this.request(
+      `/${DEFAULT_BASE_VERSION}/lock/${lockHash}`,
+      {
+        method: 'GET',
+      },
+    );
+    return lock;
+  }
 }