@bsv/sdk 2.0.12 → 2.0.13

package/src/script/templates/__tests/RPuzzle.test.ts

@@ -0,0 +1,134 @@
+import RPuzzle from '../RPuzzle'
+import Spend from '../../Spend'
+import LockingScript from '../../LockingScript'
+import Transaction from '../../../transaction/Transaction'
+import PrivateKey from '../../../primitives/PrivateKey'
+import BigNumber from '../../../primitives/BigNumber'
+import Curve from '../../../primitives/Curve'
+
+const ZERO_TXID = '0'.repeat(64)
+
+function getRValue (k: BigNumber): number[] {
+  const c = new Curve()
+  let r = c.g.mul(k).x?.umod(c.n)?.toArray()
+  if (r == null) return []
+  if (r[0] > 127) r = [0, ...r]
+  return r
+}
+
+async function buildRPuzzleSpend (
+  puz: RPuzzle,
+  k: BigNumber,
+  privateKey: PrivateKey,
+  r: number[],
+  signOutputs: 'all' | 'none' | 'single' = 'all',
+  anyoneCanPay: boolean = false
+): Promise<Spend> {
+  const lockingScript: LockingScript = puz.lock(r)
+  const sourceTx = new Transaction(1, [], [{ lockingScript, satoshis: 1 }], 0)
+  const spendTx = new Transaction(
+    1,
+    [{ sourceTransaction: sourceTx, sourceOutputIndex: 0, sequence: 0xffffffff }],
+    [{ lockingScript: LockingScript.fromASM('OP_1'), satoshis: 1 }],
+    0
+  )
+  const unlockingScript = await puz.unlock(k, privateKey, signOutputs, anyoneCanPay).sign(spendTx, 0)
+  return new Spend({
+    sourceTXID: sourceTx.id('hex'),
+    sourceOutputIndex: 0,
+    sourceSatoshis: 1,
+    lockingScript,
+    transactionVersion: 1,
+    otherInputs: [],
+    outputs: spendTx.outputs,
+    inputIndex: 0,
+    unlockingScript,
+    inputSequence: 0xffffffff,
+    lockTime: 0
+  })
+}
+
+describe('RPuzzle – additional coverage', () => {
+  const k = new BigNumber(12345678)
+  const privateKey = new PrivateKey(1)
+  const r = getRValue(k)
+
+  describe('signOutputs variations', () => {
+    it('signs with signOutputs=none', async () => {
+      const puz = new RPuzzle()
+      const spend = await buildRPuzzleSpend(puz, k, privateKey, r, 'none')
+      expect(spend.validate()).toBe(true)
+    })
+
+    it('signs with signOutputs=single', async () => {
+      const puz = new RPuzzle()
+      const spend = await buildRPuzzleSpend(puz, k, privateKey, r, 'single')
+      expect(spend.validate()).toBe(true)
+    })
+
+    it('signs with anyoneCanPay=true', async () => {
+      const puz = new RPuzzle()
+      const spend = await buildRPuzzleSpend(puz, k, privateKey, r, 'all', true)
+      expect(spend.validate()).toBe(true)
+    })
+  })
+
+  describe('estimateLength', () => {
+    it('returns 108', async () => {
+      const puz = new RPuzzle()
+      const result = await puz.unlock(k, privateKey).estimateLength()
+      expect(result).toBe(108)
+    })
+  })
+
+  describe('missing source transaction', () => {
+    it('throws when input has no sourceTransaction', async () => {
+      const puz = new RPuzzle()
+      const lockingScript = puz.lock(r)
+      // Construct a tx where the input has no sourceTransaction
+      const spendTx = new Transaction(
+        1,
+        [{ sourceTXID: ZERO_TXID, sourceOutputIndex: 0, sequence: 0xffffffff }],
+        [],
+        0
+      )
+      await expect(
+        puz.unlock(k, privateKey).sign(spendTx, 0)
+      ).rejects.toThrow('The source transaction is needed')
+    })
+  })
+
+  describe('hash type variants', () => {
+    it('SHA256 RPuzzle round-trips using hashed r value', async () => {
+      const { sha256 } = await import('../../../primitives/Hash')
+      const hashedR = sha256(r)
+      const puz = new RPuzzle('SHA256')
+      const spend = await buildRPuzzleSpend(puz, k, privateKey, hashedR)
+      expect(spend.validate()).toBe(true)
+    })
+
+    it('SHA1 RPuzzle round-trips using hashed r value', async () => {
+      const { sha1 } = await import('../../../primitives/Hash')
+      const hashedR = sha1(r)
+      const puz = new RPuzzle('SHA1')
+      const spend = await buildRPuzzleSpend(puz, k, privateKey, hashedR)
+      expect(spend.validate()).toBe(true)
+    })
+
+    it('RIPEMD160 RPuzzle round-trips using hashed r value', async () => {
+      const { ripemd160 } = await import('../../../primitives/Hash')
+      const hashedR = ripemd160(r)
+      const puz = new RPuzzle('RIPEMD160')
+      const spend = await buildRPuzzleSpend(puz, k, privateKey, hashedR)
+      expect(spend.validate()).toBe(true)
+    })
+
+    it('HASH160 RPuzzle round-trips using hashed r value', async () => {
+      const { hash160 } = await import('../../../primitives/Hash')
+      const hashedR = hash160(r)
+      const puz = new RPuzzle('HASH160')
+      const spend = await buildRPuzzleSpend(puz, k, privateKey, hashedR)
+      expect(spend.validate()).toBe(true)
+    })
+  })
+})

package/src/transaction/MerklePath.ts

@@ -482,4 +482,159 @@ export default class MerklePath {
       dropOffsetsFromLevel(dropOffsets, h)
     }
   }
+
+  /**
+   * Cached leaf finder for extract(). Uses Map-based indexes for O(1) lookups
+   * and caches computed intermediate hashes to avoid redundant work.
+   */
+  private cachedFindLeaf (
+    height: number,
+    offset: number,
+    sourceIndex: Array<Map<number, MerklePathLeaf>>,
+    hashCache: Map<string, MerklePathLeaf | undefined>,
+    maxOffset: number
+  ): MerklePathLeaf | undefined {
+    const key = `${height}:${offset}`
+    if (hashCache.has(key)) return hashCache.get(key)
+
+    const doHash = (m: string): string =>
+      toHex(hash256(toArray(m, 'hex').reverse()).reverse())
+
+    let leaf: MerklePathLeaf | undefined = height < sourceIndex.length
+      ? sourceIndex[height].get(offset)
+      : undefined
+
+    if (leaf != null) {
+      hashCache.set(key, leaf)
+      return leaf
+    }
+
+    if (height === 0) {
+      hashCache.set(key, undefined)
+      return undefined
+    }
+
+    const h = height - 1
+    const l = offset << 1
+    const leaf0 = this.cachedFindLeaf(h, l, sourceIndex, hashCache, maxOffset)
+    if (leaf0?.hash == null || leaf0.hash === '') {
+      hashCache.set(key, undefined)
+      return undefined
+    }
+
+    const leaf1 = this.cachedFindLeaf(h, l + 1, sourceIndex, hashCache, maxOffset)
+    if (leaf1?.hash == null) {
+      if (leaf1?.duplicate === true || (this.path.length === 1 && l === (maxOffset >> h))) {
+        leaf = { offset, hash: doHash(leaf0.hash + leaf0.hash) }
+        hashCache.set(key, leaf)
+        return leaf
+      }
+      hashCache.set(key, undefined)
+      return undefined
+    }
+
+    const workinghash = leaf1.duplicate === true
+      ? doHash(leaf0.hash + leaf0.hash)
+      : doHash((leaf1.hash ?? '') + (leaf0.hash ?? ''))
+    leaf = { offset, hash: workinghash }
+    hashCache.set(key, leaf)
+    return leaf
+  }
+
+  /**
+   * Extracts a minimal compound MerklePath covering only the specified transaction IDs.
+   *
+   * Given a compound MerklePath (e.g. all block txids at level 0, or a trimmed
+   * compound path), this method reconstructs the sibling hashes at each tree level
+   * for every requested txid using cached Map-indexed lookups, then assembles them
+   * into a single trimmed compound path.
+   *
+   * The extracted path is verified to compute the same Merkle root as the source.
+   *
+   * @param {string[]} txids - Transaction IDs to extract proofs for.
+   * @returns {MerklePath} - A new trimmed compound MerklePath covering only the requested txids.
+   * @throws {Error} - If no txids are provided, a txid is not found, or the roots do not match.
+   *
+   * @example
+   * // Full block compound path (all txids at level 0)
+   * const fullBlock = new MerklePath(height, [allTxidsAtLevel0])
+   * // Extract a smaller compound proof covering just two transactions
+   * const twoTxProof = fullBlock.extract([txid1, txid2])
+   * twoTxProof.computeRoot(txid1) // === fullBlock.computeRoot()
+   */
+  extract (txids: string[]): MerklePath {
+    if (txids.length === 0) {
+      throw new Error('At least one txid must be provided to extract')
+    }
+
+    const originalRoot = this.computeRoot()
+    const maxOffset = this.path[0].reduce((max, l) => Math.max(max, l.offset), 0)
+    const treeHeight = Math.max(this.path.length, 32 - Math.clz32(maxOffset))
+
+    // Build O(1) lookup indexes for the source path
+    const sourceIndex: Array<Map<number, MerklePathLeaf>> = new Array(this.path.length)
+    for (let h = 0; h < this.path.length; h++) {
+      const map = new Map<number, MerklePathLeaf>()
+      for (const leaf of this.path[h]) map.set(leaf.offset, leaf)
+      sourceIndex[h] = map
+    }
+
+    const hashCache = new Map<string, MerklePathLeaf | undefined>()
+
+    // Build txid-to-offset index for O(1) lookup
+    const txidToOffset = new Map<string, number>()
+    for (const leaf of this.path[0]) {
+      if (leaf.hash != null) txidToOffset.set(leaf.hash, leaf.offset)
+    }
+
+    // Collect all needed leaves per level
+    const neededPerLevel: Array<Map<number, MerklePathLeaf>> = new Array(treeHeight)
+    for (let h = 0; h < treeHeight; h++) neededPerLevel[h] = new Map()
+
+    for (const txid of txids) {
+      const txOffset = txidToOffset.get(txid)
+      if (txOffset === undefined) {
+        throw new Error(`Transaction ID ${txid} not found in the Merkle Path`)
+      }
+
+      // Level 0: the txid leaf + its sibling
+      neededPerLevel[0].set(txOffset, { offset: txOffset, txid: true, hash: txid })
+      const sib0Offset = txOffset ^ 1
+      if (!neededPerLevel[0].has(sib0Offset)) {
+        const sib = this.cachedFindLeaf(0, sib0Offset, sourceIndex, hashCache, maxOffset)
+        if (sib != null) neededPerLevel[0].set(sib0Offset, sib)
+      }
+
+      // Higher levels: just the sibling at each height
+      for (let h = 1; h < treeHeight; h++) {
+        const sibOffset = (txOffset >> h) ^ 1
+        if (neededPerLevel[h].has(sibOffset)) continue
+        const sib = this.cachedFindLeaf(h, sibOffset, sourceIndex, hashCache, maxOffset)
+        if (sib != null) {
+          neededPerLevel[h].set(sibOffset, sib)
+        } else if ((txOffset >> h) === (maxOffset >> h)) {
+          neededPerLevel[h].set(sibOffset, { offset: sibOffset, duplicate: true })
+        }
+      }
+    }
+
+    // Build sorted compound path
+    const compoundPath: Array<Array<{ offset: number, hash?: string, txid?: boolean, duplicate?: boolean }>> = new Array(treeHeight)
+    for (let h = 0; h < treeHeight; h++) {
+      compoundPath[h] = Array.from(neededPerLevel[h].values())
+        .sort((a, b) => a.offset - b.offset)
+    }
+
+    const compound = new MerklePath(this.blockHeight, compoundPath)
+    compound.trim()
+
+    const extractedRoot = compound.computeRoot()
+    if (extractedRoot !== originalRoot) {
+      throw new Error(
+        `Extracted path root ${extractedRoot} does not match original root ${originalRoot}`
+      )
+    }
+
+    return compound
+  }
 }

package/src/transaction/__tests/BeefParty.additional.test.ts

@@ -0,0 +1,22 @@
+import BeefParty from '../BeefParty'
+import { Beef } from '../Beef'
+
+describe('BeefParty – additional coverage', () => {
+  describe('mergeBeefFromParty', () => {
+    it('merges a Beef object directly (non-array branch)', () => {
+      const bp = new BeefParty(['alice'])
+      const b = new Beef()
+      bp.mergeBeefFromParty('alice', b)
+      // No error thrown means the Beef object branch executed
+      expect(bp.isParty('alice')).toBe(true)
+    })
+
+    it('merges a binary Beef (array branch) via Beef.fromBinary', () => {
+      const bp = new BeefParty(['bob'])
+      const emptyBeef = new Beef()
+      const binary = emptyBeef.toBinary()
+      bp.mergeBeefFromParty('bob', binary)
+      expect(bp.isParty('bob')).toBe(true)
+    })
+  })
+})

package/src/transaction/__tests/Broadcaster.test.ts

@@ -0,0 +1,159 @@
+import {
+  BroadcastResponse,
+  BroadcastFailure,
+  isBroadcastResponse,
+  isBroadcastFailure
+} from '../../transaction/Broadcaster'
+
+// Broadcaster.ts contains two interfaces (BroadcastResponse, BroadcastFailure, Broadcaster)
+// and two exported type-guard functions.  The interfaces have no runtime representation,
+// so coverage comes entirely from exercising isBroadcastResponse and isBroadcastFailure.
+
+describe('isBroadcastResponse', () => {
+  it('returns true for an object with status "success"', () => {
+    const r: BroadcastResponse = {
+      status: 'success',
+      txid: 'abc123',
+      message: 'broadcast successful'
+    }
+    expect(isBroadcastResponse(r)).toBe(true)
+  })
+
+  it('returns false for an object with status "error"', () => {
+    const r: BroadcastFailure = {
+      status: 'error',
+      code: '500',
+      description: 'Internal Server Error'
+    }
+    expect(isBroadcastResponse(r)).toBe(false)
+  })
+
+  it('narrows the type to BroadcastResponse inside a conditional', () => {
+    const r: BroadcastResponse | BroadcastFailure = {
+      status: 'success',
+      txid: 'deadbeef',
+      message: 'ok',
+      competingTxs: ['aabbcc']
+    }
+    if (isBroadcastResponse(r)) {
+      expect(r.txid).toBe('deadbeef')
+      expect(r.message).toBe('ok')
+      expect(r.competingTxs).toEqual(['aabbcc'])
+    } else {
+      fail('Expected isBroadcastResponse to return true')
+    }
+  })
+
+  it('returns false even when the failure object has extra fields', () => {
+    const r: BroadcastFailure = {
+      status: 'error',
+      code: '404',
+      txid: 'txidfail',
+      description: 'Not found',
+      more: { detail: 'extra' }
+    }
+    expect(isBroadcastResponse(r)).toBe(false)
+  })
+})
+
+describe('isBroadcastFailure', () => {
+  it('returns true for an object with status "error"', () => {
+    const r: BroadcastFailure = {
+      status: 'error',
+      code: 'ERR_UNKNOWN',
+      description: 'Something went wrong'
+    }
+    expect(isBroadcastFailure(r)).toBe(true)
+  })
+
+  it('returns false for an object with status "success"', () => {
+    const r: BroadcastResponse = {
+      status: 'success',
+      txid: 'txid1',
+      message: 'done'
+    }
+    expect(isBroadcastFailure(r)).toBe(false)
+  })
+
+  it('narrows the type to BroadcastFailure inside a conditional', () => {
+    const r: BroadcastResponse | BroadcastFailure = {
+      status: 'error',
+      code: '503',
+      txid: 'tx503',
+      description: 'Service unavailable',
+      more: { raw: 'body' }
+    }
+    if (isBroadcastFailure(r)) {
+      expect(r.code).toBe('503')
+      expect(r.description).toBe('Service unavailable')
+      expect(r.txid).toBe('tx503')
+      expect(r.more).toEqual({ raw: 'body' })
+    } else {
+      fail('Expected isBroadcastFailure to return true')
+    }
+  })
+
+  it('returns false even when the success object has an optional competingTxs field', () => {
+    const r: BroadcastResponse = {
+      status: 'success',
+      txid: 't1',
+      message: 'm1',
+      competingTxs: ['other']
+    }
+    expect(isBroadcastFailure(r)).toBe(false)
+  })
+
+  it('handles BroadcastFailure with only the required fields', () => {
+    const r: BroadcastFailure = {
+      status: 'error',
+      code: '400',
+      description: 'Bad request'
+    }
+    expect(isBroadcastFailure(r)).toBe(true)
+    if (isBroadcastFailure(r)) {
+      expect(r.txid).toBeUndefined()
+      expect(r.more).toBeUndefined()
+    }
+  })
+})
+
+describe('BroadcastResponse interface shape', () => {
+  it('accepts competingTxs as an optional field', () => {
+    const withCompeting: BroadcastResponse = {
+      status: 'success',
+      txid: 'tx',
+      message: 'msg',
+      competingTxs: ['tx1', 'tx2']
+    }
+    expect(withCompeting.competingTxs).toHaveLength(2)
+
+    const withoutCompeting: BroadcastResponse = {
+      status: 'success',
+      txid: 'tx',
+      message: 'msg'
+    }
+    expect(withoutCompeting.competingTxs).toBeUndefined()
+  })
+})
+
+describe('BroadcastFailure interface shape', () => {
+  it('accepts txid and more as optional fields', () => {
+    const full: BroadcastFailure = {
+      status: 'error',
+      code: '422',
+      txid: 'txfull',
+      description: 'Unprocessable',
+      more: { hints: ['check input'] }
+    }
+    expect(full.txid).toBe('txfull')
+    expect(full.more).toEqual({ hints: ['check input'] })
+
+    const minimal: BroadcastFailure = {
+      status: 'error',
+      code: '422',
+      description: 'Unprocessable'
+    }
+    expect(minimal.txid).toBeUndefined()
+    expect(minimal.more).toBeUndefined()
+  })
+})

package/src/transaction/__tests/MerklePath.bench.test.ts

@@ -0,0 +1,105 @@
+import MerklePath from '../../transaction/MerklePath'
+
+/**
+ * Generate a random 32-byte hex hash.
+ */
+function randomHash (): string {
+  const bytes = new Uint8Array(32)
+  for (let i = 0; i < 32; i++) bytes[i] = Math.floor(Math.random() * 256)
+  return Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('')
+}
+
+/**
+ * Build a full-block compound MerklePath with `count` transactions at level 0.
+ * All leaves are txid: true; if count is odd the last leaf gets duplicate: true.
+ */
+function buildFullBlockPath (count: number): { mp: MerklePath, txids: string[] } {
+  const txids: string[] = []
+  const leaves: Array<{ offset: number, hash?: string, txid?: boolean, duplicate?: boolean }> = []
+  for (let i = 0; i < count; i++) {
+    const h = randomHash()
+    txids.push(h)
+    leaves.push({ offset: i, hash: h, txid: true })
+  }
+  if (count % 2 === 1) {
+    leaves.push({ offset: count, duplicate: true })
+  }
+  const mp = new MerklePath(1, [leaves])
+  return { mp, txids }
+}
+
+/**
+ * Pick `n` random items from `arr` without replacement.
+ */
+function pickRandom<T> (arr: T[], n: number): T[] {
+  const copy = [...arr]
+  const result: T[] = []
+  for (let i = 0; i < n && copy.length > 0; i++) {
+    const idx = Math.floor(Math.random() * copy.length)
+    result.push(copy.splice(idx, 1)[0])
+  }
+  return result
+}
+
+describe('MerklePath.extract() benchmarks', () => {
+  // Pre-build paths once so construction time is excluded from extract timing.
+  let path101: { mp: MerklePath, txids: string[] }
+  let path501: { mp: MerklePath, txids: string[] }
+  let path999: { mp: MerklePath, txids: string[] }
+
+  beforeAll(() => {
+    path101 = buildFullBlockPath(101)
+    path501 = buildFullBlockPath(501)
+    path999 = buildFullBlockPath(999)
+  })
+
+  const runBench = (
+    label: string,
+    getPath: () => { mp: MerklePath, txids: string[] },
+    extractCount: number,
+    iterations: number = 5
+  ): void => {
+    it(label, () => {
+      const { mp, txids } = getPath()
+      const targets = pickRandom(txids, extractCount)
+
+      const times: number[] = []
+      for (let i = 0; i < iterations; i++) {
+        const start = performance.now()
+        const extracted = mp.extract(targets)
+        const elapsed = performance.now() - start
+        times.push(elapsed)
+        // Correctness check on every iteration
+        for (const txid of targets) {
+          expect(extracted.computeRoot(txid)).toBe(mp.computeRoot(txid))
+        }
+      }
+
+      const avg = times.reduce((a, b) => a + b, 0) / times.length
+      const min = Math.min(...times)
+      const max = Math.max(...times)
+      console.log(
+        `[${label}] avg=${avg.toFixed(1)}ms  min=${min.toFixed(1)}ms  max=${max.toFixed(1)}ms  (${iterations} runs)`
+      )
+    })
+  }
+
+  // --- 101 txids ---
+  runBench('101 txids, extract 1', () => path101, 1)
+  runBench('101 txids, extract 5', () => path101, 5)
+  runBench('101 txids, extract 10', () => path101, 10)
+  runBench('101 txids, extract 50', () => path101, 50)
+
+  // --- 501 txids ---
+  runBench('501 txids, extract 1', () => path501, 1)
+  runBench('501 txids, extract 5', () => path501, 5)
+  runBench('501 txids, extract 10', () => path501, 10)
+  runBench('501 txids, extract 50', () => path501, 50)
+
+  // --- 999 txids ---
+  runBench('999 txids, extract 1', () => path999, 1)
+  runBench('999 txids, extract 5', () => path999, 5)
+  runBench('999 txids, extract 10', () => path999, 10)
+  runBench('999 txids, extract 50', () => path999, 50)
+  runBench('999 txids, extract 100', () => path999, 100, 3)
+})

package/src/transaction/__tests/MerklePath.test.ts

@@ -391,6 +391,86 @@ describe('MerklePath', () => {
     expect(splitTx5.computeRoot(tx[5])).toBe(merkleroot)
     expect(splitTx8.computeRoot(tx[8])).toBe(merkleroot)
   })
+  describe('extract()', () => {
+    it('extracts a single-txid proof from a full block compound path', () => {
+      const { height, merkleroot, tx } = BLOCK_125632
+      const leafs = tx.map((hash, offset) => ({ hash, txid: true, offset }))
+      if (leafs.length % 2) leafs.push({ offset: leafs.length, duplicate: true } as any)
+      const fullBlock = new MerklePath(height, [leafs])
+
+      const extracted = fullBlock.extract([tx[2]])
+      expect(extracted.computeRoot(tx[2])).toBe(merkleroot)
+    })
+
+    it('extracts a multi-txid compound proof from a full block compound path', () => {
+      const { height, merkleroot, tx } = BLOCK_125632
+      const leafs = tx.map((hash, offset) => ({ hash, txid: true, offset }))
+      if (leafs.length % 2) leafs.push({ offset: leafs.length, duplicate: true } as any)
+      const fullBlock = new MerklePath(height, [leafs])
+
+      const extracted = fullBlock.extract([tx[2], tx[5], tx[8]])
+      expect(extracted.computeRoot(tx[2])).toBe(merkleroot)
+      expect(extracted.computeRoot(tx[5])).toBe(merkleroot)
+      expect(extracted.computeRoot(tx[8])).toBe(merkleroot)
+    })
+
+    it('extracted path serializes and deserializes correctly', () => {
+      const { height, merkleroot, tx } = BLOCK_125632
+      const leafs = tx.map((hash, offset) => ({ hash, txid: true, offset }))
+      if (leafs.length % 2) leafs.push({ offset: leafs.length, duplicate: true } as any)
+      const fullBlock = new MerklePath(height, [leafs])
+
+      const extracted = fullBlock.extract([tx[2], tx[8]])
+      const roundTripped = MerklePath.fromHex(extracted.toHex())
+      expect(roundTripped.computeRoot(tx[2])).toBe(merkleroot)
+      expect(roundTripped.computeRoot(tx[8])).toBe(merkleroot)
+    })
+
+    it('extracted path is smaller than the full block path', () => {
+      const { height, tx } = BLOCK_125632
+      const leafs = tx.map((hash, offset) => ({ hash, txid: true, offset }))
+      if (leafs.length % 2) leafs.push({ offset: leafs.length, duplicate: true } as any)
+      const fullBlock = new MerklePath(height, [leafs])
+
+      const extracted = fullBlock.extract([tx[2], tx[5]])
+      expect(extracted.toBinary().length).toBeLessThan(fullBlock.toBinary().length)
+    })
+
+    it('extract from a trimmed multi-level compound path also works', () => {
+      const { height, merkleroot, tx } = BLOCK_125632
+      const [pathA, pathB] = buildSplitPaths()
+      pathA.combine(pathB)
+      // pathA is now a trimmed multi-level compound path for tx[2] and tx[3]
+      const txid2 = BRC74TXID2
+      const compound = new MerklePath(BRC74JSON.blockHeight, BRC74JSON.path)
+      const extracted = compound.extract([txid2])
+      expect(extracted.computeRoot(txid2)).toBe(compound.computeRoot(txid2))
+      // BLOCK_125632 variant
+      const leafs = tx.map((hash, offset) => ({ hash, txid: true, offset }))
+      if (leafs.length % 2) leafs.push({ offset: leafs.length, duplicate: true } as any)
+      const fullBlock = new MerklePath(height, [leafs])
+      const ex = fullBlock.extract([tx[0], tx[10]])
+      expect(ex.computeRoot(tx[0])).toBe(merkleroot)
+      expect(ex.computeRoot(tx[10])).toBe(merkleroot)
+    })
+
+    it('throws when no txids are provided', () => {
+      const { height, tx } = BLOCK_125632
+      const leafs = tx.map((hash, offset) => ({ hash, txid: true, offset }))
+      if (leafs.length % 2) leafs.push({ offset: leafs.length, duplicate: true } as any)
+      const fullBlock = new MerklePath(height, [leafs])
+      expect(() => fullBlock.extract([])).toThrow('At least one txid must be provided')
+    })
+
+    it('throws when a txid is not in the path', () => {
+      const { height, tx } = BLOCK_125632
+      const leafs = tx.map((hash, offset) => ({ hash, txid: true, offset }))
+      if (leafs.length % 2) leafs.push({ offset: leafs.length, duplicate: true } as any)
+      const fullBlock = new MerklePath(height, [leafs])
+      expect(() => fullBlock.extract(['deadbeef'.repeat(8)])).toThrow()
+    })
+  })
+
   it('findOrComputeLeaf duplicates leaf0 when leaf1 carries both a hash and duplicate=true', () => {
     // Covers the leaf1.duplicate === true branch inside findOrComputeLeaf.
     // That branch is reached when leaf1.hash is non-null (bypassing the null-check above it)