@obolnetwork/obol-sdk 1.0.16 → 2.0.0

package/src/verification/sszTypes.ts

@@ -1,79 +1,88 @@
-import { ByteListType, ByteVectorType, ContainerType, UintNumberType } from '@chainsafe/ssz'
-import { type UintNumberByteLen } from '@chainsafe/ssz/lib/type/uint'
+import {
+  ByteListType,
+  ByteVectorType,
+  ContainerType,
+  UintNumberType,
+} from '@chainsafe/ssz';
+import { type UintNumberByteLen } from '@chainsafe/ssz/lib/type/uint';
 
 export const operatorAddressWrapperType = new ContainerType({
-    address: new ByteVectorType(20),
-})
+  address: new ByteVectorType(20),
+});
 
 export const creatorAddressWrapperType = new ContainerType({
-    address: new ByteVectorType(20),
-})
+  address: new ByteVectorType(20),
+});
 
 export const operatorContainerType = new ContainerType({
-    address: new ByteVectorType(20),
-    enr: new ByteListType(1024), // This needs to be dynamic, since ENRs do not have a fixed length.
-    config_signature: new ByteVectorType(65),
-    enr_signature: new ByteVectorType(65),
-})
+  address: new ByteVectorType(20),
+  enr: new ByteListType(1024), // This needs to be dynamic, since ENRs do not have a fixed length.
+  config_signature: new ByteVectorType(65),
+  enr_signature: new ByteVectorType(65),
+});
 
 export const creatorContainerType = new ContainerType({
-    address: new ByteVectorType(20),
-    config_signature: new ByteVectorType(65),
-})
+  address: new ByteVectorType(20),
+  config_signature: new ByteVectorType(65),
+});
 
 export const validatorsContainerType = new ContainerType({
-    fee_recipient_address: new ByteVectorType(20),
-    withdrawal_address: new ByteVectorType(20),
-})
+  fee_recipient_address: new ByteVectorType(20),
+  withdrawal_address: new ByteVectorType(20),
+});
 
-export const newCreatorContainerType = (configOnly: boolean): ContainerType<any> => {
-    return configOnly ? creatorAddressWrapperType : creatorContainerType
-}
+export const newCreatorContainerType = (
+  configOnly: boolean,
+): ContainerType<any> => {
+  return configOnly ? creatorAddressWrapperType : creatorContainerType;
+};
 
-export const newOperatorContainerType = (configOnly: boolean): ContainerType<any> => {
-    return configOnly ? operatorAddressWrapperType : operatorContainerType
-}
+export const newOperatorContainerType = (
+  configOnly: boolean,
+): ContainerType<any> => {
+  return configOnly ? operatorAddressWrapperType : operatorContainerType;
+};
 
 // Lock
 export const depositDataContainer = new ContainerType({
-    pubkey: new ByteVectorType(48),
-    withdrawal_credentials: new ByteVectorType(32),
-    amount: new UintNumberType(8 as UintNumberByteLen),
-    signature: new ByteVectorType(96),
-})
+  pubkey: new ByteVectorType(48),
+  withdrawal_credentials: new ByteVectorType(32),
+  amount: new UintNumberType(8 as UintNumberByteLen),
+  signature: new ByteVectorType(96),
+});
 
 export const builderRegistrationMessageContainer = new ContainerType({
-    fee_recipient: new ByteVectorType(20),
-    gas_limit: new UintNumberType(8 as UintNumberByteLen),
-    timestamp: new UintNumberType(8 as UintNumberByteLen),
-    pubkey: new ByteVectorType(48),
-})
+  fee_recipient: new ByteVectorType(20),
+  gas_limit: new UintNumberType(8 as UintNumberByteLen),
+  timestamp: new UintNumberType(8 as UintNumberByteLen),
+  pubkey: new ByteVectorType(48),
+});
 
 export const builderRegistrationContainer = new ContainerType({
-    message: builderRegistrationMessageContainer,
-    signature: new ByteVectorType(96),
-})
+  message: builderRegistrationMessageContainer,
+  signature: new ByteVectorType(96),
+});
 
 export const builderRegistrationMessageType = new ContainerType({
-    fee_recipient: new ByteVectorType(20),
-    gas_limit: new UintNumberType(8 as UintNumberByteLen),
-    timestamp: new UintNumberType(8 as UintNumberByteLen),
-    pubkey: new ByteVectorType(48),
-})
+  fee_recipient: new ByteVectorType(20),
+  gas_limit: new UintNumberType(8 as UintNumberByteLen),
+  timestamp: new UintNumberType(8 as UintNumberByteLen),
+  pubkey: new ByteVectorType(48),
+});
 
 // For domain computation that is used in deposit data and builder registration verification for dv
 export const forkDataType = new ContainerType({
-    currentVersion: new ByteVectorType(4),
-    genesisValidatorsRoot: new ByteVectorType(32),
-})
+  currentVersion: new ByteVectorType(4),
+  genesisValidatorsRoot: new ByteVectorType(32),
+});
 
 export const depositMessageType = new ContainerType({
-    pubkey: new ByteVectorType(48),
-    withdrawal_credentials: new ByteVectorType(32),
-    amount: new UintNumberType(8),
-})
+  pubkey: new ByteVectorType(48),
+  withdrawal_credentials: new ByteVectorType(32),
+  amount: new UintNumberType(8),
+});
 
 export const signingRootType = new ContainerType({
-    objectRoot: new ByteVectorType(32),
-    domain: new ByteVectorType(32),
-})
+  objectRoot: new ByteVectorType(32),
+  domain: new ByteVectorType(32),
+});

package/src/verification/termsAndConditions.ts

@@ -1,30 +1,32 @@
-import pdf from 'pdf-parse'
-import { ByteListType, ContainerType } from '@chainsafe/ssz'
-import { TERMS_AND_CONDITIONS_URL } from '../constants'
-import { strToUint8Array } from '../utils'
+import pdf from 'pdf-parse';
+import { ByteListType, ContainerType } from '@chainsafe/ssz';
+import { TERMS_AND_CONDITIONS_URL } from '../constants';
+import { strToUint8Array } from '../utils';
 
 export const hashTermsAndConditions = async (): Promise<string | null> => {
   try {
     // read the pdf
-    const response = await fetch(TERMS_AND_CONDITIONS_URL)
-    const pdfBuffarrayBuffer = await response.arrayBuffer()
-    const pdfBuffer = Buffer.from(pdfBuffarrayBuffer)
-    const data = await pdf(pdfBuffer)
+    const response = await fetch(TERMS_AND_CONDITIONS_URL);
+    const pdfBuffarrayBuffer = await response.arrayBuffer();
+    const pdfBuffer = Buffer.from(pdfBuffarrayBuffer);
+    const data = await pdf(pdfBuffer);
 
     // ssz hash
     const termsType = new ContainerType({
       terms_and_conditions_hash: new ByteListType(Number.MAX_SAFE_INTEGER),
-    })
+    });
 
-    const termsHasVal = termsType.defaultValue()
+    const termsHasVal = termsType.defaultValue();
 
-    termsHasVal.terms_and_conditions_hash = strToUint8Array(data?.text)
+    termsHasVal.terms_and_conditions_hash = strToUint8Array(
+      data?.text.replace(/[^a-zA-Z0-9]/g, ''),
+    );
 
     return (
       '0x' +
       Buffer.from(termsType.hashTreeRoot(termsHasVal).buffer).toString('hex')
-    )
+    );
   } catch (err) {
-    return null
+    return null;
   }
-}
+};

package/src/verification/v1.6.0.ts

@@ -1,32 +1,56 @@
-import { type UintNumberByteLen, UintNumberType } from '@chainsafe/ssz/lib/type/uint'
-import { strToUint8Array } from '../utils'
-import { type creatorAddressWrapperType, type creatorContainerType, newCreatorContainerType, newOperatorContainerType, type operatorAddressWrapperType, type operatorContainerType, validatorsContainerType } from './sszTypes'
-import { ByteListType, ByteVectorType, ContainerType, ListCompositeType, fromHexString } from '@chainsafe/ssz'
-import { type ValueOfFields } from '@chainsafe/ssz/lib/view/container'
-import { type ClusterDefinition, type ClusterLock, type DepositData } from '../types'
-import { verifyDepositData } from './common'
-import { aggregateSignatures, verifyAggregate, verifyMultiple } from '@chainsafe/bls'
-
-// cluster defintion
+import {
+  type UintNumberByteLen,
+  UintNumberType,
+} from '@chainsafe/ssz/lib/type/uint';
+import { strToUint8Array } from '../utils';
+import {
+  type creatorAddressWrapperType,
+  type creatorContainerType,
+  newCreatorContainerType,
+  newOperatorContainerType,
+  type operatorAddressWrapperType,
+  type operatorContainerType,
+  validatorsContainerType,
+} from './sszTypes';
+import {
+  ByteListType,
+  ByteVectorType,
+  ContainerType,
+  ListCompositeType,
+  fromHexString,
+} from '@chainsafe/ssz';
+import { type ValueOfFields } from '@chainsafe/ssz/lib/view/container';
+import {
+  type ClusterDefinition,
+  type ClusterLock,
+  type DepositData,
+} from '../types';
+import { verifyDepositData } from './common';
+import {
+  aggregateSignatures,
+  verifyAggregate,
+  verifyMultiple,
+} from '@chainsafe/bls';
+
+// cluster definition
 type DefinitionFieldsV1X6 = {
-    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>
-    config_hash?: ByteVectorType
-}
-
-type DefinitionContainerTypeV1X6 =
-    ContainerType<DefinitionFieldsV1X6>
+  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>;
+  config_hash?: ByteVectorType;
+};
+
+type DefinitionContainerTypeV1X6 = ContainerType<DefinitionFieldsV1X6>;
 
 /**
  * Returns the containerized cluster definition
@@ -34,193 +58,199 @@ type DefinitionContainerTypeV1X6 =
  * @returns SSZ Containerized type of cluster input
  */
 export const clusterDefinitionContainerTypeV1X6 = (
-    configOnly: boolean,
+  configOnly: boolean,
 ): DefinitionContainerTypeV1X6 => {
-    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),
-    }
+  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),
+  };
 
-    if (!configOnly) {
-        returnedContainerType = {
-            ...returnedContainerType,
-            config_hash: new ByteVectorType(32),
-        }
-    }
+  if (!configOnly) {
+    returnedContainerType = {
+      ...returnedContainerType,
+      config_hash: new ByteVectorType(32),
+    };
+  }
 
-    return new ContainerType(returnedContainerType)
-}
+  return new ContainerType(returnedContainerType);
+};
 
 export const hashClusterDefinitionV1X6 = (
-    cluster: ClusterDefinition,
-    configOnly: boolean,
+  cluster: ClusterDefinition,
+  configOnly: boolean,
 ): ValueOfFields<DefinitionFieldsV1X6> => {
-    const definitionType = clusterDefinitionContainerTypeV1X6(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 (!configOnly) {
-        val.config_hash = fromHexString(cluster.config_hash)
-    }
-    return val
-}
+  const definitionType = clusterDefinitionContainerTypeV1X6(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 (!configOnly) {
+    val.config_hash = fromHexString(cluster.config_hash);
+  }
+  return val;
+};
 
 // cluster lock
 
 const dvContainerTypeV1X6 = new ContainerType({
-    distributed_public_key: new ByteVectorType(48),
-    public_shares: new ListCompositeType(new ByteVectorType(48), 256),
-    pubkey: new ByteVectorType(48),
-    withdrawal_credentials: new ByteVectorType(32),
-    amount: new UintNumberType(8 as UintNumberByteLen),
-    signature: new ByteVectorType(96),
-})
+  distributed_public_key: new ByteVectorType(48),
+  public_shares: new ListCompositeType(new ByteVectorType(48), 256),
+  pubkey: new ByteVectorType(48),
+  withdrawal_credentials: new ByteVectorType(32),
+  amount: new UintNumberType(8 as UintNumberByteLen),
+  signature: new ByteVectorType(96),
+});
 
 type LockContainerTypeV1X6 = ContainerType<{
-    cluster_definition: DefinitionContainerTypeV1X6
-    distributed_validators: ListCompositeType<typeof dvContainerTypeV1X6>
-}>
+  cluster_definition: DefinitionContainerTypeV1X6;
+  distributed_validators: ListCompositeType<typeof dvContainerTypeV1X6>;
+}>;
 
 /**
  * @returns SSZ Containerized type of cluster lock
  */
 const clusterLockContainerTypeV1X6 = (): LockContainerTypeV1X6 => {
-    return new ContainerType({
-        cluster_definition: clusterDefinitionContainerTypeV1X6(false),
-        distributed_validators: new ListCompositeType(dvContainerTypeV1X6, 65536),
-    })
-}
+  return new ContainerType({
+    cluster_definition: clusterDefinitionContainerTypeV1X6(false),
+    distributed_validators: new ListCompositeType(dvContainerTypeV1X6, 65536),
+  });
+};
 
 /**
  * @param cluster The published cluster lock
  * @returns The lock hash in of the corresponding cluster
  */
 export const hashClusterLockV1X6 = (cluster: ClusterLock): string => {
-    const lockType = clusterLockContainerTypeV1X6()
+  const lockType = clusterLockContainerTypeV1X6();
 
-    const val = lockType.defaultValue()
+  const val = lockType.defaultValue();
 
-    // Check if we can replace with definition_hash
-    val.cluster_definition = hashClusterDefinitionV1X6(
-        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),
-            ),
-            pubkey: fromHexString(dValidator.deposit_data?.pubkey as string),
-            withdrawal_credentials: fromHexString(
-                dValidator.deposit_data?.withdrawal_credentials as string,
-            ),
-            amount: parseInt(dValidator.deposit_data?.amount as string),
-            signature: fromHexString(dValidator.deposit_data?.signature as string),
-        }
-    })
-
-    return '0x' + Buffer.from(lockType.hashTreeRoot(val).buffer).toString('hex')
-}
+  // Check if we can replace with definition_hash
+  val.cluster_definition = hashClusterDefinitionV1X6(
+    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),
+        ),
+        pubkey: fromHexString(dValidator.deposit_data?.pubkey as string),
+        withdrawal_credentials: fromHexString(
+          dValidator.deposit_data?.withdrawal_credentials as string,
+        ),
+        amount: parseInt(dValidator.deposit_data?.amount as string),
+        signature: fromHexString(dValidator.deposit_data?.signature as string),
+      };
+    },
+  );
+
+  return '0x' + Buffer.from(lockType.hashTreeRoot(val).buffer).toString('hex');
+};
 
 // DV verification
 export const verifyDVV1X6 = (clusterLock: ClusterLock): boolean => {
-    const validators = clusterLock.distributed_validators
-    const pubShares = []
-    const pubKeys = []
-    const builderRegistrationAndDepositDataMessages = []
-    const blsSignatures = []
-
-    for (let i = 0; i < validators.length; i++) {
-        const validator = validators[i]
-        const validatorPublicShares = validator.public_shares
-        const distributedPublicKey = validator.distributed_public_key
-
-        // Needed in signature_aggregate verification
-        for (const element of validatorPublicShares) {
-            pubShares.push(fromHexString(element))
-        }
-
-        const { isValidDepositData, depositDataMsg } = verifyDepositData(
-            distributedPublicKey,
-            validator.deposit_data as Partial<DepositData>,
-            clusterLock.cluster_definition.validators[i].withdrawal_address,
-            clusterLock.cluster_definition.fork_version
-        )
-
-        if (
-            !isValidDepositData
-        ) {
-            return false
-        }
-
-        pubKeys.push(fromHexString(validator.distributed_public_key))
-        builderRegistrationAndDepositDataMessages.push(depositDataMsg)
-        blsSignatures.push(fromHexString(validator.deposit_data?.signature as string))
-    }
+  const validators = clusterLock.distributed_validators;
+  const pubShares = [];
+  const pubKeys = [];
+  const builderRegistrationAndDepositDataMessages = [];
+  const blsSignatures = [];
 
-    const aggregateBLSSignature = aggregateSignatures(blsSignatures)
+  for (let i = 0; i < validators.length; i++) {
+    const validator = validators[i];
+    const validatorPublicShares = validator.public_shares;
+    const distributedPublicKey = validator.distributed_public_key;
 
-    if (
-        !verifyMultiple(
-            pubKeys,
-            builderRegistrationAndDepositDataMessages,
-            aggregateBLSSignature,
-        )
-    ) {
-        return false
+    // Needed in signature_aggregate verification
+    for (const element of validatorPublicShares) {
+      pubShares.push(fromHexString(element));
     }
 
-    if (
-        !verifyAggregate(
-            pubShares,
-            fromHexString(clusterLock.lock_hash),
-            fromHexString(clusterLock.signature_aggregate),
-        )
-    ) {
-        return false
+    const { isValidDepositData, depositDataMsg } = verifyDepositData(
+      distributedPublicKey,
+      validator.deposit_data as Partial<DepositData>,
+      clusterLock.cluster_definition.validators[i].withdrawal_address,
+      clusterLock.cluster_definition.fork_version,
+    );
+
+    if (!isValidDepositData) {
+      return false;
     }
 
-    return true
-}
+    pubKeys.push(fromHexString(validator.distributed_public_key));
+    builderRegistrationAndDepositDataMessages.push(depositDataMsg);
+    blsSignatures.push(
+      fromHexString(validator.deposit_data?.signature as string),
+    );
+  }
+
+  const aggregateBLSSignature = aggregateSignatures(blsSignatures);
+
+  if (
+    !verifyMultiple(
+      pubKeys,
+      builderRegistrationAndDepositDataMessages,
+      aggregateBLSSignature,
+    )
+  ) {
+    return false;
+  }
+
+  if (
+    !verifyAggregate(
+      pubShares,
+      fromHexString(clusterLock.lock_hash),
+      fromHexString(clusterLock.signature_aggregate),
+    )
+  ) {
+    return false;
+  }
+
+  return true;
+};