@bsv/sdk 2.0.9 → 2.0.11

package/src/script/__tests/ChronicleOpcodes.test.ts

@@ -0,0 +1,548 @@
+import Script from '../Script'
+import Spend from '../Spend'
+import LockingScript from '../LockingScript'
+import UnlockingScript from '../UnlockingScript'
+import ScriptChunk from '../ScriptChunk'
+import OP from '../OP'
+
+/**
+ * Chronicle upgrade opcode tests.
+ *
+ * Based on the bitcoin-sv node v1.2.0 functional test suite:
+ * https://github.com/bitcoin-sv/bitcoin-sv/tree/172c8fa38cce30cf4df0327b33c7418ea6289de8/test/functional/chronicle_upgrade_tests
+ *
+ * Covers:
+ *   - opcodes.py          → restored/new opcodes (OP_VER, OP_VERIF, OP_VERNOTIF, OP_SUBSTR, OP_LEFT, OP_RIGHT, OP_2MUL, OP_2DIV, OP_LSHIFTNUM, OP_RSHIFTNUM)
+ *   - script_num_size.py  → enlarged script number limits post-Chronicle
+ *   - Undefined opcodes   → 0xba+ must error (no longer NOPs)
+ */
+
+const ZERO_TXID = '0'.repeat(64)
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Build a ScriptChunk that pushes arbitrary bytes. */
+function pushChunk (bytes: number[]): ScriptChunk {
+  if (bytes.length === 0) return { op: OP.OP_0, data: [] }
+  if (bytes.length === 1) {
+    if (bytes[0] >= 1 && bytes[0] <= 16) return { op: OP.OP_1 + (bytes[0] - 1) }
+    if (bytes[0] === 0x81) return { op: OP.OP_1NEGATE }
+  }
+  let op: number
+  if (bytes.length < OP.OP_PUSHDATA1) op = bytes.length
+  else if (bytes.length < 256) op = OP.OP_PUSHDATA1
+  else if (bytes.length < 65536) op = OP.OP_PUSHDATA2
+  else op = OP.OP_PUSHDATA4
+  return { op, data: bytes.slice() }
+}
+
+/** Create a Spend that evaluates a locking script (with optional unlocking pushes). */
+function createSpend (
+  lockingScript: LockingScript,
+  unlockingPushes: number[][] = [],
+  txVersion: number = 1
+): Spend {
+  return new Spend({
+    sourceTXID: ZERO_TXID,
+    sourceOutputIndex: 0,
+    sourceSatoshis: 1,
+    lockingScript,
+    transactionVersion: txVersion,
+    otherInputs: [],
+    outputs: [],
+    inputIndex: 0,
+    unlockingScript: new UnlockingScript(unlockingPushes.map(pushChunk)),
+    inputSequence: 0xffffffff,
+    lockTime: 0
+  })
+}
+
+/** Create a Spend from ASM string for the locking script. */
+function createSpendFromAsm (
+  lockingAsm: string,
+  unlockingPushes: number[][] = [],
+  txVersion: number = 1
+): Spend {
+  const parsed = Script.fromASM(lockingAsm)
+  const ls = new LockingScript(parsed.chunks.map(c => ({
+    op: c.op,
+    data: Array.isArray(c.data) ? c.data.slice() : undefined
+  })))
+  return createSpend(ls, unlockingPushes, txVersion)
+}
+
+/** Build a locking script from a mixture of opcodes and byte-array pushes. */
+function buildLockingScript (items: Array<number | number[]>): LockingScript {
+  const chunks: ScriptChunk[] = items.map(item => {
+    if (typeof item === 'number') return { op: item }
+    return pushChunk(item)
+  })
+  return new LockingScript(chunks)
+}
+
+/** Encode a string to its byte array. */
+function strBytes (s: string): number[] {
+  return Array.from(Buffer.from(s, 'ascii'))
+}
+
+/** 4-byte little-endian encoding of a 32-bit integer (matching node's to_le). */
+function le4 (v: number): number[] {
+  return [v & 0xff, (v >>> 8) & 0xff, (v >>> 16) & 0xff, (v >>> 24) & 0xff]
+}
+
+/** Assert that a locking script built from items validates successfully. */
+function expectValid (items: Array<number | number[]>, txVersion: number = 1): void {
+  const spend = createSpend(buildLockingScript(items), [], txVersion)
+  expect(spend.validate()).toBe(true)
+}
+
+/** Assert that a locking script built from items throws on validation. */
+function expectInvalid (items: Array<number | number[]>, txVersion: number = 1): void {
+  const spend = createSpend(buildLockingScript(items), [], txVersion)
+  expect(() => spend.validate()).toThrow()
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('Chronicle Opcode Tests (based on bitcoin-sv node v1.2.0 test suite)', () => {
+
+  // ==========================================================================
+  // opcodes.py — OP_VER
+  // ==========================================================================
+  describe('OP_VER', () => {
+    it('pushes the transaction version (1) as 4-byte LE, then DROP + TRUE succeeds', () => {
+      // CScript([OP_VER, OP_DROP, OP_TRUE])
+      expectValid([OP.OP_VER, OP.OP_DROP, OP.OP_TRUE])
+    })
+
+    it('pushes tx version 2 correctly as 4-byte LE', () => {
+      // OP_VER should push [0x02, 0x00, 0x00, 0x00] for version 2
+      expectValid([OP.OP_VER, le4(2), OP.OP_EQUAL], 2)
+    })
+
+    it('pushes tx version 1 as [0x01, 0x00, 0x00, 0x00]', () => {
+      expectValid([OP.OP_VER, le4(1), OP.OP_EQUAL])
+    })
+
+    it('OP_VER with version 0xFF00 encodes correctly', () => {
+      const ver = 0xFF00
+      expectValid([OP.OP_VER, le4(ver), OP.OP_EQUAL], ver)
+    })
+  })
+
+  // ==========================================================================
+  // opcodes.py — OP_VERIF / OP_VERNOTIF
+  // ==========================================================================
+  describe('OP_VERIF', () => {
+    it('branches to TRUE when stack top matches tx version as 4-byte LE', () => {
+      // CScript([b'\x01\x00\x00\x00', OP_VERIF, OP_TRUE, OP_ELSE, OP_FALSE, OP_ENDIF])
+      expectValid([le4(1), OP.OP_VERIF, OP.OP_TRUE, OP.OP_ELSE, OP.OP_FALSE, OP.OP_ENDIF])
+    })
+
+    it('branches to ELSE when stack top does NOT match tx version', () => {
+      // Push version 2 encoding but tx version is 1 → VERIF is false → goes to ELSE
+      expectValid([le4(2), OP.OP_VERIF, OP.OP_FALSE, OP.OP_ELSE, OP.OP_TRUE, OP.OP_ENDIF])
+    })
+
+    it('only matches exactly 4-byte items (3-byte push fails match)', () => {
+      // Node v1.2.0: only matches when stack item is exactly 4 bytes
+      // 3 bytes — should NOT match version 1
+      expectValid([[0x01, 0x00, 0x00], OP.OP_VERIF, OP.OP_FALSE, OP.OP_ELSE, OP.OP_TRUE, OP.OP_ENDIF])
+    })
+
+    it('only matches exactly 4-byte items (5-byte push fails match)', () => {
+      expectValid([[0x01, 0x00, 0x00, 0x00, 0x00], OP.OP_VERIF, OP.OP_FALSE, OP.OP_ELSE, OP.OP_TRUE, OP.OP_ENDIF])
+    })
+
+    it('requires at least one item on the stack', () => {
+      expectInvalid([OP.OP_VERIF, OP.OP_TRUE, OP.OP_ELSE, OP.OP_FALSE, OP.OP_ENDIF])
+    })
+  })
+
+  describe('OP_VERNOTIF', () => {
+    it('branches to TRUE when stack top does NOT match tx version', () => {
+      // CScript([b'\x01\xFF\x00\x00', OP_VERNOTIF, OP_TRUE, OP_ELSE, OP_FALSE, OP_ENDIF])
+      // Version 0x00FF01 != version 1 → VERNOTIF negates → true → goes to OP_TRUE
+      expectValid([[0x01, 0xFF, 0x00, 0x00], OP.OP_VERNOTIF, OP.OP_TRUE, OP.OP_ELSE, OP.OP_FALSE, OP.OP_ENDIF])
+    })
+
+    it('branches to ELSE when stack top matches tx version', () => {
+      expectValid([le4(1), OP.OP_VERNOTIF, OP.OP_FALSE, OP.OP_ELSE, OP.OP_TRUE, OP.OP_ENDIF])
+    })
+
+    it('non-4-byte items always evaluate as not-matching (so VERNOTIF → true)', () => {
+      // 1 byte — won't match, so NOT(false) = true
+      expectValid([[0x01], OP.OP_VERNOTIF, OP.OP_TRUE, OP.OP_ELSE, OP.OP_FALSE, OP.OP_ENDIF])
+    })
+  })
+
+  // ==========================================================================
+  // opcodes.py — OP_SUBSTR (restored Chronicle opcode, 0xb3)
+  // ==========================================================================
+  describe('OP_SUBSTR', () => {
+    it("extracts 'oWorl' from 'HelloWorld' at offset 4, length 5", () => {
+      // CScript([b'HelloWorld', OP_4, OP_5, OP_SUBSTR, b'oWorl', OP_EQUAL])
+      expectValid([strBytes('HelloWorld'), OP.OP_4, OP.OP_5, OP.OP_SUBSTR, strBytes('oWorl'), OP.OP_EQUAL])
+    })
+
+    it('extracts full string with offset 0 and length = size', () => {
+      expectValid([strBytes('ABC'), OP.OP_0, OP.OP_3, OP.OP_SUBSTR, strBytes('ABC'), OP.OP_EQUAL])
+    })
+
+    it('extracts single char from beginning', () => {
+      expectValid([strBytes('Hello'), OP.OP_0, OP.OP_1, OP.OP_SUBSTR, strBytes('H'), OP.OP_EQUAL])
+    })
+
+    it('fails when offset is out of range', () => {
+      // offset 5, but string is only 2 bytes
+      expectInvalid([strBytes('Hi'), OP.OP_5, OP.OP_1, OP.OP_SUBSTR])
+    })
+
+    it('fails when length exceeds available bytes from offset', () => {
+      // offset 1, length 5, but only 1 byte remaining
+      expectInvalid([strBytes('Hi'), OP.OP_1, OP.OP_5, OP.OP_SUBSTR])
+    })
+
+    it('requires at least 3 stack items', () => {
+      expectInvalid([OP.OP_1, OP.OP_SUBSTR])
+    })
+  })
+
+  // ==========================================================================
+  // opcodes.py — OP_LEFT (restored Chronicle opcode, 0xb4)
+  // ==========================================================================
+  describe('OP_LEFT', () => {
+    it("extracts 'Hello' from 'HelloWorld' (left 5 bytes)", () => {
+      // CScript([b'HelloWorld', OP_5, OP_LEFT, b'Hello', OP_EQUAL])
+      expectValid([strBytes('HelloWorld'), OP.OP_5, OP.OP_LEFT, strBytes('Hello'), OP.OP_EQUAL])
+    })
+
+    it('left 0 bytes returns empty', () => {
+      expectValid([strBytes('Hello'), OP.OP_0, OP.OP_LEFT, OP.OP_0, OP.OP_EQUAL])
+    })
+
+    it('left full length returns the whole string', () => {
+      expectValid([strBytes('Hello'), OP.OP_5, OP.OP_LEFT, strBytes('Hello'), OP.OP_EQUAL])
+    })
+
+    it('fails when length exceeds string size', () => {
+      expectInvalid([strBytes('Hi'), OP.OP_5, OP.OP_LEFT])
+    })
+  })
+
+  // ==========================================================================
+  // opcodes.py — OP_RIGHT (restored Chronicle opcode, 0xb5)
+  // ==========================================================================
+  describe('OP_RIGHT', () => {
+    it("extracts 'World' from 'HelloWorld' (right 5 bytes)", () => {
+      // CScript([b'HelloWorld', OP_5, OP_RIGHT, b'World', OP_EQUAL])
+      expectValid([strBytes('HelloWorld'), OP.OP_5, OP.OP_RIGHT, strBytes('World'), OP.OP_EQUAL])
+    })
+
+    it('right 0 bytes returns empty', () => {
+      expectValid([strBytes('Hello'), OP.OP_0, OP.OP_RIGHT, OP.OP_0, OP.OP_EQUAL])
+    })
+
+    it('right full length returns the whole string', () => {
+      expectValid([strBytes('Hello'), OP.OP_5, OP.OP_RIGHT, strBytes('Hello'), OP.OP_EQUAL])
+    })
+
+    it('right 1 byte returns last char', () => {
+      expectValid([strBytes('Hello'), OP.OP_1, OP.OP_RIGHT, strBytes('o'), OP.OP_EQUAL])
+    })
+
+    it('fails when length exceeds string size', () => {
+      expectInvalid([strBytes('Hi'), OP.OP_5, OP.OP_RIGHT])
+    })
+  })
+
+  // ==========================================================================
+  // opcodes.py — OP_2MUL (restored Chronicle opcode, 0x8d)
+  // ==========================================================================
+  describe('OP_2MUL', () => {
+    it('1 * 2 = 2', () => {
+      // CScript([OP_1, OP_2MUL, OP_2, OP_EQUAL])
+      expectValid([OP.OP_1, OP.OP_2MUL, OP.OP_2, OP.OP_EQUAL])
+    })
+
+    it('0 * 2 = 0', () => {
+      expectValid([OP.OP_0, OP.OP_2MUL, OP.OP_0, OP.OP_EQUAL])
+    })
+
+    it('8 * 2 = 16', () => {
+      expectValid([OP.OP_8, OP.OP_2MUL, OP.OP_16, OP.OP_EQUAL])
+    })
+
+    it('-1 * 2 = -2', () => {
+      // -2 in script num is [0x82]
+      expectValid([OP.OP_1NEGATE, OP.OP_2MUL, [0x82], OP.OP_EQUAL])
+    })
+  })
+
+  // ==========================================================================
+  // opcodes.py — OP_2DIV (restored Chronicle opcode, 0x8e)
+  // ==========================================================================
+  describe('OP_2DIV', () => {
+    it('2 / 2 = 1', () => {
+      // CScript([OP_2, OP_2DIV, OP_1, OP_EQUAL])
+      expectValid([OP.OP_2, OP.OP_2DIV, OP.OP_1, OP.OP_EQUAL])
+    })
+
+    it('16 / 2 = 8', () => {
+      expectValid([OP.OP_16, OP.OP_2DIV, OP.OP_8, OP.OP_EQUAL])
+    })
+
+    it('1 / 2 = 0 (integer division)', () => {
+      expectValid([OP.OP_1, OP.OP_2DIV, OP.OP_0, OP.OP_EQUAL])
+    })
+
+    it('0 / 2 = 0', () => {
+      expectValid([OP.OP_0, OP.OP_2DIV, OP.OP_0, OP.OP_EQUAL])
+    })
+  })
+
+  // ==========================================================================
+  // opcodes.py — OP_LSHIFTNUM (restored Chronicle opcode, 0xb6)
+  // ==========================================================================
+  describe('OP_LSHIFTNUM', () => {
+    it('1 << 2 = 4', () => {
+      // CScript([OP_1, OP_2, OP_LSHIFTNUM, OP_4, OP_EQUAL])
+      expectValid([OP.OP_1, OP.OP_2, OP.OP_LSHIFTNUM, OP.OP_4, OP.OP_EQUAL])
+    })
+
+    it('1 << 1 = 2', () => {
+      const spend = createSpendFromAsm('OP_1 OP_1 OP_LSHIFTNUM OP_2 OP_EQUAL')
+      expect(spend.validate()).toBe(true)
+    })
+
+    it('1 << 8 produces a 2-byte result', () => {
+      const spend = createSpendFromAsm('OP_1 OP_8 OP_LSHIFTNUM 0001 OP_EQUAL')
+      expect(spend.validate()).toBe(true)
+    })
+  })
+
+  // ==========================================================================
+  // opcodes.py — OP_RSHIFTNUM (restored Chronicle opcode, 0xb7)
+  // ==========================================================================
+  describe('OP_RSHIFTNUM', () => {
+    it('16 >> 2 = 4', () => {
+      // CScript([OP_16, OP_2, OP_RSHIFTNUM, OP_4, OP_EQUAL])
+      expectValid([OP.OP_16, OP.OP_2, OP.OP_RSHIFTNUM, OP.OP_4, OP.OP_EQUAL])
+    })
+
+    it('4 >> 2 = 1', () => {
+      const spend = createSpendFromAsm('OP_4 OP_2 OP_RSHIFTNUM OP_1 OP_EQUAL')
+      expect(spend.validate()).toBe(true)
+    })
+
+    it('2 >> 1 = 1', () => {
+      const spend = createSpendFromAsm('OP_2 OP_1 OP_RSHIFTNUM OP_1 OP_EQUAL')
+      expect(spend.validate()).toBe(true)
+    })
+  })
+
+  // ==========================================================================
+  // All opcodes together — full post-Chronicle validation
+  // Mirrors the CHRONICLE_ACTIVATION / POST_CHRONICLE test sets from opcodes.py
+  // ==========================================================================
+  describe('Post-Chronicle opcode activation (all should succeed)', () => {
+    const tests: Array<{ name: string, ls: LockingScript, txVersion?: number }> = [
+      {
+        name: 'OP_VER OP_DROP OP_TRUE',
+        ls: buildLockingScript([OP.OP_VER, OP.OP_DROP, OP.OP_TRUE])
+      },
+      {
+        name: 'OP_VERIF with matching version (v1)',
+        ls: buildLockingScript([le4(1), OP.OP_VERIF, OP.OP_TRUE, OP.OP_ELSE, OP.OP_FALSE, OP.OP_ENDIF])
+      },
+      {
+        name: 'OP_VERNOTIF with non-matching version',
+        ls: buildLockingScript([[0x01, 0xFF, 0x00, 0x00], OP.OP_VERNOTIF, OP.OP_TRUE, OP.OP_ELSE, OP.OP_FALSE, OP.OP_ENDIF])
+      },
+      {
+        name: "OP_SUBSTR: 'oWorl' from 'HelloWorld'",
+        ls: buildLockingScript([strBytes('HelloWorld'), OP.OP_4, OP.OP_5, OP.OP_SUBSTR, strBytes('oWorl'), OP.OP_EQUAL])
+      },
+      {
+        name: "OP_LEFT: 'Hello' from 'HelloWorld'",
+        ls: buildLockingScript([strBytes('HelloWorld'), OP.OP_5, OP.OP_LEFT, strBytes('Hello'), OP.OP_EQUAL])
+      },
+      {
+        name: "OP_RIGHT: 'World' from 'HelloWorld'",
+        ls: buildLockingScript([strBytes('HelloWorld'), OP.OP_5, OP.OP_RIGHT, strBytes('World'), OP.OP_EQUAL])
+      },
+      {
+        name: 'OP_2MUL: 1 * 2 = 2',
+        ls: buildLockingScript([OP.OP_1, OP.OP_2MUL, OP.OP_2, OP.OP_EQUAL])
+      },
+      {
+        name: 'OP_2DIV: 2 / 2 = 1',
+        ls: buildLockingScript([OP.OP_2, OP.OP_2DIV, OP.OP_1, OP.OP_EQUAL])
+      },
+      {
+        name: 'OP_LSHIFTNUM: 1 << 2 = 4',
+        ls: buildLockingScript([OP.OP_1, OP.OP_2, OP.OP_LSHIFTNUM, OP.OP_4, OP.OP_EQUAL])
+      },
+      {
+        name: 'OP_RSHIFTNUM: 16 >> 2 = 4',
+        ls: buildLockingScript([OP.OP_16, OP.OP_2, OP.OP_RSHIFTNUM, OP.OP_4, OP.OP_EQUAL])
+      }
+    ]
+
+    for (const t of tests) {
+      it(t.name, () => {
+        const spend = createSpend(t.ls, [], t.txVersion ?? 1)
+        expect(spend.validate()).toBe(true)
+      })
+    }
+  })
+
+  // ==========================================================================
+  // Undefined opcodes >= 0xba must now fail (no longer treated as NOPs)
+  // Per node v1.2.0: opcodes >= FIRST_UNDEFINED_OP_VALUE (0xba) return SCRIPT_ERR_BAD_OPCODE
+  // ==========================================================================
+  describe('Undefined opcodes (>= 0xba) must fail', () => {
+    const undefinedOpcodes = [
+      { name: 'OP_NOP11 (0xba)', value: 0xba },
+      { name: 'OP_NOP12 (0xbb)', value: 0xbb },
+      { name: 'OP_NOP16 (0xbf)', value: 0xbf },
+      { name: 'OP_NOP20 (0xc3)', value: 0xc3 },
+      { name: 'OP_NOP32 (0xcf)', value: 0xcf },
+      { name: 'OP_NOP50 (0xe1)', value: 0xe1 },
+      { name: 'OP_NOP73 (0xf8)', value: 0xf8 },
+      { name: '0xf9 (OP_SMALLDATA)', value: 0xf9 },
+      { name: 'OP_INVALIDOPCODE (0xff)', value: 0xff }
+    ]
+
+    for (const { name, value } of undefinedOpcodes) {
+      it(`${name} should error when executed`, () => {
+        // Build a script that executes the undefined opcode followed by OP_TRUE
+        const ls = new LockingScript([{ op: value }, { op: OP.OP_TRUE }])
+        const spend = createSpend(ls)
+        expect(() => spend.validate()).toThrow()
+      })
+    }
+  })
+
+  // ==========================================================================
+  // Valid NOPs that should still work (OP_NOP1, OP_NOP2/CLTV, OP_NOP3/CSV, OP_NOP9, OP_NOP10)
+  // ==========================================================================
+  describe('Valid NOPs still work', () => {
+    const validNops = [
+      { name: 'OP_NOP1 (0xb0)', value: OP.OP_NOP1 },
+      { name: 'OP_CHECKLOCKTIMEVERIFY/OP_NOP2 (0xb1)', value: OP.OP_CHECKLOCKTIMEVERIFY },
+      { name: 'OP_CHECKSEQUENCEVERIFY/OP_NOP3 (0xb2)', value: OP.OP_CHECKSEQUENCEVERIFY },
+      { name: 'OP_NOP9 (0xb8)', value: OP.OP_NOP9 },
+      { name: 'OP_NOP10 (0xb9)', value: OP.OP_NOP10 }
+    ]
+
+    for (const { name, value } of validNops) {
+      it(`${name} acts as NOP and script succeeds`, () => {
+        const ls = new LockingScript([{ op: value }, { op: OP.OP_TRUE }])
+        const spend = createSpend(ls)
+        expect(spend.validate()).toBe(true)
+      })
+    }
+  })
+
+  // ==========================================================================
+  // script_num_size.py — Larger script numbers work post-Chronicle
+  // ==========================================================================
+  describe('Script number size (post-Chronicle)', () => {
+    it('a script number up to old genesis limit (750000 bytes) executes OP_1ADD successfully', () => {
+      // A large script number followed by OP_1ADD OP_DROP OP_TRUE
+      // Use a modest size that proves the limit is > 4 bytes (pre-genesis limit)
+      const bigNum = new Array(8).fill(42) // 8-byte script number
+      expectValid([bigNum, OP.OP_1ADD, OP.OP_DROP, OP.OP_TRUE])
+    })
+
+    it('OP_MUL works with numbers up to the genesis script num size', () => {
+      // Use OP_DUP OP_MUL to square a number, verifying arithmetic on larger nums
+      expectValid([OP.OP_3, OP.OP_DUP, OP.OP_MUL, OP.OP_9, OP.OP_EQUAL])
+    })
+  })
+
+  // ==========================================================================
+  // OP_RIGHT fix verification — the PR fixed buf.slice(size - len, len) → buf.slice(size - len)
+  // ==========================================================================
+  describe('OP_RIGHT slice fix', () => {
+    it('correctly returns last N bytes for various inputs', () => {
+      const testCases = [
+        { input: [1, 2, 3, 4, 5], len: 3, expected: [3, 4, 5] },
+        { input: [0xAA, 0xBB, 0xCC, 0xDD], len: 2, expected: [0xCC, 0xDD] },
+        { input: [0xFF], len: 1, expected: [0xFF] },
+        { input: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], len: 1, expected: [10] }
+      ]
+
+      for (const { input, len, expected } of testCases) {
+        const lenOpcode = OP.OP_1 + (len - 1) // len is always 1-10 in our test cases
+        expectValid([input, lenOpcode, OP.OP_RIGHT, expected, OP.OP_EQUAL])
+      }
+    })
+  })
+
+  // ==========================================================================
+  // OP_VER encoding fix — the PR changed from script-number to 4-byte LE
+  // ==========================================================================
+  describe('OP_VER encoding (4-byte LE, not script num)', () => {
+    it('version 1 pushes exactly [0x01, 0x00, 0x00, 0x00] (not script num [0x01])', () => {
+      // If OP_VER used script num, it would push [0x01] (1 byte).
+      // With the fix it pushes 4 bytes. Check by testing SIZE.
+      expectValid([
+        OP.OP_VER,
+        OP.OP_SIZE,       // push size of top element
+        OP.OP_4,          // expected: 4 bytes
+        OP.OP_EQUALVERIFY,
+        le4(1),           // verify actual value
+        OP.OP_EQUAL
+      ])
+    })
+
+    it('version 256 pushes [0x00, 0x01, 0x00, 0x00]', () => {
+      expectValid([OP.OP_VER, [0x00, 0x01, 0x00, 0x00], OP.OP_EQUAL], 256)
+    })
+  })
+
+  // ==========================================================================
+  // Combined OP_LEFT + OP_RIGHT = OP_SPLIT equivalent
+  // ==========================================================================
+  describe('OP_LEFT + OP_RIGHT composition', () => {
+    it('LEFT + RIGHT can reconstruct the original string', () => {
+      // Take 'HelloWorld', LEFT 5 → 'Hello', original RIGHT 5 → 'World', CAT → 'HelloWorld'
+      expectValid([
+        strBytes('HelloWorld'),
+        OP.OP_DUP,
+        OP.OP_5,
+        OP.OP_LEFT,   // stack: 'HelloWorld', 'Hello'
+        OP.OP_SWAP,
+        OP.OP_5,
+        OP.OP_RIGHT,  // stack: 'Hello', 'World'
+        OP.OP_CAT,    // stack: 'HelloWorld'
+        strBytes('HelloWorld'),
+        OP.OP_EQUAL
+      ])
+    })
+  })
+
+  // ==========================================================================
+  // Edge cases for OP_VERIF/OP_VERNOTIF with different version numbers
+  // ==========================================================================
+  describe('OP_VERIF/OP_VERNOTIF edge cases', () => {
+    it('OP_VERIF with tx version 2 matches [0x02, 0x00, 0x00, 0x00]', () => {
+      expectValid([le4(2), OP.OP_VERIF, OP.OP_TRUE, OP.OP_ELSE, OP.OP_FALSE, OP.OP_ENDIF], 2)
+    })
+
+    it('OP_VERIF with empty stack item (0 bytes) does not match any version', () => {
+      // OP_0 pushes empty array
+      expectValid([OP.OP_0, OP.OP_VERIF, OP.OP_FALSE, OP.OP_ELSE, OP.OP_TRUE, OP.OP_ENDIF])
+    })
+
+    it('OP_VERNOTIF with tx version 2: matching value goes to ELSE', () => {
+      expectValid([le4(2), OP.OP_VERNOTIF, OP.OP_FALSE, OP.OP_ELSE, OP.OP_TRUE, OP.OP_ENDIF], 2)
+    })
+  })
+})

package/src/transaction/MerklePath.ts

@@ -281,9 +281,13 @@ export default class MerklePath {
     // special case for blocks with only one transaction
     if (this.path.length === 1 && this.path[0].length === 1) return workingHash
 
-    for (let height = 0; height < this.path.length; height++) {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const leaves = this.path[height]
+    // Determine effective tree height. For a compound path where all txids are at level 0
+    // (path.length === 1 or intermediate levels are empty/trimmed), we need to compute up
+    // to the height implied by the highest offset present in path[0].
+    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))
+
+    for (let height = 0; height < treeHeight; height++) {
       const offset = (index >> height) ^ 1
       const leaf = this.findOrComputeLeaf(height, offset)
       if (typeof leaf !== 'object') {
@@ -315,9 +319,9 @@ export default class MerklePath {
     const hash = (m: string): string =>
       toHex(hash256(toArray(m, 'hex').reverse()).reverse())
 
-    let leaf: MerklePathLeaf | undefined = this.path[height].find(
-      (l) => l.offset === offset
-    )
+    let leaf: MerklePathLeaf | undefined = height < this.path.length
+      ? this.path[height].find((l) => l.offset === offset)
+      : undefined
 
     if (leaf != null) return leaf
 

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

@@ -1,8 +1,12 @@
 import ChainTracker from '../ChainTracker'
 import MerklePath from '../../transaction/MerklePath'
+import { hash256 } from '../../primitives/Hash'
+import { toHex, toArray } from '../../primitives/utils'
 import invalidBumps from './bump.invalid.vectors'
 import validBumps from './bump.valid.vectors'
 
+const merkleHash = (m: string): string => toHex(hash256(toArray(m, 'hex').reverse()).reverse())
+
 const BRC74Hex =
   'fe8a6a0c000c04fde80b0011774f01d26412f0d16ea3f0447be0b5ebec67b0782e321a7a01cbdf7f734e30fde90b02004e53753e3fe4667073063a17987292cfdea278824e9888e52180581d7188d8fdea0b025e441996fc53f0191d649e68a200e752fb5f39e0d5617083408fa179ddc5c998fdeb0b0102fdf405000671394f72237d08a4277f4435e5b6edf7adc272f25effef27cdfe805ce71a81fdf50500262bccabec6c4af3ed00cc7a7414edea9c5efa92fb8623dd6160a001450a528201fdfb020101fd7c010093b3efca9b77ddec914f8effac691ecb54e2c81d0ab81cbc4c4b93befe418e8501bf01015e005881826eb6973c54003a02118fe270f03d46d02681c8bc71cd44c613e86302f8012e00e07a2bb8bb75e5accff266022e1e5e6e7b4d6d943a04faadcf2ab4a22f796ff30116008120cafa17309c0bb0e0ffce835286b3a2dcae48e4497ae2d2b7ced4f051507d010a00502e59ac92f46543c23006bff855d96f5e648043f0fb87a7a5949e6a9bebae430104001ccd9f8f64f4d0489b30cc815351cf425e0e78ad79a589350e4341ac165dbe45010301010000af8764ce7e1cc132ab5ed2229a005c87201c9a5ee15c0f91dd53eff31ab30cd4'
 
@@ -131,6 +135,26 @@ class FakeChainTracker implements ChainTracker {
   }
 }
 
+/** Splits BRC74JSON into two partial paths (A covers txid2, B covers txid3) ready to combine. */
+function buildSplitPaths (): [MerklePath, MerklePath] {
+  const path0A = [...BRC74JSON.path[0]]
+  const path0B = [...BRC74JSON.path[0]]
+  const path1A = [...BRC74JSON.path[1]]
+  const path1B = [...BRC74JSON.path[1]]
+  const pathRest = [...BRC74JSON.path]
+  pathRest.shift()
+  pathRest.shift()
+  path0A.splice(2, 2)
+  path0B.shift()
+  path0B.shift()
+  path1A.shift()
+  path1B.pop()
+  return [
+    new MerklePath(BRC74JSON.blockHeight, [path0A, path1A, ...pathRest]),
+    new MerklePath(BRC74JSON.blockHeight, [path0B, path1B, ...pathRest])
+  ]
+}
+
 describe('MerklePath', () => {
   it('Parses from hex', () => {
     const path = MerklePath.fromHex(BRC74Hex)
@@ -163,28 +187,7 @@ describe('MerklePath', () => {
     )
   })
   it('Combines two paths', () => {
-    const path0A = [...BRC74JSON.path[0]]
-    const path0B = [...BRC74JSON.path[0]]
-    const path1A = [...BRC74JSON.path[1]]
-    const path1B = [...BRC74JSON.path[1]]
-    const pathRest = [...BRC74JSON.path]
-    pathRest.shift()
-    pathRest.shift()
-    path0A.splice(2, 2)
-    path0B.shift()
-    path0B.shift()
-    path1A.shift()
-    path1B.pop()
-    const pathAJSON = {
-      blockHeight: BRC74JSON.blockHeight,
-      path: [path0A, path1A, ...pathRest]
-    }
-    const pathBJSON = {
-      blockHeight: BRC74JSON.blockHeight,
-      path: [path0B, path1B, ...pathRest]
-    }
-    const pathA = new MerklePath(pathAJSON.blockHeight, pathAJSON.path)
-    const pathB = new MerklePath(pathBJSON.blockHeight, pathBJSON.path)
+    const [pathA, pathB] = buildSplitPaths()
     expect(pathA.computeRoot(BRC74TXID2)).toEqual(BRC74Root)
     expect(() => pathA.computeRoot(BRC74TXID3)).toThrow()
     expect(() => pathB.computeRoot(BRC74TXID2)).toThrow()
@@ -194,6 +197,41 @@ describe('MerklePath', () => {
     expect(pathA.computeRoot(BRC74TXID2)).toEqual(BRC74Root)
     expect(pathA.computeRoot(BRC74TXID3)).toEqual(BRC74Root)
   })
+  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)
+  })
+  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.
+    // The implementation should be able to compute the merkle root by calculating up from the leaves.
+    const tx0 = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+    const tx1 = 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+    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)
+    // 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)
+  })
   it('Rejects invalid bumps', () => {
     for (const invalid of invalidBumps) {
       expect(() => MerklePath.fromHex(invalid.bump)).toThrow(invalid.error)