@opcat-labs/opcat 1.0.0

package/lib/encoding/encode-hex.js

@@ -0,0 +1,284 @@
+/* global VARIANT */
+
+let encodeHex = null;
+
+// Prefer our implementation of encodeHex over Buffer when we don't know the VARIANT
+// to avoid accidentally importing the Buffer shim in the browser.
+
+if (typeof VARIANT === 'undefined' || VARIANT === 'browser') {
+  // In the browser, a lookup table is fastest, and faster than the Buffer toString shim.
+  const HEX = [
+    '00',
+    '01',
+    '02',
+    '03',
+    '04',
+    '05',
+    '06',
+    '07',
+    '08',
+    '09',
+    '0a',
+    '0b',
+    '0c',
+    '0d',
+    '0e',
+    '0f',
+    '10',
+    '11',
+    '12',
+    '13',
+    '14',
+    '15',
+    '16',
+    '17',
+    '18',
+    '19',
+    '1a',
+    '1b',
+    '1c',
+    '1d',
+    '1e',
+    '1f',
+    '20',
+    '21',
+    '22',
+    '23',
+    '24',
+    '25',
+    '26',
+    '27',
+    '28',
+    '29',
+    '2a',
+    '2b',
+    '2c',
+    '2d',
+    '2e',
+    '2f',
+    '30',
+    '31',
+    '32',
+    '33',
+    '34',
+    '35',
+    '36',
+    '37',
+    '38',
+    '39',
+    '3a',
+    '3b',
+    '3c',
+    '3d',
+    '3e',
+    '3f',
+    '40',
+    '41',
+    '42',
+    '43',
+    '44',
+    '45',
+    '46',
+    '47',
+    '48',
+    '49',
+    '4a',
+    '4b',
+    '4c',
+    '4d',
+    '4e',
+    '4f',
+    '50',
+    '51',
+    '52',
+    '53',
+    '54',
+    '55',
+    '56',
+    '57',
+    '58',
+    '59',
+    '5a',
+    '5b',
+    '5c',
+    '5d',
+    '5e',
+    '5f',
+    '60',
+    '61',
+    '62',
+    '63',
+    '64',
+    '65',
+    '66',
+    '67',
+    '68',
+    '69',
+    '6a',
+    '6b',
+    '6c',
+    '6d',
+    '6e',
+    '6f',
+    '70',
+    '71',
+    '72',
+    '73',
+    '74',
+    '75',
+    '76',
+    '77',
+    '78',
+    '79',
+    '7a',
+    '7b',
+    '7c',
+    '7d',
+    '7e',
+    '7f',
+    '80',
+    '81',
+    '82',
+    '83',
+    '84',
+    '85',
+    '86',
+    '87',
+    '88',
+    '89',
+    '8a',
+    '8b',
+    '8c',
+    '8d',
+    '8e',
+    '8f',
+    '90',
+    '91',
+    '92',
+    '93',
+    '94',
+    '95',
+    '96',
+    '97',
+    '98',
+    '99',
+    '9a',
+    '9b',
+    '9c',
+    '9d',
+    '9e',
+    '9f',
+    'a0',
+    'a1',
+    'a2',
+    'a3',
+    'a4',
+    'a5',
+    'a6',
+    'a7',
+    'a8',
+    'a9',
+    'aa',
+    'ab',
+    'ac',
+    'ad',
+    'ae',
+    'af',
+    'b0',
+    'b1',
+    'b2',
+    'b3',
+    'b4',
+    'b5',
+    'b6',
+    'b7',
+    'b8',
+    'b9',
+    'ba',
+    'bb',
+    'bc',
+    'bd',
+    'be',
+    'bf',
+    'c0',
+    'c1',
+    'c2',
+    'c3',
+    'c4',
+    'c5',
+    'c6',
+    'c7',
+    'c8',
+    'c9',
+    'ca',
+    'cb',
+    'cc',
+    'cd',
+    'ce',
+    'cf',
+    'd0',
+    'd1',
+    'd2',
+    'd3',
+    'd4',
+    'd5',
+    'd6',
+    'd7',
+    'd8',
+    'd9',
+    'da',
+    'db',
+    'dc',
+    'dd',
+    'de',
+    'df',
+    'e0',
+    'e1',
+    'e2',
+    'e3',
+    'e4',
+    'e5',
+    'e6',
+    'e7',
+    'e8',
+    'e9',
+    'ea',
+    'eb',
+    'ec',
+    'ed',
+    'ee',
+    'ef',
+    'f0',
+    'f1',
+    'f2',
+    'f3',
+    'f4',
+    'f5',
+    'f6',
+    'f7',
+    'f8',
+    'f9',
+    'fa',
+    'fb',
+    'fc',
+    'fd',
+    'fe',
+    'ff',
+  ];
+
+  encodeHex = function (buffer) {
+    const len = buffer.length;
+    const out = new Array(len);
+    for (let i = 0; i < len; ++i) {
+      out[i] = HEX[buffer[i]];
+    }
+    return out.join('');
+  };
+} else {
+  // Buffer toString('hex') in Node is faster than any JavaScript we could write
+  encodeHex = function (buffer) {
+    return buffer instanceof Buffer ? buffer.toString('hex') : Buffer.from(buffer).toString('hex');
+  };
+}
+
+module.exports = encodeHex;

package/lib/encoding/is-hex.js

@@ -0,0 +1,7 @@
+const HEX_REGEX = /^(?:[a-fA-F0-9][a-fA-F0-9])*$/;
+
+function isHex(s) {
+  return HEX_REGEX.test(s);
+}
+
+module.exports = isHex;

package/lib/encoding/varint.js

@@ -0,0 +1,75 @@
+'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) {
+  var bw = new BufferWriter();
+  this.buf = bw.writeVarintBN(bn).toBuffer();
+  return this;
+};
+
+Varint.prototype.fromNumber = function (num) {
+  var bw = new BufferWriter();
+  this.buf = bw.writeVarintNum(num).toBuffer();
+  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,54 @@
+'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 opcat = {};
+opcat.Error = function () {
+  this.message = 'Internal error';
+  this.stack = this.message + '\n' + new Error().stack;
+};
+opcat.Error.prototype = Object.create(Error.prototype);
+opcat.Error.prototype.name = 'opcat.Error';
+
+var data = require('./spec');
+traverseRoot(opcat.Error, data);
+
+module.exports = opcat.Error;
+
+module.exports.extend = function (spec) {
+  return traverseNode(opcat.Error, spec);
+};