did-sdk-js
Version:
js sdk for did and vc according to mcps did spec
241 lines • 8.71 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DisclosurePrivateData = exports.DisclosedData = exports.Claim = exports.ClaimPublicDataBase = exports.ClaimPrivateDataBase = exports.ClaimMetaBase = exports.SecretKey = void 0;
const utils_1 = require("../../utils");
const errors_1 = require("../../errors");
const crypto = require("../../crypto");
class SecretKey {
}
exports.SecretKey = SecretKey;
class ClaimMetaBase {
constructor(type) {
this.type = type;
}
}
exports.ClaimMetaBase = ClaimMetaBase;
class ClaimPrivateDataBase {
isEmpty() {
let str = JSON.stringify(this, utils_1.Utils.replacerTrimEmpty);
return utils_1.Utils.isNull(JSON.parse(str));
}
genHashList() {
if (this.isEmpty()) {
return [];
}
let kvHashList = [];
let obj = JSON.parse(JSON.stringify(this, utils_1.Utils.replacerTrimEmpty));
for (let key in obj) {
let v = obj[key];
if (utils_1.Utils.isObject(v)) {
v = JSON.stringify(utils_1.Utils.sortObject(obj[key]));
}
let kvStr = key + "=" + v;
let kvHash = utils_1.Utils.sha256(kvStr).toString("base64");
kvHashList.push(kvHash);
}
kvHashList.sort();
return kvHashList;
}
genHash(inHashList = null) {
let kvHashList = [];
if (inHashList == null) {
kvHashList = this.genHashList();
}
else {
kvHashList = inHashList;
}
if (kvHashList.length == 0) {
return "";
}
// kvHashList.sort()
let kvHashBlock = kvHashList.join("");
return utils_1.Utils.sha256(kvHashBlock).toString("base64");
}
toString() {
let str = JSON.stringify(this, utils_1.Utils.replacerTrimEmpty);
let obj = JSON.parse(str);
// sort by key
obj = utils_1.Utils.sortObject(obj);
return JSON.stringify(obj);
}
encrypt(key) {
if (this.isEmpty()) {
return "";
}
return crypto.Aes.encrypt(this.toString(), key);
}
decrypt(cipherText, key) {
let plainText = crypto.Aes.decrypt(cipherText, key);
return Object.assign(this, JSON.parse(plainText));
}
}
exports.ClaimPrivateDataBase = ClaimPrivateDataBase;
class ClaimPublicDataBase {
}
exports.ClaimPublicDataBase = ClaimPublicDataBase;
// export interface Claim {
// type(): string
// parseFrom(objStr: string): Object
//
// preparePrivateHash(): void
// privateDataEncrypt(key: string): SdkError | null
// privateDataDecrypt(cipherText: string, key: string): SdkError | null
//
// removePrivateData(): void
// removePrivateCipher(): void
// removePrivateHash(): void
// }
class Claim {
type() { return ""; }
// preparePrivateHash(): void {}
// privateDataEncrypt(key: string): SdkError | null {return null}
// privateDataDecrypt(cipherText: string, key: string): SdkError | null {return null}
//
// removePrivateData(): void {}
// removePrivateCipher(): void {}
// removePrivateHash(): void {}
validateBasic() {
if (this.type() == "") {
return new errors_1.SdkError("type is null");
}
return null;
}
newPrivateData() {
return new ClaimPrivateDataBase();
}
newPublicData() {
return new ClaimPublicDataBase();
}
newMetaData() {
return new ClaimMetaBase(this.type());
}
parseFrom(objStr) {
let claim = Object.assign(this, JSON.parse(objStr));
if (!utils_1.Utils.isNull(claim.meta)) {
claim.meta = Object.assign(this.newMetaData(), claim.meta);
}
if (!utils_1.Utils.isNull(claim.privateData)) {
claim.privateData = Object.assign(this.newPrivateData(), claim.privateData);
}
if (!utils_1.Utils.isNull(claim.publicData)) {
claim.publicData = Object.assign(this.newPublicData(), claim.publicData);
}
return claim;
}
genPrivateHash() {
if (this.privateData == null || this.privateData.isEmpty()) {
this.privateHash = "";
return;
}
this.privateHash = this.privateData.genHash();
}
preparePrivateHash() {
this.genPrivateHash();
this.removePrivateData();
this.removePrivateCipher();
}
privateDataEncrypt(key) {
if (utils_1.Utils.isNull(this.privateData)) {
return null;
}
if (this.privateData != null) {
this.privateCipherText = this.privateData.encrypt(key);
}
return null;
}
privateDataDecrypt(cipherText, key) {
if (cipherText == "") {
cipherText = this.privateCipherText;
}
if (cipherText == "") {
this.privateData = null;
return null;
}
this.privateData = this.newPrivateData().decrypt(cipherText, key);
return null;
}
removePrivateCipher() {
this.privateCipherText = "";
}
removePrivateHash() {
this.privateHash = "";
}
removePrivateData() {
this.privateData = null;
}
setPublicExtensionField(field) {
if (this.publicData == null) {
this.publicData = this.newPublicData();
}
this.publicData.extensionField = field;
}
setPrivateExtensionField(fieldValue) {
if (this.privateData == null) {
this.privateData = this.newPrivateData();
}
this.privateData.extensionField = fieldValue;
}
genDisclosureData(disclosureFields = []) {
// if (this.privateData == null) {
// throw new SdkError("private data is null, can not disclosure")
// }
let disclosurePrivateData = new DisclosedData(this.type());
if (this.privateData == null) {
return disclosurePrivateData;
}
// disPrivateData.disclosedField = this.newPrivateData()
let originPrivateObj = JSON.parse(JSON.stringify(this.privateData));
let disclosedPrivateObj = JSON.parse(JSON.stringify(this.newPrivateData()));
for (let i in disclosureFields) {
let field = disclosureFields[i];
if (originPrivateObj.hasOwnProperty(field)) {
disclosedPrivateObj[field] = originPrivateObj[field];
}
else {
throw new errors_1.SdkError(field + "not found in private data");
}
}
disclosurePrivateData.disclosedField = Object.assign(this.newPrivateData(), disclosedPrivateObj);
let originHashList = this.privateData.genHashList();
let disclosedHashList = disclosurePrivateData.disclosedField.genHashList();
let undisclosedHash = [];
for (let hk in originHashList) {
if (!utils_1.Utils.isInArray(disclosedHashList, originHashList[hk])) {
undisclosedHash.push(originHashList[hk]);
}
}
disclosurePrivateData.undisclosedHash = undisclosedHash;
return disclosurePrivateData;
}
verifyDisclosureData(disclosurePrivateData) {
let disclosedHashList = disclosurePrivateData.disclosedField.genHashList();
let hashList = disclosedHashList.concat(disclosurePrivateData.undisclosedHash);
return disclosurePrivateData.disclosedField.genHash(hashList) == this.privateData.genHash();
}
genHashFromDisclosureData(disclosedData) {
let disclosedHashList = [];
if (utils_1.Utils.isNull(disclosedData.disclosedField)) {
disclosedData.disclosedField = this.newPrivateData();
}
disclosedHashList = disclosedData.disclosedField.genHashList();
let hashList = disclosedHashList.concat(disclosedData.undisclosedHash);
return disclosedData.disclosedField.genHash(hashList);
}
preparePrivateHashFromDiscloseData(disclosedData) {
this.privateHash = this.genHashFromDisclosureData(disclosedData);
this.removePrivateData();
this.removePrivateCipher();
}
}
exports.Claim = Claim;
class DisclosedData {
constructor(type) {
this.undisclosedHash = [];
this.type = type;
}
}
exports.DisclosedData = DisclosedData;
class DisclosurePrivateData extends ClaimPrivateDataBase {
}
exports.DisclosurePrivateData = DisclosurePrivateData;
//# sourceMappingURL=common.js.map