@opcat-labs/opcat 1.0.0 → 1.0.2

package/types/crypto/ecdsa.d.cts

@@ -0,0 +1,187 @@
+export = ECDSA;
+/**
+ * Creates an ECDSA instance.
+ * @constructor
+ * @param {Object} [obj] - Optional object containing properties to initialize the instance.
+ */
+declare function ECDSA(obj?: any): ECDSA;
+declare class ECDSA {
+    /**
+     * Creates an ECDSA instance.
+     * @constructor
+     * @param {Object} [obj] - Optional object containing properties to initialize the instance.
+     */
+    constructor(obj?: any);
+    /**
+     * Updates the ECDSA instance properties with provided values.
+     * @param {Object} obj - Object containing properties to update
+     * @param {Buffer} [obj.hashbuf] - Hash buffer
+     * @param {string} [obj.endian] - Endianness of hashbuf
+     * @param {PrivateKey} [obj.privkey] - Private key
+     * @param {PublicKey} [obj.pubkey] - Public key (derived from privkey if not provided)
+     * @param {Signature} [obj.sig] - Signature
+     * @param {BigInteger} [obj.k] - Random number k
+     * @param {boolean} [obj.verified] - Verification status
+     * @returns {ECDSA} Returns the updated ECDSA instance
+     */
+    set(obj: {
+        hashbuf?: Buffer;
+        endian?: string;
+        privkey?: PrivateKey;
+        pubkey?: PublicKey;
+        sig?: Signature;
+        k?: BigInteger;
+        verified?: boolean;
+    }): ECDSA;
+    hashbuf: any;
+    endian: any;
+    privkey: any;
+    pubkey: any;
+    sig: any;
+    k: any;
+    verified: any;
+    /**
+     * Converts the private key to a public key and stores it in the `pubkey` property.
+     */
+    privkey2pubkey(): void;
+    /**
+     * Calculates the recovery factor (i) for ECDSA signature verification.
+     * Iterates through possible recovery factors (0-3) to find the one that
+     * reconstructs the correct public key from the signature.
+     *
+     * @returns {ECDSA} Returns the instance with updated signature properties if successful.
+     * @throws {Error} Throws if no valid recovery factor is found after all iterations.
+     */
+    calci(): ECDSA;
+    /**
+     * Generates a random value `k` for ECDSA signing.
+     * The value is generated within the range (0, N) where N is the curve order.
+     * The generated `k` is stored in the instance and returned for chaining.
+     */
+    randomK(): this;
+    /**
+     * Generates a deterministic K value for ECDSA signing as per RFC 6979.
+     * See:
+     *  https://tools.ietf.org/html/rfc6979#section-3.2
+     * Handles invalid r/s cases by incrementing badrs counter and regenerating K.
+     * @param {number} [badrs=0] - Counter for invalid r/s cases (default: 0)
+     * @returns {ECDSA} Returns the ECDSA instance for chaining
+     */
+    deterministicK(badrs?: number): ECDSA;
+    /**
+     * Converts an ECDSA signature to its corresponding public key.
+     *
+     * The method follows the ECDSA public key recovery process:
+     * 1. Validates the recovery parameter `i` (must be 0-3)
+     * 2. Derives the public key point Q using the formula: Q = r⁻¹(sR - eG)
+     * 3. Validates the derived curve point
+     *
+     * see:
+     *  https://bitcointalk.org/index.php?topic=6430.0
+     *  http://stackoverflow.com/questions/19665491/how-do-i-get-an-ecdsa-public-key-from-just-a-bitcoin-signature-sec1-4-1-6-k
+     * @returns {PublicKey} The recovered public key
+     * @throws {Error} If recovery parameter is invalid or derived point is invalid
+     */
+    toPublicKey(): PublicKey;
+    /**
+     * Validates an ECDSA signature and returns an error message if invalid.
+     * Checks:
+     * - hashbuf is a 32-byte buffer
+     * - r and s values are within valid range
+     * - Signature verification against public key
+     * @returns {string|boolean} Error message if invalid, false if valid
+     */
+    sigError(): string | boolean;
+    /**
+     * Finds a valid ECDSA signature (r, s) for the given private key `d` and message hash `e`.
+     * Uses deterministic k-value generation if initial attempts fail.
+     *
+     * @param {BN} d - Private key as a big number.
+     * @param {BN} e - Message hash as a big number.
+     * @returns {Object} Signature object with properties `r` and `s` (big numbers).
+     * @throws Will throw if unable to find valid signature after multiple attempts.
+     */
+    _findSignature(d: BN, e: BN): any;
+    /**
+     * Signs a message using ECDSA.
+     *
+     * @param {Buffer} hashbuf - 32-byte buffer containing the hash of the message to sign.
+     * @param {PrivateKey} privkey - Private key used for signing.
+     * @returns {ECDSA} Returns the instance for chaining.
+     * @throws {Error} Throws if parameters are invalid or hashbuf is not a 32-byte buffer.
+     */
+    sign(): ECDSA;
+    /**
+     * Signs the message using a randomly generated k value.
+     *
+     * @returns The signature object containing r and s values.
+     */
+    signRandomK(): ECDSA;
+    /**
+     * Converts the ECDSA instance to a JSON string representation.
+     * Includes hash buffer, private key, public key, signature, and k value if present.
+     * Each property is converted to a string format (hex for hashbuf, toString() for others).
+     * @returns {string} JSON string containing the ECDSA instance properties
+     */
+    toString(): string;
+    /**
+     * Verifies the ECDSA signature and updates the `verified` property.
+     * @returns {ECDSA} The current instance for chaining.
+     */
+    verify(): ECDSA;
+}
+declare namespace ECDSA {
+    /**
+     * Creates an ECDSA instance from a JSON string representation.
+     * @param {string} str - JSON string containing ECDSA parameters.
+     * @returns {ECDSA} New ECDSA instance initialized with parsed data.
+     */
+    function fromString(str: string): ECDSA;
+    /**
+     * Converts the signature `s` value to its low-S form to comply with BIP 62.
+     * This prevents signature malleability by ensuring `s` is not greater than half the curve order.
+     * @param {BN} s - The signature `s` value as a big number.
+     * @returns {BN} The low-S normalized value.
+     * @static
+     */
+    function toLowS(s: BN): BN;
+    /**
+     * Signs a message hash using ECDSA with the given private key.
+     * @param {Buffer} hashbuf - The hash of the message to sign
+     * @param {PrivateKey} privkey - The private key to sign with
+     * @param {string} [endian] - Endianness of the input/output (optional)
+     * @returns {Signature} The ECDSA signature
+     */
+    function sign(hashbuf: Buffer, privkey: PrivateKey, endian?: string): Signature;
+    /**
+     * Signs a hash buffer with a private key and calculates the 'i' value.
+     * @param {Buffer} hashbuf - The hash buffer to sign.
+     * @param {Buffer} privkey - The private key used for signing.
+     * @param {string} [endian] - The endianness of the input data (optional).
+     * @returns {Buffer} The resulting signature.
+     * @static
+     */
+    function signWithCalcI(hashbuf: Buffer, privkey: Buffer, endian?: string): Buffer;
+    /**
+     * Signs a message hash using ECDSA with a randomly generated K value.
+     * @param {Buffer} hashbuf - The message hash to sign.
+     * @param {Buffer} privkey - The private key used for signing.
+     * @param {string} [endian] - The endianness of the input/output (default: 'big').
+     * @returns {Buffer} The generated ECDSA signature.
+     * @static
+     */
+    function signRandomK(hashbuf: Buffer, privkey: Buffer, endian?: string): Buffer;
+    /**
+     * Verifies an ECDSA signature against a hash and public key.
+     * @param {Buffer} hashbuf - The hash buffer to verify against.
+     * @param {Signature} sig - The signature to verify.
+     * @param {PublicKey} pubkey - The public key to verify with.
+     * @param {string} [endian] - The endianness of the input data (optional).
+     * @returns {boolean} True if the signature is valid, false otherwise.
+     * @static
+     */
+    function verify(hashbuf: Buffer, sig: Signature, pubkey: PublicKey, endian?: string): boolean;
+}
+import PublicKey = require("../publickey.cjs");
+import Signature = require("./signature.cjs");
+import BN = require("../bn.cjs");

package/types/crypto/hash.d.cts

@@ -0,0 +1,118 @@
+export = Hash;
+/**
+ * Represents a hash utility class.
+ * @constructor
+ */
+declare function Hash(): Hash;
+declare class Hash {
+}
+declare namespace Hash {
+    /**
+     * A SHA or SHA1 hash, which is always 160 bits or 20 bytes long.
+     *
+     * See:
+     * https://en.wikipedia.org/wiki/SHA-1
+     *
+     * @param {Buffer} buf Data, a.k.a. pre-image, which can be any size.
+     * @returns {Buffer} The hash in the form of a buffer.
+     */
+    function sha1(buf: Buffer): Buffer;
+    namespace sha1 {
+        let blocksize: number;
+    }
+    /**
+     * A SHA256 hash, which is always 256 bits or 32 bytes long.
+     *
+     * See:
+     * https://www.movable-type.co.uk/scripts/sha256.html
+     *
+     * @param {Buffer} buf Data, a.k.a. pre-image, which can be any size.
+     * @returns {Buffer} The hash in the form of a buffer.
+     */
+    function sha256(buf: Buffer): Buffer;
+    namespace sha256 {
+        let blocksize_1: number;
+        export { blocksize_1 as blocksize };
+    }
+    /**
+     * A double SHA256 hash, which is always 256 bits or 32 bytes bytes long. This
+     * hash function is commonly used inside Bitcoin, particularly for the hash of a
+     * block and the hash of a transaction.
+     *
+     * See:
+     * https://www.movable-type.co.uk/scripts/sha256.html
+     *
+     * @param {Buffer} buf Data, a.k.a. pre-image, which can be any size.
+     * @returns {Buffer} The hash in the form of a buffer.
+     */
+    function sha256sha256(buf: Buffer): Buffer;
+    /**
+     * A RIPEMD160 hash, which is always 160 bits or 20 bytes long.
+     *
+     * See:
+     * https://en.wikipedia.org/wiki/RIPEMD
+     *
+     * @param {Buffer} buf Data, a.k.a. pre-image, which can be any size.
+     * @returns {Buffer} The hash in the form of a buffer.
+     */
+    function ripemd160(buf: Buffer): Buffer;
+    /**
+     * A RIPEMD160 hash of a SHA256 hash, which is always 160 bits or 20 bytes long.
+     * This value is commonly used inside Bitcoin, particularly for Bitcoin
+     * addresses.
+     *
+     * See:
+     * https://en.wikipedia.org/wiki/RIPEMD
+     *
+     * @param {Buffer} buf Data, a.k.a. pre-image, which can be any size.
+     * @returns {Buffer} The hash in the form of a buffer.
+     */
+    function sha256ripemd160(buf: Buffer): Buffer;
+    /**
+     * A SHA512 hash, which is always 512 bits or 64 bytes long.
+     *
+     * See:
+     * https://en.wikipedia.org/wiki/SHA-2
+     *
+     * @param {Buffer} buf Data, a.k.a. pre-image, which can be any size.
+     * @returns {Buffer} The hash in the form of a buffer.
+     */
+    function sha512(buf: Buffer): Buffer;
+    namespace sha512 {
+        let blocksize_2: number;
+        export { blocksize_2 as blocksize };
+    }
+    /**
+     * A way to do HMAC using any underlying hash function. If you ever find that
+     * you want to hash two pieces of data together, you should use HMAC instead of
+     * just using a hash function. Rather than doing hash(data1 + data2) you should
+     * do HMAC(data1, data2). Actually, rather than use HMAC directly, we recommend
+     * you use either sha256hmac or sha515hmac provided below.
+     *
+     * See:
+     * https://en.wikipedia.org/wiki/Length_extension_attack
+     * https://blog.skullsecurity.org/2012/everything-you-need-to-know-about-hash-length-extension-attacks
+     *
+     * @param {function} hashf Which hash function to use.
+     * @param {Buffer} data Data, which can be any size.
+     * @param {Buffer} key Key, which can be any size.
+     * @returns {Buffer} The HMAC in the form of a buffer.
+     */
+    function hmac(hashf: Function, data: Buffer, key: Buffer): Buffer;
+    /**
+     * A SHA256 HMAC.
+     *
+     * @param {Buffer} data Data, which can be any size.
+     * @param {Buffer} key Key, which can be any size.
+     * @returns {Buffer} The HMAC in the form of a buffer.
+     */
+    function sha256hmac(data: Buffer, key: Buffer): Buffer;
+    /**
+     * A SHA512 HMAC.
+     *
+     * @param {Buffer} data Data, which can be any size.
+     * @param {Buffer} key Key, which can be any size.
+     * @returns {Buffer} The HMAC in the form of a buffer.
+     */
+    function sha512hmac(data: Buffer, key: Buffer): Buffer;
+}

package/types/crypto/index.d.cts

@@ -0,0 +1,7 @@
+import BN = require("../bn.cjs");
+import ECDSA = require("./ecdsa.cjs");
+import Hash = require("./hash.cjs");
+import Random = require("./random.cjs");
+import Point = require("./point.cjs");
+import Signature = require("./signature.cjs");
+export { BN, ECDSA, Hash, Random, Point, Signature };

package/types/crypto/point.d.cts

@@ -0,0 +1,134 @@
+export = Point;
+/**
+ * Instantiate a valid secp256k1 Point from the X and Y coordinates. This class
+ * is just an extension of the secp256k1 code from the library "elliptic" by
+ * Fedor Indutny. It includes a few extra features that are useful in Bitcoin.
+ *
+ * @param {BN|String} x - The X coordinate
+ * @param {BN|String} y - The Y coordinate
+ * @link https://github.com/indutny/elliptic
+ * @augments elliptic.curve.point
+ * @throws {Error} A validation error if exists
+ * @returns {Point} An instance of Point
+ * @constructor
+ */
+declare function Point(x: BN | string, y: BN | string, isRed: any): Point;
+declare class Point {
+    /**
+     * Instantiate a valid secp256k1 Point from the X and Y coordinates. This class
+     * is just an extension of the secp256k1 code from the library "elliptic" by
+     * Fedor Indutny. It includes a few extra features that are useful in Bitcoin.
+     *
+     * @param {BN|String} x - The X coordinate
+     * @param {BN|String} y - The Y coordinate
+     * @link https://github.com/indutny/elliptic
+     * @augments elliptic.curve.point
+     * @throws {Error} A validation error if exists
+     * @returns {Point} An instance of Point
+     * @constructor
+     */
+    constructor(x: BN | string, y: BN | string, isRed: any);
+    _getX: any;
+    /**
+     * Will return the X coordinate of the Point.
+     *
+     * @returns {BN} A BN instance of the X coordinate
+     */
+    getX(): BN;
+    _getY: any;
+    /**
+     * Will return the Y coordinate of the Point.
+     *
+     * @returns {BN} A BN instance of the Y coordinate
+     */
+    getY(): BN;
+    /**
+     * Will determine if the point is valid.
+     *
+     * @link https://www.iacr.org/archive/pkc2003/25670211/25670211.pdf
+     * @throws {Error} A validation error if exists
+     * @returns {Point} An instance of the same Point
+     */
+    validate(): Point;
+    /**
+     * Convert point to a compressed buffer.
+     *
+     * @returns {Buffer} A compressed point.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Convert point to a compressed hex string.
+     *
+     * @returns {string} A compressed point as a hex string.
+     */
+    toHex(): string;
+}
+declare namespace Point {
+    /**
+     *
+     * Instantiate a valid secp256k1 Point from only the X coordinate. This is
+     * useful to rederive a full point from the compressed form of a point.
+     *
+     * @param {boolean} odd - If the Y coordinate is odd
+     * @param {BN|String} x - The X coordinate
+     * @throws {Error} A validation error if exists
+     * @returns {Point} An instance of Point
+     * @static
+     */
+    function fromX(odd: boolean, x: string | BN): Point;
+    /**
+     *
+     * Will return a secp256k1 ECDSA base point.
+     *
+     * @link https://en.bitcoin.it/wiki/Secp256k1
+     * @returns {Point} An instance of the base point.
+     * @static
+     */
+    function getG(): Point;
+    /**
+     *
+     * Will return the max of range of valid private keys as governed by the
+     * secp256k1 ECDSA standard.
+     *
+     * @link https://en.bitcoin.it/wiki/Private_key#Range_of_valid_ECDSA_private_keys
+     * @returns {BN} A BN instance of the number of points on the curve
+     * @static
+     */
+    function getN(): BN;
+    /**
+     * A "compressed" format point is the X part of the (X, Y) point plus an extra
+     * bit (which takes an entire byte) to indicate whether the Y value is odd or
+     * not. Storing points this way takes a bit less space, but requires a bit more
+     * computation to rederive the full point.
+     *
+     * @param {Point} point An instance of Point.
+     * @returns {Buffer} A compressed point in the form of a buffer.
+     * @static
+     */
+    function pointToCompressed(point: Point): Buffer;
+    /**
+     * Converts a compressed buffer into a point.
+     *
+     * @param {Buffer} buf A compressed point.
+     * @returns {Point} A Point.
+     * @static
+     */
+    function pointFromCompressed(buf: Buffer): Point;
+    /**
+     * Converts a compressed buffer into a point.
+     *
+     * @param {Buffer} buf A compressed point.
+     * @returns {Point} A Point.
+     * @static
+     */
+    function fromBuffer(buf: Buffer): Point;
+    /**
+     * Converts a compressed buffer into a point.
+     *
+     * @param {Buffer} hex A compressed point as a hex string.
+     * @returns {Point} A Point.
+     * @static
+     */
+    function fromHex(hex: Buffer): Point;
+}
+import BN = require("../bn.cjs");

package/types/crypto/random.d.cts

@@ -0,0 +1,13 @@
+export = Random;
+/**
+ * A utility class for generating random values.
+ */
+declare function Random(): void;
+declare namespace Random {
+    /**
+     * Generates a cryptographically secure random buffer of the specified size.
+     * @param {number} size - The number of bytes to generate.
+     * @returns {Buffer} A buffer filled with cryptographically secure random bytes.
+     */
+    function getRandomBuffer(size: number): Buffer;
+}

package/types/crypto/signature.d.cts

@@ -0,0 +1,160 @@
+export = Signature;
+/**
+ * Creates a new Signature instance from BN values or an object.
+ * @constructor
+ * @param {BN|Object} r - Either a BN instance for the r value or an object containing r and s properties.
+ * @param {BN} [s] - The s value (required if r is a BN instance).
+ */
+declare function Signature(r: BN | any, s?: BN): Signature;
+declare class Signature {
+    /**
+     * Creates a new Signature instance from BN values or an object.
+     * @constructor
+     * @param {BN|Object} r - Either a BN instance for the r value or an object containing r and s properties.
+     * @param {BN} [s] - The s value (required if r is a BN instance).
+     */
+    constructor(r: BN | any, s?: BN);
+    /**
+     * Sets signature properties from an object.
+     * @param {Object} obj - Object containing signature properties
+     * @param {Buffer} [obj.r] - r value
+     * @param {Buffer} [obj.s] - s value
+     * @param {number} [obj.i] - Public key recovery parameter (0-3)
+     * @param {boolean} [obj.compressed] - Whether recovered pubkey is compressed
+     * @param {number} [obj.nhashtype] - Hash type
+     * @returns {Signature} Returns the signature instance for chaining
+     */
+    set(obj: {
+        r?: Buffer;
+        s?: Buffer;
+        i?: number;
+        compressed?: boolean;
+        nhashtype?: number;
+    }): Signature;
+    r: any;
+    s: any;
+    i: any;
+    compressed: any;
+    nhashtype: any;
+    /**
+     * Converts the signature to a compact format.
+     * @param {number} [i] - The recovery ID (0, 1, 2, or 3). Defaults to the instance's `i` value.
+     * @param {boolean} [compressed] - Whether the signature is compressed. Defaults to the instance's `compressed` value.
+     * @returns {Buffer} - The compact signature as a Buffer (1 byte recovery ID + 32 bytes r + 32 bytes s).
+     * @throws {Error} - If `i` is not 0, 1, 2, or 3.
+     */
+    toCompact(i?: number, compressed?: boolean): Buffer;
+    /**
+     * Converts the signature to DER format.
+     * Handles negative values by prepending a zero byte if necessary.
+     *
+     * @returns {Buffer} The DER-encoded signature.
+     */
+    toBuffer: () => Buffer;
+    toDER(): Buffer;
+    /**
+     * Converts the signature to a hexadecimal string representation.
+     * @returns {string} The DER-encoded signature in hexadecimal format.
+     */
+    toString(): string;
+    /**
+     * Checks if the signature's S value is within the valid range (low-S).
+     * See also ECDSA signature algorithm which enforces this.
+     * See also BIP 62, "low S values in signatures"
+     * @returns {boolean} True if S is between 1 and the upper bound (0x7F...A0), false otherwise.
+     */
+    hasLowS(): boolean;
+    /**
+     * Checks if the signature has a defined hashtype.
+     * - Validates that nhashtype is a natural number
+     * - Accepts with or without Signature.SIGHASH_ANYONECANPAY by ignoring the bit
+     * - Verifies the hashtype is between SIGHASH_ALL and SIGHASH_SINGLE
+     * @returns {boolean} True if the hashtype is valid, false otherwise
+     */
+    hasDefinedHashtype(): boolean;
+    /**
+     * Converts the signature to transaction format by concatenating the DER-encoded signature
+     * with the hash type byte.
+     * @returns {Buffer} The signature in transaction format (DER + hash type byte).
+     */
+    toTxFormat(): Buffer;
+}
+declare namespace Signature {
+    /**
+     * Creates a Signature instance from a compact ECDSA signature buffer.
+     * @param {Buffer} buf - The compact signature buffer (65 bytes).
+     * @returns {Signature} The parsed signature object.
+     * @throws {Error} If the input is invalid (not a Buffer, wrong length, or invalid recovery param).
+     * @static
+     */
+    export function fromCompact(buf: Buffer): Signature;
+    export function fromDER(buf: Buffer, strict?: boolean): Signature;
+    export function fromBuffer(buf: Buffer, strict?: boolean): Signature;
+    /**
+     * Converts a transaction-format signature buffer to a Signature object.
+     * @param {Buffer} buf - The signature buffer in transaction format (DER + hash type byte)
+     * @returns {Signature} The parsed Signature object with nhashtype property set
+     * @static
+     */
+    export function fromTxFormat(buf: Buffer): Signature;
+    /**
+     * Creates a Signature instance from a hex-encoded string.
+     * @param {string} str - Hex-encoded signature string
+     * @returns {Signature} Signature instance parsed from DER format
+     * @static
+     */
+    export function fromString(str: string): Signature;
+    /**
+     * Parses a DER formatted signature buffer into its components.
+     * In order to mimic the non-strict DER encoding of OpenSSL, set strict = false.
+     * @param {Buffer} buf - The DER formatted signature buffer to parse
+     * @param {boolean} [strict=true] - Whether to perform strict length validation
+     * @returns {Object} An object containing the parsed signature components:
+     *   - header: The DER header byte (0x30)
+     *   - length: The total length of the signature components
+     *   - rheader: The R component header byte (0x02)
+     *   - rlength: The length of the R component
+     *   - rneg: Whether R is negative
+     *   - rbuf: The R component buffer
+     *   - r: The R component as a BN
+     *   - sheader: The S component header byte (0x02)
+     *   - slength: The length of the S component
+     *   - sneg: Whether S is negative
+     *   - sbuf: The S component buffer
+     *   - s: The S component as a BN
+     * @throws {Error} If the buffer is not valid DER format or length checks fail
+     * @static
+     */
+    export function parseDER(buf: Buffer, strict?: boolean): any;
+    /**
+     * This function is translated from bitcoind's IsDERSignature and is used in
+     * the script interpreter.  This "DER" format actually includes an extra byte,
+     * the nhashtype, at the end. It is really the tx format, not DER format.
+     *
+     * A canonical signature exists of: [30] [total len] [02] [len R] [R] [02] [len S] [S] [hashtype]
+     * Where R and S are not negative (their first byte has its highest bit not set), and not
+     * excessively padded (do not start with a 0 byte, unless an otherwise negative number follows,
+     * in which case a single 0 byte is necessary and even required).
+     *
+     * See https://bitcointalk.org/index.php?topic=8392.msg127623#msg127623
+     *
+     * @param {Buffer} buf - The buffer containing the signature to verify
+     * @returns {boolean} True if the signature is valid DER-encoded, false otherwise
+     * @static
+     */
+    export function isTxDER(buf: Buffer): boolean;
+    export let SIGHASH_ALL: number;
+    export let SIGHASH_NONE: number;
+    export let SIGHASH_SINGLE: number;
+    export let SIGHASH_ANYONECANPAY: number;
+    import ALL = SIGHASH_ALL;
+    export { ALL };
+    import NONE = SIGHASH_NONE;
+    export { NONE };
+    import SINGLE = SIGHASH_SINGLE;
+    export { SINGLE };
+    export let ANYONECANPAY_ALL: number;
+    export let ANYONECANPAY_NONE: number;
+    export let ANYONECANPAY_SINGLE: number;
+}
+import BN = require("../bn.cjs");