@obolnetwork/obol-sdk 1.0.8 → 1.0.11

package/dist/{fixtures.d.ts → types/test/fixtures.d.ts}

@@ -1,62 +1,61 @@
-export declare const clusterLockV1X7: {
-    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;
-        config_hash: string;
-        definition_hash: string;
-    };
-    distributed_validators: {
-        distributed_public_key: string;
-        public_shares: string[];
-        deposit_data: {
-            pubkey: string;
-            withdrawal_credentials: string;
-            amount: string;
-            signature: string;
-            deposit_data_root: string;
-        };
-        builder_registration: {
-            message: {
-                fee_recipient: string;
-                gas_limit: number;
-                timestamp: number;
-                pubkey: string;
-            };
-            signature: string;
-        };
-    }[];
-    signature_aggregate: string;
-    lock_hash: string;
-    node_signatures: string[];
-};
-export declare const clusterConfig: {
-    name: string;
-    operators: {
-        address: string;
-    }[];
-    validators: {
-        fee_recipient_address: string;
-        withdrawal_address: string;
-    }[];
-};
-//# sourceMappingURL=fixtures.d.ts.map
+export declare const clusterLockV1X7: {
+    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;
+        config_hash: string;
+        definition_hash: string;
+    };
+    distributed_validators: {
+        distributed_public_key: string;
+        public_shares: string[];
+        deposit_data: {
+            pubkey: string;
+            withdrawal_credentials: string;
+            amount: string;
+            signature: string;
+            deposit_data_root: string;
+        };
+        builder_registration: {
+            message: {
+                fee_recipient: string;
+                gas_limit: number;
+                timestamp: number;
+                pubkey: string;
+            };
+            signature: string;
+        };
+    }[];
+    signature_aggregate: string;
+    lock_hash: string;
+    node_signatures: string[];
+};
+export declare const clusterConfig: {
+    name: string;
+    operators: {
+        address: string;
+    }[];
+    validators: {
+        fee_recipient_address: string;
+        withdrawal_address: string;
+    }[];
+};

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

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,59 +1,93 @@
 {
   "name": "@obolnetwork/obol-sdk",
-  "version": "1.0.8",
+  "version": "1.0.11",
   "description": "A package for creating Distributed Validators using the Obol API.",
-  "main": "dist/index.js",
-  "module": "dist/index.es.js",
-  "typings": "dist/index.d.ts",
+  "bugs": {
+    "url": "https://github.com/obolnetwork/obol-packages/issues"
+  },
+  "homepage": "https://docs.obol.tech/",
   "keywords": [
     "Obol",
     "Distributed Validators",
     "Ethereum"
   ],
-  "files": [
-    "dist"
-  ],
   "scripts": {
-    "build": "rm -rf dist && tsc",
-    "test": "jest --config ./src/jest.config.json",
-    "ds:build": "rollup -c",
+    "compile": "tsc -b ./tsconfig.cjs.json ./tsconfig.esm.json ./tsconfig.types.json",
+    "build:clean": "rm -rf ./dist",
+    "build": "npm-run-all build:clean compile",
+    "test": "jest ./test/methods.test.ts",
     "generate-typedoc": "typedoc",
     "ds:release:major": "npm version $(semver $npm_package_version -i major) && npm publish --tag latest",
     "ds:release:minor": "npm version $(semver $npm_package_version -i minor) && npm publish --tag latest",
-    "ds:release:patch": "npm config list && npm version $(semver $npm_package_version -i patch) && npm publish --tag latest"
+    "ds:release:patch": "npm version $(semver $npm_package_version -i patch) && npm publish --tag latest"
   },
+  "main": "./dist/cjs/src/index.js",
+  "module": "./dist/esm/src/index.js",
+  "typings": "./dist/types/src/index.d.ts",
   "author": "Obol Labs (https://obol.tech)",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/obolnetwork/obol-packages.git"
   },
   "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/obolnetwork/obol-packages/issues"
-  },
-  "homepage": "https://docs.obol.tech/",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "dependencies": {
-    "@chainsafe/ssz": "^0.11.1",
+    "@chainsafe/bls": "6.0.3",
+    "@chainsafe/blst": "^0.2.9",
+    "@chainsafe/discv5": "^0.5.1",
+    "@chainsafe/ssz": "^0.14.0",
+    "@metamask/eth-sig-util": "^7.0.1",
     "ajv": "^8.12.0",
     "cross-fetch": "^3.1.5",
+    "elliptic": "^6.5.4",
     "ethers": "^6.4.0",
+    "nock": "^13.5.3",
     "uuid": "^9.0.0"
   },
   "devDependencies": {
+    "@types/elliptic": "^6.4.18",
     "@types/jest": "^28.1.8",
     "@types/node": "^20.2.5",
     "@types/uuid": "^9.0.1",
-    "fetch-mock": "^9.11.0",
+    "eslint": "^8.6.0",
     "jest": "^28.1.3",
-    "rollup-config": "*",
+    "msw": "^2.2.1",
+    "npm-run-all": "^4.1.5",
     "ts-jest": "^28.0.8",
-    "tsconfig": "*",
     "tsup": "^6.7.0",
-    "typedoc": "^0.24.8",
-    "typescript": "^5.1.3"
+    "typedoc": "^0.25.7",
+    "typedoc-plugin-markdown": "^4.0.0-next.50",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "files": [
+    "package.json",
+    "README.md",
+    "dist",
+    "src"
+  ],
+  "jest": {
+    "transform": {
+      "\\.[jt]sx?$": "ts-jest"
+    },
+    "globals": {
+      "ts-jest": {
+        "useESM": true
+      }
+    },
+    "moduleNameMapper": {
+      "^bn.js$": "<rootDir>/node_modules/bn.js",
+      "^asn1.js$": "<rootDir>/node_modules/asn1.js",
+      "^hash.js$": "<rootDir>/node_modules/hash.js",
+      "(.+)\\.js": "$1"
+    },
+    "extensionsToTreatAsEsm": [
+      ".ts"
+    ]
   }
 }

package/src/ajv.ts

@@ -0,0 +1,11 @@
+import Ajv, { ErrorObject } from 'ajv';
+
+export function validatePayload(data: any, schema: any): ErrorObject[] | undefined | null | boolean {
+    const ajv = new Ajv();
+    const validate = ajv.compile(schema);
+    const isValid = validate(data);
+    if (!isValid) {
+        throw new Error(`Schema compilation errors', ${validate.errors && validate.errors[0].message}`);
+    }
+    return isValid;
+}

package/src/base.ts

@@ -0,0 +1,44 @@
+// src/resources/base.ts
+import { DEFAULT_BASE_URL, DEFAULT_CHAIN_ID, SDK_VERSION } from './constants.js';
+import { FORK_MAPPING } from './types.js';
+
+type Config = {
+  baseUrl?: string;
+  chainId?: FORK_MAPPING;
+};
+
+export abstract class Base {
+  baseUrl: string;
+  chainId: number;
+  fork_version: string;
+
+
+
+  constructor({ baseUrl = DEFAULT_BASE_URL, chainId = DEFAULT_CHAIN_ID }: Config) {
+    this.baseUrl = baseUrl;
+    this.chainId = chainId;
+    this.fork_version = FORK_MAPPING[this.chainId]
+  }
+
+  protected async request<T>(endpoint: string, options?: RequestInit): Promise<T> {
+    const url = `${this.baseUrl}${endpoint}`
+    const config = {
+      ...options,
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': `Obol-SDK/${SDK_VERSION}`,
+        ...options?.headers
+      }
+    };
+
+    try {
+      const response = await fetch(url, config);
+      if (response.ok) {
+          return (await response.json())
+      }
+      throw new Error(response.statusText);
+    } catch (e) {
+      throw e
+    }
+  }
+}

package/src/constants.ts

@@ -0,0 +1,118 @@
+import { TypedMessage } from "@metamask/eth-sig-util";
+
+export const CONFLICT_ERROR_MSG = "Conflict"
+
+export const EIP712_DOMAIN_NAME = "Obol";
+export const EIP712_DOMAIN_VERSION = "1";
+export const CreatorConfigHashSigningTypes = {
+    CreatorConfigHash: [{ name: "creator_config_hash", type: "string" }],
+};
+
+const EIP712Domain = [
+    { name: 'name', type: 'string' },
+    { name: 'version', type: 'string' },
+    { name: 'chainId', type: 'uint256' },
+]
+
+export const Domain = (chainId: number) => {
+    return {
+        name: EIP712_DOMAIN_NAME,
+        version: EIP712_DOMAIN_VERSION,
+        chainId,
+    }
+}
+
+export const CreatorTypedMessage = {
+    EIP712Domain,
+    ...CreatorConfigHashSigningTypes
+};
+
+//A conflict once updateDefinition is merged
+export const EnrSigningTypes = {
+    ENR: [{ name: "enr", type: "string" }],
+};
+
+export const OperatorConfigHashSigningTypes = {
+    OperatorConfigHash: [{ name: "operator_config_hash", type: "string" }],
+};
+
+export const OperatorTypedMessage = {
+    EIP712Domain,
+    ...OperatorConfigHashSigningTypes
+};
+
+export const ENRTypedMessage = {
+    EIP712Domain,
+    ...EnrSigningTypes
+};
+
+export const signCreatorConfigHashPayload = (
+    payload: { creator_config_hash: string },
+    chainId: number,
+): TypedMessage<typeof CreatorTypedMessage> => {
+    return {
+        types: CreatorTypedMessage,
+        primaryType: 'CreatorConfigHash',
+        domain: {
+            name: EIP712_DOMAIN_NAME,
+            version: EIP712_DOMAIN_VERSION,
+            chainId,
+        },
+        message: payload,
+    };
+}
+
+export const signOperatorConfigHashPayload = (
+    payload: { operator_config_hash: string },
+    chainId: number,
+): TypedMessage<typeof OperatorTypedMessage> => {
+    return {
+        types: OperatorTypedMessage,
+        primaryType: 'OperatorConfigHash',
+        domain: {
+            name: EIP712_DOMAIN_NAME,
+            version: EIP712_DOMAIN_VERSION,
+            chainId,
+        },
+        message: payload,
+    };
+}
+
+export const signEnrPayload = (
+    payload: { enr: string },
+    chainId: number,
+): TypedMessage<typeof ENRTypedMessage> => {
+    return {
+        types: ENRTypedMessage,
+        primaryType: 'ENR',
+        domain: {
+            name: EIP712_DOMAIN_NAME,
+            version: EIP712_DOMAIN_VERSION,
+            chainId,
+        },
+        message: payload,
+    };
+}
+
+
+export const dkg_algorithm = "default";
+
+export const config_version = "v1.7.0";
+
+export const SDK_VERSION = "1.0.7";
+
+export const DOMAIN_APPLICATION_BUILDER = '00000001';
+export const DOMAIN_DEPOSIT = '03000000';
+export const GENESIS_VALIDATOR_ROOT =
+    '0000000000000000000000000000000000000000000000000000000000000000';
+
+// Flow used to create defintion
+export enum DefinitionFlow {
+    Group = 'LP-Group',
+    Solo = 'LP-Solo',
+    Charon = 'Charon-Command',
+
+}
+
+export const DEFAULT_BASE_URL = "https://api.obol.tech";
+export const DEFAULT_CHAIN_ID = 1;

package/src/errors.ts

@@ -0,0 +1,11 @@
+export class ConflictError extends Error {
+    name = 'ConflictError'
+  
+    constructor() {
+      super(
+        `This Cluster has been already posted.`,
+      )
+      Object.setPrototypeOf(this, ConflictError.prototype)
+    }
+  }
+  

package/src/hash.ts

@@ -0,0 +1,250 @@
+import {
+  ContainerType,
+  ByteVectorType,
+  UintNumberType,
+  ListCompositeType,
+  ByteListType,
+  fromHexString,
+} from '@chainsafe/ssz';
+import { UintNumberByteLen } from '@chainsafe/ssz/lib/type/uint.js';
+import { ValueOfFields } from '@chainsafe/ssz/lib/view/container.js';
+import { ClusterDefintion, ClusterLock } from './types.js';
+import { strToUint8Array } from './utils.js';
+
+//cluster-definition
+
+/**
+ * @param cluster The cluster configuration or the cluster definition
+ * @param configOnly a boolean to indicate config hash or definition hash
+ * @returns The config hash or the definition hash in of the corresponding cluster
+ */
+export const clusterConfigOrDefinitionHash = (
+  cluster: ClusterDefintion,
+  configOnly: boolean,
+): string => {
+
+  const definitionType = clusterDefinitionContainerType(configOnly);
+  const val = hashClusterDefinition(cluster, configOnly);
+  return (
+    '0x' + Buffer.from(definitionType.hashTreeRoot(val).buffer).toString('hex')
+  );
+};
+
+export const hashClusterDefinition = (
+  cluster: ClusterDefintion,
+  configOnly: boolean,
+): ValueOfFields<DefinitionFields> => {
+  const definitionType = clusterDefinitionContainerType(configOnly);
+
+  const val = definitionType.defaultValue();
+
+  //order should be same as charon https://github.com/ObolNetwork/charon/blob/d00b31e6465a260a43ce40f15c47fb5a5b009042/cluster/ssz.go#L285
+  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: { fee_recipient_address: string; withdrawal_address: string; }) => {
+    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 operatorAddressWrapperType = new ContainerType({
+  address: new ByteVectorType(20),
+});
+
+const creatorAddressWrapperType = new ContainerType({
+  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),
+});
+
+export const creatorContainerType = new ContainerType({
+  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),
+});
+
+const newCreatorContainerType = (configOnly: boolean) => {
+  return configOnly ? creatorAddressWrapperType : creatorContainerType;
+};
+
+const newOperatorContainerType = (configOnly: boolean) => {
+  return configOnly ? operatorAddressWrapperType : operatorContainerType;
+};
+
+type DefinitionFields = {
+  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;
+};
+
+export type DefinitionContainerType =
+  ContainerType<DefinitionFields>;
+
+/**
+ * @param configOnly a boolean to indicate config hash or definition hash
+ * @returns SSZ Containerized type of cluster definition
+ */
+export const clusterDefinitionContainerType = (
+  configOnly: boolean,
+): DefinitionContainerType => {
+  let returnedContainerType: DefinitionFields = {
+    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),
+    };
+  }
+
+  return new ContainerType(returnedContainerType);
+};
+
+//cluster-lock
+
+/**
+ * @param cluster The published cluster lock 
+ * @returns The lock hash in of the corresponding cluster
+ */
+export const clusterLockHash = (cluster: ClusterLock): string => {
+  const lockType = clusterLockContainerType();
+
+  const val = lockType.defaultValue();
+
+  //Check if we can replace with definition_hash 
+  val.cluster_definition = hashClusterDefinition(
+    cluster.cluster_definition,
+    false,
+  );
+  val.distributed_validators = cluster.distributed_validators.map(dVaidator => {
+    return {
+      distributed_public_key: fromHexString(dVaidator.distributed_public_key),
+      public_shares: dVaidator.public_shares.map(publicShare =>
+        fromHexString(publicShare),
+      ),
+      deposit_data: {
+        pubkey: fromHexString(dVaidator.deposit_data.pubkey as string),
+        withdrawal_credentials: fromHexString(
+          dVaidator.deposit_data.withdrawal_credentials as string
+        ),
+        amount: parseInt(dVaidator.deposit_data.amount as string),
+        signature: fromHexString(dVaidator.deposit_data.signature as string),
+      },
+      builder_registration: {
+        message: {
+          fee_recipient: fromHexString(
+            dVaidator.builder_registration.message.fee_recipient,
+          ),
+          gas_limit: dVaidator.builder_registration.message.gas_limit,
+          timestamp: dVaidator.builder_registration.message.timestamp,
+          pubkey: fromHexString(dVaidator.builder_registration.message.pubkey),
+        },
+        signature: fromHexString(dVaidator.builder_registration.signature),
+      },
+    };
+  });
+
+  return '0x' + Buffer.from(lockType.hashTreeRoot(val).buffer).toString('hex');
+};
+
+const depositDataContainer = new ContainerType({
+  pubkey: new ByteVectorType(48),
+  withdrawal_credentials: new ByteVectorType(32),
+  amount: new UintNumberType(8 as UintNumberByteLen),
+  signature: new ByteVectorType(96),
+});
+
+
+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),
+});
+
+const builderRegistrationContainer = new ContainerType({
+  message: builderRegistrationMessageContainer,
+  signature: new ByteVectorType(96),
+});
+
+const dvContainerType = new ContainerType({
+  distributed_public_key: new ByteVectorType(48),
+  public_shares: new ListCompositeType(new ByteVectorType(48), 256),
+  deposit_data: depositDataContainer,
+  builder_registration: builderRegistrationContainer,
+});
+
+type LockContainerType = ContainerType<{
+  cluster_definition: DefinitionContainerType;
+  distributed_validators: ListCompositeType<typeof dvContainerType>;
+}>;
+
+/**
+ * @returns SSZ Containerized type of cluster lock
+ */
+const clusterLockContainerType = (): LockContainerType => {
+  return new ContainerType({
+    cluster_definition: clusterDefinitionContainerType(false),
+    distributed_validators: new ListCompositeType(dvContainerType, 65536),
+  });
+};