@bsv/sdk 1.3.13 → 1.3.14

package/src/script/templates/RPuzzle.ts

@@ -1,13 +1,14 @@
-import OP from "../OP";
-import ScriptTemplate from "../ScriptTemplate";
-import LockingScript from "../LockingScript";
-import UnlockingScript from "../UnlockingScript";
-import Transaction from "../../transaction/Transaction";
-import PrivateKey from "../../primitives/PrivateKey";
-import TransactionSignature from "../../primitives/TransactionSignature";
-import { sha256 } from "../../primitives/Hash";
-import ScriptChunk from "../ScriptChunk";
-import BigNumber from "../../primitives/BigNumber";
+import OP from '../OP.js'
+import ScriptTemplate from '../ScriptTemplate.js'
+import LockingScript from '../LockingScript.js'
+import UnlockingScript from '../UnlockingScript.js'
+import Transaction from '../../transaction/Transaction.js'
+import PrivateKey from '../../primitives/PrivateKey.js'
+import TransactionSignature from '../../primitives/TransactionSignature.js'
+import { sha256 } from '../../primitives/Hash.js'
+import ScriptChunk from '../ScriptChunk.js'
+import BigNumber from '../../primitives/BigNumber.js'
+import Script from '../Script.js'
 
 /**
  * RPuzzle class implementing ScriptTemplate.
@@ -15,7 +16,7 @@ import BigNumber from "../../primitives/BigNumber";
  * This class provides methods to create R Puzzle and R Puzzle Hash locking and unlocking scripts, including the unlocking of UTXOs with the correct K value.
  */
 export default class RPuzzle implements ScriptTemplate {
-  type: "raw" | "SHA1" | "SHA256" | "HASH256" | "RIPEMD160" | "HASH160" = "raw";
+  type: 'raw' | 'SHA1' | 'SHA256' | 'HASH256' | 'RIPEMD160' | 'HASH160' = 'raw'
 
   /**
    * @constructor
@@ -25,14 +26,14 @@ export default class RPuzzle implements ScriptTemplate {
    */
   constructor(
     type:
-      | "raw"
-      | "SHA1"
-      | "SHA256"
-      | "HASH256"
-      | "RIPEMD160"
-      | "HASH160" = "raw"
+      | 'raw'
+      | 'SHA1'
+      | 'SHA256'
+      | 'HASH256'
+      | 'RIPEMD160'
+      | 'HASH160' = 'raw'
   ) {
-    this.type = type;
+    this.type = type
   }
 
   /**
@@ -51,17 +52,17 @@ export default class RPuzzle implements ScriptTemplate {
       { op: OP.OP_SPLIT },
       { op: OP.OP_SWAP },
       { op: OP.OP_SPLIT },
-      { op: OP.OP_DROP },
-    ];
-    if (this.type !== "raw") {
+      { op: OP.OP_DROP }
+    ]
+    if (this.type !== 'raw') {
       chunks.push({
-        op: OP["OP_" + this.type],
-      });
+        op: OP['OP_' + this.type]
+      })
     }
-    chunks.push({ op: value.length, data: value });
-    chunks.push({ op: OP.OP_EQUALVERIFY });
-    chunks.push({ op: OP.OP_CHECKSIG });
-    return new LockingScript(chunks);
+    chunks.push({ op: value.length, data: value })
+    chunks.push({ op: OP.OP_EQUALVERIFY })
+    chunks.push({ op: OP.OP_CHECKSIG })
+    return new LockingScript(chunks)
   }
 
   /**
@@ -81,78 +82,80 @@ export default class RPuzzle implements ScriptTemplate {
   unlock(
     k: BigNumber,
     privateKey: PrivateKey,
-    signOutputs: "all" | "none" | "single" = "all",
+    signOutputs: 'all' | 'none' | 'single' = 'all',
     anyoneCanPay: boolean = false
   ): {
-    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
-    estimateLength: () => Promise<108>;
+    sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
+    estimateLength: () => Promise<108>
   } {
     return {
       sign: async (tx: Transaction, inputIndex: number) => {
-        if (typeof privateKey === "undefined") {
-          privateKey = PrivateKey.fromRandom();
+        if (typeof privateKey === 'undefined') {
+          privateKey = PrivateKey.fromRandom()
         }
-        let signatureScope = TransactionSignature.SIGHASH_FORKID;
-        if (signOutputs === "all") {
-          signatureScope |= TransactionSignature.SIGHASH_ALL;
+        let signatureScope = TransactionSignature.SIGHASH_FORKID
+        if (signOutputs === 'all') {
+          signatureScope |= TransactionSignature.SIGHASH_ALL
         }
-        if (signOutputs === "none") {
-          signatureScope |= TransactionSignature.SIGHASH_NONE;
+        if (signOutputs === 'none') {
+          signatureScope |= TransactionSignature.SIGHASH_NONE
         }
-        if (signOutputs === "single") {
-          signatureScope |= TransactionSignature.SIGHASH_SINGLE;
+        if (signOutputs === 'single') {
+          signatureScope |= TransactionSignature.SIGHASH_SINGLE
         }
         if (anyoneCanPay) {
-          signatureScope |= TransactionSignature.SIGHASH_ANYONECANPAY;
+          signatureScope |= TransactionSignature.SIGHASH_ANYONECANPAY
         }
-        const otherInputs = [...tx.inputs];
-        const [input] = otherInputs.splice(inputIndex, 1);
-        if (typeof input.sourceTransaction !== "object") {
+        const otherInputs = [...tx.inputs]
+        const [input] = otherInputs.splice(inputIndex, 1)
+        if (typeof input.sourceTransaction !== 'object') {
           throw new Error(
-            "The source transaction is needed for transaction signing."
-          );
+            'The source transaction is needed for transaction signing.'
+          )
         }
         const preimage = TransactionSignature.format({
-          sourceTXID: input.sourceTransaction.id("hex"),
-          sourceOutputIndex: input.sourceOutputIndex,
+          sourceTXID: input.sourceTransaction?.id('hex') ?? '',
+          sourceOutputIndex: input.sourceOutputIndex ?? 0,
           sourceSatoshis:
-            input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis,
+            input.sourceTransaction?.outputs[input.sourceOutputIndex]
+              ?.satoshis ?? 0,
           transactionVersion: tx.version,
           otherInputs,
           inputIndex,
           outputs: tx.outputs,
-          inputSequence: input.sequence,
+          inputSequence: input.sequence ?? 0xffffffff,
           subscript:
-            input.sourceTransaction.outputs[input.sourceOutputIndex]
-              .lockingScript,
+            input.sourceTransaction?.outputs[input.sourceOutputIndex]
+              ?.lockingScript ?? new Script(),
           lockTime: tx.lockTime,
-          scope: signatureScope,
-        });
+          scope: signatureScope
+        })
+
         const rawSignature = privateKey.sign(
           sha256(preimage),
           undefined,
           true,
           k
-        );
+        )
         const sig = new TransactionSignature(
           rawSignature.r,
           rawSignature.s,
           signatureScope
-        );
-        const sigForScript = sig.toChecksigFormat();
+        )
+        const sigForScript = sig.toChecksigFormat()
         const pubkeyForScript = privateKey
           .toPublicKey()
-          .encode(true) as number[];
+          .encode(true) as number[]
         return new UnlockingScript([
           { op: sigForScript.length, data: sigForScript },
-          { op: pubkeyForScript.length, data: pubkeyForScript },
-        ]);
+          { op: pubkeyForScript.length, data: pubkeyForScript }
+        ])
       },
       estimateLength: async () => {
         // public key (1+33) + signature (1+73)
         // Note: We add 1 to each element's length because of the associated OP_PUSH
-        return 108;
-      },
-    };
+        return 108
+      }
+    }
   }
 }

package/src/script/templates/__tests/PushDrop.test.ts

@@ -6,7 +6,6 @@ import { Script, Spend } from '../../../script/index'
 import { Transaction } from '../../../transaction/index'
 
 describe('PushDrop', () => {
-  let privateKey: typeof PrivateKey
   let wallet
   let pushDrop: PushDrop
 
@@ -17,7 +16,7 @@ describe('PushDrop', () => {
     counterparty: string = 'self',
     signOutputs: 'all' | 'none' | 'single' = 'all',
     anyoneCanPay: boolean = false
-  ) => {
+  ): Promise<void> => {
     const lockingScript = await pushDrop.lock(
       fields,
       protocolID,
@@ -82,7 +81,7 @@ describe('PushDrop', () => {
   }
 
   beforeEach(() => {
-    let privateKey = PrivateKey.fromRandom()
+    const privateKey = PrivateKey.fromRandom()
     wallet = new CompletedProtoWallet(privateKey)
     pushDrop = new PushDrop(wallet)
   })

package/src/script/templates/index.ts

@@ -1,3 +1,3 @@
-export { default as P2PKH } from "./P2PKH";
-export { default as RPuzzle } from "./RPuzzle";
-export { default as PushDrop } from "./PushDrop";
+export { default as P2PKH } from './P2PKH.js'
+export { default as RPuzzle } from './RPuzzle.js'
+export { default as PushDrop } from './PushDrop.js'

package/src/totp/__tests/totp.test.ts

@@ -2,12 +2,12 @@ import { toArray } from '../../primitives/utils'
 import { TOTP } from '../../totp/totp'
 
 const secret = toArray('48656c6c6f21deadbeef', 'hex')
-const period = 30 //sec
-const periodMS = 30 * 1000 //ms
+const period = 30 // sec
+const periodMS = 30 * 1000 // ms
 const options = {
   digits: 6,
   period,
-  algorithm: 'SHA-1' as 'SHA-1'
+  algorithm: 'SHA-1' as const
 }
 
 describe('totp generation and validation', () => {
@@ -43,13 +43,13 @@ describe('totp generation and validation', () => {
   ])('$description', async ({ time, expected }) => {
     jest.setSystemTime(time)
 
-    //check if expected passcode is generated
+    // check if expected passcode is generated
     const passcode = TOTP.generate(secret, options)
     expect(passcode).toEqual(expected)
 
-    expect(TOTP.validate(secret, '000000', options)).toEqual(false) //this passcode should not be valid for any of above test cases
+    expect(TOTP.validate(secret, '000000', options)).toEqual(false) // this passcode should not be valid for any of above test cases
 
-    //should not be valid for only a part of passcode
+    // should not be valid for only a part of passcode
     expect(TOTP.validate(secret, passcode.slice(1), options)).toEqual(false)
 
     expect(TOTP.validate(secret, passcode, options)).toEqual(true)
@@ -57,7 +57,7 @@ describe('totp generation and validation', () => {
     const checkAdjacentWindow = (
       timeOfGeneration: number,
       expected: boolean
-    ) => {
+    ): void => {
       jest.setSystemTime(timeOfGeneration)
       const adjacentTimewindowPasscode = TOTP.generate(secret, options)
 
@@ -67,13 +67,14 @@ describe('totp generation and validation', () => {
       ).toEqual(expected)
     }
 
-    //because the 'skew' is '1' by default, the passcode for the next window also should be valid
-    checkAdjacentWindow(time + periodMS, true)
+    // because the 'skew' is '1' by default, the passcode for the next window also should be valid
+    checkAdjacentWindow((time as number) + periodMS, true)
+
     checkAdjacentWindow(time - periodMS, true)
 
-    //for 'skew': 1, other passcodes for further timewindows should not be valid
+    // for 'skew': 1, other passcodes for further timewindows should not be valid
     for (let i = 2; i < 10; i++) {
-      checkAdjacentWindow(time + i * periodMS, false)
+      checkAdjacentWindow((time as number) + i * periodMS, false)
       checkAdjacentWindow(time - i * periodMS, false)
     }
   })

package/src/totp/index.ts

@@ -1 +1 @@
-export * from './totp'
+export * from './totp.js'

package/src/totp/totp.ts

@@ -1,5 +1,5 @@
-import { SHA1HMAC, SHA256HMAC, SHA512HMAC } from '../primitives/Hash'
-import BigNumber from '../primitives/BigNumber'
+import { SHA1HMAC, SHA256HMAC, SHA512HMAC } from '../primitives/Hash.js'
+import BigNumber from '../primitives/BigNumber.js'
 
 export type TOTPAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-512'
 
@@ -25,6 +25,7 @@ export type TOTPValidateOptions = TOTPOptions & {
   skew?: number
 }
 
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export class TOTP {
   /**
    * Generates a Time-based One-Time Password (TOTP).
@@ -54,7 +55,7 @@ export class TOTP {
   ): boolean {
     const _options = this.withDefaultValidateOptions(options)
     passcode = passcode.trim()
-    if (passcode.length != _options.digits) {
+    if (passcode.length !== _options.digits) {
       return false
     }
 
@@ -123,7 +124,7 @@ function calcHMAC (
   secret: number[],
   timePad: number[],
   algorithm: TOTPAlgorithm
-) {
+): SHA1HMAC | SHA256HMAC | SHA512HMAC {
   switch (algorithm) {
     case 'SHA-1':
       return new SHA1HMAC(secret).update(timePad)

package/src/transaction/Beef.ts

@@ -1,9 +1,14 @@
-import MerklePath from './MerklePath'
-import Transaction from './Transaction'
-import ChainTracker from './ChainTracker'
-import BeefTx from './BeefTx'
-import { Reader, Writer, toHex, toArray } from '../primitives/utils'
-import { hash256 } from '../primitives/Hash'
+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 } 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
@@ -111,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()`
+    )
   }
 
   /**
@@ -125,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
         }
       }
@@ -149,23 +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) {
+      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)
@@ -175,7 +182,7 @@ export class Beef {
       }
     }
 
-    addInputProof(this, beefTx.tx)
+    addInputProof(this, beefTx.tx) // Safe because we checked that beefTx.tx exists
 
     return beefTx.tx
   }
@@ -213,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
@@ -264,7 +272,7 @@ export class Beef {
     const txid = tx.id('hex')
     this.removeExistingTxid(txid)
     let bumpIndex: number | undefined
-    if (tx.merklePath) {
+    if (tx.merklePath != null) {
       bumpIndex = this.mergeBump(tx.merklePath)
     }
     const newTx = new BeefTx(tx, bumpIndex)
@@ -273,7 +281,7 @@ export class Beef {
     bumpIndex = newTx.bumpIndex
     if (bumpIndex === undefined) {
       for (const input of tx.inputs) {
-        if (input.sourceTransaction) {
+        if (input.sourceTransaction != null) {
           this.mergeTransaction(input.sourceTransaction)
         }
       }
@@ -285,7 +293,7 @@ export class Beef {
    * Removes an existing transaction from the BEEF, given its TXID
    * @param txid TXID of the transaction to remove
    */
-  removeExistingTxid (txid: string) {
+  removeExistingTxid (txid: string): void {
     const existingTxIndex = this.txs.findIndex((t) => t.txid === txid)
     if (existingTxIndex >= 0) {
       this.txs.splice(existingTxIndex, 1)
@@ -294,7 +302,7 @@ export class Beef {
 
   mergeTxidOnly (txid: string): BeefTx {
     let tx = this.txs.find((t) => t.txid === txid)
-    if (!tx) {
+    if (tx == null) {
       tx = new BeefTx(txid)
       this.txs.push(tx)
       this.tryToValidateBumpIndex(tx)
@@ -304,17 +312,23 @@ export class Beef {
 
   mergeBeefTx (btx: BeefTx): BeefTx {
     let beefTx = this.findTxid(btx.txid)
-    if (btx.isTxidOnly && !beefTx) {
+
+    if (btx.isTxidOnly && (beefTx == null)) {
       beefTx = this.mergeTxidOnly(btx.txid)
-    } else if (btx._tx && (!beefTx || beefTx.isTxidOnly)) {
+    } else if ((btx._tx != null) && ((beefTx == null) || beefTx.isTxidOnly)) {
       beefTx = this.mergeTransaction(btx._tx)
-    } else if (btx._rawTx && (!beefTx || beefTx.isTxidOnly)) {
+    } 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) {
@@ -393,14 +407,14 @@ 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
       }
@@ -412,9 +426,10 @@ export class Beef {
 
     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
+
+          // All txid hashes in all bumps must agree on computed merkle path roots
           if (!confirmComputedRoot(b, n.hash)) {
             return r
           }
@@ -438,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)
@@ -472,22 +487,26 @@ 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) {
+    if (tx == null) {
       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()
+
+    // 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()
   }
 
@@ -634,11 +653,12 @@ 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 {
@@ -698,7 +718,7 @@ export class Beef {
    * Ensure that all the txids in `knownTxids` are txidOnly
    * @param knownTxids
    */
-  trimKnownTxids (knownTxids: string[]) {
+  trimKnownTxids (knownTxids: string[]): void {
     for (let i = 0; i < this.txs.length;) {
       const tx = this.txs[i]
       if (tx.isTxidOnly && knownTxids.includes(tx.txid)) {
@@ -723,15 +743,17 @@ export class Beef {
    */
   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}'`)
+        .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++
@@ -742,41 +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
+ * 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) {
+          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
+              leafR !== undefined &&
+              typeof leafR.hash === 'string' &&
+              bump.path[row].every((l) => l.offset !== offsetOnRow)
             ) {
-              // computable leaf is missing... add it.
+              // 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)
               })
             }