@obolnetwork/obol-sdk 2.4.2 → 2.4.4

package/dist/cjs/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@obolnetwork/obol-sdk",
-    "version": "2.4.2",
+    "version": "2.4.4",
     "description": "A package for creating Distributed Validators using the Obol API.",
     "bugs": {
         "url": "https://github.com/obolnetwork/obol-sdk/issues"

package/dist/cjs/src/incentives.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Incentives = void 0;
 const utils_1 = require("./utils");
 const types_1 = require("./types");
-const incentivesHalpers_1 = require("./incentivesHalpers");
+const incentiveHelpers_1 = require("./incentiveHelpers");
 const constants_1 = require("./constants");
 class Incentives {
     constructor(signer, chainId, request, provider) {
@@ -22,39 +22,42 @@ class Incentives {
         this.provider = provider;
     }
     /**
-     * Claims obol incentives from a Merkle Distributor contract.
+     * Claims obol incentives from a Merkle Distributor contract using just an address.
+     * The method automatically fetches incentives data and checks if already claimed.
      *
      * @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 {Object} incentivesData - The incentives data needed for claiming.
-     * @param {string} incentivesData.contractAddress - The address of the Merkle Distributor contract.
-     * @param {number} incentivesData.index - The index in the Merkle tree.
-     * @param {string} incentivesData.operatorAddress - The address of the operator.
-     * @param {number} incentivesData.amount - The amount to claim.
-     * @param {string[]} incentivesData.merkleProof - The Merkle proof.
-     * @returns {Promise<{ txHash: string }>} The transaction hash of the claim transaction.
-     * @throws Will throw an error if the contract is not available or the claim fails.
-     *
+     * @param {string} address - The address to claim incentives for
+     * @returns {Promise<{ txHash: string } | { alreadyClaimed: true }>} The transaction hash or already claimed status
+     * @throws Will throw an error if the incentives data is not found or the claim fails
      */
-    claimIncentives(incentivesData) {
+    claimIncentives(address) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.signer) {
                 throw new Error('Signer is required in claimIncentives');
             }
             try {
-                const isContractDeployed = yield (0, utils_1.isContractAvailable)(incentivesData.contractAddress, this.signer.provider);
+                const incentivesData = yield this.getIncentivesByAddress(address);
+                if (!(incentivesData === null || incentivesData === void 0 ? void 0 : incentivesData.contract_address)) {
+                    throw new Error(`No incentives found for address ${address}`);
+                }
+                const isContractDeployed = yield (0, utils_1.isContractAvailable)(incentivesData.contract_address, this.provider);
                 if (!isContractDeployed) {
-                    throw new Error(`Merkle Distributor contract is not available at address ${incentivesData.contractAddress}`);
+                    throw new Error(`Merkle Distributor contract is not available at address ${incentivesData.contract_address}`);
+                }
+                const claimed = yield this.isClaimed(incentivesData.contract_address, incentivesData.index);
+                if (claimed) {
+                    return { alreadyClaimed: true };
                 }
-                const { txHash } = yield (0, incentivesHalpers_1.claimIncentivesFromMerkleDistributor)({
+                const { txHash } = yield (0, incentiveHelpers_1.claimIncentivesFromMerkleDistributor)({
                     signer: this.signer,
-                    contractAddress: incentivesData.contractAddress,
+                    contractAddress: incentivesData.contract_address,
                     index: incentivesData.index,
-                    operatorAddress: incentivesData.operatorAddress,
+                    operatorAddress: incentivesData.operator_address,
                     amount: incentivesData.amount,
-                    merkleProof: incentivesData.merkleProof,
+                    merkleProof: incentivesData.merkle_proof,
                 });
                 return { txHash };
             }
@@ -74,7 +77,7 @@ class Incentives {
      */
     isClaimed(contractAddress, index) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield (0, incentivesHalpers_1.isClaimedFromMerkleDistributor)(this.chainId, contractAddress, index, this.provider);
+            return yield (0, incentiveHelpers_1.isClaimedFromMerkleDistributor)(this.chainId, contractAddress, index, this.provider);
         });
     }
     /**

package/dist/cjs/src/index.js

@@ -59,7 +59,7 @@ class Client extends base_js_1.Base {
         // Use the provided provider, or fall back to signer.provider if available
         this.provider =
             provider !== null && provider !== void 0 ? provider : (signer && 'provider' in signer ? signer.provider : undefined);
-        this.incentives = new incentives_js_1.Incentives(this.signer, this.chainId, this.request.bind(this), (this.provider = provider));
+        this.incentives = new incentives_js_1.Incentives(this.signer, this.chainId, this.request.bind(this), this.provider);
     }
     /**
      * Accepts Obol terms and conditions to be able to create or update data.

package/dist/cjs/src/types.js

@@ -16,6 +16,8 @@ var FORK_MAPPING;
     FORK_MAPPING[FORK_MAPPING["0x01017000"] = 17000] = "0x01017000";
     /** Sepolia. */
     FORK_MAPPING[FORK_MAPPING["0x90000069"] = 11155111] = "0x90000069";
+    /** Hoodi Chain. */
+    FORK_MAPPING[FORK_MAPPING["0x10000910"] = 560048] = "0x10000910";
 })(FORK_MAPPING || (exports.FORK_MAPPING = FORK_MAPPING = {}));
 /**
  * Permitted Chain Names
@@ -31,4 +33,6 @@ exports.FORK_NAMES = {
     [FORK_MAPPING['0x01017000']]: 'holesky',
     /** Sepolia. */
     [FORK_MAPPING['0x90000069']]: 'sepolia',
+    /** Hoodi. */
+    [FORK_MAPPING['0x10000910']]: 'hoodi',
 };

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

@@ -36,117 +36,145 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const index_1 = require("../src/index");
 const utils = __importStar(require("../src/utils"));
-const incentivesHelpers = __importStar(require("../src/incentivesHalpers"));
+const incentivesHelpers = __importStar(require("../src/incentiveHelpers"));
 const constants_1 = require("../src/constants");
+const globals_1 = require("@jest/globals");
 const mnemonic = (_b = (_a = ethers_1.ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) !== null && _b !== void 0 ? _b : '';
 const privateKey = ethers_1.ethers.Wallet.fromPhrase(mnemonic).privateKey;
 const provider = new ethers_1.JsonRpcProvider('https://ethereum-holesky.publicnode.com');
 const wallet = new ethers_1.ethers.Wallet(privateKey, provider);
 const mockSigner = wallet.connect(provider);
 const baseUrl = 'https://obol-api-dev.gcp.obol.tech';
-global.fetch = jest.fn();
-describe('Client.incentives', () => {
+// Fix the type error by properly typing the mock function
+global.fetch = globals_1.jest.fn();
+(0, globals_1.describe)('Client.incentives', () => {
     let clientInstance;
     const mockIncentivesData = {
-        contractAddress: '0x1234567890abcdef1234567890abcdef12345678',
+        contract_address: '0x1234567890abcdef1234567890abcdef12345678',
         index: 5,
-        operatorAddress: '0xabcdef1234567890abcdef1234567890abcdef12',
-        amount: 1000000000000000000,
-        merkleProof: [
+        operator_address: '0xabcdef1234567890abcdef1234567890abcdef12',
+        amount: '1000000000000000000',
+        merkle_proof: [
             '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
             '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
         ],
     };
-    beforeEach(() => {
-        jest.clearAllMocks();
+    (0, globals_1.beforeEach)(() => {
+        globals_1.jest.clearAllMocks();
         clientInstance = new index_1.Client({ baseUrl, chainId: 17000 }, mockSigner);
         global.fetch.mockReset();
     });
-    test('claimIncentives should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, globals_1.test)('claimIncentives should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
         const clientWithoutSigner = new index_1.Client({
             baseUrl,
             chainId: 17000,
         });
-        yield expect(clientWithoutSigner.incentives.claimIncentives(mockIncentivesData)).rejects.toThrow('Signer is required in claimIncentives');
+        yield (0, globals_1.expect)(clientWithoutSigner.incentives.claimIncentives(mockIncentivesData.operator_address)).rejects.toThrow('Signer is required in claimIncentives');
     }));
-    test('claimIncentives should throw an error if contract is not available', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest
+    (0, globals_1.test)('claimIncentives should throw an error if contract is not available', () => __awaiter(void 0, void 0, void 0, function* () {
+        globals_1.jest
+            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
+            .mockResolvedValue(mockIncentivesData);
+        globals_1.jest.spyOn(clientInstance.incentives, 'isClaimed').mockResolvedValue(false);
+        globals_1.jest
             .spyOn(utils, 'isContractAvailable')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(false); }));
-        yield expect(clientInstance.incentives.claimIncentives(mockIncentivesData)).rejects.toThrow(`Merkle Distributor contract is not available at address ${mockIncentivesData.contractAddress}`);
+        yield (0, globals_1.expect)(clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address)).rejects.toThrow(`Merkle Distributor contract is not available at address ${mockIncentivesData.contract_address}`);
     }));
-    test('claimIncentives should return txHash on successful claim', () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, globals_1.test)('claimIncentives should return txHash on successful claim', () => __awaiter(void 0, void 0, void 0, function* () {
         const mockTxHash = '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
-        jest
+        globals_1.jest
+            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
+            .mockResolvedValue(mockIncentivesData);
+        globals_1.jest.spyOn(clientInstance.incentives, 'isClaimed').mockResolvedValue(false);
+        globals_1.jest
             .spyOn(utils, 'isContractAvailable')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-        jest
+        globals_1.jest
             .spyOn(incentivesHelpers, 'claimIncentivesFromMerkleDistributor')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve({ txHash: mockTxHash }); }));
-        const result = yield clientInstance.incentives.claimIncentives(mockIncentivesData);
-        expect(result).toEqual({ txHash: mockTxHash });
-        expect(incentivesHelpers.claimIncentivesFromMerkleDistributor).toHaveBeenCalledWith({
+        const result = yield clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address);
+        (0, globals_1.expect)(result).toEqual({ txHash: mockTxHash });
+        (0, globals_1.expect)(incentivesHelpers.claimIncentivesFromMerkleDistributor).toHaveBeenCalledWith({
             signer: mockSigner,
-            contractAddress: mockIncentivesData.contractAddress,
+            contractAddress: mockIncentivesData.contract_address,
             index: mockIncentivesData.index,
-            operatorAddress: mockIncentivesData.operatorAddress,
+            operatorAddress: mockIncentivesData.operator_address,
             amount: mockIncentivesData.amount,
-            merkleProof: mockIncentivesData.merkleProof,
+            merkleProof: mockIncentivesData.merkle_proof,
         });
     }));
-    test('claimIncentives should throw an error if helper function fails', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest
+    (0, globals_1.test)('claimIncentives should return alreadyClaimed when incentives are already claimed', () => __awaiter(void 0, void 0, void 0, function* () {
+        globals_1.jest
+            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
+            .mockResolvedValue(mockIncentivesData);
+        globals_1.jest.spyOn(clientInstance.incentives, 'isClaimed').mockResolvedValue(true);
+        const result = yield clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address);
+        (0, globals_1.expect)(result).toEqual({ alreadyClaimed: true });
+        (0, globals_1.expect)(incentivesHelpers.claimIncentivesFromMerkleDistributor).not.toHaveBeenCalled();
+    }));
+    (0, globals_1.test)('claimIncentives should throw an error if no incentives found for address', () => __awaiter(void 0, void 0, void 0, function* () {
+        globals_1.jest
+            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
+            .mockRejectedValue(new Error('No incentives found for address'));
+        yield (0, globals_1.expect)(clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address)).rejects.toThrow('Failed to claim incentives: No incentives found for address');
+    }));
+    (0, globals_1.test)('claimIncentives should throw an error if helper function fails', () => __awaiter(void 0, void 0, void 0, function* () {
+        globals_1.jest
+            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
+            .mockResolvedValue(mockIncentivesData);
+        globals_1.jest.spyOn(clientInstance.incentives, 'isClaimed').mockResolvedValue(false);
+        globals_1.jest
             .spyOn(utils, 'isContractAvailable')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-        jest
+        globals_1.jest
             .spyOn(incentivesHelpers, 'claimIncentivesFromMerkleDistributor')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
             throw new Error('Helper function error');
         }));
-        yield expect(clientInstance.incentives.claimIncentives(mockIncentivesData)).rejects.toThrow('Failed to claim incentives: Helper function error');
+        yield (0, globals_1.expect)(clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address)).rejects.toThrow('Failed to claim incentives: Helper function error');
     }));
-    test('incentives should be initialized with the same chainId as client', () => {
+    (0, globals_1.test)('incentives should be initialized with the same chainId as client', () => {
         const customChainId = 5;
         const clientWithCustomChain = new index_1.Client({ baseUrl, chainId: customChainId }, mockSigner);
-        expect(clientWithCustomChain.incentives.chainId).toBe(customChainId);
+        (0, globals_1.expect)(clientWithCustomChain.incentives.chainId).toBe(customChainId);
     });
-    test('isClaimed should return true when incentive is claimed', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest
+    (0, globals_1.test)('isClaimed should return true when incentive is claimed', () => __awaiter(void 0, void 0, void 0, function* () {
+        globals_1.jest
             .spyOn(incentivesHelpers, 'isClaimedFromMerkleDistributor')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-        const result = yield clientInstance.incentives.isClaimed(mockIncentivesData.contractAddress, mockIncentivesData.index);
-        expect(result).toBe(true);
-        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(clientInstance.incentives.chainId, mockIncentivesData.contractAddress, mockIncentivesData.index, undefined);
+        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, {});
     }));
-    test('isClaimed should return false when incentive is not claimed', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest
+    (0, globals_1.test)('isClaimed should return false when incentive is not claimed', () => __awaiter(void 0, void 0, void 0, function* () {
+        globals_1.jest
             .spyOn(incentivesHelpers, 'isClaimedFromMerkleDistributor')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(false); }));
-        const result = yield clientInstance.incentives.isClaimed(mockIncentivesData.contractAddress, mockIncentivesData.index);
-        expect(result).toBe(false);
+        const result = yield clientInstance.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index);
+        (0, globals_1.expect)(result).toBe(false);
     }));
-    test('isClaimed should throw an error if helper function fails', () => __awaiter(void 0, void 0, void 0, function* () {
-        jest
+    (0, globals_1.test)('isClaimed should throw an error if helper function fails', () => __awaiter(void 0, void 0, void 0, function* () {
+        globals_1.jest
             .spyOn(incentivesHelpers, 'isClaimedFromMerkleDistributor')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
             throw new Error('Helper function error');
         }));
-        yield expect(clientInstance.incentives.isClaimed(mockIncentivesData.contractAddress, mockIncentivesData.index)).rejects.toThrow('Helper function error');
+        yield (0, globals_1.expect)(clientInstance.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index)).rejects.toThrow('Helper function error');
     }));
-    test('isClaimed should work with a provider and a without signer', () => __awaiter(void 0, void 0, void 0, function* () {
-        // Create a client without a signer
+    (0, globals_1.test)('isClaimed should work with a provider and a without signer', () => __awaiter(void 0, void 0, void 0, function* () {
         const clientWithoutSigner = new index_1.Client({
             baseUrl,
             chainId: 17000,
         }, undefined, provider);
-        jest
+        globals_1.jest
             .spyOn(incentivesHelpers, 'isClaimedFromMerkleDistributor')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-        const result = yield clientWithoutSigner.incentives.isClaimed(mockIncentivesData.contractAddress, mockIncentivesData.index);
-        expect(result).toBe(true);
-        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(clientWithoutSigner.incentives.chainId, mockIncentivesData.contractAddress, mockIncentivesData.index, provider);
+        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);
     }));
-    test('getIncentivesByAddress should make the correct API request', () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, globals_1.test)('getIncentivesByAddress should make the correct API request', () => __awaiter(void 0, void 0, void 0, function* () {
         const mockAddress = '0x1234567890abcdef1234567890abcdef12345678';
         const mockIncentives = {
             operator_address: '0x8c00157cae72c4ed6a1f8bfb60205601f0252e26',
@@ -162,13 +190,13 @@ describe('Client.incentives', () => {
             headers: new Headers(),
         });
         const result = yield clientInstance.incentives.getIncentivesByAddress(mockAddress);
-        expect(result).toEqual(mockIncentives);
-        expect(global.fetch).toHaveBeenCalledWith(`${baseUrl}/${constants_1.DEFAULT_BASE_VERSION}/address/incentives/holesky/${mockAddress}`, expect.objectContaining({ method: 'GET' }));
+        (0, globals_1.expect)(result).toEqual(mockIncentives);
+        (0, globals_1.expect)(global.fetch).toHaveBeenCalledWith(`${baseUrl}/${constants_1.DEFAULT_BASE_VERSION}/address/incentives/holesky/${mockAddress}`, globals_1.expect.objectContaining({ method: 'GET' }));
     }));
-    test('getIncentivesByAddress should handle API errors', () => __awaiter(void 0, void 0, void 0, function* () {
+    (0, globals_1.test)('getIncentivesByAddress should handle API errors', () => __awaiter(void 0, void 0, void 0, function* () {
         const mockAddress = '0x1234567890abcdef1234567890abcdef12345678';
         global.fetch.mockRejectedValue(new Error('Network error'));
-        yield expect(clientInstance.incentives.getIncentivesByAddress(mockAddress)).rejects.toThrow();
-        expect(global.fetch).toHaveBeenCalled();
+        yield (0, globals_1.expect)(clientInstance.incentives.getIncentivesByAddress(mockAddress)).rejects.toThrow();
+        (0, globals_1.expect)(global.fetch).toHaveBeenCalled();
     }));
 });

package/dist/esm/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@obolnetwork/obol-sdk",
-    "version": "2.4.2",
+    "version": "2.4.4",
     "description": "A package for creating Distributed Validators using the Obol API.",
     "bugs": {
         "url": "https://github.com/obolnetwork/obol-sdk/issues"

package/dist/esm/src/incentives.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { isContractAvailable } from './utils';
 import { FORK_NAMES, } from './types';
-import { claimIncentivesFromMerkleDistributor, isClaimedFromMerkleDistributor, } from './incentivesHalpers';
+import { claimIncentivesFromMerkleDistributor, isClaimedFromMerkleDistributor, } from './incentiveHelpers';
 import { DEFAULT_BASE_VERSION } from './constants';
 export class Incentives {
     constructor(signer, chainId, request, provider) {
@@ -19,39 +19,42 @@ export class Incentives {
         this.provider = provider;
     }
     /**
-     * Claims obol incentives from a Merkle Distributor contract.
+     * Claims obol incentives from a Merkle Distributor contract using just an address.
+     * The method automatically fetches incentives data and checks if already claimed.
      *
      * @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 {Object} incentivesData - The incentives data needed for claiming.
-     * @param {string} incentivesData.contractAddress - The address of the Merkle Distributor contract.
-     * @param {number} incentivesData.index - The index in the Merkle tree.
-     * @param {string} incentivesData.operatorAddress - The address of the operator.
-     * @param {number} incentivesData.amount - The amount to claim.
-     * @param {string[]} incentivesData.merkleProof - The Merkle proof.
-     * @returns {Promise<{ txHash: string }>} The transaction hash of the claim transaction.
-     * @throws Will throw an error if the contract is not available or the claim fails.
-     *
+     * @param {string} address - The address to claim incentives for
+     * @returns {Promise<{ txHash: string } | { alreadyClaimed: true }>} The transaction hash or already claimed status
+     * @throws Will throw an error if the incentives data is not found or the claim fails
      */
-    claimIncentives(incentivesData) {
+    claimIncentives(address) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.signer) {
                 throw new Error('Signer is required in claimIncentives');
             }
             try {
-                const isContractDeployed = yield isContractAvailable(incentivesData.contractAddress, this.signer.provider);
+                const incentivesData = yield this.getIncentivesByAddress(address);
+                if (!(incentivesData === null || incentivesData === void 0 ? void 0 : incentivesData.contract_address)) {
+                    throw new Error(`No incentives found for address ${address}`);
+                }
+                const isContractDeployed = yield isContractAvailable(incentivesData.contract_address, this.provider);
                 if (!isContractDeployed) {
-                    throw new Error(`Merkle Distributor contract is not available at address ${incentivesData.contractAddress}`);
+                    throw new Error(`Merkle Distributor contract is not available at address ${incentivesData.contract_address}`);
+                }
+                const claimed = yield this.isClaimed(incentivesData.contract_address, incentivesData.index);
+                if (claimed) {
+                    return { alreadyClaimed: true };
                 }
                 const { txHash } = yield claimIncentivesFromMerkleDistributor({
                     signer: this.signer,
-                    contractAddress: incentivesData.contractAddress,
+                    contractAddress: incentivesData.contract_address,
                     index: incentivesData.index,
-                    operatorAddress: incentivesData.operatorAddress,
+                    operatorAddress: incentivesData.operator_address,
                     amount: incentivesData.amount,
-                    merkleProof: incentivesData.merkleProof,
+                    merkleProof: incentivesData.merkle_proof,
                 });
                 return { txHash };
             }

package/dist/esm/src/index.js

@@ -42,7 +42,7 @@ export class Client extends Base {
         // Use the provided provider, or fall back to signer.provider if available
         this.provider =
             provider !== null && provider !== void 0 ? provider : (signer && 'provider' in signer ? signer.provider : undefined);
-        this.incentives = new Incentives(this.signer, this.chainId, this.request.bind(this), (this.provider = provider));
+        this.incentives = new Incentives(this.signer, this.chainId, this.request.bind(this), this.provider);
     }
     /**
      * Accepts Obol terms and conditions to be able to create or update data.

package/dist/esm/src/types.js

@@ -13,6 +13,8 @@ export var FORK_MAPPING;
     FORK_MAPPING[FORK_MAPPING["0x01017000"] = 17000] = "0x01017000";
     /** Sepolia. */
     FORK_MAPPING[FORK_MAPPING["0x90000069"] = 11155111] = "0x90000069";
+    /** Hoodi Chain. */
+    FORK_MAPPING[FORK_MAPPING["0x10000910"] = 560048] = "0x10000910";
 })(FORK_MAPPING || (FORK_MAPPING = {}));
 /**
  * Permitted Chain Names
@@ -28,4 +30,6 @@ export const FORK_NAMES = {
     [FORK_MAPPING['0x01017000']]: 'holesky',
     /** Sepolia. */
     [FORK_MAPPING['0x90000069']]: 'sepolia',
+    /** Hoodi. */
+    [FORK_MAPPING['0x10000910']]: 'hoodi',
 };

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

@@ -11,23 +11,25 @@ var _a, _b;
 import { ethers, JsonRpcProvider } from 'ethers';
 import { Client } from '../src/index';
 import * as utils from '../src/utils';
-import * as incentivesHelpers from '../src/incentivesHalpers';
+import * as incentivesHelpers from '../src/incentiveHelpers';
 import { DEFAULT_BASE_VERSION } from '../src/constants';
+import { jest, describe, beforeEach, test, expect } from '@jest/globals';
 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 baseUrl = 'https://obol-api-dev.gcp.obol.tech';
+// Fix the type error by properly typing the mock function
 global.fetch = jest.fn();
 describe('Client.incentives', () => {
     let clientInstance;
     const mockIncentivesData = {
-        contractAddress: '0x1234567890abcdef1234567890abcdef12345678',
+        contract_address: '0x1234567890abcdef1234567890abcdef12345678',
         index: 5,
-        operatorAddress: '0xabcdef1234567890abcdef1234567890abcdef12',
-        amount: 1000000000000000000,
-        merkleProof: [
+        operator_address: '0xabcdef1234567890abcdef1234567890abcdef12',
+        amount: '1000000000000000000',
+        merkle_proof: [
             '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
             '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
         ],
@@ -42,34 +44,61 @@ describe('Client.incentives', () => {
             baseUrl,
             chainId: 17000,
         });
-        yield expect(clientWithoutSigner.incentives.claimIncentives(mockIncentivesData)).rejects.toThrow('Signer is required in claimIncentives');
+        yield expect(clientWithoutSigner.incentives.claimIncentives(mockIncentivesData.operator_address)).rejects.toThrow('Signer is required in claimIncentives');
     }));
     test('claimIncentives should throw an error if contract is not available', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
+            .mockResolvedValue(mockIncentivesData);
+        jest.spyOn(clientInstance.incentives, 'isClaimed').mockResolvedValue(false);
         jest
             .spyOn(utils, 'isContractAvailable')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(false); }));
-        yield expect(clientInstance.incentives.claimIncentives(mockIncentivesData)).rejects.toThrow(`Merkle Distributor contract is not available at address ${mockIncentivesData.contractAddress}`);
+        yield expect(clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address)).rejects.toThrow(`Merkle Distributor contract is not available at address ${mockIncentivesData.contract_address}`);
     }));
     test('claimIncentives should return txHash on successful claim', () => __awaiter(void 0, void 0, void 0, function* () {
         const mockTxHash = '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
+        jest
+            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
+            .mockResolvedValue(mockIncentivesData);
+        jest.spyOn(clientInstance.incentives, 'isClaimed').mockResolvedValue(false);
         jest
             .spyOn(utils, 'isContractAvailable')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
         jest
             .spyOn(incentivesHelpers, 'claimIncentivesFromMerkleDistributor')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve({ txHash: mockTxHash }); }));
-        const result = yield clientInstance.incentives.claimIncentives(mockIncentivesData);
+        const result = yield clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address);
         expect(result).toEqual({ txHash: mockTxHash });
         expect(incentivesHelpers.claimIncentivesFromMerkleDistributor).toHaveBeenCalledWith({
             signer: mockSigner,
-            contractAddress: mockIncentivesData.contractAddress,
+            contractAddress: mockIncentivesData.contract_address,
             index: mockIncentivesData.index,
-            operatorAddress: mockIncentivesData.operatorAddress,
+            operatorAddress: mockIncentivesData.operator_address,
             amount: mockIncentivesData.amount,
-            merkleProof: mockIncentivesData.merkleProof,
+            merkleProof: mockIncentivesData.merkle_proof,
         });
     }));
+    test('claimIncentives should return alreadyClaimed 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(incentivesHelpers.claimIncentivesFromMerkleDistributor).not.toHaveBeenCalled();
+    }));
+    test('claimIncentives should throw an error if no incentives found for address', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
+            .mockRejectedValue(new Error('No incentives found for address'));
+        yield expect(clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address)).rejects.toThrow('Failed to claim incentives: No incentives found for address');
+    }));
     test('claimIncentives should throw an error if helper function fails', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(clientInstance.incentives, 'getIncentivesByAddress')
+            .mockResolvedValue(mockIncentivesData);
+        jest.spyOn(clientInstance.incentives, 'isClaimed').mockResolvedValue(false);
         jest
             .spyOn(utils, 'isContractAvailable')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
@@ -78,7 +107,7 @@ describe('Client.incentives', () => {
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
             throw new Error('Helper function error');
         }));
-        yield expect(clientInstance.incentives.claimIncentives(mockIncentivesData)).rejects.toThrow('Failed to claim incentives: Helper function error');
+        yield expect(clientInstance.incentives.claimIncentives(mockIncentivesData.operator_address)).rejects.toThrow('Failed to claim incentives: Helper function error');
     }));
     test('incentives should be initialized with the same chainId as client', () => {
         const customChainId = 5;
@@ -89,15 +118,15 @@ describe('Client.incentives', () => {
         jest
             .spyOn(incentivesHelpers, 'isClaimedFromMerkleDistributor')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-        const result = yield clientInstance.incentives.isClaimed(mockIncentivesData.contractAddress, mockIncentivesData.index);
+        const result = yield clientInstance.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index);
         expect(result).toBe(true);
-        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(clientInstance.incentives.chainId, mockIncentivesData.contractAddress, mockIncentivesData.index, undefined);
+        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(clientInstance.incentives.chainId, mockIncentivesData.contract_address, mockIncentivesData.index, {});
     }));
     test('isClaimed should return false when incentive is not claimed', () => __awaiter(void 0, void 0, void 0, function* () {
         jest
             .spyOn(incentivesHelpers, 'isClaimedFromMerkleDistributor')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(false); }));
-        const result = yield clientInstance.incentives.isClaimed(mockIncentivesData.contractAddress, mockIncentivesData.index);
+        const result = yield clientInstance.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index);
         expect(result).toBe(false);
     }));
     test('isClaimed should throw an error if helper function fails', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -106,10 +135,9 @@ describe('Client.incentives', () => {
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
             throw new Error('Helper function error');
         }));
-        yield expect(clientInstance.incentives.isClaimed(mockIncentivesData.contractAddress, mockIncentivesData.index)).rejects.toThrow('Helper function error');
+        yield expect(clientInstance.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index)).rejects.toThrow('Helper function error');
     }));
     test('isClaimed should work with a provider and a without signer', () => __awaiter(void 0, void 0, void 0, function* () {
-        // Create a client without a signer
         const clientWithoutSigner = new Client({
             baseUrl,
             chainId: 17000,
@@ -117,9 +145,9 @@ describe('Client.incentives', () => {
         jest
             .spyOn(incentivesHelpers, 'isClaimedFromMerkleDistributor')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-        const result = yield clientWithoutSigner.incentives.isClaimed(mockIncentivesData.contractAddress, mockIncentivesData.index);
+        const result = yield clientWithoutSigner.incentives.isClaimed(mockIncentivesData.contract_address, mockIncentivesData.index);
         expect(result).toBe(true);
-        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(clientWithoutSigner.incentives.chainId, mockIncentivesData.contractAddress, mockIncentivesData.index, provider);
+        expect(incentivesHelpers.isClaimedFromMerkleDistributor).toHaveBeenCalledWith(clientWithoutSigner.incentives.chainId, 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/types/src/{incentivesHalpers.d.ts → incentiveHelpers.d.ts}

@@ -5,7 +5,7 @@ export declare const claimIncentivesFromMerkleDistributor: (incentivesData: {
     contractAddress: ETH_ADDRESS;
     index: number;
     operatorAddress: ETH_ADDRESS;
-    amount: number;
+    amount: string;
     merkleProof: string[];
 }) => Promise<{
     txHash: string;

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

@@ -1,4 +1,4 @@
-import { type JsonRpcApiProvider, type JsonRpcProvider, type JsonRpcSigner, type Provider, type Signer } from 'ethers';
+import type { JsonRpcApiProvider, JsonRpcProvider, JsonRpcSigner, Provider, Signer } from 'ethers';
 import { type Incentives as IncentivesType, type ETH_ADDRESS } from './types';
 export declare class Incentives {
     private readonly signer;
@@ -7,30 +7,21 @@ export declare class Incentives {
     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);
     /**
-     * Claims obol incentives from a Merkle Distributor contract.
+     * Claims obol incentives from a Merkle Distributor contract using just an address.
+     * The method automatically fetches incentives data and checks if already claimed.
      *
      * @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 {Object} incentivesData - The incentives data needed for claiming.
-     * @param {string} incentivesData.contractAddress - The address of the Merkle Distributor contract.
-     * @param {number} incentivesData.index - The index in the Merkle tree.
-     * @param {string} incentivesData.operatorAddress - The address of the operator.
-     * @param {number} incentivesData.amount - The amount to claim.
-     * @param {string[]} incentivesData.merkleProof - The Merkle proof.
-     * @returns {Promise<{ txHash: string }>} The transaction hash of the claim transaction.
-     * @throws Will throw an error if the contract is not available or the claim fails.
-     *
+     * @param {string} address - The address to claim incentives for
+     * @returns {Promise<{ txHash: string } | { alreadyClaimed: true }>} The transaction hash or already claimed status
+     * @throws Will throw an error if the incentives data is not found or the claim fails
      */
-    claimIncentives(incentivesData: {
-        contractAddress: ETH_ADDRESS;
-        index: number;
-        operatorAddress: ETH_ADDRESS;
-        amount: number;
-        merkleProof: string[];
-    }): Promise<{
+    claimIncentives(address: string): Promise<{
         txHash: string;
+    } | {
+        alreadyClaimed: true;
     }>;
     /**
      * Read isClaimed.

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

@@ -11,7 +11,9 @@ export declare enum FORK_MAPPING {
     /** Holesky. */
     '0x01017000' = 17000,
     /** Sepolia. */
-    '0x90000069' = 11155111
+    '0x90000069' = 11155111,
+    /** Hoodi Chain. */
+    '0x10000910' = 560048
 }
 /**
  * Permitted Chain Names

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obolnetwork/obol-sdk",
-  "version": "2.4.2",
+  "version": "2.4.4",
   "description": "A package for creating Distributed Validators using the Obol API.",
   "bugs": {
     "url": "https://github.com/obolnetwork/obol-sdk/issues"

package/src/{incentivesHalpers.ts → incentiveHelpers.ts}

@@ -14,7 +14,7 @@ export const claimIncentivesFromMerkleDistributor = async (incentivesData: {
   contractAddress: ETH_ADDRESS;
   index: number;
   operatorAddress: ETH_ADDRESS;
-  amount: number;
+  amount: string;
   merkleProof: string[];
 }): Promise<{ txHash: string }> => {
   try {

package/src/incentives.ts

@@ -1,9 +1,9 @@
-import {
-  type JsonRpcApiProvider,
-  type JsonRpcProvider,
-  type JsonRpcSigner,
-  type Provider,
-  type Signer,
+import type {
+  JsonRpcApiProvider,
+  JsonRpcProvider,
+  JsonRpcSigner,
+  Provider,
+  Signer,
 } from 'ethers';
 import { isContractAvailable } from './utils';
 import {
@@ -14,7 +14,7 @@ import {
 import {
   claimIncentivesFromMerkleDistributor,
   isClaimedFromMerkleDistributor,
-} from './incentivesHalpers';
+} from './incentiveHelpers';
 import { DEFAULT_BASE_VERSION } from './constants';
 
 export class Incentives {
@@ -50,51 +50,58 @@ export class Incentives {
   }
 
   /**
-   * Claims obol incentives from a Merkle Distributor contract.
+   * Claims obol incentives from a Merkle Distributor contract using just an address.
+   * The method automatically fetches incentives data and checks if already claimed.
    *
    * @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 {Object} incentivesData - The incentives data needed for claiming.
-   * @param {string} incentivesData.contractAddress - The address of the Merkle Distributor contract.
-   * @param {number} incentivesData.index - The index in the Merkle tree.
-   * @param {string} incentivesData.operatorAddress - The address of the operator.
-   * @param {number} incentivesData.amount - The amount to claim.
-   * @param {string[]} incentivesData.merkleProof - The Merkle proof.
-   * @returns {Promise<{ txHash: string }>} The transaction hash of the claim transaction.
-   * @throws Will throw an error if the contract is not available or the claim fails.
-   *
+   * @param {string} address - The address to claim incentives for
+   * @returns {Promise<{ txHash: string } | { alreadyClaimed: true }>} The transaction hash or already claimed status
+   * @throws Will throw an error if the incentives data is not found or the claim fails
    */
-  async claimIncentives(incentivesData: {
-    contractAddress: ETH_ADDRESS;
-    index: number;
-    operatorAddress: ETH_ADDRESS;
-    amount: number;
-    merkleProof: string[];
-  }): Promise<{ txHash: string }> {
+  async claimIncentives(
+    address: string,
+  ): Promise<{ txHash: string } | { alreadyClaimed: true }> {
     if (!this.signer) {
       throw new Error('Signer is required in claimIncentives');
     }
+
     try {
+      const incentivesData = await this.getIncentivesByAddress(address);
+
+      if (!incentivesData?.contract_address) {
+        throw new Error(`No incentives found for address ${address}`);
+      }
+
       const isContractDeployed = await isContractAvailable(
-        incentivesData.contractAddress,
-        this.signer.provider as Provider,
+        incentivesData.contract_address,
+        this.provider as Provider,
       );
 
       if (!isContractDeployed) {
         throw new Error(
-          `Merkle Distributor contract is not available at address ${incentivesData.contractAddress}`,
+          `Merkle Distributor contract is not available at address ${incentivesData.contract_address}`,
         );
       }
 
+      const claimed = await this.isClaimed(
+        incentivesData.contract_address,
+        incentivesData.index,
+      );
+
+      if (claimed) {
+        return { alreadyClaimed: true };
+      }
+
       const { txHash } = await claimIncentivesFromMerkleDistributor({
         signer: this.signer,
-        contractAddress: incentivesData.contractAddress,
+        contractAddress: incentivesData.contract_address,
         index: incentivesData.index,
-        operatorAddress: incentivesData.operatorAddress,
+        operatorAddress: incentivesData.operator_address,
         amount: incentivesData.amount,
-        merkleProof: incentivesData.merkleProof,
+        merkleProof: incentivesData.merkle_proof,
       });
 
       return { txHash };

package/src/index.ts

@@ -98,7 +98,7 @@ export class Client extends Base {
       this.signer,
       this.chainId,
       this.request.bind(this),
-      (this.provider = provider),
+      this.provider,
     );
   }
 

package/src/types.ts

@@ -16,6 +16,9 @@ export enum FORK_MAPPING {
 
   /** Sepolia. */
   '0x90000069' = 11155111,
+
+  /** Hoodi Chain. */
+  '0x10000910' = 560048,
 }
 
 /**
@@ -36,6 +39,9 @@ export const FORK_NAMES: Record<number, string> = {
 
   /** Sepolia. */
   [FORK_MAPPING['0x90000069']]: 'sepolia',
+
+  /** Hoodi. */
+  [FORK_MAPPING['0x10000910']]: 'hoodi',
 };
 
 /**