@learncard/lca-api-service 1.3.0 → 1.3.2

package/CHANGELOG.md

@@ -1,5 +1,60 @@
 # @welibraryos/lca-api-service
 
+## 1.3.2
+
+### Patch Changes
+
+- [#1588](https://github.com/learningeconomy/LearnCard/pull/1588) [`02ed52ec7d86b51cc45de29b4f741e596e8d7c0a`](https://github.com/learningeconomy/LearnCard/commit/02ed52ec7d86b51cc45de29b4f741e596e8d7c0a) Thanks [@goblincore](https://github.com/goblincore)! - Fix automatic email verification in local dev stacks
+
+- Updated dependencies [[`2991bd32b03e26736239dd8e586e2f720d9bcd45`](https://github.com/learningeconomy/LearnCard/commit/2991bd32b03e26736239dd8e586e2f720d9bcd45), [`0c1bf9a8a33e6392d5fd279479d9ab4fb0449b5e`](https://github.com/learningeconomy/LearnCard/commit/0c1bf9a8a33e6392d5fd279479d9ab4fb0449b5e), [`0c1bf9a8a33e6392d5fd279479d9ab4fb0449b5e`](https://github.com/learningeconomy/LearnCard/commit/0c1bf9a8a33e6392d5fd279479d9ab4fb0449b5e), [`3174c09b97fde6f7b5251390245038cf6b7ea9ba`](https://github.com/learningeconomy/LearnCard/commit/3174c09b97fde6f7b5251390245038cf6b7ea9ba), [`928e587378b3674766cf58a8bbe1cbd4d66d3a9f`](https://github.com/learningeconomy/LearnCard/commit/928e587378b3674766cf58a8bbe1cbd4d66d3a9f), [`928e587378b3674766cf58a8bbe1cbd4d66d3a9f`](https://github.com/learningeconomy/LearnCard/commit/928e587378b3674766cf58a8bbe1cbd4d66d3a9f)]:
+    - @learncard/types@5.21.0
+    - @learncard/init@2.5.0
+    - @learncard/helpers@1.6.0
+    - @learncard/email-templates@1.1.0
+    - @learncard/core@9.4.36
+    - @learncard/did-web-plugin@1.1.36
+    - @learncard/didkit-plugin@1.10.1
+    - @learncard/didkit-plugin-node@0.3.1
+
+## 1.3.1
+
+### Patch Changes
+
+- [#1566](https://github.com/learningeconomy/LearnCard/pull/1566) [`e46c302eaed8b98686d21e2f3b5d11b189567304`](https://github.com/learningeconomy/LearnCard/commit/e46c302eaed8b98686d21e2f3b5d11b189567304) Thanks [@gerardopar](https://github.com/gerardopar)! - feat: [LC-2155] - Eliminate CertifiedBoostCredential wrapper
+
+    Direct credentials use their signed Boost network URI for the trusted-network check.
+    Plaintext sends reject mismatched Boost IDs. Encrypted signing-authority issuance
+    includes all subjects and, for delegated consent AutoBoosts, the contract owner.
+
+    Compatibility limitation: pre-signed `signedCredential` payloads (both plaintext and
+    client-encrypted) are stored unchanged, without a server-generated wrapper or status
+    entries. This includes plaintext credentials from older SDKs or third-party issuers
+    that omit `credentialStatus`. Without embedded status entries or server-retained status
+    coordinates, network revocation changes the recipient relationship only and is not
+    reflected by a holder's `verifyCredential` call. Such integrations must publish their
+    own signed status-list updates or use server-managed signing-authority issuance with
+    a VC v2 template. Storage now warns for both plaintext and encrypted credentials when
+    status metadata is missing or empty, including VC v1 issuance results.
+
+- [#1566](https://github.com/learningeconomy/LearnCard/pull/1566) [`e46c302eaed8b98686d21e2f3b5d11b189567304`](https://github.com/learningeconomy/LearnCard/commit/e46c302eaed8b98686d21e2f3b5d11b189567304) Thanks [@gerardopar](https://github.com/gerardopar)! - Encrypt signing-authority credentials using a single snapshot of each recipient's
+  X25519 keys. Keep DAG-JWE compatibility while eliminating repeated DID resolution
+  and post-encryption key-ID matching.
+
+    Carry status entries explicitly in serializable internal issuance results so copied
+    or cached credentials retain revocation metadata. Reject missing internal metadata,
+    and return false when persisted status JSON is malformed or fails validation.
+
+    Report an explicit Boost-authenticity warning when credential verification fails.
+
+- Updated dependencies [[`20b3844ddb7e649c9964308214ec4c395e9fc8db`](https://github.com/learningeconomy/LearnCard/commit/20b3844ddb7e649c9964308214ec4c395e9fc8db), [`b4f94f5a5ffbd52bad6cd26dc3dd627df8d5e6fb`](https://github.com/learningeconomy/LearnCard/commit/b4f94f5a5ffbd52bad6cd26dc3dd627df8d5e6fb), [`19bb79b1355dd9de7f71554fdb608f38b78ed6bb`](https://github.com/learningeconomy/LearnCard/commit/19bb79b1355dd9de7f71554fdb608f38b78ed6bb)]:
+    - @learncard/didkit-plugin@1.10.0
+    - @learncard/didkit-plugin-node@0.3.0
+    - @learncard/types@5.20.0
+    - @learncard/init@2.4.16
+    - @learncard/core@9.4.35
+    - @learncard/helpers@1.5.1
+    - @learncard/did-web-plugin@1.1.35
+
 ## 1.3.0
 
 ### Minor Changes

package/dist/app.d.ts

@@ -208,6 +208,12 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
                             } | undefined;
                             deniedWriters?: string[] | undefined;
                         } | undefined;
+                        guardianApproval?: {
+                            guardianProfileId: string;
+                            guardianDid: string;
+                            approvedAt: string;
+                            contractUpdatedAt: string;
+                        } | undefined;
                         uris?: string[] | undefined;
                     } | undefined;
                     inbox?: {
@@ -553,9 +559,9 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
                 proof: {
                     [x: string]: any;
                     type: string;
-                    created: string;
                     proofPurpose: string;
                     verificationMethod: string;
+                    created?: string | undefined;
                     challenge?: string | undefined;
                     domain?: string | undefined;
                     nonce?: string | undefined;
@@ -563,9 +569,9 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
                 } | {
                     [x: string]: any;
                     type: string;
-                    created: string;
                     proofPurpose: string;
                     verificationMethod: string;
+                    created?: string | undefined;
                     challenge?: string | undefined;
                     domain?: string | undefined;
                     nonce?: string | undefined;

package/dist/helpers/recipient-encryption.helpers.d.ts

@@ -0,0 +1,4 @@
+import { type DidDocument, type JWE, type VC } from '@learncard/types';
+import { type Encrypter } from 'did-jwt';
+export declare const resolveRecipientEncrypters: (recipients: string[], resolveDid: (did: string) => Promise<DidDocument>) => Promise<Encrypter[]>;
+export declare const encryptCredentialForRecipients: (credential: VC, encrypters: Encrypter[]) => Promise<JWE>;

package/dist/helpers/recipient-encryption.helpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/index.js
-size: 117740979 bytes
-sha256: 98fa6833e9147f766d1c6337b2e91d656ffa66c150bee87bfee4e3d4c9de3fa4
+size: 120281915 bytes
+sha256: 5ced11b8e911cdb7296d5c41f76d7e67fee6096c20a98f24ba308818feadfd6e

package/dist/models/Notification.d.ts

@@ -161,6 +161,12 @@ export declare const MongoNotificationValidator: z.ZodObject<{
                 }, z.core.$strip>>;
                 deniedWriters: z.ZodOptional<z.ZodArray<z.ZodString>>;
             }, z.core.$strip>>;
+            guardianApproval: z.ZodOptional<z.ZodObject<{
+                guardianProfileId: z.ZodString;
+                guardianDid: z.ZodString;
+                approvedAt: z.ZodString;
+                contractUpdatedAt: z.ZodString;
+            }, z.core.$strip>>;
             id: z.ZodString;
             action: z.ZodEnum<{
                 write: "write";

package/dist/routes/credentials.d.ts

@@ -229,9 +229,9 @@ export declare const credentialsRouter: import("@trpc/server").TRPCBuiltRouter<{
             proof: {
                 [x: string]: any;
                 type: string;
-                created: string;
                 proofPurpose: string;
                 verificationMethod: string;
+                created?: string | undefined;
                 challenge?: string | undefined;
                 domain?: string | undefined;
                 nonce?: string | undefined;
@@ -239,9 +239,9 @@ export declare const credentialsRouter: import("@trpc/server").TRPCBuiltRouter<{
             } | {
                 [x: string]: any;
                 type: string;
-                created: string;
                 proofPurpose: string;
                 verificationMethod: string;
+                created?: string | undefined;
                 challenge?: string | undefined;
                 domain?: string | undefined;
                 nonce?: string | undefined;

package/dist/routes/firebase.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/routes/notifications.d.ts

@@ -201,6 +201,12 @@ export declare const notificationsRouter: import("@trpc/server").TRPCBuiltRouter
                         } | undefined;
                         deniedWriters?: string[] | undefined;
                     } | undefined;
+                    guardianApproval?: {
+                        guardianProfileId: string;
+                        guardianDid: string;
+                        approvedAt: string;
+                        contractUpdatedAt: string;
+                    } | undefined;
                     uris?: string[] | undefined;
                 } | undefined;
                 inbox?: {

package/dist/types/notifications.d.ts

@@ -231,6 +231,12 @@ export declare const PaginatedNotificationsValidator: z.ZodObject<{
                     }, z.core.$strip>>;
                     deniedWriters: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 }, z.core.$strip>>;
+                guardianApproval: z.ZodOptional<z.ZodObject<{
+                    guardianProfileId: z.ZodString;
+                    guardianDid: z.ZodString;
+                    approvedAt: z.ZodString;
+                    contractUpdatedAt: z.ZodString;
+                }, z.core.$strip>>;
                 id: z.ZodString;
                 action: z.ZodEnum<{
                     write: "write";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@learncard/lca-api-service",
-    "version": "1.3.0",
+    "version": "1.3.2",
     "description": "",
     "engines": {
         "node": ">=24.12 <25"
@@ -50,14 +50,14 @@
     "dependencies": {
         "@fastify/cors": "^11.2.0",
         "@fastify/static": "^10.1.1",
-        "@learncard/core": "9.4.34",
-        "@learncard/email-templates": "1.0.6",
-        "@learncard/did-web-plugin": "1.1.34",
-        "@learncard/didkit-plugin": "1.9.14",
-        "@learncard/didkit-plugin-node": "0.2.32",
-        "@learncard/init": "2.4.15",
-        "@learncard/helpers": "1.5.0",
-        "@learncard/types": "5.19.0",
+        "@learncard/core": "9.4.36",
+        "@learncard/email-templates": "1.1.0",
+        "@learncard/did-web-plugin": "1.1.36",
+        "@learncard/didkit-plugin": "1.10.1",
+        "@learncard/didkit-plugin-node": "0.3.1",
+        "@learncard/init": "2.5.0",
+        "@learncard/helpers": "1.6.0",
+        "@learncard/types": "5.21.0",
         "@sentry/serverless": "^7.61.0",
         "@trpc/server": "11.8.0",
         "@types/jsonwebtoken": "^9.0.8",
@@ -65,6 +65,8 @@
         "@types/node-forge": "^1.3.11",
         "axios": "^0.33.0",
         "dotenv": "^16.0.3",
+        "dag-jose-utils": "2.0.0",
+        "did-jwt": "5.9.0",
         "express": "^4.18.2",
         "fastify": "^5.8.5",
         "filestack-js": "^3.24.0",

package/src/helpers/recipient-encryption.helpers.test.ts

@@ -0,0 +1,129 @@
+import { beforeAll, describe, expect, it, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { initLearnCard } from '@learncard/init';
+import { base58btc } from 'multiformats/bases/base58';
+import type { DidDocument, VC, VerificationMethod } from '@learncard/types';
+import {
+    encryptCredentialForRecipients,
+    resolveRecipientEncrypters,
+} from './recipient-encryption.helpers';
+
+type KeyMethod = Exclude<VerificationMethod, string>;
+const didkit = readFileSync(
+    require.resolve('@learncard/didkit-plugin/dist/didkit/didkit_wasm_bg.wasm')
+);
+let holder: Awaited<ReturnType<typeof makeCard>>;
+let rotated: Awaited<ReturnType<typeof makeCard>>;
+let holderKey: KeyMethod;
+let rotatedKey: KeyMethod;
+const makeCard = (seed: string) => initLearnCard({ didkit, seed });
+const payload = { name: 'Encrypted credential' } as VC;
+const did = 'did:web:holder.example';
+const documentFor = (key: KeyMethod): DidDocument => ({
+    '@context': ['https://www.w3.org/ns/did/v1'],
+    id: did,
+    keyAgreement: [key],
+});
+
+beforeAll(async () => {
+    holder = await makeCard('a'.repeat(64));
+    rotated = await makeCard('b'.repeat(64));
+    holderKey = (await holder.invoke.resolveDid(holder.id.did())).keyAgreement![0] as KeyMethod;
+    rotatedKey = (await rotated.invoke.resolveDid(rotated.id.did())).keyAgreement![0] as KeyMethod;
+});
+
+describe('recipient key snapshots', () => {
+    it('uses the checked key after rotation and produces a DIDKit-decryptable DAG-JWE', async () => {
+        const doc = documentFor({ ...holderKey, id: '#before-rotation' });
+        const resolveDid = vi.fn(async () => doc);
+        const encrypters = await resolveRecipientEncrypters([did, did], resolveDid);
+        doc.keyAgreement = [{ ...rotatedKey, id: '#after-rotation' }];
+        const jwe = await encryptCredentialForRecipients(payload, encrypters);
+        expect(resolveDid).toHaveBeenCalledTimes(1);
+        expect(jwe.recipients).toHaveLength(1);
+        expect(await holder.invoke.decryptDagJwe(jwe)).toEqual(payload);
+        expect(await rotated.invoke.decryptDagJwe(jwe).catch(() => undefined)).toBeFalsy();
+    });
+
+    it.each(['#key', '/keys/1?version=2#key', 'did:web:holder.example/keys/1?version=2#key'])(
+        'supports referenced agreement keys with ID %s without matching generated kids',
+        async id => {
+            const key = { ...holderKey, id };
+            const doc = { ...documentFor(key), keyAgreement: [id], verificationMethod: [key] };
+            const keys = await resolveRecipientEncrypters([did], async () => doc);
+            const jwe = await encryptCredentialForRecipients(payload, keys);
+            expect(await holder.invoke.decryptDagJwe(jwe)).toEqual(payload);
+        }
+    );
+
+    it.each(['base58', 'jwk'])(
+        'supports X25519 %s public keys and includes every recipient',
+        async encoding => {
+            const bytes = base58btc.decode(holderKey.publicKeyMultibase!).slice(2);
+            const key: KeyMethod = {
+                id: '#encryption',
+                controller: did,
+                type: encoding === 'base58' ? 'X25519KeyAgreementKey2019' : 'JsonWebKey2020',
+                ...(encoding === 'base58'
+                    ? { publicKeyBase58: base58btc.baseEncode(bytes) }
+                    : {
+                          publicKeyJwk: {
+                              kty: 'OKP',
+                              crv: 'X25519',
+                              x: Buffer.from(bytes).toString('base64url'),
+                          },
+                      }),
+            };
+            const keys = await resolveRecipientEncrypters([did, rotated.id.did()], async target =>
+                target === did ? documentFor(key) : documentFor(rotatedKey)
+            );
+            const jwe = await encryptCredentialForRecipients(payload, keys);
+            expect(jwe.recipients).toHaveLength(2);
+            expect(await holder.invoke.decryptDagJwe(jwe)).toEqual(payload);
+            expect(await rotated.invoke.decryptDagJwe(jwe)).toEqual(payload);
+        }
+    );
+
+    it('rejects missing, unresolved, or unsupported keys before issuance', async () => {
+        await expect(
+            resolveRecipientEncrypters([did], async () => {
+                throw new Error('not found');
+            })
+        ).rejects.toMatchObject({ code: 'BAD_REQUEST' });
+        await expect(
+            resolveRecipientEncrypters([did], async () =>
+                documentFor({
+                    id: '#unsupported',
+                    controller: did,
+                    type: 'JsonWebKey2020',
+                    publicKeyJwk: { kty: 'OKP', crv: 'Ed25519', x: 'invalid' },
+                })
+            )
+        ).rejects.toMatchObject({ code: 'BAD_REQUEST' });
+    });
+
+    it('resolves a relative relationship against an absolute verification-method ID', async () => {
+        const key = { ...holderKey, id: `${did}/keys/1?version=2#key` };
+        const doc = {
+            ...documentFor(key),
+            keyAgreement: ['/keys/1?version=2#key'],
+            verificationMethod: [key],
+        };
+        const encrypters = await resolveRecipientEncrypters([did], async () => doc);
+        expect(
+            await holder.invoke.decryptDagJwe(
+                await encryptCredentialForRecipients(payload, encrypters)
+            )
+        ).toEqual(payload);
+    });
+
+    it('rejects a partial encryption result if an encrypter omits its recipient', async () => {
+        const encrypters = await resolveRecipientEncrypters([did, rotated.id.did()], async target =>
+            documentFor(target === did ? holderKey : rotatedKey)
+        );
+        encrypters[1] = { ...encrypters[1]!, encryptCek: undefined };
+        await expect(encryptCredentialForRecipients(payload, encrypters)).rejects.toThrow(
+            'Encryption did not cover every recipient key'
+        );
+    });
+});

package/src/helpers/recipient-encryption.helpers.ts

@@ -0,0 +1,91 @@
+import { TRPCError } from '@trpc/server';
+import {
+    JWEValidator,
+    type DidDocument,
+    type JWE,
+    type VC,
+    type VerificationMethod,
+} from '@learncard/types';
+import { base58btc } from 'multiformats/bases/base58';
+import { createJWE, x25519Encrypter, type Encrypter } from 'did-jwt';
+import { prepareCleartext } from 'dag-jose-utils';
+
+type KeyMethod = Exclude<VerificationMethod, string>;
+
+const absoluteKeyId = (id: string, did: string): string => {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(id)) return id;
+    if (id.startsWith('#') || id.startsWith('?')) return `${did}${id}`;
+    const path = new URL(id, 'https://did.invalid/');
+    return `${did}${path.pathname}${path.search}${path.hash}`;
+};
+
+const getX25519Bytes = (method: KeyMethod): Uint8Array | undefined => {
+    try {
+        if (method.publicKeyJwk) {
+            const jwk = method.publicKeyJwk;
+            if (jwk.kty !== 'OKP' || jwk.crv !== 'X25519' || typeof jwk.x !== 'string') return;
+            if (!/^[A-Za-z0-9_-]+$/.test(jwk.x)) return;
+            const bytes = Buffer.from(jwk.x, 'base64url');
+            if (bytes.length === 32) return Uint8Array.from(bytes);
+        } else if (method.publicKeyMultibase) {
+            const bytes = base58btc.decode(method.publicKeyMultibase);
+            if (bytes.length === 34 && bytes[0] === 0xec && bytes[1] === 0x01)
+                return bytes.slice(2);
+        } else if (method.publicKeyBase58 && method.type === 'X25519KeyAgreementKey2019') {
+            const bytes = base58btc.baseDecode(method.publicKeyBase58);
+            if (bytes.length === 32) return bytes.slice();
+        }
+    } catch {
+        // A malformed/unsupported method must not prevent trying another agreement key.
+    }
+    return undefined;
+};
+
+/** Resolve once, then bind encryption to copies of these exact public keys. */
+export const resolveRecipientEncrypters = async (
+    recipients: string[],
+    resolveDid: (did: string) => Promise<DidDocument>
+): Promise<Encrypter[]> => {
+    const groups = await Promise.all(
+        [...new Set(recipients)].map(async did => {
+            const doc = await resolveDid(did).catch(() => undefined);
+            const encrypters: Encrypter[] = [];
+            for (const agreement of doc?.keyAgreement ?? []) {
+                const method =
+                    typeof agreement === 'string'
+                        ? [...(doc?.verificationMethod ?? []), ...(doc?.publicKey ?? [])].find(
+                              (candidate): candidate is KeyMethod =>
+                                  typeof candidate !== 'string' &&
+                                  absoluteKeyId(candidate.id, doc!.id) ===
+                                      absoluteKeyId(agreement, doc!.id)
+                          )
+                        : agreement;
+                if (!method) continue;
+                const key = getX25519Bytes(method);
+                if (key) encrypters.push(x25519Encrypter(key, absoluteKeyId(method.id, doc!.id)));
+            }
+            if (!encrypters.length) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: `Recipient has no usable X25519 key-agreement key: ${did}`,
+                });
+            }
+            return encrypters;
+        })
+    );
+    return groups.flat();
+};
+
+/** DIDKit-compatible DAG-JWE encryption with no further DID resolution or kid matching. */
+export const encryptCredentialForRecipients = async (
+    credential: VC,
+    encrypters: Encrypter[]
+): Promise<JWE> => {
+    if (!encrypters.length) throw new Error('Encryption requires at least one recipient key');
+    const jwe = await createJWE(await prepareCleartext(credential), encrypters);
+    // Every encrypter is bound to one validated key. No recipient may be silently omitted.
+    if (jwe.recipients?.length !== encrypters.length) {
+        throw new Error('Encryption did not cover every recipient key');
+    }
+    return JWEValidator.parse(jwe);
+};

package/src/routes/credentials.ts

@@ -8,6 +8,10 @@ import { getDeliveryService, getFrom } from '../services/delivery';
 import { IssueEndpointValidator } from 'types/credentials';
 import { t, authorizedDidRoute, openRoute } from '@routes';
 import { getSigningAuthorityLearnCard } from '@helpers/learnCard.helpers';
+import {
+    encryptCredentialForRecipients,
+    resolveRecipientEncrypters,
+} from '@helpers/recipient-encryption.helpers';
 
 const ENDORSEMENT_REQUEST_TEMPLATE_ALIAS =
     environment.POSTMARK_ENDORSEMENT_REQUEST_TEMPLATE_ALIAS ?? '';
@@ -61,6 +65,14 @@ export const credentialsRouter = t.router({
                 const saDid = learnCard.id.did();
                 console.log('[LCA /credentials/issue] SA LearnCard resolved, DID:', saDid);
 
+                // Validate and capture each public key once, before signing. Encryption
+                // uses these same snapshots even if a DID rotates during issuance.
+                const recipientEncrypters = encryption
+                    ? await resolveRecipientEncrypters([saDid, ...encryption.recipients], did =>
+                          learnCard.invoke.resolveDid(did)
+                      )
+                    : [];
+
                 // Preserve issuer.name/image if the credential has an object-form issuer
                 if (typeof credential.issuer === 'object' && credential.issuer !== null) {
                     credential.issuer.id = saDid;
@@ -110,13 +122,26 @@ export const credentialsRouter = t.router({
                         '[LCA /credentials/issue] Encrypting JWE for recipients:',
                         recipients
                     );
-                    const jwe = await learnCard.invoke.createDagJwe(issuedCredential, recipients);
+                    const jwe = await encryptCredentialForRecipients(
+                        issuedCredential,
+                        recipientEncrypters
+                    ).catch((error: unknown) => {
+                        // An unresolved recipient is a permanent input failure, not an issuer
+                        // failure. Return 4xx so callers do not retry it as a transient 5xx.
+                        throw new TRPCError({
+                            code: 'BAD_REQUEST',
+                            message: `Unable to encrypt for a recipient: ${
+                                error instanceof Error ? error.message : String(error)
+                            }`,
+                        });
+                    });
                     console.log('[LCA /credentials/issue] JWE created successfully');
                     return jwe;
                 }
 
                 return issuedCredential;
             } catch (error) {
+                if (error instanceof TRPCError) throw error;
                 const errMsg = error instanceof Error ? error.message : String(error);
                 const errStack = error instanceof Error ? error.stack : undefined;
                 console.error('[LCA /credentials/issue] Failed:', {

package/src/routes/firebase.test.ts

@@ -0,0 +1,94 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+    environment: { IS_OFFLINE: true, IS_E2E_TEST: false },
+    verifyIdToken: vi.fn(),
+    getDidAuthVp: vi.fn(),
+}));
+
+vi.mock('@environment', () => ({ environment: mocks.environment }));
+vi.mock('@firebase', () => ({ default: undefined }));
+vi.mock('firebase-admin', () => ({
+    default: { auth: () => ({ verifyIdToken: mocks.verifyIdToken }) },
+}));
+vi.mock('@routes', async () => {
+    const { initTRPC } = await import('@trpc/server');
+    const t = initTRPC.create();
+    return { t, openRoute: t.procedure, authorizedDidRoute: t.procedure };
+});
+vi.mock('@helpers/learnCard.helpers', () => ({
+    getDidWebLearnCard: async () => ({ invoke: { getDidAuthVp: mocks.getDidAuthVp } }),
+    getEmptyLearnCard: vi.fn(),
+}));
+vi.mock('@cache', () => ({ default: {} }));
+vi.mock('../services/delivery', () => ({ getDeliveryService: vi.fn(), getFrom: vi.fn() }));
+vi.mock('../helpers/locale.helpers', () => ({ resolveLocaleByEmail: vi.fn() }));
+vi.mock('@helpers/dids.helpers', () => ({ isAuthorizedDID: vi.fn() }));
+
+import { firebaseRouter } from './firebase';
+
+const tokenFor = (claims: Record<string, string>): string =>
+    `e30.${Buffer.from(JSON.stringify({ sub: 'local-user', ...claims })).toString('base64url')}.test`;
+const caller = firebaseRouter.createCaller({} as never);
+
+describe('getProofOfLoginVp', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        vi.clearAllMocks();
+        mocks.environment.IS_OFFLINE = true;
+        mocks.environment.IS_E2E_TEST = false;
+        mocks.getDidAuthVp.mockResolvedValue('signed-proof');
+        vi.spyOn(console, 'error').mockImplementation(() => {});
+    });
+
+    it('includes the login email without Firebase Admin credentials in local dev', async () => {
+        await expect(
+            caller.getProofOfLoginVp({ token: tokenFor({ email: 'billy@example.com' }) })
+        ).resolves.toEqual({ success: true, vp: 'signed-proof' });
+        expect(mocks.getDidAuthVp).toHaveBeenCalledWith({
+            proofFormat: 'jwt',
+            challenge: 'proof-of-login:email:billy@example.com',
+        });
+        expect(mocks.verifyIdToken).not.toHaveBeenCalled();
+    });
+
+    it('supports the e2e token path and Firebase phone_number claim', async () => {
+        mocks.environment.IS_OFFLINE = false;
+        mocks.environment.IS_E2E_TEST = true;
+        await caller.getProofOfLoginVp({ token: tokenFor({ phone_number: '+15555550123' }) });
+        expect(mocks.getDidAuthVp).toHaveBeenCalledWith({
+            proofFormat: 'jwt',
+            challenge: 'proof-of-login:phone:+15555550123',
+        });
+    });
+
+    it('does not sign a proof when the token has no contact method', async () => {
+        expect(await caller.getProofOfLoginVp({ token: tokenFor({}) })).toMatchObject({
+            success: false,
+        });
+        expect(mocks.getDidAuthVp).not.toHaveBeenCalled();
+    });
+
+    it('requires Firebase verification outside local and e2e environments', async () => {
+        mocks.environment.IS_OFFLINE = false;
+        mocks.verifyIdToken.mockRejectedValueOnce(new Error('Invalid signature'));
+        expect(
+            await caller.getProofOfLoginVp({ token: tokenFor({ email: 'forged@example.com' }) })
+        ).toMatchObject({ success: false });
+        expect(mocks.verifyIdToken).toHaveBeenCalledOnce();
+        expect(mocks.getDidAuthVp).not.toHaveBeenCalled();
+    });
+
+    it('uses verified claims in production', async () => {
+        mocks.environment.IS_OFFLINE = false;
+        mocks.verifyIdToken.mockResolvedValueOnce({
+            uid: 'real-user',
+            email: 'verified@example.com',
+        });
+        await caller.getProofOfLoginVp({ token: 'firebase-token' });
+        expect(mocks.getDidAuthVp).toHaveBeenCalledWith({
+            proofFormat: 'jwt',
+            challenge: 'proof-of-login:email:verified@example.com',
+        });
+    });
+});

package/src/routes/firebase.ts

@@ -20,6 +20,7 @@ import { resolveLocaleByEmail } from '../helpers/locale.helpers';
 import jwtDecode from 'jwt-decode';
 import { getDidWebLearnCard, getEmptyLearnCard } from '@helpers/learnCard.helpers';
 import { isAuthorizedDID } from '@helpers/dids.helpers';
+import { verifyFirebaseToken, getContactMethodFromUser } from '@helpers/auth.helpers';
 
 const LOGIN_VERIFICATION_CODE_TEMPLATE_ALIAS =
     environment.POSTMARK_LOGIN_CODE_TEMPLATE_ALIAS || 'login-verification-code';
@@ -501,16 +502,16 @@ export const firebaseRouter = t.router({
             const { token } = input;
 
             try {
-                const decodedToken = await app?.auth().verifyIdToken(token);
+                // Match sign-in's local/e2e token handling while retaining Firebase
+                // verification outside those environments.
+                const user = await verifyFirebaseToken(token);
+                const contactMethod = getContactMethodFromUser(user);
+                if (!contactMethod) {
+                    throw new Error('Login token does not contain an email or phone number');
+                }
 
                 const learnCard = await getDidWebLearnCard();
-
-                let proofOfLoginChallenge = 'proof-of-login:';
-                if (decodedToken?.email) {
-                    proofOfLoginChallenge += 'email:' + decodedToken?.email;
-                } else if (decodedToken?.phoneNumber) {
-                    proofOfLoginChallenge += 'phone:' + decodedToken?.phoneNumber;
-                }
+                const proofOfLoginChallenge = `proof-of-login:${contactMethod.type}:${contactMethod.value}`;
 
                 const result = await learnCard.invoke.getDidAuthVp({
                     proofFormat: 'jwt',

package/test/credentials.spec.ts

@@ -96,4 +96,42 @@ describe('Credentials', () => {
         );
         expect(proof).toBeDefined();
     });
+
+    it('rejects an unresolvable encryption recipient as BAD_REQUEST', async () => {
+        await expect(
+            userA.clients.authorizedDidAuth.credentials.issueCredential({
+                credential: userA.learnCard.invoke.newCredential(),
+                signingAuthority: {
+                    name: signingAuthority.name,
+                    ownerDid: signingAuthority.ownerDid,
+                    did: signingAuthority.did,
+                },
+                encryption: { recipients: ['did:example:no-key-agreement'] },
+            })
+        ).rejects.toMatchObject({ code: 'BAD_REQUEST' });
+    });
+
+    it('encrypts for both subject and owner while excluding an unrelated server key', async () => {
+        const student = await getUser('b'.repeat(64));
+        const server = await getUser('c'.repeat(64));
+        const credential = userA.learnCard.invoke.newCredential();
+        credential.credentialSubject = { id: student.learnCard.id.did() };
+        const stored = await userA.clients.authorizedDidAuth.credentials.issueCredential({
+            credential,
+            signingAuthority: {
+                name: signingAuthority.name,
+                ownerDid: signingAuthority.ownerDid,
+                did: signingAuthority.did,
+            },
+            encryption: { recipients: [student.learnCard.id.did(), userA.learnCard.id.did()] },
+        });
+        expect(stored).toHaveProperty('ciphertext');
+        const decrypted = await student.learnCard.invoke.decryptDagJwe(stored);
+        expect(await userA.learnCard.invoke.decryptDagJwe(stored)).toEqual(decrypted);
+        // WASM returns an empty value for an inaccessible JWE; native may throw.
+        expect(
+            await server.learnCard.invoke.decryptDagJwe(stored).catch(() => undefined)
+        ).toBeFalsy();
+        expect(decrypted).toMatchObject({ credentialSubject: credential.credentialSubject });
+    });
 });