@obolnetwork/obol-sdk 2.4.5 → 2.4.6

package/README.md

@@ -19,7 +19,7 @@ If you're integrating this SDK with a **backend** (e.g., in Node.js), and you st
 
 ## ⚡️ Integration with Safe Wallet
 
-When integrating the Obol SDK with a **Safe Wallet**, you will need to provide the `RPC_MAINNET` or `RPC_HOLESKY` or `RPC_GNOSIS` or `RPC_SEPOLIA` environment variable, pointing to the correct network's RPC URL. This is required to interact with Safe kit.
+When integrating the Obol SDK with a **Safe Wallet**, you can either pass an RPC URL OR provide the `RPC_MAINNET` or `RPC_HOLESKY` or `RPC_GNOSIS` or `RPC_SEPOLIA` environment variable, pointing to the correct network's RPC URL. This is required to interact with Safe kit.
 
 
 ## Contributing

package/dist/cjs/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@obolnetwork/obol-sdk",
-    "version": "2.4.5",
+    "version": "2.4.6",
     "description": "A package for creating Distributed Validators using the Obol API.",
     "bugs": {
         "url": "https://github.com/obolnetwork/obol-sdk/issues"
@@ -56,7 +56,7 @@
         "eslint-plugin-import": "^2.29.1",
         "eslint-plugin-n": "^16.6.2",
         "eslint-plugin-promise": "^6.1.1",
-        "ethers": "6.4.0",
+        "ethers": "^6.13.5",
         "nock": "^13.5.3",
         "pdf-parse": "^1.1.1",
         "semver": "^7.6.0",

package/dist/cjs/src/incentiveHelpers.js

@@ -12,7 +12,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isClaimedFromMerkleDistributor = exports.claimIncentivesFromMerkleDistributor = void 0;
 const ethers_1 = require("ethers");
 const MerkleDistributorWithDeadline_1 = require("./abi/MerkleDistributorWithDeadline");
-const utils_1 = require("./utils");
 const claimIncentivesFromMerkleDistributor = (incentivesData) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const contract = new ethers_1.Contract(incentivesData.contractAddress, MerkleDistributorWithDeadline_1.MerkleDistributorABI.abi, incentivesData.signer);
@@ -26,10 +25,9 @@ const claimIncentivesFromMerkleDistributor = (incentivesData) => __awaiter(void
     }
 });
 exports.claimIncentivesFromMerkleDistributor = claimIncentivesFromMerkleDistributor;
-const isClaimedFromMerkleDistributor = (chainId, contractAddress, index, provider) => __awaiter(void 0, void 0, void 0, function* () {
+const isClaimedFromMerkleDistributor = (contractAddress, index, provider) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const clientProvider = provider !== null && provider !== void 0 ? provider : (0, utils_1.getProvider)(chainId);
-        const contract = new ethers_1.Contract(contractAddress, MerkleDistributorWithDeadline_1.MerkleDistributorABI.abi, clientProvider);
+        const contract = new ethers_1.Contract(contractAddress, MerkleDistributorWithDeadline_1.MerkleDistributorABI.abi, provider);
         const claimed = yield contract.isClaimed(BigInt(index));
         return claimed;
     }

package/dist/cjs/src/incentives.js

@@ -95,7 +95,7 @@ class Incentives {
      */
     isClaimed(contractAddress, index) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield (0, incentiveHelpers_1.isClaimedFromMerkleDistributor)(this.chainId, contractAddress, index, this.provider);
+            return yield (0, incentiveHelpers_1.isClaimedFromMerkleDistributor)(contractAddress, index, this.provider);
         });
     }
     /**

package/dist/cjs/src/services.js

@@ -14,15 +14,16 @@ const common_js_1 = require("./verification/common.js");
 /**
  * Verifies Cluster Lock's validity.
  * @param lock - cluster lock
+ * @param safeRpcUrl - optional safeRpcUrl for safe wallet verification
  * @returns {Promise<{ result: boolean }> } boolean result to indicate if lock is valid
  * @throws on missing keys or values.
  *
  * An example of how to use validateClusterLock:
  * [validateClusterLock](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L127)
  */
-const validateClusterLock = (lock) => __awaiter(void 0, void 0, void 0, function* () {
+const validateClusterLock = (lock, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const isLockValid = yield (0, common_js_1.isValidClusterLock)(lock);
+        const isLockValid = yield (0, common_js_1.isValidClusterLock)(lock, safeRpcUrl);
         return isLockValid;
     }
     catch (err) {

package/dist/cjs/src/utils.js

@@ -67,11 +67,11 @@ const isContractAvailable = (contractAddress, provider, bytecode) => __awaiter(v
     return !!code && code !== '0x' && code !== '0x0';
 });
 exports.isContractAvailable = isContractAvailable;
-const getProvider = (chainId) => {
-    const rpcUrl = constants_1.PROVIDER_MAP[chainId];
-    if (!rpcUrl || rpcUrl === 'undefined') {
+const getProvider = (chainId, rpcUrl) => {
+    const resolvedRpcUrl = rpcUrl !== null && rpcUrl !== void 0 ? rpcUrl : constants_1.PROVIDER_MAP[chainId];
+    if (chainId && (!resolvedRpcUrl || resolvedRpcUrl === 'undefined')) {
         throw new Error(`No provider configured for ${types_1.FORK_NAMES[chainId]}`);
     }
-    return new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+    return new ethers_1.ethers.JsonRpcProvider(resolvedRpcUrl);
 };
 exports.getProvider = getProvider;

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

@@ -131,7 +131,7 @@ const clusterLockHash = (clusterLock) => {
 exports.clusterLockHash = clusterLockHash;
 // Lock verification
 // cluster-definition signatures verification
-const validatePOSTConfigHashSigner = (address, signature, configHash, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+const validatePOSTConfigHashSigner = (address, signature, configHash, chainId, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const data = (0, constants_js_1.signCreatorConfigHashPayload)({ creator_config_hash: configHash }, chainId);
         return yield (0, signature_validator_js_1.validateAddressSignature)({
@@ -139,13 +139,14 @@ const validatePOSTConfigHashSigner = (address, signature, configHash, chainId) =
             token: signature,
             data,
             chainId,
+            safeRpcUrl,
         });
     }
     catch (err) {
         throw err;
     }
 });
-const validatePUTConfigHashSigner = (address, signature, configHash, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+const validatePUTConfigHashSigner = (address, signature, configHash, chainId, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const data = (0, constants_js_1.signOperatorConfigHashPayload)({ operator_config_hash: configHash }, chainId);
         return yield (0, signature_validator_js_1.validateAddressSignature)({
@@ -153,13 +154,14 @@ const validatePUTConfigHashSigner = (address, signature, configHash, chainId) =>
             token: signature,
             data,
             chainId,
+            safeRpcUrl,
         });
     }
     catch (err) {
         throw err;
     }
 });
-const validateEnrSigner = (address, signature, payload, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+const validateEnrSigner = (address, signature, payload, chainId, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const data = (0, constants_js_1.signEnrPayload)({ enr: payload }, chainId);
         return yield (0, signature_validator_js_1.validateAddressSignature)({
@@ -167,18 +169,19 @@ const validateEnrSigner = (address, signature, payload, chainId) => __awaiter(vo
             token: signature,
             data,
             chainId,
+            safeRpcUrl,
         });
     }
     catch (err) {
         throw err;
     }
 });
-const verifyDefinitionSignatures = (clusterDefinition, definitionType) => __awaiter(void 0, void 0, void 0, function* () {
+const verifyDefinitionSignatures = (clusterDefinition, definitionType, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     if (definitionType === constants_js_1.DefinitionFlow.Charon) {
         return true;
     }
     else {
-        const isPOSTConfigHashSignerValid = yield validatePOSTConfigHashSigner(clusterDefinition.creator.address, clusterDefinition.creator.config_signature, clusterDefinition.config_hash, types_js_1.FORK_MAPPING[clusterDefinition.fork_version]);
+        const isPOSTConfigHashSignerValid = yield validatePOSTConfigHashSigner(clusterDefinition.creator.address, clusterDefinition.creator.config_signature, clusterDefinition.config_hash, types_js_1.FORK_MAPPING[clusterDefinition.fork_version], safeRpcUrl);
         if (!isPOSTConfigHashSignerValid) {
             return false;
         }
@@ -186,8 +189,8 @@ const verifyDefinitionSignatures = (clusterDefinition, definitionType) => __awai
             return true;
         }
         for (const operator of clusterDefinition.operators) {
-            const isPUTConfigHashSignerValid = yield validatePUTConfigHashSigner(operator.address, operator.config_signature, clusterDefinition.config_hash, types_js_1.FORK_MAPPING[clusterDefinition.fork_version]);
-            const isENRSignerValid = yield validateEnrSigner(operator.address, operator.enr_signature, operator.enr, types_js_1.FORK_MAPPING[clusterDefinition.fork_version]);
+            const isPUTConfigHashSignerValid = yield validatePUTConfigHashSigner(operator.address, operator.config_signature, clusterDefinition.config_hash, types_js_1.FORK_MAPPING[clusterDefinition.fork_version], safeRpcUrl);
+            const isENRSignerValid = yield validateEnrSigner(operator.address, operator.enr_signature, operator.enr, types_js_1.FORK_MAPPING[clusterDefinition.fork_version], safeRpcUrl);
             if (!isPUTConfigHashSignerValid || !isENRSignerValid) {
                 return false;
             }
@@ -322,13 +325,13 @@ const verifyLockData = (clusterLock) => __awaiter(void 0, void 0, void 0, functi
     }
     return false;
 });
-const isValidClusterLock = (clusterLock) => __awaiter(void 0, void 0, void 0, function* () {
+const isValidClusterLock = (clusterLock, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const definitionType = (0, utils_js_1.definitionFlow)(clusterLock.cluster_definition);
         if (definitionType == null) {
             return false;
         }
-        const isValidDefinitionData = yield verifyDefinitionSignatures(clusterLock.cluster_definition, definitionType);
+        const isValidDefinitionData = yield verifyDefinitionSignatures(clusterLock.cluster_definition, definitionType, safeRpcUrl);
         if (!isValidDefinitionData) {
             return false;
         }

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

@@ -20,9 +20,9 @@ const protocol_kit_1 = __importDefault(require("@safe-global/protocol-kit"));
 const constants_1 = require("../constants");
 const utils_1 = require("@safe-global/protocol-kit/dist/src/utils");
 const utils_2 = require("../utils");
-const validateAddressSignature = ({ address, token, data, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+const validateAddressSignature = ({ address, token, data, chainId, safeRpcUrl, }) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const provider = (0, utils_2.getProvider)(chainId); // [TODO Hanan], should expect it from signer.provider, or passed in client
+        const provider = (0, utils_2.getProvider)(chainId, safeRpcUrl);
         if (provider) {
             const contractAddress = yield (0, utils_2.isContractAvailable)(address, provider);
             if (contractAddress) {
@@ -31,6 +31,7 @@ const validateAddressSignature = ({ address, token, data, chainId, }) => __await
                     data: data,
                     address,
                     chainId,
+                    safeRpcUrl,
                 });
             }
         }
@@ -54,11 +55,11 @@ const validateEOASignature = ({ token, data, address, }) => {
     }
 };
 exports.validateEOASignature = validateEOASignature;
-const validateSmartContractSignature = ({ token, data, address, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+const validateSmartContractSignature = ({ token, data, address, chainId, safeRpcUrl, }) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const provider = constants_1.PROVIDER_MAP[chainId];
+        const safeProvider = safeRpcUrl !== null && safeRpcUrl !== void 0 ? safeRpcUrl : constants_1.PROVIDER_MAP[chainId];
         const protocolKit = yield protocol_kit_1.default.init({
-            provider,
+            provider: safeProvider,
             safeAddress: address,
         });
         const messageHash = (0, utils_1.hashTypedData)(data);

package/dist/cjs/test/incentives.test.js

@@ -145,7 +145,7 @@ global.fetch = globals_1.jest.fn();
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
         const result = yield clientInstance.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index);
         (0, globals_1.expect)(result).toBe(true);
-        (0, globals_1.expect)(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(clientInstance.incentives.chainId, mockIncentivesData.contract_address, mockIncentivesData.index, {});
+        (0, globals_1.expect)(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(mockIncentivesData.contract_address, mockIncentivesData.index, {});
     }));
     (0, globals_1.test)('isClaimed should return false when incentive is not claimed', () => __awaiter(void 0, void 0, void 0, function* () {
         globals_1.jest
@@ -172,7 +172,7 @@ global.fetch = globals_1.jest.fn();
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
         const result = yield clientWithoutSigner.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index);
         (0, globals_1.expect)(result).toBe(true);
-        (0, globals_1.expect)(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(clientWithoutSigner.incentives.chainId, mockIncentivesData.contract_address, mockIncentivesData.index, provider);
+        (0, globals_1.expect)(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(mockIncentivesData.contract_address, mockIncentivesData.index, provider);
     }));
     (0, globals_1.test)('getIncentivesByAddress should make the correct API request', () => __awaiter(void 0, void 0, void 0, function* () {
         const mockAddress = '0x1234567890abcdef1234567890abcdef12345678';

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

@@ -165,6 +165,9 @@ describe('Cluster Client without a signer', () => {
     beforeAll(() => {
         jest.restoreAllMocks();
     });
+    beforeEach(() => {
+        jest.resetModules();
+    });
     test('createClusterDefinition should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
         try {
             yield clientInstance.createClusterDefinition(fixtures_js_1.clusterConfigV1X8);
@@ -219,6 +222,14 @@ describe('Cluster Client without a signer', () => {
         const isValidLock = yield (0, index_1.validateClusterLock)(clusterLock);
         expect(isValidLock).toEqual(true);
     }));
+    test('should return true on verified cluster lock with Safe wallet and safe rpc url', () => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.RPC_HOLESKY = undefined;
+        /* eslint-disable @typescript-eslint/no-var-requires */
+        const { validateClusterLock: validateLockWithRpcUrl, } = require('../src/index');
+        const safeRpcUrl = 'https://ethereum-holesky-rpc.publicnode.com';
+        const isValidLock = yield validateLockWithRpcUrl(fixtures_js_1.clusterLockWithSafe, safeRpcUrl);
+        expect(isValidLock).toEqual(true);
+    }));
     test('validateCluster should return false for cluster with null deposit_amounts and incorrect partial_deposits', () => __awaiter(void 0, void 0, void 0, function* () {
         const partialDeposit = fixtures_js_1.nullDepositAmountsClusterLockV1X8.distributed_validators[0]
             .partial_deposit_data[0];

package/dist/esm/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@obolnetwork/obol-sdk",
-    "version": "2.4.5",
+    "version": "2.4.6",
     "description": "A package for creating Distributed Validators using the Obol API.",
     "bugs": {
         "url": "https://github.com/obolnetwork/obol-sdk/issues"
@@ -56,7 +56,7 @@
         "eslint-plugin-import": "^2.29.1",
         "eslint-plugin-n": "^16.6.2",
         "eslint-plugin-promise": "^6.1.1",
-        "ethers": "6.4.0",
+        "ethers": "^6.13.5",
         "nock": "^13.5.3",
         "pdf-parse": "^1.1.1",
         "semver": "^7.6.0",

package/dist/esm/src/incentiveHelpers.js

@@ -9,7 +9,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { Contract } from 'ethers';
 import { MerkleDistributorABI } from './abi/MerkleDistributorWithDeadline';
-import { getProvider } from './utils';
 export const claimIncentivesFromMerkleDistributor = (incentivesData) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const contract = new Contract(incentivesData.contractAddress, MerkleDistributorABI.abi, incentivesData.signer);
@@ -22,10 +21,9 @@ export const claimIncentivesFromMerkleDistributor = (incentivesData) => __awaite
         throw new Error(`Failed to claim incentives: ${error.message}`);
     }
 });
-export const isClaimedFromMerkleDistributor = (chainId, contractAddress, index, provider) => __awaiter(void 0, void 0, void 0, function* () {
+export const isClaimedFromMerkleDistributor = (contractAddress, index, provider) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const clientProvider = provider !== null && provider !== void 0 ? provider : getProvider(chainId);
-        const contract = new Contract(contractAddress, MerkleDistributorABI.abi, clientProvider);
+        const contract = new Contract(contractAddress, MerkleDistributorABI.abi, provider);
         const claimed = yield contract.isClaimed(BigInt(index));
         return claimed;
     }

package/dist/esm/src/incentives.js

@@ -92,7 +92,7 @@ export class Incentives {
      */
     isClaimed(contractAddress, index) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield isClaimedFromMerkleDistributor(this.chainId, contractAddress, index, this.provider);
+            return yield isClaimedFromMerkleDistributor(contractAddress, index, this.provider);
         });
     }
     /**

package/dist/esm/src/services.js

@@ -11,15 +11,16 @@ import { isValidClusterLock } from './verification/common.js';
 /**
  * Verifies Cluster Lock's validity.
  * @param lock - cluster lock
+ * @param safeRpcUrl - optional safeRpcUrl for safe wallet verification
  * @returns {Promise<{ result: boolean }> } boolean result to indicate if lock is valid
  * @throws on missing keys or values.
  *
  * An example of how to use validateClusterLock:
  * [validateClusterLock](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L127)
  */
-export const validateClusterLock = (lock) => __awaiter(void 0, void 0, void 0, function* () {
+export const validateClusterLock = (lock, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const isLockValid = yield isValidClusterLock(lock);
+        const isLockValid = yield isValidClusterLock(lock, safeRpcUrl);
         return isLockValid;
     }
     catch (err) {

package/dist/esm/src/utils.js

@@ -59,10 +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 || rpcUrl === 'undefined') {
+export const getProvider = (chainId, rpcUrl) => {
+    const resolvedRpcUrl = rpcUrl !== null && rpcUrl !== void 0 ? rpcUrl : PROVIDER_MAP[chainId];
+    if (chainId && (!resolvedRpcUrl || resolvedRpcUrl === 'undefined')) {
         throw new Error(`No provider configured for ${FORK_NAMES[chainId]}`);
     }
-    return new ethers.JsonRpcProvider(rpcUrl);
+    return new ethers.JsonRpcProvider(resolvedRpcUrl);
 };

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

@@ -100,7 +100,7 @@ export const clusterLockHash = (clusterLock) => {
 };
 // Lock verification
 // cluster-definition signatures verification
-const validatePOSTConfigHashSigner = (address, signature, configHash, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+const validatePOSTConfigHashSigner = (address, signature, configHash, chainId, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const data = signCreatorConfigHashPayload({ creator_config_hash: configHash }, chainId);
         return yield validateAddressSignature({
@@ -108,13 +108,14 @@ const validatePOSTConfigHashSigner = (address, signature, configHash, chainId) =
             token: signature,
             data,
             chainId,
+            safeRpcUrl,
         });
     }
     catch (err) {
         throw err;
     }
 });
-const validatePUTConfigHashSigner = (address, signature, configHash, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+const validatePUTConfigHashSigner = (address, signature, configHash, chainId, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const data = signOperatorConfigHashPayload({ operator_config_hash: configHash }, chainId);
         return yield validateAddressSignature({
@@ -122,13 +123,14 @@ const validatePUTConfigHashSigner = (address, signature, configHash, chainId) =>
             token: signature,
             data,
             chainId,
+            safeRpcUrl,
         });
     }
     catch (err) {
         throw err;
     }
 });
-const validateEnrSigner = (address, signature, payload, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+const validateEnrSigner = (address, signature, payload, chainId, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const data = signEnrPayload({ enr: payload }, chainId);
         return yield validateAddressSignature({
@@ -136,18 +138,19 @@ const validateEnrSigner = (address, signature, payload, chainId) => __awaiter(vo
             token: signature,
             data,
             chainId,
+            safeRpcUrl,
         });
     }
     catch (err) {
         throw err;
     }
 });
-const verifyDefinitionSignatures = (clusterDefinition, definitionType) => __awaiter(void 0, void 0, void 0, function* () {
+const verifyDefinitionSignatures = (clusterDefinition, definitionType, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     if (definitionType === DefinitionFlow.Charon) {
         return true;
     }
     else {
-        const isPOSTConfigHashSignerValid = yield validatePOSTConfigHashSigner(clusterDefinition.creator.address, clusterDefinition.creator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version]);
+        const isPOSTConfigHashSignerValid = yield validatePOSTConfigHashSigner(clusterDefinition.creator.address, clusterDefinition.creator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version], safeRpcUrl);
         if (!isPOSTConfigHashSignerValid) {
             return false;
         }
@@ -155,8 +158,8 @@ const verifyDefinitionSignatures = (clusterDefinition, definitionType) => __awai
             return true;
         }
         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]);
+            const isPUTConfigHashSignerValid = yield validatePUTConfigHashSigner(operator.address, operator.config_signature, clusterDefinition.config_hash, FORK_MAPPING[clusterDefinition.fork_version], safeRpcUrl);
+            const isENRSignerValid = yield validateEnrSigner(operator.address, operator.enr_signature, operator.enr, FORK_MAPPING[clusterDefinition.fork_version], safeRpcUrl);
             if (!isPUTConfigHashSignerValid || !isENRSignerValid) {
                 return false;
             }
@@ -287,13 +290,13 @@ const verifyLockData = (clusterLock) => __awaiter(void 0, void 0, void 0, functi
     }
     return false;
 });
-export const isValidClusterLock = (clusterLock) => __awaiter(void 0, void 0, void 0, function* () {
+export const isValidClusterLock = (clusterLock, safeRpcUrl) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const definitionType = definitionFlow(clusterLock.cluster_definition);
         if (definitionType == null) {
             return false;
         }
-        const isValidDefinitionData = yield verifyDefinitionSignatures(clusterLock.cluster_definition, definitionType);
+        const isValidDefinitionData = yield verifyDefinitionSignatures(clusterLock.cluster_definition, definitionType, safeRpcUrl);
         if (!isValidDefinitionData) {
             return false;
         }

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

@@ -14,9 +14,9 @@ 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* () {
+export const validateAddressSignature = ({ address, token, data, chainId, safeRpcUrl, }) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const provider = getProvider(chainId); // [TODO Hanan], should expect it from signer.provider, or passed in client
+        const provider = getProvider(chainId, safeRpcUrl);
         if (provider) {
             const contractAddress = yield isContractAvailable(address, provider);
             if (contractAddress) {
@@ -25,6 +25,7 @@ export const validateAddressSignature = ({ address, token, data, chainId, }) =>
                     data: data,
                     address,
                     chainId,
+                    safeRpcUrl,
                 });
             }
         }
@@ -46,11 +47,11 @@ export const validateEOASignature = ({ token, data, address, }) => {
         throw err;
     }
 };
-export const validateSmartContractSignature = ({ token, data, address, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+export const validateSmartContractSignature = ({ token, data, address, chainId, safeRpcUrl, }) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const provider = PROVIDER_MAP[chainId];
+        const safeProvider = safeRpcUrl !== null && safeRpcUrl !== void 0 ? safeRpcUrl : PROVIDER_MAP[chainId];
         const protocolKit = yield Safe.init({
-            provider,
+            provider: safeProvider,
             safeAddress: address,
         });
         const messageHash = hashTypedData(data);

package/dist/esm/test/incentives.test.js

@@ -120,7 +120,7 @@ describe('Client.incentives', () => {
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
         const result = yield clientInstance.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index);
         expect(result).toBe(true);
-        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(clientInstance.incentives.chainId, mockIncentivesData.contract_address, mockIncentivesData.index, {});
+        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(mockIncentivesData.contract_address, mockIncentivesData.index, {});
     }));
     test('isClaimed should return false when incentive is not claimed', () => __awaiter(void 0, void 0, void 0, function* () {
         jest
@@ -147,7 +147,7 @@ describe('Client.incentives', () => {
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
         const result = yield clientWithoutSigner.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index);
         expect(result).toBe(true);
-        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(clientWithoutSigner.incentives.chainId, mockIncentivesData.contract_address, mockIncentivesData.index, provider);
+        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(mockIncentivesData.contract_address, mockIncentivesData.index, provider);
     }));
     test('getIncentivesByAddress should make the correct API request', () => __awaiter(void 0, void 0, void 0, function* () {
         const mockAddress = '0x1234567890abcdef1234567890abcdef12345678';

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

@@ -140,6 +140,9 @@ describe('Cluster Client without a signer', () => {
     beforeAll(() => {
         jest.restoreAllMocks();
     });
+    beforeEach(() => {
+        jest.resetModules();
+    });
     test('createClusterDefinition should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
         try {
             yield clientInstance.createClusterDefinition(clusterConfigV1X8);
@@ -194,6 +197,14 @@ describe('Cluster Client without a signer', () => {
         const isValidLock = yield validateClusterLock(clusterLock);
         expect(isValidLock).toEqual(true);
     }));
+    test('should return true on verified cluster lock with Safe wallet and safe rpc url', () => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.RPC_HOLESKY = undefined;
+        /* eslint-disable @typescript-eslint/no-var-requires */
+        const { validateClusterLock: validateLockWithRpcUrl, } = require('../src/index');
+        const safeRpcUrl = 'https://ethereum-holesky-rpc.publicnode.com';
+        const isValidLock = yield validateLockWithRpcUrl(clusterLockWithSafe, safeRpcUrl);
+        expect(isValidLock).toEqual(true);
+    }));
     test('validateCluster should return false for cluster with null deposit_amounts and incorrect partial_deposits', () => __awaiter(void 0, void 0, void 0, function* () {
         const partialDeposit = nullDepositAmountsClusterLockV1X8.distributed_validators[0]
             .partial_deposit_data[0];

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

@@ -9,4 +9,4 @@ export declare const claimIncentivesFromMerkleDistributor: (incentivesData: {
 }) => Promise<{
     txHash: string;
 }>;
-export declare const isClaimedFromMerkleDistributor: (chainId: number, contractAddress: ETH_ADDRESS, index: number, provider: ProviderType | undefined | null) => Promise<boolean>;
+export declare const isClaimedFromMerkleDistributor: (contractAddress: ETH_ADDRESS, index: number, provider: ProviderType | undefined | null) => Promise<boolean>;

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

@@ -1,4 +1,4 @@
-import { type Incentives as IncentivesType, type ETH_ADDRESS, type ProviderType, type SignerType, type ClaimIncentivesResponse } from './types';
+import { type ClaimableIncentives, type ETH_ADDRESS, type ProviderType, type SignerType, type ClaimIncentivesResponse } from './types';
 /**
  * Incentives can be used for fetching and claiming Obol incentives.
  * @class
@@ -53,5 +53,5 @@ export declare class Incentives {
      * An example of how to use getIncentivesByAddress:
      * [obolClient](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L250)
      */
-    getIncentivesByAddress(address: string): Promise<IncentivesType>;
+    getIncentivesByAddress(address: string): Promise<ClaimableIncentives>;
 }

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

@@ -1,11 +1,12 @@
-import { type ClusterLock } from './types.js';
+import { type SafeRpcUrl, type ClusterLock } from './types.js';
 /**
  * Verifies Cluster Lock's validity.
  * @param lock - cluster lock
+ * @param safeRpcUrl - optional safeRpcUrl for safe wallet verification
  * @returns {Promise<{ result: boolean }> } boolean result to indicate if lock is valid
  * @throws on missing keys or values.
  *
  * An example of how to use validateClusterLock:
  * [validateClusterLock](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L127)
  */
-export declare const validateClusterLock: (lock: ClusterLock) => Promise<boolean>;
+export declare const validateClusterLock: (lock: ClusterLock, safeRpcUrl?: SafeRpcUrl) => Promise<boolean>;

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

@@ -1,4 +1,4 @@
-import { type ethers, type JsonRpcApiProvider, type JsonRpcProvider, type JsonRpcSigner, type Provider, type Signer } from 'ethers';
+import { type Wallet, type ethers, type JsonRpcApiProvider, type JsonRpcProvider, type JsonRpcSigner, type Provider, type Signer } from 'ethers';
 /**
  * Permitted ChainID's
  */
@@ -212,9 +212,9 @@ export type ClusterLock = {
     node_signatures?: string[];
 };
 /**
- * Incentives
+ * Claimable Obol Incentives
  */
-export type Incentives = {
+export type ClaimableIncentives = {
     /** Operator Address. */
     operator_address: string;
     /** The amount the recipient is entitled to. */
@@ -234,10 +234,14 @@ export type ETH_ADDRESS = string;
  * Provider Types
  */
 export type ProviderType = Provider | JsonRpcProvider | JsonRpcApiProvider | ethers.BrowserProvider;
+/**
+ * Safe Wallet Provider Types
+ */
+export type SafeRpcUrl = string;
 /**
  * Signer Types
  */
-export type SignerType = Signer | JsonRpcSigner;
+export type SignerType = Signer | JsonRpcSigner | Wallet;
 /**
  * claimIncentives Response
  */

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

@@ -6,4 +6,4 @@ export declare const strToUint8Array: (str: string) => Uint8Array;
 export declare const definitionFlow: (clusterDefinition: ClusterDefinition) => DefinitionFlow | null;
 export declare const findDeployedBytecode: (contractAddress: string, provider: ProviderType) => Promise<string>;
 export declare const isContractAvailable: (contractAddress: string, provider: ProviderType, bytecode?: string) => Promise<boolean>;
-export declare const getProvider: (chainId: number) => ethers.JsonRpcProvider;
+export declare const getProvider: (chainId: number, rpcUrl?: string) => ethers.JsonRpcProvider;

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

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { type ClusterDefinition, type ClusterLock, type DepositData, type DistributedValidator } from '../types.js';
+import { type ClusterDefinition, type ClusterLock, type DepositData, type DistributedValidator, type SafeRpcUrl } from '../types.js';
 /**
  * @param cluster The cluster configuration or the cluster definition
  * @param configOnly a boolean to indicate config hash or definition hash
@@ -29,4 +29,4 @@ export declare const verifyBuilderRegistration: (validator: DistributedValidator
 };
 export declare const verifyNodeSignatures: (clusterLock: ClusterLock) => boolean;
 export declare const signingRoot: (domain: Uint8Array, messageBuffer: Buffer) => Uint8Array;
-export declare const isValidClusterLock: (clusterLock: ClusterLock) => Promise<boolean>;
+export declare const isValidClusterLock: (clusterLock: ClusterLock, safeRpcUrl?: SafeRpcUrl) => Promise<boolean>;

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

@@ -1,19 +1,22 @@
 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, }: {
+import { type SafeRpcUrl } from '../types';
+export declare const validateAddressSignature: ({ address, token, data, chainId, safeRpcUrl, }: {
     address: string;
     token: string;
     data: TypedMessage<any>;
     chainId: number;
+    safeRpcUrl?: string | undefined;
 }) => 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, }: {
+export declare const validateSmartContractSignature: ({ token, data, address, chainId, safeRpcUrl, }: {
     token: string;
     data: EIP712TypedData;
     address: string;
     chainId: number;
+    safeRpcUrl?: string | undefined;
 }) => Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obolnetwork/obol-sdk",
-  "version": "2.4.5",
+  "version": "2.4.6",
   "description": "A package for creating Distributed Validators using the Obol API.",
   "bugs": {
     "url": "https://github.com/obolnetwork/obol-sdk/issues"
@@ -56,7 +56,7 @@
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-n": "^16.6.2",
     "eslint-plugin-promise": "^6.1.1",
-    "ethers": "6.4.0",
+    "ethers": "^6.13.5",
     "nock": "^13.5.3",
     "pdf-parse": "^1.1.1",
     "semver": "^7.6.0",

package/src/incentiveHelpers.ts

@@ -1,7 +1,6 @@
 import { type ProviderType, type SignerType, type ETH_ADDRESS } from './types';
 import { Contract } from 'ethers';
 import { MerkleDistributorABI } from './abi/MerkleDistributorWithDeadline';
-import { getProvider } from './utils';
 
 export const claimIncentivesFromMerkleDistributor = async (incentivesData: {
   signer: SignerType;
@@ -35,18 +34,15 @@ export const claimIncentivesFromMerkleDistributor = async (incentivesData: {
 };
 
 export const isClaimedFromMerkleDistributor = async (
-  chainId: number,
   contractAddress: ETH_ADDRESS,
   index: number,
   provider: ProviderType | undefined | null,
 ): Promise<boolean> => {
   try {
-    const clientProvider = provider ?? getProvider(chainId);
-
     const contract = new Contract(
       contractAddress,
       MerkleDistributorABI.abi,
-      clientProvider,
+      provider,
     );
 
     const claimed = await contract.isClaimed(BigInt(index));

package/src/incentives.ts

@@ -1,6 +1,6 @@
 import { isContractAvailable } from './utils';
 import {
-  type Incentives as IncentivesType,
+  type ClaimableIncentives,
   type ETH_ADDRESS,
   FORK_NAMES,
   type ProviderType,
@@ -126,7 +126,6 @@ export class Incentives {
     index: number,
   ): Promise<boolean> {
     return await isClaimedFromMerkleDistributor(
-      this.chainId,
       contractAddress,
       index,
       this.provider,
@@ -141,9 +140,9 @@ export class Incentives {
    * An example of how to use getIncentivesByAddress:
    * [obolClient](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L250)
    */
-  async getIncentivesByAddress(address: string): Promise<IncentivesType> {
+  async getIncentivesByAddress(address: string): Promise<ClaimableIncentives> {
     const network = FORK_NAMES[this.chainId];
-    const incentives: IncentivesType = await this.request(
+    const incentives: ClaimableIncentives = await this.request(
       `/${DEFAULT_BASE_VERSION}/address/incentives/${network}/${address}`,
       {
         method: 'GET',

package/src/services.ts

@@ -1,9 +1,10 @@
-import { type ClusterLock } from './types.js';
+import { type SafeRpcUrl, type ClusterLock } from './types.js';
 import { isValidClusterLock } from './verification/common.js';
 
 /**
  * Verifies Cluster Lock's validity.
  * @param lock - cluster lock
+ * @param safeRpcUrl - optional safeRpcUrl for safe wallet verification
  * @returns {Promise<{ result: boolean }> } boolean result to indicate if lock is valid
  * @throws on missing keys or values.
  *
@@ -12,9 +13,10 @@ import { isValidClusterLock } from './verification/common.js';
  */
 export const validateClusterLock = async (
   lock: ClusterLock,
+  safeRpcUrl?: SafeRpcUrl,
 ): Promise<boolean> => {
   try {
-    const isLockValid = await isValidClusterLock(lock);
+    const isLockValid = await isValidClusterLock(lock, safeRpcUrl);
     return isLockValid;
   } catch (err: any) {
     throw err;

package/src/types.ts

@@ -1,4 +1,5 @@
 import {
+  type Wallet,
   type ethers,
   type JsonRpcApiProvider,
   type JsonRpcProvider,
@@ -295,9 +296,9 @@ export type ClusterLock = {
 };
 
 /**
- * Incentives
+ * Claimable Obol Incentives
  */
-export type Incentives = {
+export type ClaimableIncentives = {
   /** Operator Address. */
   operator_address: string;
 
@@ -328,10 +329,15 @@ export type ProviderType =
   | JsonRpcApiProvider
   | ethers.BrowserProvider;
 
+/**
+ * Safe Wallet Provider Types
+ */
+export type SafeRpcUrl = string;
+
 /**
  * Signer Types
  */
-export type SignerType = Signer | JsonRpcSigner;
+export type SignerType = Signer | JsonRpcSigner | Wallet;
 
 /**
  * claimIncentives Response

package/src/utils.ts

@@ -76,10 +76,13 @@ export const isContractAvailable = async (
   return !!code && code !== '0x' && code !== '0x0';
 };
 
-export const getProvider = (chainId: number): ethers.JsonRpcProvider => {
-  const rpcUrl = PROVIDER_MAP[chainId];
-  if (!rpcUrl || rpcUrl === 'undefined') {
+export const getProvider = (
+  chainId: number,
+  rpcUrl?: string,
+): ethers.JsonRpcProvider => {
+  const resolvedRpcUrl = rpcUrl ?? PROVIDER_MAP[chainId];
+  if (chainId && (!resolvedRpcUrl || resolvedRpcUrl === 'undefined')) {
     throw new Error(`No provider configured for ${FORK_NAMES[chainId]}`);
   }
-  return new ethers.JsonRpcProvider(rpcUrl);
+  return new ethers.JsonRpcProvider(resolvedRpcUrl);
 };

package/src/verification/common.ts

@@ -1,7 +1,6 @@
 import { fromHexString } from '@chainsafe/ssz';
 import elliptic from 'elliptic';
 import { init } from '@chainsafe/bls';
-
 import {
   FORK_MAPPING,
   type ClusterDefinition,
@@ -9,6 +8,7 @@ import {
   type DepositData,
   type BuilderRegistrationMessage,
   type DistributedValidator,
+  type SafeRpcUrl,
 } from '../types.js';
 import * as semver from 'semver';
 import {
@@ -167,6 +167,7 @@ const validatePOSTConfigHashSigner = async (
   signature: string,
   configHash: string,
   chainId: FORK_MAPPING,
+  safeRpcUrl?: SafeRpcUrl,
 ): Promise<boolean> => {
   try {
     const data = signCreatorConfigHashPayload(
@@ -179,6 +180,7 @@ const validatePOSTConfigHashSigner = async (
       token: signature,
       data,
       chainId,
+      safeRpcUrl,
     });
   } catch (err) {
     throw err;
@@ -190,6 +192,7 @@ const validatePUTConfigHashSigner = async (
   signature: string,
   configHash: string,
   chainId: number,
+  safeRpcUrl?: SafeRpcUrl,
 ): Promise<boolean> => {
   try {
     const data = signOperatorConfigHashPayload(
@@ -201,6 +204,7 @@ const validatePUTConfigHashSigner = async (
       token: signature,
       data,
       chainId,
+      safeRpcUrl,
     });
   } catch (err) {
     throw err;
@@ -212,6 +216,7 @@ const validateEnrSigner = async (
   signature: string,
   payload: string,
   chainId: number,
+  safeRpcUrl?: SafeRpcUrl,
 ): Promise<boolean> => {
   try {
     const data = signEnrPayload({ enr: payload }, chainId);
@@ -221,6 +226,7 @@ const validateEnrSigner = async (
       token: signature,
       data,
       chainId,
+      safeRpcUrl,
     });
   } catch (err) {
     throw err;
@@ -230,6 +236,7 @@ const validateEnrSigner = async (
 const verifyDefinitionSignatures = async (
   clusterDefinition: ClusterDefinition,
   definitionType: DefinitionFlow,
+  safeRpcUrl?: SafeRpcUrl,
 ): Promise<boolean> => {
   if (definitionType === DefinitionFlow.Charon) {
     return true;
@@ -239,6 +246,7 @@ const verifyDefinitionSignatures = async (
       clusterDefinition.creator.config_signature as string,
       clusterDefinition.config_hash,
       FORK_MAPPING[clusterDefinition.fork_version as keyof typeof FORK_MAPPING],
+      safeRpcUrl,
     );
 
     if (!isPOSTConfigHashSignerValid) {
@@ -256,6 +264,7 @@ const verifyDefinitionSignatures = async (
         FORK_MAPPING[
           clusterDefinition.fork_version as keyof typeof FORK_MAPPING
         ],
+        safeRpcUrl,
       );
 
       const isENRSignerValid = await validateEnrSigner(
@@ -265,6 +274,7 @@ const verifyDefinitionSignatures = async (
         FORK_MAPPING[
           clusterDefinition.fork_version as keyof typeof FORK_MAPPING
         ],
+        safeRpcUrl,
       );
 
       if (!isPUTConfigHashSignerValid || !isENRSignerValid) {
@@ -485,6 +495,7 @@ const verifyLockData = async (clusterLock: ClusterLock): Promise<boolean> => {
 
 export const isValidClusterLock = async (
   clusterLock: ClusterLock,
+  safeRpcUrl?: SafeRpcUrl,
 ): Promise<boolean> => {
   try {
     const definitionType = definitionFlow(clusterLock.cluster_definition);
@@ -494,6 +505,7 @@ export const isValidClusterLock = async (
     const isValidDefinitionData = await verifyDefinitionSignatures(
       clusterLock.cluster_definition,
       definitionType,
+      safeRpcUrl,
     );
     if (!isValidDefinitionData) {
       return false;

package/src/verification/signature-validator.ts

@@ -10,20 +10,23 @@ import { PROVIDER_MAP } from '../constants';
 import { hashTypedData } from '@safe-global/protocol-kit/dist/src/utils';
 import { type EIP712TypedData } from '@safe-global/safe-core-sdk-types';
 import { isContractAvailable, getProvider } from '../utils';
+import { type SafeRpcUrl } from '../types';
 
 export const validateAddressSignature = async ({
   address,
   token,
   data,
   chainId,
+  safeRpcUrl,
 }: {
   address: string;
   token: string;
   data: TypedMessage<any>;
   chainId: number;
+  safeRpcUrl?: SafeRpcUrl;
 }): Promise<boolean> => {
   try {
-    const provider = getProvider(chainId); // [TODO Hanan], should expect it from signer.provider, or passed in client
+    const provider = getProvider(chainId, safeRpcUrl);
     if (provider) {
       const contractAddress = await isContractAvailable(address, provider);
       if (contractAddress) {
@@ -32,6 +35,7 @@ export const validateAddressSignature = async ({
           data: data as unknown as EIP712TypedData,
           address,
           chainId,
+          safeRpcUrl,
         });
       }
     }
@@ -69,16 +73,19 @@ export const validateSmartContractSignature = async ({
   data,
   address,
   chainId,
+  safeRpcUrl,
 }: {
   token: string;
   data: EIP712TypedData;
   address: string;
   chainId: number;
+  safeRpcUrl?: SafeRpcUrl;
 }): Promise<boolean> => {
   try {
-    const provider = PROVIDER_MAP[chainId];
+    const safeProvider = safeRpcUrl ?? PROVIDER_MAP[chainId];
+
     const protocolKit = await Safe.init({
-      provider,
+      provider: safeProvider,
       safeAddress: address,
     });
     const messageHash = hashTypedData(data);