@bsv/sdk 2.0.12 → 2.0.13

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

@@ -0,0 +1,79 @@
+import LockingScript from '../../script/LockingScript'
+import UnlockingScript from '../../script/UnlockingScript'
+import Script from '../../script/Script'
+
+describe('LockingScript', () => {
+  it('isLockingScript() returns true', () => {
+    const script = new LockingScript()
+    expect(script.isLockingScript()).toBe(true)
+  })
+
+  it('isUnlockingScript() returns false', () => {
+    const script = new LockingScript()
+    expect(script.isUnlockingScript()).toBe(false)
+  })
+
+  it('extends Script', () => {
+    const script = new LockingScript()
+    expect(script).toBeInstanceOf(Script)
+  })
+
+  it('can be constructed from hex via inherited fromHex', () => {
+    const hex = '76a914' + '00'.repeat(20) + '88ac'
+    const script = Script.fromHex(hex)
+    const locking = new LockingScript()
+    locking.chunks = script.chunks
+    expect(locking.toHex()).toBe(hex)
+    expect(locking.isLockingScript()).toBe(true)
+  })
+
+  it('fromHex returns a Script instance that can be used to populate a LockingScript', () => {
+    const hex = '51' // OP_1
+    const base = Script.fromHex(hex)
+    expect(base.toHex()).toBe(hex)
+  })
+})
+
+describe('UnlockingScript', () => {
+  it('isLockingScript() returns false', () => {
+    const script = new UnlockingScript()
+    expect(script.isLockingScript()).toBe(false)
+  })
+
+  it('isUnlockingScript() returns true', () => {
+    const script = new UnlockingScript()
+    expect(script.isUnlockingScript()).toBe(true)
+  })
+
+  it('extends Script', () => {
+    const script = new UnlockingScript()
+    expect(script).toBeInstanceOf(Script)
+  })
+
+  it('can be constructed from hex via inherited fromHex', () => {
+    const hex = '4830450221'
+    const script = Script.fromHex(hex)
+    const unlocking = new UnlockingScript()
+    unlocking.chunks = script.chunks
+    expect(unlocking.isUnlockingScript()).toBe(true)
+  })
+})
+
+describe('LockingScript vs UnlockingScript', () => {
+  it('LockingScript and UnlockingScript return opposite values for isLockingScript', () => {
+    const locking = new LockingScript()
+    const unlocking = new UnlockingScript()
+    expect(locking.isLockingScript()).not.toBe(unlocking.isLockingScript())
+  })
+
+  it('LockingScript and UnlockingScript return opposite values for isUnlockingScript', () => {
+    const locking = new LockingScript()
+    const unlocking = new UnlockingScript()
+    expect(locking.isUnlockingScript()).not.toBe(unlocking.isUnlockingScript())
+  })
+
+  it('both are instances of Script', () => {
+    expect(new LockingScript()).toBeInstanceOf(Script)
+    expect(new UnlockingScript()).toBeInstanceOf(Script)
+  })
+})

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

@@ -0,0 +1,100 @@
+import Script from '../Script'
+import OP from '../OP'
+import BigNumber from '../../primitives/BigNumber'
+
+describe('Script – additional coverage', () => {
+  describe('fromHex', () => {
+    it('throws for odd-length hex string', () => {
+      expect(() => Script.fromHex('abc')).toThrow()
+    })
+
+    it('throws for non-hex characters', () => {
+      expect(() => Script.fromHex('gggg')).toThrow()
+    })
+  })
+
+  describe('isLockingScript / isUnlockingScript on base Script', () => {
+    it('throws NotImplemented for isLockingScript', () => {
+      const script = new Script()
+      expect(() => script.isLockingScript()).toThrow('Not implemented')
+    })
+
+    it('throws NotImplemented for isUnlockingScript', () => {
+      const script = new Script()
+      expect(() => script.isUnlockingScript()).toThrow('Not implemented')
+    })
+  })
+
+  describe('writeScript', () => {
+    it('appends all chunks from another script', () => {
+      const s1 = Script.fromASM('OP_1 OP_2')
+      const s2 = Script.fromASM('OP_3')
+      s1.writeScript(s2)
+      expect(s1.toASM()).toBe('OP_1 OP_2 OP_3')
+    })
+  })
+
+  describe('setChunkOpCode', () => {
+    it('replaces the opcode at the given index', () => {
+      const script = Script.fromASM('OP_1 OP_2 OP_3')
+      script.setChunkOpCode(1, OP.OP_NOP)
+      expect(script.chunks[1].op).toBe(OP.OP_NOP)
+    })
+  })
+
+  describe('writeBn', () => {
+    it('pushes OP_0 for zero', () => {
+      const script = new Script().writeBn(new BigNumber(0))
+      expect(script.chunks[0].op).toBe(OP.OP_0)
+    })
+
+    it('pushes OP_1NEGATE for -1', () => {
+      const script = new Script().writeBn(new BigNumber(-1))
+      expect(script.chunks[0].op).toBe(OP.OP_1NEGATE)
+    })
+
+    it('pushes OP_1..OP_16 for 1..16', () => {
+      for (let n = 1; n <= 16; n++) {
+        const script = new Script().writeBn(new BigNumber(n))
+        expect(script.chunks[0].op).toBe(OP.OP_1 + (n - 1))
+      }
+    })
+
+    it('pushes encoded binary for numbers > 16', () => {
+      const script = new Script().writeBn(new BigNumber(1000))
+      expect(script.chunks[0].data).toBeDefined()
+    })
+  })
+
+  describe('writeNumber', () => {
+    it('writes a number to the script', () => {
+      const script = new Script().writeNumber(5)
+      expect(script.chunks[0].op).toBe(OP.OP_5)
+    })
+  })
+
+  describe('writeBin', () => {
+    it('uses OP_PUSHDATA1 for data 76..255 bytes', () => {
+      const data = new Array(76).fill(0x01)
+      const script = new Script().writeBin(data)
+      expect(script.chunks[0].op).toBe(OP.OP_PUSHDATA1)
+    })
+
+    it('uses OP_PUSHDATA2 for data 256..65535 bytes', () => {
+      const data = new Array(256).fill(0x02)
+      const script = new Script().writeBin(data)
+      expect(script.chunks[0].op).toBe(OP.OP_PUSHDATA2)
+    })
+  })
+
+  describe('findAndDelete – PUSHDATA1 target', () => {
+    it('deletes chunks encoded with OP_PUSHDATA1 (76-255 bytes)', () => {
+      const data = new Array(76).fill(0xab)
+      const target = new Script().writeBin(data)
+      const source = new Script().writeBin(data).writeBin(data).writeOpCode(OP.OP_1)
+      source.findAndDelete(target)
+      expect(source.chunks).toHaveLength(1)
+      expect(source.chunks[0].op).toBe(OP.OP_1)
+    })
+  })
+})

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

@@ -0,0 +1,98 @@
+import ScriptEvaluationError from '../ScriptEvaluationError'
+
+const baseParams = {
+  message: 'test error',
+  txid: 'a'.repeat(64),
+  outputIndex: 0,
+  context: 'LockingScript' as const,
+  programCounter: 3,
+  stackState: [] as number[][],
+  altStackState: [] as number[][],
+  ifStackState: [] as boolean[],
+  stackMem: 0,
+  altStackMem: 0
+}
+
+describe('ScriptEvaluationError', () => {
+  it('constructs with empty stacks', () => {
+    const err = new ScriptEvaluationError(baseParams)
+    expect(err).toBeInstanceOf(Error)
+    expect(err.message).toContain('test error')
+    expect(err.txid).toBe('a'.repeat(64))
+    expect(err.outputIndex).toBe(0)
+    expect(err.context).toBe('LockingScript')
+    expect(err.programCounter).toBe(3)
+  })
+
+  it('renders valid stack items as hex in the message (toHex branch)', () => {
+    const err = new ScriptEvaluationError({
+      ...baseParams,
+      stackState: [[0xde, 0xad], [0xbe, 0xef]],
+      altStackState: [[0x01]]
+    })
+    expect(err.message).toContain('dead')
+    expect(err.message).toContain('beef')
+    expect(err.message).toContain('01')
+  })
+
+  it('renders null stack item as null/undef (null/undef branch)', () => {
+    // The message is built before the deep-copy, so null/undef branch is executed
+    // even though the constructor later throws when trying to slice null.
+    expect(() => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return new ScriptEvaluationError({ ...baseParams, stackState: [null as any] })
+    }).toThrow()
+  })
+
+  it('renders undefined stack item as null/undef (undefined branch)', () => {
+    expect(() => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return new ScriptEvaluationError({ ...baseParams, stackState: [undefined as any] })
+    }).toThrow()
+  })
+
+  it('renders non-array stack item as INVALID_STACK_ITEM', () => {
+    expect(() => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return new ScriptEvaluationError({ ...baseParams, stackState: [{ notAnArray: true } as any] })
+    }).toThrow()
+  })
+
+  it('renders null alt-stack item as null/undef (covers altStack map branches)', () => {
+    expect(() => {
+      return new ScriptEvaluationError({
+        ...baseParams,
+        stackState: [[0x01]],
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        altStackState: [null as any]
+      })
+    }).toThrow()
+  })
+
+  it('includes ifStack entries in the message', () => {
+    const err = new ScriptEvaluationError({
+      ...baseParams,
+      ifStackState: [true, false]
+    })
+    expect(err.message).toContain('true, false')
+  })
+
+  it('includes UnlockingScript context in the message', () => {
+    const err = new ScriptEvaluationError({
+      ...baseParams,
+      context: 'UnlockingScript'
+    })
+    expect(err.message).toContain('UnlockingScript')
+  })
+
+  it('deep-copies stackState and altStackState to prevent mutation', () => {
+    const originalStack = [[1, 2, 3]]
+    const err = new ScriptEvaluationError({
+      ...baseParams,
+      stackState: originalStack
+    })
+    // Mutate original — error should keep its own copy
+    originalStack[0].push(4)
+    expect(err.stackState[0]).toHaveLength(3)
+  })
+})