@bsv/sdk 1.3.12 → 1.3.14

package/dist/esm/src/transaction/Beef.js

@@ -2,6 +2,11 @@ import MerklePath from './MerklePath.js';
 import BeefTx from './BeefTx.js';
 import { Reader, Writer, toHex, toArray } from '../primitives/utils.js';
 import { hash256 } from '../primitives/Hash.js';
+function verifyTruthy(v) {
+    if (v == null)
+        throw new Error('Expected a valid value, but got undefined.');
+    return v;
+}
 export const BEEF_V1 = 4022206465; // 0100BEEF in LE order
 export const BEEF_V2 = 4022206466; // 0200BEEF in LE order
 export const ATOMIC_BEEF = 0x01010101; // 01010101
@@ -73,11 +78,11 @@ export class Beef {
         this.version = version;
     }
     /**
-       * @param txid of `beefTx` to find
-       * @returns `BeefTx` in `txs` with `txid`.
-       */
+     * @param txid of `beefTx` to find
+     * @returns `BeefTx` in `txs` with `txid`.
+     */
     findTxid(txid) {
-        return this.txs.find(tx => tx.txid === txid);
+        return this.txs.find((tx) => tx.txid === txid);
     }
     /**
      * Replaces `BeefTx` for this txid with txidOnly.
@@ -90,7 +95,7 @@ export class Beef {
      * @returns undefined if txid is unknown.
      */
     makeTxidOnly(txid) {
-        const i = this.txs.findIndex(tx => tx.txid === txid);
+        const i = this.txs.findIndex((tx) => tx.txid === txid);
         if (i === -1)
             return undefined;
         let btx = this.txs[i];
@@ -105,7 +110,8 @@ export class Beef {
      * @returns `MerklePath` with level zero hash equal to txid or undefined.
      */
     findBump(txid) {
-        return this.bumps.find(b => b.path[0].find(leaf => leaf.hash === txid));
+        return this.bumps.find((b) => b.path[0].some((leaf) => leaf.hash === txid) // ✅ Ensure boolean return with `.some()`
+        );
     }
     /**
      * Finds a Transaction in this `Beef`
@@ -118,12 +124,12 @@ export class Beef {
      */
     findTransactionForSigning(txid) {
         const beefTx = this.findTxid(txid);
-        if (!beefTx)
-            return undefined;
+        if ((beefTx == null) || (beefTx.tx == null))
+            return undefined; // Ensure beefTx.tx exists before using it
         for (const i of beefTx.tx.inputs) {
-            if (!i.sourceTransaction) {
-                const itx = this.findTxid(i.sourceTXID);
-                if (itx) {
+            if (i.sourceTransaction == null) {
+                const itx = this.findTxid(verifyTruthy(i.sourceTXID)); // Ensure sourceTXID is valid
+                if (itx != null) {
                     i.sourceTransaction = itx.tx;
                 }
             }
@@ -140,24 +146,24 @@ export class Beef {
      */
     findAtomicTransaction(txid) {
         const beefTx = this.findTxid(txid);
-        if (!beefTx)
-            return undefined;
+        if ((beefTx == null) || (beefTx.tx == null))
+            return undefined; // Ensure beefTx.tx exists before using it
         const addInputProof = (beef, tx) => {
             const mp = beef.findBump(tx.id('hex'));
-            if (mp) {
+            if (mp != null) {
                 tx.merklePath = mp;
             }
             else {
                 for (const i of tx.inputs) {
-                    if (!i.sourceTransaction) {
-                        const itx = beef.findTxid(i.sourceTXID);
-                        if (itx) {
+                    if (i.sourceTransaction == null) {
+                        const itx = beef.findTxid(verifyTruthy(i.sourceTXID)); // Ensure sourceTXID is valid
+                        if (itx != null) {
                             i.sourceTransaction = itx.tx;
                         }
                     }
-                    if (i.sourceTransaction) {
+                    if (i.sourceTransaction != null) {
                         const mp = beef.findBump(i.sourceTransaction.id('hex'));
-                        if (mp) {
+                        if (mp != null) {
                             i.sourceTransaction.merklePath = mp;
                         }
                         else {
@@ -167,20 +173,21 @@ export class Beef {
                 }
             }
         };
-        addInputProof(this, beefTx.tx);
+        addInputProof(this, beefTx.tx); // Safe because we checked that beefTx.tx exists
         return beefTx.tx;
     }
     /**
-       * Merge a MerklePath that is assumed to be fully valid.
-       * @param bump
-       * @returns index of merged bump
-       */
+     * Merge a MerklePath that is assumed to be fully valid.
+     * @param bump
+     * @returns index of merged bump
+     */
     mergeBump(bump) {
         let bumpIndex;
         // 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 < this.bumps.length; i++) {
             const b = this.bumps[i];
-            if (b === bump) { // Literally the same
+            if (b === bump) {
+                // Literally the same
                 return i;
             }
             if (b.blockHeight === bump.blockHeight) {
@@ -200,11 +207,11 @@ export class Beef {
             bumpIndex = this.bumps.length;
             this.bumps.push(bump);
         }
-        // review if any transactions are proven by this bump
+        // Review if any transactions are proven by this bump
         const b = this.bumps[bumpIndex];
         for (const tx of this.txs) {
             const txid = tx.txid;
-            if (!tx.bumpIndex) {
+            if (tx.bumpIndex == null) { // ✅ Explicitly check for null or undefined
                 for (const n of b.path[0]) {
                     if (n.hash === txid) {
                         tx.bumpIndex = bumpIndex;
@@ -217,16 +224,16 @@ export class Beef {
         return bumpIndex;
     }
     /**
-       * Merge a serialized transaction.
-       *
-       * Checks that a transaction with the same txid hasn't already been merged.
-       *
-       * Replaces existing transaction with same txid.
-       *
-       * @param rawTx
-       * @param bumpIndex Optional. If a number, must be valid index into bumps array.
-       * @returns txid of rawTx
-       */
+     * Merge a serialized transaction.
+     *
+     * Checks that a transaction with the same txid hasn't already been merged.
+     *
+     * Replaces existing transaction with same txid.
+     *
+     * @param rawTx
+     * @param bumpIndex Optional. If a number, must be valid index into bumps array.
+     * @returns txid of rawTx
+     */
     mergeRawTx(rawTx, bumpIndex) {
         const newTx = new BeefTx(rawTx, bumpIndex);
         this.removeExistingTxid(newTx.txid);
@@ -235,20 +242,20 @@ export class Beef {
         return newTx;
     }
     /**
-       * Merge a `Transaction` and any referenced `merklePath` and `sourceTransaction`, recursifely.
-       *
-       * Replaces existing transaction with same txid.
-       *
-       * Attempts to match an existing bump to the new transaction.
-       *
-       * @param tx
-       * @returns txid of tx
-       */
+     * Merge a `Transaction` and any referenced `merklePath` and `sourceTransaction`, recursifely.
+     *
+     * Replaces existing transaction with same txid.
+     *
+     * Attempts to match an existing bump to the new transaction.
+     *
+     * @param tx
+     * @returns txid of tx
+     */
     mergeTransaction(tx) {
         const txid = tx.id('hex');
         this.removeExistingTxid(txid);
         let bumpIndex;
-        if (tx.merklePath) {
+        if (tx.merklePath != null) {
             bumpIndex = this.mergeBump(tx.merklePath);
         }
         const newTx = new BeefTx(tx, bumpIndex);
@@ -257,7 +264,7 @@ export class Beef {
         bumpIndex = newTx.bumpIndex;
         if (bumpIndex === undefined) {
             for (const input of tx.inputs) {
-                if (input.sourceTransaction) {
+                if (input.sourceTransaction != null) {
                     this.mergeTransaction(input.sourceTransaction);
                 }
             }
@@ -265,18 +272,18 @@ export class Beef {
         return newTx;
     }
     /**
-       * Removes an existing transaction from the BEEF, given its TXID
-       * @param txid TXID of the transaction to remove
-       */
+     * Removes an existing transaction from the BEEF, given its TXID
+     * @param txid TXID of the transaction to remove
+     */
     removeExistingTxid(txid) {
-        const existingTxIndex = this.txs.findIndex(t => t.txid === txid);
+        const existingTxIndex = this.txs.findIndex((t) => t.txid === txid);
         if (existingTxIndex >= 0) {
             this.txs.splice(existingTxIndex, 1);
         }
     }
     mergeTxidOnly(txid) {
-        let tx = this.txs.find(t => t.txid === txid);
-        if (!tx) {
+        let tx = this.txs.find((t) => t.txid === txid);
+        if (tx == null) {
             tx = new BeefTx(txid);
             this.txs.push(tx);
             this.tryToValidateBumpIndex(tx);
@@ -285,15 +292,18 @@ export class Beef {
     }
     mergeBeefTx(btx) {
         let beefTx = this.findTxid(btx.txid);
-        if (btx.isTxidOnly && !beefTx) {
+        if (btx.isTxidOnly && (beefTx == null)) {
             beefTx = this.mergeTxidOnly(btx.txid);
         }
-        else if (btx._tx && (!beefTx || beefTx.isTxidOnly)) {
+        else if ((btx._tx != null) && ((beefTx == null) || beefTx.isTxidOnly)) {
             beefTx = this.mergeTransaction(btx._tx);
         }
-        else if (btx._rawTx && (!beefTx || beefTx.isTxidOnly)) {
+        else if ((btx._rawTx != null) && ((beefTx == null) || beefTx.isTxidOnly)) {
             beefTx = this.mergeRawTx(btx._rawTx);
         }
+        if (beefTx == null) {
+            throw new Error(`Failed to merge BeefTx for txid: ${btx.txid}`);
+        }
         return beefTx;
     }
     mergeBeef(beef) {
@@ -306,35 +316,35 @@ export class Beef {
         }
     }
     /**
-       * Sorts `txs` and checks structural validity of beef.
-       *
-       * Does NOT verify merkle roots.
-       *
-       * Validity requirements:
-       * 1. No 'known' txids, unless `allowTxidOnly` is true.
-       * 2. All transactions have bumps or their inputs chain back to bumps (or are known).
-       * 3. Order of transactions satisfies dependencies before dependents.
-       * 4. No transactions with duplicate txids.
-       *
-       * @param allowTxidOnly optional. If true, transaction txid only is assumed valid
-       */
+     * Sorts `txs` and checks structural validity of beef.
+     *
+     * Does NOT verify merkle roots.
+     *
+     * Validity requirements:
+     * 1. No 'known' txids, unless `allowTxidOnly` is true.
+     * 2. All transactions have bumps or their inputs chain back to bumps (or are known).
+     * 3. Order of transactions satisfies dependencies before dependents.
+     * 4. No transactions with duplicate txids.
+     *
+     * @param allowTxidOnly optional. If true, transaction txid only is assumed valid
+     */
     isValid(allowTxidOnly) {
         return this.verifyValid(allowTxidOnly).valid;
     }
     /**
-       * Sorts `txs` and confirms validity of transaction data contained in beef
-       * by validating structure of this beef and confirming computed merkle roots
-       * using `chainTracker`.
-       *
-       * Validity requirements:
-       * 1. No 'known' txids, unless `allowTxidOnly` is true.
-       * 2. All transactions have bumps or their inputs chain back to bumps (or are known).
-       * 3. Order of transactions satisfies dependencies before dependents.
-       * 4. No transactions with duplicate txids.
-       *
-       * @param chainTracker Used to verify computed merkle path roots for all bump txids.
-       * @param allowTxidOnly optional. If true, transaction txid is assumed valid
-       */
+     * Sorts `txs` and confirms validity of transaction data contained in beef
+     * by validating structure of this beef and confirming computed merkle roots
+     * using `chainTracker`.
+     *
+     * Validity requirements:
+     * 1. No 'known' txids, unless `allowTxidOnly` is true.
+     * 2. All transactions have bumps or their inputs chain back to bumps (or are known).
+     * 3. Order of transactions satisfies dependencies before dependents.
+     * 4. No transactions with duplicate txids.
+     *
+     * @param chainTracker Used to verify computed merkle path roots for all bump txids.
+     * @param allowTxidOnly optional. If true, transaction txid is assumed valid
+     */
     async verify(chainTracker, allowTxidOnly) {
         const r = this.verifyValid(allowTxidOnly);
         if (!r.valid)
@@ -348,20 +358,23 @@ export class Beef {
         return true;
     }
     verifyValid(allowTxidOnly) {
-        const r = { valid: false, roots: {} };
+        const r = {
+            valid: false,
+            roots: {}
+        };
         this.sortTxs();
         // valid txids: only txids if allowed, bump txids, then txids with input's in txids
         const txids = {};
         for (const tx of this.txs) {
             if (tx.isTxidOnly) {
-                if (!allowTxidOnly)
-                    return r;
+                if (allowTxidOnly !== true)
+                    return r; // ✅ Explicit check for `true`
                 txids[tx.txid] = true;
             }
         }
         const confirmComputedRoot = (b, txid) => {
             const root = b.computeRoot(txid);
-            if (!r.roots[b.blockHeight]) {
+            if (r.roots[b.blockHeight] === undefined || r.roots[b.blockHeight] === '') {
                 // accept the root as valid for this block and reuse for subsequent txids
                 r.roots[b.blockHeight] = root;
             }
@@ -372,9 +385,9 @@ export class Beef {
         };
         for (const b of this.bumps) {
             for (const n of b.path[0]) {
-                if (n.txid && n.hash) {
+                if (n.txid === true && typeof n.hash === 'string' && n.hash.length > 0) {
                     txids[n.hash] = true;
-                    // all txid hashes in all bumps must have agree on computed merkle path roots
+                    // All txid hashes in all bumps must agree on computed merkle path roots
                     if (!confirmComputedRoot(b, n.hash)) {
                         return r;
                     }
@@ -382,9 +395,8 @@ export class Beef {
             }
         }
         for (const t of this.txs) {
-            for (const i of t.inputTxids) 
             // all input txids must be included before they are referenced
-            {
+            for (const i of t.inputTxids) {
                 if (!txids[i])
                     return r;
             }
@@ -409,9 +421,9 @@ export class Beef {
         }
     }
     /**
-       * Returns a binary array representing the serialized BEEF
-       * @returns A binary array representing the BEEF
-       */
+     * Returns a binary array representing the serialized BEEF
+     * @returns A binary array representing the BEEF
+     */
     toBinary() {
         const writer = new Writer();
         this.toWriter(writer);
@@ -430,13 +442,13 @@ export class Beef {
     toBinaryAtomic(txid) {
         this.sortTxs();
         const tx = this.findTxid(txid);
-        if (!tx) {
+        if (tx == null) {
             throw new Error(`${txid} does not exist in this Beef`);
         }
-        let beef = this;
-        if (this.txs[this.txs.length - 1] !== tx) {
-            beef = this.clone();
-            const i = this.txs.findIndex(t => t.txid === txid);
+        // If the transaction is not the last one, clone and modify
+        const beef = (this.txs[this.txs.length - 1] === tx) ? this : this.clone();
+        if (beef !== this) {
+            const i = this.txs.findIndex((t) => t.txid === txid);
             beef.txs.splice(i + 1);
         }
         const writer = new Writer();
@@ -446,9 +458,9 @@ export class Beef {
         return writer.toArray();
     }
     /**
-       * Returns a hex string representing the serialized BEEF
-       * @returns A hex string representing the BEEF
-       */
+     * Returns a hex string representing the serialized BEEF
+     * @returns A hex string representing the BEEF
+     */
     toHex() {
         return toHex(this.toBinary());
     }
@@ -478,39 +490,39 @@ export class Beef {
         return beef;
     }
     /**
-       * Constructs an instance of the Beef class based on the provided binary array
-       * @param bin The binary array from which to construct BEEF
-       * @returns An instance of the Beef class constructed from the binary data
-       */
+     * Constructs an instance of the Beef class based on the provided binary array
+     * @param bin The binary array from which to construct BEEF
+     * @returns An instance of the Beef class constructed from the binary data
+     */
     static fromBinary(bin) {
         const br = new Reader(bin);
         return Beef.fromReader(br);
     }
     /**
-       * Constructs an instance of the Beef class based on the provided string
-       * @param s The string value from which to construct BEEF
-       * @param enc The encoding of the string value from which BEEF should be constructed
-       * @returns An instance of the Beef class constructed from the string
-       */
+     * Constructs an instance of the Beef class based on the provided string
+     * @param s The string value from which to construct BEEF
+     * @param enc The encoding of the string value from which BEEF should be constructed
+     * @returns An instance of the Beef class constructed from the string
+     */
     static fromString(s, enc = 'hex') {
         const bin = toArray(s, enc);
         const br = new Reader(bin);
         return Beef.fromReader(br);
     }
     /**
-       * Try to validate newTx.bumpIndex by looking for an existing bump
-       * that proves newTx.txid
-       *
-       * @param newTx A new `BeefTx` that has been added to this.txs
-       * @returns true if a bump was found, false otherwise
-       */
+     * Try to validate newTx.bumpIndex by looking for an existing bump
+     * that proves newTx.txid
+     *
+     * @param newTx A new `BeefTx` that has been added to this.txs
+     * @returns true if a bump was found, false otherwise
+     */
     tryToValidateBumpIndex(newTx) {
         if (newTx.bumpIndex !== undefined) {
             return true;
         }
         const txid = newTx.txid;
         for (let i = 0; i < this.bumps.length; i++) {
-            const j = this.bumps[i].path[0].findIndex(b => b.hash === txid);
+            const j = this.bumps[i].path[0].findIndex((b) => b.hash === txid);
             if (j >= 0) {
                 newTx.bumpIndex = i;
                 this.bumps[i].path[0][j].txid = true;
@@ -520,15 +532,15 @@ export class Beef {
         return false;
     }
     /**
-       * Sort the `txs` by input txid dependency order:
-       * - Oldest Tx Anchored by Path or txid only
-       * - Newer Txs depending on Older parents
-       * - Newest Tx
-       *
-       * with proof (MerklePath) last, longest chain of dependencies first
-       *
-       * @returns `{ missingInputs, notValid, valid, withMissingInputs }`
-       */
+     * Sort the `txs` by input txid dependency order:
+     * - Oldest Tx Anchored by Path or txid only
+     * - Newer Txs depending on Older parents
+     * - Newest Tx
+     *
+     * with proof (MerklePath) last, longest chain of dependencies first
+     *
+     * @returns `{ missingInputs, notValid, valid, withMissingInputs }`
+     */
     sortTxs() {
         // Hashtable of valid txids (with proof or all inputs chain to proof)
         const validTxids = {};
@@ -568,7 +580,7 @@ export class Beef {
             // link their inputs that exist in this beef,
             // make a note of missing inputs.
             for (const inputTxid of tx.inputTxids) {
-                if (!txidToTx[inputTxid]) {
+                if (txidToTx[inputTxid] === undefined) { // Explicitly check for undefined
                     missingInputs[inputTxid] = true;
                     hasMissingInput = true;
                 }
@@ -587,7 +599,7 @@ export class Beef {
             // all tx are isValid false, hasProof false.
             // if isTxidOnly then has inputTxids
             for (const tx of oldQueue) {
-                if (tx.inputTxids.every(txid => validTxids[txid])) {
+                if (tx.inputTxids.every((txid) => validTxids[txid])) {
                     validTxids[tx.txid] = true;
                     result.push(tx);
                 }
@@ -602,28 +614,32 @@ export class Beef {
         // transactions that don't have proofs and don't chain to proofs
         const txsNotValid = queue;
         // New order of txs is unsortable (missing inputs or depends on missing inputs), txidOnly, sorted (so newest sorted is last)
-        this.txs = txsMissingInputs.concat(txsNotValid).concat(txidOnly).concat(result);
+        this.txs = txsMissingInputs
+            .concat(txsNotValid)
+            .concat(txidOnly)
+            .concat(result);
         return {
             missingInputs: Object.keys(missingInputs),
-            notValid: txsNotValid.map(tx => tx.txid),
+            notValid: txsNotValid.map((tx) => tx.txid),
             valid: Object.keys(validTxids),
-            withMissingInputs: txsMissingInputs.map(tx => tx.txid),
-            txidOnly: txidOnly.map(tx => tx.txid)
+            withMissingInputs: txsMissingInputs.map((tx) => tx.txid),
+            txidOnly: txidOnly.map((tx) => tx.txid)
         };
     }
     /**
-       * @returns a shallow copy of this beef
-       */
+     * @returns a shallow copy of this beef
+     */
     clone() {
         const c = new Beef();
+        c.version = this.version;
         c.bumps = Array.from(this.bumps);
         c.txs = Array.from(this.txs);
         return c;
     }
     /**
-       * Ensure that all the txids in `knownTxids` are txidOnly
-       * @param knownTxids
-       */
+     * Ensure that all the txids in `knownTxids` are txidOnly
+     * @param knownTxids
+     */
     trimKnownTxids(knownTxids) {
         for (let i = 0; i < this.txs.length;) {
             const tx = this.txs[i];
@@ -644,15 +660,18 @@ export class Beef {
         return r.valid;
     }
     /**
-       * @returns Summary of `Beef` contents as multi-line string.
-       */
+     * @returns Summary of `Beef` contents as multi-line string.
+     */
     toLogString() {
         let log = '';
-        log += `BEEF with ${this.bumps.length} BUMPS and ${this.txs.length} Transactions, isValid ${this.isValid()}\n`;
+        log += `BEEF with ${this.bumps.length} BUMPS and ${this.txs.length} Transactions, isValid ${this.isValid().toString()}\n`;
         let i = -1;
         for (const b of this.bumps) {
             i++;
-            log += `  BUMP ${i}\n    block: ${b.blockHeight}\n    txids: [\n${b.path[0].filter(n => !!n.txid).map(n => `      '${n.hash}'`).join(',\n')}\n    ]\n`;
+            log += `  BUMP ${i}\n    block: ${b.blockHeight}\n    txids: [\n${b.path[0]
+                .filter((n) => n.txid === true) // ✅ Explicitly check if txid is `true`
+                .map((n) => `      '${n.hash ?? ''}'`)
+                .join(',\n')}\n    ]\n`;
         }
         i = -1;
         for (const t of this.txs) {
@@ -665,32 +684,35 @@ export class Beef {
                 log += '    txidOnly\n';
             }
             else {
-                log += `    rawTx length=${t.rawTx.length}\n`;
+                log += `    rawTx length=${t.rawTx?.length ?? 0}\n`; // ✅ Fix applied here
             }
             if (t.inputTxids.length > 0) {
-                log += `    inputs: [\n${t.inputTxids.map(it => `      '${it}'`).join(',\n')}\n    ]\n`;
+                log += `    inputs: [\n${t.inputTxids
+                    .map((it) => `      '${it}'`)
+                    .join(',\n')}\n    ]\n`;
             }
         }
         return log;
     }
     /**
-     * In some circumstances it may be helpful for the BUMP MerkePaths to include
-     * leaves that can be computed from row zero.
-     */
+   * In some circumstances it may be helpful for the BUMP MerklePaths to include
+   * leaves that can be computed from row zero.
+   */
     addComputedLeaves() {
-        const beef = this;
-        const hash = (m) => toHex((hash256(toArray(m, 'hex').reverse())).reverse());
-        for (const bump of beef.bumps) {
+        const hash = (m) => toHex(hash256(toArray(m, 'hex').reverse()).reverse());
+        for (const bump of this.bumps) { // ✅ Use `this` instead of `beef`
             for (let row = 1; row < bump.path.length; row++) {
                 for (const leafL of bump.path[row - 1]) {
-                    if (leafL.hash && (leafL.offset & 1) === 0) {
-                        const leafR = bump.path[row - 1].find(l => l.offset === leafL.offset + 1);
+                    if (typeof leafL.hash === 'string' && (leafL.offset & 1) === 0) {
+                        const leafR = bump.path[row - 1].find((l) => l.offset === leafL.offset + 1);
                         const offsetOnRow = leafL.offset >> 1;
-                        if (leafR && leafR.hash && bump.path[row].findIndex(l => l.offset === offsetOnRow) === -1) {
-                            // computable leaf is missing... add it.
+                        if (leafR !== undefined &&
+                            typeof leafR.hash === 'string' &&
+                            bump.path[row].every((l) => l.offset !== offsetOnRow)) {
+                            // Computable leaf is missing... add it.
                             bump.path[row].push({
                                 offset: offsetOnRow,
-                                // string concatenation puts the right leaf on the left of the left leaf hash :-)
+                                // String concatenation puts the right leaf on the left of the left leaf hash
                                 hash: hash(leafR.hash + leafL.hash)
                             });
                         }