@smartledger/bsv 8.3.1 → 9.1.0

package/test/ltp/ids.js

@@ -1,74 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-require('chai').should()
-var expect = require('chai').expect
-
-var bsv = require('../../index.js')
-
-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}$/
-
-// A token id is covered by the credential's signature, keys the registry's
-// registration/revocation maps, and feeds proof material — so it must be
-// unpredictable, not merely distinct.
-describe('LTP identifiers', function () {
-  var generators = [
-    { name: 'Right._generateUUID', fn: function () { return bsv.LTP.Right._generateUUID() }, format: UUID_V4 },
-    { name: 'Obligation._generateUUID', fn: function () { return bsv.LTP.Obligation._generateUUID() }, format: UUID_V4 },
-    { name: 'Registry._generateRegistryId', fn: function () { return bsv.LTP.Registry._generateRegistryId() }, format: /^reg_[0-9a-f]{16}$/ },
-    { name: 'Registry._generateAuditId', fn: function () { return bsv.LTP.Registry._generateAuditId() }, format: /^audit_[0-9a-f]{32}$/ },
-    { name: 'Claim._generateBatchId', fn: function () { return bsv.LTP.Claim._generateBatchId() }, format: /^[0-9a-f]{16}$/ }
-  ]
-
-  var withFrozenMathRandom = function (fn) {
-    var original = Math.random
-    Math.random = function () { return 0.5 }
-    try { return fn() } finally { Math.random = original }
-  }
-
-  generators.forEach(function (g) {
-    describe(g.name, function () {
-      it('keeps its documented format', function () {
-        g.fn().should.match(g.format)
-      })
-
-      it('does not repeat', function () {
-        var seen = {}
-        for (var i = 0; i < 500; i++) {
-          var id = g.fn()
-          expect(seen[id], 'duplicate id: ' + id).to.equal(undefined)
-          seen[id] = true
-        }
-      })
-
-      it('does not draw from the engine PRNG', function () {
-        withFrozenMathRandom(function () {
-          var seen = {}
-          for (var i = 0; i < 100; i++) {
-            var id = g.fn()
-            expect(seen[id], 'id is predictable from the engine PRNG: ' + id).to.equal(undefined)
-            seen[id] = true
-          }
-        })
-      })
-    })
-  })
-
-  it('issues unpredictable ids on real tokens', function () {
-    var type = Object.values(bsv.LTP.Right.RightTypes)[0]
-    var ids = {}
-    for (var i = 0; i < 25; i++) {
-      var token = bsv.LTP.Right.create(
-        type,
-        'did:example:issuer',
-        'did:example:subject',
-        { description: 'test right' }
-      )
-      token.id.should.match(/^urn:uuid:/)
-      token.id.replace('urn:uuid:', '').should.match(UUID_V4)
-      expect(ids[token.id], 'duplicate token id').to.equal(undefined)
-      ids[token.id] = true
-    }
-  })
-})

package/test/ltp/right.js

@@ -1,198 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// Regression tests for LTP right-token creation, signing, transfer and the
-// instance LTP#createRightToken path. These guard three defects fixed together:
-//   1. lib/ltp/right.js defined `_signToken` twice; the second definition
-//      shadowed the working one and referenced an undefined `hash` — every
-//      prepareRightToken / transfer / reissue / obligation signing threw
-//      "hash is not defined". The second definition is the detached-JWS builder
-//      and is now `_createJWS(hash, signature)`.
-//   2. lib/ltp/index.js#createRightToken called the non-existent
-//      `LTPRight.create(...)`. `RightToken.create` now exists (build-only).
-//   3. lib/ltp/index.js#createRightToken signed via the non-existent
-//      `LTPProof.createSignature`; it now signs via `RightToken._signToken`.
-
-var expect = require('chai').expect
-var bsv = require('../../')
-
-var LTP = bsv.LTP
-var RightToken = LTP.Right
-
-function newDid () {
-  var key = bsv.PrivateKey.fromRandom()
-  return { key: key, did: 'did:key:' + key.toPublicKey().toString() }
-}
-
-describe('LTP right-token signing (regression)', function () {
-  it('prepareRightToken produces a signed token with a JWS proof and tokenHash', function () {
-    var issuer = newDid()
-    var result = RightToken.prepareRightToken(
-      'EquityShare', issuer.did, issuer.did,
-      { spv: 'spv-001', units: 1000000 }, issuer.key, { jurisdiction: 'US-DE' }
-    )
-    expect(result.success).to.equal(true)
-    expect(result.rightToken).to.be.an('object')
-    expect(result.rightToken.proof).to.be.an('object')
-    expect(result.rightToken.proof.jws).to.be.a('string').with.length.greaterThan(0)
-    expect(result.rightToken.tokenHash).to.match(/^[0-9a-f]{64}$/)
-  })
-
-  it('a prepared right token passes verification (hash integrity)', function () {
-    var issuer = newDid()
-    var result = RightToken.prepareRightToken(
-      'PropertyTitle', issuer.did, issuer.did,
-      { parcel: '123 Main St' }, issuer.key, {}
-    )
-    expect(result.success).to.equal(true)
-    var verification = RightToken.prepareRightTokenVerification(result.rightToken, {})
-    expect(verification.success).to.equal(true)
-    expect(verification.verification.valid).to.equal(true)
-  })
-
-  it('RightToken.create builds an unsigned token structure', function () {
-    var issuer = newDid()
-    var token = RightToken.create(
-      'EquityShare', issuer.did, issuer.did, { spv: 'spv-001' }, issuer.key, {}
-    )
-    expect(token).to.be.an('object')
-    expect(token.credentialSubject.rightType).to.equal('EquityShare')
-    expect(token.proof).to.equal(undefined)
-  })
-
-  it('rejects an invalid right type', function () {
-    var issuer = newDid()
-    expect(function () {
-      RightToken.create('NotAType', issuer.did, issuer.did, {}, issuer.key, {})
-    }).to.throw(/Invalid right type/)
-  })
-
-  it('prepareRightTokenTransfer signs a transfer to a new owner', function () {
-    var issuer = newDid()
-    var created = RightToken.prepareRightToken(
-      'EquityShare', issuer.did, issuer.did, { spv: 'spv-001', units: 1000000 }, issuer.key, {}
-    )
-    expect(created.success).to.equal(true)
-    var buyer = newDid()
-    var transfer = RightToken.prepareRightTokenTransfer(created.rightToken, buyer.did, issuer.key, {})
-    expect(transfer.success).to.equal(true)
-  })
-
-  it('LTP#createRightToken (instance) returns a signed, verifiable token', function () {
-    var issuer = newDid()
-    var ltp = new LTP()
-    var res = ltp.createRightToken(
-      { type: 'EquityShare', owner: issuer.did, spv: 'spv-001', units: 1000000 },
-      issuer.key, {}
-    )
-    expect(res.success).to.equal(true)
-    expect(res.token.proof.jws).to.be.a('string').with.length.greaterThan(0)
-    expect(res.token.tokenHash).to.match(/^[0-9a-f]{64}$/)
-
-    var verification = RightToken.prepareRightTokenVerification(res.token, {})
-    expect(verification.verification.valid).to.equal(true)
-  })
-})
-
-// Guards for the LTP.prototype wrappers that shared the prior "prepare* vs
-// create*" naming mismatch. Before the fix verifyToken called the missing
-// LTPProof.verifySignature, transferRight called the missing LTPRight.transfer
-// + LTPProof.createSignature, createObligation called the missing
-// LTPRight.createObligation, and createSelectiveDisclosure /
-// createLegalValidityProof called missing LTPProof.create* entrypoints — all
-// threw. RightToken.verifyToken is the new public-key signature verifier.
-describe('LTP instance token operations (regression)', function () {
-  function signedRight () {
-    var issuer = newDid()
-    var ltp = new LTP()
-    var res = ltp.createRightToken(
-      { type: 'EquityShare', owner: issuer.did, spv: 'spv-001', units: 1000000 },
-      issuer.key, {}
-    )
-    expect(res.success).to.equal(true)
-    return { issuer: issuer, ltp: ltp, token: res.token }
-  }
-
-  it('RightToken.verifyToken accepts a token signed by the matching key', function () {
-    var ctx = signedRight()
-    var result = RightToken.verifyToken(ctx.token, ctx.issuer.key.toPublicKey().toString())
-    expect(result.valid).to.equal(true)
-    expect(result.errors).to.deep.equal([])
-  })
-
-  it('RightToken.verifyToken rejects a wrong public key', function () {
-    var ctx = signedRight()
-    var stranger = newDid()
-    var result = RightToken.verifyToken(ctx.token, stranger.key.toPublicKey().toString())
-    expect(result.valid).to.equal(false)
-  })
-
-  it('RightToken.verifyToken rejects a tampered token', function () {
-    var ctx = signedRight()
-    ctx.token.credentialSubject.units = 2
-    var result = RightToken.verifyToken(ctx.token, ctx.issuer.key.toPublicKey().toString())
-    expect(result.valid).to.equal(false)
-  })
-
-  it('LTP#verifyToken validates an instance-created right token', function () {
-    var ctx = signedRight()
-    var result = ctx.ltp.verifyToken(ctx.token, ctx.issuer.key.toPublicKey().toString())
-    expect(result.valid).to.equal(true)
-  })
-
-  it('LTP#transferRight produces a signed token owned by the new owner', function () {
-    var ctx = signedRight()
-    var buyer = newDid()
-    var res = ctx.ltp.transferRight(ctx.token, buyer.did, ctx.issuer.key, {})
-    expect(res.success).to.equal(true)
-    expect(res.token.credentialSubject.id).to.equal(buyer.did)
-    expect(res.token.proof.jws).to.be.a('string').with.length.greaterThan(0)
-    expect(res.transferProof).to.be.an('object')
-    // New token is signed by the transferring (current) owner's key.
-    var check = RightToken.verifyToken(res.token, ctx.issuer.key.toPublicKey().toString())
-    expect(check.valid).to.equal(true)
-  })
-
-  it('LTP#transferRight refuses a non-transferable token', function () {
-    var issuer = newDid()
-    var ltp = new LTP()
-    var created = ltp.createRightToken(
-      { type: 'EquityShare', owner: issuer.did, spv: 'spv-001' },
-      issuer.key, { transferable: false }
-    )
-    expect(created.success).to.equal(true)
-    var buyer = newDid()
-    var res = ltp.transferRight(created.token, buyer.did, issuer.key, {})
-    expect(res.success).to.equal(false)
-  })
-
-  it('LTP#createObligation produces a signed correlative obligation', function () {
-    var ctx = signedRight()
-    var obligor = newDid()
-    var res = ctx.ltp.createObligation(
-      ctx.token,
-      { obligor: obligor.did, description: 'deliver shares', dueDate: '2030-01-01' },
-      ctx.issuer.key
-    )
-    expect(res.success).to.equal(true)
-    expect(res.obligation.proof.jws).to.be.a('string').with.length.greaterThan(0)
-    expect(res.obligation.credentialSubject.correlativeRight).to.equal(ctx.token.id)
-    expect(res.rightTokenId).to.equal(ctx.token.id)
-  })
-
-  it('LTP#createSelectiveDisclosure builds a disclosure proof', function () {
-    var ctx = signedRight()
-    var res = ctx.ltp.createSelectiveDisclosure(ctx.token, ['credentialSubject.rightType'], 'nonce-123')
-    expect(res.success).to.equal(true)
-    expect(res.proof).to.be.an('object')
-    expect(res.proof.type).to.equal('LegalTokenSelectiveDisclosure')
-  })
-
-  it('LTP#createLegalValidityProof builds a validity proof', function () {
-    var ctx = signedRight()
-    var res = ctx.ltp.createLegalValidityProof(ctx.token, { name: 'US-DE', requirements: [] }, 'nonce-456')
-    expect(res.success).to.equal(true)
-    expect(res.proof).to.be.an('object')
-  })
-})

package/test/ltp/verify_failclosed.js

@@ -1,134 +0,0 @@
-'use strict'
-
-/* global describe, it */
-
-// Regression guard for the C1–C4 fail-open verification bugs. Before the fix,
-// LTP signature verification returned the ECDSA instance (always truthy) or
-// skipped the JWS check entirely (a `// TODO`), so a forged token verified as
-// valid. These tests feed known-bad signatures/issuers and assert valid===false.
-
-var expect = require('chai').expect
-var bsv = require('../../')
-
-var LTP = bsv.LTP
-var RightToken = LTP.Right
-var Obligation = LTP.Obligation
-
-function newDid () {
-  var key = bsv.PrivateKey.fromRandom()
-  return { key: key, did: 'did:key:' + key.toPublicKey().toString() }
-}
-
-describe('LTP verification fails closed (C1–C4 regression)', function () {
-  it('a genuinely signed right token still verifies as valid', function () {
-    var issuer = newDid()
-    var result = RightToken.prepareRightToken(
-      'EquityShare', issuer.did, issuer.did,
-      { spv: 'spv-001', units: 1000 }, issuer.key, {}
-    )
-    expect(result.success).to.equal(true)
-    var v = RightToken.prepareRightTokenVerification(result.rightToken, {})
-    expect(v.verification.valid, JSON.stringify(v.verification.errors)).to.equal(true)
-  })
-
-  it('a tampered JWS signature is rejected (C4)', function () {
-    var issuer = newDid()
-    var result = RightToken.prepareRightToken(
-      'EquityShare', issuer.did, issuer.did, { spv: 'x' }, issuer.key, {}
-    )
-    var token = result.rightToken
-    // Flip the signature: replace it with a signature over different data by a
-    // different key, re-encoded as a valid-looking JWS.
-    var attacker = newDid()
-    var parts = token.proof.jws.split('.')
-    var bogusSig = bsv.crypto.ECDSA.sign(
-      bsv.crypto.Hash.sha256(Buffer.from('not the token')), attacker.key
-    )
-    token.proof.jws = parts[0] + '.' + parts[1] + '.' + bogusSig.toDER().toString('base64url')
-
-    var v = RightToken.prepareRightTokenVerification(token, {})
-    expect(v.verification.valid).to.equal(false)
-  })
-
-  it('a token re-signed by an attacker but attributed to the victim issuer is rejected (C4 binding)', function () {
-    var victim = newDid()
-    var attacker = newDid()
-    var result = RightToken.prepareRightToken(
-      'PropertyTitle', victim.did, victim.did, { parcel: '1 Main' }, victim.key, {}
-    )
-    var token = result.rightToken
-    // Attacker re-signs the exact token hash with THEIR key, but leaves issuer =
-    // victim. Verification must bind to the victim issuer key and reject.
-    var sig = bsv.crypto.ECDSA.sign(
-      bsv.crypto.Hash.sha256(Buffer.from(RightToken._canonicalizeToken(token))), attacker.key
-    )
-    var parts = token.proof.jws.split('.')
-    token.proof.jws = parts[0] + '.' + parts[1] + '.' + sig.toDER().toString('base64url')
-
-    var v = RightToken.prepareRightTokenVerification(token, {})
-    expect(v.verification.valid).to.equal(false)
-  })
-
-  it('prepareRightTokenTransfer rejects a transfer signed by a non-owner (ownership binding)', function () {
-    var owner = newDid()
-    var attacker = newDid()
-    var res = RightToken.prepareRightToken(
-      'EquityShare', owner.did, owner.did, { spv: 't-1' }, owner.key, {}
-    )
-    var token = res.rightToken
-    // Attacker tries to transfer a token they do not own → must be refused.
-    var bad = RightToken.prepareRightTokenTransfer(token, attacker.did, attacker.key, {})
-    expect(bad.success).to.equal(false)
-    // The genuine owner can transfer.
-    var good = RightToken.prepareRightTokenTransfer(token, attacker.did, owner.key, {})
-    expect(good.success, JSON.stringify(good.error)).to.equal(true)
-  })
-
-  it('verifyOwnership rejects a signature by the wrong key (C2)', function () {
-    var owner = newDid()
-    var attacker = newDid()
-    var Resolver = require('../../lib/gdaf/did-resolver')
-    var did = 'did:smartledger:' + owner.key.toPublicKey().toString()
-    var msg = 'transfer authorization'
-    // Signature by attacker, checked against owner's DID → must be false.
-    var badSig = bsv.crypto.ECDSA.sign(bsv.crypto.Hash.sha256(Buffer.from(msg)), attacker.key)
-    expect(Resolver.verifyOwnership(did, badSig.toString(), msg)).to.equal(false)
-  })
-
-  it('verifyAnchor refuses to fabricate success without a chain provider (C3)', async function () {
-    var Anchor = require('../../lib/gdaf/smartledger-anchor')
-    var threw = false
-    try {
-      await Anchor.verifyAnchor('deadbeef', 'cafe')
-    } catch (e) {
-      threw = true
-    }
-    expect(threw).to.equal(true)
-  })
-
-  it('a genuinely signed obligation token still verifies as valid', function () {
-    var issuer = newDid()
-    var ob = Obligation.prepareObligationToken(
-      'PaymentObligation', issuer.did, issuer.did, { amount: 1 }, issuer.key, {}
-    )
-    expect(ob.success).to.equal(true)
-    var v = Obligation.prepareObligationVerification(ob.obligationToken, {})
-    expect(v.verification.valid, JSON.stringify(v.verification && v.verification.errors)).to.equal(true)
-  })
-
-  it('a tampered obligation signature is rejected (C4)', function () {
-    var issuer = newDid()
-    var attacker = newDid()
-    var ob = Obligation.prepareObligationToken(
-      'PaymentObligation', issuer.did, issuer.did, { amount: 1 }, issuer.key, {}
-    )
-    var tok = ob.obligationToken
-    var sig = bsv.crypto.ECDSA.sign(
-      bsv.crypto.Hash.sha256(Buffer.from('forged')), attacker.key
-    )
-    var parts = tok.proof.jws.split('.')
-    tok.proof.jws = parts[0] + '.' + parts[1] + '.' + sig.toDER().toString('base64url')
-    var v = Obligation.prepareObligationVerification(tok, {})
-    expect(v.verification.valid).to.equal(false)
-  })
-})

package/test/message/message.js

@@ -1,190 +0,0 @@
-'use strict'
-
-var chai = require('chai')
-var expect = chai.expect
-var should = chai.should()
-
-var bsv = require('../../')
-var Address = bsv.Address
-var Signature = bsv.crypto.Signature
-var PrivateKey = bsv.PrivateKey
-var Message = require('../../lib/message')
-
-describe('Message', function () {
-  var address = 'n1ZCYg9YXtB5XCZazLxSmPDa8iwJRZHhGx'
-  var badAddress = 'mmRcrB5fTwgxaFJmVLNtaG8SV454y1E3kC'
-  var privateKey = bsv.PrivateKey.fromWIF('cPBn5A4ikZvBTQ8D7NnvHZYCAxzDZ5Z2TSGW2LkyPiLxqYaJPBW4')
-  var text = 'hello, world'
-  var textBuffer = Buffer.from('hello, world')
-  var bufferData = Buffer.from('H/DIn8uA1scAuKLlCx+/9LnAcJtwQQ0PmcPrJUq90aboLv3fH5fFvY+vmbfOSFEtGarznYli6ShPr9RXwY9UrIY=', 'base64')
-  var signatureString = 'H/DIn8uA1scAuKLlCx+/9LnAcJtwQQ0PmcPrJUq90aboLv3fH5fFvY+vmbfOSFEtGarznYli6ShPr9RXwY9UrIY='
-
-  var badSignatureString = 'H69qZ4mbZCcvXk7CWjptD5ypnYVLvQ3eMXLM8+1gX21SLH/GaFnAjQrDn37+TDw79i9zHhbiMMwhtvTwnPigZ6k='
-
-  var signature = Signature.fromCompact(Buffer.from(signatureString, 'base64'))
-  var badSignature = Signature.fromCompact(Buffer.from(badSignatureString, 'base64'))
-
-  var publicKey = privateKey.toPublicKey()
-
-  it('will error with incorrect message type', function () {
-    expect(function () {
-      return new Message(new Date())
-    }).to.throw('First argument should be a string')
-  })
-
-  it('will instantiate without "new"', function () {
-    var message = Message(text)
-    should.exist(message)
-  })
-
-  var signature2
-  var signature3
-
-  it('can sign a message', function () {
-    var message2 = new Message(text)
-    signature2 = message2._sign(privateKey)
-    signature3 = Message(text).sign(privateKey)
-    should.exist(signature2)
-    should.exist(signature3)
-  })
-
-  it('can sign a message (buffer representation of utf-8 string)', function () {
-    var messageBuf = new Message(textBuffer)
-    var signatureBuffer1 = messageBuf.sign(privateKey)
-    var signatureBuffer2 = Message(textBuffer).sign(privateKey)
-    should.exist(signatureBuffer1)
-    should.exist(signatureBuffer2)
-    var verified = messageBuf.verify(address, signatureBuffer1.toString()) && messageBuf.verify(address, signatureBuffer2.toString())
-    verified.should.equal(true)
-  })
-
-  it('can sign a message (buffer representation of arbitrary data)', function () {
-    var messageBuf = new Message(bufferData)
-    var signatureBuffer1 = messageBuf.sign(privateKey)
-    var signatureBuffer2 = Message(bufferData).sign(privateKey)
-    should.exist(signatureBuffer1)
-    should.exist(signatureBuffer2)
-    var verified = messageBuf.verify(address, signatureBuffer1.toString()) && messageBuf.verify(address, signatureBuffer2.toString())
-    verified.should.equal(true)
-  })
-
-  it('sign will error with incorrect private key argument', function () {
-    expect(function () {
-      var message3 = new Message(text)
-      return message3.sign('not a private key')
-    }).to.throw('First argument should be an instance of PrivateKey')
-  })
-
-  it('can verify a message with signature', function () {
-    var message4 = new Message(text)
-    var verified = message4._verify(publicKey, signature2)
-    verified.should.equal(true)
-  })
-
-  it('can verify a message with existing signature', function () {
-    var message5 = new Message(text)
-    var verified = message5._verify(publicKey, signature)
-    verified.should.equal(true)
-  })
-
-  it('verify will error with incorrect public key argument', function () {
-    expect(function () {
-      var message6 = new Message(text)
-      return message6._verify('not a public key', signature)
-    }).to.throw('First argument should be an instance of PublicKey')
-  })
-
-  it('verify will error with incorrect signature argument', function () {
-    expect(function () {
-      var message7 = new Message(text)
-      return message7._verify(publicKey, 'not a signature')
-    }).to.throw('Second argument should be an instance of Signature')
-  })
-
-  it('verify will correctly identify a bad signature', function () {
-    var message8 = new Message(text)
-    var verified = message8._verify(publicKey, badSignature)
-    should.exist(message8.error)
-    verified.should.equal(false)
-  })
-
-  it('can verify a message with address and generated signature string', function () {
-    var message9 = new Message(text)
-    var verified = message9.verify(address, signature3)
-    should.not.exist(message9.error)
-    verified.should.equal(true)
-  })
-
-  it('will not verify with address mismatch', function () {
-    var message10 = new Message(text)
-    var verified = message10.verify(badAddress, signatureString)
-    should.exist(message10.error)
-    verified.should.equal(false)
-  })
-
-  it('will verify with an uncompressed pubkey', function () {
-    var privateKey = new bsv.PrivateKey('5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss')
-    var message = new Message('This is an example of a signed message.')
-    var signature = message.sign(privateKey)
-    var verified = message.verify(privateKey.toAddress(), signature)
-    verified.should.equal(true)
-  })
-
-  it('can chain methods', function () {
-    var verified = Message(text).verify(address, signatureString)
-    verified.should.equal(true)
-  })
-
-  describe('@sign', function () {
-    it('should sign and verify', function () {
-      var privateKey = PrivateKey.fromString('L3nrwRssVKMkScjejmmu6kmq4hSuUApJnFdW1hGvBP69jnQuKYCh')
-      var address = privateKey.toAddress()
-      var message = 'this is the message that I want to sign'
-      var sig = Message.sign(message, privateKey)
-      sig.toString().should.equal('II5uoh3m0yQ+/5va+1acFQhPaEdTnFFiG/PiKpoC+kpgHbmIk3aWHQ6tyPGgNCUmKlSfwzcP6qVAxuUt0PwDzpg=')
-      var verify = Message.verify(message, address, sig)
-      verify.should.equal(true)
-    })
-  })
-
-  describe('#json', function () {
-    it('roundtrip to-from-to', function () {
-      var json = new Message(text).toJSON()
-      var message = Message.fromJSON(json)
-      message.toString().should.equal(Buffer.from(text).toString())
-    })
-
-    it('checks that the string parameter is valid JSON', function () {
-      expect(function () {
-        return Message.fromJSON('¹')
-      }).to.throw()
-    })
-  })
-
-  describe('#toString', function () {
-    it('message string', function () {
-      var message = new Message(text)
-      message.toString().should.equal(text)
-    })
-
-    it('roundtrip to-from-to', function () {
-      var str = new Message(text).toString()
-      var message = Message.fromString(str)
-      message.toString().should.equal(text)
-    })
-  })
-
-  describe('#inspect', function () {
-    it('should output formatted output correctly', function () {
-      var message = new Message(text)
-      var output = '<Message: ' + text + '>'
-      message.inspect().should.equal(output)
-    })
-  })
-
-  it('accepts Address for verification', function () {
-    var verified = Message(text)
-      .verify(new Address(address), signatureString)
-    verified.should.equal(true)
-  })
-})