@blocklet/sdk 1.8.66 → 1.8.67-beta-65933c91

package/lib/component/index.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -25,9 +16,9 @@ const sign = (data) => {
     const signData = typeof data === 'undefined' ? {} : data;
     return { 'x-component-sig': wallet.sign((0, json_stable_stringify_1.default)(signData)) };
 };
-const doCall = ({ url, data }) => __awaiter(void 0, void 0, void 0, function* () {
+const doCall = async ({ url, data }) => {
     try {
-        const resp = yield axios_1.default.post(url, data, { headers: sign(data), timeout: 60000 });
+        const resp = await axios_1.default.post(url, data, { headers: sign(data), timeout: 60000 });
         config_1.logger.info(`call ${url} api success`);
         return resp;
     }
@@ -40,7 +31,7 @@ const doCall = ({ url, data }) => __awaiter(void 0, void 0, void 0, function* ()
         });
         throw new Error(`call ${url} api failed`);
     }
-});
+};
 const parsePorts = () => JSON.parse(process.env.BLOCKLET_WEB_PORTS);
 const getWebEndpoint = (name) => {
     const ports = parsePorts();
@@ -68,11 +59,11 @@ const parseMountPoints = () => {
     });
     return mountPoints;
 };
-const call = ({ name, path: _path, data }) => __awaiter(void 0, void 0, void 0, function* () {
+const call = async ({ name, path: _path, data }) => {
     const baseURL = name ? getChildWebEndpoint(name) : getParentWebEndpoint();
     const url = (0, url_join_1.default)(baseURL, _path);
     return doCall({ url, data });
-});
+};
 exports.call = call;
 const getComponentMountPoint = (keyword) => {
     const mountPoints = parseMountPoints();

package/lib/connect/authenticator.js

@@ -9,7 +9,10 @@ const shared_1 = __importDefault(require("./shared"));
 class BlockletAuthenticator extends authenticator_1.Authenticator {
     constructor(options = {}) {
         (0, check_blocklet_env_1.default)();
-        super(Object.assign({ wallet: (0, wallet_1.default)() }, (0, shared_1.default)(options)));
+        super({
+            wallet: (0, wallet_1.default)(),
+            ...(0, shared_1.default)(options),
+        });
     }
 }
 module.exports = BlockletAuthenticator;

package/lib/connect/handler.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -60,8 +51,8 @@ const createConnectHandlers = ({ authenticator, storage, logger = consoleLogger,
         socketPathname,
     });
     const originCreateHandler = handlers.handleSessionCreate;
-    handlers.handleSessionCreate = (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const session = yield originCreateHandler(context);
+    handlers.handleSessionCreate = async (context) => {
+        const session = await originCreateHandler(context);
         const connectedDid = getConnectedDid(session);
         // send notification to wallet to trigger wallet to auto connect
         if (connectedDid) {
@@ -88,12 +79,12 @@ const createConnectHandlers = ({ authenticator, storage, logger = consoleLogger,
             }
             // sendNotificationFn maybe custom function so we need params
             const sendFn = sendNotificationFn || notification_1.sendToUser.bind(notification_1.default);
-            sendFn(connectedDid, message, Object.assign(Object.assign({}, context), { session })).catch((err) => {
+            sendFn(connectedDid, message, { ...context, session }).catch((err) => {
                 console.error(err);
             });
         }
         return session;
-    });
+    };
     return handlers;
 };
 module.exports = createConnectHandlers;

package/lib/connect/shared.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -16,10 +7,23 @@ const util_1 = require("@blocklet/meta/lib/util");
 const constants_1 = require("../util/constants");
 // wraps value in closure or returns closure
 const closure = (value) => (typeof value === 'function' ? value : () => value);
-const connectShared = (options = {}) => (Object.assign(Object.assign({ chainInfo: () => (0, util_1.getChainInfo)(process.env) }, options), { appInfo: (...args) => __awaiter(void 0, void 0, void 0, function* () {
-        const info = yield closure(options.appInfo)(...args);
+const connectShared = (options = {}) => ({
+    chainInfo: () => (0, util_1.getChainInfo)(process.env),
+    ...options,
+    appInfo: async (...args) => {
+        const info = await closure(options.appInfo)(...args);
         const { request, baseUrl } = args[0];
         const groupPathPrefix = request.headers['x-group-path-prefix'] || '/';
-        return Object.assign(Object.assign({ name: process.env.BLOCKLET_APP_NAME, description: process.env.BLOCKLET_APP_DESCRIPTION }, (info || {})), { link: (0, util_1.getConnectAppUrl)(args[0]), icon: (0, url_join_1.default)(baseUrl, constants_1.SERVICE_PREFIX, `/blocklet/logo?v=${process.env.BLOCKLET_APP_VERSION || ''}`), updateSubEndpoint: true, subscriptionEndpoint: (0, url_join_1.default)(groupPathPrefix, constants_1.SERVICE_PREFIX, 'websocket'), nodeDid: process.env.ABT_NODE_DID });
-    }) }));
+        return {
+            name: process.env.BLOCKLET_APP_NAME,
+            description: process.env.BLOCKLET_APP_DESCRIPTION,
+            ...(info || {}),
+            link: (0, util_1.getConnectAppUrl)(args[0]),
+            icon: (0, url_join_1.default)(baseUrl, constants_1.SERVICE_PREFIX, `/blocklet/logo?v=${process.env.BLOCKLET_APP_VERSION || ''}`),
+            updateSubEndpoint: true,
+            subscriptionEndpoint: (0, url_join_1.default)(groupPathPrefix, constants_1.SERVICE_PREFIX, 'websocket'),
+            nodeDid: process.env.ABT_NODE_DID,
+        };
+    },
+});
 module.exports = connectShared;

package/lib/database/index.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -28,27 +19,29 @@ class DataBase extends core_1.DataStore {
         const DB_DIR = path_1.default.join(process.env.BLOCKLET_DATA_DIR, 'db');
         fs_extra_1.default.ensureDirSync(DB_DIR);
         const filename = options.filename || path_1.default.join(DB_DIR, `${name}.db`);
-        super(Object.assign({ filename, autoload: true, timestampData: true, onload: (err) => {
+        super({
+            filename,
+            autoload: true,
+            timestampData: true,
+            onload: (err) => {
                 if (err) {
                     console.error(`failed to load disk database ${filename}`, err);
                 }
-            } }, options));
-    }
-    exists(...args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const doc = yield this.findOne(...args);
-            return !!doc;
+            },
+            ...options,
         });
     }
-    paginate({ condition = {}, sort = {}, page = 1, size = 100, projection = {} }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cursor(condition)
-                .sort(sort)
-                .skip(Math.max(page * size - size, 0))
-                .limit(Math.max(size, 1))
-                .projection(projection)
-                .exec();
-        });
+    async exists(...args) {
+        const doc = await this.findOne(...args);
+        return !!doc;
+    }
+    async paginate({ condition = {}, sort = {}, page = 1, size = 100, projection = {} }) {
+        return this.cursor(condition)
+            .sort(sort)
+            .skip(Math.max(page * size - size, 0))
+            .limit(Math.max(size, 1))
+            .projection(projection)
+            .exec();
     }
 }
 module.exports = DataBase;

package/lib/embed/index.d.ts

@@ -0,0 +1,9 @@
+import type { Request, Response } from 'express';
+import { generateBlockletEmbed } from './utils';
+declare const expressEmbed: (req: Request, res: Response) => Promise<void>;
+declare const _default: {
+    expressEmbed: (req: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>) => Promise<void>;
+    generateBlockletEmbed: typeof generateBlockletEmbed;
+};
+export default _default;
+export { expressEmbed, generateBlockletEmbed };

package/lib/embed/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBlockletEmbed = exports.expressEmbed = void 0;
+const utils_1 = require("./utils");
+Object.defineProperty(exports, "generateBlockletEmbed", { enumerable: true, get: function () { return utils_1.generateBlockletEmbed; } });
+const expressEmbed = async (req, res) => {
+    const { query = {} } = req;
+    const { url = '' } = query;
+    const data = await (0, utils_1.getBlockletEmbedFromUrl)(url);
+    res.json(data);
+};
+exports.expressEmbed = expressEmbed;
+exports.default = { expressEmbed, generateBlockletEmbed: utils_1.generateBlockletEmbed };

package/lib/embed/message.d.ts

@@ -0,0 +1,26 @@
+type InstanceType = 'client' | 'server';
+type MessageType = string;
+interface Callback {
+    (...args: any[]): void;
+}
+declare class Message {
+    id: string;
+    type: InstanceType;
+    private bc;
+    private eventMap;
+    init: (cb: Callback) => void;
+    onInit: (getData: () => any) => void;
+    close: () => void;
+    constructor(id: string, type?: InstanceType);
+    on(type: MessageType, cb: Callback): void;
+    off(type: MessageType, cb: Callback): void;
+    once(type: MessageType, cb: Callback): void;
+    send(type: MessageType, payload: any): void;
+}
+declare function useMessage(id?: string, type?: InstanceType): any;
+declare const _default: {
+    useMessage: typeof useMessage;
+    Message: typeof Message;
+};
+export default _default;
+export { useMessage, Message };

package/lib/embed/message.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = exports.useMessage = void 0;
+const INIT = '__init';
+const ON_INIT = '__on-init';
+function checkKey(typeKey) {
+    return !typeKey.startsWith(INIT);
+}
+function ensureType(type) {
+    if (!checkKey(type)) {
+        throw new Error(`Type can't starts with ${INIT}`);
+    }
+}
+function notExist() {
+    console.error('function not exist');
+}
+class Message {
+    constructor(id, type = 'client') {
+        this.id = id;
+        this.type = type;
+        const bc = new BroadcastChannel(this.id);
+        this.bc = bc;
+        this.eventMap = new Map();
+        const onMessage = (event) => {
+            const { data } = event;
+            const { type: messageType, payload, id: dataId } = data;
+            if (dataId === this.id) {
+                const cbList = this.eventMap.get(messageType) || [];
+                cbList.forEach((cbItem) => {
+                    cbItem(payload);
+                });
+            }
+        };
+        window.addEventListener('message', onMessage, false);
+        this.close = () => {
+            window.removeEventListener('message', onMessage, false);
+            // v1 message
+            this.bc.close();
+        };
+        // v1 message
+        bc.onmessage = ({ data }) => {
+            const { type: messageType, payload } = data;
+            const cbList = this.eventMap.get(messageType) || [];
+            cbList.forEach((cbItem) => {
+                cbItem(payload);
+            });
+        };
+        this.init = notExist;
+        this.onInit = notExist;
+        if (type === 'server') {
+            this.onInit = (getData = () => null) => {
+                this.eventMap.set(INIT, [
+                    (listenKey) => {
+                        const initData = getData();
+                        this.send(listenKey, initData);
+                    },
+                ]);
+            };
+        }
+        if (type === 'client') {
+            this.init = (cb) => {
+                const uniqueId = String(+new Date());
+                const listenKey = `${ON_INIT}_${uniqueId}`;
+                this.once(listenKey, cb);
+                this.send(INIT, listenKey);
+            };
+        }
+    }
+    on(type, cb) {
+        ensureType(type);
+        const cbList = this.eventMap.get(type) || [];
+        cbList.push(cb);
+        this.eventMap.set(type, cbList);
+    }
+    off(type, cb) {
+        ensureType(type);
+        const cbList = this.eventMap.get(type) || [];
+        if (cb) {
+            const index = cbList.indexOf(cb);
+            if (index !== -1) {
+                cbList.splice(index, 1);
+            }
+        }
+        else {
+            cbList.length = 0;
+        }
+        this.eventMap.set(type, cbList);
+    }
+    once(type, cb) {
+        ensureType(type);
+        const callback = (...args) => {
+            cb(...args);
+            this.off(type, callback);
+        };
+        this.on(type, callback);
+    }
+    send(type, payload) {
+        const data = {
+            id: this.id,
+            type,
+            payload,
+        };
+        if (this.type === 'server') {
+            const iframeList = [...document.querySelectorAll(`iframe[data-id="${this.id}"]`)];
+            iframeList.forEach((iframeItem) => {
+                iframeItem.contentWindow.postMessage(data, '*');
+            });
+        }
+        else {
+            window.parent.postMessage(data, '*');
+        }
+        // v1 message
+        this.bc.postMessage(data);
+    }
+}
+exports.Message = Message;
+const messageCache = new Map();
+function useMessage(id, type = 'client') {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const _id = id || window.frameElement?.dataset.id || window.name;
+    if (messageCache.has(_id)) {
+        return messageCache.get(_id);
+    }
+    const isInIframe = window !== window.parent;
+    const message = (type === 'server' || isInIframe) && _id ? new Message(_id, type) : null;
+    const data = { message };
+    messageCache.set(_id, data);
+    return data;
+}
+exports.useMessage = useMessage;
+exports.default = {
+    useMessage,
+    Message,
+};

package/lib/embed/utils.d.ts

@@ -0,0 +1,7 @@
+export declare function getBlockletEmbedFromUrl(url: string): Promise<object | null>;
+export declare function generateBlockletEmbed(): {
+    name: string;
+    url: string;
+    origin: string;
+    embed: any[];
+};

package/lib/embed/utils.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBlockletEmbed = exports.getBlockletEmbedFromUrl = void 0;
+const path_1 = require("path");
+const jsdom_1 = __importDefault(require("jsdom"));
+const lodash_1 = require("lodash");
+const ufo_1 = require("ufo");
+const axios_1 = __importDefault(require("axios"));
+const { JSDOM } = jsdom_1.default;
+const api = axios_1.default.create();
+/**
+ * 判断 document 是否为开发环境
+ * @param document html document 对象（jsdom）
+ * @returns boolean
+ */
+function checkDev(document) {
+    const scirptList = document.querySelectorAll('script[type="module"]');
+    return !![...scirptList].find((scriptItem) => scriptItem.textContent?.includes('window.__vite_plugin_react_preamble_installed__ = true'));
+}
+async function getEmbedUrlFromUrl(url) {
+    try {
+        const { data: htmlContent } = await api.get(url, {
+            headers: {
+                accept: 'text/html,application/xhtml+xml,application/xml',
+            },
+        });
+        const { document } = new JSDOM(htmlContent).window;
+        let prefix = '/';
+        let metaUrl = url;
+        const link = document.querySelector('link[rel="blocklet-open-embed"]');
+        const blockletScript = document.querySelector('script[src="__blocklet__.js"]');
+        if (link) {
+            metaUrl = link.getAttribute('href') || url;
+        }
+        const isDev = checkDev(document);
+        if (blockletScript) {
+            const scriptUrl = new URL('__blocklet__.js?type=json', (0, ufo_1.withTrailingSlash)(url));
+            const { data: blockletMeta } = await api.get(scriptUrl.href);
+            prefix = blockletMeta.prefix;
+        }
+        return isDev ? (0, ufo_1.joinURL)(prefix, metaUrl.replace(prefix, '')) : (0, ufo_1.joinURL)(prefix, metaUrl);
+    }
+    catch {
+        return url;
+    }
+}
+async function getBlockletEmbedFromUrl(url) {
+    const metaUrl = await getEmbedUrlFromUrl(url);
+    if (metaUrl) {
+        let finalUrl = '';
+        if (metaUrl.startsWith('http://') || metaUrl.startsWith('https://')) {
+            finalUrl = metaUrl;
+        }
+        else {
+            finalUrl = `${new URL(url).origin}${(0, path_1.join)('/', metaUrl)}`;
+        }
+        const { data: metaData } = await api.get(finalUrl);
+        if ((0, lodash_1.isObject)(metaData)) {
+            return metaData;
+        }
+    }
+    return null;
+}
+exports.getBlockletEmbedFromUrl = getBlockletEmbedFromUrl;
+function safeJsonParse(input, defaultValue) {
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return defaultValue;
+    }
+}
+function generateBlockletEmbed() {
+    const BLOCKLET_MOUNT_POINTS = safeJsonParse(process.env.BLOCKLET_MOUNT_POINTS, []);
+    const { BLOCKLET_APP_NAME, BLOCKLET_APP_URL, BLOCKLET_REAL_NAME } = process.env;
+    let name = BLOCKLET_APP_NAME;
+    const blockletNames = BLOCKLET_REAL_NAME.split('/');
+    let url = '/';
+    const componentBlocklet = BLOCKLET_MOUNT_POINTS.find((blockletItem) => blockletItem.name === blockletNames[blockletNames.length - 1]);
+    if (componentBlocklet) {
+        // 先假设只有一层 component blocklet
+        url = componentBlocklet.mountPoint;
+        name = componentBlocklet.title;
+    }
+    return {
+        name,
+        url,
+        origin: BLOCKLET_APP_URL,
+        embed: [],
+    };
+}
+exports.generateBlockletEmbed = generateBlockletEmbed;

package/lib/middlewares/auth.d.ts

@@ -1,3 +1,8 @@
 import { NextFunction, Request, Response } from 'express';
-declare const AuthMiddleware: ({ roles, permissions, _AuthClient }?: $TSFixMe) => (req: Request, res: Response, next: NextFunction) => Promise<void>;
+type MiddlewareParams = {
+    roles?: string[];
+    permissions?: string[];
+    getClient?: Function;
+};
+declare const AuthMiddleware: ({ roles, permissions, getClient }?: MiddlewareParams) => (req: Request, res: Response, next: NextFunction) => Promise<void>;
 export = AuthMiddleware;

package/lib/middlewares/auth.js

@@ -1,41 +1,38 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 const lru_cache_1 = __importDefault(require("lru-cache"));
 const auth_1 = __importDefault(require("../service/auth"));
-const cachedPermissions = new lru_cache_1.default({
-    max: 10,
-    maxAge: 60 * 1000, // cache for 2min
-});
-const getPermissionsByRole = (client, role) => __awaiter(void 0, void 0, void 0, function* () {
-    const cached = cachedPermissions.get(role);
+const cache = new lru_cache_1.default({ max: 10, maxAge: 60 * 1000 });
+const clients = {};
+const getServiceClient = () => {
+    const appId = process.env.BLOCKLET_APP_ID;
+    if (!clients[appId]) {
+        clients[appId] = new auth_1.default();
+    }
+    return clients[appId];
+};
+const getPermissionsByRole = async (getClient, role) => {
+    if (!role) {
+        return [];
+    }
+    const cached = cache.get(role);
     if (cached) {
         return cached;
     }
-    const res = yield client.getPermissionsByRole(role);
-    cachedPermissions.set(role, res);
+    const res = await getClient().getPermissionsByRole(role);
+    cache.set(role, res);
     return res;
-});
-// FIXME: 名字待确认, 全局的名称 Auth 已经被用了
-const AuthMiddleware = ({ roles, permissions, _AuthClient = auth_1.default } = {}) => {
+};
+const AuthMiddleware = ({ roles, permissions, getClient = getServiceClient } = {}) => {
     if (roles && !Array.isArray(roles)) {
         throw new Error('roles must be array');
     }
     if (permissions && !Array.isArray(permissions)) {
         throw new Error('permissions must be array');
     }
-    const client = new _AuthClient();
-    return (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    return async (req, res, next) => {
         if (!req.headers['x-user-did']) {
             res.status(401).json({ code: 'forbidden', error: 'not authorized' });
             return;
@@ -45,13 +42,13 @@ const AuthMiddleware = ({ roles, permissions, _AuthClient = auth_1.default } = {
             return;
         }
         if (permissions) {
-            const { permissions: list } = yield getPermissionsByRole(client, req.headers['x-user-role']);
+            const { permissions: list } = await getPermissionsByRole(getClient, req.headers['x-user-role']);
             if (!permissions.some((x) => (list || []).some((y) => y.name === x))) {
                 res.status(403).json({ code: 'forbidden', error: 'no permission' });
                 return;
             }
         }
         next();
-    });
+    };
 };
 module.exports = AuthMiddleware;

package/lib/middlewares/index.d.ts

@@ -12,7 +12,11 @@ declare const _default: {
             fullName: string;
         };
     }, res: import("express").Response<any, Record<string, any>>, next: import("express").NextFunction) => Promise<void>;
-    auth: ({ roles, permissions, _AuthClient }?: any) => (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: import("express").Response<any, Record<string, any>>, next: import("express").NextFunction) => Promise<void>;
+    auth: ({ roles, permissions, getClient }?: {
+        roles?: string[];
+        permissions?: string[];
+        getClient?: Function;
+    }) => (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: import("express").Response<any, Record<string, any>>, next: import("express").NextFunction) => Promise<void>;
     component: {
         verifySig: (req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: import("express").Response<any, Record<string, any>>, next: import("express").NextFunction) => void | import("express").Response<any, Record<string, any>>;
     };

package/lib/middlewares/user.js

@@ -1,14 +1,5 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-const userMiddleware = () => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+const userMiddleware = () => async (req, res, next) => {
     if (req.headers['x-user-did']) {
         req.user = {
             did: req.headers['x-user-did'],
@@ -17,5 +8,5 @@ const userMiddleware = () => (req, res, next) => __awaiter(void 0, void 0, void
         };
     }
     next();
-});
+};
 module.exports = userMiddleware;

package/lib/service/auth.d.ts

@@ -22,7 +22,7 @@ interface AuthService {
     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<ABTNodeClient.BooleanResponse>;
+    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>;

package/lib/service/auth.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -28,7 +19,7 @@ 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 === null || user === void 0 ? void 0 : user.avatar;
+    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, ''));
     }
@@ -97,30 +88,30 @@ class AuthService {
             // 'configTrustedPassports',
         ];
         const teamDid = process.env.BLOCKLET_DID;
-        const apiFallback = (fn) => (params = {}, ...args) => fn(Object.assign({ input: Object.assign(Object.assign({}, params), { teamDid }) }, args));
+        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) => (did) => __awaiter(this, void 0, void 0, function* () {
-                const res = yield fn({ input: { user: { did }, teamDid } });
+            getUser: (fn) => async (did) => {
+                const res = await fn({ input: { user: { did }, teamDid } });
                 fixAvatar(res.user);
                 return res;
-            }),
-            getUsers: (fn) => (args) => __awaiter(this, void 0, void 0, function* () {
-                const res = yield fn({ input: Object.assign({ teamDid }, args) });
+            },
+            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: Object.assign(Object.assign({}, (0, pickBy_1.default)({ name, title, description }, isNotNullOrUndefined)), { 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: Object.assign(Object.assign({}, (0, pickBy_1.default)({ name, description }, isNotNullOrUndefined)), { teamDid }) }),
+            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 } }),

package/lib/service/notification.d.ts

@@ -11,6 +11,7 @@ type $TSFixMe = any;
  * @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
@@ -30,9 +31,11 @@ export declare const _message: {
     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;

package/lib/service/notification.js

@@ -22,20 +22,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.broadcast = exports.sendToUser = exports._message = exports.off = exports.on = void 0;
+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"));
@@ -58,11 +49,16 @@ const getSender = () => ({
  * }} options
  * @returns
  */
-const doSendToUser = (receiver, notification, options) => __awaiter(void 0, void 0, void 0, function* () {
+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
@@ -74,13 +70,13 @@ exports.sendToUser = doSendToUser;
  * }} options
  * @returns
  */
-const broadcast = (notification, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+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();
@@ -178,6 +174,7 @@ exports._message = {
 };
 exports.default = {
     sendToUser: doSendToUser,
+    sendToRelay: doSendToRelay,
     broadcast,
     on: exports.on,
     off: exports.off,

package/lib/util/env.js

@@ -10,7 +10,7 @@ function parseEnv(env = process.env) {
         try {
             acc[key] = JSON.parse(env[x]);
         }
-        catch (_a) {
+        catch {
             acc[key] = env[x];
         }
         return acc;

package/lib/util/send-notification.d.ts

@@ -16,10 +16,11 @@ export type TNotificationSender = {
  */
 declare const sendToUser: (receiver: string | string[], notification: TNotificationInput, { appDid, appSk }: TNotificationSender, port?: string, options?: {}) => Promise<any>;
 declare const sendToAppChannel: (channel: string, event: string, notification: TNotificationInput, { appDid, appSk }: TNotificationSender, port?: string, options?: TSendOptions) => Promise<any>;
-export { sendToUser };
-export { sendToAppChannel };
+declare const sendToRelay: (topic: string, event: string, data: any, { appDid, appSk }: TNotificationSender, port?: string) => Promise<any>;
+export { sendToUser, sendToAppChannel, sendToRelay };
 declare const _default: {
     sendToUser: (receiver: string | string[], notification: TNotificationInput, { appDid, appSk }: TNotificationSender, port?: string, options?: {}) => Promise<any>;
     sendToAppChannel: (channel: string, event: string, notification: TNotificationInput, { appDid, appSk }: TNotificationSender, port?: string, options?: TSendOptions) => Promise<any>;
+    sendToRelay: (topic: string, event: string, data: any, { appDid, appSk }: TNotificationSender, port?: string) => Promise<any>;
 };
 export default _default;

package/lib/util/send-notification.js

@@ -22,24 +22,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendToAppChannel = exports.sendToUser = void 0;
+exports.sendToRelay = exports.sendToAppChannel = exports.sendToUser = void 0;
 const axios_1 = __importDefault(require("axios"));
 const pick_1 = __importDefault(require("lodash/pick"));
 const JWT = __importStar(require("@arcblock/jwt"));
 const constant_1 = __importDefault(require("@abtnode/constant"));
+const channel_1 = require("@blocklet/meta/lib/channel");
 const index_1 = require("../validators/index");
 const constants_1 = require("./constants");
 const version_1 = require("../version");
@@ -59,15 +51,15 @@ const getRequestHeaders = () => ({ 'User-Agent': `BlockletSDK/${VERSION}` });
  * @param {Object} options
  * @returns
  */
-const sendToUser = (receiver, notification, { appDid, appSk }, port = process.env.ABT_NODE_SERVICE_PORT, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
-    yield (0, index_1.validateReceiver)(receiver);
+const sendToUser = async (receiver, notification, { appDid, appSk }, port = process.env.ABT_NODE_SERVICE_PORT, options = {}) => {
+    await (0, index_1.validateReceiver)(receiver);
     const opt = (0, pick_1.default)(options, ['keepForOfflineUser']);
-    yield (0, index_1.validateOption)(opt);
+    await (0, index_1.validateOption)(opt);
     if (SERVER_MODE !== NODE_MODES.DEBUG) {
-        yield (0, index_1.validateNotification)(notification);
+        await (0, index_1.validateNotification)(notification);
     }
     try {
-        const { data: res } = yield axios.post(`http://127.0.0.1:${port}${constants_1.SERVICE_PREFIX}/api/send-to-user`, {
+        const { data: res } = await axios.post(`http://127.0.0.1:${port}${constants_1.SERVICE_PREFIX}/api/send-to-user`, {
             apiVersion: VERSION,
             data: {
                 sender: { appDid, token: JWT.sign(appDid, appSk) },
@@ -85,16 +77,16 @@ const sendToUser = (receiver, notification, { appDid, appSk }, port = process.en
         console.error(err.response ? err.response.data : err);
         throw new Error(err.response ? err.response.data : err.message);
     }
-});
+};
 exports.sendToUser = sendToUser;
-const sendToAppChannel = (channel, event, notification, { appDid, appSk }, port = process.env.ABT_NODE_SERVICE_PORT, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+const sendToAppChannel = async (channel, event, notification, { appDid, appSk }, port = process.env.ABT_NODE_SERVICE_PORT, options = {}) => {
     if (!channel) {
         throw new Error('channel is required');
     }
     if (!event) {
         throw new Error('event is required');
     }
-    yield (0, index_1.validateChannelEvent)(event);
+    await (0, index_1.validateChannelEvent)(event);
     const opt = (0, pick_1.default)(options, ['socketId', 'userDid']);
     if (opt.userDid) {
         // @ts-expect-error TS(2551) FIXME: Property 'socketDid' does not exist on type 'Pick<... Remove this comment to see the full error message
@@ -102,10 +94,10 @@ const sendToAppChannel = (channel, event, notification, { appDid, appSk }, port
         delete opt.userDid;
     }
     if (SERVER_MODE !== NODE_MODES.DEBUG) {
-        yield (0, index_1.validateNotification)(notification);
+        await (0, index_1.validateNotification)(notification);
     }
     try {
-        const { data: res } = yield axios.post(`http://127.0.0.1:${port}${constants_1.SERVICE_PREFIX}/api/send-to-app-channel`, {
+        const { data: res } = await axios.post(`http://127.0.0.1:${port}${constants_1.SERVICE_PREFIX}/api/send-to-app-channel`, {
             apiVersion: VERSION,
             data: {
                 sender: { appDid, token: JWT.sign(appDid, appSk) },
@@ -124,9 +116,41 @@ const sendToAppChannel = (channel, event, notification, { appDid, appSk }, port
         console.error(err.response ? err.response.data : err);
         throw new Error(err.response ? err.response.data : err.message);
     }
-});
+};
 exports.sendToAppChannel = sendToAppChannel;
+const sendToRelay = async (topic, event, data, { appDid, appSk }, port = process.env.ABT_NODE_SERVICE_PORT) => {
+    if (!topic) {
+        throw new Error('topic is required');
+    }
+    if (!event) {
+        throw new Error('event is required');
+    }
+    if (!data) {
+        throw new Error('data is required');
+    }
+    try {
+        const { data: res } = await axios.post(`http://127.0.0.1:${port}${constants_1.SERVICE_PREFIX}/relay/api/send-to-relay-channel`, {
+            apiVersion: VERSION,
+            data: {
+                sender: { appDid, token: JWT.sign(appDid, appSk) },
+                channel: (0, channel_1.getRelayChannel)(appDid, topic),
+                event,
+                data,
+            },
+        }, {
+            timeout: 60 * 1000,
+            headers: getRequestHeaders(),
+        });
+        return res;
+    }
+    catch (err) {
+        console.error(err.response ? err.response.data : err);
+        throw new Error(err.response ? err.response.data : err.message);
+    }
+};
+exports.sendToRelay = sendToRelay;
 exports.default = {
     sendToUser,
     sendToAppChannel,
+    sendToRelay,
 };

package/lib/version.d.ts

@@ -1,4 +1,4 @@
-declare const version = "1.8.66";
+declare const version = "1.8.67";
 export { version };
 declare const _default: {
     version: string;

package/lib/version.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
-const version = '1.8.66';
+const version = '1.8.67';
 exports.version = version;
 exports.default = { version };

package/lib/wallet-authenticator.js

@@ -9,7 +9,10 @@ const shared_1 = __importDefault(require("./connect/shared"));
 class WalletAuthenticator extends did_auth_1.WalletAuthenticator {
     constructor(options = {}) {
         (0, check_blocklet_env_1.default)();
-        super(Object.assign({ wallet: (0, wallet_1.default)().toJSON() }, (0, shared_1.default)(options)));
+        super({
+            wallet: (0, wallet_1.default)().toJSON(),
+            ...(0, shared_1.default)(options),
+        });
     }
 }
 module.exports = WalletAuthenticator;

package/lib/wallet-handler.d.ts

@@ -1,13 +1,15 @@
 import { WalletHandlers as Handler } from '@arcblock/did-auth';
 declare class WalletHandlers extends Handler {
     enableConnect: boolean;
-    sendNotificationFn: $TSFixMe;
+    sendNotificationFn: Function;
+    sendToRelayFn: Function;
     /**
-     * @param {boolean} autoConnect enable auto connect to wallet (wallet does not need to scan qr code)
-     * @param {boolean} connectedDidOnly only current login did or connected did can connect
-     * @param {function} sendNotificationFn use in a non-blocklet environment
+     * @param {boolean} params.autoConnect enable auto connect to wallet (wallet does not need to scan qr code)
+     * @param {boolean} params.connectedDidOnly only current login did or connected did can connect
+     * @param {function} [params.sendNotificationFn] use in a non-blocklet environment
+     * @param {function} [params.sendToRelayFn]
      */
-    constructor({ autoConnect, connectedDidOnly, sendNotificationFn, options, ...opts }: $TSFixMe);
+    constructor({ autoConnect, connectedDidOnly, sendNotificationFn, sendToRelayFn, options, ...opts }: any);
     getConnectedDid: ({ req, didwallet, extraParams }: $TSFixMe) => any;
     attach({ onStart, ...opts }: {
         [x: string]: any;

package/lib/wallet-handler.js

@@ -22,26 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -56,19 +36,21 @@ const inMobileWallet = (didwallet) => {
 };
 class WalletHandlers extends did_auth_1.WalletHandlers {
     /**
-     * @param {boolean} autoConnect enable auto connect to wallet (wallet does not need to scan qr code)
-     * @param {boolean} connectedDidOnly only current login did or connected did can connect
-     * @param {function} sendNotificationFn use in a non-blocklet environment
+     * @param {boolean} params.autoConnect enable auto connect to wallet (wallet does not need to scan qr code)
+     * @param {boolean} params.connectedDidOnly only current login did or connected did can connect
+     * @param {function} [params.sendNotificationFn] use in a non-blocklet environment
+     * @param {function} [params.sendToRelayFn]
      */
-    constructor(_a) {
-        var { autoConnect = true, connectedDidOnly = false, sendNotificationFn, options = {} } = _a, opts = __rest(_a, ["autoConnect", "connectedDidOnly", "sendNotificationFn", "options"]);
-        // FIXME: wait check
-        // if (autoConnect && connectedDidOnly) {
-        //  options.sessionDidKey = CONNECTED_DID_KEY;
-        // }
-        super(Object.assign({ options: Object.assign(Object.assign({}, options), {
-                sessionDidKey: autoConnect && connectedDidOnly ? CONNECTED_DID_KEY : options === null || options === void 0 ? void 0 : options.sessionDidKey,
-            }) }, opts));
+    constructor({ autoConnect = true, connectedDidOnly = false, sendNotificationFn = null, sendToRelayFn = null, options = {}, ...opts }) {
+        super({
+            options: {
+                ...options,
+                ...{
+                    sessionDidKey: autoConnect && connectedDidOnly ? CONNECTED_DID_KEY : options?.sessionDidKey,
+                },
+            },
+            ...opts,
+        });
         this.getConnectedDid = ({ req, didwallet, extraParams }) => {
             if (extraParams && extraParams.autoConnect === 'false') {
                 return null;
@@ -83,12 +65,16 @@ class WalletHandlers extends did_auth_1.WalletHandlers {
         };
         this.enableConnect = !!autoConnect;
         this.sendNotificationFn = sendNotificationFn || notification_1.sendToUser.bind(notification_1.default);
+        this.sendToRelayFn = sendToRelayFn || notification_1.sendToRelay.bind(notification_1.default);
+        // @ts-ignore
+        this.on('updated', (session) => {
+            this.sendToRelayFn(session.token, 'updated', session).catch(console.error);
+        });
     }
-    attach(_a) {
-        var { onStart = noop } = _a, opts = __rest(_a, ["onStart"]);
-        const realOnStart = (params) => __awaiter(this, void 0, void 0, function* () {
+    attach({ onStart = noop, ...opts }) {
+        const realOnStart = async (params) => {
             // @ts-expect-error TS(2554) FIXME: Expected 0 arguments, but got 1.
-            const extra = (yield onStart(params)) || {};
+            const extra = (await onStart(params)) || {};
             const connectedDid = this.getConnectedDid(params);
             // fill extra
             extra.connectedDid = connectedDid || '';
@@ -96,9 +82,8 @@ class WalletHandlers extends did_auth_1.WalletHandlers {
             // send notification to wallet to trigger wallet to auto connect
             if (connectedDid) {
                 // wallet use check url to check status of the session
-                let checkUrl = '';
+                let checkUrl;
                 try {
-                    // @ts-expect-error TS(2322) FIXME: Type 'URL' is not assignable to type 'string'.
                     checkUrl = new URL(decodeURIComponent(new URL(params.deepLink).searchParams.get('url')));
                     checkUrl.pathname = checkUrl.pathname.replace(/auth$/, 'status');
                 }
@@ -122,9 +107,12 @@ class WalletHandlers extends did_auth_1.WalletHandlers {
                 });
             }
             return extra;
-        });
+        };
         // @ts-expect-error TS(2345) FIXME: Argument of type '{ onStart: (params: any) => Prom... Remove this comment to see the full error message
-        super.attach(Object.assign({ onStart: realOnStart }, opts));
+        super.attach({
+            onStart: realOnStart,
+            ...opts,
+        });
     }
 }
 module.exports = WalletHandlers;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.8.66",
+  "version": "1.8.67-beta-65933c91",
   "description": "graphql client to read/write data on abt node",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -28,22 +28,25 @@
   "dependencies": {
     "@abtnode/client": "1.8.66",
     "@abtnode/constant": "1.8.66",
-    "@arcblock/did-auth": "1.18.42",
-    "@arcblock/jwt": "1.18.42",
-    "@arcblock/ws": "1.18.42",
+    "@abtnode/util": "^1.8.66",
+    "@arcblock/did-auth": "1.18.56",
+    "@arcblock/jwt": "1.18.56",
+    "@arcblock/ws": "1.18.56",
     "@blocklet/constant": "1.8.66",
     "@blocklet/meta": "1.8.66",
-    "@did-connect/authenticator": "^2.1.34",
-    "@did-connect/handler": "^2.1.34",
+    "@did-connect/authenticator": "^2.1.40",
+    "@did-connect/handler": "^2.1.40",
     "@nedb/core": "^2.1.5",
-    "@ocap/mcrypto": "1.18.42",
-    "@ocap/wallet": "1.18.42",
+    "@ocap/mcrypto": "1.18.56",
+    "@ocap/wallet": "1.18.56",
     "axios": "^0.27.2",
     "fs-extra": "^10.1.0",
     "joi": "17.7.0",
+    "jsdom": "^21.1.0",
     "json-stable-stringify": "^1.0.1",
     "lodash": "^4.17.21",
     "lru-cache": "^6.0.0",
+    "ufo": "^1.1.1",
     "url-join": "^4.0.1"
   },
   "resolutions": {
@@ -61,12 +64,11 @@
     "detect-port": "^1.5.1",
     "eslint": "^8.25.0",
     "jest": "^29.2.0",
-    "joi-to-typescript": "^4.0.6",
+    "joi-to-typescript": "^4.0.7",
     "json-stable-stringify": "^1.0.1",
     "prettier": "^2.7.1",
     "ts-jest": "^29.0.3",
     "ts-node": "^10.9.1",
     "typescript": "^4.8.4"
-  },
-  "gitHead": "282247fd0ce6702e1d6920e90e2b3be0408cf879"
+  }
 }