@obolnetwork/obol-sdk 2.0.0 → 2.1.0

package/src/splitHelpers.ts

@@ -0,0 +1,341 @@
+import {
+  type ClusterValidator,
+  type ETH_ADDRESS,
+  type SplitRecipient,
+} from './types';
+import {
+  Contract,
+  Interface,
+  parseEther,
+  ZeroAddress,
+  type Signer,
+} 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);
+
+type Call = {
+  target: ETH_ADDRESS;
+  callData: string;
+};
+
+type OWRArgs = {
+  recoveryAddress: ETH_ADDRESS;
+  principalRecipient: ETH_ADDRESS;
+  amountOfPrincipalStake: number;
+  predictedSplitterAddress: ETH_ADDRESS;
+};
+
+type SplitArgs = {
+  accounts: ETH_ADDRESS[];
+  percentAllocations: number[];
+  distributorFee: number;
+  controllerAddress: ETH_ADDRESS;
+};
+
+export const formatSplitRecipients = (
+  recipients: SplitRecipient[],
+): { accounts: ETH_ADDRESS[]; percentAllocations: number[] } => {
+  // 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 = async ({
+  signer,
+  accounts,
+  percentAllocations,
+  chainId,
+  distributorFee,
+  controllerAddress,
+}: {
+  signer: Signer;
+  accounts: ETH_ADDRESS[];
+  percentAllocations: number[];
+  chainId: number;
+  distributorFee: number;
+  controllerAddress: ETH_ADDRESS;
+}): Promise<ETH_ADDRESS> => {
+  try {
+    let predictedSplitterAddress: string;
+    const splitMainContractInstance = new Contract(
+      CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address,
+      splitMainEthereumAbi,
+      signer,
+    );
+
+    if (controllerAddress === ZeroAddress) {
+      predictedSplitterAddress =
+        await splitMainContractInstance.predictImmutableSplitAddress(
+          accounts,
+          percentAllocations,
+          distributorFee,
+        );
+    } else {
+      // It throws on deployed Immutable splitter
+      predictedSplitterAddress =
+        await splitMainContractInstance.createSplit.staticCall(
+          accounts,
+          percentAllocations,
+          distributorFee,
+          controllerAddress,
+        );
+    }
+
+    return predictedSplitterAddress;
+  } catch (e) {
+    throw e;
+  }
+};
+
+export const handleDeployOWRAndSplitter = async ({
+  signer,
+  isSplitterDeployed,
+  predictedSplitterAddress,
+  accounts,
+  percentAllocations,
+  etherAmount,
+  principalRecipient,
+  chainId,
+  distributorFee,
+  controllerAddress,
+  recoveryAddress,
+}: {
+  signer: Signer;
+  isSplitterDeployed: boolean;
+  predictedSplitterAddress: ETH_ADDRESS;
+  accounts: ETH_ADDRESS[];
+  percentAllocations: number[];
+  etherAmount: number;
+  principalRecipient: ETH_ADDRESS;
+  chainId: number;
+  distributorFee: number;
+  controllerAddress: ETH_ADDRESS;
+  recoveryAddress: ETH_ADDRESS;
+}): Promise<ClusterValidator> => {
+  try {
+    if (isSplitterDeployed) {
+      const owrAddress = await createOWRContract({
+        owrArgs: {
+          principalRecipient,
+          amountOfPrincipalStake: etherAmount,
+          predictedSplitterAddress,
+          recoveryAddress,
+        },
+        signer,
+        chainId,
+      });
+      return {
+        withdrawal_address: owrAddress,
+        fee_recipient_address: predictedSplitterAddress,
+      };
+    } else {
+      const { owrAddress, splitterAddress } =
+        await 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 = async ({
+  owrArgs,
+  signer,
+  chainId,
+}: {
+  owrArgs: OWRArgs;
+  signer: Signer;
+  chainId: number;
+}): Promise<ETH_ADDRESS> => {
+  try {
+    const OWRFactoryInstance = new Contract(
+      CHAIN_CONFIGURATION[chainId].OWR_FACTORY_ADDRESS.address,
+      OWRFactoryContract.abi,
+      signer,
+    );
+
+    const tx = await OWRFactoryInstance.createOWRecipient(
+      owrArgs.recoveryAddress,
+      owrArgs.principalRecipient,
+      owrArgs.predictedSplitterAddress,
+      parseEther(owrArgs.amountOfPrincipalStake.toString()),
+    );
+
+    const receipt = await tx.wait();
+    const OWRAddressData = receipt?.logs[0]?.topics[1];
+    const formattedOWRAddress = '0x' + OWRAddressData?.slice(26, 66);
+
+    return formattedOWRAddress;
+  } catch (e) {
+    throw e;
+  }
+};
+
+export const deploySplitterContract = async ({
+  signer,
+  accounts,
+  percentAllocations,
+  chainId,
+  distributorFee,
+  controllerAddress,
+}: {
+  signer: Signer;
+  accounts: ETH_ADDRESS[];
+  percentAllocations: number[];
+  chainId: number;
+  distributorFee: number;
+  controllerAddress: ETH_ADDRESS;
+}): Promise<ETH_ADDRESS> => {
+  try {
+    const splitMainContractInstance = new Contract(
+      CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address,
+      splitMainEthereumAbi,
+      signer,
+    );
+    const tx = await splitMainContractInstance.createSplit(
+      accounts,
+      percentAllocations,
+      distributorFee,
+      controllerAddress,
+    );
+
+    const receipt = await tx.wait();
+    const splitterAddressData = receipt?.logs[0]?.topics[1];
+    const formattedSplitterAddress = '0x' + splitterAddressData?.slice(26, 66);
+
+    return formattedSplitterAddress;
+  } catch (e) {
+    throw e;
+  }
+};
+export const deploySplitterAndOWRContracts = async ({
+  owrArgs,
+  splitterArgs,
+  signer,
+  chainId,
+}: {
+  owrArgs: OWRArgs;
+  splitterArgs: SplitArgs;
+  signer: Signer;
+  chainId: number;
+}): Promise<{ owrAddress: ETH_ADDRESS; splitterAddress: ETH_ADDRESS }> => {
+  const executeCalls: Call[] = [];
+  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 = await multicall(
+      executeCalls,
+      signer,
+      multicallAddess,
+    );
+
+    const splitAddressData = executeMultiCalls?.logs[0]?.topics[1];
+    const formattedSplitterAddress = '0x' + splitAddressData?.slice(26, 66);
+    const owrAddressData = executeMultiCalls?.logs[1]?.topics[1];
+    const formattedOwrAddress = '0x' + owrAddressData?.slice(26, 66);
+
+    return {
+      owrAddress: formattedOwrAddress,
+      splitterAddress: formattedSplitterAddress,
+    };
+  } catch (e) {
+    throw e;
+  }
+};
+
+export const multicall = async (
+  calls: Call[],
+  signer: Signer,
+  multicallAddress: string,
+): Promise<any> => {
+  const multiCallContractInstance = new Contract(
+    multicallAddress,
+    MultiCallContract.abi,
+    signer,
+  );
+  const tx = await multiCallContractInstance.aggregate(calls);
+  const receipt = await tx.wait();
+  return receipt;
+};
+
+const encodeCreateSplitTxData = (
+  accounts: ETH_ADDRESS[],
+  percentAllocations: number[],
+  distributorFee: number,
+  controller: ETH_ADDRESS,
+): ETH_ADDRESS => {
+  return splitMainContractInterface.encodeFunctionData('createSplit', [
+    accounts,
+    percentAllocations,
+    distributorFee,
+    controller,
+  ]);
+};
+
+const encodeCreateOWRecipientTxData = (
+  recoveryAddress: ETH_ADDRESS,
+  principalRecipient: ETH_ADDRESS,
+  rewardRecipient: ETH_ADDRESS,
+  amountOfPrincipalStake: number,
+): ETH_ADDRESS => {
+  return owrFactoryContractInterface.encodeFunctionData('createOWRecipient', [
+    recoveryAddress,
+    principalRecipient,
+    rewardRecipient,
+    parseEther(amountOfPrincipalStake.toString()),
+  ]);
+};

package/src/types.ts

@@ -58,10 +58,10 @@ export type ClusterCreator = {
  * Validator withdrawal configuration
  */
 export type ClusterValidator = {
-  /** The validator fee recipient address. */
+  /** Address to receive MEV rewards (if enabled), block proposal and priority fees. */
   fee_recipient_address: string;
 
-  /** The validator reward address. */
+  /** Address to receive skimming rewards and validator principal at exit. */
   withdrawal_address: string;
 };
 
@@ -79,7 +79,7 @@ export type ClusterPayload = {
   validators: ClusterValidator[];
 
   /** The cluster partial deposits in gwei or 32000000000. */
-  deposit_amounts?: string[];
+  deposit_amounts?: string[] | null;
 };
 
 /**
@@ -113,13 +113,52 @@ export interface ClusterDefinition extends ClusterPayload {
   /** The number of distributed validators in the cluster. */
   num_validators: number;
 
-  /** The cluster partial deposits in gwei or 32000000000. */
-  deposit_amounts?: string[];
-
   /** The hash of the cluster definition. */
   definition_hash?: string;
 }
 
+/**
+ * Split Recipient Keys
+ */
+export type SplitRecipient = {
+  /** The split recipient address. */
+  account: string;
+
+  /** The recipient split. */
+  percentAllocation: number;
+};
+
+/**
+ * Split Proxy Params
+ */
+export type TotalSplitPayload = {
+  /** The split recipients addresses and splits. */
+  splitRecipients: SplitRecipient[];
+
+  /** Split percentageNumber allocated for obol retroactive funding, minimum is 1%. */
+  ObolRAFSplit?: number;
+
+  /** The percentageNumber of accrued rewards that is paid to the caller of the distribution function to compensate them for the gas costs of doing so. Cannot be greater than 10%. For example, 5 represents 5%. */
+  distributorFee?: number;
+
+  /** Address that can mutate the split, should be ZeroAddress for immutable split. */
+  controllerAddress?: string;
+};
+
+/**
+ * OWR and Split Proxy Params
+ */
+export interface RewardsSplitPayload extends TotalSplitPayload {
+  /** Address that will reclaim validator principal after exit. */
+  principalRecipient: string;
+
+  /** Amount needed to deploy all validators expected for the OWR/Splitter configuration. */
+  etherAmount: number;
+
+  /** Address that can control where the owr erc-20 tokens can be pushed, if set to zero it goes to splitter or principal address. */
+  recoveryAddress?: string;
+}
+
 /**
  * Unsigned DV Builder Registration Message
  */
@@ -207,3 +246,8 @@ export type ClusterLock = {
   /** Node Signature for the lock hash by the node secp256k1 key. */
   node_signatures?: string[];
 };
+
+/**
+ * String expected to be Ethereum Address
+ */
+export type ETH_ADDRESS = string;

package/src/utils.ts

@@ -1,3 +1,4 @@
+import { type Provider } from 'ethers';
 import { DefinitionFlow } from './constants';
 import { type ClusterDefinition } from './types';
 
@@ -54,3 +55,23 @@ export const definitionFlow = (
   }
   return null;
 };
+
+export const findDeployedBytecode = async (
+  contractAddress: string,
+  provider: Provider,
+): Promise<string> => {
+  return await provider?.getCode(contractAddress);
+};
+
+export const isContractAvailable = async (
+  contractAddress: string,
+  provider: Provider,
+  bytecode?: string,
+): Promise<boolean> => {
+  const code = await findDeployedBytecode(contractAddress, provider);
+
+  if (bytecode) {
+    return !!code && code === bytecode;
+  }
+  return !!code && code !== '0x' && code !== '0x0';
+};

package/src/verification/common.ts

@@ -109,6 +109,18 @@ export const clusterLockHash = (clusterLock: ClusterLock): string => {
   }
 
   if (semver.eq(clusterLock.cluster_definition.version, 'v1.8.0')) {
+    if (
+      clusterLock.cluster_definition.deposit_amounts === null &&
+      clusterLock.distributed_validators.some(
+        distributedValidator =>
+          distributedValidator.partial_deposit_data?.length !== 1 ||
+          distributedValidator.partial_deposit_data[0].amount !== '32000000000',
+      )
+    ) {
+      throw new Error(
+        'mismatch between deposit_amounts and partial_deposit_data fields',
+      );
+    }
     return hashClusterLockV1X8(clusterLock);
   }
 

package/src/verification/v1.8.0.ts

@@ -137,11 +137,11 @@ export const hashClusterDefinitionV1X8 = (
       withdrawal_address: fromHexString(validator.withdrawal_address),
     };
   });
-  val.deposit_amounts = (cluster.deposit_amounts as string[]).map(
-    (amount: string) => {
+  if (cluster.deposit_amounts) {
+    val.deposit_amounts = cluster.deposit_amounts.map((amount: string) => {
       return parseInt(amount);
-    },
-  );
+    });
+  }
 
   if (!configOnly) {
     val.config_hash = fromHexString(cluster.config_hash);