@bsv/sdk 1.3.11 → 1.3.13

package/src/transaction/Transaction.ts

@@ -1,19 +1,19 @@
-import TransactionInput from './TransactionInput.js'
-import TransactionOutput from './TransactionOutput.js'
-import UnlockingScript from '../script/UnlockingScript.js'
-import LockingScript from '../script/LockingScript.js'
-import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
-import { hash256 } from '../primitives/Hash.js'
-import FeeModel from './FeeModel.js'
-import SatoshisPerKilobyte from './fee-models/SatoshisPerKilobyte.js'
-import { Broadcaster, BroadcastResponse, BroadcastFailure } from './Broadcaster.js'
-import MerklePath from './MerklePath.js'
-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 P2PKH from '../script/templates/P2PKH.js'
+import TransactionInput from './TransactionInput'
+import TransactionOutput from './TransactionOutput'
+import UnlockingScript from '../script/UnlockingScript'
+import LockingScript from '../script/LockingScript'
+import { Reader, Writer, toHex, toArray } from '../primitives/utils'
+import { hash256 } from '../primitives/Hash'
+import FeeModel from './FeeModel'
+import SatoshisPerKilobyte from './fee-models/SatoshisPerKilobyte'
+import { Broadcaster, BroadcastResponse, BroadcastFailure } from './Broadcaster'
+import MerklePath from './MerklePath'
+import Spend from '../script/Spend'
+import ChainTracker from './ChainTracker'
+import { defaultBroadcaster } from './broadcasters/DefaultBroadcaster'
+import { defaultChainTracker } from './chaintrackers/DefaultChainTracker'
+import { Beef, BEEF_V1 } from './Beef'
+import P2PKH from '../script/templates/P2PKH'
 
 /**
  * Represents a complete Bitcoin transaction. This class encapsulates all the details
@@ -60,10 +60,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') {
@@ -74,7 +81,9 @@ export default class Transaction {
       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}`)
+          throw new Error(
+            `Reference to unknown TXID in BEEF: ${input.sourceTXID}`
+          )
         }
         input.sourceTransaction = sourceObj.tx
         this.addPathOrInputs(sourceObj, transactions, BUMPs)
@@ -83,138 +92,51 @@ 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
+  static fromBEEF(beef: number[], txid?: string): Transaction {
+    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.`)
+  static fromAtomicBEEF(beef: number[]): Transaction {
+    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.`)
     }
-
-    // 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) }
-      }
-    }
-    // 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) {
+      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 }
   }
 
   /**
@@ -222,10 +144,10 @@ export default class Transaction {
    * @param ef A binary representation of a transaction in EF format.
    * @returns An extended transaction, linked to its associated inputs by locking script and satoshis amounts only.
    */
-  static fromEF (ef: number[]): 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++) {
@@ -284,7 +206,7 @@ export default class Transaction {
    *   outputs: { vout: number, offset: number, length: number }[]
    * }
    */
-  static parseScriptOffsets (bin: number[]): {
+  static parseScriptOffsets(bin: number[]): {
     inputs: Array<{ vin: number, offset: number, length: number }>
     outputs: Array<{ vout: number, offset: number, length: number }>
   } {
@@ -310,7 +232,7 @@ export default class Transaction {
     return { inputs, outputs }
   }
 
-  static fromReader (br: Reader): Transaction {
+  static fromReader(br: Reader): Transaction {
     const version = br.readUInt32LE()
     const inputsLength = br.readVarIntNum()
     const inputs: TransactionInput[] = []
@@ -351,7 +273,7 @@ export default class Transaction {
    * @param {number[]} bin - The binary array representation of the transaction.
    * @returns {Transaction} - A new Transaction instance.
    */
-  static fromBinary (bin: number[]): Transaction {
+  static fromBinary(bin: number[]): Transaction {
     const br = new Reader(bin)
     return Transaction.fromReader(br)
   }
@@ -363,7 +285,7 @@ export default class Transaction {
    * @param {string} hex - The hexadecimal string representation of the transaction.
    * @returns {Transaction} - A new Transaction instance.
    */
-  static fromHex (hex: string): Transaction {
+  static fromHex(hex: string): Transaction {
     return Transaction.fromBinary(toArray(hex, 'hex'))
   }
 
@@ -374,7 +296,7 @@ export default class Transaction {
    * @param {string} hex - The hexadecimal string representation of the transaction EF.
    * @returns {Transaction} - A new Transaction instance.
    */
-  static fromHexEF (hex: string): Transaction {
+  static fromHexEF(hex: string): Transaction {
     return Transaction.fromEF(toArray(hex, 'hex'))
   }
 
@@ -389,11 +311,11 @@ export default class Transaction {
    * @param {string} [txid] - Optional TXID of the transaction to retrieve from the BEEF data.
    * @returns {Transaction} - A new Transaction instance.
    */
-  static fromHexBEEF (hex: string, txid?: string): Transaction {
+  static fromHexBEEF(hex: string, txid?: string): Transaction {
     return Transaction.fromBEEF(toArray(hex, 'hex'), txid)
   }
 
-  constructor (
+  constructor(
     version: number = 1,
     inputs: TransactionInput[] = [],
     outputs: TransactionOutput[] = [],
@@ -415,16 +337,18 @@ export default class Transaction {
    * @param {TransactionInput} input - The TransactionInput object to add to the transaction.
    * @throws {Error} - If the input does not have a sourceTXID or sourceTransaction defined.
    */
-  addInput (input: TransactionInput): void {
+  addInput(input: TransactionInput): void {
     if (
       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)
@@ -435,11 +359,15 @@ export default class Transaction {
    *
    * @param {TransactionOutput} output - The TransactionOutput object to add to the transaction.
    */
-  addOutput (output: TransactionOutput): void {
+  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 (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')
     this.outputs.push(output)
@@ -452,9 +380,11 @@ export default class Transaction {
    * @param {number} [satoshis] - The number of satoshis to send to the address - if not provided, the output is considered a change output.
    *
    */
-  addP2PKHOutput (address: number[] | string, satoshis?: number): void {
+  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
@@ -466,7 +396,7 @@ export default class Transaction {
    *
    * @param {Record<string, any>} metadata - The metadata object to merge into the existing metadata.
    */
-  updateMetadata (metadata: Record<string, any>): void {
+  updateMetadata(metadata: Record<string, any>): void {
     this.metadata = {
       ...this.metadata,
       ...metadata
@@ -483,7 +413,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,19 +427,22 @@ 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)
       return
     }
     this.distributeChange(change, changeDistribution)
   }
 
-  private calculateChange (fee: number): number {
+  private calculateChange(fee: number): number {
     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
     }
     change -= fee
     for (const out of this.outputs) {
@@ -517,20 +453,27 @@ export default class Transaction {
     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)
+      this.outputs[this.outputs.length - 1].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)
@@ -548,7 +491,10 @@ export default class Transaction {
     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) {
@@ -558,9 +504,11 @@ export default class Transaction {
     return distributedChange
   }
 
-  private benfordNumber (min: number, max: number): number {
+  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)
+    )
   }
 
   /**
@@ -568,13 +516,16 @@ export default class Transaction {
    *
    * @returns The current transaction fee
    */
-  getFee (): number {
+  getFee(): number {
     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
     }
     let totalOut = 0
     for (const output of this.outputs) {
@@ -586,24 +537,30 @@ export default class Transaction {
   /**
    * Signs a transaction, hydrating all its unlocking scripts based on the provided script templates where they are available.
    */
-  async sign (): Promise<void> {
+  async sign(): Promise<void> {
     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.')
+          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 +574,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)
   }
 
@@ -626,7 +585,7 @@ export default class Transaction {
    *
    * @returns {number[]} - The binary array representation of the transaction.
    */
-  toBinary (): number[] {
+  toBinary(): number[] {
     const writer = new Writer()
     writer.writeUInt32LE(this.version)
     writer.writeVarIntNum(this.inputs.length)
@@ -658,14 +617,16 @@ export default class Transaction {
    *
    * @returns {number[]} - The BRC-30 EF representation of the transaction.
    */
-  toEF (): number[] {
+  toEF(): number[] {
     const writer = new Writer()
     writer.writeUInt32LE(this.version)
     writer.write([0, 0, 0, 0, 0, 0xef])
     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[])
@@ -677,8 +638,13 @@ export default class Transaction {
       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.writeUInt64LE(
+        i.sourceTransaction.outputs[i.sourceOutputIndex].satoshis
+      )
+      const lockingScriptBin =
+        i.sourceTransaction.outputs[
+          i.sourceOutputIndex
+        ].lockingScript.toBinary()
       writer.writeVarIntNum(lockingScriptBin.length)
       writer.write(lockingScriptBin)
     }
@@ -698,7 +664,7 @@ export default class Transaction {
    *
    * @returns {string} - The hexadecimal string representation of the transaction EF.
    */
-  toHexEF (): string {
+  toHexEF(): string {
     return toHex(this.toEF())
   }
 
@@ -707,7 +673,7 @@ export default class Transaction {
    *
    * @returns {string} - The hexadecimal string representation of the transaction.
    */
-  toHex (): string {
+  toHex(): string {
     return toHex(this.toBinary())
   }
 
@@ -716,7 +682,7 @@ export default class Transaction {
    *
    * @returns {string} - The hexadecimal string representation of the transaction BEEF.
    */
-  toHexBEEF (): string {
+  toHexBEEF(): string {
     return toHex(this.toBEEF())
   }
 
@@ -725,7 +691,7 @@ export default class Transaction {
    *
    * @returns {string} - The hexadecimal string representation of the transaction Atomic BEEF.
    */
-  toHexAtomicBEEF (): string {
+  toHexAtomicBEEF(): string {
     return toHex(this.toAtomicBEEF())
   }
 
@@ -735,7 +701,7 @@ export default class Transaction {
    * @param {'hex' | undefined} enc - The encoding to use for the hash. If 'hex', returns a hexadecimal string; otherwise returns a binary array.
    * @returns {string | number[]} - The hash of the transaction in the specified format.
    */
-  hash (enc?: 'hex'): number[] | string {
+  hash(enc?: 'hex'): number[] | string {
     let hash
     if (this.cachedHash) {
       hash = this.cachedHash
@@ -754,22 +720,22 @@ export default class Transaction {
    *
    * @returns {number[]} - The ID of the transaction in the binary array format.
    */
-  id (): number[]
+  id(): number[]
   /**
    * Calculates the transaction's ID in hexadecimal format.
    *
    * @param {'hex'} enc - The encoding to use for the ID. If 'hex', returns a hexadecimal string.
    * @returns {string} - The ID of the transaction in the hex format.
    */
-  id (enc: 'hex'): string
+  id(enc: 'hex'): string
   /**
    * Calculates the transaction's ID.
    *
    * @param {'hex' | undefined} enc - The encoding to use for the ID. If 'hex', returns a hexadecimal string; otherwise returns a binary array.
    * @returns {string | number[]} - The ID of the transaction in the specified format.
    */
-  id (enc?: 'hex'): number[] | string {
-    const id = [...this.hash() as number[]]
+  id(enc?: 'hex'): number[] | string {
+    const id = [...(this.hash() as number[])]
     id.reverse()
     if (enc === 'hex') {
       return toHex(id)
@@ -786,7 +752,7 @@ export default class Transaction {
    *
    * @example tx.verify(new WhatsOnChain(), new SatoshisPerKilobyte(1))
    */
-  async verify (
+  async verify(
     chainTracker: ChainTracker | 'scripts only' = defaultChainTracker(),
     feeModel?: FeeModel
   ): Promise<boolean> {
@@ -806,10 +772,7 @@ export default class Transaction {
           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)
@@ -825,7 +788,9 @@ export default class Transaction {
         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.`
+          )
         }
       }
 
@@ -835,12 +800,17 @@ export default class Transaction {
       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]
+        const sourceOutput =
+          input.sourceTransaction.outputs[input.sourceOutputIndex]
         inputTotal += sourceOutput.satoshis
 
         const sourceTxid = input.sourceTransaction.id('hex')
@@ -877,7 +847,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
       }
@@ -900,7 +872,7 @@ export default class Transaction {
    * @returns The serialized BEEF structure
    * @throws Error if there are any missing sourceTransactions unless `allowPartial` is true.
    */
-  toBEEF (allowPartial?: boolean): number[] {
+  toBEEF(allowPartial?: boolean): number[] {
     const writer = new Writer()
     writer.writeUInt32LE(BEEF_V1)
     const BUMPs: MerklePath[] = []
@@ -914,7 +886,8 @@ 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
@@ -938,14 +911,18 @@ export default class Transaction {
           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) {
+            throw new Error('A required source transaction is missing!')
+          }
         }
       }
     }
@@ -980,7 +957,7 @@ export default class Transaction {
    * @returns {number[]} - The serialized Atomic BEEF structure.
    * @throws Error if there are any missing sourceTransactions unless `allowPartial` is true.
    */
-  toAtomicBEEF (allowPartial?: boolean): number[] {
+  toAtomicBEEF(allowPartial?: boolean): number[] {
     const writer = new Writer()
     // Write the Atomic BEEF prefix
     writer.writeUInt32LE(0x01010101)