@bsv/sdk 1.3.12 → 1.3.14

package/src/transaction/Beef.ts

@@ -5,6 +5,11 @@ import BeefTx from './BeefTx.js'
 import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
 import { hash256 } from '../primitives/Hash.js'
 
+function verifyTruthy<T> (v: T | undefined): T {
+  if (v == null) throw new Error('Expected a valid value, but got undefined.')
+  return v
+}
+
 export const BEEF_V1 = 4022206465 // 0100BEEF in LE order
 export const BEEF_V2 = 4022206466 // 0200BEEF in LE order
 export const ATOMIC_BEEF = 0x01010101 // 01010101
@@ -78,11 +83,11 @@ export class Beef {
   }
 
   /**
-     * @param txid of `beefTx` to find
-     * @returns `BeefTx` in `txs` with `txid`.
-     */
+   * @param txid of `beefTx` to find
+   * @returns `BeefTx` in `txs` with `txid`.
+   */
   findTxid (txid: string): BeefTx | undefined {
-    return this.txs.find(tx => tx.txid === txid)
+    return this.txs.find((tx) => tx.txid === txid)
   }
 
   /**
@@ -96,10 +101,12 @@ export class Beef {
    * @returns undefined if txid is unknown.
    */
   makeTxidOnly (txid: string): BeefTx | undefined {
-    const i = this.txs.findIndex(tx => tx.txid === txid)
+    const i = this.txs.findIndex((tx) => tx.txid === txid)
     if (i === -1) return undefined
     let btx = this.txs[i]
-    if (btx.isTxidOnly) { return btx }
+    if (btx.isTxidOnly) {
+      return btx
+    }
     this.txs.splice(i, 1)
     btx = this.mergeTxidOnly(txid)
     return btx
@@ -109,7 +116,9 @@ export class Beef {
    * @returns `MerklePath` with level zero hash equal to txid or undefined.
    */
   findBump (txid: string): MerklePath | undefined {
-    return this.bumps.find(b => b.path[0].find(leaf => leaf.hash === txid))
+    return this.bumps.find((b) =>
+      b.path[0].some((leaf) => leaf.hash === txid) // ✅ Ensure boolean return with `.some()`
+    )
   }
 
   /**
@@ -123,12 +132,12 @@ export class Beef {
    */
   findTransactionForSigning (txid: string): Transaction | undefined {
     const beefTx = this.findTxid(txid)
-    if (!beefTx) return undefined
+    if ((beefTx == null) || (beefTx.tx == null)) return undefined // Ensure beefTx.tx exists before using it
 
     for (const i of beefTx.tx.inputs) {
-      if (!i.sourceTransaction) {
-        const itx = this.findTxid(i.sourceTXID)
-        if (itx) {
+      if (i.sourceTransaction == null) {
+        const itx = this.findTxid(verifyTruthy(i.sourceTXID)) // Ensure sourceTXID is valid
+        if (itx != null) {
           i.sourceTransaction = itx.tx
         }
       }
@@ -147,21 +156,23 @@ export class Beef {
    */
   findAtomicTransaction (txid: string): Transaction | undefined {
     const beefTx = this.findTxid(txid)
-    if (!beefTx) return undefined
+    if ((beefTx == null) || (beefTx.tx == null)) return undefined // Ensure beefTx.tx exists before using it
 
-    const addInputProof = (beef: Beef, tx: Transaction) => {
+    const addInputProof = (beef: Beef, tx: Transaction): void => {
       const mp = beef.findBump(tx.id('hex'))
-      if (mp) { tx.merklePath = mp } else {
+      if (mp != null) {
+        tx.merklePath = mp
+      } else {
         for (const i of tx.inputs) {
-          if (!i.sourceTransaction) {
-            const itx = beef.findTxid(i.sourceTXID)
-            if (itx) {
+          if (i.sourceTransaction == null) {
+            const itx = beef.findTxid(verifyTruthy(i.sourceTXID)) // Ensure sourceTXID is valid
+            if (itx != null) {
               i.sourceTransaction = itx.tx
             }
           }
-          if (i.sourceTransaction) {
+          if (i.sourceTransaction != null) {
             const mp = beef.findBump(i.sourceTransaction.id('hex'))
-            if (mp) {
+            if (mp != null) {
               i.sourceTransaction.merklePath = mp
             } else {
               addInputProof(beef, i.sourceTransaction)
@@ -171,22 +182,23 @@ export class Beef {
       }
     }
 
-    addInputProof(this, beefTx.tx)
+    addInputProof(this, beefTx.tx) // Safe because we checked that beefTx.tx exists
 
     return beefTx.tx
   }
 
   /**
-     * Merge a MerklePath that is assumed to be fully valid.
-     * @param bump
-     * @returns index of merged bump
-     */
+   * Merge a MerklePath that is assumed to be fully valid.
+   * @param bump
+   * @returns index of merged bump
+   */
   mergeBump (bump: MerklePath): number {
     let bumpIndex: number | undefined
     // If this proof is identical to another one previously added, we use that first. Otherwise, we try to merge it with proofs from the same block.
     for (let i = 0; i < this.bumps.length; i++) {
       const b = this.bumps[i]
-      if (b === bump) { // Literally the same
+      if (b === bump) {
+        // Literally the same
         return i
       }
       if (b.blockHeight === bump.blockHeight) {
@@ -208,11 +220,12 @@ export class Beef {
       this.bumps.push(bump)
     }
 
-    // review if any transactions are proven by this bump
+    // Review if any transactions are proven by this bump
     const b = this.bumps[bumpIndex]
     for (const tx of this.txs) {
       const txid = tx.txid
-      if (!tx.bumpIndex) {
+
+      if (tx.bumpIndex == null) { // ✅ Explicitly check for null or undefined
         for (const n of b.path[0]) {
           if (n.hash === txid) {
             tx.bumpIndex = bumpIndex
@@ -227,16 +240,16 @@ export class Beef {
   }
 
   /**
-     * Merge a serialized transaction.
-     *
-     * Checks that a transaction with the same txid hasn't already been merged.
-     *
-     * Replaces existing transaction with same txid.
-     *
-     * @param rawTx
-     * @param bumpIndex Optional. If a number, must be valid index into bumps array.
-     * @returns txid of rawTx
-     */
+   * Merge a serialized transaction.
+   *
+   * Checks that a transaction with the same txid hasn't already been merged.
+   *
+   * Replaces existing transaction with same txid.
+   *
+   * @param rawTx
+   * @param bumpIndex Optional. If a number, must be valid index into bumps array.
+   * @returns txid of rawTx
+   */
   mergeRawTx (rawTx: number[], bumpIndex?: number): BeefTx {
     const newTx: BeefTx = new BeefTx(rawTx, bumpIndex)
     this.removeExistingTxid(newTx.txid)
@@ -246,44 +259,50 @@ export class Beef {
   }
 
   /**
-     * Merge a `Transaction` and any referenced `merklePath` and `sourceTransaction`, recursifely.
-     *
-     * Replaces existing transaction with same txid.
-     *
-     * Attempts to match an existing bump to the new transaction.
-     *
-     * @param tx
-     * @returns txid of tx
-     */
+   * Merge a `Transaction` and any referenced `merklePath` and `sourceTransaction`, recursifely.
+   *
+   * Replaces existing transaction with same txid.
+   *
+   * Attempts to match an existing bump to the new transaction.
+   *
+   * @param tx
+   * @returns txid of tx
+   */
   mergeTransaction (tx: Transaction): BeefTx {
     const txid = tx.id('hex')
     this.removeExistingTxid(txid)
     let bumpIndex: number | undefined
-    if (tx.merklePath) { bumpIndex = this.mergeBump(tx.merklePath) }
+    if (tx.merklePath != null) {
+      bumpIndex = this.mergeBump(tx.merklePath)
+    }
     const newTx = new BeefTx(tx, bumpIndex)
     this.txs.push(newTx)
     this.tryToValidateBumpIndex(newTx)
     bumpIndex = newTx.bumpIndex
     if (bumpIndex === undefined) {
       for (const input of tx.inputs) {
-        if (input.sourceTransaction) { this.mergeTransaction(input.sourceTransaction) }
+        if (input.sourceTransaction != null) {
+          this.mergeTransaction(input.sourceTransaction)
+        }
       }
     }
     return newTx
   }
 
   /**
-     * Removes an existing transaction from the BEEF, given its TXID
-     * @param txid TXID of the transaction to remove
-     */
-  removeExistingTxid (txid: string) {
-    const existingTxIndex = this.txs.findIndex(t => t.txid === txid)
-    if (existingTxIndex >= 0) { this.txs.splice(existingTxIndex, 1) }
+   * Removes an existing transaction from the BEEF, given its TXID
+   * @param txid TXID of the transaction to remove
+   */
+  removeExistingTxid (txid: string): void {
+    const existingTxIndex = this.txs.findIndex((t) => t.txid === txid)
+    if (existingTxIndex >= 0) {
+      this.txs.splice(existingTxIndex, 1)
+    }
   }
 
   mergeTxidOnly (txid: string): BeefTx {
-    let tx = this.txs.find(t => t.txid === txid)
-    if (!tx) {
+    let tx = this.txs.find((t) => t.txid === txid)
+    if (tx == null) {
       tx = new BeefTx(txid)
       this.txs.push(tx)
       this.tryToValidateBumpIndex(tx)
@@ -293,63 +312,93 @@ export class Beef {
 
   mergeBeefTx (btx: BeefTx): BeefTx {
     let beefTx = this.findTxid(btx.txid)
-    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) }
+
+    if (btx.isTxidOnly && (beefTx == null)) {
+      beefTx = this.mergeTxidOnly(btx.txid)
+    } else if ((btx._tx != null) && ((beefTx == null) || beefTx.isTxidOnly)) {
+      beefTx = this.mergeTransaction(btx._tx)
+    } else if ((btx._rawTx != null) && ((beefTx == null) || beefTx.isTxidOnly)) {
+      beefTx = this.mergeRawTx(btx._rawTx)
+    }
+
+    if (beefTx == null) {
+      throw new Error(`Failed to merge BeefTx for txid: ${btx.txid}`)
+    }
+
     return beefTx
   }
 
-  mergeBeef (beef: number[] | Beef) {
+  mergeBeef (beef: number[] | Beef): void {
     const b: Beef = Array.isArray(beef) ? Beef.fromBinary(beef) : beef
 
-    for (const bump of b.bumps) { this.mergeBump(bump) }
+    for (const bump of b.bumps) {
+      this.mergeBump(bump)
+    }
 
-    for (const tx of b.txs) { this.mergeBeefTx(tx) }
+    for (const tx of b.txs) {
+      this.mergeBeefTx(tx)
+    }
   }
 
   /**
-     * Sorts `txs` and checks structural validity of beef.
-     *
-     * Does NOT verify merkle roots.
-     *
-     * Validity requirements:
-     * 1. No 'known' txids, unless `allowTxidOnly` is true.
-     * 2. All transactions have bumps or their inputs chain back to bumps (or are known).
-     * 3. Order of transactions satisfies dependencies before dependents.
-     * 4. No transactions with duplicate txids.
-     *
-     * @param allowTxidOnly optional. If true, transaction txid only is assumed valid
-     */
+   * Sorts `txs` and checks structural validity of beef.
+   *
+   * Does NOT verify merkle roots.
+   *
+   * Validity requirements:
+   * 1. No 'known' txids, unless `allowTxidOnly` is true.
+   * 2. All transactions have bumps or their inputs chain back to bumps (or are known).
+   * 3. Order of transactions satisfies dependencies before dependents.
+   * 4. No transactions with duplicate txids.
+   *
+   * @param allowTxidOnly optional. If true, transaction txid only is assumed valid
+   */
   isValid (allowTxidOnly?: boolean): boolean {
     return this.verifyValid(allowTxidOnly).valid
   }
 
   /**
-     * Sorts `txs` and confirms validity of transaction data contained in beef
-     * by validating structure of this beef and confirming computed merkle roots
-     * using `chainTracker`.
-     *
-     * Validity requirements:
-     * 1. No 'known' txids, unless `allowTxidOnly` is true.
-     * 2. All transactions have bumps or their inputs chain back to bumps (or are known).
-     * 3. Order of transactions satisfies dependencies before dependents.
-     * 4. No transactions with duplicate txids.
-     *
-     * @param chainTracker Used to verify computed merkle path roots for all bump txids.
-     * @param allowTxidOnly optional. If true, transaction txid is assumed valid
-     */
-  async verify (chainTracker: ChainTracker, allowTxidOnly?: boolean): Promise<boolean> {
+   * Sorts `txs` and confirms validity of transaction data contained in beef
+   * by validating structure of this beef and confirming computed merkle roots
+   * using `chainTracker`.
+   *
+   * Validity requirements:
+   * 1. No 'known' txids, unless `allowTxidOnly` is true.
+   * 2. All transactions have bumps or their inputs chain back to bumps (or are known).
+   * 3. Order of transactions satisfies dependencies before dependents.
+   * 4. No transactions with duplicate txids.
+   *
+   * @param chainTracker Used to verify computed merkle path roots for all bump txids.
+   * @param allowTxidOnly optional. If true, transaction txid is assumed valid
+   */
+  async verify (
+    chainTracker: ChainTracker,
+    allowTxidOnly?: boolean
+  ): Promise<boolean> {
     const r = this.verifyValid(allowTxidOnly)
     if (!r.valid) return false
 
     for (const height of Object.keys(r.roots)) {
-      const isValid = await chainTracker.isValidRootForHeight(r.roots[height], Number(height))
-      if (!isValid) { return false }
+      const isValid = await chainTracker.isValidRootForHeight(
+        r.roots[height],
+        Number(height)
+      )
+      if (!isValid) {
+        return false
+      }
     }
 
     return true
   }
 
-  private verifyValid (allowTxidOnly?: boolean): { valid: boolean, roots: Record<number, string> } {
-    const r: { valid: boolean, roots: Record<number, string> } = { valid: false, roots: {} }
+  private verifyValid (allowTxidOnly?: boolean): {
+    valid: boolean
+    roots: Record<number, string>
+  } {
+    const r: { valid: boolean, roots: Record<number, string> } = {
+      valid: false,
+      roots: {}
+    }
 
     this.sortTxs()
 
@@ -358,35 +407,41 @@ export class Beef {
 
     for (const tx of this.txs) {
       if (tx.isTxidOnly) {
-        if (!allowTxidOnly) return r
+        if (allowTxidOnly !== true) return r // ✅ Explicit check for `true`
         txids[tx.txid] = true
       }
     }
 
     const confirmComputedRoot = (b: MerklePath, txid: string): boolean => {
       const root = b.computeRoot(txid)
-      if (!r.roots[b.blockHeight]) {
+      if (r.roots[b.blockHeight] === undefined || r.roots[b.blockHeight] === '') {
         // accept the root as valid for this block and reuse for subsequent txids
         r.roots[b.blockHeight] = root
       }
-      if (r.roots[b.blockHeight] !== root) { return false }
+      if (r.roots[b.blockHeight] !== root) {
+        return false
+      }
       return true
     }
 
     for (const b of this.bumps) {
       for (const n of b.path[0]) {
-        if (n.txid && n.hash) {
+        if (n.txid === true && typeof n.hash === 'string' && n.hash.length > 0) {
           txids[n.hash] = true
-          // all txid hashes in all bumps must have agree on computed merkle path roots
-          if (!confirmComputedRoot(b, n.hash)) { return r }
+
+          // All txid hashes in all bumps must agree on computed merkle path roots
+          if (!confirmComputedRoot(b, n.hash)) {
+            return r
+          }
         }
       }
     }
 
     for (const t of this.txs) {
-      for (const i of t.inputTxids)
       // all input txids must be included before they are referenced
-      { if (!txids[i]) return r }
+      for (const i of t.inputTxids) {
+        if (!txids[i]) return r
+      }
       txids[t.txid] = true
     }
 
@@ -398,7 +453,7 @@ export class Beef {
    * Serializes this data to `writer`
    * @param writer
    */
-  toWriter (writer: Writer) {
+  toWriter (writer: Writer): void {
     writer.writeUInt32LE(this.version)
 
     writer.writeVarIntNum(this.bumps.length)
@@ -413,9 +468,9 @@ export class Beef {
   }
 
   /**
-     * Returns a binary array representing the serialized BEEF
-     * @returns A binary array representing the BEEF
-     */
+   * Returns a binary array representing the serialized BEEF
+   * @returns A binary array representing the BEEF
+   */
   toBinary (): number[] {
     const writer = new Writer()
     this.toWriter(writer)
@@ -432,27 +487,33 @@ export class Beef {
    * @param txid
    * @returns serialized contents of this Beef with AtomicBEEF prefix.
    */
-  toBinaryAtomic (txid: string) {
+  toBinaryAtomic (txid: string): number[] {
     this.sortTxs()
     const tx = this.findTxid(txid)
-    if (!tx) { throw new Error(`${txid} does not exist 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)
+    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.write(toArray(txid, 'hex'))
     beef.toWriter(writer)
+
     return writer.toArray()
   }
 
   /**
-     * Returns a hex string representing the serialized BEEF
-     * @returns A hex string representing the BEEF
-     */
+   * Returns a hex string representing the serialized BEEF
+   * @returns A hex string representing the BEEF
+   */
   toHex (): string {
     return toHex(this.toBinary())
   }
@@ -465,7 +526,11 @@ export class Beef {
       atomicTxid = toHex(br.read(32))
       version = br.readUInt32LE()
     }
-    if (version !== BEEF_V1 && version !== BEEF_V2) { throw new Error(`Serialized BEEF must start with ${BEEF_V1} or ${BEEF_V2} but starts with ${version}`) }
+    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++) {
@@ -482,21 +547,21 @@ 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
-     * @returns An instance of the Beef class constructed from the binary data
-     */
+   * Constructs an instance of the Beef class based on the provided binary array
+   * @param bin The binary array 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)
     return Beef.fromReader(br)
   }
 
   /**
-     * Constructs an instance of the Beef class based on the provided string
-     * @param s The string value from which to construct 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
-     */
+   * Constructs an instance of the Beef class based on the provided string
+   * @param s The string value from which to construct 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' = 'hex'): Beef {
     const bin = toArray(s, enc)
     const br = new Reader(bin)
@@ -504,17 +569,19 @@ export class Beef {
   }
 
   /**
-     * Try to validate newTx.bumpIndex by looking for an existing bump
-     * that proves newTx.txid
-     *
-     * @param newTx A new `BeefTx` that has been added to this.txs
-     * @returns true if a bump was found, false otherwise
-     */
+   * Try to validate newTx.bumpIndex by looking for an existing bump
+   * that proves newTx.txid
+   *
+   * @param newTx A new `BeefTx` that has been added to this.txs
+   * @returns true if a bump was found, false otherwise
+   */
   private tryToValidateBumpIndex (newTx: BeefTx): boolean {
-    if (newTx.bumpIndex !== undefined) { return true }
+    if (newTx.bumpIndex !== undefined) {
+      return true
+    }
     const txid = newTx.txid
     for (let i = 0; i < this.bumps.length; i++) {
-      const j = this.bumps[i].path[0].findIndex(b => b.hash === txid)
+      const j = this.bumps[i].path[0].findIndex((b) => b.hash === txid)
       if (j >= 0) {
         newTx.bumpIndex = i
         this.bumps[i].path[0][j].txid = true
@@ -525,15 +592,15 @@ export class Beef {
   }
 
   /**
-     * Sort the `txs` by input txid dependency order:
-     * - Oldest Tx Anchored by Path or txid only
-     * - Newer Txs depending on Older parents
-     * - Newest Tx
-     *
-     * with proof (MerklePath) last, longest chain of dependencies first
-     *
-     * @returns `{ missingInputs, notValid, valid, withMissingInputs }`
-     */
+   * Sort the `txs` by input txid dependency order:
+   * - Oldest Tx Anchored by Path or txid only
+   * - Newer Txs depending on Older parents
+   * - Newest Tx
+   *
+   * with proof (MerklePath) last, longest chain of dependencies first
+   *
+   * @returns `{ missingInputs, notValid, valid, withMissingInputs }`
+   */
   sortTxs (): {
     missingInputs: string[]
     notValid: string[]
@@ -564,7 +631,9 @@ export class Beef {
       } else if (tx.isTxidOnly && tx.inputTxids.length === 0) {
         validTxids[tx.txid] = true
         txidOnly.push(tx)
-      } else { queue.push(tx) }
+      } else {
+        queue.push(tx)
+      }
     }
 
     // Hashtable of unknown input txids used to fund transactions without their own proof.
@@ -584,12 +653,17 @@ export class Beef {
       // link their inputs that exist in this beef,
       // make a note of missing inputs.
       for (const inputTxid of tx.inputTxids) {
-        if (!txidToTx[inputTxid]) {
+        if (txidToTx[inputTxid] === undefined) { // Explicitly check for undefined
           missingInputs[inputTxid] = true
           hasMissingInput = true
         }
       }
-      if (hasMissingInput) { txsMissingInputs.push(tx) } else { queue.push(tx) }
+
+      if (hasMissingInput) {
+        txsMissingInputs.push(tx)
+      } else {
+        queue.push(tx)
+      }
     }
 
     // As long as we have unsorted transactions...
@@ -599,44 +673,52 @@ export class Beef {
       // all tx are isValid false, hasProof false.
       // if isTxidOnly then has inputTxids
       for (const tx of oldQueue) {
-        if (tx.inputTxids.every(txid => validTxids[txid])) {
+        if (tx.inputTxids.every((txid) => validTxids[txid])) {
           validTxids[tx.txid] = true
           result.push(tx)
-        } else { queue.push(tx) }
+        } else {
+          queue.push(tx)
+        }
+      }
+      if (oldQueue.length === queue.length) {
+        break
       }
-      if (oldQueue.length === queue.length) { break }
     }
 
     // transactions that don't have proofs and don't chain to proofs
     const txsNotValid = queue
 
     // New order of txs is unsortable (missing inputs or depends on missing inputs), txidOnly, sorted (so newest sorted is last)
-    this.txs = txsMissingInputs.concat(txsNotValid).concat(txidOnly).concat(result)
+    this.txs = txsMissingInputs
+      .concat(txsNotValid)
+      .concat(txidOnly)
+      .concat(result)
 
     return {
       missingInputs: Object.keys(missingInputs),
-      notValid: txsNotValid.map(tx => tx.txid),
+      notValid: txsNotValid.map((tx) => tx.txid),
       valid: Object.keys(validTxids),
-      withMissingInputs: txsMissingInputs.map(tx => tx.txid),
-      txidOnly: txidOnly.map(tx => tx.txid)
+      withMissingInputs: txsMissingInputs.map((tx) => tx.txid),
+      txidOnly: txidOnly.map((tx) => tx.txid)
     }
   }
 
   /**
-     * @returns a shallow copy of this beef
-     */
+   * @returns a shallow copy of this beef
+   */
   clone (): Beef {
     const c = new Beef()
+    c.version = this.version
     c.bumps = Array.from(this.bumps)
     c.txs = Array.from(this.txs)
     return c
   }
 
   /**
-     * Ensure that all the txids in `knownTxids` are txidOnly
-     * @param knownTxids
-     */
-  trimKnownTxids (knownTxids: string[]) {
+   * Ensure that all the txids in `knownTxids` are txidOnly
+   * @param knownTxids
+   */
+  trimKnownTxids (knownTxids: string[]): void {
     for (let i = 0; i < this.txs.length;) {
       const tx = this.txs[i]
       if (tx.isTxidOnly && knownTxids.includes(tx.txid)) {
@@ -657,16 +739,21 @@ export class Beef {
   }
 
   /**
-     * @returns Summary of `Beef` contents as multi-line string.
-     */
+   * @returns Summary of `Beef` contents as multi-line string.
+   */
   toLogString (): string {
     let log = ''
-    log += `BEEF with ${this.bumps.length} BUMPS and ${this.txs.length} Transactions, isValid ${this.isValid()}\n`
+    log += `BEEF with ${this.bumps.length} BUMPS and ${this.txs.length} Transactions, isValid ${this.isValid().toString()}\n`
     let i = -1
+
     for (const b of this.bumps) {
       i++
-      log += `  BUMP ${i}\n    block: ${b.blockHeight}\n    txids: [\n${b.path[0].filter(n => !!n.txid).map(n => `      '${n.hash}'`).join(',\n')}\n    ]\n`
+      log += `  BUMP ${i}\n    block: ${b.blockHeight}\n    txids: [\n${b.path[0]
+        .filter((n) => n.txid === true) // ✅ Explicitly check if txid is `true`
+        .map((n) => `      '${n.hash ?? ''}'`)
+        .join(',\n')}\n    ]\n`
     }
+
     i = -1
     for (const t of this.txs) {
       i++
@@ -677,36 +764,44 @@ export class Beef {
       if (t.isTxidOnly) {
         log += '    txidOnly\n'
       } else {
-        log += `    rawTx length=${t.rawTx.length}\n`
+        log += `    rawTx length=${t.rawTx?.length ?? 0}\n` // ✅ Fix applied here
       }
       if (t.inputTxids.length > 0) {
-        log += `    inputs: [\n${t.inputTxids.map(it => `      '${it}'`).join(',\n')}\n    ]\n`
+        log += `    inputs: [\n${t.inputTxids
+          .map((it) => `      '${it}'`)
+          .join(',\n')}\n    ]\n`
       }
     }
+
     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())
+ * In some circumstances it may be helpful for the BUMP MerklePaths to include
+ * leaves that can be computed from row zero.
+ */
+  addComputedLeaves (): void {
+    const hash = (m: string): string =>
+      toHex(hash256(toArray(m, 'hex').reverse()).reverse())
 
-    for (const bump of beef.bumps) {
+    for (const bump of this.bumps) { // ✅ Use `this` instead of `beef`
       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)
+          if (typeof leafL.hash === 'string' && (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.
+
+            if (
+              leafR !== undefined &&
+              typeof leafR.hash === 'string' &&
+              bump.path[row].every((l) => l.offset !== offsetOnRow)
+            ) {
+              // 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 :-)
+                // String concatenation puts the right leaf on the left of the left leaf hash
                 hash: hash(leafR.hash + leafL.hash)
               })
             }