@blocklet/sdk 1.15.17 → 1.16.0-beta-8ee536d7

package/lib/validators/notification.js

@@ -1,79 +1,237 @@
-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.dappSchema = exports.imageSchema = exports.linkSchema = exports.textSchema = exports.transactionSchema = 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',
+    NOTIFICATION: 'notification',
+    CONNECT: 'connect',
+    FEED: 'feed',
+    HI: 'hi',
+};
+exports.NOTIFICATION_TYPES = TYPES;
+const SEVERITIES = {
+    NORMAL: 'normal',
+    SUCCESS: 'success',
+    ERROR: 'error',
+    WARNING: 'warning',
+};
+const ATTACHMENT_TYPES = {
+    ASSET: 'asset',
+    VC: 'vc',
+    TOKEN: 'token',
+    TEXT: 'text',
+    IMAGE: 'image',
+    DIVIDER: 'divider',
+    TRANSACTION: 'transaction',
+    DAPP: 'dapp',
+    LINK: 'link',
+    SECTION: 'section',
 };
-
 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 textSchema = Joi.object({
+    type: Joi.string().required(),
+    text: Joi.string().required(),
+    color: Joi.string().min(0),
+    size: Joi.string().valid('small', 'normal', 'big'),
+})
+    .required()
+    .meta({ className: 'TDataText' });
+exports.textSchema = textSchema;
+const imageSchema = Joi.object({
+    url: Joi.string().uri().required(),
+    alt: Joi.string().min(0),
+})
+    .required()
+    .meta({ className: 'TDataImage' });
+exports.imageSchema = imageSchema;
+const transactionSchema = Joi.object({
+    hash: Joi.string().required(),
+    chainId: Joi.string().required(),
+})
+    .required()
+    .meta({ className: 'TDataTransaction' });
+exports.transactionSchema = transactionSchema;
+const dappSchema = Joi.object({
+    url: Joi.string().uri().required(),
+    appDID: Joi.DID().trim().required(),
+    logo: Joi.string().uri().required(),
+    title: Joi.string().required(),
+    desc: Joi.string().min(0),
+})
+    .required()
+    .meta({ className: 'TDataDapp' });
+exports.dappSchema = dappSchema;
+const linkSchema = Joi.object({
+    url: Joi.string().uri().required(),
+    description: Joi.string().min(0),
+    title: Joi.string().min(0),
+    image: Joi.string().uri().min(0),
+})
+    .required()
+    .meta({ className: 'TDataLink' });
+exports.linkSchema = linkSchema;
 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()
+        .valid(...Object.values(ATTACHMENT_TYPES))
+        .required(),
+    data: Joi.when('type', {
+        switch: [
+            { is: ATTACHMENT_TYPES.ASSET, then: assetSchema },
+            { is: ATTACHMENT_TYPES.VC, then: vcSchema },
+            { is: ATTACHMENT_TYPES.TOKEN, then: tokenSchema },
+            { is: ATTACHMENT_TYPES.TEXT, then: textSchema },
+            { is: ATTACHMENT_TYPES.IMAGE, then: imageSchema },
+            { is: ATTACHMENT_TYPES.TRANSACTION, then: transactionSchema },
+            { is: ATTACHMENT_TYPES.DAPP, then: dappSchema },
+            { is: ATTACHMENT_TYPES.LINK, then: linkSchema },
+            { is: ATTACHMENT_TYPES.DIVIDER, then: Joi.object({}) },
+        ],
+    }),
+    fields: Joi.when('type', {
+        is: ATTACHMENT_TYPES.SECTION,
+        then: Joi.array().items(Joi.object({
+            type: Joi.string().valid(ATTACHMENT_TYPES.TEXT).required(),
+            data: textSchema,
+        })),
+    }),
+}).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(),
+    severity: Joi.string().valid(...Object.values(SEVERITIES)),
+    blocks: Joi.array().items(attachmentSchema).default([]),
+    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();
-
-const notificationSchema = Joi.alternatives().try(notificationTypeSchema, connectTypeSchema).required();
-
-const receiverSchema = Joi.DID().trim().required();
-
-const inputNotificationSchema = Joi.alternatives()
-  .try(Joi.array().items(notificationSchema), notificationSchema)
-  .required();
-
-const inputReceiverSchema = Joi.alternatives().try(Joi.array().items(receiverSchema), receiverSchema).required();
-
-module.exports = {
-  validateReceiver: inputReceiverSchema.validateAsync.bind(inputReceiverSchema),
-  validateNotification: inputNotificationSchema.validateAsync.bind(inputNotificationSchema),
-  tokenSchema,
-  actionSchema,
-  assetSchema,
-  vcSchema,
-  attachmentSchema,
+    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()
+    .meta({ className: 'TNotificationFeed' });
+exports.feedTypeSchema = feedTypeSchema;
+const notificationSchema = Joi.object({
+    type: Joi.string().valid(...Object.values(TYPES)),
+    // feed type
+    feedType: Joi.string(),
+    data: Joi.object(),
+    // connect type
+    url: Joi.string().uri(),
+    checkUrl: Joi.string(),
+    // notification type
+    title: Joi.string(),
+    body: Joi.string(),
+    severity: Joi.string().valid(...Object.values(SEVERITIES)),
+    blocks: Joi.array().items(attachmentSchema).default([]),
+    attachments: Joi.array().items(attachmentSchema).default([]),
+    actions: Joi.array().items(actionSchema).default([]),
+})
+    .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(),
+})
+    .unknown()
+    .required()
+    .meta({ className: 'TMessage', unknownType: 'any' });
+exports.messageSchema = messageSchema;
+const receiverSchema = Joi.DID().trim().required().meta({ className: 'TReceiver' });
+const inputNotificationSchema = Joi.array()
+    .items(notificationSchema)
+    .single()
+    .required()
+    .meta({ className: 'TNotificationInput' });
+exports.inputNotificationSchema = inputNotificationSchema;
+const inputReceiverSchema = Joi.array().items(receiverSchema).single().required().meta({ className: 'TReceiverInput' });
+const optionSchema = Joi.object({
+    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,
+    transactionSchema,
+    textSchema,
+    linkSchema,
+    imageSchema,
+    dappSchema,
+    attachmentSchema,
+    notificationSchema,
+    messageSchema,
+    optionSchema,
+    channelEventSchema,
+    NOTIFICATION_TYPES: TYPES,
 };

package/lib/version.d.ts

@@ -0,0 +1,6 @@
+declare const version = "1.16.0";
+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.16.0';
+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,53 +1,18 @@
-const joinUrl = require('url-join');
-const { WalletAuthenticator: Authenticator } = require('@arcblock/did-auth');
-const { fromSecretKey, WalletType } = require('@ocap/wallet');
-const { types } = require('@ocap/mcrypto');
-
-const checkBlockletEnv = require('./util/check-blocklet-env');
-const { AUTH_SERVICE_PREFIX } = require('./util/constants');
-
-const type =
-  process.env.BLOCKLET_WALLET_TYPE !== 'eth'
-    ? WalletType({ role: types.RoleType.ROLE_APPLICATION, pk: types.KeyType.ED25519, hash: types.HashType.SHA3 })
-    : 'eth';
-
-// wraps value in closure or returns closure
-const closure = (value) => (typeof value === 'function' ? value : () => value);
-
-class WalletAuthenticator extends Authenticator {
-  constructor(options = {}) {
-    checkBlockletEnv();
-
-    super({
-      wallet: fromSecretKey(process.env.BLOCKLET_APP_SK, type).toJSON(),
-
-      chainInfo: () => {
-        const chainHost = process.env.CHAIN_HOST;
-        return chainHost ? { host: chainHost, id: 'chain' } : { host: 'none', id: 'none' };
-      },
-
-      ...options,
-
-      appInfo: async (...args) => {
-        const info = await closure(options.appInfo)(...args);
-
-        const { request, baseUrl } = args[0];
-        const groupPathPrefix = request.headers['x-group-path-prefix'] || '/';
-        const blockletDid = request.headers['x-blocklet-did'];
-
-        return {
-          name: process.env.BLOCKLET_APP_NAME,
-          description: process.env.BLOCKLET_APP_DESCRIPTION,
-          ...(info || {}),
-          link: baseUrl,
-          icon: joinUrl(baseUrl, AUTH_SERVICE_PREFIX, `/blocklet/logo/${blockletDid}`),
-          updateSubEndpoint: true,
-          subscriptionEndpoint: joinUrl(groupPathPrefix, AUTH_SERVICE_PREFIX, 'websocket'),
-          nodeDid: process.env.ABT_NODE_DID,
-        };
-      },
-    });
-  }
+"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 = require("./connect/shared");
+class WalletAuthenticator extends did_auth_1.WalletAuthenticator {
+    constructor(options = {}) {
+        (0, check_blocklet_env_1.default)();
+        super({
+            wallet: (0, wallet_1.default)().toJSON(),
+            ...(0, shared_1.getAuthenticatorProps)(options),
+        });
+    }
 }
-
 module.exports = WalletAuthenticator;

package/lib/wallet-handler.d.ts

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

package/lib/wallet-handler.js

@@ -1,96 +1,118 @@
-const get = require('lodash/get');
-const { WalletHandlers: Handler } = require('@arcblock/did-auth');
-const Notification = require('./service/notification');
-
+"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 };
+};
+const get_1 = __importDefault(require("lodash/get"));
+const did_auth_1 = require("@arcblock/did-auth");
+const notification_1 = __importStar(require("./service/notification"));
 const noop = () => ({});
-
 const CONNECTED_DID_KEY = 'headers[x-connected-did]';
-
 // whether app web page is in mobile DID wallet
-const inMobileWallet = (abtwallet) => {
-  return abtwallet && ['ios', 'android'].includes(abtwallet.os);
+const inMobileWallet = (didwallet) => {
+    return didwallet && ['ios', 'android'].includes(didwallet.os);
 };
-
-class WalletHandlers extends Handler {
-  /**
-   * @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 = true, connectedDidOnly = false, sendNotificationFn, options = {}, ...opts }) {
-    if (autoConnect && connectedDidOnly) {
-      options.sessionDidKey = CONNECTED_DID_KEY;
-    }
-
-    super({ options, ...opts });
-
-    this.enableConnect = !!autoConnect;
-    this.sendNotificationFn = sendNotificationFn || Notification.sendToUser.bind(Notification);
-  }
-
-  getConnectedDid = ({ req, abtwallet, extraParams }) => {
-    if (extraParams && extraParams.autoConnect === 'false') {
-      return null;
-    }
-
-    if (!this.enableConnect) {
-      return null;
-    }
-
-    if (inMobileWallet(abtwallet)) {
-      return null;
+class WalletHandlers extends did_auth_1.WalletHandlers {
+    /**
+     * @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 = 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;
+            }
+            if (!this.enableConnect) {
+                return null;
+            }
+            if (inMobileWallet(didwallet)) {
+                return null;
+            }
+            return (0, get_1.default)(req, CONNECTED_DID_KEY);
+        };
+        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);
+        });
     }
-
-    return get(req, CONNECTED_DID_KEY);
-  };
-
-  attach({ onStart = noop, ...opts }) {
-    const _onStart = async (params) => {
-      const extra = (await onStart(params)) || {};
-
-      const connectedDid = this.getConnectedDid(params);
-
-      // fill extra
-      extra.connectedDid = connectedDid || '';
-      extra.saveConnect = this.enableConnect;
-
-      // send notification to wallet to trigger wallet to auto connect
-      if (connectedDid) {
-        // wallet use check url to check status of the session
-        let checkUrl = '';
-        try {
-          checkUrl = new URL(decodeURIComponent(new URL(params.deepLink).searchParams.get('url')));
-          checkUrl.pathname = checkUrl.pathname.replace(/auth$/, 'status');
-        } catch (e) {
-          checkUrl = '';
-          console.error(e);
-        }
-
-        const message = {
-          type: 'connect',
-          url: params.deepLink,
+    attach({ onStart = noop, ...opts }) {
+        const realOnStart = async (params) => {
+            // @ts-expect-error TS(2554) FIXME: Expected 0 arguments, but got 1.
+            const extra = (await onStart(params)) || {};
+            const connectedDid = this.getConnectedDid(params);
+            // fill extra
+            extra.connectedDid = connectedDid || '';
+            extra.saveConnect = this.enableConnect;
+            // send notification to wallet to trigger wallet to auto connect
+            if (connectedDid) {
+                // wallet use check url to check status of the session
+                let checkUrl;
+                try {
+                    checkUrl = new URL(decodeURIComponent(new URL(params.deepLink).searchParams.get('url')));
+                    checkUrl.pathname = checkUrl.pathname.replace(/auth$/, 'status');
+                }
+                catch (e) {
+                    checkUrl = '';
+                    console.error(e);
+                }
+                const message = {
+                    type: 'connect',
+                    url: params.deepLink,
+                };
+                if (checkUrl) {
+                    message.checkUrl = checkUrl.href;
+                }
+                // sendNotificationFn maybe custom function so we need params
+                this.sendNotificationFn(connectedDid, message, params).catch((err) => {
+                    console.error(err);
+                    if (typeof opts.onError === 'function') {
+                        opts.onError(err);
+                    }
+                });
+            }
+            return extra;
         };
-
-        if (checkUrl) {
-          message.checkUrl = checkUrl.href;
-        }
-
-        this.sendNotificationFn(connectedDid, message, params).catch((err) => {
-          console.error(err);
-          if (typeof opts.onError === 'function') {
-            opts.onError(err);
-          }
+        // @ts-expect-error TS(2345) FIXME: Argument of type '{ onStart: (params: any) => Prom... Remove this comment to see the full error message
+        super.attach({
+            onStart: realOnStart,
+            ...opts,
         });
-      }
-
-      return extra;
-    };
-
-    super.attach({
-      onStart: _onStart,
-      ...opts,
-    });
-  }
+    }
 }
-
 module.exports = WalletHandlers;

package/lib/wallet.d.ts

@@ -0,0 +1,9 @@
+import { WalletObject } from '@ocap/wallet';
+import { DIDTypeShortcut } from '@arcblock/did';
+/**
+ * @param {string} [type=process.env.BLOCKLET_WALLET_TYPE] can only be 'eth|ethereum' or 'default|arcblock'
+ * @param {string} [appSk=process.env.BLOCKLET_APP_SK] must be hex
+ * @return {WalletObject}  {WalletObject}
+ */
+declare const getWallet: (type?: DIDTypeShortcut, appSk?: string) => WalletObject;
+export = getWallet;

package/lib/wallet.js

@@ -0,0 +1,23 @@
+"use strict";
+const wallet_1 = require("@ocap/wallet");
+const mcrypto_1 = require("@ocap/mcrypto");
+const did_1 = require("@arcblock/did");
+/**
+ * @param {string} [type=process.env.BLOCKLET_WALLET_TYPE] can only be 'eth|ethereum' or 'default|arcblock'
+ * @param {string} [appSk=process.env.BLOCKLET_APP_SK] must be hex
+ * @return {WalletObject}  {WalletObject}
+ */
+const getWallet = (type = process.env.BLOCKLET_WALLET_TYPE, appSk = process.env.BLOCKLET_APP_SK) => {
+    let t;
+    let sk;
+    if ((0, did_1.isEthereumType)((0, did_1.DidType)(type))) {
+        sk = appSk.slice(0, 66);
+        t = (0, wallet_1.WalletType)(type);
+    }
+    else {
+        sk = appSk;
+        t = (0, wallet_1.WalletType)({ role: mcrypto_1.types.RoleType.ROLE_APPLICATION, pk: mcrypto_1.types.KeyType.ED25519, hash: mcrypto_1.types.HashType.SHA3 });
+    }
+    return (0, wallet_1.fromSecretKey)(sk, t);
+};
+module.exports = getWallet;