@bsv/sdk 1.3.12 → 1.3.14

package/src/transaction/Transaction.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck
 import TransactionInput from './TransactionInput.js'
 import TransactionOutput from './TransactionOutput.js'
 import UnlockingScript from '../script/UnlockingScript.js'
@@ -12,7 +13,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_V1 } from './Beef.js'
+import { Beef, BEEF_V1 } from './Beef.js'
 import P2PKH from '../script/templates/P2PKH.js'
 
 /**
@@ -60,10 +61,17 @@ export default class Transaction {
   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 {
+  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') {
@@ -72,9 +80,14 @@ export default class Transaction {
       obj.tx.merklePath = path
     } else {
       for (const input of obj.tx.inputs) {
+        if (input.sourceTXID === undefined) {
+          throw new Error('Input sourceTXID is undefined')
+        }
         const sourceObj = transactions[input.sourceTXID]
         if (typeof sourceObj !== 'object') {
-          throw new Error(`Reference to unknown TXID in BEEF: ${input.sourceTXID}`)
+          throw new Error(
+            `Reference to unknown TXID in BEEF: ${input.sourceTXID ?? 'undefined'}`
+          )
         }
         input.sourceTransaction = sourceObj.tx
         this.addPathOrInputs(sourceObj, transactions, BUMPs)
@@ -83,138 +96,45 @@ export default class Transaction {
   }
 
   /**
-   * Creates a new transaction, linked to its inputs and their associated merkle paths, from a BEEF (BRC-62) structure.
+   * Creates a new transaction, linked to its inputs and their associated merkle paths, from a BEEF V1, V2 or Atomic.
    * Optionally, you can provide a specific TXID to retrieve a particular transaction from the BEEF data.
    * If the TXID is provided but not found in the BEEF data, an error will be thrown.
-   * If no TXID is provided, the last transaction in the BEEF data is returned.
+   * If no TXID is provided, the last transaction in the BEEF data is returned, or the atomic txid.
    * @param beef A binary representation of transactions in BEEF format.
    * @param txid Optional TXID of the transaction to retrieve from the BEEF data.
    * @returns An anchored transaction, linked to its associated inputs populated with merkle paths.
    */
   static fromBEEF (beef: number[], txid?: string): Transaction {
-    const reader = new Reader(beef)
-    const { transactions, BUMPs } = Transaction.parseBEEFData(reader)
-
-    // The last transaction in the BEEF data can be used if txid is not provided
-    const txids = Object.keys(transactions)
-    const lastTXID = txids[txids.length - 1]
-    const targetTXID = txid || lastTXID
-
-    if (!transactions[targetTXID]) {
-      throw new Error(`Transaction with TXID ${targetTXID} not found in BEEF data.`)
-    }
-
-    this.addPathOrInputs(transactions[targetTXID], transactions, BUMPs)
-
-    return transactions[targetTXID].tx
+    const { tx } = Transaction.fromAnyBeef(beef, txid)
+    return tx
   }
 
   /**
    * Creates a new transaction from an Atomic BEEF (BRC-95) structure.
-   * Extracts the subject transaction and ensures that all transactions within the BEEF data
-   * are part of the dependency graph of the subject transaction.
-   * Throws errors if the Atomic BEEF data does not strictly adhere to the BRC-95 specification.
+   * Extracts the subject transaction and supporting merkle path and source transactions contained in the BEEF data
    *
    * @param beef A binary representation of an Atomic BEEF structure.
    * @returns The subject transaction, linked to its associated inputs populated with merkle paths.
    */
   static fromAtomicBEEF (beef: number[]): Transaction {
-    const reader = new Reader(beef)
-    // Read the Atomic BEEF prefix
-    const prefix = reader.readUInt32LE()
-    if (prefix !== ATOMIC_BEEF) {
-      throw new Error(`Invalid Atomic BEEF prefix. Expected 0x01010101, received 0x${prefix.toString(16)}.`)
-    }
-
-    // Read the subject TXID
-    const subjectTXIDArray = reader.read(32)
-    const subjectTXID = toHex(subjectTXIDArray)
-
-    // The remaining data is the BEEF data
-    const beefReader = new Reader(reader.read())
-    const { transactions, BUMPs } = Transaction.parseBEEFData(beefReader)
-
-    // Ensure that the subject transaction exists
-    if (!transactions[subjectTXID]) {
-      throw new Error(`Subject transaction with TXID ${subjectTXID} not found in Atomic BEEF data.`)
-    }
-
-    // Ensure that all transactions are part of the dependency graph of the subject transaction
-    const validTxids = new Set<string>()
-    // All BUMP level 0 hashes are valid.
-    for (const bump of BUMPs) {
-      for (const n of bump.path[0]) {
-        if (n.hash) { validTxids.add(n.hash) }
-      }
+    const { tx, txid, beef: b } = Transaction.fromAnyBeef(beef)
+    if (txid !== b.atomicTxid) {
+      if (b.atomicTxid) { throw new Error(`Transaction with TXID ${b.atomicTxid} not found in BEEF data.`) } else { throw new Error('beef must conform to BRC-95 and must contain the subject txid.') }
     }
-    // To keep track of which transactions were used.
-    const unusedTxTxids = new Set<string>()
-    for (const txid of Object.keys(transactions)) unusedTxTxids.add(txid)
-
-    const traverseDependencies = (txid: string) => {
-      unusedTxTxids.delete(txid)
-      if (validTxids.has(txid)) {
-        return
-      }
-      validTxids.add(txid)
-      const tx = transactions[txid].tx
-      for (const input of tx.inputs) {
-        const inputTxid = input.sourceTXID
-        if (!transactions[inputTxid]) {
-          throw new Error(`Input transaction with TXID ${inputTxid} is missing in Atomic BEEF data.`)
-        }
-        traverseDependencies(inputTxid)
-      }
-    }
-
-    traverseDependencies(subjectTXID)
-
-    // Check for any unrelated transactions
-    for (const txid of unusedTxTxids) {
-      throw new Error(`Unrelated transaction with TXID ${txid} found in Atomic BEEF data.`)
-    }
-
-    this.addPathOrInputs(transactions[subjectTXID], transactions, BUMPs)
-
-    return transactions[subjectTXID].tx
+    return tx
   }
 
-  /**
-   * Parses BEEF data from a Reader and returns the transactions and BUMPs.
-   *
-   * @param reader The Reader positioned at the start of BEEF data.
-   * @returns An object containing the transactions and BUMPs.
-   */
-  private static parseBEEFData (reader: Reader): { transactions: Record<string, { pathIndex?: number, tx: Transaction }>, BUMPs: MerklePath[] } {
-    // Read the version
-    const version = reader.readUInt32LE()
-    if (version !== BEEF_V1) {
-      throw new Error(`Invalid BEEF version. Expected ${BEEF_V1}, received ${version}.`)
-    }
-
-    // Read the BUMPs
-    const numberOfBUMPs = reader.readVarIntNum()
-    const BUMPs = []
-    for (let i = 0; i < numberOfBUMPs; i++) {
-      BUMPs.push(MerklePath.fromReader(reader))
-    }
-
-    // Read all transactions into an object
-    // The object has keys of TXIDs and values of objects with transactions and BUMP indexes
-    const numberOfTransactions = reader.readVarIntNum()
-    const transactions: Record<string, { pathIndex?: number, tx: Transaction }> = {}
-    for (let i = 0; i < numberOfTransactions; i++) {
-      const tx = Transaction.fromReader(reader)
-      const obj: { pathIndex?: number, tx: Transaction } = { tx }
-      const txid = tx.id('hex')
-      const hasBump = Boolean(reader.readUInt8())
-      if (hasBump) {
-        obj.pathIndex = reader.readVarIntNum()
-      }
-      transactions[txid] = obj
+  private static fromAnyBeef (beef: number[], txid?: string): { tx: Transaction, beef: Beef, txid: string } {
+    const b = Beef.fromBinary(beef)
+    if (b.txs.length < 1) {
+      throw new Error('beef must include at least one transaction.')
     }
-
-    return { transactions, BUMPs }
+    const target = txid || b.atomicTxid || b.txs.slice(-1)[0].txid
+    const tx = b.findAtomicTransaction(target)
+    if (tx == null) {
+      if (txid) { throw new Error(`Transaction with TXID ${target} not found in BEEF data.`) } else { throw new Error('beef does not contain transaction for atomic txid.') }
+    }
+    return { tx, beef: b, txid: target }
   }
 
   /**
@@ -225,7 +145,7 @@ export default class Transaction {
   static fromEF (ef: number[]): Transaction {
     const br = new Reader(ef)
     const version = br.readUInt32LE()
-    if (toHex(br.read(6)) !== '0000000000ef') throw new Error('Invalid EF marker')
+    if (toHex(br.read(6)) !== '0000000000ef') { throw new Error('Invalid EF marker') }
     const inputsLength = br.readVarIntNum()
     const inputs: TransactionInput[] = []
     for (let i = 0; i < inputsLength; i++) {
@@ -239,7 +159,7 @@ export default class Transaction {
       const lockingScriptLength = br.readVarIntNum()
       const lockingScriptBin = br.read(lockingScriptLength)
       const lockingScript = LockingScript.fromBinary(lockingScriptBin)
-      const sourceTransaction = new Transaction(null, [], [], null)
+      const sourceTransaction = new Transaction(undefined, [], [], undefined)
       sourceTransaction.outputs = Array(sourceOutputIndex + 1).fill(null)
       sourceTransaction.outputs[sourceOutputIndex] = {
         satoshis,
@@ -420,11 +340,13 @@ export default class Transaction {
       typeof input.sourceTXID === 'undefined' &&
       typeof input.sourceTransaction === 'undefined'
     ) {
-      throw new Error('A reference to an an input transaction is required. If the input transaction itself cannot be referenced, its TXID must still be provided.')
+      throw new Error(
+        'A reference to an an input transaction is required. If the input transaction itself cannot be referenced, its TXID must still be provided.'
+      )
     }
     // If the input sequence number hasn't been set, the expectation is that it is final.
     if (typeof input.sequence === 'undefined') {
-      input.sequence = 0xFFFFFFFF
+      input.sequence = 0xffffffff
     }
     this.cachedHash = undefined
     this.inputs.push(input)
@@ -437,11 +359,15 @@ export default class Transaction {
    */
   addOutput (output: TransactionOutput): void {
     this.cachedHash = undefined
-    if (!output.change) {
-      if (typeof output.satoshis === 'undefined') throw new Error('either satoshis must be defined or change must be set to true')
-      if (output.satoshis < 0) throw new Error('satoshis must be a positive integer or zero')
+    if (output.change !== true) {
+      if (typeof output.satoshis === 'undefined') {
+        throw new Error(
+          'either satoshis must be defined or change must be set to true'
+        )
+      }
+      if (output.satoshis < 0) { throw new Error('satoshis must be a positive integer or zero') }
     }
-    if (!output.lockingScript) throw new Error('lockingScript must be defined')
+    if (output.lockingScript == null) throw new Error('lockingScript must be defined')
     this.outputs.push(output)
   }
 
@@ -454,7 +380,9 @@ export default class Transaction {
    */
   addP2PKHOutput (address: number[] | string, satoshis?: number): void {
     const lockingScript = new P2PKH().lock(address)
-    if (typeof satoshis === 'undefined') { return this.addOutput({ lockingScript, change: true }) }
+    if (typeof satoshis === 'undefined') {
+      return this.addOutput({ lockingScript, change: true })
+    }
     this.addOutput({
       lockingScript,
       satoshis
@@ -483,7 +411,10 @@ export default class Transaction {
    * amongst the change outputs
    *
    */
-  async fee (modelOrFee: FeeModel | number = new SatoshisPerKilobyte(10), changeDistribution: 'equal' | 'random' = 'equal'): Promise<void> {
+  async fee (
+    modelOrFee: FeeModel | number = new SatoshisPerKilobyte(10),
+    changeDistribution: 'equal' | 'random' = 'equal'
+  ): Promise<void> {
     this.cachedHash = undefined
     if (typeof modelOrFee === 'number') {
       const sats = modelOrFee
@@ -494,7 +425,7 @@ export default class Transaction {
     const fee = await modelOrFee.computeFee(this)
     const change = this.calculateChange(fee)
     if (change <= 0) {
-      this.outputs = this.outputs.filter(output => !output.change)
+      this.outputs = this.outputs.filter((output) => output.change !== true)
       return
     }
     this.distributeChange(change, changeDistribution)
@@ -504,51 +435,70 @@ export default class Transaction {
     let change = 0
     for (const input of this.inputs) {
       if (typeof input.sourceTransaction !== 'object') {
-        throw new Error('Source transactions are required for all inputs during fee computation')
+        throw new Error(
+          'Source transactions are required for all inputs during fee computation'
+        )
       }
-      change += input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis
+      change +=
+        input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis ?? 0
     }
     change -= fee
     for (const out of this.outputs) {
-      if (!out.change) {
-        change -= out.satoshis
+      if (out.change !== true) {
+        if (out.satoshis !== undefined) {
+          change -= out.satoshis
+        }
       }
     }
     return change
   }
 
-  private distributeChange (change: number, changeDistribution: 'equal' | 'random'): void {
+  private distributeChange (
+    change: number,
+    changeDistribution: 'equal' | 'random'
+  ): void {
     let distributedChange = 0
-    const changeOutputs = this.outputs.filter(out => out.change)
+    const changeOutputs = this.outputs.filter((out) => out.change)
     if (changeDistribution === 'random') {
       distributedChange = this.distributeRandomChange(change, changeOutputs)
     } else if (changeDistribution === 'equal') {
       distributedChange = this.distributeEqualChange(change, changeOutputs)
     }
     if (distributedChange < change) {
-      this.outputs[this.outputs.length - 1].satoshis += (change - distributedChange)
+      const lastOutput = this.outputs[this.outputs.length - 1]
+      if (lastOutput.satoshis !== undefined) {
+        lastOutput.satoshis += change - distributedChange
+      } else {
+        lastOutput.satoshis = change - distributedChange
+      }
     }
   }
 
-  private distributeRandomChange (change: number, changeOutputs: TransactionOutput[]): number {
+  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
+      const portion: number = this.benfordNumber(0, changeToUse)
+      benfordNumbers[i] = (benfordNumbers[i] as number) + portion
       distributedChange += portion
       changeToUse -= portion
     }
     for (const output of this.outputs) {
-      if (output.change) output.satoshis = benfordNumbers.shift()
+      if (output.change === true) output.satoshis = benfordNumbers.shift()
     }
     return distributedChange
   }
 
-  private distributeEqualChange (change: number, changeOutputs: TransactionOutput[]): number {
+  private distributeEqualChange (
+    change: number,
+    changeOutputs: TransactionOutput[]
+  ): number {
     let distributedChange = 0
     const perOutput = Math.floor(change / changeOutputs.length)
     for (const out of changeOutputs) {
@@ -560,7 +510,9 @@ export default class Transaction {
 
   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))
+    return Math.floor(
+      min + ((max - min) * Math.log10(1 + 1 / d)) / Math.log10(10)
+    )
   }
 
   /**
@@ -572,13 +524,16 @@ export default class Transaction {
     let totalIn = 0
     for (const input of this.inputs) {
       if (typeof input.sourceTransaction !== 'object') {
-        throw new Error('Source transactions or sourceSatoshis are required for all inputs to calculate fee')
+        throw new Error(
+          'Source transactions or sourceSatoshis are required for all inputs to calculate fee'
+        )
       }
-      totalIn += input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis
+      totalIn +=
+        input.sourceTransaction.outputs[input.sourceOutputIndex].satoshis ?? 0
     }
     let totalOut = 0
     for (const output of this.outputs) {
-      totalOut += output.satoshis || 0
+      totalOut += output.satoshis ?? 0
     }
     return totalIn - totalOut
   }
@@ -590,20 +545,26 @@ export default class Transaction {
     this.cachedHash = undefined
     for (const out of this.outputs) {
       if (typeof out.satoshis === 'undefined') {
-        if (out.change) {
-          throw new Error('There are still change outputs with uncomputed amounts. Use the fee() method to compute the change amounts and transaction fees prior to signing.')
+        if (out.change === true) {
+          throw new Error(
+            'There are still change outputs with uncomputed amounts. Use the fee() method to compute the change amounts and transaction fees prior to signing.'
+          )
         } else {
-          throw new Error('One or more transaction outputs is missing an amount. Ensure all output amounts are provided before signing.')
+          throw new Error(
+            'One or more transaction outputs is missing an amount. Ensure all output amounts are provided before signing.'
+          )
         }
       }
     }
-    const unlockingScripts = await Promise.all(this.inputs.map(async (x, i): Promise<UnlockingScript | undefined> => {
-      if (typeof this.inputs[i].unlockingScriptTemplate === 'object') {
-        return await this.inputs[i].unlockingScriptTemplate.sign(this, i)
-      } else {
-        return await Promise.resolve(undefined)
-      }
-    }))
+    const unlockingScripts = await Promise.all(
+      this.inputs.map(async (x, i): Promise<UnlockingScript | undefined> => {
+        if (typeof this.inputs[i].unlockingScriptTemplate === 'object') {
+          return await this.inputs[i]?.unlockingScriptTemplate?.sign(this, i)
+        } else {
+          return await Promise.resolve(undefined)
+        }
+      })
+    )
     for (let i = 0, l = this.inputs.length; i < l; i++) {
       if (typeof this.inputs[i].unlockingScriptTemplate === 'object') {
         this.inputs[i].unlockingScript = unlockingScripts[i]
@@ -617,7 +578,9 @@ export default class Transaction {
    * @param broadcaster The Broadcaster instance wwhere the transaction will be sent
    * @returns A BroadcastResponse or BroadcastFailure from the Broadcaster
    */
-  async broadcast (broadcaster: Broadcaster = defaultBroadcaster()): Promise<BroadcastResponse | BroadcastFailure> {
+  async broadcast (
+    broadcaster: Broadcaster = defaultBroadcaster()
+  ): Promise<BroadcastResponse | BroadcastFailure> {
     return await broadcaster.broadcast(this)
   }
 
@@ -632,19 +595,26 @@ export default class Transaction {
     writer.writeVarIntNum(this.inputs.length)
     for (const i of this.inputs) {
       if (typeof i.sourceTXID === 'undefined') {
-        writer.write(i.sourceTransaction.hash() as number[])
+        if (i.sourceTransaction != null) {
+          writer.write(i.sourceTransaction.hash() as number[])
+        } else {
+          throw new Error('sourceTransaction is undefined')
+        }
       } else {
         writer.writeReverse(toArray(i.sourceTXID, 'hex'))
       }
       writer.writeUInt32LE(i.sourceOutputIndex)
+      if (i.unlockingScript == null) {
+        throw new Error('unlockingScript is undefined')
+      }
       const scriptBin = i.unlockingScript.toBinary()
       writer.writeVarIntNum(scriptBin.length)
       writer.write(scriptBin)
-      writer.writeUInt32LE(i.sequence)
+      writer.writeUInt32LE(i.sequence ?? 0)
     }
     writer.writeVarIntNum(this.outputs.length)
     for (const o of this.outputs) {
-      writer.writeUInt64LE(o.satoshis)
+      writer.writeUInt64LE(o.satoshis ?? 0)
       const scriptBin = o.lockingScript.toBinary()
       writer.writeVarIntNum(scriptBin.length)
       writer.write(scriptBin)
@@ -665,7 +635,9 @@ export default class Transaction {
     writer.writeVarIntNum(this.inputs.length)
     for (const i of this.inputs) {
       if (typeof i.sourceTransaction === 'undefined') {
-        throw new Error('All inputs must have source transactions when serializing to EF format')
+        throw new Error(
+          'All inputs must have source transactions when serializing to EF format'
+        )
       }
       if (typeof i.sourceTXID === 'undefined') {
         writer.write(i.sourceTransaction.hash() as number[])
@@ -673,18 +645,26 @@ export default class Transaction {
         writer.write(toArray(i.sourceTXID, 'hex').reverse() as number[])
       }
       writer.writeUInt32LE(i.sourceOutputIndex)
+      if (i.unlockingScript == null) {
+        throw new Error('unlockingScript is undefined')
+      }
       const scriptBin = i.unlockingScript.toBinary()
       writer.writeVarIntNum(scriptBin.length)
       writer.write(scriptBin)
-      writer.writeUInt32LE(i.sequence)
-      writer.writeUInt64LE(i.sourceTransaction.outputs[i.sourceOutputIndex].satoshis)
-      const lockingScriptBin = i.sourceTransaction.outputs[i.sourceOutputIndex].lockingScript.toBinary()
+      writer.writeUInt32LE(i.sequence ?? 0)
+      writer.writeUInt64LE(
+        i.sourceTransaction.outputs[i.sourceOutputIndex].satoshis ?? 0
+      )
+      const lockingScriptBin =
+        i.sourceTransaction.outputs[
+          i.sourceOutputIndex
+        ].lockingScript.toBinary()
       writer.writeVarIntNum(lockingScriptBin.length)
       writer.write(lockingScriptBin)
     }
     writer.writeVarIntNum(this.outputs.length)
     for (const o of this.outputs) {
-      writer.writeUInt64LE(o.satoshis)
+      writer.writeUInt64LE(o.satoshis ?? 0)
       const scriptBin = o.lockingScript.toBinary()
       writer.writeVarIntNum(scriptBin.length)
       writer.write(scriptBin)
@@ -737,7 +717,7 @@ export default class Transaction {
    */
   hash (enc?: 'hex'): number[] | string {
     let hash
-    if (this.cachedHash) {
+    if (this.cachedHash != null) {
       hash = this.cachedHash
     } else {
       hash = hash256(this.toBinary())
@@ -769,7 +749,7 @@ export default class Transaction {
    * @returns {string | number[]} - The ID of the transaction in the specified format.
    */
   id (enc?: 'hex'): number[] | string {
-    const id = [...this.hash() as number[]]
+    const id = [...(this.hash() as number[])]
     id.reverse()
     if (enc === 'hex') {
       return toHex(id)
@@ -795,21 +775,20 @@ export default class Transaction {
 
     while (txQueue.length > 0) {
       const tx = txQueue.shift()
-      const txid = tx.id('hex')
-      if (verifiedTxids.has(txid)) {
+      const txid = tx?.id('hex') ?? ''
+      if (txid != null && txid !== '' && verifiedTxids.has(txid)) {
         continue
       }
 
       // If the transaction has a valid merkle path, verification is complete.
-      if (typeof tx.merklePath === 'object') {
+      if (typeof tx?.merklePath === 'object') {
         if (chainTracker === 'scripts only') {
-          verifiedTxids.add(txid)
+          if (txid != null) {
+            verifiedTxids.add(txid)
+          }
           continue
         } else {
-          const proofValid = await tx.merklePath.verify(
-            txid,
-            chainTracker
-          )
+          const proofValid = await tx.merklePath.verify(txid, chainTracker)
           // If the proof is valid, no need to verify inputs.
           if (proofValid) {
             verifiedTxids.add(txid)
@@ -820,28 +799,41 @@ export default class Transaction {
 
       // Verify fee if feeModel is provided
       if (typeof feeModel !== 'undefined') {
+        if (tx === undefined) {
+          throw new Error('Transaction is undefined')
+        }
         const cpTx = Transaction.fromEF(tx.toEF())
         delete cpTx.outputs[0].satoshis
         cpTx.outputs[0].change = true
         await cpTx.fee(feeModel)
         if (tx.getFee() < cpTx.getFee()) {
-          throw new Error(`Verification failed because the transaction ${txid} has an insufficient fee and has not been mined.`)
+          throw new Error(
+            `Verification failed because the transaction ${txid} has an insufficient fee and has not been mined.`
+          )
         }
       }
 
       // Verify each input transaction and evaluate the spend events.
       // Also, keep a total of the input amounts for later.
       let inputTotal = 0
+      if (tx === undefined) {
+        throw new Error('Transaction is undefined')
+      }
       for (let i = 0; i < tx.inputs.length; i++) {
         const input = tx.inputs[i]
         if (typeof input.sourceTransaction !== 'object') {
-          throw new Error(`Verification failed because the input at index ${i} of transaction ${txid} is missing an associated source transaction. This source transaction is required for transaction verification because there is no merkle proof for the transaction spending a UTXO it contains.`)
+          throw new Error(
+            `Verification failed because the input at index ${i} of transaction ${txid} is missing an associated source transaction. This source transaction is required for transaction verification because there is no merkle proof for the transaction spending a UTXO it contains.`
+          )
         }
         if (typeof input.unlockingScript !== 'object') {
-          throw new Error(`Verification failed because the input at index ${i} of transaction ${txid} is missing an associated unlocking script. This script is required for transaction verification because there is no merkle proof for the transaction spending the UTXO.`)
+          throw new Error(
+            `Verification failed because the input at index ${i} of transaction ${txid} is missing an associated unlocking script. This script is required for transaction verification because there is no merkle proof for the transaction spending the UTXO.`
+          )
         }
-        const sourceOutput = input.sourceTransaction.outputs[input.sourceOutputIndex]
-        inputTotal += sourceOutput.satoshis
+        const sourceOutput =
+          input.sourceTransaction.outputs[input.sourceOutputIndex]
+        inputTotal += sourceOutput.satoshis ?? 0
 
         const sourceTxid = input.sourceTransaction.id('hex')
         if (!verifiedTxids.has(sourceTxid)) {
@@ -857,11 +849,11 @@ export default class Transaction {
           sourceTXID: input.sourceTXID,
           sourceOutputIndex: input.sourceOutputIndex,
           lockingScript: sourceOutput.lockingScript,
-          sourceSatoshis: sourceOutput.satoshis,
+          sourceSatoshis: sourceOutput.satoshis ?? 0,
           transactionVersion: tx.version,
           otherInputs,
           unlockingScript: input.unlockingScript,
-          inputSequence: input.sequence,
+          inputSequence: input.sequence ?? 0,
           inputIndex: i,
           outputs: tx.outputs,
           lockTime: tx.lockTime
@@ -877,7 +869,9 @@ export default class Transaction {
       let outputTotal = 0
       for (const out of tx.outputs) {
         if (typeof out.satoshis !== 'number') {
-          throw new Error('Every output must have a defined amount during transaction verification.')
+          throw new Error(
+            'Every output must have a defined amount during transaction verification.'
+          )
         }
         outputTotal += out.satoshis
       }
@@ -914,12 +908,13 @@ export default class Transaction {
         let added = false
         // 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 < BUMPs.length; i++) {
-          if (BUMPs[i] === tx.merklePath) { // Literally the same
+          if (BUMPs[i] === tx.merklePath) {
+            // Literally the same
             obj.pathIndex = i
             added = true
             break
           }
-          if (BUMPs[i].blockHeight === tx.merklePath.blockHeight) {
+          if (tx.merklePath !== null && tx.merklePath !== undefined && BUMPs[i].blockHeight === tx.merklePath.blockHeight) {
             // Probably the same...
             const rootA = BUMPs[i].computeRoot()
             const rootB = tx.merklePath.computeRoot()
@@ -935,17 +930,23 @@ export default class Transaction {
         // Finally, if the proof is not yet added, add a new path.
         if (!added) {
           obj.pathIndex = BUMPs.length
-          BUMPs.push(tx.merklePath)
+          if (tx.merklePath !== null && tx.merklePath !== undefined) {
+            BUMPs.push(tx.merklePath)
+          }
         }
       }
-      const duplicate = txs.some(x => x.tx.id('hex') === tx.id('hex'))
+      const duplicate = txs.some((x) => x.tx.id('hex') === tx.id('hex'))
       if (!duplicate) {
         txs.unshift(obj)
       }
       if (!hasProof) {
         for (let i = 0; i < tx.inputs.length; i++) {
           const input = tx.inputs[i]
-          if (typeof input.sourceTransaction === 'object') { addPathsAndInputs(input.sourceTransaction) } else if (!allowPartial) { throw new Error('A required source transaction is missing!') }
+          if (typeof input.sourceTransaction === 'object') {
+            addPathsAndInputs(input.sourceTransaction)
+          } else if (allowPartial === false) {
+            throw new Error('A required source transaction is missing!')
+          }
         }
       }
     }