@owf/eudi-sca 0.0.0

package/dist/index.d.mts

@@ -0,0 +1,129 @@
+import { CredentialIssuerMetadata } from "@openid4vc/openid4vci";
+import z from "zod";
+
+//#region src/crypto.d.ts
+type JwtSignatureVerifier = (x5c: Array<string>, toBeVerified: string, signature: Uint8Array) => Promise<void>;
+//#endregion
+//#region src/issuerMetadata.d.ts
+declare const zCredentialIssuerMetadataWithMetadataUri: z.ZodObject<{
+  credential_issuer: z.ZodURL;
+  authorization_servers: z.ZodOptional<z.ZodArray<z.ZodURL>>;
+  credential_endpoint: z.ZodURL;
+  deferred_credential_endpoint: z.ZodOptional<z.ZodURL>;
+  notification_endpoint: z.ZodOptional<z.ZodURL>;
+  nonce_endpoint: z.ZodOptional<z.ZodURL>;
+  credential_response_encryption: z.ZodOptional<z.ZodObject<{
+    alg_values_supported: z.ZodArray<z.ZodString>;
+    enc_values_supported: z.ZodArray<z.ZodString>;
+    encryption_required: z.ZodBoolean;
+  }, z.core.$loose>>;
+  batch_credential_issuance: z.ZodOptional<z.ZodObject<{
+    batch_size: z.ZodNumber;
+  }, z.core.$loose>>;
+  display: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+    logo: z.ZodOptional<z.ZodObject<{
+      uri: z.ZodOptional<z.ZodUnion<[z.ZodURL, z.ZodString]>>;
+      alt_text: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+  }, z.core.$loose>>>;
+  credential_configurations_supported: z.ZodRecord<z.ZodString, z.ZodObject<{
+    format: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+    cryptographic_binding_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    credential_signing_alg_values_supported: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodString>, z.ZodArray<z.ZodNumber>]>>;
+    proof_types_supported: z.ZodOptional<z.ZodRecord<z.ZodUnion<readonly [z.ZodLiteral<"jwt">, z.ZodLiteral<"attestation">, z.ZodString]>, z.ZodObject<{
+      proof_signing_alg_values_supported: z.ZodArray<z.ZodString>;
+      key_attestations_required: z.ZodOptional<z.ZodObject<{
+        key_storage: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+          iso_18045_high: "iso_18045_high";
+          iso_18045_moderate: "iso_18045_moderate";
+          "iso_18045_enhanced-basic": "iso_18045_enhanced-basic";
+          iso_18045_basic: "iso_18045_basic";
+        }>, z.ZodString]>>>;
+        user_authentication: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+          iso_18045_high: "iso_18045_high";
+          iso_18045_moderate: "iso_18045_moderate";
+          "iso_18045_enhanced-basic": "iso_18045_enhanced-basic";
+          iso_18045_basic: "iso_18045_basic";
+        }>, z.ZodString]>>>;
+      }, z.core.$loose>>;
+    }, z.core.$strip>>>;
+    credential_metadata: z.ZodOptional<z.ZodObject<{
+      display: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        locale: z.ZodOptional<z.ZodString>;
+        logo: z.ZodOptional<z.ZodObject<{
+          uri: z.ZodOptional<z.ZodUnion<[z.ZodURL, z.ZodString]>>;
+          alt_text: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        description: z.ZodOptional<z.ZodString>;
+        background_color: z.ZodOptional<z.ZodString>;
+        background_image: z.ZodOptional<z.ZodObject<{
+          uri: z.ZodOptional<z.ZodUnion<[z.ZodURL, z.ZodString]>>;
+        }, z.core.$loose>>;
+        text_color: z.ZodOptional<z.ZodString>;
+      }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+  }, z.core.$loose>>;
+  credential_metadata_uri: z.ZodOptional<z.ZodURL>;
+}, z.core.$loose>;
+/**
+ *
+ * Additional check for the Credential Issuer Metadata to see if there is a `credential_metadata_uri` available
+ *
+ */
+declare const parseCredentialMetadataUri: (cim: CredentialIssuerMetadata | Record<string, unknown>) => z.infer<typeof zCredentialIssuerMetadataWithMetadataUri> & CredentialIssuerMetadata;
+type IssuerMetadataWithCredentialMetadataUri = ReturnType<typeof parseCredentialMetadataUri>;
+//#endregion
+//#region src/credentialMetadata.d.ts
+declare enum ValueType {
+  Boolean = "boolean",
+  Frequency = "frequency",
+  Image = "image",
+  IsoDate = "iso_date",
+  IsoTime = "iso_time",
+  IsoDateTime = "iso_date_time",
+  IsoCurrency = "iso_currency",
+  IsoCurrencyAmount = "iso_currency_amount",
+  LabelOnly = "label_only",
+  MiniMarkdown = "mini_markdown",
+  Url = "url"
+}
+declare const CredentialMetadataSchema: z.ZodObject<{
+  transaction_data_types: z.ZodRecord<z.ZodString, z.ZodObject<{
+    claims: z.ZodArray<z.ZodObject<{
+      path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+      mandatory: z.ZodOptional<z.ZodBoolean>;
+      display: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        locale: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        display_type: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof ValueType>, z.ZodString]>>;
+      }, z.core.$strip>>>;
+      value_type: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<typeof ValueType>, z.ZodString]>>;
+    }, z.core.$strip>>;
+    ui_labels: z.ZodUnknown;
+  }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strip>;
+type CredentialMetadata = z.infer<typeof CredentialMetadataSchema>;
+declare const parseCredentialMetadata: (credentialMetadata: Record<string, unknown>) => {
+  transaction_data_types: Record<string, {
+    [x: string]: unknown;
+    claims: {
+      path: (string | null)[];
+      mandatory?: boolean | undefined;
+      display?: {
+        name: string;
+        locale?: string | undefined;
+        display_type?: string | undefined;
+      }[] | undefined;
+      value_type?: string | undefined;
+    }[];
+    ui_labels: unknown;
+  }>;
+};
+declare function fetchCredentialMetadata(verifier: JwtSignatureVerifier, credentialMetadataSource: string | IssuerMetadataWithCredentialMetadataUri, customFetcher?: typeof fetch, langCode?: string): Promise<CredentialMetadata & CredentialIssuerMetadata>;
+//#endregion
+export { type CredentialMetadata, ValueType, fetchCredentialMetadata, parseCredentialMetadata, parseCredentialMetadataUri };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,100 @@
+import { zCredentialIssuerMetadataSchema } from "@openid4vc/openid4vci";
+import { base64url, decodeJwt } from "@owf/identity-common";
+import z from "zod";
+//#region src/credentialMetadata.ts
+let ValueType = /* @__PURE__ */ function(ValueType) {
+	ValueType["Boolean"] = "boolean";
+	ValueType["Frequency"] = "frequency";
+	ValueType["Image"] = "image";
+	ValueType["IsoDate"] = "iso_date";
+	ValueType["IsoTime"] = "iso_time";
+	ValueType["IsoDateTime"] = "iso_date_time";
+	ValueType["IsoCurrency"] = "iso_currency";
+	ValueType["IsoCurrencyAmount"] = "iso_currency_amount";
+	ValueType["LabelOnly"] = "label_only";
+	ValueType["MiniMarkdown"] = "mini_markdown";
+	ValueType["Url"] = "url";
+	return ValueType;
+}({});
+const valueTypeValues = Object.values(ValueType).join("|");
+const valueTypeRegex = new RegExp(`^template:(${valueTypeValues})$`);
+const CredentialMetadataSchema = z.object({ transaction_data_types: z.record(z.string().regex(/^urn:eudi:sca:[^:]+:[^:]+(:[^:]+)*:[^:]+$/), z.object({
+	claims: z.array(z.object({
+		path: z.array(z.union([z.string(), z.null()])),
+		mandatory: z.boolean().optional(),
+		display: z.array(z.object({
+			locale: z.string().optional(),
+			name: z.string(),
+			display_type: z.union([z.enum(ValueType), z.string().regex(valueTypeRegex)]).optional()
+		})).min(1).optional(),
+		value_type: z.union([z.enum(ValueType), z.string().regex(valueTypeRegex)]).optional()
+	}).superRefine((val, ctx) => {
+		if (!val.display && val.value_type !== void 0) ctx.addIssue({
+			code: "custom",
+			message: "value_type must not be used on claims without a display array",
+			path: ["value_type"]
+		});
+	})),
+	ui_labels: z.unknown()
+}).catchall(z.unknown())) });
+const parseCredentialMetadata = (credentialMetadata) => {
+	return CredentialMetadataSchema.parse(credentialMetadata);
+};
+async function fetchCredentialMetadata(verifier, credentialMetadataSource, customFetcher = fetch, langCode) {
+	const uri = typeof credentialMetadataSource === "string" ? credentialMetadataSource : credentialMetadataSource.credential_metadata_uri;
+	if (!uri) throw Error("credential_metadata_uri is not defined on the issuer metadata");
+	const payload = await validateJwt(await (await customFetcher(uri, { headers: {
+		Accept: "application/jwt",
+		...langCode ? { "Accept-Language": langCode } : {}
+	} })).text(), uri, verifier);
+	return CredentialMetadataSchema.extend(zCredentialIssuerMetadataSchema.shape).parse(payload.credential_metadata);
+}
+/**
+*
+* @todo validate the sub, iss, x5c chain
+*
+*/
+const validateJwt = async (jwt, credentialMetadataUri, verifier) => {
+	const { header: h, payload: p, signature } = decodeJwt(jwt);
+	const [headerString, payloadString] = jwt.split(".");
+	const header = z.object({
+		x5c: z.array(z.string()),
+		typ: z.literal("credential-metadata+jwt")
+	}).parse(h);
+	const payload = z.object({
+		iss: z.string(),
+		sub: z.string().min(1, { message: "sub must be a non-empty credential type identifier" }),
+		format: z.enum(["dc+sd-jwt", "mso_mdoc"], { message: "format must be a valid OID4VCI credential format identifier" }),
+		iat: z.number().int().positive({ message: "iat must be a positive Unix timestamp" }),
+		exp: z.number().int().positive({ message: "exp must be a positive Unix timestamp" }),
+		credential_metadata_uri: z.url({ message: "credential_metadata_uri must be a valid URL" }),
+		credential_metadata: zCredentialIssuerMetadataSchema
+	}).refine((data) => data.exp > data.iat, {
+		message: "exp must be after iat",
+		path: ["exp"]
+	}).refine((data) => new Date(data.exp) < /* @__PURE__ */ new Date(), {
+		message: "exp must be after iat",
+		path: ["exp"]
+	}).refine((data) => {
+		return data.credential_metadata_uri === credentialMetadataUri;
+	}, {
+		message: `credential_metadata_uri  must match source '${credentialMetadataUri}'`,
+		path: ["credential_metadata_uri"]
+	}).parse(p);
+	const toBeVerified = `${headerString}.${payloadString}`;
+	await verifier(header.x5c, toBeVerified, base64url.decode(signature));
+	return payload;
+};
+//#endregion
+//#region src/issuerMetadata.ts
+const zCredentialIssuerMetadataWithMetadataUri = zCredentialIssuerMetadataSchema.extend({ credential_metadata_uri: z.url().optional() });
+/**
+*
+* Additional check for the Credential Issuer Metadata to see if there is a `credential_metadata_uri` available
+*
+*/
+const parseCredentialMetadataUri = (cim) => zCredentialIssuerMetadataWithMetadataUri.parse(cim);
+//#endregion
+export { ValueType, fetchCredentialMetadata, parseCredentialMetadata, parseCredentialMetadataUri };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/credentialMetadata.ts","../src/issuerMetadata.ts"],"sourcesContent":["import { type CredentialIssuerMetadata, zCredentialIssuerMetadataSchema } from '@openid4vc/openid4vci'\nimport { base64url, decodeJwt } from '@owf/identity-common'\nimport z from 'zod'\nimport type { JwtSignatureVerifier } from './crypto'\nimport type { IssuerMetadataWithCredentialMetadataUri } from './issuerMetadata'\n\nexport enum ValueType {\n  Boolean = 'boolean',\n  Frequency = 'frequency',\n  Image = 'image',\n  IsoDate = 'iso_date',\n  IsoTime = 'iso_time',\n  IsoDateTime = 'iso_date_time',\n  IsoCurrency = 'iso_currency',\n  IsoCurrencyAmount = 'iso_currency_amount',\n  LabelOnly = 'label_only',\n  MiniMarkdown = 'mini_markdown',\n  Url = 'url',\n}\n\nconst valueTypeValues = Object.values(ValueType).join('|')\nconst valueTypeRegex = new RegExp(`^template:(${valueTypeValues})$`)\nconst urnRegex = /^urn:eudi:sca:[^:]+:[^:]+(:[^:]+)*:[^:]+$/\n\nconst CredentialMetadataSchema = z.object({\n  transaction_data_types: z.record(\n    z.string().regex(urnRegex),\n    z\n      .object({\n        claims: z.array(\n          z\n            .object({\n              path: z.array(z.union([z.string(), z.null()])),\n              mandatory: z.boolean().optional(),\n              display: z\n                .array(\n                  z.object({\n                    locale: z.string().optional(),\n                    name: z.string(),\n                    display_type: z.union([z.enum(ValueType), z.string().regex(valueTypeRegex)]).optional(),\n                  })\n                )\n                .min(1)\n                .optional(),\n              value_type: z.union([z.enum(ValueType), z.string().regex(valueTypeRegex)]).optional(),\n            })\n            .superRefine((val, ctx) => {\n              if (!val.display && val.value_type !== undefined) {\n                ctx.addIssue({\n                  code: 'custom',\n                  message: 'value_type must not be used on claims without a display array',\n                  path: ['value_type'],\n                })\n              }\n            })\n        ),\n        ui_labels: z.unknown(),\n      })\n      .catchall(z.unknown())\n  ),\n})\n\nexport type CredentialMetadata = z.infer<typeof CredentialMetadataSchema>\n\nexport const parseCredentialMetadata = (credentialMetadata: Record<string, unknown>) => {\n  const cm = CredentialMetadataSchema.parse(credentialMetadata)\n  return cm\n}\n\nexport async function fetchCredentialMetadata(\n  verifier: JwtSignatureVerifier,\n  credentialMetadataSource: string | IssuerMetadataWithCredentialMetadataUri,\n  customFetcher = fetch,\n  langCode?: string\n): Promise<CredentialMetadata & CredentialIssuerMetadata> {\n  const uri =\n    typeof credentialMetadataSource === 'string'\n      ? credentialMetadataSource\n      : credentialMetadataSource.credential_metadata_uri\n  if (!uri) {\n    throw Error('credential_metadata_uri is not defined on the issuer metadata')\n  }\n\n  const response = await customFetcher(uri, {\n    headers: {\n      Accept: 'application/jwt',\n      ...(langCode ? { 'Accept-Language': langCode } : {}),\n    },\n  })\n\n  const payload = await validateJwt(await response.text(), uri, verifier)\n\n  return CredentialMetadataSchema.extend(zCredentialIssuerMetadataSchema.shape).parse(payload.credential_metadata)\n}\n\n/**\n *\n * @todo validate the sub, iss, x5c chain\n *\n */\nconst validateJwt = async (jwt: string, credentialMetadataUri: string, verifier: JwtSignatureVerifier) => {\n  const { header: h, payload: p, signature } = decodeJwt(jwt)\n  const [headerString, payloadString] = jwt.split('.')\n\n  const header = z.object({ x5c: z.array(z.string()), typ: z.literal('credential-metadata+jwt') }).parse(h)\n  const payload = z\n    .object({\n      iss: z.string(),\n      sub: z.string().min(1, { message: 'sub must be a non-empty credential type identifier' }),\n      format: z.enum(['dc+sd-jwt', 'mso_mdoc'], {\n        message: 'format must be a valid OID4VCI credential format identifier',\n      }),\n      iat: z.number().int().positive({ message: 'iat must be a positive Unix timestamp' }),\n      exp: z.number().int().positive({ message: 'exp must be a positive Unix timestamp' }),\n      credential_metadata_uri: z.url({ message: 'credential_metadata_uri must be a valid URL' }),\n      credential_metadata: zCredentialIssuerMetadataSchema,\n    })\n    .refine((data) => data.exp > data.iat, { message: 'exp must be after iat', path: ['exp'] })\n    .refine((data) => new Date(data.exp) < new Date(), { message: 'exp must be after iat', path: ['exp'] })\n    .refine(\n      (data) => {\n        return data.credential_metadata_uri === credentialMetadataUri\n      },\n      {\n        message: `credential_metadata_uri  must match source '${credentialMetadataUri}'`,\n        path: ['credential_metadata_uri'],\n      }\n    )\n    .parse(p)\n\n  const toBeVerified = `${headerString}.${payloadString}`\n\n  await verifier(header.x5c, toBeVerified, base64url.decode(signature))\n\n  return payload\n}\n","import { type CredentialIssuerMetadata, zCredentialIssuerMetadataSchema } from '@openid4vc/openid4vci'\nimport z from 'zod'\n\nconst zCredentialIssuerMetadataWithMetadataUri = zCredentialIssuerMetadataSchema.extend({\n  credential_metadata_uri: z.url().optional(),\n})\n\n/**\n *\n * Additional check for the Credential Issuer Metadata to see if there is a `credential_metadata_uri` available\n *\n */\nexport const parseCredentialMetadataUri = (cim: CredentialIssuerMetadata | Record<string, unknown>) =>\n  zCredentialIssuerMetadataWithMetadataUri.parse(cim) as z.infer<typeof zCredentialIssuerMetadataWithMetadataUri> &\n    CredentialIssuerMetadata\n\nexport type IssuerMetadataWithCredentialMetadataUri = ReturnType<typeof parseCredentialMetadataUri>\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@owf/eudi-sca",
+  "version": "0.0.0",
+  "description": "Tools and utilities for EUDI Strong Customer Authentication per TS12",
+  "files": [
+    "dist"
+  ],
+  "license": "Apache-2.0",
+  "exports": "./src/index.ts",
+  "homepage": "https://github.com/openwallet-foundation-labs/identity-common-ts/tree/main/packages/eudi-sca",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openwallet-foundation-labs/identity-common-ts",
+    "directory": "packages/eudi-sca"
+  },
+  "publishConfig": {
+    "module": "./dist/index.mjs",
+    "types": "./dist/index.d.mts",
+    "exports": {
+      ".": "./dist/index.mjs",
+      "./package.json": "./package.json"
+    }
+  },
+  "keywords": [
+    "sca",
+    "eudi",
+    "TS12",
+    "wallet"
+  ],
+  "scripts": {
+    "build": "tsdown src/index.ts --format esm --dts --sourcemap"
+  },
+  "dependencies": {
+    "@openid4vc/openid4vci": "0.5.0-alpha-20260415063740",
+    "@owf/crypto": "workspace:",
+    "@owf/identity-common": "workspace:",
+    "@owf/mdoc": "^0.6.0",
+    "@sd-jwt/core": "^0.19.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "nock": "^14.0.13"
+  }
+}