@opcat-labs/opcat 1.0.0 → 1.0.2

package/types/networks.d.cts

@@ -0,0 +1,76 @@
+export = Networks;
+/**
+ * A tool class for managing all supported networks
+ * @constructor
+ */
+declare function Networks(): void;
+declare namespace Networks {
+    /**
+     * @function
+     * @member Networks#get
+     * Retrieves the network associated with a magic number or string.
+     * @param {string|number|Network} arg
+     * @param {string|Array} keys - if set, only check if the magic number associated with this name matches
+     * @return Network
+     */
+    export function get(arg: string | number | Network, keys: string | any[]): any;
+    /**
+     * @function
+     * @member Networks#add
+     * Will add a custom Network
+     * @param {Object} data
+     * @param {string} data.name - The name of the network
+     * @param {string} data.alias - The aliased name of the network
+     * @param {Number} data.pubkeyhash - The publickey hash cashAddrPrefix
+     * @param {Number} data.privatekey - The privatekey cashAddrPrefix
+     * @param {Number} data.scripthash - The scripthash cashAddrPrefix
+     * @param {Number} data.xpubkey - The extended public key magic
+     * @param {Number} data.xprivkey - The extended private key magic
+     * @param {Number} data.networkMagic - The network magic number
+     * @param {Number} data.port - The network port
+     * @param {Array}  data.dnsSeeds - An array of dns seeds
+     * @return Network
+     */
+    export function add(data: {
+        name: string;
+        alias: string;
+        pubkeyhash: number;
+        privatekey: number;
+        scripthash: number;
+        xpubkey: number;
+        xprivkey: number;
+        networkMagic: number;
+        port: number;
+        dnsSeeds: any[];
+    }): Network;
+    /**
+     * @function
+     * @member Networks#remove
+     * Will remove a custom network
+     * @param {Network} network
+     */
+    export function remove(network: Network): void;
+    export { livenet };
+    export { regtest };
+    export { testnet };
+    export { livenet as defaultNetwork };
+    /**
+     * Enables regtest network mode for testing purposes.
+     * @member Networks#enableRegtest
+     * @function
+     */
+    export function enableRegtest(): void;
+    /**
+     * @function
+     * @member Networks#disableRegtest
+     * Disables the regtest network configuration.
+     * This sets the `regtestEnabled` flag to false in the testnet configuration.
+     */
+    export function disableRegtest(): void;
+}
+declare class Networks {
+}
+import Network = require("./network.cjs");
+declare var livenet: any;
+declare var regtest: any;
+declare var testnet: any;

package/types/opcode.d.cts

@@ -0,0 +1,93 @@
+export = Opcode;
+/**
+ * Creates an Opcode instance from a number or string representation.
+ * @constructor
+ * @param {number|string} num - The numeric value or string name of the opcode
+ * @throws {TypeError} If the input type is not recognized
+ * @returns {Opcode} A new Opcode instance
+ */
+declare function Opcode(num: number | string): Opcode;
+declare class Opcode {
+    /**
+     * Creates an Opcode instance from a number or string representation.
+     * @constructor
+     * @param {number|string} num - The numeric value or string name of the opcode
+     * @throws {TypeError} If the input type is not recognized
+     * @returns {Opcode} A new Opcode instance
+     */
+    constructor(num: number | string);
+    /**
+     * Converts the opcode number to its hexadecimal string representation.
+     * @returns {string} Hexadecimal string of the opcode number.
+     */
+    toHex(): string;
+    /**
+     * Converts the opcode to a Buffer by first converting it to a hex string.
+     * @returns {Buffer} The opcode represented as a Buffer.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Gets the numeric value of the opcode.
+     * @returns {number} The numeric representation of the opcode.
+     */
+    toNumber(): number;
+    /**
+     * Converts the opcode number to its string representation.
+     * @throws {Error} If the opcode number has no corresponding string mapping.
+     * @returns {string} The string representation of the opcode.
+     */
+    toString(): string;
+    /**
+     * Converts the opcode to a human-readable string representation.
+     * If the opcode has a known mnemonic, returns that string.
+     * Otherwise, returns the hexadecimal representation of the opcode.
+     * @returns {string} The safe string representation of the opcode.
+     */
+    toSafeString(): string;
+    /**
+     * Will return a string formatted for the console
+     *
+     * @returns {string} Script opcode
+     */
+    inspect(): string;
+}
+declare namespace Opcode {
+    /**
+     * Creates an Opcode instance from a Buffer.
+     * @param {Buffer} buf - The buffer containing the opcode data.
+     * @returns {Opcode} The constructed Opcode instance.
+     * @throws {Error} If the input is not a Buffer.
+     */
+    function fromBuffer(buf: Buffer): Opcode;
+    /**
+     * Creates an Opcode instance from a number.
+     * @param {number} num - The numeric value to convert to an Opcode.
+     * @returns {Opcode} A new Opcode instance.
+     * @throws {Error} If the input is not a number.
+     */
+    function fromNumber(num: number): Opcode;
+    /**
+     * Creates an Opcode instance from a string representation.
+     * @param {string} str - The string representation of the opcode.
+     * @returns {Opcode} A new Opcode instance corresponding to the input string.
+     * @throws {TypeError} If the input string is not a valid opcode representation.
+     */
+    function fromString(str: string): Opcode;
+    /**
+     * Converts a small integer (0-16) to its corresponding opcode.
+     * @param {number} n - The integer to convert (must be between 0 and 16)
+     * @returns {Opcode} The corresponding opcode (OP_0 for 0, OP_1+n-1 for 1-16)
+     * @throws {Error} If n is not a number or outside valid range
+     */
+    function smallInt(n: number): Opcode;
+    let map: {
+        [x: string]: number;
+    };
+    let reverseMap: any[];
+    /**
+     * Checks if the given opcode is a small integer opcode (OP_0 to OP_16).
+     * @param {number|Opcode} opcode - The opcode to check, either as a number or Opcode instance.
+     * @returns {boolean} True if the opcode is a small integer opcode, false otherwise.
+     */
+    function isSmallIntOp(opcode: number | Opcode): boolean;
+}

package/types/privatekey.d.cts

@@ -0,0 +1,169 @@
+export = PrivateKey;
+/**
+ * Instantiate a PrivateKey from a BN, Buffer or WIF string.
+ *
+ * @param {string|BN|Buffer|Object} data - The encoded data in various formats
+ * @param {Network|string} [network] - a {@link Network} object, or a string with the network name
+ * @returns {PrivateKey} A new valid instance of an PrivateKey
+ * @constructor
+ */
+declare function PrivateKey(data: string | BN | Buffer | any, network?: Network | string): PrivateKey;
+declare class PrivateKey {
+    /**
+     * Instantiate a PrivateKey from a BN, Buffer or WIF string.
+     *
+     * @param {string|BN|Buffer|Object} data - The encoded data in various formats
+     * @param {Network|string} [network] - a {@link Network} object, or a string with the network name
+     * @returns {PrivateKey} A new valid instance of an PrivateKey
+     * @constructor
+     */
+    constructor(data: string | BN | Buffer | any, network?: Network | string);
+    get publicKey(): PublicKey;
+    get network(): any;
+    get compressed(): any;
+    private _classifyArguments;
+    /**
+     * Will output the PrivateKey in WIF
+     *
+     * @returns {string}
+     */
+    toString(): string;
+    /**
+     * Will output the PrivateKey to a WIF string
+     *
+     * @returns {string} A WIP representation of the private key
+     */
+    toWIF(): string;
+    /**
+     * Will return the private key as a BN instance
+     *
+     * @returns {BN} A BN instance of the private key
+     */
+    toBigNumber(): BN;
+    /**
+     * Will return the private key as a BN buffer
+     *
+     * @returns {Buffer} A buffer of the private key
+     */
+    toBuffer(): Buffer;
+    /**
+     * Converts the private key to a hexadecimal string representation.
+     * @returns {string} Hexadecimal string of the private key.
+     */
+    toHex(): string;
+    /**
+     * Will return the corresponding public key
+     *
+     * @returns {PublicKey} A public key generated from the private key
+     */
+    toPublicKey(): PublicKey;
+    _pubkey: PublicKey;
+    /**
+     * Will return an address for the private key
+     * @param {Network|string} [network] - optional parameter specifying
+     * the desired network for the address
+     *
+     * @returns {Address} An address generated from the private key
+     */
+    toAddress(network?: Network | string): Address;
+    /**
+     * @returns {Object} A plain object representation
+     */
+    toObject: () => any;
+    toJSON(): any;
+    /**
+     * Will return a string formatted for the console
+     *
+     * @returns {string} Private key
+     */
+    inspect(): string;
+}
+declare namespace PrivateKey {
+    /**
+     * Internal function to get a random Big Number (BN)
+     *
+     * @returns {BN} A new randomly generated BN
+     * @private
+     */
+    function _getRandomBN(): BN;
+    /**
+     * Internal function to transform a WIF Buffer into a private key
+     *
+     * @param {Buffer} buf - An WIF string
+     * @param {Network|string} [network] - a {@link Network} object, or a string with the network name
+     * @returns {Object} An object with keys: bn, network and compressed
+     * @private
+     */
+    function _transformBuffer(buf: Buffer, network?: any): any;
+    /**
+     * Internal function to transform a BN buffer into a private key
+     *
+     * @param {Buffer} buf
+     * @param {Network|string=} network - a {@link Network} object, or a string with the network name
+     * @returns {object} an Object with keys: bn, network, and compressed
+     * @private
+     */
+    function _transformBNBuffer(buf: Buffer, network?: any): any;
+    /**
+     * Internal function to transform a WIF string into a private key
+     *
+     * @param {string} buf - An WIF string
+     * @returns {Object} An object with keys: bn, network and compressed
+     * @private
+     */
+    function _transformWIF(str: any, network: any): any;
+    /**
+     * Instantiate a PrivateKey from a Buffer with the DER or WIF representation
+     *
+     * @param {Buffer} buf
+     * @param {Network} network
+     * @return {PrivateKey}
+     */
+    function fromBuffer(buf: Buffer, network: Network): PrivateKey;
+    /**
+     * Creates a PrivateKey instance from a hexadecimal string.
+     * @param {string} hex - The hexadecimal string representation of the private key.
+     * @param {Network} network - The network associated with the private key.
+     * @returns {PrivateKey} A PrivateKey instance.
+     */
+    function fromHex(hex: string, network: Network): PrivateKey;
+    /**
+     * Internal function to transform a JSON string on plain object into a private key
+     * return this.
+     *
+     * @param {string} json - A JSON string or plain object
+     * @returns {Object} An object with keys: bn, network and compressed
+     * @private
+     */
+    function _transformObject(json: string): any;
+    function fromString(str: string): PrivateKey;
+    function fromWIF(str: string): PrivateKey;
+    function fromObject(obj: any): PrivateKey;
+    function fromJSON(obj: any): PrivateKey;
+    /**
+     * Instantiate a PrivateKey from random bytes
+     *
+     * @param {string|Network} [network] - Either "livenet" or "testnet"
+     * @returns {PrivateKey} A new valid instance of PrivateKey
+     */
+    function fromRandom(network?: any): PrivateKey;
+    /**
+     * Check if there would be any errors when initializing a PrivateKey
+     *
+     * @param {string} data - The encoded data in various formats
+     * @param {string|Network} [network] - Either "livenet" or "testnet"
+     * @returns {null|Error} An error if exists
+     */
+    function getValidationError(data: string, network?: any): Error;
+    /**
+     * Check if the parameters are valid
+     *
+     * @param {string} data - The encoded data in various formats
+     * @param {string|Network} [network] - Either "livenet" or "testnet"
+     * @returns {Boolean} If the private key is would be valid
+     */
+    function isValid(data: string, network?: any): boolean;
+}
+import BN = require("./bn.cjs");
+import PublicKey = require("./publickey.cjs");
+import Address = require("./address.cjs");

package/types/publickey.d.cts

@@ -0,0 +1,202 @@
+export = PublicKey;
+/**
+ * Instantiate a PublicKey from a {@link PrivateKey}, {@link Point}, `string`, or `Buffer`.
+ *
+ * There are two internal properties, `network` and `compressed`, that deal with importing
+ * a PublicKey from a PrivateKey in WIF format. More details described on {@link PrivateKey}
+ *
+ * @example
+ * ```javascript
+ * // instantiate from a private key
+ * var key = PublicKey(privateKey, true);
+ *
+ * // export to as a DER hex encoded string
+ * var exported = key.toString();
+ *
+ * // import the public key
+ * var imported = PublicKey.fromString(exported);
+ * ```
+ *
+ * @param {string} data - The encoded data in various formats
+ * @param {Object} extra - additional options
+ * @param {Network} extra.network - Which network should the address for this public key be for
+ * @param {String=} extra.compressed - If the public key is compressed
+ * @returns {PublicKey} A new valid instance of an PublicKey
+ * @constructor
+ */
+declare function PublicKey(data: string, extra: {
+    network: Network;
+    compressed?: string | undefined;
+}): PublicKey;
+declare class PublicKey {
+    /**
+     * Instantiate a PublicKey from a {@link PrivateKey}, {@link Point}, `string`, or `Buffer`.
+     *
+     * There are two internal properties, `network` and `compressed`, that deal with importing
+     * a PublicKey from a PrivateKey in WIF format. More details described on {@link PrivateKey}
+     *
+     * @example
+     * ```javascript
+     * // instantiate from a private key
+     * var key = PublicKey(privateKey, true);
+     *
+     * // export to as a DER hex encoded string
+     * var exported = key.toString();
+     *
+     * // import the public key
+     * var imported = PublicKey.fromString(exported);
+     * ```
+     *
+     * @param {string} data - The encoded data in various formats
+     * @param {Object} extra - additional options
+     * @param {Network} extra.network - Which network should the address for this public key be for
+     * @param {String=} extra.compressed - If the public key is compressed
+     * @returns {PublicKey} A new valid instance of an PublicKey
+     * @constructor
+     */
+    constructor(data: string, extra: {
+        network: Network;
+        compressed?: string | undefined;
+    });
+    /**
+     * Internal function to differentiate between arguments passed to the constructor
+     * @param {*} data
+     * @param {Object} extra
+     */
+    _classifyArgs(data: any, extra: any): {
+        compressed: any;
+    };
+    /**
+     * @returns {Object} A plain object of the PublicKey
+     */
+    toObject: () => any;
+    toJSON(): any;
+    /**
+     * Will output the PublicKey to a DER Buffer
+     *
+     * @returns {Buffer} A DER hex encoded buffer
+     */
+    toBuffer: () => Buffer;
+    toDER(): Buffer;
+    /**
+     * Will return a sha256 + ripemd160 hash of the serialized public key
+     * @see https://github.com/bitcoin/bitcoin/blob/master/src/pubkey.h#L141
+     * @returns {Buffer}
+     */
+    _getID(): Buffer;
+    /**
+     * Will return an address for the public key
+     *
+     * @param {string|Network} [network] - Which network should the address be for
+     * @returns {Address} An address generated from the public key
+     */
+    toAddress(network?: string | Network): Address;
+    /**
+     * Will output the PublicKey to a DER encoded hex string
+     *
+     * @returns {string} A DER hex encoded string
+     */
+    toString: () => string;
+    toHex(): string;
+    /**
+     * Will return a string formatted for the console
+     *
+     * @returns {string} Public key
+     */
+    inspect(): string;
+}
+declare namespace PublicKey {
+    /**
+     * Internal function to detect if an object is a {@link PrivateKey}
+     *
+     * @param {*} param - object to test
+     * @returns {boolean}
+     * @private
+     */
+    function _isPrivateKey(param: any): boolean;
+    /**
+     * Internal function to detect if an object is a Buffer
+     *
+     * @param {*} param - object to test
+     * @returns {boolean}
+     * @private
+     */
+    function _isBuffer(param: any): boolean;
+    /**
+     * Internal function to transform a private key into a public key point
+     *
+     * @param {PrivateKey} privkey - An instance of PrivateKey
+     * @returns {Object} An object with keys: point and compressed
+     * @private
+     */
+    function _transformPrivateKey(privkey: PrivateKey): any;
+    /**
+     * Internal function to transform DER into a public key point
+     *
+     * @param {Buffer} buf - An DER buffer
+     * @param {bool=} strict - if set to false, will loosen some conditions
+     * @returns {Object} An object with keys: point and compressed
+     * @private
+     */
+    function _transformDER(buf: Buffer, strict?: bool): any;
+    /**
+     * Internal function to transform X into a public key point
+     *
+     * @param {Boolean} odd - If the point is above or below the x axis
+     * @param {Point} x - The x point
+     * @returns {Object} An object with keys: point and compressed
+     * @private
+     */
+    function _transformX(odd: boolean, x: Point): any;
+    /**
+     * Internal function to transform a JSON into a public key point
+     *
+     * @param {String|Object} json - a JSON string or plain object
+     * @returns {Object} An object with keys: point and compressed
+     * @private
+     */
+    function _transformObject(json: any): any;
+    /**
+     * Instantiate a PublicKey from a PrivateKey
+     *
+     * @param {PrivateKey} privkey - An instance of PrivateKey
+     * @returns {PublicKey} A new valid instance of PublicKey
+     */
+    function fromPrivateKey(privkey: PrivateKey): PublicKey;
+    function fromDER(buf: Buffer, strict?: bool): PublicKey;
+    function fromBuffer(buf: Buffer, strict?: bool): PublicKey;
+    /**
+     * Instantiate a PublicKey from a Point
+     *
+     * @param {Point} point - A Point instance
+     * @param {boolean=} compressed - whether to store this public key as compressed format
+     * @returns {PublicKey} A new valid instance of PublicKey
+     */
+    function fromPoint(point: Point, compressed?: boolean): PublicKey;
+    function fromHex(str: string, encoding?: string): PublicKey;
+    function fromString(str: string, encoding?: string): PublicKey;
+    /**
+     * Instantiate a PublicKey from an X Point
+     *
+     * @param {Boolean} odd - If the point is above or below the x axis
+     * @param {Point} x - The x point
+     * @returns {PublicKey} A new valid instance of PublicKey
+     */
+    function fromX(odd: boolean, x: Point): PublicKey;
+    /**
+     * Check if there would be any errors when initializing a PublicKey
+     *
+     * @param {string} data - The encoded data in various formats
+     * @returns {null|Error} An error if exists
+     */
+    function getValidationError(data: string): Error;
+    /**
+     * Check if the parameters are valid
+     *
+     * @param {string} data - The encoded data in various formats
+     * @returns {Boolean} If the public key would be valid
+     */
+    function isValid(data: string): boolean;
+}
+import Address = require("./address.cjs");
+import Point = require("./crypto/point.cjs");

package/types/script/index.d.cts

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