@bsv/sdk 1.10.4 → 2.0.0

package/src/script/Script.ts

@@ -356,11 +356,13 @@ export default class Script {
   findAndDelete (script: Script): Script {
     this.invalidateSerializationCaches()
     const buf = script.toHex()
-    for (let i = 0; i < this.chunks.length; i++) {
+    for (let i = 0; i < this.chunks.length;) {
       const script2 = new Script([this.chunks[i]])
       const buf2 = script2.toHex()
       if (buf === buf2) {
         this.chunks.splice(i, 1)
+      } else {
+        i++
       }
     }
     return this

package/src/script/Spend.ts

@@ -17,10 +17,6 @@ import TransactionOutput from '../transaction/TransactionOutput.js'
 const maxScriptElementSize = 1024 * 1024 * 1024
 const maxMultisigKeyCount = Math.pow(2, 31) - 1
 const maxMultisigKeyCountBigInt = BigInt(maxMultisigKeyCount)
-const requireMinimalPush = true
-const requirePushOnlyUnlockingScripts = true
-const requireLowSSignatures = true
-const requireCleanStack = true
 
 // --- Optimization: Pre-computed script numbers ---
 const SCRIPTNUM_NEG_1 = Object.freeze(new BigNumber(-1).toScriptNum())
@@ -89,16 +85,6 @@ function isChecksigFormatHelper (buf: Readonly<number[]>): boolean {
   return true
 }
 
-function isOpcodeDisabledHelper (op: number): boolean {
-  return (
-    op === OP.OP_2MUL ||
-    op === OP.OP_2DIV ||
-    op === OP.OP_VERIF ||
-    op === OP.OP_VERNOTIF ||
-    op === OP.OP_VER
-  )
-}
-
 function isChunkMinimalPushHelper (chunk: ScriptChunk): boolean {
   const data = chunk.data
   const op = chunk.op
@@ -130,6 +116,8 @@ function isChunkMinimalPushHelper (chunk: ScriptChunk): boolean {
  * @property {UnlockingScript} unlockingScript - The unlocking script that unlocks the UTXO for spending.
  * @property {number} inputSequence - The sequence number of this input.
  * @property {number} lockTime - The lock time of the transaction.
+ * @property {number} memoryLimit - Control over script interpreter memory usage.
+ * @property {boolean} isRelaxed - Optional. If true, disables all the unlocking script maleability restrictions consitent with Chronicle release. Maleability restrictions are neve appliced to locking scripts.
  */
 export default class Spend {
   sourceTXID: string
@@ -153,6 +141,8 @@ export default class Spend {
   memoryLimit: number
   stackMem: number
   altStackMem: number
+  isRelaxedOverride: boolean
+
   private sigHashCache: SignatureHashCache
 
   /**
@@ -171,6 +161,8 @@ export default class Spend {
    * @param {UnlockingScript} params.unlockingScript - The unlocking script for this spend.
    * @param {number} params.inputSequence - The sequence number of this input.
    * @param {number} params.lockTime - The lock time of the transaction.
+   * @param {number} params.memoryLimit - Optional control over script interpreter memory usage.
+   * @param {boolean} params.isRelaxed - Optional. If true, disables all the unlocking script maleability restrictions consitent with Chronicle release. Maleability restrictions are neve appliced to locking scripts.
    *
    * @example
    * const spend = new Spend({
@@ -200,6 +192,7 @@ export default class Spend {
     inputIndex: number
     lockTime: number
     memoryLimit?: number
+    isRelaxed?: boolean
   }) {
     this.sourceTXID = params.sourceTXID
     this.sourceOutputIndex = params.sourceOutputIndex
@@ -213,6 +206,7 @@ export default class Spend {
     this.inputSequence = params.inputSequence
     this.lockTime = params.lockTime
     this.memoryLimit = params.memoryLimit ?? 32000000
+    this.isRelaxedOverride = params.isRelaxed === true
     this.stack = []
     this.altStack = []
     this.ifStack = []
@@ -222,6 +216,11 @@ export default class Spend {
     this.reset()
   }
 
+  private isRelaxed (): boolean {
+    return this.isRelaxedOverride ||
+      (this.transactionVersion > 1)
+  }
+
   reset (): void {
     this.context = 'UnlockingScript'
     this.programCounter = 0
@@ -305,14 +304,10 @@ export default class Spend {
     }
     try {
       const sig = TransactionSignature.fromChecksigFormat(buf as number[]) // This can throw for stricter DER rules
-      if (requireLowSSignatures && !sig.hasLowS()) {
+      if (!this.isRelaxed() && !sig.hasLowS()) {
         this.scriptEvaluationError('The signature must have a low S value.')
         return false
       }
-      if ((sig.scope & TransactionSignature.SIGHASH_FORKID) === 0) {
-        this.scriptEvaluationError('The signature must use SIGHASH_FORKID.')
-        return false
-      }
     } catch (e) {
       this.scriptEvaluationError('The signature format is invalid.')
       return false
@@ -409,12 +404,8 @@ export default class Spend {
 
     const isScriptExecuting = !this.ifStack.includes(false)
 
-    if (isScriptExecuting && isOpcodeDisabledHelper(currentOpcode)) {
-      this.scriptEvaluationError(`This opcode is currently disabled. (Opcode: ${OP[currentOpcode] as string}, PC: ${this.programCounter})`) // Error thrown
-    }
-
     if (isScriptExecuting && currentOpcode >= 0 && currentOpcode <= OP.OP_PUSHDATA4) {
-      if (requireMinimalPush && !isChunkMinimalPushHelper(operation)) {
+      if (!this.isRelaxed() && !isChunkMinimalPushHelper(operation)) {
         this.scriptEvaluationError(`This data is not minimally-encoded. (PC: ${this.programCounter})`) // Error thrown
       }
       this.pushStack(Array.isArray(operation.data) ? operation.data : [])
@@ -428,6 +419,77 @@ export default class Spend {
       let i: number, ikey: number, isig: number, nKeysCount: number, nSigsCount: number, fOk: boolean
 
       switch (currentOpcode) {
+        case OP.OP_VER:
+          this.pushStackCopy(new BigNumber(this.transactionVersion).toScriptNum())
+          break
+        case OP.OP_SUBSTR: {
+          if (this.stack.length < 3) this.scriptEvaluationError('OP_SUBSTR requires at least three items to be on the stack.')
+          const len = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()).toNumber()
+          const offset = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()).toNumber()
+          buf = this.popStack()
+          const size = buf.length
+
+          if (offset < 0 || offset >= size || len < 0 || len > size - offset) {
+            this.scriptEvaluationError(`OP_SUBSTR offset (${offset}) must be in range [0, ${size}) and length (${len}) must be in range [0, ${size - offset}]`)
+          }
+
+          this.pushStack(buf.slice(offset, offset + len))
+          break
+        }
+        case OP.OP_LEFT: {
+          if (this.stack.length < 2) this.scriptEvaluationError('OP_LEFT requires at least two items to be on the stack.')
+          const len = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()).toNumber()
+          buf = this.popStack()
+          const size = buf.length
+
+          if (len < 0 || len > size) {
+            this.scriptEvaluationError(`OP_LEFT length (${len}) must be in range [0, ${size}]`)
+          }
+
+          this.pushStack(buf.slice(0, len))
+          break
+        }
+        case OP.OP_RIGHT: {
+          if (this.stack.length < 2) this.scriptEvaluationError('OP_RIGHT requires at least two items to be on the stack.')
+          const len = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()).toNumber()
+          buf = this.popStack()
+          const size = buf.length
+
+          if (len < 0 || len > size) {
+            this.scriptEvaluationError(`OP_RIGHT length (${len}) must be in range [0, ${size}]`)
+          }
+
+          this.pushStack(buf.slice(size - len, len))
+          break
+        }
+        case OP.OP_LSHIFTNUM: {
+          if (this.stack.length < 2) this.scriptEvaluationError('OP_LSHIFTNUM requires at least two items to be on the stack.')
+          const bits = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()).toBigInt()
+          if (bits < 0) {
+            this.scriptEvaluationError('OP_LSHIFTNUM bits to shift must not be negative.')
+          }
+          const value = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()).toBigInt()
+          const resultBn = new BigNumber(value << bits)
+          this.pushStack(resultBn.toScriptNum())
+          break
+        }
+        case OP.OP_RSHIFTNUM: {
+          if (this.stack.length < 2) this.scriptEvaluationError('OP_RSHIFTNUM requires at least two items to be on the stack.')
+          const bits = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()).toBigInt()
+          if (bits < 0) {
+            this.scriptEvaluationError('OP_RSHIFTNUM bits to shift must not be negative.')
+          }
+          const value = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()).toBigInt()
+          let resultBn: BigNumber
+          if (value < 0) {
+            resultBn = new BigNumber(-(-value >> bits))
+          } else {
+            resultBn = new BigNumber(value >> bits)
+          }
+          this.pushStack(resultBn.toScriptNum())
+          break
+        }
+
         case OP.OP_1NEGATE: this.pushStackCopy(SCRIPTNUM_NEG_1); break
         case OP.OP_0: this.pushStackCopy(SCRIPTNUMS_0_TO_16[0]); break
         case OP.OP_1: case OP.OP_2: case OP.OP_3: case OP.OP_4:
@@ -439,18 +501,17 @@ export default class Spend {
           break
 
         case OP.OP_NOP:
-        case OP.OP_NOP2: // Formerly CHECKLOCKTIMEVERIFY
-        case OP.OP_NOP3: // Formerly CHECKSEQUENCEVERIFY
         case OP.OP_NOP1:
-        case OP.OP_NOP4:
-        case OP.OP_NOP5:
-        case OP.OP_NOP6:
+        case OP.OP_NOP2:
+        case OP.OP_NOP3:
+        // case OP.OP_NOP4: // Allocated to OP_SUBSTR
+        // case OP.OP_NOP5: // Allocated to OP_LEFT
+        // case OP.OP_NOP6: // Allocated to OP_RIGHT
+        // eslint-disable-next-line no-fallthrough
         case OP.OP_NOP7:
         case OP.OP_NOP8:
         case OP.OP_NOP9:
         case OP.OP_NOP10:
-          /* falls through */
-          // eslint-disable-next-line no-fallthrough
         // eslint-disable-next-line no-fallthrough
         case OP.OP_NOP11: case OP.OP_NOP12: case OP.OP_NOP13: case OP.OP_NOP14: case OP.OP_NOP15:
         case OP.OP_NOP16: case OP.OP_NOP17: case OP.OP_NOP18: case OP.OP_NOP19: case OP.OP_NOP20:
@@ -468,6 +529,18 @@ export default class Spend {
         case OP.OP_NOP77:
           break
 
+        case OP.OP_VERIF:
+        case OP.OP_VERNOTIF:
+          fValue = false
+          if (isScriptExecuting) {
+            if (this.stack.length < 1) this.scriptEvaluationError('OP_VERIF and OP_VERNOTIF require at least one item on the stack when they are used!')
+            buf2 = new BigNumber(this.transactionVersion).toScriptNum()
+            buf1 = this.popStack()
+            fValue = compareNumberArrays(buf1, buf2)
+            if (currentOpcode === OP.OP_VERNOTIF) fValue = !fValue
+          }
+          this.ifStack.push(fValue)
+          break
         case OP.OP_IF:
         case OP.OP_NOTIF:
           fValue = false
@@ -581,7 +654,7 @@ export default class Spend {
         case OP.OP_PICK:
         case OP.OP_ROLL: {
           if (this.stack.length < 2) this.scriptEvaluationError(`${OP[currentOpcode] as string} requires at least two items to be on the stack.`)
-          bn = BigNumber.fromScriptNum(this.popStack(), requireMinimalPush)
+          bn = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed())
           const nBigInt = bn.toBigInt()
           if (nBigInt < 0n || nBigInt >= BigInt(this.stack.length)) {
             this.scriptEvaluationError(`${OP[currentOpcode] as string} requires the top stack element to be 0 or a positive number less than the current size of the stack.`)
@@ -654,7 +727,7 @@ export default class Spend {
         case OP.OP_LSHIFT:
         case OP.OP_RSHIFT: {
           if (this.stack.length < 2) this.scriptEvaluationError(`${OP[currentOpcode] as string} requires at least two items to be on the stack.`)
-          bn2 = BigNumber.fromScriptNum(this.popStack(), requireMinimalPush) // n (shift amount)
+          bn2 = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()) // n (shift amount)
           buf1 = this.popStack() // value to shift
           const shiftBits = bn2.toBigInt()
           if (shiftBits < 0n) this.scriptEvaluationError(`${OP[currentOpcode] as string} requires the top item on the stack not to be negative.`)
@@ -684,14 +757,16 @@ export default class Spend {
           }
           break
 
-        case OP.OP_1ADD: case OP.OP_1SUB:
+        case OP.OP_1ADD: case OP.OP_1SUB: case OP.OP_2MUL: case OP.OP_2DIV:
         case OP.OP_NEGATE: case OP.OP_ABS:
         case OP.OP_NOT: case OP.OP_0NOTEQUAL:
           if (this.stack.length < 1) this.scriptEvaluationError(`${OP[currentOpcode] as string} requires at least one item to be on the stack.`)
-          bn = BigNumber.fromScriptNum(this.popStack(), requireMinimalPush)
+          bn = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed())
           switch (currentOpcode) {
             case OP.OP_1ADD: bn = bn.add(new BigNumber(1)); break
             case OP.OP_1SUB: bn = bn.sub(new BigNumber(1)); break
+            case OP.OP_2MUL: bn = bn.mul(new BigNumber(2)); break
+            case OP.OP_2DIV: bn = bn.div(new BigNumber(2)); break
             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
@@ -708,8 +783,8 @@ export default class Spend {
           if (this.stack.length < 2) this.scriptEvaluationError(`${OP[currentOpcode] as string} requires at least two items to be on the stack.`)
           buf2 = this.popStack()
           buf1 = this.popStack()
-          bn2 = BigNumber.fromScriptNum(buf2, requireMinimalPush)
-          bn1 = BigNumber.fromScriptNum(buf1, requireMinimalPush)
+          bn2 = BigNumber.fromScriptNum(buf2, !this.isRelaxed())
+          bn1 = BigNumber.fromScriptNum(buf1, !this.isRelaxed())
           let predictedLen = 0
           switch (currentOpcode) {
             case OP.OP_MUL:
@@ -755,9 +830,9 @@ export default class Spend {
         }
         case OP.OP_WITHIN:
           if (this.stack.length < 3) this.scriptEvaluationError('OP_WITHIN requires at least three items to be on the stack.')
-          bn3 = BigNumber.fromScriptNum(this.popStack(), requireMinimalPush) // max
-          bn2 = BigNumber.fromScriptNum(this.popStack(), requireMinimalPush) // min
-          bn1 = BigNumber.fromScriptNum(this.popStack(), requireMinimalPush) // x
+          bn3 = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()) // max
+          bn2 = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()) // min
+          bn1 = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()) // x
           fValue = bn1.cmp(bn2) >= 0 && bn1.cmp(bn3) < 0
           this.pushStack(fValue ? [1] : [])
           break
@@ -789,15 +864,16 @@ export default class Spend {
             this.scriptEvaluationError(`${OP[currentOpcode] as string} requires correct encoding for the public key and signature.`) // Fallback, should be unreachable
           }
 
-          const scriptForChecksig = this.context === 'UnlockingScript' ? this.unlockingScript : this.lockingScript
-          const scriptCodeChunks = scriptForChecksig.chunks.slice(this.lastCodeSeparator === null ? 0 : this.lastCodeSeparator + 1)
-          subscript = new Script(scriptCodeChunks)
-          subscript.findAndDelete(new Script().writeBin(bufSig))
-
           fSuccess = false
           if (bufSig.length > 0) {
             try {
               sig = TransactionSignature.fromChecksigFormat(bufSig)
+
+              const scriptForChecksig: Script = this.context === 'UnlockingScript' ? this.unlockingScript : this.lockingScript
+              const scriptCodeChunks = scriptForChecksig.chunks.slice(this.lastCodeSeparator === null ? 0 : this.lastCodeSeparator + 1)
+              subscript = new Script(scriptCodeChunks)
+              subscript.findAndDelete(new Script().writeBin(bufSig))
+
               pubkey = PublicKey.fromDER(bufPubkey)
               fSuccess = this.verifySignature(sig, pubkey, subscript)
             } catch (e) {
@@ -819,7 +895,7 @@ export default class Spend {
             this.scriptEvaluationError(`${OP[currentOpcode] as string} requires at least 1 item for nKeys.`)
           }
 
-          const nKeysCountBN = BigNumber.fromScriptNum(this.stackTop(-i), requireMinimalPush)
+          const nKeysCountBN = BigNumber.fromScriptNum(this.stackTop(-i), !this.isRelaxed())
           const nKeysCountBigInt = nKeysCountBN.toBigInt()
           if (nKeysCountBigInt < 0n || nKeysCountBigInt > maxMultisigKeyCountBigInt) {
             this.scriptEvaluationError(`${OP[currentOpcode] as string} requires a key count between 0 and ${maxMultisigKeyCount}.`)
@@ -833,7 +909,7 @@ export default class Spend {
             this.scriptEvaluationError(`${OP[currentOpcode] as string} stack too small for nKeys and keys. Need ${i}, have ${this.stack.length}.`)
           }
 
-          const nSigsCountBN = BigNumber.fromScriptNum(this.stackTop(-i), requireMinimalPush)
+          const nSigsCountBN = BigNumber.fromScriptNum(this.stackTop(-i), !this.isRelaxed())
           const nSigsCountBigInt = nSigsCountBN.toBigInt()
           if (nSigsCountBigInt < 0n || nSigsCountBigInt > BigInt(nKeysCount)) {
             this.scriptEvaluationError(`${OP[currentOpcode] as string} requires the number of signatures to be no greater than the number of keys.`)
@@ -907,7 +983,7 @@ export default class Spend {
             this.scriptEvaluationError(`${OP[currentOpcode] as string} requires an extra item (dummy) to be on the stack.`)
           }
           const dummyBuf = this.popStack()
-          if (dummyBuf.length > 0) { // SCRIPT_VERIFY_NULLDUMMY
+          if (!this.isRelaxed() && dummyBuf.length > 0) { // SCRIPT_VERIFY_NULLDUMMY
             this.scriptEvaluationError(`${OP[currentOpcode] as string} requires the extra stack item (dummy) to be empty.`)
           }
 
@@ -933,7 +1009,7 @@ export default class Spend {
           const posBuf = this.popStack()
           const dataToSplit = this.popStack()
 
-          const splitIndexBigInt = BigNumber.fromScriptNum(posBuf, requireMinimalPush).toBigInt()
+          const splitIndexBigInt = BigNumber.fromScriptNum(posBuf, !this.isRelaxed()).toBigInt()
           if (splitIndexBigInt < 0n || splitIndexBigInt > BigInt(dataToSplit.length)) {
             this.scriptEvaluationError('OP_SPLIT requires the first stack item to be a non-negative number less than or equal to the size of the second-from-top stack item.')
           }
@@ -946,7 +1022,7 @@ export default class Spend {
         case OP.OP_NUM2BIN: {
           if (this.stack.length < 2) this.scriptEvaluationError('OP_NUM2BIN requires at least two items to be on the stack.')
 
-          const sizeBigInt = BigNumber.fromScriptNum(this.popStack(), requireMinimalPush).toBigInt()
+          const sizeBigInt = BigNumber.fromScriptNum(this.popStack(), !this.isRelaxed()).toBigInt()
           if (sizeBigInt > BigInt(maxScriptElementSize) || sizeBigInt < 0n) { // size can be 0
             this.scriptEvaluationError(`It's not currently possible to push data larger than ${maxScriptElementSize} bytes or negative size.`)
           }
@@ -1016,7 +1092,7 @@ export default class Spend {
    * }
    */
   validate (): boolean {
-    if (requirePushOnlyUnlockingScripts && !this.unlockingScript.isPushOnly()) {
+    if (!this.isRelaxed() && !this.unlockingScript.isPushOnly()) {
       this.scriptEvaluationError(
         'Unlocking scripts can only contain push operations, and no other opcodes.'
       )
@@ -1037,7 +1113,7 @@ export default class Spend {
       )
     }
 
-    if (requireCleanStack) {
+    if (!this.isRelaxed()) {
       if (this.stack.length !== 1) {
         this.scriptEvaluationError(
           `The clean stack rule requires exactly one item to be on the stack after script execution, found ${this.stack.length}.`

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

@@ -0,0 +1,186 @@
+import TransactionSignature from '../../primitives/TransactionSignature.js'
+import { Hash, Utils } from '../../primitives/index.js'
+import Script from '../Script.js'
+import Spend from '../Spend.js'
+import Transaction from '../../transaction/Transaction.js'
+import { sighashTestData, sighashTestDataWip } from './sighashTestData.js'
+
+describe('Chronicle Tests', () => {
+
+  it('spend bip143 input', () => {
+    const rawTx =
+      '0100000001cc5988c346027ca1f6870422616d022caf216f537f3d4994f7a7d46a8bf0758a020000006b483045022100f1c0bfe5e7c9c5559ede2b1e2b98aeaac295218406df1d66af397f615350599202201ad5d39c6706e1cc5cdc297ee5cd5d5f79d237a1c4b16c5b4646c284f2eeeabe41210245c6e32afad67f6177b02cfc2878fce2a28e77ad9ecbc6356960c020c592d867ffffffff0302000000000000001976a914a4429da7462800dedc7b03a4fc77c363b8de40f588ac000000000000000020006a4c1c507573682d5468652d427574746f6e2e617070207c204c616d6264610a32f201000000001976a914296b03a4dd56b3b0fe5706c845f2edff22e84d7388ac00000000'
+    const lockingScript =
+      '76a914296b03a4dd56b3b0fe5706c845f2edff22e84d7388ac'
+    const ok = validateUnlockScript(rawTx, 0, lockingScript, 32649741)
+    expect(ok).toBe(true)
+    // preimage 182 byes
+    // "010000002987eea6ff44b0a0c38a4c81cc92c052f6bcb7e3cfa2f59e3af1f7a73433a6fc3bb13029ce7b1f559ef5e747fcac439f1455a2ec7c5f09b72290795e70665044cc5988c346027ca1f6870422616d022caf216f537f3d4994f7a7d46a8bf0758a020000001976a914296b03a4dd56b3b0fe5706c845f2edff22e84d7388ac0d32f20100000000ffffffffa4cd3e7fef24c9653d7a12c404e428b5bb9ac1c5d3a9ddc5a4b9331536df94d50000000041000000"
+    // sighash
+    // "f40a770ed6f1952973387579d7c7d14719d2bdce871fb449b6fa3d5cca35fbcf"
+  })
+
+  it('spend OTDA', () => {
+    const rawTx =
+      // block 300000, txid 7301b595279ece985f0c415e420e425451fcf7f684fcce087ba14d10ffec1121
+      '01000000014dff4050dcee16672e48d755c6dd25d324492b5ea306f85a3ab23b4df26e16e9000000008c493046022100cb6dc911ef0bae0ab0e6265a45f25e081fc7ea4975517c9f848f82bc2b80a909022100e30fb6bb4fb64f414c351ed3abaed7491b8f0b1b9bcd75286036df8bfabc3ea5014104b70574006425b61867d2cbb8de7c26095fbc00ba4041b061cf75b85699cb2b449c6758741f640adffa356406632610efb267cb1efa0442c207059dd7fd652eeaffffffff020049d971020000001976a91461cf5af7bb84348df3fd695672e53c7d5b3f3db988ac30601c0c060000001976a914fd4ed114ef85d350d6d40ed3f6dc23743f8f99c488ac00000000'
+    const lockingScript =
+      // input sourceTxid e9166ef24d3bb23a5af806a35e2b4924d325ddc655d7482e6716eedc5040ff4d vout 0
+      // 'OP_DUP OP_HASH160 5478d152bb557ac994c9793cece77d4295ed37e3 OP_EQUALVERIFY OP_CHECKSIG'
+      '76a9145478d152bb557ac994c9793cece77d4295ed37e388ac'
+    const ok = validateUnlockScript(rawTx, 0, lockingScript, 36473000000, true)
+    expect(ok).toBe(true)
+    // preimage 148 bytes
+    // "01000000014dff4050dcee16672e48d755c6dd25d324492b5ea306f85a3ab23b4df26e16e9000000001976a9145478d152bb557ac994c9793cece77d4295ed37e388acffffffff020049d971020000001976a91461cf5af7bb84348df3fd695672e53c7d5b3f3db988ac30601c0c060000001976a914fd4ed114ef85d350d6d40ed3f6dc23743f8f99c488ac0000000001000000"
+    // sighash
+		// "bdf9e0f5600d64bf3754919bd181f5e3848440ef7b351150abcb1ca3a54d3eb9",
+  })
+
+  /**
+   * At present only the first two test vectors added as real transaction (pre and post fork) compute a sighash known to match a valid signagure.
+   * The remaining test vectors come from bitcoin-sv-staging repo as of 2025-06-23, but appear to be at least somewhat randomly generated.
+   * The "scope" (SigHashType) values are all over the place.
+   * Working with Teranode team to determine correct preimage values...
+   */
+  it('sighashTestData', () => {
+    let log = ''
+    let i = -1
+    for (const t of sighashTestData) {
+      i++
+      const tx = Transaction.fromHex(t.rawTxHex)
+      const script = Script.fromHex(t.scriptHex)
+      const input = tx.inputs[t.inputIndex]
+      if (input.unlockingScript?.chunks.length != 2)
+        continue;
+      const otherInputs = [...tx.inputs]
+      otherInputs.splice(t.inputIndex, 1)
+      const params = {
+        sourceTXID: input.sourceTXID!,
+        sourceOutputIndex: input.sourceOutputIndex,
+        sourceSatoshis: t.satoshis,
+        transactionVersion: tx.version,
+        otherInputs,
+        outputs: tx.outputs,
+        inputIndex: t.inputIndex,
+        subscript: Script.fromHex(t.scriptHex),
+        inputSequence: input.sequence ?? 0xffffffff, // Default to max sequence number
+        lockTime: tx.lockTime,
+        scope: t.hashType,
+      }
+      let ok = false
+      let okReg = false
+      let okOTDA = false
+      {
+        const sighash = t.sighashReg
+        const buf = TransactionSignature.format(params)
+        const ret = Utils.toHex(Hash.hash256(buf).reverse())
+        if (ret === sighash) {
+          ok = true
+          okReg = true
+        }
+        if (!okReg)
+          log += `${i+1} Reg ${okReg} ${!okReg ? ret : ''}\n`
+      }
+      {
+        const sighash = t.sighashOTDA
+        const buf = TransactionSignature.formatOTDA(params)
+        const ret = Utils.toHex(Hash.hash256(buf).reverse())
+        if (ret === sighash) {
+          ok = true
+          okOTDA = true
+        }
+        if (!okOTDA)
+          log += `${i+1} OTDA ${okOTDA} ${!okOTDA ? ret : ''}\n`
+      }
+    }
+    //console.log(log)
+    //expect(log).toBe('')
+  })
+
+  it('wip sighashTestData', () => {
+    let log = ''
+    let i = -1
+    for (const t of sighashTestDataWip) {
+      i++
+      const tx = Transaction.fromHex(t.rawTxHex)
+      const script = Script.fromHex(t.scriptHex)
+      const input = tx.inputs[t.inputIndex]
+      const otherInputs = [...tx.inputs]
+      otherInputs.splice(t.inputIndex, 1)
+      const params = {
+        sourceTXID: input.sourceTXID!,
+        sourceOutputIndex: input.sourceOutputIndex,
+        sourceSatoshis: t.satoshis,
+        transactionVersion: tx.version,
+        otherInputs,
+        outputs: tx.outputs,
+        inputIndex: t.inputIndex,
+        subscript: Script.fromHex(t.scriptHex),
+        inputSequence: input.sequence ?? 0xffffffff, // Default to max sequence number
+        lockTime: tx.lockTime,
+        scope: t.hashType,
+      }
+      let ok = false
+      let okReg = false
+      let okOTDA = false
+      {
+        const sighash = t.sighashReg
+        const buf = TransactionSignature.format(params)
+        const ret = Utils.toHex(Hash.hash256(buf).reverse())
+        if (ret === sighash) {
+          ok = true
+          okReg = true
+        }
+        if (!okReg)
+          log += `${i+1} Reg ${okReg} ${!okReg ? ret : ''}\n`
+      }
+      {
+        const sighash = t.sighashOTDA
+        const buf = TransactionSignature.formatOTDA(params)
+        const ret = Utils.toHex(Hash.hash256(buf).reverse())
+        if (ret === sighash) {
+          ok = true
+          okOTDA = true
+        }
+        if (!okOTDA)
+          log += `${i+1} OTDA ${okOTDA} ${!okOTDA ? ret : ''}\n`
+      }
+    }
+    console.log(log)
+    expect(log).toBe('')
+  })
+})
+
+function verifyTruthy<T> (v: T | undefined): T {
+  if (v == null) throw new Error('must have value')
+  return v
+}
+
+function validateUnlockScript (
+  spendingRawTx: string,
+  vin: number,
+  lockingScript: string,
+  amount: number,
+  isRelaxed?: boolean
+): boolean {
+  const spendingTx = Transaction.fromHex(spendingRawTx)
+  const ls = Script.fromHex(lockingScript)
+
+  const spend = new Spend({
+    sourceTXID: verifyTruthy(spendingTx.inputs[vin].sourceTXID),
+    sourceOutputIndex: verifyTruthy(spendingTx.inputs[vin].sourceOutputIndex),
+    sourceSatoshis: amount,
+    lockingScript: ls,
+    transactionVersion: spendingTx.version,
+    otherInputs: spendingTx.inputs.filter((v, i) => i !== vin),
+    inputIndex: vin,
+    unlockingScript: verifyTruthy(spendingTx.inputs[vin].unlockingScript),
+    outputs: spendingTx.outputs,
+    inputSequence: verifyTruthy(spendingTx.inputs[vin].sequence),
+    lockTime: spendingTx.lockTime,
+    isRelaxed
+  })
+
+  const valid = spend.validate()
+  return valid
+}

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

@@ -9,7 +9,7 @@ import LockingScript from '../../script/LockingScript'
 import UnlockingScript from '../../script/UnlockingScript'
 import MerklePath from '../../transaction/MerklePath'
 import ChainTracker from '../../transaction/ChainTracker'
-import spendValid from './spend.valid.vectors'
+import { preChronicle as spendValid } from './spend.valid.vectors'
 import Script from '../../script/Script'
 import BigNumber from '../../primitives/BigNumber'
 import ScriptChunk from '../../script/ScriptChunk'

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

@@ -0,0 +1,63 @@
+import PrivateKey from '../../primitives/PrivateKey'
+import { hash160, hash256 } from '../../primitives/Hash'
+import Curve from '../../primitives/Curve'
+import Spend from '../Spend'
+import P2PKH from '../templates/P2PKH'
+import RPuzzle from '../templates/RPuzzle'
+import Transaction from '../../transaction/Transaction'
+import LockingScript from '../LockingScript'
+import UnlockingScript from '../UnlockingScript'
+
+import { preChronicle as spendValid1, chronicle as spendValid2 } from './spend.valid.vectors'
+
+describe('Spend Valid Vectors 1', () => {
+  for (let i = 0; i < spendValid1.length; i++) {
+    const a = spendValid1[i]
+    if (a.length === 1) {
+      continue
+    }
+    it(`${i} ${a[2]}`, () => {
+      const spend = new Spend({
+        sourceTXID:
+          '0000000000000000000000000000000000000000000000000000000000000000',
+        sourceOutputIndex: 0,
+        sourceSatoshis: 1,
+        lockingScript: LockingScript.fromHex(a[1]),
+        transactionVersion: 1,
+        otherInputs: [],
+        outputs: [],
+        inputIndex: 0,
+        unlockingScript: UnlockingScript.fromHex(a[0]),
+        inputSequence: 0xffffffff,
+        lockTime: 0
+      })
+      expect(spend.validate()).toBe(true)
+    })
+  }
+})
+
+describe('Spend Valid Vectors 2', () => {
+  for (let i = 0; i < spendValid2.length; i++) {
+    const a = spendValid2[i]
+    if (a.length === 1) {
+      continue
+    }
+    it(`${i} ${a[2]}`, () => {
+      const spend = new Spend({
+        sourceTXID:
+          '0000000000000000000000000000000000000000000000000000000000000000',
+        sourceOutputIndex: 0,
+        sourceSatoshis: 1,
+        lockingScript: LockingScript.fromHex(a[1]),
+        transactionVersion: 1,
+        otherInputs: [],
+        outputs: [],
+        inputIndex: 0,
+        unlockingScript: UnlockingScript.fromHex(a[0]),
+        inputSequence: 0xffffffff,
+        lockTime: 0
+      })
+      expect(spend.validate()).toBe(true)
+    })
+  }
+})