@sd-jwt/jwt-status-list 0.6.2-next.27

package/dist/index.js

@@ -0,0 +1,216 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  StatusList: () => StatusList,
+  createHeaderAndPayload: () => createHeaderAndPayload,
+  getListFromStatusListJWT: () => getListFromStatusListJWT,
+  getStatusListFromJWT: () => getStatusListFromJWT
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/status-list.ts
+var import_pako = require("pako");
+var import_base64url = __toESM(require("base64url"));
+var StatusList = class _StatusList {
+  /**
+   * Create a new StatusListManager instance.
+   * @param statusList
+   * @param bitsPerStatus
+   */
+  constructor(statusList, bitsPerStatus) {
+    if (![1, 2, 4, 8].includes(bitsPerStatus)) {
+      throw new Error("bitsPerStatus must be 1, 2, 4, or 8");
+    }
+    for (let i = 0; i < statusList.length; i++) {
+      if (statusList[i] > 2 ** bitsPerStatus) {
+        throw Error(
+          `Status value out of range at index ${i} with value ${statusList[i]}`
+        );
+      }
+    }
+    this.statusList = statusList;
+    this.bitsPerStatus = bitsPerStatus;
+    this.totalStatuses = statusList.length;
+  }
+  /**
+   * Get the number of statuses.
+   * @returns
+   */
+  getBitsPerStatus() {
+    return this.bitsPerStatus;
+  }
+  /**
+   * Get the status at a specific index.
+   * @param index
+   * @returns
+   */
+  getStatus(index) {
+    if (index < 0 || index >= this.totalStatuses) {
+      throw new Error("Index out of bounds");
+    }
+    return this.statusList[index];
+  }
+  /**
+   * Set the status at a specific index.
+   * @param index
+   * @param value
+   */
+  setStatus(index, value) {
+    if (index < 0 || index >= this.totalStatuses) {
+      throw new Error("Index out of bounds");
+    }
+    this.statusList[index] = value;
+  }
+  /**
+   * Compress the status list.
+   * @returns
+   */
+  compressStatusList() {
+    const byteArray = this.encodeStatusList();
+    const compressed = (0, import_pako.deflate)(byteArray, { level: 9 });
+    return import_base64url.default.encode(compressed);
+  }
+  /**
+   * Decompress the compressed status list and return a new StatusList instance.
+   * @param compressed
+   * @param bitsPerStatus
+   * @returns
+   */
+  static decompressStatusList(compressed, bitsPerStatus) {
+    const decoded = new Uint8Array(
+      import_base64url.default.decode(compressed, "binary").split("").map((c) => c.charCodeAt(0))
+    );
+    try {
+      const decompressed = (0, import_pako.inflate)(decoded);
+      const statusList = _StatusList.decodeStatusList(
+        decompressed,
+        bitsPerStatus
+      );
+      return new _StatusList(statusList, bitsPerStatus);
+    } catch (err) {
+      throw new Error(`Decompression failed: ${err}`);
+    }
+  }
+  /**
+   * Encode the status list into a byte array.
+   * @returns
+   **/
+  encodeStatusList() {
+    const numBits = this.bitsPerStatus;
+    const numBytes = Math.ceil(this.totalStatuses * numBits / 8);
+    const byteArray = new Uint8Array(numBytes);
+    let byteIndex = 0;
+    let bitIndex = 0;
+    let currentByte = "";
+    for (let i = 0; i < this.totalStatuses; i++) {
+      const status = this.statusList[i];
+      currentByte = status.toString(2).padStart(numBits, "0") + currentByte;
+      bitIndex += numBits;
+      if (bitIndex >= 8 || i === this.totalStatuses - 1) {
+        if (i === this.totalStatuses - 1 && bitIndex % 8 !== 0) {
+          currentByte = currentByte.padStart(8, "0");
+        }
+        byteArray[byteIndex] = Number.parseInt(currentByte, 2);
+        currentByte = "";
+        bitIndex = 0;
+        byteIndex++;
+      }
+    }
+    return byteArray;
+  }
+  /**
+   * Decode the byte array into a status list.
+   * @param byteArray
+   * @param bitsPerStatus
+   * @returns
+   */
+  static decodeStatusList(byteArray, bitsPerStatus) {
+    const numBits = bitsPerStatus;
+    const totalStatuses = byteArray.length * 8 / numBits;
+    const statusList = new Array(totalStatuses);
+    let bitIndex = 0;
+    for (let i = 0; i < totalStatuses; i++) {
+      const byte = byteArray[Math.floor(i * numBits / 8)];
+      let byteString = byte.toString(2);
+      if (byteString.length < 8) {
+        byteString = "0".repeat(8 - byteString.length) + byteString;
+      }
+      const status = byteString.slice(bitIndex, bitIndex + numBits);
+      const group = Math.floor(i / (8 / numBits));
+      const indexInGroup = i % (8 / numBits);
+      const position = group * (8 / numBits) + (8 / numBits + -1 - indexInGroup);
+      statusList[position] = Number.parseInt(status, 2);
+      bitIndex = (bitIndex + numBits) % 8;
+    }
+    return statusList;
+  }
+};
+
+// src/status-list-jwt.ts
+var import_base64url2 = __toESM(require("base64url"));
+function decodeJwt(jwt) {
+  const parts = jwt.split(".");
+  return JSON.parse(import_base64url2.default.decode(parts[1]));
+}
+function createHeaderAndPayload(list, payload, header) {
+  if (!payload.iss) {
+    throw new Error("iss field is required");
+  }
+  if (!payload.sub) {
+    throw new Error("sub field is required");
+  }
+  if (!payload.iat) {
+    throw new Error("iat field is required");
+  }
+  header.typ = "statuslist+jwt";
+  payload.status_list = {
+    bits: list.getBitsPerStatus(),
+    lst: list.compressStatusList()
+  };
+  return { header, payload };
+}
+function getListFromStatusListJWT(jwt) {
+  const payload = decodeJwt(jwt);
+  const statusList = payload.status_list;
+  return StatusList.decompressStatusList(statusList.lst, statusList.bits);
+}
+function getStatusListFromJWT(jwt) {
+  const payload = decodeJwt(jwt);
+  return payload.status.status_list;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StatusList,
+  createHeaderAndPayload,
+  getListFromStatusListJWT,
+  getStatusListFromJWT
+});

package/dist/index.mjs

@@ -0,0 +1,176 @@
+// src/status-list.ts
+import { deflate, inflate } from "pako";
+import base64Url from "base64url";
+var StatusList = class _StatusList {
+  /**
+   * Create a new StatusListManager instance.
+   * @param statusList
+   * @param bitsPerStatus
+   */
+  constructor(statusList, bitsPerStatus) {
+    if (![1, 2, 4, 8].includes(bitsPerStatus)) {
+      throw new Error("bitsPerStatus must be 1, 2, 4, or 8");
+    }
+    for (let i = 0; i < statusList.length; i++) {
+      if (statusList[i] > 2 ** bitsPerStatus) {
+        throw Error(
+          `Status value out of range at index ${i} with value ${statusList[i]}`
+        );
+      }
+    }
+    this.statusList = statusList;
+    this.bitsPerStatus = bitsPerStatus;
+    this.totalStatuses = statusList.length;
+  }
+  /**
+   * Get the number of statuses.
+   * @returns
+   */
+  getBitsPerStatus() {
+    return this.bitsPerStatus;
+  }
+  /**
+   * Get the status at a specific index.
+   * @param index
+   * @returns
+   */
+  getStatus(index) {
+    if (index < 0 || index >= this.totalStatuses) {
+      throw new Error("Index out of bounds");
+    }
+    return this.statusList[index];
+  }
+  /**
+   * Set the status at a specific index.
+   * @param index
+   * @param value
+   */
+  setStatus(index, value) {
+    if (index < 0 || index >= this.totalStatuses) {
+      throw new Error("Index out of bounds");
+    }
+    this.statusList[index] = value;
+  }
+  /**
+   * Compress the status list.
+   * @returns
+   */
+  compressStatusList() {
+    const byteArray = this.encodeStatusList();
+    const compressed = deflate(byteArray, { level: 9 });
+    return base64Url.encode(compressed);
+  }
+  /**
+   * Decompress the compressed status list and return a new StatusList instance.
+   * @param compressed
+   * @param bitsPerStatus
+   * @returns
+   */
+  static decompressStatusList(compressed, bitsPerStatus) {
+    const decoded = new Uint8Array(
+      base64Url.decode(compressed, "binary").split("").map((c) => c.charCodeAt(0))
+    );
+    try {
+      const decompressed = inflate(decoded);
+      const statusList = _StatusList.decodeStatusList(
+        decompressed,
+        bitsPerStatus
+      );
+      return new _StatusList(statusList, bitsPerStatus);
+    } catch (err) {
+      throw new Error(`Decompression failed: ${err}`);
+    }
+  }
+  /**
+   * Encode the status list into a byte array.
+   * @returns
+   **/
+  encodeStatusList() {
+    const numBits = this.bitsPerStatus;
+    const numBytes = Math.ceil(this.totalStatuses * numBits / 8);
+    const byteArray = new Uint8Array(numBytes);
+    let byteIndex = 0;
+    let bitIndex = 0;
+    let currentByte = "";
+    for (let i = 0; i < this.totalStatuses; i++) {
+      const status = this.statusList[i];
+      currentByte = status.toString(2).padStart(numBits, "0") + currentByte;
+      bitIndex += numBits;
+      if (bitIndex >= 8 || i === this.totalStatuses - 1) {
+        if (i === this.totalStatuses - 1 && bitIndex % 8 !== 0) {
+          currentByte = currentByte.padStart(8, "0");
+        }
+        byteArray[byteIndex] = Number.parseInt(currentByte, 2);
+        currentByte = "";
+        bitIndex = 0;
+        byteIndex++;
+      }
+    }
+    return byteArray;
+  }
+  /**
+   * Decode the byte array into a status list.
+   * @param byteArray
+   * @param bitsPerStatus
+   * @returns
+   */
+  static decodeStatusList(byteArray, bitsPerStatus) {
+    const numBits = bitsPerStatus;
+    const totalStatuses = byteArray.length * 8 / numBits;
+    const statusList = new Array(totalStatuses);
+    let bitIndex = 0;
+    for (let i = 0; i < totalStatuses; i++) {
+      const byte = byteArray[Math.floor(i * numBits / 8)];
+      let byteString = byte.toString(2);
+      if (byteString.length < 8) {
+        byteString = "0".repeat(8 - byteString.length) + byteString;
+      }
+      const status = byteString.slice(bitIndex, bitIndex + numBits);
+      const group = Math.floor(i / (8 / numBits));
+      const indexInGroup = i % (8 / numBits);
+      const position = group * (8 / numBits) + (8 / numBits + -1 - indexInGroup);
+      statusList[position] = Number.parseInt(status, 2);
+      bitIndex = (bitIndex + numBits) % 8;
+    }
+    return statusList;
+  }
+};
+
+// src/status-list-jwt.ts
+import base64Url2 from "base64url";
+function decodeJwt(jwt) {
+  const parts = jwt.split(".");
+  return JSON.parse(base64Url2.decode(parts[1]));
+}
+function createHeaderAndPayload(list, payload, header) {
+  if (!payload.iss) {
+    throw new Error("iss field is required");
+  }
+  if (!payload.sub) {
+    throw new Error("sub field is required");
+  }
+  if (!payload.iat) {
+    throw new Error("iat field is required");
+  }
+  header.typ = "statuslist+jwt";
+  payload.status_list = {
+    bits: list.getBitsPerStatus(),
+    lst: list.compressStatusList()
+  };
+  return { header, payload };
+}
+function getListFromStatusListJWT(jwt) {
+  const payload = decodeJwt(jwt);
+  const statusList = payload.status_list;
+  return StatusList.decompressStatusList(statusList.lst, statusList.bits);
+}
+function getStatusListFromJWT(jwt) {
+  const payload = decodeJwt(jwt);
+  return payload.status.status_list;
+}
+export {
+  StatusList,
+  createHeaderAndPayload,
+  getListFromStatusListJWT,
+  getStatusListFromJWT
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@sd-jwt/jwt-status-list",
+  "version": "0.6.2-next.27+5711484",
+  "description": "Implementation based on https://datatracker.ietf.org/doc/draft-ietf-oauth-status-list/",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf **/dist && tsup",
+    "lint": "biome lint ./src",
+    "test": "pnpm run test:node && pnpm run test:browser && pnpm run test:cov",
+    "test:node": "vitest run ./src/test/*.spec.ts",
+    "test:browser": "vitest run ./src/test/*.spec.ts --environment jsdom",
+    "test:cov": "vitest run --coverage"
+  },
+  "keywords": [
+    "sd-jwt-vc",
+    "status-list",
+    "sd-jwt"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openwallet-foundation-labs/sd-jwt-js"
+  },
+  "author": "Mirko Mollik <mirkomollik@gmail.com>",
+  "homepage": "https://github.com/openwallet-foundation-labs/sd-jwt-js/wiki",
+  "bugs": {
+    "url": "https://github.com/openwallet-foundation-labs/sd-jwt-js/issues"
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/pako": "^2.0.3",
+    "jose": "^5.2.2"
+  },
+  "dependencies": {
+    "@sd-jwt/types": "0.6.2-next.27+5711484",
+    "base64url": "^3.0.1",
+    "pako": "^2.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "tsup": {
+    "entry": [
+      "./src/index.ts"
+    ],
+    "sourceMap": true,
+    "splitting": false,
+    "clean": true,
+    "dts": true,
+    "format": [
+      "cjs",
+      "esm"
+    ]
+  },
+  "gitHead": "5711484f7aedc207763835f1f7f656a75558798d"
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './status-list.js';
+export * from './status-list-jwt.js';
+export * from './types.js';

package/src/status-list-jwt.ts

@@ -0,0 +1,73 @@
+import type { JwtPayload } from '@sd-jwt/types';
+import { StatusList } from './status-list.js';
+import type {
+  JWTwithStatusListPayload,
+  StatusListJWTHeaderParameters,
+  StatusListEntry,
+  StatusListJWTPayload,
+} from './types.js';
+import base64Url from 'base64url';
+
+/**
+ * Decode a JWT and return the payload.
+ * @param jwt JWT token in compact JWS serialization.
+ * @returns Payload of the JWT.
+ */
+function decodeJwt<T>(jwt: string): T {
+  const parts = jwt.split('.');
+  return JSON.parse(base64Url.decode(parts[1]));
+}
+
+/**
+ * Adds the status list to the payload and header of a JWT.
+ * @param list
+ * @param payload
+ * @param header
+ * @returns The header and payload with the status list added.
+ */
+export function createHeaderAndPayload(
+  list: StatusList,
+  payload: JwtPayload,
+  header: StatusListJWTHeaderParameters,
+) {
+  // validate if the required fieds are present based on https://www.ietf.org/archive/id/draft-ietf-oauth-status-list-02.html#section-5.1
+
+  if (!payload.iss) {
+    throw new Error('iss field is required');
+  }
+  if (!payload.sub) {
+    throw new Error('sub field is required');
+  }
+  if (!payload.iat) {
+    throw new Error('iat field is required');
+  }
+  //exp and tll are optional. We will not validate the business logic of the values like exp > iat etc.
+
+  header.typ = 'statuslist+jwt';
+  payload.status_list = {
+    bits: list.getBitsPerStatus(),
+    lst: list.compressStatusList(),
+  };
+  return { header, payload };
+}
+
+/**
+ * Get the status list from a JWT, but do not verify the signature.
+ * @param jwt
+ * @returns
+ */
+export function getListFromStatusListJWT(jwt: string): StatusList {
+  const payload = decodeJwt<StatusListJWTPayload>(jwt);
+  const statusList = payload.status_list;
+  return StatusList.decompressStatusList(statusList.lst, statusList.bits);
+}
+
+/**
+ * Get the status list entry from a JWT, but do not verify the signature.
+ * @param jwt
+ * @returns
+ */
+export function getStatusListFromJWT(jwt: string): StatusListEntry {
+  const payload = decodeJwt<JWTwithStatusListPayload>(jwt);
+  return payload.status.status_list;
+}

package/src/status-list.ts

@@ -0,0 +1,167 @@
+import { deflate, inflate } from 'pako';
+import base64Url from 'base64url';
+import type { BitsPerStatus } from './types.js';
+/**
+ * StatusListManager is a class that manages a list of statuses with variable bit size.
+ */
+export class StatusList {
+  private statusList: number[];
+  private bitsPerStatus: BitsPerStatus;
+  private totalStatuses: number;
+
+  /**
+   * Create a new StatusListManager instance.
+   * @param statusList
+   * @param bitsPerStatus
+   */
+  constructor(statusList: number[], bitsPerStatus: BitsPerStatus) {
+    if (![1, 2, 4, 8].includes(bitsPerStatus)) {
+      throw new Error('bitsPerStatus must be 1, 2, 4, or 8');
+    }
+    //check that the entries in the statusList are within the range of the bitsPerStatus
+    for (let i = 0; i < statusList.length; i++) {
+      if (statusList[i] > 2 ** bitsPerStatus) {
+        throw Error(
+          `Status value out of range at index ${i} with value ${statusList[i]}`,
+        );
+      }
+    }
+    this.statusList = statusList;
+    this.bitsPerStatus = bitsPerStatus;
+    this.totalStatuses = statusList.length;
+  }
+
+  /**
+   * Get the number of statuses.
+   * @returns
+   */
+  getBitsPerStatus(): BitsPerStatus {
+    return this.bitsPerStatus;
+  }
+
+  /**
+   * Get the status at a specific index.
+   * @param index
+   * @returns
+   */
+  getStatus(index: number): number {
+    if (index < 0 || index >= this.totalStatuses) {
+      throw new Error('Index out of bounds');
+    }
+    return this.statusList[index];
+  }
+
+  /**
+   * Set the status at a specific index.
+   * @param index
+   * @param value
+   */
+  setStatus(index: number, value: number): void {
+    if (index < 0 || index >= this.totalStatuses) {
+      throw new Error('Index out of bounds');
+    }
+    this.statusList[index] = value;
+  }
+
+  /**
+   * Compress the status list.
+   * @returns
+   */
+  compressStatusList(): string {
+    const byteArray = this.encodeStatusList();
+    const compressed = deflate(byteArray, { level: 9 });
+    return base64Url.encode(compressed as Buffer);
+  }
+
+  /**
+   * Decompress the compressed status list and return a new StatusList instance.
+   * @param compressed
+   * @param bitsPerStatus
+   * @returns
+   */
+  static decompressStatusList(
+    compressed: string,
+    bitsPerStatus: BitsPerStatus,
+  ): StatusList {
+    const decoded = new Uint8Array(
+      base64Url
+        .decode(compressed, 'binary')
+        .split('')
+        .map((c) => c.charCodeAt(0)),
+    );
+    try {
+      const decompressed = inflate(decoded);
+      const statusList = StatusList.decodeStatusList(
+        decompressed,
+        bitsPerStatus,
+      );
+      return new StatusList(statusList, bitsPerStatus);
+    } catch (err: unknown) {
+      throw new Error(`Decompression failed: ${err}`);
+    }
+  }
+
+  /**
+   * Encode the status list into a byte array.
+   * @returns
+   **/
+  public encodeStatusList(): Uint8Array {
+    const numBits = this.bitsPerStatus;
+    const numBytes = Math.ceil((this.totalStatuses * numBits) / 8);
+    const byteArray = new Uint8Array(numBytes);
+    let byteIndex = 0;
+    let bitIndex = 0;
+    let currentByte = '';
+    for (let i = 0; i < this.totalStatuses; i++) {
+      const status = this.statusList[i];
+      // Place bits from status into currentByte, starting from the most significant bit.
+      currentByte = status.toString(2).padStart(numBits, '0') + currentByte;
+      bitIndex += numBits;
+
+      // If currentByte is full or this is the last status, add it to byteArray and reset currentByte and bitIndex.
+      if (bitIndex >= 8 || i === this.totalStatuses - 1) {
+        // If this is the last status and bitIndex is not a multiple of 8, shift currentByte to the left.
+        if (i === this.totalStatuses - 1 && bitIndex % 8 !== 0) {
+          currentByte = currentByte.padStart(8, '0');
+        }
+        byteArray[byteIndex] = Number.parseInt(currentByte, 2);
+        currentByte = '';
+        bitIndex = 0;
+        byteIndex++;
+      }
+    }
+
+    return byteArray;
+  }
+
+  /**
+   * Decode the byte array into a status list.
+   * @param byteArray
+   * @param bitsPerStatus
+   * @returns
+   */
+  private static decodeStatusList(
+    byteArray: Uint8Array,
+    bitsPerStatus: BitsPerStatus,
+  ): number[] {
+    const numBits = bitsPerStatus;
+    const totalStatuses = (byteArray.length * 8) / numBits;
+    const statusList = new Array<number>(totalStatuses);
+    let bitIndex = 0; // Current position in byte
+    for (let i = 0; i < totalStatuses; i++) {
+      const byte = byteArray[Math.floor((i * numBits) / 8)];
+      let byteString = byte.toString(2);
+      if (byteString.length < 8) {
+        byteString = '0'.repeat(8 - byteString.length) + byteString;
+      }
+      const status = byteString.slice(bitIndex, bitIndex + numBits);
+      const group = Math.floor(i / (8 / numBits));
+      const indexInGroup = i % (8 / numBits);
+      const position =
+        group * (8 / numBits) + (8 / numBits + -1 - indexInGroup);
+      statusList[position] = Number.parseInt(status, 2);
+      bitIndex = (bitIndex + numBits) % 8;
+    }
+    return statusList;
+  }
+}