@obolnetwork/obol-sdk 2.1.2 → 2.2.1

package/dist/esm/src/utils.js

@@ -7,7 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { DefinitionFlow } from './constants';
+import { ethers } from 'ethers';
+import { DefinitionFlow, PROVIDER_MAP } from './constants';
+import { FORK_NAMES } from './types';
 export const hexWithout0x = (hex) => {
     return hex.slice(2, hex.length);
 };
@@ -57,3 +59,10 @@ export const isContractAvailable = (contractAddress, provider, bytecode) => __aw
     }
     return !!code && code !== '0x' && code !== '0x0';
 });
+export const getProvider = (chainId) => {
+    const rpcUrl = PROVIDER_MAP[chainId];
+    if (!rpcUrl) {
+        throw new Error(`No provider configured for ${FORK_NAMES[chainId]}`);
+    }
+    return new ethers.JsonRpcProvider(rpcUrl);
+};

package/dist/esm/src/verification/common.js

@@ -14,13 +14,12 @@ import { FORK_MAPPING, } from '../types.js';
 import * as semver from 'semver';
 import { clusterDefinitionContainerTypeV1X6, hashClusterDefinitionV1X6, hashClusterLockV1X6, verifyDVV1X6, } from './v1.6.0.js';
 import { clusterDefinitionContainerTypeV1X7, hashClusterDefinitionV1X7, hashClusterLockV1X7, verifyDVV1X7, } from './v1.7.0.js';
-import { ethers } from 'ethers';
 import { DOMAIN_APPLICATION_BUILDER, DOMAIN_DEPOSIT, DefinitionFlow, GENESIS_VALIDATOR_ROOT, signCreatorConfigHashPayload, signEnrPayload, signOperatorConfigHashPayload, } from '../constants.js';
-import { SignTypedDataVersion, TypedDataUtils } from '@metamask/eth-sig-util';
 import { builderRegistrationMessageType, depositMessageType, forkDataType, signingRootType, } from './sszTypes.js';
 import { definitionFlow, hexWithout0x } from '../utils.js';
 import { ENR } from '@chainsafe/discv5';
 import { clusterDefinitionContainerTypeV1X8, hashClusterDefinitionV1X8, hashClusterLockV1X8, verifyDVV1X8, } from './v1.8.0.js';
+import { validateAddressSignature } from './signature-validator.js';
 // cluster-definition hash
 /**
  * @param cluster The cluster configuration or the cluster definition
@@ -78,62 +77,70 @@ export const clusterLockHash = (clusterLock) => {
 };
 // Lock verification
 // cluster-definition signatures verification
-const getPOSTConfigHashSigner = (signature, configHash, chainId) => {
+const validatePOSTConfigHashSigner = (address, signature, configHash, chainId) => __awaiter(void 0, void 0, void 0, function* () {
     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();
+        return yield validateAddressSignature({
+            address,
+            token: signature,
+            data,
+            chainId,
+        });
     }
     catch (err) {
         throw err;
     }
-};
-const getPUTConfigHashSigner = (signature, configHash, chainId) => {
+});
+const validatePUTConfigHashSigner = (address, signature, configHash, chainId) => __awaiter(void 0, void 0, void 0, function* () {
     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();
+        return yield validateAddressSignature({
+            address,
+            token: signature,
+            data,
+            chainId,
+        });
     }
     catch (err) {
         throw err;
     }
-};
-const getEnrSigner = (signature, payload, chainId) => {
+});
+const validateEnrSigner = (address, signature, payload, chainId) => __awaiter(void 0, void 0, void 0, function* () {
     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();
+        return yield validateAddressSignature({
+            address,
+            token: signature,
+            data,
+            chainId,
+        });
     }
     catch (err) {
         throw err;
     }
-};
-const verifyDefinitionSignatures = (clusterDefinition, definitionType) => {
+});
+const verifyDefinitionSignatures = (clusterDefinition, definitionType) => __awaiter(void 0, void 0, void 0, function* () {
     if (definitionType === DefinitionFlow.Charon) {
         return true;
     }
     else {
-        const configSigner = getPOSTConfigHashSigner(clusterDefinition.creator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version]);
-        if (configSigner !== clusterDefinition.creator.address.toLowerCase()) {
+        const isPOSTConfigHashSignerValid = yield validatePOSTConfigHashSigner(clusterDefinition.creator.address, clusterDefinition.creator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version]);
+        if (!isPOSTConfigHashSignerValid) {
             return false;
         }
         if (definitionType === DefinitionFlow.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()) {
+        for (const operator of clusterDefinition.operators) {
+            const isPUTConfigHashSignerValid = yield validatePUTConfigHashSigner(operator.address, operator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version]);
+            const isENRSignerValid = yield validateEnrSigner(operator.address, operator.enr_signature, operator.enr, FORK_MAPPING[clusterDefinition.fork_version]);
+            if (!isPUTConfigHashSignerValid || !isENRSignerValid) {
                 return false;
             }
-            return true;
-        });
+        }
+        return true;
     }
-};
+});
 // cluster-lock data verification
 const computeSigningRoot = (sszObjectRoot, domain) => {
     const signingRootDefaultValue = signingRootType.defaultValue();
@@ -260,7 +267,7 @@ export const isValidClusterLock = (clusterLock) => __awaiter(void 0, void 0, voi
         if (definitionType == null) {
             return false;
         }
-        const isValidDefinitionData = verifyDefinitionSignatures(clusterLock.cluster_definition, definitionType);
+        const isValidDefinitionData = yield verifyDefinitionSignatures(clusterLock.cluster_definition, definitionType);
         if (!isValidDefinitionData) {
             return false;
         }

package/dist/esm/src/verification/signature-validator.js

@@ -0,0 +1,63 @@
+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());
+    });
+};
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+import { ethers } from 'ethers';
+import { SignTypedDataVersion, TypedDataUtils, } from '@metamask/eth-sig-util';
+import Safe from '@safe-global/protocol-kit';
+import { PROVIDER_MAP } from '../constants';
+import { hashTypedData } from '@safe-global/protocol-kit/dist/src/utils';
+import { isContractAvailable, getProvider } from '../utils';
+export const validateAddressSignature = ({ address, token, data, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const provider = getProvider(chainId);
+        if (provider) {
+            const contractAddress = yield isContractAvailable(address, provider);
+            if (contractAddress) {
+                return yield validateSmartContractSignature({
+                    token,
+                    data: data,
+                    address,
+                    chainId,
+                });
+            }
+        }
+        return validateEOASignature({ token, data, address });
+    }
+    catch (error) {
+        return validateEOASignature({ token, data, address });
+    }
+});
+export const validateEOASignature = ({ token, data, address, }) => {
+    try {
+        const sig = ethers.Signature.from(token);
+        const digest = TypedDataUtils.eip712Hash(data, SignTypedDataVersion.V4);
+        return (ethers.recoverAddress(digest, sig).toLowerCase() ===
+            address.toLocaleLowerCase());
+    }
+    catch (err) {
+        console.error(`validate EOA Signature error: ${err}`);
+        throw err;
+    }
+};
+export const validateSmartContractSignature = ({ token, data, address, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const provider = PROVIDER_MAP[chainId];
+        const protocolKit = yield Safe.init({
+            provider,
+            safeAddress: address,
+        });
+        const messageHash = hashTypedData(data);
+        const isValidSignature = yield protocolKit.isValidSignature(messageHash, token);
+        return isValidSignature;
+    }
+    catch (err) {
+        throw new Error(`Error validating smart contract signature: ${err.message}`);
+    }
+});

package/dist/esm/test/fixtures.js

@@ -420,3 +420,90 @@ export const nullDepositAmountsClusterLockV1X8 = {
         '0xdb6332a4ca9c41592511e7480c835b449fea120430e759735f3c24f1a6d496551a516151d2baae21d0cc9469b28dc1122b672af40ebb0e77045da92e0da6a03500',
     ],
 };
+export const clusterLockWithSafe = {
+    cluster_definition: {
+        name: 'Rainy cluster',
+        creator: {
+            address: '0xEF43Ff87070247EC9D28B482D6474318e9DAFc98',
+            config_signature: '0x0c4aaafcef722cf770b419d47a21571b3c73275185a1b719e5709168af6327eb2ee392134e660d6e4ea113abd184dd4f2bd8ee09a4ae33f434433f7575873b981c',
+        },
+        operators: [
+            {
+                address: '0xe5b709A14859EdF820347D78E587b1634B0ec771',
+                enr: 'enr:-HW4QGrhMVQGLtKv_KlubzcVZM9AUsSVgDPtq4k_0q344ZtWJ6tD4riMP5jfWXXdHIklAm_pHdQv0MbTE1DrXmuEM7yAgmlkgnY0iXNlY3AyNTZrMaECa_cfUuFYiuFQp_dUEEicCBdFWNfzm8QhrNhBwey8PBg',
+                config_signature: '0xad813cd706d7469b560570ef13b0afdf36d0637e9bc5362ec358c218085d9b231b1377f0078e1ed9c2af99fddb3d7608c03bf8aee6edc931c73d7204a7fdee181b',
+                enr_signature: '0x304c022e74c13bfd492219efc52fb133f728afa01fefa9fe1d2540ce7c23ca730dd8248b0ad76630dd120975085d77fba20c050620f1e9583590d003110dbca41c',
+            },
+            {
+                address: '0x83b7CA5be230A50DEE511657CCFF262ba04D0353',
+                enr: 'enr:-HW4QNGbmr_0YhIeTUQfljlDGGCnR8RGhtWr_gjMI8a5BwigGur2qFgGZrqSumAvk4gX9ciP2Tu74uOdOZPw6nvTi7aAgmlkgnY0iXNlY3AyNTZrMaEC0nrshQsWtEOphaLrZVTzPFOz8EAJweGbhXDtSsXPiLY',
+                config_signature: '0x41dfb02ff13775d53ad3f739151c44952ff98a3283d124b6f69782e7458150e92771e32f965803391818d23ad95c9c7bcba15e896c3a576d1a700a16d8cb29fe1b',
+                enr_signature: '0x388460abfdeded56839e4ae1480ea48a70ac44a89963bda24152e4f879a9d22918c3e77733f2ccaed5c2745f503565d651a357c6a50634a597d61e16c384961e1c',
+            },
+            {
+                address: '0x123C1cD7AeE10b525D09b848D4A62596958f7D9C',
+                enr: 'enr:-HW4QMpDdYHJR3TlnWsnuIKfbmg2aRMMcAFlhTuuZa0Grd3dMFC0AEPHvHM2cKboULC4RUl2Dz7-LpwL2EJRGhJzxcyAgmlkgnY0iXNlY3AyNTZrMaEC73iR5dcgO_bJ8tvsHLrFglwspGFhaAbiBtGAHAJPD9c',
+                config_signature: '0x91d23aefc02263fdf0edd0dcfdf26eee01c4d673b97a91a099fc10dfc01f55fa690eccc809658ea2ed17383df355f80a62bd96df15e40a2e2f740189fa6537f61b',
+                enr_signature: '0x1035b284df3b1d60434bfe2d139f1472ed29663e2af719779bb5da35537f202032ab0f7cdc540c724c8e80bedfba247809d741260201fbb5bcbfc7f0813334241b',
+            },
+            {
+                address: '0x169212AE1A834C1E0efd8C827Abdbc2b5557B86C', // safe address
+                enr: 'enr:-HW4QPwheIq51G9r9k-6GYrhp9-y-hN2SSowqgQemvPyBu9cOKERqPeqy0JuZ0yKyWiji406eK8fFeHX5fKU-6OI3u6AgmlkgnY0iXNlY3AyNTZrMaECaARWVFt5KNkHPno5YYdFBUrkLU5EmOB3K0Ns9hp-s-s',
+                config_signature: '0xf97cc2536afe96e43e07aac140254cea37b0345573b12476f8840e571095d72049aa9e03a099ef2965523f83648c4323cd16ec2ee3f5e6efac177da13bcf6eb21c',
+                enr_signature: '0x422f471d54eb19fc52e076bb11fd5c8de895734ed111b66708ef805ae124f87b7519e841e59eccdb75c8328223efd8bb324f3fd7d3048f037419bb83e03caae41b',
+            },
+        ],
+        uuid: '3ac43657-b465-49a8-94aa-25b7f7979c2a',
+        version: 'v1.8.0',
+        timestamp: '2025-01-08T15:18:28.598Z',
+        num_validators: 1,
+        threshold: 3,
+        validators: [
+            {
+                fee_recipient_address: '0xe5b709A14859EdF820347D78E587b1634B0ec771',
+                withdrawal_address: '0xe5b709A14859EdF820347D78E587b1634B0ec771',
+            },
+        ],
+        dkg_algorithm: 'default',
+        fork_version: '0x01017000',
+        deposit_amounts: ['32000000000'],
+        config_hash: '0x1849d9434a5ce7a7d15e1e030a48740a307c80424608c6618386d78a2e597fb3',
+        definition_hash: '0x85dabfcebf9bf850521cdb65ea6083c462d9ac57eb62d9a9eb47761ec10bc80e',
+    },
+    distributed_validators: [
+        {
+            distributed_public_key: '0xb0427b57f3f31da882a1ca5d9980e6164ba4c4d3e2c35fb6699f4e76d88e1aede881e0bdb87c48ac707da282f0c92e92',
+            public_shares: [
+                '0x8d150f921a54fe258bb57f568288de87e392946124df65861afbe52d2a3be6a1fa09d19beb62f879b0f18b2e3b26f69f',
+                '0x8fa69ec7c31eeda66007bc3d49a3d5654dbe6a3c0890898ea5913ed263a0efc3f6744064dbde3ee0cc1d2f08db33b4d7',
+                '0xb862933b7b7adb33cfb3de1052f7dd9e45dfa30accda01dfc4d3c38716747504aade8f832fa5a256dcaf13f80dbbb38f',
+                '0xb5a15d86945c7ff38e0b09158a3264033e6dbaebf2ec9f3426988e6d24e38b3dbd6fe413d3253b308404bb691757fb2e',
+            ],
+            builder_registration: {
+                message: {
+                    fee_recipient: '0xe5b709a14859edf820347d78e587b1634b0ec771',
+                    gas_limit: 30000000,
+                    timestamp: 1696000704,
+                    pubkey: '0xb0427b57f3f31da882a1ca5d9980e6164ba4c4d3e2c35fb6699f4e76d88e1aede881e0bdb87c48ac707da282f0c92e92',
+                },
+                signature: '0xa5e4220e7d8e7fd4430590c70a27104473b15c8ea03b2d1571bc86bbbcb443e2b7467f75a7e77b5d9b1a10d5fbc335cf0d59c3b3bc1b6d036b2e22511abcf41373567a15185f011ce0129741f0ae0e9e49759f9c5c0ce62f2a99f30e8c7df996',
+            },
+            partial_deposit_data: [
+                {
+                    pubkey: '0xb0427b57f3f31da882a1ca5d9980e6164ba4c4d3e2c35fb6699f4e76d88e1aede881e0bdb87c48ac707da282f0c92e92',
+                    withdrawal_credentials: '0x010000000000000000000000e5b709a14859edf820347d78e587b1634b0ec771',
+                    amount: '32000000000',
+                    signature: '0x90aff3cb35c577644cb5fe3036ae8aeb5ac6cc2ce2a33a4332e2e883dc48f8fb71165531862d3035a4b6e3a60215d661021672a59f9406e3bd04b5f88f4f77c5f54a9ff37167807010123cdcc230040e5a485b5eb36704fd276dbf541f7151a8',
+                },
+            ],
+        },
+    ],
+    signature_aggregate: '0x86fdeae3db45215d5f24fc19645f8f95e91fffd1a1d0a87668d3f27724fa735b85fb15de120106b8463ff1d32823813e0f139ee7cb6d3b026c6b81cc96566819817742a13e24ac44fc6571385d5b0fdbaace7e50e2cfbcd692e36b1ca25436e4',
+    lock_hash: '0xe03b0fdf6d6a7d38360b0ceac1f0380b051f710e80d0e166b855ef3148d46733',
+    node_signatures: [
+        '0x564328bcad4cac498aa51b7e7e041cf264e9c65c95138df1fc00d4bf714bc38419c43b5a32662d5c8b747d646d6e77830b2bfd62fa8402e136147c244acdce0300',
+        '0xb0e984efd2874fc4bc97bb9c42dccbc723080cf29a20a3cf0b05867ebe87bc430c29a560936000439fcde610ce91452ced763586d3bcca24fbe4fe83bb39202601',
+        '0xf3633a8e59db2e8d253ffe1b284f9edab1c1c1aca6288c3a3b2e9cb4eb7e789e23366fc325274f13b7311b9faf53665c80b5cb1f93810713f7b094cd2bec1d9900',
+        '0x4067921a5257efe4ceb103f2129faaa7a502781157b3b54e5efca559c558c2b43b89f30962e87df88fbf62250049a31888fcd62735d54b7553e5dc75c3b6ae0901',
+    ],
+};

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

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { ethers, JsonRpcProvider } from 'ethers';
 import { Client, validateClusterLock } from '../src/index';
-import { clusterConfigV1X7, clusterConfigV1X8, clusterLockV1X6, clusterLockV1X7, clusterLockV1X8, nullDepositAmountsClusterLockV1X8, } from './fixtures.js';
+import { clusterConfigV1X7, clusterConfigV1X8, clusterLockV1X6, clusterLockV1X7, clusterLockV1X8, clusterLockWithSafe, nullDepositAmountsClusterLockV1X8, } from './fixtures.js';
 import { SDK_VERSION } from '../src/constants';
 import { Base } from '../src/base';
 import { validatePayload } from '../src/ajv';
@@ -18,6 +18,7 @@ import { setupServer } from 'msw/node';
 import { hashTermsAndConditions } from '../src/verification/termsAndConditions';
 import * as utils from '../src/utils';
 import * as splitsHelpers from '../src/splitHelpers';
+jest.setTimeout(20000);
 /* eslint no-new: 0 */
 describe('Cluster Client', () => {
     var _a, _b;
@@ -136,6 +137,9 @@ describe('Cluster Client without a signer', () => {
         baseUrl: 'https://obol-api-dev.gcp.obol.tech',
         chainId: 17000,
     });
+    beforeAll(() => {
+        jest.restoreAllMocks();
+    });
     test('createClusterDefinition should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
         try {
             yield clientInstance.createClusterDefinition(clusterConfigV1X8);
@@ -177,6 +181,10 @@ describe('Cluster Client without a signer', () => {
             version: 'null deposit_amounts v1.8.0',
             clusterLock: nullDepositAmountsClusterLockV1X8,
         },
+        {
+            version: 'Cluster with safe address v1.8.0',
+            clusterLock: clusterLockWithSafe,
+        },
     ])("$version: 'should return true on verified cluster lock'", ({ clusterLock }) => __awaiter(void 0, void 0, void 0, function* () {
         const isValidLock = yield validateClusterLock(clusterLock);
         expect(isValidLock).toEqual(true);
@@ -195,37 +203,40 @@ describe('Cluster Client without a signer', () => {
     }));
 });
 describe('createObolRewardsSplit', () => {
-    var _a, _b;
-    jest
-        .spyOn(utils, 'isContractAvailable')
-        .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-    jest
-        .spyOn(splitsHelpers, 'predictSplitterAddress')
-        .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xPredictedAddress'); }));
-    jest.spyOn(splitsHelpers, 'handleDeployOWRAndSplitter').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
-        return yield Promise.resolve({
-            withdrawal_address: '0xWithdrawalAddress',
-            fee_recipient_address: '0xFeeRecipientAddress',
+    let clientInstance, clientInstanceWithourSigner, mockSplitRecipients, mockPrincipalRecipient, mockEtherAmount, mockSigner;
+    beforeAll(() => {
+        var _a, _b;
+        jest
+            .spyOn(utils, 'isContractAvailable')
+            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
+        jest
+            .spyOn(splitsHelpers, 'predictSplitterAddress')
+            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xPredictedAddress'); }));
+        jest.spyOn(splitsHelpers, 'handleDeployOWRAndSplitter').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
+            return yield Promise.resolve({
+                withdrawal_address: '0xWithdrawalAddress',
+                fee_recipient_address: '0xFeeRecipientAddress',
+            });
+        }));
+        const mnemonic = (_b = (_a = ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) !== null && _b !== void 0 ? _b : '';
+        const privateKey = ethers.Wallet.fromPhrase(mnemonic).privateKey;
+        const provider = new JsonRpcProvider('https://ethereum-holesky.publicnode.com');
+        const wallet = new ethers.Wallet(privateKey, provider);
+        mockSigner = wallet.connect(provider);
+        clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
+        clientInstanceWithourSigner = new Client({
+            baseUrl: 'https://obol-api-dev.gcp.obol.tech',
+            chainId: 17000,
         });
-    }));
-    const mnemonic = (_b = (_a = ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) !== null && _b !== void 0 ? _b : '';
-    const privateKey = ethers.Wallet.fromPhrase(mnemonic).privateKey;
-    const provider = new JsonRpcProvider('https://ethereum-holesky.publicnode.com');
-    const wallet = new ethers.Wallet(privateKey, provider);
-    const mockSigner = wallet.connect(provider);
-    const clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
-    const clientInstanceWithourSigner = new Client({
-        baseUrl: 'https://obol-api-dev.gcp.obol.tech',
-        chainId: 17000,
+        mockSplitRecipients = [
+            {
+                account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
+                percentAllocation: 99,
+            },
+        ];
+        mockPrincipalRecipient = '0x86B8145c98e5BD25BA722645b15eD65f024a87EC';
+        mockEtherAmount = 64;
     });
-    const mockSplitRecipients = [
-        {
-            account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
-            percentAllocation: 99,
-        },
-    ];
-    const mockPrincipalRecipient = '0x86B8145c98e5BD25BA722645b15eD65f024a87EC';
-    const mockEtherAmount = 64;
     it('should throw an error if signer is not defined', () => __awaiter(void 0, void 0, void 0, function* () {
         yield expect(clientInstanceWithourSigner.createObolRewardsSplit({
             splitRecipients: mockSplitRecipients,
@@ -289,32 +300,35 @@ describe('createObolRewardsSplit', () => {
     }));
 });
 describe('createObolTotalSplit', () => {
-    var _a, _b;
-    jest
-        .spyOn(utils, 'isContractAvailable')
-        .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-    jest
-        .spyOn(splitsHelpers, 'predictSplitterAddress')
-        .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xPredictedAddress'); }));
-    jest
-        .spyOn(splitsHelpers, 'deploySplitterContract')
-        .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xSplitterAddress'); }));
-    const mnemonic = (_b = (_a = ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) !== null && _b !== void 0 ? _b : '';
-    const privateKey = ethers.Wallet.fromPhrase(mnemonic).privateKey;
-    const provider = new JsonRpcProvider('https://ethereum-holesky.publicnode.com');
-    const wallet = new ethers.Wallet(privateKey, provider);
-    const mockSigner = wallet.connect(provider);
-    const clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
-    const clientInstanceWithourSigner = new Client({
-        baseUrl: 'https://obol-api-dev.gcp.obol.tech',
-        chainId: 17000,
+    let clientInstanceWithourSigner, mockSplitRecipients, mockSigner, clientInstance;
+    beforeAll(() => {
+        var _a, _b;
+        jest
+            .spyOn(utils, 'isContractAvailable')
+            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
+        jest
+            .spyOn(splitsHelpers, 'predictSplitterAddress')
+            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xPredictedAddress'); }));
+        jest
+            .spyOn(splitsHelpers, 'deploySplitterContract')
+            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xSplitterAddress'); }));
+        const mnemonic = (_b = (_a = ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) !== null && _b !== void 0 ? _b : '';
+        const privateKey = ethers.Wallet.fromPhrase(mnemonic).privateKey;
+        const provider = new JsonRpcProvider('https://ethereum-holesky.publicnode.com');
+        const wallet = new ethers.Wallet(privateKey, provider);
+        mockSigner = wallet.connect(provider);
+        clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
+        clientInstanceWithourSigner = new Client({
+            baseUrl: 'https://obol-api-dev.gcp.obol.tech',
+            chainId: 17000,
+        });
+        mockSplitRecipients = [
+            {
+                account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
+                percentAllocation: 99.9,
+            },
+        ];
     });
-    const mockSplitRecipients = [
-        {
-            account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
-            percentAllocation: 99.9,
-        },
-    ];
     it('should throw an error if signer is not defined', () => __awaiter(void 0, void 0, void 0, function* () {
         yield expect(clientInstanceWithourSigner.createObolTotalSplit({
             splitRecipients: mockSplitRecipients,

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

@@ -110,3 +110,4 @@ export declare const CHAIN_CONFIGURATION: {
 export declare const DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT = 1;
 export declare const DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT = 0.1;
 export declare const OBOL_SDK_EMAIL = "sdk@dvlabs.tech";
+export declare const PROVIDER_MAP: Record<number, string>;

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

@@ -3,6 +3,7 @@ import { Base } from './base.js';
 import { type RewardsSplitPayload, type ClusterDefinition, type ClusterLock, type ClusterPayload, type OperatorPayload, type TotalSplitPayload, type ClusterValidator, type ETH_ADDRESS, type OWRTranches } from './types.js';
 export * from './types.js';
 export * from './services.js';
+export * from './verification/signature-validator.js';
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.
  */

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

@@ -9,8 +9,14 @@ export declare enum FORK_MAPPING {
     /** Gnosis Chain. */
     '0x00000064' = 100,
     /** Holesky. */
-    '0x01017000' = 17000
+    '0x01017000' = 17000,
+    /** Sepolia. */
+    '0x90000069' = 11155111
 }
+/**
+ * Permitted Chain Names
+ */
+export declare const FORK_NAMES: Record<number, string>;
 /**
  * Node operator data
  */

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

@@ -1,4 +1,4 @@
-import { type Provider } from 'ethers';
+import { ethers, type Provider } from 'ethers';
 import { DefinitionFlow } from './constants';
 import { type ClusterDefinition } from './types';
 export declare const hexWithout0x: (hex: string) => string;
@@ -6,3 +6,4 @@ export declare const strToUint8Array: (str: string) => Uint8Array;
 export declare const definitionFlow: (clusterDefinition: ClusterDefinition) => DefinitionFlow | null;
 export declare const findDeployedBytecode: (contractAddress: string, provider: Provider) => Promise<string>;
 export declare const isContractAvailable: (contractAddress: string, provider: Provider, bytecode?: string) => Promise<boolean>;
+export declare const getProvider: (chainId: number) => ethers.Provider;

package/dist/types/src/verification/signature-validator.d.ts

@@ -0,0 +1,19 @@
+import { type TypedMessage } from '@metamask/eth-sig-util';
+import { type EIP712TypedData } from '@safe-global/safe-core-sdk-types';
+export declare const validateAddressSignature: ({ address, token, data, chainId, }: {
+    address: string;
+    token: string;
+    data: TypedMessage<any>;
+    chainId: number;
+}) => Promise<boolean>;
+export declare const validateEOASignature: ({ token, data, address, }: {
+    token: string;
+    data: TypedMessage<any>;
+    address: string;
+}) => boolean;
+export declare const validateSmartContractSignature: ({ token, data, address, chainId, }: {
+    token: string;
+    data: EIP712TypedData;
+    address: string;
+    chainId: number;
+}) => Promise<boolean>;

package/dist/types/test/fixtures.d.ts

@@ -212,3 +212,54 @@ export declare const nullDepositAmountsClusterLockV1X8: {
     lock_hash: string;
     node_signatures: string[];
 };
+export declare const clusterLockWithSafe: {
+    cluster_definition: {
+        name: string;
+        creator: {
+            address: string;
+            config_signature: string;
+        };
+        operators: {
+            address: string;
+            enr: string;
+            config_signature: string;
+            enr_signature: string;
+        }[];
+        uuid: string;
+        version: string;
+        timestamp: string;
+        num_validators: number;
+        threshold: number;
+        validators: {
+            fee_recipient_address: string;
+            withdrawal_address: string;
+        }[];
+        dkg_algorithm: string;
+        fork_version: string;
+        deposit_amounts: string[];
+        config_hash: string;
+        definition_hash: string;
+    };
+    distributed_validators: {
+        distributed_public_key: string;
+        public_shares: string[];
+        builder_registration: {
+            message: {
+                fee_recipient: string;
+                gas_limit: number;
+                timestamp: number;
+                pubkey: string;
+            };
+            signature: string;
+        };
+        partial_deposit_data: {
+            pubkey: string;
+            withdrawal_credentials: string;
+            amount: string;
+            signature: string;
+        }[];
+    }[];
+    signature_aggregate: string;
+    lock_hash: string;
+    node_signatures: string[];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obolnetwork/obol-sdk",
-  "version": "2.1.2",
+  "version": "2.2.1",
   "description": "A package for creating Distributed Validators using the Obol API.",
   "bugs": {
     "url": "https://github.com/obolnetwork/obol-sdk/issues"
@@ -44,9 +44,12 @@
     "@chainsafe/discv5": "^0.5.1",
     "@chainsafe/ssz": "^0.14.0",
     "@metamask/eth-sig-util": "^7.0.1",
+    "@safe-global/protocol-kit": "4.1.1",
+    "@safe-global/safe-core-sdk-types": "5.1.0",
     "@types/pdf-parse": "^1.1.4",
     "ajv": "^8.12.0",
     "cross-fetch": "^3.1.5",
+    "dotenv": "^16.4.7",
     "elliptic": "^6.5.4",
     "eslint-config-standard-with-typescript": "^43.0.1",
     "eslint-plugin-import": "^2.29.1",

package/src/constants.ts

@@ -11,6 +11,9 @@ import {
   MAINNET_SPLITMAIN_BYTECODE,
 } from './bytecodes';
 
+import * as dotenv from 'dotenv';
+dotenv.config();
+
 export const CONFLICT_ERROR_MSG = 'Conflict';
 
 export const EIP712_DOMAIN_NAME = 'Obol';
@@ -195,3 +198,10 @@ export const DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT = 1;
 export const DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT = 0.1;
 
 export const OBOL_SDK_EMAIL = 'sdk@dvlabs.tech';
+
+export const PROVIDER_MAP: Record<number, string> = {
+  1: `${process.env.RPC_MAINNET}`, // Mainnet
+  17000: `${process.env.RPC_HOLESKY}`, // Holesky
+  11155111: `${process.env.RPC_SEPOLIA}`, // Sepolia
+  100: `${process.env.RPC_GNOSIS}`, // Gnosis
+};

package/src/index.ts

@@ -49,6 +49,7 @@ import {
 import { isContractAvailable } from './utils.js';
 export * from './types.js';
 export * from './services.js';
+export * from './verification/signature-validator.js';
 
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.