@obolnetwork/obol-sdk 2.12.2 → 2.12.4

package/dist/cjs/src/index.js

@@ -115,6 +115,7 @@ __export(index_exports, {
   CONFIG_VERSION: () => CONFIG_VERSION,
   CONFLICT_ERROR_MSG: () => CONFLICT_ERROR_MSG,
   Client: () => Client,
+  ClusterLockValidationBusyError: () => ClusterLockValidationBusyError,
   ClusterLockValidationTimeoutError: () => ClusterLockValidationTimeoutError,
   ConflictError: () => ConflictError,
   CreatorConfigHashSigningTypes: () => CreatorConfigHashSigningTypes,
@@ -185,7 +186,7 @@ var import_uuid = require("uuid");
 // package.json
 var package_default = {
   name: "@obolnetwork/obol-sdk",
-  version: "2.12.2",
+  version: "2.12.4",
   description: "A package for creating Distributed Validators using the Obol API.",
   bugs: {
     url: "https://github.com/obolnetwork/obol-sdk/issues"
@@ -200,7 +201,7 @@ var package_default = {
     "build:clean": "rm -rf ./dist",
     build: "npm-run-all build:clean build:tsup",
     "build:tsup": "tsup && tsc -b ./tsconfig.types.json",
-    test: "NODE_OPTIONS=--experimental-vm-modules jest test/**/**.spec.ts --testPathIgnorePatterns=test/sdk-package/",
+    test: "NODE_OPTIONS=--experimental-vm-modules OBOL_SDK_MAX_CONCURRENT_LOCK_VALIDATIONS=0 jest test/**/**.spec.ts --testPathIgnorePatterns=test/sdk-package/",
     "generate-typedoc": "typedoc",
     "npm:publish": "npm publish --tag latest",
     "npm:publish:next": "npm publish --tag next",
@@ -642,7 +643,8 @@ var InvalidBaseUrlError = class _InvalidBaseUrlError extends Error {
 };
 var ClusterLockValidationTimeoutError = class _ClusterLockValidationTimeoutError extends Error {
   /**
-   * @param timeoutMs - Same value as SDK whole-lock validation worker timeout.
+   * @param timeoutMs - Worker deadline that was exceeded (`VALIDATION_WORKER_TIMEOUT_MS`
+   *   for the whole-lock worker, `WORKER_TIMEOUT_MS` for per-chunk BLS workers).
    */
   constructor(timeoutMs) {
     super(
@@ -653,6 +655,16 @@ var ClusterLockValidationTimeoutError = class _ClusterLockValidationTimeoutError
     Object.setPrototypeOf(this, _ClusterLockValidationTimeoutError.prototype);
   }
 };
+var ClusterLockValidationBusyError = class _ClusterLockValidationBusyError extends Error {
+  constructor(maxConcurrent) {
+    super(
+      `Too many cluster lock validations in progress (limit: ${maxConcurrent}). Retry later.`
+    );
+    this.maxConcurrent = maxConcurrent;
+    this.name = "ClusterLockValidationBusyError";
+    Object.setPrototypeOf(this, _ClusterLockValidationBusyError.prototype);
+  }
+};
 
 // src/base.ts
 var ALLOWED_OBOL_API_BASE_URLS = [
@@ -5080,6 +5092,9 @@ var MIN_KEYS_PER_WORKER_AGG = 100;
 var MIN_VALIDATORS_FOR_VALIDATION_WORKER = 50;
 var VALIDATION_WORKER_TIMEOUT_MS = 12e4;
 var WORKER_TIMEOUT_MS = 6e4;
+function isValidationTimeoutReply(msg) {
+  return typeof msg === "object" && msg !== null && "validationTimeoutMs" in msg && typeof msg.validationTimeoutMs === "number";
+}
 var MAX_CONCURRENT_WORKERS_CAP = 8;
 function maxConcurrentWorkers(numWorkers) {
   return Math.min(numWorkers, MAX_CONCURRENT_WORKERS_CAP);
@@ -5176,7 +5191,7 @@ function verifySharesSync(shares, distributedKeys, threshold) {
 }
 function runWorkerAggregatePubkeys(wt, workerFile, data) {
   return __async(this, null, function* () {
-    return yield new Promise((resolve) => {
+    return yield new Promise((resolve, reject) => {
       let settled = false;
       const worker = new wt.Worker(workerFile, { workerData: data });
       const finish = (result) => {
@@ -5187,7 +5202,11 @@ function runWorkerAggregatePubkeys(wt, workerFile, data) {
         resolve(result);
       };
       const timer = setTimeout(() => {
-        finish(null);
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        worker.terminate();
+        reject(new ClusterLockValidationTimeoutError(WORKER_TIMEOUT_MS));
       }, WORKER_TIMEOUT_MS);
       worker.once("message", (msg) => {
         finish(msg instanceof Uint8Array ? msg : null);
@@ -5203,7 +5222,7 @@ function runWorkerAggregatePubkeys(wt, workerFile, data) {
 }
 function runWorker(wt, workerFile, data) {
   return __async(this, null, function* () {
-    return yield new Promise((resolve) => {
+    return yield new Promise((resolve, reject) => {
       let settled = false;
       const worker = new wt.Worker(workerFile, { workerData: data });
       const finish = (result) => {
@@ -5214,7 +5233,11 @@ function runWorker(wt, workerFile, data) {
         resolve(result);
       };
       const timer = setTimeout(() => {
-        finish(false);
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        worker.terminate();
+        reject(new ClusterLockValidationTimeoutError(WORKER_TIMEOUT_MS));
       }, WORKER_TIMEOUT_MS);
       worker.once("message", (msg) => {
         finish(msg === true);
@@ -5375,6 +5398,14 @@ function validateClusterLockInWorker(lock, safeRpcUrl) {
         resolve(result);
       };
       worker.once("message", (msg) => {
+        if (isValidationTimeoutReply(msg)) {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          worker.terminate();
+          reject(new ClusterLockValidationTimeoutError(msg.validationTimeoutMs));
+          return;
+        }
         finish(msg === true);
       });
       worker.once("error", () => {
@@ -14934,6 +14965,9 @@ var isValidClusterLock = (clusterLock, safeRpcUrl) => __async(null, null, functi
     }
     return true;
   } catch (err) {
+    if (err instanceof ClusterLockValidationTimeoutError) {
+      throw err;
+    }
     return false;
   }
 });
@@ -19862,15 +19896,40 @@ var EOA = class {
   }
 };
 
+// src/verification/validationConcurrency.ts
+function getMaxConcurrentLockValidations() {
+  const raw = process.env.OBOL_SDK_MAX_CONCURRENT_LOCK_VALIDATIONS;
+  if (raw === "0") return 0;
+  if (raw !== void 0 && raw !== "") {
+    const n = Number.parseInt(raw, 10);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  return 2;
+}
+var activeValidations = 0;
+function withLockValidationConcurrency(fn) {
+  return __async(this, null, function* () {
+    const max = getMaxConcurrentLockValidations();
+    if (max === 0) return yield fn();
+    if (activeValidations >= max) {
+      throw new ClusterLockValidationBusyError(max);
+    }
+    activeValidations++;
+    try {
+      return yield fn();
+    } finally {
+      activeValidations--;
+    }
+  });
+}
+
 // src/services.ts
 var validateClusterLock = (lock, safeRpcUrl) => __async(null, null, function* () {
-  try {
+  return yield withLockValidationConcurrency(() => __async(null, null, function* () {
     const inWorker = yield validateClusterLockInWorker(lock, safeRpcUrl);
     if (inWorker !== null) return inWorker;
     return yield isValidClusterLock(lock, safeRpcUrl);
-  } catch (err) {
-    throw err;
-  }
+  }));
 });
 
 // src/index.ts
@@ -20469,6 +20528,7 @@ var Client = class extends Base {
   CONFIG_VERSION,
   CONFLICT_ERROR_MSG,
   Client,
+  ClusterLockValidationBusyError,
   ClusterLockValidationTimeoutError,
   ConflictError,
   CreatorConfigHashSigningTypes,