@opcat-labs/opcat 1.0.0 → 1.0.2

package/types/transaction/input/multisig.d.cts

@@ -0,0 +1,127 @@
+export = MultiSigInput;
+/**
+ * Represents a MultiSigInput for a transaction.
+ * @constructor
+ * @param {Object} input - The input object containing publicKeys, threshold, and signatures.
+ * @param {Array} pubkeys - Array of public keys (optional, defaults to input.publicKeys).
+ * @param {number} threshold - Required number of signatures (optional, defaults to input.threshold).
+ * @param {Array} signatures - Array of signatures (optional, defaults to input.signatures).
+ * @description Validates that provided public keys match the output script and initializes signatures.
+ */
+declare function MultiSigInput(input: any, pubkeys: any[], threshold: number, signatures: any[], ...args: any[]): void;
+declare class MultiSigInput {
+    /**
+     * Represents a MultiSigInput for a transaction.
+     * @constructor
+     * @param {Object} input - The input object containing publicKeys, threshold, and signatures.
+     * @param {Array} pubkeys - Array of public keys (optional, defaults to input.publicKeys).
+     * @param {number} threshold - Required number of signatures (optional, defaults to input.threshold).
+     * @param {Array} signatures - Array of signatures (optional, defaults to input.signatures).
+     * @description Validates that provided public keys match the output script and initializes signatures.
+     */
+    constructor(input: any, pubkeys: any[], threshold: number, signatures: any[], ...args: any[]);
+    publicKeys: PublicKey[];
+    publicKeyIndex: {};
+    threshold: number;
+    signatures: any[];
+    /**
+     * Converts the MultiSigInput instance to a plain object representation.
+     * Includes threshold, publicKeys (converted to strings), and serialized signatures.
+     * @returns {Object} The plain object representation of the MultiSigInput.
+     */
+    toObject(...args: any[]): any;
+    private _deserializeSignatures;
+    private _serializeSignatures;
+    /**
+     * Gets signatures for a MultiSigInput by signing the transaction with the provided private key.
+     * Only signs for public keys that match the private key's public key.
+     *
+     * @param {Transaction} transaction - The transaction to sign
+     * @param {PrivateKey} privateKey - The private key used for signing
+     * @param {number} index - The input index
+     * @param {number} [sigtype=Signature.SIGHASH_ALL] - The signature type
+     * @returns {TransactionSignature[]} Array of transaction signatures
+     */
+    getSignatures(transaction: Transaction, privateKey: PrivateKey, index: number, sigtype?: number): TransactionSignature[];
+    /**
+     * Adds a signature to the MultiSigInput if valid and not already fully signed.
+     * @param {Object} transaction - The transaction to validate the signature against.
+     * @param {Object} signature - The signature object containing publicKey and signature data.
+     * @throws {Error} If already fully signed, no matching public key, or invalid signature.
+     * @returns {MultiSigInput} Returns the instance for chaining.
+     */
+    addSignature(transaction: any, signature: any): MultiSigInput;
+    /**
+     * Updates the multisig input script by rebuilding it with current public keys, threshold, and signatures.
+     * @returns {MultiSigInput} Returns the instance for chaining.
+     */
+    _updateScript(): MultiSigInput;
+    /**
+     * Creates DER-encoded signatures from the input's signature data.
+     * Filters out undefined signatures and converts each valid signature to a Buffer
+     * containing the DER-encoded signature followed by its sigtype byte.
+     * @returns {Buffer[]} Array of signature Buffers
+     */
+    _createSignatures(): Buffer[];
+    /**
+     * Clears all signatures from the MultiSigInput by resetting the signatures array
+     * and updating the script. The signatures array length matches the publicKeys array.
+     */
+    clearSignatures(): void;
+    /**
+     * Checks if the MultiSigInput is fully signed by comparing the number of signatures
+     * with the required threshold.
+     * @returns {boolean} True if the input has enough signatures, false otherwise.
+     */
+    isFullySigned(): boolean;
+    /**
+     * Returns the number of missing signatures required to meet the threshold.
+     * @returns {number} The count of missing signatures.
+     */
+    countMissingSignatures(): number;
+    /**
+     * Counts the number of valid signatures in the MultiSigInput.
+     * @returns {number} The count of non-null/undefined signatures.
+     */
+    countSignatures(): number;
+    /**
+     * Returns an array of public keys that haven't been signed yet in this MultiSigInput.
+     * @returns {Array} Array of unsigned public keys
+     */
+    publicKeysWithoutSignature(): any[];
+    /**
+     * Verifies a signature for a MultiSigInput transaction.
+     *
+     * @param {Object} transaction - The transaction to verify.
+     * @param {Object} signature - The signature object containing signature data.
+     * @param {Buffer} signature.signature - The signature to verify.
+     * @param {Buffer} signature.publicKey - The public key corresponding to the signature.
+     * @param {number} signature.inputIndex - The index of the input being signed.
+     * @param {number} signature.sigtype - The signature type (assigned to nhashtype as a workaround).
+     * @returns {boolean} True if the signature is valid, false otherwise.
+     */
+    isValidSignature(transaction: any, signature: {
+        signature: Buffer;
+        publicKey: Buffer;
+        inputIndex: number;
+        sigtype: number;
+    }): boolean;
+    private _estimateSize;
+}
+declare namespace MultiSigInput {
+    /**
+     * Normalizes signatures for a MultiSigInput by matching each public key with its corresponding signature.
+     * Filters and validates signatures against the provided public keys and transaction.
+     *
+     * @param {Object} transaction - The transaction to verify against.
+     * @param {Object} input - The input containing prevTxId and outputIndex.
+     * @param {number} inputIndex - The index of the input in the transaction.
+     * @param {Array<Buffer>} signatures - Array of signature buffers to normalize.
+     * @param {Array<PublicKey>} publicKeys - Array of public keys to match signatures against.
+     * @returns {Array<TransactionSignature|null>} Array of matched signatures or null for unmatched keys.
+     */
+    function normalizeSignatures(transaction: any, input: any, inputIndex: number, signatures: Buffer[], publicKeys: PublicKey[]): TransactionSignature[];
+    let SIGNATURE_SIZE: number;
+}
+import PublicKey = require("../../publickey.cjs");
+import TransactionSignature = require("../signature.cjs");

package/types/transaction/input/publickey.d.cts

@@ -0,0 +1,44 @@
+export = PublicKeyInput;
+/**
+ * Represents a special kind of input of PayToPublicKey kind.
+ * @constructor
+ */
+declare function PublicKeyInput(...args: any[]): void;
+declare class PublicKeyInput {
+    /**
+     * Represents a special kind of input of PayToPublicKey kind.
+     * @constructor
+     */
+    constructor(...args: any[]);
+    /**
+     * @param {Transaction} transaction - the transaction to be signed
+     * @param {PrivateKey} privateKey - the private key with which to sign the transaction
+     * @param {number} index - the index of the input in the transaction input vector
+     * @param {number} [sigtype] - the type of signature, defaults to Signature.SIGHASH_ALL
+     * @return {Array} of objects that can be
+     */
+    getSignatures(transaction: Transaction, privateKey: PrivateKey, index: number, sigtype?: number): any[];
+    /**
+     * Adds a signature to the public key input after validating it.
+     * @param {Object} transaction - The transaction to validate against.
+     * @param {TransactionSignature} signature - The signature object containing signature data and type.
+     * @returns {PublicKeyInput} Returns the instance for chaining.
+     * @throws {Error} Throws if the signature is invalid.
+     */
+    addSignature(transaction: any, signature: TransactionSignature): PublicKeyInput;
+    /**
+     * Clears all signatures from this input by setting an empty script.
+     * @returns {PublicKeyInput} The instance for chaining.
+     */
+    clearSignatures(): PublicKeyInput;
+    /**
+     * Checks if the public key input is fully signed by verifying the script contains a public key.
+     * @returns {boolean} True if the script contains a public key, false otherwise.
+     */
+    isFullySigned(): boolean;
+    private _estimateSize;
+}
+declare namespace PublicKeyInput {
+    let SCRIPT_MAX_SIZE: number;
+}
+import TransactionSignature = require("../signature.cjs");

package/types/transaction/input/publickeyhash.d.cts

@@ -0,0 +1,45 @@
+export = PublicKeyHashInput;
+/**
+ * Represents a special kind of input of PayToPublicKeyHash kind.
+ * @constructor
+ */
+declare function PublicKeyHashInput(...args: any[]): void;
+declare class PublicKeyHashInput {
+    /**
+     * Represents a special kind of input of PayToPublicKeyHash kind.
+     * @constructor
+     */
+    constructor(...args: any[]);
+    /**
+     * @param {Transaction} transaction - the transaction to be signed
+     * @param {PrivateKey} privateKey - the private key with which to sign the transaction
+     * @param {number} index - the index of the input in the transaction input vector
+     * @param {number} [sigtype] - the type of signature, defaults to Signature.SIGHASH_ALL
+     * @param {Buffer} [hashData] - the precalculated hash of the public key associated with the privateKey provided
+     * @return {Array} of objects that can be
+     */
+    getSignatures(transaction: Transaction, privateKey: PrivateKey, index: number, sigtype?: number, hashData?: Buffer): any[];
+    /**
+     * Adds a signature to the input and updates the script.
+     * @param {Transaction} transaction - The transaction to validate against.
+     * @param {TransactionSignature} signature - The signature object containing publicKey, signature (DER format), and sigtype.
+     * @returns {PublicKeyHashInput} Returns the instance for chaining.
+     * @throws {Error} Throws if the signature is invalid.
+     */
+    addSignature(transaction: Transaction, signature: TransactionSignature): PublicKeyHashInput;
+    /**
+     * Clear the input's signature
+     * @return {PublicKeyHashInput} this, for chaining
+     */
+    clearSignatures(): PublicKeyHashInput;
+    /**
+     * Query whether the input is signed
+     * @return {boolean}
+     */
+    isFullySigned(): boolean;
+    private _estimateSize;
+}
+declare namespace PublicKeyHashInput {
+    let SCRIPT_MAX_SIZE: number;
+}
+import TransactionSignature = require("../signature.cjs");

package/types/transaction/output.d.cts

@@ -0,0 +1,118 @@
+export = Output;
+/**
+ * Represents a transaction output in the Bitcoin protocol.
+ * @constructor
+ * @param {Object} args - The arguments to create an Output.
+ * @param {number} args.satoshis - The amount in satoshis.
+ * @param {Buffer|string|Script} args.script - The output script (either as Buffer or hex string).
+ * @param {Buffer|string} [args.data] - Additional data associated with the output.
+ * @throws {TypeError} If arguments are invalid or unrecognized.
+ */
+declare function Output(args: {
+    satoshis: number;
+    script: Buffer | string | Script;
+    data?: Buffer | string;
+}): Output;
+declare class Output {
+    /**
+     * Represents a transaction output in the Bitcoin protocol.
+     * @constructor
+     * @param {Object} args - The arguments to create an Output.
+     * @param {number} args.satoshis - The amount in satoshis.
+     * @param {Buffer|string|Script} args.script - The output script (either as Buffer or hex string).
+     * @param {Buffer|string} [args.data] - Additional data associated with the output.
+     * @throws {TypeError} If arguments are invalid or unrecognized.
+     */
+    constructor(args: {
+        satoshis: number;
+        script: Buffer | string | Script;
+        data?: Buffer | string;
+    });
+    satoshis: number;
+    get script(): Script;
+    get data(): Buffer;
+    /**
+     * Checks if the satoshis value in this output is invalid.
+     * @returns {string|boolean} Returns an error message string if invalid (satoshis exceed max safe integer,
+     *                           corrupted value, or negative), otherwise returns false.
+     */
+    invalidSatoshis(): string | boolean;
+    set satoshisBN(value: any);
+    get satoshisBN(): any;
+    /**
+     * Converts the Output instance to a plain object representation.
+     * The resulting object includes satoshis, script (as hex string), and data (as hex string).
+     * @returns {Object} - An object with satoshis, script, and data properties.
+     */
+    toObject: () => any;
+    toJSON(): any;
+    /**
+     * Sets the output data.
+     * @param {Buffer|string} data - The data to set. Can be a Buffer or hex string.
+     * @throws {TypeError} If data is not a Buffer or valid hex string.
+     */
+    setData(data: Buffer | string): void;
+    _data: Buffer;
+    /**
+     * Sets the script for this output from a buffer.
+     * @param {Buffer} buffer - The buffer containing the script data.
+     * @throws {errors.Script.InvalidBuffer} If the buffer is invalid.
+     */
+    setScriptFromBuffer(buffer: Buffer): void;
+    _script: Script;
+    /**
+     * Sets the script for this output.
+     * @param {Script|string|Buffer} script - The script to set, which can be a Script instance, hex string, or Buffer.
+     * @returns {Output} Returns the output instance for chaining.
+     * @throws {TypeError} Throws if the script type is invalid.
+     */
+    setScript(script: Script | string | Buffer): Output;
+    /**
+     * Returns a human-readable string representation of the Output object.
+     * Format: '<Output (satoshis sats) scriptString>'
+     * @returns {string} Formatted string showing satoshis and script inspection result
+     */
+    inspect(): string;
+    /**
+     * Converts the Output instance to a buffer writer format.
+     * @param {boolean} hashScriptPubkey - If true, hashes script and data with SHA256; otherwise writes them directly.
+     * @param {BufferWriter} [writer] - Optional BufferWriter instance. If not provided, a new one is created.
+     * @returns {BufferWriter} The buffer writer containing the serialized output data.
+     */
+    toBufferWriter(hashScriptPubkey: boolean, writer?: BufferWriter): BufferWriter;
+    /**
+     * Calculates the total size of the output in bytes.
+     * Includes the script size, data size, and their respective varint sizes,
+     * plus a fixed 8-byte overhead.
+     * 8    value
+     * ???  script+data size (VARINT)
+     * script size
+     * data size
+     * @returns {number} The total output size in bytes.
+     */
+    getSize(): number;
+    /**
+     * Creates a shallow clone of the Output instance.
+     * @returns {Output} A new Output instance with the same properties as the original.
+     */
+    clone(): Output;
+}
+declare namespace Output {
+    /**
+     * Creates an Output instance from a plain JavaScript object.
+     * @param {Object} data - The input object to convert to an Output
+     * @returns {Output} A new Output instance
+     * @static
+     */
+    function fromObject(data: any): Output;
+    /**
+     * Creates an Output instance from a BufferReader.
+     * @param {BufferReader} br - The buffer reader containing output data
+     * @returns {Output} A new Output instance
+     * @throws {TypeError} If the buffer contains unrecognized output format
+     * @static
+     */
+    function fromBufferReader(br: BufferReader): Output;
+}
+import Script = require("../script/script.cjs");
+import BufferWriter = require("../encoding/bufferwriter.cjs");

package/types/transaction/sighash.d.cts

@@ -0,0 +1,61 @@
+export = Sighash;
+/**
+ * Represents a Sighash utility for cryptographic signature operations.
+ * @constructor
+ */
+declare function Sighash(): void;
+declare class Sighash {
+}
+declare namespace Sighash {
+    /**
+     * Returns a buffer with the which is hashed with sighash that needs to be signed
+     * for OP_CHECKSIG.
+     *
+     * @name Signing.sighash
+     * @param {Transaction} transaction the transaction to sign
+     * @param {number} sighashType the type of the hash
+     * @param {number} inputNumber the input index for the signature
+     * @param {Script} subscript the script that will be signed
+     * @param {satoshisBN} input's amount (for  ForkId signatures)
+     *
+     */
+    function sighashPreimage(transaction: Transaction, sighashType: number, inputNumber: number): Buffer;
+    function getLowSSighashPreimage(tx: any, sigtype: any, inputIndex: any): Buffer;
+    /**
+     * Returns a buffer of length 32 bytes with the hash that needs to be signed
+     * for OP_CHECKSIG.
+     *
+     * @name Signing.sighash
+     * @param {Transaction} transaction the transaction to sign
+     * @param {number} sighashType the type of the hash
+     * @param {number} inputNumber the input index for the signature
+     *
+     */
+    function sighash(transaction: Transaction, sighashType: number, inputNumber: number): Buffer;
+    /**
+     * Create a signature
+     *
+     * @name Signing.sign
+     * @param {Transaction} transaction
+     * @param {PrivateKey} privateKey
+     * @param {number} sighash
+     * @param {number} inputIndex
+     * @return {Signature}
+     */
+    function sign(transaction: Transaction, privateKey: PrivateKey, sighashType: any, inputIndex: number): Signature;
+    /**
+     * Verify a signature
+     *
+     * @name Signing.verify
+     * @param {Transaction} transaction
+     * @param {Signature} signature
+     * @param {PublicKey} publicKey
+     * @param {number} inputIndex
+     * @param {Script} subscript
+     * @param {satoshisBN} input's amount
+     * @param {flags} verification flags
+     * @return {boolean}
+     */
+    function verify(transaction: Transaction, signature: Signature, publicKey: PublicKey, inputIndex: number): boolean;
+}
+import Signature = require("../crypto/signature.cjs");

package/types/transaction/signature.d.cts

@@ -0,0 +1,43 @@
+export = TransactionSignature;
+/**
+ * @desc
+ * Wrapper around Signature with fields related to signing a transaction specifically
+ *
+ * @param {Object|string|TransactionSignature} arg
+ * @constructor
+ */
+declare function TransactionSignature(arg: any | string | TransactionSignature): TransactionSignature;
+declare class TransactionSignature {
+    /**
+     * @desc
+     * Wrapper around Signature with fields related to signing a transaction specifically
+     *
+     * @param {Object|string|TransactionSignature} arg
+     * @constructor
+     */
+    constructor(arg: any | string | TransactionSignature);
+    private _fromObject;
+    publicKey: PublicKey;
+    prevTxId: Buffer;
+    outputIndex: number;
+    inputIndex: number;
+    signature: Signature;
+    sigtype: number;
+    private _checkObjectArgs;
+    /**
+     * Serializes a transaction to a plain JS object
+     * @return {Object}
+     */
+    toObject: () => any;
+    toJSON(): any;
+}
+declare namespace TransactionSignature {
+    /**
+     * Builds a TransactionSignature from an object
+     * @param {Object} object
+     * @return {TransactionSignature}
+     */
+    function fromObject(object: any): TransactionSignature;
+}
+import PublicKey = require("../publickey.cjs");
+import Signature = require("../crypto/signature.cjs");