@btc-vision/bitcoin 6.5.6 → 7.0.0-alpha.0

package/browser/io/BinaryReader.d.ts

@@ -0,0 +1,276 @@
+/**
+ * Stateful binary reader with a single DataView instance.
+ *
+ * Zero allocations during read operations. The DataView is created once
+ * in the constructor and reused for all reads.
+ *
+ * @packageDocumentation
+ */
+/**
+ * High-performance binary reader for parsing binary data.
+ *
+ * Creates exactly ONE DataView instance that is reused for all read operations.
+ * This eliminates garbage collection pressure from repeated DataView allocations.
+ *
+ * @example
+ * ```typescript
+ * import { BinaryReader, fromHex } from '@btc-vision/bitcoin';
+ *
+ * // Parse a Bitcoin transaction
+ * const data = fromHex('01000000...');
+ * const reader = new BinaryReader(data);
+ *
+ * const version = reader.readInt32LE();
+ * const inputCount = reader.readVarInt();
+ *
+ * for (let i = 0; i < inputCount; i++) {
+ *     const txid = reader.readBytes(32);
+ *     const vout = reader.readUInt32LE();
+ *     const script = reader.readVarBytes();
+ *     const sequence = reader.readUInt32LE();
+ * }
+ * ```
+ */
+export declare class BinaryReader {
+    #private;
+    /**
+     * Creates a new BinaryReader.
+     *
+     * @param data - The byte array to read from
+     * @param offset - Initial read position (default 0)
+     *
+     * @example
+     * ```typescript
+     * import { BinaryReader, fromHex } from '@btc-vision/bitcoin';
+     *
+     * const data = fromHex('01020304');
+     * const reader = new BinaryReader(data);
+     * ```
+     */
+    constructor(data: Uint8Array, offset?: number);
+    /**
+     * Creates a BinaryReader from a hex string.
+     *
+     * @param hex - Hex string (with or without 0x prefix)
+     * @returns A new BinaryReader instance
+     *
+     * @example
+     * ```typescript
+     * import { BinaryReader } from '@btc-vision/bitcoin';
+     *
+     * const reader = BinaryReader.fromHex('01000000');
+     * const version = reader.readInt32LE(); // 1
+     * ```
+     */
+    static fromHex(hex: string): BinaryReader;
+    /**
+     * Current read position in the buffer.
+     */
+    get offset(): number;
+    /**
+     * Sets the read position.
+     *
+     * @param value - New offset value
+     * @throws RangeError if offset is negative or beyond buffer length
+     */
+    set offset(value: number);
+    /**
+     * Total length of the underlying buffer.
+     */
+    get length(): number;
+    /**
+     * Number of bytes remaining to be read.
+     */
+    get remaining(): number;
+    /**
+     * The underlying data buffer.
+     */
+    get data(): Uint8Array;
+    /**
+     * Reads an 8-bit unsigned integer.
+     *
+     * @returns The value (0-255)
+     * @throws RangeError if reading past end of buffer
+     *
+     * @example
+     * ```typescript
+     * const reader = BinaryReader.fromHex('ff');
+     * reader.readUInt8(); // 255
+     * ```
+     */
+    readUInt8(): number;
+    /**
+     * Reads an 8-bit signed integer.
+     *
+     * @returns The value (-128 to 127)
+     * @throws RangeError if reading past end of buffer
+     */
+    readInt8(): number;
+    /**
+     * Reads a 16-bit unsigned integer in little-endian format.
+     *
+     * @returns The value (0-65535)
+     * @throws RangeError if reading past end of buffer
+     *
+     * @example
+     * ```typescript
+     * const reader = BinaryReader.fromHex('0100'); // 1 in LE
+     * reader.readUInt16LE(); // 1
+     * ```
+     */
+    readUInt16LE(): number;
+    /**
+     * Reads a 16-bit signed integer in little-endian format.
+     *
+     * @returns The value (-32768 to 32767)
+     * @throws RangeError if reading past end of buffer
+     */
+    readInt16LE(): number;
+    /**
+     * Reads a 32-bit unsigned integer in little-endian format.
+     *
+     * @returns The value (0 to 4294967295)
+     * @throws RangeError if reading past end of buffer
+     *
+     * @example
+     * ```typescript
+     * const reader = BinaryReader.fromHex('01000000'); // 1 in LE
+     * reader.readUInt32LE(); // 1
+     * ```
+     */
+    readUInt32LE(): number;
+    /**
+     * Reads a 32-bit signed integer in little-endian format.
+     *
+     * @returns The value (-2147483648 to 2147483647)
+     * @throws RangeError if reading past end of buffer
+     *
+     * @example
+     * ```typescript
+     * const reader = BinaryReader.fromHex('ffffffff'); // -1 in LE signed
+     * reader.readInt32LE(); // -1
+     * ```
+     */
+    readInt32LE(): number;
+    /**
+     * Reads a 64-bit unsigned integer in little-endian format as bigint.
+     *
+     * @returns The value as bigint
+     * @throws RangeError if reading past end of buffer
+     *
+     * @example
+     * ```typescript
+     * const reader = BinaryReader.fromHex('0100000000000000'); // 1 in LE 64-bit
+     * reader.readUInt64LE(); // 1n
+     * ```
+     */
+    readUInt64LE(): bigint;
+    /**
+     * Reads a 64-bit signed integer in little-endian format as bigint.
+     *
+     * @returns The value as bigint
+     * @throws RangeError if reading past end of buffer
+     */
+    readInt64LE(): bigint;
+    /**
+     * Reads a specified number of bytes.
+     *
+     * Returns a subarray view (no copy) for performance.
+     * Use readBytesCopy() if you need an independent copy.
+     *
+     * @param length - Number of bytes to read
+     * @returns Uint8Array view into the buffer
+     * @throws RangeError if reading past end of buffer
+     *
+     * @example
+     * ```typescript
+     * const reader = BinaryReader.fromHex('deadbeefcafebabe');
+     * const first4 = reader.readBytes(4); // deadbeef
+     * const next4 = reader.readBytes(4); // cafebabe
+     * ```
+     */
+    readBytes(length: number): Uint8Array;
+    /**
+     * Reads a specified number of bytes as an independent copy.
+     *
+     * @param length - Number of bytes to read
+     * @returns New Uint8Array with copied data
+     * @throws RangeError if reading past end of buffer
+     */
+    readBytesCopy(length: number): Uint8Array;
+    /**
+     * Reads a Bitcoin CompactSize variable-length integer.
+     *
+     * CompactSize encoding:
+     * - 0x00-0xFC: 1 byte (value as-is)
+     * - 0xFD: 3 bytes (0xFD + 2-byte LE uint16)
+     * - 0xFE: 5 bytes (0xFE + 4-byte LE uint32)
+     * - 0xFF: 9 bytes (0xFF + 8-byte LE uint64)
+     *
+     * @returns The decoded integer value
+     * @throws RangeError if reading past end of buffer
+     * @throws RangeError if value exceeds MAX_SAFE_INTEGER
+     *
+     * @example
+     * ```typescript
+     * const reader = BinaryReader.fromHex('fd0302'); // 515 encoded
+     * reader.readVarInt(); // 515
+     * ```
+     */
+    readVarInt(): number;
+    /**
+     * Reads a Bitcoin CompactSize variable-length integer as bigint.
+     *
+     * Use this when you need the full 64-bit range.
+     *
+     * @returns The decoded integer value as bigint
+     * @throws RangeError if reading past end of buffer
+     */
+    readVarIntBig(): bigint;
+    /**
+     * Reads a length-prefixed byte array (VarInt length + bytes).
+     *
+     * @returns Uint8Array view into the buffer
+     * @throws RangeError if reading past end of buffer
+     *
+     * @example
+     * ```typescript
+     * const reader = BinaryReader.fromHex('04deadbeef');
+     * reader.readVarBytes(); // Uint8Array [0xde, 0xad, 0xbe, 0xef]
+     * ```
+     */
+    readVarBytes(): Uint8Array;
+    /**
+     * Reads an array of length-prefixed byte arrays.
+     *
+     * Format: VarInt count + (VarInt length + bytes) for each item.
+     *
+     * @returns Array of Uint8Array views
+     * @throws RangeError if reading past end of buffer
+     */
+    readVector(): Uint8Array[];
+    /**
+     * Peeks at the next byte without advancing the position.
+     *
+     * @returns The next byte value, or undefined if at end
+     */
+    peek(): number | undefined;
+    /**
+     * Skips a specified number of bytes.
+     *
+     * @param length - Number of bytes to skip
+     * @throws RangeError if skipping past end of buffer
+     */
+    skip(length: number): void;
+    /**
+     * Resets the read position to the beginning.
+     */
+    reset(): void;
+    /**
+     * Checks if there are more bytes to read.
+     *
+     * @returns True if there are remaining bytes
+     */
+    hasMore(): boolean;
+}
+//# sourceMappingURL=BinaryReader.d.ts.map

package/browser/io/BinaryReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryReader.d.ts","sourceRoot":"","sources":["../../src/io/BinaryReader.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,YAAY;;IAgBrB;;;;;;;;;;;;;OAaG;gBACgB,IAAI,EAAE,UAAU,EAAE,MAAM,GAAE,MAAU;IAMvD;;;;;;;;;;;;;OAaG;WACW,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;IAIhD;;OAEG;IACH,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED;;;;;OAKG;IACH,IAAW,MAAM,CAAC,KAAK,EAAE,MAAM,EAK9B;IAED;;OAEG;IACH,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;OAEG;IACH,IAAW,IAAI,IAAI,UAAU,CAE5B;IAED;;;;;;;;;;;OAWG;IACI,SAAS,IAAI,MAAM;IAO1B;;;;;OAKG;IACI,QAAQ,IAAI,MAAM;IAKzB;;;;;;;;;;;OAWG;IACI,YAAY,IAAI,MAAM;IAS7B;;;;;OAKG;IACI,WAAW,IAAI,MAAM;IAS5B;;;;;;;;;;;OAWG;IACI,YAAY,IAAI,MAAM;IAS7B;;;;;;;;;;;OAWG;IACI,WAAW,IAAI,MAAM;IAS5B;;;;;;;;;;;OAWG;IACI,YAAY,IAAI,MAAM;IAS7B;;;;;OAKG;IACI,WAAW,IAAI,MAAM;IAS5B;;;;;;;;;;;;;;;;OAgBG;IACI,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU;IAS5C;;;;;;OAMG;IACI,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU;IAShD;;;;;;;;;;;;;;;;;;OAkBG;IACI,UAAU,IAAI,MAAM;IAuB3B;;;;;;;OAOG;IACI,aAAa,IAAI,MAAM;IAmB9B;;;;;;;;;;;OAWG;IACI,YAAY,IAAI,UAAU;IAKjC;;;;;;;OAOG;IACI,UAAU,IAAI,UAAU,EAAE;IASjC;;;;OAIG;IACI,IAAI,IAAI,MAAM,GAAG,SAAS;IAOjC;;;;;OAKG;IACI,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAOjC;;OAEG;IACI,KAAK,IAAI,IAAI;IAIpB;;;;OAIG;IACI,OAAO,IAAI,OAAO;CAG5B"}

package/browser/io/BinaryWriter.d.ts

@@ -0,0 +1,391 @@
+/**
+ * Stateful binary writer with a single DataView instance.
+ *
+ * Zero allocations during write operations. The DataView is created once
+ * in the constructor and reused for all writes.
+ *
+ * @packageDocumentation
+ */
+/**
+ * High-performance binary writer for serializing binary data.
+ *
+ * Creates exactly ONE DataView instance that is reused for all write operations.
+ * This eliminates garbage collection pressure from repeated DataView allocations.
+ *
+ * Methods return `this` for chaining.
+ *
+ * @example
+ * ```typescript
+ * import { BinaryWriter } from '@btc-vision/bitcoin';
+ *
+ * // Serialize a simple structure
+ * const writer = new BinaryWriter(16);
+ * writer
+ *     .writeInt32LE(1)        // version
+ *     .writeUInt32LE(0)       // input count
+ *     .writeUInt32LE(0)       // output count
+ *     .writeUInt32LE(0);      // locktime
+ *
+ * const bytes = writer.finish();
+ * ```
+ */
+export declare class BinaryWriter {
+    #private;
+    /**
+     * Creates a new BinaryWriter with a pre-allocated buffer.
+     *
+     * @param size - Size of the buffer in bytes
+     *
+     * @example
+     * ```typescript
+     * import { BinaryWriter } from '@btc-vision/bitcoin';
+     *
+     * const writer = new BinaryWriter(1024);
+     * writer.writeUInt32LE(42);
+     * ```
+     */
+    constructor(size: number);
+    /**
+     * Creates a new BinaryWriter wrapping an existing buffer.
+     *
+     * @param buffer - Existing buffer to write into
+     * @param offset - Initial write position (default 0)
+     *
+     * @example
+     * ```typescript
+     * import { BinaryWriter } from '@btc-vision/bitcoin';
+     *
+     * const buffer = new Uint8Array(1024);
+     * const writer = new BinaryWriter(buffer, 10); // Start at offset 10
+     * writer.writeUInt32LE(42);
+     * ```
+     */
+    constructor(buffer: Uint8Array, offset?: number);
+    /**
+     * Creates a BinaryWriter with automatic capacity management.
+     *
+     * Initial capacity is 256 bytes, grows as needed.
+     *
+     * @returns A new GrowableBinaryWriter instance
+     *
+     * @example
+     * ```typescript
+     * import { BinaryWriter } from '@btc-vision/bitcoin';
+     *
+     * const writer = BinaryWriter.growable();
+     * writer.writeUInt32LE(1);
+     * writer.writeBytes(new Uint8Array(1000)); // Automatically grows
+     * ```
+     */
+    static growable(initialCapacity?: number): GrowableBinaryWriter;
+    /**
+     * Current write position in the buffer.
+     */
+    get offset(): number;
+    /**
+     * Sets the write position.
+     *
+     * @param value - New offset value
+     * @throws RangeError if offset is negative or beyond buffer length
+     */
+    set offset(value: number);
+    /**
+     * Total capacity of the underlying buffer.
+     */
+    get capacity(): number;
+    /**
+     * Number of bytes remaining in the buffer.
+     */
+    get remaining(): number;
+    /**
+     * The underlying data buffer.
+     */
+    get data(): Uint8Array;
+    /**
+     * Writes an 8-bit unsigned integer.
+     *
+     * @param value - Value to write (0-255)
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     *
+     * @example
+     * ```typescript
+     * writer.writeUInt8(255);
+     * ```
+     */
+    writeUInt8(value: number): this;
+    /**
+     * Writes an 8-bit signed integer.
+     *
+     * @param value - Value to write (-128 to 127)
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     */
+    writeInt8(value: number): this;
+    /**
+     * Writes a 16-bit unsigned integer in little-endian format.
+     *
+     * @param value - Value to write (0-65535)
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     *
+     * @example
+     * ```typescript
+     * writer.writeUInt16LE(1); // Writes 01 00
+     * ```
+     */
+    writeUInt16LE(value: number): this;
+    /**
+     * Writes a 16-bit signed integer in little-endian format.
+     *
+     * @param value - Value to write (-32768 to 32767)
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     */
+    writeInt16LE(value: number): this;
+    /**
+     * Writes a 32-bit unsigned integer in little-endian format.
+     *
+     * @param value - Value to write (0 to 4294967295)
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     *
+     * @example
+     * ```typescript
+     * writer.writeUInt32LE(1); // Writes 01 00 00 00
+     * ```
+     */
+    writeUInt32LE(value: number): this;
+    /**
+     * Writes a 32-bit signed integer in little-endian format.
+     *
+     * @param value - Value to write (-2147483648 to 2147483647)
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     *
+     * @example
+     * ```typescript
+     * writer.writeInt32LE(-1); // Writes ff ff ff ff
+     * ```
+     */
+    writeInt32LE(value: number): this;
+    /**
+     * Writes a 64-bit unsigned integer in little-endian format.
+     *
+     * @param value - Value to write as bigint
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     *
+     * @example
+     * ```typescript
+     * writer.writeUInt64LE(50000n); // Writes 50 c3 00 00 00 00 00 00
+     * ```
+     */
+    writeUInt64LE(value: bigint): this;
+    /**
+     * Writes a 64-bit signed integer in little-endian format.
+     *
+     * @param value - Value to write as bigint
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     */
+    writeInt64LE(value: bigint): this;
+    /**
+     * Writes raw bytes.
+     *
+     * @param bytes - Bytes to write
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     *
+     * @example
+     * ```typescript
+     * writer.writeBytes(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
+     * ```
+     */
+    writeBytes(bytes: Uint8Array): this;
+    /**
+     * Writes a Bitcoin CompactSize variable-length integer.
+     *
+     * CompactSize encoding:
+     * - 0x00-0xFC: 1 byte (value as-is)
+     * - 0xFD-0xFFFF: 3 bytes (0xFD + 2-byte LE uint16)
+     * - 0x10000-0xFFFFFFFF: 5 bytes (0xFE + 4-byte LE uint32)
+     * - Larger: 9 bytes (0xFF + 8-byte LE uint64)
+     *
+     * @param value - Value to write
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     *
+     * @example
+     * ```typescript
+     * writer.writeVarInt(252);    // Writes fc
+     * writer.writeVarInt(253);    // Writes fd fd 00
+     * writer.writeVarInt(65535);  // Writes fd ff ff
+     * writer.writeVarInt(65536);  // Writes fe 00 00 01 00
+     * ```
+     */
+    writeVarInt(value: number): this;
+    /**
+     * Writes a Bitcoin CompactSize variable-length integer from bigint.
+     *
+     * @param value - Value to write as bigint
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     */
+    writeVarIntBig(value: bigint): this;
+    /**
+     * Writes a length-prefixed byte array (VarInt length + bytes).
+     *
+     * @param bytes - Bytes to write
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     *
+     * @example
+     * ```typescript
+     * writer.writeVarBytes(new Uint8Array([0xde, 0xad])); // Writes 02 de ad
+     * ```
+     */
+    writeVarBytes(bytes: Uint8Array): this;
+    /**
+     * Writes an array of length-prefixed byte arrays.
+     *
+     * Format: VarInt count + (VarInt length + bytes) for each item.
+     *
+     * @param vector - Array of byte arrays to write
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     */
+    writeVector(vector: readonly Uint8Array[]): this;
+    /**
+     * Fills a region with a specific byte value.
+     *
+     * @param value - Byte value to fill with
+     * @param length - Number of bytes to fill
+     * @returns This writer for chaining
+     * @throws RangeError if writing past end of buffer
+     */
+    fill(value: number, length: number): this;
+    /**
+     * Skips a specified number of bytes (leaves them unchanged).
+     *
+     * @param length - Number of bytes to skip
+     * @returns This writer for chaining
+     * @throws RangeError if skipping past end of buffer
+     */
+    skip(length: number): this;
+    /**
+     * Resets the write position to the beginning.
+     *
+     * @returns This writer for chaining
+     */
+    reset(): this;
+    /**
+     * Verifies the buffer was fully written and returns it.
+     *
+     * Unlike {@link finish}, this method throws if the writer has not
+     * written exactly to the end of the buffer.
+     *
+     * @returns The underlying buffer
+     * @throws Error if the buffer was not fully written
+     *
+     * @example
+     * ```typescript
+     * const writer = new BinaryWriter(8);
+     * writer.writeUInt32LE(1);
+     * writer.writeUInt32LE(2);
+     * const bytes = writer.end(); // OK: wrote exactly 8 bytes
+     *
+     * const writer2 = new BinaryWriter(8);
+     * writer2.writeUInt32LE(1);
+     * writer2.end(); // throws: buffer size 8, offset 4
+     * ```
+     */
+    end(): Uint8Array;
+    /**
+     * Returns the written portion of the buffer.
+     *
+     * If the entire buffer was written, returns the buffer directly (no copy).
+     * Otherwise, returns a subarray view.
+     *
+     * @returns Uint8Array containing the written data
+     *
+     * @example
+     * ```typescript
+     * const writer = new BinaryWriter(100);
+     * writer.writeUInt32LE(42);
+     * const bytes = writer.finish(); // 4 bytes
+     * ```
+     */
+    finish(): Uint8Array;
+    /**
+     * Returns the written portion as a hex string.
+     *
+     * @returns Hex string representation
+     *
+     * @example
+     * ```typescript
+     * const writer = new BinaryWriter(4);
+     * writer.writeUInt32LE(1);
+     * writer.toHex(); // '01000000'
+     * ```
+     */
+    toHex(): string;
+}
+/**
+ * A BinaryWriter that automatically grows its buffer as needed.
+ *
+ * Use when the final size is unknown.
+ *
+ * @example
+ * ```typescript
+ * const writer = BinaryWriter.growable();
+ * writer.writeBytes(largeData); // Automatically grows
+ * const bytes = writer.finish();
+ * ```
+ */
+export declare class GrowableBinaryWriter {
+    #private;
+    /**
+     * Creates a new GrowableBinaryWriter.
+     *
+     * @param initialCapacity - Initial buffer size (default 256)
+     */
+    constructor(initialCapacity?: number);
+    /**
+     * Current write position.
+     */
+    get offset(): number;
+    /**
+     * Sets the write position.
+     *
+     * @param value - New offset value
+     * @throws RangeError if offset is negative
+     */
+    set offset(value: number);
+    /**
+     * Current buffer capacity.
+     */
+    get capacity(): number;
+    writeUInt8(value: number): this;
+    writeUInt16LE(value: number): this;
+    writeUInt32LE(value: number): this;
+    writeInt32LE(value: number): this;
+    writeUInt64LE(value: bigint): this;
+    writeBytes(bytes: Uint8Array): this;
+    writeVarInt(value: number): this;
+    writeVarBytes(bytes: Uint8Array): this;
+    writeVector(vector: readonly Uint8Array[]): this;
+    /**
+     * Returns the written data as a new Uint8Array.
+     *
+     * @returns Copy of the written data
+     */
+    finish(): Uint8Array;
+    /**
+     * Returns the written data as a hex string.
+     *
+     * @returns Hex string representation
+     */
+    toHex(): string;
+}
+//# sourceMappingURL=BinaryWriter.d.ts.map

package/browser/io/BinaryWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryWriter.d.ts","sourceRoot":"","sources":["../../src/io/BinaryWriter.ts"],"names":[],"mappings":"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"}