Cómo construir un emisor de credenciales digitales (Guía para desarrolladores)

npx create-next-app@latest . --ts --eslint --tailwind --app --src-dir --import-alias "@/*" --use-npm

npm install jose mysql2 uuid @types/uuid

services:
    mysql:
        image: mysql:8.0
        restart: always
        environment:
            MYSQL_ROOT_PASSWORD: rootpassword
            MYSQL_DATABASE: digital_credentials
            MYSQL_USER: app_user
            MYSQL_PASSWORD: app_password
        ports:
            - "3306:3306"
        volumes:
            - mysql_data:/var/lib/mysql
            - ./sql/init.sql:/docker-entrypoint-initdb.d/init.sql
        healthcheck:
            test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
            timeout: 20s
            retries: 10
 
volumes:
    mysql_data:

-- Crear la base de datos si no existe
CREATE DATABASE IF NOT EXISTS digital_credentials;
USE digital_credentials;
 
-- Tabla para almacenar desafíos
CREATE TABLE IF NOT EXISTS challenges (
    id VARCHAR(36) PRIMARY KEY,
    challenge VARCHAR(255) NOT NULL UNIQUE,
    expires_at TIMESTAMP NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    used BOOLEAN DEFAULT FALSE,
    INDEX idx_challenge (challenge),
    INDEX idx_expires_at (expires_at)
);
 
-- Tabla para almacenar sesiones de verificación
CREATE TABLE IF NOT EXISTS verification_sessions (
    id VARCHAR(36) PRIMARY KEY,
    challenge_id VARCHAR(36),
    status ENUM('pending', 'verified', 'failed', 'expired') DEFAULT 'pending',
    presentation_data JSON,
    verified_at TIMESTAMP NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (challenge_id) REFERENCES challenges(id) ON DELETE CASCADE,
    INDEX idx_challenge_id (challenge_id),
    INDEX idx_status (status)
);
 
-- Tabla para almacenar datos de credenciales verificadas (opcional)
CREATE TABLE IF NOT EXISTS verified_credentials (
    id VARCHAR(36) PRIMARY KEY,
    session_id VARCHAR(36),
    credential_type VARCHAR(255),
    issuer VARCHAR(255),
    subject VARCHAR(255),
    claims JSON,
    verified_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (session_id) REFERENCES verification_sessions(id) ON DELETE CASCADE,
    INDEX idx_session_id (session_id),
    INDEX idx_credential_type (credential_type)
);
 
-- TABLAS DEL EMISOR
 
-- Tabla para almacenar códigos de autorización en el flujo OpenID4VCI
CREATE TABLE IF NOT EXISTS authorization_codes (
    id VARCHAR(36) PRIMARY KEY,
    code VARCHAR(255) NOT NULL UNIQUE,
    client_id VARCHAR(255),
    scope VARCHAR(255),
    code_challenge VARCHAR(255),
    code_challenge_method VARCHAR(50),
    redirect_uri TEXT,
    user_pin VARCHAR(10),
    expires_at TIMESTAMP NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    used BOOLEAN DEFAULT FALSE,
    INDEX idx_code (code),
    INDEX idx_expires_at (expires_at)
);
 
-- Tabla para almacenar sesiones de emisión
CREATE TABLE IF NOT EXISTS issuance_sessions (
    id VARCHAR(36) PRIMARY KEY,
    authorization_code_id VARCHAR(36),
    access_token VARCHAR(255),
    token_type VARCHAR(50) DEFAULT 'Bearer',
    expires_in INT DEFAULT 3600,
    c_nonce VARCHAR(255),
    c_nonce_expires_at TIMESTAMP,
    status ENUM('pending', 'authorized', 'credential_issued', 'expired', 'failed') DEFAULT 'pending',
    user_data JSON,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (authorization_code_id) REFERENCES authorization_codes(id) ON DELETE CASCADE,
    INDEX idx_access_token (access_token),
    INDEX idx_c_nonce (c_nonce),
    INDEX idx_status (status)
);
 
-- Tabla para almacenar credenciales emitidas
CREATE TABLE IF NOT EXISTS issued_credentials (
    id VARCHAR(36) PRIMARY KEY,
    session_id VARCHAR(36),
    credential_id VARCHAR(255),
    credential_type VARCHAR(255) DEFAULT 'jwt_vc',
    doctype VARCHAR(255) DEFAULT 'eu.europa.ec.eudi.pid.1',
    credential_data LONGTEXT, -- mDoc codificado en Base64
    credential_claims JSON,
    issuer_did VARCHAR(255),
    subject_id VARCHAR(255),
    issued_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    expires_at TIMESTAMP,
    revoked BOOLEAN DEFAULT FALSE,
    revoked_at TIMESTAMP NULL,
    FOREIGN KEY (session_id) REFERENCES issuance_sessions(id) ON DELETE CASCADE,
    INDEX idx_credential_id (credential_id),
    INDEX idx_session_id (session_id),
    INDEX idx_doctype (doctype),
    INDEX idx_subject_id (subject_id),
    INDEX idx_issued_at (issued_at)
);
 
-- Tabla para almacenar claves del emisor (simplificada para la demo)
CREATE TABLE IF NOT EXISTS issuer_keys (
    id VARCHAR(36) PRIMARY KEY,
    key_id VARCHAR(255) NOT NULL UNIQUE,
    key_type VARCHAR(50) NOT NULL, -- 'EC', 'RSA'
    algorithm VARCHAR(50) NOT NULL, -- 'ES256', 'RS256', etc.
    public_key TEXT NOT NULL, -- formato JWK
    private_key TEXT NOT NULL, -- formato JWK (cifrado en producción)
    is_active BOOLEAN DEFAULT TRUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_key_id (key_id),
    INDEX idx_is_active (is_active)
);

docker-compose up -d

// src/lib/database.ts
import mysql from "mysql2/promise";
 
// Configuración de la conexión a la base de datos
const dbConfig = {
    host: process.env.DATABASE_HOST || "localhost",
    port: parseInt(process.env.DATABASE_PORT || "3306"),
    user: process.env.DATABASE_USER || "app_user",
    password: process.env.DATABASE_PASSWORD || "app_password",
    database: process.env.DATABASE_NAME || "digital_credentials",
    timezone: "+00:00",
};
 
let connection: mysql.Connection | null = null;
 
export async function getConnection(): Promise<mysql.Connection> {
    if (!connection) {
        connection = await mysql.createConnection(dbConfig);
    }
    return connection;
}
 
// Funciones de Data-Access-Object (DAO) para cada tabla
// ... (ej., createChallenge, getChallenge, createAuthorizationCode, etc.)

// src/lib/crypto.ts
import { generateKeyPair, exportJWK, SignJWT } from "jose";
 
export async function generateIssuerKeyPair(keyId: string, issuerDid: string) {
    const { publicKey, privateKey } = await generateKeyPair("ES256", {
        crv: "P-256",
        extractable: true,
    });
 
    const publicKeyJWK = await exportJWK(publicKey);
    publicKeyJWK.kid = keyId; // Asignar un ID de clave único
 
    // ... (exportación de la clave privada y otra configuración)
 
    return { publicKey, privateKey, publicKeyJWK /* ... */ };
}

// src/lib/crypto.ts
 
export async function createJWTVerifiableCredential(
    claims: MDocClaims,
    issuerKeyPair: IssuerKeyPair,
    subjectId: string,
    audience: string,
): Promise<string> {
    const now = Math.floor(Date.now() / 1000);
    const oneYear = 365 * 24 * 60 * 60;
 
    const vcPayload = {
        // El DID del emisor
        iss: issuerKeyPair.issuerDid,
        // El DID del sujeto (titular)
        sub: subjectId,
        // La hora en que se emitió la credencial (iat) y cuándo expira (exp)
        iat: now,
        exp: now + oneYear,
        // El modelo de datos de Credencial Verificable
        vc: {
            "@context": [
                "https://www.w3.org/2018/credentials/v1",
                "https://europa.eu/eudi/pid/v1",
            ],
            type: ["VerifiableCredential", "eu.europa.ec.eudi.pid.1"],
            issuer: issuerKeyPair.issuerDid,
            issuanceDate: new Date(now * 1000).toISOString(),
            credentialSubject: {
                id: subjectId,
                ...claims,
            },
        },
    };
 
    // Firmar el payload con la clave privada del emisor
    return await new SignJWT(vcPayload)
        .setProtectedHeader({
            alg: issuerKeyPair.algorithm,
            kid: issuerKeyPair.keyId,
            typ: "JWT",
        })
        .sign(issuerKeyPair.privateKey);
}

// src/app/issue/page.tsx
 
const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    setLoading(true);
    setError(null);
    setCredentialOffer(null);
 
    try {
        // 1. Validar campos requeridos
        if (!userData.given_name || !userData.family_name || !userData.birth_date) {
            throw new Error("Por favor, rellena todos los campos requeridos");
        }
 
        // 2. Solicitar una oferta de credencial al backend
        const response = await fetch("/api/issue/authorize", {
            method: "POST",
            headers: {
                "Content-Type": "application/json",
            },
            body: JSON.stringify({
                user_data: userData,
            }),
        });
 
        if (!response.ok) {
            const errorData = await response.json();
            throw new Error(
                errorData.error_description || "Fallo al crear la oferta de credencial",
            );
        }
 
        // 3. Establecer la oferta de credencial en el estado para mostrar el código QR
        const result = await response.json();
        setCredentialOffer(result);
    } catch (err) {
        const errorMessage = (err as Error).message || "Ocurrió un error desconocido";
        setError(errorMessage);
    } finally {
        setLoading(false);
    }
};

// src/app/.well-known/openid-credential-issuer/route.ts
import { NextResponse } from "next/server";
 
export async function GET() {
    const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || "http://localhost:3000";
 
    const issuerMetadata = {
        // El identificador único del emisor.
        issuer: baseUrl,
        // La URL del servidor de autorización. Para simplificar, nuestro emisor es su propio servidor de autorización.
        authorization_servers: [baseUrl],
        // La URL del emisor de la credencial.
        credential_issuer: baseUrl,
        // El endpoint al que la billetera hará POST para recibir la credencial real.
        credential_endpoint: `${baseUrl}/api/issue/credential`,
        // El endpoint donde la billetera intercambia un código de autorización por un token de acceso.
        token_endpoint: `${baseUrl}/api/issue/token`,
        // El endpoint para el flujo de autorización (no se usa en nuestro flujo preautorizado, pero es una buena práctica incluirlo).
        authorization_endpoint: `${baseUrl}/api/issue/authorize`,
        // Indica soporte para el flujo de código preautorizado sin requerir autenticación del cliente.
        pre_authorized_grant_anonymous_access_supported: true,
        // Información legible por humanos sobre el emisor.
        display: [
            {
                name: "Corbado Credentials Issuer",
                locale: "en-US",
            },
        ],
        // Una lista de los tipos de credenciales que este emisor puede emitir.
        credential_configurations_supported: {
            "eu.europa.ec.eudi.pid.1": {
                // El formato de la credencial (ej., jwt_vc, mso_mdoc).
                format: "jwt_vc",
                // El tipo de documento específico, conforme a los estándares ISO mDoc.
                doctype: "eu.europa.ec.eudi.pid.1",
                // El scope de OAuth 2.0 asociado con este tipo de credencial.
                scope: "eu.europa.ec.eudi.pid.1",
                // Métodos que la billetera puede usar para probar la posesión de su clave.
                cryptographic_binding_methods_supported: ["jwk"],
                // Algoritmos de firma que el emisor soporta para esta credencial.
                credential_signing_alg_values_supported: ["ES256"],
                // Tipos de prueba de posesión que la billetera puede usar.
                proof_types_supported: {
                    jwt: {
                        proof_signing_alg_values_supported: ["ES256", "ES384", "ES512"],
                    },
                },
                // Propiedades de visualización para la credencial.
                display: [
                    {
                        name: "Corbado Credential Issuer",
                        locale: "en-US",
                        logo: {
                            uri: `${baseUrl}/logo.png`,
                            alt_text: "EU Digital Identity",
                        },
                        background_color: "#003399",
                        text_color: "#FFFFFF",
                    },
                ],
                // Una lista de las claims (atributos) en la credencial.
                claims: {
                    "eu.europa.ec.eudi.pid.1": {
                        given_name: {
                            mandatory: true,
                            display: [{ name: "Given Name", locale: "en-US" }],
                        },
                        family_name: {
                            mandatory: true,
                            display: [{ name: "Family Name", locale: "en-US" }],
                        },
                        birth_date: {
                            mandatory: true,
                            display: [{ name: "Date of Birth", locale: "en-US" }],
                        },
                    },
                },
            },
        },
        // Métodos de autenticación soportados por el token endpoint. 'none' significa cliente público.
        token_endpoint_auth_methods_supported: ["none"],
        // Métodos de desafío de código PKCE soportados.
        code_challenge_methods_supported: ["S256"],
        // Tipos de concesión de OAuth 2.0 que el emisor soporta.
        grant_types_supported: [
            "authorization_code",
            "urn:ietf:params:oauth:grant-type:pre-authorized_code",
        ],
    };
 
    return NextResponse.json(issuerMetadata, {
        headers: {
            "Content-Type": "application/json",
            "Cache-Control": "no-cache, no-store, must-revalidate",
            Pragma: "no-cache",
            Expires: "0",
        },
    });
}

// src/app/.well-known/openid-configuration/route.ts
import { NextResponse } from "next/server";
 
export async function GET() {
    const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || "http://localhost:3000";
 
    const openidConfiguration = {
        // El identificador único del emisor.
        credential_issuer: baseUrl,
        // El endpoint al que la billetera hará POST para recibir la credencial real.
        credential_endpoint: `${baseUrl}/api/issue/credential`,
        // El endpoint para el flujo de autorización.
        authorization_endpoint: `${baseUrl}/api/issue/authorize`,
        // El endpoint donde la billetera intercambia un código de autorización por un token de acceso.
        token_endpoint: `${baseUrl}/api/issue/token`,
        // Una lista de los tipos de credenciales que este emisor puede emitir.
        credential_configurations_supported: {
            "eu.europa.ec.eudi.pid.1": {
                format: "jwt_vc",
                scope: "eu.europa.ec.eudi.pid.1",
                cryptographic_binding_methods_supported: ["jwk"],
                credential_signing_alg_values_supported: ["ES256", "ES384", "ES512"],
                proof_types_supported: {
                    jwt: {
                        proof_signing_alg_values_supported: ["ES256", "ES384", "ES512"],
                    },
                },
            },
        },
        // Tipos de concesión de OAuth 2.0 que el emisor soporta.
        grant_types_supported: [
            "authorization_code",
            "urn:ietf:params:oauth:grant-type:pre-authorized_code",
        ],
        // Indica soporte para el flujo de código preautorizado.
        pre_authorized_grant_anonymous_access_supported: true,
        // Métodos de desafío de código PKCE soportados.
        code_challenge_methods_supported: ["S256"],
        // Métodos de autenticación soportados por el token endpoint.
        token_endpoint_auth_methods_supported: ["none"],
        // Scopes de OAuth 2.0 que el emisor soporta.
        scopes_supported: ["eu.europa.ec.eudi.pid.1"],
    };
 
    return NextResponse.json(openidConfiguration, {
        headers: {
            "Content-Type": "application/json",
            "Cache-Control": "no-cache, no-store, must-revalidate",
            Pragma: "no-cache",
            Expires: "0",
        },
    });
}

// src/app/.well-known/did.json/route.ts
import { NextResponse } from "next/server";
import { getActiveIssuerKey } from "../../../lib/database";
import { generateIssuerDid } from "../../../lib/crypto";
 
export async function GET() {
    const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || "http://localhost:3000";
    const issuerKey = await getActiveIssuerKey();
 
    if (!issuerKey) {
        return NextResponse.json(
            { error: "No se encontró una clave de emisor activa" },
            { status: 404 },
        );
    }
 
    const publicKeyJWK = JSON.parse(issuerKey.public_key);
    const didId = generateIssuerDid();
    const didDocument = {
        // El contexto define el vocabulario utilizado en el documento.
        "@context": [
            "https://www.w3.org/ns/did/v1",
            "https://w3id.org/security/suites/jws-2020/v1",
        ],
        // La URI del DID, que es el identificador único del emisor.
        id: didId,
        // El controlador del DID, que es la entidad que controla el DID. Aquí, es el propio emisor.
        controller: didId,
        // Una lista de claves públicas que se pueden usar para verificar las firmas del emisor.
        verificationMethod: [
            {
                // Un identificador único para la clave, dentro del ámbito del DID.
                id: `${didId}#${issuerKey.key_id}`,
                // El tipo de la clave.
                type: "JsonWebKey2020",
                // El DID del controlador de la clave.
                controller: didId,
                // La clave pública en formato JWK.
                publicKeyJwk: publicKeyJWK,
            },
        ],
        // Especifica qué claves se pueden usar para la autenticación (probar el control del DID).
        authentication: [`${didId}#${issuerKey.key_id}`],
        // Especifica qué claves se pueden usar para crear credenciales verificables.
        assertionMethod: [`${didId}#${issuerKey.key_id}`],
        // Una lista de servicios proporcionados por el sujeto del DID, como el endpoint del emisor.
        service: [
            {
                id: `${didId}#openid-credential-issuer`,
                type: "OpenIDCredentialIssuer",
                serviceEndpoint: `${baseUrl}/.well-known/openid-credential-issuer`,
            },
        ],
    };
 
    return NextResponse.json(didDocument, {
        headers: {
            "Content-Type": "application/did+json",
            "Cache-Control": "no-cache, no-store, must-revalidate",
            Pragma: "no-cache",
            Expires: "0",
        },
    });
}

// src/app/api/schemas/pid/route.ts
import { NextResponse } from "next/server";
 
export async function GET() {
    const schema = {
        $schema: "https://json-schema.org/draft/2020-12/schema",
        $id: "https://example.com/schemas/pid", // Reemplaza con tu dominio real
        title: "Credencial PID",
        description:
            "Un esquema para una Credencial Verificable que representa un Documento de Identificación Personal (PID).",
        type: "object",
        properties: {
            credentialSubject: {
                type: "object",
                properties: {
                    given_name: { type: "string" },
                    family_name: { type: "string" },
                    birth_date: { type: "string", format: "date" },
                    // ... otras propiedades del sujeto de la credencial
                },
                required: ["given_name", "family_name", "birth_date"],
            },
            // ... otras propiedades de nivel superior de una Credencial Verificable
        },
    };
 
    return NextResponse.json(schema, {
        headers: {
            "Content-Type": "application/schema+json",
            "Access-Control-Allow-Origin": "*", // Permitir solicitudes de origen cruzado
        },
    });
}

// src/app/api/issue/authorize/route.ts
import { NextRequest, NextResponse } from "next/server";
import { v4 as uuidv4 } from "uuid";
import { createAuthorizationCode } from "@/lib/database";
 
export async function POST(request: NextRequest) {
    try {
        const body = await request.json();
        const { user_data } = body;
 
        // 1. Validar los datos del usuario
        if (
            !user_data ||
            !user_data.given_name ||
            !user_data.family_name ||
            !user_data.birth_date
        ) {
            return NextResponse.json({ error: "missing_user_data" }, { status: 400 });
        }
 
        // 2. Generar un código preautorizado y un PIN
        const code = uuidv4();
        const expiresAt = new Date(Date.now() + 10 * 60 * 1000); // 10 minutos
        const txCode = Math.floor(1000 + Math.random() * 9000).toString(); // PIN de 4 dígitos
 
        // 3. Almacenar el código y los datos del usuario
        await createAuthorizationCode(uuidv4(), code, expiresAt);
        // Nota: Esto utiliza un almacén en memoria solo para fines de demostración.
        // En producción, persiste los datos de forma segura en una base de datos con una expiración adecuada.
        if (!(global as any).userDataStore) (global as any).userDataStore = new Map();
        (global as any).userDataStore.set(code, user_data);
        if (!(global as any).txCodeStore) (global as any).txCodeStore = new Map();
        (global as any).txCodeStore.set(code, txCode);
 
        // 4. Crear el objeto de oferta de credencial
        const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || "http://localhost:3000";
        const credentialOffer = {
            // El identificador del emisor, que es su URL base.
            credential_issuer: baseUrl,
            // Un array de tipos de credenciales que el emisor está ofreciendo.
            credential_configuration_ids: ["eu.europa.ec.eudi.pid.1"],
            // Especifica los tipos de concesión que la billetera puede usar.
            grants: {
                // Estamos usando el flujo de código preautorizado.
                "urn:ietf:params:oauth:grant-type:pre-authorized_code": {
                    // El código de un solo uso que la billetera intercambiará por un token.
                    "pre-authorized_code": code,
                    // Indica que el usuario debe introducir un PIN (tx_code) para canjear el código.
                    user_pin_required: true,
                },
            },
        };
 
        // 5. Crear la URI completa de la oferta de credencial (un deep link para billeteras)
        const credentialOfferUri = `openid-credential-offer://?credential_offer=${encodeURIComponent(
            JSON.stringify(credentialOffer),
        )}`;
 
        // La respuesta final al frontend.
        return NextResponse.json({
            // El deep link para el código QR.
            credential_offer_uri: credentialOfferUri,
            // El código preautorizado en crudo, para mostrarlo o para entrada manual.
            pre_authorized_code: code,
            // El PIN de 4 dígitos que el usuario debe introducir en su billetera.
            tx_code: txCode,
        });
    } catch (error) {
        console.error("Error de autorización:", error);
        return NextResponse.json({ error: "server_error" }, { status: 500 });
    }
}

// src/app/api/issue/token/route.ts
import { NextRequest, NextResponse } from "next/server";
import { v4 as uuidv4 } from "uuid";
import {
    getAuthorizationCode,
    markAuthorizationCodeAsUsed,
    createIssuanceSession,
} from "@/lib/database";
 
export async function POST(request: NextRequest) {
    try {
        const formData = await request.formData();
        const grant_type = formData.get("grant_type") as string;
        const code = formData.get("pre-authorized_code") as string;
        const user_pin = formData.get("user_pin") as string;
 
        // 1. Validar el tipo de concesión
        if (grant_type !== "urn:ietf:params:oauth:grant-type:pre-authorized_code") {
            return NextResponse.json(
                { error: "unsupported_grant_type" },
                { status: 400 },
            );
        }
 
        // 2. Validar el código preautorizado
        const authCode = await getAuthorizationCode(code);
        if (!authCode) {
            return NextResponse.json(
                {
                    error: "invalid_grant",
                    error_description: "Código inválido o expirado",
                },
                { status: 400 },
            );
        }
 
        // 3. Validar el PIN (tx_code)
        const expectedTxCode = (global as any).txCodeStore?.get(code);
        if (expectedTxCode !== user_pin) {
            return NextResponse.json(
                { error: "invalid_grant", error_description: "PIN inválido" },
                { status: 400 },
            );
        }
 
        // 4. Generar token de acceso y c_nonce
        const accessToken = uuidv4();
        const cNonce = uuidv4();
        const cNonceExpiresAt = new Date(Date.now() + 5 * 60 * 1000); // 5 minutos
 
        // 5. Crear una nueva sesión de emisión
        const userData = (global as any).userDataStore?.get(code);
        await createIssuanceSession(
            uuidv4(),
            authCode.id,
            accessToken,
            cNonce,
            cNonceExpiresAt,
            userData,
        );
 
        // 6. Marcar el código como usado y limpiar los datos temporales
        await markAuthorizationCodeAsUsed(code);
        (global as any).txCodeStore?.delete(code);
        (global as any).userDataStore?.delete(code);
 
        // 7. Devolver la respuesta del token de acceso
        return NextResponse.json({
            access_token: accessToken,
            token_type: "Bearer",
            expires_in: 3600, // 1 hora
            c_nonce: cNonce,
            c_nonce_expires_in: 300, // 5 minutos
        });
    } catch (error) {
        console.error("Error en el endpoint del token:", error);
        return NextResponse.json({ error: "server_error" }, { status: 500 });
    }
}

// src/app/api/issue/credential/route.ts
import { NextRequest, NextResponse } from "next/server";
import { v4 as uuidv4 } from "uuid";
import {
    getIssuanceSessionByToken,
    updateIssuanceSession,
    createIssuedCredential,
    getActiveIssuerKey,
} from "@/lib/database";
import {
    createJWTVerifiableCredential,
    importIssuerKeyPair,
    generateIssuerDid,
} from "@/lib/crypto";
 
export async function POST(request: NextRequest) {
    try {
        // 1. Validar el token Bearer
        const authHeader = request.headers.get("authorization");
        const accessToken = authHeader?.substring(7);
        const session = await getIssuanceSessionByToken(accessToken);
 
        if (!session) {
            return NextResponse.json({ error: "invalid_token" }, { status: 401 });
        }
 
        // 2. Obtener los datos del usuario de la sesión
        const userData = session.user_data;
        if (!userData) {
            return NextResponse.json({ error: "missing_user_data" }, { status: 400 });
        }
 
        // 3. Obtener la clave de emisor activa
        const issuerKey = await getActiveIssuerKey();
        if (!issuerKey) {
            // En una aplicación real, tendrías un sistema de gestión de claves más robusto.
            // Para esta demostración, podemos generar una clave sobre la marcha si no existe.
            // Esta parte se omite por brevedad, pero está en el repositorio.
            return NextResponse.json(
                {
                    error: "server_error",
                    error_description: "Fallo al obtener la clave del emisor",
                },
                { status: 500 },
            );
        }
 
        // 4. Crear el JWT-VC
        const issuerDid = generateIssuerDid();
        const keyPair = await importIssuerKeyPair(
            issuerKey.key_id,
            issuerKey.public_key,
            issuerKey.private_key,
            issuerDid,
        );
        const subjectId = `did:example:${uuidv4()}`;
        const credentialData = await createJWTVerifiableCredential(
            userData,
            keyPair,
            subjectId,
            process.env.NEXT_PUBLIC_BASE_URL || "http://localhost:3000",
        );
 
        // 5. Almacenar la credencial emitida en la base de datos
        await createIssuedCredential(/* ... detalles de la credencial ... */);
        await updateIssuanceSession(session.id, "credential_issued");
 
        // 6. Devolver la credencial firmada
        return NextResponse.json({
            format: "jwt_vc",
            credential: credentialData,
            c_nonce: uuidv4(), // Un nuevo nonce para solicitudes posteriores
            c_nonce_expires_in: 300,
        });
    } catch (error) {
        console.error("Error en el endpoint de la credencial:", error);
        return NextResponse.json({ error: "server_error" }, { status: 500 });
    }
}