@obolnetwork/obol-sdk 1.0.12 → 1.0.13

package/src/ajv.ts

@@ -1,11 +1,16 @@
-import Ajv, { ErrorObject } from 'ajv';
+import Ajv, { type ErrorObject } from 'ajv'
 
-export function validatePayload(data: any, schema: any): ErrorObject[] | undefined | null | boolean {
-    const ajv = new Ajv();
-    const validate = ajv.compile(schema);
-    const isValid = validate(data);
-    if (!isValid) {
-        throw new Error(`Schema compilation errors', ${validate.errors && validate.errors[0].message}`);
-    }
-    return isValid;
-}
+export function validatePayload (
+  data: any,
+  schema: any,
+): ErrorObject[] | undefined | null | boolean {
+  const ajv = new Ajv()
+  const validate = ajv.compile(schema)
+  const isValid = validate(data)
+  if (!isValid) {
+    throw new Error(
+      `Schema compilation errors', ${validate.errors?.[0].message}`,
+    )
+  }
+  return isValid
+}

package/src/base.ts

@@ -1,42 +1,46 @@
 // src/resources/base.ts
-import { DEFAULT_BASE_URL, DEFAULT_CHAIN_ID, SDK_VERSION } from './constants.js';
-import { FORK_MAPPING } from './types.js';
+import { DEFAULT_BASE_URL, DEFAULT_CHAIN_ID, SDK_VERSION } from './constants.js'
+import { FORK_MAPPING } from './types.js'
 
-type Config = {
-  baseUrl?: string;
-  chainId?: FORK_MAPPING;
-};
+interface Config {
+  baseUrl?: string
+  chainId?: FORK_MAPPING
+}
 
 export abstract class Base {
-  baseUrl: string;
-  chainId: number;
-  fork_version: string;
-
-
+  baseUrl: string
+  chainId: number
+  fork_version: string
 
-  constructor({ baseUrl = DEFAULT_BASE_URL, chainId = DEFAULT_CHAIN_ID }: Config) {
-    this.baseUrl = baseUrl;
-    this.chainId = chainId;
+  constructor ({
+    baseUrl = DEFAULT_BASE_URL,
+    chainId = DEFAULT_CHAIN_ID,
+  }: Config) {
+    this.baseUrl = baseUrl
+    this.chainId = chainId
     this.fork_version = FORK_MAPPING[this.chainId]
   }
 
-  protected async request<T>(endpoint: string, options?: RequestInit): Promise<T> {
+  protected async request<T>(
+    endpoint: string,
+    options?: RequestInit,
+  ): Promise<T> {
     const url = `${this.baseUrl}${endpoint}`
     const config = {
       ...options,
       headers: {
         'Content-Type': 'application/json',
         'User-Agent': `Obol-SDK/${SDK_VERSION}`,
-        ...options?.headers
-      }
-    };
+        ...options?.headers,
+      },
+    }
 
     try {
-      const response = await fetch(url, config);
+      const response = await fetch(url, config)
       if (response.ok) {
-          return (await response.json())
+        return await response.json()
       }
-      throw new Error(response.statusText);
+      throw new Error(response.statusText)
     } catch (e) {
       throw e
     }

package/src/constants.ts

@@ -1,118 +1,120 @@
-import { TypedMessage } from "@metamask/eth-sig-util";
+import { type TypedMessage } from '@metamask/eth-sig-util'
+import { type TypedDataDomain } from 'ethers'
+import * as pjson from '../package.json'
 
-export const CONFLICT_ERROR_MSG = "Conflict"
+export const CONFLICT_ERROR_MSG = 'Conflict'
 
-export const EIP712_DOMAIN_NAME = "Obol";
-export const EIP712_DOMAIN_VERSION = "1";
+export const EIP712_DOMAIN_NAME = 'Obol'
+export const EIP712_DOMAIN_VERSION = '1'
 export const CreatorConfigHashSigningTypes = {
-    CreatorConfigHash: [{ name: "creator_config_hash", type: "string" }],
-};
+  CreatorConfigHash: [{ name: 'creator_config_hash', type: 'string' }],
+}
 
 const EIP712Domain = [
-    { name: 'name', type: 'string' },
-    { name: 'version', type: 'string' },
-    { name: 'chainId', type: 'uint256' },
+  { name: 'name', type: 'string' },
+  { name: 'version', type: 'string' },
+  { name: 'chainId', type: 'uint256' },
 ]
 
-export const Domain = (chainId: number) => {
-    return {
-        name: EIP712_DOMAIN_NAME,
-        version: EIP712_DOMAIN_VERSION,
-        chainId,
-    }
+export const Domain = (chainId: number): TypedDataDomain => {
+  return {
+    name: EIP712_DOMAIN_NAME,
+    version: EIP712_DOMAIN_VERSION,
+    chainId,
+  }
 }
 
 export const CreatorTypedMessage = {
-    EIP712Domain,
-    ...CreatorConfigHashSigningTypes
-};
+  EIP712Domain,
+  ...CreatorConfigHashSigningTypes,
+}
 
-//A conflict once updateDefinition is merged
+// A conflict once updateDefinition is merged
 export const EnrSigningTypes = {
-    ENR: [{ name: "enr", type: "string" }],
-};
+  ENR: [{ name: 'enr', type: 'string' }],
+}
 
 export const OperatorConfigHashSigningTypes = {
-    OperatorConfigHash: [{ name: "operator_config_hash", type: "string" }],
-};
+  OperatorConfigHash: [{ name: 'operator_config_hash', type: 'string' }],
+}
 
 export const OperatorTypedMessage = {
-    EIP712Domain,
-    ...OperatorConfigHashSigningTypes
-};
+  EIP712Domain,
+  ...OperatorConfigHashSigningTypes,
+}
 
 export const ENRTypedMessage = {
-    EIP712Domain,
-    ...EnrSigningTypes
-};
+  EIP712Domain,
+  ...EnrSigningTypes,
+}
 
 export const signCreatorConfigHashPayload = (
-    payload: { creator_config_hash: string },
-    chainId: number,
+  payload: { creator_config_hash: string },
+  chainId: number,
 ): TypedMessage<typeof CreatorTypedMessage> => {
-    return {
-        types: CreatorTypedMessage,
-        primaryType: 'CreatorConfigHash',
-        domain: {
-            name: EIP712_DOMAIN_NAME,
-            version: EIP712_DOMAIN_VERSION,
-            chainId,
-        },
-        message: payload,
-    };
+  return {
+    types: CreatorTypedMessage,
+    primaryType: 'CreatorConfigHash',
+    domain: {
+      name: EIP712_DOMAIN_NAME,
+      version: EIP712_DOMAIN_VERSION,
+      chainId,
+    },
+    message: payload,
+  }
 }
 
 export const signOperatorConfigHashPayload = (
-    payload: { operator_config_hash: string },
-    chainId: number,
+  payload: { operator_config_hash: string },
+  chainId: number,
 ): TypedMessage<typeof OperatorTypedMessage> => {
-    return {
-        types: OperatorTypedMessage,
-        primaryType: 'OperatorConfigHash',
-        domain: {
-            name: EIP712_DOMAIN_NAME,
-            version: EIP712_DOMAIN_VERSION,
-            chainId,
-        },
-        message: payload,
-    };
+  return {
+    types: OperatorTypedMessage,
+    primaryType: 'OperatorConfigHash',
+    domain: {
+      name: EIP712_DOMAIN_NAME,
+      version: EIP712_DOMAIN_VERSION,
+      chainId,
+    },
+    message: payload,
+  }
 }
 
 export const signEnrPayload = (
-    payload: { enr: string },
-    chainId: number,
+  payload: { enr: string },
+  chainId: number,
 ): TypedMessage<typeof ENRTypedMessage> => {
-    return {
-        types: ENRTypedMessage,
-        primaryType: 'ENR',
-        domain: {
-            name: EIP712_DOMAIN_NAME,
-            version: EIP712_DOMAIN_VERSION,
-            chainId,
-        },
-        message: payload,
-    };
+  return {
+    types: ENRTypedMessage,
+    primaryType: 'ENR',
+    domain: {
+      name: EIP712_DOMAIN_NAME,
+      version: EIP712_DOMAIN_VERSION,
+      chainId,
+    },
+    message: payload,
+  }
 }
 
+export const DKG_ALGORITHM = 'default'
 
-export const dkg_algorithm = "default";
-
-export const config_version = "v1.7.0";
+export const CONFIG_VERSION = 'v1.7.0'
 
-export const SDK_VERSION = "1.0.7";
+export const SDK_VERSION = pjson.version
 
-export const DOMAIN_APPLICATION_BUILDER = '00000001';
-export const DOMAIN_DEPOSIT = '03000000';
+export const DOMAIN_APPLICATION_BUILDER = '00000001'
+export const DOMAIN_DEPOSIT = '03000000'
 export const GENESIS_VALIDATOR_ROOT =
-    '0000000000000000000000000000000000000000000000000000000000000000';
+  '0000000000000000000000000000000000000000000000000000000000000000'
 
 // Flow used to create defintion
 export enum DefinitionFlow {
-    Group = 'LP-Group',
-    Solo = 'LP-Solo',
-    Charon = 'Charon-Command',
-
+  Group = 'LP-Group',
+  Solo = 'LP-Solo',
+  Charon = 'Charon-Command',
 }
 
-export const DEFAULT_BASE_URL = "https://api.obol.tech";
-export const DEFAULT_CHAIN_ID = 1;
+export const DEFAULT_BASE_URL = 'https://api.obol.tech'
+export const DEFAULT_CHAIN_ID = 17000
+
+export const ETHER_TO_GWEI = 10 ** 9

package/src/errors.ts

@@ -1,11 +1,8 @@
 export class ConflictError extends Error {
-    name = 'ConflictError'
-  
-    constructor() {
-      super(
-        `This Cluster has been already posted.`,
-      )
-      Object.setPrototypeOf(this, ConflictError.prototype)
-    }
+  name = 'ConflictError'
+
+  constructor () {
+    super('This Cluster has been already posted.')
+    Object.setPrototypeOf(this, ConflictError.prototype)
   }
-  
+}

package/src/index.ts

@@ -1,34 +1,48 @@
-import { Signer } from "ethers";
-import { v4 as uuidv4 } from "uuid";
-import { Base } from './base.js';
-import { CONFLICT_ERROR_MSG, CreatorConfigHashSigningTypes, Domain, dkg_algorithm, config_version, OperatorConfigHashSigningTypes, EnrSigningTypes } from './constants.js';
-import { ConflictError } from './errors.js';
-import { ClusterDefintion, ClusterLock, ClusterPayload, OperatorPayload } from './types.js';
-import { clusterConfigOrDefinitionHash } from './hash.js';
-import { validatePayload } from './ajv.js';
-import { definitionSchema, operatorPayloadSchema } from './schema.js';
-export * from "./types.js";
-export * from "./services.js";
-
+import { type Signer } from 'ethers'
+import { v4 as uuidv4 } from 'uuid'
+import { Base } from './base.js'
+import {
+  CONFLICT_ERROR_MSG,
+  CreatorConfigHashSigningTypes,
+  Domain,
+  DKG_ALGORITHM,
+  CONFIG_VERSION,
+  OperatorConfigHashSigningTypes,
+  EnrSigningTypes,
+} from './constants.js'
+import { ConflictError } from './errors.js'
+import {
+  type ClusterDefintion,
+  type ClusterLock,
+  type ClusterPayload,
+  type OperatorPayload,
+} from './types.js'
+import { clusterConfigOrDefinitionHash } from './verification/common.js'
+import { validatePayload } from './ajv.js'
+import { definitionSchema, operatorPayloadSchema } from './schema.js'
+export * from './types.js'
+export * from './services.js'
 
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.
  */
 export class Client extends Base {
-  private signer: Signer | undefined;
+  private readonly signer: Signer | undefined
 
   /**
    * @param config - Client configurations
    * @param config.baseUrl - obol-api url
    * @param config.chainId - Blockchain network ID
-   * @param signer - ethersJS Signer 
+   * @param signer - ethersJS Signer
    * @returns Obol-SDK Client instance
-   * 
+   *
    * An example of how to instantiate obol-sdk Client:
    * [obolClient](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L29)
    */
-  constructor(config: { baseUrl?: string | undefined; chainId?: number | undefined }, signer?: Signer) {
-
+  constructor (
+    config: { baseUrl?: string, chainId?: number },
+    signer?: Signer,
+  ) {
     super(config)
     this.signer = signer
   }
@@ -38,123 +52,146 @@ export class Client extends Base {
    * @param {ClusterPayload} newCluster - The new unique cluster.
    * @returns {Promise<string>} config_hash.
    * @throws On duplicate entries, missing or wrong cluster keys.
-   * 
+   *
    * An example of how to use createClusterDefinition:
    * [createObolCluster](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts)
    */
-  async createClusterDefinition(newCluster: ClusterPayload): Promise<string> {
-    if (!this.signer) throw "Signer is required in createClusterDefinition"
+  async createClusterDefinition (newCluster: ClusterPayload): Promise<string> {
+    if (!this.signer) { throw new Error('Signer is required in createClusterDefinition') }
 
-    validatePayload(newCluster, definitionSchema);
+    validatePayload(newCluster, definitionSchema)
 
     const clusterConfig: Partial<ClusterDefintion> = {
       ...newCluster,
       fork_version: this.fork_version,
-      dkg_algorithm: dkg_algorithm,
-      version: config_version,
+      dkg_algorithm: DKG_ALGORITHM,
+      version: CONFIG_VERSION,
       uuid: uuidv4(),
       timestamp: new Date().toISOString(),
       threshold: Math.ceil((2 * newCluster.operators.length) / 3),
-      num_validators: newCluster.validators.length
+      num_validators: newCluster.validators.length,
     }
 
     try {
-      const address = await this.signer.getAddress();
+      const address = await this.signer.getAddress()
 
-      clusterConfig.creator = { address };
-      clusterConfig.config_hash = clusterConfigOrDefinitionHash(clusterConfig as ClusterDefintion, true);
+      clusterConfig.creator = { address }
+      clusterConfig.config_hash = clusterConfigOrDefinitionHash(
+        clusterConfig as ClusterDefintion,
+        true,
+      )
 
-      const creatorConfigSignature = await this.signer.signTypedData(Domain(this.chainId), CreatorConfigHashSigningTypes, { creator_config_hash: clusterConfig.config_hash });
+      const creatorConfigSignature = await this.signer.signTypedData(
+        Domain(this.chainId),
+        CreatorConfigHashSigningTypes,
+        { creator_config_hash: clusterConfig.config_hash },
+      )
 
-      const clusterDefinition: ClusterDefintion = await this.request(`/dv`, {
+      const clusterDefinition: ClusterDefintion = await this.request('/dv', {
         method: 'POST',
         body: JSON.stringify(clusterConfig),
         headers: {
           Authorization: `Bearer ${creatorConfigSignature}`,
-          "fork-version": this.fork_version,
-        }
-
-      });
-      return clusterDefinition?.config_hash;
+          'fork-version': this.fork_version,
+        },
+      })
+      return clusterDefinition?.config_hash
     } catch (err: any) {
-      if (err?.message == CONFLICT_ERROR_MSG)
-        throw new ConflictError();
-      throw err;
+      if (err?.message === CONFLICT_ERROR_MSG) {
+        throw new ConflictError()
+      }
+      throw err
     }
   }
 
   /**
-  * Approves joining a cluster with specific configuration.
-  * @param {OperatorPayload} operatorPayload - The operator data including signatures.
-  * @param {string} configHash - The config hash of the cluster which the operator confirms joining to.
-  * @returns {Promise<ClusterDefintion>} The cluster definition.
-  * @throws On unauthorized, duplicate entries, missing keys, not found cluster or invalid data.
-  * 
-  * An example of how to use acceptClusterDefinition:
-  * [acceptClusterDefinition](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts)
-  */
-  async acceptClusterDefinition(operatorPayload: OperatorPayload, configHash: string): Promise<ClusterDefintion> {
-    if (!this.signer) throw "Signer is required in acceptClusterDefinition"
-
-    validatePayload(operatorPayload, operatorPayloadSchema);
+   * Approves joining a cluster with specific configuration.
+   * @param {OperatorPayload} operatorPayload - The operator data including signatures.
+   * @param {string} configHash - The config hash of the cluster which the operator confirms joining to.
+   * @returns {Promise<ClusterDefintion>} The cluster definition.
+   * @throws On unauthorized, duplicate entries, missing keys, not found cluster or invalid data.
+   *
+   * An example of how to use acceptClusterDefinition:
+   * [acceptClusterDefinition](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts)
+   */
+  async acceptClusterDefinition (
+    operatorPayload: OperatorPayload,
+    configHash: string,
+  ): Promise<ClusterDefintion> {
+    if (!this.signer) { throw new Error('Signer is required in acceptClusterDefinition') }
 
-    try {
-      const address = await this.signer.getAddress();
+    validatePayload(operatorPayload, operatorPayloadSchema)
 
-      const operatorConfigSignature = await this.signer.signTypedData(Domain(this.chainId), OperatorConfigHashSigningTypes, { operator_config_hash: configHash });
-      const operatorENRSignature = await this.signer.signTypedData(Domain(this.chainId), EnrSigningTypes, { enr: operatorPayload.enr });
+    try {
+      const address = await this.signer.getAddress()
+
+      const operatorConfigSignature = await this.signer.signTypedData(
+        Domain(this.chainId),
+        OperatorConfigHashSigningTypes,
+        { operator_config_hash: configHash },
+      )
+      const operatorENRSignature = await this.signer.signTypedData(
+        Domain(this.chainId),
+        EnrSigningTypes,
+        { enr: operatorPayload.enr },
+      )
 
       const operatorData: OperatorPayload = {
         ...operatorPayload,
         address,
         enr_signature: operatorENRSignature,
-        fork_version: this.fork_version
+        fork_version: this.fork_version,
       }
-      const clusterDefinition: ClusterDefintion = await this.request(`/dv/${configHash}`, {
-        method: 'PUT',
-        body: JSON.stringify(operatorData),
-        headers: {
-          Authorization: `Bearer ${operatorConfigSignature}`,
-        }
-
-      });
-      return clusterDefinition;
+      const clusterDefinition: ClusterDefintion = await this.request(
+        `/dv/${configHash}`,
+        {
+          method: 'PUT',
+          body: JSON.stringify(operatorData),
+          headers: {
+            Authorization: `Bearer ${operatorConfigSignature}`,
+          },
+        },
+      )
+      return clusterDefinition
     } catch (err: any) {
-      throw err;
+      throw err
     }
   }
 
-
-  /** 
+  /**
    * @param configHash - The configuration hash returned in createClusterDefinition
    * @returns {Promise<ClusterDefintion>} The  cluster definition for config hash
    * @throws On not found config hash.
-   * 
+   *
    * An example of how to use getClusterDefinition:
    * [getObolClusterDefinition](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts)
    */
-  async getClusterDefinition(configHash: string): Promise<ClusterDefintion> {
-      const clusterDefinition: ClusterDefintion = await this.request(`/dv/${configHash}`, {
+  async getClusterDefinition (configHash: string): Promise<ClusterDefintion> {
+    const clusterDefinition: ClusterDefintion = await this.request(
+      `/dv/${configHash}`,
+      {
         method: 'GET',
-      })
+      },
+    )
 
-      return clusterDefinition
+    return clusterDefinition
   }
 
-  /** 
-   * @param configHash - The configuration hash in cluster-definition 
+  /**
+   * @param configHash - The configuration hash in cluster-definition
    * @returns {Promise<ClusterLock>} The matched cluster details (lock) from DB
    * @throws On not found cluster definition or lock.
-   * 
+   *
    * An example of how to use getClusterLock:
    * [getObolClusterLock](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts)
    */
-  async getClusterLock(configHash: string): Promise<ClusterLock> {
-
-      const lock: ClusterLock = await this.request(`/lock/configHash/${configHash}`, {
+  async getClusterLock (configHash: string): Promise<ClusterLock> {
+    const lock: ClusterLock = await this.request(
+      `/lock/configHash/${configHash}`,
+      {
         method: 'GET',
-      })
-      return lock
+      },
+    )
+    return lock
   }
 }
-