@smartledger/bsv 7.12.0 → 8.0.0

package/test/crypto/random.js

@@ -28,5 +28,78 @@ describe('Random', function () {
         }
       }
     })
+
+    // WebCrypto refuses more than 65,536 bytes per call. Before chunking, a request
+    // above that limit threw; a naive implementation that ignored the return size
+    // instead would hand back a zero-filled tail, which is far worse than throwing.
+    it('fills requests larger than the 65536-byte getRandomValues limit', function () {
+      var buf = Random.getRandomBuffer(70000)
+      buf.length.should.equal(70000)
+      // The tail comes from a second call — assert it is real entropy, not zero padding.
+      var tail = buf.subarray(65536)
+      tail.some(function (b) { return b !== 0 }).should.equal(true)
+      buf.subarray(0, 32).toString('hex').should.not.equal(tail.subarray(0, 32).toString('hex'))
+    })
+
+    it('handles the exact limit and one past it', function () {
+      Random.getRandomBuffer(65536).length.should.equal(65536)
+      Random.getRandomBuffer(65537).length.should.equal(65537)
+    })
+
+    // The backend is chosen by feature detection. This used to branch on
+    // `process.browser`, which is undefined in React Native, Deno, Workers and Bun —
+    // all of which then fell through to require('crypto').randomBytes. Where a partial
+    // crypto shim supplies a weak randomBytes, that produced guessable keys silently.
+    it('does not depend on process.browser', function () {
+      var saved = process.browser
+      try {
+        process.browser = undefined
+        Random.getRandomBuffer(16).length.should.equal(16)
+        process.browser = true
+        Random.getRandomBuffer(16).length.should.equal(16)
+      } finally {
+        process.browser = saved
+      }
+    })
+
+    it('prefers globalThis.crypto.getRandomValues when present', function () {
+      var calls = 0
+      var real = Object.getOwnPropertyDescriptor(globalThis, 'crypto')
+      try {
+        Object.defineProperty(globalThis, 'crypto', {
+          configurable: true,
+          value: {
+            getRandomValues: function (arr) {
+              calls++
+              for (var i = 0; i < arr.length; i++) arr[i] = (i * 7 + 3) & 0xff
+              return arr
+            }
+          }
+        })
+        var buf = Random.getRandomBuffer(4)
+        calls.should.equal(1)
+        buf.toString('hex').should.equal('030a1118')
+      } finally {
+        if (real) Object.defineProperty(globalThis, 'crypto', real)
+      }
+    })
+
+    // The throw matters as much as the detection: a key library must never return bytes
+    // it cannot vouch for. Verified in a child process because it has to remove both
+    // backends, which cannot be undone safely in-process.
+    it('throws rather than returning bytes when no CSPRNG exists', function () {
+      var out = require('child_process').spawnSync(process.execPath, ['-e', [
+        'var Module = require("module"), orig = Module._load',
+        'delete globalThis.crypto',
+        'Module._load = function (r) {',
+        '  if (r === "crypto") { var e = new Error("no crypto"); e.code = "MODULE_NOT_FOUND"; throw e }',
+        '  return orig.apply(this, arguments)',
+        '}',
+        'var R = require(' + JSON.stringify(require.resolve('../../lib/crypto/random.js')) + ')',
+        'try { R.getRandomBuffer(32); console.log("RETURNED") }',
+        'catch (e) { console.log("THREW") }'
+      ].join('\n')], { encoding: 'utf8' })
+      out.stdout.trim().should.equal('THREW')
+    })
   })
 })

package/test/data/bitcoin-sv/README.md

@@ -0,0 +1,170 @@
+# SV Node consensus vectors
+
+Consensus test vectors copied verbatim from the reference node implementation.
+These are the specification this library is measured against — do not hand-edit
+them. To update, re-copy from a node tag and record the new provenance here.
+
+| field | value |
+| --- | --- |
+| source | [`bitcoin-sv/bitcoin-sv`](https://github.com/bitcoin-sv/bitcoin-sv) `src/test/data` |
+| tag | `v1.2.0` (Chronicle); byte-identical in `v1.2.2`, the current release |
+| commit | `60dc6a3f2547eeaaa3a605e5a69a9fc8686b0a25` |
+| retrieved | 2026-08-11 |
+| licence | MIT (same as this library) |
+
+Genesis activated at block **620,538** on **2020-02-04**; Chronicle at block
+**943,816** on **2026-04-07**.
+
+## Files
+
+| file | rows run | covers | gate |
+| --- | --- | --- | --- |
+| `script_tests.json` | 1483 | script evaluation, including Genesis and Chronicle rules | `test/consensus/sv-script-vectors.js` |
+| `sighash.json` | 1000 | transaction digest algorithm | `test/consensus/sv-sighash-vectors.js` |
+| `tx_valid.json` | 93 | transactions that must validate | `test/consensus/sv-tx-vectors.js` |
+| `tx_invalid.json` | 68 | transactions that must be rejected | `test/consensus/sv-tx-vectors.js` |
+| `base58_keys_valid.json` | 50 | address and WIF encoding | `test/consensus/base58-vectors.js` |
+| `base58_keys_invalid.json` | 50 | malformed address rejection | `test/consensus/base58-vectors.js` |
+| `base58_encode_decode.json` | 12 | raw base58 round-trips | `test/consensus/base58-vectors.js` |
+
+Every one of these is exercised, and every one passes completely. There is no
+known-failure list and nothing is exempted, so any list added later should read
+as a decision someone made rather than as inherited debt.
+
+These supersede the older pre-Genesis vectors in `test/data/bitcoind`, which are
+inherited from the upstream fork and encode consensus rules the network
+abandoned in 2020. Those are retained for now so the two can be diffed, but
+they are **not** a valid consensus reference. Where they disagree with these,
+these win.
+
+## Measuring the gap
+
+    npm run vectors:sv                  # script vectors
+    npm run vectors:sv-tx               # transaction vectors
+    npm run vectors:sv-sighash          # transaction digest vectors
+
+Each takes `-- --verbose` for the full failing list. Every report shares its
+harness with the corresponding gate under `test/consensus`, so the progress
+figure and the regression gate cannot disagree about what passes.
+
+The script and transaction reports separate the two directions of failure. A
+**false accept** — accepting a script the node rejects — is the direction that
+can cost money, and is held at zero outright. A false reject only costs a
+transaction. The digest report makes no such distinction: a wrong digest is
+equally bad either way, since it both makes valid signatures unverifiable and
+signs something other than what the caller was shown.
+
+## Row layout, and two columns that are easy to get wrong
+
+Defined by `script_json_test` in the node's `src/test/script_tests.cpp`:
+
+    [ [nValue]?, txnVersion, scriptSig, scriptPubKey, flags, expected, comment? ]
+
+- **`nValue`** is present only when a row needs an input amount, and it is
+  wrapped in an **array**. It states whole coins; the transaction carries
+  satoshis, so multiply by 1e8 (the node's `AmountFromValue`).
+- **`txnVersion`** is the *spending* transaction's version, and is present on
+  every row. Chronicle gates its malleability relaxations on version > 1, so
+  this column is consensus-relevant — it is not padding, and it is not an
+  amount. Mistaking it for one changes the crediting transaction's value, which
+  changes its txid, which changes the sighash, which silently breaks every
+  signature-checking vector in the corpus.
+
+The crediting transaction is always version 1; only the spending transaction
+carries the version under test. Both use locktime 0 and a final sequence, and
+the crediting input's scriptSig is `OP_0 OP_0`.
+
+## Flags, and one place this fork differs
+
+Flags are mapped by **name**, never by value. This library assigns
+`MONOLITH_OPCODES` and `MAGNETIC_OPCODES` to bits `1<<18` and `1<<19`, which
+are the bits the node uses for `SCRIPT_GENESIS` and `SCRIPT_UTXO_AFTER_GENESIS`
+— mapping by value would quietly run vectors under the wrong rules while
+appearing to pass.
+
+The corpus never names `MONOLITH` or `MAGNETIC`, because the node has no such
+flags: those opcodes were restored on BSV in 2018 and are simply enabled. This
+library still gates them, so the harness enables them for every row; otherwise
+the report would be dominated by that one difference rather than by consensus.
+The gating is itself a divergence from BSV and is worth removing. It is
+compensated for here rather than hidden, so that the figures mean what they
+say.
+
+## Transaction vectors
+
+`tx_valid.json` and `tx_invalid.json` go a level above the script corpus: a
+whole transaction is deserialised, each input resolved against the output it
+claims to spend, and every one required to verify — with locktimes, sequence
+numbers and multiple inputs in play.
+
+That level is worth having. It found a Genesis rule the script corpus cannot
+reach: `OP_CHECKLOCKTIMEVERIFY` and `OP_CHECKSEQUENCEVERIFY` revert to
+upgradable NOPs after Genesis, and without that, four transactions the network
+accepts were being rejected. The behaviour only appears once a real nLockTime
+and sequence exist, so no single-script vector exercises it.
+
+## Digest vectors
+
+Each row of `sighash.json` carries **two** expected digests for the same inputs
+— one with forkid enabled and one without — which pins the routing in
+`SignatureHash()` rather than one branch of it.
+
+That second column earned its keep. It found 260 rows where this library
+honoured `SIGHASH_CHRONICLE` only when `SCRIPT_ENABLE_CHRONICLE` was also set,
+where the node routes on the bit alone and instead rejects a signature carrying
+that bit outside Chronicle in `CheckSignatureEncoding`, as
+`SCRIPT_ERR_ILLEGAL_CHRONICLE`. Rejected, not reinterpreted.
+
+For a row whose hash type sets `0x20`, both columns are identical — the
+original algorithm is taken either way. 511 of the 1000 rows are of that kind,
+so a gate checking only one column would be blind to half the corpus.
+
+## Base58
+
+The key vectors are content-identical to the bitcoind copies already used by
+`test/address.js` and `test/privatekey.js` — same 50 rows, different whitespace
+— but `base58_encode_decode.json` has no counterpart there, and nothing else
+pins the raw codec against the node in both directions.
+
+Note what the invalid-key vectors actually claim: that a string is neither a
+valid address nor a valid WIF. Several carry a perfectly good checksum and are
+simply the wrong length or version, so `Base58Check` accepts them and the layer
+above is what refuses. A test asserting the checksum layer rejects them would
+be asserting something the corpus does not say.
+
+## Result codes
+
+Matching the node's accept/reject outcome is not the same as failing for the
+node's *reason*, and the gap between the two is where bugs live. Comparing the
+result code of all 600 rejected vectors found four, each of which left the
+script failing — so the outcome check stayed green through every one:
+
+- a div-by-zero guard comparing a `BN` against the number `0`, so it never
+  fired and bn.js asserted instead
+- script number decoding throwing past the evaluator into a generic catch,
+  which is what 78 of the four hundred were
+- a truncated `PUSHDATA` doing the same
+- `OP_NUM2BIN` checking only the upper bound of its size argument, so a
+  negative size reported the wrong failure
+
+All 600 now match: 491 exactly, and 109 through `ERROR_CODE_ALIASES` in
+`tools/sv-vector-harness.js` — names this library reports more narrowly than
+the node, such as `EVAL_FALSE_IN_STACK` for `EVAL_FALSE`. That table is a short
+statement of intent rather than a list of exempted vectors, and it ratchets
+both ways: an unlisted mismatch fails, and so does an alias no vector produces
+any more, so an exemption cannot outlive its reason. Anything added to it
+should be a name that says *more* than the node's, never a different failure
+wearing its label.
+
+## What the vectors cannot reach
+
+Passing this corpus completely is not the same as matching the node. Reading
+the code alongside it found `OP_CAT` capping its result at the static 520-byte
+element size rather than the era-derived one, so after Genesis it rejected
+concatenations the network accepts — built from two 300-byte halves that are
+each legal on their own. It is the one opcode that can grow an element past the
+cap without ever pushing an oversized element, which is why no vector here
+covers it. `test/script/genesis_limits.js` holds it instead.
+
+Where a rule has no vector, the test that holds it belongs somewhere that says
+so.

package/test/data/bitcoin-sv/base58_encode_decode.json

@@ -0,0 +1,14 @@
+[
+["", ""],
+["61", "2g"],
+["626262", "a3gV"],
+["636363", "aPEr"],
+["73696d706c792061206c6f6e6720737472696e67", "2cFupjhnEsSn59qHXstmK2ffpLv2"],
+["00eb15231dfceb60925886b67d065299925915aeb172c06647", "1NS17iag9jJgTHD1VXjvLCEnZuQ3rJDE9L"],
+["516b6fcd0f", "ABnLTmg"],
+["bf4f89001e670274dd", "3SEo3LWLoPntC"],
+["572e4794", "3EFU7m"],
+["ecac89cad93923c02321", "EJDM8drfXA6uyA"],
+["10c8511e", "Rt5zm"],
+["00000000000000000000", "1111111111"]
+]

package/test/data/bitcoin-sv/base58_keys_invalid.json

@@ -0,0 +1,152 @@
+[
+    [
+        ""
+    ],
+    [
+        "x"
+    ],
+    [
+        "37qgekLpCCHrQuSjvX3fs496FWTGsHFHizjJAs6NPcR47aefnnCWECAhHV6E3g4YN7u7Yuwod5Y"
+    ],
+    [
+        "dzb7VV1Ui55BARxv7ATxAtCUeJsANKovDGWFVgpTbhq9gvPqP3yv"
+    ],
+    [
+        "MuNu7ZAEDFiHthiunm7dPjwKqrVNCM3mAz6rP9zFveQu14YA8CxExSJTHcVP9DErn6u84E6Ej7S"
+    ],
+    [
+        "rPpQpYknyNQ5AEHuY6H8ijJJrYc2nDKKk9jjmKEXsWzyAQcFGpDLU2Zvsmoi8JLR7hAwoy3RQWf"
+    ],
+    [
+        "4Uc3FmN6NQ6zLBK5QQBXRBUREaaHwCZYsGCueHauuDmJpZKn6jkEskMB2Zi2CNgtb5r6epWEFfUJq"
+    ],
+    [
+        "7aQgR5DFQ25vyXmqZAWmnVCjL3PkBcdVkBUpjrjMTcghHx3E8wb"
+    ],
+    [
+        "17QpPprjeg69fW1DV8DcYYCKvWjYhXvWkov6MJ1iTTvMFj6weAqW7wybZeH57WTNxXVCRH4veVs"
+    ],
+    [
+        "KxuACDviz8Xvpn1xAh9MfopySZNuyajYMZWz16Dv2mHHryznWUp3"
+    ],
+    [
+        "7nK3GSmqdXJQtdohvGfJ7KsSmn3TmGqExug49583bDAL91pVSGq5xS9SHoAYL3Wv3ijKTit65th"
+    ],
+    [
+        "cTivdBmq7bay3RFGEBBuNfMh2P1pDCgRYN2Wbxmgwr4ki3jNUL2va"
+    ],
+    [
+        "gjMV4vjNjyMrna4fsAr8bWxAbwtmMUBXJS3zL4NJt5qjozpbQLmAfK1uA3CquSqsZQMpoD1g2nk"
+    ],
+    [
+        "emXm1naBMoVzPjbk7xpeTVMFy4oDEe25UmoyGgKEB1gGWsK8kRGs"
+    ],
+    [
+        "7VThQnNRj1o3Zyvc7XHPRrjDf8j2oivPTeDXnRPYWeYGE4pXeRJDZgf28ppti5hsHWXS2GSobdqyo"
+    ],
+    [
+        "1G9u6oCVCPh2o8m3t55ACiYvG1y5BHewUkDSdiQarDcYXXhFHYdzMdYfUAhfxn5vNZBwpgUNpso"
+    ],
+    [
+        "31QQ7ZMLkScDiB4VyZjuptr7AEc9j1SjstF7pRoLhHTGkW4Q2y9XELobQmhhWxeRvqcukGd1XCq"
+    ],
+    [
+        "DHqKSnpxa8ZdQyH8keAhvLTrfkyBMQxqngcQA5N8LQ9KVt25kmGN"
+    ],
+    [
+        "2LUHcJPbwLCy9GLH1qXmfmAwvadWw4bp4PCpDfduLqV17s6iDcy1imUwhQJhAoNoN1XNmweiJP4i"
+    ],
+    [
+        "7USRzBXAnmck8fX9HmW7RAb4qt92VFX6soCnts9s74wxm4gguVhtG5of8fZGbNPJA83irHVY6bCos"
+    ],
+    [
+        "1DGezo7BfVebZxAbNT3XGujdeHyNNBF3vnficYoTSp4PfK2QaML9bHzAMxke3wdKdHYWmsMTJVu"
+    ],
+    [
+        "2D12DqDZKwCxxkzs1ZATJWvgJGhQ4cFi3WrizQ5zLAyhN5HxuAJ1yMYaJp8GuYsTLLxTAz6otCfb"
+    ],
+    [
+        "8AFJzuTujXjw1Z6M3fWhQ1ujDW7zsV4ePeVjVo7D1egERqSW9nZ"
+    ],
+    [
+        "163Q17qLbTCue8YY3AvjpUhotuaodLm2uqMhpYirsKjVqnxJRWTEoywMVY3NbBAHuhAJ2cF9GAZ"
+    ],
+    [
+        "2MnmgiRH4eGLyLc9eAqStzk7dFgBjFtUCtu"
+    ],
+    [
+        "461QQ2sYWxU7H2PV4oBwJGNch8XVTYYbZxU"
+    ],
+    [
+        "2UCtv53VttmQYkVU4VMtXB31REvQg4ABzs41AEKZ8UcB7DAfVzdkV9JDErwGwyj5AUHLkmgZeobs"
+    ],
+    [
+        "cSNjAsnhgtiFMi6MtfvgscMB2Cbhn2v1FUYfviJ1CdjfidvmeW6mn"
+    ],
+    [
+        "gmsow2Y6EWAFDFE1CE4Hd3Tpu2BvfmBfG1SXsuRARbnt1WjkZnFh1qGTiptWWbjsq2Q6qvpgJVj"
+    ],
+    [
+        "nksUKSkzS76v8EsSgozXGMoQFiCoCHzCVajFKAXqzK5on9ZJYVHMD5CKwgmX3S3c7M1U3xabUny"
+    ],
+    [
+        "L3favK1UzFGgdzYBF2oBT5tbayCo4vtVBLJhg2iYuMeePxWG8SQc"
+    ],
+    [
+        "7VxLxGGtYT6N99GdEfi6xz56xdQ8nP2dG1CavuXx7Rf2PrvNMTBNevjkfgs9JmkcGm6EXpj8ipyPZ"
+    ],
+    [
+        "2mbZwFXF6cxShaCo2czTRB62WTx9LxhTtpP"
+    ],
+    [
+        "dB7cwYdcPSgiyAwKWL3JwCVwSk6epU2txw"
+    ],
+    [
+        "HPhFUhUAh8ZQQisH8QQWafAxtQYju3SFTX"
+    ],
+    [
+        "4ctAH6AkHzq5ioiM1m9T3E2hiYEev5mTsB"
+    ],
+    [
+        "Hn1uFi4dNexWrqARpjMqgT6cX1UsNPuV3cHdGg9ExyXw8HTKadbktRDtdeVmY3M1BxJStiL4vjJ"
+    ],
+    [
+        "Sq3fDbvutABmnAHHExJDgPLQn44KnNC7UsXuT7KZecpaYDMU9Txs"
+    ],
+    [
+        "6TqWyrqdgUEYDQU1aChMuFMMEimHX44qHFzCUgGfqxGgZNMUVWJ"
+    ],
+    [
+        "giqJo7oWqFxNKWyrgcBxAVHXnjJ1t6cGoEffce5Y1y7u649Noj5wJ4mmiUAKEVVrYAGg2KPB3Y4"
+    ],
+    [
+        "cNzHY5e8vcmM3QVJUcjCyiKMYfeYvyueq5qCMV3kqcySoLyGLYUK"
+    ],
+    [
+        "37uTe568EYc9WLoHEd9jXEvUiWbq5LFLscNyqvAzLU5vBArUJA6eydkLmnMwJDjkL5kXc2VK7ig"
+    ],
+    [
+        "EsYbG4tWWWY45G31nox838qNdzksbPySWc"
+    ],
+    [
+        "nbuzhfwMoNzA3PaFnyLcRxE9bTJPDkjZ6Rf6Y6o2ckXZfzZzXBT"
+    ],
+    [
+        "cQN9PoxZeCWK1x56xnz6QYAsvR11XAce3Ehp3gMUdfSQ53Y2mPzx"
+    ],
+    [
+        "1Gm3N3rkef6iMbx4voBzaxtXcmmiMTqZPhcuAepRzYUJQW4qRpEnHvMojzof42hjFRf8PE2jPde"
+    ],
+    [
+        "2TAq2tuN6x6m233bpT7yqdYQPELdTDJn1eU"
+    ],
+    [
+        "ntEtnnGhqPii4joABvBtSEJG6BxjT2tUZqE8PcVYgk3RHpgxgHDCQxNbLJf7ardf1dDk2oCQ7Cf"
+    ],
+    [
+        "Ky1YjoZNgQ196HJV3HpdkecfhRBmRZdMJk89Hi5KGfpfPwS2bUbfd"
+    ],
+    [
+        "2A1q1YsMZowabbvta7kTy2Fd6qN4r5ZCeG3qLpvZBMzCixMUdkN2Y4dHB1wPsZAeVXUGD83MfRED"
+    ]
+]