@bsv/sdk 1.2.15 → 1.2.18

package/src/primitives/utils.ts

@@ -21,8 +21,8 @@ export const zero2 = (word: string): string => {
  */
 export const toHex = (msg: number[]): string => {
   let res = ''
-  for (let i = 0; i < msg.length; i++) {
-    res += zero2(msg[i].toString(16))
+  for (const num of msg) {
+    res += zero2(num.toString(16))
   }
   return res
 }
@@ -36,59 +36,63 @@ export const toHex = (msg: number[]): string => {
  * @returns {any[]} - Array representation of the input.
  */
 export const toArray = (msg: any, enc?: 'hex' | 'utf8' | 'base64'): any[] => {
-  // Return a copy if already an array
-  if (Array.isArray(msg)) { return msg.slice() }
-
-  // Return empty array for falsy values
-  if (!(msg as boolean)) { return [] }
-  const res: any[] = []
+  if (Array.isArray(msg)) return msg.slice()
+  if (!msg) return []
 
-  // Convert non-string messages to numbers
   if (typeof msg !== 'string') {
-    for (let i = 0; i < msg.length; i++) { res[i] = msg[i] | 0 }
-    return res
+    return Array.from(msg, (item: any) => item | 0)
   }
 
-  // Handle hexadecimal encoding
-  if (enc === 'hex') {
-    msg = msg.replace(/[^a-z0-9]+/ig, '')
-    if (msg.length % 2 !== 0) { msg = '0' + (msg as string) }
-    for (let i = 0; i < msg.length; i += 2) {
-      res.push(
-        parseInt((msg[i] as string) + (msg[i + 1] as string), 16)
-      )
-    }
+  switch (enc) {
+    case 'hex':
+      return hexToArray(msg)
+    case 'base64':
+      return base64ToArray(msg)
+    default:
+      return utf8ToArray(msg)
+  }
+}
 
-    // Handle base64
-  } else if (enc === 'base64') {
-    const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
-    const result: number[] = []
-    let currentBit: number = 0
-    let currentByte: number = 0
-
-    for (const char of msg.replace(/=+$/, '')) {
-      currentBit = (currentBit << 6) | base64Chars.indexOf(char)
-      currentByte += 6
-
-      if (currentByte >= 8) {
-        currentByte -= 8
-        result.push((currentBit >> currentByte) & 0xFF)
-        currentBit &= (1 << currentByte) - 1
-      }
+const hexToArray = (msg: string): number[] => {
+  msg = msg.replace(/[^a-z0-9]+/ig, '')
+  if (msg.length % 2 !== 0) msg = '0' + msg
+  const res: number[] = []
+  for (let i = 0; i < msg.length; i += 2) {
+    res.push(parseInt(msg[i] + msg[i + 1], 16))
+  }
+  return res
+}
+
+const base64ToArray = (msg: string): number[] => {
+  const base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+  const result: number[] = []
+  let currentBit = 0
+  let currentByte = 0
+
+  for (const char of msg.replace(/=+$/, '')) {
+    currentBit = (currentBit << 6) | base64Chars.indexOf(char)
+    currentByte += 6
+
+    if (currentByte >= 8) {
+      currentByte -= 8
+      result.push((currentBit >> currentByte) & 0xFF)
+      currentBit &= (1 << currentByte) - 1
     }
+  }
 
-    return result
-  } else {
-    // Handle UTF-8 encoding
-    for (let i = 0; i < msg.length; i++) {
-      const c = msg.charCodeAt(i)
-      const hi = c >> 8
-      const lo = c & 0xff
-      if (hi as unknown as boolean) {
-        res.push(hi, lo)
-      } else {
-        res.push(lo)
-      }
+  return result
+}
+
+const utf8ToArray = (msg: string): number[] => {
+  const res: number[] = []
+  for (let i = 0; i < msg.length; i++) {
+    const c = msg.charCodeAt(i)
+    const hi = c >> 8
+    const lo = c & 0xff
+    if (hi) {
+      res.push(hi, lo)
+    } else {
+      res.push(lo)
     }
   }
   return res
@@ -101,32 +105,43 @@ export const toArray = (msg: any, enc?: 'hex' | 'utf8' | 'base64'): any[] => {
  */
 export const toUTF8 = (arr: number[]): string => {
   let result = ''
+  let skip = 0
 
   for (let i = 0; i < arr.length; i++) {
     const byte = arr[i]
 
+    // this byte is part of a multi-byte sequence, skip it
+    // added to avoid modifying i within the loop which is considered unsafe.
+    if (skip > 0) {
+      skip--
+      continue
+    }
+
     // 1-byte sequence (0xxxxxxx)
     if (byte <= 0x7F) {
       result += String.fromCharCode(byte)
     }
     // 2-byte sequence (110xxxxx 10xxxxxx)
     else if (byte >= 0xC0 && byte <= 0xDF) {
-      const byte2 = arr[++i]
+      const byte2 = arr[i + 1]
+      skip = 1
       const codePoint = ((byte & 0x1F) << 6) | (byte2 & 0x3F)
       result += String.fromCharCode(codePoint)
     }
     // 3-byte sequence (1110xxxx 10xxxxxx 10xxxxxx)
     else if (byte >= 0xE0 && byte <= 0xEF) {
-      const byte2 = arr[++i]
-      const byte3 = arr[++i]
+      const byte2 = arr[i + 1]
+      const byte3 = arr[i + 2]
+      skip = 2
       const codePoint = ((byte & 0x0F) << 12) | ((byte2 & 0x3F) << 6) | (byte3 & 0x3F)
       result += String.fromCharCode(codePoint)
     }
     // 4-byte sequence (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
     else if (byte >= 0xF0 && byte <= 0xF7) {
-      const byte2 = arr[++i]
-      const byte3 = arr[++i]
-      const byte4 = arr[++i]
+      const byte2 = arr[i + 1]
+      const byte3 = arr[i + 2]
+      const byte4 = arr[i + 3]
+      skip = 3
       const codePoint = ((byte & 0x07) << 18) | ((byte2 & 0x3F) << 12) | ((byte3 & 0x3F) << 6) | (byte4 & 0x3F)
 
       // Convert to UTF-16 surrogate pair
@@ -212,7 +227,7 @@ export const fromBase58 = (str: string): number[] => {
   const uint8 = new Uint8Array([
     ...new Uint8Array(psz),
     ...str
-      .match(/.{1}/gmu)
+      .match(/./gmu)
       .map((i) => base58chars.indexOf(i))
       .reduce((acc, i) => {
         acc = acc.map((j) => {
@@ -324,19 +339,19 @@ export class Writer {
     const ret = new Array(totalLength)
     let offset = 0
     for (const buf of this.bufs) {
-      for (let i = 0; i < buf.length; i++) {
-        ret[offset++] = buf[i]
+      for (const value of buf) {
+        ret[offset++] = value
       }
     }
     return ret
   }
 
-  write (buf: number[]): Writer {
+  write (buf: number[]): this {
     this.bufs.push(buf)
     return this
   }
 
-  writeReverse (buf: number[]): Writer {
+  writeReverse (buf: number[]): this {
     const buf2: number[] = new Array(buf.length)
     for (let i = 0; i < buf2.length; i++) {
       buf2[i] = buf[buf.length - 1 - i]
@@ -345,21 +360,21 @@ export class Writer {
     return this
   }
 
-  writeUInt8 (n: number): Writer {
+  writeUInt8 (n: number): this {
     const buf = new Array(1)
     buf[0] = n
     this.write(buf)
     return this
   }
 
-  writeInt8 (n: number): Writer {
+  writeInt8 (n: number): this {
     const buf = new Array(1)
     buf[0] = n & 0xFF
     this.write(buf)
     return this
   }
 
-  writeUInt16BE (n: number): Writer {
+  writeUInt16BE (n: number): this {
     this.bufs.push([
       (n >> 8) & 0xFF, // shift right 8 bits to get the high byte
       n & 0xFF // low byte is just the last 8 bits
@@ -367,11 +382,11 @@ export class Writer {
     return this
   }
 
-  writeInt16BE (n: number): Writer {
+  writeInt16BE (n: number): this {
     return this.writeUInt16BE(n & 0xFFFF) // Mask with 0xFFFF to get the lower 16 bits
   }
 
-  writeUInt16LE (n: number): Writer {
+  writeUInt16LE (n: number): this {
     this.bufs.push([
       n & 0xFF, // low byte is just the last 8 bits
       (n >> 8) & 0xFF // shift right 8 bits to get the high byte
@@ -379,11 +394,11 @@ export class Writer {
     return this
   }
 
-  writeInt16LE (n: number): Writer {
+  writeInt16LE (n: number): this {
     return this.writeUInt16LE(n & 0xFFFF) // Mask with 0xFFFF to get the lower 16 bits
   }
 
-  writeUInt32BE (n: number): Writer {
+  writeUInt32BE (n: number): this {
     this.bufs.push([
       (n >> 24) & 0xFF, // highest byte
       (n >> 16) & 0xFF,
@@ -393,11 +408,11 @@ export class Writer {
     return this
   }
 
-  writeInt32BE (n: number): Writer {
+  writeInt32BE (n: number): this {
     return this.writeUInt32BE(n >>> 0) // Using unsigned right shift to handle negative numbers
   }
 
-  writeUInt32LE (n: number): Writer {
+  writeUInt32LE (n: number): this {
     this.bufs.push([
       n & 0xFF, // lowest byte
       (n >> 8) & 0xFF,
@@ -407,35 +422,35 @@ export class Writer {
     return this
   }
 
-  writeInt32LE (n: number): Writer {
+  writeInt32LE (n: number): this {
     return this.writeUInt32LE(n >>> 0) // Using unsigned right shift to handle negative numbers
   }
 
-  writeUInt64BEBn (bn: BigNumber): Writer {
+  writeUInt64BEBn (bn: BigNumber): this {
     const buf = bn.toArray('be', 8)
     this.write(buf)
     return this
   }
 
-  writeUInt64LEBn (bn: BigNumber): Writer {
+  writeUInt64LEBn (bn: BigNumber): this {
     const buf = bn.toArray('be', 8)
     this.writeReverse(buf)
     return this
   }
 
-  writeUInt64LE (n: number): Writer {
+  writeUInt64LE (n: number): this {
     const buf = new BigNumber(n).toArray('be', 8)
     this.writeReverse(buf)
     return this
   }
 
-  writeVarIntNum (n: number): Writer {
+  writeVarIntNum (n: number): this {
     const buf = Writer.varIntNum(n)
     this.write(buf)
     return this
   }
 
-  writeVarIntBn (bn: BigNumber): Writer {
+  writeVarIntBn (bn: BigNumber): this {
     const buf = Writer.varIntBn(bn)
     this.write(buf)
     return this
@@ -696,13 +711,13 @@ export const minimallyEncode = (buf: number[]): number[] => {
       if ((buf[i - 1] & 0x80) !== 0) {
         // We found a byte with it sign bit set so we need one more
         // byte.
-        buf[i++] = last
+        buf[i] = last
+        return buf.slice(0, i + 1)
       } else {
         // the sign bit is clear, we can use it.
         buf[i - 1] |= last
+        return buf.slice(0, i)
       }
-
-      return buf.slice(0, i)
     }
   }
 

package/src/totp/totp.ts

@@ -106,7 +106,6 @@ function generateHOTP (
   options: Required<TOTPOptions>
 ): string {
   const timePad = new BigNumber(counter).toArray('be', 8)
-  // console.log({ timePad })
   const hmac = calcHMAC(secret, timePad, options.algorithm)
   const signature = hmac.digest()
 

package/src/transaction/Beef.ts

@@ -3,13 +3,16 @@ import Transaction from './Transaction.js'
 import ChainTracker from './ChainTracker.js'
 import BeefTx from './BeefTx.js'
 import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
-
-export const BEEF_MAGIC = 4022206465 // 0100BEEF in LE order
-export const BEEF_MAGIC_V2 = 4022206466 // 0200BEEF in LE order
-export const BEEF_MAGIC_TXID_ONLY_EXTENSION = 4022206465 // 0100BEEF in LE order
-export const ATOMIC_BEEF = 0x01010101 // Atomic Beef serialization prefix
-
-export type BeefVersion = undefined | 'V1' | 'V2'
+import { hash256 } from '../primitives/Hash.js'
+
+export const BEEF_V1 = 4022206465 // 0100BEEF in LE order
+export const BEEF_V2 = 4022206466 // 0200BEEF in LE order
+export const ATOMIC_BEEF = 0x01010101 // 01010101
+export enum TX_DATA_FORMAT {
+  RAWTX = 0, // rawtx without BUMP
+  RAWTX_AND_BUMP_INDEX = 1, // rawtx with bump index
+  TXID_ONLY = 2, // txid only
+}
 
 /*
  * BEEF standard: BRC-62: Background Evaluation Extended Format (BEEF) Transactions
@@ -67,29 +70,13 @@ export type BeefVersion = undefined | 'V1' | 'V2'
 export class Beef {
   bumps: MerklePath[] = []
   txs: BeefTx[] = []
-  version: BeefVersion = undefined
+  version: number = BEEF_V2
   atomicTxid: string | undefined = undefined
 
-  constructor (version?: BeefVersion) {
+  constructor (version: number = BEEF_V2) {
     this.version = version
   }
 
-  /**
-     * BEEF_MAGIC is the original V1 version.
-     * BEEF_MAGIC_V2 includes support for txidOnly transactions in serialized beefs.
-     * @returns version magic value based on current contents and constructor version parameter.
-     */
-  get magic (): number {
-    if (this.version === 'V1') { return BEEF_MAGIC }
-
-    if (this.version === 'V2') { return BEEF_MAGIC_V2 }
-
-    const hasTxidOnly = this.txs.findIndex(tx => tx.isTxidOnly) > -1
-    if (hasTxidOnly) { return BEEF_MAGIC_V2 }
-
-    return BEEF_MAGIC
-  }
-
   /**
      * @param txid of `beefTx` to find
      * @returns `BeefTx` in `txs` with `txid`.
@@ -113,7 +100,7 @@ export class Beef {
     if (i === -1) return undefined
     let btx = this.txs[i]
     if (btx.isTxidOnly) { return btx }
-    this.txs.slice(i, i + 1)
+    this.txs.splice(i, 1)
     btx = this.mergeTxidOnly(txid)
     return btx
   }
@@ -295,8 +282,6 @@ export class Beef {
   }
 
   mergeTxidOnly (txid: string): BeefTx {
-    if (this.version === 'V1') { throw new Error('BEEF V1 format does not support txid only transactions.') }
-
     let tx = this.txs.find(t => t.txid === txid)
     if (!tx) {
       tx = new BeefTx(txid)
@@ -308,9 +293,7 @@ export class Beef {
 
   mergeBeefTx (btx: BeefTx): BeefTx {
     let beefTx = this.findTxid(btx.txid)
-    if (!beefTx && btx.isTxidOnly) { beefTx = this.mergeTxidOnly(btx.txid) } else if (!beefTx || beefTx.isTxidOnly) {
-      if (btx._tx) { beefTx = this.mergeTransaction(btx._tx) } else { beefTx = this.mergeRawTx(btx._rawTx) }
-    }
+    if (btx.isTxidOnly && !beefTx) { beefTx = this.mergeTxidOnly(btx.txid) } else if (btx._tx && (!beefTx || beefTx.isTxidOnly)) { beefTx = this.mergeTransaction(btx._tx) } else if (btx._rawTx && (!beefTx || beefTx.isTxidOnly)) { beefTx = this.mergeRawTx(btx._rawTx) }
     return beefTx
   }
 
@@ -416,7 +399,7 @@ export class Beef {
    * @param writer
    */
   toWriter (writer: Writer) {
-    writer.writeUInt32LE(this.magic)
+    writer.writeUInt32LE(this.version)
 
     writer.writeVarIntNum(this.bumps.length)
     for (const b of this.bumps) {
@@ -425,7 +408,7 @@ export class Beef {
 
     writer.writeVarIntNum(this.txs.length)
     for (const tx of this.txs) {
-      tx.toWriter(writer, this.magic)
+      tx.toWriter(writer, this.version)
     }
   }
 
@@ -442,8 +425,9 @@ export class Beef {
   /**
    * Serialize this Beef as AtomicBEEF.
    *
-   * `txid` must exist and be the last transaction
-   * in sorted (dependency) order.
+   * `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.
@@ -452,11 +436,16 @@ export class Beef {
     this.sortTxs()
     const tx = this.findTxid(txid)
     if (!tx) { throw new Error(`${txid} does not exist in this Beef`) }
-    if (this.txs[this.txs.length - 1] !== tx) { throw new Error(`${txid} is not the last transaction in this Beef`) }
+    let beef: Beef = this
+    if (this.txs[this.txs.length - 1] !== tx) {
+      beef = this.clone()
+      const i = this.txs.findIndex(t => t.txid === txid)
+      beef.txs.splice(i + 1)
+    }
     const writer = new Writer()
     writer.writeUInt32LE(ATOMIC_BEEF)
     writer.write(toArray(txid, 'hex'))
-    this.toWriter(writer)
+    beef.toWriter(writer)
     return writer.toArray()
   }
 
@@ -476,11 +465,11 @@ export class Beef {
       atomicTxid = toHex(br.read(32))
       version = br.readUInt32LE()
     }
-    if (version !== BEEF_MAGIC && version !== BEEF_MAGIC_V2) { throw new Error(`Serialized BEEF must start with ${BEEF_MAGIC} or ${BEEF_MAGIC_V2} but starts with ${version}`) }
-    const beef = new Beef(version === BEEF_MAGIC_V2 ? 'V2' : undefined)
+    if (version !== BEEF_V1 && version !== BEEF_V2) { throw new Error(`Serialized BEEF must start with ${BEEF_V1} or ${BEEF_V2} but starts with ${version}`) }
+    const beef = new Beef(version)
     const bumpsLength = br.readVarIntNum()
     for (let i = 0; i < bumpsLength; i++) {
-      const bump = MerklePath.fromReader(br)
+      const bump = MerklePath.fromReader(br, false)
       beef.bumps.push(bump)
     }
     const txsLength = br.readVarIntNum()
@@ -508,8 +497,7 @@ export class Beef {
      * @param enc The encoding of the string value from which BEEF should be constructed
      * @returns An instance of the Beef class constructed from the string
      */
-  static fromString (s: string, enc?: 'hex' | 'utf8' | 'base64'): Beef {
-    enc ||= 'hex'
+  static fromString (s: string, enc: 'hex' | 'utf8' | 'base64' = 'hex'): Beef {
     const bin = toArray(s, enc)
     const br = new Reader(bin)
     return Beef.fromReader(br)
@@ -697,6 +685,36 @@ export class Beef {
     }
     return log
   }
+
+  /**
+   * In some circumstances it may be helpful for the BUMP MerkePaths to include
+   * leaves that can be computed from row zero.
+   */
+  addComputedLeaves () {
+    const beef = this
+    const hash = (m: string): string => toHex((
+      hash256(toArray(m, 'hex').reverse())
+    ).reverse())
+
+    for (const bump of beef.bumps) {
+      for (let row = 1; row < bump.path.length; row++) {
+        for (const leafL of bump.path[row - 1]) {
+          if (leafL.hash && (leafL.offset & 1) === 0) {
+            const leafR = bump.path[row - 1].find(l => l.offset === leafL.offset + 1)
+            const offsetOnRow = leafL.offset >> 1
+            if (leafR && leafR.hash && bump.path[row].findIndex(l => l.offset === offsetOnRow) === -1) {
+              // computable leaf is missing... add it.
+              bump.path[row].push({
+                offset: offsetOnRow,
+                // string concatenation puts the right leaf on the left of the left leaf hash :-)
+                hash: hash(leafR.hash + leafL.hash)
+              })
+            }
+          }
+        }
+      }
+    }
+  }
 }
 
 export default Beef

package/src/transaction/BeefParty.ts

@@ -41,7 +41,7 @@ export class BeefParty extends Beef {
 
   /**
      * @param party
-     * @returns `true` if `party` has already beed added to this `BeefParty`.
+     * @returns `true` if `party` has already been added to this `BeefParty`.
      */
   isParty (party: string) {
     const r = Object.keys(this.knownTo).includes(party)