@obolnetwork/obol-sdk 1.0.9 → 1.0.12

package/dist/cjs/src/verify.js

@@ -0,0 +1,326 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidClusterLock = exports.signingRoot = void 0;
+const semver = __importStar(require("semver"));
+const bls_1 = require("@chainsafe/bls");
+const discv5_1 = require("@chainsafe/discv5");
+const ssz_1 = require("@chainsafe/ssz");
+const uint_js_1 = require("@chainsafe/ssz/lib/type/uint.js");
+const eth_sig_util_1 = require("@metamask/eth-sig-util");
+const elliptic_1 = __importDefault(require("elliptic"));
+const ethers_1 = require("ethers");
+const types_js_1 = require("./types.js");
+const hash_js_1 = require("./hash.js");
+const constants_js_1 = require("./constants.js");
+const utils_js_1 = require("./utils.js");
+const builderRegistrationMessageType = new ssz_1.ContainerType({
+    fee_recipient: new ssz_1.ByteVectorType(20),
+    gas_limit: new uint_js_1.UintNumberType(8),
+    timestamp: new uint_js_1.UintNumberType(8),
+    pubkey: new ssz_1.ByteVectorType(48),
+});
+//For domain computation that is used in deposit data and builder registration verification for dv
+const forkDataType = new ssz_1.ContainerType({
+    currentVersion: new ssz_1.ByteVectorType(4),
+    genesisValidatorsRoot: new ssz_1.ByteVectorType(32),
+});
+const depositMessageType = new ssz_1.ContainerType({
+    pubkey: new ssz_1.ByteVectorType(48),
+    withdrawal_credentials: new ssz_1.ByteVectorType(32),
+    amount: new uint_js_1.UintNumberType(8),
+});
+const signingRootType = new ssz_1.ContainerType({
+    objectRoot: new ssz_1.ByteVectorType(32),
+    domain: new ssz_1.ByteVectorType(32),
+});
+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 constants_js_1.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 constants_js_1.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 constants_js_1.DefinitionFlow.Charon;
+    }
+    return null;
+};
+//cluster-definition signatures verificatin
+const getPOSTConfigHashSigner = (signature, configHash, chainId) => {
+    try {
+        const sig = ethers_1.ethers.Signature.from(signature);
+        const data = (0, constants_js_1.signCreatorConfigHashPayload)({ creator_config_hash: configHash }, chainId);
+        const digest = eth_sig_util_1.TypedDataUtils.eip712Hash(data, eth_sig_util_1.SignTypedDataVersion.V4);
+        return ethers_1.ethers.recoverAddress(digest, sig).toLowerCase();
+    }
+    catch (err) {
+        throw err;
+    }
+};
+const getPUTConfigHashSigner = (signature, configHash, chainId) => {
+    try {
+        const sig = ethers_1.ethers.Signature.from(signature);
+        const data = (0, constants_js_1.signOperatorConfigHashPayload)({ operator_config_hash: configHash }, chainId);
+        const digest = eth_sig_util_1.TypedDataUtils.eip712Hash(data, eth_sig_util_1.SignTypedDataVersion.V4);
+        return ethers_1.ethers.recoverAddress(digest, sig).toLowerCase();
+    }
+    catch (err) {
+        throw err;
+    }
+};
+const getEnrSigner = (signature, payload, chainId) => {
+    try {
+        const sig = ethers_1.ethers.Signature.from(signature);
+        const data = (0, constants_js_1.signEnrPayload)({ enr: payload }, chainId);
+        const digest = eth_sig_util_1.TypedDataUtils.eip712Hash(data, eth_sig_util_1.SignTypedDataVersion.V4);
+        return ethers_1.ethers.recoverAddress(digest, sig).toLowerCase();
+    }
+    catch (err) {
+        throw err;
+    }
+};
+const verifyDefinitionSignatures = (clusterDefinition, definitionType) => {
+    if (definitionType === 'Charon-Command') {
+        return true;
+    }
+    else {
+        const configSigner = getPOSTConfigHashSigner(clusterDefinition.creator.config_signature, clusterDefinition.config_hash, types_js_1.FORK_MAPPING[clusterDefinition.fork_version]);
+        if (configSigner !== clusterDefinition.creator.address.toLowerCase()) {
+            return false;
+        }
+        if (definitionType === 'LP-Solo') {
+            return true;
+        }
+        return clusterDefinition.operators.every(operator => {
+            const configSigner = getPUTConfigHashSigner(operator.config_signature, clusterDefinition.config_hash, types_js_1.FORK_MAPPING[clusterDefinition.fork_version]);
+            const enrSigner = getEnrSigner(operator.enr_signature, operator.enr, types_js_1.FORK_MAPPING[clusterDefinition.fork_version]);
+            if (configSigner !== operator.address.toLowerCase() ||
+                enrSigner !== operator.address.toLowerCase()) {
+                return false;
+            }
+            return true;
+        });
+    }
+};
+//cluster-lock data verification 
+const computeSigningRoot = (sszObjectRoot, domain) => {
+    const val1 = signingRootType.defaultValue();
+    val1.objectRoot = sszObjectRoot;
+    val1.domain = domain;
+    return Buffer.from(signingRootType.hashTreeRoot(val1).buffer);
+};
+const computeDepositMsgRoot = (msg) => {
+    const depositMsgVal = depositMessageType.defaultValue();
+    depositMsgVal.pubkey = (0, ssz_1.fromHexString)(msg.pubkey);
+    depositMsgVal.withdrawal_credentials = (0, ssz_1.fromHexString)(msg.withdrawal_credentials);
+    depositMsgVal.amount = parseInt(msg.amount);
+    return Buffer.from(depositMessageType.hashTreeRoot(depositMsgVal).buffer);
+};
+const computeForkDataRoot = (currentVersion, genesisValidatorsRoot) => {
+    const forkDataVal = forkDataType.defaultValue();
+    forkDataVal.currentVersion = currentVersion;
+    forkDataVal.genesisValidatorsRoot = genesisValidatorsRoot;
+    return Buffer.from(forkDataType.hashTreeRoot(forkDataVal).buffer);
+};
+const computebuilderRegistrationMsgRoot = (msg) => {
+    const builderRegistrationMsgVal = builderRegistrationMessageType.defaultValue();
+    builderRegistrationMsgVal.fee_recipient = (0, ssz_1.fromHexString)(msg.fee_recipient);
+    builderRegistrationMsgVal.gas_limit = msg.gas_limit;
+    builderRegistrationMsgVal.timestamp = msg.timestamp;
+    builderRegistrationMsgVal.pubkey = (0, ssz_1.fromHexString)(msg.pubkey);
+    return Buffer.from(builderRegistrationMessageType.hashTreeRoot(builderRegistrationMsgVal)
+        .buffer);
+};
+// DV data verification
+const computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = (0, ssz_1.fromHexString)(constants_js_1.GENESIS_VALIDATOR_ROOT)) => {
+    const forkVersion = (0, ssz_1.fromHexString)(lockForkVersion.substring(2, lockForkVersion.length));
+    const forkDataRoot = computeForkDataRoot(forkVersion, genesisValidatorsRoot);
+    const domain = new Uint8Array(32);
+    domain.set(domainType);
+    domain.set(forkDataRoot.subarray(0, 28), 4);
+    return domain;
+};
+const verifyDepositData = (validator, withdrawalAddress) => {
+    const eth1AddressWithdrawalPrefix = '0x01';
+    if (eth1AddressWithdrawalPrefix +
+        '0'.repeat(22) +
+        withdrawalAddress.toLowerCase().slice(2) !==
+        validator.deposit_data.withdrawal_credentials) {
+        return false;
+    }
+    if (validator.distributed_public_key !== validator.deposit_data.pubkey) {
+        return false;
+    }
+    return true;
+};
+const verifyBuilderRegistration = (validator, feeRecipientAddress) => {
+    if (validator.distributed_public_key !==
+        validator.builder_registration.message.pubkey) {
+        return false;
+    }
+    if (feeRecipientAddress.toLowerCase() !==
+        validator.builder_registration.message.fee_recipient.toLowerCase()) {
+        return false;
+    }
+    return true;
+};
+const signingRoot = (domain, messageBuffer) => {
+    return computeSigningRoot(messageBuffer, domain);
+};
+exports.signingRoot = signingRoot;
+const verifyLockData = (clusterLock) => __awaiter(void 0, void 0, void 0, function* () {
+    const ec = new elliptic_1.default.ec('secp256k1');
+    const validators = clusterLock.distributed_validators;
+    const nodeSignatures = clusterLock.node_signatures;
+    const depositDomain = computeDomain((0, ssz_1.fromHexString)(constants_js_1.DOMAIN_DEPOSIT), clusterLock.cluster_definition.fork_version);
+    const builderDomain = computeDomain((0, ssz_1.fromHexString)(constants_js_1.DOMAIN_APPLICATION_BUILDER), clusterLock.cluster_definition.fork_version);
+    const pubShares = [];
+    const pubKeys = [];
+    const builderRegistrationAndDepositDataMessages = [];
+    const blsSignatures = [];
+    yield (0, bls_1.init)('herumi');
+    for (let i = 0; i < validators.length; i++) {
+        const validator = validators[i];
+        const validatorPublicShares = validator['public_shares'];
+        for (const element of validatorPublicShares) {
+            pubShares.push((0, ssz_1.fromHexString)(element));
+        }
+        //Deposit data signature
+        if (semver.gte(clusterLock.cluster_definition.version, 'v1.6.0')) {
+            if (!verifyDepositData(validator, clusterLock.cluster_definition.validators[i].withdrawal_address)) {
+                return false;
+            }
+            const depositMessageBuffer = computeDepositMsgRoot(validator.deposit_data);
+            const depositDataMessage = (0, exports.signingRoot)(depositDomain, depositMessageBuffer);
+            pubKeys.push((0, ssz_1.fromHexString)(validator.distributed_public_key));
+            builderRegistrationAndDepositDataMessages.push(depositDataMessage);
+            blsSignatures.push((0, ssz_1.fromHexString)(validator.deposit_data.signature));
+        }
+        //Builder registration signature
+        if (semver.gte(clusterLock.cluster_definition.version, 'v1.7.0')) {
+            if (!verifyBuilderRegistration(validator, clusterLock.cluster_definition.validators[i].fee_recipient_address)) {
+                return false;
+            }
+            const builderRegistrationMessageBuffer = computebuilderRegistrationMsgRoot(validator.builder_registration.message);
+            const builderRegistrationMessage = (0, exports.signingRoot)(builderDomain, builderRegistrationMessageBuffer);
+            pubKeys.push((0, ssz_1.fromHexString)(validator.distributed_public_key));
+            builderRegistrationAndDepositDataMessages.push(builderRegistrationMessage);
+            blsSignatures.push((0, ssz_1.fromHexString)(validator.builder_registration.signature));
+        }
+    }
+    if (blsSignatures.length &&
+        pubKeys.length &&
+        builderRegistrationAndDepositDataMessages.length) {
+        // verify all deposit data and builder registration bls signatures
+        const aggregateBLSSignature = (0, bls_1.aggregateSignatures)(blsSignatures);
+        if (!(0, bls_1.verifyMultiple)(pubKeys, builderRegistrationAndDepositDataMessages, aggregateBLSSignature)) {
+            return false;
+        }
+    }
+    if (semver.gte(clusterLock.cluster_definition.version, 'v1.7.0')) {
+        const lockHashWithout0x = (0, utils_js_1.hexWithout0x)(clusterLock.lock_hash);
+        //node(ENR) signatures
+        for (let i = 0; i < nodeSignatures.length; i++) {
+            const pubkey = discv5_1.ENR.decodeTxt(clusterLock.cluster_definition.operators[i].enr).publicKey.toString('hex');
+            const ENRsignature = {
+                r: nodeSignatures[i].slice(2, 66),
+                s: nodeSignatures[i].slice(66, 130),
+            };
+            const nodeSignatureVerification = ec
+                .keyFromPublic(pubkey, 'hex')
+                .verify(lockHashWithout0x, ENRsignature);
+            if (!nodeSignatureVerification) {
+                return false;
+            }
+        }
+    }
+    //signature aggregate
+    if (!(0, bls_1.verifyAggregate)(pubShares, (0, ssz_1.fromHexString)(clusterLock.lock_hash), (0, ssz_1.fromHexString)(clusterLock.signature_aggregate))) {
+        return false;
+    }
+    return true;
+});
+const isValidClusterLock = (clusterLock) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const definitionType = definitionFlow(clusterLock.cluster_definition);
+        if (!definitionType) {
+            return false;
+        }
+        const isValidDefinitionData = verifyDefinitionSignatures(clusterLock.cluster_definition, definitionType);
+        if (!isValidDefinitionData) {
+            return false;
+        }
+        if ((0, hash_js_1.clusterConfigOrDefinitionHash)(clusterLock.cluster_definition, false) !==
+            clusterLock.cluster_definition.definition_hash) {
+            return false;
+        }
+        if ((0, hash_js_1.clusterLockHash)(clusterLock) !== clusterLock.lock_hash) {
+            return false;
+        }
+        const isValidLockData = yield verifyLockData(clusterLock);
+        if (!isValidLockData) {
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+});
+exports.isValidClusterLock = isValidClusterLock;

package/dist/cjs/test/fixtures.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clusterConfig = exports.clusterLockV1X7 = void 0;
+exports.clusterLockV1X7 = {
+    cluster_definition: {
+        name: "v1.7.0 group test",
+        creator: {
+            address: "0x86B8145c98e5BD25BA722645b15eD65f024a87EC",
+            config_signature: "0x269aefc773de5fbfe41001cbd160b62747a27d76a92c8a6a7eae19d0f172c4b44d445ee0992e1ba6e271740a59051bf9cd8fda4042572bde75e40e8d28f7e6561b"
+        },
+        operators: [
+            {
+                address: "0x86B8145c98e5BD25BA722645b15eD65f024a87EC",
+                enr: "enr:-Iu4QCdreXm-iHrd2Y-QgLAHeGAkQSrZNvfPL-l6IuGEuKoMHnZsg93EgIWWOtcBzKs_-skexEKvY3CmcJ8SOzMIGMiAgmlkgnY0gmlwhH8AAAGJc2VjcDI1NmsxoQL4r6dX8heIruf3OW_hfcctLtsaX8roj8E-8s0-IpH9rYN0Y3CCDhqDdWRwgg4u",
+                config_signature: "0x73bc8d23dee307a02791339300b6405573e686c22222d6e6c8fe349f52bb8c0620ea1ed476fe569ed8c8d21751893216b248eb28dd4de7aa263a234efe3129181b",
+                enr_signature: "0x1dc963f01eb794170e35a972ec8b487bdea2e3c1acbbe2fc2ab7936e7fe99e407583489a7dff3fbb08f4902e77867d795a7196a83d91b0a0eb8e50b8d96d35ba1c"
+            },
+            {
+                address: "0xC35CfCd67b9C27345a54EDEcC1033F2284148c81",
+                enr: "enr:-Iu4QNbiUUUwT18LynBbVPJhNxvzQsaSpUr40mQTWscnZaqKb6vAlvV8j-eDDR3E0wjMQumGRbGm2IAb5_k4bVWJiVGAgmlkgnY0gmlwhH8AAAGJc2VjcDI1NmsxoQPOiodUji0ohgJb5sNK1hgv8g6xO5_znZz3NkkBkyYyKIN0Y3CCDhqDdWRwgg4u",
+                config_signature: "0x0ab6f58c612cd0c6af395769132fccc5c0804fd40cc395ae7ab2069a7aedb2884f2fa07a91eee57e13c3407dbeeb81b2256312d14006bdb1c19d4206b66899a41c",
+                enr_signature: "0xb580f1380a62d299587357181561c8db8d67f4cc92d094b2ca3c84eddde3759567cfe60669b30ef55308a749c3c6a32f52148ac6b667cc6554f63a04c55350451b"
+            },
+            {
+                address: "0x33807D6F1DCe44b9C599fFE03640762A6F08C496",
+                enr: "enr:-Iu4QJyserRukhG0Vgi2csu7GjpHYUGufNEbZ8Q7ZBrcZUb0KqpL5QzHonkh1xxHlxatTxrIcX_IS5J3SEWR_sa0ptGAgmlkgnY0gmlwhH8AAAGJc2VjcDI1NmsxoQMAUgEqczOjevyculnUIofhCj0DkgJudErM7qCYIvIkzIN0Y3CCDhqDdWRwgg4u",
+                config_signature: "0x6f4f030aedba854cc4fa626171038e0125a93b3c3017af932d5b2a159076d0e17c1641f28cb58c29039e2c33074dd729c3198253ea17cc38074274f5e13676441b",
+                enr_signature: "0xf63195e4238eac6d9deae5ec56626ac16a7a861294587c3ee144853ace76f8a2089980a2cbf17c72a8c5ac0651c6935d023db34fc0be58a91f0c70c26017597a1b"
+            },
+            {
+                address: "0xc6e76F72Ea672FAe05C357157CfC37720F0aF26f",
+                enr: "enr:-HW4QKJTwXC6Chw6zbnA3HFZi6Jo0DkIgjKy4eUBpsSOGnAeWE6ChEjEyk_6R6Qrm7jI-iqfs3_HYxiKde8vFgvHHrCAgmlkgnY0iXNlY3AyNTZrMaECfFKQH4spdZCHqrKVz1Q02xYla6J_RQECDNNYBRWdzv8",
+                config_signature: "0x8c09f7163c20cd0a2d28cb4fbfda22e93bc53bc537f6143407065922a25e40ab39f52b232ecb9241b3e1674f87a16d263181a17a80de55fb92b9659211428b581b",
+                enr_signature: "0x05d801705908933b7d1566f48f5726d36874423b1bbdd3f582e08c754220d211492b46ee434f1d1f5bd1507f80f9ca1df569354892e7d2eda87861bc2279be6e1c"
+            }
+        ],
+        uuid: "a1d642aa-07ed-4d48-9eda-0e70cb4bb03f",
+        version: "v1.7.0",
+        timestamp: "2023-07-18T10:36:04.505Z",
+        num_validators: 1,
+        threshold: 3,
+        validators: [
+            {
+                fee_recipient_address: "0x86B8145c98e5BD25BA722645b15eD65f024a87EC",
+                withdrawal_address: "0x86B8145c98e5BD25BA722645b15eD65f024a87EC"
+            }
+        ],
+        dkg_algorithm: "default",
+        fork_version: "0x00001020",
+        config_hash: "0x4c3e37cbdb2fb850150f6e112c4ea03cdc388bff059081182659b3407183b431",
+        definition_hash: "0xe7bf484f38a45c96e9a3fac60d3e39b88eeb9979fad983e06b0ec90e90aa20b3"
+    },
+    distributed_validators: [
+        {
+            distributed_public_key: "0xb61b17f3b6425eb2636bc6378de0ed8aab918c3346b59d297828e7c74643d51e80edc2b41290c568614cfb80d2b0be34",
+            public_shares: [
+                "0xab6c1448221f664c145a4a574302fd4419ccfe1178487b2fa4629ee9fc2999c43188c96a52ad795074124a7eb0f63841",
+                "0x8a2a265fbe9854b1532be335272717a5650e19ecc4d6ea54ed8d8d239200f5b860e5710f7a3b9f5d8a100782cbaf4ede",
+                "0xa8a0aaf1119afe1c2b21d7dbf18bbe107586dc49028d285886c2e7f2bcf3f1c6817fff1250f4a4a370229a0266ea9bff",
+                "0x93f62a042d304bbb316761712f5a39a9d549c71275e5d891afa3688b9224ebfa3bfd22f8b76f31d8ad88f65812b27dc3"
+            ],
+            deposit_data: {
+                pubkey: "0xb61b17f3b6425eb2636bc6378de0ed8aab918c3346b59d297828e7c74643d51e80edc2b41290c568614cfb80d2b0be34",
+                withdrawal_credentials: "0x01000000000000000000000086b8145c98e5bd25ba722645b15ed65f024a87ec",
+                amount: "32000000000",
+                signature: "0xae016c6c42daa8d1517d0e10370cf7882b28149635f734c5f3d83f781cd61f5df6d5203ec11bd0ca9d9e51c6030b66330476a93a65de6151d110e0f6482591f53678d863e55392e9cfb55fecac537edac51979790bcde38250a141348f116d46",
+                deposit_data_root: 'fbada6c7c4cba867780eead34c1462339795fe9b417db466ce2f9d4822e8a4bb'
+            },
+            builder_registration: {
+                message: {
+                    fee_recipient: "0x86B8145c98e5BD25BA722645b15eD65f024a87EC",
+                    gas_limit: 30000000,
+                    timestamp: 1616508000,
+                    pubkey: "0xb61b17f3b6425eb2636bc6378de0ed8aab918c3346b59d297828e7c74643d51e80edc2b41290c568614cfb80d2b0be34"
+                },
+                signature: "0xb1de0eeb44c3b9d598d50c8d48a676e45dd63a5a3040caa34e34ab8c60d0b2f079419d8699c97e76b641326845c99ee309096de1878547e370d4b82e2e4e580650fee2e46dc7b9b3bd805b7fe6f95ba6a9e2734c3ddd23bf6b1f5597e9a3f834"
+            }
+        }
+    ],
+    signature_aggregate: "0x90c32196e4dda81b39faaaec283e3ec5620b7c25c1a35949d54eb53a7c1c5a3963614c0d147085d82f9c52f550556ba406c0c5c8a4cec3fec825e6663a8792a9205f1a36fdde3e8c810cfd8861963190dd9b9eadd9a803bd5765c0b93d146542",
+    lock_hash: "0xdb19ef9c0677713f55502448b7c63d58fb25c81d34a5a8ce07a19bcfb3a9c0a0",
+    node_signatures: [
+        "0xa5230ba0586b21d49e790bc99304dc2245f8222c17d456ef60b848e3b0c5541d61825b2f9c2bda87ba3952979f28f6ba2338026603de74f925d9603aa823d42f01",
+        "0xc22ac5dc3a6f98471f2f25d11fd48600f955f68cb940e9da6789ab8fc50ca1bf40c8fb3200132ad6b2c66be7e256979fe182f8f924506ad8ba2c827401038ec600",
+        "0xebd08c9ece21abd78cfe82bc32eae68ccd77fc1e96e56ce93679918c5adcb2c92564a4fa609d7649587fbfb0c581403da8553e9e62c910e5ae589625704aa02b00",
+        "0xa07fc8f89f32a5b2551cc2173b0486f86142ee2a67400d2d4a956a2b948da96b58adddf558db6ac84de62242b5e56b1a1e95d26451be3a922fe3929f2a367a7400"
+    ]
+};
+exports.clusterConfig = {
+    name: "testSDK",
+    operators: [
+        { address: "0xC35CfCd67b9C27345a54EDEcC1033F2284148c81" },
+        { address: "0x33807D6F1DCe44b9C599fFE03640762A6F08C496" },
+        { address: "0xc6e76F72Ea672FAe05C357157CfC37720F0aF26f" },
+        { address: "0x86B8145c98e5BD25BA722645b15eD65f024a87EC" }
+    ],
+    validators: [{
+            fee_recipient_address: "0x3CD4958e76C317abcEA19faDd076348808424F99",
+            withdrawal_address: "0xE0C5ceA4D3869F156717C66E188Ae81C80914a6e"
+        }],
+};

package/dist/cjs/test/methods.test.js

@@ -0,0 +1,128 @@
+"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 });
+const ethers_1 = require("ethers");
+const index_1 = require("../src/index");
+const fixtures_js_1 = require("./fixtures.js");
+const constants_1 = require("../src/constants");
+const base_1 = require("../src/base");
+const ajv_1 = require("../src/ajv");
+const msw_1 = require("msw");
+const node_1 = require("msw/node");
+describe('Cluster Client', () => {
+    var _a;
+    const mockConfigHash = "0x1f6c94e6c070393a68c1aa6073a21cb1fd57f0e14d2a475a2958990ab728c2fd";
+    const mnemonic = ((_a = ethers_1.ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) || "";
+    const privateKey = ethers_1.ethers.Wallet.fromPhrase(mnemonic).privateKey;
+    const wallet = new ethers_1.ethers.Wallet(privateKey);
+    const mockSigner = wallet.connect(null);
+    const clientInstance = new index_1.Client({ baseUrl: "https://obol-api-dev.gcp.obol.tech", chainId: 5 }, mockSigner);
+    test('throws invalid ChainId when it is equal to 1', () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            new index_1.Client({ chainId: 1 }, mockSigner);
+        }
+        catch (error) {
+            expect(error.message).toBe("Invalid ChainId");
+        }
+    }));
+    test('createClusterDefinition should return config_hash', () => __awaiter(void 0, void 0, void 0, function* () {
+        clientInstance['request'] = jest.fn().mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
+        const config_hash = yield clientInstance.createClusterDefinition(fixtures_js_1.clusterConfig);
+        expect(config_hash).toEqual(mockConfigHash);
+    }));
+    test('acceptClusterDefinition should return cluster definition', () => __awaiter(void 0, void 0, void 0, function* () {
+        clientInstance['request'] = jest.fn().mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X7.cluster_definition));
+        const clusterDefinition = yield clientInstance.acceptClusterDefinition({ enr: fixtures_js_1.clusterLockV1X7.cluster_definition.operators[0].enr, version: fixtures_js_1.clusterLockV1X7.cluster_definition.version }, fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
+        expect(clusterDefinition).toEqual(fixtures_js_1.clusterLockV1X7.cluster_definition);
+    }));
+    test('createClusterDefinition should throw an error on invalid operators', () => __awaiter(void 0, void 0, void 0, function* () {
+        clientInstance['request'] = jest.fn().mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
+        try {
+            yield clientInstance.createClusterDefinition(Object.assign(Object.assign({}, fixtures_js_1.clusterConfig), { operators: [] }));
+        }
+        catch (error) {
+            expect(error.message).toEqual("Schema compilation errors', must NOT have fewer than 4 items");
+        }
+    }));
+    test('validatePayload should throw an error on empty schema', () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            (0, ajv_1.validatePayload)(Object.assign(Object.assign({}, fixtures_js_1.clusterConfig), { operators: [] }), "");
+        }
+        catch (error) {
+            expect(error.message).toEqual("schema must be object or boolean");
+        }
+    }));
+    test('getClusterdefinition should return cluster definition if config hash exist', () => __awaiter(void 0, void 0, void 0, function* () {
+        clientInstance['request'] = jest.fn().mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X7.cluster_definition));
+        const clusterDefinition = yield clientInstance.getClusterDefinition(fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
+        expect(clusterDefinition.config_hash).toEqual(fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
+    }));
+    test('getClusterLock should return lockFile if exist', () => __awaiter(void 0, void 0, void 0, function* () {
+        clientInstance['request'] = jest.fn().mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X7));
+        const clusterLock = yield clientInstance.getClusterLock(fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
+        expect(clusterLock.lock_hash).toEqual(fixtures_js_1.clusterLockV1X7.lock_hash);
+    }));
+    test('request method should set user agent header', () => __awaiter(void 0, void 0, void 0, function* () {
+        const server = (0, node_1.setupServer)(msw_1.http.get('http://testexample.com/test', ({ request }) => {
+            // Check if the request contains specific headers
+            if (request.headers.get('User-Agent') === `Obol-SDK/${constants_1.SDK_VERSION}`) {
+                return msw_1.HttpResponse.json({ message: 'user-agent header exist' });
+            }
+        }));
+        server.listen();
+        class TestBase extends base_1.Base {
+            callProtectedRequest(endpoint, options) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return (yield this.request(endpoint, options));
+                });
+            }
+        }
+        const testBaseInstance = new TestBase({ baseUrl: "http://testExample.com" });
+        const result = yield testBaseInstance.callProtectedRequest('/test', {
+            method: 'GET',
+        });
+        expect(result === null || result === void 0 ? void 0 : result.message).toEqual("user-agent header exist");
+        server.close();
+    }));
+});
+describe('Cluster Client without a signer', () => {
+    const clientInstance = new index_1.Client({ baseUrl: "https://obol-api-dev.gcp.obol.tech", chainId: 5 });
+    test('createClusterDefinition should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield clientInstance.createClusterDefinition(fixtures_js_1.clusterConfig);
+        }
+        catch (err) {
+            expect(err).toEqual("Signer is required in createClusterDefinition");
+        }
+    }));
+    test('acceptClusterDefinition should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield clientInstance.acceptClusterDefinition({ enr: fixtures_js_1.clusterLockV1X7.cluster_definition.operators[0].enr, version: fixtures_js_1.clusterLockV1X7.cluster_definition.version }, fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
+        }
+        catch (err) {
+            expect(err).toEqual("Signer is required in acceptClusterDefinition");
+        }
+    }));
+    test('getClusterdefinition should return cluster definition if config hash exist', () => __awaiter(void 0, void 0, void 0, function* () {
+        clientInstance['request'] = jest.fn().mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X7.cluster_definition));
+        const clusterDefinition = yield clientInstance.getClusterDefinition(fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
+        expect(clusterDefinition.config_hash).toEqual(fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
+    }));
+    test('getClusterLock should return lockFile if exist', () => __awaiter(void 0, void 0, void 0, function* () {
+        clientInstance['request'] = jest.fn().mockReturnValue(Promise.resolve(fixtures_js_1.clusterLockV1X7));
+        const clusterLock = yield clientInstance.getClusterLock(fixtures_js_1.clusterLockV1X7.cluster_definition.config_hash);
+        expect(clusterLock.lock_hash).toEqual(fixtures_js_1.clusterLockV1X7.lock_hash);
+    }));
+    it('should return true on verified the cluster lock', () => __awaiter(void 0, void 0, void 0, function* () {
+        const isValidLock = yield (0, index_1.validateClusterLock)(fixtures_js_1.clusterLockV1X7);
+        expect(isValidLock).toEqual(true);
+    }));
+});

package/dist/esm/src/ajv.js

@@ -0,0 +1,10 @@
+import Ajv from 'ajv';
+export function validatePayload(data, schema) {
+    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;
+}

package/dist/esm/src/base.js

@@ -0,0 +1,35 @@
+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());
+    });
+};
+// src/resources/base.ts
+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 }) {
+        this.baseUrl = baseUrl;
+        this.chainId = chainId;
+        this.fork_version = 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/${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;
+            }
+        });
+    }
+}