@sd-jwt/core 0.7.2 → 0.8.0

package/dist/index.js

@@ -57,16 +57,19 @@ var __async = (__this, __arguments, generator) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  FlattenJSON: () => FlattenJSON,
+  GeneralJSON: () => GeneralJSON,
   Jwt: () => Jwt,
   KBJwt: () => KBJwt,
   SDJwt: () => SDJwt,
+  SDJwtGeneralJSONInstance: () => SDJwtGeneralJSONInstance,
   SDJwtInstance: () => SDJwtInstance,
   createDecoy: () => createDecoy,
   listKeys: () => listKeys,
   pack: () => pack
 });
 module.exports = __toCommonJS(src_exports);
-var import_utils5 = require("@sd-jwt/utils");
+var import_utils7 = require("@sd-jwt/utils");
 
 // src/jwt.ts
 var import_utils = require("@sd-jwt/utils");
@@ -257,6 +260,17 @@ var SDJwt = class _SDJwt {
     });
   }
   present(presentFrame, hasher) {
+    return __async(this, null, function* () {
+      const disclosures = yield this.getPresentDisclosures(presentFrame, hasher);
+      const presentSDJwt = new _SDJwt({
+        jwt: this.jwt,
+        disclosures,
+        kbJwt: this.kbJwt
+      });
+      return presentSDJwt.encodeSDJwt();
+    });
+  }
+  getPresentDisclosures(presentFrame, hasher) {
     return __async(this, null, function* () {
       var _a;
       if (!((_a = this.jwt) == null ? void 0 : _a.payload) || !this.disclosures) {
@@ -272,12 +286,7 @@ var SDJwt = class _SDJwt {
       );
       const keys = presentFrame ? (0, import_present.transformPresentationFrame)(presentFrame) : yield this.presentableKeys(hasher);
       const disclosures = keys.map((k) => hashmap[disclosureKeymap[k]]).filter((d) => d !== void 0);
-      const presentSDJwt = new _SDJwt({
-        jwt: this.jwt,
-        disclosures,
-        kbJwt: this.kbJwt
-      });
-      return presentSDJwt.encodeSDJwt();
+      return disclosures;
     });
   }
   encodeSDJwt() {
@@ -426,8 +435,168 @@ var pack = (claims, disclosureFrame, hash, saltGenerator) => __async(void 0, nul
 });
 
 // src/index.ts
-var import_types3 = require("@sd-jwt/types");
+var import_types5 = require("@sd-jwt/types");
+var import_decode5 = require("@sd-jwt/decode");
+
+// src/flattenJSON.ts
+var import_utils5 = require("@sd-jwt/utils");
 var import_decode3 = require("@sd-jwt/decode");
+var import_types3 = require("@sd-jwt/types");
+var FlattenJSON = class _FlattenJSON {
+  constructor(data) {
+    this.disclosures = data.disclosures;
+    this.kb_jwt = data.kb_jwt;
+    this.payload = data.jwtData.payload;
+    this.signature = data.jwtData.signature;
+    this.protected = data.jwtData.protected;
+  }
+  static fromEncode(encodedSdJwt) {
+    const { jwt, disclosures, kbJwt } = (0, import_decode3.splitSdJwt)(encodedSdJwt);
+    const { 0: protectedHeader, 1: payload, 2: signature } = jwt.split(".");
+    if (!protectedHeader || !payload || !signature) {
+      throw new import_utils5.SDJWTException("Invalid JWT");
+    }
+    return new _FlattenJSON({
+      jwtData: {
+        protected: protectedHeader,
+        payload,
+        signature
+      },
+      disclosures,
+      kb_jwt: kbJwt
+    });
+  }
+  static fromSerialized(json) {
+    return new _FlattenJSON({
+      jwtData: {
+        protected: json.protected,
+        payload: json.payload,
+        signature: json.signature
+      },
+      disclosures: json.header.disclosures,
+      kb_jwt: json.header.kb_jwt
+    });
+  }
+  toJson() {
+    return {
+      payload: this.payload,
+      signature: this.signature,
+      protected: this.protected,
+      header: {
+        disclosures: this.disclosures,
+        kb_jwt: this.kb_jwt
+      }
+    };
+  }
+  toEncoded() {
+    var _a;
+    const jwt = `${this.protected}.${this.payload}.${this.signature}`;
+    const disclosures = this.disclosures.join(import_types3.SD_SEPARATOR);
+    const kb_jwt = (_a = this.kb_jwt) != null ? _a : "";
+    return [jwt, disclosures, kb_jwt].join(import_types3.SD_SEPARATOR);
+  }
+};
+
+// src/generalJSON.ts
+var import_utils6 = require("@sd-jwt/utils");
+var import_decode4 = require("@sd-jwt/decode");
+var import_types4 = require("@sd-jwt/types");
+var GeneralJSON = class _GeneralJSON {
+  constructor(data) {
+    this.payload = data.payload;
+    this.disclosures = data.disclosures;
+    this.kb_jwt = data.kb_jwt;
+    this.signatures = data.signatures;
+  }
+  static fromEncode(encodedSdJwt) {
+    const { jwt, disclosures, kbJwt } = (0, import_decode4.splitSdJwt)(encodedSdJwt);
+    const { 0: protectedHeader, 1: payload, 2: signature } = jwt.split(".");
+    if (!protectedHeader || !payload || !signature) {
+      throw new import_utils6.SDJWTException("Invalid JWT");
+    }
+    return new _GeneralJSON({
+      payload,
+      disclosures,
+      kb_jwt: kbJwt,
+      signatures: [
+        {
+          protected: protectedHeader,
+          signature
+        }
+      ]
+    });
+  }
+  static fromSerialized(json) {
+    var _a, _b, _c;
+    if (!json.signatures[0]) {
+      throw new import_utils6.SDJWTException("Invalid JSON");
+    }
+    const disclosures = (_b = (_a = json.signatures[0].header) == null ? void 0 : _a.disclosures) != null ? _b : [];
+    const kb_jwt = (_c = json.signatures[0].header) == null ? void 0 : _c.kb_jwt;
+    return new _GeneralJSON({
+      payload: json.payload,
+      disclosures,
+      kb_jwt,
+      signatures: json.signatures.map((s) => {
+        var _a2;
+        return {
+          protected: s.protected,
+          signature: s.signature,
+          kid: (_a2 = s.header) == null ? void 0 : _a2.kid
+        };
+      })
+    });
+  }
+  toJson() {
+    return {
+      payload: this.payload,
+      signatures: this.signatures.map((s, i) => {
+        if (i !== 0) {
+          return {
+            header: {
+              kid: s.kid
+            },
+            protected: s.protected,
+            signature: s.signature
+          };
+        }
+        return {
+          header: {
+            disclosures: this.disclosures,
+            kid: s.kid,
+            kb_jwt: this.kb_jwt
+          },
+          protected: s.protected,
+          signature: s.signature
+        };
+      })
+    };
+  }
+  toEncoded(index) {
+    var _a;
+    if (index < 0 || index >= this.signatures.length) {
+      throw new import_utils6.SDJWTException("Index out of bounds");
+    }
+    const { protected: protectedHeader, signature } = this.signatures[index];
+    const disclosures = this.disclosures.join(import_types4.SD_SEPARATOR);
+    const kb_jwt = (_a = this.kb_jwt) != null ? _a : "";
+    const jwt = `${protectedHeader}.${this.payload}.${signature}`;
+    return [jwt, disclosures, kb_jwt].join(import_types4.SD_SEPARATOR);
+  }
+  addSignature(protectedHeader, signer, kid) {
+    return __async(this, null, function* () {
+      const header = (0, import_utils6.base64urlEncode)(JSON.stringify(protectedHeader));
+      const signature = yield signer(`${header}.${this.payload}`);
+      this.signatures.push({
+        protected: header,
+        signature,
+        kid
+      });
+    });
+  }
+};
+
+// src/index.ts
 var _SDJwtInstance = class _SDJwtInstance {
   constructor(userConfig) {
     this.userConfig = {};
@@ -438,15 +607,15 @@ var _SDJwtInstance = class _SDJwtInstance {
   createKBJwt(options, sdHash) {
     return __async(this, null, function* () {
       if (!this.userConfig.kbSigner) {
-        throw new import_utils5.SDJWTException("Key Binding Signer not found");
+        throw new import_utils7.SDJWTException("Key Binding Signer not found");
       }
       if (!this.userConfig.kbSignAlg) {
-        throw new import_utils5.SDJWTException("Key Binding sign algorithm not specified");
+        throw new import_utils7.SDJWTException("Key Binding sign algorithm not specified");
       }
       const { payload } = options;
       const kbJwt = new KBJwt({
         header: {
-          typ: import_types3.KB_JWT_TYP,
+          typ: import_types5.KB_JWT_TYP,
           alg: this.userConfig.kbSignAlg
         },
         payload: __spreadProps(__spreadValues({}, payload), { sd_hash: sdHash })
@@ -458,7 +627,7 @@ var _SDJwtInstance = class _SDJwtInstance {
   SignJwt(jwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.signer) {
-        throw new import_utils5.SDJWTException("Signer not found");
+        throw new import_utils7.SDJWTException("Signer not found");
       }
       yield jwt.sign(this.userConfig.signer);
       return jwt;
@@ -467,7 +636,7 @@ var _SDJwtInstance = class _SDJwtInstance {
   VerifyJwt(jwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.verifier) {
-        throw new import_utils5.SDJWTException("Verifier not found");
+        throw new import_utils7.SDJWTException("Verifier not found");
       }
       return jwt.verify(this.userConfig.verifier);
     });
@@ -476,13 +645,13 @@ var _SDJwtInstance = class _SDJwtInstance {
     return __async(this, null, function* () {
       var _a, _b;
       if (!this.userConfig.hasher) {
-        throw new import_utils5.SDJWTException("Hasher not found");
+        throw new import_utils7.SDJWTException("Hasher not found");
       }
       if (!this.userConfig.saltGenerator) {
-        throw new import_utils5.SDJWTException("SaltGenerator not found");
+        throw new import_utils7.SDJWTException("SaltGenerator not found");
       }
       if (!this.userConfig.signAlg) {
-        throw new import_utils5.SDJWTException("sign alogrithm not specified");
+        throw new import_utils7.SDJWTException("sign alogrithm not specified");
       }
       if (disclosureFrame) {
         this.validateReservedFields(disclosureFrame);
@@ -525,12 +694,12 @@ var _SDJwtInstance = class _SDJwtInstance {
     return __async(this, null, function* () {
       var _a;
       if (!this.userConfig.hasher) {
-        throw new import_utils5.SDJWTException("Hasher not found");
+        throw new import_utils7.SDJWTException("Hasher not found");
       }
       const hasher = this.userConfig.hasher;
       const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
       if (!((_a = sdjwt.jwt) == null ? void 0 : _a.payload))
-        throw new import_utils5.SDJWTException("Payload not found");
+        throw new import_utils7.SDJWTException("Payload not found");
       const presentSdJwtWithoutKb = yield sdjwt.present(
         presentationFrame,
         hasher
@@ -553,19 +722,19 @@ var _SDJwtInstance = class _SDJwtInstance {
   verify(encodedSDJwt, requiredClaimKeys, requireKeyBindings) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new import_utils5.SDJWTException("Hasher not found");
+        throw new import_utils7.SDJWTException("Hasher not found");
       }
       const hasher = this.userConfig.hasher;
       const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
       if (!sdjwt.jwt || !sdjwt.jwt.payload) {
-        throw new import_utils5.SDJWTException("Invalid SD JWT");
+        throw new import_utils7.SDJWTException("Invalid SD JWT");
       }
       const { payload, header } = yield this.validate(encodedSDJwt);
       if (requiredClaimKeys) {
         const keys = yield sdjwt.keys(hasher);
         const missingKeys = requiredClaimKeys.filter((k) => !keys.includes(k));
         if (missingKeys.length > 0) {
-          throw new import_utils5.SDJWTException(
+          throw new import_utils7.SDJWTException(
             `Missing required claim keys: ${missingKeys.join(", ")}`
           );
         }
@@ -574,10 +743,10 @@ var _SDJwtInstance = class _SDJwtInstance {
         return { payload, header };
       }
       if (!sdjwt.kbJwt) {
-        throw new import_utils5.SDJWTException("Key Binding JWT not exist");
+        throw new import_utils7.SDJWTException("Key Binding JWT not exist");
       }
       if (!this.userConfig.kbVerifier) {
-        throw new import_utils5.SDJWTException("Key Binding Verifier not found");
+        throw new import_utils7.SDJWTException("Key Binding Verifier not found");
       }
       const kb = yield sdjwt.kbJwt.verifyKB({
         verifier: this.userConfig.kbVerifier,
@@ -598,7 +767,7 @@ var _SDJwtInstance = class _SDJwtInstance {
         hasher
       );
       if (sdHashStr !== sdHashfromKb) {
-        throw new import_utils5.SDJWTException("Invalid sd_hash in Key Binding JWT");
+        throw new import_utils7.SDJWTException("Invalid sd_hash in Key Binding JWT");
       }
       return { payload, header, kb };
     });
@@ -606,11 +775,11 @@ var _SDJwtInstance = class _SDJwtInstance {
   calculateSDHash(presentSdJwtWithoutKb, sdjwt, hasher) {
     return __async(this, null, function* () {
       if (!sdjwt.jwt || !sdjwt.jwt.payload) {
-        throw new import_utils5.SDJWTException("Invalid SD JWT");
+        throw new import_utils7.SDJWTException("Invalid SD JWT");
       }
-      const { _sd_alg } = (0, import_decode3.getSDAlgAndPayload)(sdjwt.jwt.payload);
+      const { _sd_alg } = (0, import_decode5.getSDAlgAndPayload)(sdjwt.jwt.payload);
       const sdHash = yield hasher(presentSdJwtWithoutKb, _sd_alg);
-      const sdHashStr = (0, import_utils5.uint8ArrayToBase64Url)(sdHash);
+      const sdHashStr = (0, import_utils7.uint8ArrayToBase64Url)(sdHash);
       return sdHashStr;
     });
   }
@@ -619,12 +788,12 @@ var _SDJwtInstance = class _SDJwtInstance {
   validate(encodedSDJwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new import_utils5.SDJWTException("Hasher not found");
+        throw new import_utils7.SDJWTException("Hasher not found");
       }
       const hasher = this.userConfig.hasher;
       const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
       if (!sdjwt.jwt) {
-        throw new import_utils5.SDJWTException("Invalid SD JWT");
+        throw new import_utils7.SDJWTException("Invalid SD JWT");
       }
       const verifiedPayloads = yield this.VerifyJwt(sdjwt.jwt);
       const claims = yield sdjwt.getClaims(hasher);
@@ -639,14 +808,14 @@ var _SDJwtInstance = class _SDJwtInstance {
   }
   decode(endcodedSDJwt) {
     if (!this.userConfig.hasher) {
-      throw new import_utils5.SDJWTException("Hasher not found");
+      throw new import_utils7.SDJWTException("Hasher not found");
     }
     return SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
   }
   keys(endcodedSDJwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new import_utils5.SDJWTException("Hasher not found");
+        throw new import_utils7.SDJWTException("Hasher not found");
       }
       const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
       return sdjwt.keys(this.userConfig.hasher);
@@ -655,7 +824,7 @@ var _SDJwtInstance = class _SDJwtInstance {
   presentableKeys(endcodedSDJwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new import_utils5.SDJWTException("Hasher not found");
+        throw new import_utils7.SDJWTException("Hasher not found");
       }
       const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
       return sdjwt.presentableKeys(this.userConfig.hasher);
@@ -664,20 +833,299 @@ var _SDJwtInstance = class _SDJwtInstance {
   getClaims(endcodedSDJwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new import_utils5.SDJWTException("Hasher not found");
+        throw new import_utils7.SDJWTException("Hasher not found");
       }
       const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
       return sdjwt.getClaims(this.userConfig.hasher);
     });
   }
+  toFlattenJSON(endcodedSDJwt) {
+    return FlattenJSON.fromEncode(endcodedSDJwt);
+  }
+  toGeneralJSON(endcodedSDJwt) {
+    return GeneralJSON.fromEncode(endcodedSDJwt);
+  }
 };
 _SDJwtInstance.DEFAULT_hashAlg = "sha-256";
 var SDJwtInstance = _SDJwtInstance;
+var SDJwtGeneralJSONInstance = class {
+  constructor(userConfig) {
+    this.userConfig = {};
+    if (userConfig) {
+      this.userConfig = userConfig;
+    }
+  }
+  createKBJwt(options, sdHash) {
+    return __async(this, null, function* () {
+      if (!this.userConfig.kbSigner) {
+        throw new import_utils7.SDJWTException("Key Binding Signer not found");
+      }
+      if (!this.userConfig.kbSignAlg) {
+        throw new import_utils7.SDJWTException("Key Binding sign algorithm not specified");
+      }
+      const { payload } = options;
+      const kbJwt = new KBJwt({
+        header: {
+          typ: import_types5.KB_JWT_TYP,
+          alg: this.userConfig.kbSignAlg
+        },
+        payload: __spreadProps(__spreadValues({}, payload), { sd_hash: sdHash })
+      });
+      yield kbJwt.sign(this.userConfig.kbSigner);
+      return kbJwt;
+    });
+  }
+  encodeObj(obj) {
+    return (0, import_utils7.base64urlEncode)(JSON.stringify(obj));
+  }
+  issue(payload, disclosureFrame, options) {
+    return __async(this, null, function* () {
+      var _a;
+      if (!this.userConfig.hasher) {
+        throw new import_utils7.SDJWTException("Hasher not found");
+      }
+      if (!this.userConfig.saltGenerator) {
+        throw new import_utils7.SDJWTException("SaltGenerator not found");
+      }
+      if (disclosureFrame) {
+        this.validateReservedFields(disclosureFrame);
+      }
+      const hasher = this.userConfig.hasher;
+      const hashAlg = (_a = this.userConfig.hashAlg) != null ? _a : SDJwtInstance.DEFAULT_hashAlg;
+      const { packedClaims, disclosures } = yield pack(
+        payload,
+        disclosureFrame,
+        { hasher, alg: hashAlg },
+        this.userConfig.saltGenerator
+      );
+      const encodedDisclosures = disclosures.map((d) => d.encode());
+      const encodedSDJwtPayload = this.encodeObj(__spreadProps(__spreadValues({}, packedClaims), {
+        _sd_alg: disclosureFrame ? hashAlg : void 0
+      }));
+      const signatures = yield Promise.all(
+        options.sigs.map((s) => __async(this, null, function* () {
+          const { signer, alg, kid, header } = s;
+          const protectedHeader = __spreadValues({ typ: this.type, alg, kid }, header);
+          const encodedProtectedHeader = this.encodeObj(protectedHeader);
+          const signature = yield signer(
+            `${encodedProtectedHeader}.${encodedSDJwtPayload}`
+          );
+          return {
+            protected: encodedProtectedHeader,
+            kid,
+            signature
+          };
+        }))
+      );
+      const generalJson = new GeneralJSON({
+        payload: encodedSDJwtPayload,
+        disclosures: encodedDisclosures,
+        signatures
+      });
+      return generalJson;
+    });
+  }
+  /**
+   * Validates if the disclosureFrame contains any reserved fields. If so it will throw an error.
+   * @param disclosureFrame
+   * @returns
+   */
+  validateReservedFields(disclosureFrame) {
+    return;
+  }
+  present(generalJSON, presentationFrame, options) {
+    return __async(this, null, function* () {
+      var _a;
+      if (!this.userConfig.hasher) {
+        throw new import_utils7.SDJWTException("Hasher not found");
+      }
+      const hasher = this.userConfig.hasher;
+      const encodedSDJwt = generalJSON.toEncoded(0);
+      const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
+      if (!((_a = sdjwt.jwt) == null ? void 0 : _a.payload))
+        throw new import_utils7.SDJWTException("Payload not found");
+      const disclosures = yield sdjwt.getPresentDisclosures(
+        presentationFrame,
+        hasher
+      );
+      const encodedDisclosures = disclosures.map((d) => d.encode());
+      const presentedGeneralJSON = new GeneralJSON({
+        payload: generalJSON.payload,
+        disclosures: encodedDisclosures,
+        signatures: generalJSON.signatures
+      });
+      if (!(options == null ? void 0 : options.kb)) {
+        return presentedGeneralJSON;
+      }
+      const presentSdJwtWithoutKb = yield sdjwt.present(
+        presentationFrame,
+        hasher
+      );
+      const sdHashStr = yield this.calculateSDHash(
+        presentSdJwtWithoutKb,
+        sdjwt,
+        hasher
+      );
+      const kbJwt = yield this.createKBJwt(options.kb, sdHashStr);
+      const encodedKbJwt = kbJwt.encodeJwt();
+      presentedGeneralJSON.kb_jwt = encodedKbJwt;
+      return presentedGeneralJSON;
+    });
+  }
+  // This function is for verifying the SD JWT
+  // If requiredClaimKeys is provided, it will check if the required claim keys are presentation in the SD JWT
+  // If requireKeyBindings is true, it will check if the key binding JWT is presentation and verify it
+  verify(generalJSON, requiredClaimKeys, requireKeyBindings) {
+    return __async(this, null, function* () {
+      if (!this.userConfig.hasher) {
+        throw new import_utils7.SDJWTException("Hasher not found");
+      }
+      const hasher = this.userConfig.hasher;
+      const { payload, headers } = yield this.validate(generalJSON);
+      const encodedSDJwt = generalJSON.toEncoded(0);
+      const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
+      if (!sdjwt.jwt || !sdjwt.jwt.payload) {
+        throw new import_utils7.SDJWTException("Invalid SD JWT");
+      }
+      if (requiredClaimKeys) {
+        const keys = yield sdjwt.keys(hasher);
+        const missingKeys = requiredClaimKeys.filter((k) => !keys.includes(k));
+        if (missingKeys.length > 0) {
+          throw new import_utils7.SDJWTException(
+            `Missing required claim keys: ${missingKeys.join(", ")}`
+          );
+        }
+      }
+      if (!requireKeyBindings) {
+        return { payload, headers };
+      }
+      if (!sdjwt.kbJwt) {
+        throw new import_utils7.SDJWTException("Key Binding JWT not exist");
+      }
+      if (!this.userConfig.kbVerifier) {
+        throw new import_utils7.SDJWTException("Key Binding Verifier not found");
+      }
+      const kb = yield sdjwt.kbJwt.verifyKB({
+        verifier: this.userConfig.kbVerifier,
+        payload
+      });
+      if (!kb) {
+        throw new Error("signature is not valid");
+      }
+      const sdHashfromKb = kb.payload.sd_hash;
+      const sdjwtWithoutKb = new SDJwt({
+        jwt: sdjwt.jwt,
+        disclosures: sdjwt.disclosures
+      });
+      const presentSdJwtWithoutKb = sdjwtWithoutKb.encodeSDJwt();
+      const sdHashStr = yield this.calculateSDHash(
+        presentSdJwtWithoutKb,
+        sdjwt,
+        hasher
+      );
+      if (sdHashStr !== sdHashfromKb) {
+        throw new import_utils7.SDJWTException("Invalid sd_hash in Key Binding JWT");
+      }
+      return { payload, headers, kb };
+    });
+  }
+  calculateSDHash(presentSdJwtWithoutKb, sdjwt, hasher) {
+    return __async(this, null, function* () {
+      if (!sdjwt.jwt || !sdjwt.jwt.payload) {
+        throw new import_utils7.SDJWTException("Invalid SD JWT");
+      }
+      const { _sd_alg } = (0, import_decode5.getSDAlgAndPayload)(sdjwt.jwt.payload);
+      const sdHash = yield hasher(presentSdJwtWithoutKb, _sd_alg);
+      const sdHashStr = (0, import_utils7.uint8ArrayToBase64Url)(sdHash);
+      return sdHashStr;
+    });
+  }
+  // This function is for validating the SD JWT
+  // Just checking signature and return its the claims
+  validate(generalJSON) {
+    return __async(this, null, function* () {
+      if (!this.userConfig.hasher) {
+        throw new import_utils7.SDJWTException("Hasher not found");
+      }
+      if (!this.userConfig.verifier) {
+        throw new import_utils7.SDJWTException("Verifier not found");
+      }
+      const hasher = this.userConfig.hasher;
+      const verifier = this.userConfig.verifier;
+      const { payload, signatures } = generalJSON;
+      const results = yield Promise.all(
+        signatures.map((s) => __async(this, null, function* () {
+          const { protected: encodedHeader, signature } = s;
+          const verified2 = yield verifier(
+            `${encodedHeader}.${payload}`,
+            signature
+          );
+          const header = JSON.parse((0, import_utils7.base64urlDecode)(encodedHeader));
+          return { verified: verified2, header };
+        }))
+      );
+      const verified = results.every((r) => r.verified);
+      if (!verified) {
+        throw new import_utils7.SDJWTException("Signature is not valid");
+      }
+      const encodedSDJwt = generalJSON.toEncoded(0);
+      const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
+      if (!sdjwt.jwt) {
+        throw new import_utils7.SDJWTException("Invalid SD JWT");
+      }
+      const claims = yield sdjwt.getClaims(hasher);
+      return { payload: claims, headers: results.map((r) => r.header) };
+    });
+  }
+  config(newConfig) {
+    this.userConfig = __spreadValues(__spreadValues({}, this.userConfig), newConfig);
+  }
+  encode(sdJwt, index) {
+    return sdJwt.toEncoded(index);
+  }
+  decode(endcodedSDJwt) {
+    return GeneralJSON.fromEncode(endcodedSDJwt);
+  }
+  keys(generalSdjwt) {
+    return __async(this, null, function* () {
+      if (!this.userConfig.hasher) {
+        throw new import_utils7.SDJWTException("Hasher not found");
+      }
+      const endcodedSDJwt = generalSdjwt.toEncoded(0);
+      const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
+      return sdjwt.keys(this.userConfig.hasher);
+    });
+  }
+  presentableKeys(generalSdjwt) {
+    return __async(this, null, function* () {
+      if (!this.userConfig.hasher) {
+        throw new import_utils7.SDJWTException("Hasher not found");
+      }
+      const endcodedSDJwt = generalSdjwt.toEncoded(0);
+      const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
+      return sdjwt.presentableKeys(this.userConfig.hasher);
+    });
+  }
+  getClaims(generalSdjwt) {
+    return __async(this, null, function* () {
+      if (!this.userConfig.hasher) {
+        throw new import_utils7.SDJWTException("Hasher not found");
+      }
+      const endcodedSDJwt = generalSdjwt.toEncoded(0);
+      const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
+      return sdjwt.getClaims(this.userConfig.hasher);
+    });
+  }
+};
+SDJwtGeneralJSONInstance.DEFAULT_hashAlg = "sha-256";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  FlattenJSON,
+  GeneralJSON,
   Jwt,
   KBJwt,
   SDJwt,
+  SDJwtGeneralJSONInstance,
   SDJwtInstance,
   createDecoy,
   listKeys,