@bsv/sdk 2.0.11 → 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/storage/StorageDownloader.ts

@@ -35,9 +35,9 @@ export class StorageDownloader {
     }
     const decodedResults: string[] = []
     const currentTime = Math.floor(Date.now() / 1000)
-    for (let i = 0; i < response.outputs.length; i++) {
-      const tx = Transaction.fromBEEF(response.outputs[i].beef)
-      const { fields } = PushDrop.decode(tx.outputs[response.outputs[i].outputIndex].lockingScript)
+    for (const output of response.outputs) {
+      const tx = Transaction.fromBEEF(output.beef)
+      const { fields } = PushDrop.decode(tx.outputs[output.outputIndex].lockingScript)
 
       const expiryTime = new Utils.Reader(fields[3]).readVarIntNum()
       if (expiryTime < currentTime) {
@@ -66,10 +66,10 @@ export class StorageDownloader {
       throw new Error('No one currently hosts this file!')
     }
 
-    for (let i = 0; i < downloadURLs.length; i++) {
+    for (const url of downloadURLs) {
       try {
         // The url is fetched
-        const result = await fetch(downloadURLs[i], { method: 'GET' })
+        const result = await fetch(url, { method: 'GET' })
 
         // If the request fails, continue to the next url
         if (!result.ok || result.status >= 400 || result.body == null) {
@@ -105,7 +105,7 @@ export class StorageDownloader {
           data,
           mimeType: result.headers.get('Content-Type')
         }
-      } catch (error) {
+      } catch {
         continue
       }
     }

package/src/storage/StorageUtils.ts

@@ -68,7 +68,7 @@ export const isValidURL = (URL: string): boolean => {
   try {
     getHashFromURL(URL)
     return true
-  } catch (e) {
+  } catch {
     return false
   }
 }

package/src/transaction/MerklePath.ts

@@ -61,7 +61,7 @@ export default class MerklePath {
     const blockHeight = reader.readVarIntNum()
     const treeHeight = reader.readUInt8()
     // Explicitly define the type of path as an array of arrays of leaf objects
-    const path: Array<Array<{ offset: number, hash?: string, txid?: boolean, duplicate?: boolean }>> = Array(treeHeight)
+    const path: Array<Array<{ offset: number, hash?: string, txid?: boolean, duplicate?: boolean }>> = new Array(treeHeight)
       .fill(null)
       .map(() => [])
     let flags: number, offset: number, nLeavesAtThisHeight: number
@@ -76,7 +76,7 @@ export default class MerklePath {
           txid?: boolean
           duplicate?: boolean
         } = { offset }
-        if ((flags & 1) !== 0) {
+        if ((flags & 1) === 1) {
           leaf.duplicate = true
         } else {
           if ((flags & 2) !== 0) {
@@ -140,7 +140,7 @@ export default class MerklePath {
     this.path = path
 
     // store all of the legal offsets which we expect given the txid indices.
-    const legalOffsets = Array(this.path.length)
+    const legalOffsets = new Array(this.path.length)
       .fill(0)
       .map(() => new Set())
     this.path.forEach((leaves, height) => {
@@ -161,12 +161,10 @@ export default class MerklePath {
               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(', ')}`
-            )
-          }
+        } 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(', ')}`
+          )
         }
       })
     })
@@ -260,19 +258,16 @@ export default class MerklePath {
   computeRoot (txid?: string): string {
     if (typeof txid !== 'string') {
       const foundLeaf = this.path[0].find((leaf) => Boolean(leaf?.hash))
-      if (foundLeaf === null || foundLeaf === undefined) {
+      if (foundLeaf == null) {
         throw new Error('No valid leaf found in the Merkle Path')
       }
       txid = foundLeaf.hash
     }
     // Find the index of the txid at the lowest level of the Merkle tree
     if (typeof txid !== 'string') {
-      throw new Error('Transaction ID is undefined')
+      throw new TypeError('Transaction ID is undefined')
     }
     const index = this.indexOf(txid)
-    if (typeof index !== 'number') {
-      throw new Error(`This proof does not contain the txid: ${txid ?? 'undefined'}`)
-    }
     // 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())
@@ -291,11 +286,16 @@ export default class MerklePath {
       const offset = (index >> height) ^ 1
       const leaf = this.findOrComputeLeaf(height, offset)
       if (typeof leaf !== 'object') {
+        // For single-level paths (all txids at level 0), the sibling may be beyond the tree
+        // because this is the last odd node at this height. Bitcoin Merkle duplicates it.
+        if (this.path.length === 1 && (index >> height) === (maxOffset >> height)) {
+          workingHash = hash((workingHash ?? '') + (workingHash ?? ''))
+          continue
+        }
         throw new Error(`Missing hash for index ${index} at height ${height}`)
-      }
-      if (leaf.duplicate === true) {
+      } else if (leaf.duplicate === true) {
         workingHash = hash((workingHash ?? '') + (workingHash ?? ''))
-      } else if (offset % 2 !== 0) {
+      } else if (offset % 2 === 1) {
         workingHash = hash((leaf.hash ?? '') + (workingHash ?? ''))
       } else {
         workingHash = hash((workingHash ?? '') + (leaf.hash ?? ''))
@@ -334,7 +334,20 @@ export default class MerklePath {
     if (leaf0 == null || leaf0.hash == null || leaf0.hash === '') return undefined
 
     const leaf1 = this.findOrComputeLeaf(h, l + 1)
-    if (leaf1 == null) return undefined
+    if (leaf1?.hash == null) {
+      // Explicit duplicate marker — duplicate leaf0 regardless of path depth.
+      if (leaf1?.duplicate === true) {
+        return { offset, hash: hash(leaf0.hash + leaf0.hash) }
+      }
+      // For single-level paths, leaf0 may be the last odd node at height h — duplicate it.
+      if (this.path.length === 1) {
+        const maxOffset0 = this.path[0].reduce((max, lf) => Math.max(max, lf.offset), 0)
+        if (l === (maxOffset0 >> h)) {
+          return { offset, hash: hash(leaf0.hash + leaf0.hash) }
+        }
+      }
+      return undefined
+    }
 
     let workinghash: string
     if (leaf1.duplicate === true) {
@@ -392,26 +405,18 @@ export default class MerklePath {
     const combinedPath: Array<Array<{ offset: number, hash?: string, txid?: boolean, duplicate?: boolean }>> = []
     for (let h = 0; h < this.path.length; h++) {
       combinedPath.push([])
-      for (let l = 0; l < this.path[h].length; l++) {
-        combinedPath[h].push(this.path[h][l])
+      for (const leaf of this.path[h]) {
+        combinedPath[h].push(leaf)
       }
-      for (let l = 0; l < other.path[h].length; l++) {
-        if (
-          combinedPath[h].find(
-            (leaf) => leaf.offset === other.path[h][l].offset
-          ) === undefined
-        ) {
-          combinedPath[h].push(other.path[h][l])
-        } else {
+      for (const otherLeaf of other.path[h]) {
+        const existingLeaf = combinedPath[h].find(
+          (leaf) => leaf.offset === otherLeaf.offset
+        )
+        if (existingLeaf === undefined) {
+          combinedPath[h].push(otherLeaf)
+        } else if (otherLeaf?.txid !== undefined && otherLeaf?.txid !== null) {
           // Ensure that any elements which appear in both are not downgraded to a non txid.
-          if (other.path[h][l]?.txid !== undefined && other.path[h][l]?.txid !== null) {
-            const target = combinedPath[h].find(
-              (leaf) => leaf.offset === other.path[h][l].offset
-            )
-            if (target !== null && target !== undefined) {
-              target.txid = true
-            }
-          }
+          existingLeaf.txid = true
         }
       }
     }
@@ -477,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()
+  })
+})