@obolnetwork/obol-sdk 2.7.0 → 2.8.0

package/src/index.ts

@@ -12,10 +12,10 @@ import {
   TermsAndConditionsSigningTypes,
   DEFAULT_BASE_VERSION,
   TERMS_AND_CONDITIONS_HASH,
-  AVAILABLE_SPLITTER_CHAINS,
   CHAIN_CONFIGURATION,
   DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
   OBOL_SDK_EMAIL,
+  isChainSupportedForSplitters,
 } from './constants.js';
 import { ConflictError } from './errors.js';
 import {
@@ -49,6 +49,7 @@ import {
 import { isContractAvailable } from './utils.js';
 import { Incentives } from './incentives/incentives.js';
 import { Exit } from './exits/exit.js';
+import { ObolSplits } from './splits/splits.js';
 export * from './types.js';
 export * from './services.js';
 export * from './verification/signature-validator.js';
@@ -56,6 +57,7 @@ export * from './verification/common.js';
 export * from './constants.js';
 export { Incentives } from './incentives/incentives.js';
 export { Exit } from './exits/exit.js';
+export { ObolSplits } from './splits/splits.js';
 
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.
@@ -78,6 +80,12 @@ export class Client extends Base {
    */
   public exit: Exit;
 
+  /**
+   * The splits module, responsible for managing splits.
+   * @type {ObolSplits}
+   */
+  public splits: ObolSplits;
+
   /**
    * 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.
@@ -112,6 +120,7 @@ export class Client extends Base {
       this.provider,
     );
     this.exit = new Exit(this.chainId, this.provider);
+    this.splits = new ObolSplits(this.signer, this.chainId, this.provider);
   }
 
   /**
@@ -205,28 +214,35 @@ export class Client extends Base {
     );
 
     // Check if we allow splitters on this chainId
-    if (!AVAILABLE_SPLITTER_CHAINS.includes(this.chainId)) {
+    if (!isChainSupportedForSplitters(this.chainId)) {
       throw new Error(
         `Splitter configuration is not supported on ${this.chainId} chain`,
       );
     }
 
+    const chainConfig = CHAIN_CONFIGURATION[this.chainId];
+    if (!chainConfig?.SPLITMAIN_ADDRESS) {
+      throw new Error(
+        `SPLITMAIN_ADDRESS is not configured for chain ${this.chainId}`,
+      );
+    }
+
     const checkSplitMainAddress = await isContractAvailable(
-      CHAIN_CONFIGURATION[this.chainId].SPLITMAIN_ADDRESS.address,
+      chainConfig.SPLITMAIN_ADDRESS.address,
       this.signer.provider as ProviderType,
-      CHAIN_CONFIGURATION[this.chainId].SPLITMAIN_ADDRESS.bytecode,
+      chainConfig.SPLITMAIN_ADDRESS.bytecode,
     );
 
     const checkMulticallAddress = await isContractAvailable(
-      CHAIN_CONFIGURATION[this.chainId].MULTICALL_ADDRESS.address,
+      chainConfig.MULTICALL_ADDRESS.address,
       this.signer.provider as ProviderType,
-      CHAIN_CONFIGURATION[this.chainId].MULTICALL_ADDRESS.bytecode,
+      chainConfig.MULTICALL_ADDRESS.bytecode,
     );
 
     const checkOWRFactoryAddress = await isContractAvailable(
-      CHAIN_CONFIGURATION[this.chainId].OWR_FACTORY_ADDRESS.address,
+      chainConfig.OWR_FACTORY_ADDRESS.address,
       this.signer.provider as ProviderType,
-      CHAIN_CONFIGURATION[this.chainId].OWR_FACTORY_ADDRESS.bytecode,
+      chainConfig.OWR_FACTORY_ADDRESS.bytecode,
     );
 
     if (
@@ -240,8 +256,7 @@ export class Client extends Base {
     }
 
     const retroActiveFundingRecipient = {
-      account:
-        CHAIN_CONFIGURATION[this.chainId].RETROACTIVE_FUNDING_ADDRESS.address,
+      account: chainConfig.RETROACTIVE_FUNDING_ADDRESS.address,
       percentAllocation: validatedPayload.ObolRAFSplit,
     };
 
@@ -320,16 +335,23 @@ export class Client extends Base {
     );
 
     // Check if we allow splitters on this chainId
-    if (!AVAILABLE_SPLITTER_CHAINS.includes(this.chainId)) {
+    if (!isChainSupportedForSplitters(this.chainId)) {
       throw new Error(
         `Splitter configuration is not supported on ${this.chainId} chain`,
       );
     }
 
+    const chainConfig = CHAIN_CONFIGURATION[this.chainId];
+    if (!chainConfig?.SPLITMAIN_ADDRESS) {
+      throw new Error(
+        `SPLITMAIN_ADDRESS is not configured for chain ${this.chainId}`,
+      );
+    }
+
     const checkSplitMainAddress = await isContractAvailable(
-      CHAIN_CONFIGURATION[this.chainId].SPLITMAIN_ADDRESS.address,
+      chainConfig.SPLITMAIN_ADDRESS.address,
       this.signer.provider as ProviderType,
-      CHAIN_CONFIGURATION[this.chainId].SPLITMAIN_ADDRESS.bytecode,
+      chainConfig.SPLITMAIN_ADDRESS.bytecode,
     );
 
     if (!checkSplitMainAddress) {
@@ -339,8 +361,7 @@ export class Client extends Base {
     }
 
     const retroActiveFundingRecipient = {
-      account:
-        CHAIN_CONFIGURATION[this.chainId].RETROACTIVE_FUNDING_ADDRESS.address,
+      account: chainConfig.RETROACTIVE_FUNDING_ADDRESS.address,
       percentAllocation: validatedPayload.ObolRAFSplit,
     };
 

package/src/schema.ts

@@ -2,8 +2,10 @@ import { ZeroAddress } from 'ethers';
 import {
   DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
   DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT,
+  PRINCIPAL_THRESHOLD,
 } from './constants';
 import { VALID_DEPOSIT_AMOUNTS, VALID_NON_COMPOUNDING_AMOUNTS } from './ajv';
+import { zeroAddress } from 'viem';
 
 export const operatorPayloadSchema = {
   type: 'object',
@@ -150,3 +152,81 @@ export const rewardsSplitterPayloadSchema = {
   validateRewardsSplitRecipients: true,
   required: ['splitRecipients', 'principalRecipient', 'etherAmount'],
 };
+
+export const ovmBaseSplitPayload = {
+  rewardSplitRecipients: {
+    type: 'array',
+    items: {
+      type: 'object',
+      properties: {
+        address: {
+          type: 'string',
+          pattern: '^0x[a-fA-F0-9]{40}$',
+        },
+        percentAllocation: { type: 'number' },
+      },
+      required: ['address', 'percentAllocation'],
+    },
+  },
+  OVMOwnerAddress: {
+    type: 'string',
+    pattern: '^0x[a-fA-F0-9]{40}$',
+  },
+  splitOwnerAddress: {
+    type: 'string',
+    pattern: '^0x[a-fA-F0-9]{40}$',
+    default: zeroAddress,
+  },
+  principalThreshold: {
+    type: 'number',
+    minimum: 16,
+    default: PRINCIPAL_THRESHOLD,
+  },
+  distributorFeePercent: {
+    type: 'number',
+    minimum: 0,
+    maximum: 10,
+    default: 0,
+  },
+};
+
+export const ovmRewardsSplitPayloadSchema = {
+  type: 'object',
+  properties: {
+    ...ovmBaseSplitPayload,
+    principalRecipient: {
+      type: 'string',
+      pattern: '^0x[a-fA-F0-9]{40}$',
+    },
+  },
+  validateOVMRewardsSplitRecipients: true,
+  required: ['rewardSplitRecipients', 'OVMOwnerAddress', 'principalRecipient'],
+};
+
+export const ovmTotalSplitPayloadSchema = {
+  type: 'object',
+  properties: {
+    ...ovmBaseSplitPayload,
+    principalSplitRecipients: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          address: {
+            type: 'string',
+            pattern: '^0x[a-fA-F0-9]{40}$',
+          },
+          percentAllocation: { type: 'number' },
+        },
+        required: ['address', 'percentAllocation'],
+      },
+    },
+  },
+  validateOVMRewardsSplitRecipients: true,
+  validateOVMTotalSplitRecipients: true,
+  required: [
+    'rewardSplitRecipients',
+    'principalSplitRecipients',
+    'OVMOwnerAddress',
+  ],
+};

package/src/splits/splitHelpers.ts

@@ -4,15 +4,31 @@ import {
   type ETH_ADDRESS,
   type SplitRecipient,
   type SignerType,
+  type SplitV2Recipient,
+  type OVMArgs,
+  type ChainConfig,
 } from '../types';
-import { Contract, Interface, parseEther, ZeroAddress } from 'ethers';
+import {
+  BrowserProvider,
+  Contract,
+  Interface,
+  parseEther,
+  type Wallet,
+  ZeroAddress,
+} from 'ethers';
 import { OWRContract, OWRFactoryContract } from '../abi/OWR';
+import { OVMFactoryContract } from '../abi/OVMFactory';
 import { splitMainEthereumAbi } from '../abi/SplitMain';
 import { MultiCallContract } from '../abi/Multicall';
-import { CHAIN_CONFIGURATION } from '../constants';
+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';
 
 const splitMainContractInterface = new Interface(splitMainEthereumAbi);
 const owrFactoryContractInterface = new Interface(OWRFactoryContract.abi);
+const ovmFactoryContractInterface = new Interface(OVMFactoryContract.abi);
 
 type Call = {
   target: ETH_ADDRESS;
@@ -33,14 +49,39 @@ type SplitArgs = {
   controllerAddress: ETH_ADDRESS;
 };
 
+// Helper function to extract common recipient formatting logic
+const formatRecipientsCommon = (
+  recipients: SplitRecipient[] | SplitV2Recipient[],
+): {
+  sortedRecipients: any[];
+  getAddress: (item: any) => string;
+  getPercentAllocation: (item: any) => number;
+} => {
+  const copiedRecipients = [...recipients];
+
+  // Handle both SplitRecipient and SplitV2Recipient types
+  const getAddress = (item: any): string => item.account || item.address;
+  const getPercentAllocation = (item: any): number => item.percentAllocation;
+
+  // Has to be sorted when passed
+  copiedRecipients.sort((a, b) => getAddress(a).localeCompare(getAddress(b)));
+
+  return {
+    sortedRecipients: copiedRecipients,
+    getAddress,
+    getPercentAllocation,
+  };
+};
+
 export const formatSplitRecipients = (
   recipients: SplitRecipient[],
 ): { accounts: ETH_ADDRESS[]; percentAllocations: number[] } => {
-  // Has to be sorted when passed
-  recipients.sort((a, b) => a.account.localeCompare(b.account));
-  const accounts = recipients.map(item => item.account);
-  const percentAllocations = recipients.map(recipient => {
-    const splitTostring = (recipient.percentAllocation * 1e4).toFixed(0);
+  const { sortedRecipients, getAddress, getPercentAllocation } =
+    formatRecipientsCommon(recipients);
+
+  const accounts = sortedRecipients.map(item => getAddress(item));
+  const percentAllocations = sortedRecipients.map(recipient => {
+    const splitTostring = (getPercentAllocation(recipient) * 1e4).toFixed(0);
     return parseInt(splitTostring);
   });
   return { accounts, percentAllocations };
@@ -63,7 +104,7 @@ export const predictSplitterAddress = async ({
 }): Promise<ETH_ADDRESS> => {
   try {
     const splitMainContractInstance = new Contract(
-      CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address,
+      getChainConfig(chainId).SPLITMAIN_ADDRESS.address,
       splitMainEthereumAbi,
       signer,
     );
@@ -217,7 +258,7 @@ const createOWRContract = async ({
 }): Promise<ETH_ADDRESS> => {
   try {
     const OWRFactoryInstance = new Contract(
-      CHAIN_CONFIGURATION[chainId].OWR_FACTORY_ADDRESS.address,
+      getChainConfig(chainId).OWR_FACTORY_ADDRESS.address,
       OWRFactoryContract.abi,
       signer,
     );
@@ -304,7 +345,7 @@ export const deploySplitterContract = async ({
 }): Promise<ETH_ADDRESS> => {
   try {
     const splitMainContractInstance = new Contract(
-      CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address,
+      getChainConfig(chainId).SPLITMAIN_ADDRESS.address,
       splitMainEthereumAbi,
       signer,
     );
@@ -403,16 +444,15 @@ export const deploySplitterAndOWRContracts = async ({
 
   executeCalls.push(
     {
-      target: CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address,
+      target: getChainConfig(chainId).SPLITMAIN_ADDRESS.address,
       callData: splitTxData,
     },
     {
-      target: CHAIN_CONFIGURATION[chainId].OWR_FACTORY_ADDRESS.address,
+      target: getChainConfig(chainId).OWR_FACTORY_ADDRESS.address,
       callData: owrTxData,
     },
   );
-  const multicallAddess =
-    CHAIN_CONFIGURATION[chainId].MULTICALL_ADDRESS.address;
+  const multicallAddess = getChainConfig(chainId).MULTICALL_ADDRESS.address;
 
   const executeMultiCalls = await multicall(
     executeCalls,
@@ -555,3 +595,309 @@ const encodeCreateOWRecipientTxData = (
     parseEther(amountOfPrincipalStake.toString()),
   ]);
 };
+
+// OVM and SplitV2 Helper Functions
+
+// Helper function to format recipients specifically for SplitV2 (returns SplitV2Recipient[])
+export const formatRecipientsForSplitV2 = (
+  splitRecipients: SplitRecipient[] | SplitV2Recipient[],
+): SplitV2Recipient[] => {
+  const { sortedRecipients, getAddress, getPercentAllocation } =
+    formatRecipientsCommon(splitRecipients);
+
+  return sortedRecipients
+    .filter(item => getAddress(item) !== '')
+    .map(item => ({
+      address: getAddress(item),
+      percentAllocation: parseFloat(getPercentAllocation(item).toString()),
+    }));
+};
+
+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;
+
+    const viemWalletClient = createWalletClient({
+      account,
+      chain,
+      transport: http(CHAIN_PUBLIC_RPC_URL[chainId]),
+    });
+    return new SplitsClient({
+      publicClient: client,
+      walletClient: viemWalletClient,
+      chainId,
+    });
+  }
+};
+
+export const predictSplitV2Address = async ({
+  splitOwnerAddress,
+  recipients,
+  distributorFeePercent,
+  salt,
+  signer,
+  chainId,
+}: {
+  splitOwnerAddress: string;
+  recipients: SplitV2Recipient[];
+  distributorFeePercent: number;
+  salt: `0x${string}`;
+  signer: SignerType;
+  chainId: number;
+}): Promise<string> => {
+  try {
+    const splitsClient = await createSplitsClient(signer, chainId);
+
+    const response = await splitsClient.splitV2.predictDeterministicAddress({
+      ownerAddress: splitOwnerAddress,
+      recipients,
+      distributorFeePercent,
+      salt,
+    });
+
+    return response.splitAddress;
+  } catch (error: any) {
+    throw new Error(
+      `Failed to predict SplitV2 address: ${error.message ?? 'SplitV2 SDK call failed'}`,
+    );
+  }
+};
+
+export const isSplitV2Deployed = async ({
+  splitOwnerAddress,
+  recipients,
+  distributorFeePercent,
+  salt,
+  signer,
+  chainId,
+}: {
+  splitOwnerAddress: string;
+  recipients: SplitV2Recipient[];
+  distributorFeePercent: number;
+  salt: `0x${string}`;
+  signer: SignerType;
+  chainId: number;
+}): Promise<boolean> => {
+  try {
+    const splitsClient = await createSplitsClient(signer, chainId);
+    const response = await splitsClient.splitV2.isDeployed({
+      ownerAddress: splitOwnerAddress,
+      recipients,
+      distributorFeePercent,
+      salt,
+    });
+
+    return response.deployed;
+  } catch (error: any) {
+    // If the check fails, assume it's not deployed
+    return false;
+  }
+};
+
+export const deployOVMContract = async ({
+  OVMOwnerAddress,
+  principalRecipient,
+  rewardRecipient,
+  principalThreshold,
+  signer,
+  chainId,
+}: {
+  OVMOwnerAddress: string;
+  principalRecipient: string;
+  rewardRecipient: string;
+  principalThreshold: number;
+  signer: SignerType;
+  chainId: number;
+}): Promise<string> => {
+  try {
+    const chainConfig = getChainConfig(chainId);
+    if (!chainConfig?.OVM_FACTORY_ADDRESS?.address) {
+      throw new Error(`OVM Factory not configured for chain ${chainId}`);
+    }
+
+    const ovmFactoryContract = new Contract(
+      chainConfig.OVM_FACTORY_ADDRESS.address,
+      OVMFactoryContract.abi,
+      signer,
+    );
+
+    const tx = await ovmFactoryContract.createObolValidatorManager(
+      OVMOwnerAddress,
+      principalRecipient,
+      rewardRecipient,
+      principalThreshold,
+    );
+
+    const receipt = await tx.wait();
+
+    // Extract OVM address from logs
+    const ovmAddressLog = receipt?.logs[1]?.topics[1];
+    if (!ovmAddressLog) {
+      throw new Error('Failed to extract OVM address from transaction logs');
+    }
+
+    const ovmAddress = '0x' + ovmAddressLog.slice(26, 66);
+    return ovmAddress;
+  } catch (error: any) {
+    throw new Error(
+      `Failed to deploy OVM contract: ${error.message ?? 'OVM deployment failed'}`,
+    );
+  }
+};
+
+export const deployOVMAndSplitV2 = async ({
+  ovmArgs,
+  rewardRecipients,
+  isRewardsSplitterDeployed,
+  distributorFeePercent,
+  salt,
+  signer,
+  chainId,
+  principalSplitRecipients,
+  isPrincipalSplitDeployed,
+  splitOwnerAddress,
+}: {
+  ovmArgs: OVMArgs;
+  rewardRecipients: SplitV2Recipient[];
+  isRewardsSplitterDeployed?: boolean;
+  distributorFeePercent: number;
+  salt: `0x${string}`;
+  signer: SignerType;
+  chainId: number;
+  principalSplitRecipients?: SplitV2Recipient[];
+  isPrincipalSplitDeployed?: boolean;
+  splitOwnerAddress: string;
+}): Promise<string> => {
+  try {
+    const chainConfig = getChainConfig(chainId);
+    if (!chainConfig?.OVM_FACTORY_ADDRESS?.address) {
+      throw new Error(`OVM Factory not configured for chain ${chainId}`);
+    }
+
+    const splitsClient = await createSplitsClient(signer, chainId);
+    const executeCalls: any[] = [];
+
+    if (rewardRecipients && !isRewardsSplitterDeployed) {
+      // Create rewards split call data
+      const rewardsSplitTxData =
+        await splitsClient.splitV2.callData.createSplit({
+          recipients: rewardRecipients,
+          distributorFeePercent,
+          ownerAddress: splitOwnerAddress,
+          salt,
+        });
+
+      executeCalls.push(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);
+    }
+
+    // Create OVM call data
+    const ovmTxData = encodeCreateOVMTxData(
+      ovmArgs.OVMOwnerAddress,
+      ovmArgs.principalRecipient,
+      ovmArgs.rewardRecipient,
+      ovmArgs.principalThreshold,
+    );
+
+    executeCalls.push({
+      address: chainConfig.OVM_FACTORY_ADDRESS.address,
+      data: ovmTxData,
+    });
+
+    // Execute multicall
+    const executeMultiCalls = await splitsClient.splitV2.multicall({
+      calls: executeCalls,
+    });
+
+    // Extract addresses from events
+    let ovmAddress: string | undefined;
+    const eventCount = executeMultiCalls?.events.length;
+
+    if (eventCount === 2) {
+      ovmAddress = executeMultiCalls?.events[0]?.address;
+    } else if (eventCount === 5) {
+      ovmAddress = executeMultiCalls?.events[3]?.address;
+    } else {
+      ovmAddress = executeMultiCalls?.events[6]?.address;
+    }
+    if (!ovmAddress) {
+      throw new Error(
+        'Failed to extract contract addresses from multicall events',
+      );
+    }
+
+    return ovmAddress;
+  } catch (error: any) {
+    throw new Error(
+      `Failed to deploy OVM and SplitV2: ${error.message ?? 'Deployment failed'}`,
+    );
+  }
+};
+
+const encodeCreateOVMTxData = (
+  OVMOwnerAddress: string,
+  principalRecipient: string,
+  rewardRecipient: string,
+  principalThreshold: number,
+): string => {
+  return ovmFactoryContractInterface.encodeFunctionData(
+    'createObolValidatorManager',
+    [OVMOwnerAddress, principalRecipient, rewardRecipient, principalThreshold],
+  );
+};
+
+// Helper function to safely get chain configuration
+const getChainConfig = (chainId: number): ChainConfig => {
+  const config = CHAIN_CONFIGURATION[chainId];
+  if (!config) {
+    throw new Error(`Chain configuration not found for chain ID ${chainId}`);
+  }
+  return config;
+};