@smartledger/bsv 8.3.1 → 9.1.0

package/test/credentials-test.js

@@ -1,332 +0,0 @@
-/**
- * Test Vectors for DID:web + VC-JWT + StatusList2021
- * Comprehensive test suite for v3.4.0
- */
-
-'use strict'
-
-var didweb = require('../lib/didweb')
-var vcjwt = require('../lib/vcjwt')
-var statuslist = require('../lib/statuslist')
-var anchor = require('../lib/anchor')
-var assert = require('assert')
-
-console.log('🧪 SmartLedger BSV v3.4.0 - Credential Test Suite\n')
-
-// Test 1: DID:web Key Generation (ES256)
-async function testES256KeyGeneration() {
-  console.log('1️⃣  Testing ES256 key generation...')
-  
-  var keys = await didweb.generateIssuerKeys({ alg: 'ES256' })
-  
-  assert(keys.privateJwk, 'Private JWK should exist')
-  assert(keys.publicJwk, 'Public JWK should exist')
-  assert.strictEqual(keys.alg, 'ES256', 'Algorithm should be ES256')
-  assert(keys.kid, 'Key ID should exist')
-  assert.strictEqual(keys.publicJwk.kty, 'EC', 'Key type should be EC')
-  assert.strictEqual(keys.publicJwk.crv, 'P-256', 'Curve should be P-256')
-  
-  console.log('   ✅ ES256 key generation successful')
-  console.log('   ✅ Kid:', keys.kid)
-  return keys
-}
-
-// Test 2: DID:web Key Generation (ES256K)
-async function testES256KKeyGeneration() {
-  console.log('\n2️⃣  Testing ES256K key generation...')
-  
-  var keys = await didweb.generateIssuerKeys({ alg: 'ES256K' })
-  
-  assert(keys.privateJwk, 'Private JWK should exist')
-  assert(keys.publicJwk, 'Public JWK should exist')
-  assert.strictEqual(keys.alg, 'ES256K', 'Algorithm should be ES256K')
-  assert(keys.kid, 'Key ID should exist')
-  assert.strictEqual(keys.publicJwk.kty, 'EC', 'Key type should be EC')
-  assert.strictEqual(keys.publicJwk.crv, 'secp256k1', 'Curve should be secp256k1')
-  
-  console.log('   ✅ ES256K key generation successful')
-  console.log('   ✅ Kid:', keys.kid)
-  return keys
-}
-
-// Test 3: DID:web Document Building
-async function testDIDDocumentBuilding(p256Keys) {
-  console.log('\n3️⃣  Testing DID:web document building...')
-  
-  var docs = didweb.buildDidWebDocuments({
-    domain: 'smartledger.technology',
-    p256: { jwk: p256Keys.publicJwk, kid: p256Keys.kid },
-    controllerName: 'SmartLedger Test Issuer'
-  })
-  
-  assert.strictEqual(docs.did, 'did:web:smartledger.technology', 'DID should be correctly formatted')
-  assert(docs.didDocument, 'DID Document should exist')
-  assert(docs.jwks, 'JWKS should exist')
-  assert(docs.didDocument.verificationMethod.length > 0, 'Should have verification methods')
-  assert(docs.jwks.keys.length > 0, 'JWKS should have keys')
-  
-  console.log('   ✅ DID:', docs.did)
-  console.log('   ✅ Verification methods:', docs.didDocument.verificationMethod.length)
-  console.log('   ✅ JWKS keys:', docs.jwks.keys.length)
-  
-  return docs
-}
-
-// Test 4: VC-JWT Issuance (ES256)
-async function testVCIssuanceES256(issuerDid, keys) {
-  console.log('\n4️⃣  Testing VC-JWT issuance (ES256)...')
-  
-  var result = await vcjwt.issueVcJwt({
-    issuerDid: issuerDid,
-    subjectId: 'did:example:holder123',
-    types: ['VerifiableCredential', 'AgeCredential'],
-    credentialSubject: {
-      ageOver: 18,
-      country: 'US'
-    },
-    privateJwk: keys.privateJwk,
-    alg: 'ES256',
-    kid: keys.kid
-  })
-  
-  assert(result.jwt, 'JWT should be generated')
-  assert(result.jwt.split('.').length === 3, 'JWT should have 3 parts')
-  
-  console.log('   ✅ JWT generated')
-  console.log('   ✅ JWT length:', result.jwt.length)
-  
-  return result.jwt
-}
-
-// Test 5: VC-JWT Verification
-async function testVCVerification(jwt, jwks) {
-  console.log('\n5️⃣  Testing VC-JWT verification...')
-  
-  var didResolver = async function(did) {
-    return { jwks: jwks }
-  }
-  
-  var result = await vcjwt.verifyVcJwt(jwt, {
-    didResolver: didResolver,
-    expectedIssuerDid: 'did:web:smartledger.technology'
-  })
-  
-  assert.strictEqual(result.valid, true, 'JWT should be valid')
-  assert(result.payload, 'Payload should be present')
-  assert(result.header, 'Header should be present')
-  
-  console.log('   ✅ JWT verification successful')
-  console.log('   ✅ Issuer:', result.payload.iss)
-  console.log('   ✅ Subject:', result.payload.sub)
-  
-  return result
-}
-
-// Test 6: StatusList2021 Creation
-async function testStatusListCreation(issuerDid, keys) {
-  console.log('\n6️⃣  Testing StatusList2021 creation...')
-  
-  var result = await statuslist.createStatusList({
-    issuerDid: issuerDid,
-    privateJwk: keys.privateJwk
-  })
-  
-  assert(result.listVcJwt, 'Status list JWT should be created')
-  assert(result.listId, 'List ID should be created')
-  
-  console.log('   ✅ Status list created')
-  console.log('   ✅ List ID:', result.listId)
-  
-  return result.listVcJwt
-}
-
-// Test 7: StatusList2021 Update (Revocation)
-async function testStatusListRevocation(listJwt, keys, issuerDid, jwks) {
-  console.log('\n7️⃣  Testing credential revocation...')
-
-  var index = 42
-  var didResolver = async function() { return { jwks: jwks } }
-  var verifyOpts = { expectedIssuerDid: issuerDid, didResolver: didResolver }
-
-  // Check initial status
-  var initialStatus = await statuslist.getCredentialStatusEntry(Object.assign({
-    listVcJwt: listJwt,
-    index: index
-  }, verifyOpts))
-
-  assert.strictEqual(initialStatus, 'valid', 'Initial status should be valid')
-  console.log('   ✅ Initial status at index', index + ':', initialStatus)
-
-  // Revoke credential
-  var result = await statuslist.updateStatusList(Object.assign({
-    listVcJwt: listJwt,
-    index: index,
-    status: 'revoked',
-    privateJwk: keys.privateJwk
-  }, verifyOpts))
-
-  assert(result.listVcJwt, 'Updated list should be returned')
-
-  // Check updated status
-  var updatedStatus = await statuslist.getCredentialStatusEntry(Object.assign({
-    listVcJwt: result.listVcJwt,
-    index: index
-  }, verifyOpts))
-  
-  assert.strictEqual(updatedStatus, 'revoked', 'Status should be revoked')
-  console.log('   ✅ Updated status at index', index + ':', updatedStatus)
-  
-  return result.listVcJwt
-}
-
-// Test 8: Anchor Hash Generation
-function testAnchorHashing() {
-  console.log('\n8️⃣  Testing anchor hash generation...')
-  
-  var testData = 'Test Verifiable Credential Data'
-  var hash = anchor.sha256Hex(testData)
-  
-  assert(hash, 'Hash should be generated')
-  assert.strictEqual(hash.length, 64, 'Hash should be 64 hex characters')
-  assert(/^[a-f0-9]{64}$/.test(hash), 'Hash should be valid hex')
-  
-  console.log('   ✅ SHA-256 hash generated')
-  console.log('   ✅ Hash:', hash)
-  
-  // Test hash reproducibility
-  var hash2 = anchor.sha256Hex(testData)
-  assert.strictEqual(hash, hash2, 'Hash should be reproducible')
-  console.log('   ✅ Hash reproducibility confirmed')
-  
-  return hash
-}
-
-// Test 9: Anchor Payload Building
-function testAnchorPayload(hash, issuerDid) {
-  console.log('\n9️⃣  Testing anchor payload building...')
-  
-  var payload = anchor.buildAnchorPayload({
-    kind: 'VC_ANCHOR_SHA256',
-    hash: hash,
-    issuerDid: issuerDid,
-    issuedAt: new Date().toISOString()
-  })
-  
-  assert(payload.json, 'Payload JSON should be generated')
-  
-  var parsed = JSON.parse(payload.json)
-  assert.strictEqual(parsed.protocol, 'SmartLedger', 'Protocol should be SmartLedger')
-  assert.strictEqual(parsed.type, 'VC_ANCHOR_SHA256', 'Type should match')
-  assert.strictEqual(parsed.hash, hash, 'Hash should match')
-  assert.strictEqual(parsed.issuer, issuerDid, 'Issuer should match')
-  
-  console.log('   ✅ Anchor payload created')
-  console.log('   ✅ Size:', payload.json.length, 'bytes')
-  console.log('   ✅ Protocol:', parsed.protocol)
-  
-  return payload
-}
-
-// Test 10: End-to-end Workflow
-async function testEndToEndWorkflow() {
-  console.log('\n🔟 Testing complete end-to-end workflow...')
-  
-  // Generate keys
-  var keys = await didweb.generateIssuerKeys({ alg: 'ES256' })
-  
-  // Build DID documents
-  var docs = didweb.buildDidWebDocuments({
-    domain: 'test.example.com',
-    p256: { jwk: keys.publicJwk, kid: keys.kid }
-  })
-  
-  // Issue credential
-  var result = await vcjwt.issueVcJwt({
-    issuerDid: docs.did,
-    subjectId: 'did:example:alice',
-    types: ['VerifiableCredential', 'DriverLicense'],
-    credentialSubject: {
-      licenseNumber: 'DL123456',
-      class: 'C'
-    },
-    privateJwk: keys.privateJwk,
-    alg: 'ES256',
-    kid: keys.kid
-  })
-  var jwt = result.jwt
-  
-  // Hash credential for anchoring
-  var hash = anchor.sha256Hex(jwt)
-  
-  // Build anchor payload
-  var anchorPayload = anchor.buildAnchorPayload({
-    kind: 'VC_ANCHOR_SHA256',
-    hash: hash,
-    issuerDid: docs.did
-  })
-  
-  // Verify credential
-  var didResolver = async function() { return { jwks: docs.jwks } }
-  var verification = await vcjwt.verifyVcJwt(jwt, { didResolver: didResolver })
-  
-  assert.strictEqual(verification.valid, true, 'Credential should be valid')
-  
-  // Create status list
-  var statusListResult = await statuslist.createStatusList({
-    issuerDid: docs.did,
-    privateJwk: keys.privateJwk
-  })
-  
-  // Revoke credential
-  var statusVerifyOpts = { expectedIssuerDid: docs.did, didResolver: didResolver }
-  var updatedList = await statuslist.updateStatusList(Object.assign({
-    listVcJwt: statusListResult.listVcJwt,
-    index: 10,
-    status: 'revoked',
-    privateJwk: keys.privateJwk
-  }, statusVerifyOpts))
-
-  // Verify credential is now revoked
-  var verification2 = await vcjwt.verifyVcJwt(jwt, { didResolver: didResolver })
-  var revokedStatus = await statuslist.getCredentialStatusEntry(Object.assign({
-    listVcJwt: updatedList.listVcJwt,
-    index: 10
-  }, statusVerifyOpts))
-  
-  assert.strictEqual(verification2.valid, true, 'JWT signature still valid')
-  assert.strictEqual(revokedStatus, 'revoked', 'But credential is revoked')
-  
-  console.log('   ✅ Complete workflow executed successfully')
-  console.log('   ✅ Issue → Anchor → Verify → Revoke → Verify')
-}
-
-// Run all tests
-async function runTests() {
-  try {
-    var p256Keys = await testES256KeyGeneration()
-    var k1Keys = await testES256KKeyGeneration()
-    var docs = await testDIDDocumentBuilding(p256Keys)
-    var jwt = await testVCIssuanceES256(docs.did, p256Keys)
-    var verification = await testVCVerification(jwt, docs.jwks)
-    var statusListJwt = await testStatusListCreation(docs.did, p256Keys)
-    var revokedListJwt = await testStatusListRevocation(statusListJwt, p256Keys, docs.did, docs.jwks)
-    var hash = testAnchorHashing()
-    var anchorPayload = testAnchorPayload(hash, docs.did)
-    await testEndToEndWorkflow()
-    
-    console.log('\n🎉 All tests passed successfully!')
-    console.log('✅ DID:web generation working')
-    console.log('✅ VC-JWT issuance and verification working')
-    console.log('✅ StatusList2021 revocation working')
-    console.log('✅ BSV anchor hashing working')
-    console.log('✅ ES256 and ES256K support confirmed')
-    
-  } catch (error) {
-    console.error('\n❌ Test failed:', error.message)
-    console.error(error.stack)
-    process.exit(1)
-  }
-}
-
-// Run the test suite
-runTests()

package/test/crypto/backend_selection.js

@@ -1,126 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// The hashing and PBKDF2 backends are chosen by CAPABILITY, not by `process.browser`.
-//
-// `process.browser` is a Browserify-era convention, undefined in React Native, Deno,
-// Cloudflare Workers and Bun. Every one of those took the node branch and
-// require('crypto')'d, which fails outright in React Native or — worse — resolves to a
-// partial shim. rn-nodeify and several RN starter templates register exactly such a
-// shim, so this is a reported failure mode, not a hypothetical one.
-//
-// Each case runs in a child process because it has to intercept module resolution
-// before lib/ is loaded, which cannot be undone safely in-process.
-
-require('chai').should()
-var path = require('path')
-var spawnSync = require('child_process').spawnSync
-
-var ROOT = path.resolve(__dirname, '../..')
-var SHA256_ABC = 'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'
-
-// Run `body` with Module._load intercepted by `stub`, and print the result of `report`.
-function inChild (stub, report) {
-  var src = [
-    'var Module = require("module"), orig = Module._load',
-    'var real = orig.call(Module, "crypto", module, false)',
-    'Module._load = function (r) {',
-    '  if (r === "crypto") { ' + stub + ' }',
-    '  return orig.apply(this, arguments)',
-    '}',
-    // Only the pure-JS backend is loaded for comparison. hash.node.js require()s
-    // 'crypto' at module scope, so it is not even loadable when the stub removes it —
-    // which is precisely why hash.js must not reach for it unconditionally.
-    'var HASH = require(' + JSON.stringify(path.join(ROOT, 'lib/crypto/hash.js')) + ')',
-    'var PURE = require(' + JSON.stringify(path.join(ROOT, 'lib/crypto/hash.browser.js')) + ')',
-    'console.log(' + report + ')'
-  ].join('\n')
-  var out = spawnSync(process.execPath, ['-e', src], { encoding: 'utf8' })
-  if (out.status !== 0) throw new Error('child failed: ' + out.stderr)
-  return out.stdout.trim()
-}
-
-describe('crypto backend selection', function () {
-  this.timeout(30000)
-
-  it('uses node crypto when it is present and correct', function () {
-    // Not the pure-JS module => the node backend was selected.
-    inChild('return real', '(HASH !== PURE) + " " + HASH.sha256(Buffer.from("abc")).toString("hex")')
-      .should.equal('true ' + SHA256_ABC)
-  })
-
-  it('falls back to the pure-JS backend when there is no crypto module', function () {
-    inChild('var e = new Error("no crypto"); e.code = "MODULE_NOT_FOUND"; throw e',
-      '(HASH === PURE) + " " + HASH.sha256(Buffer.from("abc")).toString("hex")')
-      .should.equal('true ' + SHA256_ABC)
-  })
-
-  // The important one. A shim that EXISTS but computes the wrong digest must be
-  // rejected — trusting it would silently corrupt every hash in the library, and a
-  // wrong hash is invisible until it matters.
-  it('rejects a crypto shim that returns incorrect digests', function () {
-    inChild(
-      'return { createHash: function () { return { update: function () { return this }, ' +
-      'digest: function () { return "deadbeef" } } } }',
-      '(HASH === PURE) + " " + HASH.sha256(Buffer.from("abc")).toString("hex")')
-      .should.equal('true ' + SHA256_ABC)
-  })
-
-  // OpenSSL 3 moved ripemd160 to the legacy provider, so some Node builds have sha256
-  // but throw on ripemd160 — and ripemd160 is what addresses are built from.
-  it('rejects a crypto build without ripemd160', function () {
-    inChild(
-      'return Object.assign({}, real, { createHash: function (a) { ' +
-      'if (a === "ripemd160") throw new Error("Digest method not supported"); ' +
-      'return real.createHash(a) } })',
-      '(HASH === PURE) + " " + HASH.sha256ripemd160(Buffer.from("abc")).toString("hex").slice(0, 16)')
-      .should.equal('true bb1be98c142444d7')
-  })
-
-  it('does not consult process.browser', function () {
-    var src = [
-      'process.browser = undefined',
-      'var a = require(' + JSON.stringify(path.join(ROOT, 'lib/crypto/hash.js')) + ')',
-      'console.log(a.sha256(Buffer.from("abc")).toString("hex"))'
-    ].join('\n')
-    var withoutFlag = spawnSync(process.execPath, ['-e', src], { encoding: 'utf8' })
-    var withFlag = spawnSync(process.execPath, ['-e', 'process.browser = true\n' + src.split('\n').slice(1).join('\n')], { encoding: 'utf8' })
-    withoutFlag.stdout.trim().should.equal(SHA256_ABC)
-    withFlag.stdout.trim().should.equal(SHA256_ABC)
-  })
-
-  describe('pbkdf2', function () {
-    // BIP-39 English test vector; the seed must not depend on which backend ran.
-    var PHRASE = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
-    var SEED = 'c55257c360c07c72029aebc1b53c05ed0362ada38ead3e3e9efa3708e53495531f09a6987599d18264c1e1c92f2cf141630c7a3c4ab7c81b2f001698e7463b04'
-
-    function seedInChild (stub) {
-      var src = [
-        'var Module = require("module"), orig = Module._load',
-        'var real = orig.call(Module, "crypto", module, false)',
-        'Module._load = function (r) { if (r === "crypto") { ' + stub + ' } return orig.apply(this, arguments) }',
-        'var bsv = require(' + JSON.stringify(ROOT) + ')',
-        'console.log(new bsv.Mnemonic(' + JSON.stringify(PHRASE) + ').toSeed("TREZOR").toString("hex"))'
-      ].join('\n')
-      var out = spawnSync(process.execPath, ['-e', src], { encoding: 'utf8' })
-      if (out.status !== 0) throw new Error('child failed: ' + out.stderr)
-      return out.stdout.trim()
-    }
-
-    it('derives the BIP-39 vector with node crypto', function () {
-      seedInChild('return real').should.equal(SEED)
-    })
-
-    it('derives the same seed with no crypto module', function () {
-      seedInChild('var e = new Error("no crypto"); e.code = "MODULE_NOT_FOUND"; throw e').should.equal(SEED)
-    })
-
-    it('rejects a shim whose HMAC is wrong and still derives the right seed', function () {
-      seedInChild(
-        'return Object.assign({}, real, { createHmac: function () { return { ' +
-        'update: function () { return this }, digest: function () { return Buffer.alloc(64) } } } })'
-      ).should.equal(SEED)
-    })
-  })
-})

package/test/crypto/bn.js

@@ -1,168 +0,0 @@
-'use strict'
-
-var should = require('chai').should()
-var bsv = require('../..')
-var BN = bsv.crypto.BN
-
-describe('BN', function () {
-  it('should create a bn', function () {
-    var bn = new BN(50)
-    should.exist(bn)
-    bn.toString().should.equal('50')
-  })
-
-  it('should parse this number', function () {
-    var bn = new BN(999970000)
-    bn.toString().should.equal('999970000')
-  })
-
-  it('should parse numbers below and at bn.js internal word size', function () {
-    var bn = new BN(Math.pow(2, 26) - 1)
-    bn.toString().should.equal((Math.pow(2, 26) - 1).toString())
-    bn = new BN(Math.pow(2, 26))
-    bn.toString().should.equal((Math.pow(2, 26)).toString())
-  })
-
-  describe('#add', function () {
-    it('should add two small numbers together', function () {
-      var bn1 = new BN(50)
-      var bn2 = new BN(75)
-      var bn3 = bn1.add(bn2)
-      bn3.toString().should.equal('125')
-    })
-  })
-
-  describe('#sub', function () {
-    it('should subtract a small number', function () {
-      var bn1 = new BN(50)
-      var bn2 = new BN(25)
-      var bn3 = bn1.sub(bn2)
-      bn3.toString().should.equal('25')
-    })
-  })
-
-  describe('#gt', function () {
-    it('should say 1 is greater than 0', function () {
-      var bn1 = new BN(1)
-      var bn0 = new BN(0)
-      bn1.gt(bn0).should.equal(true)
-    })
-
-    it('should say a big number is greater than a small big number', function () {
-      var bn1 = new BN('24023452345398529485723980457')
-      var bn0 = new BN('34098234283412341234049357')
-      bn1.gt(bn0).should.equal(true)
-    })
-
-    it('should say a big number is great than a standard number', function () {
-      var bn1 = new BN('24023452345398529485723980457')
-      var bn0 = new BN(5)
-      bn1.gt(bn0).should.equal(true)
-    })
-  })
-
-  describe('to/from ScriptNumBuffer', function () {
-    [0, 1, 10, 256, 1000, 65536, 65537, -1, -1000, -65536, -65537].forEach(function (n) {
-      it('rountrips correctly for ' + n, function () {
-        BN.fromScriptNumBuffer(new BN(n).toScriptNumBuffer()).toNumber().should.equal(n)
-      })
-    })
-  })
-
-  describe('#fromString', function () {
-    it('should make BN from a string', function () {
-      BN.fromString('5').toString().should.equal('5')
-    })
-    it('should work with hex string', function () {
-      BN.fromString('7fffff0000000000000000000000000000000000000000000000000000000000', 16)
-        .toString(16).should.equal('7fffff0000000000000000000000000000000000000000000000000000000000')
-    })
-  })
-
-  describe('#toString', function () {
-    it('should make a string', function () {
-      new BN(5).toString().should.equal('5')
-    })
-  })
-
-  describe('@fromBuffer', function () {
-    it('should work with big endian', function () {
-      var bn = BN.fromBuffer(Buffer.from('0001', 'hex'), {
-        endian: 'big'
-      })
-      bn.toString().should.equal('1')
-    })
-
-    it('should work with big endian 256', function () {
-      var bn = BN.fromBuffer(Buffer.from('0100', 'hex'), {
-        endian: 'big'
-      })
-      bn.toString().should.equal('256')
-    })
-
-    it('should work with little endian if we specify the size', function () {
-      var bn = BN.fromBuffer(Buffer.from('0100', 'hex'), {
-        size: 2,
-        endian: 'little'
-      })
-      bn.toString().should.equal('1')
-    })
-  })
-
-  describe('#toBuffer', function () {
-    it('should create a 4 byte buffer', function () {
-      var bn = new BN(1)
-      bn.toBuffer({
-        size: 4
-      }).toString('hex').should.equal('00000001')
-    })
-
-    it('should create a 4 byte buffer in little endian', function () {
-      var bn = new BN(1)
-      bn.toBuffer({
-        size: 4,
-        endian: 'little'
-      }).toString('hex').should.equal('01000000')
-    })
-
-    it('should create a 2 byte buffer even if you ask for a 1 byte', function () {
-      var bn = new BN('ff00', 16)
-      bn.toBuffer({
-        size: 1
-      }).toString('hex').should.equal('ff00')
-    })
-
-    it('should create a 4 byte buffer even if you ask for a 1 byte', function () {
-      var bn = new BN('ffffff00', 16)
-      bn.toBuffer({
-        size: 4
-      }).toString('hex').should.equal('ffffff00')
-    })
-  })
-
-  describe('@fromHex', function () {
-    it('should work with big endian', function () {
-      var bn = BN.fromHex('0001', {
-        endian: 'big'
-      })
-      bn.toString().should.equal('1')
-    })
-
-    it('should work with little endian if we specify the size', function () {
-      var bn = BN.fromHex('0100', {
-        size: 2,
-        endian: 'little'
-      })
-      bn.toString().should.equal('1')
-    })
-  })
-
-  describe('#toHex', function () {
-    it('should create a 4 byte he string', function () {
-      var bn = new BN(1)
-      bn.toHex({
-        size: 4
-      }).should.equal('00000001')
-    })
-  })
-})