@smartledger/bsv 4.2.1 → 4.5.0

package/lib/script/interpreter.js

@@ -701,7 +701,7 @@ Interpreter.prototype.step = function () {
           return true
         }
         break
-        
+
       // Monolith opcodes are now enabled by default in SmartLedger BSV
       // These were activated in May 2018 and are part of standard BSV consensus
       case Opcode.OP_DIV:
@@ -715,7 +715,7 @@ Interpreter.prototype.step = function () {
       case Opcode.OP_NUM2BIN:
         // These opcodes are now always enabled - no flag required
         return false
-        
+
       default:
         break
     }
@@ -1757,6 +1757,56 @@ Interpreter.prototype.step = function () {
         this.stack[this.stack.length - 1] = n1.slice(position)
         break
 
+      case Opcode.OP_LEFT:
+      case Opcode.OP_RIGHT:
+        // (in size -- out)  OP_LEFT keeps the first `size` bytes; OP_RIGHT the last.
+        // Re-enabled string opcodes (BSV Chronicle). Original Satoshi semantics.
+        if (this.stack.length < 2) {
+          this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION'
+          return false
+        }
+        buf1 = stacktop(-2)
+        n = BN.fromScriptNumBuffer(stacktop(-1), fRequireMinimal).toNumber()
+        if (n < 0) {
+          this.errstr = 'SCRIPT_ERR_INVALID_NUMBER_RANGE'
+          return false
+        }
+        if (n > buf1.length) {
+          n = buf1.length
+        }
+        this.stack.pop()
+        if (opcodenum === Opcode.OP_LEFT) {
+          this.stack[this.stack.length - 1] = Buffer.from(buf1).slice(0, n)
+        } else {
+          this.stack[this.stack.length - 1] = Buffer.from(buf1).slice(buf1.length - n)
+        }
+        break
+
+      case Opcode.OP_SUBSTR:
+        // (in begin size -- out)  out = in[begin : begin + size]
+        // Re-enabled string opcode (BSV Chronicle). Original Satoshi semantics.
+        if (this.stack.length < 3) {
+          this.errstr = 'SCRIPT_ERR_INVALID_STACK_OPERATION'
+          return false
+        }
+        buf1 = stacktop(-3)
+        var subSize = BN.fromScriptNumBuffer(stacktop(-1), fRequireMinimal).toNumber()
+        var subBegin = BN.fromScriptNumBuffer(stacktop(-2), fRequireMinimal).toNumber()
+        if (subBegin < 0 || subSize < 0) {
+          this.errstr = 'SCRIPT_ERR_INVALID_NUMBER_RANGE'
+          return false
+        }
+        if (subBegin > buf1.length) {
+          subBegin = buf1.length
+        }
+        if (subBegin + subSize > buf1.length) {
+          subSize = buf1.length - subBegin
+        }
+        this.stack.pop()
+        this.stack.pop()
+        this.stack[this.stack.length - 1] = Buffer.from(buf1).slice(subBegin, subBegin + subSize)
+        break
+
         //
         // Conversion operations
         //

package/lib/smart_contract/covenant_helpers.js

@@ -18,13 +18,14 @@ var Signature = require('../crypto/signature')
 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 intentionally omitted so the in-script OP_PUSH_TX
-// signature (which may be high-S) verifies.
+// 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.
 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_CHECKLOCKTIMEVERIFY |
     I.SCRIPT_VERIFY_CHECKSEQUENCEVERIFY |
     I.SCRIPT_ENABLE_SIGHASH_FORKID |

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/pels.js

@@ -44,8 +44,7 @@ function pelsCovenant (fee) {
 
   // 3. value (8B @ offsetFromEnd 52); newValue = value - fee, as 8-byte LE
   s.add(Opcode.OP_OVER)
-  s.add(Opcode.OP_SIZE).add(n(52)).add(Opcode.OP_SUB).add(Opcode.OP_SPLIT).add(Opcode.OP_NIP)
-  s.add(n(8)).add(Opcode.OP_SPLIT).add(Opcode.OP_DROP)
+  s.add(n(52)).add(Opcode.OP_RIGHT).add(n(8)).add(Opcode.OP_LEFT) // last 52 bytes, first 8 = value
   s.add(Opcode.OP_BIN2NUM).add(n(fee)).add(Opcode.OP_SUB)
   s.add(n(8)).add(Opcode.OP_NUM2BIN)