exonum-client-cis/lib/types/hexadecimal.js

Light Client for Exonum CIS Blockchain

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.PublicKey = exports.Digest = exports.Hash = exports.Uuid = void 0;

var validate = _interopRequireWildcard(require("./validate"));

var _crypto = require("../crypto");

/**
 * Encoder
 *
 * @param {string} str string to encode
 * @param {Array} buffer buffer to place result to
 * @param {number} from position to write from
 * @returns {Array} modified buffer
 * @private
 */
function insertHexadecimalToByteArray(str, buffer, from) {
  for (var i = 0; i < str.length; i += 2) {
    buffer[from] = parseInt(str.substr(i, 2), 16);
    from++;
  }

  return buffer;
}
/**
 * Validator wrapper
 *
 * @param {string} name structure name
 * @param {number} size value size in bytes
 * @param {string} value value representation
 * @returns {string} value if validation passes
 * @throws {TypeError} in case of validation break
 * @private
 */


function validateHexadecimal(name, size, value) {
  if (!validate.validateHexadecimal(value, size)) {
    throw new TypeError("".concat(name, " of wrong type is passed: ").concat(value));
  }

  return value;
}
/**
 * Factory for building Hex Types
 *
 * @param {function(value, buffer, from)} serizalizer function accepting value, buffer, position and returns modified buffer
 * @param {function() => number} sizeGetter a function, that returns the size of a type in bytes
 * @param {string} name type name to distinguish between types
 * @returns {Object} hex type
 */


function hexTypeFactory(serizalizer, sizeGetter, name) {
  return Object.defineProperties({}, {
    size: {
      get: function get() {
        return sizeGetter;
      },
      enumerable: true
    },
    name: {
      get: function get() {
        return name;
      },
      enumerable: true
    },
    serialize: {
      get: function get() {
        return serizalizer;
      }
    }
  });
}
/**
 * Common serializer
 *
 * @param {function(name, size, value)} validator hexadecimal validator
 * @param {function(value, buffer, from)} encoder function accepting value, buffer, position and returns modified buffer
 * @returns {function(value, buffer, from)} encoder wrapper
 * @throws {TypeError} in case of validation break
 * @private
 */


function serializer(encoder, validator) {
  return function (value, buffer, from) {
    return encoder(validator(value), buffer, from);
  };
}
/**
 * Uuid type factory
 *
 * @param {function(name, size, value)} validator hexadecimal validator
 * @param {function(validator, value, buffer, from)} encoder function accepting validator, value, buffer, position and returns modified buffer
 * @param {function(serizalizer, size, name)} factory type builder factory
 * @returns {Object} hex type
 * @private
 */


function Uuid(validator, serializer, factory) {
  var size = 16;
  var name = 'Uuid';

  function cleaner(value) {
    return String(value).replace(/-/g, '');
  }

  validator = validator.bind(null, name, size);
  serializer = serializer(function (value) {
    return validator(cleaner(value));
  });
  return factory(serializer, function () {
    return size;
  }, name);
}
/**
 * Hash type factory
 *
 * @param {function(name, size, value)} validator hexadecimal validator
 * @param {function(validator, value, buffer, from)} encoder function accepting validator, value, buffer, position and returns modified buffer
 * @param {function(serizalizer, size, name)} factory type builder factory
 * @returns {Object} hex type
 * @private
 */


function Hash(validator, serializer, factory) {
  var size = _crypto.HASH_LENGTH;
  var name = 'Hash';
  validator = validator.bind(null, name, size);
  serializer = serializer(validator);

  var hasher = function hasher(value) {
    return validator(value) && value;
  };

  return Object.defineProperty(factory(serializer, _crypto.HASH_LENGTH, name), 'hash', {
    value: hasher
  });
}
/**
 * Digest type factory
 *
 * @param {function(name, size, value)} validator hexadecimal validator
 * @param {function(validator, value, buffer, from)} encoder function accepting validator, value, buffer, position and returns modified buffer
 * @param {function(serizalizer, size, name)} factory type builder factory
 * @returns {Object} hex type
 * @private
 */


function Digest(validator, serializer, factory) {
  var size = 64;
  var name = 'Digest';
  validator = validator.bind(null, name, size);
  serializer = serializer(validator);
  return factory(serializer, function () {
    return size;
  }, name);
}
/**
 * PublicKey type factory
 *
 * @param {function(name, size, value)} validator hexadecimal validator
 * @param {function(validator, value, buffer, from)} encoder function accepting validator, value, buffer, position and returns modified buffer
 * @param {function(serizalizer, size, name)} factory type builder factory
 * @returns {Object} hex type
 * @private
 */


function PublicKey(validator, serializer, factory) {
  var name = 'PublicKey';

  var boundValidator = function boundValidator(value) {
    return validator(name, _crypto.PUBLIC_KEY_LENGTH, value);
  };

  serializer = serializer(boundValidator);
  return factory(serializer, function () {
    return _crypto.PUBLIC_KEY_LENGTH;
  }, name);
}

var baseSerializer = serializer.bind(null, insertHexadecimalToByteArray);
var uuid = Uuid(validateHexadecimal, baseSerializer, hexTypeFactory);
exports.Uuid = uuid;
var hash = Hash(validateHexadecimal, baseSerializer, hexTypeFactory);
exports.Hash = hash;
var digest = Digest(validateHexadecimal, baseSerializer, hexTypeFactory);
exports.Digest = digest;
var publicKey = PublicKey(validateHexadecimal, baseSerializer, hexTypeFactory);
exports.PublicKey = publicKey;