@bsv/sdk 1.2.17 → 1.2.19

package/src/transaction/BeefTx.ts

@@ -1,7 +1,7 @@
 import { hash256 } from '../primitives/Hash.js'
 import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
 import Transaction from './Transaction.js'
-import { BEEF_MAGIC, BEEF_MAGIC_TXID_ONLY_EXTENSION } from './Beef.js'
+import { BEEF_V2, TX_DATA_FORMAT } from './Beef.js'
 
 /**
  * A single bitcoin transaction associated with a `Beef` validity proof set.
@@ -42,20 +42,32 @@ export default class BeefTx {
 
   get txid () {
     if (this._txid) return this._txid
-    if (this._tx) return this._txid = this._tx.id('hex')
-    if (this._rawTx) return this._txid = toHex(hash256(this._rawTx))
+    if (this._tx) {
+      this._txid = this._tx.id('hex')
+      return this._txid
+    }
+    if (this._rawTx) {
+      this._txid = toHex(hash256(this._rawTx))
+      return this._txid
+    }
     throw new Error('Internal')
   }
 
   get tx () {
     if (this._tx) return this._tx
-    if (this._rawTx) return this._tx = Transaction.fromBinary(this._rawTx)
+    if (this._rawTx) {
+      this._tx = Transaction.fromBinary(this._rawTx)
+      return this._tx
+    }
     return undefined
   }
 
   get rawTx () {
     if (this._rawTx) return this._rawTx
-    if (this._tx) return this._rawTx = this._tx.toBinary()
+    if (this._tx) {
+      this._rawTx = this._tx.toBinary()
+      return this._rawTx
+    }
     return undefined
   }
 
@@ -66,87 +78,107 @@ export default class BeefTx {
   constructor (tx: Transaction | number[] | string, bumpIndex?: number) {
     if (typeof tx === 'string') {
       this._txid = tx
+    } else if (Array.isArray(tx)) {
+      this._rawTx = tx
     } else {
-      if (Array.isArray(tx)) {
-        this._rawTx = tx
-      } else {
-        this._tx = tx
-      }
+      this._tx = tx
     }
     this.bumpIndex = bumpIndex
     this.updateInputTxids()
   }
 
+  static fromTx (tx: Transaction, bumpIndex?: number): BeefTx {
+    return new BeefTx(tx, bumpIndex)
+  }
+
+  static fromRawTx (rawTx: number[], bumpIndex?: number): BeefTx {
+    return new BeefTx(rawTx, bumpIndex)
+  }
+
+  static fromTxid (txid: string, bumpIndex?: number): BeefTx {
+    return new BeefTx(txid, bumpIndex)
+  }
+
   private updateInputTxids () {
-    if (this.hasProof || !this.tx)
-    // If we have a proof, or don't have a parsed transaction
-    { this.inputTxids = [] } else {
+    if (this.hasProof || !this.tx) {
+      // 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 }
       this.inputTxids = Object.keys(inputTxids)
     }
   }
 
-  toWriter (writer: Writer, magic: number): void {
-    if (magic === BEEF_MAGIC) {
-      // V1
-      if (this.isTxidOnly) {
-        // Encode just the txid of a known transaction using the txid
-        writer.writeUInt32LE(BEEF_MAGIC_TXID_ONLY_EXTENSION)
-        writer.writeReverse(toArray(this._txid, 'hex'))
-      } else if (this._rawTx) { writer.write(this._rawTx) } else if (this._tx) { writer.write(this._tx.toBinary()) } else { throw new Error('a valid serialized Transaction is expected') }
+  toWriter (writer: Writer, version: number): void {
+    const writeByte = (bb: number) => {
+      writer.writeUInt8(bb)
+    }
+
+    const writeTxid = () => {
+      writer.writeReverse(toArray(this._txid, 'hex'))
+    }
+
+    const writeTx = () => {
+      if (this._rawTx) {
+        writer.write(this._rawTx)
+      } else if (this._tx) {
+        writer.write(this._tx.toBinary())
+      } else {
+        throw new Error('a valid serialized Transaction is expected')
+      }
+    }
+
+    const writeBumpIndex = () => {
       if (this.bumpIndex === undefined) {
-        writer.writeUInt8(0)
+        writeByte(TX_DATA_FORMAT.RAWTX) // 0
       } else {
-        writer.writeUInt8(1)
-        writer.writeVarIntNum(this.bumpIndex)
+        writeByte(TX_DATA_FORMAT.RAWTX_AND_BUMP_INDEX) // 1
+        writer.writeVarIntNum(this.bumpIndex) // the index of the associated bump
       }
-    } else {
-      // V2
+    }
+
+    if (version === BEEF_V2) {
       if (this.isTxidOnly) {
-        // Encode just the txid of a known transaction using the txid
-        writer.writeUInt8(2)
-        writer.writeReverse(toArray(this._txid, 'hex'))
+        writeByte(TX_DATA_FORMAT.TXID_ONLY)
+        writeTxid()
+      } else if (this.bumpIndex !== undefined) {
+        writeByte(TX_DATA_FORMAT.RAWTX_AND_BUMP_INDEX)
+        writer.writeVarIntNum(this.bumpIndex)
+        writeTx()
       } else {
-        if (this.bumpIndex === undefined) {
-          writer.writeUInt8(0)
-        } else {
-          writer.writeUInt8(1)
-          writer.writeVarIntNum(this.bumpIndex)
-        }
-        if (this._rawTx) { writer.write(this._rawTx) } else if (this._tx) { writer.write(this._tx.toBinary()) } else { throw new Error('a valid serialized Transaction is expected') }
+        writeByte(TX_DATA_FORMAT.RAWTX)
+        writeTx()
       }
+    } else {
+      writeTx()
+      writeBumpIndex()
     }
   }
 
-  static fromReader (br: Reader, magic: number): BeefTx {
-    let tx: Transaction | number[] | string | undefined
+  static fromReader (br: Reader, version: number): BeefTx {
+    let data: Transaction | number[] | string | undefined
     let bumpIndex: number | undefined
-
-    if (magic === BEEF_MAGIC) {
-      // V1
-      const version = br.readUInt32LE()
-      if (version === BEEF_MAGIC_TXID_ONLY_EXTENSION) {
-        // This is the extension to support known transactions
-        tx = toHex(br.readReverse(32))
-      } else {
-        br.pos -= 4 // Unread the version...
-        tx = Transaction.fromReader(br)
-      }
-      bumpIndex = br.readUInt8() ? br.readVarIntNum() : undefined
-    } else {
+    let beefTx: BeefTx | undefined
+    if (version === BEEF_V2) {
       // V2
       const format = br.readUInt8()
-      if (format === 2) {
-        // txid only
-        tx = toHex(br.readReverse(32))
+      if (format === TX_DATA_FORMAT.TXID_ONLY) {
+        beefTx = BeefTx.fromTxid(toHex(br.readReverse(32)))
       } else {
-        if (format === 1) { bumpIndex = br.readVarIntNum() }
-        tx = Transaction.fromReader(br)
+        if (format === TX_DATA_FORMAT.RAWTX_AND_BUMP_INDEX) {
+          bumpIndex = br.readVarIntNum()
+        }
+        data = Transaction.fromReader(br)
+        beefTx = BeefTx.fromTx(data, bumpIndex)
       }
+    } else {
+      // V1
+      data = Transaction.fromReader(br)
+      bumpIndex = br.readUInt8() ? br.readVarIntNum() : undefined
+      beefTx = BeefTx.fromTx(data, bumpIndex)
     }
 
-    const beefTx = new BeefTx(tx, bumpIndex)
     return beefTx
   }
 }

package/src/transaction/ChainTracker.ts

@@ -10,13 +10,19 @@
  * @function isValidRootForHeight - A method to verify the validity of a Merkle root
  *          for a given block height.
  *
+ * @function currentHeight - A method to get the current block height.
+ *
  * @example
  * const chainTracker = {
  *   isValidRootForHeight: async (root, height) => {
  *     // Implementation to check if the Merkle root is valid for the specified block height.
  *   }
+ *  currentHeight: async () => {
+*     // Implementation to get the current block height.
+*   }
  * };
  */
 export default interface ChainTracker {
   isValidRootForHeight: (root: string, height: number) => Promise<boolean>
+  currentHeight: () => Promise<number>
 }

package/src/transaction/MerklePath.ts

@@ -192,6 +192,11 @@ export default class MerklePath {
     return toHex(this.toBinary())
   }
 
+  //
+  private indexOf (txid: string): number {
+    return this.path[0].find(l => l.hash === txid).offset
+  }
+
   /**
    * Computes the Merkle root from the provided transaction ID.
    *
@@ -204,7 +209,7 @@ export default class MerklePath {
       txid = this.path[0].find(leaf => Boolean(leaf?.hash)).hash
     }
     // Find the index of the txid at the lowest level of the Merkle tree
-    const index = this.path[0].find(l => l.hash === txid).offset
+    const index = this.indexOf(txid)
     if (typeof index !== 'number') {
       throw new Error(`This proof does not contain the txid: ${txid}`)
     }
@@ -282,6 +287,13 @@ export default class MerklePath {
    */
   async verify (txid: string, chainTracker: ChainTracker): Promise<boolean> {
     const root = this.computeRoot(txid)
+    if (this.indexOf(txid) === 0) {
+      // Coinbase transaction outputs can only be spent once they're 100 blocks deep.
+      const height = await chainTracker.currentHeight()
+      if (this.blockHeight + 100 < height) {
+        return false
+      }
+    }
     // Use the chain tracker to determine whether this is a valid merkle root at the given block height
     return await chainTracker.isValidRootForHeight(root, this.blockHeight)
   }

package/src/transaction/Transaction.ts

@@ -12,7 +12,7 @@ import Spend from '../script/Spend.js'
 import ChainTracker from './ChainTracker.js'
 import { defaultBroadcaster } from './broadcasters/DefaultBroadcaster.js'
 import { defaultChainTracker } from './chaintrackers/DefaultChainTracker.js'
-import { ATOMIC_BEEF, BEEF_MAGIC } from './Beef.js'
+import { ATOMIC_BEEF, BEEF_V1 } from './Beef.js'
 import P2PKH from '../script/templates/P2PKH.js'
 
 /**
@@ -59,6 +59,29 @@ export default class Transaction {
   merklePath?: MerklePath
   private cachedHash?: number[]
 
+  // Recursive function for adding merkle proofs or input transactions
+  private static addPathOrInputs (obj: { pathIndex?: number, tx: Transaction }, transactions: Record<string, {
+    pathIndex?: number
+    tx: Transaction
+  }>, BUMPs: MerklePath[]): void {
+    if (typeof obj.pathIndex === 'number') {
+      const path = BUMPs[obj.pathIndex]
+      if (typeof path !== 'object') {
+        throw new Error('Invalid merkle path index found in BEEF!')
+      }
+      obj.tx.merklePath = path
+    } else {
+      for (const input of obj.tx.inputs) {
+        const sourceObj = transactions[input.sourceTXID]
+        if (typeof sourceObj !== 'object') {
+          throw new Error(`Reference to unknown TXID in BEEF: ${input.sourceTXID}`)
+        }
+        input.sourceTransaction = sourceObj.tx
+        this.addPathOrInputs(sourceObj, transactions, BUMPs)
+      }
+    }
+  }
+
   /**
    * Creates a new transaction, linked to its inputs and their associated merkle paths, from a BEEF (BRC-62) structure.
    * Optionally, you can provide a specific TXID to retrieve a particular transaction from the BEEF data.
@@ -81,28 +104,7 @@ export default class Transaction {
       throw new Error(`Transaction with TXID ${targetTXID} not found in BEEF data.`)
     }
 
-    // Recursive function for adding merkle proofs or input transactions
-    const addPathOrInputs = (obj: { pathIndex?: number, tx: Transaction }): void => {
-      if (typeof obj.pathIndex === 'number') {
-        const path = BUMPs[obj.pathIndex]
-        if (typeof path !== 'object') {
-          throw new Error('Invalid merkle path index found in BEEF!')
-        }
-        obj.tx.merklePath = path
-      } else {
-        for (let i = 0; i < obj.tx.inputs.length; i++) {
-          const input = obj.tx.inputs[i]
-          const sourceObj = transactions[input.sourceTXID]
-          if (typeof sourceObj !== 'object') {
-            throw new Error(`Reference to unknown TXID in BEEF: ${input.sourceTXID}`)
-          }
-          input.sourceTransaction = sourceObj.tx
-          addPathOrInputs(sourceObj)
-        }
-      }
-    }
-
-    addPathOrInputs(transactions[targetTXID])
+    this.addPathOrInputs(transactions[targetTXID], transactions, BUMPs)
 
     return transactions[targetTXID].tx
   }
@@ -172,28 +174,7 @@ export default class Transaction {
       throw new Error(`Unrelated transaction with TXID ${txid} found in Atomic BEEF data.`)
     }
 
-    // Build the transaction by linking inputs and merkle paths
-    const addPathOrInputs = (obj: { pathIndex?: number, tx: Transaction }): void => {
-      if (typeof obj.pathIndex === 'number') {
-        const path = BUMPs[obj.pathIndex]
-        if (typeof path !== 'object') {
-          throw new Error('Invalid merkle path index found in BEEF!')
-        }
-        obj.tx.merklePath = path
-      } else {
-        for (let i = 0; i < obj.tx.inputs.length; i++) {
-          const input = obj.tx.inputs[i]
-          const sourceObj = transactions[input.sourceTXID]
-          if (typeof sourceObj !== 'object') {
-            throw new Error(`Reference to unknown TXID in BEEF: ${input.sourceTXID}`)
-          }
-          input.sourceTransaction = sourceObj.tx
-          addPathOrInputs(sourceObj)
-        }
-      }
-    }
-
-    addPathOrInputs(transactions[subjectTXID])
+    this.addPathOrInputs(transactions[subjectTXID], transactions, BUMPs)
 
     return transactions[subjectTXID].tx
   }
@@ -207,8 +188,8 @@ export default class Transaction {
   private static parseBEEFData (reader: Reader): { transactions: Record<string, { pathIndex?: number, tx: Transaction }>, BUMPs: MerklePath[] } {
     // Read the version
     const version = reader.readUInt32LE()
-    if (version !== BEEF_MAGIC) {
-      throw new Error(`Invalid BEEF version. Expected ${BEEF_MAGIC}, received ${version}.`)
+    if (version !== BEEF_V1) {
+      throw new Error(`Invalid BEEF version. Expected ${BEEF_V1}, received ${version}.`)
     }
 
     // Read the BUMPs
@@ -511,7 +492,15 @@ export default class Transaction {
       }
     }
     const fee = await modelOrFee.computeFee(this)
-    // change = inputs - fee - non-change outputs
+    const change = this.calculateChange(fee)
+    if (change <= 0) {
+      this.outputs = this.outputs.filter(output => !output.change)
+      return
+    }
+    this.distributeChange(change, changeDistribution)
+  }
+
+  private calculateChange (fee: number): number {
     let change = 0
     for (const input of this.inputs) {
       if (typeof input.sourceTransaction !== 'object') {
@@ -520,71 +509,60 @@ export default class Transaction {
       change += input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis
     }
     change -= fee
-    let changeCount = 0
     for (const out of this.outputs) {
       if (!out.change) {
         change -= out.satoshis
-      } else {
-        changeCount++
-      }
-    }
-
-    if (change <= changeCount) {
-      // There is not enough change to distribute among the change outputs.
-      // We'll remove all change outputs and leave the extra for the miners.
-      for (let i = 0; i < this.outputs.length; i++) {
-        if (this.outputs[i].change) {
-          this.outputs.splice(i, 1)
-          i--
-        }
       }
-      return
     }
+    return change
+  }
 
-    // Distribute change among change outputs
+  private distributeChange (change: number, changeDistribution: 'equal' | 'random'): void {
     let distributedChange = 0
+    const changeOutputs = this.outputs.filter(out => out.change)
     if (changeDistribution === 'random') {
-      // Implement Benford's Law distribution for change outputs
-      const changeOutputs = this.outputs.filter(out => out.change)
-      let changeToUse = change
-
-      // Helper function to generate a number approximating Benford's Law
-      const benfordNumber = (min: number, max: number): number => {
-        const d = Math.floor(Math.random() * 9) + 1
-        return Math.floor(min + (max - min) * Math.log10(1 + 1 / d) / Math.log10(10))
-      }
-
-      const benfordNumbers = Array(changeOutputs.length).fill(1)
-      changeToUse -= changeOutputs.length
-      distributedChange += changeOutputs.length
-      for (let i = 0; i < changeOutputs.length - 1; i++) {
-        const portion = benfordNumber(0, changeToUse)
-        benfordNumbers[i] += portion
-        distributedChange += portion
-        changeToUse -= portion
-      }
-
-      for (let i = 0; i < this.outputs.length; i++) {
-        if (this.outputs[i].change) {
-          const t = benfordNumbers.shift()
-          this.outputs[i].satoshis = t
-        }
-      }
+      distributedChange = this.distributeRandomChange(change, changeOutputs)
     } else if (changeDistribution === 'equal') {
-      const perOutput = Math.floor(change / changeCount)
-      for (const out of this.outputs) {
-        if (out.change) {
-          distributedChange += perOutput
-          out.satoshis = perOutput
-        }
-      }
+      distributedChange = this.distributeEqualChange(change, changeOutputs)
     }
-    // if there's any remaining change, add it to the last output
     if (distributedChange < change) {
       this.outputs[this.outputs.length - 1].satoshis += (change - distributedChange)
     }
   }
 
+  private distributeRandomChange (change: number, changeOutputs: TransactionOutput[]): number {
+    let distributedChange = 0
+    let changeToUse = change
+    const benfordNumbers = Array(changeOutputs.length).fill(1)
+    changeToUse -= changeOutputs.length
+    distributedChange += changeOutputs.length
+    for (let i = 0; i < changeOutputs.length - 1; i++) {
+      const portion = this.benfordNumber(0, changeToUse)
+      benfordNumbers[i] += portion
+      distributedChange += portion
+      changeToUse -= portion
+    }
+    for (const output of this.outputs) {
+      if (output.change) output.satoshis = benfordNumbers.shift()
+    }
+    return distributedChange
+  }
+
+  private distributeEqualChange (change: number, changeOutputs: TransactionOutput[]): number {
+    let distributedChange = 0
+    const perOutput = Math.floor(change / changeOutputs.length)
+    for (const out of changeOutputs) {
+      distributedChange += perOutput
+      out.satoshis = perOutput
+    }
+    return distributedChange
+  }
+
+  private benfordNumber (min: number, max: number): number {
+    const d = Math.floor(Math.random() * 9) + 1
+    return Math.floor(min + (max - min) * Math.log10(1 + 1 / d) / Math.log10(10))
+  }
+
   /**
    * Utility method that returns the current fee based on inputs and outputs
    *
@@ -923,9 +901,8 @@ export default class Transaction {
    * @throws Error if there are any missing sourceTransactions unless `allowPartial` is true.
    */
   toBEEF (allowPartial?: boolean): number[] {
-    this.outputs.length
     const writer = new Writer()
-    writer.writeUInt32LE(4022206465)
+    writer.writeUInt32LE(BEEF_V1)
     const BUMPs: MerklePath[] = []
     const txs: Array<{ tx: Transaction, pathIndex?: number }> = []
 

package/src/transaction/__tests/Beef.test.ts

@@ -1,8 +1,7 @@
 // The following imports allow flag a large number type checking errors by the VsCode editor due to missing type information:
 import BeefTx from "../../../dist/cjs/src/transaction/BeefTx"
-import Beef from "../../../dist/cjs/src/transaction/Beef"
 import BeefParty from "../../../dist/cjs/src/transaction/BeefParty"
-import { BEEF_MAGIC, BEEF_MAGIC_V2 } from "../../../dist/cjs/src/transaction/Beef"
+import Beef, { BEEF_V1, BEEF_V2 } from "../../../dist/cjs/src/transaction/Beef"
 import Transaction from "../../../dist/cjs/src/transaction/Transaction"
 import { fromBase58 } from '../../../dist/cjs/src/primitives/utils'
 
@@ -11,7 +10,7 @@ import { fromBase58 } from '../../../dist/cjs/src/primitives/utils'
 import BeefTx from '../BeefTx'
 import Beef from '../Beef'
 import BeefParty from "../BeefParty"
-import { BEEF_MAGIC, BEEF_MAGIC_V2 } from "../Beef"
+import { BEEF_V1, BEEF_V2 } from "../Beef"
 import Transaction from "../Transaction"
 import { fromBase58 } from "../../primitives/utils"
 */
@@ -23,6 +22,7 @@ describe('Beef tests', () => {
       isValidRootForHeight: async (root: string, height: number) => {
         switch (height) {
           case 1631619: return root === "b3975a6b69b5ce7fa200649d879f79a11f4d95c054cfe024570be7d60306ecf6"
+          case 875732: return root === "a19c54129ab996c72cda7721b4555b47d11b21e1fe67aa63c59843edb302b6c2"
           default: throw new Error(`unknown height ${height}`)
         }
       }
@@ -101,7 +101,7 @@ describe('Beef tests', () => {
         {
           const version = 4290641921
           expect(() => Beef.fromString(beefs[1]))
-          .toThrow(`Serialized BEEF must start with ${BEEF_MAGIC} or ${BEEF_MAGIC_V2} but starts with ${version}`)
+          .toThrow(`Serialized BEEF must start with ${BEEF_V1} or ${BEEF_V2} but starts with ${version}`)
         }
     })
 
@@ -262,7 +262,7 @@ describe('Beef tests', () => {
       {
         const beef = Beef.fromString(beefs[0])
         expect(beef.toHex()).toBe(beefs[0])
-        const sr = beef.sortTxs()
+        beef.sortTxs()
         const beefHex = beef.toHex()
         const tx = beef.txs[beef.txs.length - 1].tx!
         expect(tx).toBeTruthy()
@@ -284,7 +284,7 @@ describe('Beef tests', () => {
         const beef = Beef.fromString(beefs[0])
         expect(beef.toHex()).toBe(beefs[0])
         beef.mergeTransaction(Transaction.fromHex(txs[0]))
-        const sr = beef.sortTxs()
+        beef.sortTxs()
         const beefHex = beef.toHex()
         const tx = beef.txs[beef.txs.length - 1].tx!
         expect(tx).toBeTruthy()
@@ -301,8 +301,8 @@ describe('Beef tests', () => {
         const beef = Beef.fromString(beefs[0])
         const tx = Transaction.fromHex(txs[0])
         beef.mergeTransaction(tx)
-        const sr = beef.sortTxs()
-        const log = beef.toLogString()
+        beef.sortTxs()
+        beef.toLogString()
         const atomic = beef.toBinaryAtomic(tx.id('hex'))
         const t2 = Transaction.fromAtomicBEEF(atomic)
         const beef2 = t2.toAtomicBEEF()
@@ -321,7 +321,7 @@ describe('Beef tests', () => {
       {
         const beef = new Beef()
         const atx = beef.mergeTxidOnly('a')
-        const btx = beef.mergeTxidOnly('b')
+        beef.mergeTxidOnly('b')
         atx.inputTxids = ['b']
         beef.sortTxs()
         expect(beef.txs[1].txid).toBe('a')

package/src/transaction/__tests/MerklePath.test.ts

@@ -1,4 +1,5 @@
-import MerklePath from '../../../dist/cjs/src/transaction/MerklePath'
+import ChainTracker from '../ChainTracker'
+import MerklePath from '../../../dist/cjs/src/transaction/MerklePath.js'
 import invalidBumps from './bump.invalid.vectors'
 import validBumps from './bump.valid.vectors'
 
@@ -111,6 +112,15 @@ const BRC74TXID1 = '304e737fdfcb017a1a322e78b067ecebb5e07b44f0a36ed1f01264d2014f
 const BRC74TXID2 = 'd888711d588021e588984e8278a2decf927298173a06737066e43f3e75534e00'
 const BRC74TXID3 = '98c9c5dd79a18f40837061d5e0395ffb52e700a2689e641d19f053fc9619445e'
 
+class FakeChainTracker implements ChainTracker {
+  async isValidRootForHeight (root: string, height: number): Promise<boolean> {
+    return root === 'd5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02' && height === 10000
+  }
+  async currentHeight (): Promise<number> {
+    return 10100
+  }
+}
+
 describe('MerklePath', () => {
   it('Parses from hex', () => {
     const path = MerklePath.fromHex(BRC74Hex)
@@ -129,7 +139,8 @@ describe('MerklePath', () => {
   it('Verifies using a ChainTracker', async () => {
     const path = new MerklePath(BRC74JSON.blockHeight, BRC74JSON.path)
     const tracker = {
-      isValidRootForHeight: jest.fn((root, height) => root === BRC74Root && height === BRC74JSON.blockHeight)
+      isValidRootForHeight: jest.fn(async (root, height) => root === BRC74Root && height === BRC74JSON.blockHeight),
+      currentHeight: jest.fn(async () => 2029209)
     }
     const result = await path.verify(BRC74TXID1, tracker)
     expect(result).toBe(true)
@@ -192,4 +203,14 @@ describe('MerklePath', () => {
   it('Creates a valid MerklePath from a txid', () => {
     expect(() => MerklePath.fromCoinbaseTxidAndHeight('d5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02', 1)).not.toThrowError()
   })
+  it('Valid for Coinbase if currentHeight is more than 100 blocks prior', async () => {
+    const mp = MerklePath.fromCoinbaseTxidAndHeight('d5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02', 10000)
+    const isValid = await mp.verify('d5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02', new FakeChainTracker())
+    expect(isValid).toBe(true)
+  })
+  it('Invalid for Coinbase if currentheight is less than 100 blocks prior ', async () => {
+    const mp = MerklePath.fromCoinbaseTxidAndHeight('d5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02', 10099)
+    const isValid = await mp.verify('d5377a7aba0c0e0dbaef230f8917217b453484c83579e11a14c8299faa57ef02', new FakeChainTracker())
+    expect(isValid).toBe(false)
+  })
 })

package/src/transaction/__tests/Transaction.benchmarks.test.ts

@@ -20,7 +20,7 @@ async function measureTime(fn: () => Promise<void>): Promise<number> {
 describe('Transaction Verification Benchmark', () => {
     const privateKey = new PrivateKey(1)
     const publicKey = privateKey.toPublicKey()
-    const publicKeyHash = hash160(publicKey.toDER())
+    const publicKeyHash = publicKey.toHash()
     const p2pkh = new P2PKH()
 
     it('verifies a transaction with a deep input chain', async () => {

package/src/transaction/__tests/Transaction.test.ts

@@ -11,7 +11,7 @@ import Curve from '../../../dist/cjs/src/primitives/Curve'
 import P2PKH from '../../../dist/cjs/src/script/templates/P2PKH'
 import fromUtxo from '../../../dist/cjs/src/compat/Utxo'
 import MerklePath from '../../../dist/cjs/src/transaction/MerklePath'
-import { BEEF_MAGIC } from '../../../dist/cjs/src/transaction/Beef'
+import { BEEF_V1 } from '../../../dist/cjs/src/transaction/Beef'
 
 import sighashVectors from '../../primitives/__tests/sighash.vectors'
 import invalidTransactions from './tx.invalid.vectors'
@@ -817,7 +817,7 @@ describe('Transaction', () => {
       const fakeTXID = toArray('00'.repeat(32), 'hex')
       writer.write(fakeTXID)
       // Write empty BEEF data
-      writer.writeUInt32LE(BEEF_MAGIC) // BEEF version
+      writer.writeUInt32LE(BEEF_V1) // BEEF version
       writer.writeVarIntNum(0) // No BUMPs
       writer.writeVarIntNum(0) // No transactions
 
@@ -890,7 +890,7 @@ describe('Transaction', () => {
 
       // Build BEEF data
       const beefWriter = new Writer()
-      beefWriter.writeUInt32LE(BEEF_MAGIC) // BEEF version
+      beefWriter.writeUInt32LE(BEEF_V1) // BEEF version
       // BUMPs
       beefWriter.writeVarIntNum(2)
       beefWriter.write(sourceTx1.merklePath.toBinary())

package/src/transaction/broadcasters/__tests/WhatsOnChainBroadcaster.test.ts

@@ -46,8 +46,8 @@ describe('WhatsOnChainBroadcaster', () => {
   it('should broadcast successfully using Node.js https', async () => {
     // Mocking Node.js https module
     mockedHttps(successResponse)
-    delete global.window
-
+    global.window = {} as any
+    
     const broadcaster = new WhatsOnChainBroadcaster(network)
     const response = await broadcaster.broadcast(transaction)