@obolnetwork/obol-sdk 2.0.1 → 2.1.0

package/dist/esm/src/splitHelpers.js

@@ -0,0 +1,168 @@
+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 { 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 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/src/utils.js

@@ -1,3 +1,12 @@
+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 { DefinitionFlow } from './constants';
 export const hexWithout0x = (hex) => {
     return hex.slice(2, hex.length);
@@ -38,3 +47,13 @@ export const definitionFlow = (clusterDefinition) => {
     }
     return null;
 };
+export const findDeployedBytecode = (contractAddress, provider) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield (provider === null || provider === void 0 ? void 0 : provider.getCode(contractAddress));
+});
+export const isContractAvailable = (contractAddress, provider, bytecode) => __awaiter(void 0, void 0, void 0, function* () {
+    const code = yield findDeployedBytecode(contractAddress, provider);
+    if (bytecode) {
+        return !!code && code === bytecode;
+    }
+    return !!code && code !== '0x' && code !== '0x0';
+});

package/dist/esm/test/fixtures.js

@@ -176,7 +176,7 @@ export const clusterConfigV1X8 = {
         { address: '0xC35CfCd67b9C27345a54EDEcC1033F2284148c81' },
         { address: '0x33807D6F1DCe44b9C599fFE03640762A6F08C496' },
         { address: '0xc6e76F72Ea672FAe05C357157CfC37720F0aF26f' },
-        { address: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC' },
+        { address: '0xf6fF1a7A14D01e86a175bA958d3B6C75f2213966' },
     ],
     validators: [
         {

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

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { ethers } from 'ethers';
+import { ethers, JsonRpcProvider } from 'ethers';
 import { Client, validateClusterLock } from '../src/index';
 import { clusterConfigV1X7, clusterConfigV1X8, clusterLockV1X6, clusterLockV1X7, clusterLockV1X8, nullDepositAmountsClusterLockV1X8, } from './fixtures.js';
 import { SDK_VERSION } from '../src/constants';
@@ -16,22 +16,18 @@ import { validatePayload } from '../src/ajv';
 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';
 /* eslint no-new: 0 */
 describe('Cluster Client', () => {
     var _a, _b;
     const mockConfigHash = '0x1f6c94e6c070393a68c1aa6073a21cb1fd57f0e14d2a475a2958990ab728c2fd';
     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 wallet = new ethers.Wallet(privateKey);
-    const mockSigner = wallet.connect(null);
-    const clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 5 }, mockSigner);
-    // test('throws invalid ChainId when it is equal to 1', async () => {
-    //   try {
-    //     new Client({ chainId: 1 }, mockSigner)
-    //   } catch (error: any) {
-    //     expect(error.message).toBe('Obol-SDK is in Beta phase, mainnet is not yet supported')
-    //   }
-    // })
+    const provider = new JsonRpcProvider('https://ethereum-holesky.publicnode.com');
+    const wallet = new ethers.Wallet(privateKey, provider);
+    const mockSigner = wallet.connect(provider);
+    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()
@@ -138,7 +134,7 @@ describe('Cluster Client', () => {
 describe('Cluster Client without a signer', () => {
     const clientInstance = new Client({
         baseUrl: 'https://obol-api-dev.gcp.obol.tech',
-        chainId: 5,
+        chainId: 17000,
     });
     test('createClusterDefinition should throw an error without signer', () => __awaiter(void 0, void 0, void 0, function* () {
         try {
@@ -198,3 +194,188 @@ describe('Cluster Client without a signer', () => {
         expect(termsAndConditionsHash).toEqual('0xd33721644e8f3afab1495a74abe3523cec12d48b8da6cb760972492ca3f1a273');
     }));
 });
+describe('createObolRewardsSplit', () => {
+    var _a, _b;
+    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',
+        });
+    }));
+    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);
+    const clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
+    const clientInstanceWithourSigner = new Client({
+        baseUrl: 'https://obol-api-dev.gcp.obol.tech',
+        chainId: 17000,
+    });
+    const mockSplitRecipients = [
+        {
+            account: '0x86B8145c98e5BD25BA722645b15eD65f024a87EC',
+            percentAllocation: 99,
+        },
+    ];
+    const mockPrincipalRecipient = '0x86B8145c98e5BD25BA722645b15eD65f024a87EC';
+    const 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('Schema compilation errors\', must pass "validateSplitRecipients" 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("Schema compilation errors', 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', () => {
+    var _a, _b;
+    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'); }));
+    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);
+    const clientInstance = new Client({ baseUrl: 'https://obol-api-dev.gcp.obol.tech', chainId: 17000 }, mockSigner);
+    const clientInstanceWithourSigner = new Client({
+        baseUrl: 'https://obol-api-dev.gcp.obol.tech',
+        chainId: 17000,
+    });
+    const 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('Schema compilation errors\', must pass "validateSplitRecipients" 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("Schema compilation errors', 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.5,
+        });
+        // 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',
+        });
+    }));
+});

package/dist/types/src/abi/Multicall.d.ts

@@ -0,0 +1,35 @@
+export declare const MultiCallContract: {
+    abi: ({
+        constant: boolean;
+        inputs: {
+            components: {
+                name: string;
+                type: string;
+            }[];
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            name: string;
+            type: string;
+        }[];
+        payable: boolean;
+        stateMutability: string;
+        type: string;
+    } | {
+        constant: boolean;
+        inputs: {
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            name: string;
+            type: string;
+        }[];
+        payable: boolean;
+        stateMutability: string;
+        type: string;
+    })[];
+};

package/dist/types/src/abi/OWR.d.ts

@@ -0,0 +1,52 @@
+export declare const OWRFactoryContract: {
+    abi: ({
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        name?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
+};