core-3nweb-client-lib 0.19.5 → 0.20.3

package/build/lib-client/cryptor/cryptor.d.ts

@@ -1,5 +1,5 @@
 import { signing } from 'ecma-nacl';
-import { LogWarning } from '../logging/log-to-file';
+import { LogError, LogWarning } from '../logging/log-to-file';
 import { AsyncSBoxCryptor } from 'xsp-files';
 export interface Cryptor {
     scrypt(passwd: Uint8Array, salt: Uint8Array, logN: number, r: number, p: number, dkLen: number, progressCB: (p: number) => void): Promise<Uint8Array>;
@@ -14,12 +14,14 @@ export interface Cryptor {
         generate_keypair(seed: Uint8Array): Promise<signing.Keypair>;
     };
 }
-export declare type makeCryptor = (logWarning: LogWarning, maxThreads?: number) => {
+export declare type makeCryptor = (logErr: LogError, logWarning: LogWarning, maxThreads?: number) => {
     cryptor: Cryptor;
     close: () => Promise<void>;
 };
-export declare function makeInWorkerCryptor(logWarning: LogWarning, maxThreads?: number): ReturnType<makeCryptor>;
+export declare const makeInWorkerCryptor: makeCryptor;
+export declare const makeInWorkerWasmCryptor: makeCryptor;
 export declare function makeInProcessCryptor(): ReturnType<makeCryptor>;
+export declare function makeInProcessWasmCryptor(): ReturnType<makeCryptor>;
 declare type RuntimeException = web3n.RuntimeException;
 export interface CryptorException extends RuntimeException {
     type: 'cryptor';

package/build/lib-client/cryptor/cryptor.js

@@ -16,15 +16,27 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeInProcessCryptor = exports.makeInWorkerCryptor = void 0;
-function makeInWorkerCryptor(logWarning, maxThreads) {
-    const { makeInWorkerCryptor } = require('./cryptor-in-worker');
-    return makeInWorkerCryptor(logWarning, maxThreads);
-}
-exports.makeInWorkerCryptor = makeInWorkerCryptor;
+exports.makeInProcessWasmCryptor = exports.makeInProcessCryptor = exports.makeInWorkerWasmCryptor = exports.makeInWorkerCryptor = void 0;
+exports.makeInWorkerCryptor = (logErr, logWarning, maxThreads) => {
+    const mod = require('./cryptor-in-worker');
+    const makeInWorkerCryptor = mod.makeInWorkerCryptor;
+    return makeInWorkerCryptor(logErr, logWarning, maxThreads);
+};
+exports.makeInWorkerWasmCryptor = (logErr, logWarning, maxThreads) => {
+    const mod = require('./cryptor-in-worker');
+    const makeInWorkerWasmCryptor = mod.makeInWorkerWasmCryptor;
+    return makeInWorkerWasmCryptor(logErr, logWarning, maxThreads);
+};
 function makeInProcessCryptor() {
-    const { makeInProcessCryptor } = require('./cryptor-in-proc');
+    const mod = require('./in-proc-js');
+    const makeInProcessCryptor = mod.makeInProcessCryptor;
     return { cryptor: makeInProcessCryptor(), close: async () => { } };
 }
 exports.makeInProcessCryptor = makeInProcessCryptor;
+function makeInProcessWasmCryptor() {
+    const mod = require('./in-proc-wasm');
+    const makeInProcessWasmCryptor = mod.makeInProcessWasmCryptor;
+    return { cryptor: makeInProcessWasmCryptor(), close: async () => { } };
+}
+exports.makeInProcessWasmCryptor = makeInProcessWasmCryptor;
 Object.freeze(exports);

package/build/lib-client/cryptor/in-proc-wasm.d.ts

@@ -0,0 +1,2 @@
+import { Cryptor } from './cryptor';
+export declare function makeInProcessWasmCryptor(): Cryptor;

package/build/lib-client/cryptor/in-proc-wasm.js

@@ -0,0 +1,187 @@
+"use strict";
+/*
+ Copyright (C) 2021 3NSoft Inc.
+
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeInProcessWasmCryptor = void 0;
+const wasm_mp1_modules_1 = require("./wasm-mp1-modules");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const protobuf_loader_1 = require("../protobuf-loader");
+const processes_1 = require("../../lib-common/processes");
+const assert_1 = require("../../lib-common/assert");
+const error_1 = require("../../lib-common/exceptions/error");
+function wasmBytes() {
+    // There is a bug with electrons 12, 13, that doesn't let
+    // worker_thread read this file from asar pack, even though main thread
+    // makes call from here.
+    // Therefore, in case this runs from asar pack, we should switch to
+    // unpacked in path that is given to worker thread.
+    // Of course, asarUnpack should be used in electron-builder.
+    const asarInd = __dirname.indexOf('app.asar');
+    const dirWithThis = ((asarInd < 0) ?
+        __dirname : `${__dirname.substring(0, asarInd + 8)}.unpacked${__dirname.substring(asarInd + 8)}`);
+    const wasmPath = path_1.join(dirWithThis, 'cryptor.wasm');
+    try {
+        return fs_1.readFileSync(wasmPath);
+    }
+    catch (err) {
+        // chances are that error is due to wasm file not being packaged, so, we
+        // look for module with base64 form in a module, that must've been packed
+        const str = require('./cryptor-wasm.js').wasm;
+        return Buffer.from(str, 'base64');
+    }
+}
+function makeProtobufType(type) {
+    const protoFile = 'cryptor.proto';
+    const typeName = `cryptor.${type}`;
+    try {
+        // make sure to copy protos with compile step (use npm script)
+        return protobuf_loader_1.ProtoType.makeFrom(__dirname, protoFile, typeName);
+    }
+    catch (err) {
+        // we won't get here if referenced  module exists, but metro packager
+        // in LiqudCore needs static path require
+        const fallback = require('./proto-defs');
+        return protobuf_loader_1.ProtoType.makeFrom(__dirname, protoFile, typeName, fallback);
+    }
+}
+function toArgs(...args) {
+    return args.map(val => ({ val }));
+}
+function toLocalErr(replyErr) {
+    if (replyErr.condition === 'cipher-verification') {
+        return { failedCipherVerification: true };
+    }
+    else if (replyErr.condition === 'signature-verification') {
+        return { failedSignatureVerification: true };
+    }
+    else {
+        return new Error(`WASM cryptor ${replyErr.condition}: ${replyErr.message}`);
+    }
+}
+const reqType = makeProtobufType('Request');
+const replyType = makeProtobufType('Reply');
+const boolValType = makeProtobufType('BoolVal');
+const kpairType = makeProtobufType('Keypair');
+function makeInProcessWasmCryptor() {
+    const wasmInstance = wasm_mp1_modules_1.startWasmFrom(wasmBytes());
+    let deferred = undefined;
+    let interimSink = undefined;
+    async function call(req, interim) {
+        // In LiquidCore on iOS call was able to get before completion of
+        // previous call, therefore, the following await loop is needed.
+        while (!!deferred) {
+            try {
+                await deferred.promise;
+            }
+            catch (err) { }
+        }
+        deferred = processes_1.defer();
+        if (interim) {
+            interimSink = interim;
+        }
+        process.nextTick(() => {
+            try {
+                wasmInstance.sendMsgIntoWASM(reqType.pack(req));
+            }
+            catch (err) {
+                deferred === null || deferred === void 0 ? void 0 : deferred.reject(err);
+            }
+        });
+        return deferred.promise;
+    }
+    wasmInstance.setMsgListener(msg => {
+        assert_1.assert(!!deferred, `Deferred is expected to be available for this output from wasm`);
+        try {
+            const reply = replyType.unpack(msg);
+            if (reply.res) {
+                deferred.resolve(reply.res.val);
+                deferred = undefined;
+                interimSink = undefined;
+            }
+            else if (reply.err) {
+                deferred.reject(error_1.errWithCause(toLocalErr(reply.err), `Error in cryptor`));
+                deferred = undefined;
+                interimSink = undefined;
+            }
+            else if (reply.interim) {
+                interimSink(reply.interim.val);
+            }
+        }
+        catch (err) {
+            deferred.reject(err);
+        }
+    });
+    return {
+        scrypt: (passwd, salt, logN, r, p, dkLen, progressCB) => call({
+            func: 1,
+            scryptArgs: { passwd, salt, logN, r, p, dkLen }
+        }, bytes => progressCB(bytes[0])),
+        box: {
+            calc_dhshared_key: (pk, sk) => call({
+                func: 2,
+                byteArgs: toArgs(pk, sk)
+            }),
+            generate_pubkey: (sk) => call({
+                func: 3,
+                byteArgs: toArgs(sk)
+            })
+        },
+        sbox: {
+            open: (c, n, k) => call({
+                func: 4,
+                byteArgs: toArgs(c, n, k)
+            }),
+            pack: (m, n, k) => call({
+                func: 5,
+                byteArgs: toArgs(m, n, k)
+            }),
+            formatWN: {
+                open: (cn, k) => call({
+                    func: 6,
+                    byteArgs: toArgs(cn, k)
+                }),
+                pack: (m, n, k) => call({
+                    func: 7,
+                    byteArgs: toArgs(m, n, k)
+                })
+            }
+        },
+        signing: {
+            generate_keypair: async (seed) => {
+                const rep = await call({
+                    func: 8,
+                    byteArgs: toArgs(seed)
+                });
+                return kpairType.unpack(rep);
+            },
+            signature: (m, sk) => call({
+                func: 9,
+                byteArgs: toArgs(m, sk)
+            }),
+            verify: async (sig, m, pk) => {
+                const rep = await call({
+                    func: 10,
+                    byteArgs: toArgs(sig, m, pk)
+                });
+                return boolValType.unpack(rep).val;
+            }
+        }
+    };
+}
+exports.makeInProcessWasmCryptor = makeInProcessWasmCryptor;
+Object.freeze(exports);

package/build/lib-client/cryptor/proto-defs.js

@@ -0,0 +1,50 @@
+exports.protos = {};
+exports.protos['cryptor.proto'] = `
+syntax = "proto3";
+
+package cryptor;
+
+message Request {
+
+	message ScryptArgs {
+		bytes passwd = 1;
+		bytes salt = 2;
+		uint32 logN = 3;
+		uint32 r = 4;
+		uint32 p = 5;
+		uint32 dkLen = 6;
+	}
+	
+	uint32 func = 1;
+	repeated BytesVal byte_args = 2;
+	ScryptArgs scrypt_args = 3;
+
+}
+
+message BytesVal {
+	bytes val = 1;
+}
+
+message Reply {
+
+	message Error {
+		string condition = 1;
+		string message = 2;
+	}
+
+	BytesVal res = 1;
+	BytesVal interim = 2;
+	Error err = 3;
+}
+
+message BoolVal {
+	bool val = 1;
+}
+
+message Keypair {
+	bytes skey = 1;
+	bytes pkey = 2;
+}
+`;
+Object.freeze(exports.protos);
+Object.freeze(exports);

package/build/lib-client/cryptor/protos/cryptor.proto

@@ -0,0 +1,45 @@
+syntax = "proto3";
+
+package cryptor;
+
+message Request {
+
+	message ScryptArgs {
+		bytes passwd = 1;
+		bytes salt = 2;
+		uint32 logN = 3;
+		uint32 r = 4;
+		uint32 p = 5;
+		uint32 dkLen = 6;
+	}
+	
+	uint32 func = 1;
+	repeated BytesVal byte_args = 2;
+	ScryptArgs scrypt_args = 3;
+
+}
+
+message BytesVal {
+	bytes val = 1;
+}
+
+message Reply {
+
+	message Error {
+		string condition = 1;
+		string message = 2;
+	}
+
+	BytesVal res = 1;
+	BytesVal interim = 2;
+	Error err = 3;
+}
+
+message BoolVal {
+	bool val = 1;
+}
+
+message Keypair {
+	bytes skey = 1;
+	bytes pkey = 2;
+}

package/build/lib-client/cryptor/wasm-mp1-modules.d.ts

@@ -0,0 +1,5 @@
+export interface WasmInstance {
+    setMsgListener: (listener: (msg: Uint8Array) => void) => void;
+    sendMsgIntoWASM: (msg: Uint8Array) => void;
+}
+export declare function startWasmFrom(wasmModuleBytes: Uint8Array): WasmInstance;

package/build/lib-client/cryptor/wasm-mp1-modules.js

@@ -0,0 +1,79 @@
+"use strict";
+/*
+ Copyright (C) 2021 3NSoft Inc.
+
+ This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWasmFrom = void 0;
+class MP1 {
+    constructor(wasmBytes) {
+        this.sinkMsgFromWasmInstance = undefined;
+        this.msgWaitingWriteCB = undefined;
+        const module = new WebAssembly.Module(wasmBytes);
+        this.instance = new WebAssembly.Instance(module, this.makeImports());
+        this.mp1_accept_msg = this.getExportedFn('_3nweb_mp1_accept_msg');
+        Object.seal(this);
+    }
+    getExportedFn(fName) {
+        const fn = this.instance.exports[fName];
+        if (typeof fn !== 'function') {
+            throw Error(`WASM instance doesn't export function ${fName}`);
+        }
+        return fn;
+    }
+    makeImports() {
+        const env = {
+            _3nweb_mp1_send_out_msg: (ptr, len) => this.processMsgFromModule(ptr, len),
+            _3nweb_mp1_write_msg_into: (ptr) => this.writeMsgInCB(ptr),
+        };
+        return { env };
+    }
+    processMsgFromModule(ptr, len) {
+        if (!this.sinkMsgFromWasmInstance) {
+            return;
+        }
+        const msgBuf = this.getWasmMemoryArea(ptr, len);
+        const msg = new Uint8Array(msgBuf.length);
+        msg.set(msgBuf);
+        this.sinkMsgFromWasmInstance(msg);
+    }
+    writeMsgInCB(ptr) {
+        const buf = this.getWasmMemoryArea(ptr, this.msgWaitingWriteCB.length);
+        buf.set(this.msgWaitingWriteCB);
+        this.msgWaitingWriteCB = undefined;
+    }
+    getWasmMemoryArea(ptr, len) {
+        const memBuf = this.instance.exports.memory.buffer;
+        return new Uint8Array(memBuf, ptr, len);
+    }
+    start() {
+        this.getExportedFn('_start')();
+    }
+    sendMsg(msg) {
+        this.msgWaitingWriteCB = msg;
+        // Note that following call to WASM expects it to call back imported
+        // function that actually copies bytes from this.msgWaitingWriteCB into
+        // then given memory area.
+        this.mp1_accept_msg(msg.length);
+    }
+    setMsgListener(listener) {
+        this.sinkMsgFromWasmInstance = listener;
+    }
+}
+Object.freeze(MP1.prototype);
+Object.freeze(MP1);
+function startWasmFrom(wasmModuleBytes) {
+    let mp1 = new MP1(wasmModuleBytes);
+    mp1.start();
+    return {
+        sendMsgIntoWASM: msg => mp1.sendMsg(msg),
+        setMsgListener: listener => mp1.setMsgListener(listener)
+    };
+}
+exports.startWasmFrom = startWasmFrom;
+Object.freeze(exports);

package/build/lib-client/cryptor/worker-js.d.ts

@@ -0,0 +1 @@
+export {};

package/build/lib-client/cryptor/worker-js.js

@@ -0,0 +1,139 @@
+"use strict";
+/*
+ Copyright (C) 2020 3NSoft Inc.
+
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = require("worker_threads");
+const ecma_nacl_1 = require("ecma-nacl");
+const error_1 = require("../../lib-common/exceptions/error");
+function transfer(...arrs) {
+    const transferLst = [];
+    for (const arr of arrs) {
+        const buffer = arr.buffer;
+        if (!transferLst.includes(buffer)) {
+            transferLst.push(buffer);
+        }
+    }
+    return transferLst;
+}
+if (!worker_threads_1.parentPort) {
+    throw new Error(`Missing expected parentPort. Is this called within WebWorker process?`);
+}
+const arrFactory = ecma_nacl_1.arrays.makeFactory();
+const wipe = ecma_nacl_1.arrays.wipe;
+const funcs = {
+    'scrypt': args => {
+        const progressCB = (n) => {
+            const reply = { interim: n };
+            worker_threads_1.parentPort.postMessage(reply);
+        };
+        const res = ecma_nacl_1.scrypt(args[0], args[1], args[2], args[3], args[4], args[5], progressCB, arrFactory);
+        wipe(args[0]);
+        return { res };
+        // electron v.11.0.3 worker thread fails on memory move
+        // return { res, trans: transfer(res) };
+    },
+    'box.calc_dhshared_key': args => {
+        const res = ecma_nacl_1.box.calc_dhshared_key(args[0], args[1], arrFactory);
+        wipe(args[0], args[1]);
+        return { res };
+        // electron v.11.0.3 worker thread fails on memory move
+        // return { res, trans: transfer(res) };
+    },
+    'box.generate_pubkey': args => {
+        const res = ecma_nacl_1.box.generate_pubkey(args[0], arrFactory);
+        wipe(args[0]);
+        return { res };
+        // electron v.11.0.3 worker thread fails on memory move
+        // return { res, trans: transfer(res) };
+    },
+    'sbox.open': args => {
+        const res = ecma_nacl_1.secret_box.open(args[0], args[1], args[2], arrFactory);
+        wipe(args[2]);
+        return { res };
+        // electron v.11.0.3 worker thread fails on memory move
+        // return { res, trans: transfer(res) };
+    },
+    'sbox.pack': args => {
+        const res = ecma_nacl_1.secret_box.pack(args[0], args[1], args[2], arrFactory);
+        wipe(args[2]);
+        return { res };
+        // electron v.11.0.3 worker thread fails on memory move
+        // return { res, trans: transfer(res) };
+    },
+    'sbox.formatWN.open': args => {
+        const res = ecma_nacl_1.secret_box.formatWN.open(args[0], args[1], arrFactory);
+        wipe(args[1]);
+        return { res };
+        // electron v.11.0.3 worker thread fails on memory move
+        // return { res, trans: transfer(res) };
+    },
+    'sbox.formatWN.pack': args => {
+        const res = ecma_nacl_1.secret_box.formatWN.pack(args[0], args[1], args[2], arrFactory);
+        wipe(args[2]);
+        return { res };
+        // electron v.11.0.3 worker thread fails on memory move
+        // return { res, trans: transfer(res) };
+    },
+    'sign.generate_keypair': args => {
+        const pair = ecma_nacl_1.signing.generate_keypair(args[0], arrFactory);
+        wipe(args[0]);
+        return { res: pair };
+        // electron v.11.0.3 worker thread fails on memory move
+        // return { res: pair, trans: transfer(pair.pkey, pair.skey) };
+    },
+    'sign.signature': args => {
+        const res = ecma_nacl_1.signing.signature(args[0], args[1], arrFactory);
+        wipe(args[1]);
+        return { res };
+        // electron v.11.0.3 worker thread fails on memory move
+        // return { res, trans: transfer(res) };
+    },
+    'sign.verify': args => {
+        const ok = ecma_nacl_1.signing.verify(args[0], args[1], args[2], arrFactory);
+        return { res: ok };
+    }
+};
+function wrapError(err) {
+    const exc = {
+        runtimeException: true,
+        type: 'cryptor'
+    };
+    if (err.failedCipherVerification) {
+        exc.failedCipherVerification = true;
+    }
+    else {
+        exc.message = `Error occured in cryptor worker thread`;
+        exc.cause = error_1.stringifyErr(err);
+    }
+    return exc;
+}
+worker_threads_1.parentPort.on('message', (msg) => {
+    const { args, func } = msg;
+    const code = funcs[func];
+    if (!code) {
+        throw new Error(`Function ${func} is unknown`);
+    }
+    try {
+        const { res, trans } = code(args);
+        const reply = { res };
+        worker_threads_1.parentPort.postMessage(reply, trans);
+    }
+    catch (err) {
+        const reply = { err: wrapError(err) };
+        worker_threads_1.parentPort.postMessage(reply);
+    }
+});

package/build/lib-client/cryptor/worker-wasm.d.ts

@@ -0,0 +1 @@
+export {};

package/build/lib-client/cryptor/worker-wasm.js

@@ -0,0 +1,37 @@
+"use strict";
+/*
+ Copyright (C) 2020 3NSoft Inc.
+
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+const worker_threads_1 = require("worker_threads");
+const path_1 = require("path");
+const wasm_mp1_modules_1 = require("./wasm-mp1-modules");
+const fs_1 = require("fs");
+if (!worker_threads_1.parentPort) {
+    throw new Error(`Missing expected parentPort. Is this called within WebWorker process?`);
+}
+const wasmFName = 'cryptor.wasm';
+const wasmModPath = path_1.join(worker_threads_1.workerData.loadDir, wasmFName);
+const wasmInstance = wasm_mp1_modules_1.startWasmFrom(fs_1.readFileSync(wasmModPath));
+wasmInstance.setMsgListener(msg => worker_threads_1.parentPort.postMessage(msg));
+worker_threads_1.parentPort.on('message', (msg) => {
+    try {
+        wasmInstance.sendMsgIntoWASM(msg);
+    }
+    catch (err) {
+        console.error(err);
+    }
+});

package/build/lib-client/key-derivation.js

@@ -45,7 +45,7 @@ async function deriveMidKeyPair(cryptor, pass, derivParams, progressCB, use = ''
     const passBytes = buffer_utils_1.utf8.pack(pass);
     const saltBytes = buffer_utils_1.base64.open(derivParams.salt);
     const skey = await cryptor.scrypt(passBytes, saltBytes, derivParams.logN, derivParams.r, derivParams.p, ecma_nacl_1.box.KEY_LENGTH, progressCB);
-    const pkey = ecma_nacl_1.box.generate_pubkey(skey);
+    const pkey = await cryptor.box.generate_pubkey(skey);
     const pkeyJSON = jwkeys_1.keyToJson({
         k: pkey,
         alg: ecma_nacl_1.box.JWK_ALG_NAME,

package/build/lib-client/protobuf-loader.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+export declare class ProtoType<T extends object> {
+    private type;
+    private constructor();
+    static makeFrom<T extends object>(searchDir: string, protoFile: string, typeName: string, fallbackMod?: {
+        protos: object;
+    }): ProtoType<T>;
+    pack(msg: T): Buffer;
+    unpack(bytes: Buffer | void): T;
+    packToBase64(msg: T): string;
+    unpackFromBase64(str: string): T;
+}