@obolnetwork/obol-sdk 2.7.0 → 2.8.1

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

@@ -0,0 +1,279 @@
+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_CONTRACT)) {
+                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_CONTRACT;
+            const splitV2FactoryConfig = chainConfig.SPLIT_V2_FACTORY_CONTRACT;
+            const multiCallConfig = chainConfig.MULTICALL_CONTRACT;
+            if (!(ovmFactoryConfig === null || ovmFactoryConfig === void 0 ? void 0 : ovmFactoryConfig.address) ||
+                !(ovmFactoryConfig === null || ovmFactoryConfig === void 0 ? void 0 : ovmFactoryConfig.bytecode) ||
+                !(splitV2FactoryConfig === null || splitV2FactoryConfig === void 0 ? void 0 : splitV2FactoryConfig.address) ||
+                !(splitV2FactoryConfig === null || splitV2FactoryConfig === void 0 ? void 0 : splitV2FactoryConfig.bytecode) ||
+                !(multiCallConfig === null || multiCallConfig === void 0 ? void 0 : multiCallConfig.address) ||
+                !(multiCallConfig === null || multiCallConfig === void 0 ? void 0 : multiCallConfig.bytecode)) {
+                throw new Error(`Contracts configuration is incomplete for chain ${this.chainId}`);
+            }
+            const checkOVMFactoryContract = yield isContractAvailable(ovmFactoryConfig.address, this.provider, ovmFactoryConfig.bytecode);
+            const checkSplitV2FactoryContract = yield isContractAvailable(splitV2FactoryConfig.address, this.provider, splitV2FactoryConfig.bytecode);
+            const checkMultiCallContract = yield isContractAvailable(multiCallConfig.address, this.provider, multiCallConfig.bytecode);
+            if (!checkOVMFactoryContract ||
+                !checkSplitV2FactoryContract ||
+                !checkMultiCallContract) {
+                throw new Error(`Splitter contract is not deployed or available on chain ${this.chainId}`);
+            }
+            const retroActiveFundingRecipient = {
+                address: chainConfig.RETROACTIVE_FUNDING_CONTRACT.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_CONTRACT)) {
+                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_CONTRACT;
+            const splitV2FactoryConfig = chainConfig.SPLIT_V2_FACTORY_CONTRACT;
+            const multiCallConfig = chainConfig.MULTICALL_CONTRACT;
+            if (!(ovmFactoryConfig === null || ovmFactoryConfig === void 0 ? void 0 : ovmFactoryConfig.address) ||
+                !(ovmFactoryConfig === null || ovmFactoryConfig === void 0 ? void 0 : ovmFactoryConfig.bytecode) ||
+                !(splitV2FactoryConfig === null || splitV2FactoryConfig === void 0 ? void 0 : splitV2FactoryConfig.address) ||
+                !(splitV2FactoryConfig === null || splitV2FactoryConfig === void 0 ? void 0 : splitV2FactoryConfig.bytecode) ||
+                !(multiCallConfig === null || multiCallConfig === void 0 ? void 0 : multiCallConfig.address) ||
+                !(multiCallConfig === null || multiCallConfig === void 0 ? void 0 : multiCallConfig.bytecode)) {
+                throw new Error(`Contracts configuration is incomplete for chain ${this.chainId}`);
+            }
+            const checkOVMFactoryContract = yield isContractAvailable(ovmFactoryConfig.address, this.provider, ovmFactoryConfig.bytecode);
+            const checkSplitV2FactoryContract = yield isContractAvailable(splitV2FactoryConfig.address, this.provider, splitV2FactoryConfig.bytecode);
+            const checkMultiCallContract = yield isContractAvailable(multiCallConfig.address, this.provider, multiCallConfig.bytecode);
+            if (!checkOVMFactoryContract ||
+                !checkSplitV2FactoryContract ||
+                !checkMultiCallContract) {
+                throw new Error(`Splitter contract is not deployed or available on chain ${this.chainId}`);
+            }
+            const retroActiveFundingRecipient = {
+                address: chainConfig.RETROACTIVE_FUNDING_CONTRACT.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

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

@@ -0,0 +1,267 @@
+import { validatePayload } from '../../src/ajv';
+import { ovmRewardsSplitPayloadSchema, ovmTotalSplitPayloadSchema, } from '../../src/schema';
+import { TEST_ADDRESSES } from '../fixtures';
+describe('validatePayload - OVM Schemas', () => {
+    describe('ovmRewardsSplitPayloadSchema', () => {
+        const validRewardsSplitPayload = {
+            rewardSplitRecipients: [
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+            ],
+            OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+            splitOwnerAddress: TEST_ADDRESSES.SPLIT_OWNER,
+            principalRecipient: TEST_ADDRESSES.PRINCIPAL_RECIPIENT,
+            distributorFeePercent: 0,
+        };
+        it('should validate a valid rewards split payload', () => {
+            const result = validatePayload(validRewardsSplitPayload, ovmRewardsSplitPayloadSchema);
+            expect(result).toEqual(validRewardsSplitPayload);
+        });
+        it('should validate rewards split payload with default values', () => {
+            const payloadWithoutDefaults = {
+                rewardSplitRecipients: [
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+                ],
+                OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+                principalRecipient: TEST_ADDRESSES.PRINCIPAL_RECIPIENT,
+            };
+            const result = validatePayload(payloadWithoutDefaults, ovmRewardsSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payloadWithoutDefaults), { splitOwnerAddress: TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should throw error when rewardSplitRecipients total percentage is not 99%', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validRewardsSplitPayload), { rewardSplitRecipients: [
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 40 }, // Total: 90%
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmRewardsSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMRewardsSplitRecipients" keyword validation');
+        });
+        it('should throw error when rewardSplitRecipients total percentage exceeds 99%', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validRewardsSplitPayload), { rewardSplitRecipients: [
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 60 },
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 50 }, // Total: 110%
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmRewardsSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMRewardsSplitRecipients" keyword validation');
+        });
+        it('should throw error when rewardSplitRecipients is empty', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validRewardsSplitPayload), { rewardSplitRecipients: [] });
+            expect(() => validatePayload(invalidPayload, ovmRewardsSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMRewardsSplitRecipients" keyword validation');
+        });
+        it('should throw error when rewardSplitRecipients has invalid address format', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validRewardsSplitPayload), { rewardSplitRecipients: [
+                    { address: 'invalid-address', percentAllocation: 50 },
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmRewardsSplitPayloadSchema)).toThrow('Validation failed: /rewardSplitRecipients/0/address must match pattern');
+        });
+        it('should throw error when OVMOwnerAddress is missing', () => {
+            const invalidPayload = {
+                rewardSplitRecipients: validRewardsSplitPayload.rewardSplitRecipients,
+                principalRecipient: validRewardsSplitPayload.principalRecipient,
+            };
+            expect(() => validatePayload(invalidPayload, ovmRewardsSplitPayloadSchema)).toThrow("Validation failed:  must have required property 'OVMOwnerAddress'");
+        });
+        it('should throw error when principalRecipient is missing', () => {
+            const invalidPayload = {
+                rewardSplitRecipients: validRewardsSplitPayload.rewardSplitRecipients,
+                OVMOwnerAddress: validRewardsSplitPayload.OVMOwnerAddress,
+            };
+            expect(() => validatePayload(invalidPayload, ovmRewardsSplitPayloadSchema)).toThrow("Validation failed:  must have required property 'principalRecipient'");
+        });
+    });
+    describe('ovmTotalSplitPayloadSchema', () => {
+        const validTotalSplitPayload = {
+            rewardSplitRecipients: [
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+            ],
+            principalSplitRecipients: [
+                {
+                    address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                    percentAllocation: 60,
+                },
+                {
+                    address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                    percentAllocation: 40,
+                },
+            ],
+            OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+            splitOwnerAddress: TEST_ADDRESSES.SPLIT_OWNER,
+            distributorFeePercent: 0,
+        };
+        it('should validate a valid total split payload', () => {
+            const result = validatePayload(validTotalSplitPayload, ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(validTotalSplitPayload);
+        });
+        it('should validate total split payload with default values', () => {
+            const payloadWithoutDefaults = {
+                rewardSplitRecipients: [
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+                ],
+                principalSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 60,
+                    },
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 40,
+                    },
+                ],
+                OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+            };
+            const result = validatePayload(payloadWithoutDefaults, ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payloadWithoutDefaults), { splitOwnerAddress: TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should throw error when rewardSplitRecipients total percentage is not 99%', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { rewardSplitRecipients: [
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 40 }, // Total: 90%
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMRewardsSplitRecipients" keyword validation');
+        });
+        it('should throw error when principalSplitRecipients total percentage is not 100%', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 60,
+                    },
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 30,
+                    }, // Total: 90%
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMTotalSplitRecipients" keyword validation');
+        });
+        it('should throw error when principalSplitRecipients total percentage exceeds 100%', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 70,
+                    },
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 40,
+                    }, // Total: 110%
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMTotalSplitRecipients" keyword validation');
+        });
+        it('should throw error when principalSplitRecipients is empty', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalSplitRecipients: [] });
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow('Validation failed:  must pass "validateOVMTotalSplitRecipients" keyword validation');
+        });
+        it('should throw error when principalSplitRecipients has invalid address format', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalSplitRecipients: [
+                    { address: 'invalid-address', percentAllocation: 60 },
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 40,
+                    },
+                ] });
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow('Validation failed: /principalSplitRecipients/0/address must match pattern');
+        });
+        it('should throw error when OVMOwnerAddress is missing', () => {
+            const invalidPayload = {
+                rewardSplitRecipients: validTotalSplitPayload.rewardSplitRecipients,
+                principalSplitRecipients: validTotalSplitPayload.principalSplitRecipients,
+            };
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow("Validation failed:  must have required property 'OVMOwnerAddress'");
+        });
+        it('should throw error when principalThreshold is less than 16', () => {
+            const invalidPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalThreshold: 15 });
+            expect(() => validatePayload(invalidPayload, ovmTotalSplitPayloadSchema)).toThrow('Validation failed: /principalThreshold must be >= 16');
+        });
+        it('should validate when principalThreshold is exactly 16', () => {
+            const validPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalThreshold: 16 });
+            const result = validatePayload(validPayload, ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(validPayload);
+        });
+        it('should validate when principalThreshold is greater than 16', () => {
+            const validPayload = Object.assign(Object.assign({}, validTotalSplitPayload), { principalThreshold: 20 });
+            const result = validatePayload(validPayload, ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(validPayload);
+        });
+    });
+    describe('Edge cases and boundary conditions', () => {
+        it('should handle decimal percentages correctly for rewards split', () => {
+            const payload = {
+                rewardSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.REWARD_RECIPIENT_1,
+                        percentAllocation: 49.5,
+                    },
+                    {
+                        address: TEST_ADDRESSES.REWARD_RECIPIENT_2,
+                        percentAllocation: 49.5,
+                    },
+                ],
+                OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+                principalRecipient: TEST_ADDRESSES.PRINCIPAL_RECIPIENT,
+            };
+            const result = validatePayload(payload, ovmRewardsSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payload), { splitOwnerAddress: TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should handle decimal percentages correctly for total split', () => {
+            const payload = {
+                rewardSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.REWARD_RECIPIENT_1,
+                        percentAllocation: 49.5,
+                    },
+                    {
+                        address: TEST_ADDRESSES.REWARD_RECIPIENT_2,
+                        percentAllocation: 49.5,
+                    },
+                ],
+                principalSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 60.5,
+                    },
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 39.5,
+                    },
+                ],
+                OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+            };
+            const result = validatePayload(payload, ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payload), { splitOwnerAddress: TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should handle single recipient with 99% allocation for rewards split', () => {
+            const payload = {
+                rewardSplitRecipients: [
+                    { address: TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 99 },
+                ],
+                OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+                principalRecipient: TEST_ADDRESSES.PRINCIPAL_RECIPIENT,
+            };
+            const result = validatePayload(payload, ovmRewardsSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payload), { splitOwnerAddress: TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should handle single recipient with 100% allocation for total split', () => {
+            const payload = {
+                rewardSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.REWARD_RECIPIENT_1,
+                        percentAllocation: 49.5,
+                    },
+                    {
+                        address: TEST_ADDRESSES.REWARD_RECIPIENT_2,
+                        percentAllocation: 49.5,
+                    },
+                ],
+                principalSplitRecipients: [
+                    {
+                        address: TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 100,
+                    },
+                ],
+                OVMOwnerAddress: TEST_ADDRESSES.OVM_OWNER,
+            };
+            const result = validatePayload(payload, ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payload), { splitOwnerAddress: TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+    });
+});