toiljs 0.0.1

package/src/io/BinaryReader.ts

@@ -0,0 +1,344 @@
+import {
+    I128_BYTE_LENGTH,
+    I16_BYTE_LENGTH,
+    I32_BYTE_LENGTH,
+    I64_BYTE_LENGTH,
+    I8_BYTE_LENGTH,
+    U128_BYTE_LENGTH,
+    U16_BYTE_LENGTH,
+    U256_BYTE_LENGTH,
+    U32_BYTE_LENGTH,
+    U64_BYTE_LENGTH,
+    U8_BYTE_LENGTH,
+} from './lengths.js';
+import type { BufferLike, i16, i32, i64, i8, Selector, u16, u32, u8 } from './types.js';
+
+export class BinaryReader {
+    private buffer: DataView;
+    private currentOffset: number = 0;
+
+    constructor(bytes: BufferLike) {
+        this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    }
+
+    public get byteLength(): number {
+        return this.buffer.byteLength;
+    }
+
+    // Helpers for comparisons; unchanged
+    public static stringCompare(a: string, b: string): number {
+        return a.localeCompare(b);
+    }
+
+    public static bigintCompare(a: bigint, b: bigint): number {
+        if (a < b) return -1;
+        if (a > b) return 1;
+        return 0;
+    }
+
+    public static numberCompare(a: number, b: number): number {
+        if (a < b) return -1;
+        if (a > b) return 1;
+        return 0;
+    }
+
+    public setBuffer(bytes: BufferLike): void {
+        this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        this.currentOffset = 0;
+    }
+
+    public length(): number {
+        return this.buffer.byteLength;
+    }
+
+    public bytesLeft(): number {
+        return this.buffer.byteLength - this.currentOffset;
+    }
+
+    /** Reads a single signed byte (i8). */
+    public readI8(): i8 {
+        this.verifyEnd(this.currentOffset + I8_BYTE_LENGTH);
+        const value = this.buffer.getInt8(this.currentOffset);
+        this.currentOffset += I8_BYTE_LENGTH;
+        return value;
+    }
+
+    /** Reads a signed 16-bit integer. By default, big-endian. */
+    public readI16(be: boolean = true): i16 {
+        this.verifyEnd(this.currentOffset + I16_BYTE_LENGTH);
+        const value = this.buffer.getInt16(this.currentOffset, !be);
+        this.currentOffset += I16_BYTE_LENGTH;
+        return value;
+    }
+
+    /** Reads a signed 32-bit integer. By default, big-endian. */
+    public readI32(be: boolean = true): i32 {
+        this.verifyEnd(this.currentOffset + I32_BYTE_LENGTH);
+        const value = this.buffer.getInt32(this.currentOffset, !be);
+        this.currentOffset += I32_BYTE_LENGTH;
+        return value;
+    }
+
+    /** Reads a signed 64-bit integer. By default, big-endian. */
+    public readI64(be: boolean = true): i64 {
+        this.verifyEnd(this.currentOffset + I64_BYTE_LENGTH);
+        const value = this.buffer.getBigInt64(this.currentOffset, !be);
+        this.currentOffset += I64_BYTE_LENGTH;
+        return value;
+    }
+
+    /** Reads a single unsigned byte (u8). */
+    public readU8(): u8 {
+        this.verifyEnd(this.currentOffset + U8_BYTE_LENGTH);
+        const value = this.buffer.getUint8(this.currentOffset);
+        this.currentOffset += U8_BYTE_LENGTH;
+        return value;
+    }
+
+    /** Reads an unsigned 16-bit integer. By default, big-endian. */
+    public readU16(be: boolean = true): u16 {
+        this.verifyEnd(this.currentOffset + U16_BYTE_LENGTH);
+        const value = this.buffer.getUint16(this.currentOffset, !be);
+        this.currentOffset += U16_BYTE_LENGTH;
+        return value;
+    }
+
+    /** Reads an unsigned 32-bit integer. By default, big-endian. */
+    public readU32(be: boolean = true): u32 {
+        this.verifyEnd(this.currentOffset + U32_BYTE_LENGTH);
+        const value = this.buffer.getUint32(this.currentOffset, !be);
+        this.currentOffset += U32_BYTE_LENGTH;
+        return value;
+    }
+
+    /** Reads an unsigned 64-bit integer. By default, big-endian. */
+    public readU64(be: boolean = true): bigint {
+        this.verifyEnd(this.currentOffset + U64_BYTE_LENGTH);
+        const value = this.buffer.getBigUint64(this.currentOffset, !be);
+        this.currentOffset += U64_BYTE_LENGTH;
+        return value;
+    }
+
+    /** Reads a 128-bit unsigned integer. By default, big-endian. */
+    public readU128(be: boolean = true): bigint {
+        const raw = this.readBytes(U128_BYTE_LENGTH);
+        let bytes = raw;
+        // If data was written in little-endian, we reverse before interpreting
+        if (!be) {
+            bytes = this.reverseBytes(raw);
+        }
+
+        return BigInt('0x' + this.toHexString(bytes));
+    }
+
+    /** Reads a 256-bit unsigned integer. Same approach as readU128. */
+    public readU256(be: boolean = true): bigint {
+        const raw = this.readBytes(U256_BYTE_LENGTH);
+        let bytes = raw;
+        if (!be) {
+            bytes = this.reverseBytes(raw);
+        }
+
+        return BigInt('0x' + this.toHexString(bytes));
+    }
+
+    /** Reads a 128-bit signed integer (two's complement). By default, big-endian. */
+    public readI128(be: boolean = true): bigint {
+        const raw = this.readBytes(I128_BYTE_LENGTH);
+        let bytes = raw;
+        if (!be) {
+            bytes = this.reverseBytes(raw);
+        }
+
+        // Construct as a 128-bit two's complement
+        let value = BigInt('0x' + this.toHexString(bytes));
+
+        // If the top bit is set (sign bit in big-endian), interpret negative
+        const signBitMask = 0x80;
+        if ((bytes[0] as number) & signBitMask) {
+            const twoTo128 = BigInt(1) << BigInt(128);
+            value = value - twoTo128;
+        }
+
+        return value;
+    }
+
+    /** Read a boolean (u8 != 0). */
+    public readBoolean(): boolean {
+        return this.readU8() !== 0;
+    }
+
+    /** Reads 32 bits as a selector. */
+    public readSelector(): Selector {
+        return this.readU32(true);
+    }
+
+    /**
+     * Reads a raw sequence of bytes (length must be known).
+     * If zeroStop = true, stops if we encounter 0x00 early.
+     */
+    public readBytes(length: u32, zeroStop: boolean = false): Uint8Array {
+        this.verifyEnd(this.currentOffset + length);
+        let bytes = new Uint8Array(length);
+
+        for (let i: u32 = 0; i < length; i++) {
+            const b = this.buffer.getUint8(this.currentOffset++);
+            if (zeroStop && b === 0) {
+                bytes = new Uint8Array(bytes.subarray(0, i));
+                break;
+            }
+
+            bytes[i] = b;
+        }
+
+        return bytes;
+    }
+
+    /** Reads a string of the given length in raw bytes. */
+    public readString(length: u32): string {
+        const textDecoder = new TextDecoder();
+        const bytes = this.readBytes(length, false);
+        return textDecoder.decode(bytes);
+    }
+
+    /** Reads a string that was written as [u32 length][raw bytes]. */
+    public readStringWithLength(be: boolean = true): string {
+        const length = this.readU32(be);
+        return this.readString(length);
+    }
+
+    /**
+     * Reads bytes written as [u32 length][bytes].
+     * @param maxLength if > 0, enforces an upper bound
+     */
+    public readBytesWithLength(maxLength: number = 0, be: boolean = true): Uint8Array {
+        const length = this.readU32(be);
+        if (maxLength > 0 && length > maxLength) {
+            throw new Error('Data length exceeds maximum length.');
+        }
+
+        return this.readBytes(length);
+    }
+
+    public readArrayOfBuffer(be: boolean = true): Uint8Array[] {
+        const length = this.readU16(be);
+        const result: Uint8Array[] = new Array<Uint8Array>(length);
+        for (let i: number = 0; i < length; i++) {
+            result[i] = this.readBytesWithLength();
+        }
+
+        return result;
+    }
+
+    public readU256Array(be: boolean = true): bigint[] {
+        const length = this.readU16(be);
+        const result: bigint[] = new Array<bigint>(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU256(be);
+        }
+
+        return result;
+    }
+
+    public readU128Array(be: boolean = true): bigint[] {
+        const length = this.readU16(be);
+        const result: bigint[] = new Array<bigint>(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU128(be);
+        }
+
+        return result;
+    }
+
+    public readU64Array(be: boolean = true): bigint[] {
+        const length = this.readU16(be);
+        const result: bigint[] = new Array<bigint>(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU64(be);
+        }
+
+        return result;
+    }
+
+    public readU32Array(be: boolean = true): u32[] {
+        const length = this.readU16(be);
+        const result: u32[] = new Array<u32>(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU32(be);
+        }
+
+        return result;
+    }
+
+    public readU16Array(be: boolean = true): u16[] {
+        const length = this.readU16(be);
+        const result: u16[] = new Array<u16>(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU16(be);
+        }
+
+        return result;
+    }
+
+    public readU8Array(): u8[] {
+        const length = this.readU16(true); // by default big-endian
+        const result: u8[] = new Array<u8>(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readU8();
+        }
+
+        return result;
+    }
+
+    public readStringArray(be: boolean = true): string[] {
+        const length = this.readU16(be);
+        const result: string[] = new Array<string>(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readStringWithLength(be);
+        }
+
+        return result;
+    }
+
+    public readBytesArray(be: boolean = true): Uint8Array[] {
+        const length = this.readU16(be);
+        const result: Uint8Array[] = new Array<Uint8Array>(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readBytesWithLength(0, be);
+        }
+
+        return result;
+    }
+
+    public getOffset(): u16 {
+        return this.currentOffset;
+    }
+
+    public setOffset(offset: u16): void {
+        this.currentOffset = offset;
+    }
+
+    /** Verifies we have enough bytes in the buffer to read up to `size`. */
+    public verifyEnd(size: number): void {
+        if (size > this.buffer.byteLength) {
+            throw new Error(
+                `Attempt to read beyond buffer length: requested up to byte offset ${size}, but buffer is only ${this.buffer.byteLength} bytes.`,
+            );
+        }
+    }
+
+    /** Utility: returns a reversed copy of a byte array. */
+    private reverseBytes(bytes: Uint8Array): Uint8Array {
+        const out = new Uint8Array(bytes.length);
+        for (let i = 0; i < bytes.length; i++) {
+            out[i] = bytes[bytes.length - 1 - i] as number;
+        }
+
+        return out;
+    }
+
+    /** Utility: turns bytes into a hex string without `0x` prefix. */
+    private toHexString(bytes: Uint8Array): string {
+        return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+    }
+}