@obolnetwork/obol-sdk 2.7.0 → 2.8.1

package/src/index.ts

@@ -12,10 +12,10 @@ import {
   TermsAndConditionsSigningTypes,
   DEFAULT_BASE_VERSION,
   TERMS_AND_CONDITIONS_HASH,
-  AVAILABLE_SPLITTER_CHAINS,
   CHAIN_CONFIGURATION,
   DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
   OBOL_SDK_EMAIL,
+  isChainSupportedForSplitters,
 } from './constants.js';
 import { ConflictError } from './errors.js';
 import {
@@ -49,6 +49,7 @@ import {
 import { isContractAvailable } from './utils.js';
 import { Incentives } from './incentives/incentives.js';
 import { Exit } from './exits/exit.js';
+import { ObolSplits } from './splits/splits.js';
 export * from './types.js';
 export * from './services.js';
 export * from './verification/signature-validator.js';
@@ -56,6 +57,7 @@ export * from './verification/common.js';
 export * from './constants.js';
 export { Incentives } from './incentives/incentives.js';
 export { Exit } from './exits/exit.js';
+export { ObolSplits } from './splits/splits.js';
 
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.
@@ -78,6 +80,12 @@ export class Client extends Base {
    */
   public exit: Exit;
 
+  /**
+   * The splits module, responsible for managing splits.
+   * @type {ObolSplits}
+   */
+  public splits: ObolSplits;
+
   /**
    * The blockchain provider, used to interact with the network.
    * It can be null, undefined, or a valid provider instance and defaults to the Signer provider if Signer is passed.
@@ -112,6 +120,7 @@ export class Client extends Base {
       this.provider,
     );
     this.exit = new Exit(this.chainId, this.provider);
+    this.splits = new ObolSplits(this.signer, this.chainId, this.provider);
   }
 
   /**
@@ -205,28 +214,35 @@ export class Client extends Base {
     );
 
     // Check if we allow splitters on this chainId
-    if (!AVAILABLE_SPLITTER_CHAINS.includes(this.chainId)) {
+    if (!isChainSupportedForSplitters(this.chainId)) {
       throw new Error(
         `Splitter configuration is not supported on ${this.chainId} chain`,
       );
     }
 
+    const chainConfig = CHAIN_CONFIGURATION[this.chainId];
+    if (!chainConfig?.SPLITMAIN_CONTRACT) {
+      throw new Error(
+        `SPLITMAIN_CONTRACT is not configured for chain ${this.chainId}`,
+      );
+    }
+
     const checkSplitMainAddress = await isContractAvailable(
-      CHAIN_CONFIGURATION[this.chainId].SPLITMAIN_ADDRESS.address,
+      chainConfig.SPLITMAIN_CONTRACT.address,
       this.signer.provider as ProviderType,
-      CHAIN_CONFIGURATION[this.chainId].SPLITMAIN_ADDRESS.bytecode,
+      chainConfig.SPLITMAIN_CONTRACT.bytecode,
     );
 
     const checkMulticallAddress = await isContractAvailable(
-      CHAIN_CONFIGURATION[this.chainId].MULTICALL_ADDRESS.address,
+      chainConfig.MULTICALL_CONTRACT.address,
       this.signer.provider as ProviderType,
-      CHAIN_CONFIGURATION[this.chainId].MULTICALL_ADDRESS.bytecode,
+      chainConfig.MULTICALL_CONTRACT.bytecode,
     );
 
     const checkOWRFactoryAddress = await isContractAvailable(
-      CHAIN_CONFIGURATION[this.chainId].OWR_FACTORY_ADDRESS.address,
+      chainConfig.OWR_FACTORY_CONTRACT.address,
       this.signer.provider as ProviderType,
-      CHAIN_CONFIGURATION[this.chainId].OWR_FACTORY_ADDRESS.bytecode,
+      chainConfig.OWR_FACTORY_CONTRACT.bytecode,
     );
 
     if (
@@ -240,8 +256,7 @@ export class Client extends Base {
     }
 
     const retroActiveFundingRecipient = {
-      account:
-        CHAIN_CONFIGURATION[this.chainId].RETROACTIVE_FUNDING_ADDRESS.address,
+      account: chainConfig.RETROACTIVE_FUNDING_CONTRACT.address,
       percentAllocation: validatedPayload.ObolRAFSplit,
     };
 
@@ -320,16 +335,23 @@ export class Client extends Base {
     );
 
     // Check if we allow splitters on this chainId
-    if (!AVAILABLE_SPLITTER_CHAINS.includes(this.chainId)) {
+    if (!isChainSupportedForSplitters(this.chainId)) {
       throw new Error(
         `Splitter configuration is not supported on ${this.chainId} chain`,
       );
     }
 
+    const chainConfig = CHAIN_CONFIGURATION[this.chainId];
+    if (!chainConfig?.SPLITMAIN_CONTRACT) {
+      throw new Error(
+        `SPLITMAIN_CONTRACT is not configured for chain ${this.chainId}`,
+      );
+    }
+
     const checkSplitMainAddress = await isContractAvailable(
-      CHAIN_CONFIGURATION[this.chainId].SPLITMAIN_ADDRESS.address,
+      chainConfig.SPLITMAIN_CONTRACT.address,
       this.signer.provider as ProviderType,
-      CHAIN_CONFIGURATION[this.chainId].SPLITMAIN_ADDRESS.bytecode,
+      chainConfig.SPLITMAIN_CONTRACT.bytecode,
     );
 
     if (!checkSplitMainAddress) {
@@ -339,8 +361,7 @@ export class Client extends Base {
     }
 
     const retroActiveFundingRecipient = {
-      account:
-        CHAIN_CONFIGURATION[this.chainId].RETROACTIVE_FUNDING_ADDRESS.address,
+      account: chainConfig.RETROACTIVE_FUNDING_CONTRACT.address,
       percentAllocation: validatedPayload.ObolRAFSplit,
     };
 

package/src/schema.ts

@@ -2,6 +2,7 @@ import { ZeroAddress } from 'ethers';
 import {
   DEFAULT_RETROACTIVE_FUNDING_REWARDS_ONLY_SPLIT,
   DEFAULT_RETROACTIVE_FUNDING_TOTAL_SPLIT,
+  PRINCIPAL_THRESHOLD,
 } from './constants';
 import { VALID_DEPOSIT_AMOUNTS, VALID_NON_COMPOUNDING_AMOUNTS } from './ajv';
 
@@ -150,3 +151,81 @@ export const rewardsSplitterPayloadSchema = {
   validateRewardsSplitRecipients: true,
   required: ['splitRecipients', 'principalRecipient', 'etherAmount'],
 };
+
+export const ovmBaseSplitPayload = {
+  rewardSplitRecipients: {
+    type: 'array',
+    items: {
+      type: 'object',
+      properties: {
+        address: {
+          type: 'string',
+          pattern: '^0x[a-fA-F0-9]{40}$',
+        },
+        percentAllocation: { type: 'number' },
+      },
+      required: ['address', 'percentAllocation'],
+    },
+  },
+  OVMOwnerAddress: {
+    type: 'string',
+    pattern: '^0x[a-fA-F0-9]{40}$',
+  },
+  splitOwnerAddress: {
+    type: 'string',
+    pattern: '^0x[a-fA-F0-9]{40}$',
+    default: ZeroAddress,
+  },
+  principalThreshold: {
+    type: 'number',
+    minimum: 16,
+    default: PRINCIPAL_THRESHOLD,
+  },
+  distributorFeePercent: {
+    type: 'number',
+    minimum: 0,
+    maximum: 10,
+    default: 0,
+  },
+};
+
+export const ovmRewardsSplitPayloadSchema = {
+  type: 'object',
+  properties: {
+    ...ovmBaseSplitPayload,
+    principalRecipient: {
+      type: 'string',
+      pattern: '^0x[a-fA-F0-9]{40}$',
+    },
+  },
+  validateOVMRewardsSplitRecipients: true,
+  required: ['rewardSplitRecipients', 'OVMOwnerAddress', 'principalRecipient'],
+};
+
+export const ovmTotalSplitPayloadSchema = {
+  type: 'object',
+  properties: {
+    ...ovmBaseSplitPayload,
+    principalSplitRecipients: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          address: {
+            type: 'string',
+            pattern: '^0x[a-fA-F0-9]{40}$',
+          },
+          percentAllocation: { type: 'number' },
+        },
+        required: ['address', 'percentAllocation'],
+      },
+    },
+  },
+  validateOVMRewardsSplitRecipients: true,
+  validateOVMTotalSplitRecipients: true,
+  required: [
+    'rewardSplitRecipients',
+    'principalSplitRecipients',
+    'OVMOwnerAddress',
+  ],
+};

package/src/splits/splitHelpers.ts

@@ -4,15 +4,22 @@ import {
   type ETH_ADDRESS,
   type SplitRecipient,
   type SignerType,
+  type SplitV2Recipient,
+  type OVMArgs,
+  type ChainConfig,
 } from '../types';
 import { Contract, Interface, parseEther, ZeroAddress } from 'ethers';
 import { OWRContract, OWRFactoryContract } from '../abi/OWR';
+import { OVMFactoryContract } from '../abi/OVMFactory';
 import { splitMainEthereumAbi } from '../abi/SplitMain';
 import { MultiCallContract } from '../abi/Multicall';
 import { CHAIN_CONFIGURATION } from '../constants';
+import { splitV2FactoryAbi } from '../abi/splitV2FactoryAbi';
 
 const splitMainContractInterface = new Interface(splitMainEthereumAbi);
 const owrFactoryContractInterface = new Interface(OWRFactoryContract.abi);
+const ovmFactoryContractInterface = new Interface(OVMFactoryContract.abi);
+const splitV2FactoryInterface = new Interface(splitV2FactoryAbi);
 
 type Call = {
   target: ETH_ADDRESS;
@@ -33,14 +40,39 @@ type SplitArgs = {
   controllerAddress: ETH_ADDRESS;
 };
 
+// Helper function to extract common recipient formatting logic
+const formatRecipientsCommon = (
+  recipients: SplitRecipient[] | SplitV2Recipient[],
+): {
+  sortedRecipients: any[];
+  getAddress: (item: any) => string;
+  getPercentAllocation: (item: any) => number;
+} => {
+  const copiedRecipients = [...recipients];
+
+  // Handle both SplitRecipient and SplitV2Recipient types
+  const getAddress = (item: any): string => item.account || item.address;
+  const getPercentAllocation = (item: any): number => item.percentAllocation;
+
+  // Has to be sorted when passed
+  copiedRecipients.sort((a, b) => getAddress(a).localeCompare(getAddress(b)));
+
+  return {
+    sortedRecipients: copiedRecipients,
+    getAddress,
+    getPercentAllocation,
+  };
+};
+
 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);
+  const { sortedRecipients, getAddress, getPercentAllocation } =
+    formatRecipientsCommon(recipients);
+
+  const accounts = sortedRecipients.map(item => getAddress(item));
+  const percentAllocations = sortedRecipients.map(recipient => {
+    const splitTostring = (getPercentAllocation(recipient) * 1e4).toFixed(0);
     return parseInt(splitTostring);
   });
   return { accounts, percentAllocations };
@@ -63,7 +95,7 @@ export const predictSplitterAddress = async ({
 }): Promise<ETH_ADDRESS> => {
   try {
     const splitMainContractInstance = new Contract(
-      CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address,
+      getChainConfig(chainId).SPLITMAIN_CONTRACT.address,
       splitMainEthereumAbi,
       signer,
     );
@@ -217,7 +249,7 @@ const createOWRContract = async ({
 }): Promise<ETH_ADDRESS> => {
   try {
     const OWRFactoryInstance = new Contract(
-      CHAIN_CONFIGURATION[chainId].OWR_FACTORY_ADDRESS.address,
+      getChainConfig(chainId).OWR_FACTORY_CONTRACT.address,
       OWRFactoryContract.abi,
       signer,
     );
@@ -304,7 +336,7 @@ export const deploySplitterContract = async ({
 }): Promise<ETH_ADDRESS> => {
   try {
     const splitMainContractInstance = new Contract(
-      CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address,
+      getChainConfig(chainId).SPLITMAIN_CONTRACT.address,
       splitMainEthereumAbi,
       signer,
     );
@@ -403,22 +435,16 @@ export const deploySplitterAndOWRContracts = async ({
 
   executeCalls.push(
     {
-      target: CHAIN_CONFIGURATION[chainId].SPLITMAIN_ADDRESS.address,
+      target: getChainConfig(chainId).SPLITMAIN_CONTRACT.address,
       callData: splitTxData,
     },
     {
-      target: CHAIN_CONFIGURATION[chainId].OWR_FACTORY_ADDRESS.address,
+      target: getChainConfig(chainId).OWR_FACTORY_CONTRACT.address,
       callData: owrTxData,
     },
   );
-  const multicallAddess =
-    CHAIN_CONFIGURATION[chainId].MULTICALL_ADDRESS.address;
 
-  const executeMultiCalls = await multicall(
-    executeCalls,
-    signer,
-    multicallAddess,
-  );
+  const executeMultiCalls = await multicall(executeCalls, signer, chainId);
 
   const splitAddressData = executeMultiCalls?.logs[0]?.topics[1];
   const formattedSplitterAddress = '0x' + splitAddressData?.slice(26, 66);
@@ -479,9 +505,11 @@ export const getOWRTranches = async ({
 export const multicall = async (
   calls: Call[],
   signer: SignerType,
-  multicallAddress: string,
+  chainId: number,
 ): Promise<any> => {
   try {
+    const chainConfig = getChainConfig(chainId);
+    const multicallAddress = chainConfig.MULTICALL_CONTRACT.address;
     const multiCallContractInstance = new Contract(
       multicallAddress,
       MultiCallContract.abi,
@@ -555,3 +583,330 @@ const encodeCreateOWRecipientTxData = (
     parseEther(amountOfPrincipalStake.toString()),
   ]);
 };
+
+// OVM and SplitV2 Helper Functions
+
+// Helper function to format recipients specifically for SplitV2 (returns SplitV2Recipient[])
+export const formatRecipientsForSplitV2 = (
+  splitRecipients: SplitRecipient[] | SplitV2Recipient[],
+): SplitV2Recipient[] => {
+  const { sortedRecipients, getAddress, getPercentAllocation } =
+    formatRecipientsCommon(splitRecipients);
+
+  return sortedRecipients
+    .filter(item => getAddress(item) !== '')
+    .map(item => ({
+      address: getAddress(item),
+      percentAllocation: parseFloat(getPercentAllocation(item).toString()),
+    }));
+};
+
+// Helper function to create SplitV2 parameters
+const createSplitV2Params = (
+  recipients: SplitV2Recipient[],
+  distributorFeePercent: number,
+): {
+  recipients: string[];
+  allocations: number[];
+  totalAllocation: number;
+  distributionIncentive: number;
+} => {
+  const addresses = recipients.map(r => r.address);
+  const allocations = recipients.map(r =>
+    Math.floor(r.percentAllocation * 1e4),
+  ); // Convert to basis points
+  const totalAllocation = allocations.reduce(
+    (sum, allocation) => sum + allocation,
+    0,
+  );
+
+  return {
+    recipients: addresses,
+    allocations,
+    totalAllocation,
+    distributionIncentive: distributorFeePercent,
+  };
+};
+
+export const predictSplitV2Address = async ({
+  splitOwnerAddress,
+  recipients,
+  distributorFeePercent,
+  salt,
+  signer,
+  chainId,
+}: {
+  splitOwnerAddress: string;
+  recipients: SplitV2Recipient[];
+  distributorFeePercent: number;
+  salt: `0x${string}`;
+  signer: SignerType;
+  chainId: number;
+}): Promise<string> => {
+  try {
+    const chainConfig = getChainConfig(chainId);
+    if (!chainConfig?.SPLIT_V2_FACTORY_CONTRACT?.address) {
+      throw new Error(`SplitV2 Factory not configured for chain ${chainId}`);
+    }
+
+    const splitV2FactoryContract = new Contract(
+      chainConfig.SPLIT_V2_FACTORY_CONTRACT.address,
+      splitV2FactoryAbi,
+      signer,
+    );
+
+    const splitParams = createSplitV2Params(recipients, distributorFeePercent);
+
+    const predictedAddress = await splitV2FactoryContract[
+      'predictDeterministicAddress((address[],uint256[],uint256,uint16),address,bytes32)'
+    ](splitParams, splitOwnerAddress, salt);
+
+    return predictedAddress;
+  } catch (error: any) {
+    throw new Error(
+      `Failed to predict SplitV2 address: ${error.message ?? 'SplitV2 contract call failed'}`,
+    );
+  }
+};
+
+export const isSplitV2Deployed = async ({
+  splitOwnerAddress,
+  recipients,
+  distributorFeePercent,
+  salt,
+  signer,
+  chainId,
+}: {
+  splitOwnerAddress: string;
+  recipients: SplitV2Recipient[];
+  distributorFeePercent: number;
+  salt: `0x${string}`;
+  signer: SignerType;
+  chainId: number;
+}): Promise<boolean> => {
+  try {
+    const chainConfig = getChainConfig(chainId);
+    if (!chainConfig?.SPLIT_V2_FACTORY_CONTRACT?.address) {
+      throw new Error(`SplitV2 Factory not configured for chain ${chainId}`);
+    }
+
+    const splitV2FactoryContract = new Contract(
+      chainConfig.SPLIT_V2_FACTORY_CONTRACT.address,
+      splitV2FactoryAbi,
+      signer,
+    );
+
+    const splitParams = createSplitV2Params(recipients, distributorFeePercent);
+
+    const [, exists] = await splitV2FactoryContract.isDeployed(
+      splitParams,
+      splitOwnerAddress,
+      salt,
+    );
+
+    return exists;
+  } catch (error: any) {
+    // If the check fails, assume it's not deployed
+    return false;
+  }
+};
+
+export const deployOVMContract = async ({
+  OVMOwnerAddress,
+  principalRecipient,
+  rewardRecipient,
+  principalThreshold,
+  signer,
+  chainId,
+}: {
+  OVMOwnerAddress: string;
+  principalRecipient: string;
+  rewardRecipient: string;
+  principalThreshold: number;
+  signer: SignerType;
+  chainId: number;
+}): Promise<string> => {
+  try {
+    const chainConfig = getChainConfig(chainId);
+    if (!chainConfig?.OVM_FACTORY_CONTRACT?.address) {
+      throw new Error(`OVM Factory not configured for chain ${chainId}`);
+    }
+
+    const ovmFactoryContract = new Contract(
+      chainConfig.OVM_FACTORY_CONTRACT.address,
+      OVMFactoryContract.abi,
+      signer,
+    );
+
+    const tx = await ovmFactoryContract.createObolValidatorManager(
+      OVMOwnerAddress,
+      principalRecipient,
+      rewardRecipient,
+      principalThreshold,
+    );
+
+    const receipt = await tx.wait();
+
+    // Extract OVM address from logs
+    const ovmAddressLog = receipt?.logs[1]?.topics[1];
+    if (!ovmAddressLog) {
+      throw new Error('Failed to extract OVM address from transaction logs');
+    }
+
+    const ovmAddress = '0x' + ovmAddressLog.slice(26, 66);
+    return ovmAddress;
+  } catch (error: any) {
+    throw new Error(
+      `Failed to deploy OVM contract: ${error.message ?? 'OVM deployment failed'}`,
+    );
+  }
+};
+
+export const deployOVMAndSplitV2 = async ({
+  ovmArgs,
+  rewardRecipients,
+  isRewardsSplitterDeployed,
+  distributorFeePercent,
+  salt,
+  signer,
+  chainId,
+  principalSplitRecipients,
+  isPrincipalSplitDeployed,
+  splitOwnerAddress,
+}: {
+  ovmArgs: OVMArgs;
+  rewardRecipients: SplitV2Recipient[];
+  isRewardsSplitterDeployed?: boolean;
+  distributorFeePercent: number;
+  salt: `0x${string}`;
+  signer: SignerType;
+  chainId: number;
+  principalSplitRecipients?: SplitV2Recipient[];
+  isPrincipalSplitDeployed?: boolean;
+  splitOwnerAddress: string;
+}): Promise<string> => {
+  try {
+    const chainConfig = getChainConfig(chainId);
+    if (!chainConfig?.OVM_FACTORY_CONTRACT?.address) {
+      throw new Error(`OVM Factory not configured for chain ${chainId}`);
+    }
+
+    if (!chainConfig?.SPLIT_V2_FACTORY_CONTRACT?.address) {
+      throw new Error(`SplitV2 Factory not configured for chain ${chainId}`);
+    }
+
+    const executeCalls: Call[] = [];
+
+    if (rewardRecipients && !isRewardsSplitterDeployed) {
+      // Create rewards split call data
+      const splitParams = createSplitV2Params(
+        rewardRecipients,
+        distributorFeePercent,
+      );
+      const rewardsSplitTxData = encodeCreateSplitV2DeterministicTxData(
+        splitParams,
+        splitOwnerAddress,
+        salt,
+      );
+
+      executeCalls.push({
+        target: chainConfig.SPLIT_V2_FACTORY_CONTRACT.address,
+        callData: rewardsSplitTxData,
+      });
+    }
+
+    // Create principal split call data if needed (for total split scenario)
+    if (principalSplitRecipients && !isPrincipalSplitDeployed) {
+      const principalSplitParams = createSplitV2Params(
+        principalSplitRecipients,
+        distributorFeePercent,
+      );
+      const principalSplitTxData = encodeCreateSplitV2DeterministicTxData(
+        principalSplitParams,
+        splitOwnerAddress,
+        salt,
+      );
+      executeCalls.push({
+        target: chainConfig.SPLIT_V2_FACTORY_CONTRACT.address,
+        callData: principalSplitTxData,
+      });
+    }
+
+    // Create OVM call data
+    const ovmTxData = encodeCreateOVMTxData(
+      ovmArgs.OVMOwnerAddress,
+      ovmArgs.principalRecipient,
+      ovmArgs.rewardRecipient,
+      ovmArgs.principalThreshold,
+    );
+
+    executeCalls.push({
+      target: chainConfig.OVM_FACTORY_CONTRACT.address,
+      callData: ovmTxData,
+    });
+
+    // Execute multicall
+    const executeMultiCalls = await multicall(executeCalls, signer, chainId);
+
+    // Extract addresses from events
+    let ovmAddress: string | undefined;
+    const logsCount = executeMultiCalls?.logs?.length || 0;
+
+    if (logsCount === 2) {
+      ovmAddress = '0x' + executeMultiCalls?.logs[1]?.topics[1]?.slice(26, 66);
+    } else if (logsCount === 5) {
+      ovmAddress = '0x' + executeMultiCalls?.logs[4]?.topics[1]?.slice(26, 66);
+    } else {
+      ovmAddress = '0x' + executeMultiCalls?.logs[7]?.topics[1]?.slice(26, 66);
+    }
+    if (!ovmAddress) {
+      throw new Error(
+        'Failed to extract contract addresses from multicall events',
+      );
+    }
+
+    return ovmAddress;
+  } catch (error: any) {
+    throw new Error(
+      `Failed to deploy OVM and SplitV2: ${error.message ?? 'Deployment failed'}`,
+    );
+  }
+};
+
+const encodeCreateOVMTxData = (
+  OVMOwnerAddress: string,
+  principalRecipient: string,
+  rewardRecipient: string,
+  principalThreshold: number,
+): string => {
+  return ovmFactoryContractInterface.encodeFunctionData(
+    'createObolValidatorManager',
+    [OVMOwnerAddress, principalRecipient, rewardRecipient, principalThreshold],
+  );
+};
+
+const encodeCreateSplitV2DeterministicTxData = (
+  splitParams: {
+    recipients: string[];
+    allocations: number[];
+    totalAllocation: number;
+    distributionIncentive: number;
+  },
+  splitOwnerAddress: string,
+  salt: `0x${string}`,
+): string => {
+  // creatorAddress can be kept as default https://docs.splits.org/sdk/splits-v2#createsplit
+  return splitV2FactoryInterface.encodeFunctionData(
+    'createSplitDeterministic',
+    [splitParams, splitOwnerAddress, ZeroAddress, salt],
+  );
+};
+
+// Helper function to safely get chain configuration
+const getChainConfig = (chainId: number): ChainConfig => {
+  const config = CHAIN_CONFIGURATION[chainId];
+  if (!config) {
+    throw new Error(`Chain configuration not found for chain ID ${chainId}`);
+  }
+  return config;
+};