@obolnetwork/obol-sdk 2.7.0 → 2.8.0

package/dist/esm/src/schema.js

@@ -1,6 +1,7 @@
 import { ZeroAddress } from 'ethers';
-import { DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT, DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT, } from './constants';
+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',
     properties: {
@@ -137,3 +138,72 @@ 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: Object.assign(Object.assign({}, ovmBaseSplitPayload), { principalRecipient: {
+            type: 'string',
+            pattern: '^0x[a-fA-F0-9]{40}$',
+        } }),
+    validateOVMRewardsSplitRecipients: true,
+    required: ['rewardSplitRecipients', 'OVMOwnerAddress', 'principalRecipient'],
+};
+export const ovmTotalSplitPayloadSchema = {
+    type: 'object',
+    properties: Object.assign(Object.assign({}, 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/dist/esm/src/splits/splitHelpers.js

@@ -7,19 +7,38 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Contract, Interface, parseEther, ZeroAddress } from 'ethers';
+import { BrowserProvider, Contract, Interface, parseEther, 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);
-export const formatSplitRecipients = (recipients) => {
+const ovmFactoryContractInterface = new Interface(OVMFactoryContract.abi);
+// Helper function to extract common recipient formatting logic
+const formatRecipientsCommon = (recipients) => {
+    const copiedRecipients = [...recipients];
+    // Handle both SplitRecipient and SplitV2Recipient types
+    const getAddress = (item) => item.account || item.address;
+    const getPercentAllocation = (item) => item.percentAllocation;
     // 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);
+    copiedRecipients.sort((a, b) => getAddress(a).localeCompare(getAddress(b)));
+    return {
+        sortedRecipients: copiedRecipients,
+        getAddress,
+        getPercentAllocation,
+    };
+};
+export const formatSplitRecipients = (recipients) => {
+    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 };
@@ -27,7 +46,7 @@ export const formatSplitRecipients = (recipients) => {
 export const predictSplitterAddress = ({ signer, accounts, percentAllocations, chainId, distributorFee, controllerAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c;
     try {
-        const splitMainContractInstance = new Contract(CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address, splitMainEthereumAbi, signer);
+        const splitMainContractInstance = new Contract(getChainConfig(chainId).SPLITMAIN_ADDRESS.address, splitMainEthereumAbi, signer);
         let predictedSplitterAddress;
         if (controllerAddress === ZeroAddress) {
             try {
@@ -128,7 +147,7 @@ export const handleDeployOWRAndSplitter = ({ signer, isSplitterDeployed, predict
 const createOWRContract = ({ owrArgs, signer, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
     var _g, _h, _j, _k, _l;
     try {
-        const OWRFactoryInstance = new Contract(CHAIN_CONFIGURATION[chainId].OWR_FACTORY_ADDRESS.address, OWRFactoryContract.abi, signer);
+        const OWRFactoryInstance = new Contract(getChainConfig(chainId).OWR_FACTORY_ADDRESS.address, OWRFactoryContract.abi, signer);
         let tx;
         try {
             tx = yield OWRFactoryInstance.createOWRecipient(owrArgs.recoveryAddress, owrArgs.principalRecipient, owrArgs.predictedSplitterAddress, parseEther(owrArgs.amountOfPrincipalStake.toString()));
@@ -172,7 +191,7 @@ const createOWRContract = ({ owrArgs, signer, chainId, }) => __awaiter(void 0, v
 export const deploySplitterContract = ({ signer, accounts, percentAllocations, chainId, distributorFee, controllerAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
     var _m, _o, _p, _q, _r;
     try {
-        const splitMainContractInstance = new Contract(CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address, splitMainEthereumAbi, signer);
+        const splitMainContractInstance = new Contract(getChainConfig(chainId).SPLITMAIN_ADDRESS.address, splitMainEthereumAbi, signer);
         let tx;
         try {
             tx = yield splitMainContractInstance.createSplit(accounts, percentAllocations, distributorFee, controllerAddress);
@@ -219,13 +238,13 @@ export const deploySplitterAndOWRContracts = ({ owrArgs, splitterArgs, signer, c
     const splitTxData = encodeCreateSplitTxData(splitterArgs.accounts, splitterArgs.percentAllocations, splitterArgs.distributorFee, splitterArgs.controllerAddress);
     const owrTxData = encodeCreateOWRecipientTxData(owrArgs.recoveryAddress, owrArgs.principalRecipient, owrArgs.predictedSplitterAddress, owrArgs.amountOfPrincipalStake);
     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 = yield multicall(executeCalls, signer, multicallAddess);
     const splitAddressData = (_s = executeMultiCalls === null || executeMultiCalls === void 0 ? void 0 : executeMultiCalls.logs[0]) === null || _s === void 0 ? void 0 : _s.topics[1];
     const formattedSplitterAddress = '0x' + (splitAddressData === null || splitAddressData === void 0 ? void 0 : splitAddressData.slice(26, 66));
@@ -315,3 +334,184 @@ const encodeCreateOWRecipientTxData = (recoveryAddress, principalRecipient, rewa
         parseEther(amountOfPrincipalStake.toString()),
     ]);
 };
+// OVM and SplitV2 Helper Functions
+// Helper function to format recipients specifically for SplitV2 (returns SplitV2Recipient[])
+export const formatRecipientsForSplitV2 = (splitRecipients) => {
+    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 = (signer, chainId) => __awaiter(void 0, void 0, void 0, function* () {
+    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 = yield signer.getAddress();
+        const viemWalletClient = createWalletClient({
+            account: address,
+            chain,
+            transport: custom(window.ethereum),
+        });
+        return new SplitsClient({
+            publicClient: client,
+            walletClient: viemWalletClient,
+            chainId,
+        });
+    }
+    else {
+        // For non-browser environment, extract private key from signer
+        const signerPrivateKey = signer === null || signer === void 0 ? void 0 : signer.privateKey;
+        if (!signerPrivateKey) {
+            throw new Error('Signer private key not available');
+        }
+        const privateKey = signerPrivateKey.startsWith('0x')
+            ? signerPrivateKey
+            : `0x${signerPrivateKey}`;
+        const scriptAccount = privateKeyToAccount(privateKey);
+        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 = ({ splitOwnerAddress, recipients, distributorFeePercent, salt, signer, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _z;
+    try {
+        const splitsClient = yield createSplitsClient(signer, chainId);
+        const response = yield splitsClient.splitV2.predictDeterministicAddress({
+            ownerAddress: splitOwnerAddress,
+            recipients,
+            distributorFeePercent,
+            salt,
+        });
+        return response.splitAddress;
+    }
+    catch (error) {
+        throw new Error(`Failed to predict SplitV2 address: ${(_z = error.message) !== null && _z !== void 0 ? _z : 'SplitV2 SDK call failed'}`);
+    }
+});
+export const isSplitV2Deployed = ({ splitOwnerAddress, recipients, distributorFeePercent, salt, signer, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const splitsClient = yield createSplitsClient(signer, chainId);
+        const response = yield splitsClient.splitV2.isDeployed({
+            ownerAddress: splitOwnerAddress,
+            recipients,
+            distributorFeePercent,
+            salt,
+        });
+        return response.deployed;
+    }
+    catch (error) {
+        // If the check fails, assume it's not deployed
+        return false;
+    }
+});
+export const deployOVMContract = ({ OVMOwnerAddress, principalRecipient, rewardRecipient, principalThreshold, signer, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _0, _1, _2;
+    try {
+        const chainConfig = getChainConfig(chainId);
+        if (!((_0 = chainConfig === null || chainConfig === void 0 ? void 0 : chainConfig.OVM_FACTORY_ADDRESS) === null || _0 === void 0 ? void 0 : _0.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 = yield ovmFactoryContract.createObolValidatorManager(OVMOwnerAddress, principalRecipient, rewardRecipient, principalThreshold);
+        const receipt = yield tx.wait();
+        // Extract OVM address from logs
+        const ovmAddressLog = (_1 = receipt === null || receipt === void 0 ? void 0 : receipt.logs[1]) === null || _1 === void 0 ? void 0 : _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) {
+        throw new Error(`Failed to deploy OVM contract: ${(_2 = error.message) !== null && _2 !== void 0 ? _2 : 'OVM deployment failed'}`);
+    }
+});
+export const deployOVMAndSplitV2 = ({ ovmArgs, rewardRecipients, isRewardsSplitterDeployed, distributorFeePercent, salt, signer, chainId, principalSplitRecipients, isPrincipalSplitDeployed, splitOwnerAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _3, _4, _5, _6, _7;
+    try {
+        const chainConfig = getChainConfig(chainId);
+        if (!((_3 = chainConfig === null || chainConfig === void 0 ? void 0 : chainConfig.OVM_FACTORY_ADDRESS) === null || _3 === void 0 ? void 0 : _3.address)) {
+            throw new Error(`OVM Factory not configured for chain ${chainId}`);
+        }
+        const splitsClient = yield createSplitsClient(signer, chainId);
+        const executeCalls = [];
+        if (rewardRecipients && !isRewardsSplitterDeployed) {
+            // Create rewards split call data
+            const rewardsSplitTxData = yield 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 = yield 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 = yield splitsClient.splitV2.multicall({
+            calls: executeCalls,
+        });
+        // Extract addresses from events
+        let ovmAddress;
+        const eventCount = executeMultiCalls === null || executeMultiCalls === void 0 ? void 0 : executeMultiCalls.events.length;
+        if (eventCount === 2) {
+            ovmAddress = (_4 = executeMultiCalls === null || executeMultiCalls === void 0 ? void 0 : executeMultiCalls.events[0]) === null || _4 === void 0 ? void 0 : _4.address;
+        }
+        else if (eventCount === 5) {
+            ovmAddress = (_5 = executeMultiCalls === null || executeMultiCalls === void 0 ? void 0 : executeMultiCalls.events[3]) === null || _5 === void 0 ? void 0 : _5.address;
+        }
+        else {
+            ovmAddress = (_6 = executeMultiCalls === null || executeMultiCalls === void 0 ? void 0 : executeMultiCalls.events[6]) === null || _6 === void 0 ? void 0 : _6.address;
+        }
+        if (!ovmAddress) {
+            throw new Error('Failed to extract contract addresses from multicall events');
+        }
+        return ovmAddress;
+    }
+    catch (error) {
+        throw new Error(`Failed to deploy OVM and SplitV2: ${(_7 = error.message) !== null && _7 !== void 0 ? _7 : 'Deployment failed'}`);
+    }
+});
+const encodeCreateOVMTxData = (OVMOwnerAddress, principalRecipient, rewardRecipient, principalThreshold) => {
+    return ovmFactoryContractInterface.encodeFunctionData('createObolValidatorManager', [OVMOwnerAddress, principalRecipient, rewardRecipient, principalThreshold]);
+};
+// Helper function to safely get chain configuration
+const getChainConfig = (chainId) => {
+    const config = CHAIN_CONFIGURATION[chainId];
+    if (!config) {
+        throw new Error(`Chain configuration not found for chain ID ${chainId}`);
+    }
+    return config;
+};

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

@@ -0,0 +1,257 @@
+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 { formatRecipientsForSplitV2, predictSplitV2Address, isSplitV2Deployed, deployOVMContract, deployOVMAndSplitV2, } from './splitHelpers';
+import { CHAIN_CONFIGURATION, SPLITS_V2_SALT, DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT, isChainSupportedForSplitters, } from '../constants';
+import { ovmRewardsSplitPayloadSchema, ovmTotalSplitPayloadSchema, } from '../schema';
+import { validatePayload } from '../ajv';
+import { isContractAvailable } from '../utils';
+/**
+ * ObolSplits can be used for creating and managing Obol splits.
+ * @class
+ * @internal Access it through Client.splits.
+ * @example
+ * const obolClient = new Client(config);
+ * await obolClient.splits.createValidatorManagerAndRewardsSplit(OVMRewardsSplitPayload);
+ */
+export class ObolSplits {
+    constructor(signer, chainId, provider) {
+        this.signer = signer;
+        this.chainId = chainId;
+        this.provider = provider;
+    }
+    /**
+     * Creates an Obol OVM and Pull split configuration for rewards-only scenario.
+     *
+     * This method deploys OVM and SplitV2 contracts for managing validator rewards only.
+     * Principal is handled by a single address, while rewards are split among recipients.
+     *
+     * @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 {OVMRewardsSplitPayload} payload - Data needed to deploy OVM and SplitV2
+     * @returns {Promise<ClusterValidator>} OVM address as withdrawal address and splitter as fee recipient
+     * @throws Will throw an error if the splitter configuration is not supported or deployment fails
+     *
+     * An example of how to use createValidatorManagerAndRewardsSplit:
+     * [createValidatorManagerAndRewardsSplit](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#L333)
+     */
+    createValidatorManagerAndRewardsSplit(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const salt = SPLITS_V2_SALT;
+            if (!this.signer) {
+                throw new Error('Signer is required in createValidatorManagerAndRewardsSplit');
+            }
+            const validatedPayload = validatePayload(payload, ovmRewardsSplitPayloadSchema);
+            if (!isChainSupportedForSplitters(this.chainId)) {
+                throw new Error(`Splitter configuration is not supported on ${this.chainId} chain`);
+            }
+            const chainConfig = CHAIN_CONFIGURATION[this.chainId];
+            if (!(chainConfig === null || chainConfig === void 0 ? void 0 : chainConfig.OVM_FACTORY_ADDRESS)) {
+                throw new Error(`OVM contract factory is not configured for chain ${this.chainId}`);
+            }
+            if (!this.provider) {
+                throw new Error('Provider is required to check OVM factory contract availability');
+            }
+            const ovmFactoryConfig = chainConfig.OVM_FACTORY_ADDRESS;
+            if (!(ovmFactoryConfig === null || ovmFactoryConfig === void 0 ? void 0 : ovmFactoryConfig.address) || !(ovmFactoryConfig === null || ovmFactoryConfig === void 0 ? void 0 : ovmFactoryConfig.bytecode)) {
+                throw new Error(`OVM factory contract configuration is incomplete for chain ${this.chainId}`);
+            }
+            const checkOVMFactoryAddress = yield isContractAvailable(ovmFactoryConfig.address, this.provider, ovmFactoryConfig.bytecode);
+            if (!checkOVMFactoryAddress) {
+                throw new Error(`OVM factory contract is not deployed or available on chain ${this.chainId}`);
+            }
+            const retroActiveFundingRecipient = {
+                address: chainConfig.RETROACTIVE_FUNDING_ADDRESS.address,
+                percentAllocation: DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
+            };
+            const copiedRewardsSplitRecipients = [
+                ...validatedPayload.rewardSplitRecipients,
+            ];
+            copiedRewardsSplitRecipients.push(retroActiveFundingRecipient);
+            // Format recipients for SplitV2
+            const rewardRecipients = formatRecipientsForSplitV2(copiedRewardsSplitRecipients);
+            const predictedSplitAddress = yield predictSplitV2Address({
+                splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                recipients: rewardRecipients,
+                distributorFeePercent: validatedPayload.distributorFeePercent,
+                salt,
+                signer: this.signer,
+                chainId: this.chainId,
+            });
+            const isRewardSplitterDeployed = yield isSplitV2Deployed({
+                splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                recipients: rewardRecipients,
+                distributorFeePercent: validatedPayload.distributorFeePercent,
+                salt,
+                signer: this.signer,
+                chainId: this.chainId,
+            });
+            if (isRewardSplitterDeployed) {
+                const ovmAddress = yield deployOVMContract({
+                    OVMOwnerAddress: validatedPayload.OVMOwnerAddress,
+                    principalRecipient: validatedPayload.principalRecipient,
+                    rewardRecipient: predictedSplitAddress,
+                    principalThreshold: validatedPayload.principalThreshold,
+                    signer: this.signer,
+                    chainId: this.chainId,
+                });
+                return {
+                    withdrawal_address: ovmAddress,
+                    fee_recipient_address: predictedSplitAddress,
+                };
+            }
+            else {
+                const ovmAddress = yield deployOVMAndSplitV2({
+                    ovmArgs: {
+                        OVMOwnerAddress: validatedPayload.OVMOwnerAddress,
+                        rewardRecipient: predictedSplitAddress,
+                        principalRecipient: validatedPayload.principalRecipient,
+                        principalThreshold: validatedPayload.principalThreshold,
+                    },
+                    rewardRecipients,
+                    isRewardsSplitterDeployed: isRewardSplitterDeployed,
+                    distributorFeePercent: validatedPayload.distributorFeePercent,
+                    salt,
+                    signer: this.signer,
+                    chainId: this.chainId,
+                    splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                });
+                return {
+                    withdrawal_address: ovmAddress,
+                    fee_recipient_address: predictedSplitAddress,
+                };
+            }
+        });
+    }
+    /**
+     * Creates an Obol OVM and Total split configuration for total split scenario.
+     *
+     * This method deploys OVM and SplitV2 contracts for managing both validator rewards and principal.
+     * Both rewards and principal are split among recipients, with rewards including RAF recipient.
+     *
+     * @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 {OVMTotalSplitPayload} payload - Data needed to deploy OVM and SplitV2
+     * @returns {Promise<ClusterValidator>} OVM address as withdrawal address and splitter as fee recipient
+     * @throws Will throw an error if the splitter configuration is not supported or deployment fails
+     *
+     * An example of how to use createValidatorManagerAndTotalSplit:
+     * [createValidatorManagerAndTotalSplit](https://github.com/ObolNetwork/obol-sdk-examples/blob/main/TS-Example/index.ts#340)
+     */
+    createValidatorManagerAndTotalSplit(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const salt = SPLITS_V2_SALT;
+            if (!this.signer) {
+                throw new Error('Signer is required in createValidatorManagerAndTotalSplit');
+            }
+            const validatedPayload = validatePayload(payload, ovmTotalSplitPayloadSchema);
+            if (!isChainSupportedForSplitters(this.chainId)) {
+                throw new Error(`Splitter configuration is not supported on ${this.chainId} chain`);
+            }
+            const chainConfig = CHAIN_CONFIGURATION[this.chainId];
+            if (!(chainConfig === null || chainConfig === void 0 ? void 0 : chainConfig.OVM_FACTORY_ADDRESS)) {
+                throw new Error(`OVM contract factory is not configured for chain ${this.chainId}`);
+            }
+            if (!this.provider) {
+                throw new Error('Provider is required to check OVM factory contract availability');
+            }
+            const ovmFactoryConfig = chainConfig.OVM_FACTORY_ADDRESS;
+            if (!(ovmFactoryConfig === null || ovmFactoryConfig === void 0 ? void 0 : ovmFactoryConfig.address) || !(ovmFactoryConfig === null || ovmFactoryConfig === void 0 ? void 0 : ovmFactoryConfig.bytecode)) {
+                throw new Error(`OVM factory contract configuration is incomplete for chain ${this.chainId}`);
+            }
+            const checkOVMFactoryAddress = yield isContractAvailable(ovmFactoryConfig.address, this.provider, ovmFactoryConfig.bytecode);
+            if (!checkOVMFactoryAddress) {
+                throw new Error(`OVM factory contract is not deployed or available on chain ${this.chainId}`);
+            }
+            const retroActiveFundingRecipient = {
+                address: chainConfig.RETROACTIVE_FUNDING_ADDRESS.address,
+                percentAllocation: DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
+            };
+            const copiedRewardsSplitRecipients = [
+                ...validatedPayload.rewardSplitRecipients,
+            ];
+            copiedRewardsSplitRecipients.push(retroActiveFundingRecipient);
+            const rewardsRecipients = formatRecipientsForSplitV2(copiedRewardsSplitRecipients);
+            const principalSplitRecipients = formatRecipientsForSplitV2(validatedPayload.principalSplitRecipients);
+            const predictedRewardsSplitAddress = yield predictSplitV2Address({
+                splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                recipients: rewardsRecipients,
+                distributorFeePercent: validatedPayload.distributorFeePercent,
+                salt,
+                signer: this.signer,
+                chainId: this.chainId,
+            });
+            const predictedPrincipalSplitAddress = yield predictSplitV2Address({
+                splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                recipients: principalSplitRecipients,
+                distributorFeePercent: validatedPayload.distributorFeePercent,
+                salt,
+                signer: this.signer,
+                chainId: this.chainId,
+            });
+            const isRewardsSplitterDeployed = yield isSplitV2Deployed({
+                splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                recipients: rewardsRecipients,
+                distributorFeePercent: validatedPayload.distributorFeePercent,
+                salt,
+                signer: this.signer,
+                chainId: this.chainId,
+            });
+            const isPrincipalSplitterDeployed = yield isSplitV2Deployed({
+                splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                recipients: principalSplitRecipients,
+                distributorFeePercent: validatedPayload.distributorFeePercent,
+                salt,
+                signer: this.signer,
+                chainId: this.chainId,
+            });
+            if (isRewardsSplitterDeployed && isPrincipalSplitterDeployed) {
+                const ovmAddress = yield deployOVMContract({
+                    OVMOwnerAddress: validatedPayload.OVMOwnerAddress,
+                    principalRecipient: predictedPrincipalSplitAddress,
+                    rewardRecipient: predictedRewardsSplitAddress,
+                    principalThreshold: validatedPayload.principalThreshold,
+                    signer: this.signer,
+                    chainId: this.chainId,
+                });
+                return {
+                    withdrawal_address: ovmAddress,
+                    fee_recipient_address: predictedRewardsSplitAddress,
+                };
+            }
+            else {
+                // Use multicall to deploy any contracts that aren't deployed
+                const ovmAddress = yield deployOVMAndSplitV2({
+                    ovmArgs: {
+                        OVMOwnerAddress: validatedPayload.OVMOwnerAddress,
+                        rewardRecipient: predictedRewardsSplitAddress,
+                        principalRecipient: predictedPrincipalSplitAddress,
+                        principalThreshold: validatedPayload.principalThreshold,
+                    },
+                    rewardRecipients: rewardsRecipients,
+                    distributorFeePercent: validatedPayload.distributorFeePercent,
+                    salt,
+                    signer: this.signer,
+                    chainId: this.chainId,
+                    principalSplitRecipients,
+                    isPrincipalSplitDeployed: isPrincipalSplitterDeployed,
+                    splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                });
+                return {
+                    withdrawal_address: ovmAddress,
+                    fee_recipient_address: predictedRewardsSplitAddress,
+                };
+            }
+        });
+    }
+}

package/dist/esm/src/types.js

@@ -24,4 +24,3 @@ export const FORK_NAMES = {
     [FORK_MAPPING['0x90000069']]: 'sepolia',
     [FORK_MAPPING['0x10000910']]: 'hoodi',
 };
-// Add other SDK-specific types below or import from other type files