@bsv/sdk 1.3.13 → 1.3.14

package/src/transaction/BeefParty.ts

@@ -1,4 +1,4 @@
-import { Beef } from './Beef'
+import { Beef } from './Beef.js'
 
 /**
  * Extends `Beef` that is used to exchange transaction validity data with more than one external party.
@@ -34,7 +34,7 @@ export class BeefParty extends Beef {
    */
   constructor (parties?: string[]) {
     super()
-    if (parties) {
+    if (parties != null) {
       for (const party of parties) {
         this.addParty(party)
       }
@@ -45,7 +45,7 @@ export class BeefParty extends Beef {
    * @param party
    * @returns `true` if `party` has already been added to this `BeefParty`.
    */
-  isParty (party: string) {
+  isParty (party: string): boolean {
     const r = Object.keys(this.knownTo).includes(party)
     return r
   }
@@ -54,7 +54,7 @@ export class BeefParty extends Beef {
    * Adds a new unique party identifier to this `BeefParty`.
    * @param party
    */
-  addParty (party: string) {
+  addParty (party: string): void {
     if (this.isParty(party)) {
       throw new Error(`Party ${party} already exists.`)
     }
@@ -67,9 +67,11 @@ export class BeefParty extends Beef {
    */
   getKnownTxidsForParty (party: string): string[] {
     const knownTxids = this.knownTo[party]
-    if (!knownTxids) {
+
+    if (knownTxids === undefined) { // ✅ Explicitly check for undefined
       throw new Error(`Party ${party} is unknown.`)
     }
+
     return Object.keys(knownTxids)
   }
 
@@ -89,7 +91,7 @@ export class BeefParty extends Beef {
    * @param party unique identifier, added if new.
    * @param knownTxids
    */
-  addKnownTxidsForParty (party: string, knownTxids: string[]) {
+  addKnownTxidsForParty (party: string, knownTxids: string[]): void {
     if (!this.isParty(party)) {
       this.addParty(party)
     }
@@ -110,7 +112,7 @@ export class BeefParty extends Beef {
    * @param party
    * @param beef
    */
-  mergeBeefFromParty (party: string, beef: number[] | Beef) {
+  mergeBeefFromParty (party: string, beef: number[] | Beef): void {
     const b: Beef = Array.isArray(beef) ? Beef.fromBinary(beef) : beef
     const knownTxids = b.getValidTxids()
     this.mergeBeef(b)

package/src/transaction/BeefTx.ts

@@ -1,7 +1,7 @@
-import { hash256 } from '../primitives/Hash'
-import { Reader, Writer, toHex, toArray } from '../primitives/utils'
-import Transaction from './Transaction'
-import { BEEF_V2, TX_DATA_FORMAT } from './Beef'
+import { hash256 } from '../primitives/Hash.js'
+import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
+import Transaction from './Transaction.js'
+import { BEEF_V2, TX_DATA_FORMAT } from './Beef.js'
 
 /**
  * A single bitcoin transaction associated with a `Beef` validity proof set.
@@ -39,34 +39,34 @@ export default class BeefTx {
   }
 
   get isTxidOnly (): boolean {
-    return !!this._txid && !this._rawTx && !this._tx
+    return this._txid !== undefined && this._txid !== null && (this._rawTx == null) && (this._tx == null)
   }
 
-  get txid () {
-    if (this._txid) return this._txid
-    if (this._tx) {
+  get txid (): string {
+    if (this._txid !== undefined && this._txid !== null && this._txid !== '') return this._txid
+    if (this._tx != null) {
       this._txid = this._tx.id('hex')
       return this._txid
     }
-    if (this._rawTx) {
+    if (this._rawTx != null) {
       this._txid = toHex(hash256(this._rawTx))
       return this._txid
     }
     throw new Error('Internal')
   }
 
-  get tx () {
-    if (this._tx) return this._tx
-    if (this._rawTx) {
+  get tx (): Transaction | undefined {
+    if (this._tx != null) return this._tx
+    if (this._rawTx != null) {
       this._tx = Transaction.fromBinary(this._rawTx)
       return this._tx
     }
     return undefined
   }
 
-  get rawTx () {
-    if (this._rawTx) return this._rawTx
-    if (this._tx) {
+  get rawTx (): number[] | undefined {
+    if (this._rawTx != null) return this._rawTx
+    if (this._tx != null) {
       this._rawTx = this._tx.toBinary()
       return this._rawTx
     }
@@ -101,39 +101,45 @@ export default class BeefTx {
     return new BeefTx(txid, bumpIndex)
   }
 
-  private updateInputTxids () {
-    if (this.hasProof || !this.tx) {
+  private updateInputTxids (): void {
+    if (this.hasProof || (this.tx == null)) {
       // If we have a proof, or don't have a parsed transaction
       this.inputTxids = []
     } else {
-      const inputTxids = {}
+      const inputTxids: Record<string, boolean> = {} // ✅ Explicit object type
       for (const input of this.tx.inputs) {
-        inputTxids[input.sourceTXID] = true
+        if (input.sourceTXID !== undefined && input.sourceTXID !== null && input.sourceTXID !== '') {
+          // ✅ Ensure sourceTXID is defined
+          inputTxids[input.sourceTXID] = true
+        }
       }
       this.inputTxids = Object.keys(inputTxids)
     }
   }
 
   toWriter (writer: Writer, version: number): void {
-    const writeByte = (bb: number) => {
+    const writeByte = (bb: number): void => {
       writer.writeUInt8(bb)
     }
 
-    const writeTxid = () => {
+    const writeTxid = (): void => {
+      if (this._txid == null) {
+        throw new Error('Transaction ID (_txid) is undefined')
+      }
       writer.writeReverse(toArray(this._txid, 'hex'))
     }
 
-    const writeTx = () => {
-      if (this._rawTx) {
+    const writeTx = (): void => {
+      if (this._rawTx != null) {
         writer.write(this._rawTx)
-      } else if (this._tx) {
+      } else if (this._tx != null) {
         writer.write(this._tx.toBinary())
       } else {
         throw new Error('a valid serialized Transaction is expected')
       }
     }
 
-    const writeBumpIndex = () => {
+    const writeBumpIndex = (): void => {
       if (this.bumpIndex === undefined) {
         writeByte(TX_DATA_FORMAT.RAWTX) // 0
       } else {
@@ -179,7 +185,7 @@ export default class BeefTx {
     } else {
       // V1
       data = Transaction.fromReader(br)
-      bumpIndex = br.readUInt8() ? br.readVarIntNum() : undefined
+      bumpIndex = br.readUInt8() !== 0 ? br.readVarIntNum() : undefined
       beefTx = BeefTx.fromTx(data, bumpIndex)
     }
 

package/src/transaction/Broadcaster.ts

@@ -1,4 +1,4 @@
-import Transaction from './Transaction'
+import Transaction from './Transaction.js'
 
 /**
  * Defines the structure of a successful broadcast response.

package/src/transaction/FeeModel.ts

@@ -1,5 +1,4 @@
-import Transaction from './Transaction'
-import BigNumber from '../primitives/BigNumber'
+import Transaction from './Transaction.js'
 
 /**
  * Represents the interface for a transaction fee model.

package/src/transaction/MerklePath.ts

@@ -1,6 +1,7 @@
-import { Reader, Writer, toHex, toArray } from '../primitives/utils'
-import { hash256 } from '../primitives/Hash'
-import ChainTracker from './ChainTracker'
+
+import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
+import { hash256 } from '../primitives/Hash.js'
+import ChainTracker from './ChainTracker.js'
 
 export interface MerklePathLeaf {
   offset: number
@@ -58,13 +59,14 @@ export default class MerklePath {
   ): MerklePath {
     const blockHeight = reader.readVarIntNum()
     const treeHeight = reader.readUInt8()
-    const path = Array(treeHeight)
-      .fill(0)
+    // Explicitly define the type of path as an array of arrays of leaf objects
+    const path: Array<Array<{ offset: number, hash?: string, txid?: boolean, duplicate?: boolean }>> = Array(treeHeight)
+      .fill(null)
       .map(() => [])
-    let flags, offset, nLeavesAtThisHeight
+    let flags: number, offset: number, nLeavesAtThisHeight: number
     for (let level = 0; level < treeHeight; level++) {
       nLeavesAtThisHeight = reader.readVarIntNum()
-      while (nLeavesAtThisHeight) {
+      while (nLeavesAtThisHeight > 0) {
         offset = reader.readVarIntNum()
         flags = reader.readUInt8()
         const leaf: {
@@ -73,17 +75,22 @@ export default class MerklePath {
           txid?: boolean
           duplicate?: boolean
         } = { offset }
-        if (flags & 1) {
+        if ((flags & 1) !== 0) {
           leaf.duplicate = true
         } else {
-          if (flags & 2) {
+          if ((flags & 2) !== 0) {
             leaf.txid = true
           }
           leaf.hash = toHex(reader.read(32).reverse())
         }
+        // Ensure path[level] exists before pushing
+        if (!Array.isArray(path[level]) || path[level].length === 0) {
+          path[level] = []
+        }
         path[level].push(leaf)
         nLeavesAtThisHeight--
       }
+      // Sort the array based on the offset property
       path[level].sort((a, b) => a.offset - b.offset)
     }
     return new MerklePath(blockHeight, path, legalOffsetsOnly)
@@ -135,12 +142,12 @@ export default class MerklePath {
     const legalOffsets = Array(this.path.length)
       .fill(0)
       .map(() => new Set())
-    this.path.map((leaves, height) => {
+    this.path.forEach((leaves, height) => {
       if (leaves.length === 0 && height === 0) {
         throw new Error(`Empty level at height: ${height}`)
       }
       const offsetsAtThisHeight = new Set()
-      leaves.map((leaf) => {
+      leaves.forEach((leaf) => {
         if (offsetsAtThisHeight.has(leaf.offset)) {
           throw new Error(
             `Duplicate offset: ${leaf.offset}, at height: ${height}`
@@ -148,7 +155,7 @@ export default class MerklePath {
         }
         offsetsAtThisHeight.add(leaf.offset)
         if (height === 0) {
-          if (!leaf.duplicate) {
+          if (leaf.duplicate !== true) {
             for (let h = 1; h < this.path.length; h++) {
               legalOffsets[h].add((leaf.offset >> h) ^ 1)
             }
@@ -165,7 +172,7 @@ export default class MerklePath {
 
     // every txid must calculate to the same root.
     let root: string
-    this.path[0].map((leaf, idx) => {
+    this.path[0].forEach((leaf, idx) => {
       if (idx === 0) root = this.computeRoot(leaf.hash)
       if (root !== this.computeRoot(leaf.hash)) {
         throw new Error('Mismatched roots')
@@ -189,10 +196,10 @@ export default class MerklePath {
       for (const leaf of this.path[level]) {
         writer.writeVarIntNum(leaf.offset)
         let flags = 0
-        if (leaf?.duplicate) {
+        if (leaf?.duplicate === true) {
           flags |= 1
         }
-        if (leaf?.txid) {
+        if (leaf?.txid !== undefined && leaf.txid !== null) {
           flags |= 2
         }
         writer.writeUInt8(flags)
@@ -215,7 +222,11 @@ export default class MerklePath {
 
   //
   private indexOf (txid: string): number {
-    return this.path[0].find((l) => l.hash === txid).offset
+    const leaf = this.path[0].find((l) => l.hash === txid)
+    if (leaf === null || leaf === undefined) {
+      throw new Error(`Transaction ID ${txid} not found in the Merkle Path`)
+    }
+    return leaf.offset
   }
 
   /**
@@ -227,12 +238,19 @@ export default class MerklePath {
    */
   computeRoot (txid?: string): string {
     if (typeof txid !== 'string') {
-      txid = this.path[0].find((leaf) => Boolean(leaf?.hash)).hash
+      const foundLeaf = this.path[0].find((leaf) => Boolean(leaf?.hash))
+      if (foundLeaf === null || foundLeaf === undefined) {
+        throw new Error('No valid leaf found in the Merkle Path')
+      }
+      txid = foundLeaf.hash
     }
     // Find the index of the txid at the lowest level of the Merkle tree
+    if (typeof txid !== 'string') {
+      throw new Error('Transaction ID is undefined')
+    }
     const index = this.indexOf(txid)
     if (typeof index !== 'number') {
-      throw new Error(`This proof does not contain the txid: ${txid}`)
+      throw new Error(`This proof does not contain the txid: ${txid ?? 'undefined'}`)
     }
     // Calculate the root using the index as a way to determine which direction to concatenate.
     const hash = (m: string): string =>
@@ -243,18 +261,19 @@ export default class MerklePath {
     if (this.path.length === 1 && this.path[0].length === 1) return workingHash
 
     for (let height = 0; height < this.path.length; height++) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const leaves = this.path[height]
       const offset = (index >> height) ^ 1
       const leaf = this.findOrComputeLeaf(height, offset)
       if (typeof leaf !== 'object') {
         throw new Error(`Missing hash for index ${index} at height ${height}`)
       }
-      if (leaf.duplicate) {
-        workingHash = hash(workingHash + workingHash)
+      if (leaf.duplicate === true) {
+        workingHash = hash((workingHash ?? '') + (workingHash ?? ''))
       } else if (offset % 2 !== 0) {
-        workingHash = hash(leaf.hash + workingHash)
+        workingHash = hash((leaf.hash ?? '') + (workingHash ?? ''))
       } else {
-        workingHash = hash(workingHash + leaf.hash)
+        workingHash = hash((workingHash ?? '') + (leaf.hash ?? ''))
       }
     }
     return workingHash
@@ -279,7 +298,7 @@ export default class MerklePath {
       (l) => l.offset === offset
     )
 
-    if (leaf) return leaf
+    if (leaf != null) return leaf
 
     if (height === 0) return undefined
 
@@ -287,16 +306,16 @@ export default class MerklePath {
     const l = offset << 1
 
     const leaf0 = this.findOrComputeLeaf(h, l)
-    if (!leaf0 || !leaf0.hash) return undefined
+    if (leaf0 == null || leaf0.hash == null || leaf0.hash === '') return undefined
 
     const leaf1 = this.findOrComputeLeaf(h, l + 1)
-    if (!leaf1) return undefined
+    if (leaf1 == null) return undefined
 
     let workinghash: string
-    if (leaf1.duplicate) {
+    if (leaf1.duplicate === true) {
       workinghash = hash(leaf0.hash + leaf0.hash)
     } else {
-      workinghash = hash(leaf1.hash + leaf0.hash)
+      workinghash = hash((leaf1.hash ?? '') + (leaf0.hash ?? ''))
     }
     leaf = {
       offset,
@@ -345,7 +364,7 @@ export default class MerklePath {
         'You cannot combine paths which do not have the same root.'
       )
     }
-    const combinedPath = []
+    const combinedPath: Array<Array<{ offset: number, hash?: string, txid?: boolean, duplicate?: boolean }>> = []
     for (let h = 0; h < this.path.length; h++) {
       combinedPath.push([])
       for (let l = 0; l < this.path[h].length; l++) {
@@ -353,18 +372,20 @@ export default class MerklePath {
       }
       for (let l = 0; l < other.path[h].length; l++) {
         if (
-          !(combinedPath[h].find(
+          combinedPath[h].find(
             (leaf) => leaf.offset === other.path[h][l].offset
-          ) as boolean)
+          ) === undefined
         ) {
           combinedPath[h].push(other.path[h][l])
         } else {
           // Ensure that any elements which appear in both are not downgraded to a non txid.
-          if (other.path[h][l]?.txid) {
+          if (other.path[h][l]?.txid !== undefined && other.path[h][l]?.txid !== null) {
             const target = combinedPath[h].find(
               (leaf) => leaf.offset === other.path[h][l].offset
             )
-            target.txid = true
+            if (target !== null && target !== undefined) {
+              target.txid = true
+            }
           }
         }
       }
@@ -378,14 +399,14 @@ export default class MerklePath {
    * Assumes that at least all required nodes are present.
    * Leaves all levels sorted by increasing offset.
    */
-  trim () {
-    const pushIfNew = (v: number, a: number[]) => {
+  trim (): void {
+    const pushIfNew = (v: number, a: number[]): void => {
       if (a.length === 0 || a.slice(-1)[0] !== v) {
         a.push(v)
       }
     }
 
-    const dropOffsetsFromLevel = (dropOffsets: number[], level: number) => {
+    const dropOffsetsFromLevel = (dropOffsets: number[], level: number): void => {
       for (let i = dropOffsets.length; i >= 0; i--) {
         const l = this.path[level].findIndex(
           (n) => n.offset === dropOffsets[i]
@@ -412,13 +433,13 @@ export default class MerklePath {
     }
     for (let l = 0; l < this.path[0].length; l++) {
       const n = this.path[0][l]
-      if (n.txid) {
+      if (n.txid === true) {
         // level 0 must enable computing level 1 for txid nodes
         pushIfNew(n.offset >> 1, computedOffsets)
       } else {
         const isOdd = n.offset % 2 === 1
         const peer = this.path[0][l + (isOdd ? -1 : 1)]
-        if (!peer.txid) {
+        if (peer.txid === undefined || peer.txid === null || !peer.txid) {
           // drop non-txid level 0 nodes without a txid peer
           pushIfNew(peer.offset, dropOffsets)
         }