@obolnetwork/obol-sdk 1.0.12 → 1.0.13

package/dist/esm/package.json

@@ -0,0 +1,128 @@
+{
+    "name": "@obolnetwork/obol-sdk",
+    "version": "1.0.13",
+    "description": "A package for creating Distributed Validators using the Obol API.",
+    "bugs": {
+        "url": "https://github.com/obolnetwork/obol-sdk/issues"
+    },
+    "homepage": "https://docs.obol.tech/",
+    "keywords": [
+        "Obol",
+        "Distributed Validators",
+        "Ethereum"
+    ],
+    "scripts": {
+        "compile": "tsc -b ./tsconfig.cjs.json ./tsconfig.esm.json ./tsconfig.types.json",
+        "build:clean": "rm -rf ./dist",
+        "build": "npm-run-all build:clean compile",
+        "test": "jest ./test/methods.test.ts",
+        "generate-typedoc": "typedoc",
+        "npm:publish": "npm publish --tag latest",
+        "release": "release-it",
+        "release:dry": "release-it --dry-run --no-npm",
+        "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+        "lint-ci": "eslint \"{src,apps,libs,test}/**/*.ts\""
+    },
+    "main": "./dist/cjs/src/index.js",
+    "module": "./dist/esm/src/index.js",
+    "typings": "./dist/types/src/index.d.ts",
+    "author": "Obol Labs (https://obol.tech)",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/obolnetwork/obol-sdk.git"
+    },
+    "license": "ISC",
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/",
+        "access": "public"
+    },
+    "dependencies": {
+        "@chainsafe/bls": "6.0.3",
+        "@chainsafe/blst": "^0.2.9",
+        "@chainsafe/discv5": "^0.5.1",
+        "@chainsafe/ssz": "^0.14.0",
+        "@metamask/eth-sig-util": "^7.0.1",
+        "ajv": "^8.12.0",
+        "cross-fetch": "^3.1.5",
+        "elliptic": "^6.5.4",
+        "eslint-config-standard-with-typescript": "^43.0.1",
+        "eslint-plugin-import": "^2.29.1",
+        "eslint-plugin-n": "^16.6.2",
+        "eslint-plugin-promise": "^6.1.1",
+        "ethers": "^6.4.0",
+        "nock": "^13.5.3",
+        "release-it": "^17.1.1",
+        "semver": "^7.6.0",
+        "typescript-eslint": "^7.1.0",
+        "uuid": "^9.0.0"
+    },
+    "devDependencies": {
+        "@release-it/conventional-changelog": "^8.0.1",
+        "@types/elliptic": "^6.4.18",
+        "@types/jest": "^28.1.8",
+        "@types/node": "^20.2.5",
+        "@types/uuid": "^9.0.1",
+        "eslint": "^8.57.0",
+        "jest": "^28.1.3",
+        "msw": "^2.2.1",
+        "npm-run-all": "^4.1.5",
+        "ts-jest": "^28.0.8",
+        "tsup": "^6.7.0",
+        "typedoc": "^0.25.7",
+        "typedoc-plugin-markdown": "^4.0.0-next.50",
+        "typescript": "^5.3.3"
+    },
+    "engines": {
+        "node": ">= 16"
+    },
+    "files": [
+        "package.json",
+        "README.md",
+        "dist",
+        "src"
+    ],
+    "release-it": {
+        "git": {
+            "commitMessage": "chore(release): v${version}",
+            "push": true,
+            "commit": true,
+            "tag": true,
+            "requireCommits": false,
+            "requireCleanWorkingDir": false
+        },
+        "github": {
+            "release": true,
+            "draft": true
+        },
+        "npm": {
+            "publish": false,
+            "ignoreVersion": false
+        },
+        "plugins": {
+            "@release-it/conventional-changelog": {
+                "preset": "angular",
+                "infile": "CHANGELOG.md",
+                "header": "# Changelog"
+            }
+        }
+    },
+    "jest": {
+        "transform": {
+            "\\.[jt]sx?$": "ts-jest"
+        },
+        "globals": {
+            "ts-jest": {
+                "useESM": true
+            }
+        },
+        "moduleNameMapper": {
+            "^bn.js$": "<rootDir>/node_modules/bn.js",
+            "^asn1.js$": "<rootDir>/node_modules/asn1.js",
+            "^hash.js$": "<rootDir>/node_modules/hash.js",
+            "(.+)\\.js": "$1"
+        },
+        "extensionsToTreatAsEsm": [
+            ".ts"
+        ]
+    }
+}

package/dist/esm/src/ajv.js

@@ -1,10 +1,11 @@
 import Ajv from 'ajv';
 export function validatePayload(data, schema) {
+    var _a;
     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}`);
+        throw new Error(`Schema compilation errors', ${(_a = validate.errors) === null || _a === void 0 ? void 0 : _a[0].message}`);
     }
     return isValid;
 }

package/dist/esm/src/base.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { DEFAULT_BASE_URL, DEFAULT_CHAIN_ID, SDK_VERSION } from './constants.js';
 import { FORK_MAPPING } from './types.js';
 export class Base {
-    constructor({ baseUrl = DEFAULT_BASE_URL, chainId = DEFAULT_CHAIN_ID }) {
+    constructor({ baseUrl = DEFAULT_BASE_URL, chainId = DEFAULT_CHAIN_ID, }) {
         this.baseUrl = baseUrl;
         this.chainId = chainId;
         this.fork_version = FORK_MAPPING[this.chainId];
@@ -23,7 +23,7 @@ export class Base {
             try {
                 const response = yield fetch(url, config);
                 if (response.ok) {
-                    return (yield response.json());
+                    return yield response.json();
                 }
                 throw new Error(response.statusText);
             }

package/dist/esm/src/constants.js

@@ -1,8 +1,9 @@
-export const CONFLICT_ERROR_MSG = "Conflict";
-export const EIP712_DOMAIN_NAME = "Obol";
-export const EIP712_DOMAIN_VERSION = "1";
+import * as pjson from '../package.json';
+export const CONFLICT_ERROR_MSG = 'Conflict';
+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' },
@@ -17,12 +18,12 @@ export const Domain = (chainId) => {
     };
 };
 export const CreatorTypedMessage = Object.assign({ 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 = Object.assign({ EIP712Domain }, OperatorConfigHashSigningTypes);
 export const ENRTypedMessage = Object.assign({ EIP712Domain }, EnrSigningTypes);
@@ -62,9 +63,9 @@ export const signEnrPayload = (payload, chainId) => {
         message: payload,
     };
 };
-export const dkg_algorithm = "default";
-export const config_version = "v1.7.0";
-export const SDK_VERSION = "1.0.7";
+export const DKG_ALGORITHM = 'default';
+export const CONFIG_VERSION = 'v1.7.0';
+export const SDK_VERSION = pjson.version;
 export const DOMAIN_APPLICATION_BUILDER = '00000001';
 export const DOMAIN_DEPOSIT = '03000000';
 export const GENESIS_VALIDATOR_ROOT = '0000000000000000000000000000000000000000000000000000000000000000';
@@ -75,5 +76,6 @@ export var DefinitionFlow;
     DefinitionFlow["Solo"] = "LP-Solo";
     DefinitionFlow["Charon"] = "Charon-Command";
 })(DefinitionFlow || (DefinitionFlow = {}));
-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/dist/esm/src/errors.js

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

package/dist/esm/src/index.js

@@ -7,15 +7,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { v4 as uuidv4 } from "uuid";
+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 { CONFLICT_ERROR_MSG, CreatorConfigHashSigningTypes, Domain, DKG_ALGORITHM, CONFIG_VERSION, OperatorConfigHashSigningTypes, EnrSigningTypes, } from './constants.js';
 import { ConflictError } from './errors.js';
-import { clusterConfigOrDefinitionHash } from './hash.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";
+export * from './types.js';
+export * from './services.js';
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.
  */
@@ -45,46 +45,49 @@ export class Client extends Base {
      */
     createClusterDefinition(newCluster) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer)
-                throw "Signer is required in createClusterDefinition";
+            if (!this.signer) {
+                throw new Error('Signer is required in createClusterDefinition');
+            }
             validatePayload(newCluster, definitionSchema);
-            const clusterConfig = Object.assign(Object.assign({}, newCluster), { fork_version: this.fork_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 });
+            const clusterConfig = Object.assign(Object.assign({}, newCluster), { fork_version: this.fork_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 });
             try {
                 const address = yield this.signer.getAddress();
                 clusterConfig.creator = { address };
                 clusterConfig.config_hash = clusterConfigOrDefinitionHash(clusterConfig, true);
                 const creatorConfigSignature = yield this.signer.signTypedData(Domain(this.chainId), CreatorConfigHashSigningTypes, { creator_config_hash: clusterConfig.config_hash });
-                const clusterDefinition = yield this.request(`/dv`, {
+                const clusterDefinition = yield this.request('/dv', {
                     method: 'POST',
                     body: JSON.stringify(clusterConfig),
                     headers: {
                         Authorization: `Bearer ${creatorConfigSignature}`,
-                        "fork-version": this.fork_version,
-                    }
+                        'fork-version': this.fork_version,
+                    },
                 });
                 return clusterDefinition === null || clusterDefinition === void 0 ? void 0 : clusterDefinition.config_hash;
             }
             catch (err) {
-                if ((err === null || err === void 0 ? void 0 : err.message) == CONFLICT_ERROR_MSG)
+                if ((err === null || err === void 0 ? void 0 : 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)
-    */
+     * 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)
+     */
     acceptClusterDefinition(operatorPayload, configHash) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.signer)
-                throw "Signer is required in acceptClusterDefinition";
+            if (!this.signer) {
+                throw new Error('Signer is required in acceptClusterDefinition');
+            }
             validatePayload(operatorPayload, operatorPayloadSchema);
             try {
                 const address = yield this.signer.getAddress();
@@ -96,7 +99,7 @@ export class Client extends Base {
                     body: JSON.stringify(operatorData),
                     headers: {
                         Authorization: `Bearer ${operatorConfigSignature}`,
-                    }
+                    },
                 });
                 return clusterDefinition;
             }

package/dist/esm/src/schema.js

@@ -1,69 +1,57 @@
 export const operatorPayloadSchema = {
-    type: "object",
+    type: 'object',
     properties: {
         version: {
-            type: "string"
+            type: 'string',
         },
         enr: {
-            type: "string"
+            type: 'string',
         },
     },
-    required: [
-        "version",
-        "enr",
-    ]
+    required: ['version', 'enr'],
 };
 export const definitionSchema = {
-    type: "object",
+    type: 'object',
     properties: {
         name: {
-            type: "string"
+            type: 'string',
         },
         operators: {
-            type: "array",
+            type: 'array',
             minItems: 4,
             uniqueItems: true,
             items: {
-                type: "object",
+                type: 'object',
                 properties: {
                     address: {
-                        type: "string",
+                        type: 'string',
                         minLength: 42,
-                        maxLength: 42
-                    }
+                        maxLength: 42,
+                    },
                 },
-                required: [
-                    "address"
-                ]
-            }
+                required: ['address'],
+            },
         },
         validators: {
-            type: "array",
+            type: 'array',
             minItems: 1,
             items: {
-                type: "object",
+                type: 'object',
                 properties: {
                     fee_recipient_address: {
-                        type: "string",
+                        type: 'string',
                         minLength: 42,
-                        maxLength: 42
+                        maxLength: 42,
                     },
                     withdrawal_address: {
-                        type: "string",
+                        type: 'string',
                         minLength: 42,
-                        maxLength: 42
-                    }
+                        maxLength: 42,
+                    },
                 },
-                required: [
-                    "fee_recipient_address",
-                    "withdrawal_address"
-                ]
-            }
-        }
+                required: ['fee_recipient_address', 'withdrawal_address'],
+            },
+        },
     },
-    required: [
-        "name",
-        "operators",
-        "validators"
-    ]
+    required: ['name', 'operators', 'validators'],
 };

package/dist/esm/src/services.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { isValidClusterLock } from "./verify.js";
+import { isValidClusterLock } from './verification/common.js';
 /**
  * Verifies Cluster Lock's validity.
  * @param lock - cluster lock

package/dist/esm/src/types.js

@@ -12,4 +12,3 @@ export var FORK_MAPPING;
     /** Holesky. */
     FORK_MAPPING[FORK_MAPPING["0x01017000"] = 17000] = "0x01017000";
 })(FORK_MAPPING || (FORK_MAPPING = {}));
-;

package/dist/esm/src/utils.js

@@ -1,6 +1,40 @@
+import { DefinitionFlow } from './constants';
 export const hexWithout0x = (hex) => {
     return hex.slice(2, hex.length);
 };
 export const strToUint8Array = (str) => {
     return new TextEncoder().encode(str);
 };
+export const definitionFlow = (clusterDefinition) => {
+    if (clusterDefinition.creator.address &&
+        clusterDefinition.creator.config_signature &&
+        clusterDefinition.operators.every((operator) => {
+            return (operator.address &&
+                operator.config_signature &&
+                operator.enr &&
+                operator.enr_signature);
+        })) {
+        return DefinitionFlow.Group;
+    }
+    else if (clusterDefinition.creator.address &&
+        clusterDefinition.creator.config_signature &&
+        clusterDefinition.operators.every((operator) => {
+            return (!operator.address &&
+                !operator.config_signature &&
+                operator.enr &&
+                !operator.enr_signature);
+        })) {
+        return DefinitionFlow.Solo;
+    }
+    else if (!clusterDefinition.creator.address &&
+        !clusterDefinition.creator.config_signature &&
+        clusterDefinition.operators.every((operator) => {
+            return (!operator.address &&
+                !operator.config_signature &&
+                operator.enr &&
+                !operator.enr_signature);
+        })) {
+        return DefinitionFlow.Charon;
+    }
+    return null;
+};