@opcat-labs/opcat 1.0.1 → 1.0.3

package/types/hash-cache.d.cts

@@ -0,0 +1,65 @@
+export = HashCache;
+/**
+ * A class representing a cache for transaction hash buffers.
+ * Provides methods for serialization/deserialization between Buffer, JSON, and hex formats.
+ *
+ * @class
+ * @property {Buffer} prevoutsHashBuf - Hash buffer for transaction prevouts
+ * @property {Buffer} sequenceHashBuf - Hash buffer for transaction sequence
+ * @property {Buffer} outputsHashBuf - Hash buffer for transaction outputs
+ */
+declare class HashCache {
+    /**
+     * Creates a HashCache instance from a buffer by parsing it as JSON.
+     * @param {Buffer} buf - The input buffer containing JSON data.
+     * @returns {HashCache} A new HashCache instance created from the parsed JSON.
+     */
+    static fromBuffer(buf: Buffer): HashCache;
+    /**
+     * Creates a HashCache instance from a JSON object.
+     * @param {Object} json - The JSON object containing hash buffers in hex format.
+     * @param {string} [json.prevoutsHashBuf] - Hex string for prevouts hash buffer.
+     * @param {string} [json.sequenceHashBuf] - Hex string for sequence hash buffer.
+     * @param {string} [json.outputsHashBuf] - Hex string for outputs hash buffer.
+     * @returns {HashCache} A new HashCache instance with converted Buffer values.
+     */
+    static fromJSON(json: {
+        prevoutsHashBuf?: string;
+        sequenceHashBuf?: string;
+        outputsHashBuf?: string;
+    }): HashCache;
+    /**
+     * Creates a HashCache instance from a hex string.
+     * @param {string} hex - The hex string to convert to a buffer.
+     * @returns {HashCache} A HashCache instance created from the hex string buffer.
+     */
+    static fromHex(hex: string): HashCache;
+    /**
+     * Constructs a new hash cache instance with the provided hash buffers.
+     * @param {Buffer} prevoutsHashBuf - Hash buffer for prevouts
+     * @param {Buffer} sequenceHashBuf - Hash buffer for sequence
+     * @param {Buffer} outputsHashBuf - Hash buffer for outputs
+     */
+    constructor(prevoutsHashBuf: Buffer, sequenceHashBuf: Buffer, outputsHashBuf: Buffer);
+    prevoutsHashBuf: Buffer;
+    sequenceHashBuf: Buffer;
+    outputsHashBuf: Buffer;
+    /**
+     * Converts the object to a Buffer containing its JSON string representation.
+     * @returns {Buffer} A Buffer containing the JSON string of the object.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Converts the hash cache object to a JSON representation.
+     * @returns {Object} An object containing hex string representations of the hash buffers:
+     *                   - prevoutsHashBuf: Hex string of prevouts hash buffer (if exists)
+     *                   - sequenceHashBuf: Hex string of sequence hash buffer (if exists)
+     *                   - outputsHashBuf: Hex string of outputs hash buffer (if exists)
+     */
+    toJSON(): any;
+    /**
+     * Converts the object's buffer representation to a hexadecimal string.
+     * @returns {string} Hexadecimal string representation of the buffer.
+     */
+    toHex(): string;
+}

package/types/hdprivatekey.d.cts

@@ -0,0 +1,281 @@
+export = HDPrivateKey;
+/**
+ * Creates a new HDPrivateKey instance from various input formats.
+ * More info on https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
+ * @constructor
+ * @param {HDPrivateKey|string|Buffer|Object} arg - Input can be:
+ *   - Existing HDPrivateKey instance (returns same instance)
+ *   - Network name (generates random key for that network)
+ *   - Serialized string/Buffer (base58 encoded)
+ *   - JSON string
+ *   - Object with key properties
+ * @throws {hdErrors.UnrecognizedArgument} If input format is not recognized
+ * @throws {Error} If serialized input is invalid
+ */
+declare function HDPrivateKey(arg: HDPrivateKey | string | Buffer | any): HDPrivateKey;
+declare class HDPrivateKey {
+    /**
+     * Creates a new HDPrivateKey instance from various input formats.
+     * More info on https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
+     * @constructor
+     * @param {HDPrivateKey|string|Buffer|Object} arg - Input can be:
+     *   - Existing HDPrivateKey instance (returns same instance)
+     *   - Network name (generates random key for that network)
+     *   - Serialized string/Buffer (base58 encoded)
+     *   - JSON string
+     *   - Object with key properties
+     * @throws {hdErrors.UnrecognizedArgument} If input format is not recognized
+     * @throws {Error} If serialized input is invalid
+     */
+    constructor(arg: HDPrivateKey | string | Buffer | any);
+    get hdPublicKey(): HDPublicKey;
+    get xpubkey(): any;
+    /**
+     * WARNING: This method will not be officially supported until v1.0.0.
+     *
+     *
+     * Get a derived child based on a string or number.
+     *
+     * If the first argument is a string, it's parsed as the full path of
+     * derivation. Valid values for this argument include "m" (which returns the
+     * same private key), "m/0/1/40/2'/1000", where the ' quote means a hardened
+     * derivation.
+     *
+     * If the first argument is a number, the child with that index will be
+     * derived. If the second argument is truthy, the hardened version will be
+     * derived. See the example usage for clarification.
+     *
+     * WARNING: The `nonCompliant` option should NOT be used, except for older implementation
+     * that used a derivation strategy that used a non-zero padded private key.
+     *
+     * @example
+     * ```javascript
+     * var parent = new HDPrivateKey('xprv...');
+     * var child_0_1_2h = parent.deriveChild(0).deriveChild(1).deriveChild(2, true);
+     * var copy_of_child_0_1_2h = parent.deriveChild("m/0/1/2'");
+     * assert(child_0_1_2h.xprivkey === copy_of_child_0_1_2h);
+     * ```
+     *
+     * @param {string|number} arg
+     * @param {boolean} [hardened]
+     */
+    deriveChild(arg: string | number, hardened?: boolean): HDPrivateKey;
+    /**
+     * WARNING: This method will not be officially supported until v1.0.0
+     *
+     *
+     * WARNING: If this is a new implementation you should NOT use this method, you should be using
+     * `derive` instead.
+     *
+     * This method is explicitly for use and compatibility with an implementation that
+     * was not compliant with BIP32 regarding the derivation algorithm. The private key
+     * must be 32 bytes hashing, and this implementation will use the non-zero padded
+     * serialization of a private key, such that it's still possible to derive the privateKey
+     * to recover those funds.
+     *
+     * @param {number|string} arg - Either a child index number or derivation path string
+     * @param {boolean} [hardened] - Whether to create hardened derivation (only used with number arg)
+     * @returns {HDPrivateKey} The derived child private key
+     * @throws {hdErrors.InvalidDerivationArgument} If argument type is invalid
+     */
+    deriveNonCompliantChild(arg: number | string, hardened?: boolean): HDPrivateKey;
+    private _deriveWithNumber;
+    private _deriveFromString;
+    private _buildFromJSON;
+    private _buildFromObject;
+    private _buildFromSerialized;
+    private _generateRandomly;
+    private _calcHDPublicKey;
+    _hdPublicKey: HDPublicKey;
+    /**
+     * Converts the HDPrivateKey instance to its corresponding HDPublicKey.
+     * @returns {HDPublicKey} The derived HD public key.
+     */
+    toHDPublicKey(): HDPublicKey;
+    /**
+     * Returns the private key associated with this HD private key.
+     * @returns {PrivateKey} The private key instance.
+     */
+    toPrivateKey(): PrivateKey;
+    private _buildFromBuffers;
+    /**
+     * Returns the extended private key string representation of this HDPrivateKey.
+     *  (a string starting with "xprv...")
+     * @returns {string} The extended private key in base58 string format.
+     */
+    toString(): string;
+    /**
+     * Returns the console representation of this extended private key.
+     * @return string
+     */
+    inspect(): string;
+    /**
+     * Returns a plain object with a representation of this private key.
+     *
+     * Fields include:
+     * <ul>
+     * <li> network: either 'livenet' or 'testnet' </li>
+     * <li> depth: a number ranging from 0 to 255 </li>
+     * <li> fingerPrint: a number ranging from 0 to 2^32-1, taken from the hash of the associated public key </li>
+     * <li> parentFingerPrint: a number ranging from 0 to 2^32-1, taken from the hash of this parent's associated public key or zero. </li>
+     * <li> childIndex: the index from which this child was derived (or zero) </li>
+     * <li> chainCode: an hexa string representing a number used in the derivation </li>
+     * <li> privateKey: the private key associated, in hexa representation </li>
+     * <li> xprivkey: the representation of this extended private key in checksum base58 format </li>
+     * <li> checksum: the base58 checksum of xprivkey </li>
+     * </ul>
+     *  @return {Object}
+     */
+    toObject: () => any;
+    toJSON(): any;
+    /**
+     * Returns a buffer representation of the HDPrivateKey
+     *
+     * @return {string}
+     */
+    toBuffer(): string;
+    /**
+     * Returns a hex string representation of the HDPrivateKey
+     *
+     * @return {string}
+     */
+    toHex(): string;
+}
+declare namespace HDPrivateKey {
+    /**
+     * Creates a new HDPrivateKey instance with random values.
+     * @returns {HDPrivateKey} A new HDPrivateKey object with randomly generated properties.
+     */
+    export function fromRandom(): HDPrivateKey;
+    /**
+     * Verifies that a given path is valid.
+     *
+     * @param {string|number} arg
+     * @param {boolean} [hardened]
+     * @return {boolean}
+     */
+    export function isValidPath(arg: string | number, hardened?: boolean): boolean;
+    /**
+     * Verifies that a given serialized private key in base58 with checksum format
+     * is valid.
+     *
+     * @param {string|Buffer} data - the serialized private key
+     * @param {string|Network} network - optional, if present, checks that the
+     *     network provided matches the network serialized.
+     * @return {boolean}
+     */
+    export function isValidSerialized(data: string | Buffer, network: any): boolean;
+    /**
+     * Checks what's the error that causes the validation of a serialized private key
+     * in base58 with checksum to fail.
+     *
+     * @param {string|Buffer} data - the serialized private key
+     * @param {string|Network} network - optional, if present, checks that the
+     *     network provided matches the network serialized.
+     * @return {errors.InvalidArgument|null}
+     */
+    export function getSerializedError(data: string | Buffer, network: any): any;
+    /**
+     * Validates if the provided data matches the expected network's extended private key version.
+     * @param {Buffer} data - The data buffer to validate (must include version bytes).
+     * @param {string|Network} networkArg - Network identifier or Network object to validate against.
+     * @returns {Error|null} Returns error if validation fails, otherwise null.
+     * @private
+     */
+    export function _validateNetwork(data: Buffer, networkArg: any): Error;
+    /**
+     * Creates an HDPrivateKey instance from a string representation.
+     * @param {string} arg - The string to convert to an HDPrivateKey
+     * @returns {HDPrivateKey} A new HDPrivateKey instance
+     * @throws {Error} If the input is not a valid string
+     */
+    export function fromString(arg: string): HDPrivateKey;
+    /**
+     * Creates an HDPrivateKey instance from a plain object.
+     * @param {Object} arg - The object containing HDPrivateKey properties.
+     * @throws {Error} Throws if argument is not a valid object.
+     * @returns {HDPrivateKey} A new HDPrivateKey instance.
+     */
+    export function fromObject(arg: any): HDPrivateKey;
+    /**
+     * Generate a private key from a seed, as described in BIP32
+     *
+     * @param {string|Buffer} hexa
+     * @param {Network} [network]
+     * @return HDPrivateKey
+     * @static
+     */
+    export function fromSeed(hexa: string | Buffer, network?: Network): HDPrivateKey;
+    /**
+     * Validates buffer arguments for HDPrivateKey.
+     * Checks that each required buffer field exists and has the correct size.
+     * @private
+     * @param {Object} arg - Object containing buffer fields to validate
+     * @param {Buffer} arg.version - Version buffer
+     * @param {Buffer} arg.depth - Depth buffer
+     * @param {Buffer} arg.parentFingerPrint - Parent fingerprint buffer
+     * @param {Buffer} arg.childIndex - Child index buffer
+     * @param {Buffer} arg.chainCode - Chain code buffer
+     * @param {Buffer} arg.privateKey - Private key buffer
+     * @param {Buffer} [arg.checksum] - Optional checksum buffer
+     */
+    export function _validateBufferArguments(arg: {
+        version: Buffer;
+        depth: Buffer;
+        parentFingerPrint: Buffer;
+        childIndex: Buffer;
+        chainCode: Buffer;
+        privateKey: Buffer;
+        checksum?: Buffer;
+    }): void;
+    /**
+     * Build a HDPrivateKey from a buffer
+     *
+     * @param {Buffer} arg
+     * @return {HDPrivateKey}
+     */
+    export function fromBuffer(buf: any): HDPrivateKey;
+    /**
+     * Build a HDPrivateKey from a hex string
+     *
+     * @param {string} hex
+     * @return {HDPrivateKey}
+     */
+    export function fromHex(hex: string): HDPrivateKey;
+    export let DefaultDepth: number;
+    export let DefaultFingerprint: number;
+    export let DefaultChildIndex: number;
+    export let Hardened: number;
+    export let MaxIndex: number;
+    export let RootElementAlias: string;
+    export let VersionSize: number;
+    export let DepthSize: number;
+    export let ParentFingerPrintSize: number;
+    export let ChildIndexSize: number;
+    export let ChainCodeSize: number;
+    export let PrivateKeySize: number;
+    export let CheckSumSize: number;
+    export let DataLength: number;
+    export let SerializedByteSize: number;
+    export let VersionStart: number;
+    export let VersionEnd: number;
+    import DepthStart = VersionEnd;
+    export { DepthStart };
+    export let DepthEnd: number;
+    import ParentFingerPrintStart = DepthEnd;
+    export { ParentFingerPrintStart };
+    export let ParentFingerPrintEnd: number;
+    import ChildIndexStart = ParentFingerPrintEnd;
+    export { ChildIndexStart };
+    export let ChildIndexEnd: number;
+    import ChainCodeStart = ChildIndexEnd;
+    export { ChainCodeStart };
+    export let ChainCodeEnd: number;
+    export let PrivateKeyStart: number;
+    export let PrivateKeyEnd: number;
+    import ChecksumStart = PrivateKeyEnd;
+    export { ChecksumStart };
+    export let ChecksumEnd: number;
+}
+import HDPublicKey = require("./hdpublickey.cjs");
+import PrivateKey = require("./privatekey.cjs");

package/types/hdpublickey.d.cts

@@ -0,0 +1,240 @@
+export = HDPublicKey;
+/**
+ * The representation of an hierarchically derived public key.
+ *
+ * See https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
+ *
+ * @constructor
+ * @param {Object|string|Buffer} arg
+ */
+declare function HDPublicKey(arg: any | string | Buffer): HDPublicKey;
+declare class HDPublicKey {
+    /**
+     * The representation of an hierarchically derived public key.
+     *
+     * See https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
+     *
+     * @constructor
+     * @param {Object|string|Buffer} arg
+     */
+    constructor(arg: any | string | Buffer);
+    /**
+     * WARNING: This method will not be officially supported until v1.0.0.
+     *
+     *
+     * Get a derivated child based on a string or number.
+     *
+     * If the first argument is a string, it's parsed as the full path of
+     * derivation. Valid values for this argument include "m" (which returns the
+     * same public key), "m/0/1/40/2/1000".
+     *
+     * Note that hardened keys can't be derived from a public extended key.
+     *
+     * If the first argument is a number, the child with that index will be
+     * derived. See the example usage for clarification.
+     *
+     * @example
+     * ```javascript
+     * var parent = new HDPublicKey('xpub...');
+     * var child_0_1_2 = parent.deriveChild(0).deriveChild(1).deriveChild(2);
+     * var copy_of_child_0_1_2 = parent.deriveChild("m/0/1/2");
+     * assert(child_0_1_2.xprivkey === copy_of_child_0_1_2);
+     * ```
+     *
+     * @param {string|number} arg - The index or path to derive
+     * @param {boolean} [hardened=false] - Whether to use hardened derivation
+     * @returns {HDPublicKey} The derived child public key
+     */
+    deriveChild(arg: string | number, hardened?: boolean): HDPublicKey;
+    private _deriveWithNumber;
+    private _deriveFromString;
+    private _buildFromObject;
+    private _buildFromSerialized;
+    private _buildFromBuffers;
+    /**
+     * Returns the base58 checked representation of the public key
+     * @return {string} a string starting with "xpub..." in livenet
+     */
+    toString(): string;
+    /**
+     * Returns the console representation of this extended public key.
+     * @return string
+     */
+    inspect(): string;
+    /**
+     * Returns a plain JavaScript object with information to reconstruct a key.
+     *
+     * Fields are:
+     * <ul>
+     *  <li> network: 'livenet' or 'testnet' </li>
+     *  <li> depth: a number from 0 to 255, the depth to the master extended key </li>
+     *  <li> fingerPrint: a number of 32 bits taken from the hash of the public key </li>
+     *  <li> fingerPrint: a number of 32 bits taken from the hash of this key's parent's public key </li>
+     *  <li> childIndex: index with which this key was derived </li>
+     *  <li> chainCode: string in hexa encoding used for derivation </li>
+     *  <li> publicKey: string, hexa encoded, in compressed key format </li>
+     *  <li> checksum: this._buffers.checksum.readUInt32BE(0) </li>
+     *  <li> xpubkey: the string with the base58 representation of this extended key </li>
+     *  <li> checksum: the base58 checksum of xpubkey </li>
+     * </ul>
+     */
+    toObject: () => {
+        network: any;
+        depth: any;
+        fingerPrint: any;
+        parentFingerPrint: any;
+        childIndex: any;
+        chainCode: any;
+        publicKey: any;
+        checksum: any;
+        xpubkey: any;
+    };
+    toJSON(): {
+        network: any;
+        depth: any;
+        fingerPrint: any;
+        parentFingerPrint: any;
+        childIndex: any;
+        chainCode: any;
+        publicKey: any;
+        checksum: any;
+        xpubkey: any;
+    };
+    /**
+     * Return a buffer representation of the xpubkey
+     *
+     * @return {Buffer}
+     */
+    toBuffer(): Buffer;
+    /**
+     * Return a hex string representation of the xpubkey
+     *
+     * @return {Buffer}
+     */
+    toHex(): Buffer;
+}
+declare namespace HDPublicKey {
+    /**
+     * Converts an HDPrivateKey to an HDPublicKey.
+     * @param {HDPrivateKey} hdPrivateKey - The HD private key to convert.
+     * @returns {HDPublicKey} The corresponding HD public key.
+     */
+    export function fromHDPrivateKey(hdPrivateKey: HDPrivateKey): HDPublicKey;
+    /**
+     * Checks if a given argument is a valid HD public key derivation path.
+     * @param {string|number} arg - The path to validate (either as string like "m/0/1" or as a single index number).
+     * @returns {boolean} True if the path is valid, false otherwise.
+     * @description Validates both string paths (e.g., "m/0/1") and individual derivation indexes.
+     * String paths must contain valid indexes separated by '/', and each index must be a non-negative number less than HDPublicKey.Hardened.
+     */
+    export function isValidPath(arg: string | number): boolean;
+    /**
+     * Verifies that a given serialized public key in base58 with checksum format
+     * is valid.
+     *
+     * @param {string|Buffer} data - the serialized public key
+     * @param {string|Network} [network]  - optional, if present, checks that the
+     *     network provided matches the network serialized.
+     * @return {boolean}
+     */
+    export function isValidSerialized(data: string | Buffer, network?: any): boolean;
+    /**
+     * Checks what's the error that causes the validation of a serialized public key
+     * in base58 with checksum to fail.
+     *
+     * @param {string|Buffer} data - the serialized public key
+     * @param {string|Network} [network] - optional, if present, checks that the
+     *     network provided matches the network serialized.
+     * @return {Error|null}
+     */
+    export function getSerializedError(data: string | Buffer, network?: any): Error;
+    /**
+     * Validates if the provided data matches the expected network version.
+     * @param {Buffer} data - The data containing the version to validate.
+     * @param {string|Network} networkArg - The network or network identifier to validate against.
+     * @returns {InvalidNetworkArgument|InvalidNetwork|null} Returns an error if validation fails, otherwise null.
+     * @private
+     */
+    export function _validateNetwork(data: Buffer, networkArg: any): any;
+    /**
+     * Validates buffer arguments for HDPublicKey.
+     * @private
+     * @param {Object} arg - The argument object containing buffer fields to validate
+     * @param {Buffer} arg.version - Version buffer (must be HDPublicKey.VersionSize bytes)
+     * @param {Buffer} arg.depth - Depth buffer (must be HDPublicKey.DepthSize bytes)
+     * @param {Buffer} arg.parentFingerPrint - Parent fingerprint buffer (must be HDPublicKey.ParentFingerPrintSize bytes)
+     * @param {Buffer} arg.childIndex - Child index buffer (must be HDPublicKey.ChildIndexSize bytes)
+     * @param {Buffer} arg.chainCode - Chain code buffer (must be HDPublicKey.ChainCodeSize bytes)
+     * @param {Buffer} arg.publicKey - Public key buffer (must be HDPublicKey.PublicKeySize bytes)
+     * @param {Buffer} [arg.checksum] - Optional checksum buffer (must be HDPublicKey.CheckSumSize bytes if provided)
+     * @throws {Error} If any buffer is invalid or has incorrect size
+     */
+    export function _validateBufferArguments(arg: {
+        version: Buffer;
+        depth: Buffer;
+        parentFingerPrint: Buffer;
+        childIndex: Buffer;
+        chainCode: Buffer;
+        publicKey: Buffer;
+        checksum?: Buffer;
+    }): void;
+    /**
+     * Creates an HDPublicKey instance from a string representation.
+     * @param {string} arg - The string to convert to an HDPublicKey.
+     * @returns {HDPublicKey} A new HDPublicKey instance.
+     * @throws {Error} Throws if the input is not a valid string.
+     */
+    export function fromString(arg: string): HDPublicKey;
+    /**
+     * Creates an HDPublicKey instance from an object.
+     * @param {Object} arg - The object containing public key data
+     * @returns {HDPublicKey} A new HDPublicKey instance
+     * @throws {Error} Will throw if no valid object argument is provided
+     */
+    export function fromObject(arg: any): HDPublicKey;
+    /**
+     * Create a HDPublicKey from a buffer argument
+     *
+     * @param {Buffer} arg
+     * @return {HDPublicKey}
+     */
+    export function fromBuffer(arg: Buffer): HDPublicKey;
+    /**
+     * Create a HDPublicKey from a hex string argument
+     *
+     * @param {Buffer} arg
+     * @return {HDPublicKey}
+     */
+    export function fromHex(hex: any): HDPublicKey;
+    export let Hardened: number;
+    export let RootElementAlias: string[];
+    export let VersionSize: number;
+    export let DepthSize: number;
+    export let ParentFingerPrintSize: number;
+    export let ChildIndexSize: number;
+    export let ChainCodeSize: number;
+    export let PublicKeySize: number;
+    export let CheckSumSize: number;
+    export let DataSize: number;
+    export let SerializedByteSize: number;
+    export let VersionStart: number;
+    export let VersionEnd: number;
+    import DepthStart = VersionEnd;
+    export { DepthStart };
+    export let DepthEnd: number;
+    import ParentFingerPrintStart = DepthEnd;
+    export { ParentFingerPrintStart };
+    export let ParentFingerPrintEnd: number;
+    import ChildIndexStart = ParentFingerPrintEnd;
+    export { ChildIndexStart };
+    export let ChildIndexEnd: number;
+    import ChainCodeStart = ChildIndexEnd;
+    export { ChainCodeStart };
+    export let ChainCodeEnd: number;
+    import PublicKeyStart = ChainCodeEnd;
+    export { PublicKeyStart };
+    export let PublicKeyEnd: number;
+    import ChecksumStart = PublicKeyEnd;
+    export { ChecksumStart };
+    export let ChecksumEnd: number;
+}

package/types/index.d.cts

@@ -0,0 +1,26 @@
+import Address = require("./address.cjs");
+import Block = require("./block/block.cjs");
+import MerkleBlock = require("./block/merkleblock.cjs");
+import BlockHeader = require("./block/blockheader.cjs");
+import HDPrivateKey = require("./hdprivatekey.cjs");
+import HDPublicKey = require("./hdpublickey.cjs");
+import Sighash = require("./transaction/sighash.cjs");
+import TransactionSignature = require("./transaction/signature.cjs");
+import Output = require("./transaction/output.cjs");
+import Input = require("./transaction/input/input.cjs");
+import Networks = require("./networks.cjs");
+import Network = require("./network.cjs");
+import Opcode = require("./opcode.cjs");
+import PrivateKey = require("./privatekey.cjs");
+import PublicKey = require("./publickey.cjs");
+import Script = require("./script/script.cjs");
+import Interpreter = require("./interpreter/interpreter.cjs");
+import Transaction = require("./transaction/transaction.cjs");
+import HashCache = require("./hash-cache.cjs");
+import Message = require("./message/message.cjs");
+import Mnemonic = require("./mnemonic/mnemonic.cjs");
+import errors = require("./errors/index.cjs");
+import util = require("./util/index.cjs");
+import encoding = require("./encoding/index.cjs");
+import crypto = require("./crypto/index.cjs");
+export { Address, Block, MerkleBlock, BlockHeader, HDPrivateKey, HDPublicKey, Sighash, TransactionSignature, Output, Input, Networks, Network, Opcode, PrivateKey, PublicKey, Script, Interpreter, Transaction, HashCache, Message, Mnemonic, errors, util, encoding, crypto };

package/types/interpreter/index.d.cts

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