@bsv/sdk 2.0.12 → 2.0.13

package/src/script/__tests/Spend.additional.test.ts

@@ -0,0 +1,837 @@
+import Spend from '../../script/Spend'
+import LockingScript from '../../script/LockingScript'
+import UnlockingScript from '../../script/UnlockingScript'
+import BigNumber from '../../primitives/BigNumber'
+import OP from '../../script/OP'
+import ScriptChunk from '../../script/ScriptChunk'
+import PrivateKey from '../../primitives/PrivateKey'
+import PublicKey from '../../primitives/PublicKey'
+import Transaction from '../../transaction/Transaction'
+import P2PKH from '../../script/templates/P2PKH'
+
+const ZERO_TXID = '0'.repeat(64)
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeSpend (
+  lockingChunks: ScriptChunk[],
+  unlockingChunks: ScriptChunk[] = [],
+  opts: { transactionVersion?: number, memoryLimit?: number, isRelaxed?: boolean } = {}
+): Spend {
+  return new Spend({
+    sourceTXID: ZERO_TXID,
+    sourceOutputIndex: 0,
+    sourceSatoshis: 1,
+    lockingScript: new LockingScript(lockingChunks),
+    transactionVersion: opts.transactionVersion ?? 1,
+    otherInputs: [],
+    outputs: [],
+    inputIndex: 0,
+    unlockingScript: new UnlockingScript(unlockingChunks),
+    inputSequence: 0xffffffff,
+    lockTime: 0,
+    memoryLimit: opts.memoryLimit,
+    isRelaxed: opts.isRelaxed
+  })
+}
+
+/** Minimal-push helper that respects script number semantics. */
+function pushChunk (data: number[]): ScriptChunk {
+  if (data.length === 0) return { op: OP.OP_0 }
+  if (data.length === 1 && data[0] >= 1 && data[0] <= 16) {
+    return { op: OP.OP_1 + (data[0] - 1) }
+  }
+  if (data.length === 1 && data[0] === 0x81) return { op: OP.OP_1NEGATE }
+  if (data.length <= 75) return { op: data.length, data }
+  if (data.length <= 255) return { op: OP.OP_PUSHDATA1, data }
+  if (data.length <= 65535) return { op: OP.OP_PUSHDATA2, data }
+  return { op: OP.OP_PUSHDATA4, data }
+}
+
+/** scriptnum bytes for an integer. */
+function scriptNum (n: number): number[] {
+  return new BigNumber(n).toScriptNum()
+}
+
+/** Fast way to make a Spend in relaxed mode with a locking-script-only test. */
+function makeLocking (
+  lockingChunks: ScriptChunk[],
+  opts: { memoryLimit?: number } = {}
+): Spend {
+  return makeSpend(lockingChunks, [], { isRelaxed: true, memoryLimit: opts.memoryLimit })
+}
+
+// ---------------------------------------------------------------------------
+// Memory limit checks (lines 238, 246, 383-384, 387-388)
+// ---------------------------------------------------------------------------
+describe('Spend – memory limit enforcement', () => {
+  it('step() throws when stackMem already exceeds memoryLimit', () => {
+    const spend = makeLocking([{ op: OP.OP_1 }], { memoryLimit: 0 })
+    spend.context = 'LockingScript'
+    spend.stackMem = 1 // artificially exceeded
+    expect(() => spend.step()).toThrow('Stack memory usage has exceeded')
+  })
+
+  it('step() throws when altStackMem already exceeds memoryLimit', () => {
+    const spend = makeLocking([{ op: OP.OP_1 }], { memoryLimit: 0 })
+    spend.context = 'LockingScript'
+    spend.altStackMem = 1
+    expect(() => spend.step()).toThrow('Alt stack memory usage has exceeded')
+  })
+
+  it('pushStack throws when additional bytes would exceed memoryLimit', () => {
+    // OP_1 calls pushStackCopy with a 1-byte item; memoryLimit=0 so 0+1>0
+    const spend = makeLocking([{ op: OP.OP_1 }], { memoryLimit: 0 })
+    spend.context = 'LockingScript'
+    expect(() => spend.step()).toThrow('Stack memory usage has exceeded')
+  })
+
+  it('pushAltStack throws when additional bytes would exceed memoryLimit', () => {
+    const spend = makeLocking([{ op: OP.OP_TOALTSTACK }], { memoryLimit: 0 })
+    spend.context = 'LockingScript'
+    // Pre-populate stack without going through ensureStackMem
+    spend.stack = [[1]]
+    spend.stackMem = 0 // bypass step() initial guard (0 > 0 = false)
+    expect(() => spend.step()).toThrow('Alt stack memory usage has exceeded')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// step() structural edge-cases (lines 401, 407, 417)
+// ---------------------------------------------------------------------------
+describe('Spend – step() structural edge-cases', () => {
+  it('step() returns false when locking script is exhausted', () => {
+    // Empty locking script: after unlocking script finishes, step() returns false
+    const spend = makeSpend([], [pushChunk([1])], { isRelaxed: true })
+    expect(spend.step()).toBe(true) // process unlocking push
+    expect(spend.step()).toBe(false) // locking is empty → return false
+  })
+
+  it('step() throws for non-minimal push in strict mode', () => {
+    // data=[0x01] should be pushed with OP_1 (0x51), not op=1
+    const nonMinimal: ScriptChunk = { op: 1, data: [0x01] }
+    const spend = makeSpend([nonMinimal], [], { memoryLimit: 1000 })
+    spend.context = 'LockingScript'
+    expect(() => spend.step()).toThrow('not minimally-encoded')
+  })
+
+  it('step() processes non-minimal push when isRelaxed=true', () => {
+    const nonMinimal: ScriptChunk = { op: 1, data: [0x01] }
+    const spend = makeSpend([nonMinimal], [], { isRelaxed: true, memoryLimit: 1000 })
+    spend.context = 'LockingScript'
+    expect(spend.step()).toBe(true)
+    expect(spend.stack[0]).toEqual([0x01])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// validate() error paths (lines 1103, 1118, 1125, 1132, 1136)
+// ---------------------------------------------------------------------------
+describe('Spend – validate() error paths', () => {
+  it('throws when unlocking script is not push-only in strict mode', () => {
+    // OP_DROP is not a push opcode
+    const spend = makeSpend(
+      [{ op: OP.OP_1 }],
+      [{ op: OP.OP_DROP }]
+    )
+    expect(() => spend.validate()).toThrow('Unlocking scripts can only contain push operations')
+  })
+
+  it('throws when OP_IF is not closed with OP_ENDIF', () => {
+    // OP_1 OP_IF OP_1 ← no OP_ENDIF
+    const spend = makeLocking([
+      { op: OP.OP_1 },
+      { op: OP.OP_IF },
+      { op: OP.OP_1 }
+    ])
+    expect(() => spend.validate()).toThrow('OP_IF')
+  })
+
+  it('throws clean-stack violation when more than one item left', () => {
+    // Non-relaxed mode: exactly 1 item is required
+    const spend = makeSpend([{ op: OP.OP_1 }, { op: OP.OP_1 }])
+    expect(() => spend.validate()).toThrow('clean stack')
+  })
+
+  it('throws when stack is empty after execution', () => {
+    // OP_DROP leaves stack empty in relaxed mode
+    const spend = makeLocking([
+      { op: OP.OP_1 },
+      { op: OP.OP_DROP }
+    ])
+    expect(() => spend.validate()).toThrow('stack is empty')
+  })
+
+  it('throws when top stack item is falsy', () => {
+    const spend = makeLocking([{ op: OP.OP_0 }])
+    expect(() => spend.validate()).toThrow('top stack element must be truthy')
+  })
+
+  it('castToBool returns false for negative-zero sentinel [0x80]', () => {
+    // Push [0x80] (negative zero) – should be falsy
+    const spend = makeLocking([pushChunk([0x80])])
+    expect(() => spend.validate()).toThrow('top stack element must be truthy')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// isChunkMinimalPushHelper – data.length 256-65535 path (line 97-98)
+// ---------------------------------------------------------------------------
+describe('Spend – isChunkMinimalPushHelper 256-65535 byte data', () => {
+  it('rejects PUSHDATA4 for 256-byte data (should use PUSHDATA2)', () => {
+    const data = new Array(256).fill(0x42)
+    // Using OP_PUSHDATA4 for 256-byte data is non-minimal (should be PUSHDATA2)
+    const badPush: ScriptChunk = { op: OP.OP_PUSHDATA4, data }
+    const spend = makeSpend([badPush], [], { memoryLimit: 10000000 })
+    spend.context = 'LockingScript'
+    expect(() => spend.step()).toThrow('not minimally-encoded')
+  })
+
+  it('accepts PUSHDATA2 for 256-byte data', () => {
+    const data = new Array(256).fill(0x42)
+    const goodPush: ScriptChunk = { op: OP.OP_PUSHDATA2, data }
+    const spend = makeSpend([goodPush, { op: OP.OP_DROP }, { op: OP.OP_1 }], [], { memoryLimit: 10000000 })
+    expect(spend.validate()).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// checkPublicKeyEncoding paths (lines 328-353)
+// ---------------------------------------------------------------------------
+describe('Spend – checkPublicKeyEncoding error paths', () => {
+  function checksigSpend (pubkeyBytes: number[], sigBytes: number[]): Spend {
+    return makeLocking([
+      pushChunk(sigBytes),
+      pushChunk(pubkeyBytes),
+      { op: OP.OP_CHECKSIG }
+    ])
+  }
+
+  it('throws when pubkey is empty', () => {
+    expect(() => checksigSpend([], []).validate()).toThrow('Public key is empty')
+  })
+
+  it('throws when pubkey is too short (< 33 bytes)', () => {
+    const shortKey = new Array(32).fill(0x02)
+    expect(() => checksigSpend(shortKey, []).validate()).toThrow('too short')
+  })
+
+  it('throws when 0x04 pubkey is not 65 bytes', () => {
+    const wrongLen = [0x04, ...new Array(33).fill(0x00)]
+    expect(() => checksigSpend(wrongLen, []).validate()).toThrow('non-compressed public key must be 65 bytes')
+  })
+
+  it('throws when 0x02 pubkey is not 33 bytes', () => {
+    const wrongLen = [0x02, ...new Array(34).fill(0x00)]
+    expect(() => checksigSpend(wrongLen, []).validate()).toThrow('compressed public key must be 33 bytes')
+  })
+
+  it('throws when 0x03 pubkey is not 33 bytes', () => {
+    const wrongLen = [0x03, ...new Array(34).fill(0x00)]
+    expect(() => checksigSpend(wrongLen, []).validate()).toThrow('compressed public key must be 33 bytes')
+  })
+
+  it('throws when pubkey prefix is unknown', () => {
+    const unknown = new Array(33).fill(0x00)
+    unknown[0] = 0x05
+    expect(() => checksigSpend(unknown, []).validate()).toThrow('unknown format')
+  })
+
+  it('throws when pubkey prefix is 0x04 but coordinates are invalid', () => {
+    // 65-byte 0x04 with all zeros – valid length but invalid curve point
+    const bad = [0x04, ...new Array(64).fill(0x00)]
+    expect(() => checksigSpend(bad, []).validate()).toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// checkSignatureEncoding paths (lines 310-321)
+// ---------------------------------------------------------------------------
+describe('Spend – checkSignatureEncoding error paths', () => {
+  it('throws when sig has invalid DER format (wrong first byte)', () => {
+    const privKey = PrivateKey.fromRandom()
+    const pubKey = PublicKey.fromPrivateKey(privKey)
+    const badSig = [0x31, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01]
+    const spend = makeLocking([
+      pushChunk(badSig),
+      pushChunk(pubKey.toDER() as number[]),
+      { op: OP.OP_CHECKSIG }
+    ])
+    expect(() => spend.validate()).toThrow('signature format is invalid')
+  })
+
+  it('CHECKSIG with empty sig returns false result without error', () => {
+    const privKey = PrivateKey.fromRandom()
+    const pubKey = PublicKey.fromPrivateKey(privKey)
+    // empty sig → fSuccess stays false → pushes [] but still truthy check fails
+    const spend = makeLocking([
+      { op: OP.OP_0 }, // empty sig
+      pushChunk(pubKey.toDER() as number[]),
+      { op: OP.OP_CHECKSIG } // pushes [] (false)
+      // Stack is [[]] which is falsy → validate throws
+    ])
+    expect(() => spend.validate()).toThrow('top stack element must be truthy')
+  })
+
+  it('CHECKSIGVERIFY throws when sig is empty (fSuccess = false)', () => {
+    const privKey = PrivateKey.fromRandom()
+    const pubKey = PublicKey.fromPrivateKey(privKey)
+    const spend = makeLocking([
+      { op: OP.OP_0 }, // empty sig
+      pushChunk(pubKey.toDER() as number[]),
+      { op: OP.OP_CHECKSIGVERIFY },
+      { op: OP.OP_1 }
+    ])
+    expect(() => spend.validate()).toThrow('OP_CHECKSIGVERIFY requires')
+  })
+
+  it('CHECKSIGVERIFY succeeds and pops result for valid sig', async () => {
+    const privKey = PrivateKey.fromRandom()
+    const pubKey = PublicKey.fromPrivateKey(privKey)
+    const p2pkh = new P2PKH()
+    const hash = pubKey.toHash()
+    const lockingScript = p2pkh.lock(hash)
+    const sourceTx = new Transaction(1, [], [{ lockingScript, satoshis: 1 }], 0)
+    const spendTx = new Transaction(
+      1,
+      [{ sourceTransaction: sourceTx, sourceOutputIndex: 0, sequence: 0xffffffff }],
+      [],
+      0
+    )
+    const unlockingScript = await p2pkh.unlock(privKey).sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: 1,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      outputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+    expect(spend.validate()).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_CODESEPARATOR (lines 861-862)
+// ---------------------------------------------------------------------------
+describe('Spend – OP_CODESEPARATOR', () => {
+  it('sets lastCodeSeparator to current programCounter', () => {
+    const spend = makeLocking([
+      { op: OP.OP_CODESEPARATOR },
+      { op: OP.OP_1 }
+    ])
+    expect(spend.validate()).toBe(true)
+    // lastCodeSeparator was set during execution
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_VER (lines 432-435)
+// ---------------------------------------------------------------------------
+describe('Spend – OP_VER', () => {
+  it('pushes transaction version as 4-byte LE', () => {
+    // transactionVersion=2, LE=[2,0,0,0]; compare with that value
+    const spend = makeLocking([
+      { op: OP.OP_VER },
+      pushChunk([2, 0, 0, 0]),
+      { op: OP.OP_EQUAL }
+    ], { memoryLimit: 100000 })
+    // isRelaxed already set, transactionVersion defaults to 1 via makeLocking
+    // Redo with version=2
+    const spend2 = makeSpend([
+      { op: OP.OP_VER },
+      pushChunk([2, 0, 0, 0]),
+      { op: OP.OP_EQUAL }
+    ], [], { isRelaxed: true, transactionVersion: 2, memoryLimit: 100000 })
+    expect(spend2.validate()).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_SUBSTR (lines 436-449)
+// ---------------------------------------------------------------------------
+describe('Spend – OP_SUBSTR', () => {
+  it('extracts a substring from a buffer', () => {
+    // "hello" starting at offset 1, length 3 → "ell"
+    const hello = [0x68, 0x65, 0x6c, 0x6c, 0x6f]
+    const ell = [0x65, 0x6c, 0x6c]
+    const spend = makeSpend([
+      pushChunk(hello),
+      pushChunk(scriptNum(1)),
+      pushChunk(scriptNum(3)),
+      { op: OP.OP_SUBSTR },
+      pushChunk(ell),
+      { op: OP.OP_EQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('throws when OP_SUBSTR offset is out of range', () => {
+    const buf = [0x01, 0x02, 0x03]
+    const spend = makeSpend([
+      pushChunk(buf),
+      pushChunk(scriptNum(5)), // offset >= size → error
+      pushChunk(scriptNum(1)),
+      { op: OP.OP_SUBSTR },
+      { op: OP.OP_1 }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(() => spend.validate()).toThrow('OP_SUBSTR')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_LEFT / OP_RIGHT (lines 450-474)
+// ---------------------------------------------------------------------------
+describe('Spend – OP_LEFT / OP_RIGHT', () => {
+  it('OP_LEFT extracts the first N bytes', () => {
+    const buf = [0x01, 0x02, 0x03, 0x04]
+    const spend = makeSpend([
+      pushChunk(buf),
+      pushChunk(scriptNum(2)),
+      { op: OP.OP_LEFT },
+      pushChunk([0x01, 0x02]),
+      { op: OP.OP_EQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('OP_LEFT throws when len is out of range', () => {
+    const buf = [0x01, 0x02]
+    const spend = makeSpend([
+      pushChunk(buf),
+      pushChunk(scriptNum(5)), // len > size → error
+      { op: OP.OP_LEFT },
+      { op: OP.OP_1 }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(() => spend.validate()).toThrow('OP_LEFT')
+  })
+
+  it('OP_RIGHT extracts the last N bytes', () => {
+    const buf = [0x01, 0x02, 0x03, 0x04]
+    const spend = makeSpend([
+      pushChunk(buf),
+      pushChunk(scriptNum(2)),
+      { op: OP.OP_RIGHT },
+      pushChunk([0x03, 0x04]),
+      { op: OP.OP_EQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('OP_RIGHT throws when len is out of range', () => {
+    const buf = [0x01, 0x02]
+    const spend = makeSpend([
+      pushChunk(buf),
+      pushChunk(scriptNum(5)),
+      { op: OP.OP_RIGHT },
+      { op: OP.OP_1 }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(() => spend.validate()).toThrow('OP_RIGHT')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_LSHIFTNUM / OP_RSHIFTNUM (lines 476-501)
+// ---------------------------------------------------------------------------
+describe('Spend – OP_LSHIFTNUM / OP_RSHIFTNUM', () => {
+  it('OP_LSHIFTNUM shifts a number left by N bits', () => {
+    // 1 << 3 = 8
+    const spend = makeSpend([
+      pushChunk(scriptNum(1)),
+      pushChunk(scriptNum(3)),
+      { op: OP.OP_LSHIFTNUM },
+      pushChunk(scriptNum(8)),
+      { op: OP.OP_NUMEQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('OP_LSHIFTNUM throws when shift bits are negative', () => {
+    const spend = makeSpend([
+      pushChunk(scriptNum(1)),
+      pushChunk(scriptNum(-1)),
+      { op: OP.OP_LSHIFTNUM },
+      { op: OP.OP_1 }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(() => spend.validate()).toThrow('OP_LSHIFTNUM bits to shift must not be negative')
+  })
+
+  it('OP_RSHIFTNUM shifts a positive number right', () => {
+    // 8 >> 2 = 2
+    const spend = makeSpend([
+      pushChunk(scriptNum(8)),
+      pushChunk(scriptNum(2)),
+      { op: OP.OP_RSHIFTNUM },
+      pushChunk(scriptNum(2)),
+      { op: OP.OP_NUMEQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('OP_RSHIFTNUM shifts a negative number right (sign-preserving)', () => {
+    // -8 >> 2 = -2
+    const spend = makeSpend([
+      pushChunk(scriptNum(-8)),
+      pushChunk(scriptNum(2)),
+      { op: OP.OP_RSHIFTNUM },
+      pushChunk(scriptNum(-2)),
+      { op: OP.OP_NUMEQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('OP_RSHIFTNUM throws when shift bits are negative', () => {
+    const spend = makeSpend([
+      pushChunk(scriptNum(8)),
+      pushChunk(scriptNum(-1)),
+      { op: OP.OP_RSHIFTNUM },
+      { op: OP.OP_1 }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(() => spend.validate()).toThrow('OP_RSHIFTNUM bits to shift must not be negative')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_1NEGATE (line 504-505)
+// ---------------------------------------------------------------------------
+describe('Spend – OP_1NEGATE', () => {
+  it('pushes -1 onto the stack', () => {
+    const spend = makeSpend([
+      { op: OP.OP_1NEGATE },
+      pushChunk(scriptNum(-1)),
+      { op: OP.OP_NUMEQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_VERIF / OP_VERNOTIF (lines 531-544)
+// ---------------------------------------------------------------------------
+describe('Spend – OP_VERIF / OP_VERNOTIF', () => {
+  it('OP_VERIF: matching 4-byte LE version makes inner block execute', () => {
+    // version=2 → LE = [2,0,0,0]; VERIF match → ifStack=true → inner push executes
+    const spend = makeSpend([
+      pushChunk([2, 0, 0, 0]),
+      { op: OP.OP_VERIF },
+      { op: OP.OP_1 },
+      { op: OP.OP_ENDIF }
+    ], [], { isRelaxed: true, transactionVersion: 2, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('OP_VERIF: non-matching version skips inner block', () => {
+    // version=2, push [3,0,0,0] → no match → ifStack=false → inner push skipped
+    const spend = makeSpend([
+      pushChunk([3, 0, 0, 0]),
+      { op: OP.OP_VERIF },
+      { op: OP.OP_1 },
+      { op: OP.OP_ENDIF },
+      { op: OP.OP_1 } // fallback truthy result
+    ], [], { isRelaxed: true, transactionVersion: 2, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('OP_VERIF: non-4-byte value never matches', () => {
+    const spend = makeSpend([
+      pushChunk([1]),    // 1-byte value → never 4-byte match
+      { op: OP.OP_VERIF },
+      { op: OP.OP_1 },
+      { op: OP.OP_ENDIF },
+      { op: OP.OP_1 }
+    ], [], { isRelaxed: true, transactionVersion: 1, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('OP_VERNOTIF: matching version skips inner block (negated)', () => {
+    // version=2, [2,0,0,0] matches → VERNOTIF negates → ifStack=false → block skipped
+    const spend = makeSpend([
+      pushChunk([2, 0, 0, 0]),
+      { op: OP.OP_VERNOTIF },
+      { op: OP.OP_1 },
+      { op: OP.OP_ENDIF },
+      { op: OP.OP_1 }
+    ], [], { isRelaxed: true, transactionVersion: 2, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_IFDUP (lines 628-633)
+// ---------------------------------------------------------------------------
+describe('Spend – OP_IFDUP', () => {
+  it('duplicates top item when truthy', () => {
+    const spend = makeSpend([
+      { op: OP.OP_1 },
+      { op: OP.OP_IFDUP },
+      { op: OP.OP_DROP } // consume duplicate
+      // stack: [1] → truthy → validate ok
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('does NOT duplicate top item when falsy', () => {
+    // [0x00] is falsy → IFDUP leaves stack unchanged → stack=[0x00] → falsy → throws
+    const spend = makeSpend([
+      pushChunk([0x00]),
+      { op: OP.OP_IFDUP }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(() => spend.validate()).toThrow('top stack element must be truthy')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_AND / OP_OR / OP_XOR / OP_INVERT (lines 704-726)
+// ---------------------------------------------------------------------------
+describe('Spend – bitwise opcodes', () => {
+  it('OP_AND performs bitwise AND', () => {
+    const spend = makeSpend([
+      pushChunk([0xff]),
+      pushChunk([0x0f]),
+      { op: OP.OP_AND },
+      pushChunk([0x0f]),
+      { op: OP.OP_EQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('OP_AND throws when operands differ in length', () => {
+    const spend = makeSpend([
+      pushChunk([0x01, 0x02]),
+      pushChunk([0x01]),
+      { op: OP.OP_AND },
+      { op: OP.OP_1 }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(() => spend.validate()).toThrow('OP_AND requires the top two stack items to be the same size')
+  })
+
+  it('OP_OR performs bitwise OR', () => {
+    const spend = makeSpend([
+      pushChunk([0xf0]),
+      pushChunk([0x0f]),
+      { op: OP.OP_OR },
+      pushChunk([0xff]),
+      { op: OP.OP_EQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('OP_XOR performs bitwise XOR', () => {
+    const spend = makeSpend([
+      pushChunk([0xff]),
+      pushChunk([0xf0]),
+      { op: OP.OP_XOR },
+      pushChunk([0x0f]),
+      { op: OP.OP_EQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('OP_INVERT performs bitwise NOT', () => {
+    const spend = makeSpend([
+      pushChunk([0xff]),
+      { op: OP.OP_INVERT },
+      pushChunk([0x00]),
+      { op: OP.OP_EQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_2MUL / OP_2DIV (lines 775-776)
+// ---------------------------------------------------------------------------
+describe('Spend – OP_2MUL / OP_2DIV', () => {
+  it('OP_2MUL doubles the top stack value', () => {
+    const spend = makeSpend([
+      pushChunk(scriptNum(7)),
+      { op: OP.OP_2MUL },
+      pushChunk(scriptNum(14)),
+      { op: OP.OP_NUMEQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('OP_2DIV halves the top stack value', () => {
+    const spend = makeSpend([
+      pushChunk(scriptNum(8)),
+      { op: OP.OP_2DIV },
+      pushChunk(scriptNum(4)),
+      { op: OP.OP_NUMEQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_CHECKMULTISIG error paths (lines 902, 908, 916, 922, 929)
+// ---------------------------------------------------------------------------
+describe('Spend – OP_CHECKMULTISIG error paths', () => {
+  it('throws when stack is empty (no nKeys item)', () => {
+    const spend = makeLocking([{ op: OP.OP_CHECKMULTISIG }])
+    expect(() => spend.validate()).toThrow('requires at least 1 item')
+  })
+
+  it('throws when nKeys is negative', () => {
+    const spend = makeLocking([
+      pushChunk(scriptNum(-1)),
+      { op: OP.OP_CHECKMULTISIG }
+    ])
+    expect(() => spend.validate()).toThrow('key count between 0')
+  })
+
+  it('throws when stack is too small for the declared keys', () => {
+    // nKeys=2 but only the nKeys element and 1 key are available
+    const spend = makeLocking([
+      pushChunk([0x01]), // one dummy key
+      pushChunk(scriptNum(2)), // nKeys=2
+      { op: OP.OP_CHECKMULTISIG }
+    ])
+    expect(() => spend.validate()).toThrow('stack too small for nKeys and keys')
+  })
+
+  it('throws when nSigs > nKeys', () => {
+    const dummyKey = [0x02, ...new Array(32).fill(0x00)] // 33-byte invalid key (will fail later)
+    // nSigs=3 but nKeys=1
+    const spend = makeLocking([
+      pushChunk([0x00]),        // dummy
+      pushChunk(scriptNum(3)), // nSigs
+      pushChunk(dummyKey),      // key 1
+      pushChunk(scriptNum(1)), // nKeys=1
+      { op: OP.OP_CHECKMULTISIG }
+    ])
+    expect(() => spend.validate()).toThrow('number of signatures to be no greater than the number of keys')
+  })
+
+  it('throws when stack is too small for the declared sigs', () => {
+    const dummyKey = [0x02, ...new Array(32).fill(0x00)]
+    // nKeys=1, nSigs=1 but no sig or dummy on stack
+    const spend = makeLocking([
+      pushChunk(dummyKey),      // key 1
+      pushChunk(scriptNum(1)), // nKeys=1
+      { op: OP.OP_CHECKMULTISIG }
+      // nSigs would be next but stack ran out
+    ])
+    expect(() => spend.validate()).toThrow()
+  })
+
+  it('throws when non-empty dummy is present in strict mode', () => {
+    const privKey = PrivateKey.fromRandom()
+    const pubKey = PublicKey.fromPrivateKey(privKey)
+    // 0 of 0 multisig with non-empty dummy → NULLDUMMY violation
+    const spend = makeSpend([
+      pushChunk([0x01]),        // non-empty dummy (violates SCRIPT_VERIFY_NULLDUMMY)
+      pushChunk(scriptNum(0)), // nSigs=0
+      pushChunk(scriptNum(0)), // nKeys=0
+      { op: OP.OP_CHECKMULTISIG }
+    ])
+    expect(() => spend.validate()).toThrow('dummy')
+  })
+
+  it('succeeds for 0-of-0 multisig with empty dummy', () => {
+    const spend = makeSpend([
+      { op: OP.OP_0 },         // empty dummy
+      { op: OP.OP_0 },         // nSigs=0
+      { op: OP.OP_0 },         // nKeys=0
+      { op: OP.OP_CHECKMULTISIG }
+    ])
+    expect(spend.validate()).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_NUM2BIN (lines 1029-1068)
+// ---------------------------------------------------------------------------
+describe('Spend – OP_NUM2BIN', () => {
+  it('throws when the requested size is too small for the value', () => {
+    // 256 needs 2 bytes; requesting 1 byte → error
+    const spend = makeSpend([
+      pushChunk(scriptNum(256)),
+      pushChunk(scriptNum(1)), // size = 1 → too small
+      { op: OP.OP_NUM2BIN },
+      { op: OP.OP_1 }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(() => spend.validate()).toThrow('OP_NUM2BIN requires that the size')
+  })
+
+  it('pads a positive number to the requested size', () => {
+    // value=5, size=4 → [0x05, 0x00, 0x00, 0x00]
+    const spend = makeSpend([
+      pushChunk(scriptNum(5)),
+      pushChunk(scriptNum(4)),
+      { op: OP.OP_NUM2BIN },
+      pushChunk([0x05, 0x00, 0x00, 0x00]),
+      { op: OP.OP_EQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('pads a negative number to the requested size (sign bit preserved)', () => {
+    // value=-5 (scriptnum: [0x85]), size=4 → [0x05, 0x00, 0x00, 0x80]
+    const spend = makeSpend([
+      pushChunk(scriptNum(-5)),
+      pushChunk(scriptNum(4)),
+      { op: OP.OP_NUM2BIN },
+      pushChunk([0x05, 0x00, 0x00, 0x80]),
+      { op: OP.OP_EQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('does not pad when rawnum length equals requested size', () => {
+    // value=256 (scriptnum [0x00, 0x01]), size=2 → [0x00, 0x01]
+    const spend = makeSpend([
+      pushChunk(scriptNum(256)),
+      pushChunk(scriptNum(2)),
+      { op: OP.OP_NUM2BIN },
+      pushChunk([0x00, 0x01]),
+      { op: OP.OP_EQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// OP_BIN2NUM (line 1070-1078)
+// ---------------------------------------------------------------------------
+describe('Spend – OP_BIN2NUM', () => {
+  it('converts binary to minimal scriptnum', () => {
+    // [0x05, 0x00, 0x00, 0x00] → 5
+    const spend = makeSpend([
+      pushChunk([0x05, 0x00, 0x00, 0x00]),
+      { op: OP.OP_BIN2NUM },
+      pushChunk(scriptNum(5)),
+      { op: OP.OP_NUMEQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+
+  it('converts padded negative binary to minimal scriptnum', () => {
+    // [0x05, 0x00, 0x00, 0x80] → -5
+    const spend = makeSpend([
+      pushChunk([0x05, 0x00, 0x00, 0x80]),
+      { op: OP.OP_BIN2NUM },
+      pushChunk(scriptNum(-5)),
+      { op: OP.OP_NUMEQUAL }
+    ], [], { isRelaxed: true, memoryLimit: 100000 })
+    expect(spend.validate()).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Default opcode path – invalid opcode (line 1082)
+// ---------------------------------------------------------------------------
+describe('Spend – default opcode (invalid)', () => {
+  it('throws for an invalid opcode value', () => {
+    // 0xff is not a valid opcode in BSV
+    const spend = makeLocking([{ op: 0xff }])
+    expect(() => spend.validate()).toThrow('Invalid opcode')
+  })
+})