gamerpc 8.0.8 → 9.0.1

package/src/index.js

@@ -1,679 +1,140 @@
-//const {encrypt, decrypt, createHmac} = require('./utils/util');
-const {stringify, NotifyType, extendObj, CommStatus, clone, ReturnCodeName, ReturnCode, CommMode, io} = require('./utils/util');
-const EventEmitter = require('events').EventEmitter;
-const Indicator = require('./utils/Indicator');
-// const assert = require('./utils/assert')
-// let {sha1, hash160, hash256, verifyData, generateKey, signObj, verifyObj, verifyAddress} = require('./utils/verifyData');
-// const Secret = require('./utils/secret')
-
 /**
- * RPC控件
- * @note
- *      1、根据创建参数，可分别支持WS、Socket、Http三种常用通讯模式，支持Notify、JSONP、Watching等报文通讯模式
- *      2、支持LBS重定向功能
- *      3、内部封装了一定的断言功能
+ * gamerpc V9.0.0 - 游戏云/区块链统一工具包
+ * 
+ * 合并 V7.1.3 (auth3.0 分支) 和 V9.0.0 (V8.0.8 继承)。
+ * 
+ * 提供两大核心连接器：
+ *   1. gameConn - 游戏云服务器连接器 (连接 Gamecloud，发起RPC调用，订阅推送)
+ *   2. conn/authConn - 区块链全节点连接器 (连接 Gamegold Core 对等网络，钱包操作)
+ * 
+ * 同时提供区块链密码学工具函数和通用工具函数。
  */
-class Remote {
-    constructor(options) {
-        this.rpcMode = CommMode.post;
-        this.loginMode = Indicator.inst();
-        this.configOri = options;                   //读取并保存初始配置，不会修改
-        this.config = clone(this.configOri);        //复制一份配置信息，有可能修改
-        this.notifyHandles = {};
-        this.userInfo = {};
-        //事件管理器
-        this.events = new EventEmitter();
-        //状态管理器
-        this.status = Indicator.inst(options.status);
-
-        //两阶段登录时，用户输入验证码时提交此事件
-        this.events.on('authcode', async code => {
-            console.log('gameconn: commit authcode', code);
-            await this.setSign(code).login();
-        })
-    }
-
-    /**
-     * 修改通讯模式
-     * @param {*} $mode     通讯模式
-     * @param {*} cb        建立连接时的回调
-     */
-    setmode($mode) {
-        this.rpcMode = $mode;
-        return this;
-    }
-
-    /**
-     * 创建通讯连接组件
-     * @param {*} ip 
-     * @param {*} port 
-     */
-    async createSocket() {
-        let port = this.config.webserver.port;
-        let host = this.config.webserver.host;
-        let url = this.config.webserver.url;
-
-        this.close();
-
-        if(!url) {
-            this.socket = io(`${this.config.UrlHead}://${host}:${port}`, {'force new connection': true});
-        } else {
-            this.socket = io(`${this.config.UrlHead}://${url}`, {'force new connection': true});
-        }
-        this.socket.on('notify', ret => {//监听推送消息
-            if(this.notifyHandles[ret.type]) {
-                this.notifyHandles[ret.type](ret.info);
-            }
-            else if(!!this.notifyHandles['0']){
-                this.notifyHandles['0'](ret.info);
-            }
-        })
-        .on('disconnect', ()=>{//断线重连
-            console.log('gameconn: socket disconnected');
-            this.events.emit('comm', {status: 'disconnect'});
-            this.socket.needConnect = true;
-            setTimeout(()=>{
-                if(!!this.socket.needConnect) {
-                    this.socket.needConnect = false;
-                    this.socket.connect();
-                }
-            }, 1500);
-        }).on('connect', () => { //连接消息
-            console.log('gameconn: socket connected');
-            this.events.emit('comm', {status: 'connect'});
-        }).on('error', () => {
-            this.events.emit('comm', {status: 'error'});
-        });
-
-        let self = this;
-        let prom = new Promise(resolve => {
-            self.events.on('comm', async msg => {
-                if(msg.status == 'connect') {
-                    resolve();
-                }
-            })
-        });
-        return prom;
-    }
-
-    /**
-     * 获取签名数据集
-     */
-    async getSign() {
-        console.log('gameconn: getSign');
-        //此处根据实际需要，发起了基于HTTP请求的认证访问，和本身创建时指定的通讯模式无关。
-        let router = this.userInfo.openid.split('.')[0]; //openid一般由代表验证模式的前缀，加上代表节点类型的后缀组成, 获取签名接口的路由路径默认等于其前缀
-        let msg = await this.getRequest({}, router);
-
-        //客户端从模拟网关取得了签名集
-        if(!msg) {
-            return false;
-        }
-
-        this.userInfo.auth = msg;
-
-        console.log('gameconn: getSign', msg);
-
-        return true;
-    }
-
-    /**
-     * 设置验证码
-     * @param {*} code 
-     */
-    setSign(code) {
-        if(!!this.userInfo) {
-            if(this.loginMode.check(CommStatus.reqSign)) {
-                this.status.set(CommStatus.signCode);
-                this.userInfo.auth = this.userInfo.auth || {};
-                this.userInfo.auth.captcha = code;
-            }
-        }
-        return this;
-    }
-
-    /**
-     * 登录并获得令牌
-     */
-    async getToken() {
-        if(!this.userInfo 
-            || (this.loginMode.check(CommStatus.reqLb) && !this.status.check(CommStatus.lb)) 
-            || (this.loginMode.check(CommStatus.reqSign) && !this.status.check(CommStatus.signCode)
-            || this.status.check(CommStatus.logined))
-        ) {
-            //不满足登录的前置条件或已经登录
-            return false;
-        }
-
-        //将签证发送到服务端进行验证
-        console.log('gameconn: getToken');
-        let msg = await this.fetching({
-            'func': 'login.UserLogin',
-            "oemInfo": this.userInfo,
-        });
-
-        if(!!msg) {
-            console.log('gameconn: getToken', msg.code);
-            if(msg.code == ReturnCode.Success && !!msg.data) {
-                if(typeof msg.data == 'object') {
-                    extendObj(this.userInfo, msg.data);
-                }
-                this.status.set(CommStatus.logined);
-                this.events.emit('logined', {code:0, data:{currentAuthority: this.userInfo.currentAuthority}});
-    
-                return true;
-            } else {
-                this.events.emit('logined', {code: msg.code});
-            }
-        } else {
-            console.log('gameconn: getToken failed');
-            this.events.emit('logined', {code:-1});
-        }
-        return false;
-    }
-
-    /**
-     * 清空先前的缓存状态
-     */
-    clearCache() {
-        if(this.userInfo) {
-            this.userInfo.token = null; 
-        }
-    }
-
-    /**
-     * 执行负载均衡流程
-     * @param {*} ui 
-     */
-    async setLB(force) {
-        if(!this.userInfo) {
-            //尚未设置有效的用户数据，无法执行
-            return false;
-        }
-
-        if(!force && this.status.check(CommStatus.lb)) {
-            //已经执行过LB操作，且非强制执行模式
-            return true;
-        }
-
-        this.clearCache();
-        this.status.init();
-
-        console.log('gameconn: lb');
-        let msg = await this.locate(this.configOri.webserver.host, this.configOri.webserver.port, this.configOri.webserver.url).getRequest({"func": "lb.getServerInfo", "oemInfo":{"domain": this.userInfo.domain, "openid": this.userInfo.openid}});
-
-        if(!!msg && msg.code == ReturnCode.Success) {
-            console.log('gameconn: lb', msg.data);
-            this.status.set(CommStatus.lb);
-            this.locate(msg.data.ip, msg.data.port, msg.data.url);
-            return true;
-        }
-
-        console.log('gameconn: lb failed');
-        return false;
-    }
-
-    /**
-     * 登录流程
-     * @param {Object} options
-     * @param {Boolean} options.force 强制登录
-     */
-    async login(options) {
-        options = options || {};
-        if(options.force) {
-            this.clearCache();
-            this.status.init();
-        }
-
-        if(options.domain) {
-            let authmode = options.openid.split('.')[0];
-            switch(authmode) {
-                case 'bxs': { //新增一种验证模式
-                    this.setUserInfo({
-                        domain: options.domain,     //认证模式
-                        openid: options.openid,     //用户证书
-                        openkey: options.openkey,   //中间证书，经由Auth服务器转换成 openid 下发给客户端
-                        auth: options.auth,         //验证信息
-                    }, CommStatus.reqLb);
-
-                    break;
-                }
-
-                case 'authwx': {
-                    this.setUserInfo({
-                        domain: options.domain,     //认证模式
-                        openkey: options.openkey,   //中间证书，经由Auth服务器转换成 openid 下发给客户端
-                    }, CommStatus.reqLb | CommStatus.reqOpenId);
-
-                    break;
-                }
-
-                case 'auth2step': {
-                    this.setUserInfo({
-                        domain: options.domain,     //验证模式
-                        openid: options.openid,     //用户证书
-                        openkey: options.openkey,   //用户证书
-                        addrType: options.addrType, //验证方式
-                        address: options.address,   //验证地址
-                    }, CommStatus.reqLb | CommStatus.reqSign);
-
-                    break;
-                }
-
-                case 'authpwd': {
-                    this.setUserInfo({
-                        domain: options.domain,     //验证模式
-                        openid: options.openid,     //用户证书
-                        openkey: options.openkey,   //用户密码
-                    }, CommStatus.reqLb);
-
-                    break;
-                }
-
-                default: {
-                    this.setUserInfo({
-                        domain: options.domain || 'official',   //验证模式
-                        openid: options.openid,                 //登录名称
-                        openkey: options.openkey,               //登录密码
-                    });
-                    break;
-                }
-            }
-        }
-
-        if(this.status.check(CommStatus.logined)) {
-            return false;
-        }
 
-        if(!this.userInfo) {
-            return false;
-        }
-
-        //检测执行负载均衡
-        if(this.loginMode.check(CommStatus.reqLb)) {
-            if(!this.status.check(CommStatus.lb)) {
-                //如果需要负载均衡且尚未执行，执行如下语句
-                if(!(await this.setLB())) {
-                    //如果负载均衡失败，抛出异常，外围程序负责重新调用
-                    throw(new Error('lb error'));
-                } else {
-                    this.status.set(CommStatus.lb);
-                }
-            }
-        }
-
-        //检测执行两阶段验证
-        //两阶段验证模式(例如浏览器直接登录)：执行此操作，访问控制器方法 authmode.auth 获取签名对象，并赋值到 userInfo.auth 字段，服务端同时会将关联验证码通过邮件或短信下发
-        //第三方授权登录模式(例如微信或QQ登录)跳过此步
-        if(this.loginMode.check(CommStatus.reqSign)) {
-            if(!this.status.check(CommStatus.sign)) {
-                //如果需要两阶段验证且尚未执行，执行如下语句
-                if(!(await this.getSign())) {
-                    //如果负载均衡失败，抛出异常，外围程序负责重新调用
-                    throw(new Error('get sign error'));
-                } else {
-                    this.status.set(CommStatus.sign);
-                    return true;
-                }
-            } else {
-                return await this.getToken();
-            }
-        } else {
-            return await this.getToken();
-        }
-    }
-
-    /**
-     * 设置用户信息
-     * 1. 支持局部设定模式
-     * 2. 每次设置，状态类缓存会被清除，通讯状态被复原
-     * @param {Object} ui {openid}
-     * @param {Number} st 登录流程描述符
-     */
-    setUserInfo(ui, st) {
-        this.userInfo = this.userInfo || {};
-
-        this.clearCache();
-
-        //设置登录模式
-        if(!!st) {
-            this.loginMode.init(st);
-        }
-
-        //合并对象数据
-        extendObj(this.userInfo, ui);
-
-        return this;
-    }
-
-    /**
-     * 设置服务端推送报文的监控句柄，支持链式调用
-     * @param cb            回调
-     * @param etype
-     * @returns {Remote}
-     */
-    watch(cb, etype = '0') {
-        this.notifyHandles[etype] = cb;
-        return this;
-    }
-    /**
-     * 移除监控句柄
-     * @param {*} etype 
-     */
-    unWatch(etype) {
-        if(!!this.notifyHandles[etype]) {
-            delete this.notifyHandles[etype];
-        }
-        return this;
+// V7.1.3: 为数组添加工具方法
+Array.prototype.randObj = function() {
+    if (this.length == 0) {
+        return null;
+    } else if (this.length == 1) {
+        return this[0];
+    } else {
+        return this[(Math.random() * this.length) | 0];
     }
+};
 
-    /**
-     * 判断返回值是否成功
-     * @param msg       网络报文
-     * @param out       强制打印日志
-     * @returns {*}
-     */
-    isSuccess(msg, out=false) {
-        if(!msg) {
-            return false;
-        }
-
-        msg.msg = ReturnCodeName[msg.code];
-
-        if((msg.code != ReturnCode.Success) || out){
-            this.log(msg);
-        }
-
-        return msg.code == ReturnCode.Success;
-    }
-
-    /**
-     * 直接打印各种对象
-     * @param val
-     */
-    log(val){
-        if(!val){
-            console.log('undefined');
-            return;
-        }
-
-        if(!!val.code){
-            val.msg = ReturnCodeName[val.code];
-        }
-
-        switch(typeof val){
-            case 'number':
-            case 'string':
-            case 'boolean':
-                console.log(val);
-                break;
-            case 'function':
-                console.log(val());
-                break;
-            case 'undefined':
-                console.log('err: undefined');
-                break;
-            default:
-                console.log(JSON.stringify(val));
-                break;
-        }
-    }
-
-    get newone(){
-        return new Remote(this.configOri).setmode(this.rpcMode);
-    }
+const toolkit = exports;
 
-    /**
-     * 获取新的远程对象
-      * @returns {Remote}
-     */
-    get new(){
-        return new Remote(this.configOri).setmode(this.rpcMode);
-    }
+// ==================== 核心连接器 ====================
 
-    /**
-     * 等待指定时长
-     * @param {Number} time 等待时长(毫秒) 
-     */
-    async wait (time) {
-        await (async (time) => {return new Promise(resolve => {setTimeout(resolve, time);});})(time);
-    }
+/** 游戏云连接器 - 用于连接游戏云服务器 */
+toolkit.gameconn = require('./gameConn');
+toolkit.gameConn = toolkit.gameconn; // 别名
 
-    /**
-     * 为了提供node下的兼容性而添加的属性设定函数
-     * @param {*} fn 
-     */
-    setFetch(fn) {
-        this.fetch = fn;
-        return this;
-    }
+/** 区块链授权式连接器 - 用于连接 Gamegold Core 全节点 */
+const AuthConn = require('./authConn');
+toolkit.conn = AuthConn;
+toolkit.authConn = AuthConn; // 别名
 
-    /**
-     * 向服务端提交请求,默认JSONP模式
-     * @param params        命令参数，JSON对象
-     *      .command    命令名称，格式: obj.func, 可以缩写为 func，此时obj为默认值'index'，例如 index.setNewbie 等价于 setNewbie
-     *      .url        附加url地址
-     * @param callback      回调函数
-     * @returns {*}
-     */
-    async fetching(params) {
-        this.parseParams(params);
+// ==================== 区块链密码学工具 ====================
 
-        if(this.loginMode.check(CommStatus.reqLb) && !this.status.check(CommStatus.lb)) {
-            await this.setLB();
-        }
+const verifyData = require('./utils/verifyData');
+const Secret = require('./utils/secret');
+const sha256 = require('./utils/sha256');
 
-        switch(this.rpcMode) {
-            case CommMode.ws:
-                if(!this.socket) {
-                    await this.createSocket();
-                }
-                return new Promise((resolve, reject) => {
-                    this.socket.emit('req', params, msg => {
-                        resolve(msg);
-                    });
-                });
+// 签名与验证
+toolkit.generateKey = verifyData.generateKey;
+toolkit.signObj = verifyData.signObj;
+toolkit.verifyObj = verifyData.verifyObj;
+toolkit.verifyData = verifyData.verifyData;
+toolkit.verifyAddress = verifyData.verifyAddress;
 
-            case CommMode.get:
-                return this.getRequest(params);
+// 哈希函数
+toolkit.hash256 = verifyData.hash256;
+toolkit.hash160 = verifyData.hash160;
+toolkit.sha1 = verifyData.sha1;
+toolkit.sha256 = sha256.digest;
 
-            case CommMode.post:
-                return this.postRequest(params);
-        }
+// BIP151 加密流
+toolkit.Secret = Secret;
 
-        return Promise.reject();
-    }
+// ==================== AES 加解密 ====================
 
-    /**
-     * 设定远程服务器地址
-     * @param host
-     * @param port
-     * @returns {Remote}
-     */
-    locate(host, port, url) {
-        this.config.webserver.host = host;
-        this.config.webserver.port = port;
-        this.config.webserver.url = url;    
+const aes = require('./utils/aes');
 
-        return this;
-    }
+/**
+ * AES-CBC 字符串加密（兼容 V7.x API）
+ * 编码规则：每字节拆分为高4位和低4位，加97偏移映射到 a-p 字符
+ */
+toolkit.encrypt = function encrypt(key, iv, data) {
+    if (!Buffer.isBuffer(key)) key = Buffer.from(key, 'binary');
+    if (!Buffer.isBuffer(iv)) iv = Buffer.from(iv, 'binary');
+    if (!Buffer.isBuffer(data)) data = Buffer.from(data, 'binary');
 
-    /**
-     * 关闭长连接
-     */
-    close() {
-        if(this.socket){
-            this.socket.removeAllListeners();
-            this.socket.disconnect();
-            this.socket = null;
-        }
+    var crypted = aes.encipher(data, key, iv);
+    crypted = Buffer.from(crypted, 'binary');
 
-        return this;
+    let ret = Buffer.alloc(crypted.length * 2);
+    for (let i = 0; i < crypted.length; i++) {
+        ret[2 * i] = (crypted[i] >> 4) + 97;
+        ret[2 * i + 1] = (crypted[i] & 0x0F) + 97;
     }
+    return ret.toString('binary');
+};
 
-    /**
-     * 彻底清除连接器历史数据，包括通讯状态、运行数据缓存，只保留最原始的配置信息
-     */
-    init() {
-        this.close();
+/**
+ * AES-CBC 字符串解密（兼容 V7.x API）
+ */
+toolkit.decrypt = function decrypt(key, iv, data) {
+    if (!Buffer.isBuffer(key)) key = Buffer.from(key, 'binary');
+    if (!Buffer.isBuffer(iv)) iv = Buffer.from(iv, 'binary');
+    if (!Buffer.isBuffer(data)) data = Buffer.from(data, 'binary');
 
-        this.config = clone(this.configOri);        //复制一份配置信息，有可能修改
-        this.userInfo = {};
-        this.status.init();
-        this.loginMode.init();
-        
-        return this;
+    let ret = Buffer.alloc(data.length / 2);
+    for (let i = 0; i < ret.length; i++) {
+        ret[i] = ((data[i * 2] - 97) << 4) | (data[i * 2 + 1] - 97);
     }
 
-    /**
-     * 参数调整
-     * @param params
-     */
-    parseParams(params) {
-        params.func = !!params.func ? params.func : 'index.login';
-        //填充自动登录参数
-        let arr = params.func.split('.');
-        if(arr.length > 1) {
-            params.control = arr[0];
-            params.func = arr[1];
-        } else {
-            params.func = arr[0];
-        }
+    var decoded = aes.decipher(ret, key, iv);
+    return decoded.toString('binary');
+};
 
-        params.oemInfo = {
-            domain: this.userInfo.domain,
-            openid: this.userInfo.openid,
-        };
-
-        if(this.userInfo.openkey) {
-            params.oemInfo.openkey = this.userInfo.openkey;
-        }
-        if(this.userInfo.token) {
-            params.oemInfo.token = this.userInfo.token;
-        }
-        if(this.userInfo.addrType) {
-            params.oemInfo.addrType = this.userInfo.addrType;
-        }
-        if(this.userInfo.address) {
-            params.oemInfo.address = this.userInfo.address;
-        }
-        if(this.userInfo.auth) {
-            params.oemInfo.auth = this.userInfo.auth;
-        }
-    }
+// ==================== HMAC 工具 ====================
 
-    /**
-     * 以 GET 方式访问远程API
-     * @param {*} url       远程地址
-     */
-    async get(url) {
-        const newOptions = { json: true, method: 'GET', mode: 'cors', };
-        
-        newOptions.headers = {
-            Accept: 'application/json',
-            'Content-Type': 'application/json; charset=utf-8',
-        };
+const createHmac = require('create-hmac/browser');
 
-        if(this.fetch) {
-            let ret = await this.fetch(url, newOptions);
-            return await ret.json();
-        }
-        else {
-            let ret = await fetch(url, newOptions);
-            return await ret.json();
-        }
-    }
-
-    /**
-     * 以 POST 方式访问远程API
-     * @param {*} url       远程地址
-     * @param {*} options   body
-     */
-    async post(url, options) {
-        const newOptions = { json: true, method: 'POST', mode: 'cors', body: JSON.stringify(options) };
-        
-        newOptions.headers = {
-            Accept: 'application/json',
-            'Content-Type': 'application/json; charset=utf-8',
-        };
+/**
+ * 利用 HMAC-SHA256 计算访问令牌
+ */
+function signHMAC(token, random) {
+    var hmac = createHmac('sha256', random);
+    return hmac.update(token).digest('hex');
+}
 
-        try {
-            if(this.fetch) {
-                let ret = await this.fetch(url, newOptions);
-                return await ret.json();
-            }
-            else {
-                let ret = await fetch(url, newOptions);
-                return await ret.json();
-            }
-        }
-        catch(e) {
-            console.error(e);
-        }
-    }
-  
-    /**
-     * (内部函数)发起基于Http协议的RPC请求
-     * @param params
-     */
-    async getRequest(params, authControl) {
-        this.parseParams(params);
+toolkit.createHmac = createHmac;
+toolkit.signHMAC = signHMAC;
 
-        let url = null;
-        if(!this.config.webserver.url) {
-            let port = !!params.port ? params.port : this.config.webserver.port;
-            url = !!authControl ? `${this.config.UrlHead}://${this.config.webserver.host}:${port}/${authControl}` : `${this.config.UrlHead}://${this.config.webserver.host}:${port}/index.html`;
-        } else {
-            url = !!authControl ? `${this.config.UrlHead}://${this.config.webserver.url}/${authControl}` : `${this.config.UrlHead}://${this.config.webserver.url}/index.html`;
-        }
+// ==================== 通用工具 ====================
 
-        url += "?" + Object.keys(params).reduce((ret, next)=>{
-            if(ret != '') { 
-                ret += '&';
-            }
-            //增加了字段编译，避免特殊字符如汉字对URL拼接造成干扰
-            return ret + next + "=" + ((typeof params[next]) == "object" ? encodeURIComponent(JSON.stringify(params[next])) : encodeURIComponent(params[next]));
-        }, '');
+const util = require('./utils/util');
 
-        return this.get(url);
-    }
+toolkit.assert = require('./utils/assert');
+toolkit.stringify = util.stringify;
+toolkit.extendObj = util.extendObj;
+toolkit.clone = util.clone;
+toolkit.Base64 = util.Base64;
+toolkit.CommMode = util.CommMode;
+toolkit.CommStatus = util.CommStatus;
+toolkit.ReturnCode = util.ReturnCode;
+toolkit.ReturnCodeName = util.ReturnCodeName;
+toolkit.NotifyType = util.NotifyType;
+toolkit.sprintf = util.sprintf;
+toolkit.isHex = util.isHex;
 
-    /**
-     * (内部函数)发起基于Http协议的RPC请求
-     * @param params
-     */
-    async postRequest(params, authControl) {
-        this.parseParams(params);
+// ==================== 全局对象挂载 ====================
 
-        let url = null;
-        if(!this.config.webserver.url) {
-            let port = !!params.port ? params.port : this.config.webserver.port;
-            url = !!authControl ? `${this.config.UrlHead}://${this.config.webserver.host}:${port}/${authControl}` : `${this.config.UrlHead}://${this.config.webserver.host}:${port}/index.html`;
-        } else {
-            url = !!authControl ? `${this.config.UrlHead}://${this.config.webserver.url}/${authControl}` : `${this.config.UrlHead}://${this.config.webserver.url}/index.html`;
-        }
+// V7.1.3: Node.js 环境的 global.toolkit
+global.toolkit = toolkit;
 
-        return this.post(url, params);
-    }
+// V9.0.0: 浏览器 <script> 标签引入时的 window.toolkit
+if (typeof window !== 'undefined') {
+    window.toolkit = toolkit;
 }
-
-Remote.prototype.CommMode = CommMode;
-// Remote.prototype.createHmac = createHmac;
-// Remote.prototype.assert = assert;
-Remote.prototype.stringify = stringify;
-// Remote.prototype.encrypt = encrypt;
-// Remote.prototype.decrypt = decrypt;
-// Remote.prototype.verifyData = verifyData;
-// Remote.prototype.generateKey = generateKey;
-// Remote.prototype.signObj = signObj;
-// Remote.prototype.verifyObj = verifyObj;
-// Remote.prototype.verifyAddress = verifyAddress;
-Remote.prototype.CommStatus = CommStatus;
-Remote.prototype.ReturnCode = ReturnCode;
-Remote.prototype.NotifyType = NotifyType;
-// Remote.prototype.Secret = Secret;
-// Remote.prototype.hash256 = hash256;
-// Remote.prototype.hash160 = hash160;
-// Remote.prototype.sha1 = sha1;
-
-module.exports = Remote;