feat: add async functions for blst-native

Author: matthewkeil

src/blst-native/index.ts

@@ -7,13 +7,14 @@ export * from "../constants.js";
 
 export {SecretKey, PublicKey, Signature};
 
+const implementation = "blst-native";
 export const bls: IBls = {
-  implementation: "blst-native",
+  implementation,
   SecretKey,
   PublicKey,
   Signature,
 
-  ...functionalInterfaceFactory({SecretKey, PublicKey, Signature}),
+  ...functionalInterfaceFactory({implementation, SecretKey, PublicKey, Signature}),
 };
 
 export default bls;

src/functional.ts

@@ -1,15 +1,18 @@
-import {IBls} from "./types.js";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as blst from "@chainsafe/blst-ts";
+import {IBls, PublicKey, PublicKeyArg, Signature, SignatureArg} from "./types.js";
 import {validateBytes} from "./helpers/index.js";
-import {NotInitializedError} from "./errors.js";
+import {NotInitializedError, ZeroSignatureError} from "./errors.js";
 
 // Returned type is enforced at each implementation's index
 // eslint-disable-next-line max-len
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type,@typescript-eslint/explicit-module-boundary-types
 export function functionalInterfaceFactory({
+  implementation,
   SecretKey,
   PublicKey,
   Signature,
-}: Pick<IBls, "SecretKey" | "PublicKey" | "Signature">) {
+}: Pick<IBls, "implementation" | "SecretKey" | "PublicKey" | "Signature">) {
   /**
    * Signs given message using secret key.
    * @param secretKey
@@ -47,9 +50,11 @@ export function functionalInterfaceFactory({
    * @param signature
    */
   function verify(publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean {
-    validateBytes(publicKey, "publicKey");
-    validateBytes(message, "message");
-    validateBytes(signature, "signature");
+    if (implementation === "herumi") {
+      validateBytes(publicKey, "publicKey");
+      validateBytes(message, "message");
+      validateBytes(signature, "signature");
+    }
 
     try {
       return Signature.fromBytes(signature).verify(PublicKey.fromBytes(publicKey), message);
@@ -58,6 +63,27 @@ export function functionalInterfaceFactory({
       return false;
     }
   }
+  async function asyncVerify(message: Uint8Array, publicKey: PublicKeyArg, signature: SignatureArg): Promise<boolean> {
+    if (implementation === "herumi") {
+      throw new Error("WASM implementation does not support asyncVerify, use verify instead");
+    }
+
+    const pk = publicKey instanceof PublicKey ? ((publicKey as any).key as blst.PublicKey) : publicKey;
+    const sig =
+      signature instanceof Signature
+        ? ((signature as any).sig as blst.Signature)
+        : blst.Signature.deserialize(signature);
+
+    if (sig.isInfinity()) {
+      false;
+    }
+
+    try {
+      return blst.asyncVerify(message, pk, sig);
+    } catch {
+      return false;
+    }
+  }
 
   /**
    * Verifies if aggregated signature is same message signed with given public keys.
@@ -80,6 +106,26 @@ export function functionalInterfaceFactory({
       return false;
     }
   }
+  async function asyncVerifyAggregate(
+    message: Uint8Array,
+    publicKeys: PublicKeyArg[],
+    signature: SignatureArg
+  ): Promise<boolean> {
+    if (implementation === "herumi") {
+      throw new Error("WASM implementation does not support asyncVerifyAggregate, use verifyAggregate instead");
+    }
+
+    const pks = publicKeys.map((pk) => (pk instanceof PublicKey ? ((pk as any).key as blst.PublicKey) : pk));
+    const sig = signature instanceof Signature ? ((signature as any).sig as blst.Signature) : signature;
+
+    // TODO: (matthewkeil) check spec to make sure this sig does not need inf check
+
+    try {
+      return blst.fastAggregateVerify(message, pks, sig);
+    } catch {
+      return false;
+    }
+  }
 
   /**
    * Verifies if signature is list of message signed with corresponding public key.
@@ -106,6 +152,30 @@ export function functionalInterfaceFactory({
       return false;
     }
   }
+  async function asyncVerifyMultiple(
+    messages: Uint8Array[],
+    publicKeys: PublicKeyArg[],
+    signature: SignatureArg
+  ): Promise<boolean> {
+    if (implementation === "herumi") {
+      throw new Error("WASM implementation does not support asyncVerifyMultiple, use verifyMultiple instead");
+    }
+
+    if (publicKeys.length === 0 || publicKeys.length != messages.length) {
+      return false;
+    }
+
+    const pks = publicKeys.map((pk) => (pk instanceof PublicKey ? ((pk as any).key as blst.PublicKey) : pk));
+    const sig = signature instanceof Signature ? ((signature as any).sig as blst.Signature) : signature;
+
+    // TODO: (matthewkeil) check spec to make sure this sig does not need inf check
+
+    try {
+      return blst.aggregateVerify(messages, pks, sig);
+    } catch {
+      return false;
+    }
+  }
 
   /**
    * Verifies multiple signatures at once returning true if all valid or false
@@ -135,6 +205,25 @@ export function functionalInterfaceFactory({
       return false;
     }
   }
+  async function asyncVerifyMultipleSignatures(
+    sets: {message: Uint8Array; publicKey: PublicKeyArg; signature: SignatureArg}[]
+  ): Promise<boolean> {
+    if (!sets) throw Error("sets is null or undefined");
+
+    try {
+      return blst.asyncVerifyMultipleAggregateSignatures(
+        sets.map((set) => ({
+          message: set.message,
+          publicKey:
+            set.publicKey instanceof PublicKey ? ((set.publicKey as any).key as blst.PublicKey) : set.publicKey,
+          signature:
+            set.signature instanceof Signature ? ((set.signature as any).sig as blst.Signature) : set.signature,
+        }))
+      );
+    } catch {
+      return false;
+    }
+  }
 
   /**
    * Computes a public key from a secret key
@@ -152,6 +241,10 @@ export function functionalInterfaceFactory({
     verifyAggregate,
     verifyMultiple,
     verifyMultipleSignatures,
+    asyncVerify,
+    asyncVerifyAggregate,
+    asyncVerifyMultiple,
+    asyncVerifyMultipleSignatures,
     secretKeyToPublicKey,
   };
 }

src/herumi/index.ts

@@ -11,13 +11,14 @@ export * from "../constants.js";
 
 export {SecretKey, PublicKey, Signature, init, destroy};
 
+const implementation = "herumi";
 export const bls: IBls = {
-  implementation: "herumi",
+  implementation,
   SecretKey,
   PublicKey,
   Signature,
 
-  ...functionalInterfaceFactory({SecretKey, PublicKey, Signature}),
+  ...functionalInterfaceFactory({implementation, SecretKey, PublicKey, Signature}),
 };
 
 export default bls;

src/types.ts

@@ -1,5 +1,7 @@
 import {CoordType} from "@chainsafe/blst-ts";
 
+export type PublicKeyArg = PublicKey | Uint8Array;
+export type SignatureArg = Signature | Uint8Array;
 export interface IBls {
   implementation: Implementation;
   SecretKey: typeof SecretKey;
@@ -13,6 +15,12 @@ export interface IBls {
   verifyAggregate(publicKeys: Uint8Array[], message: Uint8Array, signature: Uint8Array): boolean;
   verifyMultiple(publicKeys: Uint8Array[], messages: Uint8Array[], signature: Uint8Array): boolean;
   verifyMultipleSignatures(sets: {publicKey: Uint8Array; message: Uint8Array; signature: Uint8Array}[]): boolean;
+  asyncVerify(message: Uint8Array, publicKey: PublicKeyArg, signature: SignatureArg): Promise<boolean>;
+  asyncVerifyAggregate(message: Uint8Array, publicKeys: PublicKeyArg[], signature: SignatureArg): Promise<boolean>;
+  asyncVerifyMultiple(messages: Uint8Array[], publicKeys: PublicKeyArg[], signature: SignatureArg): Promise<boolean>;
+  asyncVerifyMultipleSignatures(
+    sets: {message: Uint8Array; publicKey: PublicKeyArg; signature: SignatureArg}[]
+  ): Promise<boolean>;
   secretKeyToPublicKey(secretKey: Uint8Array): Uint8Array;
 }