Run prettier

src/helpers/utils.ts

@@ -1,5 +1,5 @@
 import assert from "assert";
-import { PUBLIC_KEY_LENGTH, SIGNATURE_LENGTH } from "../constants";
+import {PUBLIC_KEY_LENGTH, SIGNATURE_LENGTH} from "../constants";
 
 /**
  * Pads byte array with zeroes on left side up to desired length.
@@ -8,10 +8,7 @@ import { PUBLIC_KEY_LENGTH, SIGNATURE_LENGTH } from "../constants";
  * @param length
  */
 export function padLeft(source: Uint8Array, length: number): Buffer {
-  assert(
-    source.length <= length,
-    "Given array must be smaller or equal to desired array size"
-  );
+  assert(source.length <= length, "Given array must be smaller or equal to desired array size");
   const result = Buffer.alloc(length, 0);
   result.set(source, length - source.length);
   return result;

src/index.ts

@@ -1,13 +1,13 @@
-import { Keypair } from "./keypair";
-import { PrivateKey } from "./privateKey";
-import { PublicKey } from "./publicKey";
-import { Signature } from "./signature";
-import { PUBLIC_KEY_LENGTH } from "./constants";
+import {Keypair} from "./keypair";
+import {PrivateKey} from "./privateKey";
+import {PublicKey} from "./publicKey";
+import {Signature} from "./signature";
+import {PUBLIC_KEY_LENGTH} from "./constants";
 import assert from "assert";
 
-export { Keypair, PrivateKey, PublicKey, Signature };
+export {Keypair, PrivateKey, PublicKey, Signature};
 
-export { init as initBLS } from "./context";
+export {init as initBLS} from "./context";
 
 function toBuffer(input: Uint8Array): Buffer {
   return Buffer.from(input.buffer, input.byteOffset, input.length);
@@ -47,10 +47,7 @@ export function sign(secretKey: Uint8Array, messageHash: Uint8Array): Buffer {
  * @param signatures
  */
 export function aggregateSignatures(signatures: Uint8Array[]): Buffer {
-  assert(
-    signatures && signatures.length > 0,
-    "signatures is null or undefined or empty array"
-  );
+  assert(signatures && signatures.length > 0, "signatures is null or undefined or empty array");
   return Signature.aggregate(
     signatures.map(
       (signature): Signature => {
@@ -81,11 +78,7 @@ export function aggregatePubkeys(publicKeys: Uint8Array[]): Buffer {
  * @param messageHash
  * @param signature
  */
-export function verify(
-  publicKey: Uint8Array,
-  messageHash: Uint8Array,
-  signature: Uint8Array
-): boolean {
+export function verify(publicKey: Uint8Array, messageHash: Uint8Array, signature: Uint8Array): boolean {
   assert(publicKey, "publicKey is null or undefined");
   assert(messageHash, "messageHash is null or undefined");
   assert(signature, "signature is null or undefined");
@@ -105,11 +98,7 @@ export function verify(
  * @param messageHash
  * @param signature
  */
-export function verifyAggregate(
-  publicKeys: Uint8Array[],
-  messageHash: Uint8Array,
-  signature: Uint8Array
-): boolean {
+export function verifyAggregate(publicKeys: Uint8Array[], messageHash: Uint8Array, signature: Uint8Array): boolean {
   assert(publicKeys, "publicKey is null or undefined");
   assert(messageHash, "messageHash is null or undefined");
   assert(signature, "signature is null or undefined");

src/keypair.ts

@@ -1,5 +1,5 @@
-import { PublicKey } from "./publicKey";
-import { PrivateKey } from "./privateKey";
+import {PublicKey} from "./publicKey";
+import {PrivateKey} from "./privateKey";
 
 export class Keypair {
   private readonly _publicKey: PublicKey;

src/privateKey.ts

@@ -1,10 +1,10 @@
-import { SECRET_KEY_LENGTH } from "./constants";
+import {SECRET_KEY_LENGTH} from "./constants";
 import assert from "assert";
-import { SecretKeyType } from "@chainsafe/eth2-bls-wasm";
-import { generateRandomSecretKey } from "@chainsafe/bls-keygen";
-import { getContext } from "./context";
-import { PublicKey } from "./publicKey";
-import { Signature } from "./signature";
+import {SecretKeyType} from "@chainsafe/eth2-bls-wasm";
+import {generateRandomSecretKey} from "@chainsafe/bls-keygen";
+import {getContext} from "./context";
+import {PublicKey} from "./publicKey";
+import {Signature} from "./signature";
 
 export class PrivateKey {
   private value: SecretKeyType;
@@ -14,10 +14,7 @@ export class PrivateKey {
   }
 
   public static fromBytes(bytes: Uint8Array): PrivateKey {
-    assert(
-      bytes.length === SECRET_KEY_LENGTH,
-      "Private key should have 32 bytes"
-    );
+    assert(bytes.length === SECRET_KEY_LENGTH, "Private key should have 32 bytes");
     const context = getContext();
     const secretKey = new context.SecretKey();
     secretKey.deserialize(Buffer.from(bytes));
@@ -26,10 +23,7 @@ export class PrivateKey {
 
   public static fromHexString(value: string): PrivateKey {
     value = value.replace("0x", "");
-    assert(
-      value.length === SECRET_KEY_LENGTH * 2,
-      "secret key must have 32 bytes"
-    );
+    assert(value.length === SECRET_KEY_LENGTH * 2, "secret key must have 32 bytes");
     const context = getContext();
     return new PrivateKey(context.deserializeHexStrToSecretKey(value));
   }

src/publicKey.ts

@@ -1,10 +1,10 @@
-import { PrivateKey } from "./privateKey";
-import { PublicKeyType } from "@chainsafe/eth2-bls-wasm";
-import { getContext } from "./context";
-import { PUBLIC_KEY_LENGTH } from "./constants";
+import {PrivateKey} from "./privateKey";
+import {PublicKeyType} from "@chainsafe/eth2-bls-wasm";
+import {getContext} from "./context";
+import {PUBLIC_KEY_LENGTH} from "./constants";
 import assert from "assert";
-import { Signature } from "./signature";
-import { EMPTY_PUBLIC_KEY } from "./helpers/utils";
+import {Signature} from "./signature";
+import {EMPTY_PUBLIC_KEY} from "./helpers/utils";
 
 export class PublicKey {
   private value: PublicKeyType;

src/signature.ts

@@ -1,9 +1,9 @@
 import assert from "assert";
-import { FP_POINT_LENGTH } from "./constants";
-import { SignatureType } from "@chainsafe/eth2-bls-wasm";
-import { getContext } from "./context";
-import { PublicKey } from "./publicKey";
-import { EMPTY_SIGNATURE } from "./helpers/utils";
+import {FP_POINT_LENGTH} from "./constants";
+import {SignatureType} from "@chainsafe/eth2-bls-wasm";
+import {getContext} from "./context";
+import {PublicKey} from "./publicKey";
+import {EMPTY_SIGNATURE} from "./helpers/utils";
 
 export class Signature {
   private value: SignatureType;
@@ -14,10 +14,7 @@ export class Signature {
   }
 
   public static fromCompressedBytes(value: Uint8Array): Signature {
-    assert(
-      value.length === 2 * FP_POINT_LENGTH,
-      `Signature must have ${2 * FP_POINT_LENGTH} bytes`
-    );
+    assert(value.length === 2 * FP_POINT_LENGTH, `Signature must have ${2 * FP_POINT_LENGTH} bytes`);
     const context = getContext();
     const signature = new context.Signature();
     if (!EMPTY_SIGNATURE.equals(value)) {
@@ -47,21 +44,14 @@ export class Signature {
     return this.value;
   }
 
-  public verifyAggregate(
-    publicKeys: PublicKey[],
-    message: Uint8Array
-  ): boolean {
+  public verifyAggregate(publicKeys: PublicKey[], message: Uint8Array): boolean {
     return this.value.fastAggregateVerify(
       publicKeys.map((key) => key.getValue()),
       message
     );
   }
 
-  public verifyMultiple(
-    publicKeys: PublicKey[],
-    messages: Uint8Array[],
-    fast = false
-  ): boolean {
+  public verifyMultiple(publicKeys: PublicKey[], messages: Uint8Array[], fast = false): boolean {
     const msgs = Buffer.concat(messages);
     if (!fast && !getContext().areAllMsgDifferent(msgs)) {
       return false;

test/spec/aggregate_sigs.test.ts

@@ -1,9 +1,6 @@
 import path from "path";
-import bls, { initBLS } from "../../src";
-import {
-  describeDirectorySpecTest,
-  InputType,
-} from "@chainsafe/lodestar-spec-test-util";
+import bls, {initBLS} from "../../src";
+import {describeDirectorySpecTest, InputType} from "@chainsafe/lodestar-spec-test-util";
 
 interface IAggregateSigsTestCase {
   data: {
@@ -18,10 +15,7 @@ before(async function f() {
 
 describeDirectorySpecTest<IAggregateSigsTestCase, string>(
   "BLS - aggregate sigs",
-  path.join(
-    __dirname,
-    "../../node_modules/@chainsafe/eth2-spec-tests/tests/general/phase0/bls/aggregate/small"
-  ),
+  path.join(__dirname, "../../node_modules/@chainsafe/eth2-spec-tests/tests/general/phase0/bls/aggregate/small"),
   (testCase) => {
     try {
       const result = bls.aggregateSignatures(

test/spec/aggregate_sigs_verify.test.ts

@@ -1,9 +1,6 @@
 import path from "path";
-import bls, { initBLS } from "../../src";
-import {
-  describeDirectorySpecTest,
-  InputType,
-} from "@chainsafe/lodestar-spec-test-util";
+import bls, {initBLS} from "../../src";
+import {describeDirectorySpecTest, InputType} from "@chainsafe/lodestar-spec-test-util";
 
 interface AggregateSigsVerifyTestCase {
   data: {
@@ -26,10 +23,7 @@ before(async function f() {
 
 describeDirectorySpecTest<AggregateSigsVerifyTestCase, boolean>(
   "BLS - aggregate sigs verify",
-  path.join(
-    __dirname,
-    "../../node_modules/@chainsafe/eth2-spec-tests/tests/general/phase0/bls/aggregate_verify/small"
-  ),
+  path.join(__dirname, "../../node_modules/@chainsafe/eth2-spec-tests/tests/general/phase0/bls/aggregate_verify/small"),
   (testCase) => {
     const pubkeys = testCase.data.input.pubkeys.map((pubkey) => {
       return Buffer.from(pubkey.replace("0x", ""), "hex");
@@ -37,11 +31,7 @@ describeDirectorySpecTest<AggregateSigsVerifyTestCase, boolean>(
     const messages = testCase.data.input.messages.map((msg) => {
       return Buffer.from(msg.replace("0x", ""), "hex");
     });
-    return bls.verifyMultiple(
-      pubkeys,
-      messages,
-      Buffer.from(testCase.data.input.signature.replace("0x", ""), "hex")
-    );
+    return bls.verifyMultiple(pubkeys, messages, Buffer.from(testCase.data.input.signature.replace("0x", ""), "hex"));
   },
   {
     inputTypes: {

test/spec/fast_aggregate_verify.test.ts

@@ -1,9 +1,6 @@
 import path from "path";
-import bls, { initBLS } from "../../src";
-import {
-  describeDirectorySpecTest,
-  InputType,
-} from "@chainsafe/lodestar-spec-test-util";
+import bls, {initBLS} from "../../src";
+import {describeDirectorySpecTest, InputType} from "@chainsafe/lodestar-spec-test-util";
 
 interface AggregateSigsVerifyTestCase {
   data: {
@@ -32,9 +29,7 @@ describeDirectorySpecTest<AggregateSigsVerifyTestCase, boolean>(
   ),
   (testCase) => {
     return bls.verifyAggregate(
-      testCase.data.input.pubkeys.map((key) =>
-        Buffer.from(key.replace("0x", ""), "hex")
-      ),
+      testCase.data.input.pubkeys.map((key) => Buffer.from(key.replace("0x", ""), "hex")),
       Buffer.from(testCase.data.input.message.replace("0x", ""), "hex"),
       Buffer.from(testCase.data.input.signature.replace("0x", ""), "hex")
     );

test/spec/sign.test.ts

@@ -1,9 +1,6 @@
 import path from "path";
-import bls, { initBLS } from "../../src";
-import {
-  describeDirectorySpecTest,
-  InputType,
-} from "@chainsafe/lodestar-spec-test-util";
+import bls, {initBLS} from "../../src";
+import {describeDirectorySpecTest, InputType} from "@chainsafe/lodestar-spec-test-util";
 
 interface ISignMessageTestCase {
   data: {
@@ -21,10 +18,7 @@ before(async function f() {
 
 describeDirectorySpecTest<ISignMessageTestCase, string>(
   "BLS - sign",
-  path.join(
-    __dirname,
-    "../../node_modules/@chainsafe/eth2-spec-tests/tests/general/phase0/bls/sign/small"
-  ),
+  path.join(__dirname, "../../node_modules/@chainsafe/eth2-spec-tests/tests/general/phase0/bls/sign/small"),
   (testCase) => {
     const signature = bls.sign(
       Buffer.from(testCase.data.input.privkey.replace("0x", ""), "hex"),

test/spec/verify.test.ts

@@ -1,9 +1,6 @@
 import path from "path";
-import bls, { initBLS } from "../../src";
-import {
-  describeDirectorySpecTest,
-  InputType,
-} from "@chainsafe/lodestar-spec-test-util";
+import bls, {initBLS} from "../../src";
+import {describeDirectorySpecTest, InputType} from "@chainsafe/lodestar-spec-test-util";
 
 interface IVerifyTestCase {
   data: {
@@ -22,10 +19,7 @@ before(async function f() {
 
 describeDirectorySpecTest<IVerifyTestCase, boolean>(
   "BLS - verify",
-  path.join(
-    __dirname,
-    "../../node_modules/@chainsafe/eth2-spec-tests/tests/general/phase0/bls/verify/small"
-  ),
+  path.join(__dirname, "../../node_modules/@chainsafe/eth2-spec-tests/tests/general/phase0/bls/verify/small"),
   (testCase) => {
     return bls.verify(
       Buffer.from(testCase.data.input.pubkey.replace("0x", ""), "hex"),

test/unit/context.test.ts

@@ -1,5 +1,5 @@
-import { init, getContext, destroy } from "../../src/context";
-import { expect } from "chai";
+import {init, getContext, destroy} from "../../src/context";
+import {expect} from "chai";
 
 describe("bls wasm constext", function () {
   afterEach(() => {

test/unit/index.test.ts

@@ -1,15 +1,8 @@
-import bls, {
-  aggregatePubkeys,
-  aggregateSignatures,
-  initBLS,
-  Keypair,
-  verify,
-  verifyMultiple,
-} from "../../src";
+import bls, {aggregatePubkeys, aggregateSignatures, initBLS, Keypair, verify, verifyMultiple} from "../../src";
 import SHA256 from "@chainsafe/as-sha256";
-import { expect } from "chai";
-import { destroy } from "../../src/context";
-import { padLeft } from "../../src/helpers/utils";
+import {expect} from "chai";
+import {destroy} from "../../src/context";
+import {padLeft} from "../../src/helpers/utils";
 
 describe("test bls", function () {
   before(async function () {
@@ -31,11 +24,7 @@ describe("test bls", function () {
       const keypair = Keypair.generate();
       const messageHash = Buffer.from(SHA256.digest(Buffer.from("Test")));
       const signature = keypair.privateKey.signMessage(messageHash);
-      const result = verify(
-        keypair.publicKey.toBytesCompressed(),
-        messageHash,
-        signature.toBytesCompressed()
-      );
+      const result = verify(keypair.publicKey.toBytesCompressed(), messageHash, signature.toBytesCompressed());
       expect(result).to.be.true;
     });
 
@@ -45,54 +34,32 @@ describe("test bls", function () {
       const signature = keypair.privateKey.signMessage(messageHash);
       const pubKey = keypair.publicKey.toBytesCompressed();
       verify(pubKey, messageHash, signature.toBytesCompressed());
-      expect("0x" + pubKey.toString("hex")).to.be.equal(
-        keypair.publicKey.toHexString()
-      );
+      expect("0x" + pubKey.toString("hex")).to.be.equal(keypair.publicKey.toHexString());
     });
 
     it("should fail verify empty signature", () => {
       const keypair = Keypair.generate();
-      const messageHash2 = Buffer.from(
-        SHA256.digest(Buffer.from("Test message2"))
-      );
+      const messageHash2 = Buffer.from(SHA256.digest(Buffer.from("Test message2")));
       const signature = Buffer.alloc(96);
-      const result = verify(
-        keypair.publicKey.toBytesCompressed(),
-        messageHash2,
-        signature
-      );
+      const result = verify(keypair.publicKey.toBytesCompressed(), messageHash2, signature);
       expect(result).to.be.false;
     });
 
     it("should fail verify signature of different message", () => {
       const keypair = Keypair.generate();
-      const messageHash = Buffer.from(
-        SHA256.digest(Buffer.from("Test message"))
-      );
-      const messageHash2 = Buffer.from(
-        SHA256.digest(Buffer.from("Test message2"))
-      );
+      const messageHash = Buffer.from(SHA256.digest(Buffer.from("Test message")));
+      const messageHash2 = Buffer.from(SHA256.digest(Buffer.from("Test message2")));
       const signature = keypair.privateKey.signMessage(messageHash);
-      const result = verify(
-        keypair.publicKey.toBytesCompressed(),
-        messageHash2,
-        signature.toBytesCompressed()
-      );
+      const result = verify(keypair.publicKey.toBytesCompressed(), messageHash2, signature.toBytesCompressed());
       expect(result).to.be.false;
     });
 
     it("should fail verify signature signed by different key", () => {
       const keypair = Keypair.generate();
       const keypair2 = Keypair.generate();
-      const messageHash = Buffer.from(
-        SHA256.digest(Buffer.from("Test message"))
-      );
+      const messageHash = Buffer.from(SHA256.digest(Buffer.from("Test message")));
       const signature = keypair.privateKey.signMessage(messageHash);
-      const result = verify(
-        keypair2.publicKey.toBytesCompressed(),
-        messageHash,
-        signature.toBytesCompressed()
-      );
+      const result = verify(keypair2.publicKey.toBytesCompressed(), messageHash, signature.toBytesCompressed());
       expect(result).to.be.false;
     });
   });
@@ -131,11 +98,7 @@ describe("test bls", function () {
         signature4.toBytesCompressed(),
       ]);
 
-      const result = verifyMultiple(
-        [aggregatePubKey12, aggregatePubKey34],
-        [message1, message2],
-        aggregateSignature
-      );
+      const result = verifyMultiple([aggregatePubKey12, aggregatePubKey34], [message1, message2], aggregateSignature);
 
       expect(result).to.be.true;
     });
@@ -245,11 +208,7 @@ describe("test bls", function () {
         signature4.toBytesCompressed(),
       ]);
 
-      const result = bls.verifyMultiple(
-        [aggregatePubKey12],
-        [message2, message1],
-        aggregateSignature
-      );
+      const result = bls.verifyMultiple([aggregatePubKey12], [message2, message1], aggregateSignature);
 
       expect(result).to.be.false;
     });

test/unit/keypair.test.ts

@@ -1,6 +1,6 @@
-import { PrivateKey, PublicKey, Keypair } from "../../src";
-import { expect } from "chai";
-import { destroy, init } from "../../src/context";
+import {PrivateKey, PublicKey, Keypair} from "../../src";
+import {expect} from "chai";
+import {destroy, init} from "../../src/context";
 
 describe("keypair", function () {
   before(async function () {
@@ -14,9 +14,7 @@ describe("keypair", function () {
   it("should create from private and public key", () => {
     const secret = PrivateKey.random();
     const secret2 = PrivateKey.random();
-    const publicKey = PublicKey.fromBytes(
-      PublicKey.fromPrivateKey(secret2).toBytesCompressed()
-    );
+    const publicKey = PublicKey.fromBytes(PublicKey.fromPrivateKey(secret2).toBytesCompressed());
     const keypair = new Keypair(secret, publicKey);
     expect(keypair.publicKey).to.be.equal(publicKey);
     expect(keypair.privateKey).to.be.equal(secret);

test/unit/privateKey.test.ts

@@ -1,7 +1,7 @@
-import { PrivateKey } from "../../src";
-import { expect } from "chai";
-import { SECRET_KEY_LENGTH } from "../../src/constants";
-import { destroy, init } from "../../src/context";
+import {PrivateKey} from "../../src";
+import {expect} from "chai";
+import {SECRET_KEY_LENGTH} from "../../src/constants";
+import {destroy, init} from "../../src/context";
 
 describe("privateKey", function () {
   before(async function () {
@@ -15,25 +15,17 @@ describe("privateKey", function () {
   it("should generate random private key", function () {
     const privateKey1 = PrivateKey.random();
     const privateKey2 = PrivateKey.random();
-    expect(privateKey1.toHexString()).to.not.be.equal(
-      privateKey2.toHexString()
-    );
+    expect(privateKey1.toHexString()).to.not.be.equal(privateKey2.toHexString());
   });
 
   it("should export private key to hex string", function () {
-    const privateKey =
-      "0x07656fd676da43883d163f49566c72b9cbf0a5a294f26808c807700732456da7";
+    const privateKey = "0x07656fd676da43883d163f49566c72b9cbf0a5a294f26808c807700732456da7";
 
-    expect(PrivateKey.fromHexString(privateKey).toHexString()).to.be.equal(
-      privateKey
-    );
+    expect(PrivateKey.fromHexString(privateKey).toHexString()).to.be.equal(privateKey);
 
-    const privateKey2 =
-      "07656fd676da43883d163f49566c72b9cbf0a5a294f26808c807700732456da7";
+    const privateKey2 = "07656fd676da43883d163f49566c72b9cbf0a5a294f26808c807700732456da7";
 
-    expect(PrivateKey.fromHexString(privateKey2).toHexString()).to.be.equal(
-      privateKey
-    );
+    expect(PrivateKey.fromHexString(privateKey2).toHexString()).to.be.equal(privateKey);
   });
 
   it("should export private key to bytes", function () {

test/unit/publicKey.test.ts

@@ -1,6 +1,6 @@
-import { destroy, init } from "../../src/context";
-import { PublicKey, PrivateKey } from "../../src";
-import { expect } from "chai";
+import {destroy, init} from "../../src/context";
+import {PublicKey, PrivateKey} from "../../src";
+import {expect} from "chai";
 
 describe("public key", function () {
   before(async function f() {
@@ -20,9 +20,7 @@ describe("public key", function () {
   it("from bytes", function () {
     const publicKey =
       "b6f21199594b56d77670564bf422cb331d5281ca2c1f9a45588a56881d8287ef8619efa6456d6cd2ef61306aa5b21311";
-    expect(
-      PublicKey.fromBytes(Buffer.from(publicKey, "hex")).toHexString()
-    ).to.be.equal(`0x${publicKey}`);
+    expect(PublicKey.fromBytes(Buffer.from(publicKey, "hex")).toHexString()).to.be.equal(`0x${publicKey}`);
   });
 
   it("from private key", function () {