@arcblock/did/lib/index.cjs

Javascript lib to work with ArcBlock DID

const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
const require_method = require('./method.cjs');
const require_parse = require('./parse.cjs');
const require_entity = require('./entity.cjs');
const require_util = require('./util.cjs');
const require_type = require('./type.cjs');
const require_validate = require('./validate.cjs');
const require_short_form = require('./short-form.cjs');
const require_name = require('./name.cjs');
const require_name_registry = require('./name-registry.cjs');
const require_name_resolver = require('./name-resolver.cjs');
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
*/
const fromSecretKey = (sk, type) => {
	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);
};
/**
* 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 = require_type.DidType(type);
	return fromPublicKeyHash((0, _ocap_mcrypto.getHasher)(info.hash)(pk, 1), info);
};
const fromPublicKeyHash = (buffer, type) => {
	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;
};
/**
* 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)]] }));
};
/**
* 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;
	return fromPublicKey(pk, require_type.toTypeInfo(did)) === (0, _ocap_util.toAddress)(did);
};
/**
* 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, _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(Uint8Array.from(bytes.slice(0, 22))).toString("hex"));
	return require_util.toStrictHex(Buffer.from(Uint8Array.from(bytes.slice(22, 26))).toString("hex")) === (0, _ocap_util.stripHexPrefix)(hashFn(`0x${bytesHex}`, 1)).slice(0, 8);
};

//#endregion
exports.ALIAS_METHODS = require_method.ALIAS_METHODS;
exports.ALL_METHODS = require_method.ALL_METHODS;
exports.CRYPTO_METHODS = require_method.CRYPTO_METHODS;
exports.DEFAULT_METHOD = require_method.DEFAULT_METHOD;
exports.DIDNameResolver = require_name_resolver.DIDNameResolver;
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.InMemoryNameRegistry = require_name_registry.InMemoryNameRegistry;
exports.expandShortForm = require_short_form.expandShortForm;
exports.extractIdentifier = require_parse.extractIdentifier;
exports.extractMethod = require_parse.extractMethod;
exports.formatDid = require_parse.formatDid;
exports.fromHash = fromHash;
exports.fromPublicKey = fromPublicKey;
exports.fromPublicKeyHash = fromPublicKeyHash;
exports.fromSecretKey = fromSecretKey;
exports.fromTypeInfo = require_type.fromTypeInfo;
exports.getEntityId = require_entity.getEntityId;
exports.getResolveRoute = require_name.getResolveRoute;
exports.isAliasMethod = require_method.isAliasMethod;
exports.isCryptoMethod = require_method.isCryptoMethod;
exports.isEthereumDid = require_type.isEthereumDid;
exports.isEthereumType = require_type.isEthereumType;
exports.isFromPublicKey = isFromPublicKey;
exports.isGlobalName = require_name.isGlobalName;
exports.isKnownDid = require_validate.isKnownDid;
exports.isKnownMethod = require_method.isKnownMethod;
exports.isLocalName = require_name.isLocalName;
exports.isSameEntity = require_entity.isSameEntity;
exports.isValid = isValid;
exports.parse = require_parse.parse;
exports.parseNameHierarchy = require_name.parseNameHierarchy;
exports.toAddress = _ocap_util.toAddress;
exports.toDid = _ocap_util.toDid;
exports.toShortForm = require_short_form.toShortForm;
exports.toStrictHex = require_util.toStrictHex;
exports.toTypeInfo = require_type.toTypeInfo;
exports.toTypeInfoStr = require_type.toTypeInfoStr;
exports.types = _ocap_mcrypto.types;