@bsv/sdk 1.10.2 → 1.10.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.10.2",
+  "version": "1.10.3",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/overlay-tools/__tests/SHIPBroadcaster.test.ts

@@ -339,8 +339,12 @@ describe('SHIPCast', () => {
     })
     const testTx = new Transaction(1, [], [], 0)
 
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { })
+
     const result = await b.broadcast(testTx)
 
+    expect(consoleErrorSpy).toHaveBeenCalled()
+
     expect(result).toEqual({
       status: 'error',
       code: 'ERR_ALL_HOSTS_REJECTED',
@@ -1076,8 +1080,13 @@ describe('SHIPCast', () => {
       resolver: mockResolver as unknown as LookupResolver
     })
     const testTx = new Transaction(1, [], [], 0)
+
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { })
+
     const response = await b.broadcast(testTx)
 
+    expect(consoleErrorSpy).toHaveBeenCalled()
+
     // Since the host responded (successfully in terms of HTTP), but with invalid data, we should consider it a failure
     expect(response).toEqual({
       status: 'error',

package/src/primitives/ReaderUint8Array.ts

@@ -0,0 +1,196 @@
+import BigNumber from './BigNumber.js'
+import { Reader } from './utils.js'
+
+/**
+ * Reader for serialized Uint8Array binary data.
+ */
+export class ReaderUint8Array {
+  public bin: Uint8Array
+  public pos: number
+  private readonly length: number
+
+  static makeReader (bin: Uint8Array | number[], pos: number = 0): Reader | ReaderUint8Array {
+    if (bin instanceof Uint8Array) {
+      return new ReaderUint8Array(bin, pos)
+    }
+    if (Array.isArray(bin)) {
+      return new Reader(bin, pos)
+    }
+    throw new Error('ReaderUint8Array.makeReader: bin must be Uint8Array or number[]')
+  }
+
+  constructor (bin: Uint8Array | number[] = new Uint8Array(0), pos: number = 0) {
+    if (bin instanceof Uint8Array) {
+      this.bin = bin
+    } else if (Array.isArray(bin)) {
+      this.bin = new Uint8Array(bin)
+    } else {
+      throw new Error('ReaderUint8Array constructor: bin must be Uint8Array or number[]')
+    }
+    this.pos = pos
+    this.length = this.bin.length
+  }
+
+  public eof (): boolean {
+    return this.pos >= this.length
+  }
+
+  public read (len = this.length): Uint8Array {
+    const start = this.pos
+    const end = this.pos + len
+    this.pos = end
+    return this.bin.slice(start, end)
+  }
+
+  public readReverse (len = this.length): Uint8Array {
+    const buf2 = new Uint8Array(len)
+    for (let i = 0; i < len; i++) {
+      buf2[i] = this.bin[this.pos + len - 1 - i]
+    }
+    this.pos += len
+    return buf2
+  }
+
+  public readUInt8 (): number {
+    const val = this.bin[this.pos]
+    this.pos += 1
+    return val
+  }
+
+  public readInt8 (): number {
+    const val = this.bin[this.pos]
+    this.pos += 1
+    // If the sign bit is set, convert to negative value
+    return (val & 0x80) !== 0 ? val - 0x100 : val
+  }
+
+  public readUInt16BE (): number {
+    const val = (this.bin[this.pos] << 8) | this.bin[this.pos + 1]
+    this.pos += 2
+    return val
+  }
+
+  public readInt16BE (): number {
+    const val = this.readUInt16BE()
+    // If the sign bit is set, convert to negative value
+    return (val & 0x8000) !== 0 ? val - 0x10000 : val
+  }
+
+  public readUInt16LE (): number {
+    const val = this.bin[this.pos] | (this.bin[this.pos + 1] << 8)
+    this.pos += 2
+    return val
+  }
+
+  public readInt16LE (): number {
+    const val = this.readUInt16LE()
+    // If the sign bit is set, convert to negative value
+    const x = (val & 0x8000) !== 0 ? val - 0x10000 : val
+    return x
+  }
+
+  public readUInt32BE (): number {
+    const val =
+      this.bin[this.pos] * 0x1000000 + // Shift the first byte by 24 bits
+      ((this.bin[this.pos + 1] << 16) | // Shift the second byte by 16 bits
+        (this.bin[this.pos + 2] << 8) | // Shift the third byte by 8 bits
+        this.bin[this.pos + 3]) // The fourth byte
+    this.pos += 4
+    return val
+  }
+
+  public readInt32BE (): number {
+    const val = this.readUInt32BE()
+    // If the sign bit is set, convert to negative value
+    return (val & 0x80000000) !== 0 ? val - 0x100000000 : val
+  }
+
+  public readUInt32LE (): number {
+    const val =
+      (this.bin[this.pos] |
+        (this.bin[this.pos + 1] << 8) |
+        (this.bin[this.pos + 2] << 16) |
+        (this.bin[this.pos + 3] << 24)) >>>
+      0
+    this.pos += 4
+    return val
+  }
+
+  public readInt32LE (): number {
+    const val = this.readUInt32LE()
+    // Explicitly check if the sign bit is set and then convert to a negative value
+    return (val & 0x80000000) !== 0 ? val - 0x100000000 : val
+  }
+
+  public readUInt64BEBn (): BigNumber {
+    const bin = Array.from(this.bin.slice(this.pos, this.pos + 8))
+    const bn = new BigNumber(bin)
+    this.pos = this.pos + 8
+    return bn
+  }
+
+  public readUInt64LEBn (): BigNumber {
+    const bin = Array.from(this.readReverse(8))
+    const bn = new BigNumber(bin)
+    return bn
+  }
+
+  public readInt64LEBn (): BigNumber {
+    const OverflowInt64 = new BigNumber(2).pow(new BigNumber(63))
+    const OverflowUint64 = new BigNumber(2).pow(new BigNumber(64))
+    const bin = Array.from(this.readReverse(8))
+    let bn = new BigNumber(bin)
+    if (bn.gte(OverflowInt64)) {
+      bn = bn.sub(OverflowUint64) // Adjust for negative numbers
+    }
+    return bn
+  }
+
+  public readVarIntNum (signed: boolean = true): number {
+    const first = this.readUInt8()
+    let bn: BigNumber
+    switch (first) {
+      case 0xfd:
+        return this.readUInt16LE()
+      case 0xfe:
+        return this.readUInt32LE()
+      case 0xff:
+        bn = signed ? this.readInt64LEBn() : this.readUInt64LEBn()
+        if (bn.lte(new BigNumber(2).pow(new BigNumber(53)))) {
+          return bn.toNumber()
+        } else {
+          throw new Error('number too large to retain precision - use readVarIntBn')
+        }
+      default:
+        return first
+    }
+  }
+
+  public readVarInt (): Uint8Array {
+    const first = this.bin[this.pos]
+    switch (first) {
+      case 0xfd:
+        return this.read(1 + 2)
+      case 0xfe:
+        return this.read(1 + 4)
+      case 0xff:
+        return this.read(1 + 8)
+      default:
+        return this.read(1)
+    }
+  }
+
+  public readVarIntBn (): BigNumber {
+    const first = this.readUInt8()
+    switch (first) {
+      case 0xfd:
+        return new BigNumber(this.readUInt16LE())
+      case 0xfe:
+        return new BigNumber(this.readUInt32LE())
+      case 0xff:
+        return this.readUInt64LEBn()
+      default:
+        return new BigNumber(first)
+    }
+  }
+}

package/src/primitives/WriterUint8Array.ts

@@ -0,0 +1,195 @@
+import BigNumber from './BigNumber.js'
+import { Writer } from './utils.js'
+
+type WriterChunk = readonly number[] | Uint8Array
+
+/**
+ * WriterUint8Array is a utility class for writing binary data into a dynamically
+ * growing Uint8Array buffer. It provides methods to write various integer types
+ * and variable-length integers, similar to the Writer class but optimized for
+ * Uint8Array usage.
+ */
+export class WriterUint8Array {
+  private buffer: Uint8Array
+  private pos: number
+  private capacity: number
+
+  constructor (bufs?: WriterChunk[], initialCapacity: number = 256) {
+    if ((bufs != null) && bufs.length > 0) {
+      const totalLength = bufs.reduce((sum, buf) => sum + buf.length, 0)
+      initialCapacity = Math.max(initialCapacity, totalLength)
+    }
+    this.buffer = new Uint8Array(initialCapacity)
+    this.pos = 0
+    this.capacity = initialCapacity
+    if (bufs != null) {
+      for (const buf of bufs) {
+        this.write(buf)
+      }
+    }
+  }
+
+  /**
+   * Returns the current length of written data
+   */
+  getLength (): number {
+    return this.pos
+  }
+
+  /**
+   * @return the written data as Uint8Array copy of the internal buffer
+   */
+  toUint8Array (): Uint8Array {
+    return this.buffer.slice(0, this.pos)
+  }
+
+  /**
+   * Legacy compatibility method – returns number[] (Byte[])
+   */
+  toArray (): number[] {
+    return Array.from(this.toUint8Array())
+  }
+
+  /**
+   * @return the written data as Uint8Array. CAUTION: This is zero-copy subarray of the internal buffer).
+   */
+  toUint8ArrayZeroCopy (): Uint8Array {
+    return this.buffer.subarray(0, this.pos)
+  }
+
+  private ensureCapacity (needed: number): void {
+    if (this.pos + needed > this.capacity) {
+      let newCapacity = this.capacity * 2
+      while (this.pos + needed > newCapacity) {
+        newCapacity *= 2
+      }
+      const newBuffer = new Uint8Array(newCapacity)
+      newBuffer.set(this.buffer)
+      this.buffer = newBuffer
+      this.capacity = newCapacity
+    }
+  }
+
+  write (bytes: WriterChunk): this {
+    const data = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)
+    this.ensureCapacity(data.length)
+    this.buffer.set(data, this.pos)
+    this.pos += data.length
+    return this
+  }
+
+  writeReverse (buf: WriterChunk): this {
+    const data = buf instanceof Uint8Array ? buf : new Uint8Array(buf)
+    this.ensureCapacity(data.length)
+    for (let i = data.length - 1; i >= 0; i--) {
+      this.buffer[this.pos] = data[i]
+      this.pos += 1
+    }
+    return this
+  }
+
+  writeUInt8 (value: number): this {
+    this.ensureCapacity(1)
+    this.buffer[this.pos] = value & 0xff
+    this.pos += 1
+    return this
+  }
+
+  writeInt8 (value: number): this {
+    this.writeUInt8(value)
+    return this
+  }
+
+  writeUInt16LE (value: number): this {
+    this.ensureCapacity(2)
+    this.buffer[this.pos] = value & 0xff
+    this.buffer[this.pos + 1] = (value >> 8) & 0xff
+    this.pos += 2
+    return this
+  }
+
+  writeUInt16BE (value: number): this {
+    this.ensureCapacity(2)
+    this.buffer[this.pos] = (value >> 8) & 0xff
+    this.buffer[this.pos + 1] = value & 0xff
+    this.pos += 2
+    return this
+  }
+
+  writeInt16LE (value: number): this {
+    this.writeUInt16LE(value & 0xffff)
+    return this
+  }
+
+  writeInt16BE (value: number): this {
+    this.writeUInt16BE(value & 0xffff)
+    return this
+  }
+
+  writeUInt32LE (value: number): this {
+    this.ensureCapacity(4)
+    this.buffer[this.pos] = value & 0xff
+    this.buffer[this.pos + 1] = (value >> 8) & 0xff
+    this.buffer[this.pos + 2] = (value >> 16) & 0xff
+    this.buffer[this.pos + 3] = (value >> 24) & 0xff
+    this.pos += 4
+    return this
+  }
+
+  writeUInt32BE (value: number): this {
+    this.ensureCapacity(4)
+    this.buffer[this.pos] = (value >> 24) & 0xff
+    this.buffer[this.pos + 1] = (value >> 16) & 0xff
+    this.buffer[this.pos + 2] = (value >> 8) & 0xff
+    this.buffer[this.pos + 3] = value & 0xff
+    this.pos += 4
+    return this
+  }
+
+  writeInt32LE (value: number): this {
+    this.writeUInt32LE(value >>> 0)
+    return this
+  }
+
+  writeInt32BE (value: number): this {
+    this.writeUInt32BE(value >>> 0)
+    return this
+  }
+
+  writeUInt64BEBn (bn: BigNumber): this {
+    const buf = bn.toArray('be', 8)
+    this.write(buf)
+    return this
+  }
+
+  writeUInt64LEBn (bn: BigNumber): this {
+    const buf = bn.toArray('be', 8)
+    this.writeReverse(buf)
+    return this
+  }
+
+  writeUInt64LE (n: number): this {
+    const buf = new BigNumber(n).toArray('be', 8)
+    this.writeReverse(buf)
+    return this
+  }
+
+  writeVarIntNum (n: number): this {
+    const buf = Writer.varIntNum(n)
+    this.write(buf)
+    return this
+  }
+
+  writeVarIntBn (bn: BigNumber): this {
+    const buf = Writer.varIntBn(bn)
+    this.write(buf)
+    return this
+  }
+
+  /**
+   * Resets the writer to empty state (reuses the buffer)
+   */
+  reset (): void {
+    this.pos = 0
+  }
+}