core-3nweb-client-lib 0.24.0 → 0.24.1

package/build/protos/cryptor.proto.js

@@ -0,0 +1,1667 @@
+/*eslint-disable block-scoped-var, id-length, no-control-regex, no-magic-numbers, no-prototype-builtins, no-redeclare, no-shadow, no-var, sort-vars*/
+"use strict";
+
+var $protobuf = require("protobufjs/minimal");
+
+// Common aliases
+var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
+
+// Exported root namespace
+var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
+
+$root.cryptor = (function() {
+
+    /**
+     * Namespace cryptor.
+     * @exports cryptor
+     * @namespace
+     */
+    var cryptor = {};
+
+    cryptor.Request = (function() {
+
+        /**
+         * Properties of a Request.
+         * @memberof cryptor
+         * @interface IRequest
+         * @property {number|null} [func] Request func
+         * @property {Array.<cryptor.IBytesVal>|null} [byteArgs] Request byteArgs
+         * @property {cryptor.Request.IScryptArgs|null} [scryptArgs] Request scryptArgs
+         */
+
+        /**
+         * Constructs a new Request.
+         * @memberof cryptor
+         * @classdesc Represents a Request.
+         * @implements IRequest
+         * @constructor
+         * @param {cryptor.IRequest=} [properties] Properties to set
+         */
+        function Request(properties) {
+            this.byteArgs = [];
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * Request func.
+         * @member {number} func
+         * @memberof cryptor.Request
+         * @instance
+         */
+        Request.prototype.func = 0;
+
+        /**
+         * Request byteArgs.
+         * @member {Array.<cryptor.IBytesVal>} byteArgs
+         * @memberof cryptor.Request
+         * @instance
+         */
+        Request.prototype.byteArgs = $util.emptyArray;
+
+        /**
+         * Request scryptArgs.
+         * @member {cryptor.Request.IScryptArgs|null|undefined} scryptArgs
+         * @memberof cryptor.Request
+         * @instance
+         */
+        Request.prototype.scryptArgs = null;
+
+        /**
+         * Creates a new Request instance using the specified properties.
+         * @function create
+         * @memberof cryptor.Request
+         * @static
+         * @param {cryptor.IRequest=} [properties] Properties to set
+         * @returns {cryptor.Request} Request instance
+         */
+        Request.create = function create(properties) {
+            return new Request(properties);
+        };
+
+        /**
+         * Encodes the specified Request message. Does not implicitly {@link cryptor.Request.verify|verify} messages.
+         * @function encode
+         * @memberof cryptor.Request
+         * @static
+         * @param {cryptor.IRequest} message Request message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Request.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.func != null && Object.hasOwnProperty.call(message, "func"))
+                writer.uint32(/* id 1, wireType 0 =*/8).uint32(message.func);
+            if (message.byteArgs != null && message.byteArgs.length)
+                for (var i = 0; i < message.byteArgs.length; ++i)
+                    $root.cryptor.BytesVal.encode(message.byteArgs[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+            if (message.scryptArgs != null && Object.hasOwnProperty.call(message, "scryptArgs"))
+                $root.cryptor.Request.ScryptArgs.encode(message.scryptArgs, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
+            return writer;
+        };
+
+        /**
+         * Encodes the specified Request message, length delimited. Does not implicitly {@link cryptor.Request.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof cryptor.Request
+         * @static
+         * @param {cryptor.IRequest} message Request message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Request.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a Request message from the specified reader or buffer.
+         * @function decode
+         * @memberof cryptor.Request
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {cryptor.Request} Request
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Request.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.cryptor.Request();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1:
+                    message.func = reader.uint32();
+                    break;
+                case 2:
+                    if (!(message.byteArgs && message.byteArgs.length))
+                        message.byteArgs = [];
+                    message.byteArgs.push($root.cryptor.BytesVal.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.scryptArgs = $root.cryptor.Request.ScryptArgs.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes a Request message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof cryptor.Request
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {cryptor.Request} Request
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Request.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a Request message.
+         * @function verify
+         * @memberof cryptor.Request
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        Request.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.func != null && message.hasOwnProperty("func"))
+                if (!$util.isInteger(message.func))
+                    return "func: integer expected";
+            if (message.byteArgs != null && message.hasOwnProperty("byteArgs")) {
+                if (!Array.isArray(message.byteArgs))
+                    return "byteArgs: array expected";
+                for (var i = 0; i < message.byteArgs.length; ++i) {
+                    var error = $root.cryptor.BytesVal.verify(message.byteArgs[i]);
+                    if (error)
+                        return "byteArgs." + error;
+                }
+            }
+            if (message.scryptArgs != null && message.hasOwnProperty("scryptArgs")) {
+                var error = $root.cryptor.Request.ScryptArgs.verify(message.scryptArgs);
+                if (error)
+                    return "scryptArgs." + error;
+            }
+            return null;
+        };
+
+        /**
+         * Creates a Request message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof cryptor.Request
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {cryptor.Request} Request
+         */
+        Request.fromObject = function fromObject(object) {
+            if (object instanceof $root.cryptor.Request)
+                return object;
+            var message = new $root.cryptor.Request();
+            if (object.func != null)
+                message.func = object.func >>> 0;
+            if (object.byteArgs) {
+                if (!Array.isArray(object.byteArgs))
+                    throw TypeError(".cryptor.Request.byteArgs: array expected");
+                message.byteArgs = [];
+                for (var i = 0; i < object.byteArgs.length; ++i) {
+                    if (typeof object.byteArgs[i] !== "object")
+                        throw TypeError(".cryptor.Request.byteArgs: object expected");
+                    message.byteArgs[i] = $root.cryptor.BytesVal.fromObject(object.byteArgs[i]);
+                }
+            }
+            if (object.scryptArgs != null) {
+                if (typeof object.scryptArgs !== "object")
+                    throw TypeError(".cryptor.Request.scryptArgs: object expected");
+                message.scryptArgs = $root.cryptor.Request.ScryptArgs.fromObject(object.scryptArgs);
+            }
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a Request message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof cryptor.Request
+         * @static
+         * @param {cryptor.Request} message Request
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        Request.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.arrays || options.defaults)
+                object.byteArgs = [];
+            if (options.defaults) {
+                object.func = 0;
+                object.scryptArgs = null;
+            }
+            if (message.func != null && message.hasOwnProperty("func"))
+                object.func = message.func;
+            if (message.byteArgs && message.byteArgs.length) {
+                object.byteArgs = [];
+                for (var j = 0; j < message.byteArgs.length; ++j)
+                    object.byteArgs[j] = $root.cryptor.BytesVal.toObject(message.byteArgs[j], options);
+            }
+            if (message.scryptArgs != null && message.hasOwnProperty("scryptArgs"))
+                object.scryptArgs = $root.cryptor.Request.ScryptArgs.toObject(message.scryptArgs, options);
+            return object;
+        };
+
+        /**
+         * Converts this Request to JSON.
+         * @function toJSON
+         * @memberof cryptor.Request
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        Request.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        Request.ScryptArgs = (function() {
+
+            /**
+             * Properties of a ScryptArgs.
+             * @memberof cryptor.Request
+             * @interface IScryptArgs
+             * @property {Uint8Array|null} [passwd] ScryptArgs passwd
+             * @property {Uint8Array|null} [salt] ScryptArgs salt
+             * @property {number|null} [logN] ScryptArgs logN
+             * @property {number|null} [r] ScryptArgs r
+             * @property {number|null} [p] ScryptArgs p
+             * @property {number|null} [dkLen] ScryptArgs dkLen
+             */
+
+            /**
+             * Constructs a new ScryptArgs.
+             * @memberof cryptor.Request
+             * @classdesc Represents a ScryptArgs.
+             * @implements IScryptArgs
+             * @constructor
+             * @param {cryptor.Request.IScryptArgs=} [properties] Properties to set
+             */
+            function ScryptArgs(properties) {
+                if (properties)
+                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                        if (properties[keys[i]] != null)
+                            this[keys[i]] = properties[keys[i]];
+            }
+
+            /**
+             * ScryptArgs passwd.
+             * @member {Uint8Array} passwd
+             * @memberof cryptor.Request.ScryptArgs
+             * @instance
+             */
+            ScryptArgs.prototype.passwd = $util.newBuffer([]);
+
+            /**
+             * ScryptArgs salt.
+             * @member {Uint8Array} salt
+             * @memberof cryptor.Request.ScryptArgs
+             * @instance
+             */
+            ScryptArgs.prototype.salt = $util.newBuffer([]);
+
+            /**
+             * ScryptArgs logN.
+             * @member {number} logN
+             * @memberof cryptor.Request.ScryptArgs
+             * @instance
+             */
+            ScryptArgs.prototype.logN = 0;
+
+            /**
+             * ScryptArgs r.
+             * @member {number} r
+             * @memberof cryptor.Request.ScryptArgs
+             * @instance
+             */
+            ScryptArgs.prototype.r = 0;
+
+            /**
+             * ScryptArgs p.
+             * @member {number} p
+             * @memberof cryptor.Request.ScryptArgs
+             * @instance
+             */
+            ScryptArgs.prototype.p = 0;
+
+            /**
+             * ScryptArgs dkLen.
+             * @member {number} dkLen
+             * @memberof cryptor.Request.ScryptArgs
+             * @instance
+             */
+            ScryptArgs.prototype.dkLen = 0;
+
+            /**
+             * Creates a new ScryptArgs instance using the specified properties.
+             * @function create
+             * @memberof cryptor.Request.ScryptArgs
+             * @static
+             * @param {cryptor.Request.IScryptArgs=} [properties] Properties to set
+             * @returns {cryptor.Request.ScryptArgs} ScryptArgs instance
+             */
+            ScryptArgs.create = function create(properties) {
+                return new ScryptArgs(properties);
+            };
+
+            /**
+             * Encodes the specified ScryptArgs message. Does not implicitly {@link cryptor.Request.ScryptArgs.verify|verify} messages.
+             * @function encode
+             * @memberof cryptor.Request.ScryptArgs
+             * @static
+             * @param {cryptor.Request.IScryptArgs} message ScryptArgs message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            ScryptArgs.encode = function encode(message, writer) {
+                if (!writer)
+                    writer = $Writer.create();
+                if (message.passwd != null && Object.hasOwnProperty.call(message, "passwd"))
+                    writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.passwd);
+                if (message.salt != null && Object.hasOwnProperty.call(message, "salt"))
+                    writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.salt);
+                if (message.logN != null && Object.hasOwnProperty.call(message, "logN"))
+                    writer.uint32(/* id 3, wireType 0 =*/24).uint32(message.logN);
+                if (message.r != null && Object.hasOwnProperty.call(message, "r"))
+                    writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.r);
+                if (message.p != null && Object.hasOwnProperty.call(message, "p"))
+                    writer.uint32(/* id 5, wireType 0 =*/40).uint32(message.p);
+                if (message.dkLen != null && Object.hasOwnProperty.call(message, "dkLen"))
+                    writer.uint32(/* id 6, wireType 0 =*/48).uint32(message.dkLen);
+                return writer;
+            };
+
+            /**
+             * Encodes the specified ScryptArgs message, length delimited. Does not implicitly {@link cryptor.Request.ScryptArgs.verify|verify} messages.
+             * @function encodeDelimited
+             * @memberof cryptor.Request.ScryptArgs
+             * @static
+             * @param {cryptor.Request.IScryptArgs} message ScryptArgs message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            ScryptArgs.encodeDelimited = function encodeDelimited(message, writer) {
+                return this.encode(message, writer).ldelim();
+            };
+
+            /**
+             * Decodes a ScryptArgs message from the specified reader or buffer.
+             * @function decode
+             * @memberof cryptor.Request.ScryptArgs
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @param {number} [length] Message length if known beforehand
+             * @returns {cryptor.Request.ScryptArgs} ScryptArgs
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            ScryptArgs.decode = function decode(reader, length) {
+                if (!(reader instanceof $Reader))
+                    reader = $Reader.create(reader);
+                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.cryptor.Request.ScryptArgs();
+                while (reader.pos < end) {
+                    var tag = reader.uint32();
+                    switch (tag >>> 3) {
+                    case 1:
+                        message.passwd = reader.bytes();
+                        break;
+                    case 2:
+                        message.salt = reader.bytes();
+                        break;
+                    case 3:
+                        message.logN = reader.uint32();
+                        break;
+                    case 4:
+                        message.r = reader.uint32();
+                        break;
+                    case 5:
+                        message.p = reader.uint32();
+                        break;
+                    case 6:
+                        message.dkLen = reader.uint32();
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                    }
+                }
+                return message;
+            };
+
+            /**
+             * Decodes a ScryptArgs message from the specified reader or buffer, length delimited.
+             * @function decodeDelimited
+             * @memberof cryptor.Request.ScryptArgs
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @returns {cryptor.Request.ScryptArgs} ScryptArgs
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            ScryptArgs.decodeDelimited = function decodeDelimited(reader) {
+                if (!(reader instanceof $Reader))
+                    reader = new $Reader(reader);
+                return this.decode(reader, reader.uint32());
+            };
+
+            /**
+             * Verifies a ScryptArgs message.
+             * @function verify
+             * @memberof cryptor.Request.ScryptArgs
+             * @static
+             * @param {Object.<string,*>} message Plain object to verify
+             * @returns {string|null} `null` if valid, otherwise the reason why it is not
+             */
+            ScryptArgs.verify = function verify(message) {
+                if (typeof message !== "object" || message === null)
+                    return "object expected";
+                if (message.passwd != null && message.hasOwnProperty("passwd"))
+                    if (!(message.passwd && typeof message.passwd.length === "number" || $util.isString(message.passwd)))
+                        return "passwd: buffer expected";
+                if (message.salt != null && message.hasOwnProperty("salt"))
+                    if (!(message.salt && typeof message.salt.length === "number" || $util.isString(message.salt)))
+                        return "salt: buffer expected";
+                if (message.logN != null && message.hasOwnProperty("logN"))
+                    if (!$util.isInteger(message.logN))
+                        return "logN: integer expected";
+                if (message.r != null && message.hasOwnProperty("r"))
+                    if (!$util.isInteger(message.r))
+                        return "r: integer expected";
+                if (message.p != null && message.hasOwnProperty("p"))
+                    if (!$util.isInteger(message.p))
+                        return "p: integer expected";
+                if (message.dkLen != null && message.hasOwnProperty("dkLen"))
+                    if (!$util.isInteger(message.dkLen))
+                        return "dkLen: integer expected";
+                return null;
+            };
+
+            /**
+             * Creates a ScryptArgs message from a plain object. Also converts values to their respective internal types.
+             * @function fromObject
+             * @memberof cryptor.Request.ScryptArgs
+             * @static
+             * @param {Object.<string,*>} object Plain object
+             * @returns {cryptor.Request.ScryptArgs} ScryptArgs
+             */
+            ScryptArgs.fromObject = function fromObject(object) {
+                if (object instanceof $root.cryptor.Request.ScryptArgs)
+                    return object;
+                var message = new $root.cryptor.Request.ScryptArgs();
+                if (object.passwd != null)
+                    if (typeof object.passwd === "string")
+                        $util.base64.decode(object.passwd, message.passwd = $util.newBuffer($util.base64.length(object.passwd)), 0);
+                    else if (object.passwd.length)
+                        message.passwd = object.passwd;
+                if (object.salt != null)
+                    if (typeof object.salt === "string")
+                        $util.base64.decode(object.salt, message.salt = $util.newBuffer($util.base64.length(object.salt)), 0);
+                    else if (object.salt.length)
+                        message.salt = object.salt;
+                if (object.logN != null)
+                    message.logN = object.logN >>> 0;
+                if (object.r != null)
+                    message.r = object.r >>> 0;
+                if (object.p != null)
+                    message.p = object.p >>> 0;
+                if (object.dkLen != null)
+                    message.dkLen = object.dkLen >>> 0;
+                return message;
+            };
+
+            /**
+             * Creates a plain object from a ScryptArgs message. Also converts values to other types if specified.
+             * @function toObject
+             * @memberof cryptor.Request.ScryptArgs
+             * @static
+             * @param {cryptor.Request.ScryptArgs} message ScryptArgs
+             * @param {$protobuf.IConversionOptions} [options] Conversion options
+             * @returns {Object.<string,*>} Plain object
+             */
+            ScryptArgs.toObject = function toObject(message, options) {
+                if (!options)
+                    options = {};
+                var object = {};
+                if (options.defaults) {
+                    if (options.bytes === String)
+                        object.passwd = "";
+                    else {
+                        object.passwd = [];
+                        if (options.bytes !== Array)
+                            object.passwd = $util.newBuffer(object.passwd);
+                    }
+                    if (options.bytes === String)
+                        object.salt = "";
+                    else {
+                        object.salt = [];
+                        if (options.bytes !== Array)
+                            object.salt = $util.newBuffer(object.salt);
+                    }
+                    object.logN = 0;
+                    object.r = 0;
+                    object.p = 0;
+                    object.dkLen = 0;
+                }
+                if (message.passwd != null && message.hasOwnProperty("passwd"))
+                    object.passwd = options.bytes === String ? $util.base64.encode(message.passwd, 0, message.passwd.length) : options.bytes === Array ? Array.prototype.slice.call(message.passwd) : message.passwd;
+                if (message.salt != null && message.hasOwnProperty("salt"))
+                    object.salt = options.bytes === String ? $util.base64.encode(message.salt, 0, message.salt.length) : options.bytes === Array ? Array.prototype.slice.call(message.salt) : message.salt;
+                if (message.logN != null && message.hasOwnProperty("logN"))
+                    object.logN = message.logN;
+                if (message.r != null && message.hasOwnProperty("r"))
+                    object.r = message.r;
+                if (message.p != null && message.hasOwnProperty("p"))
+                    object.p = message.p;
+                if (message.dkLen != null && message.hasOwnProperty("dkLen"))
+                    object.dkLen = message.dkLen;
+                return object;
+            };
+
+            /**
+             * Converts this ScryptArgs to JSON.
+             * @function toJSON
+             * @memberof cryptor.Request.ScryptArgs
+             * @instance
+             * @returns {Object.<string,*>} JSON object
+             */
+            ScryptArgs.prototype.toJSON = function toJSON() {
+                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+            };
+
+            return ScryptArgs;
+        })();
+
+        return Request;
+    })();
+
+    cryptor.BytesVal = (function() {
+
+        /**
+         * Properties of a BytesVal.
+         * @memberof cryptor
+         * @interface IBytesVal
+         * @property {Uint8Array|null} [val] BytesVal val
+         */
+
+        /**
+         * Constructs a new BytesVal.
+         * @memberof cryptor
+         * @classdesc Represents a BytesVal.
+         * @implements IBytesVal
+         * @constructor
+         * @param {cryptor.IBytesVal=} [properties] Properties to set
+         */
+        function BytesVal(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * BytesVal val.
+         * @member {Uint8Array} val
+         * @memberof cryptor.BytesVal
+         * @instance
+         */
+        BytesVal.prototype.val = $util.newBuffer([]);
+
+        /**
+         * Creates a new BytesVal instance using the specified properties.
+         * @function create
+         * @memberof cryptor.BytesVal
+         * @static
+         * @param {cryptor.IBytesVal=} [properties] Properties to set
+         * @returns {cryptor.BytesVal} BytesVal instance
+         */
+        BytesVal.create = function create(properties) {
+            return new BytesVal(properties);
+        };
+
+        /**
+         * Encodes the specified BytesVal message. Does not implicitly {@link cryptor.BytesVal.verify|verify} messages.
+         * @function encode
+         * @memberof cryptor.BytesVal
+         * @static
+         * @param {cryptor.IBytesVal} message BytesVal message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        BytesVal.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.val != null && Object.hasOwnProperty.call(message, "val"))
+                writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.val);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified BytesVal message, length delimited. Does not implicitly {@link cryptor.BytesVal.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof cryptor.BytesVal
+         * @static
+         * @param {cryptor.IBytesVal} message BytesVal message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        BytesVal.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a BytesVal message from the specified reader or buffer.
+         * @function decode
+         * @memberof cryptor.BytesVal
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {cryptor.BytesVal} BytesVal
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        BytesVal.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.cryptor.BytesVal();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1:
+                    message.val = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes a BytesVal message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof cryptor.BytesVal
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {cryptor.BytesVal} BytesVal
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        BytesVal.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a BytesVal message.
+         * @function verify
+         * @memberof cryptor.BytesVal
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        BytesVal.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.val != null && message.hasOwnProperty("val"))
+                if (!(message.val && typeof message.val.length === "number" || $util.isString(message.val)))
+                    return "val: buffer expected";
+            return null;
+        };
+
+        /**
+         * Creates a BytesVal message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof cryptor.BytesVal
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {cryptor.BytesVal} BytesVal
+         */
+        BytesVal.fromObject = function fromObject(object) {
+            if (object instanceof $root.cryptor.BytesVal)
+                return object;
+            var message = new $root.cryptor.BytesVal();
+            if (object.val != null)
+                if (typeof object.val === "string")
+                    $util.base64.decode(object.val, message.val = $util.newBuffer($util.base64.length(object.val)), 0);
+                else if (object.val.length)
+                    message.val = object.val;
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a BytesVal message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof cryptor.BytesVal
+         * @static
+         * @param {cryptor.BytesVal} message BytesVal
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        BytesVal.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.defaults)
+                if (options.bytes === String)
+                    object.val = "";
+                else {
+                    object.val = [];
+                    if (options.bytes !== Array)
+                        object.val = $util.newBuffer(object.val);
+                }
+            if (message.val != null && message.hasOwnProperty("val"))
+                object.val = options.bytes === String ? $util.base64.encode(message.val, 0, message.val.length) : options.bytes === Array ? Array.prototype.slice.call(message.val) : message.val;
+            return object;
+        };
+
+        /**
+         * Converts this BytesVal to JSON.
+         * @function toJSON
+         * @memberof cryptor.BytesVal
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        BytesVal.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        return BytesVal;
+    })();
+
+    cryptor.Reply = (function() {
+
+        /**
+         * Properties of a Reply.
+         * @memberof cryptor
+         * @interface IReply
+         * @property {cryptor.IBytesVal|null} [res] Reply res
+         * @property {cryptor.IBytesVal|null} [interim] Reply interim
+         * @property {cryptor.Reply.IError|null} [err] Reply err
+         */
+
+        /**
+         * Constructs a new Reply.
+         * @memberof cryptor
+         * @classdesc Represents a Reply.
+         * @implements IReply
+         * @constructor
+         * @param {cryptor.IReply=} [properties] Properties to set
+         */
+        function Reply(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * Reply res.
+         * @member {cryptor.IBytesVal|null|undefined} res
+         * @memberof cryptor.Reply
+         * @instance
+         */
+        Reply.prototype.res = null;
+
+        /**
+         * Reply interim.
+         * @member {cryptor.IBytesVal|null|undefined} interim
+         * @memberof cryptor.Reply
+         * @instance
+         */
+        Reply.prototype.interim = null;
+
+        /**
+         * Reply err.
+         * @member {cryptor.Reply.IError|null|undefined} err
+         * @memberof cryptor.Reply
+         * @instance
+         */
+        Reply.prototype.err = null;
+
+        /**
+         * Creates a new Reply instance using the specified properties.
+         * @function create
+         * @memberof cryptor.Reply
+         * @static
+         * @param {cryptor.IReply=} [properties] Properties to set
+         * @returns {cryptor.Reply} Reply instance
+         */
+        Reply.create = function create(properties) {
+            return new Reply(properties);
+        };
+
+        /**
+         * Encodes the specified Reply message. Does not implicitly {@link cryptor.Reply.verify|verify} messages.
+         * @function encode
+         * @memberof cryptor.Reply
+         * @static
+         * @param {cryptor.IReply} message Reply message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Reply.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.res != null && Object.hasOwnProperty.call(message, "res"))
+                $root.cryptor.BytesVal.encode(message.res, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+            if (message.interim != null && Object.hasOwnProperty.call(message, "interim"))
+                $root.cryptor.BytesVal.encode(message.interim, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+            if (message.err != null && Object.hasOwnProperty.call(message, "err"))
+                $root.cryptor.Reply.Error.encode(message.err, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
+            return writer;
+        };
+
+        /**
+         * Encodes the specified Reply message, length delimited. Does not implicitly {@link cryptor.Reply.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof cryptor.Reply
+         * @static
+         * @param {cryptor.IReply} message Reply message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Reply.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a Reply message from the specified reader or buffer.
+         * @function decode
+         * @memberof cryptor.Reply
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {cryptor.Reply} Reply
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Reply.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.cryptor.Reply();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1:
+                    message.res = $root.cryptor.BytesVal.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.interim = $root.cryptor.BytesVal.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.err = $root.cryptor.Reply.Error.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes a Reply message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof cryptor.Reply
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {cryptor.Reply} Reply
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Reply.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a Reply message.
+         * @function verify
+         * @memberof cryptor.Reply
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        Reply.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.res != null && message.hasOwnProperty("res")) {
+                var error = $root.cryptor.BytesVal.verify(message.res);
+                if (error)
+                    return "res." + error;
+            }
+            if (message.interim != null && message.hasOwnProperty("interim")) {
+                var error = $root.cryptor.BytesVal.verify(message.interim);
+                if (error)
+                    return "interim." + error;
+            }
+            if (message.err != null && message.hasOwnProperty("err")) {
+                var error = $root.cryptor.Reply.Error.verify(message.err);
+                if (error)
+                    return "err." + error;
+            }
+            return null;
+        };
+
+        /**
+         * Creates a Reply message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof cryptor.Reply
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {cryptor.Reply} Reply
+         */
+        Reply.fromObject = function fromObject(object) {
+            if (object instanceof $root.cryptor.Reply)
+                return object;
+            var message = new $root.cryptor.Reply();
+            if (object.res != null) {
+                if (typeof object.res !== "object")
+                    throw TypeError(".cryptor.Reply.res: object expected");
+                message.res = $root.cryptor.BytesVal.fromObject(object.res);
+            }
+            if (object.interim != null) {
+                if (typeof object.interim !== "object")
+                    throw TypeError(".cryptor.Reply.interim: object expected");
+                message.interim = $root.cryptor.BytesVal.fromObject(object.interim);
+            }
+            if (object.err != null) {
+                if (typeof object.err !== "object")
+                    throw TypeError(".cryptor.Reply.err: object expected");
+                message.err = $root.cryptor.Reply.Error.fromObject(object.err);
+            }
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a Reply message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof cryptor.Reply
+         * @static
+         * @param {cryptor.Reply} message Reply
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        Reply.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.defaults) {
+                object.res = null;
+                object.interim = null;
+                object.err = null;
+            }
+            if (message.res != null && message.hasOwnProperty("res"))
+                object.res = $root.cryptor.BytesVal.toObject(message.res, options);
+            if (message.interim != null && message.hasOwnProperty("interim"))
+                object.interim = $root.cryptor.BytesVal.toObject(message.interim, options);
+            if (message.err != null && message.hasOwnProperty("err"))
+                object.err = $root.cryptor.Reply.Error.toObject(message.err, options);
+            return object;
+        };
+
+        /**
+         * Converts this Reply to JSON.
+         * @function toJSON
+         * @memberof cryptor.Reply
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        Reply.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        Reply.Error = (function() {
+
+            /**
+             * Properties of an Error.
+             * @memberof cryptor.Reply
+             * @interface IError
+             * @property {string|null} [condition] Error condition
+             * @property {string|null} [message] Error message
+             */
+
+            /**
+             * Constructs a new Error.
+             * @memberof cryptor.Reply
+             * @classdesc Represents an Error.
+             * @implements IError
+             * @constructor
+             * @param {cryptor.Reply.IError=} [properties] Properties to set
+             */
+            function Error(properties) {
+                if (properties)
+                    for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                        if (properties[keys[i]] != null)
+                            this[keys[i]] = properties[keys[i]];
+            }
+
+            /**
+             * Error condition.
+             * @member {string} condition
+             * @memberof cryptor.Reply.Error
+             * @instance
+             */
+            Error.prototype.condition = "";
+
+            /**
+             * Error message.
+             * @member {string} message
+             * @memberof cryptor.Reply.Error
+             * @instance
+             */
+            Error.prototype.message = "";
+
+            /**
+             * Creates a new Error instance using the specified properties.
+             * @function create
+             * @memberof cryptor.Reply.Error
+             * @static
+             * @param {cryptor.Reply.IError=} [properties] Properties to set
+             * @returns {cryptor.Reply.Error} Error instance
+             */
+            Error.create = function create(properties) {
+                return new Error(properties);
+            };
+
+            /**
+             * Encodes the specified Error message. Does not implicitly {@link cryptor.Reply.Error.verify|verify} messages.
+             * @function encode
+             * @memberof cryptor.Reply.Error
+             * @static
+             * @param {cryptor.Reply.IError} message Error message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            Error.encode = function encode(message, writer) {
+                if (!writer)
+                    writer = $Writer.create();
+                if (message.condition != null && Object.hasOwnProperty.call(message, "condition"))
+                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.condition);
+                if (message.message != null && Object.hasOwnProperty.call(message, "message"))
+                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.message);
+                return writer;
+            };
+
+            /**
+             * Encodes the specified Error message, length delimited. Does not implicitly {@link cryptor.Reply.Error.verify|verify} messages.
+             * @function encodeDelimited
+             * @memberof cryptor.Reply.Error
+             * @static
+             * @param {cryptor.Reply.IError} message Error message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            Error.encodeDelimited = function encodeDelimited(message, writer) {
+                return this.encode(message, writer).ldelim();
+            };
+
+            /**
+             * Decodes an Error message from the specified reader or buffer.
+             * @function decode
+             * @memberof cryptor.Reply.Error
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @param {number} [length] Message length if known beforehand
+             * @returns {cryptor.Reply.Error} Error
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            Error.decode = function decode(reader, length) {
+                if (!(reader instanceof $Reader))
+                    reader = $Reader.create(reader);
+                var end = length === undefined ? reader.len : reader.pos + length, message = new $root.cryptor.Reply.Error();
+                while (reader.pos < end) {
+                    var tag = reader.uint32();
+                    switch (tag >>> 3) {
+                    case 1:
+                        message.condition = reader.string();
+                        break;
+                    case 2:
+                        message.message = reader.string();
+                        break;
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                    }
+                }
+                return message;
+            };
+
+            /**
+             * Decodes an Error message from the specified reader or buffer, length delimited.
+             * @function decodeDelimited
+             * @memberof cryptor.Reply.Error
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @returns {cryptor.Reply.Error} Error
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            Error.decodeDelimited = function decodeDelimited(reader) {
+                if (!(reader instanceof $Reader))
+                    reader = new $Reader(reader);
+                return this.decode(reader, reader.uint32());
+            };
+
+            /**
+             * Verifies an Error message.
+             * @function verify
+             * @memberof cryptor.Reply.Error
+             * @static
+             * @param {Object.<string,*>} message Plain object to verify
+             * @returns {string|null} `null` if valid, otherwise the reason why it is not
+             */
+            Error.verify = function verify(message) {
+                if (typeof message !== "object" || message === null)
+                    return "object expected";
+                if (message.condition != null && message.hasOwnProperty("condition"))
+                    if (!$util.isString(message.condition))
+                        return "condition: string expected";
+                if (message.message != null && message.hasOwnProperty("message"))
+                    if (!$util.isString(message.message))
+                        return "message: string expected";
+                return null;
+            };
+
+            /**
+             * Creates an Error message from a plain object. Also converts values to their respective internal types.
+             * @function fromObject
+             * @memberof cryptor.Reply.Error
+             * @static
+             * @param {Object.<string,*>} object Plain object
+             * @returns {cryptor.Reply.Error} Error
+             */
+            Error.fromObject = function fromObject(object) {
+                if (object instanceof $root.cryptor.Reply.Error)
+                    return object;
+                var message = new $root.cryptor.Reply.Error();
+                if (object.condition != null)
+                    message.condition = String(object.condition);
+                if (object.message != null)
+                    message.message = String(object.message);
+                return message;
+            };
+
+            /**
+             * Creates a plain object from an Error message. Also converts values to other types if specified.
+             * @function toObject
+             * @memberof cryptor.Reply.Error
+             * @static
+             * @param {cryptor.Reply.Error} message Error
+             * @param {$protobuf.IConversionOptions} [options] Conversion options
+             * @returns {Object.<string,*>} Plain object
+             */
+            Error.toObject = function toObject(message, options) {
+                if (!options)
+                    options = {};
+                var object = {};
+                if (options.defaults) {
+                    object.condition = "";
+                    object.message = "";
+                }
+                if (message.condition != null && message.hasOwnProperty("condition"))
+                    object.condition = message.condition;
+                if (message.message != null && message.hasOwnProperty("message"))
+                    object.message = message.message;
+                return object;
+            };
+
+            /**
+             * Converts this Error to JSON.
+             * @function toJSON
+             * @memberof cryptor.Reply.Error
+             * @instance
+             * @returns {Object.<string,*>} JSON object
+             */
+            Error.prototype.toJSON = function toJSON() {
+                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+            };
+
+            return Error;
+        })();
+
+        return Reply;
+    })();
+
+    cryptor.BoolVal = (function() {
+
+        /**
+         * Properties of a BoolVal.
+         * @memberof cryptor
+         * @interface IBoolVal
+         * @property {boolean|null} [val] BoolVal val
+         */
+
+        /**
+         * Constructs a new BoolVal.
+         * @memberof cryptor
+         * @classdesc Represents a BoolVal.
+         * @implements IBoolVal
+         * @constructor
+         * @param {cryptor.IBoolVal=} [properties] Properties to set
+         */
+        function BoolVal(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * BoolVal val.
+         * @member {boolean} val
+         * @memberof cryptor.BoolVal
+         * @instance
+         */
+        BoolVal.prototype.val = false;
+
+        /**
+         * Creates a new BoolVal instance using the specified properties.
+         * @function create
+         * @memberof cryptor.BoolVal
+         * @static
+         * @param {cryptor.IBoolVal=} [properties] Properties to set
+         * @returns {cryptor.BoolVal} BoolVal instance
+         */
+        BoolVal.create = function create(properties) {
+            return new BoolVal(properties);
+        };
+
+        /**
+         * Encodes the specified BoolVal message. Does not implicitly {@link cryptor.BoolVal.verify|verify} messages.
+         * @function encode
+         * @memberof cryptor.BoolVal
+         * @static
+         * @param {cryptor.IBoolVal} message BoolVal message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        BoolVal.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.val != null && Object.hasOwnProperty.call(message, "val"))
+                writer.uint32(/* id 1, wireType 0 =*/8).bool(message.val);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified BoolVal message, length delimited. Does not implicitly {@link cryptor.BoolVal.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof cryptor.BoolVal
+         * @static
+         * @param {cryptor.IBoolVal} message BoolVal message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        BoolVal.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a BoolVal message from the specified reader or buffer.
+         * @function decode
+         * @memberof cryptor.BoolVal
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {cryptor.BoolVal} BoolVal
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        BoolVal.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.cryptor.BoolVal();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1:
+                    message.val = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes a BoolVal message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof cryptor.BoolVal
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {cryptor.BoolVal} BoolVal
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        BoolVal.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a BoolVal message.
+         * @function verify
+         * @memberof cryptor.BoolVal
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        BoolVal.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.val != null && message.hasOwnProperty("val"))
+                if (typeof message.val !== "boolean")
+                    return "val: boolean expected";
+            return null;
+        };
+
+        /**
+         * Creates a BoolVal message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof cryptor.BoolVal
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {cryptor.BoolVal} BoolVal
+         */
+        BoolVal.fromObject = function fromObject(object) {
+            if (object instanceof $root.cryptor.BoolVal)
+                return object;
+            var message = new $root.cryptor.BoolVal();
+            if (object.val != null)
+                message.val = Boolean(object.val);
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a BoolVal message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof cryptor.BoolVal
+         * @static
+         * @param {cryptor.BoolVal} message BoolVal
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        BoolVal.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.defaults)
+                object.val = false;
+            if (message.val != null && message.hasOwnProperty("val"))
+                object.val = message.val;
+            return object;
+        };
+
+        /**
+         * Converts this BoolVal to JSON.
+         * @function toJSON
+         * @memberof cryptor.BoolVal
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        BoolVal.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        return BoolVal;
+    })();
+
+    cryptor.Keypair = (function() {
+
+        /**
+         * Properties of a Keypair.
+         * @memberof cryptor
+         * @interface IKeypair
+         * @property {Uint8Array|null} [skey] Keypair skey
+         * @property {Uint8Array|null} [pkey] Keypair pkey
+         */
+
+        /**
+         * Constructs a new Keypair.
+         * @memberof cryptor
+         * @classdesc Represents a Keypair.
+         * @implements IKeypair
+         * @constructor
+         * @param {cryptor.IKeypair=} [properties] Properties to set
+         */
+        function Keypair(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null)
+                        this[keys[i]] = properties[keys[i]];
+        }
+
+        /**
+         * Keypair skey.
+         * @member {Uint8Array} skey
+         * @memberof cryptor.Keypair
+         * @instance
+         */
+        Keypair.prototype.skey = $util.newBuffer([]);
+
+        /**
+         * Keypair pkey.
+         * @member {Uint8Array} pkey
+         * @memberof cryptor.Keypair
+         * @instance
+         */
+        Keypair.prototype.pkey = $util.newBuffer([]);
+
+        /**
+         * Creates a new Keypair instance using the specified properties.
+         * @function create
+         * @memberof cryptor.Keypair
+         * @static
+         * @param {cryptor.IKeypair=} [properties] Properties to set
+         * @returns {cryptor.Keypair} Keypair instance
+         */
+        Keypair.create = function create(properties) {
+            return new Keypair(properties);
+        };
+
+        /**
+         * Encodes the specified Keypair message. Does not implicitly {@link cryptor.Keypair.verify|verify} messages.
+         * @function encode
+         * @memberof cryptor.Keypair
+         * @static
+         * @param {cryptor.IKeypair} message Keypair message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Keypair.encode = function encode(message, writer) {
+            if (!writer)
+                writer = $Writer.create();
+            if (message.skey != null && Object.hasOwnProperty.call(message, "skey"))
+                writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.skey);
+            if (message.pkey != null && Object.hasOwnProperty.call(message, "pkey"))
+                writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.pkey);
+            return writer;
+        };
+
+        /**
+         * Encodes the specified Keypair message, length delimited. Does not implicitly {@link cryptor.Keypair.verify|verify} messages.
+         * @function encodeDelimited
+         * @memberof cryptor.Keypair
+         * @static
+         * @param {cryptor.IKeypair} message Keypair message or plain object to encode
+         * @param {$protobuf.Writer} [writer] Writer to encode to
+         * @returns {$protobuf.Writer} Writer
+         */
+        Keypair.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+
+        /**
+         * Decodes a Keypair message from the specified reader or buffer.
+         * @function decode
+         * @memberof cryptor.Keypair
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @param {number} [length] Message length if known beforehand
+         * @returns {cryptor.Keypair} Keypair
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Keypair.decode = function decode(reader, length) {
+            if (!(reader instanceof $Reader))
+                reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.cryptor.Keypair();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                switch (tag >>> 3) {
+                case 1:
+                    message.skey = reader.bytes();
+                    break;
+                case 2:
+                    message.pkey = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+                }
+            }
+            return message;
+        };
+
+        /**
+         * Decodes a Keypair message from the specified reader or buffer, length delimited.
+         * @function decodeDelimited
+         * @memberof cryptor.Keypair
+         * @static
+         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+         * @returns {cryptor.Keypair} Keypair
+         * @throws {Error} If the payload is not a reader or valid buffer
+         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+         */
+        Keypair.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader))
+                reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+
+        /**
+         * Verifies a Keypair message.
+         * @function verify
+         * @memberof cryptor.Keypair
+         * @static
+         * @param {Object.<string,*>} message Plain object to verify
+         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+         */
+        Keypair.verify = function verify(message) {
+            if (typeof message !== "object" || message === null)
+                return "object expected";
+            if (message.skey != null && message.hasOwnProperty("skey"))
+                if (!(message.skey && typeof message.skey.length === "number" || $util.isString(message.skey)))
+                    return "skey: buffer expected";
+            if (message.pkey != null && message.hasOwnProperty("pkey"))
+                if (!(message.pkey && typeof message.pkey.length === "number" || $util.isString(message.pkey)))
+                    return "pkey: buffer expected";
+            return null;
+        };
+
+        /**
+         * Creates a Keypair message from a plain object. Also converts values to their respective internal types.
+         * @function fromObject
+         * @memberof cryptor.Keypair
+         * @static
+         * @param {Object.<string,*>} object Plain object
+         * @returns {cryptor.Keypair} Keypair
+         */
+        Keypair.fromObject = function fromObject(object) {
+            if (object instanceof $root.cryptor.Keypair)
+                return object;
+            var message = new $root.cryptor.Keypair();
+            if (object.skey != null)
+                if (typeof object.skey === "string")
+                    $util.base64.decode(object.skey, message.skey = $util.newBuffer($util.base64.length(object.skey)), 0);
+                else if (object.skey.length)
+                    message.skey = object.skey;
+            if (object.pkey != null)
+                if (typeof object.pkey === "string")
+                    $util.base64.decode(object.pkey, message.pkey = $util.newBuffer($util.base64.length(object.pkey)), 0);
+                else if (object.pkey.length)
+                    message.pkey = object.pkey;
+            return message;
+        };
+
+        /**
+         * Creates a plain object from a Keypair message. Also converts values to other types if specified.
+         * @function toObject
+         * @memberof cryptor.Keypair
+         * @static
+         * @param {cryptor.Keypair} message Keypair
+         * @param {$protobuf.IConversionOptions} [options] Conversion options
+         * @returns {Object.<string,*>} Plain object
+         */
+        Keypair.toObject = function toObject(message, options) {
+            if (!options)
+                options = {};
+            var object = {};
+            if (options.defaults) {
+                if (options.bytes === String)
+                    object.skey = "";
+                else {
+                    object.skey = [];
+                    if (options.bytes !== Array)
+                        object.skey = $util.newBuffer(object.skey);
+                }
+                if (options.bytes === String)
+                    object.pkey = "";
+                else {
+                    object.pkey = [];
+                    if (options.bytes !== Array)
+                        object.pkey = $util.newBuffer(object.pkey);
+                }
+            }
+            if (message.skey != null && message.hasOwnProperty("skey"))
+                object.skey = options.bytes === String ? $util.base64.encode(message.skey, 0, message.skey.length) : options.bytes === Array ? Array.prototype.slice.call(message.skey) : message.skey;
+            if (message.pkey != null && message.hasOwnProperty("pkey"))
+                object.pkey = options.bytes === String ? $util.base64.encode(message.pkey, 0, message.pkey.length) : options.bytes === Array ? Array.prototype.slice.call(message.pkey) : message.pkey;
+            return object;
+        };
+
+        /**
+         * Converts this Keypair to JSON.
+         * @function toJSON
+         * @memberof cryptor.Keypair
+         * @instance
+         * @returns {Object.<string,*>} JSON object
+         */
+        Keypair.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+
+        return Keypair;
+    })();
+
+    return cryptor;
+})();
+
+module.exports = $root;