@obolnetwork/obol-sdk 2.7.0 → 2.8.0

package/dist/cjs/src/splits/splits.js

@@ -0,0 +1,261 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObolSplits = void 0;
+const splitHelpers_1 = require("./splitHelpers");
+const constants_1 = require("../constants");
+const schema_1 = require("../schema");
+const ajv_1 = require("../ajv");
+const utils_1 = require("../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);
+ */
+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 = constants_1.SPLITS_V2_SALT;
+            if (!this.signer) {
+                throw new Error('Signer is required in createValidatorManagerAndRewardsSplit');
+            }
+            const validatedPayload = (0, ajv_1.validatePayload)(payload, schema_1.ovmRewardsSplitPayloadSchema);
+            if (!(0, constants_1.isChainSupportedForSplitters)(this.chainId)) {
+                throw new Error(`Splitter configuration is not supported on ${this.chainId} chain`);
+            }
+            const chainConfig = constants_1.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 (0, utils_1.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: constants_1.DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
+            };
+            const copiedRewardsSplitRecipients = [
+                ...validatedPayload.rewardSplitRecipients,
+            ];
+            copiedRewardsSplitRecipients.push(retroActiveFundingRecipient);
+            // Format recipients for SplitV2
+            const rewardRecipients = (0, splitHelpers_1.formatRecipientsForSplitV2)(copiedRewardsSplitRecipients);
+            const predictedSplitAddress = yield (0, splitHelpers_1.predictSplitV2Address)({
+                splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                recipients: rewardRecipients,
+                distributorFeePercent: validatedPayload.distributorFeePercent,
+                salt,
+                signer: this.signer,
+                chainId: this.chainId,
+            });
+            const isRewardSplitterDeployed = yield (0, splitHelpers_1.isSplitV2Deployed)({
+                splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                recipients: rewardRecipients,
+                distributorFeePercent: validatedPayload.distributorFeePercent,
+                salt,
+                signer: this.signer,
+                chainId: this.chainId,
+            });
+            if (isRewardSplitterDeployed) {
+                const ovmAddress = yield (0, splitHelpers_1.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 (0, splitHelpers_1.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 = constants_1.SPLITS_V2_SALT;
+            if (!this.signer) {
+                throw new Error('Signer is required in createValidatorManagerAndTotalSplit');
+            }
+            const validatedPayload = (0, ajv_1.validatePayload)(payload, schema_1.ovmTotalSplitPayloadSchema);
+            if (!(0, constants_1.isChainSupportedForSplitters)(this.chainId)) {
+                throw new Error(`Splitter configuration is not supported on ${this.chainId} chain`);
+            }
+            const chainConfig = constants_1.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 (0, utils_1.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: constants_1.DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
+            };
+            const copiedRewardsSplitRecipients = [
+                ...validatedPayload.rewardSplitRecipients,
+            ];
+            copiedRewardsSplitRecipients.push(retroActiveFundingRecipient);
+            const rewardsRecipients = (0, splitHelpers_1.formatRecipientsForSplitV2)(copiedRewardsSplitRecipients);
+            const principalSplitRecipients = (0, splitHelpers_1.formatRecipientsForSplitV2)(validatedPayload.principalSplitRecipients);
+            const predictedRewardsSplitAddress = yield (0, splitHelpers_1.predictSplitV2Address)({
+                splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                recipients: rewardsRecipients,
+                distributorFeePercent: validatedPayload.distributorFeePercent,
+                salt,
+                signer: this.signer,
+                chainId: this.chainId,
+            });
+            const predictedPrincipalSplitAddress = yield (0, splitHelpers_1.predictSplitV2Address)({
+                splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                recipients: principalSplitRecipients,
+                distributorFeePercent: validatedPayload.distributorFeePercent,
+                salt,
+                signer: this.signer,
+                chainId: this.chainId,
+            });
+            const isRewardsSplitterDeployed = yield (0, splitHelpers_1.isSplitV2Deployed)({
+                splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                recipients: rewardsRecipients,
+                distributorFeePercent: validatedPayload.distributorFeePercent,
+                salt,
+                signer: this.signer,
+                chainId: this.chainId,
+            });
+            const isPrincipalSplitterDeployed = yield (0, splitHelpers_1.isSplitV2Deployed)({
+                splitOwnerAddress: validatedPayload.splitOwnerAddress,
+                recipients: principalSplitRecipients,
+                distributorFeePercent: validatedPayload.distributorFeePercent,
+                salt,
+                signer: this.signer,
+                chainId: this.chainId,
+            });
+            if (isRewardsSplitterDeployed && isPrincipalSplitterDeployed) {
+                const ovmAddress = yield (0, splitHelpers_1.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 (0, splitHelpers_1.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,
+                };
+            }
+        });
+    }
+}
+exports.ObolSplits = ObolSplits;

package/dist/cjs/src/types.js

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

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

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ajv_1 = require("../../src/ajv");
+const schema_1 = require("../../src/schema");
+const fixtures_1 = require("../fixtures");
+describe('validatePayload - OVM Schemas', () => {
+    describe('ovmRewardsSplitPayloadSchema', () => {
+        const validRewardsSplitPayload = {
+            rewardSplitRecipients: [
+                { address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                { address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+            ],
+            OVMOwnerAddress: fixtures_1.TEST_ADDRESSES.OVM_OWNER,
+            splitOwnerAddress: fixtures_1.TEST_ADDRESSES.SPLIT_OWNER,
+            principalRecipient: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT,
+            distributorFeePercent: 0,
+        };
+        it('should validate a valid rewards split payload', () => {
+            const result = (0, ajv_1.validatePayload)(validRewardsSplitPayload, schema_1.ovmRewardsSplitPayloadSchema);
+            expect(result).toEqual(validRewardsSplitPayload);
+        });
+        it('should validate rewards split payload with default values', () => {
+            const payloadWithoutDefaults = {
+                rewardSplitRecipients: [
+                    { address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                    { address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+                ],
+                OVMOwnerAddress: fixtures_1.TEST_ADDRESSES.OVM_OWNER,
+                principalRecipient: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT,
+            };
+            const result = (0, ajv_1.validatePayload)(payloadWithoutDefaults, schema_1.ovmRewardsSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payloadWithoutDefaults), { splitOwnerAddress: fixtures_1.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: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                    { address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 40 }, // Total: 90%
+                ] });
+            expect(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.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: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 60 },
+                    { address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 50 }, // Total: 110%
+                ] });
+            expect(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.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(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.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: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+                ] });
+            expect(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.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(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.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(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.ovmRewardsSplitPayloadSchema)).toThrow("Validation failed:  must have required property 'principalRecipient'");
+        });
+    });
+    describe('ovmTotalSplitPayloadSchema', () => {
+        const validTotalSplitPayload = {
+            rewardSplitRecipients: [
+                { address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                { address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+            ],
+            principalSplitRecipients: [
+                {
+                    address: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                    percentAllocation: 60,
+                },
+                {
+                    address: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                    percentAllocation: 40,
+                },
+            ],
+            OVMOwnerAddress: fixtures_1.TEST_ADDRESSES.OVM_OWNER,
+            splitOwnerAddress: fixtures_1.TEST_ADDRESSES.SPLIT_OWNER,
+            distributorFeePercent: 0,
+        };
+        it('should validate a valid total split payload', () => {
+            const result = (0, ajv_1.validatePayload)(validTotalSplitPayload, schema_1.ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(validTotalSplitPayload);
+        });
+        it('should validate total split payload with default values', () => {
+            const payloadWithoutDefaults = {
+                rewardSplitRecipients: [
+                    { address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                    { address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 49 },
+                ],
+                principalSplitRecipients: [
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 60,
+                    },
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 40,
+                    },
+                ],
+                OVMOwnerAddress: fixtures_1.TEST_ADDRESSES.OVM_OWNER,
+            };
+            const result = (0, ajv_1.validatePayload)(payloadWithoutDefaults, schema_1.ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payloadWithoutDefaults), { splitOwnerAddress: fixtures_1.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: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 50 },
+                    { address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_2, percentAllocation: 40 }, // Total: 90%
+                ] });
+            expect(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.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: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 60,
+                    },
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 30,
+                    }, // Total: 90%
+                ] });
+            expect(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.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: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 70,
+                    },
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 40,
+                    }, // Total: 110%
+                ] });
+            expect(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.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(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.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: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 40,
+                    },
+                ] });
+            expect(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.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(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.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(() => (0, ajv_1.validatePayload)(invalidPayload, schema_1.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 = (0, ajv_1.validatePayload)(validPayload, schema_1.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 = (0, ajv_1.validatePayload)(validPayload, schema_1.ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(validPayload);
+        });
+    });
+    describe('Edge cases and boundary conditions', () => {
+        it('should handle decimal percentages correctly for rewards split', () => {
+            const payload = {
+                rewardSplitRecipients: [
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_1,
+                        percentAllocation: 49.5,
+                    },
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_2,
+                        percentAllocation: 49.5,
+                    },
+                ],
+                OVMOwnerAddress: fixtures_1.TEST_ADDRESSES.OVM_OWNER,
+                principalRecipient: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT,
+            };
+            const result = (0, ajv_1.validatePayload)(payload, schema_1.ovmRewardsSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payload), { splitOwnerAddress: fixtures_1.TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should handle decimal percentages correctly for total split', () => {
+            const payload = {
+                rewardSplitRecipients: [
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_1,
+                        percentAllocation: 49.5,
+                    },
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_2,
+                        percentAllocation: 49.5,
+                    },
+                ],
+                principalSplitRecipients: [
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 60.5,
+                    },
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT_2,
+                        percentAllocation: 39.5,
+                    },
+                ],
+                OVMOwnerAddress: fixtures_1.TEST_ADDRESSES.OVM_OWNER,
+            };
+            const result = (0, ajv_1.validatePayload)(payload, schema_1.ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payload), { splitOwnerAddress: fixtures_1.TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should handle single recipient with 99% allocation for rewards split', () => {
+            const payload = {
+                rewardSplitRecipients: [
+                    { address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_1, percentAllocation: 99 },
+                ],
+                OVMOwnerAddress: fixtures_1.TEST_ADDRESSES.OVM_OWNER,
+                principalRecipient: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT,
+            };
+            const result = (0, ajv_1.validatePayload)(payload, schema_1.ovmRewardsSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payload), { splitOwnerAddress: fixtures_1.TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+        it('should handle single recipient with 100% allocation for total split', () => {
+            const payload = {
+                rewardSplitRecipients: [
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_1,
+                        percentAllocation: 49.5,
+                    },
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.REWARD_RECIPIENT_2,
+                        percentAllocation: 49.5,
+                    },
+                ],
+                principalSplitRecipients: [
+                    {
+                        address: fixtures_1.TEST_ADDRESSES.PRINCIPAL_RECIPIENT_1,
+                        percentAllocation: 100,
+                    },
+                ],
+                OVMOwnerAddress: fixtures_1.TEST_ADDRESSES.OVM_OWNER,
+            };
+            const result = (0, ajv_1.validatePayload)(payload, schema_1.ovmTotalSplitPayloadSchema);
+            expect(result).toEqual(Object.assign(Object.assign({}, payload), { splitOwnerAddress: fixtures_1.TEST_ADDRESSES.ZERO_ADDRESS, principalThreshold: 16, distributorFeePercent: 0 }));
+        });
+    });
+});