@smartledger/bsv 8.3.1 → 9.1.0

package/test/transaction/unspentoutput.js

@@ -1,97 +0,0 @@
-'use strict'
-
-var chai = require('chai')
-var expect = chai.expect
-/* global structuredClone */
-// structuredClone, not the former clone-deep dependency: the fixture below is plain
-// JSON (strings and numbers), where the two are equivalent. The interpreter's stack
-// clone is NOT — it holds Buffers, which structuredClone would return as Uint8Array.
-// The global comment is for standard@12's eslint, which predates the API.
-var cloneDeep = structuredClone
-
-var bsv = require('../..')
-var UnspentOutput = bsv.Transaction.UnspentOutput
-
-describe('UnspentOutput', function () {
-  var sampleData1 = {
-    'address': 'mszYqVnqKoQx4jcTdJXxwKAissE3Jbrrc1',
-    'txId': 'a477af6b2667c29670467e4e0728b685ee07b240235771862318e29ddbe58458',
-    'outputIndex': 0,
-    'script': 'OP_DUP OP_HASH160 20 0x88d9931ea73d60eaf7e5671efc0552b912911f2a OP_EQUALVERIFY OP_CHECKSIG',
-    'satoshis': 1020000
-  }
-  var sampleData2 = {
-    'txid': 'e42447187db5a29d6db161661e4bc66d61c3e499690fe5ea47f87b79ca573986',
-    'vout': 1,
-    'address': 'mgBCJAsvzgT2qNNeXsoECg2uPKrUsZ76up',
-    'scriptPubKey': '76a914073b7eae2823efa349e3b9155b8a735526463a0f88ac',
-    'amount': 0.01080000
-  }
-
-  it('roundtrip from raw data', function () {
-    expect(UnspentOutput(sampleData2).toObject()).to.deep.equal(sampleData2)
-  })
-
-  it('can be created without "new" operand', function () {
-    expect(UnspentOutput(sampleData1) instanceof UnspentOutput).to.equal(true)
-  })
-
-  it('fails if no tx id is provided', function () {
-    expect(function () {
-      return new UnspentOutput({})
-    }).to.throw()
-  })
-
-  it('fails if vout is not a number', function () {
-    var sample = cloneDeep(sampleData2)
-    sample.vout = '1'
-    expect(function () {
-      return new UnspentOutput(sample)
-    }).to.throw()
-  })
-
-  it('displays nicely on the console', function () {
-    var expected = '<UnspentOutput: a477af6b2667c29670467e4e0728b685ee07b240235771862318e29ddbe58458:0' +
-                   ', satoshis: 1020000, address: mszYqVnqKoQx4jcTdJXxwKAissE3Jbrrc1>'
-    expect(new UnspentOutput(sampleData1).inspect()).to.equal(expected)
-  })
-
-  describe('checking the constructor parameters', function () {
-    var notDefined = {
-      'txId': 'a477af6b2667c29670467e4e0728b685ee07b240235771862318e29ddbe58458',
-      'outputIndex': 0,
-      'script': 'OP_DUP OP_HASH160 20 0x88d9931ea73d60eaf7e5671efc0552b912911f2a OP_EQUALVERIFY OP_CHECKSIG'
-    }
-    var zero = {
-      'txId': 'a477af6b2667c29670467e4e0728b685ee07b240235771862318e29ddbe58458',
-      'outputIndex': 0,
-      'script': 'OP_DUP OP_HASH160 20 0x88d9931ea73d60eaf7e5671efc0552b912911f2a OP_EQUALVERIFY OP_CHECKSIG',
-      'amount': 0
-    }
-    it('fails when no amount is defined', function () {
-      expect(function () {
-        return new UnspentOutput(notDefined)
-      }).to.throw('Must provide an amount for the output')
-    })
-    it('does not fail when amount is zero', function () {
-      expect(function () {
-        return new UnspentOutput(zero)
-      }).to.not.throw()
-    })
-  })
-
-  it('toString returns txid:vout', function () {
-    var expected = 'a477af6b2667c29670467e4e0728b685ee07b240235771862318e29ddbe58458:0'
-    expect(new UnspentOutput(sampleData1).toString()).to.equal(expected)
-  })
-
-  it('to/from JSON roundtrip', function () {
-    var utxo = new UnspentOutput(sampleData2)
-    var obj = UnspentOutput.fromObject(utxo.toJSON()).toObject()
-    expect(obj).to.deep.equal(sampleData2)
-    var str = JSON.stringify(UnspentOutput.fromObject(obj))
-    expect(JSON.parse(str)).to.deep.equal(sampleData2)
-    var str2 = JSON.stringify(new UnspentOutput(JSON.parse(str)))
-    expect(JSON.parse(str2)).to.deep.equal(sampleData2)
-  })
-})

package/test/types/dts_drift.js

@@ -1,124 +0,0 @@
-'use strict'
-
-/* global describe, it, before */
-
-// TYPE-DRIFT GATE — mechanically proves the hand-maintained `bsv.d.ts` does not lie
-// about the runtime. `bsv.d.ts` is a curated public-API surface (better than anything
-// auto-generated from the spotty JSDoc), but nothing stopped it drifting — its own
-// header said "3.4.x" on a 6.x package. This test parses the .d.ts with the real
-// TypeScript AST and asserts:
-//   (1) every declared value symbol (class / function / const, at any nesting) EXISTS
-//       at runtime — no phantom APIs that the types promise but the code doesn't have;
-//   (2) for the audited namespaces (Ordinals, Ordinals.BSV20, SPV) every runtime
-//       function is DECLARED — so new APIs there can't ship untyped.
-// Interfaces and type aliases are compile-time only and are ignored.
-
-require('chai').should()
-var path = require('path')
-var fs = require('fs')
-var ts = require('typescript')
-var bsv = require('../..')
-
-var DTS_PATH = path.join(__dirname, '../../bsv.d.ts')
-var MODULE_NAME = '@smartledger/bsv'
-
-// Walk the `declare module '@smartledger/bsv'` block and collect the dotted path of
-// every value declaration (class / function / const), recursing into namespaces.
-function collectDeclaredPaths (source) {
-  var sf = ts.createSourceFile('bsv.d.ts', source, ts.ScriptTarget.Latest, true)
-  var paths = []
-  var moduleBody = null
-
-  sf.forEachChild(function (node) {
-    if (ts.isModuleDeclaration(node) && node.name && ts.isStringLiteral(node.name) &&
-        node.name.text === MODULE_NAME && node.body && ts.isModuleBlock(node.body)) {
-      moduleBody = node.body
-    }
-  })
-  if (!moduleBody) throw new Error('could not find `declare module "' + MODULE_NAME + '"` in bsv.d.ts')
-
-  function walk (statements, prefix) {
-    statements.forEach(function (node) {
-      if (ts.isModuleDeclaration(node) && node.name && node.body && ts.isModuleBlock(node.body)) {
-        // A namespace: recurse (the namespace itself is checked via its members' paths).
-        walk(node.body.statements, prefix.concat(node.name.text))
-      } else if (ts.isClassDeclaration(node) && node.name) {
-        paths.push(prefix.concat(node.name.text))
-      } else if (ts.isFunctionDeclaration(node) && node.name) {
-        var p = prefix.concat(node.name.text)
-        p.returnType = node.type ? node.type.getText() : null
-        paths.push(p)
-      } else if (ts.isVariableStatement(node)) {
-        node.declarationList.declarations.forEach(function (d) {
-          if (ts.isIdentifier(d.name)) paths.push(prefix.concat(d.name.text))
-        })
-      }
-      // InterfaceDeclaration / TypeAliasDeclaration: compile-time only — ignored.
-    })
-  }
-  walk(moduleBody.statements, [])
-  return paths
-}
-
-// Resolve a dotted path on the runtime object; returns undefined if any segment is missing.
-function resolve (root, segments) {
-  return segments.reduce(function (o, k) { return (o == null) ? undefined : o[k] }, root)
-}
-
-describe('types: bsv.d.ts does not drift from runtime', function () {
-  var declaredPaths
-
-  before(function () {
-    declaredPaths = collectDeclaredPaths(fs.readFileSync(DTS_PATH, 'utf8'))
-  })
-
-  it('parses a non-trivial number of declared symbols', function () {
-    // Sanity: if the parse silently produced nothing, the whole gate would be a no-op.
-    declaredPaths.length.should.be.above(50)
-  })
-
-  it('every declared class / function / const exists at runtime (no phantom API)', function () {
-    var missing = declaredPaths
-      .filter(function (segs) { return resolve(bsv, segs) === undefined })
-      .map(function (segs) { return segs.join('.') })
-    missing.should.deep.equal([], 'bsv.d.ts declares these but runtime does not expose them:\n  ' + missing.join('\n  '))
-  })
-
-  // Reverse direction where it matters most: the modules added in 6.x must stay fully typed.
-  var AUDITED = [
-    { label: 'Ordinals', obj: bsv.Ordinals, decl: 'Ordinals' },
-    { label: 'Ordinals.BSV20', obj: bsv.Ordinals && bsv.Ordinals.BSV20, decl: 'Ordinals.BSV20' },
-    { label: 'SPV', obj: bsv.SPV, decl: 'SPV' }
-  ]
-
-  // An `async` runtime function declared with a non-Promise return type is the most
-  // dangerous kind of drift, because the type checker actively hides the bug rather than
-  // merely failing to catch it: `StatusList.getCredentialStatusEntry` was declared
-  // `: CredentialStatus` while being async, so `if (fn(...) === 'revoked')` compiled clean
-  // and was ALWAYS false — every revoked credential passed as valid.
-  it('no async runtime function is declared with a synchronous return type', function () {
-    var lies = []
-    declaredPaths.forEach(function (segs) {
-      if (!segs.returnType) return
-      var fn = resolve(bsv, segs)
-      if (typeof fn !== 'function') return
-      var isAsync = fn.constructor && fn.constructor.name === 'AsyncFunction'
-      var declaresPromise = /\bPromise\s*</.test(segs.returnType)
-      if (isAsync && !declaresPromise) {
-        lies.push(segs.join('.') + ' is async but is declared `: ' + segs.returnType + '`')
-      }
-    })
-    lies.should.deep.equal([], 'these declarations hide a Promise:\n  ' + lies.join('\n  '))
-  })
-
-  AUDITED.forEach(function (ns) {
-    it('every runtime function on ' + ns.label + ' is declared in bsv.d.ts', function () {
-      ns.obj.should.be.an('object')
-      var declaredSet = {}
-      declaredPaths.forEach(function (segs) { declaredSet[segs.join('.')] = true })
-      var runtimeFns = Object.keys(ns.obj).filter(function (k) { return typeof ns.obj[k] === 'function' })
-      var untyped = runtimeFns.filter(function (k) { return !declaredSet[ns.decl + '.' + k] })
-      untyped.should.deep.equal([], ns.label + ' exposes these functions but bsv.d.ts does not declare them:\n  ' + untyped.join('\n  '))
-    })
-  })
-})

package/test/types/surface_honesty.js

@@ -1,102 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// Runtime half of a field review that found declarations disagreeing with the code.
-// The declarations themselves are gated by dts_drift.js and by the tsc check in CI; the
-// cases below are the ones where the RUNTIME also had to change, because a declaration
-// that merely matched the old behaviour would have been documenting a bug.
-
-var should = require('chai').should()
-var bsv = require('../..')
-var SC = bsv.SmartContract
-
-describe('public surface tells the truth about itself', function () {
-  describe('SmartContract.ownershipToken forwards its authorizer', function () {
-    it('is not a two-argument alias that drops the third', function () {
-      // The top-level alias took (fee, ownerPubKeyHash) and called through with only
-      // those two, so a co-signed token built via this path came out single-key — the
-      // authorizer was accepted and silently discarded.
-      var auth = SC.Authorizers.multisig(2, 3)
-      var withAuth = SC.ownershipToken(1, Buffer.alloc(20), auth).toHex()
-      var without = SC.ownershipToken(1, Buffer.alloc(20)).toHex()
-      withAuth.should.not.equal(without)
-    })
-
-    it('agrees with SmartContract.Token.ownershipToken', function () {
-      var auth = SC.Authorizers.multisig(2, 3)
-      SC.ownershipToken(1, Buffer.alloc(20), auth).toHex()
-        .should.equal(SC.Token.ownershipToken(1, Buffer.alloc(20), auth).toHex())
-    })
-  })
-
-  describe('Authorizers.multisig takes a key COUNT', function () {
-    it('rejects an array of keys instead of silently building a broken authorizer', function () {
-      // `m > nKeys` compared a number to an array, which coerces to NaN, so the guard
-      // passed and the array was interpolated into the authorizer's name.
-      var keys = [1, 2, 3].map(function () {
-        return bsv.PrivateKey.fromRandom().toPublicKey().toBuffer()
-      })
-      ;(function () { SC.Authorizers.multisig(2, keys) }).should.throw(/NUMBER of keys/)
-      // The message names the fix.
-      ;(function () { SC.Authorizers.multisig(2, keys) }).should.throw(/pass 3 instead/)
-    })
-
-    it('still accepts the documented count form', function () {
-      SC.Authorizers.multisig(2, 3).n.should.equal(3)
-      SC.Authorizers.multisig(2, 3).m.should.equal(2)
-    })
-
-    it('rejects non-integer m', function () {
-      (function () { SC.Authorizers.multisig('2', 3) }).should.throw(/m must be an integer/)
-    })
-  })
-
-  describe('StatusList refuses to record a suspension as a revocation', function () {
-    it('throws on status: suspended rather than setting the revocation bit', function () {
-      // Both statuses set the SAME bit and read back as 'revoked', so a suspension was
-      // silently recorded — and later reported — as a permanent revocation.
-      return bsv.StatusList.updateStatusList({
-        listVcJwt: 'x', index: 1, status: 'suspended', privateJwk: {}
-      }).then(
-        function () { throw new Error('should not have accepted suspended') },
-        function (err) { err.message.should.match(/'suspended' is not supported/) }
-      )
-    })
-  })
-
-  describe('securityFeatures describes what is actually shipped', function () {
-    it('no longer claims elliptic patches, since elliptic is not a dependency', function () {
-      var pkg = require('../../package.json')
-      var deps = Object.keys(pkg.dependencies || {})
-      deps.indexOf('elliptic').should.equal(-1)
-      bsv.securityFeatures.indexOf('elliptic-patches').should.equal(-1)
-      bsv.securityFeatures.should.be.an('array')
-      bsv.securityFeatures.length.should.be.above(0)
-    })
-  })
-
-  describe('documented sub-path entry points resolve', function () {
-    // Every one of these was MODULE_NOT_FOUND: the package `exports` map had no aliases
-    // for the *-entry.js files, so a documented deep import could not be loaded at all.
-    var SUBPATHS = ['didweb', 'vcjwt', 'gdaf', 'ltp', 'statuslist', 'shamir',
-      'anchor', 'covenant', 'security', 'smartcontract', 'script-helper']
-
-    SUBPATHS.forEach(function (name) {
-      it('@smartledger/bsv/' + name, function () {
-        var mod = require('@smartledger/bsv/' + name)
-        // Some entry points export a class (a function), others a namespace object.
-        var t = typeof mod
-        t.should.be.oneOf(['object', 'function'])
-        should.exist(mod)
-      })
-    })
-
-    it('still resolves the package root and lib deep imports', function () {
-      require('@smartledger/bsv').should.be.an('object')
-      require('@smartledger/bsv/version').should.be.a('string')
-      // Directory deep-imports need the explicit file — a documented 7.0 exports break.
-      require('@smartledger/bsv/lib/ordinals/index.js').should.be.an('object')
-    })
-  })
-})

package/test/util/id.js

@@ -1,72 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-require('chai').should()
-var expect = require('chai').expect
-
-var Id = require('../../lib/util/id')
-
-var UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
-
-describe('util/id', function () {
-  describe('#uuid4', function () {
-    it('produces a well-formed RFC 4122 v4 uuid', function () {
-      Id.uuid4().should.match(UUID_V4)
-    })
-
-    it('sets the version and variant bits on every draw', function () {
-      for (var i = 0; i < 200; i++) {
-        Id.uuid4().should.match(UUID_V4)
-      }
-    })
-
-    it('does not repeat', function () {
-      var seen = {}
-      for (var i = 0; i < 2000; i++) {
-        var id = Id.uuid4()
-        expect(seen[id], 'duplicate uuid: ' + id).to.equal(undefined)
-        seen[id] = true
-      }
-    })
-  })
-
-  describe('#randomHex', function () {
-    it('returns the requested number of hex characters', function () {
-      Id.randomHex(16).should.match(/^[0-9a-f]{16}$/)
-      Id.randomHex(12).should.match(/^[0-9a-f]{12}$/)
-      Id.randomHex(1).should.match(/^[0-9a-f]$/)
-    })
-
-    it('does not repeat', function () {
-      var seen = {}
-      for (var i = 0; i < 2000; i++) {
-        var id = Id.randomHex(16)
-        expect(seen[id], 'duplicate id: ' + id).to.equal(undefined)
-        seen[id] = true
-      }
-    })
-  })
-
-  describe('entropy source', function () {
-    // Identifiers must come from the CSPRNG. Freezing the engine PRNG must not
-    // affect them; if it does, they are predictable from observed output.
-    var withFrozenMathRandom = function (fn) {
-      var original = Math.random
-      Math.random = function () { return 0.5 }
-      try { return fn() } finally { Math.random = original }
-    }
-
-    it('uuid4 is unaffected by the engine PRNG', function () {
-      withFrozenMathRandom(function () {
-        Id.uuid4().should.not.equal(Id.uuid4())
-      })
-    })
-
-    it('randomHex is unaffected by the engine PRNG', function () {
-      withFrozenMathRandom(function () {
-        Id.randomHex(16).should.not.equal(Id.randomHex(16))
-      })
-    })
-  })
-})

package/test/util/js.js

@@ -1,76 +0,0 @@
-'use strict'
-
-require('chai').should()
-
-var bsv = require('../..')
-var JSUtil = bsv.util.js
-
-describe('js utils', function () {
-  describe('isValidJSON', function () {
-    var hexa = '8080808080808080808080808080808080808080808080808080808080808080'
-    var json = '{"key": ["value", "value2"]}'
-    var json2 = '["value", "value2", {"key": "value"}]'
-
-    it('does not mistake an integer as valid json object', function () {
-      var valid = JSUtil.isValidJSON(hexa)
-      valid.should.equal(false)
-    })
-
-    it('correctly validates a json object', function () {
-      var valid = JSUtil.isValidJSON(json)
-      valid.should.equal(true)
-    })
-
-    it('correctly validates an array json object', function () {
-      var valid = JSUtil.isValidJSON(json2)
-      valid.should.equal(true)
-    })
-  })
-
-  describe('isNaturalNumber', function () {
-    it('false for float', function () {
-      var a = JSUtil.isNaturalNumber(0.1)
-      a.should.equal(false)
-    })
-
-    it('false for string float', function () {
-      var a = JSUtil.isNaturalNumber('0.1')
-      a.should.equal(false)
-    })
-
-    it('false for string integer', function () {
-      var a = JSUtil.isNaturalNumber('1')
-      a.should.equal(false)
-    })
-
-    it('false for negative integer', function () {
-      var a = JSUtil.isNaturalNumber(-1)
-      a.should.equal(false)
-    })
-
-    it('false for negative integer string', function () {
-      var a = JSUtil.isNaturalNumber('-1')
-      a.should.equal(false)
-    })
-
-    it('false for infinity', function () {
-      var a = JSUtil.isNaturalNumber(Infinity)
-      a.should.equal(false)
-    })
-
-    it('false for NaN', function () {
-      var a = JSUtil.isNaturalNumber(NaN)
-      a.should.equal(false)
-    })
-
-    it('true for zero', function () {
-      var a = JSUtil.isNaturalNumber(0)
-      a.should.equal(true)
-    })
-
-    it('true for positive integer', function () {
-      var a = JSUtil.isNaturalNumber(1000)
-      a.should.equal(true)
-    })
-  })
-})

package/test/util/preconditions.js

@@ -1,79 +0,0 @@
-'use strict'
-
-var should = require('chai').should()
-
-var bsv = require('../..')
-var errors = bsv.errors
-var $ = bsv.util.preconditions
-var PrivateKey = bsv.PrivateKey
-
-describe('preconditions', function () {
-  it('can be used to assert state', function () {
-    (function () {
-      $.checkState(false, 'testing')
-    }).should.throw(errors.InvalidState)
-  })
-  it('throws no false negative', function () {
-    (function () {
-      $.checkState(true, 'testing')
-    }).should.not.throw()
-  })
-
-  it('can be used to check an argument', function () {
-    (function () {
-      $.checkArgument(false, 'testing')
-    }).should.throw(errors.InvalidArgument);
-
-    (function () {
-      $.checkArgument(true, 'testing')
-    }).should.not.throw(errors.InvalidArgument)
-  })
-
-  it('can be used to check an argument type', function () {
-    var error
-    try {
-      $.checkArgumentType(1, 'string', 'argumentName')
-    } catch (e) {
-      error = e
-      e.message.should.equal('Invalid Argument for argumentName, expected string but got number')
-    }
-    should.exist(error)
-  })
-  it('has no false negatives when used to check an argument type', function () {
-    (function () {
-      $.checkArgumentType('a String', 'string', 'argumentName')
-    }).should.not.throw()
-  })
-
-  it('can be used to check an argument type for a class', function () {
-    var error
-    try {
-      $.checkArgumentType(1, PrivateKey)
-    } catch (e) {
-      error = e
-      var fail = !(~e.message.indexOf('Invalid Argument for (unknown name)'))
-      fail.should.equal(false)
-    }
-    should.exist(error)
-  })
-  it('has no false negatives when checking a type for a class', function () {
-    (function () {
-      $.checkArgumentType(new PrivateKey(), PrivateKey)
-    }).should.not.throw()
-  })
-
-  it('formats correctly a message on InvalidArgument()', function () {
-    var error = new errors.InvalidArgument()
-    error.message.should.equal('Invalid Argument')
-  })
-
-  it('formats correctly a message on checkArgument', function () {
-    var error
-    try {
-      $.checkArgument(null, 'parameter must be provided')
-    } catch (e) {
-      error = e
-    }
-    error.message.should.equal('Invalid Argument: parameter must be provided')
-  })
-})

package/test/vcjwt/interop.js

@@ -1,126 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// Proves the VC-JWT module is interoperable with the standards-compliant
-// `jose` library in BOTH directions, for ES256 (P-256) and ES256K (secp256k1),
-// and that algorithm pinning / curve binding reject substitution attacks.
-
-var assert = require('assert')
-var crypto = require('crypto')
-var jose = require('jose')
-var vcjwt = require('../../lib/vcjwt')
-
-function genKeys (alg, namedCurve) {
-  var pair = crypto.generateKeyPairSync('ec', { namedCurve: namedCurve })
-  var privateJwk = pair.privateKey.export({ format: 'jwk' })
-  var publicJwk = pair.publicKey.export({ format: 'jwk' })
-  privateJwk.kid = publicJwk.kid = 'test-key-1'
-  privateJwk.alg = publicJwk.alg = alg
-  return { privateJwk: privateJwk, publicJwk: publicJwk }
-}
-
-function resolverFor (publicJwk) {
-  return function () {
-    return Promise.resolve({ jwks: { keys: [publicJwk] } })
-  }
-}
-
-var CASES = [
-  { alg: 'ES256', curve: 'prime256v1' },
-  { alg: 'ES256K', curve: 'secp256k1' }
-]
-
-describe('vcjwt JOSE interop', function () {
-  CASES.forEach(function (c) {
-    it('issues a token that ' + c.alg + ' jose can verify (P1363 encoding)', async function () {
-      var keys = genKeys(c.alg, c.curve)
-      var issued = await vcjwt.issueVcJwt({
-        issuerDid: 'did:web:example.com',
-        subjectId: 'did:web:subject.example',
-        credentialSubject: { name: 'Alice' },
-        privateJwk: keys.privateJwk,
-        alg: c.alg
-      })
-      var joseKey = await jose.importJWK(keys.publicJwk, c.alg)
-      var result = await jose.jwtVerify(issued.jwt, joseKey) // throws if non-compliant
-      assert.strictEqual(result.payload.iss, 'did:web:example.com')
-    })
-
-    it('verifies a ' + c.alg + ' token issued by jose', async function () {
-      var keys = genKeys(c.alg, c.curve)
-      var josePriv = await jose.importJWK(keys.privateJwk, c.alg)
-      var joseJwt = await new jose.SignJWT({ vc: { type: ['VerifiableCredential'] } })
-        .setProtectedHeader({ alg: c.alg, typ: 'JWT', kid: keys.publicJwk.kid })
-        .setIssuer('did:web:example.com')
-        .setSubject('did:web:subject.example')
-        .setIssuedAt()
-        .setExpirationTime('1y')
-        .sign(josePriv)
-      var res = await vcjwt.verifyVcJwt(joseJwt, { didResolver: resolverFor(keys.publicJwk) })
-      assert.strictEqual(res.valid, true, res.error)
-    })
-  })
-
-  it('rejects a token whose alg is not in the allowlist', async function () {
-    var keys = genKeys('ES256', 'prime256v1')
-    var issued = await vcjwt.issueVcJwt({
-      issuerDid: 'did:web:example.com', subjectId: 's', credentialSubject: {}, privateJwk: keys.privateJwk, alg: 'ES256'
-    })
-    var res = await vcjwt.verifyVcJwt(issued.jwt, {
-      allowedAlgs: ['ES256K'],
-      didResolver: resolverFor(keys.publicJwk)
-    })
-    assert.strictEqual(res.valid, false)
-    assert.ok(/Algorithm not allowed/.test(res.error), res.error)
-  })
-
-  it('rejects when the resolved key curve does not match the algorithm', async function () {
-    // ES256 token, but the JWKS serves a secp256k1 key under the same kid.
-    var p256 = genKeys('ES256', 'prime256v1')
-    var k1 = genKeys('ES256K', 'secp256k1')
-    var issued = await vcjwt.issueVcJwt({
-      issuerDid: 'did:web:example.com', subjectId: 's', credentialSubject: {}, privateJwk: p256.privateJwk, alg: 'ES256'
-    })
-    var res = await vcjwt.verifyVcJwt(issued.jwt, { didResolver: resolverFor(k1.publicJwk) })
-    assert.strictEqual(res.valid, false)
-    assert.ok(/curve does not match/.test(res.error), res.error)
-  })
-
-  it('refuses to sign when the key curve does not match the algorithm', async function () {
-    var k1 = genKeys('ES256K', 'secp256k1')
-    var threw = false
-    try {
-      await vcjwt.issueVcJwt({
-        issuerDid: 'did:web:example.com', subjectId: 's', credentialSubject: {}, privateJwk: k1.privateJwk, alg: 'ES256'
-      })
-    } catch (e) {
-      threw = /does not match alg/.test(e.message)
-    }
-    assert.ok(threw, 'expected curve/alg mismatch to throw')
-  })
-
-  it('accepts a legacy DER-encoded token only when allowLegacyDER is set', async function () {
-    // Simulate a <=4.6.0 token: same signing input, but DER-encoded signature.
-    var keys = genKeys('ES256', 'prime256v1')
-    var header = { alg: 'ES256', typ: 'JWT', kid: keys.publicJwk.kid }
-    var payload = { iss: 'did:web:example.com', sub: 's', iat: 1700000000, exp: 4102444800, vc: {} }
-    var headerB64 = vcjwt.base64UrlEncode(Buffer.from(JSON.stringify(header)))
-    var payloadB64 = vcjwt.base64UrlEncode(Buffer.from(JSON.stringify(payload)))
-    var signingInput = headerB64 + '.' + payloadB64
-    var derSig = crypto.sign('sha256', Buffer.from(signingInput), {
-      key: crypto.createPrivateKey({ key: keys.privateJwk, format: 'jwk' }),
-      dsaEncoding: 'der'
-    })
-    var legacyJwt = signingInput + '.' + vcjwt.base64UrlEncode(derSig)
-
-    var rejected = await vcjwt.verifyVcJwt(legacyJwt, { didResolver: resolverFor(keys.publicJwk) })
-    assert.strictEqual(rejected.valid, false, 'legacy DER token must fail by default')
-
-    var accepted = await vcjwt.verifyVcJwt(legacyJwt, {
-      allowLegacyDER: true,
-      didResolver: resolverFor(keys.publicJwk)
-    })
-    assert.strictEqual(accepted.valid, true, accepted.error)
-  })
-})