@obolnetwork/obol-sdk 2.9.0 → 2.10.0

package/dist/esm/src/schema.js

@@ -209,6 +209,10 @@ export const ovmTotalSplitPayloadSchema = {
 export const ovmRequestWithdrawalPayloadSchema = {
     type: 'object',
     properties: {
+        withdrawalFees: {
+            type: 'string',
+            pattern: '^[0-9]+$',
+        },
         ovmAddress: {
             type: 'string',
             pattern: '^0x[a-fA-F0-9]{40}$',
@@ -231,5 +235,23 @@ export const ovmRequestWithdrawalPayloadSchema = {
         },
     },
     validateOVMRequestWithdrawalPayload: true,
-    required: ['ovmAddress', 'pubKeys', 'amounts'],
+    required: ['ovmAddress', 'pubKeys', 'amounts', 'withdrawalFees'],
+};
+export const eoaWithdrawalPayloadSchema = {
+    type: 'object',
+    properties: {
+        pubkey: {
+            type: 'string',
+            pattern: '^0x[a-fA-F0-9]{96}$', // 48 bytes = 96 hex chars + 0x prefix
+        },
+        allocation: {
+            type: 'number',
+            minimum: 0,
+        },
+        requiredFee: {
+            type: 'string',
+            pattern: '^[0-9]+$',
+        },
+    },
+    required: ['pubkey', 'allocation', 'requiredFee'],
 };

package/dist/esm/src/splits/splitHelpers.js

@@ -12,7 +12,7 @@ import { OWRContract, OWRFactoryContract } from '../abi/OWR';
 import { OVMFactoryContract, OVMContract } from '../abi/OVMFactory';
 import { splitMainEthereumAbi } from '../abi/SplitMain';
 import { MultiCallContract } from '../abi/Multicall';
-import { CHAIN_CONFIGURATION } from '../constants';
+import { CHAIN_CONFIGURATION, ETHER_TO_GWEI } from '../constants';
 import { splitV2FactoryAbi } from '../abi/splitV2FactoryAbi';
 const splitMainContractInterface = new Interface(splitMainEthereumAbi);
 const owrFactoryContractInterface = new Interface(OWRFactoryContract.abi);
@@ -397,7 +397,7 @@ export const deployOVMContract = ({ OVMOwnerAddress, principalRecipient, rewardR
             throw new Error(`OVM Factory not configured for chain ${chainId}`);
         }
         const ovmFactoryContract = new Contract(chainConfig.OVM_FACTORY_CONTRACT.address, OVMFactoryContract.abi, signer);
-        const tx = yield ovmFactoryContract.createObolValidatorManager(OVMOwnerAddress, principalRecipient, rewardRecipient, principalThreshold);
+        const tx = yield ovmFactoryContract.createObolValidatorManager(OVMOwnerAddress, principalRecipient, rewardRecipient, principalThreshold * ETHER_TO_GWEI);
         const receipt = yield tx.wait();
         // Extract OVM address from logs
         const ovmAddressLog = (_3 = receipt === null || receipt === void 0 ? void 0 : receipt.logs[1]) === null || _3 === void 0 ? void 0 : _3.topics[1];
@@ -441,7 +441,7 @@ export const deployOVMAndSplitV2 = ({ ovmArgs, rewardRecipients, isRewardsSplitt
             });
         }
         // Create OVM call data
-        const ovmTxData = encodeCreateOVMTxData(ovmArgs.OVMOwnerAddress, ovmArgs.principalRecipient, ovmArgs.rewardRecipient, ovmArgs.principalThreshold);
+        const ovmTxData = encodeCreateOVMTxData(ovmArgs.OVMOwnerAddress, ovmArgs.principalRecipient, ovmArgs.rewardRecipient, ovmArgs.principalThreshold * ETHER_TO_GWEI);
         executeCalls.push({
             target: chainConfig.OVM_FACTORY_CONTRACT.address,
             callData: ovmTxData,
@@ -492,13 +492,15 @@ const getChainConfig = (chainId) => {
  * @param signer - The signer to use for the transaction
  * @returns Promise that resolves to the transaction hash
  */
-export const requestWithdrawalFromOVM = ({ ovmAddress, pubKeys, amounts, signer, }) => __awaiter(void 0, void 0, void 0, function* () {
+export const requestWithdrawalFromOVM = ({ ovmAddress, pubKeys, amounts, withdrawalFees, signer, }) => __awaiter(void 0, void 0, void 0, function* () {
     var _15;
     try {
         // Convert string amounts to bigint
         const bigintAmounts = amounts.map(amount => BigInt(amount));
         const ovmContract = new Contract(ovmAddress, OVMContract.abi, signer);
-        const tx = yield ovmContract.requestWithdrawal(pubKeys, bigintAmounts);
+        const tx = yield ovmContract.requestWithdrawal(pubKeys, bigintAmounts, {
+            value: BigInt(withdrawalFees),
+        });
         const receipt = yield tx.wait();
         return { txHash: receipt.hash };
     }

package/dist/esm/src/splits/splits.js

@@ -311,6 +311,7 @@ export class ObolSplits {
                 ovmAddress: validatedPayload.ovmAddress,
                 pubKeys: validatedPayload.pubKeys,
                 amounts: validatedPayload.amounts,
+                withdrawalFees: validatedPayload.withdrawalFees,
                 signer: this.signer,
             });
         });

package/dist/esm/test/client/ajv.spec.js

@@ -272,6 +272,7 @@ describe('ovmRequestWithdrawalPayloadSchema', () => {
             '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
         ],
         amounts: ['32000000000'],
+        withdrawalFees: '1',
     };
     it('should throw error when OVM address is missing', () => {
         const payload = {
@@ -286,14 +287,32 @@ describe('ovmRequestWithdrawalPayloadSchema', () => {
             pubKeys: validPayload.pubKeys,
             amounts: validPayload.amounts,
         };
-        expect(() => validatePayload(payload, ovmRequestWithdrawalPayloadSchema)).toThrow('Validation failed: /ovmAddress must match pattern');
+        expect(() => validatePayload(payload, ovmRequestWithdrawalPayloadSchema)).toThrow('Validation failed:  must have required property \'withdrawalFees\', /ovmAddress must match pattern "^0x[a-fA-F0-9]{40}$"');
     });
     it('should throw error when number of public keys does not match number of amounts', () => {
         const payload = {
             ovmAddress: validPayload.ovmAddress,
             pubKeys: validPayload.pubKeys,
             amounts: ['32000000000', '16000000000'], // 2 amounts, 1 pubKey
+            withdrawalFees: validPayload.withdrawalFees,
         };
         expect(() => validatePayload(payload, ovmRequestWithdrawalPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMRequestWithdrawalPayload" keyword validation');
     });
+    it('should throw error when withdrawalFees is missing', () => {
+        const payload = {
+            ovmAddress: validPayload.ovmAddress,
+            pubKeys: validPayload.pubKeys,
+            amounts: validPayload.amounts,
+        };
+        expect(() => validatePayload(payload, ovmRequestWithdrawalPayloadSchema)).toThrow("Validation failed:  must have required property 'withdrawalFees'");
+    });
+    it('should throw error when withdrawalFees is invalid', () => {
+        const payload = {
+            ovmAddress: validPayload.ovmAddress,
+            pubKeys: validPayload.pubKeys,
+            amounts: validPayload.amounts,
+            withdrawalFees: 'invalid',
+        };
+        expect(() => validatePayload(payload, ovmRequestWithdrawalPayloadSchema)).toThrow('Validation failed: /withdrawalFees must match pattern "^[0-9]+$"');
+    });
 });

package/dist/esm/test/eoa/eoa.spec.js

@@ -0,0 +1,85 @@
+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 { EOA } from '../../src/eoa/eoa';
+import { submitEOAWithdrawalRequest } from '../../src/eoa/eoaHelpers';
+// Mock the helper function
+jest.mock('../../src/eoa/eoaHelpers', () => ({
+    submitEOAWithdrawalRequest: jest.fn(),
+}));
+describe('EOA', () => {
+    let eoa;
+    let mockSigner;
+    let mockProvider;
+    beforeEach(() => {
+        // Clear all mocks before each test
+        jest.clearAllMocks();
+        mockSigner = {
+            getAddress: jest
+                .fn()
+                .mockResolvedValue('0x1234567890123456789012345678901234567890'),
+        };
+        mockProvider = {
+            getNetwork: jest.fn().mockResolvedValue({ chainId: 1 }),
+        };
+        eoa = new EOA(mockSigner, 1, mockProvider);
+    });
+    describe('requestWithdrawal', () => {
+        it('should successfully request withdrawal', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockPayload = {
+                pubkey: '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
+                allocation: 32,
+                requiredFee: '1',
+            };
+            const mockResult = {
+                txHash: '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
+            };
+            submitEOAWithdrawalRequest.mockResolvedValue(mockResult);
+            const result = yield eoa.requestWithdrawal(mockPayload);
+            expect(submitEOAWithdrawalRequest).toHaveBeenCalledWith({
+                pubkey: mockPayload.pubkey,
+                allocation: mockPayload.allocation,
+                withdrawalAddress: '0x1234567890123456789012345678901234567890',
+                withdrawalContractAddress: '0x00000961Ef480Eb55e80D19ad83579A64c007002',
+                requiredFee: mockPayload.requiredFee,
+                chainId: 1,
+                signer: mockSigner,
+                provider: mockProvider,
+            });
+            expect(result).toEqual(mockResult);
+        }));
+        it('should throw error when signer is not provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            const eoaWithoutSigner = new EOA(undefined, 1, mockProvider);
+            const mockPayload = {
+                pubkey: '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
+                allocation: 32,
+                requiredFee: '1',
+            };
+            yield expect(eoaWithoutSigner.requestWithdrawal(mockPayload)).rejects.toThrow('Signer is required in requestWithdrawal');
+        }));
+        it('should throw error when provider is not provided', () => __awaiter(void 0, void 0, void 0, function* () {
+            const eoaWithoutProvider = new EOA(mockSigner, 1, null);
+            const mockPayload = {
+                pubkey: '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
+                allocation: 32,
+                requiredFee: '1',
+            };
+            yield expect(eoaWithoutProvider.requestWithdrawal(mockPayload)).rejects.toThrow('Provider is required in requestWithdrawal');
+        }));
+        it('should throw error when EOA withdrawal contract is not configured for chain', () => __awaiter(void 0, void 0, void 0, function* () {
+            const eoaUnsupportedChain = new EOA(mockSigner, 999, mockProvider);
+            const mockPayload = {
+                pubkey: '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
+                allocation: 32,
+                requiredFee: '1',
+            };
+            yield expect(eoaUnsupportedChain.requestWithdrawal(mockPayload)).rejects.toThrow('EOA withdrawal contract is not configured for chain 999');
+        }));
+    });
+});

package/dist/esm/test/splits/splits.spec.js

@@ -244,6 +244,7 @@ describe('ObolSplits', () => {
                 ovmAddress: mockOVMAddress,
                 pubKeys: mockPubKeys,
                 amounts: mockAmounts,
+                withdrawalFees: '1',
             });
             expect(result).toEqual({
                 txHash: '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
@@ -252,6 +253,7 @@ describe('ObolSplits', () => {
                 ovmAddress: mockOVMAddress,
                 pubKeys: mockPubKeys,
                 amounts: mockAmounts,
+                withdrawalFees: '1',
                 signer: mockSigner,
             });
         }));
@@ -261,6 +263,7 @@ describe('ObolSplits', () => {
                 ovmAddress: mockOVMAddress,
                 pubKeys: mockPubKeys,
                 amounts: mockAmounts,
+                withdrawalFees: '1',
             })).rejects.toThrow('Signer is required in requestWithdrawal');
         }));
         // it('should throw error when amount is below minimum (1,000,000 gwei)', async () => {
@@ -288,6 +291,7 @@ describe('ObolSplits', () => {
                 ovmAddress: mockOVMAddress,
                 pubKeys: multiplePubKeys,
                 amounts: multipleAmounts,
+                withdrawalFees: '1',
             });
             expect(result).toEqual({
                 txHash: '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
@@ -296,6 +300,7 @@ describe('ObolSplits', () => {
                 ovmAddress: mockOVMAddress,
                 pubKeys: multiplePubKeys,
                 amounts: multipleAmounts,
+                withdrawalFees: '1',
                 signer: mockSigner,
             });
         }));

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

@@ -0,0 +1,42 @@
+import { type ProviderType, type SignerType, type EOAWithdrawalPayload } from '../types';
+/**
+ * EOA can be used for managing EOA (Externally Owned Account) operations like withdrawals.
+ * @class
+ * @internal Access it through Client.eoa.
+ * @example
+ * const obolClient = new Client(config);
+ * await obolClient.eoa.requestWithdrawal(EOAWithdrawalPayload);
+ */
+export declare class EOA {
+    private readonly signer;
+    readonly chainId: number;
+    readonly provider: ProviderType | undefined | null;
+    constructor(signer: SignerType | undefined, chainId: number, provider: ProviderType | undefined | null);
+    /**
+     * Requests withdrawal from an EOA contract.
+     *
+     * This method allows requesting withdrawal of validator funds.
+     * The withdrawal request includes validator public key and corresponding withdrawal amount.
+     *
+     * @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 {EOAWithdrawalPayload} payload - Data needed to request withdrawal
+     * @returns {Promise<{txHash: string}>} Transaction hash of the withdrawal request
+     * @throws Will throw an error if the signer is not provided or the request fails
+     *
+     * An example of how to use requestWithdrawal:
+     * ```typescript
+     * const result = await client.eoa.requestWithdrawal({
+     *   pubkey: '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
+     *   allocation: 32, // 32 ETH
+     *   requiredFee: '1' // in wei
+     * });
+     * console.log('Withdrawal requested:', result.txHash);
+     * ```
+     */
+    requestWithdrawal(payload: EOAWithdrawalPayload): Promise<{
+        txHash: string | null;
+    }>;
+}

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

@@ -0,0 +1,16 @@
+import { type SignerType, type ProviderType } from '../types';
+/**
+ * Helper function to submit withdrawal request for EOA
+ */
+export declare function submitEOAWithdrawalRequest({ pubkey, allocation, withdrawalAddress, withdrawalContractAddress, requiredFee, chainId, signer, provider, }: {
+    pubkey: string;
+    allocation: number;
+    withdrawalAddress: string;
+    withdrawalContractAddress: string;
+    requiredFee: string;
+    chainId: number;
+    signer: SignerType;
+    provider: ProviderType;
+}): Promise<{
+    txHash: string | null;
+}>;

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

@@ -3,6 +3,7 @@ import { type RewardsSplitPayload, type ClusterDefinition, type ClusterLock, typ
 import { Incentives } from './incentives/incentives.js';
 import { Exit } from './exits/exit.js';
 import { ObolSplits } from './splits/splits.js';
+import { EOA } from './eoa/eoa.js';
 export * from './types.js';
 export * from './services.js';
 export * from './verification/signature-validator.js';
@@ -11,6 +12,7 @@ export * from './constants.js';
 export { Incentives } from './incentives/incentives.js';
 export { Exit } from './exits/exit.js';
 export { ObolSplits } from './splits/splits.js';
+export { EOA } from './eoa/eoa.js';
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.
  */
@@ -34,6 +36,11 @@ export declare class Client extends Base {
      * @type {ObolSplits}
      */
     splits: ObolSplits;
+    /**
+     * The eoa module, responsible for managing EOA operations.
+     * @type {EOA}
+     */
+    eoa: EOA;
     /**
      * The blockchain provider, used to interact with the network.
      * It can be null, undefined, or a valid provider instance and defaults to the Signer provider if Signer is passed.

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

@@ -324,6 +324,10 @@ export declare const ovmTotalSplitPayloadSchema: {
 export declare const ovmRequestWithdrawalPayloadSchema: {
     type: string;
     properties: {
+        withdrawalFees: {
+            type: string;
+            pattern: string;
+        };
         ovmAddress: {
             type: string;
             pattern: string;
@@ -348,3 +352,21 @@ export declare const ovmRequestWithdrawalPayloadSchema: {
     validateOVMRequestWithdrawalPayload: boolean;
     required: string[];
 };
+export declare const eoaWithdrawalPayloadSchema: {
+    type: string;
+    properties: {
+        pubkey: {
+            type: string;
+            pattern: string;
+        };
+        allocation: {
+            type: string;
+            minimum: number;
+        };
+        requiredFee: {
+            type: string;
+            pattern: string;
+        };
+    };
+    required: string[];
+};

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

@@ -107,10 +107,11 @@ export declare const deployOVMAndSplitV2: ({ ovmArgs, rewardRecipients, isReward
  * @param signer - The signer to use for the transaction
  * @returns Promise that resolves to the transaction hash
  */
-export declare const requestWithdrawalFromOVM: ({ ovmAddress, pubKeys, amounts, signer, }: {
+export declare const requestWithdrawalFromOVM: ({ ovmAddress, pubKeys, amounts, withdrawalFees, signer, }: {
     ovmAddress: string;
     pubKeys: string[];
     amounts: string[];
+    withdrawalFees: string;
     signer: SignerType;
 }) => Promise<{
     txHash: string;

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

@@ -149,7 +149,7 @@ export type OVMBaseSplitPayload = {
     OVMOwnerAddress: string;
     /** Owner address for the splitter contracts. */
     splitOwnerAddress?: string;
-    /** Principal threshold for OVM contract. */
+    /** Principal threshold in ETH for OVM contract. */
     principalThreshold?: number;
     /** Distributor fee percentage (0-10). */
     distributorFeePercent?: number;
@@ -439,7 +439,7 @@ export type OVMArgs = {
     principalRecipient: string;
     /** Rewards recipient of the cluster. */
     rewardRecipient: string;
-    /** Principal threshold for OVM contract. */
+    /** Principal threshold in ETH for OVM contract. */
     principalThreshold: number;
 };
 export type ChainConfig = {
@@ -471,11 +471,16 @@ export type ChainConfig = {
         address: string;
         bytecode: string;
     };
+    EOA_WITHDRAWAL_CONTRACT?: {
+        address: string;
+    };
 };
 /**
  * Payload for requesting withdrawal from OVM contract
  */
 export type OVMRequestWithdrawalPayload = {
+    /** request withdrawal fees in wei */
+    withdrawalFees: string;
     /** OVM contract address */
     ovmAddress: string;
     /** Array of validator public keys in bytes format */
@@ -483,3 +488,14 @@ export type OVMRequestWithdrawalPayload = {
     /** Array of withdrawal amounts in gwei (uint64) as strings */
     amounts: string[];
 };
+/**
+ * Payload for requesting withdrawal from EOA contract
+ */
+export type EOAWithdrawalPayload = {
+    /** Validator public key in hex format */
+    pubkey: string;
+    /** Withdrawal amount in ETH */
+    allocation: number;
+    /** Required fee in wei */
+    requiredFee: string;
+};

package/dist/types/test/eoa/eoa.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

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

package/src/ajv.ts

@@ -112,7 +112,6 @@ const validateOVMRequestWithdrawalPayload = (
   _: boolean,
   data: OVMRequestWithdrawalPayload,
 ): boolean => {
-  console.log(data, 'hanaaan dataaaa');
   if (!data.pubKeys || !data.amounts) {
     return false;
   }

package/src/constants.ts

@@ -199,6 +199,9 @@ export const CHAIN_CONFIGURATION: Record<number, ChainConfig> = {
       address: '0x5cbA88D55Cec83caD5A105Ad40C8c9aF20bE21d1',
       bytecode: MAINNET_SPLIT_V2_FACTORY_BYTECODE,
     },
+    EOA_WITHDRAWAL_CONTRACT: {
+      address: '0x00000961Ef480Eb55e80D19ad83579A64c007002',
+    },
   },
   [FORK_MAPPING['0x01017000']]: {
     SPLITMAIN_CONTRACT: {
@@ -217,6 +220,9 @@ export const CHAIN_CONFIGURATION: Record<number, ChainConfig> = {
       address: '0x43F641fA70e09f0326ac66b4Ef0C416EaEcBC6f5',
       bytecode: '',
     },
+    EOA_WITHDRAWAL_CONTRACT: {
+      address: '0x00000961Ef480Eb55e80D19ad83579A64c007002',
+    },
   },
   [FORK_MAPPING['0x10000910']]: {
     SPLITMAIN_CONTRACT: {
@@ -248,6 +254,9 @@ export const CHAIN_CONFIGURATION: Record<number, ChainConfig> = {
       address: '0x5cbA88D55Cec83caD5A105Ad40C8c9aF20bE21d1',
       bytecode: HOODI_SPLIT_V2_FACTORY_BYTECODE,
     },
+    EOA_WITHDRAWAL_CONTRACT: {
+      address: '0x00000961Ef480Eb55e80D19ad83579A64c007002',
+    },
   },
 };
 

package/src/eoa/eoa.ts

@@ -0,0 +1,94 @@
+import { submitEOAWithdrawalRequest } from './eoaHelpers';
+import { validatePayload } from '../ajv';
+import { eoaWithdrawalPayloadSchema } from '../schema';
+import { CHAIN_CONFIGURATION } from '../constants';
+import {
+  type ProviderType,
+  type SignerType,
+  type EOAWithdrawalPayload,
+} from '../types';
+
+/**
+ * EOA can be used for managing EOA (Externally Owned Account) operations like withdrawals.
+ * @class
+ * @internal Access it through Client.eoa.
+ * @example
+ * const obolClient = new Client(config);
+ * await obolClient.eoa.requestWithdrawal(EOAWithdrawalPayload);
+ */
+export class EOA {
+  private readonly signer: SignerType | undefined;
+  public readonly chainId: number;
+  public readonly provider: ProviderType | undefined | null;
+
+  constructor(
+    signer: SignerType | undefined,
+    chainId: number,
+    provider: ProviderType | undefined | null,
+  ) {
+    this.signer = signer;
+    this.chainId = chainId;
+    this.provider = provider;
+  }
+
+  /**
+   * Requests withdrawal from an EOA contract.
+   *
+   * This method allows requesting withdrawal of validator funds.
+   * The withdrawal request includes validator public key and corresponding withdrawal amount.
+   *
+   * @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 {EOAWithdrawalPayload} payload - Data needed to request withdrawal
+   * @returns {Promise<{txHash: string}>} Transaction hash of the withdrawal request
+   * @throws Will throw an error if the signer is not provided or the request fails
+   *
+   * An example of how to use requestWithdrawal:
+   * ```typescript
+   * const result = await client.eoa.requestWithdrawal({
+   *   pubkey: '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
+   *   allocation: 32, // 32 ETH
+   *   requiredFee: '1' // in wei
+   * });
+   * console.log('Withdrawal requested:', result.txHash);
+   * ```
+   */
+  async requestWithdrawal(
+    payload: EOAWithdrawalPayload,
+  ): Promise<{ txHash: string | null }> {
+    if (!this.signer) {
+      throw new Error('Signer is required in requestWithdrawal');
+    }
+
+    if (!this.provider) {
+      throw new Error('Provider is required in requestWithdrawal');
+    }
+
+    const chainConfig = CHAIN_CONFIGURATION[this.chainId];
+    if (!chainConfig?.EOA_WITHDRAWAL_CONTRACT?.address) {
+      throw new Error(
+        `EOA withdrawal contract is not configured for chain ${this.chainId}`,
+      );
+    }
+
+    const validatedPayload = validatePayload<EOAWithdrawalPayload>(
+      payload,
+      eoaWithdrawalPayloadSchema,
+    );
+
+    const withdrawalAddress = await this.signer.getAddress();
+
+    return await submitEOAWithdrawalRequest({
+      pubkey: validatedPayload.pubkey,
+      allocation: validatedPayload.allocation,
+      withdrawalAddress,
+      withdrawalContractAddress: chainConfig.EOA_WITHDRAWAL_CONTRACT.address,
+      requiredFee: validatedPayload.requiredFee,
+      chainId: this.chainId,
+      signer: this.signer,
+      provider: this.provider,
+    });
+  }
+}

package/src/eoa/eoaHelpers.ts

@@ -0,0 +1,43 @@
+import { ETHER_TO_GWEI } from '../constants';
+import { type SignerType, type ProviderType } from '../types';
+
+/**
+ * Helper function to submit withdrawal request for EOA
+ */
+export async function submitEOAWithdrawalRequest({
+  pubkey,
+  allocation,
+  withdrawalAddress,
+  withdrawalContractAddress,
+  requiredFee,
+  chainId,
+  signer,
+  provider,
+}: {
+  pubkey: string;
+  allocation: number;
+  withdrawalAddress: string;
+  withdrawalContractAddress: string;
+  requiredFee: string;
+  chainId: number;
+  signer: SignerType;
+  provider: ProviderType;
+}): Promise<{ txHash: string | null }> {
+  if (!withdrawalAddress) throw new Error('No withdrawal address provided');
+  if (!allocation) throw new Error('No allocation provided');
+
+  const amountInGwei = BigInt(Math.floor(Number(allocation) * ETHER_TO_GWEI));
+  const data = `0x${pubkey.slice(2)}${amountInGwei.toString(16).padStart(16, '0')}`;
+
+  const { hash } = await signer.sendTransaction({
+    to: withdrawalContractAddress,
+    chainId,
+    value: BigInt(requiredFee),
+    data: data as `0x${string}`,
+  });
+
+  const txResult = await provider.getTransactionReceipt(hash);
+  if (!txResult) return { txHash: null };
+
+  return { txHash: txResult?.hash };
+}

package/src/index.ts

@@ -50,6 +50,7 @@ import { isContractAvailable } from './utils.js';
 import { Incentives } from './incentives/incentives.js';
 import { Exit } from './exits/exit.js';
 import { ObolSplits } from './splits/splits.js';
+import { EOA } from './eoa/eoa.js';
 export * from './types.js';
 export * from './services.js';
 export * from './verification/signature-validator.js';
@@ -58,6 +59,7 @@ export * from './constants.js';
 export { Incentives } from './incentives/incentives.js';
 export { Exit } from './exits/exit.js';
 export { ObolSplits } from './splits/splits.js';
+export { EOA } from './eoa/eoa.js';
 
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.
@@ -86,6 +88,12 @@ export class Client extends Base {
    */
   public splits: ObolSplits;
 
+  /**
+   * The eoa module, responsible for managing EOA operations.
+   * @type {EOA}
+   */
+  public eoa: EOA;
+
   /**
    * The blockchain provider, used to interact with the network.
    * It can be null, undefined, or a valid provider instance and defaults to the Signer provider if Signer is passed.
@@ -121,6 +129,7 @@ export class Client extends Base {
     );
     this.exit = new Exit(this.chainId, this.provider);
     this.splits = new ObolSplits(this.signer, this.chainId, this.provider);
+    this.eoa = new EOA(this.signer, this.chainId, this.provider);
   }
 
   /**