@obolnetwork/obol-sdk 2.3.0 → 2.4.0

package/dist/cjs/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@obolnetwork/obol-sdk",
-    "version": "2.3.0",
+    "version": "2.4.0",
     "description": "A package for creating Distributed Validators using the Obol API.",
     "bugs": {
         "url": "https://github.com/obolnetwork/obol-sdk/issues"
@@ -15,7 +15,7 @@
         "compile": "tsc -b ./tsconfig.cjs.json ./tsconfig.esm.json ./tsconfig.types.json",
         "build:clean": "rm -rf ./dist",
         "build": "npm-run-all build:clean compile",
-        "test": "jest ./test/methods.test.ts",
+        "test": "jest ./test/*.test.ts",
         "generate-typedoc": "typedoc",
         "npm:publish": "npm publish --tag latest",
         "release": "release-it",

package/dist/cjs/src/abi/MerkleDistributorWithDeadline.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerkleDistributorABI = void 0;
+exports.MerkleDistributorABI = {
+    abi: [
+        {
+            inputs: [
+                { internalType: 'address', name: 'token_', type: 'address' },
+                { internalType: 'bytes32', name: 'merkleRoot_', type: 'bytes32' },
+            ],
+            stateMutability: 'nonpayable',
+            type: 'constructor',
+        },
+        {
+            anonymous: false,
+            inputs: [
+                {
+                    indexed: false,
+                    internalType: 'uint256',
+                    name: 'index',
+                    type: 'uint256',
+                },
+                {
+                    indexed: false,
+                    internalType: 'address',
+                    name: 'account',
+                    type: 'address',
+                },
+                {
+                    indexed: false,
+                    internalType: 'uint256',
+                    name: 'amount',
+                    type: 'uint256',
+                },
+            ],
+            name: 'Claimed',
+            type: 'event',
+        },
+        {
+            inputs: [
+                { internalType: 'uint256', name: 'index', type: 'uint256' },
+                { internalType: 'address', name: 'account', type: 'address' },
+                { internalType: 'uint256', name: 'amount', type: 'uint256' },
+                { internalType: 'bytes32[]', name: 'merkleProof', type: 'bytes32[]' },
+            ],
+            name: 'claim',
+            outputs: [],
+            stateMutability: 'nonpayable',
+            type: 'function',
+        },
+        {
+            inputs: [{ internalType: 'uint256', name: 'index', type: 'uint256' }],
+            name: 'isClaimed',
+            outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+            stateMutability: 'view',
+            type: 'function',
+        },
+        {
+            inputs: [],
+            name: 'merkleRoot',
+            outputs: [{ internalType: 'bytes32', name: '', type: 'bytes32' }],
+            stateMutability: 'view',
+            type: 'function',
+        },
+        {
+            inputs: [],
+            name: 'token',
+            outputs: [{ internalType: 'address', name: '', type: 'address' }],
+            stateMutability: 'view',
+            type: 'function',
+        },
+    ],
+};

package/dist/cjs/src/incentives.js

@@ -0,0 +1,92 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Incentives = void 0;
+const utils_1 = require("./utils");
+const incentivesHalpers_1 = require("./incentivesHalpers");
+const constants_1 = require("./constants");
+class Incentives {
+    constructor(signer, chainId, request) {
+        this.signer = signer;
+        this.chainId = chainId;
+        this.request = request;
+    }
+    /**
+     * Claims obol incentives from a Merkle Distributor contract.
+     *
+     * @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.
+     *
+     */
+    claimIncentives(incentivesData) {
+        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);
+                if (!isContractDeployed) {
+                    throw new Error(`Merkle Distributor contract is not available at address ${incentivesData.contractAddress}`);
+                }
+                const { txHash } = yield (0, incentivesHalpers_1.claimIncentivesFromMerkleDistributor)({
+                    signer: this.signer,
+                    contractAddress: incentivesData.contractAddress,
+                    index: incentivesData.index,
+                    operatorAddress: incentivesData.operatorAddress,
+                    amount: incentivesData.amount,
+                    merkleProof: incentivesData.merkleProof,
+                });
+                return { txHash };
+            }
+            catch (error) {
+                console.log('Error claiming incentives:', error);
+                throw new Error(`Failed to claim incentives: ${error.message}`);
+            }
+        });
+    }
+    /**
+     * Read isClaimed.
+     *
+     * @param {ETH_ADDRESS} contractAddress - Address of the Merkle Distributor Contract
+     * @param {ETH_ADDRESS} index - operator index in merkle tree
+     * @returns {Promise<boolean>} true if incentives are already claime
+     *
+     */
+    isClaimed(contractAddress, index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, incentivesHalpers_1.isClaimedFromMerkleDistributor)(this.chainId, contractAddress, index);
+        });
+    }
+    /**
+     * @param address - Operator address
+     * @returns {Promise<IncentivesType>} The matched incentives from DB
+     * @throws On not found if address not found.
+     */
+    getIncentivesByAddress(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const incentives = yield this.request(`/${constants_1.DEFAULT_BASE_VERSION}/address/incentives/${address}`, {
+                method: 'GET',
+            });
+            return incentives;
+        });
+    }
+}
+exports.Incentives = Incentives;

package/dist/cjs/src/incentivesHalpers.js

@@ -0,0 +1,41 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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);
+        const tx = yield contract.claim(BigInt(incentivesData.index), incentivesData.operatorAddress, BigInt(incentivesData.amount), incentivesData.merkleProof);
+        const receipt = yield tx.wait();
+        return { txHash: receipt.hash };
+    }
+    catch (error) {
+        console.log('Error claiming incentives:', error);
+        throw new Error(`Failed to claim incentives: ${error.message}`);
+    }
+});
+exports.claimIncentivesFromMerkleDistributor = claimIncentivesFromMerkleDistributor;
+const isClaimedFromMerkleDistributor = (chainId, contractAddress, index) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const provider = (0, utils_1.getProvider)(chainId);
+        const contract = new ethers_1.Contract(contractAddress, MerkleDistributorWithDeadline_1.MerkleDistributorABI.abi, provider);
+        const claimed = yield contract.isClaimed(BigInt(index));
+        return claimed;
+    }
+    catch (error) {
+        console.log('Error checking claim status:', error);
+        throw new Error(`Failed to check claim status: ${error.message}`);
+    }
+});
+exports.isClaimedFromMerkleDistributor = isClaimedFromMerkleDistributor;

package/dist/cjs/src/index.js

@@ -34,6 +34,7 @@ const ajv_js_1 = require("./ajv.js");
 const schema_js_1 = require("./schema.js");
 const splitHelpers_js_1 = require("./splitHelpers.js");
 const utils_js_1 = require("./utils.js");
+const incentives_js_1 = require("./incentives.js");
 __exportStar(require("./types.js"), exports);
 __exportStar(require("./services.js"), exports);
 __exportStar(require("./verification/signature-validator.js"), exports);
@@ -55,6 +56,7 @@ class Client extends base_js_1.Base {
     constructor(config, signer) {
         super(config);
         this.signer = signer;
+        this.incentives = new incentives_js_1.Incentives(this.signer, this.chainId, this.request.bind(this));
     }
     /**
      * Accepts Obol terms and conditions to be able to create or update data.
@@ -370,18 +372,5 @@ class Client extends base_js_1.Base {
             return lock;
         });
     }
-    /**
-     * @param address - Operator address
-     * @returns {Promise<Incentives>} The matched incentives from DB
-     * @throws On not found if address not found.
-     */
-    getIncentivesByAddress(address) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const incentives = yield this.request(`/${constants_js_1.DEFAULT_BASE_VERSION}/address/incentives/${address}`, {
-                method: 'GET',
-            });
-            return incentives;
-        });
-    }
 }
 exports.Client = Client;

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

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a, _b;
+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 constants_1 = require("../src/constants");
+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', () => {
+    let clientInstance;
+    const mockIncentivesData = {
+        contractAddress: '0x1234567890abcdef1234567890abcdef12345678',
+        index: 5,
+        operatorAddress: '0xabcdef1234567890abcdef1234567890abcdef12',
+        amount: 1000000000000000000,
+        merkleProof: [
+            '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+            '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
+        ],
+    };
+    beforeEach(() => {
+        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* () {
+        const clientWithoutSigner = new index_1.Client({
+            baseUrl,
+            chainId: 17000,
+        });
+        yield expect(clientWithoutSigner.incentives.claimIncentives(mockIncentivesData)).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(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}`);
+    }));
+    test('claimIncentives should return txHash on successful claim', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockTxHash = '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
+        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);
+        expect(result).toEqual({ txHash: mockTxHash });
+        expect(incentivesHelpers.claimIncentivesFromMerkleDistributor).toHaveBeenCalledWith({
+            signer: mockSigner,
+            contractAddress: mockIncentivesData.contractAddress,
+            index: mockIncentivesData.index,
+            operatorAddress: mockIncentivesData.operatorAddress,
+            amount: mockIncentivesData.amount,
+            merkleProof: mockIncentivesData.merkleProof,
+        });
+    }));
+    test('claimIncentives should throw an error if helper function fails', () => __awaiter(void 0, void 0, void 0, function* () {
+        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* () {
+            throw new Error('Helper function error');
+        }));
+        yield expect(clientInstance.incentives.claimIncentives(mockIncentivesData)).rejects.toThrow('Failed to claim incentives: Helper function error');
+    }));
+    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);
+    });
+    test('isClaimed should return true when incentive is 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(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);
+    }));
+    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);
+        expect(result).toBe(false);
+    }));
+    test('isClaimed should throw an error if helper function fails', () => __awaiter(void 0, void 0, void 0, function* () {
+        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');
+    }));
+    test('isClaimed should work with a client without signer', () => __awaiter(void 0, void 0, void 0, function* () {
+        // Create a client without a signer
+        const clientWithoutSigner = new index_1.Client({
+            baseUrl,
+            chainId: 17000,
+        });
+        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);
+    }));
+    test('getIncentivesByAddress should make the correct API request', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockAddress = '0x1234567890abcdef1234567890abcdef12345678';
+        const mockIncentives = {
+            operator_address: '0x8c00157cae72c4ed6a1f8bfb60205601f0252e26',
+            amount: '100',
+            index: 1,
+            merkle_proof: ['hash1', 'hash2'],
+            contract_address: '0xContract',
+        };
+        global.fetch.mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: () => __awaiter(void 0, void 0, void 0, function* () { return mockIncentives; }),
+            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/${mockAddress}`, expect.objectContaining({ method: 'GET' }));
+    }));
+    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();
+    }));
+});

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

@@ -411,47 +411,3 @@ describe('createObolTotalSplit', () => {
         });
     }));
 });
-describe('getIncentivesByAddress', () => {
-    let clientInstance;
-    beforeAll(() => {
-        jest
-            .spyOn(utils, 'isContractAvailable')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-        jest
-            .spyOn(splitsHelpers, 'predictSplitterAddress')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xPredictedAddress'); }));
-        jest
-            .spyOn(splitsHelpers, 'deploySplitterContract')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xSplitterAddress'); }));
-        clientInstance = new index_1.Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
-    });
-    test('should return incentives for a valid address', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockAddress = '0x1234567890abcdef1234567890abcdef12345678';
-        const mockIncentives = {
-            operator_address: '0x8c00157cae72c4ed6a1f8bfb60205601f0252e26',
-            amount: '100',
-            index: 1,
-            merkle_proof: ['hash1', 'hash2'],
-            contract_address: '0xContract',
-        };
-        clientInstance['request'] = jest
-            .fn()
-            .mockReturnValue(Promise.resolve(mockIncentives));
-        const incentives = yield clientInstance.getIncentivesByAddress(mockAddress);
-        expect(incentives).toEqual(mockIncentives);
-    }));
-    test('should throw an error if address is not found', () => __awaiter(void 0, void 0, void 0, function* () {
-        const invalidAddress = '0x0000000000000000000000000000000000000000';
-        clientInstance['request'] = jest
-            .fn()
-            .mockRejectedValue(new Error('Not found'));
-        yield expect(clientInstance.getIncentivesByAddress(invalidAddress)).rejects.toThrow('Not found');
-    }));
-    test('should throw an error if request fails', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockAddress = '0x1234567890abcdef1234567890abcdef12345678';
-        clientInstance['request'] = jest
-            .fn()
-            .mockRejectedValue(new Error('Network error'));
-        yield expect(clientInstance.getIncentivesByAddress(mockAddress)).rejects.toThrow('Network error');
-    }));
-});

package/dist/esm/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@obolnetwork/obol-sdk",
-    "version": "2.3.0",
+    "version": "2.4.0",
     "description": "A package for creating Distributed Validators using the Obol API.",
     "bugs": {
         "url": "https://github.com/obolnetwork/obol-sdk/issues"
@@ -15,7 +15,7 @@
         "compile": "tsc -b ./tsconfig.cjs.json ./tsconfig.esm.json ./tsconfig.types.json",
         "build:clean": "rm -rf ./dist",
         "build": "npm-run-all build:clean compile",
-        "test": "jest ./test/methods.test.ts",
+        "test": "jest ./test/*.test.ts",
         "generate-typedoc": "typedoc",
         "npm:publish": "npm publish --tag latest",
         "release": "release-it",

package/dist/esm/src/abi/MerkleDistributorWithDeadline.js

@@ -0,0 +1,70 @@
+export const MerkleDistributorABI = {
+    abi: [
+        {
+            inputs: [
+                { internalType: 'address', name: 'token_', type: 'address' },
+                { internalType: 'bytes32', name: 'merkleRoot_', type: 'bytes32' },
+            ],
+            stateMutability: 'nonpayable',
+            type: 'constructor',
+        },
+        {
+            anonymous: false,
+            inputs: [
+                {
+                    indexed: false,
+                    internalType: 'uint256',
+                    name: 'index',
+                    type: 'uint256',
+                },
+                {
+                    indexed: false,
+                    internalType: 'address',
+                    name: 'account',
+                    type: 'address',
+                },
+                {
+                    indexed: false,
+                    internalType: 'uint256',
+                    name: 'amount',
+                    type: 'uint256',
+                },
+            ],
+            name: 'Claimed',
+            type: 'event',
+        },
+        {
+            inputs: [
+                { internalType: 'uint256', name: 'index', type: 'uint256' },
+                { internalType: 'address', name: 'account', type: 'address' },
+                { internalType: 'uint256', name: 'amount', type: 'uint256' },
+                { internalType: 'bytes32[]', name: 'merkleProof', type: 'bytes32[]' },
+            ],
+            name: 'claim',
+            outputs: [],
+            stateMutability: 'nonpayable',
+            type: 'function',
+        },
+        {
+            inputs: [{ internalType: 'uint256', name: 'index', type: 'uint256' }],
+            name: 'isClaimed',
+            outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+            stateMutability: 'view',
+            type: 'function',
+        },
+        {
+            inputs: [],
+            name: 'merkleRoot',
+            outputs: [{ internalType: 'bytes32', name: '', type: 'bytes32' }],
+            stateMutability: 'view',
+            type: 'function',
+        },
+        {
+            inputs: [],
+            name: 'token',
+            outputs: [{ internalType: 'address', name: '', type: 'address' }],
+            stateMutability: 'view',
+            type: 'function',
+        },
+    ],
+};

package/dist/esm/src/incentives.js

@@ -0,0 +1,88 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { isContractAvailable } from './utils';
+import { claimIncentivesFromMerkleDistributor, isClaimedFromMerkleDistributor, } from './incentivesHalpers';
+import { DEFAULT_BASE_VERSION } from './constants';
+export class Incentives {
+    constructor(signer, chainId, request) {
+        this.signer = signer;
+        this.chainId = chainId;
+        this.request = request;
+    }
+    /**
+     * Claims obol incentives from a Merkle Distributor contract.
+     *
+     * @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.
+     *
+     */
+    claimIncentives(incentivesData) {
+        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);
+                if (!isContractDeployed) {
+                    throw new Error(`Merkle Distributor contract is not available at address ${incentivesData.contractAddress}`);
+                }
+                const { txHash } = yield claimIncentivesFromMerkleDistributor({
+                    signer: this.signer,
+                    contractAddress: incentivesData.contractAddress,
+                    index: incentivesData.index,
+                    operatorAddress: incentivesData.operatorAddress,
+                    amount: incentivesData.amount,
+                    merkleProof: incentivesData.merkleProof,
+                });
+                return { txHash };
+            }
+            catch (error) {
+                console.log('Error claiming incentives:', error);
+                throw new Error(`Failed to claim incentives: ${error.message}`);
+            }
+        });
+    }
+    /**
+     * Read isClaimed.
+     *
+     * @param {ETH_ADDRESS} contractAddress - Address of the Merkle Distributor Contract
+     * @param {ETH_ADDRESS} index - operator index in merkle tree
+     * @returns {Promise<boolean>} true if incentives are already claime
+     *
+     */
+    isClaimed(contractAddress, index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield isClaimedFromMerkleDistributor(this.chainId, contractAddress, index);
+        });
+    }
+    /**
+     * @param address - Operator address
+     * @returns {Promise<IncentivesType>} The matched incentives from DB
+     * @throws On not found if address not found.
+     */
+    getIncentivesByAddress(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const incentives = yield this.request(`/${DEFAULT_BASE_VERSION}/address/incentives/${address}`, {
+                method: 'GET',
+            });
+            return incentives;
+        });
+    }
+}