@obolnetwork/obol-sdk 2.5.1 → 2.7.0

package/dist/esm/src/splitHelpers.js

@@ -1,177 +0,0 @@
-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 { Contract, Interface, parseEther, ZeroAddress } from 'ethers';
-import { OWRContract, OWRFactoryContract } from './abi/OWR';
-import { splitMainEthereumAbi } from './abi/SplitMain';
-import { MultiCallContract } from './abi/Multicall';
-import { CHAIN_CONFIGURATION } from './constants';
-const splitMainContractInterface = new Interface(splitMainEthereumAbi);
-const owrFactoryContractInterface = new Interface(OWRFactoryContract.abi);
-export const formatSplitRecipients = (recipients) => {
-    // 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);
-        return parseInt(splitTostring);
-    });
-    return { accounts, percentAllocations };
-};
-export const predictSplitterAddress = ({ signer, accounts, percentAllocations, chainId, distributorFee, controllerAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        let predictedSplitterAddress;
-        const splitMainContractInstance = new Contract(CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address, splitMainEthereumAbi, signer);
-        if (controllerAddress === ZeroAddress) {
-            predictedSplitterAddress =
-                yield splitMainContractInstance.predictImmutableSplitAddress(accounts, percentAllocations, distributorFee);
-        }
-        else {
-            // It throws on deployed Immutable splitter
-            predictedSplitterAddress =
-                yield splitMainContractInstance.createSplit.staticCall(accounts, percentAllocations, distributorFee, controllerAddress);
-        }
-        return predictedSplitterAddress;
-    }
-    catch (e) {
-        throw e;
-    }
-});
-export const handleDeployOWRAndSplitter = ({ signer, isSplitterDeployed, predictedSplitterAddress, accounts, percentAllocations, etherAmount, principalRecipient, chainId, distributorFee, controllerAddress, recoveryAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        if (isSplitterDeployed) {
-            const owrAddress = yield createOWRContract({
-                owrArgs: {
-                    principalRecipient,
-                    amountOfPrincipalStake: etherAmount,
-                    predictedSplitterAddress,
-                    recoveryAddress,
-                },
-                signer,
-                chainId,
-            });
-            return {
-                withdrawal_address: owrAddress,
-                fee_recipient_address: predictedSplitterAddress,
-            };
-        }
-        else {
-            const { owrAddress, splitterAddress } = yield deploySplitterAndOWRContracts({
-                owrArgs: {
-                    principalRecipient,
-                    amountOfPrincipalStake: etherAmount,
-                    predictedSplitterAddress,
-                    recoveryAddress,
-                },
-                splitterArgs: {
-                    accounts,
-                    percentAllocations,
-                    distributorFee,
-                    controllerAddress,
-                },
-                signer,
-                chainId,
-            });
-            return {
-                withdrawal_address: owrAddress,
-                fee_recipient_address: splitterAddress,
-            };
-        }
-    }
-    catch (e) {
-        throw e;
-    }
-});
-const createOWRContract = ({ owrArgs, signer, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    try {
-        const OWRFactoryInstance = new Contract(CHAIN_CONFIGURATION[chainId].OWR_FACTORY_ADDRESS.address, OWRFactoryContract.abi, signer);
-        const tx = yield OWRFactoryInstance.createOWRecipient(owrArgs.recoveryAddress, owrArgs.principalRecipient, owrArgs.predictedSplitterAddress, parseEther(owrArgs.amountOfPrincipalStake.toString()));
-        const receipt = yield tx.wait();
-        const OWRAddressData = (_a = receipt === null || receipt === void 0 ? void 0 : receipt.logs[0]) === null || _a === void 0 ? void 0 : _a.topics[1];
-        const formattedOWRAddress = '0x' + (OWRAddressData === null || OWRAddressData === void 0 ? void 0 : OWRAddressData.slice(26, 66));
-        return formattedOWRAddress;
-    }
-    catch (e) {
-        throw e;
-    }
-});
-export const deploySplitterContract = ({ signer, accounts, percentAllocations, chainId, distributorFee, controllerAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
-    var _b;
-    try {
-        const splitMainContractInstance = new Contract(CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address, splitMainEthereumAbi, signer);
-        const tx = yield splitMainContractInstance.createSplit(accounts, percentAllocations, distributorFee, controllerAddress);
-        const receipt = yield tx.wait();
-        const splitterAddressData = (_b = receipt === null || receipt === void 0 ? void 0 : receipt.logs[0]) === null || _b === void 0 ? void 0 : _b.topics[1];
-        const formattedSplitterAddress = '0x' + (splitterAddressData === null || splitterAddressData === void 0 ? void 0 : splitterAddressData.slice(26, 66));
-        return formattedSplitterAddress;
-    }
-    catch (e) {
-        throw e;
-    }
-});
-export const deploySplitterAndOWRContracts = ({ owrArgs, splitterArgs, signer, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
-    var _c, _d;
-    const executeCalls = [];
-    try {
-        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,
-            callData: splitTxData,
-        }, {
-            target: CHAIN_CONFIGURATION[chainId].OWR_FACTORY_ADDRESS.address,
-            callData: owrTxData,
-        });
-        const multicallAddess = CHAIN_CONFIGURATION[chainId].MULTICALL_ADDRESS.address;
-        const executeMultiCalls = yield multicall(executeCalls, signer, multicallAddess);
-        const splitAddressData = (_c = executeMultiCalls === null || executeMultiCalls === void 0 ? void 0 : executeMultiCalls.logs[0]) === null || _c === void 0 ? void 0 : _c.topics[1];
-        const formattedSplitterAddress = '0x' + (splitAddressData === null || splitAddressData === void 0 ? void 0 : splitAddressData.slice(26, 66));
-        const owrAddressData = (_d = executeMultiCalls === null || executeMultiCalls === void 0 ? void 0 : executeMultiCalls.logs[1]) === null || _d === void 0 ? void 0 : _d.topics[1];
-        const formattedOwrAddress = '0x' + (owrAddressData === null || owrAddressData === void 0 ? void 0 : owrAddressData.slice(26, 66));
-        return {
-            owrAddress: formattedOwrAddress,
-            splitterAddress: formattedSplitterAddress,
-        };
-    }
-    catch (e) {
-        throw e;
-    }
-});
-export const getOWRTranches = ({ owrAddress, signer, }) => __awaiter(void 0, void 0, void 0, function* () {
-    const owrContract = new Contract(owrAddress, OWRContract.abi, signer);
-    const res = yield owrContract.getTranches();
-    return {
-        principalRecipient: res.principalRecipient,
-        rewardRecipient: res.rewardRecipient,
-        amountOfPrincipalStake: res.amountOfPrincipalStake,
-    };
-});
-export const multicall = (calls, signer, multicallAddress) => __awaiter(void 0, void 0, void 0, function* () {
-    const multiCallContractInstance = new Contract(multicallAddress, MultiCallContract.abi, signer);
-    const tx = yield multiCallContractInstance.aggregate(calls);
-    const receipt = yield tx.wait();
-    return receipt;
-});
-const encodeCreateSplitTxData = (accounts, percentAllocations, distributorFee, controller) => {
-    return splitMainContractInterface.encodeFunctionData('createSplit', [
-        accounts,
-        percentAllocations,
-        distributorFee,
-        controller,
-    ]);
-};
-const encodeCreateOWRecipientTxData = (recoveryAddress, principalRecipient, rewardRecipient, amountOfPrincipalStake) => {
-    return owrFactoryContractInterface.encodeFunctionData('createOWRecipient', [
-        recoveryAddress,
-        principalRecipient,
-        rewardRecipient,
-        parseEther(amountOfPrincipalStake.toString()),
-    ]);
-};

package/dist/esm/test/methods.test.js

@@ -1,393 +0,0 @@
-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());
-    });
-};
-var _a, _b;
-import { ethers, JsonRpcProvider } from 'ethers';
-import { Client, validateClusterLock } from '../src/index';
-import { clusterConfigV1X7, clusterConfigV1X10, clusterLockV1X10, clusterLockV1X6, clusterLockV1X7, clusterLockV1X8, clusterLockWithCompoundingWithdrawals, clusterLockWithSafe, nullDepositAmountsClusterLockV1X8, } from './fixtures.js';
-import { SDK_VERSION } from '../src/constants';
-import { Base } from '../src/base';
-import { HttpResponse, http } from 'msw';
-import { setupServer } from 'msw/node';
-import { hashTermsAndConditions } from '../src/verification/termsAndConditions';
-import * as utils from '../src/utils';
-import * as splitsHelpers from '../src/splitHelpers';
-jest.setTimeout(20000);
-const mnemonic = (_b = (_a = ethers.Wallet.createRandom().mnemonic) === null || _a === void 0 ? void 0 : _a.phrase) !== null && _b !== void 0 ? _b : '';
-const privateKey = ethers.Wallet.fromPhrase(mnemonic).privateKey;
-const provider = new JsonRpcProvider('https://ethereum-holesky.publicnode.com');
-const wallet = new ethers.Wallet(privateKey, provider);
-const mockSigner = wallet.connect(provider);
-/* eslint no-new: 0 */
-describe('Cluster Client', () => {
-    const mockConfigHash = '0x1f6c94e6c070393a68c1aa6073a21cb1fd57f0e14d2a475a2958990ab728c2fd';
-    const clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
-    test('createTermsAndConditions should return "successful authorization"', () => __awaiter(void 0, void 0, void 0, function* () {
-        clientInstance['request'] = jest
-            .fn()
-            .mockReturnValue(Promise.resolve({ message: 'successful authorization' }));
-        const isAuthorized = yield clientInstance.acceptObolLatestTermsAndConditions();
-        expect(isAuthorized).toEqual('successful authorization');
-    }));
-    test('createClusterDefinition should return config_hash', () => __awaiter(void 0, void 0, void 0, function* () {
-        clientInstance['request'] = jest
-            .fn()
-            .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
-        const configHash = yield clientInstance.createClusterDefinition(clusterConfigV1X10);
-        expect(configHash).toEqual(mockConfigHash);
-    }));
-    test('acceptClusterDefinition should return cluster definition', () => __awaiter(void 0, void 0, void 0, function* () {
-        clientInstance['request'] = jest
-            .fn()
-            .mockReturnValue(Promise.resolve(clusterLockV1X10.cluster_definition));
-        const clusterDefinition = yield clientInstance.acceptClusterDefinition({
-            enr: clusterLockV1X10.cluster_definition.operators[0].enr,
-            version: clusterLockV1X10.cluster_definition.version,
-        }, clusterLockV1X10.cluster_definition.config_hash);
-        expect(clusterDefinition).toEqual(clusterLockV1X10.cluster_definition);
-    }));
-    test('createClusterDefinition should throw an error on invalid operators', () => __awaiter(void 0, void 0, void 0, function* () {
-        clientInstance['request'] = jest
-            .fn()
-            .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
-        try {
-            yield clientInstance.createClusterDefinition(Object.assign(Object.assign({}, clusterConfigV1X10), { operators: [] }));
-        }
-        catch (error) {
-            expect(error.message).toEqual('Validation failed: /operators must pass "validateUniqueAddresses" keyword validation, /operators must NOT have fewer than 4 items');
-        }
-    }));
-    // cause we default to null
-    test('createClusterDefinition should accept a configuration without deposit_amounts', () => __awaiter(void 0, void 0, void 0, function* () {
-        clientInstance['request'] = jest
-            .fn()
-            .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
-        const configHash = yield clientInstance.createClusterDefinition(Object.assign({}, clusterConfigV1X7));
-        expect(configHash).toEqual(mockConfigHash);
-    }));
-    test('createClusterDefinition should throw on not valid deposit_amounts ', () => __awaiter(void 0, void 0, void 0, function* () {
-        clientInstance['request'] = jest
-            .fn()
-            .mockReturnValue(Promise.resolve({ config_hash: mockConfigHash }));
-        try {
-            yield clientInstance.createClusterDefinition(Object.assign(Object.assign({}, clusterConfigV1X7), { deposit_amounts: ['34000000'] }));
-        }
-        catch (error) {
-            expect(error.message).toEqual('Validation failed: /deposit_amounts/0 must be equal to one of the allowed values, /deposit_amounts must match "then" schema');
-        }
-    }));
-    test('getClusterdefinition should return cluster definition if config hash exist', () => __awaiter(void 0, void 0, void 0, function* () {
-        clientInstance['request'] = jest
-            .fn()
-            .mockReturnValue(Promise.resolve(clusterLockV1X10.cluster_definition));
-        const clusterDefinition = yield clientInstance.getClusterDefinition(clusterLockV1X10.cluster_definition.config_hash);
-        expect(clusterDefinition.deposit_amounts).toBeDefined();
-        expect(clusterDefinition.config_hash).toEqual(clusterLockV1X10.cluster_definition.config_hash);
-        // Test for new fields
-        expect(clusterDefinition.compounding).toBeDefined();
-        expect(clusterDefinition.target_gas_limit).toBeDefined();
-        expect(clusterDefinition.consensus_protocol).toBeDefined();
-    }));
-    test('getClusterLock should return lockFile if exist', () => __awaiter(void 0, void 0, void 0, function* () {
-        clientInstance['request'] = jest
-            .fn()
-            .mockReturnValue(Promise.resolve(clusterLockV1X10));
-        const clusterLock = yield clientInstance.getClusterLock(clusterLockV1X10.cluster_definition.config_hash);
-        expect(clusterLock.lock_hash).toEqual(clusterLockV1X10.lock_hash);
-    }));
-    test('request method should set user agent header', () => __awaiter(void 0, void 0, void 0, function* () {
-        const server = setupServer(http.get('http://testexample.com/test', ({ request }) => {
-            // Check if the request contains specific headers
-            if (request.headers.get('User-Agent') === `Obol-SDK/${SDK_VERSION}`) {
-                return HttpResponse.json({ message: 'user-agent header exist' });
-            }
-        }));
-        server.listen();
-        class TestBase extends Base {
-            callProtectedRequest(endpoint, options) {
-                return __awaiter(this, void 0, void 0, function* () {
-                    return yield this['request'](endpoint, options);
-                });
-            }
-        }
-        const testBaseInstance = new TestBase({
-            baseUrl: 'http://testExample.com',
-        });
-        const result = yield testBaseInstance.callProtectedRequest('/test', {
-            method: 'GET',
-        });
-        expect(result === null || result === void 0 ? void 0 : result.message).toEqual('user-agent header exist');
-        server.close();
-    }));
-});
-describe('Cluster Client without a signer', () => {
-    const clientInstance = new Client({
-        baseUrl: 'https://obol-api-dev.gcp.obol.tech',
-        chainId: 17000,
-    });
-    beforeAll(() => {
-        jest.restoreAllMocks();
-    });
-    beforeEach(() => {
-        jest.resetModules();
-    });
-    test('createClusterDefinition should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            yield clientInstance.createClusterDefinition(clusterConfigV1X10);
-        }
-        catch (err) {
-            expect(err.message).toEqual('Signer is required in createClusterDefinition');
-        }
-    }));
-    test('acceptClusterDefinition should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            yield clientInstance.acceptClusterDefinition({
-                enr: clusterLockV1X10.cluster_definition.operators[0].enr,
-                version: clusterLockV1X10.cluster_definition.version,
-            }, clusterLockV1X10.cluster_definition.config_hash);
-        }
-        catch (err) {
-            expect(err.message).toEqual('Signer is required in acceptClusterDefinition');
-        }
-    }));
-    test('getClusterdefinition should return cluster definition if config hash exist', () => __awaiter(void 0, void 0, void 0, function* () {
-        clientInstance['request'] = jest
-            .fn()
-            .mockReturnValue(Promise.resolve(clusterLockV1X10.cluster_definition));
-        const clusterDefinition = yield clientInstance.getClusterDefinition(clusterLockV1X10.cluster_definition.config_hash);
-        expect(clusterDefinition.config_hash).toEqual(clusterLockV1X10.cluster_definition.config_hash);
-    }));
-    test('getClusterLock should return lockFile if exist', () => __awaiter(void 0, void 0, void 0, function* () {
-        clientInstance['request'] = jest
-            .fn()
-            .mockReturnValue(Promise.resolve(clusterLockV1X10));
-        const clusterLock = yield clientInstance.getClusterLock(clusterLockV1X10.cluster_definition.config_hash);
-        expect(clusterLock.lock_hash).toEqual(clusterLockV1X10.lock_hash);
-    }));
-    test.each([
-        { version: 'v1.6.0', clusterLock: clusterLockV1X6 },
-        { version: 'v1.7.0', clusterLock: clusterLockV1X7 },
-        { version: 'v1.8.0', clusterLock: clusterLockV1X8 },
-        {
-            version: 'null deposit_amounts v1.8.0',
-            clusterLock: nullDepositAmountsClusterLockV1X8,
-        },
-        {
-            version: 'Cluster with safe address v1.8.0',
-            clusterLock: clusterLockWithSafe,
-        },
-        { version: 'v1.10.0', clusterLock: clusterLockV1X10 },
-        {
-            version: 'v1.10.0 with compunding withdrawals',
-            clusterLock: clusterLockWithCompoundingWithdrawals,
-        },
-    ])("$version: 'should return true on verified cluster lock'", ({ clusterLock }) => __awaiter(void 0, void 0, void 0, function* () {
-        const isValidLock = yield validateClusterLock(clusterLock);
-        expect(isValidLock).toEqual(true);
-    }));
-    test('should return true on verified cluster lock with Safe wallet and safe rpc url', () => __awaiter(void 0, void 0, void 0, function* () {
-        process.env.RPC_HOLESKY = undefined;
-        /* eslint-disable @typescript-eslint/no-var-requires */
-        const { validateClusterLock: validateLockWithRpcUrl, } = require('../src/index');
-        const safeRpcUrl = 'https://ethereum-holesky-rpc.publicnode.com';
-        const isValidLock = yield validateLockWithRpcUrl(clusterLockWithSafe, safeRpcUrl);
-        expect(isValidLock).toEqual(true);
-    }));
-    test('validateCluster should return false for cluster with null deposit_amounts and incorrect partial_deposits', () => __awaiter(void 0, void 0, void 0, function* () {
-        const partialDeposit = nullDepositAmountsClusterLockV1X8.distributed_validators[0]
-            .partial_deposit_data[0];
-        const isValidLock = yield validateClusterLock(Object.assign(Object.assign({}, nullDepositAmountsClusterLockV1X8), { distributed_validators: [
-                Object.assign(Object.assign({}, nullDepositAmountsClusterLockV1X8.distributed_validators[0]), { partial_deposit_data: [partialDeposit, partialDeposit] }),
-            ] }));
-        expect(isValidLock).toEqual(false);
-    }));
-    test('Finds the hash of the latest version of terms and conditions', () => __awaiter(void 0, void 0, void 0, function* () {
-        const termsAndConditionsHash = yield hashTermsAndConditions();
-        expect(termsAndConditionsHash).toEqual('0xd33721644e8f3afab1495a74abe3523cec12d48b8da6cb760972492ca3f1a273');
-    }));
-});
-describe('createObolRewardsSplit', () => {
-    let clientInstance, clientInstanceWithourSigner, mockSplitRecipients, mockPrincipalRecipient, mockEtherAmount;
-    beforeAll(() => {
-        jest
-            .spyOn(utils, 'isContractAvailable')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-        jest
-            .spyOn(splitsHelpers, 'predictSplitterAddress')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xPredictedAddress'); }));
-        jest.spyOn(splitsHelpers, 'handleDeployOWRAndSplitter').mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
-            return yield Promise.resolve({
-                withdrawal_address: '0xWithdrawalAddress',
-                fee_recipient_address: '0xFeeRecipientAddress',
-            });
-        }));
-        clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
-        clientInstanceWithourSigner = new Client({
-            baseUrl: 'https://obol-api-dev.gcp.obol.tech',
-            chainId: 17000,
-        });
-        mockSplitRecipients = [
-            {
-                account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
-                percentAllocation: 99,
-            },
-        ];
-        mockPrincipalRecipient = '0x86B8145c98e5BD25BA722645b15eD65f024a87EC';
-        mockEtherAmount = 64;
-    });
-    it('should throw an error if signer is not defined', () => __awaiter(void 0, void 0, void 0, function* () {
-        yield expect(clientInstanceWithourSigner.createObolRewardsSplit({
-            splitRecipients: mockSplitRecipients,
-            principalRecipient: mockPrincipalRecipient,
-            etherAmount: mockEtherAmount,
-        })).rejects.toThrow('Signer is required in createObolRewardsSplit');
-    }));
-    it('should throw an error if chainId is not supported', () => __awaiter(void 0, void 0, void 0, function* () {
-        const unsupportedSplitterChainClient = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 100 }, mockSigner);
-        try {
-            yield unsupportedSplitterChainClient.createObolRewardsSplit({
-                splitRecipients: mockSplitRecipients,
-                principalRecipient: mockPrincipalRecipient,
-                etherAmount: mockEtherAmount,
-            });
-        }
-        catch (error) {
-            expect(error.message).toEqual('Splitter configuration is not supported on 100 chain');
-        }
-    }));
-    test('should throw an error on invalid recipients', () => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            yield clientInstance.createObolRewardsSplit({
-                splitRecipients: [
-                    {
-                        account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
-                        percentAllocation: 22,
-                    },
-                ],
-                principalRecipient: mockPrincipalRecipient,
-                etherAmount: mockEtherAmount,
-            });
-        }
-        catch (error) {
-            expect(error.message).toEqual('Validation failed:  must pass "validateRewardsSplitRecipients" keyword validation');
-        }
-    }));
-    test('should throw an error if ObolRAFSplit is less than 1', () => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            yield clientInstance.createObolRewardsSplit({
-                splitRecipients: mockSplitRecipients,
-                principalRecipient: mockPrincipalRecipient,
-                etherAmount: mockEtherAmount,
-                ObolRAFSplit: 0.5,
-            });
-        }
-        catch (error) {
-            expect(error.message).toEqual('Validation failed:  must pass "validateRewardsSplitRecipients" keyword validation, /ObolRAFSplit must be >= 1');
-        }
-    }));
-    it('should return the correct withdrawal and fee recipient addresses', () => __awaiter(void 0, void 0, void 0, function* () {
-        const result = yield clientInstance.createObolRewardsSplit({
-            splitRecipients: mockSplitRecipients,
-            principalRecipient: mockPrincipalRecipient,
-            etherAmount: mockEtherAmount,
-        });
-        expect(result).toEqual({
-            withdrawal_address: '0xWithdrawalAddress',
-            fee_recipient_address: '0xFeeRecipientAddress',
-        });
-    }));
-});
-describe('createObolTotalSplit', () => {
-    let clientInstanceWithourSigner, mockSplitRecipients, clientInstance;
-    beforeAll(() => {
-        jest
-            .spyOn(utils, 'isContractAvailable')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve(true); }));
-        jest
-            .spyOn(splitsHelpers, 'predictSplitterAddress')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xPredictedAddress'); }));
-        jest
-            .spyOn(splitsHelpers, 'deploySplitterContract')
-            .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return yield Promise.resolve('0xSplitterAddress'); }));
-        clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
-        clientInstanceWithourSigner = new Client({
-            baseUrl: 'https://obol-api-dev.gcp.obol.tech',
-            chainId: 17000,
-        });
-        mockSplitRecipients = [
-            {
-                account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
-                percentAllocation: 99.9,
-            },
-        ];
-    });
-    it('should throw an error if signer is not defined', () => __awaiter(void 0, void 0, void 0, function* () {
-        yield expect(clientInstanceWithourSigner.createObolTotalSplit({
-            splitRecipients: mockSplitRecipients,
-        })).rejects.toThrow('Signer is required in createObolTotalSplit');
-    }));
-    it('should throw an error if chainId is not supported', () => __awaiter(void 0, void 0, void 0, function* () {
-        const unsupportedSplitterChainClient = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 100 }, mockSigner);
-        try {
-            yield unsupportedSplitterChainClient.createObolTotalSplit({
-                splitRecipients: mockSplitRecipients,
-            });
-        }
-        catch (error) {
-            expect(error.message).toEqual('Splitter configuration is not supported on 100 chain');
-        }
-    }));
-    test('should throw an error on invalid recipients', () => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            yield clientInstance.createObolTotalSplit({
-                splitRecipients: [
-                    {
-                        account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
-                        percentAllocation: 22,
-                    },
-                ],
-            });
-        }
-        catch (error) {
-            expect(error.message).toEqual('Validation failed:  must pass "validateTotalSplitRecipients" keyword validation');
-        }
-    }));
-    test('should throw an error if ObolRAFSplit is less than 0.1', () => __awaiter(void 0, void 0, void 0, function* () {
-        try {
-            yield clientInstance.createObolTotalSplit({
-                splitRecipients: mockSplitRecipients,
-                ObolRAFSplit: 0.05,
-            });
-        }
-        catch (error) {
-            expect(error.message).toEqual('Validation failed:  must pass "validateTotalSplitRecipients" keyword validation, /ObolRAFSplit must be >= 0.1');
-        }
-    }));
-    it('should return the correct withdrawal and fee recipient addresses and ObolRAFSplit', () => __awaiter(void 0, void 0, void 0, function* () {
-        const result = yield clientInstance.createObolTotalSplit({
-            splitRecipients: mockSplitRecipients,
-            ObolRAFSplit: 0.1,
-        });
-        // 0xPredictedAddress and not 0xSplitterAddress since were mocking isContractAvailable response to be true
-        expect(result).toEqual({
-            withdrawal_address: '0xPredictedAddress',
-            fee_recipient_address: '0xPredictedAddress',
-        });
-    }));
-    it('should return the correct withdrawal and fee recipient addresses without passing ObolRAFSplit', () => __awaiter(void 0, void 0, void 0, function* () {
-        const result = yield clientInstance.createObolTotalSplit({
-            splitRecipients: mockSplitRecipients,
-        });
-        // 0xPredictedAddress and not 0xSplitterAddress since were mocking isContractAvailable response to be true
-        expect(result).toEqual({
-            withdrawal_address: '0xPredictedAddress',
-            fee_recipient_address: '0xPredictedAddress',
-        });
-    }));
-});