@smartledger/bsv 8.0.1 → 8.2.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 }

package/tools/sv-sighash-report.js

@@ -0,0 +1,71 @@
+'use strict'
+
+/**
+ * How far this library's transaction digest is from the reference node.
+ *
+ *   npm run vectors:sv-sighash
+ *   npm run vectors:sv-sighash -- --verbose
+ *
+ * There is no accept/reject direction to report here as there is for the
+ * script and transaction vectors: a digest either matches or it does not, and
+ * a wrong one is equally bad either way — it makes valid signatures unverifiable
+ * and, worse, signs something other than what the caller was shown.
+ *
+ * The breakdown by algorithm is the useful reading, because the failure this
+ * corpus is best at catching is a routing mistake rather than a hashing one.
+ */
+
+const harness = require('./sv-sighash-harness')
+
+const verbose = process.argv.indexOf('--verbose') !== -1
+const results = harness.runAll()
+
+const failing = results.filter(r => !r.passed)
+const passing = results.length - failing.length
+const chronicle = results.filter(r => r.chronicleBit)
+const bip143 = results.filter(r => r.algorithm === 'BIP143')
+const otda = results.filter(r => r.algorithm === 'OTDA')
+
+function line (label, subset) {
+  const bad = subset.filter(r => !r.passed).length
+  console.log('  ' + label.padEnd(34),
+    String(subset.length - bad).padStart(4) + '/' + String(subset.length).padEnd(5),
+    bad ? '  <- ' + bad + ' failing' : '')
+}
+
+console.log()
+console.log('=== SV Node v1.2.0 transaction digest vectors ===')
+console.log()
+console.log('vectors run   :', results.length, '(each checked on both columns)')
+console.log('passing       :', passing,
+  ' (' + (100 * passing / results.length).toFixed(1) + '%)')
+console.log('failing       :', failing.length)
+console.log()
+console.log('--- by routing ---')
+line('BIP-143 digest', bip143)
+line('original digest (OTDA)', otda)
+line('  of which set SIGHASH_CHRONICLE', chronicle)
+
+if (failing.length) {
+  const byReason = {}
+  failing.forEach(function (r) {
+    const key = String(r.reason).replace(/:.*/, '')
+    byReason[key] = (byReason[key] || 0) + 1
+  })
+  console.log()
+  console.log('--- failure reasons ---')
+  Object.keys(byReason).sort((a, b) => byReason[b] - byReason[a])
+    .forEach(k => console.log(String(byReason[k]).padStart(5), k))
+
+  console.log()
+  console.log('--- failing rows ---')
+  failing.slice(0, verbose ? failing.length : 10).forEach(function (r) {
+    console.log('  #' + String(r.index).padStart(4) +
+      '  hashType 0x' + (r.hashType >>> 0).toString(16).padStart(2, '0') +
+      '  ' + r.algorithm.padEnd(7) + r.reason)
+  })
+  if (!verbose && failing.length > 10) {
+    console.log('  ... and ' + (failing.length - 10) + ' more; pass --verbose')
+  }
+}
+console.log()

package/tools/sv-tx-harness.js

@@ -0,0 +1,172 @@
+'use strict'
+
+/**
+ * Harness for the SV Node transaction vectors in test/data/bitcoin-sv.
+ *
+ * These reach a level the script vectors do not. A script vector evaluates one
+ * unlocking script against one locking script; these deserialise a whole
+ * transaction, resolve each input against the outputs it claims to spend, and
+ * require every one of them to verify — across multiple inputs, with locktimes
+ * and sequence numbers in play, and with the transaction's own structural
+ * checks applied.
+ *
+ * Row layout, from the node's src/test/transaction_tests.cpp:
+ *
+ *   [ [[prevout hash, prevout n, scriptPubKey, amount?], ...],
+ *     serialized transaction,
+ *     flags ]
+ *
+ * A row in tx_valid.json must verify; one in tx_invalid.json must not. A
+ * prevout index of -1 is the node casting to an unsigned int, so it means
+ * 0xffffffff. The amount is present only where a row needs one.
+ */
+
+const bsv = require('..')
+const Transaction = bsv.Transaction
+const Interpreter = bsv.Script.Interpreter
+const BN = bsv.crypto.BN
+
+const harness = require('./sv-vector-harness')
+
+const validVectors = require('../test/data/bitcoin-sv/tx_valid.json')
+const invalidVectors = require('../test/data/bitcoin-sv/tx_invalid.json')
+
+/** A stable id for a row, so a list of known failures survives reordering. */
+function vectorId (raw) {
+  return harness.vectorId(raw)
+}
+
+/**
+ * Resolve each input against the output it spends and verify it.
+ *
+ * Returns { ok, reason }. `ok` is whether the transaction verifies overall,
+ * which requires the structural checks to pass and every non-null input to
+ * verify.
+ */
+function evaluate (row) {
+  const prevouts = {}
+  row[0].forEach(function (p) {
+    // -1 is the node's cast of an unsigned index.
+    const n = p[1] === -1 ? 0xffffffff : p[1]
+    prevouts[p[0] + ':' + n] = {
+      script: harness.fromBitcoindString(p[2]),
+      satoshis: p.length > 3 ? p[3] : 0
+    }
+  })
+
+  const tx = new Transaction(row[1])
+  const cls = harness.classifyFlags(row[2])
+
+  // The node runs these vectors at ProtocolEra::PreGenesis explicitly —
+  // transaction_tests.cpp says so — which is why one tx_valid row legitimately
+  // carries a P2SH output, an output Genesis stopped anyone creating. This
+  // library's verify() has no era and applies the pre-Genesis rules, which is
+  // what these vectors want.
+  let structural
+  try {
+    structural = tx.verify()
+  } catch (e) {
+    return { ok: false, reason: 'tx.verify threw: ' + String(e.message).slice(0, 60) }
+  }
+  if (structural !== true) {
+    return { ok: false, reason: 'tx.verify: ' + structural }
+  }
+
+  for (let i = 0; i < tx.inputs.length; i++) {
+    const input = tx.inputs[i]
+    if (input.isNull()) {
+      continue
+    }
+    const key = input.prevTxId.toString('hex') + ':' + input.outputIndex
+    const prevout = prevouts[key]
+    if (prevout === undefined) {
+      return { ok: false, reason: 'no prevout given for input ' + i }
+    }
+    const interp = new Interpreter()
+    const verified = interp.verify(
+      input.script, prevout.script, tx, i, cls.flags, new BN(prevout.satoshis)
+    )
+    if (!verified) {
+      return { ok: false, reason: 'input ' + i + ': ' + interp.errstr }
+    }
+  }
+
+  return { ok: true, reason: null }
+}
+
+/**
+ * Run both files. Each result is
+ *
+ *   { id, expected, ok, passed, reason, direction, comment }
+ *
+ * `direction` is 'accept' where we accepted a transaction the node rejects —
+ * the dangerous way round — and 'reject' for the converse.
+ */
+function runAll () {
+  const results = []
+
+  const run = function (vectors, expected) {
+    let comment = ''
+    vectors.forEach(function (raw) {
+      if (!Array.isArray(raw)) return
+      if (raw.length === 1) {
+        // A single-element row is a comment describing the rows below it.
+        comment = String(raw[0])
+        return
+      }
+
+      let got = null
+      let thrown = null
+      try {
+        got = evaluate(raw)
+      } catch (e) {
+        thrown = e
+      }
+
+      let reason = null
+      let direction = null
+      const ok = thrown === null && got.ok
+
+      if (thrown !== null) {
+        reason = 'threw: ' + String(thrown.message).slice(0, 70)
+        direction = expected ? 'reject' : null
+        if (!expected) {
+          // Throwing on a transaction the node also rejects is the right
+          // outcome reached untidily, not a consensus failure.
+          reason = null
+        }
+      } else if (ok !== expected) {
+        reason = expected
+          ? 'expected valid, rejected with ' + got.reason
+          : 'expected invalid, but ACCEPTED'
+        direction = expected ? 'reject' : 'accept'
+      }
+
+      results.push({
+        id: vectorId(raw),
+        expected,
+        ok,
+        passed: reason === null,
+        reason,
+        direction,
+        comment
+      })
+    })
+  }
+
+  run(validVectors, true)
+  run(invalidVectors, false)
+  return results
+}
+
+/** A one-line description of a row, for failure output. */
+function describe (result) {
+  return (result.expected ? 'tx_valid' : 'tx_invalid') +
+    (result.comment ? '  // ' + result.comment.slice(0, 70) : '')
+}
+
+module.exports = {
+  runAll,
+  evaluate,
+  describe
+}

package/tools/sv-tx-report.js

@@ -0,0 +1,43 @@
+'use strict'
+
+/**
+ * How far this interpreter is from the node at the transaction level.
+ *
+ *   npm run vectors:sv-tx
+ *
+ * A script vector evaluates one unlocking script against one locking script.
+ * These deserialise a whole transaction, resolve each input against the output
+ * it claims to spend, and require every one to verify — with locktimes,
+ * sequence numbers and multiple inputs in play. That reaches rules no single
+ * script can.
+ */
+
+const harness = require('./sv-tx-harness')
+
+const results = harness.runAll()
+const failing = results.filter(r => !r.passed)
+const accepts = failing.filter(r => r.direction === 'accept')
+const rejects = failing.filter(r => r.direction === 'reject')
+
+console.log()
+console.log('=== SV Node v1.2.0 transaction vectors ===')
+console.log()
+console.log('vectors run   :', results.length,
+  '(' + results.filter(r => r.expected).length + ' must verify, ' +
+  results.filter(r => !r.expected).length + ' must not)')
+console.log('passing       :', results.length - failing.length,
+  ' (' + (100 * (results.length - failing.length) / results.length).toFixed(1) + '%)')
+console.log()
+console.log('  false accepts (we accept, node rejects) :', accepts.length,
+  accepts.length ? '  <- the direction that can cost money' : '')
+console.log('  false rejects (we reject, node accepts) :', rejects.length)
+
+if (failing.length) {
+  console.log()
+  console.log('--- failing ---')
+  failing.forEach(function (r) {
+    console.log('  ' + r.id + '  ' + r.reason)
+    console.log('      ' + harness.describe(r))
+  })
+}
+console.log()