@arcblock/did 1.16.16 → 1.16.17

package/lib/index.d.ts

@@ -1,110 +1,57 @@
-// Generate by [js2dts@0.3.3](https://github.com/whxaxes/js2dts#readme)
-
+import { types } from '@ocap/mcrypto';
+import { toAddress, toDid, BytesType } from '@ocap/util';
+import { DidType, DIDType, DIDTypeStr, DIDTypeArg, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, fromTypeInfo, isEthereumDid, isEthereumType, toTypeInfo, toTypeInfoStr } from './type';
+import { toStrictHex } from './util';
 /**
- * Ensure the hex length is even number, 2, 4, 6, 8
+ * Gen DID from private key and type config
  *
- * @param {string} hex
- * @param {number} length
- * @returns {string} hex
- */
-declare function toStrictHex(hex: string, length: number): string;
-/**
- * Convert did to address: remove `did:abt:` prefix
+ * Spec: https://github.com/ArcBlock/ABT-DID-Protocol#create-did
  *
  * @public
  * @static
- * @param {string} did - address string
- * @returns {string}
+ * @param {string} sk - hex encoded secret key string
+ * @param {object} type - wallet type, {@see @ocap/wallet#WalletType}
+ * @returns {string} DID string
  */
-declare function toAddress(did: string): string;
+declare const fromSecretKey: (sk: BytesType, type?: DIDTypeArg) => string;
 /**
- * Convert address to did: prepend `did:abt:` prefix
+ * Gen DID from public key and type config
  *
  * @public
  * @static
- * @param {string} did - address string
- * @returns {string}
+ * @param {string} pk - hex encoded public key
+ * @param {object} type - wallet type, {@see @ocap/wallet#WalletType}
+ * @returns {string} DID string
  */
-declare function toDid(address: any): string;
+declare const fromPublicKey: (pk: BytesType, type?: DIDTypeArg) => string;
+declare const fromPublicKeyHash: (buffer: string, type: DIDTypeArg) => string;
 /**
- * Checks if the given string is an address
- *
- * @method isEthereumDid
- * @param {String} address the given HEX address
- * @return {Boolean}
- */
-declare function isEthereumDid(did: any): boolean;
-declare function isEthereumType(type: any): any;
-/**
- * Get type info from did (base58 format)
+ * Gen DID from an hex encoded hash and role type
  *
  * @public
  * @static
- * @param {string} did - address string
- * @param {boolean} [returnString=true]
- * @returns {object} wallet type {@see @arcblock/did#DidType}
+ * @param {string} hash - hex encoded hash
+ * @param {enum} role - role type, {@see @ocap/mcrypto#types}
+ * @returns {string} DID string
  */
-declare function toTypeInfo(did: string, returnString?: boolean): object;
+declare const fromHash: (hash: string, role?: number) => string;
 /**
- * Convert type info object to hex string
+ * Check if an DID is generated from a publicKey
  *
  * @public
  * @static
- * @param {object} type - wallet type, {@see @arcblock/did#DidType}
- * @returns string
+ * @param {string} did - string of the did, usually base58btc format
+ * @param {string} pk - hex encoded publicKey string
+ * @returns {boolean}
  */
-declare function fromTypeInfo(type: object): string;
+declare const isFromPublicKey: (did: string, pk: BytesType) => boolean;
 /**
- * The structure of a forge wallet type
+ * Check if a DID string is valid
  *
  * @public
  * @static
- * @global
- * @typedef {Object} DidType
- * @prop {number} role - Enum field to identify wallet role type
- * @prop {number} pk - Crypto algorithm to derive publicKey from the secretKey
- * @prop {number} hash - Hash algorithm used to hash data before sign them
- */
-
-/**
- * Create an wallet type object that be used as param to create a new wallet
- *
- * @public
- * @static
- * @param {DidType|string} [type='default']
- * @returns {object}
- * @example
- * const assert = require('assert');
- * const { DidType } = require('@arcblock/did');
- * const { types } = require('@ocap/mcrypto');
- *
- * const type = DidType({
- *   role: types.RoleType.ROLE_APPLICATION,
- *   pk: types.KeyType.ED25519,
- *   hash: types.HashType.SHA3,
- * });
+ * @param {string} did - address string
+ * @returns {boolean}
  */
-declare function DidType(type?: DidType | string): object;
-declare const _Lib: _Lib.T100;
-declare namespace _Lib {
-  export interface T100 {
-    types: any;
-    toStrictHex: typeof toStrictHex;
-    fromSecretKey: (sk: string, type: any) => string;
-    fromPublicKey: (pk: string, type: any) => string;
-    fromPublicKeyHash: (buffer: any, type: any) => string;
-    fromHash: (hash: string, role?: any) => string;
-    toAddress: typeof toAddress;
-    toDid: typeof toDid;
-    isFromPublicKey: (did: string, pk: string) => boolean;
-    isValid: (did: string) => boolean;
-    isEthereumDid: typeof isEthereumDid;
-    isEthereumType: typeof isEthereumType;
-    toTypeInfo: typeof toTypeInfo;
-    fromTypeInfo: typeof fromTypeInfo;
-    DidType: typeof DidType;
-    DID_TYPE_ARCBLOCK: typeof DID_TYPE_ARCBLOCK;
-    DID_TYPE_ETHEREUM: typeof DID_TYPE_ETHEREUM;
-  }
-}
-export = _Lib;
+declare const isValid: (did: string) => boolean;
+export { DIDType, DIDTypeStr, DIDTypeArg, types, toStrictHex, fromSecretKey, fromPublicKey, fromPublicKeyHash, fromHash, toAddress, toDid, isFromPublicKey, isValid, isEthereumDid, isEthereumType, toTypeInfo, toTypeInfoStr, fromTypeInfo, DidType, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, };

package/lib/index.js

@@ -1,29 +1,24 @@
-/**
- * @fileOverview Utility functions to create/inspect did, and do did-based auth, an implementation of abt-did-protocol
- *
- * @module @arcblock/did
- * @requires @ocap/mcrypto
- * @requires @ocap/util
- */
-const Mcrypto = require('@ocap/mcrypto');
-const { stripHexPrefix, toBase58, toAddress, toDid } = require('@ocap/util');
-const { DID_PREFIX, toBytes, toStrictHex } = require('./util');
-const {
-  DidType,
-  toTypeInfo,
-  fromTypeInfo,
-  isEthereumType,
-  isEthereumDid,
-  DID_TYPE_ARCBLOCK,
-  DID_TYPE_ETHEREUM,
-  toChecksumAddress,
-} = require('./type');
-
-// eslint-disable-next-line
-const debug = require('debug')(require('../package.json').name);
-
-const { types, getSigner, getHasher } = Mcrypto;
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DID_TYPE_ETHEREUM = exports.DID_TYPE_ARCBLOCK = exports.DidType = exports.fromTypeInfo = exports.toTypeInfoStr = exports.toTypeInfo = exports.isEthereumType = exports.isEthereumDid = exports.isValid = exports.isFromPublicKey = exports.toDid = exports.toAddress = exports.fromHash = exports.fromPublicKeyHash = exports.fromPublicKey = exports.fromSecretKey = exports.toStrictHex = exports.types = void 0;
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const mcrypto_1 = require("@ocap/mcrypto");
+Object.defineProperty(exports, "types", { enumerable: true, get: function () { return mcrypto_1.types; } });
+const util_1 = require("@ocap/util");
+Object.defineProperty(exports, "toAddress", { enumerable: true, get: function () { return util_1.toAddress; } });
+Object.defineProperty(exports, "toDid", { enumerable: true, get: function () { return util_1.toDid; } });
+const type_1 = require("./type");
+Object.defineProperty(exports, "DidType", { enumerable: true, get: function () { return type_1.DidType; } });
+Object.defineProperty(exports, "DID_TYPE_ARCBLOCK", { enumerable: true, get: function () { return type_1.DID_TYPE_ARCBLOCK; } });
+Object.defineProperty(exports, "DID_TYPE_ETHEREUM", { enumerable: true, get: function () { return type_1.DID_TYPE_ETHEREUM; } });
+Object.defineProperty(exports, "fromTypeInfo", { enumerable: true, get: function () { return type_1.fromTypeInfo; } });
+Object.defineProperty(exports, "isEthereumDid", { enumerable: true, get: function () { return type_1.isEthereumDid; } });
+Object.defineProperty(exports, "isEthereumType", { enumerable: true, get: function () { return type_1.isEthereumType; } });
+Object.defineProperty(exports, "toTypeInfo", { enumerable: true, get: function () { return type_1.toTypeInfo; } });
+Object.defineProperty(exports, "toTypeInfoStr", { enumerable: true, get: function () { return type_1.toTypeInfoStr; } });
+const util_2 = require("./util");
+Object.defineProperty(exports, "toStrictHex", { enumerable: true, get: function () { return util_2.toStrictHex; } });
 /**
  * Gen DID from private key and type config
  *
@@ -36,12 +31,11 @@ const { types, getSigner, getHasher } = Mcrypto;
  * @returns {string} DID string
  */
 const fromSecretKey = (sk, type) => {
-  const info = DidType(type || {});
-  const pub = getSigner(info.pk).getPublicKey(sk);
-  // debug('fromSecretKey', { sk, pub });
-  return fromPublicKey(pub.indexOf('0x') === 0 ? pub : `0x${pub}`, info);
+    const info = (0, type_1.DidType)(type);
+    const pub = (0, mcrypto_1.getSigner)(info.pk).getPublicKey(sk);
+    return fromPublicKey(pub.indexOf('0x') === 0 ? pub : `0x${pub}`, info);
 };
-
+exports.fromSecretKey = fromSecretKey;
 /**
  * Gen DID from public key and type config
  *
@@ -52,37 +46,32 @@ const fromSecretKey = (sk, type) => {
  * @returns {string} DID string
  */
 const fromPublicKey = (pk, type) => {
-  const info = DidType(type || {});
-  const hashFn = getHasher(info.hash);
-  const pkHash = hashFn(pk, 1);
-  // debug('fromPublicKey', pkHash);
-  return fromPublicKeyHash(pkHash, info);
+    const info = (0, type_1.DidType)(type);
+    const hashFn = (0, mcrypto_1.getHasher)(info.hash);
+    const pkHash = hashFn(pk, 1);
+    return fromPublicKeyHash(pkHash, info);
 };
-
+exports.fromPublicKey = fromPublicKey;
 const fromPublicKeyHash = (buffer, type) => {
-  const info = DidType(type || {});
-  const pkHash = stripHexPrefix(buffer).slice(0, 40); // 20 bytes
-  const hashFn = getHasher(info.hash);
-  const typeHex = fromTypeInfo(info);
-  const checksum = stripHexPrefix(hashFn(`0x${typeHex}${pkHash}`, 1)).slice(0, 8); // 4 bytes
-  const didHash = `0x${typeHex}${pkHash}${checksum}`;
-  // debug('fromPublicKeyHash', { buffer, info, pkHash, typeHex, checksum, didHash });
-
-  // ethereum-compatible address, this address does not contain any type info
-  // but we can infer from the address itself
-  if (isEthereumType(info)) {
-    return toChecksumAddress(`0x${buffer.slice(-40)}`);
-  }
-
-  // default forge-compatible did
-  if (info.address === types.EncodingType.BASE58) {
-    return toBase58(didHash);
-  }
-
-  // fallback base16 encoding
-  return didHash;
+    const info = (0, type_1.DidType)(type);
+    const pkHash = (0, util_1.stripHexPrefix)(buffer).slice(0, 40); // 20 bytes
+    const hashFn = (0, mcrypto_1.getHasher)(info.hash);
+    const typeHex = (0, type_1.fromTypeInfo)(info);
+    const checksum = (0, util_1.stripHexPrefix)(hashFn(`0x${typeHex}${pkHash}`, 1)).slice(0, 8); // 4 bytes
+    const didHash = `0x${typeHex}${pkHash}${checksum}`;
+    // ethereum-compatible address, this address does not contain any type info
+    // but we can infer from the address itself
+    if ((0, type_1.isEthereumType)(info)) {
+        return (0, type_1.toChecksumAddress)(`0x${buffer.slice(-40)}`);
+    }
+    // default forge-compatible did
+    if (info.address === mcrypto_1.types.EncodingType.BASE58) {
+        return (0, util_1.toBase58)(didHash);
+    }
+    // fallback base16 encoding
+    return didHash;
 };
-
+exports.fromPublicKeyHash = fromPublicKeyHash;
 /**
  * Gen DID from an hex encoded hash and role type
  *
@@ -92,21 +81,19 @@ const fromPublicKeyHash = (buffer, type) => {
  * @param {enum} role - role type, {@see @ocap/mcrypto#types}
  * @returns {string} DID string
  */
-const fromHash = (hash, role = types.RoleType.ROLE_ACCOUNT) => {
-  const roleKeys = Object.keys(types.RoleType);
-  const roleValues = Object.values(types.RoleType);
-  if (roleValues.indexOf(role) === -1) {
-    throw new Error(`Unsupported role type ${role} when gen ddi from hash`);
-  }
-
-  const type = DidType({
-    role: types.RoleType[roleKeys[roleValues.indexOf(role)]],
-  });
-
-  // debug('fromHash', { hash, role, type });
-  return fromPublicKeyHash(hash, type);
+const fromHash = (hash, role = mcrypto_1.types.RoleType.ROLE_ACCOUNT) => {
+    const roleKeys = Object.keys(mcrypto_1.types.RoleType);
+    const roleValues = Object.values(mcrypto_1.types.RoleType);
+    if (roleValues.indexOf(role) === -1) {
+        throw new Error(`Unsupported role type ${role} when gen ddi from hash`);
+    }
+    const type = (0, type_1.DidType)({
+        // @ts-ignore
+        role: mcrypto_1.types.RoleType[roleKeys[roleValues.indexOf(role)]],
+    });
+    return fromPublicKeyHash(hash, type);
 };
-
+exports.fromHash = fromHash;
 /**
  * Check if an DID is generated from a publicKey
  *
@@ -117,17 +104,15 @@ const fromHash = (hash, role = types.RoleType.ROLE_ACCOUNT) => {
  * @returns {boolean}
  */
 const isFromPublicKey = (did, pk) => {
-  if (isValid(did) === false) {
-    return false;
-  }
-
-  const type = toTypeInfo(did);
-  const didNew = fromPublicKey(pk, type);
-  const didClean = did.replace(DID_PREFIX, '');
-
-  return didNew === didClean;
+    if (isValid(did) === false) {
+        return false;
+    }
+    const type = (0, type_1.toTypeInfo)(did);
+    const didNew = fromPublicKey(pk, type);
+    const didClean = did.replace(util_2.DID_PREFIX, '');
+    return didNew === didClean;
 };
-
+exports.isFromPublicKey = isFromPublicKey;
 /**
  * Check if a DID string is valid
  *
@@ -137,48 +122,19 @@ const isFromPublicKey = (did, pk) => {
  * @returns {boolean}
  */
 const isValid = (did) => {
-  const address = toAddress(did);
-  const { hash } = toTypeInfo(address);
-
-  if (typeof hash === 'undefined') {
-    return false;
-  }
-
-  if (isEthereumDid(address)) {
-    return true;
-  }
-
-  const hashFn = getHasher(hash);
-  const bytes = toBytes(address);
-  const bytesHex = toStrictHex(Buffer.from(bytes.slice(0, 22)).toString('hex'));
-  const didChecksum = toStrictHex(Buffer.from(bytes.slice(22, 26)).toString('hex'));
-
-  const checksum = stripHexPrefix(hashFn(`0x${bytesHex}`, 1)).slice(0, 8);
-
-  return didChecksum === checksum;
-};
-
-module.exports = {
-  types,
-
-  toStrictHex,
-  fromSecretKey,
-  fromPublicKey,
-  fromPublicKeyHash,
-  fromHash,
-
-  toAddress,
-  toDid,
-
-  isFromPublicKey,
-  isValid,
-
-  isEthereumDid,
-  isEthereumType,
-
-  toTypeInfo,
-  fromTypeInfo,
-  DidType,
-  DID_TYPE_ARCBLOCK,
-  DID_TYPE_ETHEREUM,
+    const address = (0, util_1.toAddress)(did);
+    const { hash } = (0, type_1.toTypeInfo)(address);
+    if (typeof hash === 'undefined') {
+        return false;
+    }
+    if ((0, type_1.isEthereumDid)(address)) {
+        return true;
+    }
+    const hashFn = (0, mcrypto_1.getHasher)(hash);
+    const bytes = (0, util_2.toBytes)(address);
+    const bytesHex = (0, util_2.toStrictHex)(Buffer.from(bytes.slice(0, 22)).toString('hex'));
+    const didChecksum = (0, util_2.toStrictHex)(Buffer.from(bytes.slice(22, 26)).toString('hex'));
+    const checksum = (0, util_1.stripHexPrefix)(hashFn(`0x${bytesHex}`, 1)).slice(0, 8);
+    return didChecksum === checksum;
 };
+exports.isValid = isValid;

package/lib/type.d.ts

@@ -1,56 +1,21 @@
-/**
- * The structure of a forge wallet type
- */
-export type DidType = {
-    /**
-     * - Enum field to identify wallet role type
-     */
-    role: number;
-    /**
-     * - Crypto algorithm to derive publicKey from the secretKey
-     */
-    pk: number;
-    /**
-     * - Hash algorithm used to hash data before sign them
-     */
-    hash: number;
+export declare type DIDType = {
+    role?: number;
+    pk?: number;
+    hash?: number;
+    address?: number;
+    [key: string]: number;
 };
-export namespace DID_TYPE_ARCBLOCK {
-    const role: any;
-    const pk: any;
-    const hash: any;
-    const address: any;
-}
-export namespace DID_TYPE_ETHEREUM {
-    const role_1: any;
-    export { role_1 as role };
-    const pk_1: any;
-    export { pk_1 as pk };
-    const hash_1: any;
-    export { hash_1 as hash };
-    const address_1: any;
-    export { address_1 as address };
-}
-/**
- * Convert type info object to hex string
- *
- * @public
- * @static
- * @param {object} type - wallet type, {@see @arcblock/did#DidType}
- * @returns string
- */
-export function fromTypeInfo(type: object): string;
-/**
- * Get type info from did (base58 format)
- *
- * @public
- * @static
- * @param {string} did - address string
- * @param {boolean} [returnString=true]
- * @returns {object} wallet type {@see @arcblock/did#DidType}
- */
-export function toTypeInfo(did: string, returnString?: boolean): object;
-export function isEthereumType(type: any): any;
+export declare type DIDTypeStr = {
+    role?: string;
+    pk?: string;
+    hash?: string;
+    address?: string;
+    [key: string]: string;
+};
+export declare type DIDTypeArg = 'default' | 'eth' | 'forge' | DIDType;
+declare const DID_TYPE_ARCBLOCK: DIDType;
+declare const DID_TYPE_ETHEREUM: DIDType;
+declare const isEthereumType: (type: DIDType) => boolean;
 /**
  * Checks if the given string is an address
  *
@@ -58,7 +23,7 @@ export function isEthereumType(type: any): any;
  * @param {String} address the given HEX address
  * @return {Boolean}
  */
-export function isEthereumDid(did: any): boolean;
+declare const isEthereumDid: (did: string) => boolean;
 /**
  * Converts to a checksum address
  *
@@ -66,38 +31,27 @@ export function isEthereumDid(did: any): boolean;
  * @param {String} address the given HEX address
  * @return {String}
  */
-export function toChecksumAddress(address: string): string;
+declare const toChecksumAddress: (address: string) => string;
 /**
- * The structure of a forge wallet type
- *
- * @public
- * @static
- * @global
- * @typedef {Object} DidType
- * @prop {number} role - Enum field to identify wallet role type
- * @prop {number} pk - Crypto algorithm to derive publicKey from the secretKey
- * @prop {number} hash - Hash algorithm used to hash data before sign them
+ * Create an wallet type object that be used as param to create a new wallet
  */
+declare function DidType(type?: DIDTypeArg): DIDType;
+declare namespace DidType {
+    var toJSON: (type: DIDType) => DIDTypeStr;
+    var fromJSON: (json: DIDTypeStr) => DIDType;
+}
 /**
- * Create an wallet type object that be used as param to create a new wallet
+ * Convert type info object to hex string
  *
  * @public
  * @static
- * @param {DidType|string} [type='default']
- * @returns {object}
- * @example
- * const assert = require('assert');
- * const { DidType } = require('@arcblock/did');
- * const { types } = require('@ocap/mcrypto');
- *
- * const type = DidType({
- *   role: types.RoleType.ROLE_APPLICATION,
- *   pk: types.KeyType.ED25519,
- *   hash: types.HashType.SHA3,
- * });
+ * @param {object} type - wallet type, {@see @arcblock/did#DidType}
+ * @returns string
  */
-export function DidType(type?: DidType | string): object;
-export namespace DidType {
-    function toJSON(type: any): {};
-    function fromJSON(json: any): {};
-}
+declare const fromTypeInfo: (type: DIDTypeArg) => string;
+/**
+ * Get type info from did
+ */
+declare const toTypeInfo: (did: string) => DIDType;
+declare const toTypeInfoStr: (did: string) => DIDTypeStr;
+export { DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, fromTypeInfo, toTypeInfo, toTypeInfoStr, isEthereumType, isEthereumDid, toChecksumAddress, DidType, };

package/lib/type.js

@@ -1,38 +1,40 @@
-const { BN } = require('@ocap/util');
-const upperFirst = require('lodash/upperFirst');
-const isEqual = require('lodash/isEqual');
-const pick = require('lodash/pick');
-const { types, Hasher } = require('@ocap/mcrypto');
-const { numberToHex, stripHexPrefix, toAddress, isHex } = require('@ocap/util');
-const { toBits, toBytes, toStrictHex } = require('./util');
-
-// eslint-disable-next-line
-const debug = require('debug')(require('../package.json').name);
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DidType = exports.toChecksumAddress = exports.isEthereumDid = exports.isEthereumType = exports.toTypeInfoStr = exports.toTypeInfo = exports.fromTypeInfo = exports.DID_TYPE_ETHEREUM = exports.DID_TYPE_ARCBLOCK = void 0;
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const util_1 = require("@ocap/util");
+const upperFirst_1 = __importDefault(require("lodash/upperFirst"));
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const pick_1 = __importDefault(require("lodash/pick"));
+const mcrypto_1 = require("@ocap/mcrypto");
+const util_2 = require("./util");
 const mapping = {
-  pk: 'key',
-  address: 'encoding',
+    pk: 'key',
+    address: 'encoding',
 };
-
 const DID_TYPE_ARCBLOCK = {
-  role: types.RoleType.ROLE_ACCOUNT,
-  pk: types.KeyType.ED25519,
-  hash: types.HashType.SHA3,
-  address: types.EncodingType.BASE58,
+    role: mcrypto_1.types.RoleType.ROLE_ACCOUNT,
+    pk: mcrypto_1.types.KeyType.ED25519,
+    hash: mcrypto_1.types.HashType.SHA3,
+    address: mcrypto_1.types.EncodingType.BASE58,
 };
-
+exports.DID_TYPE_ARCBLOCK = DID_TYPE_ARCBLOCK;
 const DID_TYPE_ETHEREUM = {
-  role: types.RoleType.ROLE_ACCOUNT, // this field does not have any effect for eth address
-  pk: types.KeyType.ETHEREUM,
-  hash: types.HashType.KECCAK,
-  address: types.EncodingType.BASE16,
+    role: mcrypto_1.types.RoleType.ROLE_ACCOUNT,
+    pk: mcrypto_1.types.KeyType.ETHEREUM,
+    hash: mcrypto_1.types.HashType.KECCAK,
+    address: mcrypto_1.types.EncodingType.BASE16,
 };
-
+exports.DID_TYPE_ETHEREUM = DID_TYPE_ETHEREUM;
 const isEthereumType = (type) => {
-  const props = ['pk', 'hash', 'address'];
-  return isEqual(pick(type, props), pick(DID_TYPE_ETHEREUM, props));
+    const props = ['pk', 'hash', 'address'];
+    return (0, isEqual_1.default)((0, pick_1.default)(type, props), (0, pick_1.default)(DID_TYPE_ETHEREUM, props));
 };
-
+exports.isEthereumType = isEthereumType;
 /**
  * Checks if the given string is an address
  *
@@ -41,22 +43,19 @@ const isEthereumType = (type) => {
  * @return {Boolean}
  */
 const isEthereumDid = (did) => {
-  const address = toAddress(did);
-
-  // check if it has the basic requirements of an address
-  if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
-    return false;
-  }
-
-  // If it's ALL lowercase or ALL upppercase
-  if (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address)) {
-    return true;
-  }
-
-  // Otherwise check each case
-  return checkAddressChecksum(address);
+    const address = (0, util_1.toAddress)(did);
+    // check if it has the basic requirements of an address
+    if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
+        return false;
+    }
+    // If it's ALL lowercase or ALL upppercase
+    if (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address)) {
+        return true;
+    }
+    // Otherwise check each case
+    return checkAddressChecksum(address);
 };
-
+exports.isEthereumDid = isEthereumDid;
 /**
  * Checks if the given string is a checksummed address
  *
@@ -65,22 +64,18 @@ const isEthereumDid = (did) => {
  * @return {Boolean}
  */
 const checkAddressChecksum = (address) => {
-  // Check each case
-  const origin = address.replace(/^0x/i, '');
-  const addressHash = Hasher.Keccak.hash256(origin.toLowerCase()).replace(/^0x/i, '');
-
-  for (let i = 0; i < 40; i++) {
-    // the nth letter should be uppercase if the nth digit of casemap is 1
-    if (
-      (parseInt(addressHash[i], 16) > 7 && origin[i].toUpperCase() !== origin[i]) ||
-      (parseInt(addressHash[i], 16) <= 7 && origin[i].toLowerCase() !== origin[i])
-    ) {
-      return false;
+    // Check each case
+    const origin = address.replace(/^0x/i, '');
+    const addressHash = mcrypto_1.Hasher.Keccak.hash256(origin.toLowerCase()).replace(/^0x/i, '');
+    for (let i = 0; i < 40; i++) {
+        // the nth letter should be uppercase if the nth digit of casemap is 1
+        if ((parseInt(addressHash[i], 16) > 7 && origin[i].toUpperCase() !== origin[i]) ||
+            (parseInt(addressHash[i], 16) <= 7 && origin[i].toLowerCase() !== origin[i])) {
+            return false;
+        }
     }
-  }
-  return true;
+    return true;
 };
-
 /**
  * Converts to a checksum address
  *
@@ -89,114 +84,89 @@ const checkAddressChecksum = (address) => {
  * @return {String}
  */
 const toChecksumAddress = (address) => {
-  if (typeof address === 'undefined') {
-    return '';
-  }
-
-  if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
-    throw new Error(`Given address "${address}" is not a valid Ethereum address.`);
-  }
-
-  const lower = address.toLowerCase().replace(/^0x/i, '');
-  const addressHash = Hasher.Keccak.hash256(lower).replace(/^0x/i, '');
-  let checksumAddress = '0x';
-
-  for (let i = 0; i < lower.length; i++) {
-    // If ith character is 8 to f then make it uppercase
-    if (parseInt(addressHash[i], 16) > 7) {
-      checksumAddress += lower[i].toUpperCase();
-    } else {
-      checksumAddress += lower[i];
+    if (typeof address === 'undefined') {
+        return '';
+    }
+    if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
+        throw new Error(`Given address "${address}" is not a valid Ethereum address.`);
+    }
+    const lower = address.toLowerCase().replace(/^0x/i, '');
+    const addressHash = mcrypto_1.Hasher.Keccak.hash256(lower).replace(/^0x/i, '');
+    let checksumAddress = '0x';
+    for (let i = 0; i < lower.length; i++) {
+        // If ith character is 8 to f then make it uppercase
+        if (parseInt(addressHash[i], 16) > 7) {
+            checksumAddress += lower[i].toUpperCase();
+        }
+        else {
+            checksumAddress += lower[i];
+        }
     }
-  }
-
-  return checksumAddress;
+    return checksumAddress;
 };
-
-/**
- * The structure of a forge wallet type
- *
- * @public
- * @static
- * @global
- * @typedef {Object} DidType
- * @prop {number} role - Enum field to identify wallet role type
- * @prop {number} pk - Crypto algorithm to derive publicKey from the secretKey
- * @prop {number} hash - Hash algorithm used to hash data before sign them
- */
-
+exports.toChecksumAddress = toChecksumAddress;
 /**
  * Create an wallet type object that be used as param to create a new wallet
- *
- * @public
- * @static
- * @param {DidType|string} [type='default']
- * @returns {object}
- * @example
- * const assert = require('assert');
- * const { DidType } = require('@arcblock/did');
- * const { types } = require('@ocap/mcrypto');
- *
- * const type = DidType({
- *   role: types.RoleType.ROLE_APPLICATION,
- *   pk: types.KeyType.ED25519,
- *   hash: types.HashType.SHA3,
- * });
  */
-function DidType(type = 'default') {
-  let input = null;
-  if (type === 'default' || type === 'forge') {
-    input = DID_TYPE_ARCBLOCK;
-  } else if (type === 'eth') {
-    input = DID_TYPE_ETHEREUM;
-  } else {
-    input = { ...DID_TYPE_ARCBLOCK, ...type };
-  }
-
-  const { role, pk, hash, address } = input;
-  Object.keys(input).forEach((x) => {
-    const key = upperFirst(`${mapping[x] || x}Type`);
-    if (Object.values(types[key]).includes(input[x]) === false) {
-      throw new Error(`Unsupported ${x} type: ${input[x]}`);
+function DidType(type = {}) {
+    let input = null;
+    if (['default', 'forge'].includes(type)) {
+        input = DID_TYPE_ARCBLOCK;
+    }
+    else if (['eth', 'ethereum'].includes(type)) {
+        input = DID_TYPE_ETHEREUM;
     }
-  });
-
-  const output = { role, pk, hash, address };
-
-  // Overwrite hash methods for some role type if we are not eth-type
-  if (isEthereumType(output) === false) {
-    const sha2Roles = [
-      types.RoleType.ROLE_NODE,
-      types.RoleType.ROLE_VALIDATOR,
-      types.RoleType.ROLE_TETHER,
-      types.RoleType.ROLE_SWAP,
-    ];
-    if (sha2Roles.includes(output.role)) {
-      output.hash = types.HashType.SHA2;
+    else {
+        input = Object.assign(Object.assign({}, DID_TYPE_ARCBLOCK), type);
     }
-  }
-
-  return output;
+    const { role, pk, hash, address } = input;
+    Object.keys(input).forEach((x) => {
+        // @ts-ignore
+        const key = (0, upperFirst_1.default)(`${mapping[x] || x}Type`);
+        // @ts-ignore
+        if (Object.values(mcrypto_1.types[key]).includes(input[x]) === false) {
+            // @ts-ignore
+            throw new Error(`Unsupported ${x} type: ${input[x]}`);
+        }
+    });
+    const output = { role, pk, hash, address };
+    // Overwrite hash methods for some role type if we are not eth-type
+    if (isEthereumType(output) === false) {
+        const sha2Roles = [
+            mcrypto_1.types.RoleType.ROLE_NODE,
+            mcrypto_1.types.RoleType.ROLE_VALIDATOR,
+            mcrypto_1.types.RoleType.ROLE_TETHER,
+            mcrypto_1.types.RoleType.ROLE_SWAP,
+        ];
+        if (sha2Roles.includes(output.role)) {
+            output.hash = mcrypto_1.types.HashType.SHA2;
+        }
+    }
+    return output;
 }
-
-DidType.toJSON = (type) =>
-  Object.keys(type).reduce((acc, x) => {
-    const key = upperFirst(`${mapping[x] || x}Type`);
-    const typeStr = Object.keys(types[key]);
-    const typeValues = Object.values(types[key]);
+exports.DidType = DidType;
+DidType.toJSON = (type) => Object.keys(type).reduce((acc, x) => {
+    // @ts-ignore
+    const key = (0, upperFirst_1.default)(`${mapping[x] || x}Type`);
+    // @ts-ignore
+    const typeStr = Object.keys(mcrypto_1.types[key]);
+    // @ts-ignore
+    const typeValues = Object.values(mcrypto_1.types[key]);
+    // @ts-ignore
     acc[x] = typeStr[typeValues.indexOf(type[x])];
     return acc;
-  }, {});
-
-DidType.fromJSON = (json) =>
-  Object.keys(json).reduce((acc, x) => {
-    const key = upperFirst(`${mapping[x] || x}Type`);
-    const typeStr = Object.keys(types[key]);
-    const typeValues = Object.values(types[key]);
+}, {});
+DidType.fromJSON = (json) => Object.keys(json).reduce((acc, x) => {
+    // @ts-ignore
+    const key = (0, upperFirst_1.default)(`${mapping[x] || x}Type`);
+    // @ts-ignore
+    const typeStr = Object.keys(mcrypto_1.types[key]);
+    // @ts-ignore
+    const typeValues = Object.values(mcrypto_1.types[key]);
+    // @ts-ignore
     acc[x] = typeValues[typeStr.indexOf(json[x])];
     return acc;
-  }, {});
-
+}, {});
 /**
  * Convert type info object to hex string
  *
@@ -206,75 +176,62 @@ DidType.fromJSON = (json) =>
  * @returns string
  */
 const fromTypeInfo = (type) => {
-  const info = DidType(type || {});
-
-  const roleBits = toBits(info.role, 6);
-  const keyBits = toBits(info.pk, 5);
-  const hashBits = toBits(info.hash, 5);
-  const infoBits = `${roleBits}${keyBits}${hashBits}`;
-  const infoHex = stripHexPrefix(numberToHex(parseInt(infoBits, 2)));
-  // debug('fromTypeInfo', info, roleBits, hashBits, infoBits, infoHex);
-  return toStrictHex(infoHex, 4);
+    const info = DidType(type);
+    const roleBits = (0, util_2.toBits)(info.role, 6);
+    const keyBits = (0, util_2.toBits)(info.pk, 5);
+    const hashBits = (0, util_2.toBits)(info.hash, 5);
+    const infoBits = `${roleBits}${keyBits}${hashBits}`;
+    const infoHex = (0, util_1.stripHexPrefix)((0, util_1.numberToHex)(parseInt(infoBits, 2)));
+    return (0, util_2.toStrictHex)(infoHex, 4);
 };
-
+exports.fromTypeInfo = fromTypeInfo;
 /**
- * Get type info from did (base58 format)
- *
- * @public
- * @static
- * @param {string} did - address string
- * @param {boolean} [returnString=true]
- * @returns {object} wallet type {@see @arcblock/did#DidType}
+ * Get type info from did
  */
-const toTypeInfo = (did, returnString = false) => {
-  try {
-    let type = null;
-    if (isEthereumDid(did)) {
-      type = DID_TYPE_ETHEREUM;
-    } else {
-      const bytes = toBytes(did);
-      const typeBytes = bytes.slice(0, 2);
-      const typeHex = toStrictHex(Buffer.from(typeBytes).toString('hex'));
-      const typeBits = toBits(new BN(typeHex, 16), 16);
-      const roleBits = typeBits.slice(0, 6);
-      const keyBits = typeBits.slice(6, 11);
-      const hashBits = typeBits.slice(11, 16);
-      type = {
-        role: parseInt(roleBits, 2),
-        pk: parseInt(keyBits, 2),
-        hash: parseInt(hashBits, 2),
-        address: isHex(toAddress(did)) ? types.EncodingType.BASE16 : types.EncodingType.BASE58,
-      };
+const toTypeInfo = (did) => {
+    let type = {};
+    try {
+        if (isEthereumDid(did)) {
+            type = DID_TYPE_ETHEREUM;
+        }
+        else {
+            const bytes = (0, util_2.toBytes)(did);
+            const typeBytes = bytes.slice(0, 2);
+            const typeHex = (0, util_2.toStrictHex)(Buffer.from(typeBytes).toString('hex'));
+            const typeBits = (0, util_2.toBits)(new util_1.BN(typeHex, 16), 16);
+            const roleBits = typeBits.slice(0, 6);
+            const keyBits = typeBits.slice(6, 11);
+            const hashBits = typeBits.slice(11, 16);
+            type = {
+                role: parseInt(roleBits, 2),
+                pk: parseInt(keyBits, 2),
+                hash: parseInt(hashBits, 2),
+                address: (0, util_1.isHex)((0, util_1.toAddress)(did)) ? mcrypto_1.types.EncodingType.BASE16 : mcrypto_1.types.EncodingType.BASE58,
+            };
+        }
+        // remove unsupported types
+        Object.keys(type).forEach((x) => {
+            // @ts-ignore
+            const enums = Object.values(mcrypto_1.types[`${(0, upperFirst_1.default)(mapping[x] || x)}Type`]);
+            if (enums.includes(type[x]) === false) {
+                delete type[x];
+            }
+        });
+        return type;
+    }
+    catch (_a) {
+        return type;
     }
-
-    // remove unsupported types
-    Object.keys(type).forEach((x) => {
-      const enums = Object.values(types[`${upperFirst(mapping[x] || x)}Type`]);
-      if (enums.includes(type[x]) === false) {
-        delete type[x];
-      }
-    });
-
-    const typeStr = Object.keys(type).reduce((acc, x) => {
-      const enums = types[`${upperFirst(mapping[x] || x)}Type`];
-      acc[x] = Object.keys(enums).find((d) => enums[d] === type[x]);
-      return acc;
-    }, {});
-
-    return returnString ? typeStr : type;
-  } catch (err) {
-    debug('AbtDid.toTypeInfo.decodeError', err);
-    return {};
-  }
 };
-
-module.exports = {
-  DID_TYPE_ARCBLOCK,
-  DID_TYPE_ETHEREUM,
-  fromTypeInfo,
-  toTypeInfo,
-  isEthereumType,
-  isEthereumDid,
-  toChecksumAddress,
-  DidType,
+exports.toTypeInfo = toTypeInfo;
+const toTypeInfoStr = (did) => {
+    const type = toTypeInfo(did);
+    return Object.keys(type).reduce((acc, x) => {
+        // @ts-ignore
+        const enums = mcrypto_1.types[`${(0, upperFirst_1.default)(mapping[x] || x)}Type`];
+        // @ts-ignore
+        acc[x] = Object.keys(enums).find((d) => enums[d] === type[x]);
+        return acc;
+    }, {});
 };
+exports.toTypeInfoStr = toTypeInfoStr;

package/lib/util.d.ts

@@ -1,19 +1,17 @@
-export const DID_PREFIX: "did:abt:";
-/**
- * Convert number to bit string with predefined length
- *
- * @param {string} decimal
- * @param {number} length
- * @returns String
- */
-export function toBits(decimal: string, length: number): any;
+/// <reference types="node" />
+import { BN } from '@ocap/util';
+declare const DID_PREFIX = "did:abt:";
 /**
  * Convert did to bytes with length of 26
  *
  * @param {string} did
  * @returns {Buffer}
  */
-export function toBytes(did: string): Buffer;
+declare const toBytes: (did: string) => Buffer;
+/**
+ * Convert number to bit string with predefined length
+ */
+declare const toBits: (number: string | number | BN, length: number) => string;
 /**
  * Ensure the hex length is even number, 2, 4, 6, 8
  *
@@ -21,4 +19,5 @@ export function toBytes(did: string): Buffer;
  * @param {number} length
  * @returns {string} hex
  */
-export function toStrictHex(hex: string, length: number): string;
+declare const toStrictHex: (hex: string, length?: number) => string;
+export { DID_PREFIX, toBits, toBytes, toStrictHex };

package/lib/util.js

@@ -1,8 +1,14 @@
-const padStart = require('lodash/padStart');
-const { toBN, fromBase58, isHexStrict, stripHexPrefix } = require('@ocap/util');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStrictHex = exports.toBytes = exports.toBits = exports.DID_PREFIX = void 0;
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const padStart_1 = __importDefault(require("lodash/padStart"));
+const util_1 = require("@ocap/util");
 const DID_PREFIX = 'did:abt:';
-
+exports.DID_PREFIX = DID_PREFIX;
 /**
  * Convert did to bytes with length of 26
  *
@@ -10,31 +16,27 @@ const DID_PREFIX = 'did:abt:';
  * @returns {Buffer}
  */
 const toBytes = (did) => {
-  try {
-    if (isHexStrict(did)) {
-      return Buffer.from(stripHexPrefix(did), 'hex');
+    try {
+        if ((0, util_1.isHexStrict)(did)) {
+            return Buffer.from((0, util_1.stripHexPrefix)(did), 'hex');
+        }
+        let bytes = (0, util_1.fromBase58)(did.replace(DID_PREFIX, ''));
+        while (bytes.length < 26) {
+            bytes = Buffer.concat([Buffer.from([0]), bytes]);
+        }
+        return bytes;
     }
-
-    let bytes = fromBase58(did.replace(DID_PREFIX, ''));
-    while (bytes.length < 26) {
-      bytes = Buffer.concat([Buffer.from([0]), bytes]);
+    catch (err) {
+        // @ts-ignore
+        throw new Error(`Cannot convert DID string to byte array: ${err.message}`);
     }
-
-    return bytes;
-  } catch (err) {
-    throw new Error(`Cannot convert DID string to byte array: ${err.message}`);
-  }
 };
-
+exports.toBytes = toBytes;
 /**
  * Convert number to bit string with predefined length
- *
- * @param {string} decimal
- * @param {number} length
- * @returns String
  */
-const toBits = (decimal, length) => padStart(toBN(decimal).toString(2), length, '0');
-
+const toBits = (number, length) => (0, padStart_1.default)((0, util_1.toBN)(number).toString(2), length, '0');
+exports.toBits = toBits;
 /**
  * Ensure the hex length is even number, 2, 4, 6, 8
  *
@@ -43,18 +45,10 @@ const toBits = (decimal, length) => padStart(toBN(decimal).toString(2), length,
  * @returns {string} hex
  */
 const toStrictHex = (hex, length) => {
-  const str = hex.replace(/^0x/i, '');
-
-  if (typeof length === 'number' && length % 2 === 0) {
-    return padStart(hex, length, '0');
-  }
-
-  return str.length % 2 === 0 ? str : `0${str}`;
-};
-
-module.exports = {
-  DID_PREFIX,
-  toBits,
-  toBytes,
-  toStrictHex,
+    const str = hex.replace(/^0x/i, '');
+    if (typeof length === 'number' && length % 2 === 0) {
+        return (0, padStart_1.default)(hex, length, '0');
+    }
+    return str.length % 2 === 0 ? str : `0${str}`;
 };
+exports.toStrictHex = toStrictHex;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcblock/did",
-  "version": "1.16.16",
+  "version": "1.16.17",
   "description": "Javascript lib to work with ArcBlock DID",
   "keywords": [
     "arcblock",
@@ -22,36 +22,42 @@
   "homepage": "https://github.com/ArcBlock/asset-chain/tree/master/did/did",
   "license": "Apache-2.0",
   "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
   "files": [
     "lib"
   ],
   "devDependencies": {
-    "jest": "^27.3.1"
+    "@arcblock/eslint-config-ts": "0.2.2",
+    "@types/jest": "^28.1.1",
+    "@types/node": "^17.0.42",
+    "eslint": "^8.17.0",
+    "jest": "^28.1.1",
+    "ts-jest": "^28.0.4",
+    "typescript": "^4.7.3"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ArcBlock/asset-chain.git"
   },
   "scripts": {
-    "lint": "eslint tests lib",
-    "lint:fix": "eslint --fix tests lib",
-    "docs": "yarn gen-dts && yarn gen-docs && yarn cleanup-docs && yarn format-docs",
-    "cleanup-docs": "node ../../scripts/cleanup-docs.js docs/README.md $npm_package_name",
-    "gen-docs": "jsdoc2md lib/index.js > docs/README.md",
-    "gen-dts": "j2d lib/index.js",
-    "format-docs": "remark . -o",
+    "lint": "eslint src tests",
+    "lint:fix": "npm run lint -- --fix",
     "test": "jest --forceExit --detectOpenHandles",
-    "coverage": "yarn test -- --coverage"
+    "coverage": "yarn test -- --coverage",
+    "clean": "rm -fr lib",
+    "prebuild": "npm run clean",
+    "build": "tsc",
+    "build:watch": "npm run build -- -w"
   },
   "bugs": {
     "url": "https://github.com/ArcBlock/asset-chain/issues"
   },
   "dependencies": {
-    "@ocap/mcrypto": "1.16.16",
-    "@ocap/util": "1.16.16",
-    "bn.js": "^5.2.0",
-    "debug": "^4.3.3",
+    "@ocap/mcrypto": "1.16.17",
+    "@ocap/util": "1.16.17",
+    "bn.js": "^5.2.1",
+    "debug": "^4.3.4",
     "lodash": "^4.17.21"
   },
-  "gitHead": "051f9620995cf24407374cc4811b0fa6ed6dc7ca"
+  "gitHead": "489ce5e03bce27ddcd535390228b11ab56e7a2e3"
 }