LumeWeb
/
chainsafe-bls
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix lint

This commit is contained in:
Marin Petrunić 2020-11-23 14:42:52 +01:00
parent 135625ccc0
commit c153de6e24
No known key found for this signature in database
GPG Key ID: 834D07135E110DA5
8 changed files with 121 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/context.ts
View File

@ -1,21 +1,23 @@
import herumi from "bls-eth-wasm";
import { herumiToIBls } from "./herumi";
import { IBls } from "./interface";
import {herumiToIBls} from "./herumi";
import {IBls} from "./interface";
export type Backing = "herumi" | "blst-native" | "blst-wasm";
let contextBacking: Backing|undefined = undefined;
let context: IBls|undefined = undefined;
let contextBacking: Backing | undefined = undefined;
let context: IBls | undefined = undefined;
//to maintain api compatible, add all backing context to return type
export async function init(backing: Backing = "herumi"): Promise<IBls> {
if (!context) {
switch(backing) {
case "herumi": {
context = await herumiToIBls();
contextBacking = backing;
} break;
default: throw new Error(`Unsupported backing - ${backing}`)
switch (backing) {
case "herumi":
{
context = await herumiToIBls();
contextBacking = backing;
}
break;
default:
throw new Error(`Unsupported backing - ${backing}`);
}
}
await context.init();
@ -23,9 +25,9 @@ export async function init(backing: Backing = "herumi"): Promise<IBls> {
}
export function destroy(): void {
if(context) {
context.destroy();
}
if (context) {
context.destroy();
}
context = undefined;
contextBacking = undefined;
}
@ -37,7 +39,6 @@ export function getContext(): IBls {
return context;
}
export function getContextBacking(): Backing {
if (!context) {
throw new Error("BLS not initialized");

58
src/herumi/adapter.ts
View File

@ -1,33 +1,33 @@
import herumi from "bls-eth-wasm";
import { init as initHerumi, destroy, getContext } from "./context";
import { IBls, IPrivateKeyValue, IPublicKeyValue, ISignatureValue } from '../interface';
import {init as initHerumi, destroy, getContext} from "./context";
import {IBls, IPrivateKeyValue, IPublicKeyValue, ISignatureValue} from "../interface";
export async function herumiToIBls(): Promise<IBls> {
await initHerumi();
const context: IBls = {
SecretKey: getContext().SecretKey as IPrivateKeyValue,
PublicKey: getContext().PublicKey as IPublicKeyValue,
Signature: getContext().Signature as ISignatureValue,
await initHerumi();
const context: IBls = {
SecretKey: getContext().SecretKey as IPrivateKeyValue,
PublicKey: getContext().PublicKey as IPublicKeyValue,
Signature: getContext().Signature as ISignatureValue,
toHex: herumi.toHex,
toHexStr: herumi.toHexStr,
fromHexStr: herumi.fromHexStr,
getCurveOrder: herumi.getCurveOrder,
getFieldOrder: herumi.getFieldOrder,
verifySignatureOrder: herumi.verifySignatureOrder,
verifyPublicKeyOrder: herumi.verifyPublicKeyOrder,
areAllMsgDifferent: herumi.areAllMsgDifferent,
shouldVerifyBlsSignatureOrder: herumi.shouldVerifyBlsSignatureOrder,
shouldVerifyBlsPublicKeyOrder: herumi.shouldVerifyBlsPublicKeyOrder,
deserializeHexStrToSecretKey: herumi.deserializeHexStrToSecretKey as IBls["deserializeHexStrToSecretKey"],
deserializeHexStrToPublicKey: herumi.deserializeHexStrToPublicKey as IBls["deserializeHexStrToPublicKey"],
deserializeHexStrToSignature: herumi.deserializeHexStrToSignature as IBls["deserializeHexStrToSignature"],
init: async () => {
return context;
},
destroy: () => {
destroy();
}
}
return context;
}
toHex: herumi.toHex,
toHexStr: herumi.toHexStr,
fromHexStr: herumi.fromHexStr,
getCurveOrder: herumi.getCurveOrder,
getFieldOrder: herumi.getFieldOrder,
verifySignatureOrder: herumi.verifySignatureOrder,
verifyPublicKeyOrder: herumi.verifyPublicKeyOrder,
areAllMsgDifferent: herumi.areAllMsgDifferent,
shouldVerifyBlsSignatureOrder: herumi.shouldVerifyBlsSignatureOrder,
shouldVerifyBlsPublicKeyOrder: herumi.shouldVerifyBlsPublicKeyOrder,
deserializeHexStrToSecretKey: herumi.deserializeHexStrToSecretKey as IBls["deserializeHexStrToSecretKey"],
deserializeHexStrToPublicKey: herumi.deserializeHexStrToPublicKey as IBls["deserializeHexStrToPublicKey"],
deserializeHexStrToSignature: herumi.deserializeHexStrToSignature as IBls["deserializeHexStrToSignature"],
init: async () => {
return context;
},
destroy: () => {
destroy();
},
};
return context;
}

2
src/herumi/index.ts
View File

@ -1 +1 @@
export {herumiToIBls} from "./adapter";
export {herumiToIBls} from "./adapter";

8
src/index.ts
View File

@ -1,9 +1,9 @@
import {PUBLIC_KEY_LENGTH} from "./constants";
import assert from "assert";
import { Keypair } from "./keypair";
import { PrivateKey } from "./privateKey";
import { PublicKey } from "./publicKey";
import { Signature } from "./signature";
import {Keypair} from "./keypair";
import {PrivateKey} from "./privateKey";
import {PublicKey} from "./publicKey";
import {Signature} from "./signature";
export {Keypair, PrivateKey, PublicKey, Signature};

125
src/interface.ts
View File

@ -1,90 +1,85 @@
interface Common {
interface ICommon {
new (): this;
new(): this;
deserializeHexStr(s: string): void;
deserializeHexStr(s: string): void;
serializeToHexStr(): string;
serializeToHexStr(): string;
isEqual(rhs: this): boolean;
isEqual(rhs: this): boolean
deserialize(v: Uint8Array): void;
deserialize(v: Uint8Array): void;
serialize(): Uint8Array;
serialize(): Uint8Array;
add(rhs: this): void;
add(rhs: this): void;
dump(msg?: string): string;
dump(msg?: string): string;
clear(): void;
clear(): void;
clone(): this;
clone(): this;
}
export interface IPrivateKeyValue extends Common {
export interface IPrivateKeyValue extends ICommon {
setInt(x: number): void;
setInt(x: number): void;
setHashOf(a: Uint8Array): void;
setHashOf(a: Uint8Array): void;
setLittleEndian(a: Uint8Array): void;
setLittleEndian(a: Uint8Array): void;
setByCSPRNG(): void;
setByCSPRNG(): void;
getPublicKey(): IPublicKeyValue;
sign(m: string | Uint8Array): ISignatureValue;
getPublicKey(): IPublicKeyValue;
sign(m: string | Uint8Array): ISignatureValue;
}
export interface IPublicKeyValue extends Common {
verify(signature: ISignatureValue, m: Uint8Array | string): boolean;
isValidOrder(): boolean;
deserializeUncompressed (s: Uint8Array): void;
serializeUncompressed (): Uint8Array;
deserializeUncompressedHexStr (s:string): void;
serializeUncompressedToHexStr(): string;
export interface IPublicKeyValue extends ICommon {
verify(signature: ISignatureValue, m: Uint8Array | string): boolean;
isValidOrder(): boolean;
deserializeUncompressed(s: Uint8Array): void;
serializeUncompressed(): Uint8Array;
deserializeUncompressedHexStr(s: string): void;
serializeUncompressedToHexStr(): string;
}
export interface ISignatureValue extends Common {
deserializeUncompressed (s: Uint8Array): void;
serializeUncompressed (): Uint8Array;
deserializeUncompressedHexStr (s:string): void;
serializeUncompressedToHexStr(): string;
isValidOrder(): boolean;
aggregate(others: ISignatureValue[]): boolean;
aggregateVerifyNoCheck(publicKeys: IPublicKeyValue[], messages: Uint8Array): boolean;
fastAggregateVerify(publicKeys: IPublicKeyValue[], message: Uint8Array): boolean;
export interface ISignatureValue extends ICommon {
deserializeUncompressed(s: Uint8Array): void;
serializeUncompressed(): Uint8Array;
deserializeUncompressedHexStr(s: string): void;
serializeUncompressedToHexStr(): string;
isValidOrder(): boolean;
aggregate(others: ISignatureValue[]): boolean;
aggregateVerifyNoCheck(publicKeys: IPublicKeyValue[], messages: Uint8Array): boolean;
fastAggregateVerify(publicKeys: IPublicKeyValue[], message: Uint8Array): boolean;
}
export interface IBls {
//property names are like that for api compatibility
SecretKey: InstanceType<IPrivateKeyValue>;
PublicKey: InstanceType<IPublicKeyValue>;
Signature: InstanceType<ISignatureValue>;
//property names are like that for api compatibility
SecretKey: InstanceType<IPrivateKeyValue>;
PublicKey: InstanceType<IPublicKeyValue>;
Signature: InstanceType<ISignatureValue>;
toHex(a: Uint8Array, start: number, length: number): string;
toHexStr(a: Uint8Array): string;
fromHexStr(s: string): Uint8Array;
getCurveOrder(): string;
getFieldOrder(): string;
verifySignatureOrder(doVerify: boolean): void;
verifyPublicKeyOrder(doVerify: boolean): void;
/**
*
* @param msgs single array with concatenated messages
* @param msgSize defaults to MSG_SIZE
*/
areAllMsgDifferent(msgs: Uint8Array, msgSize?: number): boolean;
shouldVerifyBlsSignatureOrder(b: string): void;
shouldVerifyBlsPublicKeyOrder(b: string): void;
deserializeHexStrToSecretKey(s: string): IPrivateKeyValue;
deserializeHexStrToPublicKey(s: string): IPublicKeyValue;
deserializeHexStrToSignature(s: string): ISignatureValue;
toHex(a: Uint8Array, start: number, length: number): string;
toHexStr(a: Uint8Array): string;
fromHexStr(s: string): Uint8Array;
getCurveOrder(): string;
getFieldOrder(): string;
verifySignatureOrder(doVerify: boolean): void;
verifyPublicKeyOrder(doVerify: boolean): void;
init(): Promise<this>;
destroy(): void;
}
/**
*
* @param msgs single array with concatenated messages
* @param msgSize defaults to MSG_SIZE
*/
areAllMsgDifferent(msgs: Uint8Array, msgSize?: number): boolean;
shouldVerifyBlsSignatureOrder(b: string): void;
shouldVerifyBlsPublicKeyOrder(b: string): void;
deserializeHexStrToSecretKey(s: string): IPrivateKeyValue;
deserializeHexStrToPublicKey(s: string): IPublicKeyValue;
deserializeHexStrToSignature(s: string): ISignatureValue;
init(): Promise<this>;
destroy(): void;
}

6
src/privateKey.ts
View File

@ -1,9 +1,9 @@
import {SECRET_KEY_LENGTH} from "./constants";
import assert from "assert";
import {generateRandomSecretKey} from "@chainsafe/bls-keygen";
import { IPrivateKeyValue } from "./interface";
import { getContext } from "./context";
import { PublicKey, Signature } from ".";
import {IPrivateKeyValue} from "./interface";
import {getContext} from "./context";
import {PublicKey, Signature} from ".";
export class PrivateKey {
private value: IPrivateKeyValue;

6
src/publicKey.ts
View File

@ -3,8 +3,8 @@ import {PUBLIC_KEY_LENGTH} from "./constants";
import assert from "assert";
import {Signature} from "./signature";
import {EMPTY_PUBLIC_KEY} from "./helpers/utils";
import { IPublicKeyValue } from './interface';
import { getContext } from "./context";
import {IPublicKeyValue} from "./interface";
import {getContext} from "./context";
export class PublicKey {
private value: IPublicKeyValue;
@ -31,7 +31,7 @@ export class PublicKey {
assert(value.length === PUBLIC_KEY_LENGTH * 2);
const context = getContext();
const pubkeyValue = new context.PublicKey();
pubkeyValue.deserializeHexStr(value)
pubkeyValue.deserializeHexStr(value);
return new PublicKey(pubkeyValue);
}

10
src/signature.ts
View File

@ -1,9 +1,9 @@
import assert from "assert";
import { FP_POINT_LENGTH } from "./constants";
import { getContext } from "./context";
import { EMPTY_SIGNATURE } from "./helpers/utils";
import { ISignatureValue } from './interface';
import { PublicKey } from "./publicKey";
import {FP_POINT_LENGTH} from "./constants";
import {getContext} from "./context";
import {EMPTY_SIGNATURE} from "./helpers/utils";
import {ISignatureValue} from "./interface";
import {PublicKey} from "./publicKey";
export class Signature {
private value: ISignatureValue;