@bsv/sdk 2.0.9 → 2.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "2.0.9",
+  "version": "2.0.11",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/auth/certificates/Certificate.ts

@@ -113,7 +113,7 @@ export default class Certificate {
 
     // Write fields
     // Sort field names lexicographically
-    const fieldNames = Object.keys(this.fields).sort()
+    const fieldNames = Object.keys(this.fields).sort((a, b) => a.localeCompare(b))
     writer.writeVarIntNum(fieldNames.length)
     for (const fieldName of fieldNames) {
       const fieldValue = this.fields[fieldName]

package/src/primitives/BigNumber.ts

@@ -664,9 +664,8 @@ export default class BigNumber {
   neg (): BigNumber { return this.clone().ineg() }
   ineg (): this { if (this._magnitude !== 0n) this._sign = this._sign === 1 ? 0 : 1; return this }
 
-  private _iuop (num: BigNumber, op: (a: bigint, b: bigint) => bigint): this {
+  private _iuop (num: BigNumber, op: (a: bigint, b: bigint) => bigint, isXor: boolean = false): this {
     const newMag = op(this._magnitude, num._magnitude)
-    const isXor = op === ((a: bigint, b: bigint) => a ^ b)
     let targetNominalLength = this._nominalWordLength
     if (isXor) targetNominalLength = Math.max(this.length, num.length)
 
@@ -678,11 +677,11 @@ export default class BigNumber {
 
   iuor (num: BigNumber): this { return this._iuop(num, (a, b) => a | b) }
   iuand (num: BigNumber): this { return this._iuop(num, (a, b) => a & b) }
-  iuxor (num: BigNumber): this { return this._iuop(num, (a, b) => a ^ b) }
-  private _iop (num: BigNumber, op: (a: bigint, b: bigint) => bigint): this { this.assert(this._sign === 0 && num._sign === 0); return this._iuop(num, op) }
+  iuxor (num: BigNumber): this { return this._iuop(num, (a, b) => a ^ b, true) }
+  private _iop (num: BigNumber, op: (a: bigint, b: bigint) => bigint, isXor: boolean = false): this { this.assert(this._sign === 0 && num._sign === 0); return this._iuop(num, op, isXor) }
   ior (num: BigNumber): this { return this._iop(num, (a, b) => a | b) }
   iand (num: BigNumber): this { return this._iop(num, (a, b) => a & b) }
-  ixor (num: BigNumber): this { return this._iop(num, (a, b) => a ^ b) }
+  ixor (num: BigNumber): this { return this._iop(num, (a, b) => a ^ b, true) }
   private _uop_new (num: BigNumber, opName: 'iuor' | 'iuand' | 'iuxor'): BigNumber { if (this.length >= num.length) return this.clone()[opName](num); return num.clone()[opName](this) }
   or (num: BigNumber): BigNumber { this.assert(this._sign === 0 && num._sign === 0); return this._uop_new(num, 'iuor') }
   uor (num: BigNumber): BigNumber { return this._uop_new(num, 'iuor') }

package/src/primitives/__tests/BigNumber.constructor.test.ts

@@ -117,11 +117,11 @@ describe('BN.js/Constructor', () => {
 
     it('should not accept decimal', () => {
       expect(() => {
-        new BigNumber('10.00', 10) // eslint-disable-line no-new
+        return new BigNumber('10.00', 10)
       }).toThrow(new Error('Invalid character'))
 
       expect(() => {
-        new BigNumber('16.00', 16) // eslint-disable-line no-new
+        return new BigNumber('16.00', 16)
       }).toThrow(/* new Error('Invalid character') */)
     })
 
@@ -137,7 +137,7 @@ describe('BN.js/Constructor', () => {
         'hexadecimal'
       ].forEach(function (str) {
         expect(() => {
-          new BigNumber(str, 16) // eslint-disable-line no-new
+          return new BigNumber(str, 16)
         }).toThrow(/* Invalid character in */)
       })
     })

package/src/script/OP.ts

@@ -3,15 +3,15 @@
  */
 const OP = {
   // push value
+  OP_0: 0x00, // when two op codes have the same value, the top one will be used in standard ASM output
   OP_FALSE: 0x00,
-  OP_0: 0x00,
   OP_PUSHDATA1: 0x4c,
   OP_PUSHDATA2: 0x4d,
   OP_PUSHDATA4: 0x4e,
   OP_1NEGATE: 0x4f,
   OP_RESERVED: 0x50,
-  OP_TRUE: 0x51,
   OP_1: 0x51,
+  OP_TRUE: 0x51,
   OP_2: 0x52,
   OP_3: 0x53,
   OP_4: 0x54,
@@ -124,20 +124,24 @@ const OP = {
 
   // expansion
   OP_NOP1: 0xb0,
-  OP_NOP2: 0xb1, // Used on BTC for OP_CHECKLOCKTIMEVERIFY
-  OP_NOP3: 0xb2, // Used on BTC for OP_CHECKSEQUENCEVERIFY
-  OP_NOP4: 0xb3, // OP_NOP4 allocated to restore OP_SUBSTR in 2026 CHRONICLE upgrade
-  OP_SUBSTR: 0xb3, // OP_NOP4 allocated to restore OP_SUBSTR in 2026 CHRONICLE upgrade
-  OP_NOP5: 0xb4, // OP_NOP5 allocated to restore OP_LEFT in 2026 CHRONICLE upgrade
-  OP_LEFT: 0xb4, // OP_NOP5 allocated to restore OP_LEFT in 2026 CHRONICLE upgrade
-  OP_NOP6: 0xb5, // OP_NOP6 allocated to restore OP_RIGHT in 2026 CHRONICLE upgrade
-  OP_RIGHT: 0xb5, // OP_NOP6 allocated to restore OP_RIGHT in 2026 CHRONICLE upgrade
-  OP_NOP7: 0xb6, // OP_NOP7 allocated to restore OP_LSHIFTNUM in 2026 CHRONICLE upgrade
-  OP_LSHIFTNUM: 0xb6, // OP_NOP7 allocated to restore OP_LSHIFTNUM in 2026 CHRONICLE upgrade
-  OP_NOP8: 0xb7, // OP_NOP7 allocated to restore OP_RSHIFTNUM in 2026 CHRONICLE upgrade
-  OP_RSHIFTNUM: 0xb7, // OP_NOP7 allocated to restore OP_RSHIFTNUM in 2026 CHRONICLE upgrade
+  OP_CHECKLOCKTIMEVERIFY: 0xb1, // BIP65 - on BSV post-genesis acts as NOP
+  OP_NOP2: 0xb1, // alias for OP_CHECKLOCKTIMEVERIFY
+  OP_CHECKSEQUENCEVERIFY: 0xb2, // BIP112 - on BSV post-genesis acts as NOP
+  OP_NOP3: 0xb2, // alias for OP_CHECKSEQUENCEVERIFY
+  OP_SUBSTR: 0xb3, // restored in 2026 CHRONICLE upgrade (was OP_NOP4)
+  OP_NOP4: 0xb3, // alias for OP_SUBSTR
+  OP_LEFT: 0xb4, // restored in 2026 CHRONICLE upgrade (was OP_NOP5)
+  OP_NOP5: 0xb4, // alias for OP_LEFT
+  OP_RIGHT: 0xb5, // restored in 2026 CHRONICLE upgrade (was OP_NOP6)
+  OP_NOP6: 0xb5, // alias for OP_RIGHT
+  OP_LSHIFTNUM: 0xb6, // restored in 2026 CHRONICLE upgrade (was OP_NOP7)
+  OP_NOP7: 0xb6, // alias for OP_LSHIFTNUM
+  OP_RSHIFTNUM: 0xb7, // restored in 2026 CHRONICLE upgrade (was OP_NOP8)
+  OP_NOP8: 0xb7, // alias for OP_RSHIFTNUM
   OP_NOP9: 0xb8,
   OP_NOP10: 0xb9,
+  // 0xba–0xf9 are FIRST_UNDEFINED_OP_VALUE in node v1.2.0 and return SCRIPT_ERR_BAD_OPCODE
+  // when executed. The names below are retained for ASM parsing/serialisation only.
   OP_NOP11: 0xba,
   OP_NOP12: 0xbb,
   OP_NOP13: 0xbc,
@@ -203,7 +207,8 @@ const OP = {
   OP_NOP73: 0xf8,
   OP_NOP77: 0xfc,
 
-  // template matching params
+  // template matching params (not executable opcodes; 0xf9 was removed from node v1.2.0 opcodes.h
+  // but retained here for ASM round-trip compatibility)
   OP_SMALLDATA: 0xf9,
   OP_SMALLINTEGER: 0xfa,
   OP_PUBKEYS: 0xfb,
@@ -214,7 +219,7 @@ const OP = {
 }
 
 for (const name in OP) {
-  OP[OP[name]] = name
+  if (OP[OP[name]] === undefined) OP[OP[name]] = name
 }
 
 export default OP

package/src/script/Spend.ts

@@ -419,9 +419,12 @@ 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())
+        case OP.OP_VER: {
+          // Node v1.2.0: pushes tx_version as a 4-byte little-endian integer (to_le encoding)
+          const ver = this.transactionVersion
+          this.pushStack([ver & 0xff, (ver >>> 8) & 0xff, (ver >>> 16) & 0xff, (ver >>> 24) & 0xff])
           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()
@@ -459,7 +462,7 @@ export default class Spend {
             this.scriptEvaluationError(`OP_RIGHT length (${len}) must be in range [0, ${size}]`)
           }
 
-          this.pushStack(buf.slice(size - len, len))
+          this.pushStack(buf.slice(size - len))
           break
         }
         case OP.OP_LSHIFTNUM: {
@@ -501,32 +504,18 @@ export default class Spend {
           break
 
         case OP.OP_NOP:
+        // OP_NOP1 (0xb0), OP_NOP9 (0xb8), OP_NOP10 (0xb9) are the only defined upgrade-NOP slots
+        // in node v1.2.0. All other values above 0xb9 are FIRST_UNDEFINED_OP_VALUE and invalid.
+        // falls through
         case OP.OP_NOP1:
-        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:
+        // OP_NOP2 (0xb1) = OP_CHECKLOCKTIMEVERIFY: on BSV post-genesis treated as NOP
+        // falls through
+        case OP.OP_CHECKLOCKTIMEVERIFY:
+        // OP_NOP3 (0xb2) = OP_CHECKSEQUENCEVERIFY: on BSV post-genesis treated as NOP
+        // falls through
+        case OP.OP_CHECKSEQUENCEVERIFY:
         case OP.OP_NOP9:
         case OP.OP_NOP10:
-        // 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:
-        case OP.OP_NOP21: case OP.OP_NOP22: case OP.OP_NOP23: case OP.OP_NOP24: case OP.OP_NOP25:
-        case OP.OP_NOP26: case OP.OP_NOP27: case OP.OP_NOP28: case OP.OP_NOP29: case OP.OP_NOP30:
-        case OP.OP_NOP31: case OP.OP_NOP32: case OP.OP_NOP33: case OP.OP_NOP34: case OP.OP_NOP35:
-        case OP.OP_NOP36: case OP.OP_NOP37: case OP.OP_NOP38: case OP.OP_NOP39: case OP.OP_NOP40:
-        case OP.OP_NOP41: case OP.OP_NOP42: case OP.OP_NOP43: case OP.OP_NOP44: case OP.OP_NOP45:
-        case OP.OP_NOP46: case OP.OP_NOP47: case OP.OP_NOP48: case OP.OP_NOP49: case OP.OP_NOP50:
-        case OP.OP_NOP51: case OP.OP_NOP52: case OP.OP_NOP53: case OP.OP_NOP54: case OP.OP_NOP55:
-        case OP.OP_NOP56: case OP.OP_NOP57: case OP.OP_NOP58: case OP.OP_NOP59: case OP.OP_NOP60:
-        case OP.OP_NOP61: case OP.OP_NOP62: case OP.OP_NOP63: case OP.OP_NOP64: case OP.OP_NOP65:
-        case OP.OP_NOP66: case OP.OP_NOP67: case OP.OP_NOP68: case OP.OP_NOP69: case OP.OP_NOP70:
-        case OP.OP_NOP71: case OP.OP_NOP72: case OP.OP_NOP73:
-        case OP.OP_NOP77:
           break
 
         case OP.OP_VERIF:
@@ -534,9 +523,13 @@ export default class Spend {
           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)
+            // Node v1.2.0: compares against 4-byte little-endian tx_version (only matches when item is exactly 4 bytes)
+            if (buf1.length === 4) {
+              const ver = this.transactionVersion
+              buf2 = [ver & 0xff, (ver >>> 8) & 0xff, (ver >>> 16) & 0xff, (ver >>> 24) & 0xff]
+              fValue = compareNumberArrays(buf1, buf2)
+            }
             if (currentOpcode === OP.OP_VERNOTIF) fValue = !fValue
           }
           this.ifStack.push(fValue)

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

@@ -37,120 +37,56 @@ describe('Chronicle Tests', () => {
   })
 
   /**
-   * 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.
+   * At present only the first test vector 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`
-      }
-    }
+    const log = computeSighashLog(sighashTestDataWip)
     console.log(log)
     expect(log).toBe('')
   })
 })
 
+function computeSighashLog (
+  data: typeof sighashTestData,
+  filterByUnlockingChunks: boolean = false
+): string {
+  let log = ''
+  let i = -1
+  for (const t of data) {
+    i++
+    const tx = Transaction.fromHex(t.rawTxHex)
+    const input = tx.inputs[t.inputIndex]
+    if (filterByUnlockingChunks && 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,
+      lockTime: tx.lockTime,
+      scope: t.hashType,
+    }
+    const reg = Utils.toHex(Hash.hash256(TransactionSignature.format(params)).reverse())
+    if (reg !== t.sighashReg)
+      log += `${i+1} Reg false ${reg}\n`
+    const otda = Utils.toHex(Hash.hash256(TransactionSignature.formatOTDA(params)).reverse())
+    if (otda !== t.sighashOTDA)
+      log += `${i+1} OTDA false ${otda}\n`
+  }
+  return log
+}
+
 function verifyTruthy<T> (v: T | undefined): T {
   if (v == null) throw new Error('must have value')
   return v