@smartledger/bsv 7.8.1 → 7.10.0

package/lib/mnemonic/errors.js

@@ -15,4 +15,4 @@ var spec = {
   }]
 }
 
-module.exports = require('../../').errors.extend(spec)
+module.exports = require('../errors').extend(spec)

package/lib/mnemonic/index.js

@@ -1,4 +1,5 @@
-var bsv = require('../../')
-bsv.Mnemonic = require('./mnemonic')
-
-module.exports = bsv.Mnemonic
+// Previously this module required the package root and registered itself onto
+// it (`bsv.Mnemonic = require('./mnemonic')`), which made lib/ depend on
+// index.js. The registration was redundant — index.js assigns bsv.Mnemonic
+// itself — so this is now a plain re-export.
+module.exports = require('./mnemonic')

package/lib/mnemonic/mnemonic.js

@@ -1,17 +1,20 @@
 'use strict'
 
-var bsv = require('../../')
-var BN = bsv.crypto.BN
+var HDPrivateKey = require('../hdprivatekey')
+var BN = require('../crypto/bn')
 var unorm = require('unorm')
-var _ = bsv.deps._
+var _ = require('../util/_')
 
 var pbkdf2 = require('./pbkdf2')
 var errors = require('./errors')
+// Named bsvErrors, not errors: `errors` above is this module's OWN error set.
+// The library-wide errors module is a different object and must not shadow it.
+var bsvErrors = require('../errors')
 
-var Hash = bsv.crypto.Hash
-var Random = bsv.crypto.Random
+var Hash = require('../crypto/hash')
+var Random = require('../crypto/random')
 
-var $ = bsv.util.preconditions
+var $ = require('../util/preconditions')
 
 /**
  * This is an immutable class that represents a BIP39 Mnemonic code.
@@ -53,7 +56,7 @@ var Mnemonic = function (data, wordlist) {
   } else if (_.isNumber(data)) {
     ent = data
   } else if (data) {
-    throw new bsv.errors.InvalidArgument('data', 'Must be a Buffer, a string or an integer')
+    throw new bsvErrors.InvalidArgument('data', 'Must be a Buffer, a string or an integer')
   }
   ent = ent || 128
 
@@ -73,7 +76,7 @@ var Mnemonic = function (data, wordlist) {
     throw new errors.InvalidMnemonic(phrase)
   }
   if (ent % 32 !== 0 || ent < 128) {
-    throw new bsv.errors.InvalidArgument('ENT', 'Values must be ENT > 128 and ENT % 32 == 0')
+    throw new bsvErrors.InvalidArgument('ENT', 'Values must be ENT > 128 and ENT % 32 == 0')
   }
 
   phrase = phrase || Mnemonic._mnemonic(ent, wordlist)
@@ -241,7 +244,7 @@ Mnemonic.fromSeed = function (seed, wordlist) {
  */
 Mnemonic.prototype.toHDPrivateKey = function (passphrase, network) {
   var seed = this.toSeed(passphrase)
-  return bsv.HDPrivateKey.fromSeed(seed, network)
+  return HDPrivateKey.fromSeed(seed, network)
 }
 
 /**
@@ -329,6 +332,15 @@ Mnemonic._entropyChecksum = function (entropy) {
   return checksum
 }
 
-Mnemonic.bsv = bsv
+// Back-reference to the whole library, preserved as public API. Defined as a
+// lazy getter rather than `Mnemonic.bsv = require('../../')`: this module is
+// loaded while index.js is still initializing, so an eager require would
+// capture a half-built namespace. Resolving on first access defers it past
+// load and removes the module-init cycle.
+Object.defineProperty(Mnemonic, 'bsv', {
+  configurable: true,
+  enumerable: true,
+  get: function () { return require('../../') }
+})
 
 module.exports = Mnemonic

package/lib/ordinals/bsv20.js

@@ -17,6 +17,8 @@
  * are never coerced to JS numbers. `dec` (decimals, 0–18) scales display only.
  */
 var inscription = require('./inscription')
+var Script = require('../script')
+var Output = require('../transaction/output')
 
 var CONTENT_TYPE = 'application/bsv-20'
 var MAX_DEC = 18
@@ -261,8 +263,7 @@ function buildDeployMint (params) {
 }
 
 function outputFor (script, satoshis) {
-  var bsv = require('../..')
-  return new bsv.Transaction.Output({ script: script, satoshis: satoshis != null ? satoshis : 1 })
+  return new Output({ script: script, satoshis: satoshis != null ? satoshis : 1 })
 }
 
 /** 1-sat Output helpers mirroring the builders. */
@@ -276,8 +277,7 @@ function createAuthOutput (params) { return outputFor(buildAuth(params), params
 
 /** Extract the JSON body from a locking script, a JSON string, a Buffer, or an object. */
 function bodyOf (input) {
-  var bsv = require('../..')
-  if (input && typeof input === 'object' && !Buffer.isBuffer(input) && !(input instanceof bsv.Script)) {
+  if (input && typeof input === 'object' && !Buffer.isBuffer(input) && !(input instanceof Script)) {
     return input // already a parsed object
   }
   if (typeof input === 'string' && input.trim()[0] === '{') return input // raw JSON string

package/lib/ordinals/inscription.js

@@ -16,13 +16,13 @@
  *
  * This matches the widely-used 1Sat Ordinals format (js-1sat-ord).
  */
-var bsv = require('../..')
+var Script = require('../script')
+var Opcode = require('../opcode')
+var Address = require('../address')
+var Output = require('../transaction/output')
 
 var ORD = Buffer.from('ord', 'utf8')
 
-function scriptClass () { return bsv.Script }
-function op () { return bsv.Opcode }
-
 /** Describe a rejected value for an error message, without dumping its contents. */
 function typeName (v) {
   if (v === null) return 'null'
@@ -50,7 +50,6 @@ var CONTENT_ALIASES = ['data', 'body', 'payload', 'text', 'message']
 
 /** Resolve a base locking script from a Script, an Address, or an address string. */
 function resolveLock (params) {
-  var Script = scriptClass()
   var hasLock = params.lock != null
   var hasAddress = params.address != null
 
@@ -81,9 +80,9 @@ function resolveLock (params) {
   }
 
   if (hasAddress) {
-    var addr = (params.address instanceof bsv.Address)
+    var addr = (params.address instanceof Address)
       ? params.address
-      : bsv.Address.fromString(String(params.address))
+      : Address.fromString(String(params.address))
     return Script.buildPublicKeyHashOut(addr)
   }
 
@@ -111,7 +110,6 @@ function resolveLock (params) {
  */
 function buildInscription (params) {
   params = params || {}
-  var Opcode = op()
   var lock = resolveLock(params)
 
   if (params.content == null) {
@@ -137,7 +135,7 @@ function buildInscription (params) {
   }
 
   // Clone the base lock so we never mutate the caller's Script.
-  var s = scriptClass().fromBuffer(lock.toBuffer())
+  var s = Script.fromBuffer(lock.toBuffer())
   s.add(Opcode.OP_FALSE)
   s.add(Opcode.OP_IF)
   s.add(ORD)
@@ -168,8 +166,6 @@ function chunkIsOp (chunk, opcodenum) {
  *   null if the script carries no inscription envelope.
  */
 function parseInscription (script) {
-  var Script = scriptClass()
-  var Opcode = op()
   var s = (script instanceof Script) ? script
     : Buffer.isBuffer(script) ? Script.fromBuffer(script)
       : Script.fromHex(script)
@@ -235,7 +231,7 @@ function createInscriptionOutput (params) {
   if (typeof satoshis !== 'number' || !Number.isInteger(satoshis) || satoshis < 1) {
     throw new Error('satoshis must be a positive integer (1 for a standard 1Sat ordinal)')
   }
-  return new bsv.Transaction.Output({
+  return new Output({
     script: buildInscription(params),
     satoshis: satoshis
   })

package/lib/ordinals/ordlock.js

@@ -37,14 +37,19 @@
  *
  * Requires post-Genesis limits: call SmartContract.enableGenesis() before verifying.
  */
-var bsv = require('../..')
-var P = require('../smart_contract/pushtx')
-var H = require('../smart_contract/covenant_helpers')
+var P = require('../covenant/pushtx')
+var H = require('../covenant/helpers')
 var inscription = require('./inscription')
 
-var Script = bsv.Script
-var Opcode = bsv.Opcode
-var BufferReader = bsv.encoding.BufferReader
+var Script = require('../script')
+var Opcode = require('../opcode')
+var Address = require('../address')
+var PublicKey = require('../publickey')
+var Hash = require('../crypto/hash')
+var Transaction = require('../transaction')
+var Input = require('../transaction/input')
+var Output = require('../transaction/output')
+var BufferReader = require('../encoding/bufferreader')
 
 // OrdLock commits to the FULL output set (so payments can be pinned) but leaves the
 // input set open for the buyer's funding — SIGHASH_ALL|ANYONECANPAY|FORKID (0xc1).
@@ -73,9 +78,9 @@ function coerceScript (v) {
 
 /** Coerce an Address, PublicKey, PrivateKey, or address string to an Address. */
 function toAddress (v) {
-  if (v instanceof bsv.Address) return v
+  if (v instanceof Address) return v
   if (v && typeof v.toAddress === 'function') return v.toAddress() // PublicKey / PrivateKey
-  return bsv.Address.fromString(String(v))
+  return Address.fromString(String(v))
 }
 
 /** Resolve a 20-byte HASH160 owner commitment from an Address/PublicKey/key or 20-byte Buffer. */
@@ -84,7 +89,7 @@ function resolvePubKeyHash (owner) {
     if (owner.length !== 20) throw new Error('seller pubkeyhash buffer must be 20 bytes (HASH160)')
     return owner
   }
-  if (owner instanceof bsv.PublicKey) return bsv.crypto.Hash.sha256ripemd160(owner.toBuffer())
+  if (owner instanceof PublicKey) return Hash.sha256ripemd160(owner.toBuffer())
   return toAddress(owner).hashBuffer
 }
 
@@ -95,15 +100,15 @@ function resolvePubKeyHash (owner) {
  */
 function payOutputFor (payTo, price) {
   assertSats(price, 'payment price')
-  return new bsv.Transaction.Output({
+  return new Output({
     script: Script.buildPublicKeyHashOut(toAddress(payTo)), satoshis: price
   })
 }
 
 /** Coerce one payment spec to a Transaction.Output. */
 function outputFromSpec (spec) {
-  if (spec instanceof bsv.Transaction.Output) return spec
-  if (Buffer.isBuffer(spec)) return bsv.Transaction.Output.fromBufferReader(new BufferReader(spec))
+  if (spec instanceof Output) return spec
+  if (Buffer.isBuffer(spec)) return Output.fromBufferReader(new BufferReader(spec))
   var to = spec.payTo != null ? spec.payTo : spec.address
   var amt = spec.satoshis != null ? spec.satoshis : spec.price
   if (to == null || amt == null) throw new Error('payment spec needs {address|payTo, satoshis|price}')
@@ -125,7 +130,7 @@ function resolvePayOutputs (params) {
   if (params.price != null) {
     var payTo = params.payTo != null ? params.payTo : params.seller
     // A pre-built Output as payTo is used verbatim (its own value); otherwise build P2PKH(price).
-    var first = (payTo instanceof bsv.Transaction.Output) ? payTo : payOutputFor(payTo, params.price)
+    var first = (payTo instanceof Output) ? payTo : payOutputFor(payTo, params.price)
     var arr = [first]
     if (params.royalties) params.royalties.forEach(function (r) { arr.push(outputFromSpec(r)) })
     return arr
@@ -199,7 +204,7 @@ function chunkIsOp (chunk, opcodenum) {
 function splitPayBlob (blob) {
   var br = new BufferReader(blob)
   var outs = []
-  while (!br.eof()) outs.push(bsv.Transaction.Output.fromBufferReader(br))
+  while (!br.eof()) outs.push(Output.fromBufferReader(br))
   return outs
 }
 
@@ -296,7 +301,7 @@ function parseOrdLock (script, opts) {
     if (rebuilt.toHex() !== s.toHex()) return null
 
     return {
-      seller: { pubKeyHash: sellerPKH, address: bsv.Address.fromPublicKeyHash(sellerPKH, network).toString() },
+      seller: { pubKeyHash: sellerPKH, address: Address.fromPublicKeyHash(sellerPKH, network).toString() },
       payOutputs: payOutputs,
       payBlob: payBlob,
       totalPrice: totalPrice,
@@ -317,7 +322,7 @@ function isOrdLock (script, opts) { return parseOrdLock(script, opts) !== null }
 function listInscriptionOutput (params) {
   params = params || {}
   var satoshis = params.satoshis != null ? params.satoshis : 1
-  return new bsv.Transaction.Output({ script: buildOrdLock(params), satoshis: satoshis })
+  return new Output({ script: buildOrdLock(params), satoshis: satoshis })
 }
 
 /**
@@ -426,7 +431,7 @@ function cancel (params) {
 
 /** Add an input spending `outpoint` under `script` worth `satoshis`, script-sig empty. */
 function addSpendInput (tx, outpoint, script, satoshis) {
-  tx.addInput(new bsv.Transaction.Input({
+  tx.addInput(new Input({
     prevTxId: outpoint.txid || outpoint.prevTxId,
     outputIndex: outpoint.outputIndex != null ? outpoint.outputIndex : outpoint.vout,
     script: Script.empty()
@@ -479,11 +484,11 @@ function buildListingTx (params) {
     throw new Error('buildListingTx: insufficient funding — need ' + fee + ' sat fee, funded ' + fundingTotal)
   }
 
-  var tx = new bsv.Transaction()
+  var tx = new Transaction()
   addSpendInput(tx, ordinal, ordinal.script, ordSats) // input 0 = the ordinal (P2PKH)
   funding.forEach(function (f) { addSpendInput(tx, f, f.script, f.satoshis) })
 
-  tx.addOutput(new bsv.Transaction.Output({ script: lock, satoshis: ordSats })) // output 0 = listing
+  tx.addOutput(new Output({ script: lock, satoshis: ordSats })) // output 0 = listing
   if (change > 0) {
     tx.addOutput(payOutputFor(params.changeAddress || ordinal.privateKey.toAddress(), change))
   }
@@ -533,7 +538,7 @@ function buildPurchaseTx (params) {
   var payOuts = params.payOutputs
     ? params.payOutputs.map(outputFromSpec)
     : parsed.payOutputs.map(function (p) {
-      return new bsv.Transaction.Output({ script: p.script, satoshis: p.satoshis })
+      return new Output({ script: p.script, satoshis: p.satoshis })
     })
   var paidTotal = payOuts.reduce(function (a, o) { return a + o.satoshis }, 0)
 
@@ -545,7 +550,7 @@ function buildPurchaseTx (params) {
       ' sat (payments ' + paidTotal + ' + fee ' + fee + '), funded ' + fundingTotal)
   }
 
-  var tx = new bsv.Transaction()
+  var tx = new Transaction()
   addSpendInput(tx, listing, lockingScript, ordSats) // input 0 = the listing (covenant)
   params.funding.forEach(function (f) { addSpendInput(tx, f, f.script, f.satoshis) })
 

package/lib/script/interpreter.js

@@ -728,6 +728,13 @@ function padBufferToSize (buf, len) {
  * Based on the inner loop of bitcoind's EvalScript function
  * bitcoind commit: b5d1b1092998bc95313856d535c632ea5a8f9104
  */
+/** The transaction version as the four little-endian bytes Chronicle compares. */
+function versionLE (version) {
+  var buf = Buffer.alloc(4)
+  buf.writeInt32LE(version | 0, 0)
+  return buf
+}
+
 Interpreter.prototype.step = function () {
   var self = this
 
@@ -1044,7 +1051,19 @@ Interpreter.prototype.step = function () {
         break
 
       case Opcode.OP_VER:
-        // Chronicle: pushes the executing transaction's version.
+        // Chronicle: pushes the transaction version as FOUR LITTLE-ENDIAN
+        // BYTES, not as a script number. The node is:
+        //
+        //   const auto tx_version{checker.Version()};
+        //   std::vector<uint8_t> val(sizeof(tx_version));
+        //   to_le(tx_version, val.data());
+        //   stack.push_back(std::move(val));
+        //
+        // A script number pushes `01` for version 1 where the node pushes
+        // `01000000`, so anything consuming the value diverges.
+        //
+        // Unlike the string opcodes, BAD_OPCODE pre-Chronicle IS correct here —
+        // the node returns it unconditionally.
         if ((this.flags & Interpreter.SCRIPT_ENABLE_CHRONICLE) === 0) {
           this.errstr = 'SCRIPT_ERR_BAD_OPCODE'
           return false
@@ -1053,18 +1072,26 @@ Interpreter.prototype.step = function () {
           this.errstr = 'SCRIPT_ERR_UNKNOWN_ERROR'
           return false
         }
-        this.stack.push(new BN(this.tx.version).toScriptNumBuffer())
+        this.stack.push(versionLE(this.tx.version))
         break
 
       case Opcode.OP_VERIF:
       case Opcode.OP_VERNOTIF:
-        // Chronicle: an IF whose condition is "top of stack equals the executing
-        // transaction's version", closed by OP_ENDIF.
+        // Chronicle: an IF whose condition is "top of stack equals the
+        // transaction version", closed by OP_ENDIF.
         //
-        // Before Chronicle these are invalid EVEN IN AN UNEXECUTED BRANCH — a rule
-        // Bitcoin applies to no other opcode — so the flag check deliberately sits
-        // OUTSIDE the fExec guard below, which preserves that.
+        //   if(!utxo_after_chronicle) {
+        //     if(utxo_after_genesis && !fExec) break;
+        //     else return SCRIPT_ERR_BAD_OPCODE;
+        //   }
+        //
+        // So pre-Chronicle they are an error only in an EXECUTED branch. BSV is
+        // post-Genesis, which is the whole condition. Returning BAD_OPCODE
+        // unconditionally rejected scripts the network accepts.
         if ((this.flags & Interpreter.SCRIPT_ENABLE_CHRONICLE) === 0) {
+          if (!fExec) {
+            break
+          }
           this.errstr = 'SCRIPT_ERR_BAD_OPCODE'
           return false
         }
@@ -1078,12 +1105,16 @@ Interpreter.prototype.step = function () {
             this.errstr = 'SCRIPT_ERR_UNKNOWN_ERROR'
             return false
           }
-          // Popping mirrors OP_IF. The spec describes the comparison but not the
-          // stack effect; the OP_VERIF ... OP_ENDIF form it documents is an IF, and
-          // an IF that left its condition behind would unbalance every script using
-          // it. Pinned by its own test so a correction shows up as a diff.
-          bn = BN.fromScriptNumBuffer(stacktop(-1), fRequireMinimal)
-          fValue = bn.cmp(new BN(this.tx.version)) === 0
+          // BYTE-WISE against the 4-byte little-endian version, not a numeric
+          // compare. An operand of any other length simply yields false — it is
+          // NOT an error — so `OP_2 OP_VERIF` against version 2 is false, where
+          // a numeric comparison made it true. The idiomatic form is
+          // `OP_VER OP_VERIF`.
+          //
+          // MINIMALIF deliberately does not apply: the node guards it with
+          // `(opcode == OP_IF || opcode == OP_NOTIF) && VerifyMinimalIf(flags)`.
+          buf = stacktop(-1)
+          fValue = buf.length === 4 && buf.equals(versionLE(this.tx.version))
           if (opcodenum === Opcode.OP_VERNOTIF) {
             fValue = !fValue
           }
@@ -1953,21 +1984,39 @@ Interpreter.prototype.step = function () {
 
       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.
+        // (in size -- out)  Chronicle, ported from SV Node.
+        // Pre-Chronicle these bytes are UPGRADABLE NOPS on the network — they were
+        // OP_NOP4/OP_NOP5/OP_NOP6 — so the node breaks rather than erroring:
+        //
+        //   if(!utxo_after_chronicle) {
+        //     if(flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
+        //       return SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS;
+        //     else break;
+        //   }
+        //
+        // Running them unconditionally consumed stack where the network does
+        // nothing, which is a wrong answer rather than an error.
+        if ((this.flags & Interpreter.SCRIPT_ENABLE_CHRONICLE) === 0) {
+          if (this.flags & Interpreter.SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS) {
+            this.errstr = 'SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS'
+            return false
+          }
+          break
+        }
+
         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) {
+        n = BN.fromScriptNumBuffer(stacktop(-1), fRequireMinimal, Interpreter.MAXIMUM_ELEMENT_SIZE).toNumber()
+        // ERRORS on out of range; it does not clamp. The node is
+        // `if(len < 0 || len > size) return SCRIPT_ERR_INVALID_NUMBER_RANGE`.
+        // Clamping made scripts the node rejects succeed here.
+        if (n < 0 || n > buf1.length) {
           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)
@@ -1977,25 +2026,41 @@ Interpreter.prototype.step = function () {
         break
 
       case Opcode.OP_SUBSTR:
-        // (in begin size -- out)  out = in[begin : begin + size]
-        // Re-enabled string opcode (BSV Chronicle). Original Satoshi semantics.
+        // (in begin size -- out)  Chronicle, ported from SV Node.
+        // Pre-Chronicle these bytes are UPGRADABLE NOPS on the network — they were
+        // OP_NOP4/OP_NOP5/OP_NOP6 — so the node breaks rather than erroring:
+        //
+        //   if(!utxo_after_chronicle) {
+        //     if(flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
+        //       return SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS;
+        //     else break;
+        //   }
+        //
+        // Running them unconditionally consumed stack where the network does
+        // nothing, which is a wrong answer rather than an error.
+        if ((this.flags & Interpreter.SCRIPT_ENABLE_CHRONICLE) === 0) {
+          if (this.flags & Interpreter.SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS) {
+            this.errstr = 'SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS'
+            return false
+          }
+          break
+        }
+
         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) {
+        var subSize = BN.fromScriptNumBuffer(stacktop(-1), fRequireMinimal, Interpreter.MAXIMUM_ELEMENT_SIZE).toNumber()
+        var subBegin = BN.fromScriptNumBuffer(stacktop(-2), fRequireMinimal, Interpreter.MAXIMUM_ELEMENT_SIZE).toNumber()
+        // ERRORS on out of range, matching
+        //   offset < 0 || offset >= size || len < 0 || len > size - offset
+        // Note `offset >= size` is strict: a begin index AT the end is an
+        // error, not an empty result.
+        if (subBegin < 0 || subBegin >= buf1.length || subSize < 0 || subSize > buf1.length - subBegin) {
           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)

package/lib/smart_contract/authorizers.js

@@ -28,16 +28,18 @@
  * always just a 20-byte value the covenant splices into the recreated scriptCode.
  */
 
-var bsv = require('../..')
+var PrivateKey = require('../privatekey')
+var PublicKey = require('../publickey')
+var Script = require('../script')
 var Hash = require('../crypto/hash')
-var H = require('./covenant_helpers')
+var H = require('../covenant/helpers')
 
-var Opcode = bsv.Opcode
+var Opcode = require('../opcode')
 var n = H.scriptNum
 
 function pubBuffer (key) {
-  if (key instanceof bsv.PrivateKey) return key.toPublicKey().toBuffer()
-  if (key instanceof bsv.PublicKey) return key.toBuffer()
+  if (key instanceof PrivateKey) return key.toPublicKey().toBuffer()
+  if (key instanceof PublicKey) return key.toBuffer()
   return key // already a Buffer
 }
 
@@ -71,7 +73,7 @@ function singleKey () {
 function redeemScript (m, pubkeys) {
   var nn = pubkeys.length
   if (m < 1 || m > nn || nn < 1 || nn > 16) throw new Error('multisig requires 1 <= m <= n <= 16')
-  var s = new bsv.Script().add(Opcode['OP_' + m])
+  var s = new Script().add(Opcode['OP_' + m])
   pubkeys.forEach(function (p) { s.add(Buffer.from(p)) }) // each emitted as 0x21||pk (33-byte push)
   s.add(Opcode['OP_' + nn]).add(Opcode.OP_CHECKMULTISIG)
   return s.toBuffer()