@opcat-labs/opcat 1.0.0 → 1.0.2

package/types/block/block.d.cts

@@ -0,0 +1,139 @@
+export = Block;
+/**
+ * Instantiate a Block from a Buffer, JSON object, or Object with
+ * the properties of the Block
+ *
+ * @param {*} - A Buffer, JSON string, or Object
+ * @returns {Block}
+ * @constructor
+ */
+declare function Block(arg: any): Block;
+declare class Block {
+    /**
+     * Instantiate a Block from a Buffer, JSON object, or Object with
+     * the properties of the Block
+     *
+     * @param {*} - A Buffer, JSON string, or Object
+     * @returns {Block}
+     * @constructor
+     */
+    constructor(arg: any);
+    /**
+     * Converts the Block instance to a plain object (also aliased as toJSON).
+     * @returns {Object} The plain object representation of the Block.
+     */
+    toObject: () => any;
+    toJSON(): any;
+    /**
+     * Converts the block to a buffer representation.
+     * @returns {Buffer} The buffer containing the block data.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Returns the string representation of the Block instance.
+     * @returns {string} - A hex encoded string of the block
+     */
+    toString(): string;
+    /**
+     * @param {BufferWriter} - An existing instance of BufferWriter
+     * @returns {BufferWriter} - An instance of BufferWriter representation of the Block
+     */
+    toBufferWriter(bw: any): BufferWriter;
+    /**
+     * Will iterate through each transaction and return an array of hashes
+     * @returns {Array} - An array with transaction hashes
+     */
+    getTransactionHashes(): any[];
+    /**
+     * Will build a merkle tree of all the transactions, ultimately arriving at
+     * a single point, the merkle root.
+     * @link https://en.bitcoin.it/wiki/Protocol_specification#Merkle_Trees
+     * @returns {Array} - An array with each level of the tree after the other.
+     */
+    getMerkleTree(): any[];
+    /**
+     * Calculates the merkleRoot from the transactions.
+     * @returns {Buffer} - A buffer of the merkle root hash
+     */
+    getMerkleRoot(): Buffer;
+    /**
+     * Verifies that the transactions in the block match the header merkle root
+     * @returns {Boolean} - If the merkle roots match
+     */
+    validMerkleRoot(): boolean;
+    /**
+     * @returns {Buffer} - The little endian hash buffer of the header
+     */
+    _getHash(): Buffer;
+    id: any;
+    hash: any;
+    /**
+     * @returns {string} - A string formatted for the console
+     */
+    inspect(): string;
+}
+declare namespace Block {
+    export let MAX_BLOCK_SIZE: number;
+    /**
+     * Creates a Block instance from the given argument.
+     * @param {*} arg - The input to convert into a Block.
+     * @returns {Block} A new Block instance.
+     * @throws {TypeError} - If the argument was not recognized
+     * @private
+     */
+    export function _from(arg: any): Block;
+    /**
+     * Creates a Block instance from a plain object.
+     * @param {Object} data - The plain object containing block data.
+     * @returns {Block} The created Block instance.
+     * @private
+     */
+    export function _fromObject(data: any): Block;
+    /**
+     * Creates a Block instance from a plain JavaScript object.
+     * @param {Object} obj - The source object to convert to a Block.
+     * @returns {Block} A new Block instance.
+     */
+    export function fromObject(obj: any): Block;
+    /**
+     * Creates a Block instance from a BufferReader.
+     * @private
+     * @param {BufferReader} br - The buffer reader containing block data
+     * @returns {Block} The parsed Block instance
+     */
+    export function _fromBufferReader(br: BufferReader): Block;
+    /**
+     * Creates a Block instance from a BufferReader.
+     * @param {BufferReader} br - The buffer reader containing block data.
+     * @returns {Block} The parsed Block instance.
+     */
+    export function fromBufferReader(br: BufferReader): Block;
+    /**
+     * Creates a Block instance from a buffer.
+     * @param {Buffer} buf - The input buffer to create the block from.
+     * @returns {Block} The created Block instance.
+     */
+    export function fromBuffer(buf: Buffer): Block;
+    /**
+     * Creates a Block instance from a string representation.
+     * @param {string} str - The string to parse into a Block.
+     * @returns {Block} The parsed Block instance.
+     */
+    export function fromString(str: string): Block;
+    /**
+     * Creates a Block instance from raw block data.
+     * @param {Object} data - The raw block data to convert.
+     * @returns {Block} A new Block instance.
+     */
+    export function fromRawBlock(data: any): Block;
+    export namespace Values {
+        let START_OF_BLOCK: number;
+        let NULL_HASH: Buffer;
+    }
+    export { BlockHeader };
+    export { MerkleBlock };
+}
+import BufferWriter = require("../encoding/bufferwriter.cjs");
+import BufferReader = require("../encoding/bufferreader.cjs");
+import BlockHeader = require("./blockheader.cjs");
+import MerkleBlock = require("./merkleblock.cjs");

package/types/block/blockheader.d.cts

@@ -0,0 +1,125 @@
+export = BlockHeader;
+/**
+ * Instantiate a BlockHeader from a Buffer, JSON object, or Object with
+ * the properties of the BlockHeader
+ *
+ * @param {*} - A Buffer, JSON string, or Object
+ * @returns {BlockHeader} - An instance of block header
+ * @constructor
+ */
+declare function BlockHeader(arg: any): BlockHeader;
+declare class BlockHeader {
+    /**
+     * Instantiate a BlockHeader from a Buffer, JSON object, or Object with
+     * the properties of the BlockHeader
+     *
+     * @param {*} - A Buffer, JSON string, or Object
+     * @returns {BlockHeader} - An instance of block header
+     * @constructor
+     */
+    constructor(arg: any);
+    version: any;
+    prevHash: any;
+    merkleRoot: any;
+    time: any;
+    timestamp: any;
+    bits: any;
+    nonce: any;
+    /**
+     * @returns {Object} - A plain object of the BlockHeader
+     */
+    toObject: () => any;
+    toJSON(): any;
+    /**
+     * @returns {Buffer} - A Buffer of the BlockHeader
+     */
+    toBuffer(): Buffer;
+    /**
+     * @returns {string} - A hex encoded string of the BlockHeader
+     */
+    toString(): string;
+    /**
+     * @param {BufferWriter} - An existing instance BufferWriter
+     * @returns {BufferWriter} - An instance of BufferWriter representation of the BlockHeader
+     */
+    toBufferWriter(bw: any): BufferWriter;
+    /**
+     * Returns the target difficulty for this block
+     * @param {Number} bits
+     * @returns {BN} An instance of BN with the decoded difficulty bits
+     */
+    getTargetDifficulty(bits: number): BN;
+    /**
+     * @link https://en.bitcoin.it/wiki/Difficulty
+     * @return {Number}
+     */
+    getDifficulty(): number;
+    private _getHash;
+    id: any;
+    hash: any;
+    /**
+     * @returns {Boolean} - If timestamp is not too far in the future
+     */
+    validTimestamp(): boolean;
+    /**
+     * @returns {Boolean} - If the proof-of-work hash satisfies the target difficulty
+     */
+    validProofOfWork(): boolean;
+    /**
+     * @returns {string} - A string formatted for the console
+     */
+    inspect(): string;
+}
+declare namespace BlockHeader {
+    /**
+     * @param {*} - A Buffer, JSON string or Object
+     * @returns {Object} - An object representing block header data
+     * @throws {TypeError} - If the argument was not recognized
+     * @private
+     */
+    function _from(arg: any): any;
+    /**
+     * @param {Object} - A JSON string
+     * @returns {Object} - An object representing block header data
+     * @private
+     */
+    function _fromObject(data: any): any;
+    /**
+     * @param {Object} - A plain JavaScript object
+     * @returns {BlockHeader} - An instance of block header
+     */
+    function fromObject(obj: any): BlockHeader;
+    /**
+     * @param {Binary} - Raw block binary data or buffer
+     * @returns {BlockHeader} - An instance of block header
+     */
+    function fromRawBlock(data: any): BlockHeader;
+    /**
+     * @param {Buffer} - A buffer of the block header
+     * @returns {BlockHeader} - An instance of block header
+     */
+    function fromBuffer(buf: any): BlockHeader;
+    /**
+     * @param {string} - A hex encoded buffer of the block header
+     * @returns {BlockHeader} - An instance of block header
+     */
+    function fromString(str: any): BlockHeader;
+    /**
+     * @param {BufferReader} - A BufferReader of the block header
+     * @returns {Object} - An object representing block header data
+     * @private
+     */
+    function _fromBufferReader(br: any): any;
+    /**
+     * @param {BufferReader} - A BufferReader of the block header
+     * @returns {BlockHeader} - An instance of block header
+     */
+    function fromBufferReader(br: any): BlockHeader;
+    namespace Constants {
+        let START_OF_HEADER: number;
+        let MAX_TIME_OFFSET: number;
+        let LARGEST_HASH: BN;
+    }
+}
+import BufferWriter = require("../encoding/bufferwriter.cjs");
+import BN = require("../bn.cjs");

package/types/block/index.d.cts

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

package/types/block/merkleblock.d.cts

@@ -0,0 +1,95 @@
+export = MerkleBlock;
+/**
+ * Instantiate a MerkleBlock from a Buffer, JSON object, or Object with
+ * the properties of the Block
+ *
+ * @param {*} - A Buffer, JSON string, or Object representing a MerkleBlock
+ * @returns {MerkleBlock}
+ * @constructor
+ */
+declare function MerkleBlock(arg: any): MerkleBlock;
+declare class MerkleBlock {
+    /**
+     * Instantiate a MerkleBlock from a Buffer, JSON object, or Object with
+     * the properties of the Block
+     *
+     * @param {*} - A Buffer, JSON string, or Object representing a MerkleBlock
+     * @returns {MerkleBlock}
+     * @constructor
+     */
+    constructor(arg: any);
+    _flagBitsUsed: number;
+    _hashesUsed: number;
+    /**
+     * @returns {Buffer} - A buffer of the block
+     */
+    toBuffer(): Buffer;
+    /**
+     * @param {BufferWriter} [bw] - An existing instance of BufferWriter
+     * @returns {BufferWriter} - An instance of BufferWriter representation of the MerkleBlock
+     */
+    toBufferWriter(bw?: BufferWriter): BufferWriter;
+    /**
+     * @returns {Object} - A plain object with the MerkleBlock properties
+     */
+    toObject: () => any;
+    toJSON(): any;
+    /**
+     * Verify that the MerkleBlock is valid
+     * @returns {Boolean} - True/False whether this MerkleBlock is Valid
+     */
+    validMerkleTree(): boolean;
+    /**
+     * WARNING: This method is deprecated. Use filteredTxsHash instead.
+     *
+     * Return a list of all the txs hash that match the filter
+     * @returns {Array} - txs hash that match the filter
+     */
+    filterdTxsHash(): any[];
+    /**
+     * Return a list of all the txs hash that match the filter
+     * @returns {Array} - txs hash that match the filter
+     */
+    filteredTxsHash(): any[];
+    private _traverseMerkleTree;
+    private _calcTreeWidth;
+    private _calcTreeHeight;
+    /**
+     * @param {Transaction|String} tx - Transaction or Transaction ID Hash
+     * @returns {Boolean} - return true/false if this MerkleBlock has the TX or not
+     */
+    hasTransaction(tx: Transaction | string): boolean;
+}
+declare namespace MerkleBlock {
+    /**
+     * @param {Buffer} - MerkleBlock data in a Buffer object
+     * @returns {MerkleBlock} - A MerkleBlock object
+     */
+    function fromBuffer(buf: any): MerkleBlock;
+    /**
+     * @param {BufferReader} - MerkleBlock data in a BufferReader object
+     * @returns {MerkleBlock} - A MerkleBlock object
+     */
+    function fromBufferReader(br: any): MerkleBlock;
+    /**
+     * Parses a MerkleBlock from a buffer reader.
+     * @private
+     * @param {BufferReader} br - The buffer reader containing the MerkleBlock data
+     * @returns {Object} An object containing:
+     *   - header {BlockHeader} - The block header
+     *   - numTransactions {number} - Number of transactions in the block
+     *   - hashes {string[]} - Array of transaction hashes as hex strings
+     *   - flags {number[]} - Array of flag bytes
+     * @throws {Error} If no merkleblock data is received
+     */
+    function _fromBufferReader(br: BufferReader): any;
+    /**
+     * Creates a MerkleBlock instance from a plain object.
+     * @param {Object} obj - The plain object containing MerkleBlock data.
+     * @returns {MerkleBlock} A new MerkleBlock instance.
+     */
+    function fromObject(obj: any): MerkleBlock;
+}
+import BufferWriter = require("../encoding/bufferwriter.cjs");
+import Transaction = require("../transaction/transaction.cjs");
+import BufferReader = require("../encoding/bufferreader.cjs");

package/types/bn.d.cts

@@ -0,0 +1,202 @@
+export = BN;
+/**
+ * BN (Big Number) constructor.
+ * Creates a new BN instance or returns the existing one if input is already a BN.
+ * @param {number|BN} number - The number to initialize with (or existing BN instance)
+ * @param {number|string} [base=10] - Numeric base (10, 16, etc) or endianness ('le', 'be')
+ * @param {string} [endian='be'] - Endianness ('le' for little-endian, 'be' for big-endian)
+ * @constructor
+ */
+declare function BN(number: number | BN, base?: number | string, endian?: string): number | BN;
+declare class BN {
+    /**
+     * BN (Big Number) constructor.
+     * Creates a new BN instance or returns the existing one if input is already a BN.
+     * @param {number|BN} number - The number to initialize with (or existing BN instance)
+     * @param {number|string} [base=10] - Numeric base (10, 16, etc) or endianness ('le', 'be')
+     * @param {string} [endian='be'] - Endianness ('le' for little-endian, 'be' for big-endian)
+     * @constructor
+     */
+    constructor(number: number | BN, base?: number | string, endian?: string);
+    negative: number;
+    words: any[] | number[];
+    length: number;
+    red: any;
+    _init(number: any, base: any, endian: any): void | this;
+    private _initNumber;
+    _initArray(number: any, base: any, endian: any): this;
+    _parseHex(number: any, start: any): void;
+    _parseBase(number: any, base: any, start: any): void;
+    copy(dest: any): void;
+    clone(): BN;
+    _expand(size: any): this;
+    strip(): this;
+    _normSign(): this;
+    inspect(): string;
+    toString(base: any, padding: any): string;
+    toNumber(): any;
+    toJSON(): string;
+    toBuffer(endian: any, length: any): any;
+    toArray(endian: any, length: any): any;
+    toArrayLike(ArrayType: any, endian: any, length: any): any;
+    _countBits(w: any): number;
+    _zeroBits(w: any): number;
+    bitLength(): number;
+    zeroBits(): number;
+    byteLength(): number;
+    toTwos(width: any): any;
+    fromTwos(width: any): any;
+    isNeg(): boolean;
+    neg(): BN;
+    ineg(): this;
+    iuor(num: any): this;
+    ior(num: any): this;
+    or(num: any): any;
+    uor(num: any): any;
+    iuand(num: any): this;
+    iand(num: any): this;
+    and(num: any): any;
+    uand(num: any): any;
+    iuxor(num: any): this;
+    ixor(num: any): this;
+    xor(num: any): any;
+    uxor(num: any): any;
+    inotn(width: any): this;
+    notn(width: any): BN;
+    setn(bit: any, val: any): this;
+    iadd(num: any): any;
+    add(num: any): any;
+    isub(num: any): any;
+    sub(num: any): any;
+    mulTo(num: any, out: any): any;
+    mul(num: any): any;
+    mulf(num: any): any;
+    imul(num: any): any;
+    imuln(num: any): this;
+    muln(num: any): BN;
+    sqr(): any;
+    isqr(): any;
+    pow(num: any): BN;
+    iushln(bits: any): this;
+    ishln(bits: any): this;
+    iushrn(bits: any, hint: any, extended: any): this;
+    ishrn(bits: any, hint: any, extended: any): this;
+    shln(bits: any): BN;
+    ushln(bits: any): BN;
+    shrn(bits: any): BN;
+    ushrn(bits: any): BN;
+    testn(bit: any): boolean;
+    imaskn(bits: any): this;
+    maskn(bits: any): BN;
+    iaddn(num: any): any;
+    _iaddn(num: any): this;
+    isubn(num: any): any;
+    addn(num: any): any;
+    subn(num: any): any;
+    iabs(): this;
+    abs(): BN;
+    _ishlnsubmul(num: any, mul: any, shift: any): this;
+    _wordDiv(num: any, mode: any): {
+        div: BN;
+        mod: BN;
+    };
+    divmod(num: any, mode: any, positive: any): any;
+    div(num: any): any;
+    mod(num: any): any;
+    umod(num: any): any;
+    divRound(num: any): any;
+    modn(num: any): number;
+    idivn(num: any): this;
+    divn(num: any): BN;
+    egcd(p: any): {
+        a: BN;
+        b: BN;
+        gcd: any;
+    };
+    _invmp(p: any): BN;
+    gcd(num: any): any;
+    invm(num: any): any;
+    isEven(): boolean;
+    isOdd(): boolean;
+    andln(num: any): number;
+    bincn(bit: any): this;
+    isZero(): boolean;
+    cmpn(num: any): number;
+    cmp(num: any): number;
+    ucmp(num: any): number;
+    gtn(num: any): boolean;
+    gt(num: any): boolean;
+    gten(num: any): boolean;
+    gte(num: any): boolean;
+    ltn(num: any): boolean;
+    lt(num: any): boolean;
+    lten(num: any): boolean;
+    lte(num: any): boolean;
+    eqn(num: any): boolean;
+    eq(num: any): boolean;
+    toRed(ctx: any): any;
+    fromRed(): any;
+    _forceRed(ctx: any): this;
+    forceRed(ctx: any): this;
+    redAdd(num: any): any;
+    redIAdd(num: any): any;
+    redSub(num: any): any;
+    redISub(num: any): any;
+    redShl(num: any): any;
+    redMul(num: any): any;
+    redIMul(num: any): any;
+    redSqr(): any;
+    redISqr(): any;
+    redSqrt(): any;
+    redInvm(): any;
+    redNeg(): any;
+    redPow(num: any): any;
+}
+declare namespace BN {
+    export { BN };
+    export let wordSize: number;
+    export function isBN(num: any): boolean;
+    export function max(left: any, right: any): any;
+    export function min(left: any, right: any): any;
+    export function red(num: any): Red;
+    export function _prime(name: any): any;
+    export function mont(num: any): Mont;
+}
+declare function Red(m: any): void;
+declare class Red {
+    constructor(m: any);
+    m: any;
+    prime: any;
+    _verify1(a: any): void;
+    _verify2(a: any, b: any): void;
+    imod(a: any): any;
+    neg(a: any): any;
+    add(a: any, b: any): any;
+    iadd(a: any, b: any): any;
+    sub(a: any, b: any): any;
+    isub(a: any, b: any): any;
+    shl(a: any, num: any): any;
+    imul(a: any, b: any): any;
+    mul(a: any, b: any): any;
+    isqr(a: any): any;
+    sqr(a: any): any;
+    sqrt(a: any): any;
+    invm(a: any): any;
+    pow(a: any, num: any): any;
+    convertTo(num: any): any;
+    convertFrom(num: any): any;
+}
+declare function Mont(m: any): void;
+declare class Mont {
+    constructor(m: any);
+    shift: any;
+    r: BN;
+    r2: any;
+    rinv: BN;
+    minv: any;
+    convertTo(num: any): any;
+    convertFrom(num: any): any;
+    imul(a: any, b: any): any;
+    mul(a: any, b: any): any;
+    invm(a: any): any;
+}

package/types/crypto/bn.d.cts

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