@opcat-labs/opcat 1.0.1 → 1.0.2

package/types/interpreter/interpreter.d.cts

@@ -0,0 +1,228 @@
+export = Interpreter;
+/**
+ * Bitcoin transactions contain scripts. Each input has a script called the
+ * scriptSig, and each output has a script called the scriptPubkey. To validate
+ * an input, the input's script is concatenated with the referenced output script,
+ * and the result is executed. If at the end of execution the stack contains a
+ * "true" value, then the transaction is valid.
+ *
+ * The primary way to use this class is via the verify function.
+ * e.g., Interpreter().verify( ... );
+ * @constructor
+ * @param {Object} [obj] - Optional object to initialize the interpreter with.
+ * @returns {Interpreter} A new Interpreter instance.
+ */
+declare function Interpreter(obj?: any): Interpreter;
+declare class Interpreter {
+    /**
+     * Bitcoin transactions contain scripts. Each input has a script called the
+     * scriptSig, and each output has a script called the scriptPubkey. To validate
+     * an input, the input's script is concatenated with the referenced output script,
+     * and the result is executed. If at the end of execution the stack contains a
+     * "true" value, then the transaction is valid.
+     *
+     * The primary way to use this class is via the verify function.
+     * e.g., Interpreter().verify( ... );
+     * @constructor
+     * @param {Object} [obj] - Optional object to initialize the interpreter with.
+     * @returns {Interpreter} A new Interpreter instance.
+     */
+    constructor(obj?: any);
+    /**
+     * Verifies a Script by executing it and returns true if it is valid.
+     * This function needs to be provided with the scriptSig and the scriptPubkey
+     * separately.
+     * @param {Script} scriptSig - the script's first part (corresponding to the tx input)
+     * @param {Script} scriptPubkey - the script's last part (corresponding to the tx output)
+     * @param {Transaction=} tx - the Transaction containing the scriptSig in one input (used
+     *    to check signature validity for some opcodes like OP_CHECKSIG)
+     * @param {number} nin - index of the transaction input containing the scriptSig verified.
+     * @param {number} flags - evaluation flags. See Interpreter.SCRIPT_* constants
+     * @param {number} satoshisBN - amount in satoshis of the input to be verified (when FORKID signhash is used)
+     *
+     * Translated from bitcoind's VerifyScript
+     */
+    verify(scriptSig: Script, scriptPubkey: Script, tx?: Transaction | undefined, nin: number, flags: number, satoshisBN: number): boolean;
+    errstr: any;
+    /**
+     * Initializes the interpreter instance with default values.
+     * Sets up empty stacks, resets program counter and execution flags,
+     * and initializes state tracking variables for script execution.
+     */
+    initialize(): void;
+    stack: any;
+    altstack: any;
+    pc: any;
+    pbegincodehash: any;
+    nOpCount: any;
+    vfExec: any;
+    vfElse: any;
+    flags: any;
+    nonTopLevelReturnAfterGenesis: boolean;
+    returned: boolean;
+    /**
+     * Updates the interpreter's state with provided values.
+     * @param {Object} obj - Object containing properties to update
+     * @param {Buffer} [obj.script] - Script buffer
+     * @param {Object} [obj.tx] - Transaction object
+     * @param {boolean} [obj.nin] - Non-input flag
+     * @param {BN} [obj.satoshisBN] - Satoshis as BN.js instance
+     * @param {Array} [obj.stack] - Main stack
+     * @param {Array} [obj.altstack] - Alternate stack
+     * @param {number} [obj.pc] - Program counter
+     * @param {number} [obj.pbegincodehash] - Begin code hash position
+     * @param {number} [obj.nOpCount] - Operation count
+     * @param {Array} [obj.vfExec] - Execution flags
+     * @param {Array} [obj.vfElse] - Else flags
+     * @param {string} [obj.errstr] - Error string
+     * @param {number} [obj.flags] - Interpreter flags
+     */
+    set(obj: {
+        script?: Buffer;
+        tx?: any;
+        nin?: boolean;
+        satoshisBN?: BN;
+        stack?: any[];
+        altstack?: any[];
+        pc?: number;
+        pbegincodehash?: number;
+        nOpCount?: number;
+        vfExec?: any[];
+        vfElse?: any[];
+        errstr?: string;
+        flags?: number;
+    }): void;
+    script: any;
+    tx: any;
+    nin: any;
+    satoshisBN: any;
+    /**
+     * Returns a subset of the script starting from the most recent OP_CODESEPARATOR.
+     * @returns {Script} A new Script instance containing the sliced chunks.
+     */
+    subscript(): Script;
+    /**
+     * Checks if a signature encoding is valid according to the interpreter's flags.
+     * - For empty signatures: always valid (used for compact invalid signatures in CHECK(MULTI)SIG)
+     * - With DERSIG/STRICTENC flags: validates DER encoding and strict encoding rules
+     * - With LOW_S flag: ensures signature uses low S value
+     * - With STRICTENC flag: validates defined hash type
+     * @param {Buffer} buf - The signature buffer to validate
+     * @returns {boolean} True if valid, false otherwise (sets errstr on failure)
+     */
+    checkSignatureEncoding(buf: Buffer): boolean;
+    /**
+     * Checks if the provided public key buffer is valid according to strict encoding rules.
+     * Sets an error message if validation fails under SCRIPT_VERIFY_STRICTENC flag.
+     * @param {Buffer} buf - The public key buffer to validate.
+     * @returns {boolean} True if valid, false otherwise (with error string set).
+     */
+    checkPubkeyEncoding(buf: Buffer): boolean;
+    /**
+     * Evaluates a script by executing each opcode step-by-step.
+     * Performs size checks on the script and stacks before execution.
+     *
+     * Based on bitcoind's EvalScript function, with the inner loop moved to `Interpreter.prototype.step()`
+     * bitcoind commit: b5d1b1092998bc95313856d535c632ea5a8f9104
+     * @param {string} scriptType - The type of script being evaluated
+     * @returns {boolean} True if evaluation succeeds, false if any error occurs
+     * @throws {Error} If an unknown error occurs during evaluation
+     */
+    evaluate(scriptType: string): boolean;
+    private _callbackStep;
+    private _callbackStack;
+    /**
+     * Checks a locktime parameter with the transaction's locktime.
+     * There are two times of nLockTime: lock-by-blockheight and lock-by-blocktime,
+     * distinguished by whether nLockTime < LOCKTIME_THRESHOLD = 500000000
+     *
+     * See the corresponding code on bitcoin core:
+     * https://github.com/bitcoin/bitcoin/blob/ffd75adce01a78b3461b3ff05bcc2b530a9ce994/src/script/interpreter.cpp#L1129
+     *
+     * @param {BN} nLockTime the locktime read from the script
+     * @return {boolean} true if the transaction's locktime is less than or equal to
+     *                   the transaction's locktime
+     */
+    checkLockTime(nLockTime: BN): boolean;
+    /**
+     * Checks a sequence parameter with the transaction's sequence.
+     * @param {BN} nSequence the sequence read from the script
+     * @return {boolean} true if the transaction's sequence is less than or equal to
+     *                   the transaction's sequence
+     */
+    checkSequence(nSequence: BN): boolean;
+    /**
+     * Executes a single step in the script interpreter.
+     *
+     * This method processes the current opcode in the script, performs the corresponding operation,
+     * and updates the stack or interpreter state accordingly. It handles various opcode types including
+     * stack operations, arithmetic, bitwise logic, cryptographic operations, and control flow.
+     *
+     * Based on the inner loop of bitcoind's EvalScript function
+     * bitcoind commit: b5d1b1092998bc95313856d535c632ea5a8f9104
+     * @param {string} scriptType - The type of script being executed (e.g., scriptPubkey, scriptSig).
+     * @returns {boolean} Returns `true` if the step executed successfully, or `false` if an error occurred.
+     *                   Errors are stored in `this.errstr`.
+     */
+    step(scriptType: string): boolean;
+}
+declare namespace Interpreter {
+    function getTrue(): Buffer;
+    function getFalse(): Buffer;
+    let MAX_SCRIPT_ELEMENT_SIZE: number;
+    let MAXIMUM_ELEMENT_SIZE: number;
+    let LOCKTIME_THRESHOLD: number;
+    let LOCKTIME_THRESHOLD_BN: BN;
+    let SCRIPT_VERIFY_NONE: number;
+    let SCRIPT_VERIFY_STRICTENC: number;
+    let SCRIPT_VERIFY_DERSIG: number;
+    let SCRIPT_VERIFY_LOW_S: number;
+    let SCRIPT_VERIFY_NULLDUMMY: number;
+    let SCRIPT_VERIFY_SIGPUSHONLY: number;
+    let SCRIPT_VERIFY_MINIMALDATA: number;
+    let SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS: number;
+    let SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY: number;
+    let SCRIPT_VERIFY_CHECKSEQUENCEVERIFY: number;
+    let SCRIPT_VERIFY_NULLFAIL: number;
+    let SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE: number;
+    let SCRIPT_ENABLE_MONOLITH_OPCODES: number;
+    let SCRIPT_ENABLE_MAGNETIC_OPCODES: number;
+    let SEQUENCE_LOCKTIME_DISABLE_FLAG: number;
+    let SEQUENCE_LOCKTIME_TYPE_FLAG: number;
+    let SEQUENCE_LOCKTIME_MASK: number;
+    let MAX_SCRIPT_SIZE: number;
+    let MAX_OPCODE_COUNT: number;
+    let DEFAULT_FLAGS: number;
+    /**
+     * Casts a buffer to a boolean value.
+     * Returns true if any byte in the buffer is non-zero (except for the special case of negative zero).
+     * Returns false if all bytes are zero or if the last byte is 0x80 (negative zero case).
+     * @param {Buffer} buf - The input buffer to check
+     * @returns {boolean} The boolean representation of the buffer
+     */
+    function castToBool(buf: Buffer): boolean;
+    /**
+     * Checks if a buffer is minimally encoded (see https://github.com/bitcoincashorg/spec/blob/master/may-2018-reenabled-opcodes.md#op_bin2num) as a number.
+     * @param {Buffer} buf - The buffer to check.
+     * @param {number} [nMaxNumSize=Interpreter.MAXIMUM_ELEMENT_SIZE] - Maximum allowed size for the buffer.
+     * @returns {boolean} True if the buffer is minimally encoded, false otherwise.
+     * @private
+     */
+    function _isMinimallyEncoded(buf: Buffer, nMaxNumSize?: number): boolean;
+    /**
+     * Minimally encodes a buffer by removing unnecessary trailing zeros.
+     *
+     * This function implements minimal encoding rules for script numbers:
+     * - Empty buffer remains empty
+     * - Last byte must not be 0x00 or 0x80 unless necessary
+     * - Single zero byte encodes as empty buffer
+     * - Preserves sign bit when trimming
+     *
+     * @param {Buffer} buf - The input buffer to encode
+     * @returns {Buffer} Minimally encoded buffer (may be empty)
+     */
+    function _minimallyEncode(buf: Buffer): Buffer;
+}
+import Script = require("../script/script.cjs");
+import Transaction = require("../transaction/transaction.cjs");
+import BN = require("../bn.cjs");

package/types/interpreter/stack.d.cts

@@ -0,0 +1,35 @@
+export = Stack;
+/**
+ * Represents a stack structure with optional variable stack support.
+ * @constructor
+ * @param {Array} rawstack - The initial stack array
+ * @param {Array} [varStack] - Optional variable stack array
+ */
+declare function Stack(rawstack: any[], varStack?: any[]): void;
+declare class Stack {
+    /**
+     * Represents a stack structure with optional variable stack support.
+     * @constructor
+     * @param {Array} rawstack - The initial stack array
+     * @param {Array} [varStack] - Optional variable stack array
+     */
+    constructor(rawstack: any[], varStack?: any[]);
+    stack: any[];
+    varStack: any[];
+    pushVar(varName: any): void;
+    popVar(): void;
+    push(n: any, varName: any): void;
+    pop(): any;
+    updateTopVars(vars: any): void;
+    stacktop(i: any): any;
+    vartop(i: any): any;
+    slice(start: any, end: any): any[];
+    splice(start: any, deleteCount: any, ...items: any[]): any[];
+    write(i: any, value: any): void;
+    copy(): Stack;
+    printVarStack(): void;
+    checkConsistency(): void;
+    checkConsistencyWithVars(varStack: any): void;
+    get length(): number;
+    get rawstack(): any[];
+}

package/types/message/message.d.cts

@@ -0,0 +1,110 @@
+export = Message;
+/**
+ * Creates a Message instance from a string or Buffer.
+ * @constructor
+ * @param {string|Buffer} message - The message content as either a string or Buffer
+ * @throws {Error} Will throw if message is not a string or Buffer
+ * @returns {Message} A new Message instance containing the message buffer
+ */
+declare function Message(message: string | Buffer): Message;
+declare class Message {
+    /**
+     * Creates a Message instance from a string or Buffer.
+     * @constructor
+     * @param {string|Buffer} message - The message content as either a string or Buffer
+     * @throws {Error} Will throw if message is not a string or Buffer
+     * @returns {Message} A new Message instance containing the message buffer
+     */
+    constructor(message: string | Buffer);
+    messageBuffer: Buffer;
+    /**
+     * Calculates the magic hash for the message by concatenating magic bytes prefixes
+     * with the message buffer and computing a double SHA-256 hash.
+     * @returns {Buffer} The resulting 32-byte hash.
+     */
+    magicHash(): Buffer;
+    private _sign;
+    /**
+     * Will sign a message with a given bitcoin private key.
+     *
+     * @param {PrivateKey} privateKey - An instance of PrivateKey
+     * @returns {String} A base64 encoded compact signature
+     */
+    sign(privateKey: PrivateKey): string;
+    /**
+     * Verifies the message signature using the provided public key.
+     * @param {PublicKey} publicKey - The public key to verify against
+     * @param {Signature} signature - The signature to verify
+     * @returns {boolean} True if signature is valid, false otherwise
+     * @throws {Error} If arguments are not valid PublicKey/Signature instances
+     */
+    _verify(publicKey: PublicKey, signature: Signature): boolean;
+    error: string;
+    /**
+     * Will return a boolean of the signature is valid for a given bitcoin address.
+     * If it isn't the specific reason is accessible via the "error" member.
+     *
+     * @param {Address|String} bitcoinAddress - A bitcoin address
+     * @param {String} signatureString - A base64 encoded compact signature
+     * @returns {Boolean}
+     */
+    verify(bitcoinAddress: Address | string, signatureString: string): boolean;
+    /**
+     * Converts the message to a plain object with hex representation.
+     * @returns {Object} An object containing the hex string of the message buffer.
+     */
+    toObject(): any;
+    /**
+     * Converts the Message instance to a JSON string representation.
+     * @returns {string} The JSON string representation of the Message object.
+     */
+    toJSON(): string;
+    /**
+     * Converts the message buffer to a string representation.
+     * @returns {string} The string representation of the message buffer.
+     */
+    toString(): string;
+    /**
+     * Custom inspect method for Message instances.
+     * @returns {string} String representation in format '<Message: [content]>'.
+     */
+    inspect(): string;
+}
+declare namespace Message {
+    /**
+     * Signs a message with the given private key.
+     * @param {string|Buffer} message - The message to sign.
+     * @param {PrivateKey} privateKey - The private key used for signing.
+     * @returns {Message} The signed message instance.
+     */
+    function sign(message: string | Buffer, privateKey: PrivateKey): Message;
+    function verify(message: any, address: any, signature: any): boolean;
+    let MAGIC_BYTES: Buffer;
+    /**
+     * Instantiate a message from a message string
+     *
+     * @param {String} str - A string of the message
+     * @returns {Message} A new instance of a Message
+     */
+    function fromString(str: string): Message;
+    /**
+     * Instantiate a message from JSON
+     *
+     * @param {String} json - An JSON string or Object with keys: message
+     * @returns {Message} A new instance of a Message
+     */
+    function fromJSON(json: string): Message;
+    /**
+     * Creates a Message instance from an object containing a hex-encoded message.
+     * @param {Object} obj - The source object containing the message data.
+     * @param {string} obj.messageHex - Hex-encoded message string.
+     * @returns {Message} A new Message instance created from the decoded buffer.
+     */
+    function fromObject(obj: {
+        messageHex: string;
+    }): Message;
+}
+import PrivateKey = require("../privatekey.cjs");
+import PublicKey = require("../publickey.cjs");
+import Signature = require("../crypto/signature.cjs");
+import Address = require("../address.cjs");

package/types/mnemonic/index.d.cts

@@ -0,0 +1,2 @@
+export = Mnemonic;
+import Mnemonic = require("./mnemonic.cjs");

package/types/mnemonic/mnemonic.d.cts

@@ -0,0 +1,171 @@
+export = Mnemonic;
+/**
+ * This is an immutable class that represents a BIP39 Mnemonic code.
+ * See BIP39 specification for more info: https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki
+ * A Mnemonic code is a a group of easy to remember words used for the generation
+ * of deterministic wallets. A Mnemonic can be used to generate a seed using
+ * an optional passphrase, for later generate a HDPrivateKey.
+ *
+ * @example
+ * // generate a random mnemonic
+ * var mnemonic = new Mnemonic();
+ * var phrase = mnemonic.phrase;
+ *
+ * // use a different language
+ * var mnemonic = new Mnemonic(Mnemonic.Words.SPANISH);
+ * var xprivkey = mnemonic.toHDPrivateKey();
+ *
+ * @param {Buffer|string|number} [data] - Input data (Buffer for seed, string for phrase, or number for entropy bits)
+ * @param {Array} [wordlist] - Optional wordlist for phrase generation/validation
+ * @throws {InvalidArgument} If invalid data type provided
+ * @throws {Mnemonic.UnknownWordlist} If phrase language can't be detected
+ * @throws {Mnemonic.InvalidMnemonic} If phrase is invalid
+ * @throws {InvalidArgument} If invalid ENT value (must be >=128 and divisible by 32)
+ * @returns {Mnemonic} A new instance of Mnemonic
+ * @constructor
+ */
+declare function Mnemonic(data?: Buffer | string | number, wordlist?: any[]): Mnemonic;
+declare class Mnemonic {
+    /**
+     * This is an immutable class that represents a BIP39 Mnemonic code.
+     * See BIP39 specification for more info: https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki
+     * A Mnemonic code is a a group of easy to remember words used for the generation
+     * of deterministic wallets. A Mnemonic can be used to generate a seed using
+     * an optional passphrase, for later generate a HDPrivateKey.
+     *
+     * @example
+     * // generate a random mnemonic
+     * var mnemonic = new Mnemonic();
+     * var phrase = mnemonic.phrase;
+     *
+     * // use a different language
+     * var mnemonic = new Mnemonic(Mnemonic.Words.SPANISH);
+     * var xprivkey = mnemonic.toHDPrivateKey();
+     *
+     * @param {Buffer|string|number} [data] - Input data (Buffer for seed, string for phrase, or number for entropy bits)
+     * @param {Array} [wordlist] - Optional wordlist for phrase generation/validation
+     * @throws {InvalidArgument} If invalid data type provided
+     * @throws {Mnemonic.UnknownWordlist} If phrase language can't be detected
+     * @throws {Mnemonic.InvalidMnemonic} If phrase is invalid
+     * @throws {InvalidArgument} If invalid ENT value (must be >=128 and divisible by 32)
+     * @returns {Mnemonic} A new instance of Mnemonic
+     * @constructor
+     */
+    constructor(data?: Buffer | string | number, wordlist?: any[]);
+    /**
+     * Will generate a seed based on the mnemonic and optional passphrase. Note that
+     * this seed is absolutely NOT the seed that is output by .toSeed(). These are
+     * two different seeds. The seed you want to put in here, if any, is just some
+     * random byte string. Normally you should rely on the .fromRandom() method.
+     *
+     * @param {String} [passphrase]
+     * @returns {Buffer}
+     */
+    toSeed(passphrase?: string): Buffer;
+    /**
+     *
+     * Generates a HD Private Key from a Mnemonic.
+     * Optionally receive a passphrase and bitcoin network.
+     *
+     * @param {String=} [passphrase]
+     * @param {Network|String|number=} [network] - The network: 'livenet' or 'testnet'
+     * @returns {HDPrivateKey}
+     */
+    toHDPrivateKey(passphrase?: string | undefined, network?: (Network | string | number) | undefined): HDPrivateKey;
+    /**
+     * Will return a the string representation of the mnemonic
+     *
+     * @returns {String} Mnemonic
+     */
+    toString(): string;
+    /**
+     * Will return a string formatted for the console
+     *
+     * @returns {String} Mnemonic
+     */
+    inspect(): string;
+}
+declare namespace Mnemonic {
+    /**
+     * Creates a new Mnemonic instance with random entropy using the specified wordlist.
+     * @param {Array} [wordlist=Mnemonic.Words.ENGLISH] - The wordlist to use for mnemonic generation (defaults to English).
+     * @returns {Mnemonic} A new Mnemonic instance with random entropy.
+     */
+    export function fromRandom(wordlist?: any[]): Mnemonic;
+    /**
+     * Creates a Mnemonic instance from a mnemonic string.
+     * @param {string} mnemonic - The mnemonic phrase string.
+     * @param {string} [wordlist=Mnemonic.Words.ENGLISH] - Optional wordlist (defaults to English).
+     * @returns {Mnemonic} A new Mnemonic instance.
+     */
+    export function fromString(mnemonic: string, wordlist?: string): Mnemonic;
+    /**
+     * Will return a boolean if the mnemonic is valid
+     *
+     * @example
+     *
+     * var valid = Mnemonic.isValid('lab rescue lunch elbow recall phrase perfect donkey biology guess moment husband');
+     * // true
+     *
+     * @param {String} mnemonic - The mnemonic string
+     * @param {String} [wordlist] - The wordlist used
+     * @returns {boolean}
+     */
+    export function isValid(mnemonic: string, wordlist?: string): boolean;
+    /**
+     * Internal function to check if a mnemonic belongs to a wordlist.
+     *
+     * @param {String} mnemonic - The mnemonic string
+     * @param {String} wordlist - The wordlist
+     * @returns {boolean}
+     * @private
+     */
+    export function _belongsToWordlist(mnemonic: string, wordlist: string): boolean;
+    /**
+     * Internal function to detect the wordlist used to generate the mnemonic.
+     *
+     * @param {String} mnemonic - The mnemonic string
+     * @returns {Array} the wordlist or null
+     * @private
+     */
+    export function _getDictionary(mnemonic: string): any[];
+    /**
+     * Will generate a Mnemonic object based on a seed.
+     *
+     * @param {Buffer} [seed]
+     * @param {string} [wordlist]
+     * @returns {Mnemonic}
+     */
+    export function fromSeed(seed?: Buffer, wordlist?: string): Mnemonic;
+    /**
+     * Internal function to generate a random mnemonic
+     *
+     * @param {Number} ENT - Entropy size, defaults to 128
+     * @param {Array} wordlist - Array of words to generate the mnemonic
+     * @returns {String} Mnemonic string
+     * @private
+     */
+    export function _mnemonic(ENT: number, wordlist: any[]): string;
+    /**
+     * Internal function to generate mnemonic based on entropy
+     *
+     * @param {Number} entropy - Entropy buffer
+     * @param {Array} wordlist - Array of words to generate the mnemonic
+     * @returns {String} Mnemonic string
+     * @private
+     */
+    export function _entropy2mnemonic(entropy: number, wordlist: any[]): string;
+    /**
+     * Internal function to create checksum of entropy
+     *
+     * @param entropy
+     * @returns {string} Checksum of entropy length / 32
+     * @private
+     */
+    export function _entropyChecksum(entropy: any): string;
+    export { Words };
+    export { pbkdf2 };
+}
+import HDPrivateKey = require("../hdprivatekey.cjs");
+import Words = require("./words/index.cjs");
+import pbkdf2 = require("./pbkdf2.cjs");

package/types/mnemonic/pbkdf2.d.cts

@@ -0,0 +1,14 @@
+export = pbkdf2;
+/**
+ * PDKBF2: Derives a key using PBKDF2 (Password-Based Key Derivation Function 2) with HMAC-SHA512.
+ * Credit to: https://github.com/stayradiated/pbkdf2-sha512
+ *
+ * @param {string|Buffer} key - The input key/password (as string or Buffer)
+ * @param {string|Buffer} salt - The salt value (as string or Buffer)
+ * @param {number} iterations - Number of iterations to perform
+ * @param {number} dkLen - Desired length of the derived key in bytes
+ * @returns {Buffer} Derived key as Buffer
+ * @throws {TypeError} If key or salt are not strings or Buffers
+ * @throws {Error} If requested key length is too long
+ */
+declare function pbkdf2(key: string | Buffer, salt: string | Buffer, iterations: number, dkLen: number): Buffer;

package/types/mnemonic/words/chinese.d.cts

@@ -0,0 +1,2 @@
+export = chinese;
+declare var chinese: string[];

package/types/mnemonic/words/english.d.cts

@@ -0,0 +1,2 @@
+export = english;
+declare var english: string[];

package/types/mnemonic/words/french.d.cts

@@ -0,0 +1,2 @@
+export = french;
+declare var french: string[];

package/types/mnemonic/words/index.d.cts

@@ -0,0 +1,22 @@
+export = Words;
+/**
+ * Represents a collection of words for mnemonic purposes.
+ * @constructor
+ */
+declare function Words(): void;
+declare class Words {
+}
+declare namespace Words {
+    export { chinese as CHINESE };
+    export { english as ENGLISH };
+    export { french as FRENCH };
+    export { italian as ITALIAN };
+    export { japanese as JAPANESE };
+    export { spanish as SPANISH };
+}
+import chinese = require("./chinese.cjs");
+import english = require("./english.cjs");
+import french = require("./french.cjs");
+import italian = require("./italian.cjs");
+import japanese = require("./japanese.cjs");
+import spanish = require("./spanish.cjs");

package/types/mnemonic/words/italian.d.cts

@@ -0,0 +1,2 @@
+export = italian;
+declare var italian: string[];

package/types/mnemonic/words/japanese.d.cts

@@ -0,0 +1,2 @@
+export = japanese;
+declare var japanese: string[];

package/types/mnemonic/words/spanish.d.cts

@@ -0,0 +1,2 @@
+export = spanish;
+declare var spanish: string[];

package/types/network.d.cts

@@ -0,0 +1,11 @@
+export = Network;
+/**
+ * A network is merely a map containing values that correspond to version
+ * numbers for each bitcoin network. Currently only supporting "livenet"
+ * (a.k.a. "mainnet"), "testnet", "regtest".
+ * @constructor
+ */
+declare function Network(): void;
+declare class Network {
+    toString(): any;
+}