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

Light Client for Exonum CIS Blockchain

"use strict";

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

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Bool = exports.Uint64 = exports.Uint32 = exports.Uint16 = exports.Uint8 = void 0;

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _bigInteger = _interopRequireDefault(require("big-integer"));

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

var MAX_UINT8 = 255;
var MAX_UINT16 = 65535;
var MAX_UINT32 = 4294967295;
var MAX_UINT64 = 18446744073709551615;
/**
 * Insert number into array as little-endian or big-endian
 * @param {number|bigInt} number
 * @param {Array} buffer
 * @param {number} from
 * @param {number} size
 * @param {boolean} isBigEndian
 * @returns {Array}
 */

function insertIntegerToByteArray(number, buffer, from, size) {
  var isBigEndian = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
  var value = (0, _bigInteger["default"])(number); // convert a number-like object into a big integer

  for (var pos = isBigEndian ? size - 1 : 0; isBigEndian ? pos >= 0 : pos < size; isBigEndian ? pos-- : pos++) {
    var divmod = value.divmod(256);
    buffer[from + pos] = divmod.remainder.toJSNumber();
    value = divmod.quotient;
  }

  return buffer;
}

var Uint8 =
/*#__PURE__*/
function () {
  function Uint8() {
    (0, _classCallCheck2["default"])(this, Uint8);
  }

  (0, _createClass2["default"])(Uint8, null, [{
    key: "size",
    value: function size() {
      return 1;
    }
    /**
     * @param {number} value
     * @param {Array} buffer
     * @param {number} from
     * @returns {Array}
     */

  }, {
    key: "serialize",
    value: function serialize(value, buffer, from) {
      if (!validate.validateInteger(value, 0, MAX_UINT8, from, this.size())) {
        throw new TypeError('Uint8 of wrong type is passed: ' + value);
      }

      return insertIntegerToByteArray(value, buffer, from, this.size());
    }
  }]);
  return Uint8;
}();

exports.Uint8 = Uint8;

var Uint16 =
/*#__PURE__*/
function () {
  function Uint16() {
    (0, _classCallCheck2["default"])(this, Uint16);
  }

  (0, _createClass2["default"])(Uint16, null, [{
    key: "size",
    value: function size() {
      return 2;
    }
    /**
     * @param {number} value
     * @param {Array} buffer
     * @param {number} from
     * @param {boolean} isBigEndian
     * @returns {Array}
     */

  }, {
    key: "serialize",
    value: function serialize(value, buffer, from, isBigEndian) {
      if (!validate.validateInteger(value, 0, MAX_UINT16, from, this.size())) {
        throw new TypeError('Uint16 of wrong type is passed: ' + value);
      }

      return insertIntegerToByteArray(value, buffer, from, this.size(), isBigEndian);
    }
  }]);
  return Uint16;
}();

exports.Uint16 = Uint16;

var Uint32 =
/*#__PURE__*/
function () {
  function Uint32() {
    (0, _classCallCheck2["default"])(this, Uint32);
  }

  (0, _createClass2["default"])(Uint32, null, [{
    key: "size",
    value: function size() {
      return 4;
    }
    /**
     * @param {number} value
     * @param {Array} buffer
     * @param {number} from
     * @param {boolean} isBigEndian
     * @returns {Array}
     */

  }, {
    key: "serialize",
    value: function serialize(value, buffer, from, isBigEndian) {
      if (!validate.validateInteger(value, 0, MAX_UINT32, from, this.size())) {
        throw new TypeError('Uint32 of wrong type is passed: ' + value);
      }

      return insertIntegerToByteArray(value, buffer, from, this.size(), isBigEndian);
    }
  }]);
  return Uint32;
}();

exports.Uint32 = Uint32;

var Uint64 =
/*#__PURE__*/
function () {
  function Uint64() {
    (0, _classCallCheck2["default"])(this, Uint64);
  }

  (0, _createClass2["default"])(Uint64, null, [{
    key: "size",
    value: function size() {
      return 8;
    }
    /**
     * @param {number} value
     * @param {Array} buffer
     * @param {number} from
     * @param {boolean} isBigEndian
     * @returns {Array}
     */

  }, {
    key: "serialize",
    value: function serialize(value, buffer, from, isBigEndian) {
      if (!validate.validateInteger(value, 0, MAX_UINT64, from, this.size())) {
        throw new TypeError('Uint16 of wrong type is passed: ' + value);
      }

      return insertIntegerToByteArray(value, buffer, from, this.size(), isBigEndian);
    }
  }]);
  return Uint64;
}();

exports.Uint64 = Uint64;

var Bool =
/*#__PURE__*/
function () {
  function Bool() {
    (0, _classCallCheck2["default"])(this, Bool);
  }

  (0, _createClass2["default"])(Bool, null, [{
    key: "size",
    value: function size() {
      return 1;
    }
    /**
     * @param {boolean} value
     * @param {Array} buffer
     * @param {number} from
     * @returns {Array}
     */

  }, {
    key: "serialize",
    value: function serialize(value, buffer, from) {
      if (typeof value !== 'boolean') {
        throw new TypeError('Wrong data type is passed as Boolean. Boolean is required');
      }

      return insertIntegerToByteArray(value ? 1 : 0, buffer, from, this.size());
    }
  }]);
  return Bool;
}();

exports.Bool = Bool;