@obolnetwork/obol-sdk 2.2.3 → 2.3.0

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

@@ -7,9 +7,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var _a, _b;
 import { ethers, JsonRpcProvider } from 'ethers';
 import { Client, validateClusterLock } from '../src/index';
-import { clusterConfigV1X7, clusterConfigV1X8, clusterLockV1X10, clusterLockV1X6, clusterLockV1X7, clusterLockV1X8, clusterLockWithSafe, nullDepositAmountsClusterLockV1X8, } from './fixtures.js';
+import { clusterConfigV1X7, clusterConfigV1X8, clusterLockV1X10, clusterLockV1X6, clusterLockV1X7, clusterLockV1X8, clusterLockWithCompoundingWithdrawals, clusterLockWithSafe, nullDepositAmountsClusterLockV1X8, } from './fixtures.js';
 import { SDK_VERSION } from '../src/constants';
 import { Base } from '../src/base';
 import { validatePayload } from '../src/ajv';
@@ -19,15 +20,14 @@ import { hashTermsAndConditions } from '../src/verification/termsAndConditions';
 import * as utils from '../src/utils';
 import * as splitsHelpers from '../src/splitHelpers';
 jest.setTimeout(20000);
+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);
 /* eslint no-new: 0 */
 describe('Cluster Client', () => {
-    var _a, _b;
     const mockConfigHash = '0x1f6c94e6c070393a68c1aa6073a21cb1fd57f0e14d2a475a2958990ab728c2fd';
-    const mnemonic = (_b = (_a = ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) !== null && _b !== void 0 ? _b : '';
-    const privateKey = ethers.Wallet.fromPhrase(mnemonic).privateKey;
-    const provider = new JsonRpcProvider('https://ethereum-holesky.publicnode.com');
-    const wallet = new ethers.Wallet(privateKey, provider);
-    const mockSigner = wallet.connect(provider);
     const clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
     test('createTermsAndConditions should return "successful authorization"', () => __awaiter(void 0, void 0, void 0, function* () {
         clientInstance['request'] = jest
@@ -92,12 +92,12 @@ describe('Cluster Client', () => {
         }
     }));
     test('getClusterdefinition should return cluster definition if config hash exist', () => __awaiter(void 0, void 0, void 0, function* () {
-        var _c;
+        var _a;
         clientInstance['request'] = jest
             .fn()
             .mockReturnValue(Promise.resolve(clusterLockV1X8.cluster_definition));
         const clusterDefinition = yield clientInstance.getClusterDefinition(clusterLockV1X8.cluster_definition.config_hash);
-        expect((_c = clusterDefinition.deposit_amounts) === null || _c === void 0 ? void 0 : _c.length).toEqual(clusterLockV1X8.cluster_definition.deposit_amounts.length);
+        expect((_a = clusterDefinition.deposit_amounts) === null || _a === void 0 ? void 0 : _a.length).toEqual(clusterLockV1X8.cluster_definition.deposit_amounts.length);
         expect(clusterDefinition.config_hash).toEqual(clusterLockV1X8.cluster_definition.config_hash);
     }));
     test('getClusterLock should return lockFile if exist', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -186,6 +186,10 @@ describe('Cluster Client without a signer', () => {
             clusterLock: clusterLockWithSafe,
         },
         { version: 'v1.10.0', clusterLock: clusterLockV1X10 },
+        {
+            version: 'v1.10.0 with compunding withdrawals',
+            clusterLock: clusterLockWithCompoundingWithdrawals,
+        },
     ])("$version: 'should return true on verified cluster lock'", ({ clusterLock }) => __awaiter(void 0, void 0, void 0, function* () {
         const isValidLock = yield validateClusterLock(clusterLock);
         expect(isValidLock).toEqual(true);
@@ -204,9 +208,8 @@ describe('Cluster Client without a signer', () => {
     }));
 });
 describe('createObolRewardsSplit', () => {
-    let clientInstance, clientInstanceWithourSigner, mockSplitRecipients, mockPrincipalRecipient, mockEtherAmount, mockSigner;
+    let clientInstance, clientInstanceWithourSigner, mockSplitRecipients, mockPrincipalRecipient, mockEtherAmount;
     beforeAll(() => {
-        var _a, _b;
         jest
             .spyOn(utils, 'isContractAvailable')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
@@ -219,11 +222,6 @@ describe('createObolRewardsSplit', () => {
                 fee_recipient_address: '0xFeeRecipientAddress',
             });
         }));
-        const mnemonic = (_b = (_a = ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) !== null && _b !== void 0 ? _b : '';
-        const privateKey = ethers.Wallet.fromPhrase(mnemonic).privateKey;
-        const provider = new JsonRpcProvider('https://ethereum-holesky.publicnode.com');
-        const wallet = new ethers.Wallet(privateKey, provider);
-        mockSigner = wallet.connect(provider);
         clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
         clientInstanceWithourSigner = new Client({
             baseUrl: 'https://obol-api-dev.gcp.obol.tech',
@@ -301,9 +299,8 @@ describe('createObolRewardsSplit', () => {
     }));
 });
 describe('createObolTotalSplit', () => {
-    let clientInstanceWithourSigner, mockSplitRecipients, mockSigner, clientInstance;
+    let clientInstanceWithourSigner, mockSplitRecipients, clientInstance;
     beforeAll(() => {
-        var _a, _b;
         jest
             .spyOn(utils, 'isContractAvailable')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
@@ -313,11 +310,6 @@ describe('createObolTotalSplit', () => {
         jest
             .spyOn(splitsHelpers, 'deploySplitterContract')
             .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xSplitterAddress'); }));
-        const mnemonic = (_b = (_a = ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) !== null && _b !== void 0 ? _b : '';
-        const privateKey = ethers.Wallet.fromPhrase(mnemonic).privateKey;
-        const provider = new JsonRpcProvider('https://ethereum-holesky.publicnode.com');
-        const wallet = new ethers.Wallet(privateKey, provider);
-        mockSigner = wallet.connect(provider);
         clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
         clientInstanceWithourSigner = new Client({
             baseUrl: 'https://obol-api-dev.gcp.obol.tech',
@@ -394,3 +386,47 @@ 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 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/types/src/index.d.ts

@@ -1,6 +1,6 @@
 import { type Signer } 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 Incentives } from './types.js';
 export * from './types.js';
 export * from './services.js';
 export * from './verification/signature-validator.js';
@@ -112,4 +112,10 @@ export declare class Client extends Base {
      * [getObolClusterLock](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L89)
      */
     getClusterLock(configHash: string): Promise<ClusterLock>;
+    /**
+     * @param address - Operator address
+     * @returns {Promise<Incentives>} The matched incentives from DB
+     * @throws On not found if address not found.
+     */
+    getIncentivesByAddress(address: string): Promise<Incentives>;
 }

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

@@ -97,6 +97,8 @@ export interface ClusterDefinition extends ClusterPayload {
     consensus_protocol?: string;
     /** The target gas limit where default is 30M. */
     target_gas_limit?: number;
+    /** A withdrawal mechanism with 0x02 withdrawal credentials. */
+    compounding?: boolean;
 }
 /**
  * Split Recipient Keys
@@ -209,6 +211,21 @@ export type ClusterLock = {
     /** Node Signature for the lock hash by the node secp256k1 key. */
     node_signatures?: string[];
 };
+/**
+ * Incentives
+ */
+export type Incentives = {
+    /** Operator Address. */
+    operator_address: string;
+    /** The amount the recipient is entitled to. */
+    amount: string;
+    /** The recipient’s index in the Merkle tree. */
+    index: number;
+    /** The Merkle proof (an array of hashes) generated for the recipient. */
+    merkle_proof: string[];
+    /** The MerkleDistributor contract address. */
+    contract_address: string;
+};
 /**
  * String expected to be Ethereum Address
  */

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

@@ -19,7 +19,7 @@ export declare const clusterLockHash: (clusterLock: ClusterLock) => string;
  * @param {string} withdrawalAddress - withdrawal address in definition file.
  * @returns {boolean} - return if deposit data is valid.
  */
-export declare const verifyDepositData: (distributedPublicKey: string, depositData: Partial<DepositData>, withdrawalAddress: string, forkVersion: string) => {
+export declare const verifyDepositData: (distributedPublicKey: string, depositData: Partial<DepositData>, withdrawalAddress: string, forkVersion: string, compounding?: boolean) => {
     isValidDepositData: boolean;
     depositDataMsg: Uint8Array;
 };

package/dist/types/src/verification/v1.10.0.d.ts

@@ -1,6 +1,6 @@
 import { UintNumberType } from '@chainsafe/ssz/lib/type/uint';
 import { type creatorAddressWrapperType, type creatorContainerType, type operatorAddressWrapperType, type operatorContainerType, validatorsContainerType } from './sszTypes';
-import { ByteListType, ByteVectorType, ContainerType, ListBasicType, ListCompositeType } from '@chainsafe/ssz';
+import { ByteListType, ByteVectorType, ContainerType, ListBasicType, ListCompositeType, BooleanType } from '@chainsafe/ssz';
 import { type ValueOfFields } from '@chainsafe/ssz/lib/view/container';
 import { type ClusterDefinition, type ClusterLock } from '../types';
 type DefinitionFieldsV1X10 = {
@@ -18,6 +18,7 @@ type DefinitionFieldsV1X10 = {
     deposit_amounts: ListBasicType<UintNumberType>;
     consensus_protocol: ByteListType;
     target_gas_limit: UintNumberType;
+    compounding: BooleanType;
     config_hash?: ByteVectorType;
 };
 type DefinitionContainerTypeV1X10 = ContainerType<DefinitionFieldsV1X10>;

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

@@ -290,6 +290,61 @@ export declare const clusterLockV1X10: {
         deposit_amounts: null;
         consensus_protocol: string;
         target_gas_limit: number;
+        compounding: boolean;
+        config_hash: string;
+        definition_hash: string;
+    };
+    distributed_validators: {
+        distributed_public_key: string;
+        public_shares: string[];
+        builder_registration: {
+            message: {
+                fee_recipient: string;
+                gas_limit: number;
+                timestamp: number;
+                pubkey: string;
+            };
+            signature: string;
+        };
+        partial_deposit_data: {
+            pubkey: string;
+            withdrawal_credentials: string;
+            amount: string;
+            signature: string;
+        }[];
+    }[];
+    signature_aggregate: string;
+    lock_hash: string;
+    node_signatures: string[];
+};
+export declare const clusterLockWithCompoundingWithdrawals: {
+    cluster_definition: {
+        name: string;
+        creator: {
+            address: string;
+            config_signature: string;
+        };
+        operators: {
+            address: string;
+            enr: string;
+            config_signature: string;
+            enr_signature: string;
+        }[];
+        uuid: string;
+        version: string;
+        timestamp: string;
+        num_validators: number;
+        threshold: number;
+        validators: {
+            fee_recipient_address: string;
+            withdrawal_address: string;
+        }[];
+        dkg_algorithm: string;
+        fork_version: string;
+        deposit_amounts: null;
+        consensus_protocol: string;
+        target_gas_limit: number;
+        compounding: boolean;
         config_hash: string;
         definition_hash: string;
     };

package/package.json

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

package/src/index.ts

@@ -30,6 +30,7 @@ import {
   type ClusterValidator,
   type ETH_ADDRESS,
   type OWRTranches,
+  type Incentives,
 } from './types.js';
 import { clusterConfigOrDefinitionHash } from './verification/common.js';
 import { validatePayload } from './ajv.js';
@@ -520,4 +521,19 @@ export class Client extends Base {
     );
     return lock;
   }
+
+  /**
+   * @param address - Operator address
+   * @returns {Promise<Incentives>} The matched incentives from DB
+   * @throws On not found if address not found.
+   */
+  async getIncentivesByAddress(address: string): Promise<Incentives> {
+    const incentives: Incentives = await this.request(
+      `/${DEFAULT_BASE_VERSION}/address/incentives/${address}`,
+      {
+        method: 'GET',
+      },
+    );
+    return incentives;
+  }
 }

package/src/types.ts

@@ -144,6 +144,9 @@ export interface ClusterDefinition extends ClusterPayload {
 
   /** The target gas limit where default is 30M. */
   target_gas_limit?: number;
+
+  /** A withdrawal mechanism with 0x02 withdrawal credentials. */
+  compounding?: boolean;
 }
 
 /**
@@ -290,6 +293,26 @@ export type ClusterLock = {
   node_signatures?: string[];
 };
 
+/**
+ * Incentives
+ */
+export type Incentives = {
+  /** Operator Address. */
+  operator_address: string;
+
+  /** The amount the recipient is entitled to. */
+  amount: string;
+
+  /** The recipient’s index in the Merkle tree. */
+  index: number;
+
+  /** The Merkle proof (an array of hashes) generated for the recipient. */
+  merkle_proof: string[];
+
+  /** The MerkleDistributor contract address. */
+  contract_address: string;
+};
+
 /**
  * String expected to be Ethereum Address
  */

package/src/verification/common.ts

@@ -354,23 +354,19 @@ export const verifyDepositData = (
   depositData: Partial<DepositData>,
   withdrawalAddress: string,
   forkVersion: string,
+  compounding?: boolean,
 ): { isValidDepositData: boolean; depositDataMsg: Uint8Array } => {
   const depositDomain = computeDomain(
     fromHexString(DOMAIN_DEPOSIT),
     forkVersion,
   );
-  const eth1AddressWithdrawalPrefix = '0x01';
-  const compoundingWithdrawalPrefix = '0x02';
-  if (
-    eth1AddressWithdrawalPrefix +
-      '0'.repeat(22) +
-      withdrawalAddress.toLowerCase().slice(2) !==
-      depositData.withdrawal_credentials &&
-    compoundingWithdrawalPrefix +
-      '0'.repeat(22) +
-      withdrawalAddress.toLowerCase().slice(2) !==
-      depositData.withdrawal_credentials
-  ) {
+  const withdrawalPrefix = compounding ? '0x02' : '0x01';
+  const expectedWithdrawalCredentials =
+    withdrawalPrefix +
+    '0'.repeat(22) +
+    withdrawalAddress.toLowerCase().slice(2);
+
+  if (expectedWithdrawalCredentials !== depositData.withdrawal_credentials) {
     return { isValidDepositData: false, depositDataMsg: new Uint8Array(0) };
   }
 

package/src/verification/v1.10.0.ts

@@ -21,6 +21,7 @@ import {
   ListBasicType,
   ListCompositeType,
   fromHexString,
+  BooleanType,
 } from '@chainsafe/ssz';
 import { type ValueOfFields } from '@chainsafe/ssz/lib/view/container';
 import {
@@ -48,6 +49,7 @@ type DefinitionFieldsV1X10 = {
   deposit_amounts: ListBasicType<UintNumberType>;
   consensus_protocol: ByteListType;
   target_gas_limit: UintNumberType;
+  compounding: BooleanType;
   config_hash?: ByteVectorType;
 };
 
@@ -79,6 +81,7 @@ export const clusterDefinitionContainerTypeV1X10 = (
     ),
     consensus_protocol: new ByteListType(256),
     target_gas_limit: new UintNumberType(8 as UintNumberByteLen),
+    compounding: new BooleanType(),
   };
 
   if (!configOnly) {
@@ -144,6 +147,10 @@ export const hashClusterDefinitionV1X10 = (
     val.target_gas_limit = cluster.target_gas_limit;
   }
 
+  if (cluster.compounding) {
+    val.compounding = cluster.compounding;
+  }
+
   if (!configOnly) {
     val.config_hash = fromHexString(cluster.config_hash);
   }

package/src/verification/v1.8.0.ts

@@ -259,6 +259,7 @@ export const verifyDVV1X8 = (clusterLock: ClusterLock): boolean => {
         depositData as Partial<DepositData>,
         clusterLock.cluster_definition.validators[i].withdrawal_address,
         clusterLock.cluster_definition.fork_version,
+        clusterLock.cluster_definition.compounding,
       );
 
       if (!isValidDepositData) {