@bsv/sdk 1.1.29 → 1.1.32

package/src/transaction/BeefParty.ts

@@ -1,100 +1,113 @@
-import { Beef } from "./Beef.js";
+import { Beef } from './Beef.js'
 
 /**
  * Extends `Beef` that is used to exchange transaction validity data with more than one external party.
- * 
+ *
  * Use `addKnownTxidsForParty` to keep track of who knows what to reduce re-transmission of potentially large transactions.
- * 
+ *
  * Use `getTrimmedBeefForParty` to obtain a `Beef` trimmed of transaction validity data known to a specific party.
- * 
+ *
  * Typical usage scenario:
- * 
+ *
  * 1. Query a wallet storage provider for spendable outputs.
  * 2. The provider replies with a Beef validating the returned outputs.
  * 3. Construct a new transaction using some of the queried outputs as inputs, including Beef validating all the inputs.
  * 4. Receive new valid raw transaction after processing and Beef validating change outputs added to original inputs.
  * 5. Return to step 1, continuing to build on old and new spendable outputs.
- * 
+ *
  * By default, each Beef is required to be complete and valid: All transactions appear as full serialized bitcoin transactions and
  * each transaction either has a merkle path proof (it has been mined) or all of its input transactions are included.
- * 
+ *
  * The size and redundancy of these Beefs becomes a problem when chained transaction creation out-paces the block mining rate.
- * 
+ *
  */
 export class BeefParty extends Beef {
-    /**
+  /**
      * keys are party identifiers.
      * values are records of txids with truthy value for which the party already has validity proof.
      */
-    knownTo: Record<string, Record<string, boolean>> = {}
+  knownTo: Record<string, Record<string, boolean>> = {}
 
-    /**
-     * 
+  /**
+     *
      * @param parties Optional array of initial unique party identifiers.
      */
-    constructor(parties?: string[]) {
-        super()
-        if (parties) {
-            for (const party of parties)
-                this.addParty(party)
-        }
+  constructor (parties?: string[]) {
+    super()
+    if (parties) {
+      for (const party of parties) { this.addParty(party) }
     }
+  }
 
-    /**
-     * @param party 
+  /**
+     * @param party
      * @returns `true` if `party` has already beed added to this `BeefParty`.
      */
-    isParty(party: string) {
-        const r = Object.keys(this.knownTo).includes(party)
-        return r
-    }
+  isParty (party: string) {
+    const r = Object.keys(this.knownTo).includes(party)
+    return r
+  }
 
-    /**
+  /**
      * Adds a new unique party identifier to this `BeefParty`.
-     * @param party 
+     * @param party
      */
-    addParty(party: string) {
-        if (this.isParty(party))
-            throw new Error(`Party ${party} already exists.`)
-        this.knownTo[party] = {}
-    }
+  addParty (party: string) {
+    if (this.isParty(party)) { throw new Error(`Party ${party} already exists.`) }
+    this.knownTo[party] = {}
+  }
 
-    /**
-     * @param party 
+  /**
+     * @param party
      * @returns Array of txids "known" to `party`.
      */
-    getKnownTxidsForParty(party: string) : string[] {
-        const knownTxids = this.knownTo[party]
-        if (!knownTxids)
-            throw new Error(`Party ${party} is unknown.`)
-        return Object.keys(knownTxids)
-    }
+  getKnownTxidsForParty (party: string): string[] {
+    const knownTxids = this.knownTo[party]
+    if (!knownTxids) { throw new Error(`Party ${party} is unknown.`) }
+    return Object.keys(knownTxids)
+  }
 
-    /**
-     * @param party 
+  /**
+     * @param party
      * @returns trimmed beef of unknown transactions and proofs for `party`
      */
-    getTrimmedBeefForParty(party: string) : Beef {
-        const knownTxids = this.getKnownTxidsForParty(party)
-        const prunedBeef = this.clone()
-        prunedBeef.trimKnownTxids(knownTxids)
-        return prunedBeef
-    }
+  getTrimmedBeefForParty (party: string): Beef {
+    const knownTxids = this.getKnownTxidsForParty(party)
+    const prunedBeef = this.clone()
+    prunedBeef.trimKnownTxids(knownTxids)
+    return prunedBeef
+  }
 
-    /**
+  /**
      * Make note of additional txids "known" to `party`.
      * @param party unique identifier, added if new.
-     * @param knownTxids 
+     * @param knownTxids
      */
-    addKnownTxidsForParty(party: string, knownTxids: string[]) {
-        if (!this.isParty(party))
-            this.addParty(party)
-        const kts = this.knownTo[party]
-        for (const txid of knownTxids) {
-            kts[txid] = true
-            this.mergeTxidOnly(txid)
-        }
+  addKnownTxidsForParty (party: string, knownTxids: string[]) {
+    if (!this.isParty(party)) { this.addParty(party) }
+    const kts = this.knownTo[party]
+    for (const txid of knownTxids) {
+      kts[txid] = true
+      this.mergeTxidOnly(txid)
     }
+  }
+
+  /**
+   * Merge a `beef` received from a specific `party`.
+   * 
+   * Updates this `BeefParty` to track all the txids
+   * corresponding to transactions for which `party`
+   * has raw transaction and validity proof data.
+   * 
+   * @param party 
+   * @param beef 
+   */
+  mergeBeefFromParty (party: string, beef: number[] | Beef) {
+    const b: Beef = Array.isArray(beef) ? Beef.fromBinary(beef) : beef
+    const knownTxids = b.getValidTxids()
+    this.mergeBeef(b)
+    this.addKnownTxidsForParty(party, knownTxids)
+  }
 }
 
-export default BeefParty
+export default BeefParty

package/src/transaction/BeefTx.ts

@@ -1,162 +1,152 @@
-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 { 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'
 
 /**
  * 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
-    }
-
-    /**
+  _bumpIndex?: number
+  _tx?: Transaction
+  _rawTx?: number[]
+  _txid?: string
+  inputTxids: string[] = []
+  /**
+   * true if `hasProof` or all inputs chain to `hasProof`.
+   * 
+   * Typically set by sorting transactions by proven dependency chains.
+   */
+  isValid?: boolean = undefined
+
+  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()
+  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 = tx
+      }
     }
-
-    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);
-        }
+    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, 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')
-            if (this.bumpIndex === undefined) {
-                writer.writeUInt8(0)
-            } else {
-                writer.writeUInt8(1)
-                writer.writeVarIntNum(this.bumpIndex)
-            }
+  }
+
+  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') }
+      if (this.bumpIndex === undefined) {
+        writer.writeUInt8(0)
+      } else {
+        writer.writeUInt8(1)
+        writer.writeVarIntNum(this.bumpIndex)
+      }
+    } else {
+      // V2
+      if (this.isTxidOnly) {
+        // Encode just the txid of a known transaction using the txid
+        writer.writeUInt8(2)
+        writer.writeReverse(toArray(this._txid, 'hex'))
+      } else {
+        if (this.bumpIndex === undefined) {
+          writer.writeUInt8(0)
         } else {
-            // V2
-            if (this.isTxidOnly) {
-                // Encode just the txid of a known transaction using the txid
-                writer.writeUInt8(2)
-                writer.writeReverse(toArray(this._txid, 'hex'))
-            } 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')
-            }
+          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') }
+      }
     }
-
-    static fromReader (br: Reader, magic: number): BeefTx {
-
-        let tx: Transaction | number[] | string | undefined = undefined
-        let bumpIndex: number | undefined = 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 {
-            // V2
-            const format = br.readUInt8()
-            if (format === 2) {
-                // txid only
-                tx = toHex(br.readReverse(32))
-            } else {
-                if (format === 1)
-                    bumpIndex =  br.readVarIntNum()
-                tx = Transaction.fromReader(br)
-            }
-        }
-
-        const beefTx = new BeefTx(tx, bumpIndex)
-        return beefTx
+  }
+
+  static fromReader (br: Reader, magic: number): BeefTx {
+    let tx: 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 {
+      // V2
+      const format = br.readUInt8()
+      if (format === 2) {
+        // txid only
+        tx = toHex(br.readReverse(32))
+      } else {
+        if (format === 1) { bumpIndex = br.readVarIntNum() }
+        tx = Transaction.fromReader(br)
+      }
     }
 
-}
+    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) }
     }