@bsv/sdk 2.0.11 → 2.0.13

package/src/script/Spend.ts

@@ -266,7 +266,11 @@ export default class Spend {
     if (this.stack.length === 0) {
       this.scriptEvaluationError('Attempted to pop from an empty stack.')
     }
-    const item = this.stack.pop() as number[]
+    const item = this.stack.pop()
+    if (item === undefined) {
+      this.scriptEvaluationError('Attempted to pop from an empty stack.')
+      return [] // unreachable; scriptEvaluationError always throws
+    }
     this.stackMem -= item.length
     return item
   }
@@ -290,7 +294,11 @@ export default class Spend {
     if (this.altStack.length === 0) {
       this.scriptEvaluationError('Attempted to pop from an empty alt stack.')
     }
-    const item = this.altStack.pop() as number[]
+    const item = this.altStack.pop()
+    if (item === undefined) {
+      this.scriptEvaluationError('Attempted to pop from an empty alt stack.')
+      return [] // unreachable; scriptEvaluationError always throws
+    }
     this.altStackMem -= item.length
     return item
   }
@@ -308,7 +316,7 @@ export default class Spend {
         this.scriptEvaluationError('The signature must have a low S value.')
         return false
       }
-    } catch (e) {
+    } catch {
       this.scriptEvaluationError('The signature format is invalid.')
       return false
     }
@@ -340,7 +348,7 @@ export default class Spend {
     }
     try {
       PublicKey.fromDER(buf as number[]) // This can throw for stricter DER rules
-    } catch (e) {
+    } catch {
       this.scriptEvaluationError('The public key is in an unknown format.')
       return false
     }
@@ -395,7 +403,7 @@ export default class Spend {
     const operation = currentScript.chunks[this.programCounter]
 
     const currentOpcode = operation.op
-    if (typeof currentOpcode === 'undefined') {
+    if (currentOpcode === undefined) {
       this.scriptEvaluationError(`Missing opcode in ${this.context} at pc=${this.programCounter}.`) // Error thrown
     }
     if (Array.isArray(operation.data) && operation.data.length > maxScriptElementSize) {
@@ -547,7 +555,7 @@ export default class Spend {
           break
         case OP.OP_ELSE:
           if (this.ifStack.length === 0) this.scriptEvaluationError('OP_ELSE requires a preceeding OP_IF.')
-          this.ifStack[this.ifStack.length - 1] = !this.ifStack[this.ifStack.length - 1]
+          this.ifStack[this.ifStack.length - 1] = !(this.ifStack[this.ifStack.length - 1])
           break
         case OP.OP_ENDIF:
           if (this.ifStack.length === 0) this.scriptEvaluationError('OP_ENDIF requires a preceeding OP_IF.')
@@ -682,7 +690,7 @@ export default class Spend {
           // stack is [... rest, x1, x2]
           // We want [... rest, x2_copy, x1, x2]
           this.ensureStackMem(buf1.length)
-          this.stack.splice(this.stack.length - 2, 0, buf1.slice()) // Insert copy of x2 before x1
+          this.stack.splice(-2, 0, buf1.slice()) // Insert copy of x2 before x1
           this.stackMem += buf1.length // Account for the new copy
           break
         case OP.OP_SIZE:
@@ -769,7 +777,7 @@ export default class Spend {
             case OP.OP_NEGATE: bn = bn.neg(); break
             case OP.OP_ABS: if (bn.isNeg()) bn = bn.neg(); break
             case OP.OP_NOT: bn = new BigNumber(bn.cmpn(0) === 0 ? 1 : 0); break
-            case OP.OP_0NOTEQUAL: bn = new BigNumber(bn.cmpn(0) !== 0 ? 1 : 0); break
+            case OP.OP_0NOTEQUAL: bn = new BigNumber(bn.cmpn(0) === 0 ? 0 : 1); break
           }
           this.pushStack(bn.toScriptNum())
           break
@@ -812,7 +820,7 @@ export default class Spend {
             case OP.OP_BOOLOR: resultBnArithmetic = new BigNumber((bn1.cmpn(0) !== 0 || bn2.cmpn(0) !== 0) ? 1 : 0); break
             case OP.OP_NUMEQUAL: resultBnArithmetic = new BigNumber(bn1.cmp(bn2) === 0 ? 1 : 0); break
             case OP.OP_NUMEQUALVERIFY: resultBnArithmetic = new BigNumber(bn1.cmp(bn2) === 0 ? 1 : 0); break
-            case OP.OP_NUMNOTEQUAL: resultBnArithmetic = new BigNumber(bn1.cmp(bn2) !== 0 ? 1 : 0); break
+            case OP.OP_NUMNOTEQUAL: resultBnArithmetic = new BigNumber(bn1.cmp(bn2) === 0 ? 0 : 1); break
             case OP.OP_LESSTHAN: resultBnArithmetic = new BigNumber(bn1.cmp(bn2) < 0 ? 1 : 0); break
             case OP.OP_GREATERTHAN: resultBnArithmetic = new BigNumber(bn1.cmp(bn2) > 0 ? 1 : 0); break
             case OP.OP_LESSTHANOREQUAL: resultBnArithmetic = new BigNumber(bn1.cmp(bn2) <= 0 ? 1 : 0); break
@@ -875,7 +883,7 @@ export default class Spend {
 
               pubkey = PublicKey.fromDER(bufPubkey)
               fSuccess = this.verifySignature(sig, pubkey, subscript)
-            } catch (e) {
+            } catch {
               fSuccess = false
             }
           }
@@ -949,7 +957,7 @@ export default class Spend {
                 sig = TransactionSignature.fromChecksigFormat(bufSig)
                 pubkey = PublicKey.fromDER(bufPubkey)
                 fOk = this.verifySignature(sig, pubkey, subscript)
-              } catch (e) {
+              } catch {
                 fOk = false
               }
             }

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)
+  })
+})