@smartledger/bsv 4.4.0 → 4.6.0

package/lib/smart_contract/covenant_helpers.js

@@ -17,15 +17,18 @@ var Signature = require('../crypto/signature')
 // SIGHASH_ALL | SIGHASH_FORKID — the BSV default these covenants are built for.
 var SIGHASH = Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID // 0x41
 
-// Post-Genesis consensus flags (big numbers, OP_CAT/OP_SPLIT/OP_MUL, FORKID,
-// CLTV/CSV). LOW_S is enforced: the OP_PUSH_TX grind produces a canonical
-// (low-S) in-script signature, so these covenants meet mainnet standardness.
+// Post-Genesis consensus + STANDARD RELAY flags — what mainnet miners actually
+// enforce. Includes SCRIPT_VERIFY_MINIMALDATA (every push must be minimal) and
+// SCRIPT_VERIFY_LOW_S (canonical signatures). Verifying with these locally
+// catches non-relayable covenants BEFORE broadcast — covenants verified here
+// have been deployed and spent on BSV mainnet.
 function flags () {
   var I = bsv.Script.Interpreter
   return I.SCRIPT_VERIFY_P2SH |
     I.SCRIPT_VERIFY_STRICTENC |
     I.SCRIPT_VERIFY_DERSIG |
     I.SCRIPT_VERIFY_LOW_S |
+    I.SCRIPT_VERIFY_MINIMALDATA |
     I.SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY |
     I.SCRIPT_VERIFY_CHECKSEQUENCEVERIFY |
     I.SCRIPT_ENABLE_SIGHASH_FORKID |
@@ -102,6 +105,13 @@ function p2pkhOutput (addressOrPubKey, satoshis) {
 
 /** Minimal little-endian script-number Buffer (push as data to put a number on-stack). */
 function scriptNum (n) {
+  // Minimal on-stack number: 0..16 and -1 use the dedicated opcodes (OP_0..OP_16,
+  // OP_1NEGATE) instead of a data push, so covenant scripts stay MINIMALDATA-clean
+  // (mainnet relay policy). Larger values use a minimal scriptNum push. The result
+  // is passed to Script.add(), which accepts an opcode number or a Buffer.
+  if (n === 0) return bsv.Opcode.OP_0
+  if (n === -1) return bsv.Opcode.OP_1NEGATE
+  if (n >= 1 && n <= 16) return bsv.Opcode['OP_' + n]
   return new BN(n).toScriptNumBuffer()
 }
 

package/lib/smart_contract/debugger.js

@@ -0,0 +1,71 @@
+'use strict'
+/**
+ * SmartContract.trace — a covenant stack debugger.
+ *
+ * Step-traces a locking/unlocking pair through Script.Interpreter and records the
+ * stack + alt-stack after every opcode, so you can watch an OP_PUSH_TX covenant
+ * build its signature and enforce its constraints. Uses the interpreter's
+ * stepListener hook. Call SmartContract.enableGenesis() first for OP_PUSH_TX
+ * covenants (their preimage element / opcode count exceed pre-Genesis limits).
+ */
+
+var bsv = require('../..')
+var helpers = require('./covenant_helpers')
+
+function opLabel (opcodenum) {
+  if (opcodenum === 0) return 'OP_0'
+  if (opcodenum >= 1 && opcodenum <= 75) return 'PUSH(' + opcodenum + ')'
+  if (opcodenum === 76) return 'OP_PUSHDATA1'
+  if (opcodenum === 77) return 'OP_PUSHDATA2'
+  if (opcodenum === 78) return 'OP_PUSHDATA4'
+  try { return bsv.Opcode.fromNumber(opcodenum).toString() } catch (e) { return '0x' + opcodenum.toString(16) }
+}
+
+function hex (buf, max) {
+  max = max || 16
+  var h = Buffer.from(buf).toString('hex')
+  return h.length <= max * 2 ? (h || '0') : h.slice(0, max * 2) + '...(' + buf.length + 'B)'
+}
+
+/**
+ * @returns {{ ok:boolean, err:string, steps:Array<{phase,op,stack,altstack}> }}
+ */
+function trace (unlock, lock, opts) {
+  opts = opts || {}
+  var interp = new bsv.Script.Interpreter()
+  var steps = []
+  interp.stepListener = function (step, stack, altstack) {
+    steps.push({
+      phase: interp.script === lock ? 'lock' : 'unlock',
+      op: opLabel(step.opcode && typeof step.opcode.toNumber === 'function' ? step.opcode.toNumber() : step.opcode.num),
+      stack: stack.map(function (b) { return hex(b) }),
+      altstack: altstack.map(function (b) { return hex(b) })
+    })
+  }
+  var ok = interp.verify(
+    unlock, lock,
+    opts.tx || new bsv.Transaction(),
+    opts.inputIndex || 0,
+    typeof opts.flags === 'number' ? opts.flags : helpers.flags(),
+    new bsv.crypto.BN(opts.satoshis || 0)
+  )
+  return { ok: ok, err: interp.errstr || '', steps: steps }
+}
+
+/** Pretty-print a trace result to a string. */
+function format (result) {
+  var lines = []
+  var phase = null
+  result.steps.forEach(function (s, i) {
+    if (s.phase !== phase) { lines.push('-- ' + s.phase + ' script --'); phase = s.phase }
+    var stk = s.stack.length ? s.stack.join(' | ') : '(empty)'
+    var alt = s.altstack.length ? '   alt:[' + s.altstack.join(' | ') + ']' : ''
+    lines.push(String(i).padStart(3) + '  ' + s.op.padEnd(16) + ' -> [' + stk + ']' + alt)
+  })
+  lines.push((result.ok ? 'VALID' : 'INVALID') + (result.err ? ' (' + result.err + ')' : ''))
+  return lines.join('\n')
+}
+
+function print (result) { console.log(format(result)); return result } // eslint-disable-line no-console
+
+module.exports = { trace: trace, format: format, print: print, opLabel: opLabel }

package/lib/smart_contract/dsl.js

@@ -0,0 +1,129 @@
+'use strict'
+/**
+ * SmartContract.policy — a declarative covenant DSL.
+ *
+ * Describe a spending POLICY and compile it to a verified OP_PUSH_TX locking
+ * script, no hand-written opcodes:
+ *
+ *   var c = bsv.SmartContract.policy()
+ *     .payTo(aliceAddr, 9500)        // the spend MUST create this output...
+ *     .lockUntil(800000)             // ...with nLockTime >= 800000
+ *     .compile()
+ *   // c.lock      -> locking Script
+ *   // c.outputs   -> the required Transaction.Output[]
+ *   // c.unlock(spendTx, satoshis) -> grinds + returns the preimage unlock Script
+ *
+ * Each clause compiles to one preimage-field check on top of a single OP_PUSH_TX
+ * authentication; clauses AND together. Requires post-Genesis limits at verify
+ * time (SmartContract.enableGenesis()).
+ */
+
+var bsv = require('../..')
+var PushTx = require('./pushtx')
+var PELS = require('./pels')
+var Token = require('./token')
+var helpers = require('./covenant_helpers')
+
+var Script = bsv.Script
+var Opcode = bsv.Opcode
+var Transaction = bsv.Transaction
+var n = helpers.scriptNum
+
+function toOutput (dest, satoshis) {
+  if (dest instanceof Transaction.Output) return dest
+  if (dest instanceof Script) return new Transaction.Output({ script: dest, satoshis: satoshis })
+  return helpers.p2pkhOutput(dest, satoshis)
+}
+
+// Grind the OP_PUSH_TX nonce (nLockTime) from `base` upward until the in-script
+// signature is a clean low-S DER. Grinding from `base` keeps nLockTime within a
+// lockUntil floor instead of fighting it (grind uses nLockTime as its nonce).
+function grindFrom (spendTx, inputIndex, lock, satoshis, base, maxTries) {
+  maxTries = maxTries || 50000
+  for (var t = 0; t < maxTries; t++) {
+    spendTx.nLockTime = base + t
+    var pre = helpers.rawPreimage(spendTx, inputIndex, lock, satoshis)
+    if (PushTx.sFromPreimage(pre)) return pre
+  }
+  throw new Error('covenant grind failed after ' + maxTries + ' tries')
+}
+
+function Policy () {
+  if (!(this instanceof Policy)) return new Policy()
+  this._outputs = []
+  this._minLockTime = null
+}
+
+/** Require the spend to create this output (call once per required output, in order). */
+Policy.prototype.payTo = function (dest, satoshis) {
+  this._outputs.push(toOutput(dest, satoshis))
+  return this
+}
+
+/** Require the spend's nLockTime to be >= height. */
+Policy.prototype.lockUntil = function (height) {
+  this._minLockTime = height
+  return this
+}
+
+/** The exact outputs a valid spend must contain. */
+Policy.prototype.outputs = function () {
+  return this._outputs.map(function (o) { return new Transaction.Output(o.toObject()) })
+}
+
+Policy.prototype.describe = function () {
+  var parts = []
+  this._outputs.forEach(function (o, i) {
+    parts.push('output[' + i + '] = ' + o.satoshis + ' sat to ' + o.script.toASM().slice(0, 24) + '...')
+  })
+  if (this._minLockTime !== null) parts.push('nLockTime >= ' + this._minLockTime)
+  return 'spend allowed iff: ' + parts.join(' AND ')
+}
+
+/** Compile to a locking script + spend helpers. */
+Policy.prototype.compile = function () {
+  if (this._outputs.length === 0 && this._minLockTime === null) {
+    throw new Error('empty policy: add at least one constraint (payTo / lockUntil)')
+  }
+  var policy = this
+  var s = new Script().add(Opcode.OP_DUP)
+  PushTx.pushTxCore(s) // authenticate the preimage
+  s.add(Opcode.OP_VERIFY) // stack: [preimage]
+
+  if (this._outputs.length) {
+    var expected = PushTx.hashOutputs(this._outputs)
+    s.add(Opcode.OP_DUP)
+    PushTx.extractHashOutputs(s)
+    s.add(Buffer.from(expected)).add(Opcode.OP_EQUALVERIFY)
+  }
+
+  if (this._minLockTime !== null) {
+    s.add(Opcode.OP_DUP)
+    s.add(n(8)).add(Opcode.OP_RIGHT).add(n(4)).add(Opcode.OP_LEFT) // last 8, first 4 = nLockTime
+    s.add(Opcode.OP_BIN2NUM).add(n(this._minLockTime)).add(Opcode.OP_GREATERTHANOREQUAL).add(Opcode.OP_VERIFY)
+  }
+
+  s.add(Opcode.OP_DROP).add(Opcode.OP_1) // drop preimage; succeed
+
+  return {
+    lock: s,
+    outputs: policy.outputs(),
+    describe: function () { return policy.describe() },
+    unlock: function (spendTx, satoshis, inputIndex) {
+      inputIndex = inputIndex || 0
+      var base = policy._minLockTime === null ? 0 : policy._minLockTime
+      if (policy._minLockTime !== null) {
+        spendTx.inputs[inputIndex].sequenceNumber = 0xfffffffe // non-final so locktime applies
+      }
+      return new Script().add(grindFrom(spendTx, inputIndex, s, satoshis, base))
+    }
+  }
+}
+
+function policy () { return new Policy() }
+
+// Terminal shortcuts for the non-composable whole-covenant patterns.
+policy.perpetual = function (fee) { return PELS.pelsCovenant(fee) }
+policy.token = function (fee, ownerHash) { return Token.ownershipToken(fee, ownerHash) }
+
+module.exports = { policy: policy, Policy: Policy }

package/lib/smart_contract/index.js

@@ -1,11 +1,11 @@
 /**
  * SmartContract Module
  * ===================
- * 
+ *
  * Production-ready covenant functionality for Bitcoin SV (BSV).
  * Implements BIP-143 transaction preimage parsing and covenant operations
  * with comprehensive SIGHASH flag support and error handling.
- * 
+ *
  * Classes:
  * - Covenant: Core covenant creation and spending logic
  * - Preimage: BIP-143 preimage parsing and validation with field extraction
@@ -43,7 +43,20 @@ var SmartContract = {
   Locks: require('./locks'),
   PushTx: require('./pushtx'),
   PELS: require('./pels'),
-  Token: require('./token')
+  Token: require('./token'),
+
+  // Declarative covenant DSL + stack debugger (v4.5.0)
+  DSL: require('./dsl'),
+  Policy: require('./dsl').Policy,
+  Debugger: require('./debugger')
+}
+
+// Declarative spending policy -> verified OP_PUSH_TX covenant (v4.5.0).
+// (Exposes the policy() factory with its .perpetual()/.token() shortcuts.)
+SmartContract.policy = SmartContract.DSL.policy
+// Step-trace a locking/unlocking pair (returns { ok, err, steps }).
+SmartContract.trace = function (unlockingScript, lockingScript, opts) {
+  return SmartContract.Debugger.trace(unlockingScript, lockingScript, opts)
 }
 
 // --- Covenant convenience API (v4.2.0) ---
@@ -69,161 +82,161 @@ SmartContract.valueCovenant = function (expectedHashOutputs) {
 }
 
 // Convenience constructor methods
-SmartContract.createCovenant = function(privateKey, options) {
+SmartContract.createCovenant = function (privateKey, options) {
   return new SmartContract.Covenant(privateKey, options)
 }
 
-SmartContract.extractPreimage = function(preimage, options) {
+SmartContract.extractPreimage = function (preimage, options) {
   return new SmartContract.Preimage(preimage, options)
 }
 
-SmartContract.analyzeSIGHASH = function(sighashType) {
+SmartContract.analyzeSIGHASH = function (sighashType) {
   return new SmartContract.SIGHASH(sighashType)
 }
 
-SmartContract.buildCovenant = function(privateKey, options) {
+SmartContract.buildCovenant = function (privateKey, options) {
   return new SmartContract.Builder(privateKey, options)
 }
 
-SmartContract.createUTXOGenerator = function(options) {
+SmartContract.createUTXOGenerator = function (options) {
   return new SmartContract.UTXOGenerator(options)
 }
 
-SmartContract.createTestEnvironment = function(options) {
+SmartContract.createTestEnvironment = function (options) {
   return SmartContract.UTXOGenerator.createTestEnvironment(options)
 }
 
-SmartContract.testScript = function(unlocking, locking, options) {
+SmartContract.testScript = function (unlocking, locking, options) {
   return SmartContract.ScriptTester.test(unlocking, locking, options)
 }
 
-SmartContract.testCovenant = function(preimageHex, constraints, options) {
+SmartContract.testCovenant = function (preimageHex, constraints, options) {
   return SmartContract.ScriptTester.testCovenant(preimageHex, constraints, options)
 }
 
-SmartContract.testFieldExtraction = function(preimageHex, fieldName, options) {
+SmartContract.testFieldExtraction = function (preimageHex, fieldName, options) {
   return SmartContract.ScriptTester.testFieldExtraction(preimageHex, fieldName, options)
 }
 
-SmartContract.debugScript = function(config, options) {
+SmartContract.debugScript = function (config, options) {
   var tester = new SmartContract.ScriptTester(options)
   return tester.debug(config)
 }
 
 // Educational and utility functions
-SmartContract.explainZeroHashes = function() {
+SmartContract.explainZeroHashes = function () {
   return SmartContract.SIGHASH.explainZeroMystery()
 }
 
-SmartContract.getAllSIGHASHTypes = function() {
+SmartContract.getAllSIGHASHTypes = function () {
   return SmartContract.SIGHASH.getAllTypes()
 }
 
-SmartContract.demonstrateAllSIGHASH = function() {
+SmartContract.demonstrateAllSIGHASH = function () {
   return SmartContract.SIGHASH.generateAllDemonstrations()
 }
 
 // JavaScript-to-Bitcoin Script covenant generation
-SmartContract.createCovenantBuilder = function() {
+SmartContract.createCovenantBuilder = function () {
   return new SmartContract.CovenantBuilder()
 }
 
-SmartContract.createValueLockCovenant = function(expectedValue) {
+SmartContract.createValueLockCovenant = function (expectedValue) {
   return SmartContract.CovenantTemplates.valueLock(expectedValue)
 }
 
-SmartContract.createHashLockCovenant = function(expectedHash) {
+SmartContract.createHashLockCovenant = function (expectedHash) {
   return SmartContract.CovenantTemplates.hashLock(expectedHash)
 }
 
-SmartContract.createComplexValidationCovenant = function(rules) {
+SmartContract.createComplexValidationCovenant = function (rules) {
   return SmartContract.CovenantTemplates.complexValidation(rules)
 }
 
 // Opcode mapping utilities
-SmartContract.getOpcodeMap = function() {
+SmartContract.getOpcodeMap = function () {
   return SmartContract.OpcodeMap.opcodeMap
 }
 
-SmartContract.simulateScript = function(operations, initialStack) {
+SmartContract.simulateScript = function (operations, initialStack) {
   return SmartContract.OpcodeMap.utils.simulate(operations, initialStack)
 }
 
-SmartContract.createASMFromJS = function(operations) {
+SmartContract.createASMFromJS = function (operations) {
   return SmartContract.OpcodeMap.utils.createASM(operations)
 }
 
 // Script analysis and conversion utilities
-SmartContract.scriptToASM = function(scriptBuffer) {
+SmartContract.scriptToASM = function (scriptBuffer) {
   return SmartContract.ScriptUtils.scriptToASM(scriptBuffer)
 }
 
-SmartContract.asmToScript = function(asmString) {
+SmartContract.asmToScript = function (asmString) {
   return SmartContract.ScriptUtils.asmToScript(asmString)
 }
 
-SmartContract.asmToHex = function(asmString) {
+SmartContract.asmToHex = function (asmString) {
   return SmartContract.ScriptUtils.asmToHex(asmString)
 }
 
-SmartContract.hexToASM = function(hexString) {
+SmartContract.hexToASM = function (hexString) {
   return SmartContract.ScriptUtils.hexToASM(hexString)
 }
 
-SmartContract.scriptToHex = function(script) {
+SmartContract.scriptToHex = function (script) {
   return SmartContract.ScriptUtils.scriptToHex(script)
 }
 
-SmartContract.validateASM = function(asmString) {
+SmartContract.validateASM = function (asmString) {
   return SmartContract.ScriptUtils.validateASM(asmString)
 }
 
-SmartContract.validateScript = function(script) {
+SmartContract.validateScript = function (script) {
   return SmartContract.ScriptUtils.validateScript(script)
 }
 
-SmartContract.estimateScriptSize = function(script) {
+SmartContract.estimateScriptSize = function (script) {
   return SmartContract.ScriptUtils.estimateScriptSize(script)
 }
 
-SmartContract.optimizeScript = function(script) {
+SmartContract.optimizeScript = function (script) {
   return SmartContract.ScriptUtils.optimizeScript(script)
 }
 
-SmartContract.compareScripts = function(scriptA, scriptB) {
+SmartContract.compareScripts = function (scriptA, scriptB) {
   return SmartContract.ScriptUtils.compareScripts(scriptA, scriptB)
 }
 
-SmartContract.explainScript = function(script) {
+SmartContract.explainScript = function (script) {
   return SmartContract.ScriptUtils.explainScript(script)
 }
 
-SmartContract.scriptMetrics = function(script) {
+SmartContract.scriptMetrics = function (script) {
   return SmartContract.ScriptUtils.scriptMetrics(script)
 }
 
-SmartContract.analyzeComplexity = function(script) {
+SmartContract.analyzeComplexity = function (script) {
   return SmartContract.ScriptUtils.analyzeComplexity(script)
 }
 
-SmartContract.findOptimizations = function(script) {
+SmartContract.findOptimizations = function (script) {
   return SmartContract.ScriptUtils.findOptimizations(script)
 }
 
-SmartContract.covenantToEnglish = function(covenant) {
+SmartContract.covenantToEnglish = function (covenant) {
   return SmartContract.ScriptUtils.covenantToEnglish(covenant)
 }
 
-SmartContract.batchTestScripts = function(scripts, options) {
+SmartContract.batchTestScripts = function (scripts, options) {
   return SmartContract.ScriptUtils.batchTestScripts(scripts, options)
 }
 
 // Debug and analysis tools
-SmartContract.examineStack = function(lockingHex, unlockingHex) {
+SmartContract.examineStack = function (lockingHex, unlockingHex) {
   return SmartContract.StackExaminer.runScript(lockingHex, unlockingHex)
 }
 
-SmartContract.debugScriptExecution = function(unlockingScript, lockingScript, options) {
+SmartContract.debugScriptExecution = function (unlockingScript, lockingScript, options) {
   options = options || {}
   if (options.stepMode) {
     return SmartContract.ScriptInterpreter.stepThroughScript(
@@ -240,18 +253,18 @@ SmartContract.debugScriptExecution = function(unlockingScript, lockingScript, op
   }
 }
 
-SmartContract.parseScript = function(scriptInput) {
+SmartContract.parseScript = function (scriptInput) {
   return SmartContract.ScriptInterpreter.parseScript(scriptInput)
 }
 
-SmartContract.printStack = function(stack, altstack) {
+SmartContract.printStack = function (stack, altstack) {
   return SmartContract.ScriptInterpreter.printStack(stack, altstack)
 }
 
 // Quick covenant creation utility
-SmartContract.createQuickCovenant = function(type, params) {
+SmartContract.createQuickCovenant = function (type, params) {
   const builder = SmartContract.createCovenantBuilder()
-  
+
   switch (type) {
     case 'value_lock':
       return builder
@@ -261,7 +274,7 @@ SmartContract.createQuickCovenant = function(type, params) {
         .greaterThanOrEqual()
         .verify()
         .build()
-    
+
     case 'hash_lock':
       return builder
         .comment(`Hash lock: requires preimage of ${params.hash}`)
@@ -270,7 +283,7 @@ SmartContract.createQuickCovenant = function(type, params) {
         .push(params.hash)
         .equalVerify()
         .build()
-    
+
     case 'time_lock':
       return builder
         .comment(`Time lock: requires nLockTime > ${params.timestamp}`)
@@ -279,7 +292,7 @@ SmartContract.createQuickCovenant = function(type, params) {
         .greaterThan()
         .verify()
         .build()
-    
+
     case 'multi_condition':
       let covenant = builder.comment('Multi-condition covenant')
       params.conditions.forEach(condition => {
@@ -308,20 +321,20 @@ SmartContract.createQuickCovenant = function(type, params) {
         }
       })
       return covenant.build()
-    
+
     default:
       throw new Error(`Unknown covenant type: ${type}`)
   }
 }
 
 // Complete workflow helpers
-SmartContract.completeCovenantFlow = function(privateKey, p2pkhUtxo, broadcastCallback) {
+SmartContract.completeCovenantFlow = function (privateKey, p2pkhUtxo, broadcastCallback) {
   var covenant = new SmartContract.Covenant(privateKey)
   return covenant.completeFlow(p2pkhUtxo, broadcastCallback)
 }
 
 // Educational utilities
-SmartContract.getEducationalResources = function() {
+SmartContract.getEducationalResources = function () {
   return {
     zeroHashMystery: SmartContract.SIGHASH.explainZeroMystery(),
     sighashTypes: SmartContract.SIGHASH.getAllTypes(),
@@ -331,17 +344,17 @@ SmartContract.getEducationalResources = function() {
 
 // Utility functions
 SmartContract.utils = {}
-SmartContract.utils.reconstructP2pkhScript = function(address) {
+SmartContract.utils.reconstructP2pkhScript = function (address) {
   return bsv.Script.buildPublicKeyHashOut(address).toHex()
 }
 
-SmartContract.utils.createCovenantAddress = function(script) {
+SmartContract.utils.createCovenantAddress = function (script) {
   // Create P2SH address for covenant script
   var scriptHash = bsv.crypto.Hash.sha256ripemd160(script.toBuffer())
   return bsv.Address.fromScriptHash(scriptHash)
 }
 
-SmartContract.utils.decodeCompactSize = function(buffer, offset) {
+SmartContract.utils.decodeCompactSize = function (buffer, offset) {
   return SmartContract.Preimage.decodeCompactSize(buffer, offset)
 }
 
@@ -380,4 +393,4 @@ SmartContract.features = {
 SmartContract.interpretScript = SmartContract.debugScriptExecution
 SmartContract.getScriptMetrics = SmartContract.scriptMetrics
 
-module.exports = SmartContract
+module.exports = SmartContract

package/lib/smart_contract/pushtx.js

@@ -54,8 +54,9 @@ function reverseBytes (script, n) {
  */
 function pushTxCore (script) {
   script.add(Opcode.OP_HASH256) // z = HASH256(preimage), 32B BE
-  reverseBytes(script, 32) // -> little-endian
-  script.add(Buffer.from([0x00])).add(Opcode.OP_CAT).add(Opcode.OP_BIN2NUM) // e (positive)
+  reverseBytes(script, 32) // -> little-endian = e. The grind guarantees e is
+  // already positive and minimally encoded (z[0] in 0x01..0x7f), so NO 0x00 sign
+  // byte is appended — keeping the script MINIMALDATA-clean (mainnet-relayable).
   script.add(gxLe).add(Opcode.OP_ADD) // e + Gx
   script.add(N_LE).add(Opcode.OP_MOD) // s = (e + Gx) mod n
   script.add(scriptNum(32)).add(Opcode.OP_NUM2BIN) // s -> 32-byte LE
@@ -64,7 +65,7 @@ function pushTxCore (script) {
   // r-value inside the DER prefix and the body of the 02||Gx pubkey). Sharing it
   // via the altstack saves a 32-byte constant vs. embedding Gx twice.
   script.add(Gx).add(Opcode.OP_DUP) // [s_be, Gx, Gx]
-  script.add(Buffer.from([0x02])).add(Opcode.OP_SWAP).add(Opcode.OP_CAT) // pubkey = 02||Gx
+  script.add(Opcode.OP_2).add(Opcode.OP_SWAP).add(Opcode.OP_CAT) // pubkey = 02||Gx (OP_2 = minimal push of 0x02)
   script.add(Opcode.OP_TOALTSTACK) // park pubkey ; [s_be, Gx]
   script.add(Buffer.from([0x30, 0x44, 0x02, 0x20])).add(Opcode.OP_SWAP).add(Opcode.OP_CAT) // 30440220||Gx
   script.add(Buffer.from([0x02, 0x20])).add(Opcode.OP_CAT) // ||0220  => DER prefix
@@ -117,6 +118,10 @@ var HALF_N = new BN('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681
  */
 function sFromPreimage (preimage) {
   var z = Hash.sha256sha256(preimage)
+  // Script no longer sign-extends z, so e (= reverse(z) as a number) must be
+  // positive AND minimally encoded: its little-endian MSB (= z[0]) in 0x01..0x7f.
+  // This keeps the locking script MINIMALDATA-clean (mainnet-relayable).
+  if (z[0] < 0x01 || z[0] > 0x7f) return null
   var s = new BN(z).add(new BN(Gx)).mod(N)
   if (s.gt(HALF_N)) return null // enforce low-S (canonical / non-malleable)
   var sBE = s.toBuffer('be', 32)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartledger/bsv",
-  "version": "4.4.0",
+  "version": "4.6.0",
   "description": "🚀 Complete Bitcoin SV development framework with legally-recognizable DID:web + W3C VC-JWT toolkit, Legal Token Protocol (LTP), Global Digital Attestation Framework (GDAF), StatusList2021 revocation, and 16 flexible loading options. Standards-based credentials with ES256/ES256K support, on-chain BSV anchoring, and comprehensive Bitcoin SV API. Perfect for legal tokens, verifiable credentials, DeFi, smart contracts, and secure Bitcoin applications.",
   "author": "SmartLedger Technology <hello@smartledger.technology> (https://smartledger.technology)",
   "homepage": "https://github.com/codenlighten/smartledger-bsv#readme",
@@ -198,6 +198,7 @@
     "request": "browser-request"
   },
   "dependencies": {
+    "@smartledger/bsv": "^4.4.0",
     "aes-js": "^3.1.2",
     "bn.js": "=4.11.9",
     "bs58": "=4.0.1",