@obolnetwork/obol-sdk 2.10.2 → 2.11.0

package/src/schema.ts

@@ -280,3 +280,87 @@ export const eoaWithdrawalPayloadSchema = {
   },
   required: ['pubkey', 'allocation', 'requiredFee'],
 };
+
+export const ovmDepositPayloadSchema = {
+  type: 'object',
+  properties: {
+    ovmAddress: {
+      type: 'string',
+      pattern: '^0x[a-fA-F0-9]{40}$',
+    },
+    deposits: {
+      type: 'array',
+      minItems: 1,
+      items: {
+        type: 'object',
+        properties: {
+          pubkey: {
+            type: 'string',
+            pattern: '^0x[a-fA-F0-9]{96}$',
+          },
+          withdrawal_credentials: {
+            type: 'string',
+            pattern: '^0x[a-fA-F0-9]{64}$',
+            description: '32 bytes withdrawal credentials',
+          },
+          signature: {
+            type: 'string',
+            pattern: '^0x[a-fA-F0-9]{192}$',
+            description: '96 bytes signature (190 hex chars + 0x prefix)',
+          },
+          deposit_data_root: {
+            type: 'string',
+            pattern: '^0x[a-fA-F0-9]{64}$', // 32 bytes = 64 hex chars + 0x prefix
+          },
+          amount: {
+            type: 'string',
+            pattern: '^[0-9]+$',
+          },
+        },
+        required: [
+          'pubkey',
+          'withdrawal_credentials',
+          'signature',
+          'deposit_data_root',
+          'amount',
+        ],
+      },
+    },
+  },
+  required: ['ovmAddress', 'deposits'],
+};
+
+export const eoaDepositPayloadSchema = {
+  type: 'object',
+  properties: {
+    deposits: {
+      type: 'array',
+      minItems: 1,
+      items: {
+        type: 'object',
+        properties: {
+          pubKey: {
+            type: 'string',
+            pattern: '^0x[a-fA-F0-9]{96}$',
+          },
+          withdrawalCredentials: {
+            type: 'string',
+            pattern: '^0x[a-fA-F0-9]{64}$',
+            description: '32 bytes withdrawal credentials',
+          },
+          signature: {
+            type: 'string',
+            pattern: '^0x[a-fA-F0-9]{192}$',
+            description: '96 bytes signature (190 hex chars + 0x prefix)',
+          },
+          amount: {
+            type: 'string',
+            pattern: '^[0-9]+$',
+          },
+        },
+        required: ['pubKey', 'withdrawalCredentials', 'signature', 'amount'],
+      },
+    },
+  },
+  required: ['deposits'],
+};

package/src/splits/splitHelpers.ts

@@ -12,9 +12,9 @@ import { Contract, Interface, parseEther, ZeroAddress } from 'ethers';
 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, ETHER_TO_GWEI } from '../constants';
 import { splitV2FactoryAbi } from '../abi/splitV2FactoryAbi';
+import { MultiCall3Contract } from '../abi/Multicall3';
 
 const splitMainContractInterface = new Interface(splitMainEthereumAbi);
 const owrFactoryContractInterface = new Interface(OWRFactoryContract.abi);
@@ -217,7 +217,7 @@ export const handleDeployOWRAndSplitter = async ({
         splitterAddress = result.splitterAddress;
       } catch (error: any) {
         throw new Error(
-          `Failed to deploy both splitter and OWR contracts: ${error.message ?? 'Multicall contract deployment failed'}`,
+          `Failed to deploy both splitter and OWR contracts: ${error.message ?? 'Multicall3 contract deployment failed'}`,
         );
       }
 
@@ -444,7 +444,7 @@ export const deploySplitterAndOWRContracts = async ({
     },
   );
 
-  const executeMultiCalls = await multicall(executeCalls, signer, chainId);
+  const executeMultiCalls = await multicall3(executeCalls, signer, chainId);
 
   const splitAddressData = executeMultiCalls?.logs[0]?.topics[1];
   const formattedSplitterAddress = '0x' + splitAddressData?.slice(26, 66);
@@ -502,26 +502,26 @@ export const getOWRTranches = async ({
   }
 };
 
-export const multicall = async (
+export const multicall3 = async (
   calls: Call[],
   signer: SignerType,
   chainId: number,
 ): Promise<any> => {
   try {
     const chainConfig = getChainConfig(chainId);
-    const multicallAddress = chainConfig.MULTICALL_CONTRACT.address;
-    const multiCallContractInstance = new Contract(
-      multicallAddress,
-      MultiCallContract.abi,
+    const multicall3Address = chainConfig.MULTICALL3_CONTRACT.address;
+    const multiCall3ContractInstance = new Contract(
+      multicall3Address,
+      MultiCall3Contract.abi,
       signer,
     );
 
     let tx;
     try {
-      tx = await multiCallContractInstance.aggregate(calls);
+      tx = await multiCall3ContractInstance.aggregate(calls);
     } catch (error: any) {
       throw new Error(
-        `Failed to submit multicall transaction: ${error.message ?? 'Transaction submission failed'}`,
+        `Failed to submit multicall3 transaction: ${error.message ?? 'Transaction submission failed'}`,
       );
     }
 
@@ -530,13 +530,13 @@ export const multicall = async (
       receipt = await tx.wait();
     } catch (error: any) {
       throw new Error(
-        `Multicall transaction failed or was reverted: ${error.message ?? 'Transaction execution failed'}`,
+        `Multicall3 transaction failed or was reverted: ${error.message ?? 'Transaction execution failed'}`,
       );
     }
 
     if (!receipt) {
       throw new Error(
-        'Multicall transaction succeeded but no receipt was returned',
+        'Multicall3 transaction succeeded but no receipt was returned',
       );
     }
 
@@ -545,13 +545,13 @@ export const multicall = async (
     // Re-throw if it's already our custom error
     if (
       error.message.includes('Failed to') ||
-      error.message.includes('Multicall transaction')
+      error.message.includes('Multicall3 transaction')
     ) {
       throw error;
     }
     // Handle unexpected errors
     throw new Error(
-      `Unexpected error in multicall: ${error.message ?? 'Unknown error during multicall execution'}`,
+      `Unexpected error in multicall3: ${error.message ?? 'Unknown error during multicall3 execution'}`,
     );
   }
 };
@@ -845,8 +845,8 @@ export const deployOVMAndSplitV2 = async ({
       callData: ovmTxData,
     });
 
-    // Execute multicall
-    const executeMultiCalls = await multicall(executeCalls, signer, chainId);
+    // Execute multicall3
+    const executeMultiCalls = await multicall3(executeCalls, signer, chainId);
 
     // Extract addresses from events
     let ovmAddress: string | undefined;
@@ -861,7 +861,7 @@ export const deployOVMAndSplitV2 = async ({
     }
     if (!ovmAddress) {
       throw new Error(
-        'Failed to extract contract addresses from multicall events',
+        'Failed to extract contract addresses from multicall3 events',
       );
     }
 
@@ -944,9 +944,89 @@ export const requestWithdrawalFromOVM = async ({
     const receipt = await tx.wait();
 
     return { txHash: receipt.hash };
-  } catch (error: any) {
+  } catch (error: unknown) {
+    const errorMessage =
+      error instanceof Error ? error.message : 'Request withdrawal failed';
+    throw new Error(`Failed to request withdrawal from OVM: ${errorMessage}`);
+  }
+};
+
+/**
+ * Deposits to OVM contract using multicall3 for batch operations
+ * @param ovmAddress - The address of the OVM contract
+ * @param deposits - Array of deposit objects with all required parameters
+ * @param signer - The signer to use for the transaction
+ * @returns Promise that resolves to an array of transaction hashes
+ */
+export const depositWithMulticall3 = async ({
+  ovmAddress,
+  deposits,
+  signer,
+  chainId,
+}: {
+  ovmAddress: string;
+  deposits: Array<{
+    pubkey: string;
+    withdrawal_credentials: string;
+    signature: string;
+    deposit_data_root: string;
+    amount: string;
+  }>;
+  signer: SignerType;
+  chainId: number;
+}): Promise<{ txHashes: string[] }> => {
+  try {
+    const ovmContract = new Contract(ovmAddress, OVMContract.abi, signer);
+    const chainConfig = getChainConfig(chainId);
+    const multicall3Address = chainConfig.MULTICALL3_CONTRACT.address;
+    const multiCall3ContractInstance = new Contract(
+      multicall3Address,
+      MultiCall3Contract.abi,
+      signer,
+    );
+
+    const BATCH_SIZE = 500;
+    const txHashes: string[] = [];
+
+    // Process deposits in batches of 500
+    for (let i = 0; i < deposits.length; i += BATCH_SIZE) {
+      const batchDeposits = deposits.slice(i, i + BATCH_SIZE);
+
+      // Use Multicall3 aggregate3Value (payable per-call)
+      const callsWithValue = batchDeposits.map(deposit => ({
+        target: ovmAddress,
+        allowFailure: false,
+        callData: ovmContract.interface.encodeFunctionData('deposit', [
+          deposit.pubkey,
+          deposit.withdrawal_credentials,
+          deposit.signature,
+          deposit.deposit_data_root,
+        ]),
+        value: BigInt(deposit.amount),
+      }));
+
+      const totalBatchValue = callsWithValue.reduce(
+        (sum: bigint, c: { value: bigint }) => sum + c.value,
+        BigInt(0),
+      );
+
+      const tx = await multiCall3ContractInstance.aggregate3Value(
+        callsWithValue,
+        { value: totalBatchValue },
+      );
+
+      const receipt = await tx.wait();
+      if (receipt?.hash) {
+        txHashes.push(receipt.hash);
+      }
+    }
+
+    return { txHashes };
+  } catch (error: unknown) {
+    const errorMessage =
+      error instanceof Error ? error.message : 'Deposit failed';
     throw new Error(
-      `Failed to request withdrawal from OVM: ${error.message ?? 'Request withdrawal failed'}`,
+      `Failed to deposit to OVM with multicall3: ${errorMessage}`,
     );
   }
 };

package/src/splits/splits.ts

@@ -5,6 +5,7 @@ import {
   deployOVMContract,
   deployOVMAndSplitV2,
   requestWithdrawalFromOVM,
+  depositWithMulticall3,
 } from './splitHelpers';
 import {
   CHAIN_CONFIGURATION,
@@ -16,6 +17,7 @@ import {
   ovmRewardsSplitPayloadSchema,
   ovmTotalSplitPayloadSchema,
   ovmRequestWithdrawalPayloadSchema,
+  ovmDepositPayloadSchema,
 } from '../schema';
 import { validatePayload } from '../ajv';
 import { isContractAvailable } from '../utils';
@@ -26,6 +28,7 @@ import {
   type OVMRewardsSplitPayload,
   type OVMTotalSplitPayload,
   type OVMRequestWithdrawalPayload,
+  type OVMDepositPayload,
 } from '../types';
 
 /**
@@ -103,15 +106,15 @@ export class ObolSplits {
     }
     const ovmFactoryConfig = chainConfig.OVM_FACTORY_CONTRACT;
     const splitV2FactoryConfig = chainConfig.SPLIT_V2_FACTORY_CONTRACT;
-    const multiCallConfig = chainConfig.MULTICALL_CONTRACT;
+    const multiCall3Config = chainConfig.MULTICALL3_CONTRACT;
 
     if (
       !ovmFactoryConfig?.address ||
       !ovmFactoryConfig?.bytecode ||
       !splitV2FactoryConfig?.address ||
       !splitV2FactoryConfig?.bytecode ||
-      !multiCallConfig?.address ||
-      !multiCallConfig?.bytecode
+      !multiCall3Config?.address ||
+      !multiCall3Config?.bytecode
     ) {
       throw new Error(
         `Contracts configuration is incomplete for chain ${this.chainId}`,
@@ -130,16 +133,16 @@ export class ObolSplits {
       splitV2FactoryConfig.bytecode,
     );
 
-    const checkMultiCallContract = await isContractAvailable(
-      multiCallConfig.address,
+    const checkMultiCall3Contract = await isContractAvailable(
+      multiCall3Config.address,
       this.provider,
-      multiCallConfig.bytecode,
+      multiCall3Config.bytecode,
     );
 
     if (
       !checkOVMFactoryContract ||
       !checkSplitV2FactoryContract ||
-      !checkMultiCallContract
+      !checkMultiCall3Contract
     ) {
       throw new Error(
         `Splitter contract is not deployed or available on chain ${this.chainId}`,
@@ -270,15 +273,15 @@ export class ObolSplits {
 
     const ovmFactoryConfig = chainConfig.OVM_FACTORY_CONTRACT;
     const splitV2FactoryConfig = chainConfig.SPLIT_V2_FACTORY_CONTRACT;
-    const multiCallConfig = chainConfig.MULTICALL_CONTRACT;
+    const multiCall3Config = chainConfig.MULTICALL3_CONTRACT;
 
     if (
       !ovmFactoryConfig?.address ||
       !ovmFactoryConfig?.bytecode ||
       !splitV2FactoryConfig?.address ||
       !splitV2FactoryConfig?.bytecode ||
-      !multiCallConfig?.address ||
-      !multiCallConfig?.bytecode
+      !multiCall3Config?.address ||
+      !multiCall3Config?.bytecode
     ) {
       throw new Error(
         `Contracts configuration is incomplete for chain ${this.chainId}`,
@@ -297,16 +300,16 @@ export class ObolSplits {
       splitV2FactoryConfig.bytecode,
     );
 
-    const checkMultiCallContract = await isContractAvailable(
-      multiCallConfig.address,
+    const checkMultiCall3Contract = await isContractAvailable(
+      multiCall3Config.address,
       this.provider,
-      multiCallConfig.bytecode,
+      multiCall3Config.bytecode,
     );
 
     if (
       !checkOVMFactoryContract ||
       !checkSplitV2FactoryContract ||
-      !checkMultiCallContract
+      !checkMultiCall3Contract
     ) {
       throw new Error(
         `Splitter contract is not deployed or available on chain ${this.chainId}`,
@@ -382,7 +385,7 @@ export class ObolSplits {
         fee_recipient_address: predictedRewardsSplitAddress,
       };
     } else {
-      // Use multicall to deploy any contracts that aren't deployed
+      // Use multicall3 to deploy any contracts that aren't deployed
       const ovmAddress = await deployOVMAndSplitV2({
         ovmArgs: {
           OVMOwnerAddress: validatedPayload.OVMOwnerAddress,
@@ -451,4 +454,51 @@ export class ObolSplits {
       signer: this.signer,
     });
   }
+
+  /**
+   * Deposits to OVM contract using multicall3 for batch operations.
+   *
+   * This method allows depositing to an OVM contract using multicall3 for efficient batch processing.
+   * Each deposit includes validator public key, withdrawal credentials, signature, deposit data root, and 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 {OVMDepositPayload} payload - Data needed to deposit to OVM
+   * @returns {Promise<{txHashes: string[]}>} Array of transaction hashes for all batches
+   * @throws Will throw an error if the signer is not provided, OVM address is invalid, or the deposit fails
+   *
+   * An example of how to use deposit:
+   * ```typescript
+   * const result = await client.splits.deposit({
+   *   ovmAddress: '0x1234567890123456789012345678901234567890',
+   *   deposits: [{
+   *     pubkey: '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
+   *     withdrawal_credentials: '0x1234567890123456789012345678901234567890',
+   *     signature: '0x123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456',
+   *     deposit_data_root: '0x1234567890123456789012345678901234567890123456789012345678901234',
+   *     amount: '32000000000000000000' // 32 ETH in wei
+   *   }]
+   * });
+   * console.log('Deposits completed:', result.txHashes);
+   * ```
+   */
+  async deposit(payload: OVMDepositPayload): Promise<{ txHashes: string[] }> {
+    if (!this.signer) {
+      throw new Error('Signer is required in deposit');
+    }
+
+    const validatedPayload = validatePayload<OVMDepositPayload>(
+      payload,
+      ovmDepositPayloadSchema,
+    );
+
+    return await depositWithMulticall3({
+      ovmAddress: validatedPayload.ovmAddress,
+      deposits: validatedPayload.deposits,
+      signer: this.signer,
+      chainId: this.chainId,
+    });
+  }
 }

package/src/types.ts

@@ -582,7 +582,7 @@ export type ChainConfig = {
     address: string;
     bytecode: string;
   };
-  MULTICALL_CONTRACT: {
+  MULTICALL3_CONTRACT: {
     address: string;
     bytecode: string;
   };
@@ -609,6 +609,9 @@ export type ChainConfig = {
   EOA_WITHDRAWAL_CONTRACT?: {
     address: string;
   };
+  BATCH_DEPOSIT_CONTRACT?: {
+    address: string;
+  };
 };
 
 /**
@@ -641,3 +644,42 @@ export type EOAWithdrawalPayload = {
   /** Required fee in wei */
   requiredFee: string;
 };
+
+/**
+ * Payload for depositing to OVM contract with multicall3
+ */
+export type OVMDepositPayload = {
+  /** OVM contract address */
+  ovmAddress: string;
+
+  /** Array of deposit objects */
+  deposits: Array<{
+    /** Validator public key in hex format (48 bytes) */
+    pubkey: string;
+    /** Withdrawal credentials in hex format */
+    withdrawal_credentials: string;
+    /** Deposit signature in hex format */
+    signature: string;
+    /** Deposit data root in hex format (32 bytes) */
+    deposit_data_root: string;
+    /** Deposit amount in wei as string */
+    amount: string;
+  }>;
+};
+
+/**
+ * Payload for depositing to batch deposit contract
+ */
+export type EOADepositPayload = {
+  /** Array of deposit objects */
+  deposits: Array<{
+    /** Validator public key in hex format (48 bytes) */
+    pubKey: string;
+    /** Withdrawal credentials in hex format */
+    withdrawalCredentials: string;
+    /** Deposit signature in hex format */
+    signature: string;
+    /** Deposit amount in wei as string */
+    amount: string;
+  }>;
+};

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

@@ -1,148 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiCallContract = void 0;
-exports.MultiCallContract = {
-    abi: [
-        {
-            constant: true,
-            inputs: [],
-            name: 'getCurrentBlockTimestamp',
-            outputs: [
-                {
-                    name: 'timestamp',
-                    type: 'uint256',
-                },
-            ],
-            payable: false,
-            stateMutability: 'view',
-            type: 'function',
-        },
-        {
-            constant: false,
-            inputs: [
-                {
-                    components: [
-                        {
-                            name: 'target',
-                            type: 'address',
-                        },
-                        {
-                            name: 'callData',
-                            type: 'bytes',
-                        },
-                    ],
-                    name: 'calls',
-                    type: 'tuple[]',
-                },
-            ],
-            name: 'aggregate',
-            outputs: [
-                {
-                    name: 'blockNumber',
-                    type: 'uint256',
-                },
-                {
-                    name: 'returnData',
-                    type: 'bytes[]',
-                },
-            ],
-            payable: false,
-            stateMutability: 'nonpayable',
-            type: 'function',
-        },
-        {
-            constant: true,
-            inputs: [],
-            name: 'getLastBlockHash',
-            outputs: [
-                {
-                    name: 'blockHash',
-                    type: 'bytes32',
-                },
-            ],
-            payable: false,
-            stateMutability: 'view',
-            type: 'function',
-        },
-        {
-            constant: true,
-            inputs: [
-                {
-                    name: 'addr',
-                    type: 'address',
-                },
-            ],
-            name: 'getEthBalance',
-            outputs: [
-                {
-                    name: 'balance',
-                    type: 'uint256',
-                },
-            ],
-            payable: false,
-            stateMutability: 'view',
-            type: 'function',
-        },
-        {
-            constant: true,
-            inputs: [],
-            name: 'getCurrentBlockDifficulty',
-            outputs: [
-                {
-                    name: 'difficulty',
-                    type: 'uint256',
-                },
-            ],
-            payable: false,
-            stateMutability: 'view',
-            type: 'function',
-        },
-        {
-            constant: true,
-            inputs: [],
-            name: 'getCurrentBlockGasLimit',
-            outputs: [
-                {
-                    name: 'gaslimit',
-                    type: 'uint256',
-                },
-            ],
-            payable: false,
-            stateMutability: 'view',
-            type: 'function',
-        },
-        {
-            constant: true,
-            inputs: [],
-            name: 'getCurrentBlockCoinbase',
-            outputs: [
-                {
-                    name: 'coinbase',
-                    type: 'address',
-                },
-            ],
-            payable: false,
-            stateMutability: 'view',
-            type: 'function',
-        },
-        {
-            constant: true,
-            inputs: [
-                {
-                    name: 'blockNumber',
-                    type: 'uint256',
-                },
-            ],
-            name: 'getBlockHash',
-            outputs: [
-                {
-                    name: 'blockHash',
-                    type: 'bytes32',
-                },
-            ],
-            payable: false,
-            stateMutability: 'view',
-            type: 'function',
-        },
-    ],
-};