smartledger-bsv 3.0.0

package/lib/hdpublickey.js

@@ -0,0 +1,509 @@
+'use strict'
+
+var _ = require('./util/_')
+var $ = require('./util/preconditions')
+
+var BN = require('./crypto/bn')
+var Base58 = require('./encoding/base58')
+var Base58Check = require('./encoding/base58check')
+var Hash = require('./crypto/hash')
+var HDPrivateKey = require('./hdprivatekey')
+var Network = require('./networks')
+var Point = require('./crypto/point')
+var PublicKey = require('./publickey')
+
+var bsvErrors = require('./errors')
+var errors = bsvErrors
+var hdErrors = bsvErrors.HDPublicKey
+var assert = require('assert')
+
+var JSUtil = require('./util/js')
+
+/**
+ * The representation of an hierarchically derived public key.
+ *
+ * See https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
+ *
+ * @constructor
+ * @param {Object|string|Buffer} arg
+ */
+function HDPublicKey (arg) {
+  if (arg instanceof HDPublicKey) {
+    return arg
+  }
+  if (!(this instanceof HDPublicKey)) {
+    return new HDPublicKey(arg)
+  }
+  if (arg) {
+    if (_.isString(arg) || Buffer.isBuffer(arg)) {
+      var error = HDPublicKey.getSerializedError(arg)
+      if (!error) {
+        return this._buildFromSerialized(arg)
+      } else if (Buffer.isBuffer(arg) && !HDPublicKey.getSerializedError(arg.toString())) {
+        return this._buildFromSerialized(arg.toString())
+      } else {
+        if (error instanceof hdErrors.ArgumentIsPrivateExtended) {
+          return new HDPrivateKey(arg).hdPublicKey
+        }
+        throw error
+      }
+    } else {
+      if (_.isObject(arg)) {
+        if (arg instanceof HDPrivateKey) {
+          return this._buildFromPrivate(arg)
+        } else {
+          return this._buildFromObject(arg)
+        }
+      } else {
+        throw new hdErrors.UnrecognizedArgument(arg)
+      }
+    }
+  } else {
+    throw new hdErrors.MustSupplyArgument()
+  }
+}
+
+HDPublicKey.fromHDPrivateKey = function (hdPrivateKey) {
+  return new HDPublicKey(hdPrivateKey)
+}
+
+/**
+ * Verifies that a given path is valid.
+ *
+ * @param {string|number} arg
+ * @return {boolean}
+ */
+HDPublicKey.isValidPath = function (arg) {
+  if (_.isString(arg)) {
+    var indexes = HDPrivateKey._getDerivationIndexes(arg)
+    return indexes !== null && _.every(indexes, HDPublicKey.isValidPath)
+  }
+
+  if (_.isNumber(arg)) {
+    return arg >= 0 && arg < HDPublicKey.Hardened
+  }
+
+  return false
+}
+
+/**
+ * WARNING: This method is deprecated. Use deriveChild instead.
+ *
+ *
+ * Get a derivated child based on a string or number.
+ *
+ * If the first argument is a string, it's parsed as the full path of
+ * derivation. Valid values for this argument include "m" (which returns the
+ * same public key), "m/0/1/40/2/1000".
+ *
+ * Note that hardened keys can't be derived from a public extended key.
+ *
+ * If the first argument is a number, the child with that index will be
+ * derived. See the example usage for clarification.
+ *
+ * @example
+ * ```javascript
+ * var parent = new HDPublicKey('xpub...');
+ * var child_0_1_2 = parent.derive(0).derive(1).derive(2);
+ * var copy_of_child_0_1_2 = parent.derive("m/0/1/2");
+ * assert(child_0_1_2.xprivkey === copy_of_child_0_1_2);
+ * ```
+ *
+ * @param {string|number} arg
+ */
+HDPublicKey.prototype.derive = function () {
+  throw new Error('derive has been deprecated. use deriveChild or, for the old way, deriveNonCompliantChild.')
+}
+
+/**
+ * WARNING: This method will not be officially supported until v1.0.0.
+ *
+ *
+ * Get a derivated child based on a string or number.
+ *
+ * If the first argument is a string, it's parsed as the full path of
+ * derivation. Valid values for this argument include "m" (which returns the
+ * same public key), "m/0/1/40/2/1000".
+ *
+ * Note that hardened keys can't be derived from a public extended key.
+ *
+ * If the first argument is a number, the child with that index will be
+ * derived. See the example usage for clarification.
+ *
+ * @example
+ * ```javascript
+ * var parent = new HDPublicKey('xpub...');
+ * var child_0_1_2 = parent.deriveChild(0).deriveChild(1).deriveChild(2);
+ * var copy_of_child_0_1_2 = parent.deriveChild("m/0/1/2");
+ * assert(child_0_1_2.xprivkey === copy_of_child_0_1_2);
+ * ```
+ *
+ * @param {string|number} arg
+ */
+HDPublicKey.prototype.deriveChild = function (arg, hardened) {
+  if (_.isNumber(arg)) {
+    return this._deriveWithNumber(arg, hardened)
+  } else if (_.isString(arg)) {
+    return this._deriveFromString(arg)
+  } else {
+    throw new hdErrors.InvalidDerivationArgument(arg)
+  }
+}
+
+HDPublicKey.prototype._deriveWithNumber = function (index, hardened) {
+  if (index >= HDPublicKey.Hardened || hardened) {
+    throw new hdErrors.InvalidIndexCantDeriveHardened()
+  }
+  if (index < 0) {
+    throw new hdErrors.InvalidPath(index)
+  }
+
+  var indexBuffer = JSUtil.integerAsBuffer(index)
+  var data = Buffer.concat([this.publicKey.toBuffer(), indexBuffer])
+  var hash = Hash.sha512hmac(data, this._buffers.chainCode)
+  var leftPart = BN.fromBuffer(hash.slice(0, 32), { size: 32 })
+  var chainCode = hash.slice(32, 64)
+
+  var publicKey
+  try {
+    publicKey = PublicKey.fromPoint(Point.getG().mul(leftPart).add(this.publicKey.point))
+  } catch (e) {
+    return this._deriveWithNumber(index + 1)
+  }
+
+  var derived = new HDPublicKey({
+    network: this.network,
+    depth: this.depth + 1,
+    parentFingerPrint: this.fingerPrint,
+    childIndex: index,
+    chainCode: chainCode,
+    publicKey: publicKey
+  })
+
+  return derived
+}
+
+HDPublicKey.prototype._deriveFromString = function (path) {
+  if (_.includes(path, "'")) {
+    throw new hdErrors.InvalidIndexCantDeriveHardened()
+  } else if (!HDPublicKey.isValidPath(path)) {
+    throw new hdErrors.InvalidPath(path)
+  }
+
+  var indexes = HDPrivateKey._getDerivationIndexes(path)
+  var derived = indexes.reduce(function (prev, index) {
+    return prev._deriveWithNumber(index)
+  }, this)
+
+  return derived
+}
+
+/**
+ * Verifies that a given serialized public key in base58 with checksum format
+ * is valid.
+ *
+ * @param {string|Buffer} data - the serialized public key
+ * @param {string|Network=} network - optional, if present, checks that the
+ *     network provided matches the network serialized.
+ * @return {boolean}
+ */
+HDPublicKey.isValidSerialized = function (data, network) {
+  return _.isNull(HDPublicKey.getSerializedError(data, network))
+}
+
+/**
+ * Checks what's the error that causes the validation of a serialized public key
+ * in base58 with checksum to fail.
+ *
+ * @param {string|Buffer} data - the serialized public key
+ * @param {string|Network=} network - optional, if present, checks that the
+ *     network provided matches the network serialized.
+ * @return {errors|null}
+ */
+HDPublicKey.getSerializedError = function (data, network) {
+  if (!(_.isString(data) || Buffer.isBuffer(data))) {
+    return new hdErrors.UnrecognizedArgument('expected buffer or string')
+  }
+  if (!Base58.validCharacters(data)) {
+    return new errors.InvalidB58Char('(unknown)', data)
+  }
+  try {
+    data = Base58Check.decode(data)
+  } catch (e) {
+    return new errors.InvalidB58Checksum(data)
+  }
+  if (data.length !== HDPublicKey.DataSize) {
+    return new hdErrors.InvalidLength(data)
+  }
+  if (!_.isUndefined(network)) {
+    var error = HDPublicKey._validateNetwork(data, network)
+    if (error) {
+      return error
+    }
+  }
+  var version = data.readUInt32BE(0)
+  if (version === Network.livenet.xprivkey || version === Network.testnet.xprivkey) {
+    return new hdErrors.ArgumentIsPrivateExtended()
+  }
+  return null
+}
+
+HDPublicKey._validateNetwork = function (data, networkArg) {
+  var network = Network.get(networkArg)
+  if (!network) {
+    return new errors.InvalidNetworkArgument(networkArg)
+  }
+  var version = data.slice(HDPublicKey.VersionStart, HDPublicKey.VersionEnd)
+  if (version.readUInt32BE(0) !== network.xpubkey) {
+    return new errors.InvalidNetwork(version)
+  }
+  return null
+}
+
+HDPublicKey.prototype._buildFromPrivate = function (arg) {
+  var args = _.clone(arg._buffers)
+  var point = Point.getG().mul(BN.fromBuffer(args.privateKey))
+  args.publicKey = Point.pointToCompressed(point)
+  args.version = JSUtil.integerAsBuffer(Network.get(args.version.readUInt32BE(0)).xpubkey)
+  args.privateKey = undefined
+  args.checksum = undefined
+  args.xprivkey = undefined
+  return this._buildFromBuffers(args)
+}
+
+HDPublicKey.prototype._buildFromObject = function (arg) {
+  // TODO: Type validation
+  var buffers = {
+    version: arg.network ? JSUtil.integerAsBuffer(Network.get(arg.network).xpubkey) : arg.version,
+    depth: _.isNumber(arg.depth) ? Buffer.from([arg.depth & 0xff]) : arg.depth,
+    parentFingerPrint: _.isNumber(arg.parentFingerPrint) ? JSUtil.integerAsBuffer(arg.parentFingerPrint) : arg.parentFingerPrint,
+    childIndex: _.isNumber(arg.childIndex) ? JSUtil.integerAsBuffer(arg.childIndex) : arg.childIndex,
+    chainCode: _.isString(arg.chainCode) ? Buffer.from(arg.chainCode, 'hex') : arg.chainCode,
+    publicKey: _.isString(arg.publicKey) ? Buffer.from(arg.publicKey, 'hex')
+      : Buffer.isBuffer(arg.publicKey) ? arg.publicKey : arg.publicKey.toBuffer(),
+    checksum: _.isNumber(arg.checksum) ? JSUtil.integerAsBuffer(arg.checksum) : arg.checksum
+  }
+  return this._buildFromBuffers(buffers)
+}
+
+HDPublicKey.prototype._buildFromSerialized = function (arg) {
+  var decoded = Base58Check.decode(arg)
+  var buffers = {
+    version: decoded.slice(HDPublicKey.VersionStart, HDPublicKey.VersionEnd),
+    depth: decoded.slice(HDPublicKey.DepthStart, HDPublicKey.DepthEnd),
+    parentFingerPrint: decoded.slice(HDPublicKey.ParentFingerPrintStart,
+      HDPublicKey.ParentFingerPrintEnd),
+    childIndex: decoded.slice(HDPublicKey.ChildIndexStart, HDPublicKey.ChildIndexEnd),
+    chainCode: decoded.slice(HDPublicKey.ChainCodeStart, HDPublicKey.ChainCodeEnd),
+    publicKey: decoded.slice(HDPublicKey.PublicKeyStart, HDPublicKey.PublicKeyEnd),
+    checksum: decoded.slice(HDPublicKey.ChecksumStart, HDPublicKey.ChecksumEnd),
+    xpubkey: arg
+  }
+  return this._buildFromBuffers(buffers)
+}
+
+/**
+ * Receives a object with buffers in all the properties and populates the
+ * internal structure
+ *
+ * @param {Object} arg
+ * @param {buffer.Buffer} arg.version
+ * @param {buffer.Buffer} arg.depth
+ * @param {buffer.Buffer} arg.parentFingerPrint
+ * @param {buffer.Buffer} arg.childIndex
+ * @param {buffer.Buffer} arg.chainCode
+ * @param {buffer.Buffer} arg.publicKey
+ * @param {buffer.Buffer} arg.checksum
+ * @param {string=} arg.xpubkey - if set, don't recalculate the base58
+ *      representation
+ * @return {HDPublicKey} this
+ */
+HDPublicKey.prototype._buildFromBuffers = function (arg) {
+  HDPublicKey._validateBufferArguments(arg)
+
+  JSUtil.defineImmutable(this, {
+    _buffers: arg
+  })
+
+  var sequence = [
+    arg.version, arg.depth, arg.parentFingerPrint, arg.childIndex, arg.chainCode,
+    arg.publicKey
+  ]
+  var concat = Buffer.concat(sequence)
+  var checksum = Base58Check.checksum(concat)
+  if (!arg.checksum || !arg.checksum.length) {
+    arg.checksum = checksum
+  } else {
+    if (arg.checksum.toString('hex') !== checksum.toString('hex')) {
+      throw new errors.InvalidB58Checksum(concat, checksum)
+    }
+  }
+  var network = Network.get(arg.version.readUInt32BE(0))
+
+  var xpubkey
+  xpubkey = Base58Check.encode(Buffer.concat(sequence))
+  arg.xpubkey = Buffer.from(xpubkey)
+
+  var publicKey = new PublicKey(arg.publicKey, { network: network })
+  var size = HDPublicKey.ParentFingerPrintSize
+  var fingerPrint = Hash.sha256ripemd160(publicKey.toBuffer()).slice(0, size)
+
+  JSUtil.defineImmutable(this, {
+    xpubkey: xpubkey,
+    network: network,
+    depth: arg.depth[0],
+    publicKey: publicKey,
+    fingerPrint: fingerPrint
+  })
+
+  return this
+}
+
+HDPublicKey._validateBufferArguments = function (arg) {
+  var checkBuffer = function (name, size) {
+    var buff = arg[name]
+    assert(Buffer.isBuffer(buff), name + ' argument is not a buffer, it\'s ' + typeof buff)
+    assert(
+      buff.length === size,
+      name + ' has not the expected size: found ' + buff.length + ', expected ' + size
+    )
+  }
+  checkBuffer('version', HDPublicKey.VersionSize)
+  checkBuffer('depth', HDPublicKey.DepthSize)
+  checkBuffer('parentFingerPrint', HDPublicKey.ParentFingerPrintSize)
+  checkBuffer('childIndex', HDPublicKey.ChildIndexSize)
+  checkBuffer('chainCode', HDPublicKey.ChainCodeSize)
+  checkBuffer('publicKey', HDPublicKey.PublicKeySize)
+  if (arg.checksum && arg.checksum.length) {
+    checkBuffer('checksum', HDPublicKey.CheckSumSize)
+  }
+}
+
+HDPublicKey.fromString = function (arg) {
+  $.checkArgument(_.isString(arg), 'No valid string was provided')
+  return new HDPublicKey(arg)
+}
+
+HDPublicKey.fromObject = function (arg) {
+  $.checkArgument(_.isObject(arg), 'No valid argument was provided')
+  return new HDPublicKey(arg)
+}
+
+/**
+ * Returns the base58 checked representation of the public key
+ * @return {string} a string starting with "xpub..." in livenet
+ */
+HDPublicKey.prototype.toString = function () {
+  return this.xpubkey
+}
+
+/**
+ * Returns the console representation of this extended public key.
+ * @return string
+ */
+HDPublicKey.prototype.inspect = function () {
+  return '<HDPublicKey: ' + this.xpubkey + '>'
+}
+
+/**
+ * Returns a plain JavaScript object with information to reconstruct a key.
+ *
+ * Fields are: <ul>
+ *  <li> network: 'livenet' or 'testnet'
+ *  <li> depth: a number from 0 to 255, the depth to the master extended key
+ *  <li> fingerPrint: a number of 32 bits taken from the hash of the public key
+ *  <li> fingerPrint: a number of 32 bits taken from the hash of this key's
+ *  <li>     parent's public key
+ *  <li> childIndex: index with which this key was derived
+ *  <li> chainCode: string in hexa encoding used for derivation
+ *  <li> publicKey: string, hexa encoded, in compressed key format
+ *  <li> checksum: this._buffers.checksum.readUInt32BE(0),
+ *  <li> xpubkey: the string with the base58 representation of this extended key
+ *  <li> checksum: the base58 checksum of xpubkey
+ * </ul>
+ */
+HDPublicKey.prototype.toObject = HDPublicKey.prototype.toJSON = function toObject () {
+  return {
+    network: Network.get(this._buffers.version.readUInt32BE(0)).name,
+    depth: this._buffers.depth[0],
+    fingerPrint: this.fingerPrint.readUInt32BE(0),
+    parentFingerPrint: this._buffers.parentFingerPrint.readUInt32BE(0),
+    childIndex: this._buffers.childIndex.readUInt32BE(0),
+    chainCode: this._buffers.chainCode.toString('hex'),
+    publicKey: this.publicKey.toString(),
+    checksum: this._buffers.checksum.readUInt32BE(0),
+    xpubkey: this.xpubkey
+  }
+}
+
+/**
+ * Create a HDPublicKey from a buffer argument
+ *
+ * @param {Buffer} arg
+ * @return {HDPublicKey}
+ */
+HDPublicKey.fromBuffer = function (arg) {
+  return new HDPublicKey(arg)
+}
+
+/**
+ * Create a HDPublicKey from a hex string argument
+ *
+ * @param {Buffer} arg
+ * @return {HDPublicKey}
+ */
+HDPublicKey.fromHex = function (hex) {
+  return HDPublicKey.fromBuffer(Buffer.from(hex, 'hex'))
+}
+
+/**
+ * Return a buffer representation of the xpubkey
+ *
+ * @return {Buffer}
+ */
+HDPublicKey.prototype.toBuffer = function () {
+  return Buffer.from(this._buffers.xpubkey)
+}
+
+/**
+ * Return a hex string representation of the xpubkey
+ *
+ * @return {Buffer}
+ */
+HDPublicKey.prototype.toHex = function () {
+  return this.toBuffer().toString('hex')
+}
+
+HDPublicKey.Hardened = 0x80000000
+HDPublicKey.RootElementAlias = ['m', 'M']
+
+HDPublicKey.VersionSize = 4
+HDPublicKey.DepthSize = 1
+HDPublicKey.ParentFingerPrintSize = 4
+HDPublicKey.ChildIndexSize = 4
+HDPublicKey.ChainCodeSize = 32
+HDPublicKey.PublicKeySize = 33
+HDPublicKey.CheckSumSize = 4
+
+HDPublicKey.DataSize = 78
+HDPublicKey.SerializedByteSize = 82
+
+HDPublicKey.VersionStart = 0
+HDPublicKey.VersionEnd = HDPublicKey.VersionStart + HDPublicKey.VersionSize
+HDPublicKey.DepthStart = HDPublicKey.VersionEnd
+HDPublicKey.DepthEnd = HDPublicKey.DepthStart + HDPublicKey.DepthSize
+HDPublicKey.ParentFingerPrintStart = HDPublicKey.DepthEnd
+HDPublicKey.ParentFingerPrintEnd = HDPublicKey.ParentFingerPrintStart + HDPublicKey.ParentFingerPrintSize
+HDPublicKey.ChildIndexStart = HDPublicKey.ParentFingerPrintEnd
+HDPublicKey.ChildIndexEnd = HDPublicKey.ChildIndexStart + HDPublicKey.ChildIndexSize
+HDPublicKey.ChainCodeStart = HDPublicKey.ChildIndexEnd
+HDPublicKey.ChainCodeEnd = HDPublicKey.ChainCodeStart + HDPublicKey.ChainCodeSize
+HDPublicKey.PublicKeyStart = HDPublicKey.ChainCodeEnd
+HDPublicKey.PublicKeyEnd = HDPublicKey.PublicKeyStart + HDPublicKey.PublicKeySize
+HDPublicKey.ChecksumStart = HDPublicKey.PublicKeyEnd
+HDPublicKey.ChecksumEnd = HDPublicKey.ChecksumStart + HDPublicKey.CheckSumSize
+
+assert(HDPublicKey.PublicKeyEnd === HDPublicKey.DataSize)
+assert(HDPublicKey.ChecksumEnd === HDPublicKey.SerializedByteSize)
+
+module.exports = HDPublicKey

package/lib/message/index.js

@@ -0,0 +1,4 @@
+var bsv = require('../../')
+bsv.Message = require('./message')
+
+module.exports = bsv.Message

package/lib/message/message.js

@@ -0,0 +1,181 @@
+'use strict'
+
+var bsv = require('../../')
+var _ = bsv.deps._
+var PrivateKey = bsv.PrivateKey
+var PublicKey = bsv.PublicKey
+var Address = bsv.Address
+var BufferWriter = bsv.encoding.BufferWriter
+var ECDSA = bsv.crypto.ECDSA
+var Signature = bsv.crypto.Signature
+var sha256sha256 = bsv.crypto.Hash.sha256sha256
+var JSUtil = bsv.util.js
+var $ = bsv.util.preconditions
+
+/**
+ * constructs a new message to sign and verify.
+ *
+ * @param {String} message
+ * @returns {Message}
+ */
+var Message = function Message (message) {
+  if (!(this instanceof Message)) {
+    return new Message(message)
+  }
+
+  $.checkArgument(_.isString(message) || Buffer.isBuffer(message), 'First argument should be a string or Buffer')
+
+  if (_.isString(message)) {
+    this.messageBuffer = Buffer.from(message)
+  }
+
+  if (Buffer.isBuffer(message)) {
+    this.messageBuffer = message
+  }
+  return this
+}
+
+Message.sign = function (message, privateKey) {
+  return new Message(message).sign(privateKey)
+}
+
+Message.verify = function (message, address, signature) {
+  return new Message(message).verify(address, signature)
+}
+
+Message.MAGIC_BYTES = Buffer.from('Bitcoin Signed Message:\n')
+
+Message.prototype.magicHash = function magicHash () {
+  var prefix1 = BufferWriter.varintBufNum(Message.MAGIC_BYTES.length)
+  var prefix2 = BufferWriter.varintBufNum(this.messageBuffer.length)
+  var buf = Buffer.concat([prefix1, Message.MAGIC_BYTES, prefix2, this.messageBuffer])
+  var hash = sha256sha256(buf)
+  return hash
+}
+
+Message.prototype._sign = function _sign (privateKey) {
+  $.checkArgument(privateKey instanceof PrivateKey,
+    'First argument should be an instance of PrivateKey')
+  var hash = this.magicHash()
+  return ECDSA.signWithCalcI(hash, privateKey)
+}
+
+/**
+ * Will sign a message with a given bitcoin private key.
+ *
+ * @param {PrivateKey} privateKey - An instance of PrivateKey
+ * @returns {String} A base64 encoded compact signature
+ */
+Message.prototype.sign = function sign (privateKey) {
+  var signature = this._sign(privateKey)
+  return signature.toCompact().toString('base64')
+}
+
+Message.prototype._verify = function _verify (publicKey, signature) {
+  $.checkArgument(publicKey instanceof PublicKey, 'First argument should be an instance of PublicKey')
+  $.checkArgument(signature instanceof Signature, 'Second argument should be an instance of Signature')
+  var hash = this.magicHash()
+  var verified = ECDSA.verify(hash, signature, publicKey)
+  if (!verified) {
+    this.error = 'The signature was invalid'
+  }
+  return verified
+}
+
+/**
+ * Will return a boolean of the signature is valid for a given bitcoin address.
+ * If it isn't the specific reason is accessible via the "error" member.
+ *
+ * @param {Address|String} bitcoinAddress - A bitcoin address
+ * @param {String} signatureString - A base64 encoded compact signature
+ * @returns {Boolean}
+ */
+Message.prototype.verify = function verify (bitcoinAddress, signatureString) {
+  $.checkArgument(bitcoinAddress)
+  $.checkArgument(signatureString && _.isString(signatureString))
+
+  if (_.isString(bitcoinAddress)) {
+    bitcoinAddress = Address.fromString(bitcoinAddress)
+  }
+  var signature = Signature.fromCompact(Buffer.from(signatureString, 'base64'))
+
+  // recover the public key
+  var ecdsa = new ECDSA()
+  ecdsa.hashbuf = this.magicHash()
+  ecdsa.sig = signature
+  var publicKey = ecdsa.toPublicKey()
+
+  var signatureAddress = Address.fromPublicKey(publicKey, bitcoinAddress.network)
+
+  // check that the recovered address and specified address match
+  if (bitcoinAddress.toString() !== signatureAddress.toString()) {
+    this.error = 'The signature did not match the message digest'
+    return false
+  }
+
+  return this._verify(publicKey, signature)
+}
+
+/**
+ * Instantiate a message from a message string
+ *
+ * @param {String} str - A string of the message
+ * @returns {Message} A new instance of a Message
+ */
+Message.fromString = function (str) {
+  return new Message(str)
+}
+
+/**
+ * Instantiate a message from JSON
+ *
+ * @param {String} json - An JSON string or Object with keys: message
+ * @returns {Message} A new instance of a Message
+ */
+Message.fromJSON = function fromJSON (json) {
+  if (JSUtil.isValidJSON(json)) {
+    json = JSON.parse(json)
+  }
+  return Message.fromObject(json)
+}
+
+/**
+ * @returns {Object} A plain object with the message information
+ */
+Message.prototype.toObject = function toObject () {
+  return {
+    messageHex: this.messageBuffer.toString('hex')
+  }
+}
+
+Message.fromObject = function (obj) {
+  let messageBuffer = Buffer.from(obj.messageHex, 'hex')
+  return new Message(messageBuffer)
+}
+
+/**
+ * @returns {String} A JSON representation of the message information
+ */
+Message.prototype.toJSON = function toJSON () {
+  return JSON.stringify(this.toObject())
+}
+
+/**
+ * Will return a the string representation of the message
+ *
+ * @returns {String} Message
+ */
+Message.prototype.toString = function () {
+  return this.messageBuffer.toString()
+}
+
+/**
+ * Will return a string formatted for the console
+ *
+ * @returns {String} Message
+ */
+Message.prototype.inspect = function () {
+  return '<Message: ' + this.toString() + '>'
+}
+
+module.exports = Message

package/lib/mnemonic/errors.js

@@ -0,0 +1,18 @@
+'use strict'
+
+var spec = {
+  name: 'Mnemonic',
+  message: 'Internal Error on bsv-mnemonic module {0}',
+  errors: [{
+    name: 'InvalidEntropy',
+    message: 'Entropy length must be an even multiple of 11 bits: {0}'
+  }, {
+    name: 'UnknownWordlist',
+    message: 'Could not detect the used word list: {0}'
+  }, {
+    name: 'InvalidMnemonic',
+    message: 'Mnemonic string is invalid: {0}'
+  }]
+}
+
+module.exports = require('../../').errors.extend(spec)