Improve BLS multi-thread worker pool strategy

packages/beacon-state-transition/src/fast/signatureSets/attesterSlashings.ts

@@ -1,16 +1,25 @@
 import {readonlyValues} from "@chainsafe/ssz";
-import {allForks} from "@chainsafe/lodestar-types";
+import {allForks, phase0} from "@chainsafe/lodestar-types";
 import {ISignatureSet} from "../../util";
 import {CachedBeaconState} from "../util";
 import {getIndexedAttestationSignatureSet} from "./indexedAttestation";
 
+/** Get signature sets from a single AttesterSlashing object */
+export function getAttesterSlashingSignatureSets(
+  state: CachedBeaconState<allForks.BeaconState>,
+  attesterSlashing: phase0.AttesterSlashing
+): ISignatureSet[] {
+  return [attesterSlashing.attestation1, attesterSlashing.attestation2].map((attestation) =>
+    getIndexedAttestationSignatureSet(state, attestation)
+  );
+}
+
+/** Get signature sets from all AttesterSlashing objects in a block */
 export function getAttesterSlashingsSignatureSets(
   state: CachedBeaconState<allForks.BeaconState>,
   signedBlock: allForks.SignedBeaconBlock
 ): ISignatureSet[] {
   return Array.from(readonlyValues(signedBlock.message.body.attesterSlashings), (attesterSlashing) =>
-    [attesterSlashing.attestation1, attesterSlashing.attestation2].map((attestation) =>
-      getIndexedAttestationSignatureSet(state, attestation)
-    )
+    getAttesterSlashingSignatureSets(state, attesterSlashing)
   ).flat(1);
 }

packages/beacon-state-transition/src/util/signatureSets.ts

@@ -26,10 +26,10 @@ export function verifySignatureSet(signatureSet: ISignatureSet): boolean {
 
   switch (signatureSet.type) {
     case SignatureSetType.single:
-      return signature.verify(signatureSet.pubkey, signatureSet.signingRoot as Uint8Array);
+      return signature.verify(signatureSet.pubkey, signatureSet.signingRoot.valueOf() as Uint8Array);
 
     case SignatureSetType.aggregate:
-      return signature.verifyAggregate(signatureSet.pubkeys, signatureSet.signingRoot as Uint8Array);
+      return signature.verifyAggregate(signatureSet.pubkeys, signatureSet.signingRoot.valueOf() as Uint8Array);
 
     default:
       throw Error("Unknown signature set type");

packages/lodestar/src/chain/blocks/process.ts

@@ -46,7 +46,7 @@ export async function processBlock({
           )
         : fast.getAllBlockSignatureSets(preState as CachedBeaconState<allForks.BeaconState>, job.signedBlock);
 
-      if (!(await bls.verifySignatureSetsBatch(signatureSets))) {
+      if (signatureSets.length > 0 && !(await bls.verifySignatureSets(signatureSets))) {
         throw new BlockError({
           code: BlockErrorCode.INVALID_SIGNATURE,
           job,
@@ -137,7 +137,7 @@ export async function processChainSegment({
           );
         }
 
-        if (!(await bls.verifySignatureSetsBatch(signatureSets))) {
+        if (signatureSets.length > 0 && !(await bls.verifySignatureSets(signatureSets))) {
           throw new ChainSegmentError({
             code: BlockErrorCode.INVALID_SIGNATURE,
             job,

packages/lodestar/src/chain/bls/index.ts

@@ -1,19 +1,25 @@
 import {bls, PublicKey} from "@chainsafe/bls";
 import {ISignatureSet, SignatureSetType} from "@chainsafe/lodestar-beacon-state-transition";
-import {ILogger} from "@chainsafe/lodestar-utils";
-import {BlsMultiThreadNaive} from "./multithread";
+import {BlsMultiThreadWorkerPool, BlsMultiThreadWorkerPoolModules} from "./multithread";
 
 export interface IBlsVerifier {
-  verifySignatureSetsBatch(signatureSets: ISignatureSet[]): Promise<boolean>;
+  verifySignatureSets(signatureSets: ISignatureSet[]): Promise<boolean>;
 }
 
 export class BlsVerifier implements IBlsVerifier {
-  private readonly pool: BlsMultiThreadNaive;
-  constructor(logger: ILogger) {
-    this.pool = new BlsMultiThreadNaive(logger, bls.implementation);
+  private readonly pool: BlsMultiThreadWorkerPool;
+  constructor(modules: BlsMultiThreadWorkerPoolModules) {
+    this.pool = new BlsMultiThreadWorkerPool(bls.implementation, modules);
   }
 
-  verifySignatureSetsBatch(signatureSets: ISignatureSet[]): Promise<boolean> {
+  /**
+   * Verify 1 or more signature sets. Sets may be verified on batch or not depending on their count
+   */
+  verifySignatureSets(signatureSets: ISignatureSet[], validateSignature = true): Promise<boolean> {
+    if (signatureSets.length === 0) {
+      throw Error("Empty signature set");
+    }
+
     // Signatures all come from the wire (untrusted) are all bytes compressed, must be:
     // - Parsed from bytes
     // - Uncompressed
@@ -31,12 +37,13 @@ export class BlsVerifier implements IBlsVerifier {
     // Public keys have already been checked for subgroup and infinity
     // Signatures have already been checked for subgroup
     // Signature checks above could be done here for convienence as well
-    return this.pool.verifyMultipleAggregateSignatures(
+    return this.pool.verifySignatureSets(
       signatureSets.map((signatureSet) => ({
         publicKey: getAggregatedPubkey(signatureSet),
-        message: signatureSet.signingRoot as Uint8Array,
+        message: signatureSet.signingRoot.valueOf() as Uint8Array,
         signature: signatureSet.signature,
-      }))
+      })),
+      validateSignature
     );
   }
 }