@obolnetwork/obol-sdk 2.4.4 → 2.4.6

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

@@ -79,13 +79,13 @@ describe('Client.incentives', () => {
             merkleProof: mockIncentivesData.merkle_proof,
         });
     }));
-    test('claimIncentives should return alreadyClaimed when incentives are already claimed', () => __awaiter(void 0, void 0, void 0, function* () {
+    test('claimIncentives should return txHash as null when incentives are already claimed', () => __awaiter(void 0, void 0, void 0, function* () {
         jest
             .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
             .mockResolvedValue(mockIncentivesData);
         jest.spyOn(clientInstance.incentives, 'isClaimed').mockResolvedValue(true);
         const result = yield clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address);
-        expect(result).toEqual({ alreadyClaimed: true });
+        expect(result).toEqual({ txHash: null });
         expect(incentivesHelpers.claimIncentivesFromMerkleDistributor).not.toHaveBeenCalled();
     }));
     test('claimIncentives should throw an error if no incentives found for address', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -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

@@ -1,7 +1,6 @@
-import { type ETH_ADDRESS } from './types';
-import { type JsonRpcApiProvider, type JsonRpcProvider, type Provider, type Signer } from 'ethers';
+import { type ProviderType, type SignerType, type ETH_ADDRESS } from './types';
 export declare const claimIncentivesFromMerkleDistributor: (incentivesData: {
-    signer: Signer;
+    signer: SignerType;
     contractAddress: ETH_ADDRESS;
     index: number;
     operatorAddress: ETH_ADDRESS;
@@ -10,4 +9,4 @@ export declare const claimIncentivesFromMerkleDistributor: (incentivesData: {
 }) => Promise<{
     txHash: string;
 }>;
-export declare const isClaimedFromMerkleDistributor: (chainId: number, contractAddress: ETH_ADDRESS, index: number, provider: Provider | JsonRpcProvider | JsonRpcApiProvider | 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,28 +1,38 @@
-import type { JsonRpcApiProvider, JsonRpcProvider, JsonRpcSigner, Provider, Signer } from 'ethers';
-import { type Incentives as IncentivesType, type ETH_ADDRESS } 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
+ * @internal Access it through Client.incentives.
+ * @example
+ * const obolClient = new Client(config);
+ * await obolClient.incentives.claimIncentives(address);
+ */
 export declare class Incentives {
     private readonly signer;
     readonly chainId: number;
     private readonly request;
-    readonly provider: Provider | JsonRpcProvider | JsonRpcApiProvider | undefined | null;
-    constructor(signer: Signer | JsonRpcSigner | undefined, chainId: number, request: (endpoint: string, options?: RequestInit) => Promise<any>, provider: Provider | JsonRpcProvider | JsonRpcApiProvider | undefined | null);
+    readonly provider: ProviderType | undefined | null;
+    constructor(signer: SignerType | undefined, chainId: number, request: (endpoint: string, options?: RequestInit) => Promise<any>, provider: ProviderType | undefined | null);
     /**
-     * Claims obol incentives from a Merkle Distributor contract using just an address.
-     * The method automatically fetches incentives data and checks if already claimed.
+     * Claims Obol incentives from a Merkle Distributor contract using an address.
+     *
+     * This method automatically fetches incentive data and verifies whether the incentives have already been claimed.
+     * If `txHash` is `null`, it indicates that the incentives were already claimed.
+     *
+     * Note: This method is not yet enabled and will throw an error if called.
      *
      * @remarks
      * **⚠️ Important:**  If you're storing the private key in an `.env` file, ensure it is securely managed
      * and not pushed to version control.
      *
      * @param {string} address - The address to claim incentives for
-     * @returns {Promise<{ txHash: string } | { alreadyClaimed: true }>} The transaction hash or already claimed status
+     * @returns {Promise<ClaimIncentivesResponse>} The transaction hash or already claimed status
      * @throws Will throw an error if the incentives data is not found or the claim fails
+     *
+     * An example of how to use claimIncentives:
+     * [obolClient](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L281)
      */
-    claimIncentives(address: string): Promise<{
-        txHash: string;
-    } | {
-        alreadyClaimed: true;
-    }>;
+    claimIncentives(address: string): Promise<ClaimIncentivesResponse>;
     /**
      * Read isClaimed.
      *
@@ -30,12 +40,18 @@ export declare class Incentives {
      * @param {ETH_ADDRESS} index - operator index in merkle tree
      * @returns {Promise<boolean>} true if incentives are already claime
      *
+     *
+     * An example of how to use isClaimed:
+     * [obolClient](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L266)
      */
     isClaimed(contractAddress: ETH_ADDRESS, index: number): Promise<boolean>;
     /**
      * @param address - Operator address
      * @returns {Promise<IncentivesType>} The matched incentives from DB
      * @throws On not found if address not found.
+     *
+     * 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/index.d.ts

@@ -1,18 +1,29 @@
-import { type Provider, type Signer, type JsonRpcSigner, type JsonRpcProvider, type JsonRpcApiProvider } from 'ethers';
 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';
+import { type RewardsSplitPayload, type ClusterDefinition, type ClusterLock, type ClusterPayload, type OperatorPayload, type TotalSplitPayload, type ClusterValidator, type ETH_ADDRESS, type OWRTranches, type ProviderType, type SignerType } from './types.js';
 import { Incentives } from './incentives.js';
 export * from './types.js';
 export * from './services.js';
 export * from './verification/signature-validator.js';
 export * from './verification/common.js';
+export { Incentives } from './incentives.js';
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.
  */
 export declare class Client extends Base {
+    /**
+     * The signer used for signing transactions.
+     */
     private readonly signer;
+    /**
+     * The incentives module, responsible for managing Obol tokens distribution.
+     * @type {Incentives}
+     */
     incentives: Incentives;
-    provider: Provider | JsonRpcProvider | JsonRpcApiProvider | undefined | null;
+    /**
+     * The blockchain provider, used to interact with the network.
+     * It can be null, undefined, or a valid provider instance and defaults to the Signer provider if Signer is passed.
+     */
+    provider: ProviderType | undefined | null;
     /**
      * @param config - Client configurations
      * @param config.baseUrl - obol-api url
@@ -26,7 +37,7 @@ export declare class Client extends Base {
     constructor(config: {
         baseUrl?: string;
         chainId?: number;
-    }, signer?: Signer | JsonRpcSigner, provider?: Provider | JsonRpcProvider);
+    }, signer?: SignerType, provider?: ProviderType);
     /**
      * Accepts Obol terms and conditions to be able to create or update data.
      * @returns {Promise<string>} terms and conditions acceptance success message.

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/splitHelpers.d.ts

@@ -1,5 +1,4 @@
-import { type OWRTranches, type ClusterValidator, type ETH_ADDRESS, type SplitRecipient } from './types';
-import { type Signer } from 'ethers';
+import { type OWRTranches, type ClusterValidator, type ETH_ADDRESS, type SplitRecipient, type SignerType } from './types';
 type Call = {
     target: ETH_ADDRESS;
     callData: string;
@@ -21,7 +20,7 @@ export declare const formatSplitRecipients: (recipients: SplitRecipient[]) => {
     percentAllocations: number[];
 };
 export declare const predictSplitterAddress: ({ signer, accounts, percentAllocations, chainId, distributorFee, controllerAddress, }: {
-    signer: Signer;
+    signer: SignerType;
     accounts: ETH_ADDRESS[];
     percentAllocations: number[];
     chainId: number;
@@ -29,7 +28,7 @@ export declare const predictSplitterAddress: ({ signer, accounts, percentAllocat
     controllerAddress: ETH_ADDRESS;
 }) => Promise<ETH_ADDRESS>;
 export declare const handleDeployOWRAndSplitter: ({ signer, isSplitterDeployed, predictedSplitterAddress, accounts, percentAllocations, etherAmount, principalRecipient, chainId, distributorFee, controllerAddress, recoveryAddress, }: {
-    signer: Signer;
+    signer: SignerType;
     isSplitterDeployed: boolean;
     predictedSplitterAddress: ETH_ADDRESS;
     accounts: ETH_ADDRESS[];
@@ -42,7 +41,7 @@ export declare const handleDeployOWRAndSplitter: ({ signer, isSplitterDeployed,
     recoveryAddress: ETH_ADDRESS;
 }) => Promise<ClusterValidator>;
 export declare const deploySplitterContract: ({ signer, accounts, percentAllocations, chainId, distributorFee, controllerAddress, }: {
-    signer: Signer;
+    signer: SignerType;
     accounts: ETH_ADDRESS[];
     percentAllocations: number[];
     chainId: number;
@@ -52,7 +51,7 @@ export declare const deploySplitterContract: ({ signer, accounts, percentAllocat
 export declare const deploySplitterAndOWRContracts: ({ owrArgs, splitterArgs, signer, chainId, }: {
     owrArgs: OWRArgs;
     splitterArgs: SplitArgs;
-    signer: Signer;
+    signer: SignerType;
     chainId: number;
 }) => Promise<{
     owrAddress: ETH_ADDRESS;
@@ -60,7 +59,7 @@ export declare const deploySplitterAndOWRContracts: ({ owrArgs, splitterArgs, si
 }>;
 export declare const getOWRTranches: ({ owrAddress, signer, }: {
     owrAddress: ETH_ADDRESS;
-    signer: Signer;
+    signer: SignerType;
 }) => Promise<OWRTranches>;
-export declare const multicall: (calls: Call[], signer: Signer, multicallAddress: string) => Promise<any>;
+export declare const multicall: (calls: Call[], signer: SignerType, multicallAddress: string) => Promise<any>;
 export {};

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

@@ -1,3 +1,4 @@
+import { type Wallet, type ethers, type JsonRpcApiProvider, type JsonRpcProvider, type JsonRpcSigner, type Provider, type Signer } from 'ethers';
 /**
  * Permitted ChainID's
  */
@@ -15,9 +16,6 @@ export declare enum FORK_MAPPING {
     /** Hoodi Chain. */
     '0x10000910' = 560048
 }
-/**
- * Permitted Chain Names
- */
 export declare const FORK_NAMES: Record<number, string>;
 /**
  * Node operator data
@@ -214,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. */
@@ -232,3 +230,21 @@ export type Incentives = {
  * String expected to be Ethereum Address
  */
 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 | Wallet;
+/**
+ * claimIncentives Response
+ */
+export type ClaimIncentivesResponse = {
+    txHash: string | null;
+};

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

@@ -1,9 +1,9 @@
-import { ethers, type Provider } from 'ethers';
+import { ethers } from 'ethers';
 import { DefinitionFlow } from './constants';
-import { type ClusterDefinition } from './types';
+import { type ProviderType, type ClusterDefinition } from './types';
 export declare const hexWithout0x: (hex: string) => string;
 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;
+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, 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.4",
+  "version": "2.4.6",
   "description": "A package for creating Distributed Validators using the Obol API.",
   "bugs": {
     "url": "https://github.com/obolnetwork/obol-sdk/issues"
@@ -23,7 +23,8 @@
     "lint": "eslint \"{src,test}/**/*.{js,ts}\" --fix",
     "lint-ci": "eslint \"{src,test}/**/*.{js,ts}\"",
     "prettier-ci": "prettier --check \"{src,test}/**/*.{js,ts}\"",
-    "prettier": "prettier --write \"{src,test}/**/*.{js,ts}\""
+    "prettier": "prettier --write \"{src,test}/**/*.{js,ts}\"",
+    "docs": "typedoc"
   },
   "main": "./dist/cjs/src/index.js",
   "module": "./dist/esm/src/index.js",
@@ -55,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",
@@ -79,8 +80,8 @@
     "release-it": "^17.2.1",
     "ts-jest": "^28.0.8",
     "tsup": "^6.7.0",
-    "typedoc": "^0.25.7",
-    "typedoc-plugin-markdown": "^4.0.0-next.50",
+    "typedoc": "^0.28.0",
+    "typedoc-plugin-markdown": "^4.5.2",
     "typescript": "~5.3.3"
   },
   "engines": {

package/src/incentiveHelpers.ts

@@ -1,16 +1,9 @@
-import { type ETH_ADDRESS } from './types';
-import {
-  Contract,
-  type JsonRpcApiProvider,
-  type JsonRpcProvider,
-  type Provider,
-  type Signer,
-} from 'ethers';
+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: Signer;
+  signer: SignerType;
   contractAddress: ETH_ADDRESS;
   index: number;
   operatorAddress: ETH_ADDRESS;
@@ -41,18 +34,15 @@ export const claimIncentivesFromMerkleDistributor = async (incentivesData: {
 };
 
 export const isClaimedFromMerkleDistributor = async (
-  chainId: number,
   contractAddress: ETH_ADDRESS,
   index: number,
-  provider: Provider | JsonRpcProvider | JsonRpcApiProvider | undefined | null,
+  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));