@bsv/sdk 1.10.1 → 1.10.3

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

@@ -0,0 +1,208 @@
+import BigNumber from '../BigNumber'
+import { Reader, encode, WriterUint8Array } from '../utils'
+
+describe('WriterUint8Array', () => {
+  it('should create a new buffer writer', () => {
+    const bw = new WriterUint8Array()
+    expect(bw).toBeDefined()
+  })
+
+  describe('#getLength', () => {
+    it('should compute length correctly of two 2-byte buffers', () => {
+      const buf1 = Buffer.from('0000', 'hex')
+      const buf2 = Buffer.from('0000', 'hex')
+      const bw = new WriterUint8Array().write([...buf1]).write([...buf2])
+      expect(bw.getLength()).toEqual(4)
+    })
+  })
+
+  describe('#toArray', () => {
+    it('should concat these two bufs', () => {
+      const buf1 = [0]
+      const buf2 = [1]
+      const bw = new WriterUint8Array([buf1, buf2])
+      expect(encode(bw.toArray(), 'hex')).toEqual('0001')
+    })
+  })
+
+  describe('#write', () => {
+    it('should write a buffer', () => {
+      const buf = [0]
+      const bw = new WriterUint8Array()
+      bw.write(buf)
+      expect(encode(bw.toArray(), 'hex')).toEqual('00')
+    })
+  })
+
+  describe('#writeReverse', () => {
+    it('should write a buffer in reverse', () => {
+      const buf = [0, 1]
+      const bw = new WriterUint8Array()
+      bw.writeReverse(buf)
+      expect(encode(bw.toArray(), 'hex')).toEqual('0100')
+    })
+  })
+
+  describe('#writeUInt8', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeUInt8(1).toArray(), 'hex')).toEqual('01')
+    })
+  })
+
+  describe('#writeInt8', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeInt8(1).toArray(), 'hex')).toEqual('01')
+      expect(encode(new WriterUint8Array().writeInt8(-1).toArray(), 'hex')).toEqual('ff')
+    })
+  })
+
+  describe('#writeUInt16BE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeUInt16BE(1).toArray(), 'hex')).toEqual('0001')
+    })
+  })
+
+  describe('#writeInt16BE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeInt16BE(1).toArray(), 'hex')).toEqual('0001')
+      expect(encode(new WriterUint8Array().writeInt16BE(-1).toArray(), 'hex')).toEqual(
+        'ffff'
+      )
+    })
+  })
+
+  describe('#writeUInt16LE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeUInt16LE(1).toArray(), 'hex')).toEqual('0100')
+    })
+  })
+
+  describe('#writeInt16LE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeInt16LE(1).toArray(), 'hex')).toEqual('0100')
+      expect(encode(new WriterUint8Array().writeInt16LE(-1).toArray(), 'hex')).toEqual(
+        'ffff'
+      )
+    })
+  })
+
+  describe('#writeUInt32BE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeUInt32BE(1).toArray(), 'hex')).toEqual('00000001')
+    })
+  })
+
+  describe('#writeInt32BE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeInt32BE(1).toArray(), 'hex')).toEqual('00000001')
+      expect(encode(new WriterUint8Array().writeInt32BE(-1).toArray(), 'hex')).toEqual(
+        'ffffffff'
+      )
+    })
+  })
+
+  describe('#writeUInt32LE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeUInt32LE(1).toArray(), 'hex')).toEqual('01000000')
+    })
+  })
+
+  describe('#writeInt32LE', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(encode(bw.writeInt32LE(1).toArray(), 'hex')).toEqual('01000000')
+      expect(encode(new WriterUint8Array().writeInt32LE(-1).toArray(), 'hex')).toEqual(
+        'ffffffff'
+      )
+    })
+  })
+
+  describe('#writeUInt64BEBn', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(
+        encode(bw.writeUInt64BEBn(new BigNumber(1)).toArray(), 'hex')
+      ).toEqual('0000000000000001')
+    })
+  })
+
+  describe('#writeUInt64LEBn', () => {
+    it('should write 1', () => {
+      const bw = new WriterUint8Array()
+      expect(
+        encode(bw.writeUInt64LEBn(new BigNumber(1)).toArray(), 'hex')
+      ).toEqual('0100000000000000')
+    })
+  })
+
+  describe('#writeVarInt', () => {
+    it('should write a 1 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntNum(1)
+      expect(bw.toArray().length).toEqual(1)
+    })
+
+    it('should write a 3 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntNum(1000)
+      expect(bw.toArray().length).toEqual(3)
+    })
+
+    it('should write a 5 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntNum(Math.pow(2, 16 + 1))
+      expect(bw.toArray().length).toEqual(5)
+    })
+
+    it('should write a 9 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntNum(Math.pow(2, 32 + 1))
+      expect(bw.toArray().length).toEqual(9)
+    })
+
+    it('should read back the same value it wrote for a 9 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      const n = Math.pow(2, 53)
+      expect(n).toEqual(n + 1) // javascript number precision limit
+      bw.writeVarIntNum(n)
+      const br = new Reader(bw.toArray())
+      expect(br.readVarIntBn().toHex()).toEqual('20000000000000')
+    })
+  })
+
+  describe('#writeVarIntBn', () => {
+    it('should write a 1 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntBn(new BigNumber(1))
+      expect(bw.toArray().length).toEqual(1)
+    })
+
+    it('should write a 3 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntBn(new BigNumber(1000))
+      expect(bw.toArray().length).toEqual(3)
+    })
+
+    it('should write a 5 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      const bn = new BigNumber(Math.pow(2, 16 + 1))
+      bw.writeVarIntBn(bn)
+      expect(bw.toArray().length).toEqual(5)
+    })
+
+    it('should write a 9 byte varInt', () => {
+      const bw = new WriterUint8Array()
+      bw.writeVarIntBn(new BigNumber(Math.pow(2, 32 + 1)))
+      expect(bw.toArray().length).toEqual(9)
+    })
+  })
+})

package/src/primitives/utils.ts

@@ -1,6 +1,11 @@
 import BigNumber from './BigNumber.js'
 import { hash256 } from './Hash.js'
 import { assertValidHex } from './hex.js'
+import { WriterUint8Array } from './WriterUint8Array.js'
+import { ReaderUint8Array } from './ReaderUint8Array.js'
+
+export { WriterUint8Array }
+export { ReaderUint8Array }
 
 const BufferCtor =
   typeof globalThis !== 'undefined' ? (globalThis as any).Buffer : undefined
@@ -32,7 +37,7 @@ for (let i = 0; i < 256; i++) {
     HEX_DIGITS[(i >> 4) & 0xf] + HEX_DIGITS[i & 0xf]
 }
 
-export const toHex = (msg: number[]): string => {
+export const toHex = (msg: number[] | Uint8Array): string => {
   if (CAN_USE_BUFFER) {
     return BufferCtor.from(msg).toString('hex')
   }
@@ -44,11 +49,24 @@ export const toHex = (msg: number[]): string => {
   return out.join('')
 }
 
+/**
+ * Converts various message formats into a Uint8Array.
+ * Supports Uint8Array, arrays of bytes, hexadecimal strings, base64 strings, and UTF-8 strings.
+ *
+ * @param {any} msg - The input message (Uint8Array, number[], Array or string).
+ * @param {('hex' | 'utf8' | 'base64')} enc - Specifies the string encoding, if applicable.
+ * @returns {Uint8Array}
+ */
+export const toUint8Array = (msg: any, enc?: 'hex' | 'utf8' | 'base64'): Uint8Array => {
+  if (msg instanceof Uint8Array) return msg
+  return new Uint8Array(toArray(msg, enc))
+}
+
 /**
  * Converts various message formats into an array of numbers.
  * Supports arrays, hexadecimal strings, base64 strings, and UTF-8 strings.
  *
- * @param {any} msg - The input message (array or string).
+ * @param {any} msg - The input message (Uint8Array, number[], Array or string).
  * @param {('hex' | 'utf8' | 'base64')} enc - Specifies the string encoding, if applicable.
  * @returns {any[]} - Array representation of the input.
  */

package/src/transaction/Beef.ts

@@ -2,12 +2,9 @@ import MerklePath from './MerklePath.js'
 import Transaction from './Transaction.js'
 import ChainTracker from './ChainTracker.js'
 import BeefTx from './BeefTx.js'
-import { Reader, Writer, toHex, toArray, verifyNotNull } from '../primitives/utils.js'
+import { Reader, Writer, toHex, toArray, verifyNotNull, ReaderUint8Array, WriterUint8Array, toUint8Array } from '../primitives/utils.js'
 import { hash256 } from '../primitives/Hash.js'
 
-const BufferCtor =
-  typeof globalThis !== 'undefined' ? (globalThis as any).Buffer : undefined
-
 export const BEEF_V1 = 4022206465 // 0100BEEF in LE order
 export const BEEF_V2 = 4022206466 // 0200BEEF in LE order
 export const ATOMIC_BEEF = 0x01010101 // 01010101
@@ -112,13 +109,37 @@ export class Beef {
     this.ensureSerializableState()
     if (this.rawBytesCache == null) {
       this.ensureSortedForSerialization()
-      const writer = new Writer()
+      const writer = new WriterUint8Array()
       this.toWriter(writer)
       this.rawBytesCache = writer.toUint8Array()
     }
     return this.rawBytesCache
   }
 
+  private getBeefForAtomic (txid: string): { beef: Beef, writer: WriterUint8Array } {
+    if (this.needsSort) {
+      this.sortTxs()
+    }
+    const tx = this.findTxid(txid)
+    if (tx == null) {
+      throw new Error(`${txid} does not exist in this Beef`)
+    }
+
+    // If the transaction is not the last one, clone and modify
+    const beef = (this.txs[this.txs.length - 1] === tx) ? this : this.clone()
+
+    if (beef !== this) {
+      const i = this.txs.findIndex((t) => t.txid === txid)
+      beef.txs.splice(i + 1)
+    }
+
+    const writer = new WriterUint8Array()
+    writer.writeUInt32LE(ATOMIC_BEEF)
+    writer.writeReverse(toArray(txid, 'hex'))
+
+    return { beef, writer }
+  }
+
   /**
    * @param txid of `beefTx` to find
    * @returns `BeefTx` in `txs` with `txid`.
@@ -308,7 +329,7 @@ export class Beef {
    * @param bumpIndex Optional. If a number, must be valid index into bumps array.
    * @returns txid of rawTx
    */
-  mergeRawTx (rawTx: number[], bumpIndex?: number): BeefTx {
+  mergeRawTx (rawTx: number[] | Uint8Array, bumpIndex?: number): BeefTx {
     this.markMutated(true)
     const newTx: BeefTx = new BeefTx(rawTx, bumpIndex)
     this.removeExistingTxid(newTx.txid)
@@ -394,8 +415,8 @@ export class Beef {
     return beefTx
   }
 
-  mergeBeef (beef: number[] | Beef): void {
-    const b: Beef = Array.isArray(beef) ? Beef.fromBinary(beef) : beef
+  mergeBeef (beef: Beef | number[] | Uint8Array): void {
+    const b: Beef = (beef instanceof Beef) ? beef : Beef.fromBinary(beef)
 
     for (const bump of b.bumps) {
       this.mergeBump(bump)
@@ -549,7 +570,7 @@ export class Beef {
    * Serializes this data to `writer`
    * @param writer
    */
-  toWriter (writer: Writer): void {
+  toWriter (writer: Writer | WriterUint8Array): void {
     writer.writeUInt32LE(this.version)
 
     writer.writeVarIntNum(this.bumps.length)
@@ -566,11 +587,16 @@ export class Beef {
   /**
    * Returns a binary array representing the serialized BEEF
    * @returns A binary array representing the BEEF
+   * @returns An array of byte values containing binary serialization of the BEEF
    */
   toBinary (): number[] {
     return Array.from(this.getSerializedBytes())
   }
 
+  /**
+   * Returns a binary array representing the serialized BEEF
+   * @returns A Uint8Array containing binary serialization of the BEEF
+   */
   toUint8Array (): Uint8Array {
     return this.getSerializedBytes()
   }
@@ -586,30 +612,31 @@ export class Beef {
    * @returns serialized contents of this Beef with AtomicBEEF prefix.
    */
   toBinaryAtomic (txid: string): number[] {
-    if (this.needsSort) {
-      this.sortTxs()
-    }
-    const tx = this.findTxid(txid)
-    if (tx == null) {
-      throw new Error(`${txid} does not exist in this Beef`)
-    }
-
-    // If the transaction is not the last one, clone and modify
-    const beef = (this.txs[this.txs.length - 1] === tx) ? this : this.clone()
-
-    if (beef !== this) {
-      const i = this.txs.findIndex((t) => t.txid === txid)
-      beef.txs.splice(i + 1)
-    }
-
-    const writer = new Writer()
-    writer.writeUInt32LE(ATOMIC_BEEF)
-    writer.writeReverse(toArray(txid, 'hex'))
+    const { beef, writer } = this.getBeefForAtomic(txid)
     beef.toWriter(writer)
-
     return writer.toArray()
   }
 
+  /**
+   * Serialize this Beef as AtomicBEEF.
+   *
+   * `txid` must exist
+   *
+   * after sorting, if txid is not last txid, creates a clone and removes newer txs
+   *
+   * @param txid
+   * @returns serialized contents of this Beef with AtomicBEEF prefix.
+   */
+  toUint8ArrayAtomic (txid: string): Uint8Array {
+    const { beef, writer } = this.getBeefForAtomic(txid)
+    const beefUint8 = beef.getSerializedBytes()
+    const prefix = writer.toUint8Array()
+    const atomic = new Uint8Array(prefix.length + beefUint8.length)
+    atomic.set(prefix, 0)
+    atomic.set(beefUint8, prefix.length)
+    return atomic
+  }
+
   /**
    * Returns a hex string representing the serialized BEEF
    * @returns A hex string representing the BEEF
@@ -619,15 +646,12 @@ export class Beef {
       return this.hexCache
     }
     const bytes = this.getSerializedBytes()
-    const hex =
-      BufferCtor != null
-        ? BufferCtor.from(bytes).toString('hex')
-        : toHex(Array.from(bytes))
+    const hex = toHex(bytes)
     this.hexCache = hex
     return hex
   }
 
-  static fromReader (br: Reader): Beef {
+  static fromReader (br: Reader | ReaderUint8Array): Beef {
     let version = br.readUInt32LE()
     let atomicTxid: string | undefined
     if (version === ATOMIC_BEEF) {
@@ -657,11 +681,11 @@ export class Beef {
 
   /**
    * Constructs an instance of the Beef class based on the provided binary array
-   * @param bin The binary array from which to construct BEEF
+   * @param bin The binary array or Uint8Array from which to construct BEEF
    * @returns An instance of the Beef class constructed from the binary data
    */
-  static fromBinary (bin: number[]): Beef {
-    const br = new Reader(bin)
+  static fromBinary (bin: number[] | Uint8Array): Beef {
+    const br = ReaderUint8Array.makeReader(bin)
     return Beef.fromReader(br)
   }
 
@@ -672,8 +696,8 @@ export class Beef {
    * @returns An instance of the Beef class constructed from the string
    */
   static fromString (s: string, enc: 'hex' | 'utf8' | 'base64' = 'hex'): Beef {
-    const bin = toArray(s, enc)
-    const br = new Reader(bin)
+    const bin = toUint8Array(s, enc)
+    const br = new ReaderUint8Array(bin)
     return Beef.fromReader(br)
   }
 
@@ -825,6 +849,8 @@ export class Beef {
     c.txs = Array.from(this.txs)
     c.txidIndex = undefined
     c.needsSort = this.needsSort
+    c.hexCache = this.hexCache
+    c.rawBytesCache = this.rawBytesCache
     return c
   }
 
@@ -844,7 +870,44 @@ export class Beef {
         i++
       }
     }
-    // TODO: bumps could be trimmed to eliminate unreferenced proofs.
+
+    // Trim unreferenced bumps after removing known txids
+    const referencedBumpIndices = new Set<number>()
+    for (const tx of this.txs) {
+      if (tx.bumpIndex !== undefined) {
+        referencedBumpIndices.add(tx.bumpIndex)
+      }
+    }
+
+    // Check if there are any unreferenced bumps to remove
+    if (referencedBumpIndices.size < this.bumps.length) {
+      // Build mapping of old indices to new indices after removal
+      const indexMap = new Map<number, number>()
+      let newIndex = 0
+      for (let i = 0; i < this.bumps.length; i++) {
+        if (referencedBumpIndices.has(i)) {
+          indexMap.set(i, newIndex)
+          newIndex++
+        }
+      }
+
+      // Remove unreferenced bumps
+      this.bumps = this.bumps.filter((_, i) => referencedBumpIndices.has(i))
+
+      // Update all transaction bumpIndex references
+      for (const tx of this.txs) {
+        if (tx.bumpIndex !== undefined) {
+          const newIndex = indexMap.get(tx.bumpIndex)
+          if (newIndex === undefined) {
+            throw new Error(`Internal error: bumpIndex ${tx.bumpIndex} not found in indexMap`)
+          }
+          tx.bumpIndex = newIndex
+        }
+      }
+
+      mutated = true
+    }
+
     if (mutated) {
       this.markMutated(true)
     }

package/src/transaction/BeefTx.ts

@@ -1,5 +1,5 @@
 import { hash256 } from '../primitives/Hash.js'
-import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
+import { Reader, Writer, toHex, toArray, ReaderUint8Array, WriterUint8Array } from '../primitives/utils.js'
 import Transaction from './Transaction.js'
 import { BEEF_V2, TX_DATA_FORMAT } from './Beef.js'
 
@@ -15,7 +15,7 @@ import { BEEF_V2, TX_DATA_FORMAT } from './Beef.js'
 export default class BeefTx {
   _bumpIndex?: number
   _tx?: Transaction
-  _rawTx?: number[]
+  _rawTx?: Uint8Array // ← changed to Uint8Array internally
   _txid?: string
   inputTxids: string[] = []
   /**
@@ -64,10 +64,28 @@ export default class BeefTx {
     return undefined
   }
 
+  /**
+   * Legacy compatibility getter — returns number[] (Byte[])
+   */
   get rawTx (): number[] | undefined {
+    if (this._rawTx != null) {
+      return Array.from(this._rawTx)
+    }
+    if (this._tx != null) {
+      const bytes = this._tx.toUint8Array()
+      this._rawTx = bytes // cache
+      return Array.from(bytes)
+    }
+    return undefined
+  }
+
+  /**
+   * Preferred modern getter — returns Uint8Array (zero-copy where possible)
+   */
+  get rawTxUint8Array (): Uint8Array | undefined {
     if (this._rawTx != null) return this._rawTx
     if (this._tx != null) {
-      this._rawTx = this._tx.toBinary()
+      this._rawTx = this._tx.toUint8Array()
       return this._rawTx
     }
     return undefined
@@ -77,13 +95,17 @@ export default class BeefTx {
    * @param tx If string, must be a valid txid. If `number[]` must be a valid serialized transaction.
    * @param bumpIndex If transaction already has a proof in the beef to which it will be added.
    */
-  constructor (tx: Transaction | number[] | string, bumpIndex?: number) {
+  constructor (tx: Transaction | Uint8Array | number[] | string, bumpIndex?: number) {
     if (typeof tx === 'string') {
       this._txid = tx
-    } else if (Array.isArray(tx)) {
+    } else if (tx instanceof Uint8Array) {
       this._rawTx = tx
-    } else {
+    } else if (Array.isArray(tx)) {
+      this._rawTx = new Uint8Array(tx)
+    } else if (tx instanceof Transaction) {
       this._tx = tx
+    } else {
+      throw new Error('Invalid transaction data type')
     }
     this.bumpIndex = bumpIndex
     this.updateInputTxids()
@@ -93,7 +115,7 @@ export default class BeefTx {
     return new BeefTx(tx, bumpIndex)
   }
 
-  static fromRawTx (rawTx: number[], bumpIndex?: number): BeefTx {
+  static fromRawTx (rawTx: Uint8Array | number[], bumpIndex?: number): BeefTx {
     return new BeefTx(rawTx, bumpIndex)
   }
 
@@ -106,18 +128,17 @@ export default class BeefTx {
       // If we have a proof, or don't have a parsed transaction
       this.inputTxids = []
     } else {
-      const inputTxids: Record<string, boolean> = {} // ✅ Explicit object type
+      const inputTxids: Set<string> = new Set() // minor perf improvement
       for (const input of this.tx.inputs) {
         if (input.sourceTXID !== undefined && input.sourceTXID !== null && input.sourceTXID !== '') {
-          // ✅ Ensure sourceTXID is defined
-          inputTxids[input.sourceTXID] = true
+          inputTxids.add(input.sourceTXID)
         }
       }
-      this.inputTxids = Object.keys(inputTxids)
+      this.inputTxids = Array.from(inputTxids)
     }
   }
 
-  toWriter (writer: Writer, version: number): void {
+  toWriter (writer: Writer | WriterUint8Array, version: number): void {
     const writeByte = (bb: number): void => {
       writer.writeUInt8(bb)
     }
@@ -130,13 +151,11 @@ export default class BeefTx {
     }
 
     const writeTx = (): void => {
-      if (this._rawTx != null) {
-        writer.write(this._rawTx)
-      } else if (this._tx != null) {
-        writer.write(this._tx.toUint8Array())
-      } else {
+      const bytes = this.rawTxUint8Array
+      if (bytes == null) {
         throw new Error('a valid serialized Transaction is expected')
       }
+      writer.write(bytes)
     }
 
     const writeBumpIndex = (): void => {
@@ -166,8 +185,8 @@ export default class BeefTx {
     }
   }
 
-  static fromReader (br: Reader, version: number): BeefTx {
-    let data: Transaction | number[] | string | undefined
+  static fromReader (br: Reader | ReaderUint8Array, version: number): BeefTx {
+    let data: Transaction | undefined
     let bumpIndex: number | undefined
     let beefTx: BeefTx | undefined
     if (version === BEEF_V2) {