@obolnetwork/obol-sdk 1.0.9 → 1.0.11

package/README.md

@@ -1,9 +1,10 @@
 ![Obol Logo](https://obol.tech/obolnetwork.png)
 
+
 <h1 align="center">Obol SDK</h1>
 
 This repo contains the Obol Software Development Kit, for creating Distributed Validators with the help of the [Obol API](https://docs.obol.tech/api). 
 
 ## Getting Started
 
-Checkout our [docs](https://docs.obol.tech/docs/int/quickstart/advanced/quickstart-sdk), [examples](https://github.com/ObolNetwork/obol-sdk-examples/), and SDK [reference](https://obolnetwork.github.io/obol-packages). Further guides and walkthroughs coming soon. 
+Checkout our [docs](https://docs.obol.tech/docs/advanced/quickstart-sdk), [examples](https://github.com/ObolNetwork/obol-sdk-examples/), and SDK [reference](https://obolnetwork.github.io/obol-packages). Further guides and walkthroughs coming soon. 

package/dist/cjs/src/ajv.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePayload = void 0;
+const ajv_1 = __importDefault(require("ajv"));
+function validatePayload(data, schema) {
+    const ajv = new ajv_1.default();
+    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;
+}
+exports.validatePayload = validatePayload;

package/dist/cjs/src/base.js

@@ -0,0 +1,39 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base = void 0;
+// src/resources/base.ts
+const constants_js_1 = require("./constants.js");
+const types_js_1 = require("./types.js");
+class Base {
+    constructor({ baseUrl = constants_js_1.DEFAULT_BASE_URL, chainId = constants_js_1.DEFAULT_CHAIN_ID }) {
+        this.baseUrl = baseUrl;
+        this.chainId = chainId;
+        this.fork_version = types_js_1.FORK_MAPPING[this.chainId];
+    }
+    request(endpoint, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${this.baseUrl}${endpoint}`;
+            const config = Object.assign(Object.assign({}, options), { headers: Object.assign({ 'Content-Type': 'application/json', 'User-Agent': `Obol-SDK/${constants_js_1.SDK_VERSION}` }, options === null || options === void 0 ? void 0 : options.headers) });
+            try {
+                const response = yield fetch(url, config);
+                if (response.ok) {
+                    return (yield response.json());
+                }
+                throw new Error(response.statusText);
+            }
+            catch (e) {
+                throw e;
+            }
+        });
+    }
+}
+exports.Base = Base;

package/dist/cjs/src/constants.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CHAIN_ID = exports.DEFAULT_BASE_URL = exports.DefinitionFlow = exports.GENESIS_VALIDATOR_ROOT = exports.DOMAIN_DEPOSIT = exports.DOMAIN_APPLICATION_BUILDER = exports.SDK_VERSION = exports.config_version = exports.dkg_algorithm = exports.signEnrPayload = exports.signOperatorConfigHashPayload = exports.signCreatorConfigHashPayload = exports.ENRTypedMessage = exports.OperatorTypedMessage = exports.OperatorConfigHashSigningTypes = exports.EnrSigningTypes = exports.CreatorTypedMessage = exports.Domain = exports.CreatorConfigHashSigningTypes = exports.EIP712_DOMAIN_VERSION = exports.EIP712_DOMAIN_NAME = exports.CONFLICT_ERROR_MSG = void 0;
+exports.CONFLICT_ERROR_MSG = "Conflict";
+exports.EIP712_DOMAIN_NAME = "Obol";
+exports.EIP712_DOMAIN_VERSION = "1";
+exports.CreatorConfigHashSigningTypes = {
+    CreatorConfigHash: [{ name: "creator_config_hash", type: "string" }],
+};
+const EIP712Domain = [
+    { name: 'name', type: 'string' },
+    { name: 'version', type: 'string' },
+    { name: 'chainId', type: 'uint256' },
+];
+const Domain = (chainId) => {
+    return {
+        name: exports.EIP712_DOMAIN_NAME,
+        version: exports.EIP712_DOMAIN_VERSION,
+        chainId,
+    };
+};
+exports.Domain = Domain;
+exports.CreatorTypedMessage = Object.assign({ EIP712Domain }, exports.CreatorConfigHashSigningTypes);
+//A conflict once updateDefinition is merged
+exports.EnrSigningTypes = {
+    ENR: [{ name: "enr", type: "string" }],
+};
+exports.OperatorConfigHashSigningTypes = {
+    OperatorConfigHash: [{ name: "operator_config_hash", type: "string" }],
+};
+exports.OperatorTypedMessage = Object.assign({ EIP712Domain }, exports.OperatorConfigHashSigningTypes);
+exports.ENRTypedMessage = Object.assign({ EIP712Domain }, exports.EnrSigningTypes);
+const signCreatorConfigHashPayload = (payload, chainId) => {
+    return {
+        types: exports.CreatorTypedMessage,
+        primaryType: 'CreatorConfigHash',
+        domain: {
+            name: exports.EIP712_DOMAIN_NAME,
+            version: exports.EIP712_DOMAIN_VERSION,
+            chainId,
+        },
+        message: payload,
+    };
+};
+exports.signCreatorConfigHashPayload = signCreatorConfigHashPayload;
+const signOperatorConfigHashPayload = (payload, chainId) => {
+    return {
+        types: exports.OperatorTypedMessage,
+        primaryType: 'OperatorConfigHash',
+        domain: {
+            name: exports.EIP712_DOMAIN_NAME,
+            version: exports.EIP712_DOMAIN_VERSION,
+            chainId,
+        },
+        message: payload,
+    };
+};
+exports.signOperatorConfigHashPayload = signOperatorConfigHashPayload;
+const signEnrPayload = (payload, chainId) => {
+    return {
+        types: exports.ENRTypedMessage,
+        primaryType: 'ENR',
+        domain: {
+            name: exports.EIP712_DOMAIN_NAME,
+            version: exports.EIP712_DOMAIN_VERSION,
+            chainId,
+        },
+        message: payload,
+    };
+};
+exports.signEnrPayload = signEnrPayload;
+exports.dkg_algorithm = "default";
+exports.config_version = "v1.7.0";
+exports.SDK_VERSION = "1.0.7";
+exports.DOMAIN_APPLICATION_BUILDER = '00000001';
+exports.DOMAIN_DEPOSIT = '03000000';
+exports.GENESIS_VALIDATOR_ROOT = '0000000000000000000000000000000000000000000000000000000000000000';
+// Flow used to create defintion
+var DefinitionFlow;
+(function (DefinitionFlow) {
+    DefinitionFlow["Group"] = "LP-Group";
+    DefinitionFlow["Solo"] = "LP-Solo";
+    DefinitionFlow["Charon"] = "Charon-Command";
+})(DefinitionFlow || (exports.DefinitionFlow = DefinitionFlow = {}));
+exports.DEFAULT_BASE_URL = "https://api.obol.tech";
+exports.DEFAULT_CHAIN_ID = 1;

package/dist/cjs/src/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConflictError = void 0;
+class ConflictError extends Error {
+    constructor() {
+        super(`This Cluster has been already posted.`);
+        this.name = 'ConflictError';
+        Object.setPrototypeOf(this, ConflictError.prototype);
+    }
+}
+exports.ConflictError = ConflictError;

package/dist/cjs/src/hash.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clusterLockHash = exports.clusterDefinitionContainerType = exports.validatorsContainerType = exports.creatorContainerType = exports.operatorContainerType = exports.hashClusterDefinition = exports.clusterConfigOrDefinitionHash = void 0;
+const ssz_1 = require("@chainsafe/ssz");
+const utils_js_1 = require("./utils.js");
+//cluster-definition
+/**
+ * @param cluster The cluster configuration or the cluster definition
+ * @param configOnly a boolean to indicate config hash or definition hash
+ * @returns The config hash or the definition hash in of the corresponding cluster
+ */
+const clusterConfigOrDefinitionHash = (cluster, configOnly) => {
+    const definitionType = (0, exports.clusterDefinitionContainerType)(configOnly);
+    const val = (0, exports.hashClusterDefinition)(cluster, configOnly);
+    return ('0x' + Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex'));
+};
+exports.clusterConfigOrDefinitionHash = clusterConfigOrDefinitionHash;
+const hashClusterDefinition = (cluster, configOnly) => {
+    const definitionType = (0, exports.clusterDefinitionContainerType)(configOnly);
+    const val = definitionType.defaultValue();
+    //order should be same as charon https://github.com/ObolNetwork/charon/blob/d00b31e6465a260a43ce40f15c47fb5a5b009042/cluster/ssz.go#L285
+    val.uuid = (0, utils_js_1.strToUint8Array)(cluster.uuid);
+    val.name = (0, utils_js_1.strToUint8Array)(cluster.name);
+    val.version = (0, utils_js_1.strToUint8Array)(cluster.version);
+    val.timestamp = (0, utils_js_1.strToUint8Array)(cluster.timestamp);
+    val.num_validators = cluster.num_validators;
+    val.threshold = cluster.threshold;
+    val.dkg_algorithm = (0, utils_js_1.strToUint8Array)(cluster.dkg_algorithm);
+    val.fork_version = (0, ssz_1.fromHexString)(cluster.fork_version);
+    val.operators = cluster.operators.map((operator) => {
+        return configOnly
+            ? { address: (0, ssz_1.fromHexString)(operator.address) }
+            : {
+                address: (0, ssz_1.fromHexString)(operator.address),
+                enr: (0, utils_js_1.strToUint8Array)(operator.enr),
+                config_signature: (0, ssz_1.fromHexString)(operator.config_signature),
+                enr_signature: (0, ssz_1.fromHexString)(operator.enr_signature),
+            };
+    });
+    val.creator = configOnly
+        ? { address: (0, ssz_1.fromHexString)(cluster.creator.address) }
+        : {
+            address: (0, ssz_1.fromHexString)(cluster.creator.address),
+            config_signature: (0, ssz_1.fromHexString)(cluster.creator.config_signature),
+        };
+    val.validators = cluster.validators.map((validator) => {
+        return {
+            fee_recipient_address: (0, ssz_1.fromHexString)(validator.fee_recipient_address),
+            withdrawal_address: (0, ssz_1.fromHexString)(validator.withdrawal_address),
+        };
+    });
+    if (!configOnly) {
+        val.config_hash = (0, ssz_1.fromHexString)(cluster.config_hash);
+    }
+    return val;
+};
+exports.hashClusterDefinition = hashClusterDefinition;
+const operatorAddressWrapperType = new ssz_1.ContainerType({
+    address: new ssz_1.ByteVectorType(20),
+});
+const creatorAddressWrapperType = new ssz_1.ContainerType({
+    address: new ssz_1.ByteVectorType(20),
+});
+exports.operatorContainerType = new ssz_1.ContainerType({
+    address: new ssz_1.ByteVectorType(20),
+    enr: new ssz_1.ByteListType(1024), // This needs to be dynamic, since ENRs do not have a fixed length.
+    config_signature: new ssz_1.ByteVectorType(65),
+    enr_signature: new ssz_1.ByteVectorType(65),
+});
+exports.creatorContainerType = new ssz_1.ContainerType({
+    address: new ssz_1.ByteVectorType(20),
+    config_signature: new ssz_1.ByteVectorType(65),
+});
+exports.validatorsContainerType = new ssz_1.ContainerType({
+    fee_recipient_address: new ssz_1.ByteVectorType(20),
+    withdrawal_address: new ssz_1.ByteVectorType(20),
+});
+const newCreatorContainerType = (configOnly) => {
+    return configOnly ? creatorAddressWrapperType : exports.creatorContainerType;
+};
+const newOperatorContainerType = (configOnly) => {
+    return configOnly ? operatorAddressWrapperType : exports.operatorContainerType;
+};
+/**
+ * @param configOnly a boolean to indicate config hash or definition hash
+ * @returns SSZ Containerized type of cluster definition
+ */
+const clusterDefinitionContainerType = (configOnly) => {
+    let returnedContainerType = {
+        uuid: new ssz_1.ByteListType(64),
+        name: new ssz_1.ByteListType(256),
+        version: new ssz_1.ByteListType(16),
+        timestamp: new ssz_1.ByteListType(32),
+        num_validators: new ssz_1.UintNumberType(8),
+        threshold: new ssz_1.UintNumberType(8),
+        dkg_algorithm: new ssz_1.ByteListType(32),
+        fork_version: new ssz_1.ByteVectorType(4),
+        operators: new ssz_1.ListCompositeType(newOperatorContainerType(configOnly), 256),
+        creator: newCreatorContainerType(configOnly),
+        validators: new ssz_1.ListCompositeType(exports.validatorsContainerType, 65536),
+    };
+    if (!configOnly) {
+        returnedContainerType = Object.assign(Object.assign({}, returnedContainerType), { config_hash: new ssz_1.ByteVectorType(32) });
+    }
+    return new ssz_1.ContainerType(returnedContainerType);
+};
+exports.clusterDefinitionContainerType = clusterDefinitionContainerType;
+//cluster-lock
+/**
+ * @param cluster The published cluster lock
+ * @returns The lock hash in of the corresponding cluster
+ */
+const clusterLockHash = (cluster) => {
+    const lockType = clusterLockContainerType();
+    const val = lockType.defaultValue();
+    //Check if we can replace with definition_hash 
+    val.cluster_definition = (0, exports.hashClusterDefinition)(cluster.cluster_definition, false);
+    val.distributed_validators = cluster.distributed_validators.map(dVaidator => {
+        return {
+            distributed_public_key: (0, ssz_1.fromHexString)(dVaidator.distributed_public_key),
+            public_shares: dVaidator.public_shares.map(publicShare => (0, ssz_1.fromHexString)(publicShare)),
+            deposit_data: {
+                pubkey: (0, ssz_1.fromHexString)(dVaidator.deposit_data.pubkey),
+                withdrawal_credentials: (0, ssz_1.fromHexString)(dVaidator.deposit_data.withdrawal_credentials),
+                amount: parseInt(dVaidator.deposit_data.amount),
+                signature: (0, ssz_1.fromHexString)(dVaidator.deposit_data.signature),
+            },
+            builder_registration: {
+                message: {
+                    fee_recipient: (0, ssz_1.fromHexString)(dVaidator.builder_registration.message.fee_recipient),
+                    gas_limit: dVaidator.builder_registration.message.gas_limit,
+                    timestamp: dVaidator.builder_registration.message.timestamp,
+                    pubkey: (0, ssz_1.fromHexString)(dVaidator.builder_registration.message.pubkey),
+                },
+                signature: (0, ssz_1.fromHexString)(dVaidator.builder_registration.signature),
+            },
+        };
+    });
+    return '0x' + Buffer.from(lockType.hashTreeRoot(val).buffer).toString('hex');
+};
+exports.clusterLockHash = clusterLockHash;
+const depositDataContainer = new ssz_1.ContainerType({
+    pubkey: new ssz_1.ByteVectorType(48),
+    withdrawal_credentials: new ssz_1.ByteVectorType(32),
+    amount: new ssz_1.UintNumberType(8),
+    signature: new ssz_1.ByteVectorType(96),
+});
+const builderRegistrationMessageContainer = new ssz_1.ContainerType({
+    fee_recipient: new ssz_1.ByteVectorType(20),
+    gas_limit: new ssz_1.UintNumberType(8),
+    timestamp: new ssz_1.UintNumberType(8),
+    pubkey: new ssz_1.ByteVectorType(48),
+});
+const builderRegistrationContainer = new ssz_1.ContainerType({
+    message: builderRegistrationMessageContainer,
+    signature: new ssz_1.ByteVectorType(96),
+});
+const dvContainerType = new ssz_1.ContainerType({
+    distributed_public_key: new ssz_1.ByteVectorType(48),
+    public_shares: new ssz_1.ListCompositeType(new ssz_1.ByteVectorType(48), 256),
+    deposit_data: depositDataContainer,
+    builder_registration: builderRegistrationContainer,
+});
+/**
+ * @returns SSZ Containerized type of cluster lock
+ */
+const clusterLockContainerType = () => {
+    return new ssz_1.ContainerType({
+        cluster_definition: (0, exports.clusterDefinitionContainerType)(false),
+        distributed_validators: new ssz_1.ListCompositeType(dvContainerType, 65536),
+    });
+};

package/dist/cjs/src/index.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const uuid_1 = require("uuid");
+const base_js_1 = require("./base.js");
+const constants_js_1 = require("./constants.js");
+const errors_js_1 = require("./errors.js");
+const hash_js_1 = require("./hash.js");
+const ajv_js_1 = require("./ajv.js");
+const schema_js_1 = require("./schema.js");
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./services.js"), exports);
+/**
+ * Obol sdk Client can be used for creating, managing and activating distributed validators.
+ */
+class Client extends base_js_1.Base {
+    /**
+     * @param config - Client configurations
+     * @param config.baseUrl - obol-api url
+     * @param config.chainId - Blockchain network ID
+     * @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, signer) {
+        super(config);
+        this.signer = signer;
+    }
+    /**
+     * Creates a cluster definition which contains cluster configuration.
+     * @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)
+     */
+    createClusterDefinition(newCluster) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.signer)
+                throw "Signer is required in createClusterDefinition";
+            (0, ajv_js_1.validatePayload)(newCluster, schema_js_1.definitionSchema);
+            const clusterConfig = Object.assign(Object.assign({}, newCluster), { fork_version: this.fork_version, dkg_algorithm: constants_js_1.dkg_algorithm, version: constants_js_1.config_version, uuid: (0, uuid_1.v4)(), 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 = (0, hash_js_1.clusterConfigOrDefinitionHash)(clusterConfig, true);
+                const creatorConfigSignature = yield this.signer.signTypedData((0, constants_js_1.Domain)(this.chainId), constants_js_1.CreatorConfigHashSigningTypes, { creator_config_hash: clusterConfig.config_hash });
+                const clusterDefinition = yield this.request(`/dv`, {
+                    method: 'POST',
+                    body: JSON.stringify(clusterConfig),
+                    headers: {
+                        Authorization: `Bearer ${creatorConfigSignature}`,
+                        "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) == constants_js_1.CONFLICT_ERROR_MSG)
+                    throw new errors_js_1.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)
+    */
+    acceptClusterDefinition(operatorPayload, configHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.signer)
+                throw "Signer is required in acceptClusterDefinition";
+            (0, ajv_js_1.validatePayload)(operatorPayload, schema_js_1.operatorPayloadSchema);
+            try {
+                const address = yield this.signer.getAddress();
+                const operatorConfigSignature = yield this.signer.signTypedData((0, constants_js_1.Domain)(this.chainId), constants_js_1.OperatorConfigHashSigningTypes, { operator_config_hash: configHash });
+                const operatorENRSignature = yield this.signer.signTypedData((0, constants_js_1.Domain)(this.chainId), constants_js_1.EnrSigningTypes, { enr: operatorPayload.enr });
+                const operatorData = Object.assign(Object.assign({}, operatorPayload), { address, enr_signature: operatorENRSignature, fork_version: this.fork_version });
+                const clusterDefinition = yield this.request(`/dv/${configHash}`, {
+                    method: 'PUT',
+                    body: JSON.stringify(operatorData),
+                    headers: {
+                        Authorization: `Bearer ${operatorConfigSignature}`,
+                    }
+                });
+                return clusterDefinition;
+            }
+            catch (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)
+     */
+    getClusterDefinition(configHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const clusterDefinition = yield this.request(`/dv/${configHash}`, {
+                method: 'GET',
+            });
+            return clusterDefinition;
+        });
+    }
+    /**
+     * @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)
+     */
+    getClusterLock(configHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lock = yield this.request(`/lock/configHash/${configHash}`, {
+                method: 'GET',
+            });
+            return lock;
+        });
+    }
+}
+exports.Client = Client;

package/dist/cjs/src/schema.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definitionSchema = exports.operatorPayloadSchema = void 0;
+exports.operatorPayloadSchema = {
+    type: "object",
+    properties: {
+        version: {
+            type: "string"
+        },
+        enr: {
+            type: "string"
+        },
+    },
+    required: [
+        "version",
+        "enr",
+    ]
+};
+exports.definitionSchema = {
+    type: "object",
+    properties: {
+        name: {
+            type: "string"
+        },
+        operators: {
+            type: "array",
+            minItems: 4,
+            uniqueItems: true,
+            items: {
+                type: "object",
+                properties: {
+                    address: {
+                        type: "string",
+                        minLength: 42,
+                        maxLength: 42
+                    }
+                },
+                required: [
+                    "address"
+                ]
+            }
+        },
+        validators: {
+            type: "array",
+            minItems: 1,
+            items: {
+                type: "object",
+                properties: {
+                    fee_recipient_address: {
+                        type: "string",
+                        minLength: 42,
+                        maxLength: 42
+                    },
+                    withdrawal_address: {
+                        type: "string",
+                        minLength: 42,
+                        maxLength: 42
+                    }
+                },
+                required: [
+                    "fee_recipient_address",
+                    "withdrawal_address"
+                ]
+            }
+        }
+    },
+    required: [
+        "name",
+        "operators",
+        "validators"
+    ]
+};

package/dist/cjs/src/services.js

@@ -0,0 +1,32 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateClusterLock = void 0;
+const verify_js_1 = require("./verify.js");
+/**
+ * Verifies Cluster Lock's validity.
+ * @param lock - cluster lock
+ * @returns {Promise<{ result: boolean }> } boolean result to indicate if lock is valid
+ * @throws on missing keys or values.
+ *
+ * An example of how to use validateClusterLock:
+ * [validateClusterLock](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts)
+ */
+const validateClusterLock = (lock) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const isLockValid = yield (0, verify_js_1.isValidClusterLock)(lock);
+        return isLockValid;
+    }
+    catch (err) {
+        throw err;
+    }
+});
+exports.validateClusterLock = validateClusterLock;

package/dist/cjs/src/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORK_MAPPING = void 0;
+/**
+ * Permitted ChainID's
+ */
+var FORK_MAPPING;
+(function (FORK_MAPPING) {
+    /** Mainnet. */
+    FORK_MAPPING[FORK_MAPPING["0x00000000"] = 1] = "0x00000000";
+    /** Goerli/Prater. */
+    FORK_MAPPING[FORK_MAPPING["0x00001020"] = 5] = "0x00001020";
+    /** Gnosis Chain. */
+    FORK_MAPPING[FORK_MAPPING["0x00000064"] = 100] = "0x00000064";
+    /** Holesky. */
+    FORK_MAPPING[FORK_MAPPING["0x01017000"] = 17000] = "0x01017000";
+})(FORK_MAPPING || (exports.FORK_MAPPING = FORK_MAPPING = {}));
+;

package/dist/cjs/src/utils.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strToUint8Array = exports.hexWithout0x = void 0;
+const hexWithout0x = (hex) => {
+    return hex.slice(2, hex.length);
+};
+exports.hexWithout0x = hexWithout0x;
+const strToUint8Array = (str) => {
+    return new TextEncoder().encode(str);
+};
+exports.strToUint8Array = strToUint8Array;