madeline-ton/dist/crypto/crypto-sync.js

Pure JS client-side implementation of the Telegram TON blockchain protocol

"use strict";

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

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

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

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

var _prime = _interopRequireDefault(require("../crypto-sync/prime"));

var _random = require("../crypto-sync/random");

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

var _zlib = require("zlib");

var CryptoSync =
/*#__PURE__*/
function () {
  /**
   * 
   * @param {Parser} parser TL Parser
   */
  function CryptoSync(parser) {
    (0, _classCallCheck2["default"])(this, CryptoSync);
    this.TL = parser;
  }
  /**
   * Factorize semiprime
   * @param {Uint8Array} what Number to factorize
   * @returns Uint8Array[]
   */


  (0, _createClass2["default"])(CryptoSync, [{
    key: "factorize",
    value: function factorize(what) {
      return Promise.resolve((0, _prime["default"])(what));
    }
    /**
     * Fill buffer with secure random values
     * @param {BufferSource} buffer Buffer to fill
     */

  }, {
    key: "secureRandom",
    value: function secureRandom(buffer) {
      return Promise.resolve((0, _random.secureRandom)(buffer));
    }
    /**
     * Get secure random number modulo modulus
     * @param {number} mod Modulus
     */

  }, {
    key: "secureRandomInt",
    value: function secureRandomInt(mod) {
      return Promise.resolve((0, _random.secureRandomInt)(mod));
    }
    /**
     * SHA1
     * @param {Uint32Array} data Data to hash
     * @returns Uint32Array
     */

  }, {
    key: "sha1",
    value: function sha1(buffer) {
      return Promise.resolve((0, _crypto.sha1)(buffer));
    }
    /**
     * SHA256
     * @param {Uint32Array} data Data to hash
     * @returns Uint32Array
     */

  }, {
    key: "sha256",
    value: function sha256(buffer) {
      return Promise.resolve((0, _crypto.sha256)(buffer));
    }
    /**
     * Encrypt data using AES IGE
     * @param {Uint32Array} data Data
     * @param {Uint32Array} key  Key
     * @param {Uint32Array} iv   IV
     */

  }, {
    key: "igeEncrypt",
    value: function igeEncrypt(data, key, iv) {
      return Promise.resolve((0, _crypto.igeEncrypt)(data, key, iv));
    }
    /**
     * Decrypt data using AES IGE
     * @param {Uint32Array} data Data
     * @param {Uint32Array} key  Key
     * @param {Uint32Array} iv   IV
     */

  }, {
    key: "igeDecrypt",
    value: function igeDecrypt(data, key, iv) {
      return Promise.resolve((0, _crypto.igeDecrypt)(data, key, iv));
    }
    /**
     * Deserialize TL payload
     * @param {Stream} data Data
     * @returns {Object}
     */

  }, {
    key: "deserialize",
    value: function deserialize(data) {
      return Promise.resolve(this.TL.deserialize(data));
    }
    /**
     * Generate elliptic-curve init context
     * @param {Uint32Array} peerPublic Peer's public Ed25519 key
     * @returns {Object}
     */

  }, {
    key: "initEC",
    value: function initEC(peerPublic) {
      return Promise.resolve((0, _crypto.initEC)(peerPublic));
    }
    /**
     * Get crc16 checksum of data
     * @param {Uint8Array} data Data
     * @returns {Uint8Array} Checksum
     */

  }, {
    key: "crc16",
    value: function crc16(data) {
      return Promise.resolve((0, _crypto.crc16)(data));
    }
  }]);
  return CryptoSync;
}();

var _default = CryptoSync;
exports["default"] = _default;