@smartledger/bsv 9.0.0 → 9.1.1

package/test/notaryhash/verify.js

@@ -1,342 +0,0 @@
-'use strict'
-
-/* global describe, it, before */
-
-// BRC-220 verification: the three checks the spec requires, wired together.
-//
-// The plan's stance is that each check must have a test that defeats it IN ISOLATION —
-// a suite where only the conjunction is tested cannot tell you that check 3 was never
-// wired up, because checks 1 and 2 carry the verdict. Each of the three below is broken
-// on its own with the others left intact.
-
-require('chai').should()
-var bsv = require('../..')
-var NH = require('../../lib/notaryhash')
-var Encoding = require('../../lib/notaryhash/encoding')
-var Hash = require('../../lib/crypto/hash')
-var BN = require('../../lib/crypto/bn')
-
-// The Bitcoin genesis coinbase — one of the reference vectors the spec names, and the
-// only check here that is external to this implementation.
-var GENESIS_COINBASE_RAWTX =
-  '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff' +
-  '4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72' +
-  '206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff' +
-  '0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f' +
-  '61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000'
-var GENESIS_COINBASE_TXID = '4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b'
-
-function rawSig (sig) {
-  return Buffer.concat([
-    sig.r.toArrayLike(Buffer, 'be', 32),
-    sig.s.toArrayLike(Buffer, 'be', 32)
-  ])
-}
-
-describe('BRC-220 verification', function () {
-  var key, publicKey, payloadHash, signature, certificate, header, rawTx
-
-  before(function () {
-    key = bsv.PrivateKey.fromRandom()
-    publicKey = key.toPublicKey().toBuffer()
-    payloadHash = Hash.sha256(Buffer.from('the document nobody sees'))
-
-    // The signer signs the 32-byte payloadHash DIRECTLY — spec §Algorithms. No endian
-    // option: the digest IS the scalar, big-endian. Until 8.3.1 this line passed
-    // `endian: 'little'` while the comment above it said "directly", and the suite
-    // reversed to match, so the two agreed with each other and with nothing else.
-    var ecdsa = bsv.crypto.ECDSA().set({ hashbuf: payloadHash, privkey: key })
-    ecdsa.sign()
-    signature = rawSig(ecdsa.sig)
-
-    var createdAt = '2026-08-16T00:00:00.000Z'
-    var proofHash = Encoding.proofHash({
-      algorithm: 'ECDSA-secp256k1',
-      hashAlgorithm: 'SHA-256',
-      payloadHash: payloadHash,
-      publicKey: publicKey,
-      signature: signature,
-      createdAtUnix: Encoding.toUnixSeconds(createdAt)
-    })
-
-    // A real transaction carrying the record, so the anchor check has something to read.
-    var tx = new bsv.Transaction()
-    tx.addOutput(new bsv.Transaction.Output({
-      script: NH.Script.build({
-        mode: NH.MODE.FULL,
-        algorithm: 'ECDSA-secp256k1',
-        hashAlgorithm: 'SHA-256',
-        payloadHash: payloadHash,
-        proofHash: proofHash,
-        publicKey: publicKey,
-        signature: signature
-      }),
-      satoshis: 0
-    }))
-    rawTx = tx.toString()
-    var txid = NH.txidFromRawTx(rawTx)
-
-    // A single-transaction block: the Merkle root is the txid itself, so an empty path
-    // folds to it. Proof of work is not required for these fixtures.
-    header = new bsv.BlockHeader({
-      version: 1,
-      prevHash: Buffer.alloc(32),
-      merkleRoot: Buffer.from(txid, 'hex').reverse(),
-      time: 1786838400,
-      bits: 0x1d00ffff,
-      nonce: 0
-    })
-
-    certificate = NH.Certificate.attachSPV(
-      NH.Certificate.build({
-        mode: NH.MODE.FULL,
-        algorithm: 'ECDSA-secp256k1',
-        hashAlgorithm: 'SHA-256',
-        payloadHash: payloadHash,
-        publicKey: publicKey,
-        signature: signature,
-        createdAt: createdAt,
-        anchor: { txid: txid, blockHeight: 800000 }
-      }),
-      { rawTx: rawTx, blockHash: header.id, blockHeight: 800000, merkleProof: { index: 0, nodes: [] } }
-    )
-  })
-
-  var OPTS = function () { return { header: header, requirePow: false } }
-
-  describe('the happy path', function () {
-    it('passes all three checks', function () {
-      var report = NH.verify(certificate, OPTS())
-      report.signature.should.equal(true)
-      report.proofIntegrity.should.equal(true)
-      report.anchor.should.equal(true, JSON.stringify(report.errors))
-      report.valid.should.equal(true)
-    })
-
-    it('isValid returns a strict boolean', function () {
-      NH.isValid(certificate, OPTS()).should.equal(true)
-      NH.isValid(certificate, OPTS()).should.be.a('boolean')
-    })
-  })
-
-  // Each check defeated on its own, with the other two left working.
-  describe('check 1 — signature, defeated in isolation', function () {
-    it('fails when the signature is forged, while proof integrity still passes', function () {
-      var forged = Object.assign({}, certificate, { signature: 'aa'.repeat(64) })
-      var report = NH.verify(forged, OPTS())
-      report.signature.should.equal(false)
-      report.valid.should.equal(false)
-    })
-
-    it('fails when the certificate names a key that did not sign', function () {
-      var other = bsv.PrivateKey.fromRandom().toPublicKey().toBuffer()
-      var swapped = Object.assign({}, certificate, { publicKey: other.toString('hex') })
-      NH.verify(swapped, OPTS()).signature.should.equal(false)
-    })
-
-    // An unregistered algorithm must FAIL, never fall through to a default. Falling
-    // through to ECDSA for an ML-DSA certificate would be catastrophic.
-    it('fails for an algorithm no suite is registered for', function () {
-      var pq = Object.assign({}, certificate, { algorithm: 'ML-DSA-65' })
-      NH.verifySignature(pq).should.equal(false)
-      NH.Suites.verify('ML-DSA-65', Buffer.alloc(32), Buffer.alloc(64), Buffer.alloc(33))
-        .should.equal(false)
-    })
-  })
-
-  describe('check 2 — proof integrity, defeated in isolation', function () {
-    // The signature still verifies here: payloadHash, signature and publicKey are
-    // untouched. Only proofHash is a lie, and only check 2 can see it.
-    it('fails when proofHash is replaced, while the signature still verifies', function () {
-      var lying = Object.assign({}, certificate, { proofHash: '00'.repeat(32) })
-      var report = NH.verify(lying, OPTS())
-      report.signature.should.equal(true)
-      report.proofIntegrity.should.equal(false)
-      report.valid.should.equal(false)
-    })
-
-    it('fails when createdAt is moved after issuance', function () {
-      var moved = Object.assign({}, certificate, { createdAt: '2026-08-17T00:00:00.000Z' })
-      NH.verify(moved, OPTS()).proofIntegrity.should.equal(false)
-    })
-  })
-
-  describe('check 3 — anchor, defeated in isolation', function () {
-    // Signature and proof integrity both still pass; only the anchor is wrong.
-    it('fails when rawTx does not hash to anchor.txid', function () {
-      var wrongTxid = Object.assign({}, certificate, {
-        anchor: { txid: 'ff'.repeat(32), blockHeight: 800000 }
-      })
-      var report = NH.verify(wrongTxid, OPTS())
-      report.signature.should.equal(true)
-      report.proofIntegrity.should.equal(true)
-      report.anchor.should.equal(false)
-      report.errors.should.include('rawTx does not hash to anchor.txid')
-    })
-
-    it('fails when the merkle proof does not fold to the header root', function () {
-      var otherHeader = new bsv.BlockHeader({
-        version: 1,
-        prevHash: Buffer.alloc(32),
-        merkleRoot: Buffer.alloc(32, 0x77),
-        time: 1786838400,
-        bits: 0x1d00ffff,
-        nonce: 0
-      })
-      NH.verifyAnchorSPV(certificate, { header: otherHeader, requirePow: false })
-        .valid.should.equal(false)
-    })
-
-    it('fails when the transaction carries no NotaryHash record', function () {
-      var empty = new bsv.Transaction()
-      empty.addOutput(new bsv.Transaction.Output({
-        script: bsv.Script.buildDataOut('nothing to see'), satoshis: 0
-      }))
-      var swapped = Object.assign({}, certificate, {
-        spv: Object.assign({}, certificate.spv, { rawTx: empty.toString() })
-      })
-      NH.verifyAnchorSPV(swapped, OPTS()).errors.join(' ').should.match(/no NotaryHash record|does not hash/)
-    })
-
-    // THE anchor check. The certificate is internally perfect and the transaction is
-    // real; it simply is not the transaction this certificate describes.
-    it('fails when the on-chain record describes a different payload', function () {
-      var otherPayload = Hash.sha256(Buffer.from('a different document'))
-      var tx = new bsv.Transaction()
-      tx.addOutput(new bsv.Transaction.Output({
-        script: NH.Script.build({
-          mode: NH.MODE.FULL,
-          algorithm: 'ECDSA-secp256k1',
-          hashAlgorithm: 'SHA-256',
-          payloadHash: otherPayload,
-          proofHash: Buffer.alloc(32, 0x01),
-          publicKey: Buffer.from(certificate.publicKey, 'hex'),
-          signature: Buffer.from(certificate.signature, 'hex')
-        }),
-        satoshis: 0
-      }))
-      var raw = tx.toString()
-      var txid = NH.txidFromRawTx(raw)
-      var h = new bsv.BlockHeader({
-        version: 1,
-        prevHash: Buffer.alloc(32),
-        merkleRoot: Buffer.from(txid, 'hex').reverse(),
-        time: 1786838400,
-        bits: 0x1d00ffff,
-        nonce: 0
-      })
-      var mismatched = Object.assign({}, certificate, {
-        anchor: { txid: txid, blockHeight: 800000 },
-        spv: Object.assign({}, certificate.spv, { rawTx: raw })
-      })
-      var report = NH.verifyAnchorSPV(mismatched, { header: h, requirePow: false })
-      report.valid.should.equal(false)
-      report.errors.should.include('on-chain record does not match the certificate')
-    })
-
-    // Not supplying a header is not a pass. This is the trust the spec exists to remove.
-    it('refuses to pass without a block header', function () {
-      var report = NH.verifyAnchorSPV(certificate, {})
-      report.valid.should.equal(false)
-      report.errors.join(' ').should.match(/block header is required/)
-    })
-
-    it('reports a missing SPV envelope rather than ignoring the anchor', function () {
-      var noSpv = Object.assign({}, certificate)
-      delete noSpv.spv
-      NH.verifyAnchorSPV(noSpv, OPTS()).errors.should.include('certificate has no SPV envelope')
-    })
-  })
-
-  describe('reporting', function () {
-    it('names which check failed rather than saying only "invalid"', function () {
-      var forged = Object.assign({}, certificate, { signature: 'aa'.repeat(64) })
-      NH.verify(forged, OPTS()).errors.should.include('signature does not verify')
-    })
-
-    it('reports shape problems before attempting the checks', function () {
-      var report = NH.verify({ protocol: 'NotaryHash' }, OPTS())
-      report.shape.length.should.be.above(0)
-      report.signature.should.equal(false)
-      report.valid.should.equal(false)
-    })
-
-    // skipAnchor is for offline triage and must never report a valid certificate.
-    it('never reports valid when the anchor was skipped', function () {
-      var report = NH.verify(certificate, { skipAnchor: true })
-      report.signature.should.equal(true)
-      report.proofIntegrity.should.equal(true)
-      report.valid.should.equal(false)
-      report.errors.join(' ').should.match(/NOT verified/)
-    })
-  })
-
-  describe('txidFromRawTx', function () {
-    // External check: the spec names this reference vector, and it is the one assertion
-    // here that does not depend on our own construction being right.
-    it('matches the Bitcoin genesis coinbase transaction', function () {
-      NH.txidFromRawTx(GENESIS_COINBASE_RAWTX).should.equal(GENESIS_COINBASE_TXID)
-    })
-
-    it('accepts a Buffer as well as hex', function () {
-      NH.txidFromRawTx(Buffer.from(GENESIS_COINBASE_RAWTX, 'hex')).should.equal(GENESIS_COINBASE_TXID)
-    })
-  })
-
-  describe('suite registry', function () {
-    it('registers a caller-supplied suite and uses it', function () {
-      var called = false
-      NH.registerSuite('TEST-SUITE', {
-        verify: function () { called = true; return true }
-      })
-      NH.Suites.verify('TEST-SUITE', Buffer.alloc(32), Buffer.alloc(8), Buffer.alloc(8))
-        .should.equal(true)
-      called.should.equal(true)
-      NH.Suites.unregister('TEST-SUITE')
-    })
-
-    // A suite returning a truthy object must not smuggle a pass through — that is the
-    // defect class this codebase has fixed most often.
-    it('coerces a truthy non-boolean suite result to false', function () {
-      NH.registerSuite('TRUTHY-SUITE', { verify: function () { return { ok: true } } })
-      NH.Suites.verify('TRUTHY-SUITE', Buffer.alloc(32), Buffer.alloc(8), Buffer.alloc(8))
-        .should.equal(false)
-      NH.Suites.unregister('TRUTHY-SUITE')
-    })
-
-    it('survives a throwing suite without reporting a pass', function () {
-      NH.registerSuite('THROWS', { verify: function () { throw new Error('boom') } })
-      NH.Suites.verify('THROWS', Buffer.alloc(32), Buffer.alloc(8), Buffer.alloc(8))
-        .should.equal(false)
-      NH.Suites.unregister('THROWS')
-    })
-
-    it('ships only ECDSA-secp256k1 by default', function () {
-      NH.Suites.list().should.deep.equal(['ECDSA-secp256k1'])
-    })
-  })
-
-  describe('ECDSA suite specifics', function () {
-    it('requires low-S, rejecting the malleated form', function () {
-      var sig = bsv.crypto.Signature.fromDER(
-        new bsv.crypto.Signature(
-          BN.fromBuffer(Buffer.from(certificate.signature, 'hex').slice(0, 32)),
-          BN.fromBuffer(Buffer.from(certificate.signature, 'hex').slice(32))
-        ).toDER()
-      )
-      var high = Buffer.concat([
-        sig.r.toArrayLike(Buffer, 'be', 32),
-        bsv.crypto.Point.getN().sub(sig.s).toArrayLike(Buffer, 'be', 32)
-      ])
-      NH.Suites.verify('ECDSA-secp256k1', payloadHash, high, publicKey).should.equal(false)
-    })
-
-    it('accepts DER for the legacy encoding', function () {
-      var raw = Buffer.from(certificate.signature, 'hex')
-      var der = new bsv.crypto.Signature(
-        BN.fromBuffer(raw.slice(0, 32)), BN.fromBuffer(raw.slice(32))
-      ).toDER()
-      NH.Suites.verify('ECDSA-secp256k1', payloadHash, der, publicKey).should.equal(true)
-    })
-  })
-})

package/test/opcode.js

@@ -1,186 +0,0 @@
-'use strict'
-
-var chai = require('chai')
-var should = chai.should()
-var expect = chai.expect
-var bsv = require('..')
-var Opcode = bsv.Opcode
-
-describe('Opcode', function () {
-  it('should create a new Opcode', function () {
-    var opcode = new Opcode(5)
-    should.exist(opcode)
-  })
-
-  it('should convert to a string with this handy syntax', function () {
-    Opcode(0).toString().should.equal('OP_0')
-    Opcode(96).toString().should.equal('OP_16')
-    Opcode(97).toString().should.equal('OP_NOP')
-  })
-
-  it('should convert to a number with this handy syntax', function () {
-    Opcode('OP_0').toNumber().should.equal(0)
-    Opcode('OP_16').toNumber().should.equal(96)
-    Opcode('OP_NOP').toNumber().should.equal(97)
-  })
-
-  describe('#fromNumber', function () {
-    it('should work for 0', function () {
-      Opcode.fromNumber(0).num.should.equal(0)
-    })
-    it('should fail for non-number', function () {
-      Opcode.fromNumber.bind(null, 'a string').should.throw('Invalid Argument')
-    })
-  })
-
-  describe('#set', function () {
-    it('should work for object', function () {
-      Opcode(42).num.should.equal(42)
-    })
-    it('should fail for empty-object', function () {
-      expect(function () {
-        Opcode()
-      }).to.throw(TypeError)
-    })
-  })
-
-  describe('#toNumber', function () {
-    it('should work for 0', function () {
-      Opcode.fromNumber(0).toNumber().should.equal(0)
-    })
-  })
-
-  describe('#buffer', function () {
-    it('should correctly input/output a buffer', function () {
-      var buf = Buffer.from('a6', 'hex')
-      Opcode.fromBuffer(buf).toBuffer().should.deep.equal(buf)
-    })
-  })
-
-  describe('#fromString', function () {
-    it('should work for OP_0', function () {
-      Opcode.fromString('OP_0').num.should.equal(0)
-    })
-    it('should fail for invalid string', function () {
-      Opcode.fromString.bind(null, 'OP_SATOSHI').should.throw('Invalid opcodestr')
-      Opcode.fromString.bind(null, 'BANANA').should.throw('Invalid opcodestr')
-    })
-    it('should fail for non-string', function () {
-      Opcode.fromString.bind(null, 123).should.throw('Invalid Argument')
-    })
-  })
-
-  describe('#toString', function () {
-    it('should work for OP_0', function () {
-      Opcode.fromString('OP_0').toString().should.equal('OP_0')
-    })
-
-    it('should not work for non-opcode', function () {
-      expect(function () {
-        Opcode('OP_NOTACODE').toString()
-      }).to.throw('Opcode does not have a string representation')
-    })
-  })
-
-  describe('@map', function () {
-    it('should have a map containing 118 elements', function () {
-      Object.keys(Opcode.map).length.should.equal(118)
-    })
-  })
-
-  describe('@reverseMap', function () {
-    it('should exist and have op 185', function () {
-      should.exist(Opcode.reverseMap)
-      Opcode.reverseMap[185].should.equal('OP_NOP10')
-    })
-
-    // Chronicle reassigns 179-183 and names which NOP each byte used to be, so
-    // OP_NOP4..OP_NOP8 cease to exist and OP_NOP9/OP_NOP10 keep their own numbers.
-    // Pinning the whole range by name catches a future edit sliding them again —
-    // which is how 182 came to parse as a no-op and verify a shift that never ran.
-    it('assigns the Chronicle range exactly, with no invented NOPs above it', function () {
-      var expected = {
-        179: 'OP_SUBSTR',
-        180: 'OP_LEFT',
-        181: 'OP_RIGHT',
-        182: 'OP_LSHIFTNUM',
-        183: 'OP_RSHIFTNUM',
-        184: 'OP_NOP9',
-        185: 'OP_NOP10'
-      }
-      Object.keys(expected).forEach(function (b) {
-        Opcode.reverseMap[b].should.equal(expected[b])
-      })
-      ;[186, 187, 188].forEach(function (b) {
-        should.not.exist(Opcode.reverseMap[b])
-      })
-      ;['OP_NOP4', 'OP_NOP5', 'OP_NOP6', 'OP_NOP7', 'OP_NOP8'].forEach(function (n) {
-        should.not.exist(Opcode.map[n])
-      })
-    })
-  })
-  var smallints = [
-    Opcode('OP_0'),
-    Opcode('OP_1'),
-    Opcode('OP_2'),
-    Opcode('OP_3'),
-    Opcode('OP_4'),
-    Opcode('OP_5'),
-    Opcode('OP_6'),
-    Opcode('OP_7'),
-    Opcode('OP_8'),
-    Opcode('OP_9'),
-    Opcode('OP_10'),
-    Opcode('OP_11'),
-    Opcode('OP_12'),
-    Opcode('OP_13'),
-    Opcode('OP_14'),
-    Opcode('OP_15'),
-    Opcode('OP_16')
-  ]
-
-  describe('@smallInt', function () {
-    var testSmallInt = function (n, op) {
-      Opcode.smallInt(n).toString().should.equal(op.toString())
-    }
-
-    for (var i = 0; i < smallints.length; i++) {
-      var op = smallints[i]
-      it('should work for small int ' + op, testSmallInt.bind(null, i, op))
-    }
-
-    it('with not number', function () {
-      Opcode.smallInt.bind(null, '2').should.throw('Invalid Argument')
-    })
-
-    it('with n equal -1', function () {
-      Opcode.smallInt.bind(null, -1).should.throw('Invalid Argument')
-    })
-
-    it('with n equal 17', function () {
-      Opcode.smallInt.bind(null, 17).should.throw('Invalid Argument')
-    })
-  })
-  describe('@isSmallIntOp', function () {
-    var testIsSmallInt = function (op) {
-      Opcode.isSmallIntOp(op).should.equal(true)
-    }
-    for (var i = 0; i < smallints.length; i++) {
-      var op = smallints[i]
-      it('should work for small int ' + op, testIsSmallInt.bind(null, op))
-    }
-
-    it('should work for non-small ints', function () {
-      Opcode.isSmallIntOp(Opcode('OP_RETURN')).should.equal(false)
-      Opcode.isSmallIntOp(Opcode('OP_CHECKSIG')).should.equal(false)
-      Opcode.isSmallIntOp(Opcode('OP_IF')).should.equal(false)
-      Opcode.isSmallIntOp(Opcode('OP_NOP')).should.equal(false)
-    })
-  })
-
-  describe('#inspect', function () {
-    it('should output opcode by name, hex, and decimal', function () {
-      Opcode.fromString('OP_NOP').inspect().should.equal('<Opcode: OP_NOP, hex: 61, decimal: 97>')
-    })
-  })
-})