@arcblock/did 1.18.165 → 1.19.0

package/esm/index.d.ts

@@ -0,0 +1,57 @@
+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';
+/**
+ * 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
+ */
+declare const fromSecretKey: (sk: BytesType, type?: DIDTypeArg) => 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
+ */
+declare const fromPublicKey: (pk: BytesType, type?: DIDTypeArg) => string;
+declare const fromPublicKeyHash: (buffer: string, type: DIDTypeArg) => 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
+ */
+declare const fromHash: (hash: string, role?: number) => string;
+/**
+ * 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}
+ */
+declare const isFromPublicKey: (did: string, pk: BytesType) => boolean;
+/**
+ * Check if a DID string is valid
+ *
+ * @public
+ * @static
+ * @param {string} did - address string
+ * @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, };

package/esm/index.js

@@ -0,0 +1,123 @@
+/* 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';
+/**
+ * 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);
+};
+/**
+ * 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 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;
+};
+/**
+ * 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);
+};
+/**
+ * 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;
+};
+/**
+ * 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;
+};
+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, };

package/esm/type.d.ts

@@ -0,0 +1,53 @@
+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;
+declare const DID_TYPE_ARCBLOCK: DIDType;
+declare const DID_TYPE_PASSKEY: DIDType;
+declare const DID_TYPE_ETHEREUM: DIDType;
+declare const isEthereumType: (type: DIDType) => any;
+/**
+ * Checks if the given string is an address
+ *
+ * @method isEthereumDid
+ * @param {String} address the given HEX address
+ * @return {Boolean}
+ */
+declare const isEthereumDid: (did: string) => boolean;
+/**
+ * Converts to a checksum address
+ *
+ * @method toChecksumAddress
+ * @param {String} address the given HEX address
+ * @return {String}
+ */
+declare const toChecksumAddress: (address: string) => string;
+/**
+ * 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;
+}
+/**
+ * Convert type info object to hex string
+ *
+ * @public
+ * @static
+ * @param {object} type - wallet type, {@see @arcblock/did#DidType}
+ * @returns string
+ */
+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, DID_TYPE_PASSKEY, fromTypeInfo, toTypeInfo, toTypeInfoStr, isEthereumType, isEthereumDid, toChecksumAddress, DidType, };

package/esm/type.js

@@ -0,0 +1,228 @@
+/* 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';
+const mapping = {
+    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,
+};
+const DID_TYPE_PASSKEY = {
+    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,
+};
+const isEthereumType = (type) => {
+    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}
+ */
+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);
+};
+/**
+ * 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;
+};
+/**
+ * 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;
+};
+/**
+ * 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;
+}
+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;
+}, {});
+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;
+}, {});
+/**
+ * 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);
+};
+/**
+ * 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;
+    }
+};
+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;
+    }, {});
+};
+export { DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, fromTypeInfo, toTypeInfo, toTypeInfoStr, isEthereumType, isEthereumDid, toChecksumAddress, DidType, };

package/esm/util.d.ts

@@ -0,0 +1,22 @@
+import { BN } from '@ocap/util';
+declare const DID_PREFIX = "did:abt:";
+/**
+ * Convert did to bytes with length of 26
+ *
+ * @param {string} did
+ * @returns {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
+ *
+ * @param {string} hex
+ * @param {number} length
+ * @returns {string} hex
+ */
+declare const toStrictHex: (hex: string, length?: number) => any;
+export { DID_PREFIX, toBits, toBytes, toStrictHex };

package/esm/util.js

@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import padStart from 'lodash/padStart';
+import { toBN, fromBase58, isHexStrict, stripHexPrefix } from '@ocap/util';
+const DID_PREFIX = 'did:abt:';
+/**
+ * Convert did to bytes with length of 26
+ *
+ * @param {string} did
+ * @returns {Buffer}
+ */
+const toBytes = (did) => {
+    try {
+        if (isHexStrict(did)) {
+            return Buffer.from(stripHexPrefix(did), 'hex');
+        }
+        let bytes = fromBase58(did.replace(DID_PREFIX, ''));
+        while (bytes.length < 26) {
+            bytes = Buffer.concat([Buffer.from([0]), bytes]);
+        }
+        return bytes;
+    }
+    catch (err) {
+        // @ts-ignore
+        throw new Error(`Cannot convert DID string to byte array: ${err.message}`);
+    }
+};
+/**
+ * Convert number to bit string with predefined length
+ */
+const toBits = (number, length) => padStart(toBN(number).toString(2), length, '0');
+/**
+ * Ensure the hex length is even number, 2, 4, 6, 8
+ *
+ * @param {string} hex
+ * @param {number} 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}`;
+};
+export { DID_PREFIX, toBits, toBytes, toStrictHex };

package/lib/index.d.ts

@@ -1,6 +1,6 @@
 import { types } from '@ocap/mcrypto';
 import { toAddress, toDid, BytesType } from '@ocap/util';
-import { DidType, DIDType, DIDTypeShortcut, DIDTypeStr, DIDTypeArg, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, fromTypeInfo, isEthereumDid, isEthereumType, toTypeInfo, toTypeInfoStr } from './type';
+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';
 /**
  * Gen DID from private key and type config
@@ -54,4 +54,4 @@ 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, };
+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, };

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DID_TYPE_ETHEREUM = exports.DID_TYPE_ARCBLOCK = exports.DID_PREFIX = 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;
+exports.DID_TYPE_PASSKEY = exports.DID_TYPE_ETHEREUM = exports.DID_TYPE_ARCBLOCK = exports.DID_PREFIX = 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");
@@ -12,6 +12,7 @@ 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, "DID_TYPE_PASSKEY", { enumerable: true, get: function () { return type_1.DID_TYPE_PASSKEY; } });
 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; } });

package/lib/type.d.ts

@@ -1,14 +1,15 @@
 import type { LiteralUnion } from 'type-fest';
-export declare type DIDTypeKey = LiteralUnion<'role' | 'pk' | 'hash' | 'address', string>;
-export declare type DIDTypeShortcut = LiteralUnion<'default' | 'arcblock' | 'eth' | 'ethereum', string>;
-export declare type DIDType = {
+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 declare type DIDTypeStr = {
+export type DIDTypeStr = {
     [key in DIDTypeKey]?: string;
 };
-export declare type DIDTypeArg = DIDTypeShortcut | DIDType;
+export 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;
 /**
@@ -49,4 +50,4 @@ 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, fromTypeInfo, toTypeInfo, toTypeInfoStr, isEthereumType, isEthereumDid, toChecksumAddress, DidType, };
+export { DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, fromTypeInfo, toTypeInfo, toTypeInfoStr, isEthereumType, isEthereumDid, toChecksumAddress, DidType, };

package/lib/type.js

@@ -3,7 +3,8 @@ 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;
+exports.toChecksumAddress = exports.isEthereumDid = exports.isEthereumType = exports.toTypeInfoStr = exports.toTypeInfo = exports.fromTypeInfo = exports.DID_TYPE_PASSKEY = exports.DID_TYPE_ETHEREUM = exports.DID_TYPE_ARCBLOCK = void 0;
+exports.DidType = DidType;
 /* eslint-disable @typescript-eslint/no-use-before-define */
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 const util_1 = require("@ocap/util");
@@ -23,6 +24,13 @@ const DID_TYPE_ARCBLOCK = {
     address: mcrypto_1.types.EncodingType.BASE58,
 };
 exports.DID_TYPE_ARCBLOCK = DID_TYPE_ARCBLOCK;
+const DID_TYPE_PASSKEY = {
+    role: mcrypto_1.types.RoleType.ROLE_PASSKEY,
+    pk: mcrypto_1.types.KeyType.PASSKEY,
+    hash: mcrypto_1.types.HashType.SHA2,
+    address: mcrypto_1.types.EncodingType.BASE58,
+};
+exports.DID_TYPE_PASSKEY = DID_TYPE_PASSKEY;
 const DID_TYPE_ETHEREUM = {
     role: mcrypto_1.types.RoleType.ROLE_ACCOUNT,
     pk: mcrypto_1.types.KeyType.ETHEREUM,
@@ -116,6 +124,9 @@ function DidType(type = {}) {
     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 };
     }
@@ -142,7 +153,6 @@ function DidType(type = {}) {
     }
     return output;
 }
-exports.DidType = DidType;
 DidType.toJSON = (type) => Object.keys(type).reduce((acc, x) => {
     const key = (0, upperFirst_1.default)(`${mapping[x] || x}Type`);
     // @ts-ignore

package/lib/util.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { BN } from '@ocap/util';
 declare const DID_PREFIX = "did:abt:";
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcblock/did",
-  "version": "1.18.165",
+  "version": "1.19.0",
   "description": "Javascript lib to work with ArcBlock DID",
   "keywords": [
     "arcblock",
@@ -21,20 +21,32 @@
   ],
   "homepage": "https://github.com/ArcBlock/blockchain/tree/master/did/did",
   "license": "Apache-2.0",
-  "main": "lib/index.js",
-  "typings": "lib/index.d.ts",
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "types": "./esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./lib/index.js",
+      "default": "./esm/index.js"
+    },
+    "./lib/*": {
+      "require": "./lib/*.js"
+    }
+  },
   "files": [
-    "lib"
+    "lib",
+    "esm"
   ],
   "devDependencies": {
-    "@arcblock/eslint-config-ts": "0.2.3",
-    "@types/jest": "^29.5.12",
-    "@types/node": "^17.0.45",
-    "eslint": "^8.25.0",
+    "@arcblock/eslint-config-ts": "0.3.3",
+    "@types/jest": "^29.5.13",
+    "@types/node": "^22.7.5",
+    "eslint": "^8.57.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "type-fest": "^3.1.0",
-    "typescript": "^4.8.4"
+    "typescript": "^5.6.2"
   },
   "repository": {
     "type": "git",
@@ -45,20 +57,22 @@
     "lint:fix": "npm run lint -- --fix",
     "test": "jest --forceExit --detectOpenHandles",
     "coverage": "npm run test -- --coverage",
-    "clean": "rm -fr lib",
+    "clean": "rm -fr lib esm",
     "prebuild": "npm run clean",
-    "build": "tsc",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build": "npm run build:cjs && npm run build:esm",
     "build:watch": "npm run build -- -w"
   },
   "bugs": {
     "url": "https://github.com/ArcBlock/blockchain/issues"
   },
   "dependencies": {
-    "@ocap/mcrypto": "1.18.165",
-    "@ocap/util": "1.18.165",
+    "@ocap/mcrypto": "1.19.0",
+    "@ocap/util": "1.19.0",
     "bn.js": "^5.2.1",
     "debug": "^4.3.6",
     "lodash": "^4.17.21"
   },
-  "gitHead": "e1a9e9e807ca049f67ffbb5ac556b014461cb7a1"
+  "gitHead": "1b6fac03988fb18507c8ef4c21de282762005f87"
 }