@blocklet/sdk 1.15.17 → 1.16.0-beta-b16cb035

package/lib/security/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = exports.encrypt = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const aes_legacy_1 = __importDefault(require("@ocap/mcrypto/lib/crypter/aes-legacy"));
+const AES = { default: aes_legacy_1.default }.default;
+const encrypt = (message) => {
+    if (!process.env.BLOCKLET_DID || !process.env.BLOCKLET_APP_EK) {
+        return message;
+    }
+    return (AES.encrypt(message, crypto_1.default.pbkdf2Sync(process.env.BLOCKLET_APP_EK, process.env.BLOCKLET_DID, 256, 32, 'sha512').toString('hex')));
+};
+exports.encrypt = encrypt;
+const decrypt = (message) => {
+    if (!process.env.BLOCKLET_DID || !process.env.BLOCKLET_APP_EK) {
+        return message;
+    }
+    return (AES.decrypt(message, crypto_1.default.pbkdf2Sync(process.env.BLOCKLET_APP_EK, process.env.BLOCKLET_DID, 256, 32, 'sha512').toString('hex')));
+};
+exports.decrypt = decrypt;
+exports.default = {
+    encrypt,
+    decrypt,
+};

package/lib/service/auth.d.ts

@@ -0,0 +1,31 @@
+import Client from '@abtnode/client';
+type PartialDeep<T> = {
+    [K in keyof T]?: T[K] extends object ? PartialDeep<T[K]> : T[K];
+};
+type OmitTeamDid<T> = PartialDeep<Omit<T, 'teamDid'>>;
+declare class AuthService {
+    constructor(httpEndpoint?: string);
+}
+interface AuthService {
+    getUser(did: string): Promise<Client.ResponseUser>;
+    getUsers(args?: OmitTeamDid<Client.RequestUsersInput>): Promise<Client.ResponseUsers>;
+    getOwner(): Promise<Client.ResponseUser>;
+    updateUserApproval(did: string, approved: boolean): Promise<Client.ResponseUser>;
+    issuePassportToUser(args: OmitTeamDid<Client.RequestIssuePassportToUserInput>): Promise<Client.ResponseUser>;
+    enableUserPassport(args: OmitTeamDid<Client.RequestRevokeUserPassportInput>): Promise<Client.ResponseUser>;
+    revokeUserPassport(args: OmitTeamDid<Client.RequestRevokeUserPassportInput>): Promise<Client.ResponseUser>;
+    getPermissionsByRole(role: string): Promise<Client.ResponsePermissions>;
+    getRoles(): Promise<Client.ResponseRoles>;
+    createRole(args: OmitTeamDid<Client.RequestCreateRoleInput>): Promise<Client.ResponseRole>;
+    updateRole(name: string, updates: Pick<Client.RoleInput, 'title' | 'description'>): Promise<Client.ResponseRole>;
+    deleteRole(name: string): Promise<Client.GeneralResponse>;
+    grantPermissionForRole(role: string, permission: string): Promise<Client.GeneralResponse>;
+    revokePermissionFromRole(role: string, permission: string): Promise<Client.GeneralResponse>;
+    updatePermissionsForRole(role: string, permissions: string): Promise<Client.ResponseRole>;
+    hasPermission(role: string, permission: string): Promise<Client.BooleanResponse>;
+    getPermissions(): Promise<Client.ResponsePermissions>;
+    createPermission(args: OmitTeamDid<Client.RequestCreatePermissionInput>): Promise<Client.ResponsePermission>;
+    updatePermission(args: OmitTeamDid<Client.PermissionInput>): Promise<Client.ResponsePermission>;
+    deletePermission(name: string): Promise<Client.GeneralResponse>;
+}
+export = AuthService;

package/lib/service/auth.js

@@ -1,142 +1,135 @@
-const pickBy = require('lodash/pickBy');
-const Client = require('@abtnode/client');
-const { types } = require('@ocap/mcrypto');
-const { WalletType } = require('@ocap/wallet');
-const { NODE_SERVICES } = require('@abtnode/constant');
-
-const checkBlockletEnv = require('../util/check-blocklet-env');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+/* eslint-disable max-classes-per-file */
+/* eslint-disable @typescript-eslint/indent */
+const pickBy_1 = __importDefault(require("lodash/pickBy"));
+const url_join_1 = __importDefault(require("url-join"));
+const client_1 = __importDefault(require("@abtnode/client"));
+const mcrypto_1 = require("@ocap/mcrypto");
+const wallet_1 = require("@ocap/wallet");
+const constant_1 = __importDefault(require("@abtnode/constant"));
+const check_blocklet_env_1 = __importDefault(require("../util/check-blocklet-env"));
+const version_1 = require("../version");
+const { NODE_SERVICES, WELLKNOWN_SERVICE_PATH_PREFIX, USER_AVATAR_URL_PREFIX, USER_AVATAR_PATH_PREFIX } = constant_1.default;
+const VERSION = version_1.version; // version of notification sdk
+const isNotNullOrUndefined = (x) => ![null, undefined].includes(x);
+const type = process.env.BLOCKLET_WALLET_TYPE !== 'eth'
+    ? (0, wallet_1.WalletType)({ role: mcrypto_1.types.RoleType.ROLE_APPLICATION, pk: mcrypto_1.types.KeyType.ED25519, hash: mcrypto_1.types.HashType.SHA3 })
+    : 'eth';
+const fixAvatar = (user) => {
+    const avatar = user?.avatar;
+    if (avatar && avatar.startsWith(USER_AVATAR_URL_PREFIX)) {
+        user.avatar = (0, url_join_1.default)(WELLKNOWN_SERVICE_PATH_PREFIX, USER_AVATAR_PATH_PREFIX, avatar.replace(USER_AVATAR_URL_PREFIX, ''));
+    }
+    return user;
+};
+class AuthClient extends client_1.default {
+    constructor(httpEndpoint) {
+        (0, check_blocklet_env_1.default)();
+        super(httpEndpoint || `http://127.0.0.1:${process.env.ABT_NODE_PORT}/api/gql`.trim(), `BlockletSDK/${VERSION}`);
+        this.setAuthAccessKey({
+            accessKeyId: process.env.BLOCKLET_APP_ID,
+            accessKeySecret: process.env.BLOCKLET_APP_SK,
+            type,
+        });
+    }
+    _getAuthHeaders() {
+        const headers = super._getAuthHeaders();
+        // BLOCKLET_DID is always same as BLOCKLET_APP_PID in structV2 application
+        headers['x-access-blocklet'] = process.env.BLOCKLET_DID;
+        // x-access-service is not used since 1.8.35
+        headers['x-access-service'] = NODE_SERVICES.AUTH_SERVICE;
+        return headers;
+    }
+}
 // Auth 相关的功能 API 都在这里
 // core/state/lib/api/team.js L42
-
 // 所有可配置调用的函数在这里，如果需要额外增加，则需要在这里新增对应的函数
 // core/gql/lib/config.js L25
-
-const isNotNullOrUndefined = (x) => ![null, undefined].includes(x);
-
-const type =
-  process.env.BLOCKLET_WALLET_TYPE !== 'eth'
-    ? WalletType({ role: types.RoleType.ROLE_APPLICATION, pk: types.KeyType.ED25519, hash: types.HashType.SHA3 })
-    : 'eth';
-
-class AuthService extends Client {
-  constructor(httpEndpoint, axios) {
-    checkBlockletEnv();
-
-    super(httpEndpoint || `http://127.0.0.1:${process.env.ABT_NODE_PORT}/api/gql`.trim(), axios);
-
-    this.setAuthAccessKey({
-      accessKeyId: process.env.BLOCKLET_APP_ID,
-      accessKeySecret: process.env.BLOCKLET_APP_SK,
-      type,
-    });
-
-    this._blockletDid = process.env.BLOCKLET_DID;
-
-    const apiList = [
-      // user
-      'getUsers',
-      'getUser',
-      // 'removeUser',
-      'updateUserRole', // deprecated
-      // 'updateUserApproval',
-
-      // invitation
-      // 'getInvitations',
-      // 'createInvitation',
-      // 'deleteInvitation',
-
-      // rbac
-      'getRoles',
-      'createRole',
-      'updateRole',
-      'deleteRole',
-      'grantPermissionForRole', // grant
-      'revokePermissionFromRole', // revoke
-      'updatePermissionsForRole', // grant many
-      'hasPermission',
-
-      // user passport
-      // 'getPassportIssuances',
-      // 'createPassportIssuance',
-      // 'deletePassportIssuance',
-      // 'revokeUserPassport',
-      // 'enableUserPassport',
-
-      // permission
-      'getPermissions',
-      'createPermission',
-      'updatePermission',
-      'deletePermission',
-      'getPermissionsByRole',
-
-      // disabled in current
-      // 'configTrustedPassports',
-    ];
-
-    const teamDid = this._blockletDid;
-
-    const apiFallback =
-      (fn) =>
-      (params = {}, ...args) =>
-        fn({ input: { ...params, teamDid }, ...args });
-
-    const apiConvertDid = (fn) => (did) => fn({ input: { user: { did }, teamDid } });
-
-    const apiFnMap = {
-      getUser: apiConvertDid,
-      removeUser: apiConvertDid,
-      updateUserRole: (fn) => (did, role) => fn({ input: { user: { did, role }, teamDid } }),
-      updateUserApproval: (fn) => (did, approved) => fn({ input: { user: { did, approved }, teamDid } }),
-      getPermissionsByRole: (fn) => (name) => fn({ input: { role: { name }, teamDid } }),
-      createRole:
-        (fn) =>
-        ({ name, title, description }) =>
-          fn({ input: { ...pickBy({ name, title, description }, isNotNullOrUndefined), teamDid } }),
-      updateRole:
-        (fn) =>
-        (name, { title, description }) =>
-          fn({ input: { role: pickBy({ name, title, description }, isNotNullOrUndefined), teamDid } }), // todo
-      deleteRole: (fn) => (name) => fn({ input: { name, teamDid } }),
-      grantPermissionForRole: (fn) => (roleName, permissionName) =>
-        fn({ input: { teamDid, roleName, grantName: permissionName } }),
-      revokePermissionFromRole: (fn) => (roleName, permissionName) =>
-        fn({ input: { teamDid, roleName, grantName: permissionName } }),
-      updatePermissionsForRole: (fn) => (roleName, permissionNames) =>
-        fn({ input: { teamDid, roleName, grantNames: permissionNames } }),
-      createPermission:
-        (fn) =>
-        ({ name, description }) =>
-          fn({ input: { ...pickBy({ name, description }, isNotNullOrUndefined), teamDid } }),
-      updatePermission:
-        (fn) =>
-        (name, { description }) =>
-          fn({ input: { permission: pickBy({ name, description }, isNotNullOrUndefined), teamDid } }), // todo
-      deletePermission: (fn) => (name) => fn({ input: { name, teamDid } }),
-      hasPermission: (fn) => (role, permission) => fn({ input: { teamDid, role, permission } }),
-    };
-
-    apiList.forEach((api) => {
-      const fn = this[api];
-      this[api] = apiFnMap[api] ? apiFnMap[api](fn) : apiFallback(fn);
-    });
-
-    return new Proxy(this, {
-      get(target, propKey) {
-        if (!apiList.includes(propKey)) {
-          return undefined;
-        }
-        return target[propKey];
-      },
-    });
-  }
-
-  _getAuthHeaders() {
-    const headers = super._getAuthHeaders();
-    headers['x-access-blocklet'] = this._blockletDid;
-    headers['x-access-service'] = NODE_SERVICES.AUTH_SERVICE;
-    return headers;
-  }
+class AuthService {
+    constructor(httpEndpoint) {
+        const client = new AuthClient(httpEndpoint);
+        const apiList = [
+            // user
+            'getUsers',
+            'getUser',
+            'getOwner',
+            // 'removeUser',
+            // 'updateUserRole',
+            'updateUserApproval',
+            // invitation
+            // 'getInvitations',
+            // 'createMemberInvitation',
+            // 'deleteInvitation',
+            // rbac
+            'getRoles',
+            'createRole',
+            'updateRole',
+            'deleteRole',
+            'grantPermissionForRole',
+            'revokePermissionFromRole',
+            'updatePermissionsForRole',
+            'hasPermission',
+            // user passport
+            'issuePassportToUser',
+            'revokeUserPassport',
+            'enableUserPassport',
+            // 'getPassportIssuances',
+            // 'createPassportIssuance',
+            // 'deletePassportIssuance',
+            // permission
+            'getPermissions',
+            'createPermission',
+            'updatePermission',
+            'deletePermission',
+            'getPermissionsByRole',
+            // disabled in current
+            // 'configTrustedPassports',
+        ];
+        const teamDid = process.env.BLOCKLET_DID;
+        const apiFallback = (fn) => (params = {}, ...args) => fn({ input: { ...params, teamDid }, ...args });
+        // const apiConvertDid = (fn: Function) => (did: string) => fn({ input: { user: { did }, teamDid } });
+        const apiFnMap = {
+            getUser: (fn) => async (did) => {
+                const res = await fn({ input: { user: { did }, teamDid } });
+                fixAvatar(res.user);
+                return res;
+            },
+            getUsers: (fn) => async (args) => {
+                const res = await fn({ input: { teamDid, ...args } });
+                (res.users || []).forEach(fixAvatar);
+                return res;
+            },
+            // removeUser: apiConvertDid,
+            // updateUserRole: (fn: Function) => (did: string, role: string) => fn({ input: { user: { did, role }, teamDid } }),
+            updateUserApproval: (fn) => (did, approved) => fn({ input: { user: { did, approved }, teamDid } }),
+            getPermissionsByRole: (fn) => (name) => fn({ input: { role: { name }, teamDid } }),
+            createRole: (fn) => ({ name, title, description }) => fn({ input: { ...(0, pickBy_1.default)({ name, title, description }, isNotNullOrUndefined), teamDid } }),
+            updateRole: (fn) => (name, { title, description }) => fn({ input: { role: (0, pickBy_1.default)({ name, title, description }, isNotNullOrUndefined), teamDid } }),
+            deleteRole: (fn) => (name) => fn({ input: { name, teamDid } }),
+            grantPermissionForRole: (fn) => (roleName, permissionName) => fn({ input: { teamDid, roleName, grantName: permissionName } }),
+            revokePermissionFromRole: (fn) => (roleName, permissionName) => fn({ input: { teamDid, roleName, grantName: permissionName } }),
+            updatePermissionsForRole: (fn) => (roleName, permissionNames) => fn({ input: { teamDid, roleName, grantNames: permissionNames } }),
+            createPermission: (fn) => ({ name, description }) => fn({ input: { ...(0, pickBy_1.default)({ name, description }, isNotNullOrUndefined), teamDid } }),
+            updatePermission: (fn) => (name, { description }) => fn({ input: { permission: (0, pickBy_1.default)({ name, description }, isNotNullOrUndefined), teamDid } }),
+            deletePermission: (fn) => (name) => fn({ input: { name, teamDid } }),
+            hasPermission: (fn) => (role, permission) => fn({ input: { teamDid, role, permission } }),
+        };
+        apiList.forEach((api) => {
+            const fn = client[api];
+            this[api] = apiFnMap[api] ? apiFnMap[api](fn) : apiFallback(fn);
+        });
+        // eslint-disable-next-line no-constructor-return
+        return new Proxy(this, {
+            get(target, propKey) {
+                if (!apiList.includes(propKey)) {
+                    return undefined;
+                }
+                return target[propKey];
+            },
+        });
+    }
 }
-
 module.exports = AuthService;

package/lib/service/notification.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { TNotificationInput, TSendOptions } from '../types/notification';
+type $TSFixMe = any;
+/**
+ *
+ * @param {Notification} notification
+ * @param {{
+ *   keepForOfflineUser: Boolean
+ * }} options
+ * @returns
+ */
+declare const doSendToUser: (receiver: string | string[], notification: TNotificationInput, options?: TSendOptions) => Promise<any>;
+declare const doSendToRelay: (topic: string, event: string, data: any) => Promise<any>;
+/**
+ *
+ * @param {Notification} notification
+ * @param {{
+ *   channel: String
+ *   event: String
+ *   socketId: String
+ *   socketDid: String
+ * }} options
+ * @returns
+ */
+declare const broadcast: (notification: TNotificationInput, options?: TSendOptions) => Promise<any>;
+export declare const on: (event: string, cb?: $TSFixMe) => EventEmitter;
+export declare const off: any;
+export declare const _message: {
+    on: (event: string, cb: $TSFixMe) => EventEmitter;
+    off: any;
+};
+export { doSendToUser as sendToUser };
+export { doSendToRelay as sendToRelay };
+export { broadcast };
+declare const _default: {
+    sendToUser: (receiver: string | string[], notification: TNotificationInput, options?: TSendOptions) => Promise<any>;
+    sendToRelay: (topic: string, event: string, data: any) => Promise<any>;
+    broadcast: (notification: TNotificationInput, options?: TSendOptions) => Promise<any>;
+    on: (event: string, cb?: any) => EventEmitter;
+    off: any;
+    _message: {
+        on: (event: string, cb: any) => EventEmitter;
+        off: any;
+    };
+};
+export default _default;

package/lib/service/notification.js

@@ -1,18 +1,182 @@
-const checkBlockletEnv = require('../util/check-blocklet-env');
-const sendNotification = require('../util/send-notification');
-
-class NotificationService {
-  static async sendToUser(receiver, notification) {
-    checkBlockletEnv();
-
-    const sender = {
-      appId: process.env.BLOCKLET_APP_ID,
-      appSk: process.env.BLOCKLET_APP_SK,
-      did: process.env.BLOCKLET_DID,
-    };
-
-    return sendNotification(receiver, notification, sender, process.env.ABT_NODE_SERVICE_PORT);
-  }
-}
-
-module.exports = NotificationService;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.broadcast = exports.sendToRelay = exports.sendToUser = exports._message = exports.off = exports.on = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+const Jwt = __importStar(require("@arcblock/jwt"));
+const events_1 = __importDefault(require("events"));
+const ws_1 = require("@arcblock/ws");
+const channel_1 = require("@blocklet/meta/lib/channel");
+const check_blocklet_env_1 = __importDefault(require("../util/check-blocklet-env"));
+const send_notification_1 = require("../util/send-notification");
+const constants_1 = require("../util/constants");
+const wallet_1 = __importDefault(require("../wallet"));
+const notification_1 = require("../validators/notification");
+const getSender = () => ({
+    appDid: process.env.BLOCKLET_APP_ID,
+    appSk: process.env.BLOCKLET_APP_SK,
+});
+/**
+ *
+ * @param {Notification} notification
+ * @param {{
+ *   keepForOfflineUser: Boolean
+ * }} options
+ * @returns
+ */
+const doSendToUser = async (receiver, notification, options) => {
+    (0, check_blocklet_env_1.default)();
+    return (0, send_notification_1.sendToUser)(receiver, notification, getSender(), process.env.ABT_NODE_SERVICE_PORT, options);
+};
+exports.sendToUser = doSendToUser;
+const doSendToRelay = async (topic, event, data) => {
+    (0, check_blocklet_env_1.default)();
+    return (0, send_notification_1.sendToRelay)(topic, event, data, getSender(), process.env.ABT_NODE_SERVICE_PORT);
+};
+exports.sendToRelay = doSendToRelay;
+/**
+ *
+ * @param {Notification} notification
+ * @param {{
+ *   channel: String
+ *   event: String
+ *   socketId: String
+ *   socketDid: String
+ * }} options
+ * @returns
+ */
+const broadcast = async (notification, options = {}) => {
+    (0, check_blocklet_env_1.default)();
+    const sender = getSender();
+    const { channel = (0, channel_1.getAppPublicChannel)(sender.appDid) } = options;
+    const { event = 'message' } = options;
+    return (0, send_notification_1.sendToAppChannel)(channel, event, notification, sender, process.env.ABT_NODE_SERVICE_PORT, options);
+};
+exports.broadcast = broadcast;
+const emitter = new events_1.default();
+const messageEmitter = new events_1.default();
+const emitError = (error) => {
+    messageEmitter.emit('error', error);
+    emitter.emit('error', error);
+};
+let client = null;
+const initClient = () => {
+    if (!client) {
+        const wallet = (0, wallet_1.default)();
+        const { address: did, publicKey: pk, secretKey: sk } = wallet;
+        const url = `ws://127.0.0.1:${process.env.ABT_NODE_SERVICE_PORT}${constants_1.SERVICE_PREFIX}`;
+        const token = () => Jwt.sign(did, sk, {});
+        client = new ws_1.WsClient(url, {
+            heartbeatIntervalMs: 10 * 1000,
+            params: () => ({
+                token: token(),
+                pk,
+            }),
+        });
+        client.connect();
+        const messageChannel = client.channel(did, () => ({ token: token(), pk }));
+        const appPublicChannel = client.channel((0, channel_1.getAppPublicChannel)(did), () => ({ token: token(), pk }));
+        messageChannel
+            .join()
+            .receive('error', (err) => {
+            const msg = `join channel error: ${err.message}`;
+            console.error(msg);
+            emitError({ message: msg });
+        })
+            .receive('timeout', () => {
+            const msg = 'join channel timeout';
+            console.error(msg);
+            emitError({ message: msg });
+        });
+        messageChannel.on('message', ({ status, response } = {}) => {
+            if (status === 'ok') {
+                messageEmitter.emit(response.type, response);
+                if (response.type === notification_1.NOTIFICATION_TYPES.HI) {
+                    emitter.emit(response.type, response);
+                }
+            }
+            else {
+                emitError(response);
+                console.error({
+                    status,
+                    response,
+                });
+            }
+        });
+        appPublicChannel
+            .join()
+            .receive('error', (err) => {
+            const msg = `join channel error: ${err.message}`;
+            console.error(msg);
+            emitter.emit('error', { message: msg });
+        })
+            .receive('timeout', () => {
+            const msg = 'join channel timeout';
+            console.error(msg);
+            emitter.emit('error', { message: msg });
+        });
+        appPublicChannel.on(notification_1.NOTIFICATION_TYPES.HI, ({ status, response } = {}) => {
+            if (status === 'ok') {
+                emitter.emit(notification_1.NOTIFICATION_TYPES.HI, response);
+            }
+            else {
+                emitter.emit('error', response);
+                console.error({
+                    status,
+                    response,
+                });
+            }
+        });
+    }
+};
+const ensureClient = () => {
+    if (!client) {
+        initClient();
+    }
+};
+const on = (event, cb) => {
+    ensureClient();
+    return emitter.on(event, cb);
+};
+exports.on = on;
+exports.off = emitter.off.bind(emitter);
+exports._message = {
+    on: (event, cb) => {
+        ensureClient();
+        return messageEmitter.on(event, cb);
+    },
+    off: messageEmitter.off.bind(messageEmitter),
+};
+exports.default = {
+    sendToUser: doSendToUser,
+    sendToRelay: doSendToRelay,
+    broadcast,
+    on: exports.on,
+    off: exports.off,
+    _message: exports._message,
+};