@bsv/sdk 2.0.11 → 2.0.13

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

@@ -112,6 +112,24 @@ const BRC74JSONTrimmed = {
 }
 BRC74JSONTrimmed.path[1] = []
 
+const BLOCK_125632 = {
+  height: 125632,
+  merkleroot: '205b2e27c58601fc1a8de04c83b6b0c46f89c16b2161c93441b7e9269cf6bc4a',
+  tx: [
+    '17cba98da71fe75862aac894392f2ff604356db386767fec364877a5a9ff200c',
+    '14ce64bd223ec9bb42662b74fdcf94f96a209a1aee72b7ba7639db503150ec2e',
+    '90a2de85351cfadd2326b9b0098e9c453af09b2980835f57a1429bbb44beb872',
+    'a31f2ddfea7ddd4581dca3007ee99e58ea6baa97a8ac3b32bb4610baac9f7206',
+    'c36eeed6fbc0259d30804f59f804dfcda35a54461157d6ac9c094f0ea378f35c',
+    '17752483868c52a98407a0e226d73b42e214e0fad548541619d858e1fd4a9549',
+    '3b8c4460412cfc55be0d50308ba704a859bd6f83bfed01b0828c9b067cd69246',
+    'a3f1b9d4b3ef3b061af352fdc2d02048417030fef9282c36da689cd899437cdb',
+    '66e2b022da877621ef197e02c3ef7d3f820d33a86ead2e72bf966432ea6776f1',
+    'e988b5d7a2cec8e0759ade2e151737d1cdfdde68accff42938583ad12eb98b99',
+    '5e7a8a8ec3f912ac1c4e90279c04263f170ed055c0411c8d490b846f01e6a99e'
+  ]
+}
+
 const BRC74Root =
   '57aab6e6fb1b697174ffb64e062c4728f2ffd33ddcfa02a43b64d8cd29b483b4'
 const BRC74TXID1 =
@@ -200,10 +218,9 @@ describe('MerklePath', () => {
   it('Serializes and deserializes a combined trimmed path', () => {
     const [pathA, pathB] = buildSplitPaths()
     pathA.combine(pathB)
-    let deserialized: MerklePath
-    expect(() => { deserialized = MerklePath.fromHex(pathA.toHex()) }).not.toThrow()
-    expect(deserialized!.computeRoot(BRC74TXID2)).toEqual(BRC74Root)
-    expect(deserialized!.computeRoot(BRC74TXID3)).toEqual(BRC74Root)
+    const deserialized = MerklePath.fromHex(pathA.toHex())
+    expect(deserialized.computeRoot(BRC74TXID2)).toEqual(BRC74Root)
+    expect(deserialized.computeRoot(BRC74TXID3)).toEqual(BRC74Root)
   })
   it('Constructs a compound path from all txids at level 0 only', () => {
     // A single-level compound path: all txids for a block given at level 0, no higher levels.
@@ -213,24 +230,20 @@ describe('MerklePath', () => {
     const tx2 = 'cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc'
     const tx3 = 'dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd'
     const root4 = merkleHash(merkleHash(tx3 + tx2) + merkleHash(tx1 + tx0))
-    let mp: MerklePath
-    expect(() => {
-      mp = new MerklePath(100, [[
-        { offset: 0, txid: true, hash: tx0 },
-        { offset: 1, txid: true, hash: tx1 },
-        { offset: 2, txid: true, hash: tx2 },
-        { offset: 3, txid: true, hash: tx3 }
-      ]])
-    }).not.toThrow()
-    expect(mp!.computeRoot(tx0)).toEqual(root4)
-    expect(mp!.computeRoot(tx1)).toEqual(root4)
-    expect(mp!.computeRoot(tx2)).toEqual(root4)
-    expect(mp!.computeRoot(tx3)).toEqual(root4)
+    const mp = new MerklePath(100, [[
+      { offset: 0, txid: true, hash: tx0 },
+      { offset: 1, txid: true, hash: tx1 },
+      { offset: 2, txid: true, hash: tx2 },
+      { offset: 3, txid: true, hash: tx3 }
+    ]])
+    expect(mp.computeRoot(tx0)).toEqual(root4)
+    expect(mp.computeRoot(tx1)).toEqual(root4)
+    expect(mp.computeRoot(tx2)).toEqual(root4)
+    expect(mp.computeRoot(tx3)).toEqual(root4)
     // Serializing and deserializing a single-level compound path should also work
-    let deserialized: MerklePath
-    expect(() => { deserialized = MerklePath.fromHex(mp!.toHex()) }).not.toThrow()
-    expect(deserialized!.computeRoot(tx0)).toEqual(root4)
-    expect(deserialized!.computeRoot(tx3)).toEqual(root4)
+    const deserialized = MerklePath.fromHex(mp.toHex())
+    expect(deserialized.computeRoot(tx0)).toEqual(root4)
+    expect(deserialized.computeRoot(tx3)).toEqual(root4)
   })
   it('Rejects invalid bumps', () => {
     for (const invalid of invalidBumps) {
@@ -284,4 +297,202 @@ describe('MerklePath', () => {
     )
     expect(isValid).toBe(false)
   })
+  it('constructs a compound MerklePath from all txids in a block with odd tree levels', () => {
+    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 mp = new MerklePath(height, [leafs])
+    expect(mp.computeRoot()).toBe(merkleroot)
+  })
+  it('compound path for 3 txids trims, round-trips through hex, and splits into per-txid proofs', () => {
+    const { height, merkleroot, tx } = BLOCK_125632
+
+    // Precompute the full Merkle tree for block 125632.
+    // merkleHash(right + left) matches the SDK's internal hash convention.
+    const L1 = [
+      merkleHash(tx[1] + tx[0]),
+      merkleHash(tx[3] + tx[2]),
+      merkleHash(tx[5] + tx[4]),
+      merkleHash(tx[7] + tx[6]),
+      merkleHash(tx[9] + tx[8]),
+      merkleHash(tx[10] + tx[10]) // tx[10] duplicated — odd count at level 0
+    ]
+    const L2 = [
+      merkleHash(L1[1] + L1[0]),
+      merkleHash(L1[3] + L1[2]),
+      merkleHash(L1[5] + L1[4])
+    ]
+    const L3 = [
+      merkleHash(L2[1] + L2[0]),
+      merkleHash(L2[2] + L2[2]) // L2 count = 3 (odd) — last node duplicated
+    ]
+    expect(merkleHash(L3[1] + L3[0])).toBe(merkleroot)
+
+    // Build minimal per-txid MerklePaths for tx[2], tx[5], and tx[8].
+    // tx[8] exercises the odd-level duplication at level 2 ({offset:3, duplicate:true}).
+    const mpTx2 = new MerklePath(height, [
+      [{ offset: 2, txid: true, hash: tx[2] }, { offset: 3, hash: tx[3] }],
+      [{ offset: 0, hash: L1[0] }],
+      [{ offset: 1, hash: L2[1] }],
+      [{ offset: 1, hash: L3[1] }]
+    ])
+    const mpTx5 = new MerklePath(height, [
+      [{ offset: 4, hash: tx[4] }, { offset: 5, txid: true, hash: tx[5] }],
+      [{ offset: 3, hash: L1[3] }],
+      [{ offset: 0, hash: L2[0] }],
+      [{ offset: 1, hash: L3[1] }]
+    ])
+    const mpTx8 = new MerklePath(height, [
+      [{ offset: 8, txid: true, hash: tx[8] }, { offset: 9, hash: tx[9] }],
+      [{ offset: 5, hash: L1[5] }],
+      [{ offset: 3, duplicate: true }], // tx[8] is last odd node at level 2
+      [{ offset: 0, hash: L3[0] }]
+    ])
+    expect(mpTx2.computeRoot(tx[2])).toBe(merkleroot)
+    expect(mpTx5.computeRoot(tx[5])).toBe(merkleroot)
+    expect(mpTx8.computeRoot(tx[8])).toBe(merkleroot)
+
+    // Combine into one compound path (combine() trims automatically)
+    const compound = new MerklePath(height, mpTx2.path.map(l => [...l]))
+    compound.combine(mpTx5)
+    compound.combine(mpTx8)
+    expect(compound.computeRoot(tx[2])).toBe(merkleroot)
+    expect(compound.computeRoot(tx[5])).toBe(merkleroot)
+    expect(compound.computeRoot(tx[8])).toBe(merkleroot)
+
+    // Serialize and deserialize
+    const deserialized = MerklePath.fromHex(compound.toHex())
+    expect(deserialized.computeRoot(tx[2])).toBe(merkleroot)
+    expect(deserialized.computeRoot(tx[5])).toBe(merkleroot)
+    expect(deserialized.computeRoot(tx[8])).toBe(merkleroot)
+
+    // Split the deserialized compound path into standalone per-txid proofs.
+    // findOrComputeLeaf reconstructs sibling hashes that were trimmed away.
+    const splitProof = (source: MerklePath, txOffset: number, txHash: string): MerklePath => {
+      const levels = source.path.map((_, h) => {
+        const sibOffset = (txOffset >> h) ^ 1
+        if (h === 0) {
+          const sib = source.findOrComputeLeaf(0, sibOffset)
+          if (sib == null) throw new Error('Missing sibling at level 0')
+          return [{ offset: txOffset, txid: true, hash: txHash }, sib].sort((a, b) => a.offset - b.offset)
+        }
+        const sib = source.findOrComputeLeaf(h, sibOffset)
+        return sib == null ? [] : [sib]
+      })
+      return new MerklePath(source.blockHeight, levels)
+    }
+
+    const splitTx2 = splitProof(deserialized, 2, tx[2])
+    const splitTx5 = splitProof(deserialized, 5, tx[5])
+    const splitTx8 = splitProof(deserialized, 8, tx[8])
+
+    // Each standalone proof computes the same root — no data was lost through the pipeline
+    expect(splitTx2.computeRoot(tx[2])).toBe(merkleroot)
+    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)
+    // but leaf1.duplicate is also true — an unusual but valid interface state.
+    const tx0 = 'aa'.repeat(32)
+    const tx1 = 'bb'.repeat(32)
+
+    // Build a minimal valid path so the constructor does not throw.
+    const mp = new MerklePath(1, [[
+      { offset: 0, txid: true, hash: tx0 },
+      { offset: 1, hash: tx1 }
+    ]])
+
+    // Mutate: give the sibling leaf at offset 1 both a hash and duplicate=true.
+    // findOrComputeLeaf(1, 0) will:
+    //   - not find offset 0 in path[1] (path.length === 1, no higher levels)
+    //   - recurse to level 0: leaf0 = tx0 (offset 0), leaf1 = {hash:tx1, duplicate:true}
+    //   - leaf1.hash is non-null → skips the null-branch
+    //   - leaf1.duplicate === true → line 349: workinghash = hash(leaf0 + leaf0)
+    mp.path[0][1] = { offset: 1, hash: tx1, duplicate: true }
+
+    const result = mp.findOrComputeLeaf(1, 0)
+    expect(result?.hash).toBe(merkleHash(tx0 + tx0))
+  })
 })

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

@@ -0,0 +1,225 @@
+import Transaction from '../Transaction'
+import LockingScript from '../../script/LockingScript'
+import UnlockingScript from '../../script/UnlockingScript'
+import { toArray } from '../../primitives/utils'
+
+// Known EF-format transaction hex (BRC-30)
+const KNOWN_EF_HEX =
+  '010000000000000000ef01ac4e164f5bc16746bb0868404292ac8318bbac3800e4aad13a014da427adce3e000000006a47304402203a61a2e931612b4bda08d541cfb980885173b8dcf64a3471238ae7abcd368d6402204cbf24f04b9aa2256d8901f0ed97866603d2be8324c2bfb7a37bf8fc90edd5b441210263e2dee22b1ddc5e11f6fab8bcd2378bdd19580d640501ea956ec0e786f93e76ffffffff3e660000000000001976a9146bfd5c7fbe21529d45803dbcf0c87dd3c71efbc288ac013c660000000000001976a9146bfd5c7fbe21529d45803dbcf0c87dd3c71efbc288ac00000000'
+
+// Known BEEF V1 hex (non-Atomic, has no atomicTxid)
+const KNOWN_BEEF_V1_HEX =
+  '0100beef01fe636d0c0007021400fe507c0c7aa754cef1f7889d5fd395cf1f785dd7de98eed895dbedfe4e5bc70d1502ac4e164f5bc16746bb0868404292ac8318bbac3800e4aad13a014da427adce3e010b00bc4ff395efd11719b277694cface5aa50d085a0bb81f613f70313acd28cf4557010400574b2d9142b8d28b61d88e3b2c3f44d858411356b49a28a4643b6d1a6a092a5201030051a05fc84d531b5d250c23f4f886f6812f9fe3f402d61607f977b4ecd2701c19010000fd781529d58fc2523cf396a7f25440b409857e7e221766c57214b1d38c7b481f01010062f542f45ea3660f86c013ced80534cb5fd4c19d66c56e7e8c5d4bf2d40acc5e010100b121e91836fd7cd5102b654e9f72f3cf6fdbfd0b161c53a9c54b12c841126331020100000001cd4e4cac3c7b56920d1e7655e7e260d31f29d9a388d04910f1bbd72304a79029010000006b483045022100e75279a205a547c445719420aa3138bf14743e3f42618e5f86a19bde14bb95f7022064777d34776b05d816daf1699493fcdf2ef5a5ab1ad710d9c97bfb5b8f7cef3641210263e2dee22b1ddc5e11f6fab8bcd2378bdd19580d640501ea956ec0e786f93e76ffffffff013e660000000000001976a9146bfd5c7fbe21529d45803dbcf0c87dd3c71efbc288ac0000000001000100000001ac4e164f5bc16746bb0868404292ac8318bbac3800e4aad13a014da427adce3e000000006a47304402203a61a2e931612b4bda08d541cfb980885173b8dcf64a3471238ae7abcd368d6402204cbf24f04b9aa2256d8901f0ed97866603d2be8324c2bfb7a37bf8fc90edd5b441210263e2dee22b1ddc5e11f6fab8bcd2378bdd19580d640501ea956ec0e786f93e76ffffffff013c660000000000001976a9146bfd5c7fbe21529d45803dbcf0c87dd3c71efbc288ac0000000000'
+
+describe('Transaction – additional coverage', () => {
+  describe('fromHexEF', () => {
+    it('parses a known EF hex string', () => {
+      const tx = Transaction.fromHexEF(KNOWN_EF_HEX)
+      expect(tx).toBeInstanceOf(Transaction)
+      expect(tx.inputs).toHaveLength(1)
+      expect(tx.outputs).toHaveLength(1)
+    })
+  })
+
+  describe('fromAtomicBEEF – non-atomic BEEF', () => {
+    it('throws when passed a regular BEEF with no atomicTxid', () => {
+      const beefBytes = toArray(KNOWN_BEEF_V1_HEX, 'hex')
+      expect(() => Transaction.fromAtomicBEEF(beefBytes)).toThrow(
+        'beef must conform to BRC-95 and must contain the subject txid.'
+      )
+    })
+  })
+
+  describe('addInput', () => {
+    it('throws when both sourceTXID and sourceTransaction are undefined', () => {
+      const tx = new Transaction()
+      expect(() =>
+        tx.addInput({
+          sourceOutputIndex: 0,
+          unlockingScript: new UnlockingScript(),
+          sequence: 0xffffffff
+        })
+      ).toThrow('A reference to an an input transaction is required')
+    })
+
+    it('sets sequence to 0xffffffff when not provided', () => {
+      const tx = new Transaction()
+      tx.addInput({
+        sourceTXID: '00'.repeat(32),
+        sourceOutputIndex: 0,
+        unlockingScript: new UnlockingScript()
+      })
+      expect(tx.inputs[0].sequence).toBe(0xffffffff)
+    })
+  })
+
+  describe('addOutput', () => {
+    it('throws when satoshis is undefined and change is not true', () => {
+      const tx = new Transaction()
+      expect(() =>
+        tx.addOutput({
+          lockingScript: new LockingScript()
+        })
+      ).toThrow('either satoshis must be defined or change must be set to true')
+    })
+
+    it('throws when satoshis is negative', () => {
+      const tx = new Transaction()
+      expect(() =>
+        tx.addOutput({
+          lockingScript: new LockingScript(),
+          satoshis: -1
+        })
+      ).toThrow('satoshis must be a positive integer or zero')
+    })
+
+    it('throws when lockingScript is null', () => {
+      const tx = new Transaction()
+      expect(() =>
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        tx.addOutput({ satoshis: 100, lockingScript: null as any })
+      ).toThrow('lockingScript must be defined')
+    })
+  })
+
+  describe('addP2PKHOutput', () => {
+    it('adds a change output when satoshis is omitted', () => {
+      const tx = new Transaction()
+      // Pass a 20-byte hash directly to avoid base58 parsing
+      const pubKeyHash = new Array(20).fill(0x01)
+      tx.addP2PKHOutput(pubKeyHash)
+      expect(tx.outputs).toHaveLength(1)
+      expect(tx.outputs[0].change).toBe(true)
+    })
+  })
+
+  describe('hash / id', () => {
+    it('returns hex string from hash("hex")', () => {
+      const tx = new Transaction()
+      const h = tx.hash('hex')
+      expect(typeof h).toBe('string')
+      expect((h as string)).toHaveLength(64)
+    })
+
+    it('returns binary array from id() without enc', () => {
+      const tx = new Transaction()
+      const id = tx.id()
+      expect(Array.isArray(id)).toBe(true)
+      expect(id).toHaveLength(32)
+    })
+  })
+
+  describe('toHexAtomicBEEF', () => {
+    it('produces a hex string from toHexAtomicBEEF()', () => {
+      const sourceTx = new Transaction(
+        1,
+        [],
+        [{ lockingScript: new LockingScript(), satoshis: 1000 }],
+        0
+      )
+      const tx = new Transaction(1, [], [{ lockingScript: new LockingScript(), satoshis: 900 }], 0)
+      tx.addInput({
+        sourceTXID: sourceTx.id('hex'),
+        sourceTransaction: sourceTx,
+        sourceOutputIndex: 0,
+        unlockingScript: new UnlockingScript(),
+        sequence: 0xffffffff
+      })
+      const hex = tx.toHexAtomicBEEF()
+      expect(typeof hex).toBe('string')
+      expect(hex.length).toBeGreaterThan(0)
+    })
+  })
+
+  describe('getFee', () => {
+    it('throws when an input has no sourceTransaction', () => {
+      const tx = new Transaction()
+      tx.addInput({
+        sourceTXID: '00'.repeat(32),
+        sourceOutputIndex: 0,
+        unlockingScript: new UnlockingScript()
+      })
+      expect(() => tx.getFee()).toThrow(
+        'Source transactions or sourceSatoshis are required for all inputs to calculate fee'
+      )
+    })
+  })
+
+  describe('sign', () => {
+    it('throws when an output has undefined satoshis and change is not set', async () => {
+      const tx = new Transaction(
+        1,
+        [],
+        [{ lockingScript: new LockingScript(), satoshis: undefined, change: false }],
+        0
+      )
+      await expect(tx.sign()).rejects.toThrow(
+        'One or more transaction outputs is missing an amount'
+      )
+    })
+
+    it('throws when an output has undefined satoshis and change is true (uncomputed change)', async () => {
+      const tx = new Transaction(
+        1,
+        [],
+        [{ lockingScript: new LockingScript(), satoshis: undefined, change: true }],
+        0
+      )
+      await expect(tx.sign()).rejects.toThrow(
+        'There are still change outputs with uncomputed amounts'
+      )
+    })
+  })
+
+  describe('toEF / writeEF error paths', () => {
+    it('throws when an input has no sourceTransaction during EF serialization', () => {
+      // sourceTXID is defined so addInput passes, but sourceTransaction is undefined
+      const tx = new Transaction()
+      tx.addInput({
+        sourceTXID: '00'.repeat(32),
+        sourceOutputIndex: 0,
+        unlockingScript: new UnlockingScript()
+      })
+      expect(() => tx.toEF()).toThrow(
+        'All inputs must have source transactions when serializing to EF format'
+      )
+    })
+  })
+
+  describe('toBinary / writeTransactionBody error paths', () => {
+    it('throws when an input has no sourceTXID and no sourceTransaction', () => {
+      // Bypass addInput validation by constructing directly
+      const tx = new Transaction(
+        1,
+        [
+          {
+            sourceOutputIndex: 0,
+            unlockingScript: new UnlockingScript(),
+            sequence: 0xffffffff
+            // no sourceTXID, no sourceTransaction
+          }
+        ],
+        [],
+        0
+      )
+      expect(() => tx.toBinary()).toThrow('sourceTransaction is undefined')
+    })
+
+    it('throws when an input has no unlockingScript during serialization', () => {
+      const tx = new Transaction(
+        1,
+        [
+          {
+            sourceTXID: '00'.repeat(32),
+            sourceOutputIndex: 0,
+            sequence: 0xffffffff
+            // no unlockingScript
+          }
+        ],
+        [],
+        0
+      )
+      expect(() => tx.toBinary()).toThrow('unlockingScript is undefined')
+    })
+  })
+})