Create noble-secp256k1.

Author: paulmillr

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Paul Miller (https://paulmillr.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,90 @@
+# noble-secp256k1
+> **noble-crypto** — high-security, easily auditable set of contained cryptographic libraries and tools.
+
+Noble [secp256k1](https://en.bitcoin.it/wiki/Secp256k1), an elliptic curve that could be used for assymetric encryption and ECDSA signature scheme.
+
+- No dependencies, one small file
+- Easily auditable TypeScript/JS code
+- Uses es2019 bigint. Supported in Chrome, Firefox, node 10+
+
+## Usage
+
+```js
+import * as secp256k1 from "noble-secp256k1";
+
+// You can also pass BigInt:
+// const PRIVATE_KEY = 0xa665a45920422f9d417e4867efn;
+const PRIVATE_KEY = Uint8Array.from([
+  0xa6, 0x65, 0xa4, 0x59, 0x20, 0x42, 0x2f,
+  0x9d, 0x41, 0x7e, 0x48, 0x67, 0xef
+]);
+const MESSAGE_HASH = "9c1185a5c5e9fc54612808977ee8f548b2258d31";
+
+const publicKey = secp256k1.getPublicKey(PRIVATE_KEY);
+const signature = secp256k1.sign(MESSAGE_HASH, PRIVATE_KEY);
+const isMessageSigned = secp256k1.verify(signature, MESSAGE_HASH, publicKey);
+```
+
+## API
+
+```typescript
+function getPublicKey(privateKey: Uint8Array, isCompressed?: false): Uint8Array;
+function getPublicKey(privateKey: string, isCompressed?: false): string;
+function getPublicKey(privateKey: bigint): Point;
+```
+`privateKey` will be used to generate public key.
+  Public key is generated by doing scalar multiplication of a base Point(x, y) by a fixed
+  integer. The result is another `Point(x, y)` which we will by default encode to hex Uint8Array.
+`isCompressed` (default is `false`) determines whether the output should contain `y` coordinate of the point.
+
+```typescript
+function sign(hash: Uint8Array, privateKey: Uint8Array | bigint, k?: bigint): Uint8Array;
+function sign(hash: string, privateKey: string | bigint, k?: bigint): string;
+```
+- `hash: Uint8Array | string` - message hash which would be signed
+- `privateKey: Uint8Array | string | bigint` - private key which will sign the hash
+- `k?: bigint` - *optional* random seed. Default is one from `crypto.getRandomValues()`. **Must be cryptographically secure**, which means `Math.random()` won't work.
+- Returns DER encoded ECDSA signature, as hex uint8a / string.
+
+```typescript
+function verify(signature: Uint8Array | string | SignResult, hash: Uint8Array | string): boolean
+```
+- `signature: Uint8Array` - object returned by the `sign` function
+- `hash: string | Uint8Array` - message hash that needs to be verified
+- `publicKey: string | Point` - e.g. that was generated from `privateKey` by `getPublicKey`
+- Returns `boolean`: `true` if `signature == hash`; otherwise `false`
+
+The library also exports helpers:
+
+```typescript
+// Finite field over prime Fp
+secp256k1.P // 2 ^ 256 - 2 ^ 32 - 977
+
+// Prime order
+secp256k1.PRIME_ORDER // 2 ^ 256 - 432420386565659656852420866394968145599
+
+// Base point
+secp256k1.BASE_POINT // new secp256k1.Point(x, y) where
+// x = 55066263022277343669578718895168534326250603453777594175500187360389116729240n
+// y = 32670510020758816978083085130507043184471273380659243275938904335757337482424n;
+
+// Elliptic curve point
+secp256k1.Point {
+  constructor(x: bigint, y: bigint);
+  // Compressed elliptic curve point representation
+  static fromHex(hex: Uint8Array | string);
+  static fromCompressedHex(hex: string);
+  toHex(): string;
+  toCompressedHex(): string;
+}
+secp256k1.SignResult {
+  constructor(r: bigint, s: bigint);
+  // DER encoded ECDSA signature
+  static fromHex(hex: Uint8Array | string);
+  toHex()
+}
+```
+
+## License
+
+MIT (c) Paul Miller (https://paulmillr.com), see LICENSE file.

generate-precomputes.js

@@ -0,0 +1,24 @@
+// Optional file that allows to generate precomputes
+// Not included in NPM distribution to simplify code.
+// Precomputes are initially computed powers of two (2^120, 2^121 etc)
+// Which are used to speed-up calculations of elliptic curve cryptography.
+const fs = require("fs");
+const path = require("path");
+const { GG, multiple } = require("./index");
+
+let precomputeContent = `import { Point } from "./point";
+export default [`
+
+for (let i = 0; i < 257; i++) {
+  const multiplier = 2n ** BigInt(i);
+  const result = multiple(GG, multiplier);
+  precomputeContent = `${precomputeContent}
+  new Point(
+    ${result.x}n,
+    ${result.y}n,
+  ),`
+}
+
+precomputeContent += "\n];";
+
+fs.writeFileSync(path.join(__dirname, "./precomputed.ts"), precomputeContent);

index.d.ts

@@ -0,0 +1,34 @@
+/*! noble-secp256k1 - MIT License (c) Paul Miller (paulmillr.com) */
+export declare const P: bigint;
+export declare const PRIME_ORDER: bigint;
+declare type PrivKey = Uint8Array | string | bigint | number;
+declare type PubKey = Uint8Array | string | Point;
+declare type Hex = Uint8Array | string;
+declare type Signature = Uint8Array | string | SignResult;
+export declare class Point {
+    x: bigint;
+    y: bigint;
+    constructor(x: bigint, y: bigint);
+    private static fromCompressedHex;
+    private static fromUncompressedHex;
+    static fromHex(hash: Hex): Point;
+    private uncompressedHex;
+    private compressedHex;
+    toRawBytes(isCompressed?: boolean): Uint8Array;
+    toHex(isCompressed?: boolean): string;
+}
+export declare class SignResult {
+    r: bigint;
+    s: bigint;
+    constructor(r: bigint, s: bigint);
+    static fromHex(hex: Hex): SignResult;
+    toHex(): string;
+}
+export declare const BASE_POINT: Point;
+export declare function getPublicKey(privateKey: Uint8Array, isCompressed?: boolean): Uint8Array;
+export declare function getPublicKey(privateKey: string, isCompressed?: boolean): string;
+export declare function getPublicKey(privateKey: bigint | number, isCompressed?: boolean): Point;
+export declare function sign(hash: Uint8Array, privateKey: PrivKey, k?: bigint | number): Uint8Array;
+export declare function sign(hash: string, privateKey: PrivKey, k?: bigint | number): string;
+export declare function verify(signature: Signature, hash: Hex, publicKey: PubKey): boolean;
+export {};