@bsv/sdk 1.1.24 → 1.1.26

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/MerklePath.ts

@@ -46,11 +46,11 @@ export default class MerklePath {
    * @param {string} hex - The hexadecimal string representation of the Merkle Path.
    * @returns {MerklePath} - A new MerklePath instance.
    */
-  static fromHex (hex: string): MerklePath {
+  static fromHex(hex: string): MerklePath {
     return MerklePath.fromBinary(toArray(hex, 'hex'))
   }
 
-  static fromReader (reader: Reader): MerklePath {
+  static fromReader(reader: Reader): MerklePath {
     const blockHeight = reader.readVarIntNum()
     const treeHeight = reader.readUInt8()
     const path = Array(treeHeight).fill(0).map(() => ([]))
@@ -89,12 +89,12 @@ export default class MerklePath {
    * @param {number[]} bump - The binary array representation of the Merkle Path.
    * @returns {MerklePath} - A new MerklePath instance.
    */
-  static fromBinary (bump: number[]): MerklePath {
+  static fromBinary(bump: number[]): MerklePath {
     const reader = new Reader(bump)
     return MerklePath.fromReader(reader)
   }
 
-  constructor (blockHeight: number, path: Array<Array<{
+  constructor(blockHeight: number, path: Array<Array<{
     offset: number
     hash?: string
     txid?: boolean
@@ -142,7 +142,7 @@ export default class MerklePath {
    *
    * @returns {number[]} - The binary array representation of the Merkle Path.
    */
-  toBinary (): number[] {
+  toBinary(): number[] {
     const writer = new Writer()
     writer.writeVarIntNum(this.blockHeight)
     const treeHeight = this.path.length
@@ -173,7 +173,7 @@ export default class MerklePath {
    *
    * @returns {string} - The hexadecimal string representation of the Merkle Path.
    */
-  toHex (): string {
+  toHex(): string {
     return toHex(this.toBinary())
   }
 
@@ -184,7 +184,7 @@ export default class MerklePath {
    * @returns {string} - The computed Merkle root as a hexadecimal string.
    * @throws {Error} - If the transaction ID is not part of the Merkle Path.
    */
-  computeRoot (txid?: string): string {
+  computeRoot(txid?: string): string {
     if (typeof txid !== 'string') {
       txid = this.path[0].find(leaf => Boolean(leaf?.hash)).hash
     }
@@ -224,7 +224,7 @@ export default class MerklePath {
    * @param height
    * @param offset
    */
-  findOrComputeLeaf (height: number, offset: number): MerklePathLeaf | undefined {
+  findOrComputeLeaf(height: number, offset: number): MerklePathLeaf | undefined {
     const hash = (m: string): string => toHex((
       hash256(toArray(m, 'hex').reverse())
     ).reverse())
@@ -261,7 +261,7 @@ export default class MerklePath {
    * @param {ChainTracker} chainTracker - The ChainTracker instance used to verify the Merkle root.
    * @returns {boolean} - True if the transaction ID is valid within the Merkle Path at the specified block height.
    */
-  async verify (txid: string, chainTracker: ChainTracker): Promise<boolean> {
+  async verify(txid: string, chainTracker: ChainTracker): Promise<boolean> {
     const root = this.computeRoot(txid)
     // 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)
@@ -273,7 +273,7 @@ export default class MerklePath {
    * @param {MerklePath} other - Another MerklePath to combine with this path.
    * @throws {Error} - If the paths have different block heights or roots.
    */
-  combine (other: MerklePath): void {
+  combine(other: MerklePath): void {
     if (this.blockHeight !== other.blockHeight) {
       throw new Error('You cannot combine paths which do not have the same block height.')
     }
@@ -309,7 +309,7 @@ export default class MerklePath {
    * Assumes that at least all required nodes are present.
    * Leaves all levels sorted by increasing offset.
    */
-  trim () {
+  trim() {
     const pushIfNew = (v: number, a: number[]) => {
       if (a.length === 0 || a.slice(-1)[0] !== v) { a.push(v) }
     }