@blocklet/sdk 1.8.32 → 1.8.34

package/lib/util/send-notification.js

@@ -1,21 +1,53 @@
-/* eslint-disable global-require */
-const axios = require('axios').create({ proxy: false });
-const pick = require('lodash/pick');
-
-const JWT = require('@arcblock/jwt');
-const { NODE_MODES } = require('@abtnode/constant');
-
-const validators = require('../validators');
-const { SERVICE_PREFIX } = require('./constants');
-
-const VERSION = require('../../package.json').version; // version of notification sdk
-
-const { validateNotification, validateReceiver, validateOption, validateChannelEvent } = validators;
-
+"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 __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;
+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 index_1 = require("../validators/index");
+const constants_1 = require("./constants");
+const version_1 = require("../version");
+const axios = axios_1.default.create({ proxy: false });
+const { NODE_MODES } = constant_1.default;
+const VERSION = version_1.version; // version of notification sdk
 const SERVER_MODE = process.env.ABT_NODE_MODE;
-
 const getRequestHeaders = () => ({ 'User-Agent': `BlockletSDK/${VERSION}` });
-
 /**
  * @param {String|Array} receiver
  * @param {Object} notification
@@ -27,103 +59,74 @@ const getRequestHeaders = () => ({ 'User-Agent': `BlockletSDK/${VERSION}` });
  * @param {Object} options
  * @returns
  */
-const sendToUser = async (
-  receiver,
-  notification,
-  { appDid, appSk } = {},
-  port = process.env.ABT_NODE_SERVICE_PORT,
-  options = {}
-) => {
-  await validateReceiver(receiver);
-
-  const opt = pick(options, ['keepForOfflineUser']);
-  await validateOption(opt);
-
-  if (SERVER_MODE !== NODE_MODES.DEBUG) {
-    await validateNotification(notification);
-  }
-
-  try {
-    const { data: res } = await axios.post(
-      `http://127.0.0.1:${port}${SERVICE_PREFIX}/api/send-to-user`,
-      {
-        apiVersion: VERSION,
-        data: {
-          sender: { appDid, token: JWT.sign(appDid, appSk) },
-          receiver,
-          notification,
-          options: opt,
-        },
-      },
-      {
-        timeout: 60 * 1000,
-        headers: getRequestHeaders(),
-      }
-    );
-
-    return res;
-  } catch (error) {
-    console.error(error);
-    throw new Error(error.response ? error.response.statusText : error.message);
-  }
-};
-
-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');
-  }
-
-  await validateChannelEvent(event);
-
-  const opt = pick(options, ['socketId', 'userDid']);
-
-  if (opt.userDid) {
-    opt.socketDid = opt.userDid;
-    delete opt.userDid;
-  }
-
-  if (SERVER_MODE !== NODE_MODES.DEBUG) {
-    await validateNotification(notification);
-  }
-
-  try {
-    const { data: res } = await axios.post(
-      `http://127.0.0.1:${port}${SERVICE_PREFIX}/api/send-to-app-channel`,
-      {
-        apiVersion: VERSION,
-        data: {
-          sender: { appDid, token: JWT.sign(appDid, appSk) },
-          channel,
-          event,
-          notification,
-          options: opt,
-        },
-      },
-      {
-        timeout: 60 * 1000,
-        headers: getRequestHeaders(),
-      }
-    );
-
-    return res;
-  } catch (error) {
-    console.error(error);
-    throw new Error(error.response ? error.response.statusText : error.message);
-  }
-};
-
-module.exports = {
-  sendToUser,
-  sendToAppChannel,
+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 opt = (0, pick_1.default)(options, ['keepForOfflineUser']);
+    yield (0, index_1.validateOption)(opt);
+    if (SERVER_MODE !== NODE_MODES.DEBUG) {
+        yield (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`, {
+            apiVersion: VERSION,
+            data: {
+                sender: { appDid, token: JWT.sign(appDid, appSk) },
+                receiver,
+                notification,
+                options: opt,
+            },
+        }, {
+            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.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* () {
+    if (!channel) {
+        throw new Error('channel is required');
+    }
+    if (!event) {
+        throw new Error('event is required');
+    }
+    yield (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
+        opt.socketDid = opt.userDid;
+        delete opt.userDid;
+    }
+    if (SERVER_MODE !== NODE_MODES.DEBUG) {
+        yield (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`, {
+            apiVersion: VERSION,
+            data: {
+                sender: { appDid, token: JWT.sign(appDid, appSk) },
+                channel,
+                event,
+                notification,
+                options: opt,
+            },
+        }, {
+            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.sendToAppChannel = sendToAppChannel;
+exports.default = {
+    sendToUser,
+    sendToAppChannel,
 };

package/lib/validators/index.d.ts

@@ -0,0 +1,12 @@
+import { validateNotification, validateReceiver, validateOption, validateChannelEvent } from './notification';
+export { validateNotification };
+export { validateReceiver };
+export { validateOption };
+export { validateChannelEvent };
+declare const _default: {
+    validateNotification: any;
+    validateReceiver: any;
+    validateOption: any;
+    validateChannelEvent: any;
+};
+export default _default;

package/lib/validators/index.js

@@ -1,8 +1,14 @@
-const { validateNotification, validateReceiver, validateOption, validateChannelEvent } = require('./notification');
-
-module.exports = {
-  validateNotification,
-  validateReceiver,
-  validateOption,
-  validateChannelEvent,
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateChannelEvent = exports.validateOption = exports.validateReceiver = exports.validateNotification = void 0;
+const notification_1 = require("./notification");
+Object.defineProperty(exports, "validateNotification", { enumerable: true, get: function () { return notification_1.validateNotification; } });
+Object.defineProperty(exports, "validateReceiver", { enumerable: true, get: function () { return notification_1.validateReceiver; } });
+Object.defineProperty(exports, "validateOption", { enumerable: true, get: function () { return notification_1.validateOption; } });
+Object.defineProperty(exports, "validateChannelEvent", { enumerable: true, get: function () { return notification_1.validateChannelEvent; } });
+exports.default = {
+    validateNotification: notification_1.validateNotification,
+    validateReceiver: notification_1.validateReceiver,
+    validateOption: notification_1.validateOption,
+    validateChannelEvent: notification_1.validateChannelEvent,
 };

package/lib/validators/notification.d.ts

@@ -0,0 +1,59 @@
+import JOI from 'joi';
+declare const TYPES: {
+    NOTIFICATION: string;
+    CONNECT: string;
+    FEED: string;
+    HI: string;
+};
+declare const assetSchema: JOI.ObjectSchema<any>;
+declare const vcSchema: JOI.ObjectSchema<any>;
+declare const tokenSchema: JOI.ObjectSchema<any>;
+declare const actionSchema: JOI.ObjectSchema<any>;
+declare const attachmentSchema: JOI.ObjectSchema<any>;
+declare const notificationTypeSchema: JOI.ObjectSchema<any>;
+declare const connectTypeSchema: JOI.ObjectSchema<any>;
+declare const feedTypeSchema: JOI.ObjectSchema<any>;
+declare const notificationSchema: JOI.AlternativesSchema<any>;
+declare const messageSchema: JOI.ObjectSchema<any>;
+declare const inputNotificationSchema: JOI.AlternativesSchema<any>;
+declare const optionSchema: JOI.ObjectSchema<any>;
+declare const channelEventSchema: JOI.StringSchema<string>;
+export declare const validateReceiver: any;
+export declare const validateNotification: any;
+export declare const validateMessage: any;
+export declare const validateChannelEvent: any;
+export declare const validateOption: any;
+export { tokenSchema };
+export { actionSchema };
+export { assetSchema };
+export { vcSchema };
+export { attachmentSchema };
+export { notificationSchema };
+export { messageSchema };
+export { optionSchema };
+export { channelEventSchema };
+export { TYPES as NOTIFICATION_TYPES };
+export { inputNotificationSchema, notificationTypeSchema, connectTypeSchema, feedTypeSchema };
+declare const _default: {
+    validateReceiver: any;
+    validateNotification: any;
+    validateMessage: any;
+    validateChannelEvent: any;
+    validateOption: any;
+    tokenSchema: JOI.ObjectSchema<any>;
+    actionSchema: JOI.ObjectSchema<any>;
+    assetSchema: JOI.ObjectSchema<any>;
+    vcSchema: JOI.ObjectSchema<any>;
+    attachmentSchema: JOI.ObjectSchema<any>;
+    notificationSchema: JOI.AlternativesSchema<any>;
+    messageSchema: JOI.ObjectSchema<any>;
+    optionSchema: JOI.ObjectSchema<any>;
+    channelEventSchema: JOI.StringSchema<string>;
+    NOTIFICATION_TYPES: {
+        NOTIFICATION: string;
+        CONNECT: string;
+        FEED: string;
+        HI: string;
+    };
+};
+export default _default;

package/lib/validators/notification.js

@@ -1,112 +1,142 @@
-const JOI = require('joi');
-
-const { didExtension } = require('@blocklet/meta/lib/extension');
-
-const Joi = JOI.extend(didExtension);
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.feedTypeSchema = exports.connectTypeSchema = exports.notificationTypeSchema = exports.inputNotificationSchema = exports.NOTIFICATION_TYPES = exports.channelEventSchema = exports.optionSchema = exports.messageSchema = exports.notificationSchema = exports.attachmentSchema = exports.vcSchema = exports.assetSchema = exports.actionSchema = exports.tokenSchema = exports.validateOption = exports.validateChannelEvent = exports.validateMessage = exports.validateNotification = exports.validateReceiver = void 0;
+const joi_1 = __importDefault(require("joi"));
+const extension_1 = require("@blocklet/meta/lib/extension");
+const Joi = joi_1.default.extend(extension_1.didExtension);
 const TYPES = {
-  NOTIFICATION: 'notification',
-  CONNECT: 'connect',
-  FEED: 'feed',
-  HI: 'hi',
+    NOTIFICATION: 'notification',
+    CONNECT: 'connect',
+    FEED: 'feed',
+    HI: 'hi',
 };
-
+exports.NOTIFICATION_TYPES = TYPES;
 const assetSchema = Joi.object({
-  did: Joi.DID().trim().required(),
-  chainHost: Joi.string().uri().required(),
-}).required();
-
+    did: Joi.DID().trim().required(),
+    chainHost: Joi.string().uri().required(),
+})
+    .required()
+    .meta({ className: 'TDataAsset' });
+exports.assetSchema = assetSchema;
 const vcSchema = Joi.object({
-  credential: Joi.object().required().unknown(true),
-  tag: Joi.string(),
-}).required();
-
+    credential: Joi.object().required().unknown(true),
+    tag: Joi.string(),
+})
+    .required()
+    .meta({ className: 'TDataVC', unknownType: 'any' });
+exports.vcSchema = vcSchema;
 const tokenSchema = Joi.object({
-  address: Joi.DID().trim().allow(''),
-  amount: Joi.string().required(),
-  symbol: Joi.string().required(),
-  senderDid: Joi.DID().trim().required(),
-  chainHost: Joi.string().uri().required(),
-  decimal: Joi.number().integer().required(),
-}).required();
-
+    address: Joi.DID().trim().allow(''),
+    amount: Joi.string().required(),
+    symbol: Joi.string().required(),
+    senderDid: Joi.DID().trim().required(),
+    chainHost: Joi.string().uri().required(),
+    decimal: Joi.number().integer().required(),
+})
+    .required()
+    .meta({ className: 'TDataToken' });
+exports.tokenSchema = tokenSchema;
 const actionSchema = Joi.object({
-  name: Joi.string().required(),
-  title: Joi.string(),
-  color: Joi.string(),
-  bgColor: Joi.string(),
-  link: Joi.string().uri(),
-});
-
+    name: Joi.string().required(),
+    title: Joi.string(),
+    color: Joi.string(),
+    bgColor: Joi.string(),
+    link: Joi.string().uri(),
+}).meta({ className: 'TNotificationAction' });
+exports.actionSchema = actionSchema;
 const attachmentSchema = Joi.object({
-  type: Joi.string().required().valid('asset', 'vc', 'token'),
-  data: Joi.object()
-    .when('type', { is: 'asset', then: assetSchema })
-    .concat(Joi.object().when('type', { is: 'vc', then: vcSchema }))
-    .concat(Joi.object().when('type', { is: 'token', then: tokenSchema })),
-}).required();
-
+    type: Joi.string().required().valid('asset', 'vc', 'token'),
+    data: Joi.object()
+        .when('type', { is: 'asset', then: assetSchema })
+        .concat(Joi.object().when('type', { is: 'vc', then: vcSchema }))
+        .concat(Joi.object().when('type', { is: 'token', then: tokenSchema })),
+})
+    .required()
+    .meta({ className: 'TNotificationAttachment' });
+exports.attachmentSchema = attachmentSchema;
 const notificationTypeSchema = Joi.object({
-  type: Joi.string().valid(TYPES.NOTIFICATION),
-  title: Joi.string(),
-  body: Joi.string(),
-  attachments: Joi.array().items(attachmentSchema).default([]),
-  actions: Joi.array().items(actionSchema).default([]),
-}).required();
-
+    type: Joi.string().valid(TYPES.NOTIFICATION),
+    title: Joi.string(),
+    body: Joi.string(),
+    attachments: Joi.array().items(attachmentSchema).default([]),
+    actions: Joi.array().items(actionSchema).default([]),
+})
+    .required()
+    .meta({ className: 'TNotificationItem' });
+exports.notificationTypeSchema = notificationTypeSchema;
 const connectTypeSchema = Joi.object({
-  type: Joi.string().valid(TYPES.CONNECT),
-  url: Joi.string().uri().required(),
-  checkUrl: Joi.string().uri(),
-}).required();
-
+    type: Joi.string().valid(TYPES.CONNECT),
+    url: Joi.string().uri().required(),
+    checkUrl: Joi.string().uri(),
+})
+    .required()
+    .meta({ className: 'TNotificationConnect' });
+exports.connectTypeSchema = connectTypeSchema;
 const feedTypeSchema = Joi.object({
-  type: Joi.string().valid(TYPES.FEED),
-  feedType: Joi.string().required(),
-  data: Joi.object().required(),
-}).required();
-
-const notificationSchema = Joi.alternatives().try(notificationTypeSchema, connectTypeSchema, feedTypeSchema).required();
-
+    type: Joi.string().valid(TYPES.FEED),
+    feedType: Joi.string().required(),
+    data: Joi.object().required(),
+})
+    .required()
+    .meta({ className: 'TNotificationFeed' });
+exports.feedTypeSchema = feedTypeSchema;
+const notificationSchema = Joi.alternatives()
+    .try(notificationTypeSchema, connectTypeSchema, feedTypeSchema)
+    .required()
+    .meta({ className: 'TNotification' });
+exports.notificationSchema = notificationSchema;
 const messageSchema = Joi.object({
-  id: Joi.string().required(),
-  createdAt: Joi.date().iso().required(),
-  type: Joi.string().required(),
-  receiver: Joi.object({
-    did: Joi.DID().trim().required(),
-  }).required(),
+    id: Joi.string().required(),
+    createdAt: Joi.date().iso().required(),
+    type: Joi.string().required(),
+    receiver: Joi.object({
+        did: Joi.DID().trim().required(),
+    }).required(),
 })
-  .unknown()
-  .required();
-
-const receiverSchema = Joi.DID().trim().required();
-
+    .unknown()
+    .required()
+    .meta({ className: 'TMessage', unknownType: 'any' });
+exports.messageSchema = messageSchema;
+const receiverSchema = Joi.DID().trim().required().meta({ className: 'TReceiver' });
 const inputNotificationSchema = Joi.alternatives()
-  .try(Joi.array().items(notificationSchema), notificationSchema)
-  .required();
-
-const inputReceiverSchema = Joi.alternatives().try(Joi.array().items(receiverSchema), receiverSchema).required();
-
+    .try(Joi.array().items(notificationSchema), notificationSchema)
+    .required()
+    .meta({ className: 'TNotificationInput' });
+exports.inputNotificationSchema = inputNotificationSchema;
+const inputReceiverSchema = Joi.alternatives()
+    .try(Joi.array().items(receiverSchema), receiverSchema)
+    .required()
+    .meta({ className: 'TReceiverInput' });
 const optionSchema = Joi.object({
-  keepForOfflineUser: Joi.boolean(),
-}).unknown();
-
-const channelEventSchema = Joi.string().required();
-
-module.exports = {
-  validateReceiver: inputReceiverSchema.validateAsync.bind(inputReceiverSchema),
-  validateNotification: inputNotificationSchema.validateAsync.bind(inputNotificationSchema),
-  validateMessage: messageSchema.validateAsync.bind(messageSchema),
-  validateChannelEvent: channelEventSchema.validateAsync.bind(channelEventSchema),
-  validateOption: optionSchema.validateAsync.bind(optionSchema),
-  tokenSchema,
-  actionSchema,
-  assetSchema,
-  vcSchema,
-  attachmentSchema,
-  notificationSchema,
-  messageSchema,
-  optionSchema,
-  channelEventSchema,
-  NOTIFICATION_TYPES: TYPES,
+    keepForOfflineUser: Joi.boolean(),
+})
+    .unknown()
+    .meta({ className: 'TSendOptions', unknownType: 'any' });
+exports.optionSchema = optionSchema;
+const channelEventSchema = Joi.string().required().meta({ className: 'TChannelEvent' });
+exports.channelEventSchema = channelEventSchema;
+exports.validateReceiver = inputReceiverSchema.validateAsync.bind(inputReceiverSchema);
+exports.validateNotification = inputNotificationSchema.validateAsync.bind(inputNotificationSchema);
+exports.validateMessage = messageSchema.validateAsync.bind(messageSchema);
+exports.validateChannelEvent = channelEventSchema.validateAsync.bind(channelEventSchema);
+exports.validateOption = optionSchema.validateAsync.bind(optionSchema);
+exports.default = {
+    validateReceiver: exports.validateReceiver,
+    validateNotification: exports.validateNotification,
+    validateMessage: exports.validateMessage,
+    validateChannelEvent: exports.validateChannelEvent,
+    validateOption: exports.validateOption,
+    tokenSchema,
+    actionSchema,
+    assetSchema,
+    vcSchema,
+    attachmentSchema,
+    notificationSchema,
+    messageSchema,
+    optionSchema,
+    channelEventSchema,
+    NOTIFICATION_TYPES: TYPES,
 };

package/lib/version.d.ts

@@ -0,0 +1,6 @@
+declare const version = "1.8.34";
+export { version };
+declare const _default: {
+    version: string;
+};
+export default _default;

package/lib/version.js

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

package/lib/wallet-authenticator.d.ts

@@ -0,0 +1,5 @@
+import { WalletAuthenticator as Authenticator } from '@arcblock/did-auth';
+declare class WalletAuthenticator extends Authenticator {
+    constructor(options?: {});
+}
+export = WalletAuthenticator;

package/lib/wallet-authenticator.js

@@ -1,18 +1,15 @@
-const { WalletAuthenticator: Authenticator } = require('@arcblock/did-auth');
-
-const getWallet = require('./wallet');
-const checkBlockletEnv = require('./util/check-blocklet-env');
-const getShared = require('./connect/shared');
-
-class WalletAuthenticator extends Authenticator {
-  constructor(options = {}) {
-    checkBlockletEnv();
-
-    super({
-      wallet: getWallet().toJSON(),
-      ...getShared(options),
-    });
-  }
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const did_auth_1 = require("@arcblock/did-auth");
+const wallet_1 = __importDefault(require("./wallet"));
+const check_blocklet_env_1 = __importDefault(require("./util/check-blocklet-env"));
+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)));
+    }
 }
-
 module.exports = WalletAuthenticator;

package/lib/wallet-handler.d.ts

@@ -0,0 +1,17 @@
+import { WalletHandlers as Handler } from '@arcblock/did-auth';
+declare class WalletHandlers extends Handler {
+    enableConnect: boolean;
+    sendNotificationFn: $TSFixMe;
+    /**
+     * @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
+     */
+    constructor({ autoConnect, connectedDidOnly, sendNotificationFn, options, ...opts }: $TSFixMe);
+    getConnectedDid: ({ req, didwallet, extraParams }: $TSFixMe) => any;
+    attach({ onStart, ...opts }: {
+        [x: string]: any;
+        onStart?: () => {};
+    }): void;
+}
+export = WalletHandlers;