@obolnetwork/obol-sdk 2.8.0 → 2.9.0

package/src/constants.ts

@@ -9,11 +9,13 @@ import {
   HOODI_MULTICALL_BYTECODE,
   HOODI_OVM_FACTORY_BYTECODE,
   HOODI_OWR_FACTORY_BYTECODE,
+  HOODI_SPLIT_V2_FACTORY_BYTECODE,
   HOODI_SPLITMAIN_BYTECODE,
   HOODI_WAREHOUSE_BYTECODE,
   MAINNET_MULTICALL_BYTECODE,
   MAINNET_OVM_FACTORY_BYTECODE,
   MAINNET_OWR_FACTORY_BYTECODE,
+  MAINNET_SPLIT_V2_FACTORY_BYTECODE,
   MAINNET_SPLITMAIN_BYTECODE,
   MAINNET_WAREHOUSE_BYTECODE,
 } from './bytecodes';
@@ -168,76 +170,84 @@ export const isChainSupportedForSplitters = (chainId: number): boolean => {
 
 export const CHAIN_CONFIGURATION: Record<number, ChainConfig> = {
   [FORK_MAPPING['0x00000000']]: {
-    SPLITMAIN_ADDRESS: {
+    SPLITMAIN_CONTRACT: {
       address: '0x2ed6c4B5dA6378c7897AC67Ba9e43102Feb694EE',
       bytecode: MAINNET_SPLITMAIN_BYTECODE,
     },
-    MULTICALL_ADDRESS: {
+    MULTICALL_CONTRACT: {
       address: '0xeefba1e63905ef1d7acba5a8513c70307c1ce441',
       bytecode: MAINNET_MULTICALL_BYTECODE,
     },
-    OWR_FACTORY_ADDRESS: {
+    OWR_FACTORY_CONTRACT: {
       address: '0x119acd7844cbdd5fc09b1c6a4408f490c8f7f522',
       bytecode: MAINNET_OWR_FACTORY_BYTECODE,
     },
-    RETROACTIVE_FUNDING_ADDRESS: {
+    RETROACTIVE_FUNDING_CONTRACT: {
       address: '0xDe5aE4De36c966747Ea7DF13BD9589642e2B1D0d',
       bytecode: '',
     },
     // OVM and SplitV2 Contract Addresses
-    OVM_FACTORY_ADDRESS: {
+    OVM_FACTORY_CONTRACT: {
       address: '0xdfe2d8b26806583cf03b3cb623b0752f8670e93e',
       bytecode: MAINNET_OVM_FACTORY_BYTECODE,
     },
-    WAREHOUSE_ADDRESS: {
+    WAREHOUSE_CONTRACT: {
       address: '0x8fb66F38cF86A3d5e8768f8F1754A24A6c661Fb8',
       bytecode: MAINNET_WAREHOUSE_BYTECODE,
     },
+    SPLIT_V2_FACTORY_CONTRACT: {
+      address: '0x5cbA88D55Cec83caD5A105Ad40C8c9aF20bE21d1',
+      bytecode: MAINNET_SPLIT_V2_FACTORY_BYTECODE,
+    },
   },
   [FORK_MAPPING['0x01017000']]: {
-    SPLITMAIN_ADDRESS: {
+    SPLITMAIN_CONTRACT: {
       address: '0xfC8a305728051367797DADE6Aa0344E0987f5286',
       bytecode: HOLESKY_SPLITMAIN_BYTECODE,
     },
-    MULTICALL_ADDRESS: {
+    MULTICALL_CONTRACT: {
       address: '0xcA11bde05977b3631167028862bE2a173976CA11',
       bytecode: HOLESKY_MULTICALL_BYTECODE,
     },
-    OWR_FACTORY_ADDRESS: {
+    OWR_FACTORY_CONTRACT: {
       address: '0xc0961353fcc43a99e3041db07ac646720e116256',
       bytecode: HOLESKY_OWR_FACTORY_BYTECODE,
     },
-    RETROACTIVE_FUNDING_ADDRESS: {
+    RETROACTIVE_FUNDING_CONTRACT: {
       address: '0x43F641fA70e09f0326ac66b4Ef0C416EaEcBC6f5',
       bytecode: '',
     },
   },
   [FORK_MAPPING['0x10000910']]: {
-    SPLITMAIN_ADDRESS: {
+    SPLITMAIN_CONTRACT: {
       address: '0xc05ae267291705ac16F75283572294ed2a91CBc7',
       bytecode: HOODI_SPLITMAIN_BYTECODE,
     },
-    MULTICALL_ADDRESS: {
+    MULTICALL_CONTRACT: {
       address: '0xcA11bde05977b3631167028862bE2a173976CA11',
       bytecode: HOODI_MULTICALL_BYTECODE,
     },
-    OWR_FACTORY_ADDRESS: {
+    OWR_FACTORY_CONTRACT: {
       address: '0x9ff0c649d0bf5fe7efa4d72e94bed7302ed5c8d7',
       bytecode: HOODI_OWR_FACTORY_BYTECODE,
     },
-    RETROACTIVE_FUNDING_ADDRESS: {
+    RETROACTIVE_FUNDING_CONTRACT: {
       address: '0x43F641fA70e09f0326ac66b4Ef0C416EaEcBC6f5',
       bytecode: '',
     },
     // OVM and SplitV2 Contract Addresses
-    OVM_FACTORY_ADDRESS: {
+    OVM_FACTORY_CONTRACT: {
       address: '0x6F13d929C783a420AE4DC71C1dcc27A02038Ed09',
       bytecode: HOODI_OVM_FACTORY_BYTECODE,
     },
-    WAREHOUSE_ADDRESS: {
+    WAREHOUSE_CONTRACT: {
       address: '0x8fb66F38cF86A3d5e8768f8F1754A24A6c661Fb8',
       bytecode: HOODI_WAREHOUSE_BYTECODE,
     },
+    SPLIT_V2_FACTORY_CONTRACT: {
+      address: '0x5cbA88D55Cec83caD5A105Ad40C8c9aF20bE21d1',
+      bytecode: HOODI_SPLIT_V2_FACTORY_BYTECODE,
+    },
   },
 };
 

package/src/index.ts

@@ -221,28 +221,28 @@ export class Client extends Base {
     }
 
     const chainConfig = CHAIN_CONFIGURATION[this.chainId];
-    if (!chainConfig?.SPLITMAIN_ADDRESS) {
+    if (!chainConfig?.SPLITMAIN_CONTRACT) {
       throw new Error(
-        `SPLITMAIN_ADDRESS is not configured for chain ${this.chainId}`,
+        `SPLITMAIN_CONTRACT is not configured for chain ${this.chainId}`,
       );
     }
 
     const checkSplitMainAddress = await isContractAvailable(
-      chainConfig.SPLITMAIN_ADDRESS.address,
+      chainConfig.SPLITMAIN_CONTRACT.address,
       this.signer.provider as ProviderType,
-      chainConfig.SPLITMAIN_ADDRESS.bytecode,
+      chainConfig.SPLITMAIN_CONTRACT.bytecode,
     );
 
     const checkMulticallAddress = await isContractAvailable(
-      chainConfig.MULTICALL_ADDRESS.address,
+      chainConfig.MULTICALL_CONTRACT.address,
       this.signer.provider as ProviderType,
-      chainConfig.MULTICALL_ADDRESS.bytecode,
+      chainConfig.MULTICALL_CONTRACT.bytecode,
     );
 
     const checkOWRFactoryAddress = await isContractAvailable(
-      chainConfig.OWR_FACTORY_ADDRESS.address,
+      chainConfig.OWR_FACTORY_CONTRACT.address,
       this.signer.provider as ProviderType,
-      chainConfig.OWR_FACTORY_ADDRESS.bytecode,
+      chainConfig.OWR_FACTORY_CONTRACT.bytecode,
     );
 
     if (
@@ -256,7 +256,7 @@ export class Client extends Base {
     }
 
     const retroActiveFundingRecipient = {
-      account: chainConfig.RETROACTIVE_FUNDING_ADDRESS.address,
+      account: chainConfig.RETROACTIVE_FUNDING_CONTRACT.address,
       percentAllocation: validatedPayload.ObolRAFSplit,
     };
 
@@ -342,16 +342,16 @@ export class Client extends Base {
     }
 
     const chainConfig = CHAIN_CONFIGURATION[this.chainId];
-    if (!chainConfig?.SPLITMAIN_ADDRESS) {
+    if (!chainConfig?.SPLITMAIN_CONTRACT) {
       throw new Error(
-        `SPLITMAIN_ADDRESS is not configured for chain ${this.chainId}`,
+        `SPLITMAIN_CONTRACT is not configured for chain ${this.chainId}`,
       );
     }
 
     const checkSplitMainAddress = await isContractAvailable(
-      chainConfig.SPLITMAIN_ADDRESS.address,
+      chainConfig.SPLITMAIN_CONTRACT.address,
       this.signer.provider as ProviderType,
-      chainConfig.SPLITMAIN_ADDRESS.bytecode,
+      chainConfig.SPLITMAIN_CONTRACT.bytecode,
     );
 
     if (!checkSplitMainAddress) {
@@ -361,7 +361,7 @@ export class Client extends Base {
     }
 
     const retroActiveFundingRecipient = {
-      account: chainConfig.RETROACTIVE_FUNDING_ADDRESS.address,
+      account: chainConfig.RETROACTIVE_FUNDING_CONTRACT.address,
       percentAllocation: validatedPayload.ObolRAFSplit,
     };
 

package/src/schema.ts

@@ -5,7 +5,6 @@ import {
   PRINCIPAL_THRESHOLD,
 } from './constants';
 import { VALID_DEPOSIT_AMOUNTS, VALID_NON_COMPOUNDING_AMOUNTS } from './ajv';
-import { zeroAddress } from 'viem';
 
 export const operatorPayloadSchema = {
   type: 'object',
@@ -175,7 +174,7 @@ export const ovmBaseSplitPayload = {
   splitOwnerAddress: {
     type: 'string',
     pattern: '^0x[a-fA-F0-9]{40}$',
-    default: zeroAddress,
+    default: ZeroAddress,
   },
   principalThreshold: {
     type: 'number',
@@ -230,3 +229,31 @@ export const ovmTotalSplitPayloadSchema = {
     'OVMOwnerAddress',
   ],
 };
+
+export const ovmRequestWithdrawalPayloadSchema = {
+  type: 'object',
+  properties: {
+    ovmAddress: {
+      type: 'string',
+      pattern: '^0x[a-fA-F0-9]{40}$',
+    },
+    pubKeys: {
+      type: 'array',
+      minItems: 1,
+      items: {
+        type: 'string',
+        pattern: '^0x[a-fA-F0-9]{96}$', // 48 bytes = 96 hex chars + 0x prefix
+      },
+    },
+    amounts: {
+      type: 'array',
+      minItems: 1,
+      items: {
+        type: 'string',
+        pattern: '^[0-9]+$',
+      },
+    },
+  },
+  validateOVMRequestWithdrawalPayload: true,
+  required: ['ovmAddress', 'pubKeys', 'amounts'],
+};

package/src/splits/splitHelpers.ts

@@ -8,27 +8,18 @@ import {
   type OVMArgs,
   type ChainConfig,
 } from '../types';
-import {
-  BrowserProvider,
-  Contract,
-  Interface,
-  parseEther,
-  type Wallet,
-  ZeroAddress,
-} from 'ethers';
+import { Contract, Interface, parseEther, ZeroAddress } from 'ethers';
 import { OWRContract, OWRFactoryContract } from '../abi/OWR';
-import { OVMFactoryContract } from '../abi/OVMFactory';
+import { OVMFactoryContract, OVMContract } from '../abi/OVMFactory';
 import { splitMainEthereumAbi } from '../abi/SplitMain';
 import { MultiCallContract } from '../abi/Multicall';
-import { CHAIN_CONFIGURATION, CHAIN_PUBLIC_RPC_URL } from '../constants';
-import { SplitsClient } from '@0xsplits/splits-sdk';
-import { createPublicClient, createWalletClient, custom, http } from 'viem';
-import { hoodi, mainnet } from 'viem/chains';
-import { privateKeyToAccount } from 'viem/accounts';
+import { CHAIN_CONFIGURATION } from '../constants';
+import { splitV2FactoryAbi } from '../abi/splitV2FactoryAbi';
 
 const splitMainContractInterface = new Interface(splitMainEthereumAbi);
 const owrFactoryContractInterface = new Interface(OWRFactoryContract.abi);
 const ovmFactoryContractInterface = new Interface(OVMFactoryContract.abi);
+const splitV2FactoryInterface = new Interface(splitV2FactoryAbi);
 
 type Call = {
   target: ETH_ADDRESS;
@@ -104,7 +95,7 @@ export const predictSplitterAddress = async ({
 }): Promise<ETH_ADDRESS> => {
   try {
     const splitMainContractInstance = new Contract(
-      getChainConfig(chainId).SPLITMAIN_ADDRESS.address,
+      getChainConfig(chainId).SPLITMAIN_CONTRACT.address,
       splitMainEthereumAbi,
       signer,
     );
@@ -258,7 +249,7 @@ const createOWRContract = async ({
 }): Promise<ETH_ADDRESS> => {
   try {
     const OWRFactoryInstance = new Contract(
-      getChainConfig(chainId).OWR_FACTORY_ADDRESS.address,
+      getChainConfig(chainId).OWR_FACTORY_CONTRACT.address,
       OWRFactoryContract.abi,
       signer,
     );
@@ -345,7 +336,7 @@ export const deploySplitterContract = async ({
 }): Promise<ETH_ADDRESS> => {
   try {
     const splitMainContractInstance = new Contract(
-      getChainConfig(chainId).SPLITMAIN_ADDRESS.address,
+      getChainConfig(chainId).SPLITMAIN_CONTRACT.address,
       splitMainEthereumAbi,
       signer,
     );
@@ -444,21 +435,16 @@ export const deploySplitterAndOWRContracts = async ({
 
   executeCalls.push(
     {
-      target: getChainConfig(chainId).SPLITMAIN_ADDRESS.address,
+      target: getChainConfig(chainId).SPLITMAIN_CONTRACT.address,
       callData: splitTxData,
     },
     {
-      target: getChainConfig(chainId).OWR_FACTORY_ADDRESS.address,
+      target: getChainConfig(chainId).OWR_FACTORY_CONTRACT.address,
       callData: owrTxData,
     },
   );
-  const multicallAddess = getChainConfig(chainId).MULTICALL_ADDRESS.address;
 
-  const executeMultiCalls = await multicall(
-    executeCalls,
-    signer,
-    multicallAddess,
-  );
+  const executeMultiCalls = await multicall(executeCalls, signer, chainId);
 
   const splitAddressData = executeMultiCalls?.logs[0]?.topics[1];
   const formattedSplitterAddress = '0x' + splitAddressData?.slice(26, 66);
@@ -519,9 +505,11 @@ export const getOWRTranches = async ({
 export const multicall = async (
   calls: Call[],
   signer: SignerType,
-  multicallAddress: string,
+  chainId: number,
 ): Promise<any> => {
   try {
+    const chainConfig = getChainConfig(chainId);
+    const multicallAddress = chainConfig.MULTICALL_CONTRACT.address;
     const multiCallContractInstance = new Contract(
       multicallAddress,
       MultiCallContract.abi,
@@ -613,57 +601,31 @@ export const formatRecipientsForSplitV2 = (
     }));
 };
 
-export const createSplitsClient = async (
-  signer: SignerType,
-  chainId: number,
-): Promise<SplitsClient> => {
-  const chain = chainId === 1 ? mainnet : hoodi;
-  const client = createPublicClient({
-    chain,
-    transport: http(CHAIN_PUBLIC_RPC_URL[chainId]),
-  });
-  // convert signer to walletClient
-  if (
-    typeof window !== 'undefined' &&
-    signer.provider instanceof BrowserProvider
-  ) {
-    // For browser environment
-    const address = await signer.getAddress();
-    const viemWalletClient = createWalletClient({
-      account: address,
-      chain,
-      transport: custom((window as any).ethereum),
-    });
-    return new SplitsClient({
-      publicClient: client,
-      walletClient: viemWalletClient,
-      chainId,
-    });
-  } else {
-    // For non-browser environment, extract private key from signer
-    const signerPrivateKey = (signer as Wallet)?.privateKey;
-    if (!signerPrivateKey) {
-      throw new Error('Signer private key not available');
-    }
-
-    const privateKey = signerPrivateKey.startsWith('0x')
-      ? signerPrivateKey
-      : `0x${signerPrivateKey}`;
-
-    const scriptAccount = privateKeyToAccount(privateKey as `0x${string}`);
-    const account = scriptAccount;
+// Helper function to create SplitV2 parameters
+const createSplitV2Params = (
+  recipients: SplitV2Recipient[],
+  distributorFeePercent: number,
+): {
+  recipients: string[];
+  allocations: number[];
+  totalAllocation: number;
+  distributionIncentive: number;
+} => {
+  const addresses = recipients.map(r => r.address);
+  const allocations = recipients.map(r =>
+    Math.floor(r.percentAllocation * 1e4),
+  ); // Convert to basis points
+  const totalAllocation = allocations.reduce(
+    (sum, allocation) => sum + allocation,
+    0,
+  );
 
-    const viemWalletClient = createWalletClient({
-      account,
-      chain,
-      transport: http(CHAIN_PUBLIC_RPC_URL[chainId]),
-    });
-    return new SplitsClient({
-      publicClient: client,
-      walletClient: viemWalletClient,
-      chainId,
-    });
-  }
+  return {
+    recipients: addresses,
+    allocations,
+    totalAllocation,
+    distributionIncentive: distributorFeePercent,
+  };
 };
 
 export const predictSplitV2Address = async ({
@@ -682,19 +644,27 @@ export const predictSplitV2Address = async ({
   chainId: number;
 }): Promise<string> => {
   try {
-    const splitsClient = await createSplitsClient(signer, chainId);
+    const chainConfig = getChainConfig(chainId);
+    if (!chainConfig?.SPLIT_V2_FACTORY_CONTRACT?.address) {
+      throw new Error(`SplitV2 Factory not configured for chain ${chainId}`);
+    }
 
-    const response = await splitsClient.splitV2.predictDeterministicAddress({
-      ownerAddress: splitOwnerAddress,
-      recipients,
-      distributorFeePercent,
-      salt,
-    });
+    const splitV2FactoryContract = new Contract(
+      chainConfig.SPLIT_V2_FACTORY_CONTRACT.address,
+      splitV2FactoryAbi,
+      signer,
+    );
+
+    const splitParams = createSplitV2Params(recipients, distributorFeePercent);
+
+    const predictedAddress = await splitV2FactoryContract[
+      'predictDeterministicAddress((address[],uint256[],uint256,uint16),address,bytes32)'
+    ](splitParams, splitOwnerAddress, salt);
 
-    return response.splitAddress;
+    return predictedAddress;
   } catch (error: any) {
     throw new Error(
-      `Failed to predict SplitV2 address: ${error.message ?? 'SplitV2 SDK call failed'}`,
+      `Failed to predict SplitV2 address: ${error.message ?? 'SplitV2 contract call failed'}`,
     );
   }
 };
@@ -715,15 +685,26 @@ export const isSplitV2Deployed = async ({
   chainId: number;
 }): Promise<boolean> => {
   try {
-    const splitsClient = await createSplitsClient(signer, chainId);
-    const response = await splitsClient.splitV2.isDeployed({
-      ownerAddress: splitOwnerAddress,
-      recipients,
-      distributorFeePercent,
+    const chainConfig = getChainConfig(chainId);
+    if (!chainConfig?.SPLIT_V2_FACTORY_CONTRACT?.address) {
+      throw new Error(`SplitV2 Factory not configured for chain ${chainId}`);
+    }
+
+    const splitV2FactoryContract = new Contract(
+      chainConfig.SPLIT_V2_FACTORY_CONTRACT.address,
+      splitV2FactoryAbi,
+      signer,
+    );
+
+    const splitParams = createSplitV2Params(recipients, distributorFeePercent);
+
+    const [, exists] = await splitV2FactoryContract.isDeployed(
+      splitParams,
+      splitOwnerAddress,
       salt,
-    });
+    );
 
-    return response.deployed;
+    return exists;
   } catch (error: any) {
     // If the check fails, assume it's not deployed
     return false;
@@ -747,12 +728,12 @@ export const deployOVMContract = async ({
 }): Promise<string> => {
   try {
     const chainConfig = getChainConfig(chainId);
-    if (!chainConfig?.OVM_FACTORY_ADDRESS?.address) {
+    if (!chainConfig?.OVM_FACTORY_CONTRACT?.address) {
       throw new Error(`OVM Factory not configured for chain ${chainId}`);
     }
 
     const ovmFactoryContract = new Contract(
-      chainConfig.OVM_FACTORY_ADDRESS.address,
+      chainConfig.OVM_FACTORY_CONTRACT.address,
       OVMFactoryContract.abi,
       signer,
     );
@@ -806,36 +787,49 @@ export const deployOVMAndSplitV2 = async ({
 }): Promise<string> => {
   try {
     const chainConfig = getChainConfig(chainId);
-    if (!chainConfig?.OVM_FACTORY_ADDRESS?.address) {
+    if (!chainConfig?.OVM_FACTORY_CONTRACT?.address) {
       throw new Error(`OVM Factory not configured for chain ${chainId}`);
     }
 
-    const splitsClient = await createSplitsClient(signer, chainId);
-    const executeCalls: any[] = [];
+    if (!chainConfig?.SPLIT_V2_FACTORY_CONTRACT?.address) {
+      throw new Error(`SplitV2 Factory not configured for chain ${chainId}`);
+    }
+
+    const executeCalls: Call[] = [];
 
     if (rewardRecipients && !isRewardsSplitterDeployed) {
       // Create rewards split call data
-      const rewardsSplitTxData =
-        await splitsClient.splitV2.callData.createSplit({
-          recipients: rewardRecipients,
-          distributorFeePercent,
-          ownerAddress: splitOwnerAddress,
-          salt,
-        });
+      const splitParams = createSplitV2Params(
+        rewardRecipients,
+        distributorFeePercent,
+      );
+      const rewardsSplitTxData = encodeCreateSplitV2DeterministicTxData(
+        splitParams,
+        splitOwnerAddress,
+        salt,
+      );
 
-      executeCalls.push(rewardsSplitTxData);
+      executeCalls.push({
+        target: chainConfig.SPLIT_V2_FACTORY_CONTRACT.address,
+        callData: rewardsSplitTxData,
+      });
     }
 
     // Create principal split call data if needed (for total split scenario)
     if (principalSplitRecipients && !isPrincipalSplitDeployed) {
-      const principalSplitTxData =
-        await splitsClient.splitV2.callData.createSplit({
-          recipients: principalSplitRecipients,
-          distributorFeePercent,
-          salt,
-          ownerAddress: splitOwnerAddress,
-        });
-      executeCalls.push(principalSplitTxData);
+      const principalSplitParams = createSplitV2Params(
+        principalSplitRecipients,
+        distributorFeePercent,
+      );
+      const principalSplitTxData = encodeCreateSplitV2DeterministicTxData(
+        principalSplitParams,
+        splitOwnerAddress,
+        salt,
+      );
+      executeCalls.push({
+        target: chainConfig.SPLIT_V2_FACTORY_CONTRACT.address,
+        callData: principalSplitTxData,
+      });
     }
 
     // Create OVM call data
@@ -847,25 +841,23 @@ export const deployOVMAndSplitV2 = async ({
     );
 
     executeCalls.push({
-      address: chainConfig.OVM_FACTORY_ADDRESS.address,
-      data: ovmTxData,
+      target: chainConfig.OVM_FACTORY_CONTRACT.address,
+      callData: ovmTxData,
     });
 
     // Execute multicall
-    const executeMultiCalls = await splitsClient.splitV2.multicall({
-      calls: executeCalls,
-    });
+    const executeMultiCalls = await multicall(executeCalls, signer, chainId);
 
     // Extract addresses from events
     let ovmAddress: string | undefined;
-    const eventCount = executeMultiCalls?.events.length;
+    const logsCount = executeMultiCalls?.logs?.length || 0;
 
-    if (eventCount === 2) {
-      ovmAddress = executeMultiCalls?.events[0]?.address;
-    } else if (eventCount === 5) {
-      ovmAddress = executeMultiCalls?.events[3]?.address;
+    if (logsCount === 2) {
+      ovmAddress = '0x' + executeMultiCalls?.logs[1]?.topics[1]?.slice(26, 66);
+    } else if (logsCount === 5) {
+      ovmAddress = '0x' + executeMultiCalls?.logs[4]?.topics[1]?.slice(26, 66);
     } else {
-      ovmAddress = executeMultiCalls?.events[6]?.address;
+      ovmAddress = '0x' + executeMultiCalls?.logs[7]?.topics[1]?.slice(26, 66);
     }
     if (!ovmAddress) {
       throw new Error(
@@ -893,6 +885,23 @@ const encodeCreateOVMTxData = (
   );
 };
 
+const encodeCreateSplitV2DeterministicTxData = (
+  splitParams: {
+    recipients: string[];
+    allocations: number[];
+    totalAllocation: number;
+    distributionIncentive: number;
+  },
+  splitOwnerAddress: string,
+  salt: `0x${string}`,
+): string => {
+  // creatorAddress can be kept as default https://docs.splits.org/sdk/splits-v2#createsplit
+  return splitV2FactoryInterface.encodeFunctionData(
+    'createSplitDeterministic',
+    [splitParams, splitOwnerAddress, ZeroAddress, salt],
+  );
+};
+
 // Helper function to safely get chain configuration
 const getChainConfig = (chainId: number): ChainConfig => {
   const config = CHAIN_CONFIGURATION[chainId];
@@ -901,3 +910,39 @@ const getChainConfig = (chainId: number): ChainConfig => {
   }
   return config;
 };
+
+/**
+ * Requests withdrawal from an OVM contract
+ * @param ovmAddress - The address of the OVM contract
+ * @param pubKeys - Array of validator public keys in bytes format
+ * @param amounts - Array of withdrawal amounts in wei (uint64)
+ * @param signer - The signer to use for the transaction
+ * @returns Promise that resolves to the transaction hash
+ */
+export const requestWithdrawalFromOVM = async ({
+  ovmAddress,
+  pubKeys,
+  amounts,
+  signer,
+}: {
+  ovmAddress: string;
+  pubKeys: string[];
+  amounts: string[];
+  signer: SignerType;
+}): Promise<{ txHash: string }> => {
+  try {
+    // Convert string amounts to bigint
+    const bigintAmounts = amounts.map(amount => BigInt(amount));
+
+    const ovmContract = new Contract(ovmAddress, OVMContract.abi, signer);
+
+    const tx = await ovmContract.requestWithdrawal(pubKeys, bigintAmounts);
+    const receipt = await tx.wait();
+
+    return { txHash: receipt.hash };
+  } catch (error: any) {
+    throw new Error(
+      `Failed to request withdrawal from OVM: ${error.message ?? 'Request withdrawal failed'}`,
+    );
+  }
+};