@smartledger/bsv 8.3.1 → 9.1.0

package/test/encoding/bufferwriter.js

@@ -1,160 +0,0 @@
-'use strict'
-
-var bsv = require('../..')
-var should = require('chai').should()
-var BufferWriter = bsv.encoding.BufferWriter
-var BufferReader = bsv.encoding.BufferReader
-var BN = bsv.crypto.BN
-
-describe('BufferWriter', function () {
-  it('should create a new buffer writer', function () {
-    var bw = new BufferWriter()
-    should.exist(bw)
-  })
-
-  describe('#set', function () {
-    it('set bufs', function () {
-      var buf1 = Buffer.from([0])
-      var buf2 = Buffer.from([1])
-      var bw = new BufferWriter().set({ bufs: [buf1, buf2] })
-      bw.concat().toString('hex').should.equal('0001')
-    })
-  })
-
-  describe('#toBuffer', function () {
-    it('should concat these two bufs', function () {
-      var buf1 = Buffer.from([0])
-      var buf2 = Buffer.from([1])
-      var bw = new BufferWriter({ bufs: [buf1, buf2] })
-      bw.toBuffer().toString('hex').should.equal('0001')
-    })
-  })
-
-  describe('#concat', function () {
-    it('should concat these two bufs', function () {
-      var buf1 = Buffer.from([0])
-      var buf2 = Buffer.from([1])
-      var bw = new BufferWriter({ bufs: [buf1, buf2] })
-      bw.concat().toString('hex').should.equal('0001')
-    })
-  })
-
-  describe('#write', function () {
-    it('should write a buffer', function () {
-      var buf = Buffer.from([0])
-      var bw = new BufferWriter()
-      bw.write(buf)
-      bw.concat().toString('hex').should.equal('00')
-    })
-  })
-
-  describe('#writeUInt8', function () {
-    it('should write 1', function () {
-      var bw = new BufferWriter()
-      bw.writeUInt8(1).concat().toString('hex').should.equal('01')
-    })
-  })
-
-  describe('#writeUInt16BE', function () {
-    it('should write 1', function () {
-      var bw = new BufferWriter()
-      bw.writeUInt16BE(1).concat().toString('hex').should.equal('0001')
-    })
-  })
-
-  describe('#writeUInt16LE', function () {
-    it('should write 1', function () {
-      var bw = new BufferWriter()
-      bw.writeUInt16LE(1).concat().toString('hex').should.equal('0100')
-    })
-  })
-
-  describe('#writeUInt32BE', function () {
-    it('should write 1', function () {
-      var bw = new BufferWriter()
-      bw.writeUInt32BE(1).concat().toString('hex').should.equal('00000001')
-    })
-  })
-
-  describe('#writeUInt32LE', function () {
-    it('should write 1', function () {
-      var bw = new BufferWriter()
-      bw.writeUInt32LE(1).concat().toString('hex').should.equal('01000000')
-    })
-  })
-
-  describe('#writeUInt64BEBN', function () {
-    it('should write 1', function () {
-      var bw = new BufferWriter()
-      bw.writeUInt64BEBN(new BN(1)).concat().toString('hex').should.equal('0000000000000001')
-    })
-  })
-
-  describe('#writeUInt64LEBN', function () {
-    it('should write 1', function () {
-      var bw = new BufferWriter()
-      bw.writeUInt64LEBN(new BN(1)).concat().toString('hex').should.equal('0100000000000000')
-    })
-  })
-
-  describe('#writeVarint', function () {
-    it('should write a 1 byte varint', function () {
-      var bw = new BufferWriter()
-      bw.writeVarintNum(1)
-      bw.concat().length.should.equal(1)
-    })
-
-    it('should write a 3 byte varint', function () {
-      var bw = new BufferWriter()
-      bw.writeVarintNum(1000)
-      bw.concat().length.should.equal(3)
-    })
-
-    it('should write a 5 byte varint', function () {
-      var bw = new BufferWriter()
-      bw.writeVarintNum(Math.pow(2, 16 + 1))
-      bw.concat().length.should.equal(5)
-    })
-
-    it('should write a 9 byte varint', function () {
-      var bw = new BufferWriter()
-      bw.writeVarintNum(Math.pow(2, 32 + 1))
-      bw.concat().length.should.equal(9)
-    })
-
-    it('should read back the same value it wrote for a 9 byte varint', function () {
-      var bw = new BufferWriter()
-      var n = Math.pow(2, 53)
-      n.should.equal(n + 1) // javascript number precision limit
-      bw.writeVarintNum(n)
-      var br = new BufferReader({ buf: bw.concat() })
-      br.readVarintBN().toNumber().should.equal(n)
-    })
-  })
-
-  describe('#writeVarintBN', function () {
-    it('should write a 1 byte varint', function () {
-      var bw = new BufferWriter()
-      bw.writeVarintBN(new BN(1))
-      bw.concat().length.should.equal(1)
-    })
-
-    it('should write a 3 byte varint', function () {
-      var bw = new BufferWriter()
-      bw.writeVarintBN(new BN(1000))
-      bw.concat().length.should.equal(3)
-    })
-
-    it('should write a 5 byte varint', function () {
-      var bw = new BufferWriter()
-      bw.writeVarintBN(new BN(Math.pow(2, 16 + 1)))
-      bw.concat().length.should.equal(5)
-    })
-
-    it('should write a 9 byte varint', function () {
-      var bw = new BufferWriter()
-      bw.writeVarintBN(new BN(Math.pow(2, 32 + 1)))
-      bw.concat().length.should.equal(9)
-    })
-  })
-})

package/test/encoding/varint.js

@@ -1,104 +0,0 @@
-'use strict'
-
-var should = require('chai').should()
-var bsv = require('../..')
-var BN = bsv.crypto.BN
-var BufferReader = bsv.encoding.BufferReader
-var BufferWriter = bsv.encoding.BufferWriter
-var Varint = bsv.encoding.Varint
-
-describe('Varint', function () {
-  it('should make a new varint', function () {
-    var buf = Buffer.from('00', 'hex')
-    var varint = new Varint(buf)
-    should.exist(varint)
-    varint.buf.toString('hex').should.equal('00')
-    varint = Varint(buf)
-    should.exist(varint)
-    varint.buf.toString('hex').should.equal('00')
-
-    // various ways to use the constructor
-    Varint(Varint(0).toBuffer()).toNumber().should.equal(0)
-    Varint(0).toNumber().should.equal(0)
-    Varint(new BN(0)).toNumber().should.equal(0)
-  })
-
-  describe('#set', function () {
-    it('should set a buffer', function () {
-      var buf = Buffer.from('00', 'hex')
-      var varint = Varint().set({ buf: buf })
-      varint.buf.toString('hex').should.equal('00')
-      varint.set({})
-      varint.buf.toString('hex').should.equal('00')
-    })
-  })
-
-  describe('#fromString', function () {
-    it('should set a buffer', function () {
-      var buf = BufferWriter().writeVarintNum(5).concat()
-      var varint = Varint().fromString(buf.toString('hex'))
-      varint.toNumber().should.equal(5)
-    })
-  })
-
-  describe('#toString', function () {
-    it('should return a buffer', function () {
-      var buf = BufferWriter().writeVarintNum(5).concat()
-      var varint = Varint().fromString(buf.toString('hex'))
-      varint.toString().should.equal('05')
-    })
-  })
-
-  describe('#fromBuffer', function () {
-    it('should set a buffer', function () {
-      var buf = BufferWriter().writeVarintNum(5).concat()
-      var varint = Varint().fromBuffer(buf)
-      varint.toNumber().should.equal(5)
-    })
-  })
-
-  describe('#fromBufferReader', function () {
-    it('should set a buffer reader', function () {
-      var buf = BufferWriter().writeVarintNum(5).concat()
-      var br = BufferReader(buf)
-      var varint = Varint().fromBufferReader(br)
-      varint.toNumber().should.equal(5)
-    })
-  })
-
-  describe('#fromBN', function () {
-    it('should set a number', function () {
-      var varint = Varint().fromBN(new BN(5))
-      varint.toNumber().should.equal(5)
-    })
-  })
-
-  describe('#fromNumber', function () {
-    it('should set a number', function () {
-      var varint = Varint().fromNumber(5)
-      varint.toNumber().should.equal(5)
-    })
-  })
-
-  describe('#toBuffer', function () {
-    it('should return a buffer', function () {
-      var buf = BufferWriter().writeVarintNum(5).concat()
-      var varint = Varint(buf)
-      varint.toBuffer().toString('hex').should.equal(buf.toString('hex'))
-    })
-  })
-
-  describe('#toBN', function () {
-    it('should return a buffer', function () {
-      var varint = Varint(5)
-      varint.toBN().toString().should.equal(new BN(5).toString())
-    })
-  })
-
-  describe('#toNumber', function () {
-    it('should return a buffer', function () {
-      var varint = Varint(5)
-      varint.toNumber().should.equal(5)
-    })
-  })
-})

package/test/gdaf/anchor_no_key_leak.js

@@ -1,146 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// The GDAF anchoring wrappers take (payload, privateKey, options) while the underlying
-// SmartLedgerAnchor methods take (payload, metadata, utxos). Every wrapper forwarded
-// `privateKey` into a slot that is not a key. For anchorCredential/anchorBatch it landed
-// in `metadata`, which is JSON.stringify-ed straight into the OP_RETURN — so the secret
-// scalar was broadcast, and the key was recoverable from chain data with an identical WIF.
-
-require('chai').should()
-var bsv = require('../..')
-
-describe('GDAF anchoring never publishes key material', function () {
-  var key = bsv.PrivateKey.fromBuffer(Buffer.alloc(32, 7))
-  var utxos = [{
-    txId: '11'.repeat(32),
-    outputIndex: 0,
-    script: bsv.Script.buildPublicKeyHashOut(key.toAddress()).toHex(),
-    satoshis: 100000
-  }]
-  var HASH = 'ab'.repeat(32)
-
-  function gdaf () { return new bsv.GDAF() }
-
-  // Pull every OP_RETURN payload out of a built transaction, as UTF-8.
-  function payloadsOf (result) {
-    var tx = new bsv.Transaction((result.transaction || result.tx || result).toString())
-    return tx.outputs.map(function (o) {
-      var asm = o.script.toASM().split(' ')
-      return Buffer.from(asm[asm.length - 1], 'hex').toString('utf8')
-    })
-  }
-
-  function assertNoSecret (result) {
-    var scalarHex = key.bn.toString('hex')
-    var raw = (result.transaction || result.tx || result).toString()
-    raw.indexOf(Buffer.from(scalarHex, 'utf8').toString('hex')).should.equal(-1)
-    raw.indexOf(Buffer.from('"bn"', 'utf8').toString('hex')).should.equal(-1)
-    payloadsOf(result).forEach(function (p) {
-      p.indexOf(scalarHex).should.equal(-1)
-      p.indexOf('"bn"').should.equal(-1)
-    })
-  }
-
-  it('anchorCredential does not put the key in the OP_RETURN', function () {
-    return gdaf().anchorCredential(HASH, key, utxos).then(assertNoSecret)
-  })
-
-  it('anchorBatch does not put the key in the OP_RETURN', function () {
-    return gdaf().anchorBatch([HASH, 'cd'.repeat(32)], key, utxos).then(assertNoSecret)
-  })
-
-  it('accepts the documented { utxos, metadata } options shape', function () {
-    return gdaf().anchorCredential(HASH, key, { utxos: utxos, metadata: { issuer: 'did:web:example' } })
-      .then(function (r) {
-        assertNoSecret(r)
-        // The caller's own metadata still reaches the chain.
-        payloadsOf(r).join('').indexOf('did:web:example').should.not.equal(-1)
-      })
-  })
-
-  it('still accepts a bare UTXO array, the only shape that used to work', function () {
-    return gdaf().anchorCredential(HASH, key, utxos).then(function (r) {
-      r.should.be.an('object')
-    })
-  })
-
-  // Defence in depth: even reaching the payload builder with key material must fail
-  // loudly rather than broadcast it.
-  it('refuses to anchor metadata containing a PrivateKey instance', function () {
-    return gdaf().anchorCredential(HASH, key, { utxos: utxos, metadata: { signer: key } })
-      .then(function () { throw new Error('should not have anchored') },
-        function (err) { err.message.should.match(/Refusing to anchor/) })
-  })
-
-  it('refuses to anchor metadata carrying a key-shaped field', function () {
-    return gdaf().anchorCredential(HASH, key, { utxos: utxos, metadata: { wif: key.toWIF() } })
-      .then(function () { throw new Error('should not have anchored') },
-        function (err) { err.message.should.match(/key material/) })
-  })
-
-  it('leaves ordinary metadata alone', function () {
-    return gdaf().anchorCredential(HASH, key, {
-      utxos: utxos, metadata: { id: 'urn:uuid:1', nested: { note: 'fine' } }
-    }).then(function (r) { assertNoSecret(r) })
-  })
-  // The guard keyed off field NAMES alone, which was wrong in both directions: it
-  // rejected `{ d: '2026-01-01' }` as key material while publishing a real WIF stored
-  // under `note`. Detection is now by value as well as name.
-  describe('detects key material by value, not just by field name', function () {
-    var Anchor = require('../../lib/gdaf/smartledger-anchor.js')
-    var other = bsv.PrivateKey.fromBuffer(Buffer.alloc(32, 99))
-    var HASH_BUF = bsv.crypto.Hash.sha256(Buffer.from('doc'))
-
-    function build (metadata) {
-      return new Anchor(key, {})._createAnchorPayload('CREDENTIAL', HASH_BUF, metadata)
-    }
-    function refuses (label, metadata) {
-      it('refuses ' + label, function () {
-        ;(function () { build(metadata) }).should.throw(/Refusing to anchor/)
-      })
-    }
-    function accepts (label, metadata) {
-      it('accepts ' + label, function () {
-        var payload = Buffer.from(build(metadata)).toString('utf8')
-        payload.indexOf(key.toWIF()).should.equal(-1)
-      })
-    }
-
-    // Self-identifying secrets: the encoding says "private key" whatever the field is
-    // called. Naming a WIF `note` does not make it safe to publish.
-    refuses('a WIF under an innocuous name', { note: other.toWIF() })
-    refuses('an xprv under an innocuous name', {
-      ref: bsv.HDPrivateKey.fromSeed(Buffer.alloc(32, 1)).toString()
-    })
-    refuses('a BIP39 mnemonic under an innocuous name', {
-      memo: 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
-    })
-    refuses('a secret nested in an array', { signers: [other.toWIF()] })
-
-    // The anchor's OWN key, in any representation — the exact defect this guard exists
-    // for. A bare hex scalar is otherwise indistinguishable from a hash, so knowing our
-    // own key is what makes this catchable.
-    refuses("the anchor's own key as a raw hex scalar", { backup: key.toString() })
-    refuses("the anchor's own key as a WIF", { backup: key.toWIF() })
-
-    // Ambiguous names are refused only when the value really is secret.
-    refuses('d holding a private scalar', { d: other.toString() })
-    refuses('seed holding a mnemonic', {
-      seed: 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
-    })
-
-    // ...and left alone otherwise. Anchoring a document hash is the module's purpose,
-    // and a 64-hex hash cannot be told apart from a scalar, so it must not be rejected.
-    accepts('d as a date', { d: '2026-01-01' })
-    accepts('seed as a campaign name', { seed: 'spring-campaign' })
-    accepts('a SHA-256 document hash', { docHash: bsv.crypto.Hash.sha256(Buffer.from('x')).toString('hex') })
-    accepts('key used as an ordinary label', { key: 'value' })
-
-    // Public material is not secret and an anchor legitimately references it.
-    accepts('an address', { payTo: key.toAddress().toString() })
-    accepts('a public key', { pub: key.toPublicKey().toString() })
-    accepts('an xpub', { xpub: bsv.HDPrivateKey.fromSeed(Buffer.alloc(32, 1)).hdPublicKey.toString() })
-  })
-})

package/test/gdaf/anchor_spv.js

@@ -1,163 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// Trustless SPV anchor verification end-to-end: build a real anchoring tx with an
-// OP_RETURN commitment, place it in a block, prove its inclusion with a Merkle
-// branch + header, and verify through SmartLedgerAnchor.verifyAnchor with NO trusted
-// provider. Replaces the old {verified:true} stub / trust-the-caller-txData path.
-
-require('chai').should()
-var bsv = require('../..')
-var Anchor = require('../../lib/gdaf/smartledger-anchor')
-var Hash = bsv.crypto.Hash
-
-function rev (b) { return Buffer.from(b).reverse() }
-function buildTree (leaves) {
-  var tree = leaves.slice(); var j = 0
-  for (var size = leaves.length; size > 1; size = Math.floor((size + 1) / 2)) {
-    for (var i = 0; i < size; i += 2) {
-      var i2 = Math.min(i + 1, size - 1)
-      tree.push(Hash.sha256sha256(Buffer.concat([tree[j + i], tree[j + i2]])))
-    }
-    j += size
-  }
-  return tree
-}
-function rootOf (l) { var t = buildTree(l); return t[t.length - 1] }
-function branchFor (leaves, index) {
-  var tree = buildTree(leaves); var branch = []; var j = 0; var idx = index
-  for (var size = leaves.length; size > 1; size = Math.floor((size + 1) / 2)) {
-    var sib = idx ^ 1; if (sib >= size) sib = idx
-    branch.push(rev(tree[j + sib]).toString('hex'))
-    j += size; idx = Math.floor(idx / 2)
-  }
-  return branch
-}
-
-function anchorTxFor (hashHex) {
-  var tx = new bsv.Transaction()
-  tx.addOutput(new bsv.Transaction.Output({
-    script: bsv.Script.buildDataOut(Buffer.from(hashHex, 'hex')),
-    satoshis: 0
-  }))
-  return tx
-}
-
-function blockOf (rootInternal) {
-  return new bsv.BlockHeader({
-    version: 1, prevHash: Buffer.alloc(32), merkleRoot: rootInternal,
-    time: 1231006505, bits: 0x1d00ffff, nonce: 0
-  })
-}
-
-// "Mine" a regtest-difficulty header (PoW passes after trivial nonce grinding).
-function minedHeader (prevHashInternal, merkleInternal) {
-  for (var nonce = 0; nonce < 100000; nonce++) {
-    var h = new bsv.BlockHeader({
-      version: 1, prevHash: prevHashInternal, merkleRoot: merkleInternal,
-      time: 1231006505 + nonce, bits: 0x207fffff, nonce: nonce
-    })
-    if (h.validProofOfWork()) return h
-  }
-  throw new Error('could not mine header')
-}
-
-describe('SPV anchor verification (trustless)', function () {
-  var anchorHash = Hash.sha256(Buffer.from('anchor me')).toString('hex')
-  var atx = anchorTxFor(anchorHash)
-  var rawTx = atx.uncheckedSerialize()
-  var txid = atx.hash
-  // Place the anchor tx at index 2 among 5 leaves.
-  var leaves = [
-    bsv.crypto.Random.getRandomBuffer(32),
-    bsv.crypto.Random.getRandomBuffer(32),
-    atx._getHash(),
-    bsv.crypto.Random.getRandomBuffer(32),
-    bsv.crypto.Random.getRandomBuffer(32)
-  ]
-  var header = blockOf(rootOf(leaves))
-  var spvProof = { index: 2, nodes: branchFor(leaves, 2) }
-
-  it('verifies inclusion + commitment with a valid proof', async function () {
-    var res = await Anchor.verifyAnchor(txid, anchorHash, {
-      spvProof: spvProof, header: header, rawTx: rawTx, requirePow: false
-    })
-    res.verified.should.equal(true)
-    res.chainVerified.should.equal(true)
-    res.committed.should.equal(true)
-    res.txidBound.should.equal(true)
-    res.proof.type.should.equal('spv_merkle_inclusion')
-  })
-
-  it('rejects when the tx does not commit to the expected hash', async function () {
-    var otherHash = Hash.sha256(Buffer.from('something else')).toString('hex')
-    var res = await Anchor.verifyAnchor(txid, otherHash, {
-      spvProof: spvProof, header: header, rawTx: rawTx, requirePow: false
-    })
-    res.committed.should.equal(false)
-    res.verified.should.equal(false)
-  })
-
-  it('rejects a tampered Merkle branch (inclusion fails)', async function () {
-    var bad = { index: 2, nodes: branchFor(leaves, 2).slice() }
-    bad.nodes[0] = rev(bsv.crypto.Random.getRandomBuffer(32)).toString('hex')
-    var res = await Anchor.verifyAnchor(txid, anchorHash, {
-      spvProof: bad, header: header, rawTx: rawTx, requirePow: false
-    })
-    res.chainVerified.should.equal(false)
-    res.verified.should.equal(false)
-  })
-
-  it('rejects rawTx that does not hash to txid', async function () {
-    var otherRaw = anchorTxFor(Hash.sha256(Buffer.from('decoy')).toString('hex')).uncheckedSerialize()
-    var res = await Anchor.verifyAnchor(txid, anchorHash, {
-      spvProof: spvProof, header: header, rawTx: otherRaw, requirePow: false
-    })
-    res.txidBound.should.equal(false)
-    res.verified.should.equal(false)
-  })
-
-  it('still refuses to fabricate a result with neither an SPV proof nor a provider', async function () {
-    var threw = false
-    try { await Anchor.verifyAnchor(txid, anchorHash, {}) } catch (e) { threw = true }
-    threw.should.equal(true)
-  })
-
-  describe('with a header chain (confirmations under real PoW)', function () {
-    this.timeout(10000)
-    // Block containing the tx must carry the real merkle root; then descendants.
-    var h0 = minedHeader(Buffer.alloc(32), rootOf(leaves))
-    var h1 = minedHeader(h0._getHash(), bsv.crypto.Random.getRandomBuffer(32))
-    var h2 = minedHeader(h1._getHash(), bsv.crypto.Random.getRandomBuffer(32))
-    var headerChain = [h0, h1, h2]
-
-    it('verifies inclusion + 3 confirmations under real proof-of-work', async function () {
-      var res = await Anchor.verifyAnchor(txid, anchorHash, {
-        spvProof: spvProof, headerChain: headerChain, rawTx: rawTx, minConfirmations: 3
-      })
-      res.verified.should.equal(true)
-      res.confirmations.should.equal(3)
-      res.headerChainValid.should.equal(true)
-      res.powValid.should.equal(true)
-      res.tipHash.should.equal(h2.id)
-      res.proof.type.should.equal('spv_merkle_inclusion_with_confirmations')
-    })
-
-    it('rejects when confirmations are below the required minimum', async function () {
-      var res = await Anchor.verifyAnchor(txid, anchorHash, {
-        spvProof: spvProof, headerChain: headerChain, rawTx: rawTx, minConfirmations: 6
-      })
-      res.confirmations.should.equal(3)
-      res.verified.should.equal(false)
-    })
-
-    it('rejects a header chain with a broken link', async function () {
-      var res = await Anchor.verifyAnchor(txid, anchorHash, {
-        spvProof: spvProof, headerChain: [h0, h2], rawTx: rawTx, minConfirmations: 1
-      })
-      res.headerChainValid.should.equal(false)
-      res.verified.should.equal(false)
-    })
-  })
-})

package/test/gdaf/canonicalization.js

@@ -1,106 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// GDAF signs a hash of canonical JSON, so the canonicalization IS part of the signature
-// scheme. It was sorted-key JSON that rebuilt the object, which loses the sort: V8 orders
-// integer-like own properties numerically, ahead of string keys, whatever order they were
-// inserted in.
-//
-// Within this library that was deterministic — signing and verification agreed, and no
-// forgery followed. Across implementations it was a verification failure, which for
-// credentials that exist to be checked by other parties is the thing that matters.
-
-require('chai').should()
-var Signer = require('../../lib/gdaf/attestation-signer')
-
-describe('GDAF canonicalization', function () {
-  describe('RFC 8785 conformance', function () {
-    // The concrete divergence. JCS sorts by UTF-16 code unit, where '10' < '2'.
-    it('sorts integer-like keys lexicographically, not numerically', function () {
-      var o = {}
-      o['10'] = 'ten'
-      o['2'] = 'two'
-      Signer._canonicalizeJCS(o).should.equal('{"10":"ten","2":"two"}')
-    })
-
-    it('is what the legacy form got wrong, which is why both exist', function () {
-      var o = {}
-      o['10'] = 'ten'
-      o['2'] = 'two'
-      Signer._canonicalizeJSON(o).should.equal('{"2":"two","10":"ten"}')
-      Signer._canonicalizeJCS(o).should.not.equal(Signer._canonicalizeJSON(o))
-    })
-
-    it('sorts at every depth and leaves arrays in order', function () {
-      Signer._canonicalizeJCS({ z: { b: 1, a: 2 }, a: [3, { d: 1, c: 2 }] })
-        .should.equal('{"a":[3,{"c":2,"d":1}],"z":{"a":2,"b":1}}')
-    })
-
-    it('is insensitive to key insertion order', function () {
-      var x = {}; x.b = 1; x.a = 2
-      var y = {}; y.a = 2; y.b = 1
-      Signer._canonicalizeJCS(x).should.equal(Signer._canonicalizeJCS(y))
-    })
-
-    // These are the same IEEE-754 double, so collapsing them is correct rather than a
-    // weakness — JavaScript has one number type. Pinned so nobody "fixes" it.
-    it('treats 1847, 1847.0 and 1.847e3 as the one number they are', function () {
-      Signer._canonicalizeJCS({ a: 1847 }).should.equal('{"a":1847}')
-      Signer._canonicalizeJCS({ a: 1847.0 }).should.equal('{"a":1847}')
-      Signer._canonicalizeJCS({ a: 1.847e3 }).should.equal('{"a":1847}')
-    })
-
-    it('keeps a number distinct from its string form', function () {
-      Signer._canonicalizeJCS({ a: 1847 }).should.not.equal(Signer._canonicalizeJCS({ a: '1847' }))
-    })
-
-    // JSON.stringify would emit `null` here, silently signing a different document.
-    it('refuses non-finite numbers rather than emitting null', function () {
-      ;(function () { Signer._canonicalizeJCS({ a: NaN }) }).should.throw(/non-finite/)
-      ;(function () { Signer._canonicalizeJCS({ a: Infinity }) }).should.throw(/non-finite/)
-    })
-
-    it('emits unicode and non-BMP characters directly', function () {
-      Signer._canonicalizeJCS({ a: 'é' }).should.equal('{"a":"é"}')
-      Signer._canonicalizeJCS({ a: '😀' }).should.equal('{"a":"😀"}')
-    })
-
-    it('drops undefined members, which JSON cannot represent', function () {
-      Signer._canonicalizeJCS({ a: 1, b: undefined }).should.equal('{"a":1}')
-    })
-
-    it('nulls undefined array elements, as JSON.stringify does', function () {
-      Signer._canonicalizeJCS([1, undefined, 2]).should.equal('[1,null,2]')
-    })
-  })
-
-  describe('hashing and migration', function () {
-    var CRED = { id: 'urn:x', credentialSubject: { name: 'Alice', age: 41 } }
-
-    it('hashes with JCS by default', function () {
-      Signer._hashCredential(CRED).toString('hex')
-        .should.equal(Signer._hashCredential(CRED, Signer.CANONICALIZATION.JCS).toString('hex'))
-    })
-
-    // The migration path. A credential whose keys make the two forms differ must hash
-    // differently, or the legacy fallback in the verifier would be pointless.
-    it('gives a different hash under the legacy form when the forms diverge', function () {
-      var withIntKeys = { '10': 'ten', '2': 'two' }
-      Signer._hashCredential(withIntKeys, Signer.CANONICALIZATION.JCS).toString('hex')
-        .should.not.equal(
-          Signer._hashCredential(withIntKeys, Signer.CANONICALIZATION.LEGACY).toString('hex')
-        )
-    })
-
-    it('agrees between the forms when no integer-like keys are present', function () {
-      Signer._hashCredential(CRED, Signer.CANONICALIZATION.JCS).toString('hex')
-        .should.equal(Signer._hashCredential(CRED, Signer.CANONICALIZATION.LEGACY).toString('hex'))
-    })
-
-    it('exposes both forms by name', function () {
-      Signer.CANONICALIZATION.JCS.should.equal('jcs')
-      Signer.CANONICALIZATION.LEGACY.should.equal('legacy')
-    })
-  })
-})