xpi-ts 0.2.22 → 0.2.24

package/dist/types/lib/bitcore/crypto/signature.d.ts

@@ -1,5 +1,37 @@
+/**
+ * Digital signature handling for ECDSA and Schnorr signatures in Lotus
+ *
+ * This module provides a unified Signature class that supports both:
+ * - ECDSA signatures (DER-encoded, variable length ~70-72 bytes)
+ * - Schnorr signatures (fixed 64 bytes, big-endian)
+ *
+ * The signature type is automatically detected and handled based on:
+ * - The `isSchnorr` flag
+ * - The signature length (64 bytes = Schnorr)
+ * - The serialization method parameter
+ *
+ * Key Features:
+ * - Unified API for both signature types
+ * - Automatic type detection
+ * - Multiple serialization formats (DER, compact, transaction format)
+ * - Full validation and parsing
+ *
+ * Reference: lotusd/src/secp256k1/ and lotusd/src/pubkey.cpp
+ *
+ * Migrated from bitcore-lib-xpi with ESM support and BigInt
+ */
 import { BN } from './bn';
 import type { Buffer } from 'buffer/';
+/**
+ * Data structure for initializing a Signature object
+ *
+ * @property r - The r value of the signature (x-coordinate of ephemeral public key)
+ * @property s - The s value of the signature (proof component)
+ * @property i - Recovery ID for ECDSA signature recovery (0-3)
+ * @property compressed - Whether the signature uses compressed public key
+ * @property isSchnorr - Flag indicating if this is a Schnorr signature (vs ECDSA)
+ * @property nhashtype - Signature hash type (SIGHASH_ALL, etc.)
+ */
 export interface SignatureData {
     r: BN;
     s: BN;
@@ -9,48 +41,468 @@ export interface SignatureData {
     nhashtype?: number;
 }
 export type SignatureSigningMethod = 'schnorr' | 'ecdsa';
+/**
+ * Represents a cryptographic signature (ECDSA or Schnorr)
+ *
+ * This class handles both ECDSA and Schnorr signatures with a unified interface.
+ * The signature type is determined by the `isSchnorr` flag or automatically
+ * detected during parsing based on signature length and format.
+ *
+ * Signature Types:
+ * - **ECDSA**: DER-encoded, variable length (typically 70-72 bytes), must use low-S
+ * - **Schnorr**: Fixed 64 bytes, big-endian format [r (32) || s (32)]
+ *
+ * Serialization Formats:
+ * - DER: Standard format (toDER)
+ * - Transaction: DER + 1-byte sighash type (toTxFormat)
+ * - Compact: Recovery format for message signing (toCompact)
+ *
+ * @example ECDSA Usage
+ * ```typescript
+ * const sig = ECDSA.sign(hash, privateKey)
+ * const der = sig.toDER() // Returns DER-encoded bytes
+ * const txFormat = sig.toTxFormat() // Adds sighash byte
+ * ```
+ *
+ * @example Schnorr Usage
+ * ```typescript
+ * const sig = Schnorr.sign(hash, privateKey)
+ * const bytes = sig.toDER('schnorr') // Returns 64 bytes big-endian
+ * const txFormat = sig.toTxFormat('schnorr') // 65 bytes with sighash
+ * ```
+ */
 export declare class Signature {
+    /** The r value of the signature (elliptic curve point x-coordinate) */
     r: BN;
+    /** The s value of the signature (proof component) */
     s: BN;
+    /** Recovery ID for ECDSA public key recovery (0-3), used in message signing */
     i?: number;
+    /** Whether this signature uses a compressed public key */
     compressed?: boolean;
+    /** Flag indicating if this is a Schnorr signature (true) or ECDSA (false/undefined) */
     isSchnorr?: boolean;
+    /** Signature hash type - determines what parts of the transaction are signed */
     nhashtype?: number;
+    /**
+     * SIGHASH_ALL (0x01): Sign all inputs and outputs
+     *
+     * This is the most common and secure sighash type. It commits to:
+     * - All transaction inputs
+     * - All transaction outputs
+     * - Transaction version and locktime
+     *
+     * This prevents any modification of the transaction after signing.
+     *
+     * @constant
+     */
     static readonly SIGHASH_ALL = 1;
+    /**
+     * SIGHASH_NONE (0x02): Sign all inputs, but no outputs
+     *
+     * Allows outputs to be modified after signing. Commits to:
+     * - All transaction inputs
+     * - Transaction version and locktime
+     * - NO outputs (can be changed)
+     *
+     * WARNING: Rarely used, can be dangerous if not understood properly.
+     *
+     * @constant
+     */
     static readonly SIGHASH_NONE = 2;
+    /**
+     * SIGHASH_SINGLE (0x03): Sign all inputs and one corresponding output
+     *
+     * Signs only the output at the same index as the input being signed.
+     * Other outputs can be modified. Commits to:
+     * - All transaction inputs
+     * - The output at the same index as this input
+     * - Transaction version and locktime
+     *
+     * Used for more complex transaction constructions.
+     *
+     * @constant
+     */
     static readonly SIGHASH_SINGLE = 3;
+    /**
+     * SIGHASH_FORKID (0x40): Use BIP143 sighash algorithm
+     *
+     * Indicates the signature uses the BIP143 sighash algorithm (BCH-style).
+     * This is the standard for Lotus transactions and provides:
+     * - Protection against replay attacks
+     * - More efficient validation
+     * - Better hardware wallet support
+     *
+     * This flag is typically combined with base types:
+     * - SIGHASH_ALL | SIGHASH_FORKID = 0x41 (most common)
+     * - SIGHASH_NONE | SIGHASH_FORKID = 0x42
+     * - SIGHASH_SINGLE | SIGHASH_FORKID = 0x43
+     *
+     * Reference: BIP143 (Bitcoin Cash sighash)
+     *
+     * @constant
+     */
     static readonly SIGHASH_FORKID = 64;
+    /**
+     * SIGHASH_LOTUS (0x60): Use Lotus-specific sighash algorithm
+     *
+     * Indicates the signature uses the Lotus sighash algorithm.
+     * This is a more advanced sighash that includes:
+     * - Merkle roots for inputs and outputs (instead of simple hashes)
+     * - Merkle tree heights for efficient validation
+     * - Total input and output amounts
+     * - Support for taproot/tapscript execution data
+     *
+     * Benefits over BIP143 (FORKID):
+     * - More efficient batch validation via merkle proofs
+     * - Better scaling for large transactions
+     * - Enables future optimization strategies
+     *
+     * Usage Requirements:
+     * - Must combine with a base type (SIGHASH_ALL or SIGHASH_SINGLE)
+     * - SIGHASH_FORKID is already included (bit 6 is set in 0x60)
+     * - Must provide spent outputs for all inputs via transaction.from()
+     * - Example: SIGHASH_ALL | SIGHASH_LOTUS = 0x61
+     *
+     * Note: SIGHASH_LOTUS (0x60 = 0110 0000) already includes SIGHASH_FORKID
+     * (0x40 = 0100 0000) because bit 6 is set. Adding FORKID is redundant.
+     *
+     * Status: ✅ FULLY IMPLEMENTED as of October 28, 2025
+     *
+     * Reference: lotusd/src/script/interpreter.cpp lines 1782-1846
+     * Implementation: sighash.ts sighashForLotus()
+     *
+     * @constant
+     */
     static readonly SIGHASH_LOTUS = 96;
+    /**
+     * SIGHASH_ANYONECANPAY (0x80): Sign only this input, others can be added
+     *
+     * Modifier flag that changes how inputs are signed. When set:
+     * - Only the current input is signed
+     * - Other inputs can be added or removed
+     * - All outputs are still signed (unless combined with NONE/SINGLE)
+     *
+     * Commonly combined with other flags:
+     * - SIGHASH_ALL | SIGHASH_ANYONECANPAY | SIGHASH_FORKID = 0xC1
+     *
+     * Use cases:
+     * - Crowdfunding transactions (anyone can add inputs)
+     * - Partial transaction signing
+     *
+     * @constant
+     */
     static readonly SIGHASH_ANYONECANPAY = 128;
+    /**
+     * SIGHASH_RESERVED (0x20): Invalid reserved sighash algorithm
+     *
+     * This value is explicitly reserved and must not be used.
+     * Any signature using this algorithm value will be rejected.
+     *
+     * Reference: lotusd/src/script/sighashtype.h
+     *
+     * @constant
+     */
     static readonly SIGHASH_RESERVED = 32;
+    /**
+     * SIGHASH_ALGORITHM_MASK (0x60): Bits which specify the sighash algorithm
+     *
+     * Masks bits 5-6 to extract the algorithm type:
+     * - 0x00 = LEGACY (original Bitcoin sighash)
+     * - 0x20 = RESERVED (invalid)
+     * - 0x40 = FORKID (BIP143)
+     * - 0x60 = LOTUS (Lotus sighash with merkle trees)
+     *
+     * Reference: lotusd/src/script/sighashtype.h
+     *
+     * @constant
+     */
     static readonly SIGHASH_ALGORITHM_MASK = 96;
+    /**
+     * Create a new Signature instance
+     *
+     * @param r - Either a BN representing the r value, or a SignatureData object with all properties
+     * @param s - The s value as a BN (only used if first param is BN)
+     * @param isSchnorr - Whether this is a Schnorr signature (only used if first param is BN)
+     *
+     * @example Create from r and s values
+     * ```typescript
+     * const sig = new Signature(rBN, sBN, false) // ECDSA
+     * const sig = new Signature(rBN, sBN, true)  // Schnorr
+     * ```
+     *
+     * @example Create from SignatureData object
+     * ```typescript
+     * const sig = new Signature({
+     *   r: rBN,
+     *   s: sBN,
+     *   isSchnorr: true,
+     *   nhashtype: Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID
+     * })
+     * ```
+     */
     constructor(r: BN | SignatureData, s?: BN, isSchnorr?: boolean);
+    /**
+     * Factory function to create a Signature without 'new' keyword
+     *
+     * @param r - Either a BN or SignatureData object
+     * @param s - The s value (if r is a BN)
+     * @param isSchnorr - Schnorr flag (if r is a BN)
+     * @returns New Signature instance
+     */
     static create(r?: BN | SignatureData, s?: BN, isSchnorr?: boolean): Signature;
+    /**
+     * Set signature properties from a data object
+     *
+     * Updates the signature's properties with values from the provided object.
+     * Only updates properties that are defined in the object.
+     *
+     * @param obj - Object containing signature properties to set
+     * @returns This signature instance for chaining
+     */
     set(obj: SignatureData): Signature;
+    /**
+     * Create signature from compact format (used for message signing)
+     *
+     * Compact format is used for Bitcoin message signing and includes:
+     * - 1 byte: recovery ID + compression flag (27-34)
+     * - 32 bytes: r value (little-endian)
+     * - 32 bytes: s value (little-endian)
+     *
+     * Total: 65 bytes
+     *
+     * Note: This format uses little-endian for compatibility with message signing.
+     * This is different from Schnorr signatures which use big-endian.
+     *
+     * @param buf - 65-byte buffer in compact format
+     * @returns Signature with recovery ID and compression flag set
+     * @throws Error if buffer format is invalid
+     */
     static fromCompact(buf: Buffer): Signature;
+    /**
+     * Create signature from DER or Schnorr format (auto-detect)
+     *
+     * This is the main parsing method that automatically detects signature type:
+     * - If 64-65 bytes and doesn't start with 0x30: Parse as Schnorr
+     * - Otherwise: Parse as DER-encoded ECDSA
+     *
+     * Schnorr Detection:
+     * - 64 bytes: Schnorr signature without sighash
+     * - 65 bytes starting with non-0x30: Schnorr with sighash
+     *
+     * ECDSA Format:
+     * - Starts with 0x30 (DER sequence marker)
+     * - Variable length (typically 70-72 bytes)
+     * - Strictly validated if strict=true
+     *
+     * @param buf - Buffer containing the signature
+     * @param strict - If true, enforce strict DER validation (default: true)
+     * @returns Signature object with isSchnorr flag set appropriately
+     * @throws Error if format is invalid
+     */
     static fromDER(buf: Buffer, strict?: boolean): Signature;
+    /**
+     * Create signature from buffer (alias for fromDER)
+     *
+     * @param buf - Buffer containing signature data
+     * @param strict - Enforce strict DER validation
+     * @returns Signature object
+     */
     static fromBuffer(buf: Buffer, strict?: boolean): Signature;
+    /**
+     * Create signature from transaction format
+     *
+     * Transaction format includes the signature plus a 1-byte sighash type:
+     * - ECDSA: [DER signature (70-72 bytes)] + [sighash byte]
+     * - Schnorr: [64-byte signature] + [sighash byte]
+     *
+     * The sighash byte is extracted and set as the nhashtype property.
+     *
+     * @param buf - Buffer in transaction format (signature + sighash byte)
+     * @returns Signature with nhashtype property set
+     */
     static fromTxFormat(buf: Buffer): Signature;
+    /**
+     * Create signature from data format (alias for fromDER with non-strict parsing)
+     *
+     * @param buf - Buffer containing signature
+     * @returns Signature object
+     */
     static fromDataFormat(buf: Buffer): Signature;
+    /**
+     * Create signature from hexadecimal string
+     *
+     * @param str - Hex string representing the signature
+     * @returns Signature object
+     */
     static fromString(str: string): Signature;
+    /**
+     * Create signature from Schnorr format
+     *
+     * Accepts 64-byte Schnorr signature or 65-byte with sighash type
+     *
+     * @param buf - Buffer containing Schnorr signature
+     * @returns Signature object with isSchnorr flag set
+     */
     static fromSchnorr(buf: Buffer): Signature;
+    /**
+     * Parse Schnorr encoded signature
+     *
+     * Schnorr signatures are 64 bytes (r + s) or 65 bytes (r + s + sighash)
+     * Both r and s are 32-byte values in big-endian format
+     *
+     * CRITICAL: Schnorr signatures use big-endian byte order per Lotus specification
+     * Reference: lotusd/src/secp256k1/src/modules/schnorr/schnorr_impl.h
+     */
     static parseSchnorrEncodedSig(buf: Buffer): {
         r: BN;
         s: BN;
         nhashtype?: Buffer;
     };
+    /**
+     * Parse DER-encoded ECDSA signature
+     *
+     * DER (Distinguished Encoding Rules) format structure:
+     * ```
+     * 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
+     * ```
+     *
+     * Validation checks:
+     * - Must start with 0x30 (SEQUENCE marker)
+     * - Length bytes must match actual content
+     * - R and S must start with 0x02 (INTEGER marker)
+     * - No unnecessary padding
+     * - High bit padding for positive values
+     *
+     * @param buf - Buffer containing DER-encoded signature
+     * @param strict - If true, enforce strict DER validation
+     * @returns Object with r and s as BN values (big-endian)
+     * @throws Error if DER format is invalid
+     */
     static parseDER(buf: Buffer, strict?: boolean): {
         r: BN;
         s: BN;
     };
+    /**
+     * Convert signature to compact format (for message signing)
+     *
+     * Compact format encodes the signature with recovery information:
+     * - Byte 0: recovery ID (0-3) + 27 + (compressed ? 4 : 0)
+     * - Bytes 1-32: r value (little-endian)
+     * - Bytes 33-64: s value (little-endian)
+     *
+     * Total: 65 bytes
+     *
+     * Note: Uses little-endian for compatibility with Bitcoin message signing.
+     *
+     * @param i - Recovery ID override (0-3), uses this.i if not provided
+     * @param compressed - Compression flag override, uses this.compressed if not provided
+     * @returns 65-byte buffer in compact format
+     * @throws Error if recovery ID is invalid
+     */
     toCompact(i?: number, compressed?: boolean): Buffer;
+    /**
+     * Convert to DER format
+     *
+     * For ECDSA: Returns DER-encoded signature (variable length, typically 70-72 bytes)
+     * For Schnorr: Returns 64-byte signature in big-endian format [r (32) || s (32)]
+     *
+     * CRITICAL: Schnorr signatures use big-endian byte order per Lotus specification
+     * Reference: lotusd/src/secp256k1/src/modules/schnorr/schnorr_impl.h
+     */
     toDER(signingMethod?: string): Buffer;
+    /**
+     * Convert to buffer format (alias for toDER)
+     *
+     * @param signingMethod - 'ecdsa' (default) or 'schnorr'
+     * @returns Signature as Buffer
+     */
     toBuffer(signingMethod?: string): Buffer;
+    /**
+     * Convert to hexadecimal string
+     *
+     * Automatically detects format based on isSchnorr flag.
+     * For Schnorr: Returns 64-byte raw signature as hex
+     * For ECDSA: Returns DER-encoded signature as hex
+     *
+     * @returns Hex string of signature
+     */
     toString(): string;
+    /**
+     * Convert to transaction format (signature + sighash byte)
+     *
+     * This is the format used in transaction scriptSig:
+     * - ECDSA: [DER signature (70-72 bytes)] + [sighash type (1 byte)] = 71-73 bytes
+     * - Schnorr: [64-byte signature] + [sighash type (1 byte)] = 65 bytes
+     *
+     * The sighash byte indicates what parts of the transaction are signed.
+     * For Schnorr signatures (Taproot), defaults to SIGHASH_ALL | SIGHASH_LOTUS.
+     *
+     * @param signingMethod - 'ecdsa' (default) or 'schnorr'
+     * @returns Buffer with signature + sighash byte appended
+     *
+     * @example
+     * ```typescript
+     * const sig = ECDSA.sign(hash, privkey)
+     * sig.nhashtype = Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID
+     * const txFormat = sig.toTxFormat() // 71-73 bytes
+     * ```
+     */
     toTxFormat(signingMethod?: SignatureSigningMethod): Buffer;
+    /**
+     * Check if buffer contains a valid DER-encoded signature
+     *
+     * Validates DER encoding rules without throwing errors:
+     * - Length between 8 and 72 bytes
+     * - Proper DER structure with sequence and integer markers
+     * - Valid length encodings
+     * - No unnecessary padding
+     *
+     * This is a non-throwing validation useful for checking if data
+     * is likely a valid ECDSA signature.
+     *
+     * @param buf - Buffer to validate
+     * @returns true if buffer appears to be valid DER signature
+     */
     static isDER(buf: Buffer): boolean;
+    /**
+     * Check if signature has low S value (BIP 62 compliance)
+     *
+     * To prevent signature malleability, Lotus requires that S <= (n-1)/2
+     * where n is the secp256k1 curve order.
+     *
+     * Threshold: 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0
+     *
+     * This check is important for:
+     * - Transaction signature validation
+     * - Preventing signature malleability attacks
+     * - Network consensus compliance
+     *
+     * Reference: lotusd enforces low-S via secp256k1_ecdsa_signature_normalize
+     *
+     * @returns true if S is in the low range [1, (n-1)/2]
+     */
     hasLowS(): boolean;
+    /**
+     * Check if signature has a valid/defined sighash type
+     *
+     * Validates that the nhashtype is a valid sighash type value.
+     * Valid base types are SIGHASH_ALL (1), SIGHASH_NONE (2), or SIGHASH_SINGLE (3).
+     * Can be combined with SIGHASH_FORKID (0x40), SIGHASH_LOTUS (0x60),
+     * and SIGHASH_ANYONECANPAY (0x80).
+     *
+     * @returns true if nhashtype is defined and valid
+     */
     hasDefinedHashtype(): boolean;
+    /**
+     * Check if buffer is valid transaction DER format
+     *
+     * Transaction format is: [DER signature] + [1-byte sighash type]
+     * This validates only the DER portion (excluding the last sighash byte).
+     *
+     * @param buf - Buffer to check (including sighash byte)
+     * @returns true if the signature portion (excluding last byte) is valid DER
+     */
     static isTxDER(buf: Buffer): boolean;
 }
 //# sourceMappingURL=signature.d.ts.map

package/dist/types/lib/bitcore/crypto/signature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../../../../lib/bitcore/crypto/signature.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../../../../lib/bitcore/crypto/signature.ts"],"names":[],"mappings":"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"}

package/dist/types/lib/bitcore/crypto/sigtype.d.ts

@@ -1,6 +1,52 @@
+/**
+ * Signature type detection utilities for Lotus
+ *
+ * Lotus automatically determines signature type by length:
+ * - 64 bytes = Schnorr signature
+ * - Other lengths (typically 70-72 bytes) = ECDSA signature (DER-encoded)
+ *
+ * Reference: lotusd/src/script/interpreter.cpp lines 1900-1908
+ * Reference: lotusd/src/script/sigencoding.cpp lines 156-158
+ */
 import type { Buffer } from 'buffer/';
+/**
+ * Check if a signature is Schnorr format (64 bytes)
+ *
+ * In Lotus, signatures are automatically interpreted as Schnorr if they are
+ * exactly 64 bytes long. This is checked before any other validation.
+ *
+ * @param sig - The signature buffer (without sighash byte)
+ * @returns true if signature is 64 bytes (Schnorr), false otherwise (ECDSA)
+ */
 export declare function isSchnorrSignature(sig: Buffer): boolean;
+/**
+ * Check if a signature is ECDSA format (DER-encoded)
+ *
+ * ECDSA signatures are DER-encoded and typically 70-72 bytes long.
+ * Any signature that is not 64 bytes is assumed to be ECDSA.
+ *
+ * @param sig - The signature buffer (without sighash byte)
+ * @returns true if signature is not 64 bytes (ECDSA), false if 64 bytes (Schnorr)
+ */
 export declare function isECDSASignature(sig: Buffer): boolean;
+/**
+ * Get signature type as string for debugging
+ *
+ * @param sig - The signature buffer (without sighash byte)
+ * @returns "schnorr" or "ecdsa"
+ */
 export declare function getSignatureType(sig: Buffer): 'schnorr' | 'ecdsa';
+/**
+ * Validate signature length
+ *
+ * Checks if a signature has a valid length for either Schnorr or ECDSA.
+ *
+ * Valid lengths:
+ * - Schnorr: Exactly 64 bytes
+ * - ECDSA: Typically 70-72 bytes, but can be 9-73 bytes (DER format)
+ *
+ * @param sig - The signature buffer (without sighash byte)
+ * @returns true if valid length, false otherwise
+ */
 export declare function isValidSignatureLength(sig: Buffer): boolean;
 //# sourceMappingURL=sigtype.d.ts.map

package/dist/types/lib/bitcore/crypto/sigtype.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sigtype.d.ts","sourceRoot":"","sources":["../../../../../lib/bitcore/crypto/sigtype.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAWrC,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEvD;AAWD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAErD;AAQD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAEjE;AAcD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAe3D"}
+{"version":3,"file":"sigtype.d.ts","sourceRoot":"","sources":["../../../../../lib/bitcore/crypto/sigtype.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAErC;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAEjE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAe3D"}

package/dist/types/lib/bitcore/encoding/base58.d.ts

@@ -1,17 +1,85 @@
+/**
+ * Base58 encoding/decoding module
+ * Migrated from bitcore-lib-xpi with ESM support and TypeScript
+ */
 import type { Buffer } from 'buffer/';
 export interface Base58Data {
     buf?: Buffer;
 }
+/**
+ * Base58 encoding/decoding class
+ *
+ * Provides utilities for encoding and decoding data using Base58 encoding,
+ * which is commonly used in Lotus and other cryptocurrencies for addresses
+ * and other data that needs to be human-readable.
+ *
+ * @example
+ * // Encode a buffer to Base58 string
+ * const encoded = Base58.encode(Buffer.from('hello'))
+ *
+ * @example
+ * // Decode a Base58 string to buffer
+ * const decoded = Base58.decode('Cn8eVZg')
+ *
+ * @example
+ * // Create instance from buffer
+ * const b58 = new Base58(Buffer.from('hello'))
+ * console.log(b58.toString())
+ */
 export declare class Base58 {
     buf?: Buffer;
+    /**
+     * Creates a new Base58 instance
+     * @param obj - Optional input: Buffer to encode, Base58 string to decode, or Base58Data object
+     */
     constructor(obj?: Buffer | string | Base58Data);
+    /**
+     * Validates that all characters in the input are valid Base58 characters
+     * @param chars - String or Buffer to validate
+     * @returns True if all characters are valid Base58 characters
+     */
     static validCharacters(chars: string | Buffer): boolean;
+    /**
+     * Sets the internal buffer from a Base58Data object
+     * @param obj - Object containing buffer data
+     * @returns This Base58 instance for chaining
+     */
     set(obj: Base58Data): Base58;
+    /**
+     * Encodes a buffer to a Base58 string
+     * @param buf - Buffer to encode
+     * @returns Base58 encoded string
+     * @throws Error if input is not a Buffer
+     */
     static encode(buf: Buffer): string;
+    /**
+     * Decodes a Base58 string to a buffer
+     * @param str - Base58 encoded string to decode
+     * @returns Decoded buffer
+     * @throws Error if input is not a string
+     */
     static decode(str: string): Buffer;
+    /**
+     * Sets the internal buffer from a Buffer
+     * @param buf - Buffer to store
+     * @returns This Base58 instance for chaining
+     */
     fromBuffer(buf: Buffer): Base58;
+    /**
+     * Decodes a Base58 string and stores the result in the internal buffer
+     * @param str - Base58 encoded string to decode
+     * @returns This Base58 instance for chaining
+     */
     fromString(str: string): Base58;
+    /**
+     * Returns the internal buffer
+     * @returns The stored buffer
+     */
     toBuffer(): Buffer;
+    /**
+     * Encodes the internal buffer to a Base58 string
+     * @returns Base58 encoded string
+     */
     toString(): string;
 }
 //# sourceMappingURL=base58.d.ts.map

package/dist/types/lib/bitcore/encoding/base58.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base58.d.ts","sourceRoot":"","sources":["../../../../../lib/bitcore/encoding/base58.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAKrC,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAsBD,qBAAa,MAAM;IACjB,GAAG,CAAC,EAAE,MAAM,CAAA;gBAMA,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU;IAiB9C,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAYvD,GAAG,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM;IAW5B,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAalC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAYlC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAU/B,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAU/B,QAAQ,IAAI,MAAM;IAQlB,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"base58.d.ts","sourceRoot":"","sources":["../../../../../lib/bitcore/encoding/base58.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAKrC,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,MAAM;IACjB,GAAG,CAAC,EAAE,MAAM,CAAA;IAEZ;;;OAGG;gBACS,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU;IAY9C;;;;OAIG;IACH,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAOvD;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM;IAK5B;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAOlC;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAOlC;;;;OAIG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAK/B;;;;OAIG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAM/B;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;OAGG;IACH,QAAQ,IAAI,MAAM;CAGnB"}