@obolnetwork/obol-sdk 2.5.1 → 2.6.0

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

@@ -0,0 +1,317 @@
+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* () {
+    var _a, _b, _c;
+    try {
+        const splitMainContractInstance = new Contract(CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address, splitMainEthereumAbi, signer);
+        let predictedSplitterAddress;
+        if (controllerAddress === ZeroAddress) {
+            try {
+                predictedSplitterAddress =
+                    yield splitMainContractInstance.predictImmutableSplitAddress(accounts, percentAllocations, distributorFee);
+            }
+            catch (error) {
+                throw new Error(`Failed to predict immutable splitter address: ${(_a = error.message) !== null && _a !== void 0 ? _a : 'Contract call failed'}`);
+            }
+        }
+        else {
+            try {
+                // It throws on deployed Immutable splitter
+                predictedSplitterAddress =
+                    yield splitMainContractInstance.createSplit.staticCall(accounts, percentAllocations, distributorFee, controllerAddress);
+            }
+            catch (error) {
+                throw new Error(`Failed to predict mutable splitter address via static call: ${(_b = error.message) !== null && _b !== void 0 ? _b : 'Static call failed'}`);
+            }
+        }
+        return predictedSplitterAddress;
+    }
+    catch (error) {
+        // Re-throw if it's already our custom error
+        if (error.message.includes('Failed to predict')) {
+            throw error;
+        }
+        // Handle unexpected errors
+        throw new Error(`Unexpected error in predictSplitterAddress: ${(_c = error.message) !== null && _c !== void 0 ? _c : 'Unknown contract interaction error'}`);
+    }
+});
+export const handleDeployOWRAndSplitter = ({ signer, isSplitterDeployed, predictedSplitterAddress, accounts, percentAllocations, etherAmount, principalRecipient, chainId, distributorFee, controllerAddress, recoveryAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _d, _e, _f;
+    try {
+        if (isSplitterDeployed) {
+            let owrAddress;
+            try {
+                owrAddress = yield createOWRContract({
+                    owrArgs: {
+                        principalRecipient,
+                        amountOfPrincipalStake: etherAmount,
+                        predictedSplitterAddress,
+                        recoveryAddress,
+                    },
+                    signer,
+                    chainId,
+                });
+            }
+            catch (error) {
+                throw new Error(`Failed to create OWR contract with existing splitter: ${(_d = error.message) !== null && _d !== void 0 ? _d : 'OWR contract creation failed'}`);
+            }
+            return {
+                withdrawal_address: owrAddress,
+                fee_recipient_address: predictedSplitterAddress,
+            };
+        }
+        else {
+            let owrAddress;
+            let splitterAddress;
+            try {
+                const result = yield deploySplitterAndOWRContracts({
+                    owrArgs: {
+                        principalRecipient,
+                        amountOfPrincipalStake: etherAmount,
+                        predictedSplitterAddress,
+                        recoveryAddress,
+                    },
+                    splitterArgs: {
+                        accounts,
+                        percentAllocations,
+                        distributorFee,
+                        controllerAddress,
+                    },
+                    signer,
+                    chainId,
+                });
+                owrAddress = result.owrAddress;
+                splitterAddress = result.splitterAddress;
+            }
+            catch (error) {
+                throw new Error(`Failed to deploy both splitter and OWR contracts: ${(_e = error.message) !== null && _e !== void 0 ? _e : 'Multicall contract deployment failed'}`);
+            }
+            return {
+                withdrawal_address: owrAddress,
+                fee_recipient_address: splitterAddress,
+            };
+        }
+    }
+    catch (error) {
+        // Re-throw if it's already our custom error
+        if (error.message.includes('Failed to')) {
+            throw error;
+        }
+        // Handle unexpected errors
+        throw new Error(`Unexpected error in handleDeployOWRAndSplitter: ${(_f = error.message) !== null && _f !== void 0 ? _f : 'Unknown error during contract deployment orchestration'}`);
+    }
+});
+const createOWRContract = ({ owrArgs, signer, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _g, _h, _j, _k, _l;
+    try {
+        const OWRFactoryInstance = new Contract(CHAIN_CONFIGURATION[chainId].OWR_FACTORY_ADDRESS.address, OWRFactoryContract.abi, signer);
+        let tx;
+        try {
+            tx = yield OWRFactoryInstance.createOWRecipient(owrArgs.recoveryAddress, owrArgs.principalRecipient, owrArgs.predictedSplitterAddress, parseEther(owrArgs.amountOfPrincipalStake.toString()));
+        }
+        catch (error) {
+            throw new Error(`Failed to submit OWR contract creation transaction: ${(_g = error.message) !== null && _g !== void 0 ? _g : 'Transaction submission failed'}`);
+        }
+        let receipt;
+        try {
+            receipt = yield tx.wait();
+        }
+        catch (error) {
+            throw new Error(`OWR contract creation transaction failed or was reverted: ${(_h = error.message) !== null && _h !== void 0 ? _h : 'Transaction execution failed'}`);
+        }
+        if (!((_j = receipt === null || receipt === void 0 ? void 0 : receipt.logs) === null || _j === void 0 ? void 0 : _j.length)) {
+            throw new Error('OWR contract creation transaction succeeded but no events were emitted - unable to determine contract address');
+        }
+        const OWRAddressData = (_k = receipt.logs[0]) === null || _k === void 0 ? void 0 : _k.topics[1];
+        if (!OWRAddressData) {
+            throw new Error('OWR contract creation transaction succeeded but contract address could not be extracted from events');
+        }
+        const formattedOWRAddress = '0x' + OWRAddressData.slice(26, 66);
+        // Basic address validation
+        if (formattedOWRAddress.length !== 42 ||
+            !formattedOWRAddress.startsWith('0x')) {
+            throw new Error(`Invalid OWR contract address format: ${formattedOWRAddress}`);
+        }
+        return formattedOWRAddress;
+    }
+    catch (error) {
+        // Re-throw if it's already our custom error
+        if (error.message.includes('Failed to') ||
+            error.message.includes('OWR contract') ||
+            error.message.includes('Invalid OWR')) {
+            throw error;
+        }
+        // Handle unexpected errors
+        throw new Error(`Unexpected error in createOWRContract: ${(_l = error.message) !== null && _l !== void 0 ? _l : 'Unknown error during OWR contract creation'}`);
+    }
+});
+export const deploySplitterContract = ({ signer, accounts, percentAllocations, chainId, distributorFee, controllerAddress, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _m, _o, _p, _q, _r;
+    try {
+        const splitMainContractInstance = new Contract(CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address, splitMainEthereumAbi, signer);
+        let tx;
+        try {
+            tx = yield splitMainContractInstance.createSplit(accounts, percentAllocations, distributorFee, controllerAddress);
+        }
+        catch (error) {
+            throw new Error(`Failed to submit splitter contract creation transaction: ${(_m = error.message) !== null && _m !== void 0 ? _m : 'Transaction submission failed'}`);
+        }
+        let receipt;
+        try {
+            receipt = yield tx.wait();
+        }
+        catch (error) {
+            throw new Error(`Splitter contract creation transaction failed or was reverted: ${(_o = error.message) !== null && _o !== void 0 ? _o : 'Transaction execution failed'}`);
+        }
+        if (!((_p = receipt === null || receipt === void 0 ? void 0 : receipt.logs) === null || _p === void 0 ? void 0 : _p.length)) {
+            throw new Error('Splitter contract creation transaction succeeded but no events were emitted - unable to determine contract address');
+        }
+        const splitterAddressData = (_q = receipt.logs[0]) === null || _q === void 0 ? void 0 : _q.topics[1];
+        if (!splitterAddressData) {
+            throw new Error('Splitter contract creation transaction succeeded but contract address could not be extracted from events');
+        }
+        const formattedSplitterAddress = '0x' + splitterAddressData.slice(26, 66);
+        // Basic address validation
+        if (formattedSplitterAddress.length !== 42 ||
+            !formattedSplitterAddress.startsWith('0x')) {
+            throw new Error(`Invalid splitter contract address format: ${formattedSplitterAddress}`);
+        }
+        return formattedSplitterAddress;
+    }
+    catch (error) {
+        // Re-throw if it's already our custom error
+        if (error.message.includes('Failed to') ||
+            error.message.includes('Splitter contract') ||
+            error.message.includes('Invalid splitter')) {
+            throw error;
+        }
+        // Handle unexpected errors
+        throw new Error(`Unexpected error in deploySplitterContract: ${(_r = error.message) !== null && _r !== void 0 ? _r : 'Unknown error during splitter contract creation'}`);
+    }
+});
+export const deploySplitterAndOWRContracts = ({ owrArgs, splitterArgs, signer, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _s, _t;
+    const executeCalls = [];
+    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 = (_s = executeMultiCalls === null || executeMultiCalls === void 0 ? void 0 : executeMultiCalls.logs[0]) === null || _s === void 0 ? void 0 : _s.topics[1];
+    const formattedSplitterAddress = '0x' + (splitAddressData === null || splitAddressData === void 0 ? void 0 : splitAddressData.slice(26, 66));
+    const owrAddressData = (_t = executeMultiCalls === null || executeMultiCalls === void 0 ? void 0 : executeMultiCalls.logs[1]) === null || _t === void 0 ? void 0 : _t.topics[1];
+    const formattedOwrAddress = '0x' + (owrAddressData === null || owrAddressData === void 0 ? void 0 : owrAddressData.slice(26, 66));
+    return {
+        owrAddress: formattedOwrAddress,
+        splitterAddress: formattedSplitterAddress,
+    };
+});
+export const getOWRTranches = ({ owrAddress, signer, }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _u, _v;
+    try {
+        const owrContract = new Contract(owrAddress, OWRContract.abi, signer);
+        let res;
+        try {
+            res = yield owrContract.getTranches();
+        }
+        catch (error) {
+            throw new Error(`Failed to call getTranches on OWR contract at ${owrAddress}: ${(_u = error.message) !== null && _u !== void 0 ? _u : 'Contract call failed'}`);
+        }
+        if (!res) {
+            throw new Error(`OWR contract at ${owrAddress} returned empty result for getTranches()`);
+        }
+        return {
+            principalRecipient: res.principalRecipient,
+            rewardRecipient: res.rewardRecipient,
+            amountOfPrincipalStake: res.amountOfPrincipalStake,
+        };
+    }
+    catch (error) {
+        // Re-throw if it's already our custom error
+        if (error.message.includes('Failed to') ||
+            error.message.includes('OWR contract')) {
+            throw error;
+        }
+        // Handle unexpected errors
+        throw new Error(`Unexpected error in getOWRTranches: ${(_v = error.message) !== null && _v !== void 0 ? _v : 'Unknown error while fetching OWR tranche data'}`);
+    }
+});
+export const multicall = (calls, signer, multicallAddress) => __awaiter(void 0, void 0, void 0, function* () {
+    var _w, _x, _y;
+    try {
+        const multiCallContractInstance = new Contract(multicallAddress, MultiCallContract.abi, signer);
+        let tx;
+        try {
+            tx = yield multiCallContractInstance.aggregate(calls);
+        }
+        catch (error) {
+            throw new Error(`Failed to submit multicall transaction: ${(_w = error.message) !== null && _w !== void 0 ? _w : 'Transaction submission failed'}`);
+        }
+        let receipt;
+        try {
+            receipt = yield tx.wait();
+        }
+        catch (error) {
+            throw new Error(`Multicall transaction failed or was reverted: ${(_x = error.message) !== null && _x !== void 0 ? _x : 'Transaction execution failed'}`);
+        }
+        if (!receipt) {
+            throw new Error('Multicall transaction succeeded but no receipt was returned');
+        }
+        return receipt;
+    }
+    catch (error) {
+        // Re-throw if it's already our custom error
+        if (error.message.includes('Failed to') ||
+            error.message.includes('Multicall transaction')) {
+            throw error;
+        }
+        // Handle unexpected errors
+        throw new Error(`Unexpected error in multicall: ${(_y = error.message) !== null && _y !== void 0 ? _y : 'Unknown error during multicall execution'}`);
+    }
+});
+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/src/types.js

@@ -24,3 +24,4 @@ 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/exit/ethUtils.spec.js

@@ -0,0 +1,81 @@
+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 { getCapellaFork, getGenesisValidatorsRoot, } from '../../src/exits/ethUtils';
+import { CAPELLA_FORK_MAPPING } from '../../src/constants';
+describe('ethUtils', () => {
+    describe('getCapellaFork', () => {
+        Object.entries(CAPELLA_FORK_MAPPING).forEach(([baseFork, expectedCapellaFork]) => {
+            it(`should return ${expectedCapellaFork} for base fork ${baseFork}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const result = yield getCapellaFork(baseFork);
+                expect(result).toBe(expectedCapellaFork);
+            }));
+        });
+        it('should return null for an unknown base fork version', () => __awaiter(void 0, void 0, void 0, function* () {
+            const result = yield getCapellaFork('0xUNKNOWNFORK');
+            expect(result).toBeNull();
+        }));
+    });
+    describe('getGenesisValidatorsRoot', () => {
+        const mockBeaconApiUrl = 'http://localhost:5052';
+        const mockGenesisRoot = '0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2';
+        beforeEach(() => {
+            // Reset fetch mock
+            global.fetch = jest.fn();
+        });
+        afterEach(() => {
+            jest.restoreAllMocks();
+        });
+        it('should fetch and return the genesis_validators_root successfully', () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch.mockResolvedValueOnce({
+                json: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        data: { genesis_validators_root: mockGenesisRoot },
+                    });
+                }),
+            });
+            const result = yield getGenesisValidatorsRoot(mockBeaconApiUrl);
+            expect(result).toBe(mockGenesisRoot);
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+            expect(global.fetch).toHaveBeenCalledWith(`${mockBeaconApiUrl}/eth/v1/beacon/genesis`, { method: 'GET' });
+        }));
+        it('should return null if the HTTP request fails (e.g., network error)', () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch.mockRejectedValueOnce(new Error('Network error'));
+            yield expect(getGenesisValidatorsRoot(mockBeaconApiUrl)).rejects.toThrow('Failed to fetch genesis validators root: Network error');
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+        }));
+        it('should return null if the response data structure is invalid (missing genesis_validators_root)', () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch.mockResolvedValueOnce({
+                json: () => __awaiter(void 0, void 0, void 0, function* () {
+                    return ({
+                        data: { some_other_field: 'value' },
+                    });
+                }),
+            });
+            const result = yield getGenesisValidatorsRoot(mockBeaconApiUrl);
+            expect(result).toBeNull();
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+        }));
+        it('should return null if the response data is missing', () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch.mockResolvedValueOnce({
+                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({}); }),
+            });
+            const result = yield getGenesisValidatorsRoot(mockBeaconApiUrl);
+            expect(result).toBeNull();
+        }));
+        it('should throw an error if fetch throws an error with a message', () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch.mockRejectedValueOnce(new Error('Custom HTTP error'));
+            yield expect(getGenesisValidatorsRoot(mockBeaconApiUrl)).rejects.toThrow('Failed to fetch genesis validators root: Custom HTTP error');
+        }));
+        it('should throw an error if fetch throws a non-Error object', () => __awaiter(void 0, void 0, void 0, function* () {
+            global.fetch.mockRejectedValueOnce('some string error');
+            yield expect(getGenesisValidatorsRoot(mockBeaconApiUrl)).rejects.toThrow('Failed to fetch genesis validators root: some string error');
+        }));
+    });
+});