@bsv/sdk 1.10.1 → 1.10.3

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
+  }
+}

package/src/primitives/__tests/ReaderUint8Array.test.ts

@@ -0,0 +1,317 @@
+import BigNumber from '../BigNumber'
+import { ReaderUint8Array, Writer, toHex } from '../utils'
+
+describe('ReaderUint8Array', () => {
+  it('should make a new Br', () => {
+    let br = new ReaderUint8Array()
+    expect(br).toBeDefined()
+    br = new ReaderUint8Array()
+    expect(br).toBeDefined()
+  })
+
+  it('should create a new ReaderUint8Array with an Array', () => {
+    const arr: number[] = []
+    const br = new ReaderUint8Array(arr)
+    expect(br).toBeDefined()
+    expect(br.bin instanceof Uint8Array).toBeTruthy()
+  })
+
+  describe('#eof', () => {
+    it('should return true for a blank br', () => {
+      const br = new ReaderUint8Array([...Buffer.from([])])
+      expect(br.eof()).toBeTruthy()
+    })
+  })
+
+  describe('#read', () => {
+    it('should return the same buffer', () => {
+      const buf = Buffer.from([0])
+      const br = new ReaderUint8Array([...buf])
+      expect(Buffer.from(br.read()).toString('hex')).toEqual(
+        buf.toString('hex')
+      )
+    })
+  })
+
+  it('should return a buffer of this length', () => {
+    const buf = Buffer.alloc(10)
+    buf.fill(0)
+    const br = new ReaderUint8Array([...buf])
+    const buf2 = br.read(2)
+    expect(buf2.length).toEqual(2)
+    expect(br.eof()).toBeFalsy()
+    expect(br.pos).toEqual(2)
+  })
+
+  it('should be able to read 0 bytes', () => {
+    const buf = Buffer.from('0101', 'hex')
+    expect(new ReaderUint8Array([...buf]).read(0).length).toEqual(0)
+  })
+})
+
+describe('#readReverse', () => {
+  it('should reverse this [0, 1]', () => {
+    const buf = Buffer.from([0, 1])
+    const br = new ReaderUint8Array([...buf])
+    expect(toHex(br.readReverse())).toEqual('0100')
+  })
+
+  it('should be able to read 0 bytes', () => {
+    const buf = Buffer.from('0101', 'hex')
+    expect(new ReaderUint8Array([...buf]).readReverse(0).length).toEqual(0)
+  })
+})
+
+describe('#readUInt8', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(1)
+    buf.writeUInt8(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt8()).toEqual(1)
+  })
+})
+
+describe('#readInt8', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(1)
+    buf.writeInt8(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readInt8()).toEqual(1)
+    const bufNegative = Buffer.from('ff', 'hex')
+    const brNegative = new ReaderUint8Array([...bufNegative])
+    expect(brNegative.readInt8()).toEqual(-1)
+  })
+})
+
+describe('#readUInt16BE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(2)
+    buf.writeUInt16BE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt16BE()).toEqual(1)
+  })
+})
+
+describe('#readInt16BE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(2)
+    buf.writeInt16BE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readInt16BE()).toEqual(1)
+    const bufNegative = Buffer.from('ffff', 'hex')
+    const brNegative = new ReaderUint8Array([...bufNegative])
+    expect(brNegative.readInt8()).toEqual(-1)
+  })
+})
+
+describe('#readUInt16LE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(2)
+    buf.writeUInt16LE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt16LE()).toEqual(1)
+  })
+})
+
+describe('#readInt16LE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(2)
+    buf.writeInt16LE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readInt16LE()).toEqual(1)
+    const bufNegative = Buffer.from('ffff', 'hex')
+    const brNegative = new ReaderUint8Array([...bufNegative])
+    expect(brNegative.readInt8()).toEqual(-1)
+  })
+})
+
+describe('#readUInt32BE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(4)
+    buf.writeUInt32BE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt32BE()).toEqual(1)
+  })
+})
+
+describe('#readInt32BE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(4)
+    buf.writeInt32BE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readInt32BE()).toEqual(1)
+    const bufNegative = Buffer.from('ffffffff', 'hex')
+    const brNegative = new ReaderUint8Array([...bufNegative])
+    expect(brNegative.readInt8()).toEqual(-1)
+  })
+})
+
+describe('#readUInt32LE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(4)
+    buf.writeUInt32LE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt32LE()).toEqual(1)
+  })
+})
+
+describe('#readInt32LE', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(4)
+    buf.writeInt32LE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readInt32LE()).toEqual(1)
+    expect(
+      new ReaderUint8Array([...Buffer.from('ffffffff', 'hex')]).readInt32LE()
+    ).toEqual(-1)
+  })
+})
+
+describe('#readUInt64BEBn', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(8)
+    buf.fill(0)
+    buf.writeUInt32BE(1, 4)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt64BEBn().toNumber()).toEqual(1)
+  })
+
+  it('should return 2^64', () => {
+    const buf = Buffer.alloc(8)
+    buf.fill(0xff)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt64BEBn().toHex()).toEqual('ffffffffffffffff')
+  })
+})
+
+describe('#readUInt64LEBn', () => {
+  it('should return 1', () => {
+    const buf = Buffer.alloc(8)
+    buf.fill(0)
+    buf.writeUInt32LE(1, 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt64LEBn().toNumber()).toEqual(1)
+  })
+
+  it('should return 2^30', () => {
+    const buf = Buffer.alloc(8)
+    buf.fill(0)
+    buf.writeUInt32LE(Math.pow(2, 30), 0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt64LEBn().toNumber()).toEqual(Math.pow(2, 30))
+  })
+
+  it('should return 0', () => {
+    const buf = Buffer.alloc(8)
+    buf.fill(0)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt64LEBn().toNumber()).toEqual(0)
+  })
+
+  it('should return 2^64', () => {
+    const buf = Buffer.alloc(8)
+    buf.fill(0xff)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readUInt64LEBn().toHex()).toEqual('ffffffffffffffff')
+  })
+})
+
+describe('#readVarInt', () => {
+  it('should read a 1 byte varInt', () => {
+    const buf = Buffer.from([50])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarInt().length).toEqual(1)
+  })
+
+  it('should read a 3 byte varInt', () => {
+    const buf = Buffer.from([253, 253, 0])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarInt().length).toEqual(3)
+  })
+
+  it('should read a 5 byte varInt', () => {
+    const buf = Buffer.from([254, 0, 0, 0, 0])
+    buf.writeUInt32LE(50000, 1)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarInt().length).toEqual(5)
+  })
+
+  it('should read a 9 byte varInt', () => {
+    const buf = new Writer()
+      .writeVarIntBn(new BigNumber(Math.pow(2, 54).toString()))
+      .toArray()
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarInt().length).toEqual(9)
+  })
+})
+
+describe('#readVarIntNum', () => {
+  it('should read a 1 byte varInt', () => {
+    const buf = Buffer.from([50])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntNum()).toEqual(50)
+  })
+
+  it('should read a 3 byte varInt', () => {
+    const buf = Buffer.from([253, 253, 0])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntNum()).toEqual(253)
+  })
+
+  it('should read a 5 byte varInt', () => {
+    const buf = Buffer.from([254, 0, 0, 0, 0])
+    buf.writeUInt32LE(50000, 1)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntNum()).toEqual(50000)
+  })
+
+  it('should throw an error on a 9 byte varInt over the javascript uint precision limit', () => {
+    const buf = new Writer()
+      .writeVarIntBn(new BigNumber(Math.pow(2, 54).toString()))
+      .toArray()
+    const br = new ReaderUint8Array([...buf])
+    expect(() => {
+      br.readVarIntNum()
+    }).toThrow('number too large to retain precision - use readVarIntBn')
+  })
+
+  it('should not throw an error on a 9 byte varInt not over the javascript uint precision limit', () => {
+    const buf = new Writer()
+      .writeVarIntBn(new BigNumber(Math.pow(2, 53).toString()))
+      .toArray()
+    const br = new ReaderUint8Array([...buf])
+    expect(() => {
+      br.readVarIntNum()
+    }).not.toThrow('number too large to retain precision - use readVarIntBn')
+  })
+})
+
+describe('#readVarIntBn', () => {
+  it('should read a 1 byte varInt', () => {
+    const buf = Buffer.from([50])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntBn().toNumber()).toEqual(50)
+  })
+
+  it('should read a 3 byte varInt', () => {
+    const buf = Buffer.from([253, 253, 0])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntBn().toNumber()).toEqual(253)
+  })
+
+  it('should read a 5 byte varInt', () => {
+    const buf = Buffer.from([254, 0, 0, 0, 0])
+    buf.writeUInt32LE(50000, 1)
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntBn().toNumber()).toEqual(50000)
+  })
+
+  it('should read a 9 byte varInt', () => {
+    const buf = Buffer.concat([
+      Buffer.from([255]),
+      Buffer.from('ffffffffffffffff', 'hex')
+    ])
+    const br = new ReaderUint8Array([...buf])
+    expect(br.readVarIntBn().toHex()).toEqual('ffffffffffffffff')
+  })
+})