@smartledger/bsv 7.8.1 → 7.10.0

package/lib/smart_contract/script_tester.js

@@ -15,7 +15,13 @@
 
 'use strict'
 
-var bsv = require('../..')
+var Output = require('../transaction/output')
+var Input = require('../transaction/input')
+var Interpreter = require('../script/interpreter')
+var BN = require('../crypto/bn')
+var Transaction = require('../transaction')
+var Opcode = require('../opcode')
+var Script = require('../script')
 
 /**
  * ScriptTester Class - Local script execution and debugging
@@ -27,7 +33,7 @@ function ScriptTester(options) {
   }
 
   this.options = options || {}
-  this.flags = this.options.flags || bsv.Script.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
+  this.flags = this.options.flags || Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
   this.satoshis = this.options.satoshis || 100000
 }
 
@@ -44,8 +50,8 @@ ScriptTester.prototype.execute = function(config) {
   var tx = this._createDummyTransaction()
   
   // Create interpreter
-  var interpreter = new bsv.Script.Interpreter()
-  var satoshisBN = new bsv.crypto.BN(this.satoshis)
+  var interpreter = new Interpreter()
+  var satoshisBN = new BN(this.satoshis)
   
   try {
     var verified = interpreter.verify(
@@ -86,7 +92,7 @@ ScriptTester.prototype.debug = function(config) {
   var combinedScript = this._createCombinedScript(config)
   var tx = this._createDummyTransaction()
   
-  var interpreter = new bsv.Script.Interpreter()
+  var interpreter = new Interpreter()
   interpreter.script = combinedScript
   interpreter.tx = tx
   interpreter.nIn = 0
@@ -98,7 +104,7 @@ ScriptTester.prototype.debug = function(config) {
   try {
     for (var i = 0; i < chunks.length; i++) {
       var chunk = chunks[i]
-      var opname = bsv.Opcode.reverseMap[chunk.opcodenum] || 'PUSH'
+      var opname = Opcode.reverseMap[chunk.opcodenum] || 'PUSH'
       
       // Capture state before execution
       var beforeStack = interpreter.stack.map(function(b) { return b.toString('hex') })
@@ -230,7 +236,7 @@ ScriptTester.prototype.testFieldExtraction = function(preimageHex, fieldName) {
  * @private
  */
 ScriptTester.prototype._parseScript = function(input) {
-  if (!input) return new bsv.Script()
+  if (!input) return new Script()
   
   var trimmed = input.trim()
   var isHex = /^[0-9a-fA-F]+$/.test(trimmed.replace(/\s+/g, ''))
@@ -241,13 +247,13 @@ ScriptTester.prototype._parseScript = function(input) {
       var hexLength = trimmed.length / 2
       if (hexLength >= 180 && hexLength <= 250) {
         // This is likely preimage data - create a script that pushes it
-        return new bsv.Script().add(Buffer.from(trimmed, 'hex'))
+        return new Script().add(Buffer.from(trimmed, 'hex'))
       } else {
         // Normal hex script
-        return bsv.Script.fromHex(trimmed)
+        return Script.fromHex(trimmed)
       }
     } else {
-      return bsv.Script.fromASM(trimmed)
+      return Script.fromASM(trimmed)
     }
   } catch (error) {
     throw new Error('Failed to parse script: ' + error.message)
@@ -271,7 +277,7 @@ ScriptTester.prototype._createCombinedScript = function(config) {
     lockingScript.toBuffer()
   ])
   
-  return bsv.Script.fromBuffer(combinedBuffer)
+  return Script.fromBuffer(combinedBuffer)
 }
 
 /**
@@ -279,24 +285,24 @@ ScriptTester.prototype._createCombinedScript = function(config) {
  * @private
  */
 ScriptTester.prototype._createDummyTransaction = function() {
-  var tx = new bsv.Transaction()
+  var tx = new Transaction()
   
   // Create dummy input
-  var dummyInput = new bsv.Transaction.Input({
+  var dummyInput = new Input({
     prevTxId: '0'.repeat(64),
     outputIndex: 0,
-    script: bsv.Script.empty(),
+    script: Script.empty(),
     satoshis: this.satoshis,
-    output: new bsv.Transaction.Output({
+    output: new Output({
       satoshis: this.satoshis,
-      script: bsv.Script.empty()
+      script: Script.empty()
     })
   })
   
   tx.addInput(dummyInput)
-  tx.addOutput(new bsv.Transaction.Output({ 
+  tx.addOutput(new Output({ 
     satoshis: this.satoshis, 
-    script: bsv.Script.empty() 
+    script: Script.empty() 
   }))
   
   return tx

package/lib/smart_contract/script_utils.js

@@ -15,7 +15,8 @@
 
 'use strict'
 
-const bsv = require('../..')
+var Opcode = require('../opcode')
+var Script = require('../script')
 
 /**
  * Script Format Conversion Utilities
@@ -23,7 +24,7 @@ const bsv = require('../..')
 
 function scriptToASM(scriptBuffer) {
   if (Buffer.isBuffer(scriptBuffer)) {
-    const script = bsv.Script.fromBuffer(scriptBuffer)
+    const script = Script.fromBuffer(scriptBuffer)
     return script.toASM()
   } else if (scriptBuffer && typeof scriptBuffer.toASM === 'function') {
     return scriptBuffer.toASM()
@@ -33,7 +34,7 @@ function scriptToASM(scriptBuffer) {
 
 function asmToScript(asmString) {
   try {
-    return bsv.Script.fromASM(asmString)
+    return Script.fromASM(asmString)
   } catch (error) {
     throw new Error(`Invalid ASM string: ${error.message}`)
   }
@@ -41,7 +42,7 @@ function asmToScript(asmString) {
 
 function asmToHex(asmString) {
   try {
-    const script = bsv.Script.fromASM(asmString)
+    const script = Script.fromASM(asmString)
     return script.toBuffer().toString('hex')
   } catch (error) {
     throw new Error(`Cannot convert ASM to hex: ${error.message}`)
@@ -51,7 +52,7 @@ function asmToHex(asmString) {
 function hexToASM(hexString) {
   try {
     const buffer = Buffer.from(hexString, 'hex')
-    const script = bsv.Script.fromBuffer(buffer)
+    const script = Script.fromBuffer(buffer)
     return script.toASM()
   } catch (error) {
     throw new Error(`Cannot convert hex to ASM: ${error.message}`)
@@ -73,7 +74,7 @@ function scriptToHex(script) {
 
 function validateASM(asmString) {
   try {
-    bsv.Script.fromASM(asmString)
+    Script.fromASM(asmString)
     return { valid: true, error: null }
   } catch (error) {
     return { valid: false, error: error.message }
@@ -84,9 +85,9 @@ function validateScript(script) {
   try {
     let scriptObj
     if (typeof script === 'string') {
-      scriptObj = bsv.Script.fromASM(script)
+      scriptObj = Script.fromASM(script)
     } else if (Buffer.isBuffer(script)) {
-      scriptObj = bsv.Script.fromBuffer(script)
+      scriptObj = Script.fromBuffer(script)
     } else if (script && typeof script.toBuffer === 'function') {
       scriptObj = script
     } else {
@@ -123,7 +124,7 @@ function validateSyntax(asmString) {
     const op = operations[i]
     
     // Check for unknown opcodes
-    if (op.startsWith('OP_') && !bsv.Opcode.map[op]) {
+    if (op.startsWith('OP_') && !Opcode.map[op]) {
       issues.push(`Unknown opcode: ${op} at position ${i}`)
     }
     
@@ -151,9 +152,9 @@ function estimateScriptSize(script) {
   try {
     let scriptObj
     if (typeof script === 'string') {
-      scriptObj = bsv.Script.fromASM(script)
+      scriptObj = Script.fromASM(script)
     } else if (Array.isArray(script)) {
-      scriptObj = bsv.Script.fromASM(script.join(' '))
+      scriptObj = Script.fromASM(script.join(' '))
     } else if (Buffer.isBuffer(script)) {
       return script.length
     } else if (script && typeof script.toBuffer === 'function') {
@@ -292,7 +293,7 @@ function optimizeScript(script) {
     // Create script object from optimized ASM
     let optimizedScript = null
     try {
-      optimizedScript = bsv.Script.fromASM(optimizedASM)
+      optimizedScript = Script.fromASM(optimizedASM)
     } catch (err) {
       // If we can't create a script object, that's okay
       optimizedScript = null
@@ -372,7 +373,7 @@ function compareScripts(scriptA, scriptB) {
     let bufferA, bufferB
     
     if (typeof scriptA === 'string') {
-      bufferA = bsv.Script.fromASM(scriptA).toBuffer()
+      bufferA = Script.fromASM(scriptA).toBuffer()
     } else if (Buffer.isBuffer(scriptA)) {
       bufferA = scriptA
     } else {
@@ -380,7 +381,7 @@ function compareScripts(scriptA, scriptB) {
     }
     
     if (typeof scriptB === 'string') {
-      bufferB = bsv.Script.fromASM(scriptB).toBuffer()
+      bufferB = Script.fromASM(scriptB).toBuffer()
     } else if (Buffer.isBuffer(scriptB)) {
       bufferB = scriptB
     } else {

package/lib/smart_contract/sighash.js

@@ -13,7 +13,15 @@
 
 'use strict'
 
-var bsv = require('../..')
+var Signature = require('../crypto/signature')
+var BN = require('../crypto/bn')
+var Transaction = require('../transaction')
+var PrivateKey = require('../privatekey')
+var Script = require('../script')
+// Named Sighash, not sighash: this file already uses `sighash` as a local
+// variable for a SIGHASH instance further down, and a module-scope binding of
+// the same name would be shadowed inside that function.
+var Sighash = require('../transaction/sighash')
 
 /**
  * SIGHASH Class - SIGHASH flag analysis and utilities
@@ -24,7 +32,7 @@ function SIGHASH(sighashType) {
     return new SIGHASH(sighashType)
   }
 
-  this.sighashType = sighashType || (bsv.crypto.Signature.SIGHASH_ALL | bsv.crypto.Signature.SIGHASH_FORKID)
+  this.sighashType = sighashType || (Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID)
   this.analysis = this._analyzeFlags()
 }
 
@@ -79,30 +87,30 @@ SIGHASH.prototype.getZeroHashBehavior = function() {
  */
 SIGHASH.prototype.generateExample = function() {
   // Create simple single-input transaction to avoid complex script size issues
-  var privateKey = bsv.PrivateKey.fromRandom()
+  var privateKey = PrivateKey.fromRandom()
   var address = privateKey.toAddress()
 
   // Create simple P2PKH UTXO
   var utxo = {
     txId: 'a'.repeat(64),
     outputIndex: 0,
-    script: bsv.Script.buildPublicKeyHashOut(address).toHex(),
+    script: Script.buildPublicKeyHashOut(address).toHex(),
     satoshis: 100000
   }
 
   // Create simple transaction
-  var transaction = new bsv.Transaction()
+  var transaction = new Transaction()
     .from(utxo)
     .to(address, 99000)
 
   // Generate preimage for the input with our SIGHASH type
-  var subscript = bsv.Script.fromHex(utxo.script)
-  var preimageBuffer = bsv.Transaction.sighash.sighashPreimage(
+  var subscript = Script.fromHex(utxo.script)
+  var preimageBuffer = Sighash.sighashPreimage(
     transaction,
     this.sighashType,
     0,
     subscript,
-    new bsv.crypto.BN(utxo.satoshis)
+    new BN(utxo.satoshis)
   )
 
   var Preimage = require('./preimage')
@@ -261,15 +269,15 @@ SIGHASH.prototype._analyzeFlags = function() {
  * @returns {Array} Array of SIGHASH type objects
  */
 SIGHASH.getAllTypes = function() {
-  var forkId = bsv.crypto.Signature.SIGHASH_FORKID
+  var forkId = Signature.SIGHASH_FORKID
 
   return [
-    { name: 'ALL', value: bsv.crypto.Signature.SIGHASH_ALL | forkId },
-    { name: 'NONE', value: bsv.crypto.Signature.SIGHASH_NONE | forkId },
-    { name: 'SINGLE', value: bsv.crypto.Signature.SIGHASH_SINGLE | forkId },
-    { name: 'ALL | ANYONECANPAY', value: bsv.crypto.Signature.SIGHASH_ALL | bsv.crypto.Signature.SIGHASH_ANYONECANPAY | forkId },
-    { name: 'NONE | ANYONECANPAY', value: bsv.crypto.Signature.SIGHASH_NONE | bsv.crypto.Signature.SIGHASH_ANYONECANPAY | forkId },
-    { name: 'SINGLE | ANYONECANPAY', value: bsv.crypto.Signature.SIGHASH_SINGLE | bsv.crypto.Signature.SIGHASH_ANYONECANPAY | forkId }
+    { name: 'ALL', value: Signature.SIGHASH_ALL | forkId },
+    { name: 'NONE', value: Signature.SIGHASH_NONE | forkId },
+    { name: 'SINGLE', value: Signature.SIGHASH_SINGLE | forkId },
+    { name: 'ALL | ANYONECANPAY', value: Signature.SIGHASH_ALL | Signature.SIGHASH_ANYONECANPAY | forkId },
+    { name: 'NONE | ANYONECANPAY', value: Signature.SIGHASH_NONE | Signature.SIGHASH_ANYONECANPAY | forkId },
+    { name: 'SINGLE | ANYONECANPAY', value: Signature.SIGHASH_SINGLE | Signature.SIGHASH_ANYONECANPAY | forkId }
   ]
 }
 

package/lib/smart_contract/stack_examiner.js

@@ -13,98 +13,105 @@
  */
 
 // Browser-safe require
-const bsv = (typeof window !== 'undefined' && window.bsv) ? window.bsv : require('../../index.js');
-const util = require('util');
+const _global = (typeof window !== 'undefined' && window.bsv) ? window.bsv : null
+const Script = _global ? _global.Script : require('../script')
+const Interpreter = _global ? _global.Script.Interpreter : require('../script/interpreter')
+const Opcode = _global ? _global.Opcode : require('../opcode')
+const Transaction = _global ? _global.Transaction : require('../transaction')
+const Input = _global ? _global.Transaction.Input : require('../transaction/input')
+const Output = _global ? _global.Transaction.Output : require('../transaction/output')
+const BN = _global ? _global.crypto.BN : require('../crypto/bn')
+const util = require('util')
 
-function bufferToHexArray(stack) {
-  return stack.map((buf) => buf.toString('hex'));
+function bufferToHexArray (stack) {
+  return stack.map((buf) => buf.toString('hex'))
 }
 
 /**
  * Executes a locking/unlocking script and prints intermediate stack states.
  */
-function runScript(lockingHex, unlockingHex) {
-  console.log("===========================================");
-  console.log("🔍 STACK EXAMINATION TOOL");
-  console.log("===========================================\n");
+function runScript (lockingHex, unlockingHex) {
+  console.log('===========================================')
+  console.log('🔍 STACK EXAMINATION TOOL')
+  console.log('===========================================\n')
 
-  console.log("🔐 Locking Script:", lockingHex);
-  console.log("🔓 Unlocking Script:", unlockingHex);
-  console.log("-------------------------------------------");
+  console.log('🔐 Locking Script:', lockingHex)
+  console.log('🔓 Unlocking Script:', unlockingHex)
+  console.log('-------------------------------------------')
 
   try {
-    const lockingScript = bsv.Script.fromHex(lockingHex);
-    const unlockingScript = bsv.Script.fromHex(unlockingHex);
+    const lockingScript = Script.fromHex(lockingHex)
+    const unlockingScript = Script.fromHex(unlockingHex)
 
-    const combined = bsv.Script.fromBuffer(
+    const combined = Script.fromBuffer(
       Buffer.concat([unlockingScript.toBuffer(), lockingScript.toBuffer()])
-    );
+    )
+
+    const interpreter = new Interpreter()
+    const tx = new Transaction()
 
-    const interpreter = new bsv.Script.Interpreter();
-    const tx = new bsv.Transaction();
-    
     // Create proper transaction context
-    const dummyInput = new bsv.Transaction.Input({
+    const dummyInput = new Input({
       prevTxId: '0'.repeat(64),
       outputIndex: 0,
-      script: bsv.Script.empty()
-    });
-    
-    tx.addInput(dummyInput);
-    tx.addOutput(new bsv.Transaction.Output({ 
-      satoshis: 100000, 
-      script: lockingScript 
-    }));
-
-    const scriptChunks = combined.chunks;
-    const sandbox = new bsv.Script.Interpreter();
-    sandbox.script = combined;
-    sandbox.tx = tx;
-    sandbox.nIn = 0;
-    sandbox.flags = bsv.Script.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID;
+      script: Script.empty()
+    })
+
+    tx.addInput(dummyInput)
+    tx.addOutput(new Output({
+      satoshis: 100000,
+      script: lockingScript
+    }))
+
+    const scriptChunks = combined.chunks
+    const sandbox = new Interpreter()
+    sandbox.script = combined
+    sandbox.tx = tx
+    sandbox.nIn = 0
+    sandbox.flags = Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
 
     // Step through each opcode
     for (let i = 0; i < scriptChunks.length; i++) {
-      const chunk = scriptChunks[i];
+      const chunk = scriptChunks[i]
       try {
         // Check if step method exists (compatibility check)
         if (typeof sandbox.step === 'function') {
-          sandbox.step();
+          sandbox.step()
         } else {
-          console.log("⚠️ Step-by-step execution not supported in this BSV version");
-          break;
+          console.log('⚠️ Step-by-step execution not supported in this BSV version')
+          break
         }
-        
-        console.log(`\n🧩 Step ${i + 1}: ${bsv.Opcode.reverseMap[chunk.opcodenum] || 'PUSH'}`);
-        console.log("Stack:", bufferToHexArray(sandbox.stack));
-        console.log("AltStack:", bufferToHexArray(sandbox.altstack));
+
+        console.log(`\n🧩 Step ${i + 1}: ${Opcode.reverseMap[chunk.opcodenum] || 'PUSH'}`)
+        console.log('Stack:', bufferToHexArray(sandbox.stack))
+        console.log('AltStack:', bufferToHexArray(sandbox.altstack))
       } catch (err) {
-        console.log(`⚠️ Error executing opcode ${i + 1}:`, err.message);
-        break;
+        console.log(`⚠️ Error executing opcode ${i + 1}:`, err.message)
+        break
       }
     }
 
     // Final verification with proper satoshis parameter
-    const satoshisBN = new bsv.crypto.BN(100000);
+    const satoshisBN = new BN(100000)
     const verified = interpreter.verify(
       unlockingScript,
       lockingScript,
       tx,
       0,
-      bsv.Script.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID,
+      Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID,
       satoshisBN
-    );
-
-    console.log("\n===========================================");
-    console.log("✅ Final Result:", verified ? "TRUE (Success)" : "❌ FALSE (Failure)");
-    console.log("Final Stack:", bufferToHexArray(sandbox.stack || []));
-    console.log("AltStack:", bufferToHexArray(sandbox.altstack || []));
-    console.log("===========================================");
-    
-    return verified;
+    )
+
+    console.log('\n===========================================')
+    console.log('✅ Final Result:', verified ? 'TRUE (Success)' : '❌ FALSE (Failure)')
+    console.log('Final Stack:', bufferToHexArray(sandbox.stack || []))
+    console.log('AltStack:', bufferToHexArray(sandbox.altstack || []))
+    console.log('===========================================')
+
+    return verified
   } catch (err) {
-    console.error("❌ Error in script execution:", err.message);
-    return false;
+    console.error('❌ Error in script execution:', err.message)
+    return false
   }
 }
 
@@ -113,17 +120,17 @@ function runScript(lockingHex, unlockingHex) {
 // ============================================
 if (typeof require !== 'undefined' && require.main === module) {
   if (process.argv.length < 4) {
-    console.log("Usage: node stack_examiner.js <locking_script_hex> <unlocking_script_hex>");
-    process.exit(1);
+    console.log('Usage: node stack_examiner.js <locking_script_hex> <unlocking_script_hex>')
+    process.exit(1)
   }
 
-  const locking = process.argv[2];
-  const unlocking = process.argv[3];
-  runScript(locking, unlocking);
+  const locking = process.argv[2]
+  const unlocking = process.argv[3]
+  runScript(locking, unlocking)
 }
 
 // Export for module usage
 module.exports = {
   runScript,
   bufferToHexArray
-};
+}

package/lib/smart_contract/token.js

@@ -39,13 +39,13 @@
  * Requires post-Genesis limits (SmartContract.enableGenesis()).
  */
 
-var bsv = require('../..')
-var P = require('./pushtx')
-var H = require('./covenant_helpers')
+var BN = require('../crypto/bn')
+var P = require('../covenant/pushtx')
+var H = require('../covenant/helpers')
 var A = require('./authorizers')
 
-var Script = bsv.Script
-var Opcode = bsv.Opcode
+var Script = require('../script')
+var Opcode = require('../opcode')
 var n = H.scriptNum
 
 function resolveCommit (owner, auth) {
@@ -285,7 +285,7 @@ function transferOrdinal (signer, newOwnerHash, spend, ordinalSats, lockingScrip
   function ser (o) { return o.toBufferWriter().toBuffer() }
   var before = Buffer.concat(outs.slice(0, tokenIndex).map(ser))
   var after = Buffer.concat(outs.slice(tokenIndex + 1).map(ser))
-  var tokenValue = new bsv.crypto.BN(ordinalSats).toBuffer({ endian: 'little', size: 8 })
+  var tokenValue = new BN(ordinalSats).toBuffer({ endian: 'little', size: 8 })
 
   return unlockTransferMulti(signer, newOwnerHash, spend, ordinalSats, lockingScript, {
     before: before,

package/lib/smart_contract/utxo_generator.js

@@ -15,7 +15,13 @@
 
 'use strict'
 
-var bsv = require('../..')
+var sighash = require('../transaction/sighash')
+var Signature = require('../crypto/signature')
+var BN = require('../crypto/bn')
+var Transaction = require('../transaction')
+var PrivateKey = require('../privatekey')
+var Networks = require('../networks')
+var Script = require('../script')
 var crypto = require('crypto')
 
 /**
@@ -28,14 +34,14 @@ function UTXOGenerator(options) {
   }
 
   this.options = options || {}
-  this.network = this.options.network || bsv.Networks.mainnet
+  this.network = this.options.network || Networks.mainnet
   this.keyRing = {} // Store generated keys
   this.utxoPool = [] // Store generated UTXOs
   
   // Initialize with SmartUTXO integration via direct require so that
   // touching this internal integration path doesn't surface the
-  // bsv.SmartUTXO deprecation warning (the warning is for downstream
-  // consumers who reach for bsv.SmartUTXO themselves, not for our own
+  // SmartUTXO deprecation warning (the warning is for downstream
+  // consumers who reach for SmartUTXO themselves, not for our own
   // internal coupling). Try/catch because smartutxo is Node-only.
   try {
     var SmartUTXO = require('../smartutxo')
@@ -51,7 +57,7 @@ function UTXOGenerator(options) {
 UTXOGenerator.prototype.generateKeypair = function(label) {
   label = label || 'key_' + Date.now()
   
-  var privateKey = bsv.PrivateKey.fromRandom(this.network)
+  var privateKey = PrivateKey.fromRandom(this.network)
   var publicKey = privateKey.toPublicKey()
   var address = privateKey.toAddress(this.network)
   
@@ -119,25 +125,25 @@ UTXOGenerator.prototype._createSingleUTXO = function(config) {
   
   switch (config.scriptType) {
     case 'P2PKH':
-      script = bsv.Script.buildPublicKeyHashOut(config.keypair.address)
+      script = Script.buildPublicKeyHashOut(config.keypair.address)
       scriptHex = script.toHex()
       break
       
     case 'P2SH':
       // Create a simple multisig for P2SH example
-      var redeemScript = bsv.Script.buildMultisigOut([config.keypair.publicKey], 1)
-      script = bsv.Script.buildScriptHashOut(redeemScript)
+      var redeemScript = Script.buildMultisigOut([config.keypair.publicKey], 1)
+      script = Script.buildScriptHashOut(redeemScript)
       scriptHex = script.toHex()
       break
       
     case 'CUSTOM':
       // Allow custom script injection
-      script = config.customScript || bsv.Script.buildPublicKeyHashOut(config.keypair.address)
+      script = config.customScript || Script.buildPublicKeyHashOut(config.keypair.address)
       scriptHex = script.toHex()
       break
       
     default:
-      script = bsv.Script.buildPublicKeyHashOut(config.keypair.address)
+      script = Script.buildPublicKeyHashOut(config.keypair.address)
       scriptHex = script.toHex()
   }
   
@@ -174,7 +180,7 @@ UTXOGenerator.prototype.createTestTransaction = function(config) {
   }, 0)
   
   // Create transaction
-  var transaction = new bsv.Transaction()
+  var transaction = new Transaction()
   
   // Add inputs
   inputUTXOs.forEach(function(utxo) {
@@ -217,15 +223,15 @@ UTXOGenerator.prototype.createTestTransaction = function(config) {
     
     // Preimage generation helper
     generatePreimage: function(inputIndex, sighashType) {
-      sighashType = sighashType || bsv.crypto.Signature.SIGHASH_ALL | bsv.crypto.Signature.SIGHASH_FORKID
+      sighashType = sighashType || Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID
       var utxo = inputUTXOs[inputIndex]
       
-      return bsv.Transaction.sighash.sighashPreimage(
+      return sighash.sighashPreimage(
         transaction,
         sighashType,
         inputIndex,
-        bsv.Script.fromHex(utxo.script),
-        new bsv.crypto.BN(utxo.satoshis)
+        Script.fromHex(utxo.script),
+        new BN(utxo.satoshis)
       )
     }
   }