@smartledger/bsv 7.9.0 → 7.10.1

package/lib/smart_contract/script_interpreter.js

@@ -20,204 +20,211 @@
  */
 
 // Browser-safe requires
-let readline = null;
+let readline = null
 try {
   // Only require readline in Node.js environment
   if (typeof window === 'undefined' && typeof require !== 'undefined') {
-    readline = require("readline");
+    readline = require('readline')
   }
 } catch (err) {
   // Gracefully handle missing readline in browser
-  readline = null;
+  readline = null
 }
 
-const bsv = (typeof window !== 'undefined' && window.bsv) ? window.bsv : require("../../index.js");
+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 BN = _global ? _global.crypto.BN : require('../crypto/bn')
+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')
 
 // Debug: Show Script Interpreter module structure (uncomment to inspect)
-// const ScriptInterpreter = bsv.Script.Interpreter;
+// const ScriptInterpreter = Interpreter;
 // console.log("Script Interpreter Module:", ScriptInterpreter);
 /**
  * Parse input as either ASM or HEX.
  */
-function parseScript(input) {
-  if (!input) return new bsv.Script();
-  const trimmed = input.trim();
-  const isHex = /^[0-9a-fA-F]+$/.test(trimmed.replace(/\s+/g, ""));
+function parseScript (input) {
+  if (!input) return new Script()
+  const trimmed = input.trim()
+  const isHex = /^[0-9a-fA-F]+$/.test(trimmed.replace(/\s+/g, ''))
   try {
     return isHex
-      ? bsv.Script.fromHex(trimmed)
-      : bsv.Script.fromASM(trimmed);
+      ? Script.fromHex(trimmed)
+      : Script.fromASM(trimmed)
   } catch (err) {
-    console.error("❌ Error parsing script:", err.message);
-    process.exit(1);
+    console.error('❌ Error parsing script:', err.message)
+    process.exit(1)
   }
 }
 
 /**
  * Display stack contents in readable format.
  */
-function printStack(stack, altstack = []) {
-  const fmt = (b) => (b.length ? b.toString("hex") : "(empty)");
-  const top = stack.map(fmt);
-  console.log("Stack:", top.length ? top : ["(empty)"]);
-  if (altstack.length) console.log("AltStack:", altstack.map(fmt));
+function printStack (stack, altstack = []) {
+  const fmt = (b) => (b.length ? b.toString('hex') : '(empty)')
+  const top = stack.map(fmt)
+  console.log('Stack:', top.length ? top : ['(empty)'])
+  if (altstack.length) console.log('AltStack:', altstack.map(fmt))
 }
 
 /**
  * Execute script step-by-step with optional interactivity.
  */
-async function stepThroughScript(combinedScript, tx, verbose = true) {
-  const interpreter = new bsv.Script.Interpreter();
-  interpreter.script = combinedScript;
-  interpreter.tx = tx;
-  interpreter.nIn = 0;
-  interpreter.flags = bsv.Script.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID;
-
-  const chunks = combinedScript.chunks;
-  
+async function stepThroughScript (combinedScript, tx, verbose = true) {
+  const interpreter = new Interpreter()
+  interpreter.script = combinedScript
+  interpreter.tx = tx
+  interpreter.nIn = 0
+  interpreter.flags = Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
+
+  const chunks = combinedScript.chunks
+
   // Browser compatibility check for readline
-  let rl = null;
+  let rl = null
   if (readline && typeof process !== 'undefined' && process.stdin) {
     rl = readline.createInterface({
       input: process.stdin,
-      output: process.stdout,
-    });
+      output: process.stdout
+    })
   }
 
-  console.log("===========================================");
-  console.log("🔍 SCRIPT INTERPRETER DEBUGGER (STEP MODE)");
-  console.log("===========================================\n");
-  console.log("Script:", combinedScript.toASM());
-  console.log("-------------------------------------------");
+  console.log('===========================================')
+  console.log('🔍 SCRIPT INTERPRETER DEBUGGER (STEP MODE)')
+  console.log('===========================================\n')
+  console.log('Script:', combinedScript.toASM())
+  console.log('-------------------------------------------')
 
   for (let i = 0; i < chunks.length; i++) {
-    const chunk = chunks[i];
-    const opname = bsv.Opcode.reverseMap[chunk.opcodenum] || "PUSH";
+    const chunk = chunks[i]
+    const opname = Opcode.reverseMap[chunk.opcodenum] || 'PUSH'
 
     if (verbose && rl) {
       await new Promise((resolve) =>
         rl.question(`\n[${i + 1}/${chunks.length}] Step (${opname}) — press Enter to execute...`, resolve)
-      );
+      )
     } else if (verbose) {
-      console.log(`\n[${i + 1}/${chunks.length}] Step (${opname})`);
+      console.log(`\n[${i + 1}/${chunks.length}] Step (${opname})`)
     }
 
     try {
       // Check if step method exists (compatibility check)
       if (typeof interpreter.step === 'function') {
-        interpreter.step();
+        interpreter.step()
       } else {
-        console.log("⚠️ Step-by-step execution not supported in this BSV version");
-        console.log("💡 Consider using runFullEvaluation instead");
-        break;
+        console.log('⚠️ Step-by-step execution not supported in this BSV version')
+        console.log('💡 Consider using runFullEvaluation instead')
+        break
       }
-      
-      console.log(`🧩 Executed: ${opname}`);
-      printStack(interpreter.stack, interpreter.altstack);
+
+      console.log(`🧩 Executed: ${opname}`)
+      printStack(interpreter.stack, interpreter.altstack)
     } catch (err) {
-      console.log(`⚠️  Error executing ${opname}: ${err.message}`);
-      break;
+      console.log(`⚠️  Error executing ${opname}: ${err.message}`)
+      break
     }
   }
 
-  if (rl) rl.close();
-  console.log("\n===========================================");
-  console.log("✅ Final Stack State:");
-  printStack(interpreter.stack || [], interpreter.altstack || []);
-  console.log("===========================================");
+  if (rl) rl.close()
+  console.log('\n===========================================')
+  console.log('✅ Final Stack State:')
+  printStack(interpreter.stack || [], interpreter.altstack || [])
+  console.log('===========================================')
 }
 
 /**
  * Run complete truth evaluation (non-interactive)
  */
-function runFullEvaluation(unlockingScript, lockingScript, tx) {
-  console.log("===========================================");
-  console.log("🔍 SCRIPT INTERPRETER DEBUGGER (FULL RUN)");
-  console.log("===========================================\n");
+function runFullEvaluation (unlockingScript, lockingScript, tx) {
+  console.log('===========================================')
+  console.log('🔍 SCRIPT INTERPRETER DEBUGGER (FULL RUN)')
+  console.log('===========================================\n')
+
+  const interpreter = new Interpreter()
 
-  const interpreter = new bsv.Script.Interpreter();
-  
   // For smartledger-bsv, need to provide satoshisBN parameter
-  const satoshisBN = new bsv.crypto.BN(100000); // 100,000 satoshis
-  
+  const satoshisBN = new BN(100000) // 100,000 satoshis
+
   const verified = interpreter.verify(
     unlockingScript,
     lockingScript,
     tx,
     0,
-    bsv.Script.Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID,
+    Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID,
     satoshisBN
-  );
-
-  console.log("🔐 Locking Script:", lockingScript.toASM());
-  console.log("🔓 Unlocking Script:", unlockingScript.toASM());
-  console.log("-------------------------------------------");
-  console.log("✅ Result:", verified ? "TRUE (Success)" : "❌ FALSE (Failure)");
-  console.log("Final Stack:", interpreter.stack.map((b) => b.toString("hex")));
-  console.log("AltStack:", interpreter.altstack.map((b) => b.toString("hex")));
-  console.log("===========================================");
+  )
+
+  console.log('🔐 Locking Script:', lockingScript.toASM())
+  console.log('🔓 Unlocking Script:', unlockingScript.toASM())
+  console.log('-------------------------------------------')
+  console.log('✅ Result:', verified ? 'TRUE (Success)' : '❌ FALSE (Failure)')
+  console.log('Final Stack:', interpreter.stack.map((b) => b.toString('hex')))
+  console.log('AltStack:', interpreter.altstack.map((b) => b.toString('hex')))
+  console.log('===========================================')
 }
 
 /**
  * Main entrypoint
  */
-async function main() {
+async function main () {
   // Browser compatibility check
   if (typeof process === 'undefined' || !process.argv) {
-    console.log("⚙️ CLI mode not available in browser environment");
-    return;
+    console.log('⚙️ CLI mode not available in browser environment')
+    return
   }
 
-  const args = process.argv.slice(2);
+  const args = process.argv.slice(2)
   const getArg = (name) => {
-    const idx = args.indexOf(name);
-    return idx !== -1 && args[idx + 1] ? args[idx + 1] : null;
-  };
+    const idx = args.indexOf(name)
+    return idx !== -1 && args[idx + 1] ? args[idx + 1] : null
+  }
 
-  const unlockingInput = getArg("--unlocking");
-  const lockingInput = getArg("--locking");
-  const combinedInput = getArg("--combined");
-  const stepMode = args.includes("--step");
-  const truthMode = args.includes("--truth");
+  const unlockingInput = getArg('--unlocking')
+  const lockingInput = getArg('--locking')
+  const combinedInput = getArg('--combined')
+  const stepMode = args.includes('--step')
+  const truthMode = args.includes('--truth')
 
   // Build scripts
-  let unlockingScript, lockingScript, combinedScript;
+  let unlockingScript, lockingScript, combinedScript
   if (combinedInput) {
-    combinedScript = parseScript(combinedInput);
+    combinedScript = parseScript(combinedInput)
   } else {
-    unlockingScript = parseScript(unlockingInput);
-    lockingScript = parseScript(lockingInput);
+    unlockingScript = parseScript(unlockingInput)
+    lockingScript = parseScript(lockingInput)
     const combinedBuf = Buffer.concat([
       unlockingScript.toBuffer(),
-      lockingScript.toBuffer(),
-    ]);
-    combinedScript = bsv.Script.fromBuffer(combinedBuf);
+      lockingScript.toBuffer()
+    ])
+    combinedScript = Script.fromBuffer(combinedBuf)
   }
 
   // Dummy TX context for interpreter
-  const tx = new bsv.Transaction();
-  
+  const tx = new Transaction()
+
   // Create proper input with UTXO information
-  const dummyInput = new bsv.Transaction.Input({
+  const dummyInput = new Input({
     prevTxId: '0'.repeat(64),
     outputIndex: 0,
-    script: bsv.Script.empty(),
+    script: Script.empty(),
     satoshis: 100000,
-    output: new bsv.Transaction.Output({
+    output: new Output({
       satoshis: 100000,
-      script: bsv.Script.empty()
+      script: Script.empty()
     })
-  });
-  
-  tx.addInput(dummyInput);
-  tx.addOutput(new bsv.Transaction.Output({ satoshis: 100000, script: bsv.Script.empty() }));
+  })
+
+  tx.addInput(dummyInput)
+  tx.addOutput(new Output({ satoshis: 100000, script: Script.empty() }))
 
   if (stepMode) {
-    await stepThroughScript(combinedScript, tx, true);
+    await stepThroughScript(combinedScript, tx, true)
   } else if (truthMode) {
-    runFullEvaluation(unlockingScript || bsv.Script.empty(), lockingScript || bsv.Script.empty(), tx);
+    runFullEvaluation(unlockingScript || Script.empty(), lockingScript || Script.empty(), tx)
   } else {
-    console.log("⚙️  No mode specified. Use --step or --truth");
+    console.log('⚙️  No mode specified. Use --step or --truth')
   }
 }
 
@@ -228,9 +235,9 @@ module.exports = {
   stepThroughScript,
   runFullEvaluation,
   main
-};
+}
 
 // CLI execution
 if (typeof require !== 'undefined' && require.main === module) {
-  main();
+  main()
 }

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 }
   ]
 }