@obolnetwork/obol-sdk 2.2.1 → 2.2.3

package/dist/types/test/fixtures.d.ts

@@ -263,3 +263,56 @@ export declare const clusterLockWithSafe: {
     lock_hash: string;
     node_signatures: string[];
 };
+export declare const clusterLockV1X10: {
+    cluster_definition: {
+        name: string;
+        creator: {
+            address: string;
+            config_signature: string;
+        };
+        operators: {
+            address: string;
+            enr: string;
+            config_signature: string;
+            enr_signature: string;
+        }[];
+        uuid: string;
+        version: string;
+        timestamp: string;
+        num_validators: number;
+        threshold: number;
+        validators: {
+            fee_recipient_address: string;
+            withdrawal_address: string;
+        }[];
+        dkg_algorithm: string;
+        fork_version: string;
+        deposit_amounts: null;
+        consensus_protocol: string;
+        target_gas_limit: number;
+        config_hash: string;
+        definition_hash: string;
+    };
+    distributed_validators: {
+        distributed_public_key: string;
+        public_shares: string[];
+        builder_registration: {
+            message: {
+                fee_recipient: string;
+                gas_limit: number;
+                timestamp: number;
+                pubkey: string;
+            };
+            signature: string;
+        };
+        partial_deposit_data: {
+            pubkey: string;
+            withdrawal_credentials: string;
+            amount: string;
+            signature: string;
+        }[];
+    }[];
+    signature_aggregate: string;
+    lock_hash: string;
+    node_signatures: string[];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obolnetwork/obol-sdk",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "description": "A package for creating Distributed Validators using the Obol API.",
   "bugs": {
     "url": "https://github.com/obolnetwork/obol-sdk/issues"

package/src/index.ts

@@ -50,6 +50,7 @@ import { isContractAvailable } from './utils.js';
 export * from './types.js';
 export * from './services.js';
 export * from './verification/signature-validator.js';
+export * from './verification/common.js';
 
 /**
  * Obol sdk Client can be used for creating, managing and activating distributed validators.

package/src/types.ts

@@ -138,6 +138,12 @@ export interface ClusterDefinition extends ClusterPayload {
 
   /** The hash of the cluster definition. */
   definition_hash?: string;
+
+  /** The consensus protocol e.g qbft. */
+  consensus_protocol?: string;
+
+  /** The target gas limit where default is 30M. */
+  target_gas_limit?: number;
 }
 
 /**

package/src/utils.ts

@@ -78,7 +78,7 @@ export const isContractAvailable = async (
 
 export const getProvider = (chainId: number): ethers.Provider => {
   const rpcUrl = PROVIDER_MAP[chainId];
-  if (!rpcUrl) {
+  if (!rpcUrl || rpcUrl === 'undefined') {
     throw new Error(`No provider configured for ${FORK_NAMES[chainId]}`);
   }
   return new ethers.JsonRpcProvider(rpcUrl);

package/src/verification/common.ts

@@ -47,6 +47,12 @@ import {
   verifyDVV1X8,
 } from './v1.8.0.js';
 import { validateAddressSignature } from './signature-validator.js';
+import {
+  clusterDefinitionContainerTypeV1X10,
+  hashClusterDefinitionV1X10,
+  hashClusterLockV1X10,
+  verifyDVV1X10,
+} from './v1.10.0.js';
 
 // cluster-definition hash
 
@@ -88,6 +94,15 @@ export const clusterConfigOrDefinitionHash = (
     );
   }
 
+  if (semver.eq(cluster.version, 'v1.10.0')) {
+    definitionType = clusterDefinitionContainerTypeV1X10(configOnly);
+    val = hashClusterDefinitionV1X10(cluster, configOnly);
+    const x =
+      '0x' +
+      Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex');
+    return x;
+  }
+
   throw new Error('unsupported version');
 };
 
@@ -123,6 +138,22 @@ export const clusterLockHash = (clusterLock: ClusterLock): string => {
     return hashClusterLockV1X8(clusterLock);
   }
 
+  if (semver.eq(clusterLock.cluster_definition.version, 'v1.10.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 hashClusterLockV1X10(clusterLock);
+  }
+
   // other versions
   throw new Error('unsupported version');
 };
@@ -329,11 +360,16 @@ export const verifyDepositData = (
     forkVersion,
   );
   const eth1AddressWithdrawalPrefix = '0x01';
+  const compoundingWithdrawalPrefix = '0x02';
   if (
     eth1AddressWithdrawalPrefix +
       '0'.repeat(22) +
       withdrawalAddress.toLowerCase().slice(2) !==
-    depositData.withdrawal_credentials
+      depositData.withdrawal_credentials &&
+    compoundingWithdrawalPrefix +
+      '0'.repeat(22) +
+      withdrawalAddress.toLowerCase().slice(2) !==
+      depositData.withdrawal_credentials
   ) {
     return { isValidDepositData: false, depositDataMsg: new Uint8Array(0) };
   }
@@ -444,6 +480,10 @@ const verifyLockData = async (clusterLock: ClusterLock): Promise<boolean> => {
   if (semver.eq(clusterLock.cluster_definition.version, 'v1.8.0')) {
     return verifyDVV1X8(clusterLock);
   }
+
+  if (semver.eq(clusterLock.cluster_definition.version, 'v1.10.0')) {
+    return verifyDVV1X10(clusterLock);
+  }
   return false;
 };
 

package/src/verification/v1.10.0.ts

@@ -0,0 +1,238 @@
+import {
+  type UintNumberByteLen,
+  UintNumberType,
+} from '@chainsafe/ssz/lib/type/uint';
+import { strToUint8Array } from '../utils';
+import {
+  builderRegistrationContainer,
+  type creatorAddressWrapperType,
+  type creatorContainerType,
+  depositDataContainer,
+  newCreatorContainerType,
+  newOperatorContainerType,
+  type operatorAddressWrapperType,
+  type operatorContainerType,
+  validatorsContainerType,
+} from './sszTypes';
+import {
+  ByteListType,
+  ByteVectorType,
+  ContainerType,
+  ListBasicType,
+  ListCompositeType,
+  fromHexString,
+} from '@chainsafe/ssz';
+import { type ValueOfFields } from '@chainsafe/ssz/lib/view/container';
+import {
+  type ClusterDefinition,
+  type ClusterLock,
+  type DepositData,
+} from '../types';
+import { verifyDVV1X8 } from './v1.8.0';
+
+// cluster definition
+type DefinitionFieldsV1X10 = {
+  uuid: ByteListType;
+  name: ByteListType;
+  version: ByteListType;
+  timestamp: ByteListType;
+  num_validators: UintNumberType;
+  threshold: UintNumberType;
+  dkg_algorithm: ByteListType;
+  fork_version: ByteVectorType;
+  operators: ListCompositeType<
+    typeof operatorContainerType | typeof operatorAddressWrapperType
+  >;
+  creator: typeof creatorContainerType | typeof creatorAddressWrapperType;
+  validators: ListCompositeType<typeof validatorsContainerType>;
+  deposit_amounts: ListBasicType<UintNumberType>;
+  consensus_protocol: ByteListType;
+  target_gas_limit: UintNumberType;
+  config_hash?: ByteVectorType;
+};
+
+type DefinitionContainerTypeV1X10 = ContainerType<DefinitionFieldsV1X10>;
+
+/**
+ * Returns the containerized cluster definition
+ * @param cluster ClusterDefinition to calculate the type from
+ * @returns SSZ Containerized type of cluster input
+ */
+export const clusterDefinitionContainerTypeV1X10 = (
+  configOnly: boolean,
+): DefinitionContainerTypeV1X10 => {
+  let returnedContainerType: any = {
+    uuid: new ByteListType(64),
+    name: new ByteListType(256),
+    version: new ByteListType(16),
+    timestamp: new ByteListType(32),
+    num_validators: new UintNumberType(8 as UintNumberByteLen),
+    threshold: new UintNumberType(8 as UintNumberByteLen),
+    dkg_algorithm: new ByteListType(32),
+    fork_version: new ByteVectorType(4),
+    operators: new ListCompositeType(newOperatorContainerType(configOnly), 256),
+    creator: newCreatorContainerType(configOnly),
+    validators: new ListCompositeType(validatorsContainerType, 65536),
+    deposit_amounts: new ListBasicType(
+      new UintNumberType(8 as UintNumberByteLen),
+      256,
+    ),
+    consensus_protocol: new ByteListType(256),
+    target_gas_limit: new UintNumberType(8 as UintNumberByteLen),
+  };
+
+  if (!configOnly) {
+    returnedContainerType = {
+      ...returnedContainerType,
+      config_hash: new ByteVectorType(32),
+    };
+  }
+
+  return new ContainerType(returnedContainerType);
+};
+
+export const hashClusterDefinitionV1X10 = (
+  cluster: ClusterDefinition,
+  configOnly: boolean,
+): ValueOfFields<DefinitionFieldsV1X10> => {
+  const definitionType = clusterDefinitionContainerTypeV1X10(configOnly);
+
+  const val = definitionType.defaultValue();
+
+  // order should be same as charon https://github.com/ObolNetwork/charon/blob/main/cluster/ssz.go#L276
+  val.uuid = strToUint8Array(cluster.uuid);
+  val.name = strToUint8Array(cluster.name);
+  val.version = strToUint8Array(cluster.version);
+  val.timestamp = strToUint8Array(cluster.timestamp);
+  val.num_validators = cluster.num_validators;
+  val.threshold = cluster.threshold;
+  val.dkg_algorithm = strToUint8Array(cluster.dkg_algorithm);
+  val.fork_version = fromHexString(cluster.fork_version);
+  val.operators = cluster.operators.map(operator => {
+    return configOnly
+      ? { address: fromHexString(operator.address) }
+      : {
+          address: fromHexString(operator.address),
+          enr: strToUint8Array(operator.enr as string),
+          config_signature: fromHexString(operator.config_signature as string),
+          enr_signature: fromHexString(operator.enr_signature as string),
+        };
+  });
+  val.creator = configOnly
+    ? { address: fromHexString(cluster.creator.address) }
+    : {
+        address: fromHexString(cluster.creator.address),
+        config_signature: fromHexString(
+          cluster.creator.config_signature as string,
+        ),
+      };
+  val.validators = cluster.validators.map(validator => {
+    return {
+      fee_recipient_address: fromHexString(validator.fee_recipient_address),
+      withdrawal_address: fromHexString(validator.withdrawal_address),
+    };
+  });
+  if (cluster.deposit_amounts) {
+    val.deposit_amounts = cluster.deposit_amounts.map((amount: string) => {
+      return parseInt(amount);
+    });
+  }
+  if (cluster.consensus_protocol) {
+    val.consensus_protocol = strToUint8Array(cluster.consensus_protocol);
+  }
+  if (cluster.target_gas_limit) {
+    val.target_gas_limit = cluster.target_gas_limit;
+  }
+
+  if (!configOnly) {
+    val.config_hash = fromHexString(cluster.config_hash);
+  }
+  return val;
+};
+
+// cluster lock
+
+const dvContainerTypeV1X10 = new ContainerType({
+  distributed_public_key: new ByteVectorType(48),
+  public_shares: new ListCompositeType(new ByteVectorType(48), 256),
+  partial_deposit_data: new ListCompositeType(depositDataContainer, 256),
+  builder_registration: builderRegistrationContainer,
+});
+
+type LockContainerTypeV1X10 = ContainerType<{
+  cluster_definition: DefinitionContainerTypeV1X10;
+  distributed_validators: ListCompositeType<typeof dvContainerTypeV1X10>;
+}>;
+
+/**
+ * @returns SSZ Containerized type of cluster lock
+ */
+const clusterLockContainerTypeV1X10 = (): LockContainerTypeV1X10 => {
+  return new ContainerType({
+    cluster_definition: clusterDefinitionContainerTypeV1X10(false),
+    distributed_validators: new ListCompositeType(dvContainerTypeV1X10, 65536),
+  });
+};
+
+/**
+ * @param cluster The published cluster lock
+ * @returns The lock hash in of the corresponding cluster
+ */
+export const hashClusterLockV1X10 = (cluster: ClusterLock): string => {
+  const lockType = clusterLockContainerTypeV1X10();
+
+  const val = lockType.defaultValue();
+
+  // Check if we can replace with definition_hash
+  val.cluster_definition = hashClusterDefinitionV1X10(
+    cluster.cluster_definition,
+    false,
+  );
+  val.distributed_validators = cluster.distributed_validators.map(
+    dValidator => {
+      return {
+        distributed_public_key: fromHexString(
+          dValidator.distributed_public_key,
+        ),
+        public_shares: dValidator.public_shares.map(publicShare =>
+          fromHexString(publicShare),
+        ),
+        // should be fixed
+        partial_deposit_data: (
+          dValidator.partial_deposit_data as DepositData[]
+        ).map(depositData => {
+          return {
+            pubkey: fromHexString(depositData.pubkey),
+            withdrawal_credentials: fromHexString(
+              depositData.withdrawal_credentials,
+            ),
+            amount: parseInt(depositData.amount),
+            signature: fromHexString(depositData.signature),
+          };
+        }),
+        builder_registration: {
+          message: {
+            fee_recipient: fromHexString(
+              dValidator.builder_registration?.message.fee_recipient as string,
+            ),
+            gas_limit: dValidator.builder_registration?.message
+              .gas_limit as number,
+            timestamp: dValidator.builder_registration?.message
+              .timestamp as number,
+            pubkey: fromHexString(
+              dValidator.builder_registration?.message.pubkey as string,
+            ),
+          },
+          signature: fromHexString(
+            dValidator.builder_registration?.signature as string,
+          ),
+        },
+      };
+    },
+  );
+
+  return '0x' + Buffer.from(lockType.hashTreeRoot(val).buffer).toString('hex');
+};
+
+// DV verification
+export const verifyDVV1X10 = verifyDVV1X8;