ganach-cli 6.12.2

package/node_modules/@types/node/zlib.d.ts

@@ -0,0 +1,352 @@
+declare module "zlib" {
+    import * as stream from "stream";
+
+    interface ZlibOptions {
+        /**
+         * @default constants.Z_NO_FLUSH
+         */
+        flush?: number;
+        /**
+         * @default constants.Z_FINISH
+         */
+        finishFlush?: number;
+        /**
+         * @default 16*1024
+         */
+        chunkSize?: number;
+        windowBits?: number;
+        level?: number; // compression only
+        memLevel?: number; // compression only
+        strategy?: number; // compression only
+        dictionary?: NodeJS.ArrayBufferView | ArrayBuffer; // deflate/inflate only, empty dictionary by default
+    }
+
+    interface BrotliOptions {
+        /**
+         * @default constants.BROTLI_OPERATION_PROCESS
+         */
+        flush?: number;
+        /**
+         * @default constants.BROTLI_OPERATION_FINISH
+         */
+        finishFlush?: number;
+        /**
+         * @default 16*1024
+         */
+        chunkSize?: number;
+        params?: {
+            /**
+             * Each key is a `constants.BROTLI_*` constant.
+             */
+            [key: number]: boolean | number;
+        };
+    }
+
+    interface Zlib {
+        /** @deprecated Use bytesWritten instead. */
+        readonly bytesRead: number;
+        readonly bytesWritten: number;
+        shell?: boolean | string;
+        close(callback?: () => void): void;
+        flush(kind?: number | (() => void), callback?: () => void): void;
+    }
+
+    interface ZlibParams {
+        params(level: number, strategy: number, callback: () => void): void;
+    }
+
+    interface ZlibReset {
+        reset(): void;
+    }
+
+    interface BrotliCompress extends stream.Transform, Zlib { }
+    interface BrotliDecompress extends stream.Transform, Zlib { }
+    interface Gzip extends stream.Transform, Zlib { }
+    interface Gunzip extends stream.Transform, Zlib { }
+    interface Deflate extends stream.Transform, Zlib, ZlibReset, ZlibParams { }
+    interface Inflate extends stream.Transform, Zlib, ZlibReset { }
+    interface DeflateRaw extends stream.Transform, Zlib, ZlibReset, ZlibParams { }
+    interface InflateRaw extends stream.Transform, Zlib, ZlibReset { }
+    interface Unzip extends stream.Transform, Zlib { }
+
+    function createBrotliCompress(options?: BrotliOptions): BrotliCompress;
+    function createBrotliDecompress(options?: BrotliOptions): BrotliDecompress;
+    function createGzip(options?: ZlibOptions): Gzip;
+    function createGunzip(options?: ZlibOptions): Gunzip;
+    function createDeflate(options?: ZlibOptions): Deflate;
+    function createInflate(options?: ZlibOptions): Inflate;
+    function createDeflateRaw(options?: ZlibOptions): DeflateRaw;
+    function createInflateRaw(options?: ZlibOptions): InflateRaw;
+    function createUnzip(options?: ZlibOptions): Unzip;
+
+    type InputType = string | ArrayBuffer | NodeJS.ArrayBufferView;
+
+    type CompressCallback = (error: Error | null, result: Buffer) => void;
+
+    function brotliCompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
+    function brotliCompress(buf: InputType, callback: CompressCallback): void;
+    function brotliCompressSync(buf: InputType, options?: BrotliOptions): Buffer;
+    function brotliDecompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
+    function brotliDecompress(buf: InputType, callback: CompressCallback): void;
+    function brotliDecompressSync(buf: InputType, options?: BrotliOptions): Buffer;
+    function deflate(buf: InputType, callback: CompressCallback): void;
+    function deflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    function deflateSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function deflateRaw(buf: InputType, callback: CompressCallback): void;
+    function deflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    function deflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function gzip(buf: InputType, callback: CompressCallback): void;
+    function gzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    function gzipSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function gunzip(buf: InputType, callback: CompressCallback): void;
+    function gunzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    function gunzipSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function inflate(buf: InputType, callback: CompressCallback): void;
+    function inflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    function inflateSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function inflateRaw(buf: InputType, callback: CompressCallback): void;
+    function inflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    function inflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
+    function unzip(buf: InputType, callback: CompressCallback): void;
+    function unzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
+    function unzipSync(buf: InputType, options?: ZlibOptions): Buffer;
+
+    namespace constants {
+        const BROTLI_DECODE: number;
+        const BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: number;
+        const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: number;
+        const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: number;
+        const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: number;
+        const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: number;
+        const BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: number;
+        const BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: number;
+        const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: number;
+        const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: number;
+        const BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: number;
+        const BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: number;
+        const BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: number;
+        const BROTLI_DECODER_ERROR_FORMAT_DISTANCE: number;
+        const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: number;
+        const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: number;
+        const BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: number;
+        const BROTLI_DECODER_ERROR_FORMAT_PADDING_1: number;
+        const BROTLI_DECODER_ERROR_FORMAT_PADDING_2: number;
+        const BROTLI_DECODER_ERROR_FORMAT_RESERVED: number;
+        const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: number;
+        const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: number;
+        const BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: number;
+        const BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: number;
+        const BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: number;
+        const BROTLI_DECODER_ERROR_UNREACHABLE: number;
+        const BROTLI_DECODER_NEEDS_MORE_INPUT: number;
+        const BROTLI_DECODER_NEEDS_MORE_OUTPUT: number;
+        const BROTLI_DECODER_NO_ERROR: number;
+        const BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: number;
+        const BROTLI_DECODER_PARAM_LARGE_WINDOW: number;
+        const BROTLI_DECODER_RESULT_ERROR: number;
+        const BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: number;
+        const BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: number;
+        const BROTLI_DECODER_RESULT_SUCCESS: number;
+        const BROTLI_DECODER_SUCCESS: number;
+
+        const BROTLI_DEFAULT_MODE: number;
+        const BROTLI_DEFAULT_QUALITY: number;
+        const BROTLI_DEFAULT_WINDOW: number;
+        const BROTLI_ENCODE: number;
+        const BROTLI_LARGE_MAX_WINDOW_BITS: number;
+        const BROTLI_MAX_INPUT_BLOCK_BITS: number;
+        const BROTLI_MAX_QUALITY: number;
+        const BROTLI_MAX_WINDOW_BITS: number;
+        const BROTLI_MIN_INPUT_BLOCK_BITS: number;
+        const BROTLI_MIN_QUALITY: number;
+        const BROTLI_MIN_WINDOW_BITS: number;
+
+        const BROTLI_MODE_FONT: number;
+        const BROTLI_MODE_GENERIC: number;
+        const BROTLI_MODE_TEXT: number;
+
+        const BROTLI_OPERATION_EMIT_METADATA: number;
+        const BROTLI_OPERATION_FINISH: number;
+        const BROTLI_OPERATION_FLUSH: number;
+        const BROTLI_OPERATION_PROCESS: number;
+
+        const BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: number;
+        const BROTLI_PARAM_LARGE_WINDOW: number;
+        const BROTLI_PARAM_LGBLOCK: number;
+        const BROTLI_PARAM_LGWIN: number;
+        const BROTLI_PARAM_MODE: number;
+        const BROTLI_PARAM_NDIRECT: number;
+        const BROTLI_PARAM_NPOSTFIX: number;
+        const BROTLI_PARAM_QUALITY: number;
+        const BROTLI_PARAM_SIZE_HINT: number;
+
+        const DEFLATE: number;
+        const DEFLATERAW: number;
+        const GUNZIP: number;
+        const GZIP: number;
+        const INFLATE: number;
+        const INFLATERAW: number;
+        const UNZIP: number;
+
+        const Z_BEST_COMPRESSION: number;
+        const Z_BEST_SPEED: number;
+        const Z_BLOCK: number;
+        const Z_BUF_ERROR: number;
+        const Z_DATA_ERROR: number;
+
+        const Z_DEFAULT_CHUNK: number;
+        const Z_DEFAULT_COMPRESSION: number;
+        const Z_DEFAULT_LEVEL: number;
+        const Z_DEFAULT_MEMLEVEL: number;
+        const Z_DEFAULT_STRATEGY: number;
+        const Z_DEFAULT_WINDOWBITS: number;
+
+        const Z_ERRNO: number;
+        const Z_FILTERED: number;
+        const Z_FINISH: number;
+        const Z_FIXED: number;
+        const Z_FULL_FLUSH: number;
+        const Z_HUFFMAN_ONLY: number;
+        const Z_MAX_CHUNK: number;
+        const Z_MAX_LEVEL: number;
+        const Z_MAX_MEMLEVEL: number;
+        const Z_MAX_WINDOWBITS: number;
+        const Z_MEM_ERROR: number;
+        const Z_MIN_CHUNK: number;
+        const Z_MIN_LEVEL: number;
+        const Z_MIN_MEMLEVEL: number;
+        const Z_MIN_WINDOWBITS: number;
+        const Z_NEED_DICT: number;
+        const Z_NO_COMPRESSION: number;
+        const Z_NO_FLUSH: number;
+        const Z_OK: number;
+        const Z_PARTIAL_FLUSH: number;
+        const Z_RLE: number;
+        const Z_STREAM_END: number;
+        const Z_STREAM_ERROR: number;
+        const Z_SYNC_FLUSH: number;
+        const Z_VERSION_ERROR: number;
+        const ZLIB_VERNUM: number;
+    }
+
+    /**
+     * @deprecated
+     */
+    const Z_NO_FLUSH: number;
+    /**
+     * @deprecated
+     */
+    const Z_PARTIAL_FLUSH: number;
+    /**
+     * @deprecated
+     */
+    const Z_SYNC_FLUSH: number;
+    /**
+     * @deprecated
+     */
+    const Z_FULL_FLUSH: number;
+    /**
+     * @deprecated
+     */
+    const Z_FINISH: number;
+    /**
+     * @deprecated
+     */
+    const Z_BLOCK: number;
+    /**
+     * @deprecated
+     */
+    const Z_TREES: number;
+    /**
+     * @deprecated
+     */
+    const Z_OK: number;
+    /**
+     * @deprecated
+     */
+    const Z_STREAM_END: number;
+    /**
+     * @deprecated
+     */
+    const Z_NEED_DICT: number;
+    /**
+     * @deprecated
+     */
+    const Z_ERRNO: number;
+    /**
+     * @deprecated
+     */
+    const Z_STREAM_ERROR: number;
+    /**
+     * @deprecated
+     */
+    const Z_DATA_ERROR: number;
+    /**
+     * @deprecated
+     */
+    const Z_MEM_ERROR: number;
+    /**
+     * @deprecated
+     */
+    const Z_BUF_ERROR: number;
+    /**
+     * @deprecated
+     */
+    const Z_VERSION_ERROR: number;
+    /**
+     * @deprecated
+     */
+    const Z_NO_COMPRESSION: number;
+    /**
+     * @deprecated
+     */
+    const Z_BEST_SPEED: number;
+    /**
+     * @deprecated
+     */
+    const Z_BEST_COMPRESSION: number;
+    /**
+     * @deprecated
+     */
+    const Z_DEFAULT_COMPRESSION: number;
+    /**
+     * @deprecated
+     */
+    const Z_FILTERED: number;
+    /**
+     * @deprecated
+     */
+    const Z_HUFFMAN_ONLY: number;
+    /**
+     * @deprecated
+     */
+    const Z_RLE: number;
+    /**
+     * @deprecated
+     */
+    const Z_FIXED: number;
+    /**
+     * @deprecated
+     */
+    const Z_DEFAULT_STRATEGY: number;
+    /**
+     * @deprecated
+     */
+    const Z_BINARY: number;
+    /**
+     * @deprecated
+     */
+    const Z_TEXT: number;
+    /**
+     * @deprecated
+     */
+    const Z_ASCII: number;
+    /**
+     * @deprecated
+     */
+    const Z_UNKNOWN: number;
+    /**
+     * @deprecated
+     */
+    const Z_DEFLATED: number;
+}

package/node_modules/@types/pbkdf2/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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

package/node_modules/@types/pbkdf2/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/pbkdf2`
+
+# Summary
+This package contains type definitions for pbkdf2 (https://github.com/crypto-browserify/pbkdf2).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/pbkdf2.
+
+### Additional Details
+ * Last updated: Sat, 18 Jul 2020 15:47:21 GMT
+ * Dependencies: [@types/node](https://npmjs.com/package/@types/node)
+ * Global values: none
+
+# Credits
+These definitions were written by [Timon Engelke](https://github.com/timonegk).

package/node_modules/@types/pbkdf2/index.d.ts

@@ -0,0 +1,41 @@
+// Type definitions for pbkdf2 3.1
+// Project: https://github.com/crypto-browserify/pbkdf2
+// Definitions by: Timon Engelke <https://github.com/timonegk>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+/// <reference types="node" />
+
+// No need to export this
+type TypedArray =
+    | Int8Array
+    | Uint8Array
+    | Uint8ClampedArray
+    | Int16Array
+    | Uint16Array
+    | Int32Array
+    | Uint32Array
+    | Float32Array
+    | Float64Array;
+export function pbkdf2(
+    password: string | Buffer | TypedArray | DataView,
+    salt: string | Buffer | TypedArray | DataView,
+    iterations: number,
+    keylen: number,
+    callback: (err: Error, derivedKey: Buffer) => void,
+): void;
+export function pbkdf2(
+    password: string | Buffer | TypedArray | DataView,
+    salt: string | Buffer | TypedArray | DataView,
+    iterations: number,
+    keylen: number,
+    digest: string,
+    callback: (err: Error, derivedKey: Buffer) => void,
+): void;
+export function pbkdf2Sync(
+    password: string | Buffer | TypedArray | DataView,
+    salt: string | Buffer | TypedArray | DataView,
+    iterations: number,
+    keylen: number,
+    digest?: string,
+): Buffer;
+
+export {};

package/node_modules/@types/pbkdf2/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@types/pbkdf2",
+    "version": "3.1.0",
+    "description": "TypeScript definitions for pbkdf2",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Timon Engelke",
+            "url": "https://github.com/timonegk",
+            "githubUsername": "timonegk"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/pbkdf2"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/node": "*"
+    },
+    "typesPublisherContentHash": "a40fa74f1ff0d2f082cc550aa5d1b8642eee12a12cb2edea546e25e466f4cf4e",
+    "typeScriptVersion": "3.0"
+
+,"_resolved": "https://registry.npmjs.org/@types/pbkdf2/-/pbkdf2-3.1.0.tgz"
+,"_integrity": "sha512-Cf63Rv7jCQ0LaL8tNXmEyqTHuIJxRdlS5vMh1mj5voN4+QFhVZnlZruezqpWYDiJ8UTzhP0VmeLXCmBk66YrMQ=="
+,"_from": "@types/pbkdf2@3.1.0"
+}

package/node_modules/@types/secp256k1/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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

package/node_modules/@types/secp256k1/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/secp256k1`
+
+# Summary
+This package contains type definitions for secp256k1 (https://github.com/cryptocoinjs/secp256k1-node).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/secp256k1.
+
+### Additional Details
+ * Last updated: Thu, 16 Apr 2020 21:35:04 GMT
+ * Dependencies: [@types/node](https://npmjs.com/package/@types/node)
+ * Global values: none
+
+# Credits
+These definitions were written by [Anler](https://github.com/anler).

package/node_modules/@types/secp256k1/index.d.ts

@@ -0,0 +1,141 @@
+// Type definitions for secp256k1 4.0
+// Project: https://github.com/cryptocoinjs/secp256k1-node
+// Definitions by: Anler <https://github.com/anler>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="node" />
+
+/** Options for the `sign` function */
+export interface SignOptions {
+    /** Nonce generator. By default it is rfc6979 */
+    noncefn?: (message: Uint8Array, privateKey: Uint8Array, algo: Uint8Array | null,
+               data: Uint8Array | null, attempt: number) => Uint8Array;
+
+    /**
+     * Additional data for noncefn (RFC 6979 3.6) (32 bytes).
+     *
+     * By default is `null`.
+     */
+    data?: Uint8Array;
+}
+
+export interface ecdhOptions {
+    data?: Uint8Array;
+    xbuf?: Uint8Array;
+    ybuf?: Uint8Array;
+    hashfn?: (x: Uint8Array, y: Uint8Array, data: Uint8Array) => Uint8Array;
+}
+
+/**
+ * Verify an ECDSA privateKey.
+ */
+export function privateKeyVerify(privateKey: Uint8Array): boolean;
+
+/**
+ * Export a privateKey in DER format.
+ */
+export function privateKeyExport(privateKey: Uint8Array, compressed?: boolean): Uint8Array;
+
+/**
+ * Import a privateKey in DER format.
+ */
+export function privateKeyImport(privateKey: Uint8Array): Uint8Array;
+
+/**
+ * Negate a privateKey by subtracting it from the order of the curve's base point.
+ */
+export function privateKeyNegate(privateKey: Uint8Array): Uint8Array;
+
+/**
+ * Compute the inverse of a privateKey (modulo the order of the curve's base point).
+ */
+export function privateKeyModInverse(privateKey: Uint8Array): Uint8Array;
+
+/**
+ * Tweak a privateKey by adding tweak to it.
+ */
+export function privateKeyTweakAdd(privateKey: Uint8Array, tweak: Uint8Array): Uint8Array;
+
+/**
+ * Tweak a privateKey by multiplying it by a tweak.
+ */
+export function privateKeyTweakMul(privateKey: Uint8Array, tweak: Uint8Array): Uint8Array;
+
+/**
+ * Compute the public key for a privateKey.
+ */
+export function publicKeyCreate(privateKey: Uint8Array, compressed?: boolean): Uint8Array;
+
+/**
+ * Convert a publicKey to compressed or uncompressed form.
+ */
+export function publicKeyConvert(publicKey: Uint8Array, compressed?: boolean): Uint8Array;
+
+/**
+ * Verify an ECDSA publicKey.
+ */
+export function publicKeyVerify(publicKey: Uint8Array): boolean;
+
+/**
+ * Tweak a publicKey by adding tweak times the generator to it.
+ */
+export function publicKeyTweakAdd(publicKey: Uint8Array, tweak: Uint8Array, compressed?: boolean): Uint8Array;
+
+/**
+ * Tweak a publicKey by multiplying it by a tweak value.
+ */
+export function publicKeyTweakMul(publicKey: Uint8Array, tweak: Uint8Array, compressed?: boolean): Uint8Array;
+
+/**
+ * Add a given publicKeys together.
+ */
+export function publicKeyCombine(publicKeys: Uint8Array[], compressed?: boolean): Uint8Array;
+
+/**
+ * Convert a signature to a normalized lower-S form.
+ */
+export function signatureNormalize(signature: Uint8Array): Uint8Array;
+
+/**
+ * Serialize an ECDSA signature in DER format.
+ */
+export function signatureExport(signature: Uint8Array): Uint8Array;
+
+/**
+ * Parse a DER ECDSA signature (follow by BIP66).
+ */
+export function signatureImport(signature: Uint8Array): Uint8Array;
+
+/**
+ * Create an ECDSA signature. Always return low-S signature.
+ *
+ * Inputs: 32-byte message `m`, 32-byte scalar key `d`, 32-byte scalar nonce `k`.
+ * - Compute point `R = k * G`. Reject nonce if R's `x` coordinate is zero.
+ * - Compute 32-byte scalar `r`, the serialization of R's `x` coordinate.
+ * - Compose 32-byte scalar `s = k^-1 * (r * d + m)`. Reject nonce if `s` is zero.
+ * - The signature is `(r, s)`.
+ */
+export function ecdsaSign(message: Uint8Array, privateKey: Uint8Array, options?: SignOptions): {signature: Uint8Array, recid: number};
+
+/**
+ * Verify an ECDSA signature.
+ *
+ * Note: return false for high signatures!
+ *
+ * Inputs: 32-byte message `m`, public key point `Q`, signature: (32-byte `r`, scalar `s`).
+ * - Signature is invalid if `r` is zero.
+ * - Signature is invalid if `s` is zero.
+ * - Compute point `R = (s^-1 * m * G + s^-1 * r * Q)`. Reject if `R` is infinity.
+ * - Signature is valid if R's `x` coordinate equals to `r`.
+ */
+export function ecdsaVerify(signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): boolean;
+
+/**
+ * Recover an ECDSA public key from a signature.
+ */
+export function ecdsaRecover(signature: Uint8Array, recid: number, message: Uint8Array, compressed?: boolean): Uint8Array;
+
+/**
+ * Compute an EC Diffie-Hellman secret and applied sha256 to compressed public key.
+ */
+export function ecdh(publicKey: Uint8Array, privateKey: Uint8Array, opt?: ecdhOptions): Uint8Array;

package/node_modules/@types/secp256k1/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@types/secp256k1",
+    "version": "4.0.1",
+    "description": "TypeScript definitions for secp256k1",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "Anler",
+            "url": "https://github.com/anler",
+            "githubUsername": "anler"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/secp256k1"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/node": "*"
+    },
+    "typesPublisherContentHash": "ce18928fa4f48686df7b413f8247531848b8f22243b4f53778e7a3bb67f2120e",
+    "typeScriptVersion": "2.8"
+
+,"_resolved": "https://registry.npmjs.org/@types/secp256k1/-/secp256k1-4.0.1.tgz"
+,"_integrity": "sha512-+ZjSA8ELlOp8SlKi0YLB2tz9d5iPNEmOBd+8Rz21wTMdaXQIa9b6TEnD6l5qKOCypE7FSyPyck12qZJxSDNoog=="
+,"_from": "@types/secp256k1@4.0.1"
+}

package/node_modules/ansi-regex/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = options => {
+	options = Object.assign({
+		onlyFirst: false
+	}, options);
+
+	const pattern = [
+		'[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+		'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
+	].join('|');
+
+	return new RegExp(pattern, options.onlyFirst ? undefined : 'g');
+};