@arcblock/did 1.27.16 → 1.28.1

package/esm/index.d.ts

@@ -1,7 +1,10 @@
-import { types } from '@ocap/mcrypto';
-import { toAddress, toDid, BytesType } from '@ocap/util';
-import { DidType, DIDType, DIDTypeShortcut, DIDTypeStr, DIDTypeArg, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, fromTypeInfo, isEthereumDid, isEthereumType, toTypeInfo, toTypeInfoStr } from './type';
-import { DID_PREFIX, toStrictHex } from './util';
+import { DIDType, DIDTypeArg, DIDTypeShortcut, DIDTypeStr, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, DidType, fromTypeInfo, isEthereumDid, isEthereumType, toTypeInfo, toTypeInfoStr } from "./type.js";
+import { DID_PREFIX, toStrictHex } from "./util.js";
+import { types } from "@ocap/mcrypto";
+import { BytesType, toAddress, toDid } from "@ocap/util";
+
+//#region src/index.d.ts
+
 /**
  * Gen DID from private key and type config
  *
@@ -54,4 +57,5 @@ declare const isFromPublicKey: (did: string, pk: BytesType) => boolean;
  * @returns {boolean}
  */
 declare const isValid: (did: string) => boolean;
-export { DIDType, DIDTypeStr, DIDTypeArg, DIDTypeShortcut, types, toStrictHex, fromSecretKey, fromPublicKey, fromPublicKeyHash, fromHash, toAddress, toDid, isFromPublicKey, isValid, isEthereumDid, isEthereumType, toTypeInfo, toTypeInfoStr, fromTypeInfo, DidType, DID_PREFIX, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, };
+//#endregion
+export { type DIDType, type DIDTypeArg, type DIDTypeShortcut, type DIDTypeStr, DID_PREFIX, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, DidType, fromHash, fromPublicKey, fromPublicKeyHash, fromSecretKey, fromTypeInfo, isEthereumDid, isEthereumType, isFromPublicKey, isValid, toAddress, toDid, toStrictHex, toTypeInfo, toTypeInfoStr, types };

package/esm/index.js

@@ -1,123 +1,95 @@
-/* eslint-disable @typescript-eslint/no-use-before-define */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import { types, getSigner, getHasher } from '@ocap/mcrypto';
-import { stripHexPrefix, toAddress, toBase58, toDid } from '@ocap/util';
-import { DidType, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, fromTypeInfo, isEthereumDid, isEthereumType, toChecksumAddress, toTypeInfo, toTypeInfoStr, } from './type';
-import { DID_PREFIX, toBytes, toStrictHex } from './util';
+import { DID_PREFIX, toBytes, toStrictHex } from "./util.js";
+import { DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, DidType, fromTypeInfo, isEthereumDid, isEthereumType, toChecksumAddress, toTypeInfo, toTypeInfoStr } from "./type.js";
+import { getHasher, getSigner, types } from "@ocap/mcrypto";
+import { stripHexPrefix, toAddress, toBase58, toDid } from "@ocap/util";
+
+//#region src/index.ts
 /**
- * Gen DID from private key and type config
- *
- * Spec: https://github.com/ArcBlock/ABT-DID-Protocol#create-did
- *
- * @public
- * @static
- * @param {string} sk - hex encoded secret key string
- * @param {object} type - wallet type, {@see @ocap/wallet#WalletType}
- * @returns {string} DID string
- */
+* Gen DID from private key and type config
+*
+* Spec: https://github.com/ArcBlock/ABT-DID-Protocol#create-did
+*
+* @public
+* @static
+* @param {string} sk - hex encoded secret key string
+* @param {object} type - wallet type, {@see @ocap/wallet#WalletType}
+* @returns {string} DID string
+*/
 const fromSecretKey = (sk, type) => {
-    const info = DidType(type);
-    const pub = getSigner(info.pk).getPublicKey(sk);
-    return fromPublicKey(pub.indexOf('0x') === 0 ? pub : `0x${pub}`, info);
+	const info = DidType(type);
+	const pub = getSigner(info.pk).getPublicKey(sk);
+	return fromPublicKey(pub.indexOf("0x") === 0 ? pub : `0x${pub}`, info);
 };
 /**
- * Gen DID from public key and type config
- *
- * @public
- * @static
- * @param {string} pk - hex encoded public key
- * @param {object} type - wallet type, {@see @ocap/wallet#WalletType}
- * @returns {string} DID string
- */
+* Gen DID from public key and type config
+*
+* @public
+* @static
+* @param {string} pk - hex encoded public key
+* @param {object} type - wallet type, {@see @ocap/wallet#WalletType}
+* @returns {string} DID string
+*/
 const fromPublicKey = (pk, type) => {
-    const info = DidType(type);
-    const hashFn = getHasher(info.hash);
-    const pkHash = hashFn(pk, 1);
-    return fromPublicKeyHash(pkHash, info);
+	const info = DidType(type);
+	return fromPublicKeyHash(getHasher(info.hash)(pk, 1), info);
 };
 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}`;
-    // 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 = DidType(type);
+	const pkHash = stripHexPrefix(buffer).slice(0, 40);
+	const hashFn = getHasher(info.hash);
+	const typeHex = fromTypeInfo(info);
+	const didHash = `0x${typeHex}${pkHash}${stripHexPrefix(hashFn(`0x${typeHex}${pkHash}`, 1)).slice(0, 8)}`;
+	if (isEthereumType(info)) return toChecksumAddress(`0x${buffer.slice(-40)}`);
+	if (info.address === types.EncodingType.BASE58) return toBase58(didHash);
+	return didHash;
 };
 /**
- * Gen DID from an hex encoded hash and role type
- *
- * @public
- * @static
- * @param {string} hash - hex encoded hash
- * @param {enum} role - role type, {@see @ocap/mcrypto#types}
- * @returns {string} DID string
- */
+* Gen DID from an hex encoded hash and role type
+*
+* @public
+* @static
+* @param {string} hash - hex encoded hash
+* @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({
-        // @ts-ignore
-        role: types.RoleType[roleKeys[roleValues.indexOf(role)]],
-    });
-    return fromPublicKeyHash(hash, type);
+	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`);
+	return fromPublicKeyHash(hash, DidType({ role: types.RoleType[roleKeys[roleValues.indexOf(role)]] }));
 };
 /**
- * Check if an DID is generated from a publicKey
- *
- * @public
- * @static
- * @param {string} did - string of the did, usually base58btc format
- * @param {string} pk - hex encoded publicKey string
- * @returns {boolean}
- */
+* Check if an DID is generated from a publicKey
+*
+* @public
+* @static
+* @param {string} did - string of the did, usually base58btc format
+* @param {string} pk - hex encoded publicKey string
+* @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;
+	return fromPublicKey(pk, toTypeInfo(did)) === did.replace(DID_PREFIX, "");
 };
 /**
- * Check if a DID string is valid
- *
- * @public
- * @static
- * @param {string} did - address string
- * @returns {boolean}
- */
+* Check if a DID string is valid
+*
+* @public
+* @static
+* @param {string} did - address string
+* @returns {boolean}
+*/
 const isValid = (did) => {
-    if (!did) {
-        return false;
-    }
-    const address = toAddress(String(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;
+	if (!did) return false;
+	const address = toAddress(String(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"));
+	return toStrictHex(Buffer.from(bytes.slice(22, 26)).toString("hex")) === stripHexPrefix(hashFn(`0x${bytesHex}`, 1)).slice(0, 8);
 };
-export { types, toStrictHex, fromSecretKey, fromPublicKey, fromPublicKeyHash, fromHash, toAddress, toDid, isFromPublicKey, isValid, isEthereumDid, isEthereumType, toTypeInfo, toTypeInfoStr, fromTypeInfo, DidType, DID_PREFIX, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, };
+
+//#endregion
+export { DID_PREFIX, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, DidType, fromHash, fromPublicKey, fromPublicKeyHash, fromSecretKey, fromTypeInfo, isEthereumDid, isEthereumType, isFromPublicKey, isValid, toAddress, toDid, toStrictHex, toTypeInfo, toTypeInfoStr, types };

package/esm/lodash.d.ts

@@ -0,0 +1,4 @@
+declare module 'lodash/isEqual';
+declare module 'lodash/pick';
+declare module 'lodash/padStart';
+declare module 'lodash/upperFirst';

package/esm/type.d.ts

@@ -1,17 +1,15 @@
-import type { LiteralUnion } from 'type-fest';
-export type DIDTypeKey = LiteralUnion<'role' | 'pk' | 'hash' | 'address', string>;
-export type DIDTypeShortcut = LiteralUnion<'default' | 'arcblock' | 'eth' | 'ethereum' | 'passkey', string>;
-export type DIDType = {
-    [key in DIDTypeKey]?: number;
-};
-export type DIDTypeStr = {
-    [key in DIDTypeKey]?: string;
-};
-export type DIDTypeArg = DIDTypeShortcut | DIDType;
+import { LiteralUnion } from "type-fest";
+
+//#region src/type.d.ts
+type DIDTypeKey = LiteralUnion<'role' | 'pk' | 'hash' | 'address', string>;
+type DIDTypeShortcut = LiteralUnion<'default' | 'arcblock' | 'eth' | 'ethereum' | 'passkey', string>;
+type DIDType = { [key in DIDTypeKey]?: number };
+type DIDTypeStr = { [key in DIDTypeKey]?: string };
+type DIDTypeArg = DIDTypeShortcut | DIDType;
 declare const DID_TYPE_ARCBLOCK: DIDType;
 declare const DID_TYPE_PASSKEY: DIDType;
 declare const DID_TYPE_ETHEREUM: DIDType;
-declare const isEthereumType: (type: DIDType) => any;
+declare const isEthereumType: (type: DIDType) => boolean;
 /**
  * Checks if the given string is an address
  *
@@ -33,8 +31,8 @@ declare const toChecksumAddress: (address: string) => string;
  */
 declare function DidType(type?: DIDTypeArg): DIDType;
 declare namespace DidType {
-    var toJSON: (type: DIDType) => DIDTypeStr;
-    var fromJSON: (json: DIDTypeStr) => DIDType;
+  var toJSON: (type: DIDType) => DIDTypeStr;
+  var fromJSON: (json: DIDTypeStr) => DIDType;
 }
 /**
  * Convert type info object to hex string
@@ -50,4 +48,5 @@ declare const fromTypeInfo: (type: DIDTypeArg) => string;
  */
 declare const toTypeInfo: (did: string) => DIDType;
 declare const toTypeInfoStr: (did: string) => DIDTypeStr;
-export { DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, fromTypeInfo, toTypeInfo, toTypeInfoStr, isEthereumType, isEthereumDid, toChecksumAddress, DidType, };
+//#endregion
+export { DIDType, DIDTypeArg, DIDTypeKey, DIDTypeShortcut, DIDTypeStr, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, DidType, fromTypeInfo, isEthereumDid, isEthereumType, toChecksumAddress, toTypeInfo, toTypeInfoStr };

package/esm/type.js

@@ -1,228 +1,177 @@
-/* eslint-disable @typescript-eslint/no-use-before-define */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import { BN, numberToHex, stripHexPrefix, toAddress, isHex } from '@ocap/util';
-import upperFirst from 'lodash/upperFirst';
-import isEqual from 'lodash/isEqual';
-import pick from 'lodash/pick';
-import { types, Hasher } from '@ocap/mcrypto';
-import { toBits, toBytes, toStrictHex } from './util';
+import { toBits, toBytes, toStrictHex } from "./util.js";
+import { Hasher, types } from "@ocap/mcrypto";
+import { BN, isHex, numberToHex, stripHexPrefix, toAddress } from "@ocap/util";
+import upperFirst from "lodash/upperFirst.js";
+import isEqual from "lodash/isEqual.js";
+import pick from "lodash/pick.js";
+
+//#region src/type.ts
 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: types.RoleType.ROLE_ACCOUNT,
+	pk: types.KeyType.ED25519,
+	hash: types.HashType.SHA3,
+	address: types.EncodingType.BASE58
 };
 const DID_TYPE_PASSKEY = {
-    role: types.RoleType.ROLE_PASSKEY,
-    pk: types.KeyType.PASSKEY,
-    hash: types.HashType.SHA2,
-    address: types.EncodingType.BASE58,
+	role: types.RoleType.ROLE_PASSKEY,
+	pk: types.KeyType.PASSKEY,
+	hash: types.HashType.SHA2,
+	address: types.EncodingType.BASE58
 };
 const DID_TYPE_ETHEREUM = {
-    role: types.RoleType.ROLE_ACCOUNT,
-    pk: types.KeyType.ETHEREUM,
-    hash: types.HashType.KECCAK,
-    address: types.EncodingType.BASE16,
+	role: types.RoleType.ROLE_ACCOUNT,
+	pk: types.KeyType.ETHEREUM,
+	hash: types.HashType.KECCAK,
+	address: types.EncodingType.BASE16
 };
 const isEthereumType = (type) => {
-    const props = ['pk', 'hash', 'address'];
-    return isEqual(pick(type, props), pick(DID_TYPE_ETHEREUM, props));
+	const props = [
+		"pk",
+		"hash",
+		"address"
+	];
+	return isEqual(pick(type, props), pick(DID_TYPE_ETHEREUM, props));
 };
 /**
- * Checks if the given string is an address
- *
- * @method isEthereumDid
- * @param {String} address the given HEX address
- * @return {Boolean}
- */
+* Checks if the given string is an address
+*
+* @method isEthereumDid
+* @param {String} address the given HEX address
+* @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 = toAddress(did);
+	if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) return false;
+	if (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address)) return true;
+	return checkAddressChecksum(address);
 };
 /**
- * Checks if the given string is a checksummed address
- *
- * @method checkAddressChecksum
- * @param {String} address the given HEX address
- * @return {Boolean}
- */
+* Checks if the given string is a checksummed address
+*
+* @method checkAddressChecksum
+* @param {String} address the given HEX address
+* @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;
-        }
-    }
-    return true;
+	const origin = address.replace(/^0x/i, "");
+	const addressHash = Hasher.Keccak.hash256(origin.toLowerCase()).replace(/^0x/i, "");
+	for (let i = 0; i < 40; i++) 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;
 };
 /**
- * Converts to a checksum address
- *
- * @method toChecksumAddress
- * @param {String} address the given HEX address
- * @return {String}
- */
+* Converts to a checksum address
+*
+* @method toChecksumAddress
+* @param {String} address the given HEX 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];
-        }
-    }
-    return checksumAddress;
+	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 (parseInt(addressHash[i], 16) > 7) checksumAddress += lower[i].toUpperCase();
+	else checksumAddress += lower[i];
+	return checksumAddress;
 };
 /**
- * Create an wallet type object that be used as param to create a new wallet
- */
+* Create an wallet type object that be used as param to create a new wallet
+*/
 function DidType(type = {}) {
-    let input = {};
-    if (['default', 'arcblock'].includes(type)) {
-        input = DID_TYPE_ARCBLOCK;
-    }
-    else if (['eth', 'ethereum'].includes(type)) {
-        input = DID_TYPE_ETHEREUM;
-    }
-    else if (['passkey'].includes(type)) {
-        input = DID_TYPE_PASSKEY;
-    }
-    else {
-        input = { ...DID_TYPE_ARCBLOCK, ...type };
-    }
-    const { role, pk, hash, address } = input;
-    Object.keys(input).forEach((x) => {
-        const key = upperFirst(`${mapping[x] || x}Type`);
-        // @ts-ignore
-        if (Object.values(types[key]).includes(input[x]) === false) {
-            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 = [
-            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;
-        }
-    }
-    return output;
+	let input = {};
+	if (["default", "arcblock"].includes(type)) input = DID_TYPE_ARCBLOCK;
+	else if (["eth", "ethereum"].includes(type)) input = DID_TYPE_ETHEREUM;
+	else if (["passkey"].includes(type)) input = DID_TYPE_PASSKEY;
+	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]}`);
+	});
+	const output = {
+		role,
+		pk,
+		hash,
+		address
+	};
+	if (isEthereumType(output) === false) {
+		if ([
+			types.RoleType.ROLE_NODE,
+			types.RoleType.ROLE_VALIDATOR,
+			types.RoleType.ROLE_TETHER,
+			types.RoleType.ROLE_SWAP
+		].includes(output.role)) output.hash = types.HashType.SHA2;
+	}
+	return output;
 }
 DidType.toJSON = (type) => Object.keys(type).reduce((acc, x) => {
-    const key = upperFirst(`${mapping[x] || x}Type`);
-    // @ts-ignore
-    const typeStr = Object.keys(types[key]);
-    // @ts-ignore
-    const typeValues = Object.values(types[key]);
-    // @ts-ignore
-    acc[x] = typeStr[typeValues.indexOf(type[x])];
-    return acc;
+	const key = upperFirst(`${mapping[x] || x}Type`);
+	acc[x] = Object.keys(types[key])[Object.values(types[key]).indexOf(type[x])];
+	return acc;
 }, {});
 DidType.fromJSON = (json) => Object.keys(json).reduce((acc, x) => {
-    const key = upperFirst(`${mapping[x] || x}Type`);
-    // @ts-ignore
-    const typeStr = Object.keys(types[key]);
-    // @ts-ignore
-    const typeValues = Object.values(types[key]);
-    // @ts-ignore
-    acc[x] = typeValues[typeStr.indexOf(json[x])];
-    return acc;
+	const key = upperFirst(`${mapping[x] || x}Type`);
+	const typeStr = Object.keys(types[key]);
+	acc[x] = Object.values(types[key])[typeStr.indexOf(json[x])];
+	return acc;
 }, {});
 /**
- * Convert type info object to hex string
- *
- * @public
- * @static
- * @param {object} type - wallet type, {@see @arcblock/did#DidType}
- * @returns string
- */
+* Convert type info object to hex string
+*
+* @public
+* @static
+* @param {object} type - wallet type, {@see @arcblock/did#DidType}
+* @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)));
-    return toStrictHex(infoHex, 4);
+	const info = DidType(type);
+	const infoBits = `${toBits(info.role, 6)}${toBits(info.pk, 5)}${toBits(info.hash, 5)}`;
+	return toStrictHex(stripHexPrefix(numberToHex(parseInt(infoBits, 2))), 4);
 };
 /**
- * Get type info from did
- */
+* Get type info from did
+*/
 const toTypeInfo = (did) => {
-    let type = {};
-    try {
-        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,
-            };
-        }
-        // remove unsupported types
-        Object.keys(type).forEach((x) => {
-            // @ts-ignore
-            const enums = Object.values(types[`${upperFirst(mapping[x] || x)}Type`]);
-            if (enums.includes(type[x]) === false) {
-                delete type[x];
-            }
-        });
-        return type;
-    }
-    catch {
-        return type;
-    }
+	let type = {};
+	try {
+		if (isEthereumDid(did)) type = DID_TYPE_ETHEREUM;
+		else {
+			const typeBytes = toBytes(did).slice(0, 2);
+			const typeBits = toBits(new BN(toStrictHex(Buffer.from(typeBytes).toString("hex")), 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
+			};
+		}
+		Object.keys(type).forEach((x) => {
+			if (Object.values(types[`${upperFirst(mapping[x] || x)}Type`]).includes(type[x]) === false) delete type[x];
+		});
+		return type;
+	} catch {
+		return type;
+	}
 };
 const toTypeInfoStr = (did) => {
-    const type = toTypeInfo(did);
-    return Object.keys(type).reduce((acc, x) => {
-        // @ts-ignore
-        const enums = types[`${upperFirst(mapping[x] || x)}Type`];
-        // @ts-ignore
-        acc[x] = Object.keys(enums).find((d) => enums[d] === type[x]);
-        return acc;
-    }, {});
+	const type = toTypeInfo(did);
+	return 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;
+	}, {});
 };
-export { DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, fromTypeInfo, toTypeInfo, toTypeInfoStr, isEthereumType, isEthereumDid, toChecksumAddress, DidType, };
+
+//#endregion
+export { DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, DidType, fromTypeInfo, isEthereumDid, isEthereumType, toChecksumAddress, toTypeInfo, toTypeInfoStr };