@bsv/sdk 1.0.0

package/src/script/UnlockingScript.ts

@@ -0,0 +1,30 @@
+import Script from './Script.js'
+
+/**
+ * The UnlockingScript class represents an unlocking script in a Bitcoin SV transaction.
+ * It extends the Script class and is used specifically for input scripts that unlock funds.
+ *
+ * Inherits all properties and methods from the Script class.
+ *
+ * @extends {Script}
+ * @see {@link Script} for more information on Script.
+ */
+export default class UnlockingScript extends Script {
+  /**
+   * @method isLockingScript
+   * Determines if the script is a locking script.
+   * @returns {boolean} Always returns false for an UnlockingScript instance.
+   */
+  isLockingScript (): boolean {
+    return false
+  }
+
+  /**
+   * @method isUnlockingScript
+   * Determines if the script is an unlocking script.
+   * @returns {boolean} Always returns true for an UnlockingScript instance.
+   */
+  isUnlockingScript (): boolean {
+    return true
+  }
+}

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

@@ -0,0 +1,369 @@
+import Script from '../../../dist/cjs/src/script/Script'
+import OP from '../../../dist/cjs/src/script/OP'
+import { toHex } from '../../../dist/cjs/src/primitives/utils'
+import scriptFromVector from './scriptFromVector'
+
+import scriptInvalid from './script.invalid.vectors'
+import scriptValid from './script.valid.vectors'
+
+describe('Script', () => {
+  it('should make a new script', () => {
+    const script = new Script()
+    expect(script).toBeDefined()
+    expect(new Script().toASM()).toEqual('')
+  })
+
+  describe('fromHex', () => {
+    it('should parse this hex string containing an OP code', () => {
+      const buf = Buffer.alloc(1)
+      buf[0] = OP.OP_0
+      const script = Script.fromHex(buf.toString('hex'))
+      expect(script.chunks).toHaveLength(1)
+      expect(script.chunks[0].op).toBe(buf[0])
+    })
+  })
+
+  describe('fromBinary', () => {
+    it('should parse this buffer containing an OP code', () => {
+      const buf = Buffer.alloc(1)
+      buf[0] = OP.OP_0
+      const script = Script.fromBinary(buf)
+      expect(script.chunks).toHaveLength(1)
+      expect(script.chunks[0].op).toBe(buf[0])
+    })
+
+    it('should parse this buffer containing another OP code', () => {
+      const buf = Buffer.alloc(1)
+      buf[0] = OP.OP_CHECKMULTISIG
+      const script = Script.fromBinary(buf)
+      expect(script.chunks).toHaveLength(1)
+      expect(script.chunks[0].op).toBe(buf[0])
+    })
+
+    it('should parse this buffer containing three bytes of data', () => {
+      const buf = ([3, 1, 2, 3])
+      const script = Script.fromBinary(buf)
+      expect(script.chunks).toHaveLength(1)
+      expect(script.chunks[0].data).toEqual([1, 2, 3])
+    })
+
+    it('should parse this buffer containing OP_PUSHDATA1 and zero bytes of data', () => {
+      const buf = ([0])
+      buf[0] = OP.OP_PUSHDATA1
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(1)
+      expect(script.chunks[0].data).toEqual([])
+    })
+
+    it('should parse this buffer containing OP_PUSHDATA2 and zero bytes of data', () => {
+      const buf = ([0])
+      buf[0] = OP.OP_PUSHDATA2
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(1)
+      expect(script.chunks[0].data).toEqual([])
+    })
+
+    it('should parse this buffer containing OP_PUSHDATA2 and three bytes of data', () => {
+      const buf = ([OP.OP_PUSHDATA2, 3, 0, 1, 2, 3])
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(1)
+      expect(script.chunks[0].data).toEqual([1, 2, 3])
+    })
+
+    it('should parse this buffer containing OP_PUSHDATA4 and zero bytes of data', () => {
+      const buf = ([0, 0])
+      buf[0] = OP.OP_PUSHDATA4
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(1)
+      expect(script.chunks[0].data).toEqual([])
+    })
+
+    it('should parse this buffer containing OP_PUSHDATA4 and three bytes of data', () => {
+      const buf = [OP.OP_PUSHDATA4, 3, 0, 0, 0, 1, 2, 3]
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(1)
+      expect(script.chunks[0].data).toEqual([1, 2, 3])
+    })
+
+    it('should parse this buffer an OP code, data, and another OP code', () => {
+      const buf = [OP.OP_0, OP.OP_PUSHDATA4, 3, 0, 0, 0, 1, 2, 3, OP.OP_0]
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(3)
+      expect(script.chunks[0].op).toEqual(buf[0])
+      expect(script.chunks[1].data).toEqual([1, 2, 3])
+      expect(script.chunks[2].op).toEqual(buf[buf.length - 1])
+    })
+
+    it('should output this hex string containing an OP code', () => {
+      const buf = Buffer.alloc(1)
+      buf[0] = OP.OP_0
+      const script = Script.fromHex(buf.toString('hex'))
+      expect(script.chunks.length).toEqual(1)
+      expect(script.chunks[0].op).toEqual(buf[0])
+      expect(script.toHex()).toEqual(buf.toString('hex'))
+    })
+
+    it('should output this buffer containing an OP code', () => {
+      const buf = Buffer.alloc(1)
+      buf[0] = OP.OP_0
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(1)
+      expect(script.chunks[0].op).toEqual(buf[0])
+      expect(script.toHex()).toEqual(buf.toString('hex'))
+    })
+
+    it('should output this buffer containing another OP code', () => {
+      const buf = Buffer.alloc(1)
+      buf[0] = OP.OP_CHECKMULTISIG
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(1)
+      expect(script.chunks[0].op).toEqual(buf[0])
+      expect(script.toHex()).toEqual(buf.toString('hex'))
+    })
+
+    it('should output this buffer containing three bytes of data', () => {
+      const buf = Buffer.from([3, 1, 2, 3])
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(1)
+      expect(script.chunks[0].data).toEqual([1, 2, 3])
+      expect(script.toHex()).toEqual(buf.toString('hex'))
+    })
+
+    it('should output this buffer containing OP_PUSHDATA1 and three bytes of data', () => {
+      const buf = Buffer.from([0, 0, 1, 2, 3])
+      buf[0] = OP.OP_PUSHDATA1
+      buf.writeUInt8(3, 1)
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(1)
+      expect(script.chunks[0].data).toEqual([1, 2, 3])
+      expect(script.toHex()).toEqual(buf.toString('hex'))
+    })
+
+    it('should output this buffer containing OP_PUSHDATA2 and three bytes of data', () => {
+      const buf = Buffer.from([0, 0, 0, 1, 2, 3])
+      buf[0] = OP.OP_PUSHDATA2
+      buf.writeUInt16LE(3, 1)
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(1)
+      expect(script.chunks[0].data).toEqual([1, 2, 3])
+      expect(script.toHex()).toEqual(buf.toString('hex'))
+    })
+
+    it('should output this buffer containing OP_PUSHDATA4 and three bytes of data', () => {
+      const buf = Buffer.from([0, 0, 0, 0, 0, 1, 2, 3])
+      buf[0] = OP.OP_PUSHDATA4
+      buf.writeUInt16LE(3, 1)
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(1)
+      expect(script.chunks[0].data).toEqual([1, 2, 3])
+      expect(script.toHex()).toEqual(buf.toString('hex'))
+    })
+
+    it('should output this buffer an OP code, data, and another OP code', () => {
+      const buf = Buffer.from([0, 0, 0, 0, 0, 0, 1, 2, 3, 0])
+      buf[0] = OP.OP_0
+      buf[1] = OP.OP_PUSHDATA4
+      buf.writeUInt16LE(3, 2)
+      buf[buf.length - 1] = OP.OP_0
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(3)
+      expect(script.chunks[0].op).toEqual(buf[0])
+      expect(script.chunks[1].data).toEqual([1, 2, 3])
+      expect(script.chunks[2].op).toEqual(buf[buf.length - 1])
+      expect(script.toHex()).toEqual(buf.toString('hex'))
+    })
+  })
+
+  describe('toASM', () => {
+    it('should output this buffer an OP code, data, and another OP code', () => {
+      const buf = Buffer.from([0, 0, 0, 0, 0, 0, 1, 2, 3, 0])
+      buf[0] = OP.OP_0
+      buf[1] = OP.OP_PUSHDATA4
+      buf.writeUInt16LE(3, 2)
+      buf[buf.length - 1] = OP.OP_0
+      const script = Script.fromBinary(buf)
+      expect(script.chunks.length).toEqual(3)
+      expect(script.chunks[0].op).toEqual(buf[0])
+      expect(script.chunks[1].data).toEqual([1, 2, 3])
+      expect(script.chunks[2].op).toEqual(buf[buf.length - 1])
+      expect(script.toASM()).toEqual('OP_0 010203 OP_0')
+    })
+  })
+
+  describe('fromASM', () => {
+    it('should parse these known scripts', () => {
+      expect(Script.fromASM('OP_0 010203 OP_0')
+        .toASM()
+      ).toEqual('OP_0 010203 OP_0')
+      expect(Script.fromASM(
+        'OP_DUP OP_HASH160 1451baa3aad777144a0759998a03538018dd7b4b OP_EQUALVERIFY OP_CHECKSIG'
+      ).toASM()).toEqual(
+        'OP_DUP OP_HASH160 1451baa3aad777144a0759998a03538018dd7b4b OP_EQUALVERIFY OP_CHECKSIG'
+      )
+      expect(Script.fromASM(
+        'OP_SHA256 8cc17e2a2b10e1da145488458a6edec4a1fdb1921c2d5ccbc96aa0ed31b4d5f8 OP_EQUALVERIFY OP_DUP OP_HASH160 1451baa3aad777144a0759998a03538018dd7b4b OP_EQUALVERIFY OP_CHECKSIGVERIFY OP_EQUALVERIFY OP_DUP OP_HASH160 1451baa3aad777144a0759998a03538018dd7b4b OP_EQUALVERIFY OP_CHECKSIG'
+      ).toASM()).toEqual(
+        'OP_SHA256 8cc17e2a2b10e1da145488458a6edec4a1fdb1921c2d5ccbc96aa0ed31b4d5f8 OP_EQUALVERIFY OP_DUP OP_HASH160 1451baa3aad777144a0759998a03538018dd7b4b OP_EQUALVERIFY OP_CHECKSIGVERIFY OP_EQUALVERIFY OP_DUP OP_HASH160 1451baa3aad777144a0759998a03538018dd7b4b OP_EQUALVERIFY OP_CHECKSIG'
+      )
+      expect(Script.fromASM('OP_0 010203 OP_0')
+        .toASM()
+      ).toEqual('OP_0 010203 OP_0')
+      expect(Script.fromASM('OP_0 010203 OP_0')
+        .toASM()
+      ).toEqual('OP_0 010203 OP_0')
+      expect(Script.fromASM('OP_0 3 010203 OP_0').toASM()).toEqual('OP_0 03 010203 OP_0')
+      expect(Script.fromASM('').toASM()).toEqual('')
+    })
+    it('should parse this known script in ASM', () => {
+      const asm = 'OP_DUP OP_HASH160 f4c03610e60ad15100929cc23da2f3a799af1725 OP_EQUALVERIFY OP_CHECKSIG'
+      const script = Script.fromASM(asm)
+      expect(script.chunks[0].op).toEqual(OP.OP_DUP)
+      expect(script.chunks[1].op).toEqual(OP.OP_HASH160)
+      expect(script.chunks[2].op).toEqual(20)
+      expect(toHex(script.chunks[2].data)).toEqual('f4c03610e60ad15100929cc23da2f3a799af1725')
+      expect(script.chunks[3].op).toEqual(OP.OP_EQUALVERIFY)
+      expect(script.chunks[4].op).toEqual(OP.OP_CHECKSIG)
+    })
+
+    it('should parse this known problematic script in ASM', () => {
+      const asm = 'OP_RETURN 026d02 0568656c6c6f'
+      const script = Script.fromASM(asm)
+      expect(script.toASM()).toEqual(asm)
+    })
+
+    it('should know this is invalid hex', () => {
+      const asm = 'OP_RETURN 026d02 0568656c6c6fzz'
+
+      const createScript = () => {
+        const script = Script.fromASM(asm)
+        return script.toASM()
+      }
+
+      // Expect the function to throw an error with the specified message
+      expect(createScript).toThrow('invalid hex string in script')
+    })
+
+    it('should parse this long PUSHDATA1 script in ASM', () => {
+      const buf = Buffer.alloc(220, 0)
+      const asm = 'OP_RETURN ' + buf.toString('hex')
+      const script = Script.fromASM(asm)
+      expect(script.chunks[1].op).toEqual(OP.OP_PUSHDATA1)
+      expect(script.toASM()).toEqual(asm)
+    })
+
+    it('should parse this long PUSHDATA2 script in ASM', () => {
+      const buf = Buffer.alloc(1024, 0)
+      const asm = 'OP_RETURN ' + buf.toString('hex')
+      const script = Script.fromASM(asm)
+      expect(script.chunks[1].op).toEqual(OP.OP_PUSHDATA2)
+      expect(script.toASM()).toEqual(asm)
+    })
+
+    it('should parse this long PUSHDATA4 script in ASM', () => {
+      const buf = Buffer.alloc(Math.pow(2, 17), 0)
+      const asm = 'OP_RETURN ' + buf.toString('hex')
+      const script = Script.fromASM(asm)
+      expect(script.chunks[1].op).toEqual(OP.OP_PUSHDATA4)
+      expect(script.toASM()).toEqual(asm)
+    })
+
+    it('should return this script correctly', () => {
+      const asm1 = 'OP_FALSE'
+      const asm2 = 'OP_0'
+      const asm3 = '0'
+      expect(Script.fromASM(asm1).toASM()).toEqual(asm2)
+      expect(Script.fromASM(asm2).toASM()).toEqual(asm2)
+      expect(Script.fromASM(asm3).toASM()).toEqual(asm2)
+    })
+
+    it('should return this script correctly', () => {
+      const asm1 = 'OP_1NEGATE'
+      const asm2 = '-1'
+      expect(Script.fromASM(asm1).toASM()).toEqual(asm1)
+      expect(Script.fromASM(asm2).toASM()).toEqual(asm1)
+    })
+  })
+
+  describe('#removeCodeseparators', () => {
+    it('should remove any OP_CODESEPARATORs', () => {
+      expect(Script.fromASM('OP_CODESEPARATOR OP_0 OP_CODESEPARATOR')
+        .removeCodeseparators()
+        .toASM()).toEqual('OP_0')
+    })
+  })
+
+  describe('#isPushOnly', () => {
+    it("should know these scripts are or aren't push only", () => {
+      expect(Script.fromASM('OP_0').isPushOnly()).toEqual(true)
+      expect(Script.fromASM('OP_0 OP_RETURN').isPushOnly()).toEqual(false)
+      expect(Script.fromASM('OP_PUSHDATA1 5 1010101010').isPushOnly()).toEqual(true)
+
+      // like bitcoind, we regard OP_RESERVED as being "push only"
+      expect(Script.fromASM('OP_RESERVED').isPushOnly()).toEqual(true)
+    })
+  })
+
+  describe('#findAndDelete', () => {
+    it('should find and delete this buffer', () => {
+      expect(Script
+        .fromASM('OP_RETURN f0f0')
+        .findAndDelete(Script.fromASM('f0f0'))
+        .toASM()).toEqual('OP_RETURN')
+    })
+  })
+
+  describe('vectors', () => {
+    scriptValid.forEach((a, i) => {
+      if (a.length === 1) {
+        return
+      }
+      it(`should not fail when reading scriptValid vector ${i}`, () => {
+        expect(() => {
+          scriptFromVector(a[0]).toHex()
+          scriptFromVector(a[0]).toASM()
+        }).not.toThrow()
+
+        expect(() => {
+          scriptFromVector(a[1]).toHex()
+          scriptFromVector(a[1]).toASM()
+        }).not.toThrow()
+
+        // should be able to return the same output over and over
+        let str = scriptFromVector(a[0]).toASM()
+        expect(Script.fromASM(str).toASM()).toEqual(str)
+        str = scriptFromVector(a[1]).toASM()
+        expect(Script.fromASM(str).toASM()).toEqual(str)
+      })
+    })
+
+    scriptInvalid.forEach((a, i) => {
+      if (a.length === 1) {
+        return
+      }
+
+      it(`should not fail when reading scriptInvalid vector ${i}`, () => {
+      // Test that no errors are thrown for the first item
+        expect(() => {
+          const scriptA = scriptFromVector(a[0])
+          scriptA.toHex()
+          scriptA.toASM()
+        }).not.toThrow()
+
+        // Test that no errors are thrown for the second item
+        expect(() => {
+          const scriptB = scriptFromVector(a[1])
+          scriptB.toHex()
+          scriptB.toASM()
+        }).not.toThrow()
+
+        // Test that it should be able to return the same output over and over for the first item
+        const strA = scriptFromVector(a[0]).toASM()
+        expect(Script.fromASM(strA).toASM()).toEqual(strA)
+
+        // Test that it should be able to return the same output over and over for the second item
+        const strB = scriptFromVector(a[1]).toASM()
+        expect(Script.fromASM(strB).toASM()).toEqual(strB)
+      })
+    })
+  })
+})

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

@@ -0,0 +1,248 @@
+import BigNumber from '../../../dist/cjs/src/primitives/BigNumber'
+import PrivateKey from '../../../dist/cjs/src/primitives/PrivateKey'
+import { hash160, hash256 } from '../../../dist/cjs/src/primitives/Hash'
+import Curve from '../../../dist/cjs/src/primitives/Curve'
+import Spend from '../../../dist/cjs/src/script/Spend'
+import P2PKH from '../../../dist/cjs/src/script/templates/P2PKH'
+import RPuzzle from '../../../dist/cjs/src/script/templates/RPuzzle'
+import Transaction from '../../../dist/cjs/src/transaction/Transaction'
+import scriptFromVector from './scriptFromVector'
+import LockingScript from '../../../dist/cjs/src/script/LockingScript'
+import UnlockingScript from '../../../dist/cjs/src/script/UnlockingScript'
+
+import spendValid from './spend.valid.vectors'
+
+describe('Spend', () => {
+  it('Successfully validates a P2PKH spend', async () => {
+    const privateKey = new PrivateKey(1)
+    const publicKey = privateKey.toPublicKey()
+    const hash = publicKey.toHash()
+    const p2pkh = new P2PKH()
+    const lockingScript = p2pkh.lock(hash)
+    const satoshis = new BigNumber(1)
+    const unlockingTemplate = p2pkh.unlock(privateKey)
+    const sourceTx = new Transaction(1, [], [{
+      lockingScript,
+      satoshis
+    }], 0)
+    const spendTx = new Transaction(1, [{
+      sourceTransaction: sourceTx,
+      sourceOutputIndex: 0,
+      sequence: 0xffffffff
+    }], [], 0)
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+    const valid = spend.validate()
+    expect(valid).toBe(true)
+  })
+  it('Fails to verify a P2PKH spend with the wrong key', async () => {
+    const privateKey = new PrivateKey(1)
+    const publicKey = privateKey.toPublicKey()
+    const wrongPrivateKey = new PrivateKey(2)
+    const hash = publicKey.toHash()
+    const p2pkh = new P2PKH()
+    const lockingScript = p2pkh.lock(hash)
+    const satoshis = new BigNumber(1)
+    const unlockingTemplate = p2pkh.unlock(wrongPrivateKey)
+    const sourceTx = new Transaction(1, [], [{
+      lockingScript,
+      satoshis
+    }], 0)
+    const spendTx = new Transaction(1, [{
+      sourceTransaction: sourceTx,
+      sourceOutputIndex: 0,
+      sequence: 0xffffffff
+    }], [], 0)
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+    expect(() => spend.validate()).toThrow()
+  })
+  it('Successfully validates an R-puzzle spend', async () => {
+    const k = new PrivateKey(2)
+    const c = new Curve()
+    let r = c.g.mul(k).x.umod(c.n).toArray()
+    r = r[0] > 127 ? [0, ...r] : r
+    const puz = new RPuzzle()
+    const lockingScript = puz.lock(r)
+    const satoshis = new BigNumber(1)
+    const unlockingTemplate = puz.unlock(k)
+    const sourceTx = new Transaction(1, [], [{
+      lockingScript,
+      satoshis
+    }], 0)
+    const spendTx = new Transaction(1, [{
+      sourceTransaction: sourceTx,
+      sourceOutputIndex: 0,
+      sequence: 0xffffffff
+    }], [], 0)
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+    const valid = spend.validate()
+    expect(valid).toBe(true)
+  })
+  it('Successfully validates an R-puzzle spend (HASH256)', async () => {
+    const k = new PrivateKey(2)
+    const c = new Curve()
+    let r = c.g.mul(k).x.umod(c.n).toArray()
+    r = r[0] > 127 ? [0, ...r] : r
+    r = hash256(r)
+    const puz = new RPuzzle('HASH256')
+    const lockingScript = puz.lock(r)
+    const satoshis = new BigNumber(1)
+    const unlockingTemplate = puz.unlock(k)
+    const sourceTx = new Transaction(1, [], [{
+      lockingScript,
+      satoshis
+    }], 0)
+    const spendTx = new Transaction(1, [{
+      sourceTransaction: sourceTx,
+      sourceOutputIndex: 0,
+      sequence: 0xffffffff
+    }], [], 0)
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+    const valid = spend.validate()
+    expect(valid).toBe(true)
+  })
+  it('Fails to validate an R-puzzle spend with the wrong K value', async () => {
+    const k = new PrivateKey(2)
+    const wrongK = new PrivateKey(5)
+    const c = new Curve()
+    let r = c.g.mul(k).x.umod(c.n).toArray()
+    r = r[0] > 127 ? [0, ...r] : r
+    r = hash256(r)
+    const puz = new RPuzzle('HASH256')
+    const lockingScript = puz.lock(r)
+    const satoshis = new BigNumber(1)
+    const unlockingTemplate = puz.unlock(wrongK)
+    const sourceTx = new Transaction(1, [], [{
+      lockingScript,
+      satoshis
+    }], 0)
+    const spendTx = new Transaction(1, [{
+      sourceTransaction: sourceTx,
+      sourceOutputIndex: 0,
+      sequence: 0xffffffff
+    }], [], 0)
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+    expect(() => spend.validate()).toThrow()
+  })
+  it('Fails to validate an R-puzzle spend with the wrong hash', async () => {
+    const k = new PrivateKey(2)
+    const c = new Curve()
+    let r = c.g.mul(k).x.umod(c.n).toArray()
+    r = r[0] > 127 ? [0, ...r] : r
+    r = hash160(r)
+    const puz = new RPuzzle('HASH256')
+    const lockingScript = puz.lock(r)
+    const satoshis = new BigNumber(1)
+    const unlockingTemplate = puz.unlock(k)
+    const sourceTx = new Transaction(1, [], [{
+      lockingScript,
+      satoshis
+    }], 0)
+    const spendTx = new Transaction(1, [{
+      sourceTransaction: sourceTx,
+      sourceOutputIndex: 0,
+      sequence: 0xffffffff
+    }], [], 0)
+    const unlockingScript = await unlockingTemplate.sign(spendTx, 0)
+    const spend = new Spend({
+      sourceTXID: sourceTx.id('hex'),
+      sourceOutputIndex: 0,
+      sourceSatoshis: satoshis,
+      lockingScript,
+      transactionVersion: 1,
+      otherInputs: [],
+      inputIndex: 0,
+      unlockingScript,
+      outputs: [],
+      inputSequence: 0xffffffff,
+      lockTime: 0
+    })
+    expect(() => spend.validate()).toThrow()
+  })
+  for (let i = 0; i < spendValid.length; i++) {
+    const a = spendValid[i]
+    if (a.length === 1) {
+      continue
+    }
+    it(a[2], () => {
+      const spend = new Spend({
+        sourceTXID: '0000000000000000000000000000000000000000000000000000000000000000',
+        sourceOutputIndex: 0,
+        sourceSatoshis: new BigNumber(1),
+        lockingScript: new LockingScript(scriptFromVector(a[1]).chunks),
+        transactionVersion: 1,
+        otherInputs: [],
+        outputs: [],
+        inputIndex: 0,
+        unlockingScript: new UnlockingScript(scriptFromVector(a[0]).chunks),
+        inputSequence: 0xffffffff,
+        lockTime: 0
+      })
+      expect(spend.validate()).toBe(true)
+    })
+  }
+})