@obolnetwork/obol-sdk 1.0.16 → 1.0.17

package/src/base.ts

@@ -1,31 +1,35 @@
 // 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';
 
 interface Config {
-  baseUrl?: string
-  chainId?: FORK_MAPPING
+  baseUrl?: string;
+  chainId?: FORK_MAPPING;
 }
 
 export abstract class Base {
-  baseUrl: string
-  chainId: number
-  fork_version: string
+  baseUrl: string;
+  chainId: number;
+  fork_version: string;
 
-  constructor ({
+  constructor({
     baseUrl = DEFAULT_BASE_URL,
     chainId = DEFAULT_CHAIN_ID,
   }: Config) {
-    this.baseUrl = baseUrl
-    this.chainId = chainId
-    this.fork_version = FORK_MAPPING[this.chainId]
+    this.baseUrl = baseUrl;
+    this.chainId = chainId;
+    this.fork_version = FORK_MAPPING[this.chainId];
   }
 
   protected async request<T>(
     endpoint: string,
     options?: RequestInit,
   ): Promise<T> {
-    const url = `${this.baseUrl}${endpoint}`
+    const url = `${this.baseUrl}${endpoint}`;
     const config = {
       ...options,
       headers: {
@@ -33,18 +37,18 @@ export abstract class Base {
         'User-Agent': `Obol-SDK/${SDK_VERSION}`,
         ...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();
       } else {
-        const errorResponse = await response.json()
-        throw errorResponse
+        const errorResponse = await response.json();
+        throw errorResponse;
       }
     } catch (e: any) {
-      throw e
+      throw e;
     }
   }
 }

package/src/constants.ts

@@ -1,61 +1,61 @@
-import { type TypedMessage } from '@metamask/eth-sig-util'
-import { type TypedDataDomain } from 'ethers'
-import * as pjson from '../package.json'
+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' }],
-}
+};
 export const TermsAndConditionsSigningTypes = {
   TermsAndConditions: [
     { name: 'terms_and_conditions_hash', type: 'string' },
     { name: 'version', type: 'uint256' },
-  ]
-}
+  ],
+};
 
 const EIP712Domain = [
   { name: 'name', type: 'string' },
   { name: 'version', type: 'string' },
   { name: 'chainId', type: 'uint256' },
-]
+];
 
 export const Domain = (chainId?: number): TypedDataDomain => {
   const typeDataDomain: any = {
     name: EIP712_DOMAIN_NAME,
     version: EIP712_DOMAIN_VERSION,
-  }
+  };
   if (chainId) {
-    typeDataDomain.chainId = chainId
+    typeDataDomain.chainId = chainId;
   }
-  return typeDataDomain
-}
+  return typeDataDomain;
+};
 
 export const CreatorTypedMessage = {
   EIP712Domain,
   ...CreatorConfigHashSigningTypes,
-}
+};
 
 // A conflict once updateDefinition is merged
 export const EnrSigningTypes = {
   ENR: [{ name: 'enr', type: 'string' }],
-}
+};
 
 export const OperatorConfigHashSigningTypes = {
   OperatorConfigHash: [{ name: 'operator_config_hash', type: 'string' }],
-}
+};
 
 export const OperatorTypedMessage = {
   EIP712Domain,
   ...OperatorConfigHashSigningTypes,
-}
+};
 
 export const ENRTypedMessage = {
   EIP712Domain,
   ...EnrSigningTypes,
-}
+};
 
 export const signCreatorConfigHashPayload = (
   payload: { creator_config_hash: string },
@@ -70,8 +70,8 @@ export const signCreatorConfigHashPayload = (
       chainId,
     },
     message: payload,
-  }
-}
+  };
+};
 
 export const signOperatorConfigHashPayload = (
   payload: { operator_config_hash: string },
@@ -86,8 +86,8 @@ export const signOperatorConfigHashPayload = (
       chainId,
     },
     message: payload,
-  }
-}
+  };
+};
 
 export const signEnrPayload = (
   payload: { enr: string },
@@ -102,19 +102,19 @@ export const signEnrPayload = (
       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.8.0';
 
-export const SDK_VERSION = pjson.version
+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 definition
 export enum DefinitionFlow {
@@ -123,10 +123,16 @@ export enum DefinitionFlow {
   Charon = 'Charon-Command',
 }
 
-export const DEFAULT_BASE_URL = 'https://api.obol.tech'
-export const DEFAULT_CHAIN_ID = 17000
+export const DEFAULT_BASE_URL = 'https://api.obol.tech';
+export const DEFAULT_BASE_VERSION = 'v1';
+export const DEFAULT_CHAIN_ID = 17000;
 
-export const ETHER_TO_GWEI = 10 ** 9
+export const ETHER_TO_GWEI = 10 ** 9;
 
-export const TERMS_AND_CONDITIONS_VERSION = 1
-export const TERMS_AND_CONDITIONS_URL = (TERMS_AND_CONDITIONS_VERSION === 1) ? 'https://obol.tech/terms.pdf' : `https://obol.tech/${TERMS_AND_CONDITIONS_VERSION as number}/terms.pdf`
+export const TERMS_AND_CONDITIONS_VERSION = 1;
+export const TERMS_AND_CONDITIONS_URL =
+  TERMS_AND_CONDITIONS_VERSION === 1
+    ? 'https://obol.org/terms.pdf'
+    : `https://obol.org/${TERMS_AND_CONDITIONS_VERSION as number}/terms.pdf`;
+export const TERMS_AND_CONDITIONS_HASH =
+  '0xd33721644e8f3afab1495a74abe3523cec12d48b8da6cb760972492ca3f1a273';

package/src/errors.ts

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

package/src/index.ts

@@ -1,6 +1,6 @@
-import { type Signer } from 'ethers'
-import { v4 as uuidv4 } from 'uuid'
-import { Base } from './base.js'
+import { type Signer } from 'ethers';
+import { v4 as uuidv4 } from 'uuid';
+import { Base } from './base.js';
 import {
   CONFLICT_ERROR_MSG,
   CreatorConfigHashSigningTypes,
@@ -11,26 +11,27 @@ import {
   EnrSigningTypes,
   TERMS_AND_CONDITIONS_VERSION,
   TermsAndConditionsSigningTypes,
-} from './constants.js'
-import { ConflictError } from './errors.js'
+  DEFAULT_BASE_VERSION,
+  TERMS_AND_CONDITIONS_HASH,
+} from './constants.js';
+import { ConflictError } from './errors.js';
 import {
   type ClusterDefinition,
   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'
-import { hashTermsAndConditions } from './verification/termsAndConditions.js'
-export * from './types.js'
-export * from './services.js'
+} 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 readonly signer: Signer | undefined
+  private readonly signer: Signer | undefined;
 
   /**
    * @param config - Client configurations
@@ -42,12 +43,9 @@ export class Client extends Base {
    * 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, chainId?: number },
-    signer?: Signer,
-  ) {
-    super(config)
-    this.signer = signer
+  constructor(config: { baseUrl?: string; chainId?: number }, signer?: Signer) {
+    super(config);
+    this.signer = signer;
   }
 
   /**
@@ -58,17 +56,19 @@ export class Client extends Base {
    * An example of how to use acceptObolLatestTermsAndConditions:
    * [acceptObolLatestTermsAndConditions](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L44)
    */
-  async acceptObolLatestTermsAndConditions (): Promise<string> {
-    if (!this.signer) { throw new Error('Signer is required in acceptObolTermsAndConditions') }
+  async acceptObolLatestTermsAndConditions(): Promise<string> {
+    if (!this.signer) {
+      throw new Error('Signer is required in acceptObolTermsAndConditions');
+    }
 
     try {
-      const termsAndConditionsHash = await hashTermsAndConditions()
-      const address = await this.signer.getAddress()
+      const termsAndConditionsHash = TERMS_AND_CONDITIONS_HASH;
+      const address = await this.signer.getAddress();
       const termsAndConditionsPayload = {
         address,
         version: TERMS_AND_CONDITIONS_VERSION,
-        terms_and_conditions_hash: termsAndConditionsHash
-      }
+        terms_and_conditions_hash: termsAndConditionsHash,
+      };
 
       const termsAndConditionsSignature = await this.signer.signTypedData(
         Domain(),
@@ -77,21 +77,22 @@ export class Client extends Base {
           terms_and_conditions_hash: termsAndConditionsHash,
           version: TERMS_AND_CONDITIONS_VERSION,
         },
-      )
+      );
 
-      const termsAndConditionsResponse: { message: string, success: boolean } = await this.request('/termsAndConditions', {
-        method: 'POST',
-        body: JSON.stringify(termsAndConditionsPayload),
-        headers: {
-          Authorization: `Bearer ${termsAndConditionsSignature}`,
-        },
-      })
-      return termsAndConditionsResponse?.message
+      const termsAndConditionsResponse: { message: string; success: boolean } =
+        await this.request(`/${DEFAULT_BASE_VERSION}/termsAndConditions`, {
+          method: 'POST',
+          body: JSON.stringify(termsAndConditionsPayload),
+          headers: {
+            Authorization: `Bearer ${termsAndConditionsSignature}`,
+          },
+        });
+      return termsAndConditionsResponse?.message;
     } catch (err: any) {
       if (err?.message === CONFLICT_ERROR_MSG) {
-        throw new ConflictError()
+        throw new ConflictError();
       }
-      throw err
+      throw err;
     }
   }
 
@@ -104,10 +105,12 @@ export class Client extends Base {
    * An example of how to use createClusterDefinition:
    * [createObolCluster](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L59)
    */
-  async createClusterDefinition (newCluster: ClusterPayload): Promise<string> {
-    if (!this.signer) { throw new Error('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<ClusterDefinition> = {
       ...newCluster,
@@ -118,37 +121,42 @@ export class Client extends Base {
       timestamp: new Date().toISOString(),
       threshold: Math.ceil((2 * newCluster.operators.length) / 3),
       num_validators: newCluster.validators.length,
-    }
-
+      deposit_amounts: newCluster.deposit_amounts
+        ? newCluster.deposit_amounts
+        : ['32000000000'],
+    };
     try {
-      const address = await this.signer.getAddress()
+      const address = await this.signer.getAddress();
 
-      clusterConfig.creator = { address }
+      clusterConfig.creator = { address };
       clusterConfig.config_hash = clusterConfigOrDefinitionHash(
         clusterConfig as ClusterDefinition,
         true,
-      )
+      );
 
       const creatorConfigSignature = await this.signer.signTypedData(
         Domain(this.chainId),
         CreatorConfigHashSigningTypes,
         { creator_config_hash: clusterConfig.config_hash },
-      )
-
-      const clusterDefinition: ClusterDefinition = await this.request('/v1/definition', {
-        method: 'POST',
-        body: JSON.stringify(clusterConfig),
-        headers: {
-          Authorization: `Bearer ${creatorConfigSignature}`,
-          'fork-version': this.fork_version,
+      );
+
+      const clusterDefinition: ClusterDefinition = await this.request(
+        `/${DEFAULT_BASE_VERSION}/definition`,
+        {
+          method: 'POST',
+          body: JSON.stringify(clusterConfig),
+          headers: {
+            Authorization: `Bearer ${creatorConfigSignature}`,
+            'fork-version': this.fork_version,
+          },
         },
-      })
-      return clusterDefinition?.config_hash
+      );
+      return clusterDefinition?.config_hash;
     } catch (err: any) {
       if (err?.message === CONFLICT_ERROR_MSG) {
-        throw new ConflictError()
+        throw new ConflictError();
       }
-      throw err
+      throw err;
     }
   }
 
@@ -162,36 +170,38 @@ export class Client extends Base {
    * An example of how to use acceptClusterDefinition:
    * [acceptClusterDefinition](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L106)
    */
-  async acceptClusterDefinition (
+  async acceptClusterDefinition(
     operatorPayload: OperatorPayload,
     configHash: string,
   ): Promise<ClusterDefinition> {
-    if (!this.signer) { throw new Error('Signer is required in acceptClusterDefinition') }
+    if (!this.signer) {
+      throw new Error('Signer is required in acceptClusterDefinition');
+    }
 
-    validatePayload(operatorPayload, operatorPayloadSchema)
+    validatePayload(operatorPayload, operatorPayloadSchema);
 
     try {
-      const address = await this.signer.getAddress()
+      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,
-      }
+      };
       const clusterDefinition: ClusterDefinition = await this.request(
-        `/v1/definition/${configHash}`,
+        `/${DEFAULT_BASE_VERSION}/definition/${configHash}`,
         {
           method: 'PUT',
           body: JSON.stringify(operatorData),
@@ -199,10 +209,10 @@ export class Client extends Base {
             Authorization: `Bearer ${operatorConfigSignature}`,
           },
         },
-      )
-      return clusterDefinition
+      );
+      return clusterDefinition;
     } catch (err: any) {
-      throw err
+      throw err;
     }
   }
 
@@ -214,15 +224,15 @@ export class Client extends Base {
    * An example of how to use getClusterDefinition:
    * [getObolClusterDefinition](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L74)
    */
-  async getClusterDefinition (configHash: string): Promise<ClusterDefinition> {
+  async getClusterDefinition(configHash: string): Promise<ClusterDefinition> {
     const clusterDefinition: ClusterDefinition = await this.request(
-      `/dv/${configHash}`,
+      `/${DEFAULT_BASE_VERSION}/definition/${configHash}`,
       {
         method: 'GET',
       },
-    )
+    );
 
-    return clusterDefinition
+    return clusterDefinition;
   }
 
   /**
@@ -233,13 +243,13 @@ export class Client extends Base {
    * An example of how to use getClusterLock:
    * [getObolClusterLock](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L89)
    */
-  async getClusterLock (configHash: string): Promise<ClusterLock> {
+  async getClusterLock(configHash: string): Promise<ClusterLock> {
     const lock: ClusterLock = await this.request(
-      `/lock/configHash/${configHash}`,
+      `/${DEFAULT_BASE_VERSION}/lock/configHash/${configHash}`,
       {
         method: 'GET',
       },
-    )
-    return lock
+    );
+    return lock;
   }
 }

package/src/schema.ts

@@ -9,7 +9,7 @@ export const operatorPayloadSchema = {
     },
   },
   required: ['version', 'enr'],
-}
+};
 
 export const definitionSchema = {
   type: 'object',
@@ -53,6 +53,14 @@ export const definitionSchema = {
         required: ['fee_recipient_address', 'withdrawal_address'],
       },
     },
+    deposit_amounts: {
+      type: 'array',
+      items: {
+        type: 'string',
+        pattern: '^[0-9]+$',
+      },
+      validDepositAmounts: true,
+    },
   },
   required: ['name', 'operators', 'validators'],
-}
+};

package/src/services.ts

@@ -1,5 +1,5 @@
-import { type ClusterLock } from './types.js'
-import { isValidClusterLock } from './verification/common.js'
+import { type ClusterLock } from './types.js';
+import { isValidClusterLock } from './verification/common.js';
 
 /**
  * Verifies Cluster Lock's validity.
@@ -14,9 +14,9 @@ export const validateClusterLock = async (
   lock: ClusterLock,
 ): Promise<boolean> => {
   try {
-    const isLockValid = await isValidClusterLock(lock)
-    return isLockValid
+    const isLockValid = await isValidClusterLock(lock);
+    return isLockValid;
   } catch (err: any) {
-    throw err
+    throw err;
   }
-}
+};