@bsv/sdk 1.3.12 → 1.3.14

package/src/transaction/BeefParty.ts

@@ -23,54 +23,62 @@ import { Beef } from './Beef.js'
  */
 export class BeefParty extends Beef {
   /**
-     * keys are party identifiers.
-     * values are records of txids with truthy value for which the party already has validity proof.
-     */
+   * keys are party identifiers.
+   * values are records of txids with truthy value for which the party already has validity proof.
+   */
   knownTo: Record<string, Record<string, boolean>> = {}
 
   /**
-     *
-     * @param parties Optional array of initial unique party identifiers.
-     */
+   *
+   * @param parties Optional array of initial unique party identifiers.
+   */
   constructor (parties?: string[]) {
     super()
-    if (parties) {
-      for (const party of parties) { this.addParty(party) }
+    if (parties != null) {
+      for (const party of parties) {
+        this.addParty(party)
+      }
     }
   }
 
   /**
-     * @param party
-     * @returns `true` if `party` has already been added to this `BeefParty`.
-     */
-  isParty (party: string) {
+   * @param party
+   * @returns `true` if `party` has already been added to this `BeefParty`.
+   */
+  isParty (party: string): boolean {
     const r = Object.keys(this.knownTo).includes(party)
     return r
   }
 
   /**
-     * Adds a new unique party identifier to this `BeefParty`.
-     * @param party
-     */
-  addParty (party: string) {
-    if (this.isParty(party)) { throw new Error(`Party ${party} already exists.`) }
+   * Adds a new unique party identifier to this `BeefParty`.
+   * @param party
+   */
+  addParty (party: string): void {
+    if (this.isParty(party)) {
+      throw new Error(`Party ${party} already exists.`)
+    }
     this.knownTo[party] = {}
   }
 
   /**
-     * @param party
-     * @returns Array of txids "known" to `party`.
-     */
+   * @param party
+   * @returns Array of txids "known" to `party`.
+   */
   getKnownTxidsForParty (party: string): string[] {
     const knownTxids = this.knownTo[party]
-    if (!knownTxids) { throw new Error(`Party ${party} is unknown.`) }
+
+    if (knownTxids === undefined) { // ✅ Explicitly check for undefined
+      throw new Error(`Party ${party} is unknown.`)
+    }
+
     return Object.keys(knownTxids)
   }
 
   /**
-     * @param party
-     * @returns trimmed beef of unknown transactions and proofs for `party`
-     */
+   * @param party
+   * @returns trimmed beef of unknown transactions and proofs for `party`
+   */
   getTrimmedBeefForParty (party: string): Beef {
     const knownTxids = this.getKnownTxidsForParty(party)
     const prunedBeef = this.clone()
@@ -79,12 +87,14 @@ export class BeefParty extends Beef {
   }
 
   /**
-     * Make note of additional txids "known" to `party`.
-     * @param party unique identifier, added if new.
-     * @param knownTxids
-     */
-  addKnownTxidsForParty (party: string, knownTxids: string[]) {
-    if (!this.isParty(party)) { this.addParty(party) }
+   * Make note of additional txids "known" to `party`.
+   * @param party unique identifier, added if new.
+   * @param knownTxids
+   */
+  addKnownTxidsForParty (party: string, knownTxids: string[]): void {
+    if (!this.isParty(party)) {
+      this.addParty(party)
+    }
     const kts = this.knownTo[party]
     for (const txid of knownTxids) {
       kts[txid] = true
@@ -102,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

@@ -25,7 +25,9 @@ export default class BeefTx {
    */
   isValid?: boolean = undefined
 
-  get bumpIndex (): number | undefined { return this._bumpIndex }
+  get bumpIndex (): number | undefined {
+    return this._bumpIndex
+  }
 
   set bumpIndex (v: number | undefined) {
     this._bumpIndex = v
@@ -37,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
     }
@@ -72,9 +74,9 @@ 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.
-     */
+   * @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) {
     if (typeof tx === 'string') {
       this._txid = tx
@@ -99,37 +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 = {}
-      for (const input of this.tx.inputs) { inputTxids[input.sourceTXID] = true }
+      const inputTxids: Record<string, boolean> = {} // ✅ Explicit object type
+      for (const input of this.tx.inputs) {
+        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 {
@@ -175,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

@@ -44,22 +44,26 @@ export interface BroadcastFailure {
  *                                  The promise resolves to an array of broadcast result response objects.
  */
 export interface Broadcaster {
-  broadcast: (transaction: Transaction) =>
-  Promise<BroadcastResponse | BroadcastFailure>
-  broadcastMany?: (txs: Transaction[]) =>
-  Promise<object[]>
+  broadcast: (
+    transaction: Transaction
+  ) => Promise<BroadcastResponse | BroadcastFailure>
+  broadcastMany?: (txs: Transaction[]) => Promise<object[]>
 }
 
 /**
  * Convenience type guard for response from `Broadcaster.broadcast`
  */
-export function isBroadcastResponse (r: BroadcastResponse | BroadcastFailure): r is BroadcastResponse {
+export function isBroadcastResponse (
+  r: BroadcastResponse | BroadcastFailure
+): r is BroadcastResponse {
   return r.status === 'success'
 }
 
 /**
  * Convenience type guard for response from `Broadcaster.broadcast`
  */
-export function isBroadcastFailure (r: BroadcastResponse | BroadcastFailure): r is BroadcastFailure {
+export function isBroadcastFailure (
+  r: BroadcastResponse | BroadcastFailure
+): r is BroadcastFailure {
   return r.status === 'error'
 }

package/src/transaction/ChainTracker.ts

@@ -18,8 +18,8 @@
  *     // Implementation to check if the Merkle root is valid for the specified block height.
  *   }
  *  currentHeight: async () => {
-*     // Implementation to get the current block height.
-*   }
+ *     // Implementation to get the current block height.
+ *   }
  * };
  */
 export default interface ChainTracker {

package/src/transaction/FeeModel.ts

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

package/src/transaction/MerklePath.ts

@@ -1,3 +1,4 @@
+
 import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
 import { hash256 } from '../primitives/Hash.js'
 import ChainTracker from './ChainTracker.js'
@@ -32,12 +33,14 @@ export interface MerklePathLeaf {
  */
 export default class MerklePath {
   blockHeight: number
-  path: Array<Array<{
+  path: Array<
+  Array<{
     offset: number
     hash?: string
     txid?: boolean
     duplicate?: boolean
-  }>>
+  }>
+  >
 
   /**
    * Creates a MerklePath instance from a hexadecimal string.
@@ -50,14 +53,20 @@ export default class MerklePath {
     return MerklePath.fromBinary(toArray(hex, 'hex'))
   }
 
-  static fromReader (reader: Reader, legalOffsetsOnly: boolean = true): MerklePath {
+  static fromReader (
+    reader: Reader,
+    legalOffsetsOnly: boolean = true
+  ): MerklePath {
     const blockHeight = reader.readVarIntNum()
     const treeHeight = reader.readUInt8()
-    const path = Array(treeHeight).fill(0).map(() => ([]))
-    let flags, offset, nLeavesAtThisHeight
+    // 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: 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: {
@@ -66,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)
@@ -109,34 +123,48 @@ export default class MerklePath {
     return new MerklePath(height, [[{ offset: 0, hash: txid, txid: true }]])
   }
 
-  constructor (blockHeight: number, path: Array<Array<{
-    offset: number
-    hash?: string
-    txid?: boolean
-    duplicate?: boolean
-  }>>, legalOffsetsOnly: boolean = true) {
+  constructor (
+    blockHeight: number,
+    path: Array<
+    Array<{
+      offset: number
+      hash?: string
+      txid?: boolean
+      duplicate?: boolean
+    }>
+    >,
+    legalOffsetsOnly: boolean = true
+  ) {
     this.blockHeight = blockHeight
     this.path = path
 
     // store all of the legal offsets which we expect given the txid indices.
-    const legalOffsets = Array(this.path.length).fill(0).map(() => new Set())
-    this.path.map((leaves, height) => {
+    const legalOffsets = Array(this.path.length)
+      .fill(0)
+      .map(() => new Set())
+    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 => {
-        if (offsetsAtThisHeight.has(leaf.offset)) throw new Error(`Duplicate offset: ${leaf.offset}, at height: ${height}`)
+      leaves.forEach((leaf) => {
+        if (offsetsAtThisHeight.has(leaf.offset)) {
+          throw new Error(
+            `Duplicate offset: ${leaf.offset}, at height: ${height}`
+          )
+        }
         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)
+              legalOffsets[h].add((leaf.offset >> h) ^ 1)
             }
           }
         } else {
           if (legalOffsetsOnly && !legalOffsets[height].has(leaf.offset)) {
-            throw new Error(`Invalid offset: ${leaf.offset}, at height: ${height}, with legal offsets: ${Array.from(legalOffsets[height]).join(', ')}`)
+            throw new Error(
+              `Invalid offset: ${leaf.offset}, at height: ${height}, with legal offsets: ${Array.from(legalOffsets[height]).join(', ')}`
+            )
           }
         }
       })
@@ -144,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')
@@ -168,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)
@@ -194,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
   }
 
   /**
@@ -206,35 +238,42 @@ 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 => toHex((
-      hash256(toArray(m, 'hex').reverse())
-    ).reverse())
+    const hash = (m: string): string =>
+      toHex(hash256(toArray(m, 'hex').reverse()).reverse())
     let workingHash = txid
 
     // special case for blocks with only one transaction
     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 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
@@ -248,14 +287,18 @@ export default class MerklePath {
    * @param height
    * @param offset
    */
-  findOrComputeLeaf (height: number, offset: number): MerklePathLeaf | undefined {
-    const hash = (m: string): string => toHex((
-      hash256(toArray(m, 'hex').reverse())
-    ).reverse())
+  findOrComputeLeaf (
+    height: number,
+    offset: number
+  ): MerklePathLeaf | undefined {
+    const hash = (m: string): string =>
+      toHex(hash256(toArray(m, 'hex').reverse()).reverse())
 
-    let leaf: MerklePathLeaf | undefined = this.path[height].find(l => l.offset === offset)
+    let leaf: MerklePathLeaf | undefined = this.path[height].find(
+      (l) => l.offset === offset
+    )
 
-    if (leaf) return leaf
+    if (leaf != null) return leaf
 
     if (height === 0) return undefined
 
@@ -263,13 +306,17 @@ 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) { workinghash = hash(leaf0.hash + leaf0.hash) } else { workinghash = hash(leaf1.hash + leaf0.hash) }
+    if (leaf1.duplicate === true) {
+      workinghash = hash(leaf0.hash + leaf0.hash)
+    } else {
+      workinghash = hash((leaf1.hash ?? '') + (leaf0.hash ?? ''))
+    }
     leaf = {
       offset,
       hash: workinghash
@@ -306,27 +353,39 @@ export default class MerklePath {
    */
   combine (other: MerklePath): void {
     if (this.blockHeight !== other.blockHeight) {
-      throw new Error('You cannot combine paths which do not have the same block height.')
+      throw new Error(
+        'You cannot combine paths which do not have the same block height.'
+      )
     }
     const root1 = this.computeRoot()
     const root2 = other.computeRoot()
     if (root1 !== root2) {
-      throw new Error('You cannot combine paths which do not have the same root.')
+      throw new Error(
+        '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++) {
         combinedPath[h].push(this.path[h][l])
       }
       for (let l = 0; l < other.path[h].length; l++) {
-        if (!(combinedPath[h].find(leaf => leaf.offset === other.path[h][l].offset) as boolean)) {
+        if (
+          combinedPath[h].find(
+            (leaf) => leaf.offset === other.path[h][l].offset
+          ) === 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) {
-            const target = combinedPath[h].find(leaf => leaf.offset === other.path[h][l].offset)
-            target.txid = true
+          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
+            )
+            if (target !== null && target !== undefined) {
+              target.txid = true
+            }
           }
         }
       }
@@ -340,15 +399,21 @@ 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[]) => {
-      if (a.length === 0 || a.slice(-1)[0] !== v) { a.push(v) }
+  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])
-        if (l >= 0) { this.path[level].splice(l, 1) }
+        const l = this.path[level].findIndex(
+          (n) => n.offset === dropOffsets[i]
+        )
+        if (l >= 0) {
+          this.path[level].splice(l, 1)
+        }
       }
     }
 
@@ -368,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)
         }