@smartledger/bsv 8.1.0 → 8.3.0

package/tools/opcode_map.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+
+/**
+ * BSV Opcode Mapping and Interpreter Configuration Tool
+ * 
+ * Maps all opcodes with their enabled/disabled status and required flags
+ * Provides helper functions for script execution with proper flags
+ * 
+ * Usage: node opcode_map.js
+ */
+
+const bsv = require('./index.js');
+const { Opcode, Script } = bsv;
+const Interpreter = bsv.Script.Interpreter;
+
+// Create reverse opcode mapping
+const opcodeMap = {};
+for (let key in Opcode.map) {
+  const code = Opcode.map[key];
+  opcodeMap[code] = key;
+}
+
+// Define opcode categories and their enablement requirements
+const OPCODE_CATEGORIES = {
+  // Always enabled opcodes
+  CORE: {
+    description: 'Core opcodes - always enabled',
+    flag: null,
+    opcodes: [
+      'OP_0', 'OP_1NEGATE', 'OP_1', 'OP_2', 'OP_3', 'OP_4', 'OP_5', 'OP_6', 'OP_7', 'OP_8', 'OP_9', 'OP_10',
+      'OP_11', 'OP_12', 'OP_13', 'OP_14', 'OP_15', 'OP_16', 'OP_NOP', 'OP_IF', 'OP_NOTIF', 'OP_ELSE', 'OP_ENDIF',
+      'OP_VERIFY', 'OP_RETURN', 'OP_TOALTSTACK', 'OP_FROMALTSTACK', 'OP_2DROP', 'OP_2DUP', 'OP_3DUP', 'OP_2OVER',
+      'OP_2ROT', 'OP_2SWAP', 'OP_IFDUP', 'OP_DEPTH', 'OP_DROP', 'OP_DUP', 'OP_NIP', 'OP_OVER', 'OP_PICK', 'OP_ROLL',
+      'OP_ROT', 'OP_SWAP', 'OP_TUCK', 'OP_SIZE', 'OP_EQUAL', 'OP_EQUALVERIFY', 'OP_1ADD', 'OP_1SUB', 'OP_NEGATE',
+      'OP_ABS', 'OP_NOT', 'OP_0NOTEQUAL', 'OP_ADD', 'OP_SUB', 'OP_BOOLAND', 'OP_BOOLOR', 'OP_NUMEQUAL',
+      'OP_NUMEQUALVERIFY', 'OP_NUMNOTEQUAL', 'OP_LESSTHAN', 'OP_GREATERTHAN', 'OP_LESSTHANOREQUAL',
+      'OP_GREATERTHANOREQUAL', 'OP_MIN', 'OP_MAX', 'OP_WITHIN', 'OP_RIPEMD160', 'OP_SHA1', 'OP_SHA256',
+      'OP_HASH160', 'OP_HASH256', 'OP_CODESEPARATOR', 'OP_CHECKSIG', 'OP_CHECKSIGVERIFY', 'OP_CHECKMULTISIG',
+      'OP_CHECKMULTISIGVERIFY', 'OP_NOP1', 'OP_PUSHDATA1', 'OP_PUSHDATA2', 'OP_PUSHDATA4'
+    ]
+  },
+  
+  // Monolith opcodes (May 2018 upgrade)
+  MONOLITH: {
+    description: 'Monolith opcodes - require SCRIPT_ENABLE_MONOLITH_OPCODES',
+    flag: 'SCRIPT_ENABLE_MONOLITH_OPCODES',
+    flagValue: (1 << 18),
+    opcodes: [
+      'OP_CAT', 'OP_SPLIT', 'OP_NUM2BIN', 'OP_BIN2NUM', 'OP_AND', 'OP_OR', 'OP_XOR', 'OP_DIV', 'OP_MOD'
+    ]
+  },
+  
+  // Magnetic opcodes (future upgrade)
+  MAGNETIC: {
+    description: 'Magnetic opcodes - require SCRIPT_ENABLE_MAGNETIC_OPCODES',
+    flag: 'SCRIPT_ENABLE_MAGNETIC_OPCODES',
+    flagValue: (1 << 19),
+    opcodes: [
+      'OP_INVERT', 'OP_MUL', 'OP_LSHIFT', 'OP_RSHIFT'
+    ]
+  },
+  
+  // Always disabled opcodes
+  DISABLED: {
+    description: 'Permanently disabled opcodes',
+    flag: null,
+    opcodes: [
+      'OP_RESERVED', 'OP_VER', 'OP_VERIF', 'OP_VERNOTIF', 'OP_RESERVED1', 'OP_RESERVED2', 'OP_2MUL', 'OP_2DIV'
+    ]
+  },
+  
+  // NOP opcodes
+  NOPS: {
+    description: 'NOP opcodes - may be discouraged with SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS',
+    flag: 'SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS',
+    flagValue: (1 << 7),
+    opcodes: [
+      'OP_NOP2', 'OP_NOP3', 'OP_NOP4', 'OP_NOP5', 'OP_NOP6', 'OP_NOP7', 'OP_NOP8', 'OP_NOP9', 'OP_NOP10'
+    ]
+  }
+};
+
+/**
+ * Get opcode information including enablement status
+ */
+function getOpcodeInfo(opcodeValue) {
+  const opcodeName = opcodeMap[opcodeValue];
+  if (!opcodeName) {
+    return {
+      value: opcodeValue,
+      name: `UNKNOWN_${opcodeValue}`,
+      enabled: false,
+      category: 'UNKNOWN',
+      requiresFlag: null
+    };
+  }
+  
+  // Find which category this opcode belongs to
+  for (const [category, info] of Object.entries(OPCODE_CATEGORIES)) {
+    if (info.opcodes.includes(opcodeName)) {
+      return {
+        value: opcodeValue,
+        hex: `0x${opcodeValue.toString(16).padStart(2, '0')}`,
+        name: opcodeName,
+        enabled: category !== 'DISABLED',
+        category: category,
+        requiresFlag: info.flag,
+        flagValue: info.flagValue,
+        description: info.description
+      };
+    }
+  }
+  
+  // Default to core if not found in any category
+  return {
+    value: opcodeValue,
+    hex: `0x${opcodeValue.toString(16).padStart(2, '0')}`,
+    name: opcodeName,
+    enabled: true,
+    category: 'CORE',
+    requiresFlag: null,
+    description: 'Core opcode - always enabled'
+  };
+}
+
+/**
+ * Get recommended interpreter flags for different use cases
+ */
+function getInterpreterFlags() {
+  return {
+    // Minimal flags for basic scripts
+    BASIC: Interpreter.SCRIPT_VERIFY_P2SH,
+    
+    // Standard flags for most scripts
+    STANDARD: Interpreter.SCRIPT_VERIFY_P2SH | 
+              Interpreter.SCRIPT_VERIFY_STRICTENC |
+              Interpreter.SCRIPT_VERIFY_MINIMALDATA,
+    
+    // Modern BSV with monolith opcodes (recommended for new scripts)
+    MODERN: Interpreter.SCRIPT_VERIFY_P2SH | 
+            Interpreter.SCRIPT_VERIFY_STRICTENC |
+            Interpreter.SCRIPT_VERIFY_MINIMALDATA |
+            Interpreter.SCRIPT_VERIFY_SIGPUSHONLY |
+            Interpreter.SCRIPT_VERIFY_CLEANSTACK |
+            Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID |
+            Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES,
+    
+    // Full BSV with all opcodes enabled
+    FULL: Interpreter.SCRIPT_VERIFY_P2SH | 
+          Interpreter.SCRIPT_VERIFY_STRICTENC |
+          Interpreter.SCRIPT_VERIFY_MINIMALDATA |
+          Interpreter.SCRIPT_VERIFY_SIGPUSHONLY |
+          Interpreter.SCRIPT_VERIFY_CLEANSTACK |
+          Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID |
+          Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES |
+          Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES,
+    
+    // Genesis rules (most permissive)
+    GENESIS: Interpreter.SCRIPT_VERIFY_P2SH |
+             Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID |
+             Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES |
+             Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES
+  };
+}
+
+/**
+ * Analyze a script and determine required flags
+ */
+function analyzeScriptRequirements(script) {
+  let requiredFlags = Interpreter.SCRIPT_VERIFY_P2SH; // Base requirement
+  const usedOpcodes = [];
+  const issues = [];
+  
+  // Parse script
+  let chunks;
+  if (typeof script === 'string') {
+    // ASM format
+    chunks = script.split(' ').map(token => {
+      if (token.startsWith('OP_')) {
+        const opcodeValue = Object.keys(opcodeMap).find(key => opcodeMap[key] === token);
+        return { opcodenum: parseInt(opcodeValue) };
+      }
+      return { buf: Buffer.from(token, 'hex') };
+    });
+  } else if (script instanceof Script) {
+    chunks = script.chunks;
+  } else {
+    throw new Error('Invalid script format');
+  }
+  
+  // Analyze each chunk
+  chunks.forEach((chunk, index) => {
+    if (chunk.opcodenum !== undefined) {
+      const info = getOpcodeInfo(chunk.opcodenum);
+      usedOpcodes.push(info);
+      
+      if (!info.enabled) {
+        issues.push(`Opcode ${info.name} at position ${index} is permanently disabled`);
+      } else if (info.requiresFlag) {
+        if (info.flag === 'SCRIPT_ENABLE_MONOLITH_OPCODES') {
+          requiredFlags |= Interpreter.SCRIPT_ENABLE_MONOLITH_OPCODES;
+        } else if (info.flag === 'SCRIPT_ENABLE_MAGNETIC_OPCODES') {
+          requiredFlags |= Interpreter.SCRIPT_ENABLE_MAGNETIC_OPCODES;
+        }
+      }
+    }
+  });
+  
+  // Add FORKID if using any signature opcodes
+  const hasSignatureOpcodes = usedOpcodes.some(op => 
+    op.name === 'OP_CHECKSIG' || op.name === 'OP_CHECKSIGVERIFY' || 
+    op.name === 'OP_CHECKMULTISIG' || op.name === 'OP_CHECKMULTISIGVERIFY'
+  );
+  
+  if (hasSignatureOpcodes) {
+    requiredFlags |= Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID;
+  }
+  
+  return {
+    requiredFlags,
+    usedOpcodes,
+    issues,
+    recommendations: {
+      basic: requiredFlags,
+      safe: requiredFlags | Interpreter.SCRIPT_VERIFY_STRICTENC | Interpreter.SCRIPT_VERIFY_MINIMALDATA,
+      strict: requiredFlags | Interpreter.SCRIPT_VERIFY_STRICTENC | Interpreter.SCRIPT_VERIFY_MINIMALDATA | 
+              Interpreter.SCRIPT_VERIFY_SIGPUSHONLY | Interpreter.SCRIPT_VERIFY_CLEANSTACK
+    }
+  };
+}
+
+/**
+ * Print opcode analysis
+ */
+function printOpcodeAnalysis() {
+  console.log('🔧 BSV Opcode Mapping and Interpreter Configuration');
+  console.log('═'.repeat(80));
+  
+  // Show interpreter flags
+  console.log('\n⚙️  Available Interpreter Flags:');
+  const flagNames = Object.keys(Interpreter).filter(key => key.startsWith('SCRIPT_'));
+  flagNames.forEach(flagName => {
+    const value = Interpreter[flagName];
+    console.log(`  ${flagName.padEnd(40)}: 0x${value.toString(16).padStart(8, '0').toUpperCase()}`);
+  });
+  
+  // Show recommended flag combinations
+  console.log('\n🎯 Recommended Flag Combinations:');
+  const flags = getInterpreterFlags();
+  Object.entries(flags).forEach(([name, value]) => {
+    console.log(`  ${name.padEnd(10)}: 0x${value.toString(16).padStart(8, '0').toUpperCase()}`);
+  });
+  
+  // Show opcode categories
+  console.log('\n📋 Opcode Categories:');
+  Object.entries(OPCODE_CATEGORIES).forEach(([category, info]) => {
+    console.log(`\n  ${category} - ${info.description}`);
+    if (info.flag) {
+      console.log(`    Required flag: ${info.flag} (0x${info.flagValue.toString(16).toUpperCase()})`);
+    }
+    console.log(`    Opcodes: ${info.opcodes.length}`);
+    
+    // Show first few opcodes
+    const sample = info.opcodes.slice(0, 5);
+    console.log(`    Sample: ${sample.join(', ')}${info.opcodes.length > 5 ? '...' : ''}`);
+  });
+  
+  // Show total counts
+  const totalOpcodes = Object.keys(opcodeMap).length;
+  const enabledOpcodes = Object.keys(opcodeMap).filter(code => {
+    const info = getOpcodeInfo(parseInt(code));
+    return info.enabled;
+  }).length;
+  
+  console.log(`\n📊 Summary:`);
+  console.log(`  Total opcodes defined: ${totalOpcodes}`);
+  console.log(`  Enabled opcodes: ${enabledOpcodes}`);
+  console.log(`  Disabled opcodes: ${totalOpcodes - enabledOpcodes}`);
+}
+
+/**
+ * Create a properly configured interpreter
+ */
+function createInterpreter(flagLevel = 'MODERN') {
+  const flags = getInterpreterFlags();
+  return {
+    interpreter: new Interpreter(),
+    flags: flags[flagLevel.toUpperCase()] || flags.MODERN,
+    
+    verify: function(scriptSig, scriptPubkey, tx, nin, satoshisBN) {
+      return this.interpreter.verify(
+        scriptSig, 
+        scriptPubkey, 
+        tx, 
+        nin, 
+        this.flags, 
+        satoshisBN
+      );
+    }
+  };
+}
+
+// CLI execution
+if (require.main === module) {
+  printOpcodeAnalysis();
+  
+  // Test with sample nLockTime script
+  console.log('\n🧪 Testing nLockTime Script Requirements:');
+  const sampleScript = 'OP_OVER OP_HASH256 a7a9bc2c7389fecf7d5279e0909bcaac1b0f7d0ee81713adfb7e97fad95322ad OP_EQUALVERIFY OP_OVER 6a OP_SPLIT OP_NIP 04 OP_SPLIT OP_NIP OP_BIN2NUM e803 OP_NUMEQUALVERIFY 03433a1466b09a27e0067efa9c58ec12ae5e26071a413cfe918b49656c75d7fb2d OP_CHECKSIGVERIFY';
+  
+  try {
+    const analysis = analyzeScriptRequirements(sampleScript);
+    console.log(`  Required flags: 0x${analysis.requiredFlags.toString(16).toUpperCase()}`);
+    console.log(`  Used opcodes: ${analysis.usedOpcodes.length}`);
+    
+    if (analysis.issues.length > 0) {
+      console.log(`  Issues:`);
+      analysis.issues.forEach(issue => console.log(`    ⚠️  ${issue}`));
+    } else {
+      console.log(`  ✅ No issues found`);
+    }
+    
+    console.log(`  Recommendations:`);
+    console.log(`    Basic:  0x${analysis.recommendations.basic.toString(16).toUpperCase()}`);
+    console.log(`    Safe:   0x${analysis.recommendations.safe.toString(16).toUpperCase()}`);
+    console.log(`    Strict: 0x${analysis.recommendations.strict.toString(16).toUpperCase()}`);
+    
+  } catch (error) {
+    console.log(`  ❌ Error analyzing script: ${error.message}`);
+  }
+}
+
+// Export functions and data
+module.exports = {
+  opcodeMap,
+  OPCODE_CATEGORIES,
+  getOpcodeInfo,
+  getInterpreterFlags,
+  analyzeScriptRequirements,
+  createInterpreter,
+  printOpcodeAnalysis
+};

package/tools/server.js

@@ -0,0 +1,97 @@
+const http = require('http')
+const fs = require('fs')
+const path = require('path')
+
+const port = 8080
+
+// MIME types for different file extensions
+const mimeTypes = {
+  '.html': 'text/html',
+  '.js': 'application/javascript',
+  '.css': 'text/css',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpg',
+  '.gif': 'image/gif',
+  '.ico': 'image/x-icon',
+  '.svg': 'image/svg+xml',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2'
+}
+
+const server = http.createServer((req, res) => {
+  console.log(`Request for ${req.url}`)
+
+  // Parse URL and remove query string
+  let filePath = req.url.split('?')[0]
+
+  // Default to index.html if no specific file requested
+  if (filePath === '/') {
+    filePath = '/test.html'
+  }
+
+  // Build full file path
+  const fullPath = path.join(__dirname, filePath)
+
+  // Get file extension
+  const extname = path.extname(fullPath)
+  const contentType = mimeTypes[extname] || 'application/octet-stream'
+
+  // Check if file exists
+  fs.readFile(fullPath, (err, content) => {
+    if (err) {
+      if (err.code === 'ENOENT') {
+        // File not found
+        res.writeHead(404, { 'Content-Type': 'text/html' })
+        res.end(`
+          <html>
+            <body style="font-family: Arial, sans-serif; text-align: center; padding: 50px;">
+              <h1>404 - File Not Found</h1>
+              <p>The requested file <strong>${req.url}</strong> was not found.</p>
+              <p><a href="/test.html">Go to BSV Security Test</a></p>
+            </body>
+          </html>
+        `)
+      } else {
+        // Server error
+        res.writeHead(500)
+        res.end(`Server Error: ${err.code}`)
+      }
+    } else {
+      // Success - serve the file
+      res.writeHead(200, {
+        'Content-Type': contentType,
+        'Cache-Control': 'no-cache' // Prevent caching for development
+      })
+      res.end(content)
+    }
+  })
+})
+
+server.listen(port, () => {
+  console.log(`
+🚀 SmartLedger BSV Test Server Started!
+
+📍 Server running at: http://localhost:${port}
+🧪 Test page: http://localhost:${port}/test.html
+📁 Serving files from: ${__dirname}
+
+📊 Available files:
+- test.html (Main test page)
+- bsv.min.js (${Math.round(fs.statSync('bsv.min.js').size / 1024)} KB)
+- bsv-message.min.js (${Math.round(fs.statSync('bsv-message.min.js').size / 1024)} KB)
+- bsv-ecies.min.js (${Math.round(fs.statSync('bsv-ecies.min.js').size / 1024)} KB)
+- bsv-mnemonic.min.js (${Math.round(fs.statSync('bsv-mnemonic.min.js').size / 1024)} KB)
+
+Press Ctrl+C to stop the server
+  `)
+})
+
+// Handle server shutdown gracefully
+process.on('SIGINT', () => {
+  console.log('\n👋 Shutting down server...')
+  server.close(() => {
+    console.log('✅ Server stopped')
+    process.exit(0)
+  })
+})

package/tools/simple_real_tx.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+
+/**
+ * Simple Real BSV Transaction Test
+ * 
+ * Uses only real UTXOs to create and broadcast a transaction
+ */
+
+const bsv = require('./index.js');
+const https = require('https');
+
+console.log('🚀 Simple Real BSV Transaction Test');
+console.log('===================================\n');
+
+const privateKey = new bsv.PrivateKey('L1aW4aubDFB7yfras2S1mN3bqg9nwySY8nkoLmJebSLD5BWv3ENZ');
+const address = privateKey.toAddress().toString();
+
+console.log(`Address: ${address}`);
+console.log(`Private Key: ${privateKey.toString()}\n`);
+
+// Simple API call
+function makeRequest(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (error) {
+          reject(new Error(`Failed to parse response: ${error.message}`));
+        }
+      });
+    }).on('error', reject);
+  });
+}
+
+async function createSimpleTransaction() {
+  try {
+    // Get real UTXO
+    console.log('🔍 Fetching real UTXO...');
+    const utxos = await makeRequest(`https://api.whatsonchain.com/v1/bsv/main/address/${address}/unspent`);
+    
+    if (utxos.length === 0) {
+      throw new Error('No UTXOs found');
+    }
+    
+    const utxo = utxos[0]; // Use the first UTXO
+    console.log(`Found UTXO: ${utxo.tx_hash}:${utxo.tx_pos} = ${utxo.value} sats`);
+    
+    // Create P2PKH script for the UTXO
+    const addr = bsv.Address.fromString(address);
+    const p2pkhScript = bsv.Script.buildPublicKeyHashOut(address);
+    
+    // Format UTXO for BSV transaction
+    const formattedUTXO = {
+      txid: utxo.tx_hash,
+      vout: utxo.tx_pos,
+      address: address,
+      satoshis: utxo.value,
+      script: p2pkhScript.toHex()
+    };
+    
+    console.log(`UTXO Script: ${p2pkhScript.toHex()}`);
+    
+    // Create transaction - send smaller amount since we now have the result of previous tx
+    const sendAmount = Math.min(500, Math.floor(utxo.value * 0.8)); // Send 80% or 500 sats, whichever is smaller
+    const feePerKb = 10; // 10 sats per KB
+    
+    // Estimate transaction size (typical P2PKH transaction is ~225 bytes)
+    const estimatedSize = 225; 
+    const fee = Math.ceil((estimatedSize * feePerKb) / 1000);
+    const changeAmount = utxo.value - sendAmount - fee;
+    
+    if (changeAmount < 0) {
+      throw new Error(`Insufficient funds. Need ${sendAmount + fee}, have ${utxo.value}`);
+    }
+    
+    console.log(`\n💸 Creating transaction:`);
+    console.log(`Send: ${sendAmount} sats`);
+    console.log(`Fee rate: ${feePerKb} sats/KB`);
+    console.log(`Estimated fee: ${fee} sats`);
+    console.log(`Change: ${changeAmount} sats`);
+    
+    const transaction = new bsv.Transaction()
+      .from(formattedUTXO)
+      .to(address, sendAmount) // Send to ourselves
+      .change(address) // Change back to ourselves
+      .feePerKb(feePerKb) // Set fee rate
+      .sign(privateKey);
+    
+    console.log(`\n✅ Transaction created successfully!`);
+    console.log(`Transaction ID: ${transaction.id}`);
+    console.log(`Transaction size: ${transaction.toBuffer().length} bytes`);
+    
+    // Validation
+    console.log(`\n🔍 Validation:`);
+    const isValid = transaction.verify();
+    console.log(`Basic BSV validation: ${isValid ? '✅ VALID' : '❌ INVALID'}`);
+    
+    if (isValid) {
+      console.log(`Raw transaction: ${transaction.toString()}`);
+      
+      // Test broadcast
+      if (process.argv.includes('--broadcast')) {
+        console.log('\n📡 Broadcasting transaction...');
+        
+        try {
+          const response = await fetch('https://api.whatsonchain.com/v1/bsv/main/tx/raw', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ txhex: transaction.toString() })
+          });
+          
+          if (response.ok) {
+            const result = await response.text();
+            console.log(`✅ Transaction broadcast successful!`);
+            console.log(`Transaction ID: ${result}`);
+          } else {
+            const error = await response.text();
+            console.log(`❌ Broadcast failed: ${response.status} "${error}"`);
+          }
+        } catch (error) {
+          console.log(`❌ Broadcast failed: ${error.message}`);
+        }
+      } else {
+        console.log('\n💡 To broadcast: node simple_real_tx.js --broadcast');
+      }
+    }
+    
+  } catch (error) {
+    console.log(`❌ Error: ${error.message}`);
+  }
+}
+
+createSimpleTransaction();

package/tools/sv-sighash-harness.js

@@ -0,0 +1,123 @@
+'use strict'
+
+/**
+ * Shared harness for the SV Node transaction digest vectors in
+ * test/data/bitcoin-sv/sighash.json.
+ *
+ * Used by tools/sv-sighash-report.js (which reports) and
+ * test/consensus/sv-sighash-vectors.js (which ratchets), so the progress
+ * report and the regression gate cannot disagree about what passes.
+ *
+ * Row layout, from sighash_tests.cpp in the node:
+ *
+ *   [ raw_transaction, script, input_index, hashType,
+ *     signature_hash (regular), signature_hash (no forkid) ]
+ *
+ * Two columns pin the routing in SignatureHash() rather than one branch of it.
+ * The node takes BIP143 only when forkid is enabled AND requested AND the
+ * signature has not asked for the original algorithm:
+ *
+ *   if(enabledSighashForkid && sigHashType.hasForkId() && !sigHashType.hasChronicle())
+ *       return SignatureHashBIP143(...);
+ *   return SignatureHashOriginal(...);
+ *
+ * Note where the Chronicle bit is NOT consulted: the node does not ask whether
+ * Chronicle is enabled before honouring it. That gating lives in
+ * CheckSignatureEncoding, which rejects a signature carrying the bit outside
+ * Chronicle as SCRIPT_ERR_ILLEGAL_CHRONICLE — so such a signature never
+ * reaches a digest at all. For a row whose hash type sets 0x20 both columns
+ * are therefore identical, the original algorithm being taken either way, and
+ * that is what makes carrying both columns worth the trouble.
+ */
+
+const bsv = require('..')
+const Script = bsv.Script
+const BN = bsv.crypto.BN
+const Transaction = bsv.Transaction
+const Signature = bsv.crypto.Signature
+const Interpreter = bsv.Script.Interpreter
+const sighash = Transaction.Sighash
+
+const rawVectors = require('../test/data/bitcoin-sv/sighash.json')
+
+const FORKID = Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID
+const zeroBN = BN.Zero
+
+/** The first row of the corpus names the columns rather than carrying data. */
+function rows () {
+  return rawVectors.slice(1).filter(v => Array.isArray(v) && v.length >= 6)
+}
+
+/**
+ * Which digest the node produces for this hash type, under each flag setting.
+ * Named rather than inferred, so a routing regression reports as one.
+ */
+function algorithm (nhashtype, forkidEnabled) {
+  const t = nhashtype >>> 0
+  const bip143 = forkidEnabled &&
+    (t & Signature.SIGHASH_FORKID) !== 0 &&
+    (t & Signature.SIGHASH_CHRONICLE) === 0
+  return bip143 ? 'BIP143' : 'OTDA'
+}
+
+/**
+ * Run every vector. Each result is
+ *
+ *   { index, hashType, chronicleBit, algorithm, passed, reason }
+ *
+ * where `algorithm` is the one the node's routing selects with forkid enabled.
+ */
+function runAll () {
+  return rows().map(function (vector, i) {
+    const nhashtype = vector[3]
+    const chronicleBit = ((nhashtype >>> 0) & Signature.SIGHASH_CHRONICLE) !== 0
+
+    const base = {
+      index: i + 1,
+      hashType: nhashtype,
+      chronicleBit,
+      algorithm: algorithm(nhashtype, true)
+    }
+
+    // A fresh Script per call: the original algorithm removes code separators
+    // in place, so sharing one would let the first call change what the second
+    // is given.
+    function digest (flags) {
+      const tx = new Transaction(Buffer.from(vector[0], 'hex'))
+      return sighash.sighash(tx, nhashtype, vector[2],
+        Script(Buffer.from(vector[1], 'hex')), zeroBN, flags).toString('hex')
+    }
+
+    let regular, noForkId
+    try {
+      regular = digest(FORKID)
+      noForkId = digest(0)
+    } catch (e) {
+      return Object.assign(base, {
+        passed: false,
+        reason: 'threw: ' + String(e.message).slice(0, 70)
+      })
+    }
+
+    if (regular !== vector[4]) {
+      return Object.assign(base, {
+        passed: false,
+        reason: 'regular column: ' + regular + ' != ' + vector[4]
+      })
+    }
+    if (noForkId !== vector[5]) {
+      return Object.assign(base, {
+        passed: false,
+        reason: 'no-forkid column: ' + noForkId + ' != ' + vector[5]
+      })
+    }
+    return Object.assign(base, { passed: true, reason: null })
+  })
+}
+
+/** Rows whose two columns must agree, because the Chronicle bit is set. */
+function chronicleRows () {
+  return rows().filter(v => ((v[3] >>> 0) & Signature.SIGHASH_CHRONICLE) !== 0)
+}
+
+module.exports = { runAll, rows, chronicleRows, algorithm }