@obolnetwork/obol-sdk 2.12.0 → 2.12.1

package/dist/cjs/src/verification/parallelPool.js

@@ -58,7 +58,10 @@ var __async = (__this, __arguments, generator) => {
 // src/verification/parallelPool.ts
 var parallelPool_exports = {};
 __export(parallelPool_exports, {
+  validateClusterLockInWorker: () => validateClusterLockInWorker,
+  verifyAggregateParallel: () => verifyAggregateParallel,
   verifyBatchParallel: () => verifyBatchParallel,
+  verifyBlsChecksParallel: () => verifyBlsChecksParallel,
   verifySharesBinding: () => verifySharesBinding
 });
 module.exports = __toCommonJS(parallelPool_exports);
@@ -3739,6 +3742,30 @@ function mapToG2(scalars) {
 // src/blsUtils.ts
 var { longSignatures: ls } = bls12_381;
 var ETH2_DST = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_";
+function blsAggregatePublicKeys(pubkeys) {
+  if (pubkeys.length === 0) {
+    throw new Error("cannot aggregate empty pubkey set");
+  }
+  return ls.aggregatePublicKeys(pubkeys).toBytes();
+}
+function blsVerifyAggregate(pubkeys, message, signature) {
+  try {
+    return ls.verify(
+      signature,
+      ls.hash(message, ETH2_DST),
+      ls.aggregatePublicKeys(pubkeys)
+    );
+  } catch (e) {
+    return false;
+  }
+}
+function blsVerifyWithAggregatedPubkey(aggregatedPubkey, message, signature) {
+  try {
+    return ls.verify(signature, ls.hash(message, ETH2_DST), aggregatedPubkey);
+  } catch (e) {
+    return false;
+  }
+}
 function blsVerifyMultiple(pubkeys, messages, signature) {
   try {
     if (pubkeys.length !== messages.length) return false;
@@ -3803,16 +3830,39 @@ function blsVerifyExtraShares(pubshares, threshold, distributedPubkey) {
   }
 }
 
+// src/errors.ts
+var ClusterLockValidationTimeoutError = class _ClusterLockValidationTimeoutError extends Error {
+  /**
+   * @param timeoutMs - Same value as SDK whole-lock validation worker timeout.
+   */
+  constructor(timeoutMs) {
+    super(
+      `Cluster lock validation exceeded worker time limit (${timeoutMs} ms). Retry later; this does not imply invalid lock data.`
+    );
+    this.timeoutMs = timeoutMs;
+    this.name = "ClusterLockValidationTimeoutError";
+    Object.setPrototypeOf(this, _ClusterLockValidationTimeoutError.prototype);
+  }
+};
+
 // src/verification/parallelPool.ts
 var MIN_PARALLEL_VALIDATORS = 50;
 var MIN_PARALLEL_BATCH_PAIRS = 100;
 var MAX_WORKERS = 8;
 var MIN_VALIDATORS_PER_WORKER = 25;
 var MIN_PAIRS_PER_WORKER = 50;
+var MIN_PARALLEL_AGGREGATE_KEYS = 400;
+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;
+var MAX_CONCURRENT_WORKERS_CAP = 8;
+function maxConcurrentWorkers(numWorkers) {
+  return Math.min(numWorkers, MAX_CONCURRENT_WORKERS_CAP);
+}
 var workerThreadsCache;
 var osCache;
-var workerPathCache;
+var workerPathByFile = /* @__PURE__ */ new Map();
 function loadWorkerThreads() {
   if (workerThreadsCache !== void 0) return workerThreadsCache;
   try {
@@ -3831,18 +3881,47 @@ function loadOs() {
   }
   return osCache;
 }
-function getWorkerPath() {
-  if (workerPathCache !== void 0) return workerPathCache;
-  if (typeof __dirname === "undefined") return workerPathCache = null;
+function getWorkerPath(filename) {
+  const cached = workerPathByFile.get(filename);
+  if (cached !== void 0) return cached;
+  if (typeof __dirname === "undefined") {
+    workerPathByFile.set(filename, null);
+    return null;
+  }
   const path = require("path");
-  const candidate = path.join(__dirname, "lockWorker.js");
+  const fs = require("fs");
+  const candidates = [
+    path.join(__dirname, filename),
+    path.join(__dirname, "verification", filename)
+  ];
   try {
-    const fs = require("fs");
-    if (!fs.existsSync(candidate)) return workerPathCache = null;
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) {
+        workerPathByFile.set(filename, candidate);
+        return candidate;
+      }
+    }
   } catch (e) {
-    return workerPathCache = null;
   }
-  return workerPathCache = candidate;
+  workerPathByFile.set(filename, null);
+  return null;
+}
+function mapWithConcurrency(items, concurrency, fn) {
+  return __async(this, null, function* () {
+    const results = new Array(items.length);
+    let next = 0;
+    const runners = Array.from(
+      { length: Math.min(concurrency, items.length) },
+      () => __async(null, null, function* () {
+        while (next < items.length) {
+          const i = next++;
+          results[i] = yield fn(items[i], i);
+        }
+      })
+    );
+    yield Promise.all(runners);
+    return results;
+  });
 }
 function chunkArrays(arr, n) {
   const size = Math.ceil(arr.length / n);
@@ -3871,6 +3950,33 @@ function verifySharesSync(shares, distributedKeys, threshold) {
   }
   return true;
 }
+function runWorkerAggregatePubkeys(wt, workerFile, data) {
+  return __async(this, null, function* () {
+    return yield new Promise((resolve) => {
+      let settled = false;
+      const worker = new wt.Worker(workerFile, { workerData: data });
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        worker.terminate();
+        resolve(result);
+      };
+      const timer = setTimeout(() => {
+        finish(null);
+      }, WORKER_TIMEOUT_MS);
+      worker.once("message", (msg) => {
+        finish(msg instanceof Uint8Array ? msg : null);
+      });
+      worker.once("error", () => {
+        finish(null);
+      });
+      worker.once("exit", (code) => {
+        if (code !== 0) finish(null);
+      });
+    });
+  });
+}
 function runWorker(wt, workerFile, data) {
   return __async(this, null, function* () {
     return yield new Promise((resolve) => {
@@ -3901,8 +4007,8 @@ function runWorker(wt, workerFile, data) {
 function poolSize(itemCount, minPerWorker) {
   const wt = loadWorkerThreads();
   const os = loadOs();
-  const workerFile = getWorkerPath();
-  const numCpus = os ? os.cpus().length : 1;
+  const workerFile = getWorkerPath("lockWorker.js");
+  const numCpus = os ? Math.max(1, os.cpus().length) : 1;
   const numWorkers = Math.min(
     MAX_WORKERS,
     Math.max(1, Math.floor(itemCount / minPerWorker)),
@@ -3910,6 +4016,18 @@ function poolSize(itemCount, minPerWorker) {
   );
   return { numWorkers, wt, workerFile };
 }
+function runWorkerChunks(wt, workerFile, chunks) {
+  return __async(this, null, function* () {
+    const results = yield mapWithConcurrency(
+      chunks,
+      maxConcurrentWorkers(chunks.length),
+      (data) => __async(null, null, function* () {
+        return yield runWorker(wt, workerFile, data);
+      })
+    );
+    return results.every(Boolean);
+  });
+}
 function verifySharesBinding(shares, distributedKeys, threshold) {
   return __async(this, null, function* () {
     if (shares.length !== distributedKeys.length) return false;
@@ -3923,19 +4041,26 @@ function verifySharesBinding(shares, distributedKeys, threshold) {
     }
     const shareChunks = chunkArrays(shares, numWorkers);
     const keyChunks = chunkArrays(distributedKeys, numWorkers);
-    const results = yield Promise.all(
-      shareChunks.map(
-        (chunk, i) => __async(null, null, function* () {
-          return yield runWorker(wt, workerFile, {
-            mode: "shareBinding",
-            shares: chunk,
-            distributedKeys: keyChunks[i],
-            threshold
-          });
-        })
-      )
+    return yield runWorkerChunks(
+      wt,
+      workerFile,
+      shareChunks.map((chunk, i) => ({
+        mode: "shareBinding",
+        shares: chunk,
+        distributedKeys: keyChunks[i],
+        threshold
+      }))
+    );
+  });
+}
+function verifyBlsChecksParallel(checks) {
+  return __async(this, null, function* () {
+    if (checks.length === 0) return true;
+    return yield verifyBatchParallel(
+      checks.map((c) => c.pubkey),
+      checks.map((c) => c.message),
+      checks.map((c) => c.signature)
     );
-    return results.every(Boolean);
   });
 }
 function verifyBatchParallel(pubkeys, messages, signatures) {
@@ -3958,24 +4083,92 @@ function verifyBatchParallel(pubkeys, messages, signatures) {
     const pkChunks = chunkArrays(pubkeys, numWorkers);
     const msgChunks = chunkArrays(messages, numWorkers);
     const sigChunks = chunkArrays(signatures, numWorkers);
-    const results = yield Promise.all(
-      pkChunks.map(
-        (pks, i) => __async(null, null, function* () {
-          return yield runWorker(wt, workerFile, {
-            mode: "verifyBatch",
-            pubkeys: pks,
-            messages: msgChunks[i],
-            aggregateSignature: blsAggregateSignatures(sigChunks[i])
-          });
-        })
-      )
+    return yield runWorkerChunks(
+      wt,
+      workerFile,
+      pkChunks.map((pks, i) => ({
+        mode: "verifyBatch",
+        pubkeys: pks,
+        messages: msgChunks[i],
+        signatures: sigChunks[i]
+      }))
     );
-    return results.every(Boolean);
+  });
+}
+function verifyAggregateParallel(pubkeys, message, signature) {
+  return __async(this, null, function* () {
+    if (pubkeys.length === 0) return false;
+    const { numWorkers, wt, workerFile } = poolSize(
+      pubkeys.length,
+      MIN_KEYS_PER_WORKER_AGG
+    );
+    if (wt === null || workerFile === null || pubkeys.length < MIN_PARALLEL_AGGREGATE_KEYS || numWorkers < 2) {
+      return blsVerifyAggregate(pubkeys, message, signature);
+    }
+    const pkChunks = chunkArrays(pubkeys, numWorkers);
+    const partials = yield mapWithConcurrency(
+      pkChunks,
+      maxConcurrentWorkers(pkChunks.length),
+      (chunk) => __async(null, null, function* () {
+        return yield runWorkerAggregatePubkeys(wt, workerFile, {
+          mode: "aggregatePubkeys",
+          pubkeys: chunk
+        });
+      })
+    );
+    if (partials.some((p) => p === null)) return false;
+    const aggregated = blsAggregatePublicKeys(partials);
+    return blsVerifyWithAggregatedPubkey(aggregated, message, signature);
+  });
+}
+function validateClusterLockInWorker(lock, safeRpcUrl) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    const n = (_b = (_a = lock.distributed_validators) == null ? void 0 : _a.length) != null ? _b : 0;
+    if (n < MIN_VALIDATORS_FOR_VALIDATION_WORKER) return null;
+    const wt = loadWorkerThreads();
+    const workerFile = getWorkerPath("clusterLockValidationWorker.js");
+    if (wt === null || workerFile === null) return null;
+    return yield new Promise((resolve, reject) => {
+      let settled = false;
+      const worker = new wt.Worker(workerFile, {
+        workerData: { lock, safeRpcUrl }
+      });
+      let timer;
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        worker.terminate();
+        resolve(result);
+      };
+      timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        void worker.terminate();
+        reject(
+          new ClusterLockValidationTimeoutError(VALIDATION_WORKER_TIMEOUT_MS)
+        );
+      }, VALIDATION_WORKER_TIMEOUT_MS);
+      worker.once("message", (msg) => {
+        finish(msg === true);
+      });
+      worker.once("error", () => {
+        finish(null);
+      });
+      worker.once("exit", (code) => {
+        if (code !== 0) finish(null);
+      });
+    });
   });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  validateClusterLockInWorker,
+  verifyAggregateParallel,
   verifyBatchParallel,
+  verifyBlsChecksParallel,
   verifySharesBinding
 });
 /*! Bundled license information: