@sd-jwt/core 0.19.1-next.5 → 0.19.1-next.6

package/src/present/present.ts

@@ -0,0 +1,210 @@
+import {
+  createHashMapping,
+  createHashMappingSync,
+  decodeSdJwt,
+  decodeSdJwtSync,
+  getSDAlgAndPayload,
+  splitSdJwt,
+  unpack,
+  unpackObj,
+  unpackSync,
+} from '../decode';
+import type { Extensible, HasherSync } from '../types';
+import { type Hasher, type PresentationFrame, SD_SEPARATOR } from '../types';
+import { Disclosure, SDJWTException } from '../utils';
+
+// Presentable keys
+// The presentable keys are the path of JSON object that are presentable in the SD JWT
+// e.g. if the SD JWT has the following payload and set sd like this:
+// {
+//   "foo": "bar",  // sd
+//   "arr": [       // sd
+//     "1",         // sd
+//     "2",
+//     {
+//       "a": "1"   // sd
+//     }
+//   ],
+//   "test": {
+//     "zzz": "xxx" // sd
+//   }
+// }
+// The presentable keys are: ["arr", "arr.0", "arr.2.a", "foo", "test.zzz"]
+export const presentableKeys = async (
+  rawPayload: Record<string, unknown>,
+  disclosures: Array<Disclosure>,
+  hasher: Hasher,
+): Promise<string[]> => {
+  const { disclosureKeymap } = await unpack(rawPayload, disclosures, hasher);
+  return Object.keys(disclosureKeymap).sort();
+};
+
+export const presentableKeysSync = (
+  rawPayload: Record<string, unknown>,
+  disclosures: Array<Disclosure>,
+  hasher: HasherSync,
+): string[] => {
+  const { disclosureKeymap } = unpackSync(rawPayload, disclosures, hasher);
+  return Object.keys(disclosureKeymap).sort();
+};
+
+export const present = async <T extends Record<string, unknown>>(
+  sdJwt: string,
+  presentFrame: PresentationFrame<T>,
+  hasher: Hasher,
+): Promise<string> => {
+  const { jwt, kbJwt } = splitSdJwt(sdJwt);
+  const {
+    jwt: { payload },
+    disclosures,
+  } = await decodeSdJwt(sdJwt, hasher);
+
+  const { _sd_alg: alg } = getSDAlgAndPayload(payload);
+  const hash = { alg, hasher };
+  const keys = transformPresentationFrame(presentFrame);
+
+  // hashmap: <digest> => <disclosure>
+  // to match the digest with the disclosure
+  const hashmap = await createHashMapping(disclosures, hash);
+  const { disclosureKeymap } = await unpack(payload, disclosures, hasher);
+  const presentedDisclosures = keys
+    .map((k) => hashmap[disclosureKeymap[k]])
+    .filter((d) => d !== undefined);
+
+  return [
+    jwt,
+    ...presentedDisclosures.map((d) => d.encode()),
+    kbJwt ?? '',
+  ].join(SD_SEPARATOR);
+};
+
+export const presentSync = <T extends Record<string, unknown>>(
+  sdJwt: string,
+  presentFrame: PresentationFrame<T>,
+  hasher: HasherSync,
+): string => {
+  const { jwt, kbJwt } = splitSdJwt(sdJwt);
+  const {
+    jwt: { payload },
+    disclosures,
+  } = decodeSdJwtSync(sdJwt, hasher);
+
+  const { _sd_alg: alg } = getSDAlgAndPayload(payload);
+  const hash = { alg, hasher };
+  const keys = transformPresentationFrame(presentFrame);
+
+  // hashmap: <digest> => <disclosure>
+  // to match the digest with the disclosure
+  const hashmap = createHashMappingSync(disclosures, hash);
+  const { disclosureKeymap } = unpackSync(payload, disclosures, hasher);
+
+  const presentedDisclosures = keys
+    .map((k) => hashmap[disclosureKeymap[k]])
+    .filter((d) => d !== undefined);
+
+  return [
+    jwt,
+    ...presentedDisclosures.map((d) => d.encode()),
+    kbJwt ?? '',
+  ].join(SD_SEPARATOR);
+};
+
+/**
+ * Transform the object keys into an array of strings. We are not sorting the array in any way.
+ * @param obj The object to transform
+ * @param prefix The prefix to add to the keys
+ * @returns
+ */
+export const transformPresentationFrame = (
+  obj: PresentationFrame<Extensible>,
+  prefix = '',
+): string[] => {
+  return Object.entries(obj).reduce<string[]>((acc, [key, value]) => {
+    const newPrefix = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === 'boolean') {
+      // only add it, when it's true
+      if (value) {
+        acc.push(newPrefix);
+      }
+    } else if (typeof value === 'object' && value !== null) {
+      acc.push(
+        newPrefix,
+        ...transformPresentationFrame(
+          value as PresentationFrame<Extensible>,
+          newPrefix,
+        ),
+      );
+    }
+    return acc;
+  }, []);
+};
+
+export type SerializedDisclosure = {
+  digest: string;
+  encoded: string;
+  salt: string;
+  key: string | undefined;
+  value: unknown;
+};
+
+export const createHashMappingForSerializedDisclosure = (
+  disclosures: SerializedDisclosure[],
+) => {
+  const map: Record<string, Disclosure> = {};
+  for (let i = 0; i < disclosures.length; i++) {
+    const disclosure = disclosures[i];
+    const { digest, encoded, key, salt, value } = disclosure;
+    // we made Disclosure to fit the interface of unpack
+    map[digest] = Disclosure.fromArray(
+      key ? [salt, key, value] : [salt, value],
+      { digest, encoded },
+    );
+  }
+  return map;
+};
+
+/**
+ * This function selects the serialized disclosures from the payload
+ * and array of serialized disclosure based on the presentation frame.
+ * If you want to know what is serialized disclosures, check type SerializedDisclosure.
+ * @param payload: Record<string, unknown>
+ * @param disclosures: SerializedDisclosure[]
+ * @param presentationFrame: PresentationFrame<T>
+ */
+export const selectDisclosures = <T extends Record<string, unknown>>(
+  payload: Record<string, unknown>,
+  disclosures: SerializedDisclosure[],
+  presentationFrame: PresentationFrame<T>,
+) => {
+  if (disclosures.length === 0) {
+    return [];
+  }
+
+  const hashmap = createHashMappingForSerializedDisclosure(disclosures);
+  const { disclosureKeymap } = unpackObj(payload, hashmap);
+  const keys = transformPresentationFrame(presentationFrame);
+
+  const presentedDisclosures = keys
+    .map((k) => hashmap[disclosureKeymap[k]])
+    .filter((d) => d !== undefined);
+
+  const selectedDisclosures: SerializedDisclosure[] = presentedDisclosures.map(
+    (d) => {
+      const { salt, key, value, _digest } = d;
+      if (!_digest) {
+        throw new SDJWTException(
+          'Implementation error: _digest is not defined',
+        );
+      }
+      return {
+        digest: _digest,
+        encoded: d.encode(),
+        salt,
+        key,
+        value,
+      };
+    },
+  );
+
+  return selectedDisclosures;
+};

package/src/sdjwt.ts

@@ -1,5 +1,8 @@
-import { createHashMapping, getSDAlgAndPayload, unpack } from '@sd-jwt/decode';
-import { transformPresentationFrame } from '@sd-jwt/present';
+import { createHashMapping, getSDAlgAndPayload, unpack } from './decode';
+import { createDecoy } from './decoy';
+import { Jwt } from './jwt';
+import { KBJwt } from './kbjwt';
+import { transformPresentationFrame } from './present';
 import {
   type DisclosureFrame,
   type Hasher,
@@ -13,11 +16,8 @@ import {
   SD_LIST_KEY,
   SD_SEPARATOR,
   type SDJWTCompact,
-} from '@sd-jwt/types';
-import { Disclosure, SDJWTException } from '@sd-jwt/utils';
-import { createDecoy } from './decoy';
-import { Jwt } from './jwt';
-import { KBJwt } from './kbjwt';
+} from './types';
+import { Disclosure, SDJWTException } from './utils';
 
 export type SDJwtData<
   Header extends Record<string, unknown>,
@@ -81,7 +81,7 @@ export class SDJwt<
     const { _sd_alg } = getSDAlgAndPayload(jwt.payload);
 
     const disclosures = await Promise.all(
-      (encodedDisclosures as Array<string>).map((ed) =>
+      encodedDisclosures.map((ed) =>
         Disclosure.fromEncode(ed, { alg: _sd_alg, hasher }),
       ),
     );
@@ -221,8 +221,9 @@ export const listKeys = (obj: Record<string, unknown>, prefix = '') => {
     const newKey = prefix ? `${prefix}.${key}` : key;
     keys.push(newKey);
 
-    if (obj[key] && typeof obj[key] === 'object' && obj[key] !== null) {
-      keys.push(...listKeys(obj[key] as Record<string, unknown>, newKey));
+    const value = obj[key];
+    if (value && typeof value === 'object') {
+      keys.push(...listKeys(value as Record<string, unknown>, newKey));
     }
   }
   return keys;

package/src/test/decode/decode.spec.ts

@@ -0,0 +1,202 @@
+import { hasher as digest } from '@owf/crypto';
+import { describe, expect, test } from 'vitest';
+import {
+  createHashMapping,
+  decodeJwt,
+  decodeSdJwt,
+  decodeSdJwtSync,
+  getClaims,
+  getClaimsSync,
+  getSDAlgAndPayload,
+  splitSdJwt,
+  unpackObj,
+} from '../../decode';
+
+describe('decode tests', () => {
+  test('decode jwt', () => {
+    const jwt =
+      'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+    const { header, payload, signature } = decodeJwt(jwt);
+    expect(signature).toBeDefined();
+    expect(header).toStrictEqual({ alg: 'HS256', typ: 'JWT' });
+    expect(payload).toStrictEqual({
+      sub: '1234567890',
+      name: 'John Doe',
+      iat: 1516239022,
+    });
+  });
+
+  test('decode jwt with invalid input', () => {
+    const jwt = 'invalid.invalid';
+    expect(() => decodeJwt(jwt)).toThrow('Invalid JWT as input');
+  });
+
+  test('split sdjwt', () => {
+    const sdjwt = 'h.p.s~d1~d2~';
+    const { jwt, disclosures, kbJwt } = splitSdJwt(sdjwt);
+    expect(jwt).toBe('h.p.s');
+    expect(disclosures).toStrictEqual(['d1', 'd2']);
+    expect(kbJwt).toBeUndefined();
+  });
+
+  test('split sdjwt without disclosures', () => {
+    const sdjwt = 'h.p.s';
+    const { jwt, disclosures, kbJwt } = splitSdJwt(sdjwt);
+    expect(jwt).toBe('h.p.s');
+    expect(disclosures).toStrictEqual([]);
+    expect(kbJwt).toBeUndefined();
+  });
+
+  test('split sdjwt with kbjwt', () => {
+    const sdjwt = 'h.p.s~d1~d2~kbh.kbp.kbs';
+    const { jwt, disclosures, kbJwt } = splitSdJwt(sdjwt);
+    expect(jwt).toBe('h.p.s');
+    expect(disclosures).toStrictEqual(['d1', 'd2']);
+    expect(kbJwt).toBe('kbh.kbp.kbs');
+  });
+
+  test('decode sdjwt', async () => {
+    const sdjwt =
+      'eyJ0eXAiOiJzZC1qd3QiLCJhbGciOiJFZERTQSJ9.eyJfc2QiOlsiaWQ1azZ1ZVplVTY4bExaMlU2YjJJbF9QR3ZKb1RDMlpkMkpwY0RwMzFIWSJdLCJfc2RfYWxnIjoic2hhLTI1NiJ9.GiLF_HhacrstqCJ223VvWOoJJWU8qk4dYQHklSMwxv36pPF_7ER53Wbty1qYRlQ6NeMUdBRRdj9JQLLCzz1gCQ~WyI2NTMxNDA2ZmVhZmU0YjBmIiwiZm9vIiwiYmFyIl0~';
+    const decodedSdJwt = await decodeSdJwt(sdjwt, digest);
+    expect(decodedSdJwt).toBeDefined();
+    expect(decodedSdJwt.kbJwt).toBeUndefined();
+    expect(decodedSdJwt.disclosures.length).toEqual(1);
+    expect(decodedSdJwt.jwt).toBeDefined();
+  });
+
+  test('decode jwt', async () => {
+    const jwt =
+      'eyJhbGciOiJIUzI1NiIsInR5cCI6InNkK2p3dCJ9.eyJsYXN0bmFtZSI6IkRvZSIsInNzbiI6IjEyMy00NS02Nzg5IiwiX3NkIjpbIk4yUXhZV1UxTlRnME1qQmpOR1JpWVRCaU1tRmtaamN5WXpSbFpXUmhaRGd5WkRCbE1qaGhZVGcwTnpJMU9XSXpZek5qWkdNNE1qZG1NVGN6TmpZd05RIiwiWlRSalkyUTVOemRoWkRVM05tWTFZV0UyTmpka01XVmpNRE16WXpOak5qQmtNak5pT0dZelpHSTBOelV4TURsak9EWTRNREEzWm1JeFpUY3daREZqTmciXSwiX3NkX2FsZyI6InNoYS0yNTYifQ.mX14Sw86xy8NFQta7tCfNmhVCqzfaJ_K3VEIhTjbLDY';
+    const decodedSdJwt = await decodeSdJwt(jwt, digest);
+    expect(decodedSdJwt).toBeDefined();
+    expect(decodedSdJwt.kbJwt).toBeUndefined();
+    expect(decodedSdJwt.disclosures.length).toEqual(0);
+    expect(decodedSdJwt.jwt).toBeDefined();
+  });
+
+  test('decode sdjwt sync', () => {
+    const sdjwt =
+      'eyJ0eXAiOiJzZC1qd3QiLCJhbGciOiJFZERTQSJ9.eyJfc2QiOlsiaWQ1azZ1ZVplVTY4bExaMlU2YjJJbF9QR3ZKb1RDMlpkMkpwY0RwMzFIWSJdLCJfc2RfYWxnIjoic2hhLTI1NiJ9.GiLF_HhacrstqCJ223VvWOoJJWU8qk4dYQHklSMwxv36pPF_7ER53Wbty1qYRlQ6NeMUdBRRdj9JQLLCzz1gCQ~WyI2NTMxNDA2ZmVhZmU0YjBmIiwiZm9vIiwiYmFyIl0~';
+    const decodedSdJwt = decodeSdJwtSync(sdjwt, digest);
+    expect(decodedSdJwt).toBeDefined();
+    expect(decodedSdJwt.kbJwt).toBeUndefined();
+    expect(decodedSdJwt.disclosures.length).toEqual(1);
+    expect(decodedSdJwt.jwt).toBeDefined();
+  });
+
+  test('decode jwt sync', () => {
+    const jwt =
+      'eyJhbGciOiJIUzI1NiIsInR5cCI6InNkK2p3dCJ9.eyJsYXN0bmFtZSI6IkRvZSIsInNzbiI6IjEyMy00NS02Nzg5IiwiX3NkIjpbIk4yUXhZV1UxTlRnME1qQmpOR1JpWVRCaU1tRmtaamN5WXpSbFpXUmhaRGd5WkRCbE1qaGhZVGcwTnpJMU9XSXpZek5qWkdNNE1qZG1NVGN6TmpZd05RIiwiWlRSalkyUTVOemRoWkRVM05tWTFZV0UyTmpka01XVmpNRE16WXpOak5qQmtNak5pT0dZelpHSTBOelV4TURsak9EWTRNREEzWm1JeFpUY3daREZqTmciXSwiX3NkX2FsZyI6InNoYS0yNTYifQ.mX14Sw86xy8NFQta7tCfNmhVCqzfaJ_K3VEIhTjbLDY';
+    const decodedSdJwt = decodeSdJwtSync(jwt, digest);
+    expect(decodedSdJwt).toBeDefined();
+    expect(decodedSdJwt.kbJwt).toBeUndefined();
+    expect(decodedSdJwt.disclosures.length).toEqual(0);
+    expect(decodedSdJwt.jwt).toBeDefined();
+  });
+
+  test('decode sdjwt sync (with KB)', () => {
+    const sdjwt =
+      'eyJ0eXAiOiJzZCtqd3QiLCJhbGciOiJFUzI1NiJ9.eyJpZCI6IjEyMzQiLCJfc2QiOlsiYkRUUnZtNS1Zbi1IRzdjcXBWUjVPVlJJWHNTYUJrNTdKZ2lPcV9qMVZJNCIsImV0M1VmUnlsd1ZyZlhkUEt6Zzc5aGNqRDFJdHpvUTlvQm9YUkd0TW9zRmsiLCJ6V2ZaTlMxOUF0YlJTVGJvN3NKUm4wQlpRdldSZGNob0M3VVphYkZyalk4Il0sIl9zZF9hbGciOiJzaGEtMjU2In0.n27NCtnuwytlBYtUNjgkesDP_7gN7bhaLhWNL4SWT6MaHsOjZ2ZMp987GgQRL6ZkLbJ7Cd3hlePHS84GBXPuvg~WyI1ZWI4Yzg2MjM0MDJjZjJlIiwiZmlyc3RuYW1lIiwiSm9obiJd~WyJjNWMzMWY2ZWYzNTg4MWJjIiwibGFzdG5hbWUiLCJEb2UiXQ~WyJmYTlkYTUzZWJjOTk3OThlIiwic3NuIiwiMTIzLTQ1LTY3ODkiXQ~eyJ0eXAiOiJrYitqd3QiLCJhbGciOiJFUzI1NiJ9.eyJpYXQiOjE3MTAwNjk3MjIsImF1ZCI6ImRpZDpleGFtcGxlOjEyMyIsIm5vbmNlIjoiazh2ZGYwbmQ2Iiwic2RfaGFzaCI6Il8tTmJWSzNmczl3VzNHaDNOUktSNEt1NmZDMUwzN0R2MFFfalBXd0ppRkUifQ.pqw2OB5IA5ya9Mxf60hE3nr2gsJEIoIlnuCa4qIisijHbwg3WzTDFmW2SuNvK_ORN0WU6RoGbJx5uYZh8k4EbA';
+    const decodedSdJwt = decodeSdJwtSync(sdjwt, digest);
+    expect(decodedSdJwt).toBeDefined();
+    expect(decodedSdJwt.kbJwt).toBeDefined();
+    expect(decodedSdJwt.disclosures.length).toEqual(3);
+    expect(decodedSdJwt.jwt).toBeDefined();
+  });
+
+  test('decode sdjwt (with KB)', async () => {
+    const sdjwt =
+      'eyJ0eXAiOiJzZCtqd3QiLCJhbGciOiJFUzI1NiJ9.eyJpZCI6IjEyMzQiLCJfc2QiOlsiYkRUUnZtNS1Zbi1IRzdjcXBWUjVPVlJJWHNTYUJrNTdKZ2lPcV9qMVZJNCIsImV0M1VmUnlsd1ZyZlhkUEt6Zzc5aGNqRDFJdHpvUTlvQm9YUkd0TW9zRmsiLCJ6V2ZaTlMxOUF0YlJTVGJvN3NKUm4wQlpRdldSZGNob0M3VVphYkZyalk4Il0sIl9zZF9hbGciOiJzaGEtMjU2In0.n27NCtnuwytlBYtUNjgkesDP_7gN7bhaLhWNL4SWT6MaHsOjZ2ZMp987GgQRL6ZkLbJ7Cd3hlePHS84GBXPuvg~WyI1ZWI4Yzg2MjM0MDJjZjJlIiwiZmlyc3RuYW1lIiwiSm9obiJd~WyJjNWMzMWY2ZWYzNTg4MWJjIiwibGFzdG5hbWUiLCJEb2UiXQ~WyJmYTlkYTUzZWJjOTk3OThlIiwic3NuIiwiMTIzLTQ1LTY3ODkiXQ~eyJ0eXAiOiJrYitqd3QiLCJhbGciOiJFUzI1NiJ9.eyJpYXQiOjE3MTAwNjk3MjIsImF1ZCI6ImRpZDpleGFtcGxlOjEyMyIsIm5vbmNlIjoiazh2ZGYwbmQ2Iiwic2RfaGFzaCI6Il8tTmJWSzNmczl3VzNHaDNOUktSNEt1NmZDMUwzN0R2MFFfalBXd0ppRkUifQ.pqw2OB5IA5ya9Mxf60hE3nr2gsJEIoIlnuCa4qIisijHbwg3WzTDFmW2SuNvK_ORN0WU6RoGbJx5uYZh8k4EbA';
+    const decodedSdJwt = await decodeSdJwt(sdjwt, digest);
+    expect(decodedSdJwt).toBeDefined();
+    expect(decodedSdJwt.kbJwt).toBeDefined();
+    expect(decodedSdJwt.disclosures.length).toEqual(3);
+    expect(decodedSdJwt.jwt).toBeDefined();
+  });
+
+  test('get claims', async () => {
+    const sdjwt =
+      'eyJ0eXAiOiJzZC1qd3QiLCJhbGciOiJFZERTQSJ9.eyJfc2QiOlsiaWQ1azZ1ZVplVTY4bExaMlU2YjJJbF9QR3ZKb1RDMlpkMkpwY0RwMzFIWSJdLCJfc2RfYWxnIjoic2hhLTI1NiJ9.GiLF_HhacrstqCJ223VvWOoJJWU8qk4dYQHklSMwxv36pPF_7ER53Wbty1qYRlQ6NeMUdBRRdj9JQLLCzz1gCQ~WyI2NTMxNDA2ZmVhZmU0YjBmIiwiZm9vIiwiYmFyIl0~';
+    const decodedSdJwt = await decodeSdJwt(sdjwt, digest);
+    const claims = await getClaims(
+      decodedSdJwt.jwt.payload,
+      decodedSdJwt.disclosures,
+      digest,
+    );
+    expect(claims).toStrictEqual({
+      foo: 'bar',
+    });
+  });
+
+  test('getClaims #2', async () => {
+    const sdjwt =
+      'eyJ0eXAiOiJzZC1qd3QiLCJhbGciOiJFZERTQSJ9.eyJ0ZXN0Ijp7Il9zZCI6WyJqVEszMHNleDZhYV9kUk1KSWZDR056Q0FwbVB5MzRRNjNBa3QzS3hhSktzIl19LCJfc2QiOlsiME9nMi1ReG95eW1UOGNnVzZZUjVSSFpQLUJuR2tHUi1NM2otLV92RWlzSSIsIkcwZ3lHNnExVFMyUlQxMkZ3X2RRRDVVcjlZc1AwZlVWOXVtQWdGMC1jQ1EiXSwiX3NkX2FsZyI6InNoYS0yNTYifQ.ggEyE4SeDO2Hu3tol3VLmi7NQj56yKzKQDaafocgkLrUBdivghohtzrfcbrMN7CRufJ_Cnh0EL54kymXLGTdDQ~WyIwNGU0MjAzOWU4ZWFiOWRjIiwiYSIsIjEiXQ~WyIwOGE1Yjc5MjMyYjAzYzBhIiwiMSJd~WyJiNWE2YjUzZGQwYTFmMGIwIiwienp6IiwieHh4Il0~WyIxYzdmOTE4ZTE0MjA2NzZiIiwiZm9vIiwiYmFyIl0~WyJmZjYxYzQ5ZGU2NjFiYzMxIiwiYXJyIixbeyIuLi4iOiJTSG96VW5KNUpkd0ZtTjVCbXB5dXZCWGZfZWRjckVvcExPYThTVlBFUmg0In0sIjIiLHsiX3NkIjpbIkpuODNhZkp0OGx4NG1FMzZpRkZyS2U2R2VnN0dlVUQ4Z3UwdVo3NnRZcW8iXX1dXQ~';
+    const decodedSdJwt = await decodeSdJwt(sdjwt, digest);
+    const claims = await getClaims(
+      decodedSdJwt.jwt.payload,
+      decodedSdJwt.disclosures,
+      digest,
+    );
+    expect(claims).toStrictEqual({
+      foo: 'bar',
+      arr: ['1', '2', { a: '1' }],
+      test: {
+        zzz: 'xxx',
+      },
+    });
+  });
+
+  test('get claims sync', () => {
+    const sdjwt =
+      'eyJ0eXAiOiJzZC1qd3QiLCJhbGciOiJFZERTQSJ9.eyJfc2QiOlsiaWQ1azZ1ZVplVTY4bExaMlU2YjJJbF9QR3ZKb1RDMlpkMkpwY0RwMzFIWSJdLCJfc2RfYWxnIjoic2hhLTI1NiJ9.GiLF_HhacrstqCJ223VvWOoJJWU8qk4dYQHklSMwxv36pPF_7ER53Wbty1qYRlQ6NeMUdBRRdj9JQLLCzz1gCQ~WyI2NTMxNDA2ZmVhZmU0YjBmIiwiZm9vIiwiYmFyIl0~';
+    const decodedSdJwt = decodeSdJwtSync(sdjwt, digest);
+    const claims = getClaimsSync(
+      decodedSdJwt.jwt.payload,
+      decodedSdJwt.disclosures,
+      digest,
+    );
+    expect(claims).toStrictEqual({
+      foo: 'bar',
+    });
+  });
+
+  test('getClaims sync #2', () => {
+    const sdjwt =
+      'eyJ0eXAiOiJzZC1qd3QiLCJhbGciOiJFZERTQSJ9.eyJ0ZXN0Ijp7Il9zZCI6WyJqVEszMHNleDZhYV9kUk1KSWZDR056Q0FwbVB5MzRRNjNBa3QzS3hhSktzIl19LCJfc2QiOlsiME9nMi1ReG95eW1UOGNnVzZZUjVSSFpQLUJuR2tHUi1NM2otLV92RWlzSSIsIkcwZ3lHNnExVFMyUlQxMkZ3X2RRRDVVcjlZc1AwZlVWOXVtQWdGMC1jQ1EiXSwiX3NkX2FsZyI6InNoYS0yNTYifQ.ggEyE4SeDO2Hu3tol3VLmi7NQj56yKzKQDaafocgkLrUBdivghohtzrfcbrMN7CRufJ_Cnh0EL54kymXLGTdDQ~WyIwNGU0MjAzOWU4ZWFiOWRjIiwiYSIsIjEiXQ~WyIwOGE1Yjc5MjMyYjAzYzBhIiwiMSJd~WyJiNWE2YjUzZGQwYTFmMGIwIiwienp6IiwieHh4Il0~WyIxYzdmOTE4ZTE0MjA2NzZiIiwiZm9vIiwiYmFyIl0~WyJmZjYxYzQ5ZGU2NjFiYzMxIiwiYXJyIixbeyIuLi4iOiJTSG96VW5KNUpkd0ZtTjVCbXB5dXZCWGZfZWRjckVvcExPYThTVlBFUmg0In0sIjIiLHsiX3NkIjpbIkpuODNhZkp0OGx4NG1FMzZpRkZyS2U2R2VnN0dlVUQ4Z3UwdVo3NnRZcW8iXX1dXQ~';
+    const decodedSdJwt = decodeSdJwtSync(sdjwt, digest);
+    const claims = getClaimsSync(
+      decodedSdJwt.jwt.payload,
+      decodedSdJwt.disclosures,
+      digest,
+    );
+    expect(claims).toStrictEqual({
+      foo: 'bar',
+      arr: ['1', '2', { a: '1' }],
+      test: {
+        zzz: 'xxx',
+      },
+    });
+  });
+
+  test('Test default sd hash algorithm', () => {
+    const { _sd_alg } = getSDAlgAndPayload({});
+    expect(_sd_alg).toBe('sha-256');
+  });
+
+  test('unpackObj clone', async () => {
+    const sdjwt =
+      'eyJ0eXAiOiJzZC1qd3QiLCJhbGciOiJFZERTQSJ9.eyJ0ZXN0Ijp7Il9zZCI6WyJqVEszMHNleDZhYV9kUk1KSWZDR056Q0FwbVB5MzRRNjNBa3QzS3hhSktzIl19LCJfc2QiOlsiME9nMi1ReG95eW1UOGNnVzZZUjVSSFpQLUJuR2tHUi1NM2otLV92RWlzSSIsIkcwZ3lHNnExVFMyUlQxMkZ3X2RRRDVVcjlZc1AwZlVWOXVtQWdGMC1jQ1EiXSwiX3NkX2FsZyI6InNoYS0yNTYifQ.ggEyE4SeDO2Hu3tol3VLmi7NQj56yKzKQDaafocgkLrUBdivghohtzrfcbrMN7CRufJ_Cnh0EL54kymXLGTdDQ~WyIwNGU0MjAzOWU4ZWFiOWRjIiwiYSIsIjEiXQ~WyIwOGE1Yjc5MjMyYjAzYzBhIiwiMSJd~WyJiNWE2YjUzZGQwYTFmMGIwIiwienp6IiwieHh4Il0~WyIxYzdmOTE4ZTE0MjA2NzZiIiwiZm9vIiwiYmFyIl0~WyJmZjYxYzQ5ZGU2NjFiYzMxIiwiYXJyIixbeyIuLi4iOiJTSG96VW5KNUpkd0ZtTjVCbXB5dXZCWGZfZWRjckVvcExPYThTVlBFUmg0In0sIjIiLHsiX3NkIjpbIkpuODNhZkp0OGx4NG1FMzZpRkZyS2U2R2VnN0dlVUQ4Z3UwdVo3NnRZcW8iXX1dXQ~';
+    const decodedSdJwt = await decodeSdJwt(sdjwt, digest);
+    const jwtPayload = JSON.parse(JSON.stringify(decodedSdJwt.jwt.payload));
+
+    const { _sd_alg } = getSDAlgAndPayload(decodedSdJwt.jwt.payload);
+    const hash = { hasher: digest, alg: _sd_alg };
+    const map = await createHashMapping(decodedSdJwt.disclosures, hash);
+
+    const { unpackedObj } = unpackObj(decodedSdJwt.jwt.payload, map);
+
+    expect(unpackedObj).toBeDefined();
+    expect(jwtPayload).toStrictEqual(decodedSdJwt.jwt.payload);
+  });
+});

package/src/test/decoy.spec.ts

@@ -1,7 +1,7 @@
-import { digest, generateSalt } from '@sd-jwt/crypto-nodejs';
-import { base64urlEncode } from '@sd-jwt/utils';
+import { hasher as digest, generateSalt } from '@owf/crypto';
 import { describe, expect, test } from 'vitest';
 import { createDecoy } from '../decoy';
+import { base64urlEncode } from '../utils';
 
 const hash = {
   hasher: digest,

package/src/test/generalJSON.spec.ts

@@ -1,7 +1,7 @@
 import Crypto from 'node:crypto';
-import type { Signer, Verifier } from '@sd-jwt/types';
 import { describe, expect, test } from 'vitest';
 import { GeneralJSON } from '..';
+import type { Signer, Verifier } from '../types';
 
 const createSignerVerifier = () => {
   const { privateKey, publicKey } = Crypto.generateKeyPairSync('ed25519');

package/src/test/index.spec.ts

@@ -1,9 +1,9 @@
 import Crypto, { type KeyLike } from 'node:crypto';
-import { digest, ES256, generateSalt } from '@sd-jwt/crypto-nodejs';
-import type { JwtPayload, KbVerifier, Signer, Verifier } from '@sd-jwt/types';
+import { hasher as digest, ES256, generateSalt } from '@owf/crypto';
 import { exportJWK, importJWK, type JWK } from 'jose';
 import { describe, expect, test } from 'vitest';
 import { SDJwtInstance, type SdJwtPayload } from '../index';
+import type { JwtPayload, KbVerifier, Signer, Verifier } from '../types';
 
 // Extract the major version as a number
 const nodeVersionMajor = Number.parseInt(

package/src/test/jwt.spec.ts

@@ -1,8 +1,8 @@
 import Crypto from 'node:crypto';
-import type { Signer, Verifier } from '@sd-jwt/types';
-import { SDJWTException } from '@sd-jwt/utils';
 import { describe, expect, test } from 'vitest';
 import { Jwt } from '../jwt';
+import type { Signer, Verifier } from '../types';
+import { base64urlEncode, SDJWTException } from '../utils';
 
 describe('JWT', () => {
   test('create', async () => {
@@ -16,17 +16,11 @@ describe('JWT', () => {
   });
 
   test('returns decoded JWT when correct JWT string is provided', () => {
-    // Two objects are created separately, the first: { alg: 'HS256', typ: 'JWT' } represents a JWT Header and the second: { sub: '1234567890', name: 'John Doe' } represents a JWT Payload.
-    // These objects are turned into strings with JSON.stringify. The resulting strings are encoded with base64 encoding using Buffer.from(string).toString('base64').
-    // These base64 encoded strings are concatenated with a period (.) between them, following the structure of a JWT, which is composed of three Base64-URL strings separated by dots (header.payload.signature).
-    // A 'signature' string is added at the end to represent a JWT signature.
-    // So, the jwt variable ends up being a string with the format of a base64Url encoded Header, a period, a base64Url encoded Payload, another period, and a 'signature' string.
-    // It's important to note that the 'signature' here is just a placeholder string and not an actual cryptographic signature generated from the header and payload data.
-    const jwt = `${Buffer.from(
+    const jwt = `${base64urlEncode(
       JSON.stringify({ alg: 'HS256', typ: 'JWT' }),
-    ).toString('base64')}.${Buffer.from(
+    )}.${base64urlEncode(
       JSON.stringify({ sub: '1234567890', name: 'John Doe' }),
-    ).toString('base64')}.signature`;
+    )}.signature`;
     const result = Jwt.decodeJWT(jwt);
     expect(result).toEqual({
       header: { alg: 'HS256', typ: 'JWT' },
@@ -41,9 +35,9 @@ describe('JWT', () => {
   });
 
   test('throws an error when JWT parts are missing', () => {
-    const jwt = `${Buffer.from(
+    const jwt = `${base64urlEncode(
       JSON.stringify({ alg: 'HS256', typ: 'JWT' }),
-    ).toString('base64')}`;
+    )}`;
     expect(() => Jwt.decodeJWT(jwt)).toThrow('Invalid JWT as input');
   });
 

package/src/test/kbjwt.spec.ts

@@ -1,14 +1,14 @@
 import Crypto, { type KeyLike } from 'node:crypto';
+import { exportJWK, importJWK, type JWK } from 'jose';
+import { describe, expect, test } from 'vitest';
+import { KBJwt } from '../kbjwt';
 import {
   type JwtPayload,
   KB_JWT_TYP,
   type KbVerifier,
   type Signer,
-} from '@sd-jwt/types';
-import type { SDJWTException } from '@sd-jwt/utils';
-import { exportJWK, importJWK, type JWK } from 'jose';
-import { describe, expect, test } from 'vitest';
-import { KBJwt } from '../kbjwt';
+} from '../types';
+import type { SDJWTException } from '../utils';
 
 describe('KB JWT', () => {
   test('create', async () => {