@bsv/sdk 1.7.6 → 1.7.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.7.6",
+  "version": "1.7.7",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/transaction/Beef.ts

@@ -77,6 +77,7 @@ export class Beef {
   txs: BeefTx[] = []
   version: number = BEEF_V2
   atomicTxid: string | undefined = undefined
+  private txidIndex: Map<string, BeefTx> | undefined = undefined
 
   constructor (version: number = BEEF_V2) {
     this.version = version
@@ -87,7 +88,25 @@ export class Beef {
    * @returns `BeefTx` in `txs` with `txid`.
    */
   findTxid (txid: string): BeefTx | undefined {
-    return this.txs.find((tx) => tx.txid === txid)
+    return this.ensureTxidIndex().get(txid)
+  }
+
+  private ensureTxidIndex (): Map<string, BeefTx> {
+    if (this.txidIndex == null) {
+      this.txidIndex = new Map<string, BeefTx>()
+      for (const tx of this.txs) {
+        this.txidIndex.set(tx.txid, tx)
+      }
+    }
+    return this.txidIndex
+  }
+
+  private deleteFromIndex (txid: string): void {
+    this.txidIndex?.delete(txid)
+  }
+
+  private addToIndex (tx: BeefTx): void {
+    this.txidIndex?.set(tx.txid, tx)
   }
 
   /**
@@ -107,6 +126,7 @@ export class Beef {
     if (btx.isTxidOnly) {
       return btx
     }
+    this.deleteFromIndex(txid)
     this.txs.splice(i, 1)
     btx = this.mergeTxidOnly(txid)
     return btx
@@ -254,6 +274,7 @@ export class Beef {
     const newTx: BeefTx = new BeefTx(rawTx, bumpIndex)
     this.removeExistingTxid(newTx.txid)
     this.txs.push(newTx)
+    this.addToIndex(newTx)
     this.tryToValidateBumpIndex(newTx)
     return newTx
   }
@@ -277,6 +298,7 @@ export class Beef {
     }
     const newTx = new BeefTx(tx, bumpIndex)
     this.txs.push(newTx)
+    this.addToIndex(newTx)
     this.tryToValidateBumpIndex(newTx)
     bumpIndex = newTx.bumpIndex
     if (bumpIndex === undefined) {
@@ -296,15 +318,17 @@ export class Beef {
   removeExistingTxid (txid: string): void {
     const existingTxIndex = this.txs.findIndex((t) => t.txid === txid)
     if (existingTxIndex >= 0) {
+      this.deleteFromIndex(txid)
       this.txs.splice(existingTxIndex, 1)
     }
   }
 
   mergeTxidOnly (txid: string): BeefTx {
-    let tx = this.txs.find((t) => t.txid === txid)
+    let tx = this.findTxid(txid)
     if (tx == null) {
       tx = new BeefTx(txid)
       this.txs.push(tx)
+      this.addToIndex(tx)
       this.tryToValidateBumpIndex(tx)
     }
     return tx
@@ -743,6 +767,7 @@ export class Beef {
     c.version = this.version
     c.bumps = Array.from(this.bumps)
     c.txs = Array.from(this.txs)
+    c.txidIndex = undefined
     return c
   }
 
@@ -754,6 +779,7 @@ export class Beef {
     for (let i = 0; i < this.txs.length;) {
       const tx = this.txs[i]
       if (tx.isTxidOnly && knownTxids.includes(tx.txid)) {
+        this.deleteFromIndex(tx.txid)
         this.txs.splice(i, 1)
       } else {
         i++

package/src/transaction/Transaction.ts

@@ -912,49 +912,49 @@ export default class Transaction {
     const writer = new Writer()
     writer.writeUInt32LE(BEEF_V1)
     const BUMPs: MerklePath[] = []
+    const bumpIndexByInstance = new Map<MerklePath, number>()
+    const bumpIndexByRoot = new Map<string, number>()
     const txs: Array<{ tx: Transaction, pathIndex?: number }> = []
+    const seenTxids = new Set<string>()
+
+    const getBumpIndex = (merklePath: MerklePath): number => {
+      const existingByInstance = bumpIndexByInstance.get(merklePath)
+      if (existingByInstance !== undefined) {
+        return existingByInstance
+      }
+
+      const key = `${merklePath.blockHeight}:${merklePath.computeRoot()}`
+      const existingByRoot = bumpIndexByRoot.get(key)
+      if (existingByRoot !== undefined) {
+        BUMPs[existingByRoot].combine(merklePath)
+        bumpIndexByInstance.set(merklePath, existingByRoot)
+        return existingByRoot
+      }
+
+      const newIndex = BUMPs.length
+      BUMPs.push(merklePath)
+      bumpIndexByInstance.set(merklePath, newIndex)
+      bumpIndexByRoot.set(key, newIndex)
+      return newIndex
+    }
 
     // Recursive function to add paths and input transactions for a TX
     const addPathsAndInputs = (tx: Transaction): void => {
-      const obj: { tx: Transaction, pathIndex?: number } = { tx }
-      const hasProof = typeof tx.merklePath === 'object'
-      if (hasProof) {
-        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
-            obj.pathIndex = i
-            added = true
-            break
-          }
-          if (tx.merklePath !== null && tx.merklePath !== undefined && BUMPs[i].blockHeight === tx.merklePath.blockHeight) {
-            // Probably the same...
-            const rootA = BUMPs[i].computeRoot()
-            const rootB = tx.merklePath.computeRoot()
-            if (rootA === rootB) {
-              // Definitely the same... combine them to save space
-              BUMPs[i].combine(tx.merklePath)
-              obj.pathIndex = i
-              added = true
-              break
-            }
-          }
-        }
-        // Finally, if the proof is not yet added, add a new path.
-        if (!added) {
-          obj.pathIndex = BUMPs.length
-          if (tx.merklePath !== null && tx.merklePath !== undefined) {
-            BUMPs.push(tx.merklePath)
-          }
-        }
+      const txid = tx.id('hex')
+      if (seenTxids.has(txid)) {
+        return
       }
-      const duplicate = txs.some((x) => x.tx.id('hex') === tx.id('hex'))
-      if (!duplicate) {
-        txs.unshift(obj)
+
+      const obj: { tx: Transaction, pathIndex?: number } = { tx }
+      const merklePath = tx.merklePath
+      const hasProof = typeof merklePath === 'object'
+
+      if (hasProof && merklePath != null) {
+        obj.pathIndex = getBumpIndex(merklePath)
       }
+
       if (!hasProof) {
-        for (let i = 0; i < tx.inputs.length; i++) {
+        for (let i = tx.inputs.length - 1; i >= 0; i--) {
           const input = tx.inputs[i]
           if (typeof input.sourceTransaction === 'object') {
             addPathsAndInputs(input.sourceTransaction)
@@ -963,6 +963,9 @@ export default class Transaction {
           }
         }
       }
+
+      seenTxids.add(txid)
+      txs.push(obj)
     }
 
     addPathsAndInputs(this)