smartledger-bsv 3.0.0

package/lib/encoding/bufferwriter.js

@@ -0,0 +1,150 @@
+'use strict'
+
+var assert = require('assert')
+
+var BufferWriter = function BufferWriter (obj) {
+  if (!(this instanceof BufferWriter)) { return new BufferWriter(obj) }
+  this.bufLen = 0
+  if (obj) { this.set(obj) } else { this.bufs = [] }
+}
+
+BufferWriter.prototype.set = function (obj) {
+  this.bufs = obj.bufs || this.bufs || []
+  this.bufLen = this.bufs.reduce(function (prev, buf) { return prev + buf.length }, 0)
+  return this
+}
+
+BufferWriter.prototype.toBuffer = function () {
+  return this.concat()
+}
+
+BufferWriter.prototype.concat = function () {
+  return Buffer.concat(this.bufs, this.bufLen)
+}
+
+BufferWriter.prototype.write = function (buf) {
+  assert(Buffer.isBuffer(buf))
+  this.bufs.push(buf)
+  this.bufLen += buf.length
+  return this
+}
+
+BufferWriter.prototype.writeReverse = function (buf) {
+  assert(Buffer.isBuffer(buf))
+  this.bufs.push(Buffer.from(buf).reverse())
+  this.bufLen += buf.length
+  return this
+}
+
+BufferWriter.prototype.writeUInt8 = function (n) {
+  var buf = Buffer.alloc(1)
+  buf.writeUInt8(n, 0)
+  this.write(buf)
+  return this
+}
+
+BufferWriter.prototype.writeUInt16BE = function (n) {
+  var buf = Buffer.alloc(2)
+  buf.writeUInt16BE(n, 0)
+  this.write(buf)
+  return this
+}
+
+BufferWriter.prototype.writeUInt16LE = function (n) {
+  var buf = Buffer.alloc(2)
+  buf.writeUInt16LE(n, 0)
+  this.write(buf)
+  return this
+}
+
+BufferWriter.prototype.writeUInt32BE = function (n) {
+  var buf = Buffer.alloc(4)
+  buf.writeUInt32BE(n, 0)
+  this.write(buf)
+  return this
+}
+
+BufferWriter.prototype.writeInt32LE = function (n) {
+  var buf = Buffer.alloc(4)
+  buf.writeInt32LE(n, 0)
+  this.write(buf)
+  return this
+}
+
+BufferWriter.prototype.writeUInt32LE = function (n) {
+  var buf = Buffer.alloc(4)
+  buf.writeUInt32LE(n, 0)
+  this.write(buf)
+  return this
+}
+
+BufferWriter.prototype.writeUInt64BEBN = function (bn) {
+  var buf = bn.toBuffer({ size: 8 })
+  this.write(buf)
+  return this
+}
+
+BufferWriter.prototype.writeUInt64LEBN = function (bn) {
+  var buf = bn.toBuffer({ size: 8 })
+  this.writeReverse(buf)
+  return this
+}
+
+BufferWriter.prototype.writeVarintNum = function (n) {
+  var buf = BufferWriter.varintBufNum(n)
+  this.write(buf)
+  return this
+}
+
+BufferWriter.prototype.writeVarintBN = function (bn) {
+  var buf = BufferWriter.varintBufBN(bn)
+  this.write(buf)
+  return this
+}
+
+BufferWriter.varintBufNum = function (n) {
+  var buf
+  if (n < 253) {
+    buf = Buffer.alloc(1)
+    buf.writeUInt8(n, 0)
+  } else if (n < 0x10000) {
+    buf = Buffer.alloc(1 + 2)
+    buf.writeUInt8(253, 0)
+    buf.writeUInt16LE(n, 1)
+  } else if (n < 0x100000000) {
+    buf = Buffer.alloc(1 + 4)
+    buf.writeUInt8(254, 0)
+    buf.writeUInt32LE(n, 1)
+  } else {
+    buf = Buffer.alloc(1 + 8)
+    buf.writeUInt8(255, 0)
+    buf.writeInt32LE(n & -1, 1)
+    buf.writeUInt32LE(Math.floor(n / 0x100000000), 5)
+  }
+  return buf
+}
+
+BufferWriter.varintBufBN = function (bn) {
+  var buf
+  var n = bn.toNumber()
+  if (n < 253) {
+    buf = Buffer.alloc(1)
+    buf.writeUInt8(n, 0)
+  } else if (n < 0x10000) {
+    buf = Buffer.alloc(1 + 2)
+    buf.writeUInt8(253, 0)
+    buf.writeUInt16LE(n, 1)
+  } else if (n < 0x100000000) {
+    buf = Buffer.alloc(1 + 4)
+    buf.writeUInt8(254, 0)
+    buf.writeUInt32LE(n, 1)
+  } else {
+    var bw = new BufferWriter()
+    bw.writeUInt8(255)
+    bw.writeUInt64LEBN(bn)
+    buf = bw.concat()
+  }
+  return buf
+}
+
+module.exports = BufferWriter

package/lib/encoding/varint.js

@@ -0,0 +1,71 @@
+'use strict'
+
+var BufferWriter = require('./bufferwriter')
+var BufferReader = require('./bufferreader')
+var BN = require('../crypto/bn')
+
+var Varint = function Varint (buf) {
+  if (!(this instanceof Varint)) { return new Varint(buf) }
+  if (Buffer.isBuffer(buf)) {
+    this.buf = buf
+  } else if (typeof buf === 'number') {
+    var num = buf
+    this.fromNumber(num)
+  } else if (buf instanceof BN) {
+    var bn = buf
+    this.fromBN(bn)
+  } else if (buf) {
+    var obj = buf
+    this.set(obj)
+  }
+}
+
+Varint.prototype.set = function (obj) {
+  this.buf = obj.buf || this.buf
+  return this
+}
+
+Varint.prototype.fromString = function (str) {
+  this.set({
+    buf: Buffer.from(str, 'hex')
+  })
+  return this
+}
+
+Varint.prototype.toString = function () {
+  return this.buf.toString('hex')
+}
+
+Varint.prototype.fromBuffer = function (buf) {
+  this.buf = buf
+  return this
+}
+
+Varint.prototype.fromBufferReader = function (br) {
+  this.buf = br.readVarintBuf()
+  return this
+}
+
+Varint.prototype.fromBN = function (bn) {
+  this.buf = BufferWriter().writeVarintBN(bn).concat()
+  return this
+}
+
+Varint.prototype.fromNumber = function (num) {
+  this.buf = BufferWriter().writeVarintNum(num).concat()
+  return this
+}
+
+Varint.prototype.toBuffer = function () {
+  return this.buf
+}
+
+Varint.prototype.toBN = function () {
+  return BufferReader(this.buf).readVarintBN()
+}
+
+Varint.prototype.toNumber = function () {
+  return BufferReader(this.buf).readVarintNum()
+}
+
+module.exports = Varint

package/lib/errors/index.js

@@ -0,0 +1,57 @@
+'use strict'
+
+var _ = require('../util/_')
+
+function format (message, args) {
+  return message
+    .replace('{0}', args[0])
+    .replace('{1}', args[1])
+    .replace('{2}', args[2])
+}
+var traverseNode = function (parent, errorDefinition) {
+  var NodeError = function () {
+    if (_.isString(errorDefinition.message)) {
+      this.message = format(errorDefinition.message, arguments)
+    } else if (_.isFunction(errorDefinition.message)) {
+      this.message = errorDefinition.message.apply(null, arguments)
+    } else {
+      throw new Error('Invalid error definition for ' + errorDefinition.name)
+    }
+    this.stack = this.message + '\n' + (new Error()).stack
+  }
+  NodeError.prototype = Object.create(parent.prototype)
+  NodeError.prototype.name = parent.prototype.name + errorDefinition.name
+  parent[errorDefinition.name] = NodeError
+  if (errorDefinition.errors) {
+    childDefinitions(NodeError, errorDefinition.errors)
+  }
+  return NodeError
+}
+
+var childDefinitions = function (parent, childDefinitions) {
+  _.each(childDefinitions, function (childDefinition) {
+    traverseNode(parent, childDefinition)
+  })
+}
+
+var traverseRoot = function (parent, errorsDefinition) {
+  childDefinitions(parent, errorsDefinition)
+  return parent
+}
+
+var bsv = {}
+bsv.Error = function () {
+  this.message = 'Internal error'
+  this.stack = this.message + '\n' + (new Error()).stack
+}
+bsv.Error.prototype = Object.create(Error.prototype)
+bsv.Error.prototype.name = 'bsv.Error'
+
+var data = require('./spec')
+traverseRoot(bsv.Error, data)
+
+module.exports = bsv.Error
+
+module.exports.extend = function (spec) {
+  return traverseNode(bsv.Error, spec)
+}

package/lib/errors/spec.js

@@ -0,0 +1,184 @@
+'use strict'
+
+var docsURL = 'https://docs.moneybutton.com/'
+
+module.exports = [{
+  name: 'InvalidB58Char',
+  message: 'Invalid Base58 character: {0} in {1}'
+}, {
+  name: 'InvalidB58Checksum',
+  message: 'Invalid Base58 checksum for {0}'
+}, {
+  name: 'InvalidNetwork',
+  message: 'Invalid version for network: got {0}'
+}, {
+  name: 'InvalidState',
+  message: 'Invalid state: {0}'
+}, {
+  name: 'NotImplemented',
+  message: 'Function {0} was not implemented yet'
+}, {
+  name: 'InvalidNetworkArgument',
+  message: 'Invalid network: must be "livenet" or "testnet", got {0}'
+}, {
+  name: 'InvalidArgument',
+  message: function () {
+    return 'Invalid Argument' + (arguments[0] ? (': ' + arguments[0]) : '') +
+      (arguments[1] ? (' Documentation: ' + docsURL + arguments[1]) : '')
+  }
+}, {
+  name: 'AbstractMethodInvoked',
+  message: 'Abstract Method Invocation: {0}'
+}, {
+  name: 'InvalidArgumentType',
+  message: function () {
+    return 'Invalid Argument for ' + arguments[2] + ', expected ' + arguments[1] + ' but got ' + typeof arguments[0]
+  }
+}, {
+  name: 'Unit',
+  message: 'Internal Error on Unit {0}',
+  errors: [{
+    'name': 'UnknownCode',
+    'message': 'Unrecognized unit code: {0}'
+  }, {
+    'name': 'InvalidRate',
+    'message': 'Invalid exchange rate: {0}'
+  }]
+}, {
+  name: 'MerkleBlock',
+  message: 'Internal Error on MerkleBlock {0}',
+  errors: [{
+    'name': 'InvalidMerkleTree',
+    'message': 'This MerkleBlock contain an invalid Merkle Tree'
+  }]
+}, {
+  name: 'Transaction',
+  message: 'Internal Error on Transaction {0}',
+  errors: [{
+    name: 'Input',
+    message: 'Internal Error on Input {0}',
+    errors: [{
+      name: 'MissingScript',
+      message: 'Need a script to create an input'
+    }, {
+      name: 'UnsupportedScript',
+      message: 'Unsupported input script type: {0}'
+    }, {
+      name: 'MissingPreviousOutput',
+      message: 'No previous output information.'
+    }]
+  }, {
+    name: 'NeedMoreInfo',
+    message: '{0}'
+  }, {
+    name: 'InvalidSorting',
+    message: 'The sorting function provided did not return the change output as one of the array elements'
+  }, {
+    name: 'InvalidOutputAmountSum',
+    message: '{0}'
+  }, {
+    name: 'MissingSignatures',
+    message: 'Some inputs have not been fully signed'
+  }, {
+    name: 'InvalidIndex',
+    message: 'Invalid index: {0} is not between 0, {1}'
+  }, {
+    name: 'UnableToVerifySignature',
+    message: 'Unable to verify signature: {0}'
+  }, {
+    name: 'DustOutputs',
+    message: 'Dust amount detected in one output'
+  }, {
+    name: 'InvalidSatoshis',
+    message: 'Output satoshis are invalid'
+  }, {
+    name: 'FeeError',
+    message: 'Internal Error on Fee {0}',
+    errors: [{
+      name: 'TooSmall',
+      message: 'Fee is too small: {0}'
+    }, {
+      name: 'TooLarge',
+      message: 'Fee is too large: {0}'
+    }, {
+      name: 'Different',
+      message: 'Unspent value is different from specified fee: {0}'
+    }]
+  }, {
+    name: 'ChangeAddressMissing',
+    message: 'Change address is missing'
+  }, {
+    name: 'BlockHeightTooHigh',
+    message: 'Block Height can be at most 2^32 -1'
+  }, {
+    name: 'NLockTimeOutOfRange',
+    message: 'Block Height can only be between 0 and 499 999 999'
+  }, {
+    name: 'LockTimeTooEarly',
+    message: 'Lock Time can\'t be earlier than UNIX date 500 000 000'
+  }]
+}, {
+  name: 'Script',
+  message: 'Internal Error on Script {0}',
+  errors: [{
+    name: 'UnrecognizedAddress',
+    message: 'Expected argument {0} to be an address'
+  }, {
+    name: 'CantDeriveAddress',
+    message: 'Can\'t derive address associated with script {0}, needs to be p2pkh in, p2pkh out, p2sh in, or p2sh out.'
+  }, {
+    name: 'InvalidBuffer',
+    message: 'Invalid script buffer: can\'t parse valid script from given buffer {0}'
+  }]
+}, {
+  name: 'HDPrivateKey',
+  message: 'Internal Error on HDPrivateKey {0}',
+  errors: [{
+    name: 'InvalidDerivationArgument',
+    message: 'Invalid derivation argument {0}, expected string, or number and boolean'
+  }, {
+    name: 'InvalidEntropyArgument',
+    message: 'Invalid entropy: must be an hexa string or binary buffer, got {0}',
+    errors: [{
+      name: 'TooMuchEntropy',
+      message: 'Invalid entropy: more than 512 bits is non standard, got "{0}"'
+    }, {
+      name: 'NotEnoughEntropy',
+      message: 'Invalid entropy: at least 128 bits needed, got "{0}"'
+    }]
+  }, {
+    name: 'InvalidLength',
+    message: 'Invalid length for xprivkey string in {0}'
+  }, {
+    name: 'InvalidPath',
+    message: 'Invalid derivation path: {0}'
+  }, {
+    name: 'UnrecognizedArgument',
+    message: 'Invalid argument: creating a HDPrivateKey requires a string, buffer, json or object, got "{0}"'
+  }]
+}, {
+  name: 'HDPublicKey',
+  message: 'Internal Error on HDPublicKey {0}',
+  errors: [{
+    name: 'ArgumentIsPrivateExtended',
+    message: 'Argument is an extended private key: {0}'
+  }, {
+    name: 'InvalidDerivationArgument',
+    message: 'Invalid derivation argument: got {0}'
+  }, {
+    name: 'InvalidLength',
+    message: 'Invalid length for xpubkey: got "{0}"'
+  }, {
+    name: 'InvalidPath',
+    message: 'Invalid derivation path, it should look like: "m/1/100", got "{0}"'
+  }, {
+    name: 'InvalidIndexCantDeriveHardened',
+    message: 'Invalid argument: creating a hardened path requires an HDPrivateKey'
+  }, {
+    name: 'MustSupplyArgument',
+    message: 'Must supply an argument to create a HDPublicKey'
+  }, {
+    name: 'UnrecognizedArgument',
+    message: 'Invalid argument for creation, must be string, json, buffer, or object'
+  }]
+}]