@bsv/sdk 1.3.11 → 1.3.13

package/src/transaction/BeefParty.ts

@@ -1,4 +1,4 @@
-import { Beef } from './Beef.js'
+import { Beef } from './Beef'
 
 /**
  * Extends `Beef` that is used to exchange transaction validity data with more than one external party.
@@ -23,54 +23,60 @@ import { Beef } from './Beef.js'
  */
 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.
-     */
+   * 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>> = {}
 
   /**
-     *
-     * @param parties Optional array of initial unique party identifiers.
-     */
+   *
+   * @param parties Optional array of initial unique party identifiers.
+   */
   constructor (parties?: string[]) {
     super()
     if (parties) {
-      for (const party of parties) { this.addParty(party) }
+      for (const party of parties) {
+        this.addParty(party)
+      }
     }
   }
 
   /**
-     * @param party
-     * @returns `true` if `party` has already been added to this `BeefParty`.
-     */
+   * @param party
+   * @returns `true` if `party` has already been added to this `BeefParty`.
+   */
   isParty (party: string) {
     const r = Object.keys(this.knownTo).includes(party)
     return r
   }
 
   /**
-     * Adds a new unique party identifier to this `BeefParty`.
-     * @param party
-     */
+   * Adds a new unique party identifier to this `BeefParty`.
+   * @param party
+   */
   addParty (party: string) {
-    if (this.isParty(party)) { throw new Error(`Party ${party} already exists.`) }
+    if (this.isParty(party)) {
+      throw new Error(`Party ${party} already exists.`)
+    }
     this.knownTo[party] = {}
   }
 
   /**
-     * @param party
-     * @returns Array of txids "known" to `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.`) }
+    if (!knownTxids) {
+      throw new Error(`Party ${party} is unknown.`)
+    }
     return Object.keys(knownTxids)
   }
 
   /**
-     * @param party
-     * @returns trimmed beef of unknown transactions and proofs for `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()
@@ -79,12 +85,14 @@ export class BeefParty extends Beef {
   }
 
   /**
-     * Make note of additional txids "known" to `party`.
-     * @param party unique identifier, added if new.
-     * @param knownTxids
-     */
+   * Make note of additional txids "known" to `party`.
+   * @param party unique identifier, added if new.
+   * @param knownTxids
+   */
   addKnownTxidsForParty (party: string, knownTxids: string[]) {
-    if (!this.isParty(party)) { this.addParty(party) }
+    if (!this.isParty(party)) {
+      this.addParty(party)
+    }
     const kts = this.knownTo[party]
     for (const txid of knownTxids) {
       kts[txid] = true

package/src/transaction/BeefTx.ts

@@ -1,7 +1,7 @@
-import { hash256 } from '../primitives/Hash.js'
-import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
-import Transaction from './Transaction.js'
-import { BEEF_V2, TX_DATA_FORMAT } from './Beef.js'
+import { hash256 } from '../primitives/Hash'
+import { Reader, Writer, toHex, toArray } from '../primitives/utils'
+import Transaction from './Transaction'
+import { BEEF_V2, TX_DATA_FORMAT } from './Beef'
 
 /**
  * A single bitcoin transaction associated with a `Beef` validity proof set.
@@ -25,7 +25,9 @@ export default class BeefTx {
    */
   isValid?: boolean = undefined
 
-  get bumpIndex (): number | undefined { return this._bumpIndex }
+  get bumpIndex (): number | undefined {
+    return this._bumpIndex
+  }
 
   set bumpIndex (v: number | undefined) {
     this._bumpIndex = v
@@ -72,9 +74,9 @@ export default class BeefTx {
   }
 
   /**
-     * @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.
-     */
+   * @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
@@ -105,7 +107,9 @@ export default class BeefTx {
       this.inputTxids = []
     } else {
       const inputTxids = {}
-      for (const input of this.tx.inputs) { inputTxids[input.sourceTXID] = true }
+      for (const input of this.tx.inputs) {
+        inputTxids[input.sourceTXID] = true
+      }
       this.inputTxids = Object.keys(inputTxids)
     }
   }

package/src/transaction/Broadcaster.ts

@@ -1,4 +1,4 @@
-import Transaction from './Transaction.js'
+import Transaction from './Transaction'
 
 /**
  * Defines the structure of a successful broadcast response.
@@ -44,22 +44,26 @@ export interface BroadcastFailure {
  *                                  The promise resolves to an array of broadcast result response objects.
  */
 export interface Broadcaster {
-  broadcast: (transaction: Transaction) =>
-  Promise<BroadcastResponse | BroadcastFailure>
-  broadcastMany?: (txs: Transaction[]) =>
-  Promise<object[]>
+  broadcast: (
+    transaction: Transaction
+  ) => Promise<BroadcastResponse | BroadcastFailure>
+  broadcastMany?: (txs: Transaction[]) => Promise<object[]>
 }
 
 /**
  * Convenience type guard for response from `Broadcaster.broadcast`
  */
-export function isBroadcastResponse (r: BroadcastResponse | BroadcastFailure): r is BroadcastResponse {
+export function isBroadcastResponse (
+  r: BroadcastResponse | BroadcastFailure
+): r is BroadcastResponse {
   return r.status === 'success'
 }
 
 /**
  * Convenience type guard for response from `Broadcaster.broadcast`
  */
-export function isBroadcastFailure (r: BroadcastResponse | BroadcastFailure): r is BroadcastFailure {
+export function isBroadcastFailure (
+  r: BroadcastResponse | BroadcastFailure
+): r is BroadcastFailure {
   return r.status === 'error'
 }

package/src/transaction/ChainTracker.ts

@@ -18,8 +18,8 @@
  *     // Implementation to check if the Merkle root is valid for the specified block height.
  *   }
  *  currentHeight: async () => {
-*     // Implementation to get the current block height.
-*   }
+ *     // Implementation to get the current block height.
+ *   }
  * };
  */
 export default interface ChainTracker {

package/src/transaction/FeeModel.ts

@@ -1,5 +1,5 @@
-import Transaction from './Transaction.js'
-import BigNumber from '../primitives/BigNumber.js'
+import Transaction from './Transaction'
+import BigNumber from '../primitives/BigNumber'
 
 /**
  * Represents the interface for a transaction fee model.

package/src/transaction/MerklePath.ts

@@ -1,6 +1,6 @@
-import { Reader, Writer, toHex, toArray } from '../primitives/utils.js'
-import { hash256 } from '../primitives/Hash.js'
-import ChainTracker from './ChainTracker.js'
+import { Reader, Writer, toHex, toArray } from '../primitives/utils'
+import { hash256 } from '../primitives/Hash'
+import ChainTracker from './ChainTracker'
 
 export interface MerklePathLeaf {
   offset: number
@@ -32,12 +32,14 @@ export interface MerklePathLeaf {
  */
 export default class MerklePath {
   blockHeight: number
-  path: Array<Array<{
+  path: Array<
+  Array<{
     offset: number
     hash?: string
     txid?: boolean
     duplicate?: boolean
-  }>>
+  }>
+  >
 
   /**
    * Creates a MerklePath instance from a hexadecimal string.
@@ -50,10 +52,15 @@ export default class MerklePath {
     return MerklePath.fromBinary(toArray(hex, 'hex'))
   }
 
-  static fromReader (reader: Reader, legalOffsetsOnly: boolean = true): MerklePath {
+  static fromReader (
+    reader: Reader,
+    legalOffsetsOnly: boolean = true
+  ): MerklePath {
     const blockHeight = reader.readVarIntNum()
     const treeHeight = reader.readUInt8()
-    const path = Array(treeHeight).fill(0).map(() => ([]))
+    const path = Array(treeHeight)
+      .fill(0)
+      .map(() => [])
     let flags, offset, nLeavesAtThisHeight
     for (let level = 0; level < treeHeight; level++) {
       nLeavesAtThisHeight = reader.readVarIntNum()
@@ -109,34 +116,48 @@ export default class MerklePath {
     return new MerklePath(height, [[{ offset: 0, hash: txid, txid: true }]])
   }
 
-  constructor (blockHeight: number, path: Array<Array<{
-    offset: number
-    hash?: string
-    txid?: boolean
-    duplicate?: boolean
-  }>>, legalOffsetsOnly: boolean = true) {
+  constructor (
+    blockHeight: number,
+    path: Array<
+    Array<{
+      offset: number
+      hash?: string
+      txid?: boolean
+      duplicate?: boolean
+    }>
+    >,
+    legalOffsetsOnly: boolean = true
+  ) {
     this.blockHeight = blockHeight
     this.path = path
 
     // store all of the legal offsets which we expect given the txid indices.
-    const legalOffsets = Array(this.path.length).fill(0).map(() => new Set())
+    const legalOffsets = Array(this.path.length)
+      .fill(0)
+      .map(() => new Set())
     this.path.map((leaves, height) => {
       if (leaves.length === 0 && height === 0) {
         throw new Error(`Empty level at height: ${height}`)
       }
       const offsetsAtThisHeight = new Set()
-      leaves.map(leaf => {
-        if (offsetsAtThisHeight.has(leaf.offset)) throw new Error(`Duplicate offset: ${leaf.offset}, at height: ${height}`)
+      leaves.map((leaf) => {
+        if (offsetsAtThisHeight.has(leaf.offset)) {
+          throw new Error(
+            `Duplicate offset: ${leaf.offset}, at height: ${height}`
+          )
+        }
         offsetsAtThisHeight.add(leaf.offset)
         if (height === 0) {
           if (!leaf.duplicate) {
             for (let h = 1; h < this.path.length; h++) {
-              legalOffsets[h].add(leaf.offset >> h ^ 1)
+              legalOffsets[h].add((leaf.offset >> h) ^ 1)
             }
           }
         } else {
           if (legalOffsetsOnly && !legalOffsets[height].has(leaf.offset)) {
-            throw new Error(`Invalid offset: ${leaf.offset}, at height: ${height}, with legal offsets: ${Array.from(legalOffsets[height]).join(', ')}`)
+            throw new Error(
+              `Invalid offset: ${leaf.offset}, at height: ${height}, with legal offsets: ${Array.from(legalOffsets[height]).join(', ')}`
+            )
           }
         }
       })
@@ -194,7 +215,7 @@ export default class MerklePath {
 
   //
   private indexOf (txid: string): number {
-    return this.path[0].find(l => l.hash === txid).offset
+    return this.path[0].find((l) => l.hash === txid).offset
   }
 
   /**
@@ -206,7 +227,7 @@ export default class MerklePath {
    */
   computeRoot (txid?: string): string {
     if (typeof txid !== 'string') {
-      txid = this.path[0].find(leaf => Boolean(leaf?.hash)).hash
+      txid = this.path[0].find((leaf) => Boolean(leaf?.hash)).hash
     }
     // Find the index of the txid at the lowest level of the Merkle tree
     const index = this.indexOf(txid)
@@ -214,9 +235,8 @@ export default class MerklePath {
       throw new Error(`This proof does not contain the txid: ${txid}`)
     }
     // Calculate the root using the index as a way to determine which direction to concatenate.
-    const hash = (m: string): string => toHex((
-      hash256(toArray(m, 'hex').reverse())
-    ).reverse())
+    const hash = (m: string): string =>
+      toHex(hash256(toArray(m, 'hex').reverse()).reverse())
     let workingHash = txid
 
     // special case for blocks with only one transaction
@@ -224,7 +244,7 @@ export default class MerklePath {
 
     for (let height = 0; height < this.path.length; height++) {
       const leaves = this.path[height]
-      const offset = index >> height ^ 1
+      const offset = (index >> height) ^ 1
       const leaf = this.findOrComputeLeaf(height, offset)
       if (typeof leaf !== 'object') {
         throw new Error(`Missing hash for index ${index} at height ${height}`)
@@ -248,12 +268,16 @@ export default class MerklePath {
    * @param height
    * @param offset
    */
-  findOrComputeLeaf (height: number, offset: number): MerklePathLeaf | undefined {
-    const hash = (m: string): string => toHex((
-      hash256(toArray(m, 'hex').reverse())
-    ).reverse())
+  findOrComputeLeaf (
+    height: number,
+    offset: number
+  ): MerklePathLeaf | undefined {
+    const hash = (m: string): string =>
+      toHex(hash256(toArray(m, 'hex').reverse()).reverse())
 
-    let leaf: MerklePathLeaf | undefined = this.path[height].find(l => l.offset === offset)
+    let leaf: MerklePathLeaf | undefined = this.path[height].find(
+      (l) => l.offset === offset
+    )
 
     if (leaf) return leaf
 
@@ -269,7 +293,11 @@ export default class MerklePath {
     if (!leaf1) return undefined
 
     let workinghash: string
-    if (leaf1.duplicate) { workinghash = hash(leaf0.hash + leaf0.hash) } else { workinghash = hash(leaf1.hash + leaf0.hash) }
+    if (leaf1.duplicate) {
+      workinghash = hash(leaf0.hash + leaf0.hash)
+    } else {
+      workinghash = hash(leaf1.hash + leaf0.hash)
+    }
     leaf = {
       offset,
       hash: workinghash
@@ -306,12 +334,16 @@ export default class MerklePath {
    */
   combine (other: MerklePath): void {
     if (this.blockHeight !== other.blockHeight) {
-      throw new Error('You cannot combine paths which do not have the same block height.')
+      throw new Error(
+        'You cannot combine paths which do not have the same block height.'
+      )
     }
     const root1 = this.computeRoot()
     const root2 = other.computeRoot()
     if (root1 !== root2) {
-      throw new Error('You cannot combine paths which do not have the same root.')
+      throw new Error(
+        'You cannot combine paths which do not have the same root.'
+      )
     }
     const combinedPath = []
     for (let h = 0; h < this.path.length; h++) {
@@ -320,12 +352,18 @@ export default class MerklePath {
         combinedPath[h].push(this.path[h][l])
       }
       for (let l = 0; l < other.path[h].length; l++) {
-        if (!(combinedPath[h].find(leaf => leaf.offset === other.path[h][l].offset) as boolean)) {
+        if (
+          !(combinedPath[h].find(
+            (leaf) => leaf.offset === other.path[h][l].offset
+          ) as boolean)
+        ) {
           combinedPath[h].push(other.path[h][l])
         } else {
           // Ensure that any elements which appear in both are not downgraded to a non txid.
           if (other.path[h][l]?.txid) {
-            const target = combinedPath[h].find(leaf => leaf.offset === other.path[h][l].offset)
+            const target = combinedPath[h].find(
+              (leaf) => leaf.offset === other.path[h][l].offset
+            )
             target.txid = true
           }
         }
@@ -342,13 +380,19 @@ export default class MerklePath {
    */
   trim () {
     const pushIfNew = (v: number, a: number[]) => {
-      if (a.length === 0 || a.slice(-1)[0] !== v) { a.push(v) }
+      if (a.length === 0 || a.slice(-1)[0] !== v) {
+        a.push(v)
+      }
     }
 
     const dropOffsetsFromLevel = (dropOffsets: number[], level: number) => {
       for (let i = dropOffsets.length; i >= 0; i--) {
-        const l = this.path[level].findIndex(n => n.offset === dropOffsets[i])
-        if (l >= 0) { this.path[level].splice(l, 1) }
+        const l = this.path[level].findIndex(
+          (n) => n.offset === dropOffsets[i]
+        )
+        if (l >= 0) {
+          this.path[level].splice(l, 1)
+        }
       }
     }