@smartledger/bsv 7.9.0 → 7.10.1

package/lib/smart_contract/covenant_helpers.js

@@ -1,140 +1,9 @@
 'use strict'
-/**
- * SmartContract covenant helpers
- * ==============================
- *
- * Shared utilities for building and verifying custom locking scripts &
- * OP_PUSH_TX covenants: a consensus-flag verify() harness, raw BIP-143 preimage
- * access, signing, and fund/spend scaffolding. Used by ./pushtx, ./pels, ./token
- * and ./locks.
- */
-
-var bsv = require('../..')
-var BN = require('../crypto/bn')
-var Hash = require('../crypto/hash')
-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 + 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 flags locally
-// mirrors mainnet relay/consensus policy, so a covenant that passes here is
-// expected to be accepted on broadcast — catch non-relayable scripts before then.
-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 |
-    I.SCRIPT_ENABLE_MAGNETIC_OPCODES |
-    I.SCRIPT_ENABLE_MONOLITH_OPCODES |
-    // REQUIRED, not optional. pushTxCore emits OP_RIGHT/OP_LEFT — see
-    // extractHashOutputs and assertSighashType — and those bytes (180/181) are
-    // upgradable NOPs on the network until Chronicle activates. Without this
-    // flag the interpreter treats them as no-ops, exactly as a pre-Chronicle
-    // node does, and the covenant does not verify.
-    //
-    // Stated plainly: OP_PUSH_TX covenants built by this library DEPEND on
-    // Chronicle and cannot be spent on a pre-Chronicle chain. That was
-    // previously invisible because the interpreter ran the string opcodes
-    // unconditionally — more permissively than the network.
-    I.SCRIPT_ENABLE_CHRONICLE
-}
-
-/**
- * Opt into post-Genesis script limits (needed by OP_PUSH_TX covenants).
- * Thin wrapper over Interpreter.useGenesisLimits (added in 4.1.0).
- */
-function enableGenesis (max) {
-  return bsv.Script.Interpreter.useGenesisLimits(max)
-}
-
-/**
- * Verify an unlocking script against a locking script through the consensus
- * interpreter. @returns {{ok:boolean, err:string}}
- */
-function verify (unlockingScript, lockingScript, opts) {
-  opts = opts || {}
-  var interp = new bsv.Script.Interpreter()
-  var ok = interp.verify(
-    unlockingScript,
-    lockingScript,
-    opts.tx || new bsv.Transaction(),
-    opts.inputIndex || 0,
-    opts.flags || flags(),
-    new BN(opts.satoshis || 0)
-  )
-  return { ok: ok, err: interp.errstr || '' }
-}
-
-/** Raw BIP-143 preimage (the serialization that is double-SHA256'd), not the digest. */
-function rawPreimage (tx, inputIndex, lockingScript, satoshis, sighashType) {
-  return bsv.Transaction.sighash.sighashPreimage(
-    tx, sighashType || SIGHASH, inputIndex, lockingScript, new BN(satoshis))
-}
-
-/** Sighash digest = HASH256(rawPreimage) — useful for asserting OP_PUSH_TX linkage in JS. */
-function sighashDigest (tx, inputIndex, lockingScript, satoshis, sighashType) {
-  return Hash.sha256sha256(rawPreimage(tx, inputIndex, lockingScript, satoshis, sighashType))
-}
-
-/** DER+sighash-byte signature over `lockingScript` for `inputIndex`. */
-function signInput (tx, privateKey, inputIndex, lockingScript, satoshis, sighashType) {
-  sighashType = sighashType || SIGHASH
-  var sig = bsv.Transaction.sighash.sign(tx, privateKey, sighashType, inputIndex, lockingScript, new BN(satoshis))
-  return Buffer.concat([sig.toDER(), Buffer.from([sighashType])])
-}
-
-/**
- * Build a funding tx paying `satoshis` into `lockingScript`, plus a spending tx
- * consuming it with the supplied outputs. Returns { funding, spend }; the caller
- * sets spend.inputs[0] script.
- */
-function fundAndSpend (lockingScript, satoshis, opts) {
-  opts = opts || {}
-  var funding = new bsv.Transaction().addOutput(
-    new bsv.Transaction.Output({ script: lockingScript, satoshis: satoshis }))
-  var spend = new bsv.Transaction()
-  spend.addInput(
-    new bsv.Transaction.Input({ prevTxId: funding.hash, outputIndex: 0, script: bsv.Script.empty() }),
-    lockingScript, satoshis)
-  if (opts.outputs) opts.outputs.forEach(function (o) { spend.addOutput(o) })
-  return { funding: funding, spend: spend }
-}
-
-/** A P2PKH Output object for an address or public key. */
-function p2pkhOutput (addressOrPubKey, satoshis) {
-  var addr = addressOrPubKey.toAddress ? addressOrPubKey.toAddress() : addressOrPubKey
-  return new bsv.Transaction.Output({ script: bsv.Script.buildPublicKeyHashOut(addr), satoshis: 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()
-}
-
-module.exports = {
-  SIGHASH: SIGHASH,
-  flags: flags,
-  enableGenesis: enableGenesis,
-  verify: verify,
-  rawPreimage: rawPreimage,
-  sighashDigest: sighashDigest,
-  signInput: signInput,
-  fundAndSpend: fundAndSpend,
-  p2pkhOutput: p2pkhOutput,
-  scriptNum: scriptNum
-}
+// Moved to lib/covenant/helpers.js.
+//
+// lib/ordinals needs these primitives too, and importing them from
+// lib/smart_contract was the only dependency from core code into the
+// application layer. This path is retained because deep imports
+// (require('@smartledger/bsv/lib/smart_contract/covenant_helpers')) are public
+// API via the package.json exports map.
+module.exports = require('../covenant/helpers')

package/lib/smart_contract/debugger.js

@@ -9,8 +9,11 @@
  * covenants (their preimage element / opcode count exceed pre-Genesis limits).
  */
 
-var bsv = require('../..')
-var helpers = require('./covenant_helpers')
+var Interpreter = require('../script/interpreter')
+var BN = require('../crypto/bn')
+var Transaction = require('../transaction')
+var Opcode = require('../opcode')
+var helpers = require('../covenant/helpers')
 
 function opLabel (opcodenum) {
   if (opcodenum === 0) return 'OP_0'
@@ -18,7 +21,7 @@ function opLabel (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) }
+  try { return Opcode.fromNumber(opcodenum).toString() } catch (e) { return '0x' + opcodenum.toString(16) }
 }
 
 function hex (buf, max) {
@@ -32,7 +35,7 @@ function hex (buf, max) {
  */
 function trace (unlock, lock, opts) {
   opts = opts || {}
-  var interp = new bsv.Script.Interpreter()
+  var interp = new Interpreter()
   var steps = []
   interp.stepListener = function (step, stack, altstack) {
     steps.push({
@@ -44,10 +47,10 @@ function trace (unlock, lock, opts) {
   }
   var ok = interp.verify(
     unlock, lock,
-    opts.tx || new bsv.Transaction(),
+    opts.tx || new Transaction(),
     opts.inputIndex || 0,
     typeof opts.flags === 'number' ? opts.flags : helpers.flags(),
-    new bsv.crypto.BN(opts.satoshis || 0)
+    new BN(opts.satoshis || 0)
   )
   return { ok: ok, err: interp.errstr || '', steps: steps }
 }

package/lib/smart_contract/dsl.js

@@ -18,15 +18,14 @@
  * time (SmartContract.enableGenesis()).
  */
 
-var bsv = require('../..')
-var PushTx = require('./pushtx')
+var PushTx = require('../covenant/pushtx')
 var PELS = require('./pels')
 var Token = require('./token')
-var helpers = require('./covenant_helpers')
+var helpers = require('../covenant/helpers')
 
-var Script = bsv.Script
-var Opcode = bsv.Opcode
-var Transaction = bsv.Transaction
+var Script = require('../script')
+var Opcode = require('../opcode')
+var Transaction = require('../transaction')
 var n = helpers.scriptNum
 
 function toOutput (dest, satoshis) {

package/lib/smart_contract/index.js

@@ -27,7 +27,10 @@
 
 'use strict'
 
-var bsv = require('../..')
+var Hash = require('../crypto/hash')
+var Transaction = require('../transaction')
+var Address = require('../address')
+var Script = require('../script')
 
 var SmartContract = {
   Covenant: require('./covenant'),
@@ -44,9 +47,9 @@ var SmartContract = {
   ScriptInterpreter: require('./script_interpreter'),
 
   // Interpreter-verified custom locking scripts & OP_PUSH_TX covenants (v4.2.0)
-  CovenantHelpers: require('./covenant_helpers'),
+  CovenantHelpers: require('../covenant/helpers'),
   Locks: require('./locks'),
-  PushTx: require('./pushtx'),
+  PushTx: require('../covenant/pushtx'),
   PELS: require('./pels'),
   Token: require('./token'),
   Authorizers: require('./authorizers'),
@@ -258,14 +261,14 @@ SmartContract.debugScriptExecution = function (unlockingScript, lockingScript, o
   if (options.stepMode) {
     return SmartContract.ScriptInterpreter.stepThroughScript(
       SmartContract.ScriptInterpreter.parseScript(unlockingScript + ' ' + lockingScript),
-      new bsv.Transaction(),
+      new Transaction(),
       true
     )
   } else {
     return SmartContract.ScriptInterpreter.runFullEvaluation(
       SmartContract.ScriptInterpreter.parseScript(unlockingScript),
       SmartContract.ScriptInterpreter.parseScript(lockingScript),
-      new bsv.Transaction()
+      new Transaction()
     )
   }
 }
@@ -362,13 +365,13 @@ SmartContract.getEducationalResources = function () {
 // Utility functions
 SmartContract.utils = {}
 SmartContract.utils.reconstructP2pkhScript = function (address) {
-  return bsv.Script.buildPublicKeyHashOut(address).toHex()
+  return Script.buildPublicKeyHashOut(address).toHex()
 }
 
 SmartContract.utils.createCovenantAddress = function (script) {
   // Create P2SH address for covenant script
-  var scriptHash = bsv.crypto.Hash.sha256ripemd160(script.toBuffer())
-  return bsv.Address.fromScriptHash(scriptHash)
+  var scriptHash = Hash.sha256ripemd160(script.toBuffer())
+  return Address.fromScriptHash(scriptHash)
 }
 
 SmartContract.utils.decodeCompactSize = function (buffer, offset) {

package/lib/smart_contract/locks.js

@@ -4,12 +4,11 @@
  * Each factory returns { lock: Script, unlock: fn, meta }.
  */
 
-var bsv = require('../..')
 var Hash = require('../crypto/hash')
-var H = require('./covenant_helpers')
+var H = require('../covenant/helpers')
 
-var Script = bsv.Script
-var Opcode = bsv.Opcode
+var Script = require('../script')
+var Opcode = require('../opcode')
 var signInput = H.signInput
 var n = H.scriptNum
 

package/lib/smart_contract/opcode_list.js

@@ -1,12 +1,11 @@
-const bsv = require('../..')
-const opcode = bsv.Opcode;
+const opcode = require('../opcode')
 console.log('Opcode List:');
 for (let key in opcode.map) {
   const code = opcode.map[key];
   console.log(`${key}: 0x${code.toString(16).padStart(2, '0')}`);
 }
 
-const Script = bsv.Script;
+const Script = require('../script')
 console.log(Script);
 console.log('\nSample Script using OP_CHECKSIG and OP_RETURN:');
 const script = new Script()

package/lib/smart_contract/pels.js

@@ -17,12 +17,11 @@
  * Requires post-Genesis limits (SmartContract.enableGenesis()).
  */
 
-var bsv = require('../..')
-var P = require('./pushtx')
-var H = require('./covenant_helpers')
+var P = require('../covenant/pushtx')
+var H = require('../covenant/helpers')
 
-var Script = bsv.Script
-var Opcode = bsv.Opcode
+var Script = require('../script')
+var Opcode = require('../opcode')
 var n = H.scriptNum
 
 /**

package/lib/smart_contract/preimage.js

@@ -13,7 +13,11 @@
 
 'use strict'
 
-var bsv = require('../..')
+var sighash = require('../transaction/sighash')
+var BN = require('../crypto/bn')
+var Transaction = require('../transaction')
+var PrivateKey = require('../privatekey')
+var Script = require('../script')
 var crypto = require('crypto')
 
 /**
@@ -800,12 +804,12 @@ Preimage.decodeCompactSize = function(buffer, offset) {
  * @returns {Preimage} Preimage instance
  */
 Preimage.fromTransaction = function(transaction, inputIndex, subscript, satoshis, sighashType) {
-  var preimageBuffer = bsv.Transaction.sighash.sighashPreimage(
+  var preimageBuffer = sighash.sighashPreimage(
     transaction,
     sighashType,
     inputIndex,
     subscript,
-    new bsv.crypto.BN(satoshis)
+    new BN(satoshis)
   )
 
   return new Preimage(preimageBuffer, {
@@ -824,21 +828,21 @@ Preimage.fromTransaction = function(transaction, inputIndex, subscript, satoshis
  */
 Preimage.createExample = function(sighashType) {
   // Create a simple example transaction
-  var privateKey = bsv.PrivateKey.fromRandom()
+  var privateKey = PrivateKey.fromRandom()
   var address = privateKey.toAddress()
 
   var utxo = {
     txId: '0'.repeat(64),
     outputIndex: 0,
-    script: bsv.Script.buildPublicKeyHashOut(address).toHex(),
+    script: Script.buildPublicKeyHashOut(address).toHex(),
     satoshis: 100000
   }
 
-  var transaction = new bsv.Transaction()
+  var transaction = new Transaction()
     .from(utxo)
     .to(address, 99000)
 
-  var subscript = bsv.Script.fromHex(utxo.script)
+  var subscript = Script.fromHex(utxo.script)
   
   return Preimage.fromTransaction(transaction, 0, subscript, utxo.satoshis, sighashType)
 }

package/lib/smart_contract/pushtx.js

@@ -1,264 +1,9 @@
 'use strict'
-/**
- * SmartContract.PushTx — a correct, interpreter-verified OP_PUSH_TX (nChain
- * WP1605) for Bitcoin SV.
- *
- * The locking script GENERATES an ECDSA signature in-script from a preimage the
- * spender pushed, then OP_CHECKSIG verifies it against a fixed public key.
- * OP_CHECKSIG only passes if the message it derives internally (the genuine
- * BIP-143 sighash of THIS spend) equals HASH256(preimage) — so a passing check
- * proves the pushed preimage IS this transaction, letting a script read and
- * constrain its own spending transaction.
- *
- * Optimal parameters: private key a = 1, ephemeral k = 1  =>  r = Gx,
- *   s = (e + Gx) mod n,  pubkey P = 02||Gx,  e = HASH256(preimage).
- *
- * Requires post-Genesis limits — call SmartContract.enableGenesis() (a.k.a
- * Interpreter.useGenesisLimits()) before verifying these scripts.
- */
-
-var bsv = require('../..')
-var BN = require('../crypto/bn')
-var Hash = require('../crypto/hash')
-var H = require('./covenant_helpers')
-
-var Script = bsv.Script
-var Opcode = bsv.Opcode
-var SIGHASH = H.SIGHASH
-var scriptNum = H.scriptNum
-
-// secp256k1 constants (big-endian)
-var Gx = Buffer.from('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798', 'hex')
-var N = new BN('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141', 16)
-var PUBKEY = Buffer.concat([Buffer.from([0x02]), Gx]) // compressed P = G (y even)
-
-// script-number (little-endian) forms
-var gxLe = Buffer.from(Gx).reverse() // 32B, top 0x79 => positive
-var N_LE = Buffer.concat([Buffer.from(N.toBuffer()).reverse(), Buffer.from([0x00])]) // 33B positive
-
-// fixed DER prefix: SEQUENCE(0x44) INTEGER(0x20) r=Gx INTEGER(0x20)
-var DER_PREFIX = Buffer.concat([Buffer.from([0x30, 0x44, 0x02, 0x20]), Gx, Buffer.from([0x02, 0x20])])
-
-/** Reverse a fixed n-byte buffer on top of the stack (big-endian <-> little-endian). */
-function reverseBytes (script, n) {
-  var i
-  for (i = 0; i < n - 1; i++) script.add(Opcode.OP_1).add(Opcode.OP_SPLIT)
-  for (i = 0; i < n - 1; i++) script.add(Opcode.OP_SWAP).add(Opcode.OP_CAT)
-  return script
-}
-
-// Common SIGHASH flag combinations (all include FORKID, required on BSV). The
-// marketplace/partially-signed pattern uses SINGLE|ANYONECANPAY: the signer commits
-// only to its own input and its own output (the output at the same index), leaving
-// a counterparty free to add funding inputs and change outputs without invalidating
-// the signature.
-var Signature = bsv.crypto.Signature
-var SIGHASH_ALL_FORKID = Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID // 0x41
-var SIGHASH_SINGLE_FORKID = Signature.SIGHASH_SINGLE | Signature.SIGHASH_FORKID // 0x43
-var SIGHASH_SINGLE_ANYONECANPAY_FORKID =
-  Signature.SIGHASH_SINGLE | Signature.SIGHASH_ANYONECANPAY | Signature.SIGHASH_FORKID // 0xc3
-// ALL|ANYONECANPAY commits to ALL outputs (so the covenant can pin the FULL output
-// set) while leaving inputs open for a counterparty to add funding. This is the flag
-// the 1Sat Ordinals OrdLock uses: the buyer supplies the surrounding outputs and the
-// covenant binds the seller's payment output into the committed hashOutputs.
-var SIGHASH_ALL_ANYONECANPAY_FORKID =
-  Signature.SIGHASH_ALL | Signature.SIGHASH_ANYONECANPAY | Signature.SIGHASH_FORKID // 0xc1
-
-/**
- * Append the in-script signature generator + verifier ("PUSH_TX core").
- * Pre:  top of stack = preimage. Post: top = OP_CHECKSIG result.
- *
- * @param {Script} script
- * @param {object} [opts]
- * @param {number} [opts.sighashType=0x41] the SIGHASH flag byte baked into the
- *   synthetic signature. OP_CHECKSIG derives the spend's sighash using THIS flag,
- *   so the spender must push the matching BIP-143 preimage (grind with the same
- *   sighashType). Defaults to SIGHASH_ALL|FORKID — existing covenants are unchanged.
- */
-function pushTxCore (script, opts) {
-  var sighashType = (opts && opts.sighashType) || SIGHASH
-  script.add(Opcode.OP_HASH256) // z = HASH256(preimage), 32B BE
-  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
-  reverseBytes(script, 32) // -> big-endian (DER INTEGER body) ; stack: [s_be]
-  // Build the DER signature and the pubkey from a SINGLE Gx push (Gx is both the
-  // 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(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
-  script.add(Opcode.OP_SWAP).add(Opcode.OP_CAT) // DER prefix || s_be
-  script.add(Buffer.from([sighashType])).add(Opcode.OP_CAT) // || sighash flag => full DER sig
-  script.add(Opcode.OP_FROMALTSTACK).add(Opcode.OP_CHECKSIG) // pubkey ; verify against P = G
-  return script
-}
-
-/** Bare authenticator script: unlock with the (grindable) preimage. */
-function authenticator () {
-  return pushTxCore(new Script())
-}
-
-/** Extract the committed hashOutputs (item 9, offsetFromEnd 40, len 32) from a preimage on-stack. */
-function extractHashOutputs (script) {
-  // last 40 bytes, then the first 32 of those = hashOutputs. (BSV string opcodes.)
-  script.add(scriptNum(40)).add(Opcode.OP_RIGHT).add(scriptNum(32)).add(Opcode.OP_LEFT)
-  return script
-}
-
-// The BIP-143 preimage ends with nHashType as a 4-byte LE word; for SIGHASH_ALL|
-// FORKID that word is 0x41 00 00 00. assertSighashType builds this word per flag.
-
-/**
- * Assert the spend is SIGHASH_ALL|FORKID (0x41). Pre/Post: top of stack = preimage
- * (left untouched). These covenants read fixed offsets (104 / 52 / 40) that are
- * meaningful only for the 0x41 layout, and the OP_PUSH_TX core already pins the
- * flag implicitly (its synthetic sig carries 0x41, so OP_CHECKSIG only accepts a
- * preimage hashing to the 0x41 sighash). Note the offsets themselves are invariant
- * in the number of INPUTS — hashPrevouts/hashSequence are digests of all inputs,
- * so the preimage is the same length for 1 or N inputs; the covenant simply does
- * not constrain sibling inputs, by design. What it does assume is a single
- * recreated OUTPUT (HASH256(nextOutput) == hashOutputs). This guard makes the
- * flag assumption explicit and fails fast — and survives any refactor of the core.
- */
-function assertSighashAll (script) {
-  return assertSighashType(script, SIGHASH)
-}
-
-/**
- * Assert the spend uses a specific SIGHASH flag. Pre/Post: top of stack = preimage
- * (left untouched). The BIP-143 preimage's trailing 4-byte LE nHashType word must
- * equal `sighashType`. Use with pushTxCore({ sighashType }) + grind({ sighashType })
- * to build covenants under SIGHASH_SINGLE|ANYONECANPAY (marketplace) etc.
- */
-function assertSighashType (script, sighashType) {
-  var word = Buffer.from([sighashType & 0xff, 0x00, 0x00, 0x00])
-  script.add(Opcode.OP_DUP).add(scriptNum(4)).add(Opcode.OP_RIGHT)
-    .add(word).add(Opcode.OP_EQUALVERIFY)
-  return script
-}
-
-/** BIP-143 hashOutputs (SIGHASH_ALL) for a set of Transaction.Output objects. */
-function hashOutputs (outputs) {
-  var ser = Buffer.concat(outputs.map(function (o) { return o.toBufferWriter().toBuffer() }))
-  return Hash.sha256sha256(ser)
-}
-
-/**
- * Value/output covenant: the spend is valid only if its outputs hash to
- * `expectedHashOutputs` — coins can only go where the covenant says.
- */
-function valueCovenant (expectedHashOutputs) {
-  var script = new Script().add(Opcode.OP_DUP)
-  pushTxCore(script)
-  script.add(Opcode.OP_VERIFY)
-  extractHashOutputs(script)
-  script.add(Buffer.from(expectedHashOutputs)).add(Opcode.OP_EQUAL)
-  return script
-}
-
-// floor(n/2) — the canonical low-S boundary (matches Signature.hasLowS()).
-var HALF_N = new BN('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 'hex')
-
-/**
- * Compute s = (HASH256(preimage)+Gx) mod n; return its 32-byte BE form, or null
- * if the resulting signature would not be a clean, CANONICAL (low-S) DER.
- * Requiring s <= n/2 makes the in-script signature non-malleable and standard,
- * so it passes nodes enforcing SCRIPT_VERIFY_LOW_S — at zero script-size cost
- * (the burden is on the spender's grind, not extra opcodes).
- */
-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)
-  // NOT s.toBuffer('be', 32): lib/crypto/bn.js REPLACES toBuffer with an
-  // options-object form, so 'be' would land in `opts`, opts.size would be
-  // undefined and the 32 ignored — yielding a natural-length buffer.
-  //
-  // That truncation is currently UNREACHABLE, and the reason is worth writing
-  // down because it is not obvious: z is filtered to a leading byte of
-  // 0x01..0x7f above, so z is in [2**248, 2**255); adding Gx (~0.476 * 2**256)
-  // never wraps; and the low-S check caps the result at n/2. s therefore lands
-  // in a narrow band with a leading byte of 0x7a..0x7f and is always 32 bytes.
-  //
-  // The call is still wrong, and worth fixing, because that safety is an
-  // accident of two filters that have nothing to do with buffer length. Widen
-  // the MINIMALDATA range or drop low-S and the truncation becomes reachable —
-  // silently, inside a covenant, where DER_PREFIX declares s to be exactly 32
-  // bytes and a short one makes the spend invalid.
-  var sBE = s.toBuffer({ size: 32 })
-  return (sBE[0] >= 0x01) ? sBE : null // s <= n/2 already guarantees sBE[0] <= 0x7f
-}
-
-/**
- * Grind a malleable field of the spend until the in-script OP_PUSH_TX signature
- * is a clean, canonical (low-S) fixed-length DER. Returns { preimage, tries,
- * field, nonce }; mutates the chosen field on `spend`.
- *
- * @param {object} [opts] grind options (a bare number is accepted as legacy maxTries):
- *   - maxTries {number}  attempts before giving up (default 5000).
- *   - start    {number}  first nonce value to try (default 0).
- *   - field    {'nLockTime'|'sequence'}  which field carries the grind nonce
- *       (default 'nLockTime'). Use 'sequence' when the covenant pins nLockTime for
- *       a real CLTV absolute timelock: the input's sequence is swept down from
- *       0xfffffffe (kept non-final, so CLTV still triggers) instead of clobbering
- *       nLockTime. (Not for CSV/relative-locktime covenants, which encode meaning
- *       in the sequence number itself.)
- */
-function grind (spend, inputIndex, lockingScript, satoshis, opts) {
-  if (typeof opts === 'number') opts = { maxTries: opts } // back-compat: legacy maxTries arg
-  opts = opts || {}
-  var maxTries = opts.maxTries || 5000
-  var start = opts.start || 0
-  var field = opts.field || 'nLockTime'
-  var sighashType = opts.sighashType || SIGHASH
-  if (field !== 'nLockTime' && field !== 'sequence') {
-    throw new Error("grind field must be 'nLockTime' or 'sequence'")
-  }
-  var input = spend.inputs[inputIndex]
-  for (var i = 0; i < maxTries; i++) {
-    var nonce = start + i
-    if (field === 'nLockTime') spend.nLockTime = nonce
-    else input.sequenceNumber = 0xfffffffe - nonce // stay < 0xffffffff (non-final)
-    var preimage = H.rawPreimage(spend, inputIndex, lockingScript, satoshis, sighashType)
-    // Length-checked, not truthy: grind's contract is a FIXED-length DER
-    // signature, and a short s would be truthy. Belt-and-braces alongside the
-    // toBuffer fix above — this is the check that would catch it if the
-    // upstream filters that currently make a short s impossible ever change.
-    var sBE = sFromPreimage(preimage)
-    if (sBE && sBE.length === 32) return { preimage: preimage, tries: i + 1, field: field, nonce: nonce }
-  }
-  throw new Error('OP_PUSH_TX grind failed after ' + maxTries + ' tries')
-}
-
-module.exports = {
-  Gx: Gx,
-  N: N,
-  PUBKEY: PUBKEY,
-  gxLe: gxLe,
-  N_LE: N_LE,
-  DER_PREFIX: DER_PREFIX,
-  reverseBytes: reverseBytes,
-  pushTxCore: pushTxCore,
-  authenticator: authenticator,
-  extractHashOutputs: extractHashOutputs,
-  assertSighashAll: assertSighashAll,
-  assertSighashType: assertSighashType,
-  SIGHASH_ALL_FORKID: SIGHASH_ALL_FORKID,
-  SIGHASH_SINGLE_FORKID: SIGHASH_SINGLE_FORKID,
-  SIGHASH_SINGLE_ANYONECANPAY_FORKID: SIGHASH_SINGLE_ANYONECANPAY_FORKID,
-  SIGHASH_ALL_ANYONECANPAY_FORKID: SIGHASH_ALL_ANYONECANPAY_FORKID,
-  hashOutputs: hashOutputs,
-  valueCovenant: valueCovenant,
-  sFromPreimage: sFromPreimage,
-  grind: grind
-}
+// Moved to lib/covenant/pushtx.js.
+//
+// lib/ordinals needs these primitives too, and importing them from
+// lib/smart_contract was the only dependency from core code into the
+// application layer. This path is retained because deep imports
+// (require('@smartledger/bsv/lib/smart_contract/pushtx')) are public API via
+// the package.json exports map.
+module.exports = require('../covenant/pushtx')