@obolnetwork/obol-sdk 1.0.9 → 1.0.12

package/dist/esm/src/verify.js

@@ -0,0 +1,295 @@
+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());
+    });
+};
+import * as semver from 'semver';
+import { init, aggregateSignatures, verifyMultiple, verifyAggregate } from "@chainsafe/bls";
+import { ENR } from '@chainsafe/discv5';
+import { ByteVectorType, ContainerType, fromHexString } from '@chainsafe/ssz';
+import { UintNumberType } from '@chainsafe/ssz/lib/type/uint.js';
+import { SignTypedDataVersion, TypedDataUtils, } from '@metamask/eth-sig-util';
+import elliptic from 'elliptic';
+import { ethers } from 'ethers';
+import { FORK_MAPPING } from "./types.js";
+import { clusterConfigOrDefinitionHash, clusterLockHash } from './hash.js';
+import { DOMAIN_APPLICATION_BUILDER, DOMAIN_DEPOSIT, DefinitionFlow, GENESIS_VALIDATOR_ROOT, signCreatorConfigHashPayload, signEnrPayload, signOperatorConfigHashPayload } from './constants.js';
+import { hexWithout0x } from './utils.js';
+const builderRegistrationMessageType = new ContainerType({
+    fee_recipient: new ByteVectorType(20),
+    gas_limit: new UintNumberType(8),
+    timestamp: new UintNumberType(8),
+    pubkey: new ByteVectorType(48),
+});
+//For domain computation that is used in deposit data and builder registration verification for dv
+const forkDataType = new ContainerType({
+    currentVersion: new ByteVectorType(4),
+    genesisValidatorsRoot: new ByteVectorType(32),
+});
+const depositMessageType = new ContainerType({
+    pubkey: new ByteVectorType(48),
+    withdrawal_credentials: new ByteVectorType(32),
+    amount: new UintNumberType(8),
+});
+const signingRootType = new ContainerType({
+    objectRoot: new ByteVectorType(32),
+    domain: new 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 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;
+};
+//cluster-definition signatures verificatin
+const getPOSTConfigHashSigner = (signature, configHash, chainId) => {
+    try {
+        const sig = ethers.Signature.from(signature);
+        const data = signCreatorConfigHashPayload({ creator_config_hash: configHash }, chainId);
+        const digest = TypedDataUtils.eip712Hash(data, SignTypedDataVersion.V4);
+        return ethers.recoverAddress(digest, sig).toLowerCase();
+    }
+    catch (err) {
+        throw err;
+    }
+};
+const getPUTConfigHashSigner = (signature, configHash, chainId) => {
+    try {
+        const sig = ethers.Signature.from(signature);
+        const data = signOperatorConfigHashPayload({ operator_config_hash: configHash }, chainId);
+        const digest = TypedDataUtils.eip712Hash(data, SignTypedDataVersion.V4);
+        return ethers.recoverAddress(digest, sig).toLowerCase();
+    }
+    catch (err) {
+        throw err;
+    }
+};
+const getEnrSigner = (signature, payload, chainId) => {
+    try {
+        const sig = ethers.Signature.from(signature);
+        const data = signEnrPayload({ enr: payload }, chainId);
+        const digest = TypedDataUtils.eip712Hash(data, SignTypedDataVersion.V4);
+        return 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, 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, FORK_MAPPING[clusterDefinition.fork_version]);
+            const enrSigner = getEnrSigner(operator.enr_signature, operator.enr, 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 = fromHexString(msg.pubkey);
+    depositMsgVal.withdrawal_credentials = 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 = fromHexString(msg.fee_recipient);
+    builderRegistrationMsgVal.gas_limit = msg.gas_limit;
+    builderRegistrationMsgVal.timestamp = msg.timestamp;
+    builderRegistrationMsgVal.pubkey = fromHexString(msg.pubkey);
+    return Buffer.from(builderRegistrationMessageType.hashTreeRoot(builderRegistrationMsgVal)
+        .buffer);
+};
+// DV data verification
+const computeDomain = (domainType, lockForkVersion, genesisValidatorsRoot = fromHexString(GENESIS_VALIDATOR_ROOT)) => {
+    const forkVersion = 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;
+};
+export const signingRoot = (domain, messageBuffer) => {
+    return computeSigningRoot(messageBuffer, domain);
+};
+const verifyLockData = (clusterLock) => __awaiter(void 0, void 0, void 0, function* () {
+    const ec = new elliptic.ec('secp256k1');
+    const validators = clusterLock.distributed_validators;
+    const nodeSignatures = clusterLock.node_signatures;
+    const depositDomain = computeDomain(fromHexString(DOMAIN_DEPOSIT), clusterLock.cluster_definition.fork_version);
+    const builderDomain = computeDomain(fromHexString(DOMAIN_APPLICATION_BUILDER), clusterLock.cluster_definition.fork_version);
+    const pubShares = [];
+    const pubKeys = [];
+    const builderRegistrationAndDepositDataMessages = [];
+    const blsSignatures = [];
+    yield 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(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 = signingRoot(depositDomain, depositMessageBuffer);
+            pubKeys.push(fromHexString(validator.distributed_public_key));
+            builderRegistrationAndDepositDataMessages.push(depositDataMessage);
+            blsSignatures.push(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 = signingRoot(builderDomain, builderRegistrationMessageBuffer);
+            pubKeys.push(fromHexString(validator.distributed_public_key));
+            builderRegistrationAndDepositDataMessages.push(builderRegistrationMessage);
+            blsSignatures.push(fromHexString(validator.builder_registration.signature));
+        }
+    }
+    if (blsSignatures.length &&
+        pubKeys.length &&
+        builderRegistrationAndDepositDataMessages.length) {
+        // verify all deposit data and builder registration bls signatures
+        const aggregateBLSSignature = aggregateSignatures(blsSignatures);
+        if (!verifyMultiple(pubKeys, builderRegistrationAndDepositDataMessages, aggregateBLSSignature)) {
+            return false;
+        }
+    }
+    if (semver.gte(clusterLock.cluster_definition.version, 'v1.7.0')) {
+        const lockHashWithout0x = hexWithout0x(clusterLock.lock_hash);
+        //node(ENR) signatures
+        for (let i = 0; i < nodeSignatures.length; i++) {
+            const pubkey = 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 (!verifyAggregate(pubShares, fromHexString(clusterLock.lock_hash), fromHexString(clusterLock.signature_aggregate))) {
+        return false;
+    }
+    return true;
+});
+export 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 (clusterConfigOrDefinitionHash(clusterLock.cluster_definition, false) !==
+            clusterLock.cluster_definition.definition_hash) {
+            return false;
+        }
+        if (clusterLockHash(clusterLock) !== clusterLock.lock_hash) {
+            return false;
+        }
+        const isValidLockData = yield verifyLockData(clusterLock);
+        if (!isValidLockData) {
+            return false;
+        }
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
+});

package/dist/esm/test/fixtures.js

@@ -0,0 +1,98 @@
+export const 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"
+    ]
+};
+export const clusterConfig = {
+    name: "testSDK",
+    operators: [
+        { address: "0xC35CfCd67b9C27345a54EDEcC1033F2284148c81" },
+        { address: "0x33807D6F1DCe44b9C599fFE03640762A6F08C496" },
+        { address: "0xc6e76F72Ea672FAe05C357157CfC37720F0aF26f" },
+        { address: "0x86B8145c98e5BD25BA722645b15eD65f024a87EC" }
+    ],
+    validators: [{
+            fee_recipient_address: "0x3CD4958e76C317abcEA19faDd076348808424F99",
+            withdrawal_address: "0xE0C5ceA4D3869F156717C66E188Ae81C80914a6e"
+        }],
+};

package/dist/esm/test/methods.test.js

@@ -0,0 +1,126 @@
+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());
+    });
+};
+import { ethers } from 'ethers';
+import { Client, validateClusterLock } from '../src/index';
+import { clusterConfig, clusterLockV1X7 } from './fixtures.js';
+import { SDK_VERSION } from '../src/constants';
+import { Base } from '../src/base';
+import { validatePayload } from '../src/ajv';
+import { HttpResponse, http } from 'msw';
+import { setupServer } from 'msw/node';
+describe('Cluster Client', () => {
+    var _a;
+    const mockConfigHash = "0x1f6c94e6c070393a68c1aa6073a21cb1fd57f0e14d2a475a2958990ab728c2fd";
+    const mnemonic = ((_a = ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) || "";
+    const privateKey = ethers.Wallet.fromPhrase(mnemonic).privateKey;
+    const wallet = new ethers.Wallet(privateKey);
+    const mockSigner = wallet.connect(null);
+    const clientInstance = new 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 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(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(clusterLockV1X7.cluster_definition));
+        const clusterDefinition = yield clientInstance.acceptClusterDefinition({ enr: clusterLockV1X7.cluster_definition.operators[0].enr, version: clusterLockV1X7.cluster_definition.version }, clusterLockV1X7.cluster_definition.config_hash);
+        expect(clusterDefinition).toEqual(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({}, 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 {
+            validatePayload(Object.assign(Object.assign({}, 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(clusterLockV1X7.cluster_definition));
+        const clusterDefinition = yield clientInstance.getClusterDefinition(clusterLockV1X7.cluster_definition.config_hash);
+        expect(clusterDefinition.config_hash).toEqual(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(clusterLockV1X7));
+        const clusterLock = yield clientInstance.getClusterLock(clusterLockV1X7.cluster_definition.config_hash);
+        expect(clusterLock.lock_hash).toEqual(clusterLockV1X7.lock_hash);
+    }));
+    test('request method should set user agent header', () => __awaiter(void 0, void 0, void 0, function* () {
+        const server = setupServer(http.get('http://testexample.com/test', ({ request }) => {
+            // Check if the request contains specific headers
+            if (request.headers.get('User-Agent') === `Obol-SDK/${SDK_VERSION}`) {
+                return HttpResponse.json({ message: 'user-agent header exist' });
+            }
+        }));
+        server.listen();
+        class TestBase extends 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 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(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: clusterLockV1X7.cluster_definition.operators[0].enr, version: clusterLockV1X7.cluster_definition.version }, 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(clusterLockV1X7.cluster_definition));
+        const clusterDefinition = yield clientInstance.getClusterDefinition(clusterLockV1X7.cluster_definition.config_hash);
+        expect(clusterDefinition.config_hash).toEqual(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(clusterLockV1X7));
+        const clusterLock = yield clientInstance.getClusterLock(clusterLockV1X7.cluster_definition.config_hash);
+        expect(clusterLock.lock_hash).toEqual(clusterLockV1X7.lock_hash);
+    }));
+    it('should return true on verified the cluster lock', () => __awaiter(void 0, void 0, void 0, function* () {
+        const isValidLock = yield validateClusterLock(clusterLockV1X7);
+        expect(isValidLock).toEqual(true);
+    }));
+});

package/dist/{ajv.d.ts → types/src/ajv.d.ts}

@@ -1,3 +1,2 @@
-import { ErrorObject } from 'ajv';
-export declare function validatePayload(data: any, schema: any): ErrorObject[] | undefined | null | boolean;
-//# sourceMappingURL=ajv.d.ts.map
+import { ErrorObject } from 'ajv';
+export declare function validatePayload(data: any, schema: any): ErrorObject[] | undefined | null | boolean;

package/dist/{base.d.ts → types/src/base.d.ts}

@@ -1,14 +1,13 @@
-import { FORK_MAPPING } from './types';
-declare type Config = {
-    baseUrl?: string;
-    chainId?: FORK_MAPPING;
-};
-export declare abstract class Base {
-    baseUrl: string;
-    chainId: number;
-    fork_version: string;
-    constructor({ baseUrl, chainId }: Config);
-    protected request<T>(endpoint: string, options?: RequestInit): Promise<T>;
-}
-export {};
-//# sourceMappingURL=base.d.ts.map
+import { FORK_MAPPING } from './types.js';
+type Config = {
+    baseUrl?: string;
+    chainId?: FORK_MAPPING;
+};
+export declare abstract class Base {
+    baseUrl: string;
+    chainId: number;
+    fork_version: string;
+    constructor({ baseUrl, chainId }: Config);
+    protected request<T>(endpoint: string, options?: RequestInit): Promise<T>;
+}
+export {};

package/dist/types/src/constants.d.ts

@@ -0,0 +1,79 @@
+import { TypedMessage } from "@metamask/eth-sig-util";
+export declare const CONFLICT_ERROR_MSG = "Conflict";
+export declare const EIP712_DOMAIN_NAME = "Obol";
+export declare const EIP712_DOMAIN_VERSION = "1";
+export declare const CreatorConfigHashSigningTypes: {
+    CreatorConfigHash: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const Domain: (chainId: number) => {
+    name: string;
+    version: string;
+    chainId: number;
+};
+export declare const CreatorTypedMessage: {
+    CreatorConfigHash: {
+        name: string;
+        type: string;
+    }[];
+    EIP712Domain: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const EnrSigningTypes: {
+    ENR: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const OperatorConfigHashSigningTypes: {
+    OperatorConfigHash: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const OperatorTypedMessage: {
+    OperatorConfigHash: {
+        name: string;
+        type: string;
+    }[];
+    EIP712Domain: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const ENRTypedMessage: {
+    ENR: {
+        name: string;
+        type: string;
+    }[];
+    EIP712Domain: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare const signCreatorConfigHashPayload: (payload: {
+    creator_config_hash: string;
+}, chainId: number) => TypedMessage<typeof CreatorTypedMessage>;
+export declare const signOperatorConfigHashPayload: (payload: {
+    operator_config_hash: string;
+}, chainId: number) => TypedMessage<typeof OperatorTypedMessage>;
+export declare const signEnrPayload: (payload: {
+    enr: string;
+}, chainId: number) => TypedMessage<typeof ENRTypedMessage>;
+export declare const dkg_algorithm = "default";
+export declare const config_version = "v1.7.0";
+export declare const SDK_VERSION = "1.0.7";
+export declare const DOMAIN_APPLICATION_BUILDER = "00000001";
+export declare const DOMAIN_DEPOSIT = "03000000";
+export declare const GENESIS_VALIDATOR_ROOT = "0000000000000000000000000000000000000000000000000000000000000000";
+export declare enum DefinitionFlow {
+    Group = "LP-Group",
+    Solo = "LP-Solo",
+    Charon = "Charon-Command"
+}
+export declare const DEFAULT_BASE_URL = "https://api.obol.tech";
+export declare const DEFAULT_CHAIN_ID = 1;

package/dist/{errors.d.ts → types/src/errors.d.ts}

@@ -1,5 +1,4 @@
-export declare class ConflictError extends Error {
-    name: string;
-    constructor();
-}
-//# sourceMappingURL=errors.d.ts.map
+export declare class ConflictError extends Error {
+    name: string;
+    constructor();
+}