@smartledger/bsv 7.5.0 → 7.5.2

package/test/gdaf/anchor_no_key_leak.js

@@ -0,0 +1,88 @@
+'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(/looks like 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) })
+  })
+})

package/test/privatekey.js

@@ -205,7 +205,13 @@ describe('PrivateKey', function () {
         network: 'livenet'
       })
       var key = PrivateKey.fromObject(JSON.parse(json))
-      JSON.stringify(key).should.equal(json)
+      // toObject() is the deliberate export and still round-trips exactly...
+      JSON.stringify(key.toObject()).should.equal(json)
+      // ...but JSON.stringify() must NOT emit the secret. This test used to assert that
+      // it did, which is how a private key reached an OP_RETURN via the GDAF anchor path:
+      // anything that stringified an object holding a key published the scalar.
+      JSON.parse(JSON.stringify(key)).bn.should.equal('[REDACTED]')
+      JSON.stringify(key).indexOf('96c13222').should.equal(-1)
     })
 
     it('should input/output json', function () {
@@ -215,7 +221,13 @@ describe('PrivateKey', function () {
         network: 'livenet'
       })
       var key = PrivateKey.fromJSON(JSON.parse(json))
-      JSON.stringify(key).should.equal(json)
+      // toObject() is the deliberate export and still round-trips exactly...
+      JSON.stringify(key.toObject()).should.equal(json)
+      // ...but JSON.stringify() must NOT emit the secret. This test used to assert that
+      // it did, which is how a private key reached an OP_RETURN via the GDAF anchor path:
+      // anything that stringified an object holding a key published the scalar.
+      JSON.parse(JSON.stringify(key)).bn.should.equal('[REDACTED]')
+      JSON.stringify(key).indexOf('96c13222').should.equal(-1)
     })
 
     it('input json should correctly initialize network field', function () {
@@ -427,4 +439,69 @@ describe('PrivateKey', function () {
     var privkey = new PrivateKey('92VYMmwFLXRwXn5688edGxYYgMFsc3fUXYhGp17WocQhU6zG1kd')
     privkey.publicKey.toAddress().toString().should.equal('moiAvLUw16qgrwhFGo1eDnXHC2wPMYiv7Y')
   })
+  // Reported from the field against 7.4.0 and reproduced here. Each of these returned a
+  // DIFFERENT key or address than the caller asked for, silently.
+  describe('argument handling that used to produce the wrong key', function () {
+    var HEX = '0000000000000000000000000000000000000000000000000000000000000001'
+
+    it('honours the network passed to fromString instead of discarding it', function () {
+      // Returned a livenet key — and therefore a MAINNET address — so funds sent to it
+      // landed on the wrong network.
+      var k = PrivateKey.fromString(HEX, 'testnet')
+      k.network.name.should.equal('testnet')
+      k.toAddress().toString().should.equal(new PrivateKey(HEX, 'testnet').toAddress().toString())
+    })
+
+    it('agrees with the constructor for WIF input', function () {
+      var wif = new PrivateKey(HEX, 'testnet').toWIF()
+      PrivateKey.fromString(wif).toWIF().should.equal(wif)
+      PrivateKey.fromString(wif, 'testnet').toWIF().should.equal(wif)
+    })
+
+    it('rejects a network that contradicts the WIF rather than ignoring it', function () {
+      var wif = new PrivateKey(HEX, 'testnet').toWIF()
+      ;(function () { PrivateKey.fromString(wif, 'livenet') }).should.throw()
+    })
+
+    it('fromHex and the constructor return the SAME key', function () {
+      // These disagreed on the compression flag, so the same input produced two different
+      // addresses and two different WIFs. Restore by the wrong route, derive an address
+      // you never funded.
+      var a = new PrivateKey(HEX)
+      var b = PrivateKey.fromHex(HEX)
+      var c = PrivateKey.fromBuffer(Buffer.from(HEX, 'hex'))
+      b.compressed.should.equal(a.compressed)
+      b.toWIF().should.equal(a.toWIF())
+      b.toAddress().toString().should.equal(a.toAddress().toString())
+      c.toWIF().should.equal(a.toWIF())
+    })
+
+    it('still allows the legacy uncompressed form explicitly', function () {
+      PrivateKey.fromHex(HEX, null, false).compressed.should.equal(false)
+      PrivateKey.fromBuffer(Buffer.from(HEX, 'hex'), null, false).compressed.should.equal(false)
+    })
+  })
+
+  // JSON.stringify() on a key — or on any object holding one — used to emit the secret
+  // scalar. That is how a private key reached an OP_RETURN through the GDAF anchor path.
+  describe('does not leak the secret through JSON', function () {
+    it('redacts bn from JSON.stringify', function () {
+      var k = new PrivateKey()
+      var scalar = k.bn.toString('hex')
+      JSON.stringify(k).indexOf(scalar).should.equal(-1)
+      JSON.parse(JSON.stringify(k)).bn.should.equal('[REDACTED]')
+    })
+
+    it('redacts it when the key is nested inside another object', function () {
+      var k = new PrivateKey()
+      var payload = JSON.stringify({ context: { signer: k } })
+      payload.indexOf(k.bn.toString('hex')).should.equal(-1)
+    })
+
+    it('keeps toObject() exact, so deliberate export still round-trips', function () {
+      var k = new PrivateKey()
+      k.toObject().bn.should.equal(k.bn.toString('hex'))
+      PrivateKey.fromObject(k.toObject()).toWIF().should.equal(k.toWIF())
+    })
+  })
 })

package/test/types/dts_drift.js

@@ -45,7 +45,9 @@ function collectDeclaredPaths (source) {
       } else if (ts.isClassDeclaration(node) && node.name) {
         paths.push(prefix.concat(node.name.text))
       } else if (ts.isFunctionDeclaration(node) && node.name) {
-        paths.push(prefix.concat(node.name.text))
+        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))
@@ -89,6 +91,26 @@ describe('types: bsv.d.ts does not drift from runtime', function () {
     { 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')

package/test/types/surface_honesty.js

@@ -0,0 +1,102 @@
+'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/version.js

@@ -1,3 +1,3 @@
 'use strict'
 // GENERATED by scripts/sync-version.js on `npm version` — do not edit.
-module.exports = '7.5.0'
+module.exports = '7.5.2'