@bsv/sdk 1.1.23 → 1.1.25

package/src/transaction/BeefTx.ts

@@ -0,0 +1,121 @@
+import { hash256 } from "../primitives/Hash.js"
+import { Reader, Writer, toHex, toArray } from "../primitives/utils.js"
+import Transaction from "./Transaction.js"
+import { BEEF_MAGIC_TXID_ONLY_EXTENSION } from "./Beef.js"
+
+/**
+ * A single bitcoin transaction associated with a `Beef` validity proof set.
+ * 
+ * Simple case is transaction data included directly, either as raw bytes or fully parsed data, or both.
+ * 
+ * Supports 'known' transactions which are represented by just their txid.
+ * It is assumed that intended consumer of this beef already has validity proof for such a transaction,
+ * which they can merge if necessary to create a valid beef.
+ */
+export default class BeefTx {
+    _bumpIndex?: number
+    _tx?: Transaction
+    _rawTx?: number[]
+    _txid?: string
+    inputTxids: string[] = []
+    degree: number = 0
+
+    get bumpIndex() : number | undefined { return this._bumpIndex}
+
+    set bumpIndex(v: number | undefined) {
+        this._bumpIndex = v
+        this.updateInputTxids()
+    }
+
+    get hasProof() : boolean {
+        return this._bumpIndex !== undefined
+    }
+
+    get isTxidOnly() : boolean {
+        return !!this._txid && !this._rawTx && !this._tx
+    }
+
+    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))
+        throw new Error('Internal')
+    }
+
+    get tx() {
+        if (this._tx) return this._tx
+        if (this._rawTx) return this._tx = Transaction.fromBinary(this._rawTx)
+        return undefined
+    }
+
+    get rawTx() {
+        if (this._rawTx) return this._rawTx
+        if (this._tx) return this._rawTx = this._tx.toBinary()
+        return undefined
+    }
+
+    /**
+     * @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
+        } else {
+            if (Array.isArray(tx)) {
+                this._rawTx = tx
+            } else {
+                this._tx = <Transaction>tx
+            }
+        }
+        this.bumpIndex = bumpIndex
+        this.updateInputTxids()
+    }
+
+    private updateInputTxids() {
+        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) : void {
+        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')
+        if (this.bumpIndex === undefined) {
+            writer.writeUInt8(0)
+        } else {
+            writer.writeUInt8(1)
+            writer.writeVarIntNum(this.bumpIndex)
+        }
+    }
+
+    static fromReader (br: Reader): BeefTx {
+        let tx: Transaction | number[] | string | undefined = undefined
+        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)
+        }
+        const bumpIndex = br.readUInt8() ? br.readVarIntNum() : undefined
+        const beefTx = new BeefTx(tx, bumpIndex)
+        return beefTx
+    }
+
+}

package/src/transaction/Transaction.ts

@@ -12,6 +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 { BEEF_MAGIC } from './Beef.js'
 
 /**
  * Represents a complete Bitcoin transaction. This class encapsulates all the details
@@ -66,7 +67,7 @@ export default class Transaction {
     const reader = new Reader(beef)
     // Read the version
     const version = reader.readUInt32LE()
-    if (version !== 4022206465) {
+    if (version !== BEEF_MAGIC) {
       throw new Error(`Invalid BEEF version. Expected 4022206465, received ${version}.`)
     }
 
@@ -593,9 +594,8 @@ export default class Transaction {
     }
     if (enc === 'hex') {
       return toHex(hash)
-    } else {
-      return hash
     }
+    return hash
   }
 
   /**
@@ -635,84 +635,110 @@ export default class Transaction {
    *
    * @example tx.verify(new WhatsOnChain(), new SatoshisPerKilobyte(1))
    */
-  async verify (chainTracker: ChainTracker | 'scripts only' = defaultChainTracker(), feeModel?: FeeModel): Promise<boolean> {
-    // If the transaction has a valid merkle path, verification is complete.
-    if (typeof this.merklePath === 'object') {
-      if (chainTracker === 'scripts only') {
-        return true
-      } else {
-        const proofValid = await this.merklePath.verify(
-          this.id('hex'),
-          chainTracker
-        )
-        // Note that if the proof is provided but not valid, the transaction could still be verified by proving all inputs (if they are available) and checking the associated spends.
-        if (proofValid) {
-          return true
-        }
+  async verify (
+    chainTracker: ChainTracker | 'scripts only' = defaultChainTracker(),
+    feeModel?: FeeModel
+  ): Promise<boolean> {
+    const verifiedTxids = new Set<string>()
+    const txQueue: Transaction[] = [this]
+
+    while (txQueue.length > 0) {
+      const tx = txQueue.shift()
+      const txid = tx.id('hex')
+      if (verifiedTxids.has(txid)) {
+        continue
       }
-    }
-
-    if (typeof feeModel !== 'undefined') {
-      const cpTx = Transaction.fromHexEF(this.toHexEF())
-      delete cpTx.outputs[0].satoshis
-      cpTx.outputs[0].change = true
-      await cpTx.fee(feeModel)
-      if (this.getFee() < cpTx.getFee()) throw new Error(`Verification failed because the transaction ${this.id('hex')} 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
-    for (let i = 0; i < this.inputs.length; i++) {
-      const input = this.inputs[i]
-      if (typeof input.sourceTransaction !== 'object') {
-        throw new Error(`Verification failed because the input at index ${i} of transaction ${this.id('hex')} 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 ${this.id('hex')} 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.`)
+      // If the transaction has a valid merkle path, verification is complete.
+      if (typeof tx.merklePath === 'object') {
+        if (chainTracker === 'scripts only') {
+          verifiedTxids.add(txid)
+          continue
+        } else {
+          const proofValid = await tx.merklePath.verify(
+            txid,
+            chainTracker
+          )
+          // If the proof is valid, no need to verify inputs.
+          if (proofValid) {
+            verifiedTxids.add(txid)
+            continue
+          }
+        }
       }
-      const sourceOutput = input.sourceTransaction.outputs[input.sourceOutputIndex]
-      inputTotal += sourceOutput.satoshis
-      const inputVerified = await input.sourceTransaction.verify(chainTracker, feeModel)
-      if (!inputVerified) {
-        return false
+
+      // Verify fee if feeModel is provided
+      if (typeof feeModel !== '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.`)
+        }
       }
-      const otherInputs = [...this.inputs]
-      otherInputs.splice(i, 1)
-      if (typeof input.sourceTXID === 'undefined') {
-        input.sourceTXID = input.sourceTransaction.id('hex')
+
+      // Verify each input transaction and evaluate the spend events.
+      // Also, keep a total of the input amounts for later.
+      let inputTotal = 0
+      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.`)
+        }
+        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.`)
+        }
+        const sourceOutput = input.sourceTransaction.outputs[input.sourceOutputIndex]
+        inputTotal += sourceOutput.satoshis
+
+        const sourceTxid = input.sourceTransaction.id('hex')
+        if (!verifiedTxids.has(sourceTxid)) {
+          txQueue.push(input.sourceTransaction)
+        }
+
+        const otherInputs = tx.inputs.filter((_, idx) => idx !== i)
+        if (typeof input.sourceTXID === 'undefined') {
+          input.sourceTXID = sourceTxid
+        }
+
+        const spend = new Spend({
+          sourceTXID: input.sourceTXID,
+          sourceOutputIndex: input.sourceOutputIndex,
+          lockingScript: sourceOutput.lockingScript,
+          sourceSatoshis: sourceOutput.satoshis,
+          transactionVersion: tx.version,
+          otherInputs,
+          unlockingScript: input.unlockingScript,
+          inputSequence: input.sequence,
+          inputIndex: i,
+          outputs: tx.outputs,
+          lockTime: tx.lockTime
+        })
+        const spendValid = spend.validate()
+
+        if (!spendValid) {
+          return false
+        }
       }
 
-      const spend = new Spend({
-        sourceTXID: input.sourceTXID,
-        sourceOutputIndex: input.sourceOutputIndex,
-        lockingScript: sourceOutput.lockingScript,
-        sourceSatoshis: sourceOutput.satoshis,
-        transactionVersion: this.version,
-        otherInputs,
-        unlockingScript: input.unlockingScript,
-        inputSequence: input.sequence,
-        inputIndex: i,
-        outputs: this.outputs,
-        lockTime: this.lockTime
-      })
-      const spendValid = spend.validate()
+      // Total the outputs to ensure they don't amount to more than the inputs
+      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.')
+        }
+        outputTotal += out.satoshis
+      }
 
-      if (!spendValid) {
+      if (outputTotal > inputTotal) {
         return false
       }
-    }
 
-    // Total the outputs to ensure they don't amount to more than the inputs
-    let outputTotal = 0
-    for (const out of this.outputs) {
-      if (typeof out.satoshis !== 'number') {
-        throw new Error('Every output must have a defined amount during transaction verification.')
-      }
-      outputTotal += out.satoshis
+      verifiedTxids.add(txid)
     }
 
-    return outputTotal <= inputTotal
+    return true
   }
 
   /**

package/src/transaction/TransactionInput.ts

@@ -59,5 +59,5 @@ export default interface TransactionInput {
     sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>
     estimateLength: (tx: Transaction, inputIndex: number) => Promise<number>
   }
-  sequence: number
+  sequence?: number
 }