@arcblock/did 1.27.16 → 1.28.1

package/esm/util.d.ts

@@ -1,4 +1,6 @@
-import { BN } from '@ocap/util';
+import { BN } from "@ocap/util";
+
+//#region src/util.d.ts
 declare const DID_PREFIX = "did:abt:";
 /**
  * Convert did to bytes with length of 26
@@ -18,5 +20,6 @@ declare const toBits: (number: string | number | BN, length: number) => string;
  * @param {number} length
  * @returns {string} hex
  */
-declare const toStrictHex: (hex: string, length?: number) => any;
-export { DID_PREFIX, toBits, toBytes, toStrictHex };
+declare const toStrictHex: (hex: string, length?: number) => string;
+//#endregion
+export { DID_PREFIX, toBits, toBytes, toStrictHex };

package/esm/util.js

@@ -1,45 +1,40 @@
-/* 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:';
+import { fromBase58, isHexStrict, stripHexPrefix, toBN } from "@ocap/util";
+import padStart from "lodash/padStart.js";
+
+//#region src/util.ts
+const DID_PREFIX = "did:abt:";
 /**
- * Convert did to bytes with length of 26
- *
- * @param {string} did
- * @returns {Buffer}
- */
+* 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}`);
-    }
+	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) {
+		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');
+* 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
- */
+* 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}`;
+	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 };
+
+//#endregion
+export { DID_PREFIX, toBits, toBytes, toStrictHex };

package/lib/_virtual/rolldown_runtime.js

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/lib/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/lib/index.js

@@ -1,145 +1,115 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-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");
-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, "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; } });
-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, "DID_PREFIX", { enumerable: true, get: function () { return util_2.DID_PREFIX; } });
-Object.defineProperty(exports, "toStrictHex", { enumerable: true, get: function () { return util_2.toStrictHex; } });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+const require_util = require('./util.js');
+const require_type = require('./type.js');
+let _ocap_mcrypto = require("@ocap/mcrypto");
+let _ocap_util = require("@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 = (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);
+	const info = require_type.DidType(type);
+	const pub = (0, _ocap_mcrypto.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
- *
- * @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 = (0, type_1.DidType)(type);
-    const hashFn = (0, mcrypto_1.getHasher)(info.hash);
-    const pkHash = hashFn(pk, 1);
-    return fromPublicKeyHash(pkHash, info);
+	const info = require_type.DidType(type);
+	return fromPublicKeyHash((0, _ocap_mcrypto.getHasher)(info.hash)(pk, 1), info);
 };
-exports.fromPublicKey = fromPublicKey;
 const fromPublicKeyHash = (buffer, type) => {
-    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;
+	const info = require_type.DidType(type);
+	const pkHash = (0, _ocap_util.stripHexPrefix)(buffer).slice(0, 40);
+	const hashFn = (0, _ocap_mcrypto.getHasher)(info.hash);
+	const typeHex = require_type.fromTypeInfo(info);
+	const didHash = `0x${typeHex}${pkHash}${(0, _ocap_util.stripHexPrefix)(hashFn(`0x${typeHex}${pkHash}`, 1)).slice(0, 8)}`;
+	if (require_type.isEthereumType(info)) return require_type.toChecksumAddress(`0x${buffer.slice(-40)}`);
+	if (info.address === _ocap_mcrypto.types.EncodingType.BASE58) return (0, _ocap_util.toBase58)(didHash);
+	return didHash;
 };
-exports.fromPublicKeyHash = fromPublicKeyHash;
 /**
- * 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 = 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);
+* 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 = _ocap_mcrypto.types.RoleType.ROLE_ACCOUNT) => {
+	const roleKeys = Object.keys(_ocap_mcrypto.types.RoleType);
+	const roleValues = Object.values(_ocap_mcrypto.types.RoleType);
+	if (roleValues.indexOf(role) === -1) throw new Error(`Unsupported role type ${role} when gen ddi from hash`);
+	return fromPublicKeyHash(hash, require_type.DidType({ role: _ocap_mcrypto.types.RoleType[roleKeys[roleValues.indexOf(role)]] }));
 };
-exports.fromHash = fromHash;
 /**
- * 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 = (0, type_1.toTypeInfo)(did);
-    const didNew = fromPublicKey(pk, type);
-    const didClean = did.replace(util_2.DID_PREFIX, '');
-    return didNew === didClean;
+	if (isValid(did) === false) return false;
+	return fromPublicKey(pk, require_type.toTypeInfo(did)) === did.replace(require_util.DID_PREFIX, "");
 };
-exports.isFromPublicKey = isFromPublicKey;
 /**
- * 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 = (0, util_1.toAddress)(String(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;
+	if (!did) return false;
+	const address = (0, _ocap_util.toAddress)(String(did));
+	const { hash } = require_type.toTypeInfo(address);
+	if (typeof hash === "undefined") return false;
+	if (require_type.isEthereumDid(address)) return true;
+	const hashFn = (0, _ocap_mcrypto.getHasher)(hash);
+	const bytes = require_util.toBytes(address);
+	const bytesHex = require_util.toStrictHex(Buffer.from(bytes.slice(0, 22)).toString("hex"));
+	return require_util.toStrictHex(Buffer.from(bytes.slice(22, 26)).toString("hex")) === (0, _ocap_util.stripHexPrefix)(hashFn(`0x${bytesHex}`, 1)).slice(0, 8);
 };
+
+//#endregion
+exports.DID_PREFIX = require_util.DID_PREFIX;
+exports.DID_TYPE_ARCBLOCK = require_type.DID_TYPE_ARCBLOCK;
+exports.DID_TYPE_ETHEREUM = require_type.DID_TYPE_ETHEREUM;
+exports.DID_TYPE_PASSKEY = require_type.DID_TYPE_PASSKEY;
+exports.DidType = require_type.DidType;
+exports.fromHash = fromHash;
+exports.fromPublicKey = fromPublicKey;
+exports.fromPublicKeyHash = fromPublicKeyHash;
+exports.fromSecretKey = fromSecretKey;
+exports.fromTypeInfo = require_type.fromTypeInfo;
+exports.isEthereumDid = require_type.isEthereumDid;
+exports.isEthereumType = require_type.isEthereumType;
+exports.isFromPublicKey = isFromPublicKey;
 exports.isValid = isValid;
+exports.toAddress = _ocap_util.toAddress;
+exports.toDid = _ocap_util.toDid;
+exports.toStrictHex = require_util.toStrictHex;
+exports.toTypeInfo = require_type.toTypeInfo;
+exports.toTypeInfoStr = require_type.toTypeInfoStr;
+exports.types = _ocap_mcrypto.types;

package/lib/lodash.d.ts

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

package/lib/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 };