@sd-jwt/core 0.7.2 → 0.8.0

package/dist/index.mjs

@@ -39,7 +39,12 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/index.ts
-import { SDJWTException as SDJWTException4, uint8ArrayToBase64Url as uint8ArrayToBase64Url2 } from "@sd-jwt/utils";
+import {
+  base64urlDecode,
+  base64urlEncode as base64urlEncode3,
+  SDJWTException as SDJWTException6,
+  uint8ArrayToBase64Url as uint8ArrayToBase64Url2
+} from "@sd-jwt/utils";
 
 // src/jwt.ts
 import { base64urlEncode, SDJWTException } from "@sd-jwt/utils";
@@ -237,6 +242,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) {
@@ -252,12 +268,7 @@ var SDJwt = class _SDJwt {
       );
       const keys = presentFrame ? 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() {
@@ -410,6 +421,166 @@ import {
   KB_JWT_TYP as KB_JWT_TYP2
 } from "@sd-jwt/types";
 import { getSDAlgAndPayload as getSDAlgAndPayload2 } from "@sd-jwt/decode";
+
+// src/flattenJSON.ts
+import { SDJWTException as SDJWTException4 } from "@sd-jwt/utils";
+import { splitSdJwt } from "@sd-jwt/decode";
+import { SD_SEPARATOR as SD_SEPARATOR2 } from "@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 } = splitSdJwt(encodedSdJwt);
+    const { 0: protectedHeader, 1: payload, 2: signature } = jwt.split(".");
+    if (!protectedHeader || !payload || !signature) {
+      throw new SDJWTException4("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(SD_SEPARATOR2);
+    const kb_jwt = (_a = this.kb_jwt) != null ? _a : "";
+    return [jwt, disclosures, kb_jwt].join(SD_SEPARATOR2);
+  }
+};
+
+// src/generalJSON.ts
+import { base64urlEncode as base64urlEncode2, SDJWTException as SDJWTException5 } from "@sd-jwt/utils";
+import { splitSdJwt as splitSdJwt2 } from "@sd-jwt/decode";
+import { SD_SEPARATOR as SD_SEPARATOR3 } from "@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 } = splitSdJwt2(encodedSdJwt);
+    const { 0: protectedHeader, 1: payload, 2: signature } = jwt.split(".");
+    if (!protectedHeader || !payload || !signature) {
+      throw new SDJWTException5("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 SDJWTException5("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 SDJWTException5("Index out of bounds");
+    }
+    const { protected: protectedHeader, signature } = this.signatures[index];
+    const disclosures = this.disclosures.join(SD_SEPARATOR3);
+    const kb_jwt = (_a = this.kb_jwt) != null ? _a : "";
+    const jwt = `${protectedHeader}.${this.payload}.${signature}`;
+    return [jwt, disclosures, kb_jwt].join(SD_SEPARATOR3);
+  }
+  addSignature(protectedHeader, signer, kid) {
+    return __async(this, null, function* () {
+      const header = base64urlEncode2(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 = {};
@@ -420,10 +591,10 @@ var _SDJwtInstance = class _SDJwtInstance {
   createKBJwt(options, sdHash) {
     return __async(this, null, function* () {
       if (!this.userConfig.kbSigner) {
-        throw new SDJWTException4("Key Binding Signer not found");
+        throw new SDJWTException6("Key Binding Signer not found");
       }
       if (!this.userConfig.kbSignAlg) {
-        throw new SDJWTException4("Key Binding sign algorithm not specified");
+        throw new SDJWTException6("Key Binding sign algorithm not specified");
       }
       const { payload } = options;
       const kbJwt = new KBJwt({
@@ -440,7 +611,7 @@ var _SDJwtInstance = class _SDJwtInstance {
   SignJwt(jwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.signer) {
-        throw new SDJWTException4("Signer not found");
+        throw new SDJWTException6("Signer not found");
       }
       yield jwt.sign(this.userConfig.signer);
       return jwt;
@@ -449,7 +620,7 @@ var _SDJwtInstance = class _SDJwtInstance {
   VerifyJwt(jwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.verifier) {
-        throw new SDJWTException4("Verifier not found");
+        throw new SDJWTException6("Verifier not found");
       }
       return jwt.verify(this.userConfig.verifier);
     });
@@ -458,13 +629,13 @@ var _SDJwtInstance = class _SDJwtInstance {
     return __async(this, null, function* () {
       var _a, _b;
       if (!this.userConfig.hasher) {
-        throw new SDJWTException4("Hasher not found");
+        throw new SDJWTException6("Hasher not found");
       }
       if (!this.userConfig.saltGenerator) {
-        throw new SDJWTException4("SaltGenerator not found");
+        throw new SDJWTException6("SaltGenerator not found");
       }
       if (!this.userConfig.signAlg) {
-        throw new SDJWTException4("sign alogrithm not specified");
+        throw new SDJWTException6("sign alogrithm not specified");
       }
       if (disclosureFrame) {
         this.validateReservedFields(disclosureFrame);
@@ -507,12 +678,12 @@ var _SDJwtInstance = class _SDJwtInstance {
     return __async(this, null, function* () {
       var _a;
       if (!this.userConfig.hasher) {
-        throw new SDJWTException4("Hasher not found");
+        throw new SDJWTException6("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 SDJWTException4("Payload not found");
+        throw new SDJWTException6("Payload not found");
       const presentSdJwtWithoutKb = yield sdjwt.present(
         presentationFrame,
         hasher
@@ -535,19 +706,19 @@ var _SDJwtInstance = class _SDJwtInstance {
   verify(encodedSDJwt, requiredClaimKeys, requireKeyBindings) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException4("Hasher not found");
+        throw new SDJWTException6("Hasher not found");
       }
       const hasher = this.userConfig.hasher;
       const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
       if (!sdjwt.jwt || !sdjwt.jwt.payload) {
-        throw new SDJWTException4("Invalid SD JWT");
+        throw new SDJWTException6("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 SDJWTException4(
+          throw new SDJWTException6(
             `Missing required claim keys: ${missingKeys.join(", ")}`
           );
         }
@@ -556,10 +727,10 @@ var _SDJwtInstance = class _SDJwtInstance {
         return { payload, header };
       }
       if (!sdjwt.kbJwt) {
-        throw new SDJWTException4("Key Binding JWT not exist");
+        throw new SDJWTException6("Key Binding JWT not exist");
       }
       if (!this.userConfig.kbVerifier) {
-        throw new SDJWTException4("Key Binding Verifier not found");
+        throw new SDJWTException6("Key Binding Verifier not found");
       }
       const kb = yield sdjwt.kbJwt.verifyKB({
         verifier: this.userConfig.kbVerifier,
@@ -580,7 +751,7 @@ var _SDJwtInstance = class _SDJwtInstance {
         hasher
       );
       if (sdHashStr !== sdHashfromKb) {
-        throw new SDJWTException4("Invalid sd_hash in Key Binding JWT");
+        throw new SDJWTException6("Invalid sd_hash in Key Binding JWT");
       }
       return { payload, header, kb };
     });
@@ -588,7 +759,7 @@ var _SDJwtInstance = class _SDJwtInstance {
   calculateSDHash(presentSdJwtWithoutKb, sdjwt, hasher) {
     return __async(this, null, function* () {
       if (!sdjwt.jwt || !sdjwt.jwt.payload) {
-        throw new SDJWTException4("Invalid SD JWT");
+        throw new SDJWTException6("Invalid SD JWT");
       }
       const { _sd_alg } = getSDAlgAndPayload2(sdjwt.jwt.payload);
       const sdHash = yield hasher(presentSdJwtWithoutKb, _sd_alg);
@@ -601,12 +772,12 @@ var _SDJwtInstance = class _SDJwtInstance {
   validate(encodedSDJwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException4("Hasher not found");
+        throw new SDJWTException6("Hasher not found");
       }
       const hasher = this.userConfig.hasher;
       const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
       if (!sdjwt.jwt) {
-        throw new SDJWTException4("Invalid SD JWT");
+        throw new SDJWTException6("Invalid SD JWT");
       }
       const verifiedPayloads = yield this.VerifyJwt(sdjwt.jwt);
       const claims = yield sdjwt.getClaims(hasher);
@@ -621,14 +792,14 @@ var _SDJwtInstance = class _SDJwtInstance {
   }
   decode(endcodedSDJwt) {
     if (!this.userConfig.hasher) {
-      throw new SDJWTException4("Hasher not found");
+      throw new SDJWTException6("Hasher not found");
     }
     return SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
   }
   keys(endcodedSDJwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException4("Hasher not found");
+        throw new SDJWTException6("Hasher not found");
       }
       const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
       return sdjwt.keys(this.userConfig.hasher);
@@ -637,7 +808,7 @@ var _SDJwtInstance = class _SDJwtInstance {
   presentableKeys(endcodedSDJwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException4("Hasher not found");
+        throw new SDJWTException6("Hasher not found");
       }
       const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
       return sdjwt.presentableKeys(this.userConfig.hasher);
@@ -646,19 +817,298 @@ var _SDJwtInstance = class _SDJwtInstance {
   getClaims(endcodedSDJwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException4("Hasher not found");
+        throw new SDJWTException6("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 SDJWTException6("Key Binding Signer not found");
+      }
+      if (!this.userConfig.kbSignAlg) {
+        throw new SDJWTException6("Key Binding sign algorithm not specified");
+      }
+      const { payload } = options;
+      const kbJwt = new KBJwt({
+        header: {
+          typ: KB_JWT_TYP2,
+          alg: this.userConfig.kbSignAlg
+        },
+        payload: __spreadProps(__spreadValues({}, payload), { sd_hash: sdHash })
+      });
+      yield kbJwt.sign(this.userConfig.kbSigner);
+      return kbJwt;
+    });
+  }
+  encodeObj(obj) {
+    return base64urlEncode3(JSON.stringify(obj));
+  }
+  issue(payload, disclosureFrame, options) {
+    return __async(this, null, function* () {
+      var _a;
+      if (!this.userConfig.hasher) {
+        throw new SDJWTException6("Hasher not found");
+      }
+      if (!this.userConfig.saltGenerator) {
+        throw new SDJWTException6("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 SDJWTException6("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 SDJWTException6("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 SDJWTException6("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 SDJWTException6("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 SDJWTException6(
+            `Missing required claim keys: ${missingKeys.join(", ")}`
+          );
+        }
+      }
+      if (!requireKeyBindings) {
+        return { payload, headers };
+      }
+      if (!sdjwt.kbJwt) {
+        throw new SDJWTException6("Key Binding JWT not exist");
+      }
+      if (!this.userConfig.kbVerifier) {
+        throw new SDJWTException6("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 SDJWTException6("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 SDJWTException6("Invalid SD JWT");
+      }
+      const { _sd_alg } = getSDAlgAndPayload2(sdjwt.jwt.payload);
+      const sdHash = yield hasher(presentSdJwtWithoutKb, _sd_alg);
+      const sdHashStr = uint8ArrayToBase64Url2(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 SDJWTException6("Hasher not found");
+      }
+      if (!this.userConfig.verifier) {
+        throw new SDJWTException6("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(base64urlDecode(encodedHeader));
+          return { verified: verified2, header };
+        }))
+      );
+      const verified = results.every((r) => r.verified);
+      if (!verified) {
+        throw new SDJWTException6("Signature is not valid");
+      }
+      const encodedSDJwt = generalJSON.toEncoded(0);
+      const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
+      if (!sdjwt.jwt) {
+        throw new SDJWTException6("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 SDJWTException6("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 SDJWTException6("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 SDJWTException6("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";
 export {
+  FlattenJSON,
+  GeneralJSON,
   Jwt,
   KBJwt,
   SDJwt,
+  SDJwtGeneralJSONInstance,
   SDJwtInstance,
   createDecoy,
   listKeys,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sd-jwt/core",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "sd-jwt draft 7 implementation in typescript",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -38,13 +38,13 @@
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "@sd-jwt/crypto-nodejs": "0.7.2"
+    "@sd-jwt/crypto-nodejs": "0.8.0"
   },
   "dependencies": {
-    "@sd-jwt/decode": "0.7.2",
-    "@sd-jwt/present": "0.7.2",
-    "@sd-jwt/types": "0.7.2",
-    "@sd-jwt/utils": "0.7.2"
+    "@sd-jwt/decode": "0.8.0",
+    "@sd-jwt/present": "0.8.0",
+    "@sd-jwt/types": "0.8.0",
+    "@sd-jwt/utils": "0.8.0"
   },
   "publishConfig": {
     "access": "public"
@@ -62,5 +62,5 @@
       "esm"
     ]
   },
-  "gitHead": "d3cc53b66be9ef40ede9f86a931b7a43f55dbd3a"
+  "gitHead": "0d9742cd87d643079c7828ac3689d39ac4f6f21d"
 }