diff --git a/.claude/settings.local.json b/.claude/settings.local.json
index 29341606..b3b167a0 100644
--- a/.claude/settings.local.json
+++ b/.claude/settings.local.json
@@ -88,7 +88,8 @@
       "Bash(PORT=5555 DEBUG=false TEST_NEW_VAR=hello node test-output.js)",
       "Bash(bunx prettier:*)",
       "Read(//c/c/Users/Marcos/Documents/GitHub/aviso-projeto/FluxStack/**)",
-      "Read(//c/**)"
+      "Read(//c/**)",
+      "Bash(LOG_LEVEL=debug timeout 5 bun run dev)"
     ],
     "deny": []
   }
diff --git a/.env.example b/.env.example
index 70e30de3..764d0a7c 100644
--- a/.env.example
+++ b/.env.example
@@ -27,4 +27,11 @@ LOG_LEVEL=info
 
 # Build Configuration
 BUILD_TARGET=bun
-BUILD_OUTDIR=dist
\ No newline at end of file
+BUILD_OUTDIR=dist
+
+# Crypto Auth Plugin
+CRYPTO_AUTH_ENABLED=true
+CRYPTO_AUTH_MAX_TIME_DRIFT=300000
+# Adicione chaves públicas de admin separadas por vírgula (64 chars hex cada)
+CRYPTO_AUTH_ADMIN_KEYS=
+CRYPTO_AUTH_ENABLE_METRICS=true
\ No newline at end of file
diff --git a/CRYPTO-AUTH-MIDDLEWARE-GUIDE.md b/CRYPTO-AUTH-MIDDLEWARE-GUIDE.md
new file mode 100644
index 00000000..f6e0ac17
--- /dev/null
+++ b/CRYPTO-AUTH-MIDDLEWARE-GUIDE.md
@@ -0,0 +1,475 @@
+# 🔐 Crypto Auth - Guia de Middlewares
+
+> **✅ Nova Abordagem**: Middlewares declarativos - sem necessidade de configurar listas de paths!
+
+## 📖 **Visão Geral**
+
+O plugin Crypto Auth agora usa **middlewares Elysia nativos** aplicados diretamente nas rotas. Isso torna o código mais limpo, explícito e fácil de manter.
+
+## 🚀 **Quick Start**
+
+### **1. Configuração Simplificada**
+
+```typescript
+// fluxstack.config.ts
+plugins: {
+  enabled: ['crypto-auth'],
+  config: {
+    'crypto-auth': {
+      enabled: true,
+      maxTimeDrift: 300000, // 5 minutos
+      adminKeys: [
+        'abc123def456...' // Chaves públicas dos admins
+      ],
+      enableMetrics: true
+    }
+  }
+}
+```
+
+**✅ Removido**: `protectedRoutes` e `publicRoutes`
+**✅ Novo**: Middlewares aplicados diretamente nas rotas
+
+---
+
+## 🔌 **Middlewares Disponíveis**
+
+### **1. `cryptoAuthRequired()` - Requer Autenticação**
+
+Bloqueia a rota se não houver assinatura válida.
+
+```typescript
+import { cryptoAuthRequired, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+import { Elysia } from 'elysia'
+
+export const protectedRoutes = new Elysia()
+  .use(cryptoAuthRequired()) // ⚡ Middleware aplicado
+
+  .get('/profile', ({ request }) => {
+    const user = getCryptoAuthUser(request)! // Garantido que existe
+    return {
+      publicKey: user.publicKey,
+      isAdmin: user.isAdmin
+    }
+  })
+```
+
+**Response se não autenticado (401):**
+```json
+{
+  "error": {
+    "message": "Authentication required",
+    "code": "CRYPTO_AUTH_REQUIRED",
+    "statusCode": 401
+  }
+}
+```
+
+---
+
+### **2. `cryptoAuthAdmin()` - Requer Admin**
+
+Bloqueia a rota se não for administrador.
+
+```typescript
+import { cryptoAuthAdmin } from '@/plugins/crypto-auth/server'
+
+export const adminRoutes = new Elysia()
+  .use(cryptoAuthAdmin()) // ⚡ Requer admin
+
+  .delete('/users/:id', ({ params, request }) => {
+    const user = getCryptoAuthUser(request)! // Garantido admin
+    return {
+      deleted: params.id,
+      by: user.publicKey
+    }
+  })
+```
+
+**Response se não for admin (403):**
+```json
+{
+  "error": {
+    "message": "Admin privileges required",
+    "code": "ADMIN_REQUIRED",
+    "statusCode": 403,
+    "yourPermissions": ["user", "read"]
+  }
+}
+```
+
+---
+
+### **3. `cryptoAuthPermissions([...])` - Requer Permissões**
+
+Bloqueia se não tiver as permissões específicas.
+
+```typescript
+import { cryptoAuthPermissions } from '@/plugins/crypto-auth/server'
+
+export const writeRoutes = new Elysia()
+  .use(cryptoAuthPermissions(['write', 'edit'])) // ⚡ Requer ambas
+
+  .post('/posts', ({ body }) => {
+    return { created: body }
+  })
+```
+
+**Response se sem permissão (403):**
+```json
+{
+  "error": {
+    "message": "Insufficient permissions",
+    "code": "PERMISSION_DENIED",
+    "statusCode": 403,
+    "required": ["write", "edit"],
+    "yours": ["read"]
+  }
+}
+```
+
+---
+
+### **4. `cryptoAuthOptional()` - Autenticação Opcional**
+
+Não bloqueia, mas adiciona `user` se autenticado.
+
+```typescript
+import { cryptoAuthOptional, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+export const feedRoutes = new Elysia()
+  .use(cryptoAuthOptional()) // ⚡ Opcional
+
+  .get('/posts', ({ request }) => {
+    const user = getCryptoAuthUser(request) // Pode ser null
+
+    return {
+      posts: getPosts(),
+      personalizedFor: user ? user.publicKey : 'anonymous'
+    }
+  })
+```
+
+---
+
+## 🎯 **Padrões de Uso**
+
+### **Padrão 1: Grupo de Rotas Protegidas**
+
+```typescript
+import { Elysia } from 'elysia'
+import { cryptoAuthRequired } from '@/plugins/crypto-auth/server'
+
+export const apiRoutes = new Elysia({ prefix: '/api' })
+
+  // Rotas públicas
+  .get('/health', () => ({ status: 'ok' }))
+  .get('/docs', () => ({ version: '1.0.0' }))
+
+  // Grupo protegido
+  .group('/users', (app) => app
+    .use(cryptoAuthRequired()) // ⚡ Todas as rotas do grupo requerem auth
+
+    .get('/', ({ request }) => {
+      const user = getCryptoAuthUser(request)!
+      return { users: getUsers(user.publicKey) }
+    })
+
+    .post('/', ({ body }) => {
+      return { created: body }
+    })
+  )
+```
+
+---
+
+### **Padrão 2: Mix de Permissões no Mesmo Grupo**
+
+```typescript
+export const postsRoutes = new Elysia({ prefix: '/api/posts' })
+
+  // Leitura: apenas auth
+  .group('', (app) => app
+    .use(cryptoAuthRequired())
+
+    .get('/', () => ({ posts: [] }))
+    .get('/:id', ({ params }) => ({ post: params.id }))
+  )
+
+  // Escrita: auth + permissão write
+  .group('', (app) => app
+    .use(cryptoAuthPermissions(['write']))
+
+    .post('/', ({ body }) => ({ created: body }))
+    .put('/:id', ({ params, body }) => ({ updated: params.id }))
+  )
+
+  // Deleção: só admin
+  .group('', (app) => app
+    .use(cryptoAuthAdmin())
+
+    .delete('/:id', ({ params }) => ({ deleted: params.id }))
+  )
+```
+
+---
+
+### **Padrão 3: Auth Opcional com Comportamento Diferente**
+
+```typescript
+import { cryptoAuthOptional, getCryptoAuthUser, isCryptoAuthAdmin } from '@/plugins/crypto-auth/server'
+
+export const contentRoutes = new Elysia({ prefix: '/api/content' })
+  .use(cryptoAuthOptional()) // ⚡ Auth opcional para todas
+
+  .get('/articles/:id', ({ request, params }) => {
+    const user = getCryptoAuthUser(request)
+    const isAdmin = isCryptoAuthAdmin(request)
+    const article = getArticle(params.id)
+
+    return {
+      ...article,
+      premium: user ? article.premiumContent : '[Premium - Login Required]',
+      canEdit: isAdmin,
+      canComment: !!user
+    }
+  })
+```
+
+---
+
+## 🛠️ **Helpers Disponíveis**
+
+### **`getCryptoAuthUser(request)`**
+
+Retorna o usuário autenticado ou `null`.
+
+```typescript
+import { getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+.get('/me', ({ request }) => {
+  const user = getCryptoAuthUser(request)
+
+  if (!user) {
+    return { error: 'Not authenticated' }
+  }
+
+  return { user }
+})
+```
+
+---
+
+### **`isCryptoAuthAuthenticated(request)`**
+
+Verifica se está autenticado.
+
+```typescript
+import { isCryptoAuthAuthenticated } from '@/plugins/crypto-auth/server'
+
+.get('/status', ({ request }) => {
+  return {
+    authenticated: isCryptoAuthAuthenticated(request)
+  }
+})
+```
+
+---
+
+### **`isCryptoAuthAdmin(request)`**
+
+Verifica se é admin.
+
+```typescript
+import { isCryptoAuthAdmin } from '@/plugins/crypto-auth/server'
+
+.get('/posts/:id', ({ request, params }) => {
+  const post = getPost(params.id)
+
+  return {
+    ...post,
+    canEdit: isCryptoAuthAdmin(request)
+  }
+})
+```
+
+---
+
+### **`hasCryptoAuthPermission(request, permission)`**
+
+Verifica permissão específica.
+
+```typescript
+import { hasCryptoAuthPermission } from '@/plugins/crypto-auth/server'
+
+.post('/posts/:id/publish', ({ request, params }) => {
+  if (!hasCryptoAuthPermission(request, 'publish')) {
+    return { error: 'Permission denied' }
+  }
+
+  return publishPost(params.id)
+})
+```
+
+---
+
+## 📋 **Estrutura do User**
+
+```typescript
+interface CryptoAuthUser {
+  publicKey: string      // Chave pública Ed25519 (hex)
+  isAdmin: boolean       // Se está na lista adminKeys
+  permissions: string[]  // ['read', 'write', 'admin', ...]
+}
+```
+
+**Como o `isAdmin` é determinado:**
+```typescript
+// Plugin verifica se a publicKey está em adminKeys
+const isAdmin = config.adminKeys.includes(user.publicKey)
+```
+
+---
+
+## 🔄 **Migrando da Abordagem Antiga**
+
+### **❌ Antes (listas de paths)**
+
+```typescript
+// fluxstack.config.ts
+plugins: {
+  config: {
+    'crypto-auth': {
+      protectedRoutes: ['/api/users/*', '/api/admin/*'],
+      publicRoutes: ['/api/health', '/api/docs']
+    }
+  }
+}
+
+// Rotas (sem controle explícito)
+export const routes = new Elysia()
+  .get('/api/users', handler) // Protegido pelo plugin
+```
+
+### **✅ Agora (middlewares declarativos)**
+
+```typescript
+// fluxstack.config.ts
+plugins: {
+  config: {
+    'crypto-auth': {
+      adminKeys: ['abc123...']
+      // Sem protectedRoutes/publicRoutes!
+    }
+  }
+}
+
+// Rotas (controle explícito)
+import { cryptoAuthRequired } from '@/plugins/crypto-auth/server'
+
+export const routes = new Elysia()
+  .get('/health', handler) // ✅ Público explicitamente
+
+  .group('/users', (app) => app
+    .use(cryptoAuthRequired()) // ✅ Protegido explicitamente
+    .get('/', handler)
+  )
+```
+
+---
+
+## 🎯 **Vantagens da Nova Abordagem**
+
+| Aspecto | Antes | Agora |
+|---------|-------|-------|
+| **Clareza** | Rotas implicitamente protegidas | ✅ Explícito no código |
+| **Manutenção** | Editar config + rotas | ✅ Editar apenas rotas |
+| **Type Safety** | Sem garantia de user | ✅ TypeScript sabe que user existe |
+| **Flexibilidade** | Apenas on/off | ✅ Permissões, admin, opcional |
+| **Debugging** | Difícil rastrear proteção | ✅ Fácil ver middleware aplicado |
+
+---
+
+## 🧪 **Testando**
+
+### **Rota Pública**
+```bash
+curl http://localhost:3000/api/crypto-auth/public
+# ✅ 200 OK - sem headers
+```
+
+### **Rota Protegida (sem auth)**
+```bash
+curl http://localhost:3000/api/crypto-auth/protected
+# ❌ 401 Unauthorized
+```
+
+### **Rota Protegida (com auth)**
+```bash
+curl http://localhost:3000/api/crypto-auth/protected \
+  -H "x-public-key: abc123..." \
+  -H "x-timestamp: 1234567890" \
+  -H "x-nonce: xyz789" \
+  -H "x-signature: def456..."
+# ✅ 200 OK
+```
+
+### **Rota Admin (sem ser admin)**
+```bash
+curl http://localhost:3000/api/crypto-auth/admin \
+  -H "x-public-key: user123..." \
+  -H "x-signature: ..."
+# ❌ 403 Forbidden - "Admin privileges required"
+```
+
+---
+
+## 📚 **Exemplos Completos**
+
+Veja exemplos práticos em:
+- `app/server/routes/crypto-auth-demo.routes.ts` - Rotas de demonstração
+- `plugins/crypto-auth/server/middlewares.ts` - Implementação dos middlewares
+
+---
+
+## 🆘 **Troubleshooting**
+
+### **Erro: "CryptoAuthService not initialized"**
+
+**Causa**: Plugin não está carregado.
+
+**Solução**:
+```typescript
+// fluxstack.config.ts
+plugins: {
+  enabled: ['crypto-auth'], // ✅ Adicione aqui
+}
+```
+
+### **User sempre null**
+
+**Causa**: Não está usando o middleware.
+
+**Solução**:
+```typescript
+// ❌ Errado
+.get('/protected', ({ request }) => {
+  const user = getCryptoAuthUser(request) // null
+})
+
+// ✅ Correto
+.use(cryptoAuthRequired())
+.get('/protected', ({ request }) => {
+  const user = getCryptoAuthUser(request)! // Garantido
+})
+```
+
+### **403 ao invés de 401**
+
+**Causa**: Usuário autenticado mas sem permissão.
+
+**Solução**: Verificar se `adminKeys` ou permissões estão corretas.
+
+---
+
+**✅ Pronto!** Agora você tem controle total e explícito sobre quais rotas são protegidas, sem precisar configurar listas de paths!
diff --git a/CRYPTO-AUTH-MIDDLEWARES.md b/CRYPTO-AUTH-MIDDLEWARES.md
new file mode 100644
index 00000000..c62d0d5d
--- /dev/null
+++ b/CRYPTO-AUTH-MIDDLEWARES.md
@@ -0,0 +1,473 @@
+# 🔐 Crypto Auth - Middlewares Elysia
+
+## 🚀 Guia Rápido
+
+### Uso Básico
+
+```typescript
+import { Elysia } from 'elysia'
+import { cryptoAuthRequired, cryptoAuthAdmin } from '@/plugins/crypto-auth/server'
+
+export const myRoutes = new Elysia()
+  // ✅ Aplica autenticação a todas as rotas
+  .use(cryptoAuthRequired())
+
+  .get('/users', ({ request }) => {
+    const user = (request as any).user
+    return { users: [], requestedBy: user.publicKey }
+  })
+
+  .post('/users', ({ request, body }) => {
+    const user = (request as any).user
+    return { created: body, by: user.publicKey }
+  })
+```
+
+---
+
+## 📚 Middlewares Disponíveis
+
+### 1️⃣ `cryptoAuthRequired()` - Requer Autenticação
+
+Valida assinatura e bloqueia acesso se não autenticado.
+
+```typescript
+import { cryptoAuthRequired, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+export const protectedRoutes = new Elysia()
+  .use(cryptoAuthRequired())  // ✅ Todas as rotas protegidas
+
+  .get('/profile', ({ request }) => {
+    const user = getCryptoAuthUser(request)!
+    return {
+      publicKey: user.publicKey,
+      isAdmin: user.isAdmin,
+      permissions: user.permissions
+    }
+  })
+```
+
+**Retorno se não autenticado**:
+```json
+{
+  "error": {
+    "message": "Authentication required",
+    "code": "CRYPTO_AUTH_REQUIRED",
+    "statusCode": 401
+  }
+}
+```
+
+---
+
+### 2️⃣ `cryptoAuthAdmin()` - Requer Admin
+
+Valida autenticação E verifica se usuário é admin.
+
+```typescript
+import { cryptoAuthAdmin } from '@/plugins/crypto-auth/server'
+
+export const adminRoutes = new Elysia()
+  .use(cryptoAuthAdmin())  // ✅ Apenas admins
+
+  .get('/admin/stats', () => ({
+    totalUsers: 100,
+    systemHealth: 'optimal'
+  }))
+
+  .delete('/admin/users/:id', ({ params, request }) => {
+    const user = (request as any).user
+    return {
+      deleted: params.id,
+      by: user.publicKey
+    }
+  })
+```
+
+**Retorno se não for admin**:
+```json
+{
+  "error": {
+    "message": "Admin privileges required",
+    "code": "ADMIN_REQUIRED",
+    "statusCode": 403,
+    "yourPermissions": ["read"]
+  }
+}
+```
+
+---
+
+### 3️⃣ `cryptoAuthPermissions(permissions)` - Requer Permissões
+
+Valida autenticação E verifica permissões específicas.
+
+```typescript
+import { cryptoAuthPermissions } from '@/plugins/crypto-auth/server'
+
+export const writeRoutes = new Elysia()
+  .use(cryptoAuthPermissions(['write']))  // ✅ Requer permissão 'write'
+
+  .put('/posts/:id', ({ params, body }) => ({
+    updated: params.id,
+    data: body
+  }))
+
+  .patch('/posts/:id/publish', ({ params }) => ({
+    published: params.id
+  }))
+```
+
+**Múltiplas permissões**:
+```typescript
+.use(cryptoAuthPermissions(['write', 'publish']))
+```
+
+**Retorno se sem permissão**:
+```json
+{
+  "error": {
+    "message": "Insufficient permissions",
+    "code": "PERMISSION_DENIED",
+    "statusCode": 403,
+    "required": ["write"],
+    "yours": ["read"]
+  }
+}
+```
+
+---
+
+### 4️⃣ `cryptoAuthOptional()` - Autenticação Opcional
+
+Adiciona `user` se autenticado, mas NÃO bloqueia se não autenticado.
+
+```typescript
+import { cryptoAuthOptional, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+export const mixedRoutes = new Elysia()
+  .use(cryptoAuthOptional())  // ✅ Opcional
+
+  // Comportamento diferente se autenticado
+  .get('/posts/:id', ({ request, params }) => {
+    const user = getCryptoAuthUser(request)
+
+    return {
+      post: {
+        id: params.id,
+        title: 'Post Title',
+        // Conteúdo completo apenas se autenticado
+        content: user ? 'Full content...' : 'Preview...'
+      },
+      viewer: user ? {
+        publicKey: user.publicKey,
+        canEdit: user.isAdmin
+      } : null
+    }
+  })
+```
+
+---
+
+## 🛠️ Helper Functions
+
+### `getCryptoAuthUser(request)` - Obter Usuário
+
+```typescript
+import { getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+.get('/me', ({ request }) => {
+  const user = getCryptoAuthUser(request)
+
+  if (!user) {
+    return { error: 'Not authenticated' }
+  }
+
+  return { user }
+})
+```
+
+---
+
+### `isCryptoAuthAuthenticated(request)` - Verificar se Autenticado
+
+```typescript
+import { isCryptoAuthAuthenticated } from '@/plugins/crypto-auth/server'
+
+.get('/posts/:id', ({ request, params }) => {
+  const isAuth = isCryptoAuthAuthenticated(request)
+
+  return {
+    post: { id: params.id },
+    canComment: isAuth
+  }
+})
+```
+
+---
+
+### `isCryptoAuthAdmin(request)` - Verificar se é Admin
+
+```typescript
+import { isCryptoAuthAdmin } from '@/plugins/crypto-auth/server'
+
+.get('/posts/:id', ({ request, params, set }) => {
+  if (!isCryptoAuthAdmin(request)) {
+    set.status = 403
+    return { error: 'Admin only' }
+  }
+
+  return { post: params.id }
+})
+```
+
+---
+
+### `hasCryptoAuthPermission(request, permission)` - Verificar Permissão
+
+```typescript
+import { hasCryptoAuthPermission } from '@/plugins/crypto-auth/server'
+
+.put('/posts/:id', ({ request, params, set }) => {
+  if (!hasCryptoAuthPermission(request, 'write')) {
+    set.status = 403
+    return { error: 'Write permission required' }
+  }
+
+  return { updated: params.id }
+})
+```
+
+---
+
+## 🎯 Padrões de Uso
+
+### Padrão 1: Grupo de Rotas Protegidas
+
+```typescript
+export const apiRoutes = new Elysia()
+  // Rotas públicas
+  .get('/health', () => ({ status: 'ok' }))
+  .get('/posts', () => ({ posts: [] }))
+
+  // Grupo protegido
+  .group('/users', (app) => app
+    .use(cryptoAuthRequired())
+    .get('/', () => ({ users: [] }))
+    .post('/', ({ body }) => ({ created: body }))
+    .delete('/:id', ({ params }) => ({ deleted: params.id }))
+  )
+
+  // Grupo admin
+  .group('/admin', (app) => app
+    .use(cryptoAuthAdmin())
+    .get('/stats', () => ({ stats: {} }))
+  )
+```
+
+---
+
+### Padrão 2: Middleware Cascata
+
+```typescript
+export const routes = new Elysia()
+  // Aplica a todas as rotas
+  .use(cryptoAuthRequired())
+
+  .get('/profile', () => ({ profile: {} }))
+
+  // Sub-grupo com restrição adicional
+  .group('/admin', (app) => app
+    .use(cryptoAuthAdmin())  // Admin adicional ao required
+    .get('/users', () => ({ users: [] }))
+  )
+```
+
+---
+
+### Padrão 3: Verificação Manual Combinada
+
+```typescript
+export const routes = new Elysia()
+  .use(cryptoAuthRequired())
+
+  .delete('/posts/:id', ({ request, params, set }) => {
+    const user = getCryptoAuthUser(request)!
+
+    // Buscar post do DB
+    const post = { id: params.id, authorKey: 'abc...' }
+
+    // Apenas autor ou admin pode deletar
+    const canDelete = user.isAdmin ||
+                      user.publicKey === post.authorKey
+
+    if (!canDelete) {
+      set.status = 403
+      return {
+        error: 'Apenas o autor ou admin podem deletar'
+      }
+    }
+
+    return { deleted: params.id }
+  })
+```
+
+---
+
+### Padrão 4: Rotas Condicionais
+
+```typescript
+export const routes = new Elysia()
+  .use(cryptoAuthOptional())
+
+  .get('/posts/:id/download', ({ request, params, set }) => {
+    const user = getCryptoAuthUser(request)
+
+    // Usuários autenticados: download ilimitado
+    // Não autenticados: limite de 3 por dia
+    if (!user) {
+      const dailyLimit = checkRateLimit(request.headers.get('x-forwarded-for'))
+      if (dailyLimit > 3) {
+        set.status = 429
+        return { error: 'Rate limit exceeded. Authenticate for unlimited access.' }
+      }
+    }
+
+    return { download: `post-${params.id}.pdf` }
+  })
+```
+
+---
+
+## 🔍 Debugging
+
+### Log de Autenticação
+
+```typescript
+import { cryptoAuthRequired } from '@/plugins/crypto-auth/server'
+
+export const routes = new Elysia()
+  .use(cryptoAuthRequired({
+    logger: yourLogger  // ✅ Passar logger para debug
+  }))
+
+  .get('/users', ({ request }) => {
+    const user = (request as any).user
+    console.log('User:', user)
+    return { users: [] }
+  })
+```
+
+---
+
+### Rota de Debug
+
+```typescript
+export const debugRoutes = new Elysia()
+  .use(cryptoAuthOptional())
+
+  .get('/debug/auth', ({ request }) => {
+    const user = getCryptoAuthUser(request)
+
+    return {
+      authenticated: !!user,
+      user: user || null,
+      headers: {
+        publicKey: request.headers.get('x-public-key'),
+        timestamp: request.headers.get('x-timestamp'),
+        nonce: request.headers.get('x-nonce'),
+        signature: request.headers.get('x-signature')?.substring(0, 16) + '...'
+      }
+    }
+  })
+```
+
+---
+
+## ⚠️ Importante
+
+1. **Ordem importa**: Aplique middlewares antes de definir rotas
+   ```typescript
+   .use(cryptoAuthRequired())  // ✅ Primeiro
+   .get('/users', ...)         // ✅ Depois
+   ```
+
+2. **Grupos herdam middlewares**:
+   ```typescript
+   .use(cryptoAuthRequired())
+   .group('/api', ...)  // ✅ Herda cryptoAuthRequired
+   ```
+
+3. **User object sempre disponível**: Em rotas com `cryptoAuthRequired`, `cryptoAuthAdmin` ou `cryptoAuthPermissions`
+
+4. **Null check necessário**: Em rotas com `cryptoAuthOptional`:
+   ```typescript
+   const user = getCryptoAuthUser(request)
+   if (user) {  // ✅ Verificar antes de usar
+     ...
+   }
+   ```
+
+---
+
+## 📦 TypeScript Types
+
+```typescript
+interface CryptoAuthUser {
+  publicKey: string      // Chave pública (ID único)
+  isAdmin: boolean       // Se é administrador
+  permissions: string[]  // ["read"] ou ["admin", "read", "write", "delete"]
+}
+```
+
+---
+
+## 🆚 Comparação com Config
+
+### ❌ Antes (Config Global)
+```typescript
+// config/app.config.ts
+plugins: {
+  config: {
+    'crypto-auth': {
+      protectedRoutes: ["/api/users/*"]
+    }
+  }
+}
+
+// routes/users.routes.ts
+.get('/users', ({ request }) => {
+  // Protegido automaticamente
+})
+```
+
+### ✅ Agora (Middlewares)
+```typescript
+// routes/users.routes.ts
+import { cryptoAuthRequired } from '@/plugins/crypto-auth/server'
+
+export const routes = new Elysia()
+  .use(cryptoAuthRequired())  // ✅ Explícito
+  .get('/users', ({ request }) => {
+    // Protegido
+  })
+```
+
+**Vantagens**:
+- ✅ Explícito e visível
+- ✅ Type-safe
+- ✅ Mais flexível
+- ✅ Melhor autocomplete
+- ✅ Não depende de config global
+
+---
+
+## 📚 Ver Mais
+
+- **Exemplo completo**: `app/server/routes/example-with-crypto-auth.routes.ts`
+- **Documentação AI**: `plugins/crypto-auth/ai-context.md`
+- **Demo rotas**: `app/server/routes/crypto-auth-demo.routes.ts`
+
+---
+
+**Última atualização**: Janeiro 2025
diff --git a/CRYPTO-AUTH-USAGE.md b/CRYPTO-AUTH-USAGE.md
new file mode 100644
index 00000000..994e6177
--- /dev/null
+++ b/CRYPTO-AUTH-USAGE.md
@@ -0,0 +1,491 @@
+# 🔐 Como Usar Crypto Auth no Servidor
+
+## 📋 Índice
+1. [Middlewares Disponíveis](#middlewares-disponíveis)
+2. [Uso Básico](#uso-básico)
+3. [Acessar Dados do Usuário](#acessar-dados-do-usuário)
+4. [Verificar Permissões](#verificar-permissões)
+5. [Exemplos Completos](#exemplos-completos)
+6. [Helper Functions](#helper-functions)
+
+---
+
+## 🚀 Middlewares Disponíveis
+
+### 1️⃣ `cryptoAuthRequired()` - Requer Autenticação
+
+Valida assinatura e **bloqueia** acesso se não autenticado.
+
+```typescript
+import { cryptoAuthRequired, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+export const protectedRoutes = new Elysia()
+  .use(cryptoAuthRequired())  // ✅ Todas as rotas protegidas
+
+  .get('/profile', ({ request }) => {
+    const user = getCryptoAuthUser(request)!
+    return {
+      publicKey: user.publicKey,
+      isAdmin: user.isAdmin,
+      permissions: user.permissions
+    }
+  })
+```
+
+**Retorno se não autenticado**: `401 Unauthorized`
+
+---
+
+### 2️⃣ `cryptoAuthAdmin()` - Requer Admin
+
+Valida autenticação E verifica se usuário é admin.
+
+```typescript
+import { cryptoAuthAdmin } from '@/plugins/crypto-auth/server'
+
+export const adminRoutes = new Elysia()
+  .use(cryptoAuthAdmin())  // ✅ Apenas admins
+
+  .get('/admin/stats', () => ({
+    totalUsers: 100,
+    systemHealth: 'optimal'
+  }))
+
+  .delete('/admin/users/:id', ({ params }) => ({
+    deleted: params.id
+  }))
+```
+
+**Retorno se não for admin**: `403 Forbidden`
+
+---
+
+### 3️⃣ `cryptoAuthPermissions(permissions)` - Requer Permissões
+
+Valida autenticação E verifica permissões específicas.
+
+```typescript
+import { cryptoAuthPermissions } from '@/plugins/crypto-auth/server'
+
+export const writeRoutes = new Elysia()
+  .use(cryptoAuthPermissions(['write']))  // ✅ Requer permissão 'write'
+
+  .put('/posts/:id', ({ params, body }) => ({
+    updated: params.id,
+    data: body
+  }))
+```
+
+**Múltiplas permissões**:
+```typescript
+.use(cryptoAuthPermissions(['write', 'publish']))
+```
+
+---
+
+### 4️⃣ `cryptoAuthOptional()` - Autenticação Opcional
+
+Adiciona `user` se autenticado, mas **NÃO bloqueia** se não autenticado.
+
+```typescript
+import { cryptoAuthOptional, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+export const mixedRoutes = new Elysia()
+  .use(cryptoAuthOptional())  // ✅ Opcional
+
+  .get('/posts/:id', ({ request, params }) => {
+    const user = getCryptoAuthUser(request)
+
+    return {
+      post: {
+        id: params.id,
+        title: 'Post Title',
+        // Conteúdo completo apenas se autenticado
+        content: user ? 'Full content...' : 'Preview...'
+      },
+      viewer: user ? {
+        publicKey: user.publicKey,
+        canEdit: user.isAdmin
+      } : null
+    }
+  })
+```
+
+---
+
+## 🛠️ Uso Básico
+
+### Aplicar Middleware a Todas as Rotas
+
+```typescript
+import { Elysia } from 'elysia'
+import { cryptoAuthRequired } from '@/plugins/crypto-auth/server'
+
+export const myRoutes = new Elysia()
+  // ✅ Aplica autenticação a todas as rotas
+  .use(cryptoAuthRequired())
+
+  .get('/users', ({ request }) => {
+    const user = (request as any).user
+    return { users: [], requestedBy: user.publicKey }
+  })
+
+  .post('/users', ({ request, body }) => {
+    const user = (request as any).user
+    return { created: body, by: user.publicKey }
+  })
+```
+
+---
+
+### Aplicar a Grupos Específicos
+
+```typescript
+export const apiRoutes = new Elysia()
+  // Rotas públicas
+  .get('/health', () => ({ status: 'ok' }))
+  .get('/posts', () => ({ posts: [] }))
+
+  // Grupo protegido
+  .group('/users', (app) => app
+    .use(cryptoAuthRequired())
+    .get('/', () => ({ users: [] }))
+    .post('/', ({ body }) => ({ created: body }))
+  )
+
+  // Grupo admin
+  .group('/admin', (app) => app
+    .use(cryptoAuthAdmin())
+    .get('/stats', () => ({ stats: {} }))
+  )
+```
+
+---
+
+## 📦 Acessar Dados do Usuário
+
+### Interface `CryptoAuthUser`
+
+```typescript
+interface CryptoAuthUser {
+  publicKey: string      // Chave pública (ID único)
+  isAdmin: boolean       // Se é admin
+  permissions: string[]  // [\"read\"] ou [\"admin\", \"read\", \"write\", \"delete\"]
+}
+```
+
+### Acessar no Handler
+
+```typescript
+import { getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+.get('/me', ({ request }) => {
+  const user = getCryptoAuthUser(request)!  // ! porque já passou pelo middleware
+
+  return {
+    id: user.publicKey,
+    isAdmin: user.isAdmin,
+    permissions: user.permissions
+  }
+})
+```
+
+---
+
+## 🔒 Verificar Permissões
+
+### Verificar se é Admin
+
+```typescript
+import { isCryptoAuthAdmin } from '@/plugins/crypto-auth/server'
+
+.delete('/posts/:id', ({ request, params, set }) => {
+  if (!isCryptoAuthAdmin(request)) {
+    set.status = 403
+    return { error: 'Admin only' }
+  }
+
+  return { deleted: params.id }
+})
+```
+
+---
+
+### Verificar Permissão Específica
+
+```typescript
+import { hasCryptoAuthPermission } from '@/plugins/crypto-auth/server'
+
+.put('/posts/:id', ({ request, params, set }) => {
+  if (!hasCryptoAuthPermission(request, 'write')) {
+    set.status = 403
+    return { error: 'Write permission required' }
+  }
+
+  return { updated: params.id }
+})
+```
+
+---
+
+## 🎯 Exemplos Completos
+
+### Exemplo 1: CRUD de Posts
+
+```typescript
+import { Elysia, t } from 'elysia'
+import {
+  cryptoAuthRequired,
+  cryptoAuthAdmin,
+  cryptoAuthOptional,
+  getCryptoAuthUser
+} from '@/plugins/crypto-auth/server'
+
+export const postsRoutes = new Elysia()
+
+  // ✅ PÚBLICO - Listar posts
+  .get('/posts', () => ({
+    posts: [
+      { id: 1, title: 'Post 1', author: 'João' },
+      { id: 2, title: 'Post 2', author: 'Maria' }
+    ]
+  }))
+
+  // 🔒 PROTEGIDO - Criar post
+  .post('/posts', ({ request, body }) => {
+    const user = getCryptoAuthUser(request)!
+    const { title, content } = body as { title: string; content: string }
+
+    return {
+      success: true,
+      post: {
+        title,
+        content,
+        author: user.publicKey,
+        createdAt: new Date()
+      }
+    }
+  }, {
+    body: t.Object({
+      title: t.String(),
+      content: t.String()
+    })
+  })
+  .use(cryptoAuthRequired())  // Aplica apenas ao .post acima
+
+  // 🔒 ADMIN - Deletar post
+  .delete('/posts/:id', ({ params }) => ({
+    success: true,
+    message: `Post ${params.id} deletado`
+  }))
+  .use(cryptoAuthAdmin())  // Aplica apenas ao .delete acima
+```
+
+---
+
+### Exemplo 2: Rotas Condicionais
+
+```typescript
+export const mixedRoutes = new Elysia()
+  .use(cryptoAuthOptional())
+
+  .get('/posts/:id', ({ request, params }) => {
+    const user = getCryptoAuthUser(request)
+
+    // Post básico (público)
+    const post = {
+      id: params.id,
+      title: 'Título do Post',
+      excerpt: 'Prévia do conteúdo...'
+    }
+
+    // Se autenticado, retorna conteúdo completo
+    if (user) {
+      return {
+        ...post,
+        fullContent: 'Conteúdo completo do post...',
+        comments: [/* comentários */],
+        viewer: {
+          publicKey: user.publicKey,
+          canEdit: user.isAdmin
+        }
+      }
+    }
+
+    // Se não autenticado, apenas prévia
+    return post
+  })
+```
+
+---
+
+### Exemplo 3: Middleware Cascata
+
+```typescript
+export const routes = new Elysia()
+  // Aplica a todas as rotas
+  .use(cryptoAuthRequired())
+
+  .get('/profile', () => ({ profile: {} }))
+
+  // Sub-grupo com restrição adicional
+  .group('/admin', (app) => app
+    .use(cryptoAuthAdmin())  // Admin adicional ao required
+    .get('/users', () => ({ users: [] }))
+  )
+```
+
+---
+
+## 🛠️ Helper Functions
+
+### `getCryptoAuthUser(request)` - Obter Usuário
+
+```typescript
+import { getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+.get('/me', ({ request }) => {
+  const user = getCryptoAuthUser(request)
+
+  if (!user) {
+    return { error: 'Not authenticated' }
+  }
+
+  return { user }
+})
+```
+
+---
+
+### `isCryptoAuthAuthenticated(request)` - Verificar se Autenticado
+
+```typescript
+import { isCryptoAuthAuthenticated } from '@/plugins/crypto-auth/server'
+
+.get('/posts/:id', ({ request, params }) => {
+  const isAuth = isCryptoAuthAuthenticated(request)
+
+  return {
+    post: { id: params.id },
+    canComment: isAuth
+  }
+})
+```
+
+---
+
+### `isCryptoAuthAdmin(request)` - Verificar se é Admin
+
+```typescript
+import { isCryptoAuthAdmin } from '@/plugins/crypto-auth/server'
+
+.get('/posts/:id', ({ request, params, set }) => {
+  if (!isCryptoAuthAdmin(request)) {
+    set.status = 403
+    return { error: 'Admin only' }
+  }
+
+  return { post: params.id }
+})
+```
+
+---
+
+### `hasCryptoAuthPermission(request, permission)` - Verificar Permissão
+
+```typescript
+import { hasCryptoAuthPermission } from '@/plugins/crypto-auth/server'
+
+.put('/posts/:id', ({ request, params, set }) => {
+  if (!hasCryptoAuthPermission(request, 'write')) {
+    set.status = 403
+    return { error: 'Write permission required' }
+  }
+
+  return { updated: params.id }
+})
+```
+
+---
+
+## 🔍 Debugging
+
+### Log de Autenticação
+
+```typescript
+import { cryptoAuthRequired } from '@/plugins/crypto-auth/server'
+
+export const routes = new Elysia()
+  .use(cryptoAuthRequired({
+    logger: yourLogger  // ✅ Passar logger para debug
+  }))
+
+  .get('/users', ({ request }) => {
+    const user = (request as any).user
+    console.log('User:', user)
+    return { users: [] }
+  })
+```
+
+---
+
+### Rota de Debug
+
+```typescript
+export const debugRoutes = new Elysia()
+  .use(cryptoAuthOptional())
+
+  .get('/debug/auth', ({ request }) => {
+    const user = getCryptoAuthUser(request)
+
+    return {
+      authenticated: !!user,
+      user: user || null,
+      headers: {
+        publicKey: request.headers.get('x-public-key'),
+        timestamp: request.headers.get('x-timestamp'),
+        nonce: request.headers.get('x-nonce'),
+        signature: request.headers.get('x-signature')?.substring(0, 16) + '...'
+      }
+    }
+  })
+```
+
+---
+
+## ⚠️ Importante
+
+1. **Ordem importa**: Aplique middlewares antes de definir rotas
+   ```typescript
+   .use(cryptoAuthRequired())  // ✅ Primeiro
+   .get('/users', ...)         // ✅ Depois
+   ```
+
+2. **Grupos herdam middlewares**:
+   ```typescript
+   .use(cryptoAuthRequired())
+   .group('/api', ...)  // ✅ Herda cryptoAuthRequired
+   ```
+
+3. **User object sempre disponível**: Em rotas com `cryptoAuthRequired`, `cryptoAuthAdmin` ou `cryptoAuthPermissions`
+
+4. **Null check necessário**: Em rotas com `cryptoAuthOptional`:
+   ```typescript
+   const user = getCryptoAuthUser(request)
+   if (user) {  // ✅ Verificar antes de usar
+     ...
+   }
+   ```
+
+---
+
+## 📚 Ver Mais
+
+- **Documentação completa de middlewares**: `CRYPTO-AUTH-MIDDLEWARES.md`
+- **Exemplo completo**: `app/server/routes/example-with-crypto-auth.routes.ts`
+- **Documentação AI**: `plugins/crypto-auth/ai-context.md`
+- **Demo rotas**: `app/server/routes/crypto-auth-demo.routes.ts`
+
+---
+
+**Última atualização**: Janeiro 2025
diff --git a/EXEMPLO-ROTA-PROTEGIDA.md b/EXEMPLO-ROTA-PROTEGIDA.md
new file mode 100644
index 00000000..46434f6d
--- /dev/null
+++ b/EXEMPLO-ROTA-PROTEGIDA.md
@@ -0,0 +1,347 @@
+# 🔐 Como Criar Rotas com Crypto-Auth
+
+Guia prático para desenvolvedores criarem rotas usando o sistema de autenticação.
+
+## 📋 Passo a Passo
+
+### 1️⃣ Criar Arquivo de Rotas
+
+Crie um arquivo em `app/server/routes/`:
+
+```typescript
+// app/server/routes/posts.routes.ts
+import { Elysia, t } from 'elysia'
+import {
+  cryptoAuthRequired,
+  cryptoAuthAdmin,
+  cryptoAuthOptional,
+  getCryptoAuthUser
+} from '@/plugins/crypto-auth/server'
+
+export const postsRoutes = new Elysia({ prefix: '/posts' })
+
+  // ========================================
+  // 🌐 ROTA PÚBLICA - Qualquer um pode acessar
+  // ========================================
+  .get('/', () => {
+    return {
+      success: true,
+      posts: [
+        { id: 1, title: 'Post público' },
+        { id: 2, title: 'Outro post' }
+      ]
+    }
+  })
+
+  // ========================================
+  // 🔒 ROTA PROTEGIDA - Requer autenticação
+  // ========================================
+  .guard({}, (app) =>
+    app.use(cryptoAuthRequired())
+
+      // GET /api/posts/my-posts - Lista posts do usuário autenticado
+      .get('/my-posts', ({ request }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: `Posts de ${user.publicKey.substring(0, 8)}...`,
+          posts: [
+            { id: 1, title: 'Meu post privado', author: user.publicKey }
+          ]
+        }
+      })
+
+      // POST /api/posts - Criar novo post (autenticação obrigatória)
+      .post('/', ({ request, body }) => {
+        const user = getCryptoAuthUser(request)!
+        const { title, content } = body as { title: string; content: string }
+
+        return {
+          success: true,
+          message: 'Post criado com sucesso',
+          post: {
+            id: Date.now(),
+            title,
+            content,
+            author: user.publicKey,
+            createdAt: new Date().toISOString()
+          }
+        }
+      }, {
+        body: t.Object({
+          title: t.String(),
+          content: t.String()
+        })
+      })
+  )
+
+  // ========================================
+  // 👑 ROTA ADMIN - Apenas administradores
+  // ========================================
+  .guard({}, (app) =>
+    app.use(cryptoAuthAdmin())
+
+      // DELETE /api/posts/:id - Deletar qualquer post (só admin)
+      .delete('/:id', ({ request, params }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: `Post ${params.id} deletado por admin`,
+          deletedBy: user.publicKey.substring(0, 8) + '...'
+        }
+      })
+
+      // GET /api/posts/moderation - Painel de moderação
+      .get('/moderation', ({ request }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: 'Painel de moderação',
+          admin: user.publicKey.substring(0, 8) + '...',
+          pendingPosts: [],
+          reportedPosts: []
+        }
+      })
+  )
+
+  // ========================================
+  // 🌓 ROTA COM AUTH OPCIONAL - Funciona com/sem auth
+  // ========================================
+  .guard({}, (app) =>
+    app.use(cryptoAuthOptional())
+
+      // GET /api/posts/:id - Detalhes do post (conteúdo extra se autenticado)
+      .get('/:id', ({ request, params }) => {
+        const user = getCryptoAuthUser(request)
+        const isAuthenticated = !!user
+
+        return {
+          success: true,
+          post: {
+            id: params.id,
+            title: 'Post de exemplo',
+            content: 'Conteúdo público',
+            // ✅ Conteúdo extra apenas para autenticados
+            extraContent: isAuthenticated
+              ? 'Conteúdo premium para usuários autenticados'
+              : null,
+            canEdit: isAuthenticated,
+            viewer: user ? user.publicKey.substring(0, 8) + '...' : 'anonymous'
+          }
+        }
+      })
+  )
+```
+
+### 2️⃣ Registrar no Router Principal
+
+```typescript
+// app/server/routes/index.ts
+import { Elysia } from 'elysia'
+import { postsRoutes } from './posts.routes'  // ✅ Importar suas rotas
+
+export const apiRoutes = new Elysia({ prefix: '/api' })
+  .use(userRoutes)
+  .use(postsRoutes)  // ✅ Adicionar aqui
+  // ... outras rotas
+```
+
+### 3️⃣ Como o Cliente Faz Login
+
+O cliente precisa enviar headers de autenticação criptográfica:
+
+```typescript
+// Frontend/Cliente
+import { generateKeyPair, sign } from './crypto-utils'
+
+// 1. Gerar par de chaves (feito uma vez)
+const { publicKey, privateKey } = generateKeyPair()
+
+// 2. Fazer requisição autenticada
+const timestamp = Date.now()
+const nonce = crypto.randomUUID()
+const message = `GET:/api/posts/my-posts:${timestamp}:${nonce}`
+const signature = sign(message, privateKey)
+
+fetch('http://localhost:3000/api/posts/my-posts', {
+  headers: {
+    'X-Public-Key': publicKey,
+    'X-Timestamp': timestamp.toString(),
+    'X-Nonce': nonce,
+    'X-Signature': signature
+  }
+})
+```
+
+## 🧪 Testando as Rotas
+
+### Rota Pública (sem auth)
+```bash
+curl http://localhost:3000/api/posts
+# ✅ 200 OK
+```
+
+### Rota Protegida (sem auth)
+```bash
+curl http://localhost:3000/api/posts/my-posts
+# ❌ 401 {"error": {"message": "Authentication required"}}
+```
+
+### Rota Protegida (com auth)
+```bash
+curl http://localhost:3000/api/posts/my-posts \
+  -H "X-Public-Key: abc123..." \
+  -H "X-Timestamp: 1234567890" \
+  -H "X-Nonce: uuid-here" \
+  -H "X-Signature: signature-here"
+# ✅ 200 OK {"posts": [...]}
+```
+
+### Rota Admin (sem admin)
+```bash
+curl http://localhost:3000/api/posts/moderation \
+  -H "X-Public-Key: user-key..." \
+  # ... outros headers
+# ❌ 403 {"error": {"message": "Admin privileges required"}}
+```
+
+### Rota Opcional (ambos funcionam)
+```bash
+# Sem auth
+curl http://localhost:3000/api/posts/123
+# ✅ 200 OK {"post": {"extraContent": null}}
+
+# Com auth
+curl http://localhost:3000/api/posts/123 -H "X-Public-Key: ..."
+# ✅ 200 OK {"post": {"extraContent": "Conteúdo premium..."}}
+```
+
+## 📦 Middlewares Disponíveis
+
+### `cryptoAuthRequired()`
+Bloqueia acesso se não autenticado.
+```typescript
+.use(cryptoAuthRequired())
+.get('/protected', ({ request }) => {
+  const user = getCryptoAuthUser(request)! // ✅ Sempre existe
+})
+```
+
+### `cryptoAuthAdmin()`
+Bloqueia se não for admin.
+```typescript
+.use(cryptoAuthAdmin())
+.delete('/users/:id', ({ request }) => {
+  const user = getCryptoAuthUser(request)! // ✅ Sempre admin
+})
+```
+
+### `cryptoAuthOptional()`
+Adiciona user se autenticado, mas não bloqueia.
+```typescript
+.use(cryptoAuthOptional())
+.get('/feed', ({ request }) => {
+  const user = getCryptoAuthUser(request) // ⚠️ Pode ser null
+  if (user) {
+    return { message: 'Feed personalizado' }
+  }
+  return { message: 'Feed público' }
+})
+```
+
+### `cryptoAuthPermissions(['write', 'delete'])`
+Bloqueia se não tiver permissões específicas.
+```typescript
+.use(cryptoAuthPermissions(['write', 'delete']))
+.put('/posts/:id', ({ request }) => {
+  const user = getCryptoAuthUser(request)! // ✅ Tem as permissões
+})
+```
+
+## 🔑 Helpers Úteis
+
+```typescript
+import {
+  getCryptoAuthUser,
+  isCryptoAuthAuthenticated,
+  isCryptoAuthAdmin,
+  hasCryptoAuthPermission
+} from '@/plugins/crypto-auth/server'
+
+// Dentro de uma rota
+({ request }) => {
+  // Pegar usuário autenticado (null se não autenticado)
+  const user = getCryptoAuthUser(request)
+
+  // Verificar se está autenticado
+  if (!isCryptoAuthAuthenticated(request)) {
+    return { error: 'Login required' }
+  }
+
+  // Verificar se é admin
+  if (isCryptoAuthAdmin(request)) {
+    return { message: 'Admin panel' }
+  }
+
+  // Verificar permissão específica
+  if (hasCryptoAuthPermission(request, 'delete')) {
+    return { message: 'Can delete' }
+  }
+}
+```
+
+## ⚠️ Boas Práticas
+
+### ✅ Fazer
+- Usar `.guard({})` para isolar middlewares
+- Verificar `null` em rotas com `cryptoAuthOptional()`
+- Usar `!` apenas após middlewares obrigatórios
+- Separar rotas por nível de permissão
+
+### ❌ Não Fazer
+- Usar `.use()` fora de `.guard()` (afeta TODAS as rotas seguintes)
+- Esquecer `.as('plugin')` ao criar middlewares customizados
+- Assumir que `user` existe sem middleware de proteção
+
+## 🎯 Padrão Recomendado
+
+```typescript
+export const myRoutes = new Elysia({ prefix: '/my-feature' })
+
+  // Públicas primeiro
+  .get('/public', () => ({ ... }))
+
+  // Auth opcional (separado)
+  .guard({}, (app) =>
+    app.use(cryptoAuthOptional())
+      .get('/optional', ({ request }) => {
+        const user = getCryptoAuthUser(request)
+        // ...
+      })
+  )
+
+  // Protegidas (separado)
+  .guard({}, (app) =>
+    app.use(cryptoAuthRequired())
+      .get('/protected', ({ request }) => {
+        const user = getCryptoAuthUser(request)!
+        // ...
+      })
+  )
+
+  // Admin (separado)
+  .guard({}, (app) =>
+    app.use(cryptoAuthAdmin())
+      .delete('/admin-only', ({ request }) => {
+        const user = getCryptoAuthUser(request)!
+        // ...
+      })
+  )
+```
+
+---
+
+**Pronto!** Agora você sabe criar rotas com autenticação crypto-auth no FluxStack. 🚀
diff --git a/QUICK-START-CRYPTO-AUTH.md b/QUICK-START-CRYPTO-AUTH.md
new file mode 100644
index 00000000..2f012811
--- /dev/null
+++ b/QUICK-START-CRYPTO-AUTH.md
@@ -0,0 +1,221 @@
+# ⚡ Quick Start: Crypto-Auth em 5 Minutos
+
+## 🎯 Como Criar uma Rota Protegida
+
+### 🚀 Opção 1: CLI (Recomendado)
+
+Use o comando `crypto-auth:make:route` para gerar rotas automaticamente:
+
+```bash
+# Rota com autenticação obrigatória (padrão)
+bun flux crypto-auth:make:route users
+
+# Rota apenas para admins
+bun flux crypto-auth:make:route admin-panel --auth admin
+
+# Rota com autenticação opcional
+bun flux crypto-auth:make:route blog --auth optional
+
+# Rota pública (sem auth)
+bun flux crypto-auth:make:route public-api --auth public
+```
+
+O comando cria automaticamente:
+- ✅ Arquivo de rotas em `app/server/routes/[nome].routes.ts`
+- ✅ Middlewares de autenticação configurados
+- ✅ Templates de CRUD completos
+- ✅ Exemplos de uso de `getCryptoAuthUser()`
+
+**Tipos de `--auth` disponíveis:**
+- `required` - Autenticação obrigatória (padrão)
+- `admin` - Apenas administradores
+- `optional` - Auth opcional (rota pública com conteúdo extra para autenticados)
+- `public` - Completamente pública (sem middleware)
+
+---
+
+### ⚙️ Opção 2: Manual
+
+#### 1️⃣ Criar Arquivo de Rotas
+
+```typescript
+// app/server/routes/minhas-rotas.routes.ts
+import { Elysia } from 'elysia'
+import { cryptoAuthRequired, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+export const minhasRotas = new Elysia({ prefix: '/minhas-rotas' })
+
+  // Rota pública
+  .get('/publica', () => ({ message: 'Todos podem ver' }))
+
+  // Rota protegida
+  .guard({}, (app) =>
+    app.use(cryptoAuthRequired())
+      .get('/protegida', ({ request }) => {
+        const user = getCryptoAuthUser(request)!
+        return {
+          message: 'Área restrita',
+          user: user.publicKey.substring(0, 8) + '...'
+        }
+      })
+  )
+```
+
+#### 2️⃣ Registrar no Router
+
+```typescript
+// app/server/routes/index.ts
+import { minhasRotas } from './minhas-rotas.routes'
+
+export const apiRoutes = new Elysia({ prefix: '/api' })
+  .use(minhasRotas)  // ✅ Adicionar aqui
+```
+
+#### 3️⃣ Testar
+
+```bash
+# Pública (funciona)
+curl http://localhost:3000/api/minhas-rotas/publica
+# ✅ {"message": "Todos podem ver"}
+
+# Protegida (sem auth)
+curl http://localhost:3000/api/minhas-rotas/protegida
+# ❌ {"error": {"message": "Authentication required", "code": "CRYPTO_AUTH_REQUIRED", "statusCode": 401}}
+```
+
+## 🔐 Tipos de Middleware
+
+### `cryptoAuthRequired()` - Autenticação Obrigatória
+```typescript
+.guard({}, (app) =>
+  app.use(cryptoAuthRequired())
+    .get('/protegida', ({ request }) => {
+      const user = getCryptoAuthUser(request)!  // ✅ Sempre existe
+      return { user }
+    })
+)
+```
+
+### `cryptoAuthAdmin()` - Apenas Administradores
+```typescript
+.guard({}, (app) =>
+  app.use(cryptoAuthAdmin())
+    .delete('/deletar/:id', ({ request, params }) => {
+      const user = getCryptoAuthUser(request)!  // ✅ Sempre admin
+      return { message: `${params.id} deletado` }
+    })
+)
+```
+
+### `cryptoAuthOptional()` - Autenticação Opcional
+```typescript
+.guard({}, (app) =>
+  app.use(cryptoAuthOptional())
+    .get('/feed', ({ request }) => {
+      const user = getCryptoAuthUser(request)  // ⚠️ Pode ser null
+
+      if (user) {
+        return { message: 'Feed personalizado', user }
+      }
+      return { message: 'Feed público' }
+    })
+)
+```
+
+### `cryptoAuthPermissions([...])` - Permissões Específicas
+```typescript
+.guard({}, (app) =>
+  app.use(cryptoAuthPermissions(['write', 'delete']))
+    .put('/editar/:id', ({ request }) => {
+      const user = getCryptoAuthUser(request)!  // ✅ Tem as permissões
+      return { message: 'Editado' }
+    })
+)
+```
+
+## 📊 Exemplo Real Funcionando
+
+Veja o arquivo criado: **`app/server/routes/exemplo-posts.routes.ts`**
+
+Rotas disponíveis:
+- ✅ `GET /api/exemplo-posts` - Pública
+- ✅ `GET /api/exemplo-posts/:id` - Auth opcional
+- ✅ `GET /api/exemplo-posts/meus-posts` - Protegida
+- ✅ `POST /api/exemplo-posts/criar` - Protegida
+- ✅ `GET /api/exemplo-posts/admin/todos` - Admin
+- ✅ `DELETE /api/exemplo-posts/admin/:id` - Admin
+
+## 🧪 Testando Agora
+
+```bash
+# Pública
+curl http://localhost:3000/api/exemplo-posts
+# ✅ {"success":true,"posts":[...]}
+
+# Auth opcional (sem auth)
+curl http://localhost:3000/api/exemplo-posts/1
+# ✅ {"success":true,"post":{"premiumContent":null,"viewer":"Visitante anônimo"}}
+
+# Protegida (sem auth)
+curl http://localhost:3000/api/exemplo-posts/meus-posts
+# ❌ {"error":{"message":"Authentication required"}}
+
+# Admin (sem auth)
+curl http://localhost:3000/api/exemplo-posts/admin/todos
+# ❌ {"error":{"message":"Authentication required"}}
+```
+
+## 🔑 Helpers Úteis
+
+```typescript
+import {
+  getCryptoAuthUser,
+  isCryptoAuthAuthenticated,
+  isCryptoAuthAdmin,
+  hasCryptoAuthPermission
+} from '@/plugins/crypto-auth/server'
+
+({ request }) => {
+  const user = getCryptoAuthUser(request)  // User | null
+  const isAuth = isCryptoAuthAuthenticated(request)  // boolean
+  const isAdmin = isCryptoAuthAdmin(request)  // boolean
+  const canDelete = hasCryptoAuthPermission(request, 'delete')  // boolean
+}
+```
+
+## ⚠️ Importante
+
+### ✅ Fazer
+```typescript
+// Isolar middlewares com .guard({})
+.guard({}, (app) =>
+  app.use(cryptoAuthRequired())
+    .get('/protected', () => {})
+)
+
+// Verificar null em auth opcional
+.guard({}, (app) =>
+  app.use(cryptoAuthOptional())
+    .get('/feed', ({ request }) => {
+      const user = getCryptoAuthUser(request)
+      if (user) { /* autenticado */ }
+    })
+)
+```
+
+### ❌ Não Fazer
+```typescript
+// ❌ Usar .use() sem .guard() (afeta TODAS as rotas seguintes)
+export const myRoutes = new Elysia()
+  .use(cryptoAuthRequired())  // ❌ ERRADO
+  .get('/publica', () => {})  // Esta rota ficará protegida!
+```
+
+## 📚 Documentação Completa
+
+- **Guia Detalhado**: `EXEMPLO-ROTA-PROTEGIDA.md`
+- **Referência de Middlewares**: `CRYPTO-AUTH-MIDDLEWARE-GUIDE.md`
+
+---
+
+**Pronto!** Agora você pode criar rotas protegidas em minutos. 🚀
diff --git a/app/client/src/App.tsx b/app/client/src/App.tsx
index 0b5b72a1..fd843fc3 100644
--- a/app/client/src/App.tsx
+++ b/app/client/src/App.tsx
@@ -15,6 +15,7 @@ import { OverviewPage } from './pages/Overview'
 import { DemoPage } from './pages/Demo'
 import { HybridLivePage } from './pages/HybridLive'
 import { ApiDocsPage } from './pages/ApiDocs'
+import { CryptoAuthPage } from './pages/CryptoAuthPage'
 import { MainLayout } from './components/MainLayout'
 import { LiveClock } from './components/LiveClock'
 
@@ -166,6 +167,7 @@ function AppContent() {
                       {[
                         { id: 'overview', label: 'Visão Geral', icon: <FaClipboardList />, path: '/' },
                         { id: 'demo', label: 'Demo', icon: <FaRocket />, path: '/demo' },
+                        { id: 'crypto-auth', label: 'Crypto Auth', icon: <FaShieldAlt />, path: '/crypto-auth' },
                         { id: 'hybrid-live', label: 'Hybrid Live', icon: <FaBolt />, path: '/hybrid-live' },
                         { id: 'live-app', label: 'Live App', icon: <FaFire />, path: '/live-app' },
                         { id: 'api-docs', label: 'API Docs', icon: <FaBook />, path: '/api-docs' },
@@ -208,8 +210,8 @@ function AppContent() {
                     {[
                       { id: 'overview', label: 'Visão', icon: <FaClipboardList />, path: '/' },
                       { id: 'demo', label: 'Demo', icon: <FaRocket />, path: '/demo' },
+                      { id: 'crypto-auth', label: 'Crypto', icon: <FaShieldAlt />, path: '/crypto-auth' },
                       { id: 'hybrid-live', label: 'Hybrid', icon: <FaBolt />, path: '/hybrid-live' },
-                      { id: 'live-app', label: 'Live', icon: <FaFire />, path: '/live-app' },
                       { id: 'api-docs', label: 'Docs', icon: <FaBook />, path: '/api-docs' },
                       { id: 'tests', label: 'Testes', icon: <FaTest />, path: '/tests' }
                     ].map(tab => (
@@ -256,6 +258,7 @@ function AppContent() {
                     />
                   }
                 />
+                <Route path="/crypto-auth" element={<CryptoAuthPage />} />
                 <Route path="/hybrid-live" element={<HybridLivePage />} />
                 <Route path="/api-docs" element={<ApiDocsPage />} />
                 <Route path="/tests" element={
diff --git a/app/client/src/pages/CryptoAuthPage.tsx b/app/client/src/pages/CryptoAuthPage.tsx
new file mode 100644
index 00000000..91b1b79c
--- /dev/null
+++ b/app/client/src/pages/CryptoAuthPage.tsx
@@ -0,0 +1,394 @@
+import { useState, useEffect } from 'react'
+import { FaKey, FaLock, FaUnlock, FaCheckCircle, FaTimesCircle, FaSync, FaShieldAlt, FaCopy, FaFileImport, FaExclamationTriangle } from 'react-icons/fa'
+import { CryptoAuthClient, type KeyPair } from '../../../../plugins/crypto-auth/client'
+
+export function CryptoAuthPage() {
+  const [authClient] = useState(() => new CryptoAuthClient({
+    storage: 'sessionStorage', // Usar sessionStorage ao invés de localStorage
+    autoInit: true // Gerar automaticamente ao inicializar
+  }))
+  const [keys, setKeys] = useState<KeyPair | null>(null)
+  const [loading, setLoading] = useState(false)
+  const [publicDataResult, setPublicDataResult] = useState<any>(null)
+  const [protectedDataResult, setProtectedDataResult] = useState<any>(null)
+  const [copiedKey, setCopiedKey] = useState('')
+  const [showImportModal, setShowImportModal] = useState(false)
+  const [importKey, setImportKey] = useState('')
+  const [importError, setImportError] = useState('')
+
+  useEffect(() => {
+    const existingKeys = authClient.getKeys()
+    if (existingKeys) {
+      setKeys(existingKeys)
+    }
+  }, [authClient])
+
+  const handleCreateKeys = () => {
+    setLoading(true)
+    try {
+      const newKeys = authClient.createNewKeys()
+      setKeys(newKeys)
+    } catch (error) {
+      console.error('Erro ao criar chaves:', error)
+      alert('Erro ao criar chaves: ' + (error as Error).message)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const handleClearKeys = () => {
+    setLoading(true)
+    try {
+      authClient.clearKeys()
+      setKeys(null)
+      setPublicDataResult(null)
+      setProtectedDataResult(null)
+    } catch (error) {
+      console.error('Erro ao limpar chaves:', error)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const handleImportKey = () => {
+    setImportError('')
+    setLoading(true)
+    try {
+      const trimmedKey = importKey.trim()
+      const importedKeys = authClient.importPrivateKey(trimmedKey)
+      setKeys(importedKeys)
+      setShowImportModal(false)
+      setImportKey('')
+    } catch (error) {
+      console.error('Erro ao importar chave:', error)
+      setImportError((error as Error).message)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const openImportModal = () => {
+    setShowImportModal(true)
+    setImportKey('')
+    setImportError('')
+  }
+
+  const handlePublicRequest = async () => {
+    setLoading(true)
+    try {
+      const response = await fetch('/api/crypto-auth/public')
+      const data = await response.json()
+      setPublicDataResult(data)
+    } catch (error) {
+      console.error('Erro na requisição pública:', error)
+      setPublicDataResult({ error: (error as Error).message })
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const handleProtectedRequest = async () => {
+    setLoading(true)
+    try {
+      const response = await authClient.fetch('/api/crypto-auth/protected')
+      const data = await response.json()
+      setProtectedDataResult(data)
+    } catch (error) {
+      console.error('Erro na requisição protegida:', error)
+      setProtectedDataResult({ error: (error as Error).message })
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const copyToClipboard = (text: string, type: string) => {
+    navigator.clipboard.writeText(text)
+    setCopiedKey(type)
+    setTimeout(() => setCopiedKey(''), 2000)
+  }
+
+  return (
+    <div className="space-y-6">
+      {/* Header */}
+      <div className="bg-gradient-to-r from-purple-500 to-indigo-600 rounded-xl p-6 text-white">
+        <div className="flex items-center space-x-3 mb-2">
+          <FaShieldAlt className="text-3xl" />
+          <h1 className="text-3xl font-bold">🔐 Crypto Auth Demo</h1>
+        </div>
+        <p className="text-purple-100">
+          Autenticação criptográfica usando Ed25519 - SEM sessões no servidor
+        </p>
+      </div>
+
+      {/* Keys Status */}
+      <div className="bg-white rounded-xl shadow-sm border border-gray-200 p-6">
+        <h2 className="text-xl font-bold text-gray-800 mb-4 flex items-center">
+          <FaKey className="mr-2 text-purple-600" />
+          Suas Chaves Criptográficas
+        </h2>
+
+        {!keys ? (
+          <div className="text-center py-8">
+            <FaUnlock className="text-6xl text-gray-300 mx-auto mb-4" />
+            <p className="text-gray-600 mb-4">Nenhum par de chaves gerado</p>
+            <div className="flex gap-3 justify-center">
+              <button
+                onClick={handleCreateKeys}
+                disabled={loading}
+                className="bg-purple-600 text-white px-6 py-3 rounded-lg hover:bg-purple-700 disabled:opacity-50 flex items-center"
+              >
+                {loading ? <FaSync className="animate-spin mr-2" /> : <FaKey className="mr-2" />}
+                Gerar Novo Par de Chaves
+              </button>
+              <button
+                onClick={openImportModal}
+                disabled={loading}
+                className="bg-blue-600 text-white px-6 py-3 rounded-lg hover:bg-blue-700 disabled:opacity-50 flex items-center"
+              >
+                <FaFileImport className="mr-2" />
+                Importar Chave Privada
+              </button>
+            </div>
+          </div>
+        ) : (
+          <div className="space-y-4">
+            <div className="flex items-center justify-between p-4 bg-green-50 rounded-lg">
+              <div className="flex items-center">
+                <FaLock className="text-green-600 text-2xl mr-3" />
+                <div>
+                  <p className="font-semibold text-green-800 flex items-center gap-2">
+                    Chaves Ativas
+                    <span className="text-xs bg-blue-100 text-blue-700 px-2 py-0.5 rounded-full">
+                      sessionStorage
+                    </span>
+                  </p>
+                  <p className="text-sm text-green-600">
+                    Criadas em: {keys.createdAt.toLocaleString()}
+                  </p>
+                </div>
+              </div>
+              <div className="flex gap-2">
+                <button
+                  onClick={openImportModal}
+                  disabled={loading}
+                  className="bg-blue-500 text-white px-4 py-2 rounded-lg hover:bg-blue-600 disabled:opacity-50 flex items-center text-sm"
+                >
+                  <FaFileImport className="mr-2" />
+                  Importar
+                </button>
+                <button
+                  onClick={handleClearKeys}
+                  disabled={loading}
+                  className="bg-red-500 text-white px-4 py-2 rounded-lg hover:bg-red-600 disabled:opacity-50"
+                >
+                  Limpar Chaves
+                </button>
+              </div>
+            </div>
+
+            <div className="grid grid-cols-1 gap-4">
+              <div className="p-4 bg-gray-50 rounded-lg">
+                <p className="text-sm text-gray-600 mb-1">Chave Pública (enviada ao servidor)</p>
+                <div className="flex items-center space-x-2">
+                  <code className="text-xs bg-white px-2 py-1 rounded border flex-1 break-all">
+                    {keys.publicKey}
+                  </code>
+                  <button
+                    onClick={() => copyToClipboard(keys.publicKey, 'public')}
+                    className="text-purple-600 hover:text-purple-700 flex-shrink-0"
+                  >
+                    {copiedKey === 'public' ? <FaCheckCircle /> : <FaCopy />}
+                  </button>
+                </div>
+              </div>
+
+              <div className="p-4 bg-red-50 rounded-lg border-2 border-red-200">
+                <p className="text-sm text-red-600 mb-1 font-bold">⚠️ Chave Privada (NUNCA compartilhar!)</p>
+                <div className="flex items-center space-x-2">
+                  <code className="text-xs bg-white px-2 py-1 rounded border flex-1 break-all blur-sm hover:blur-none transition">
+                    {keys.privateKey}
+                  </code>
+                  <button
+                    onClick={() => copyToClipboard(keys.privateKey, 'private')}
+                    className="text-red-600 hover:text-red-700 flex-shrink-0"
+                  >
+                    {copiedKey === 'private' ? <FaCheckCircle /> : <FaCopy />}
+                  </button>
+                </div>
+                <p className="text-xs text-red-500 mt-2">
+                  Esta chave fica APENAS no seu navegador e nunca é enviada ao servidor
+                </p>
+              </div>
+            </div>
+          </div>
+        )}
+      </div>
+
+      {/* API Tests */}
+      <div className="bg-white rounded-xl shadow-sm border border-gray-200 p-6">
+        <h2 className="text-xl font-bold text-gray-800 mb-4">🧪 Testes de API</h2>
+
+        <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+          {/* Public Request */}
+          <div className="border border-gray-200 rounded-lg p-4">
+            <h3 className="font-semibold text-gray-800 mb-2">Rota Pública</h3>
+            <p className="text-sm text-gray-600 mb-3">Não requer autenticação</p>
+            <button
+              onClick={handlePublicRequest}
+              disabled={loading}
+              className="w-full bg-blue-500 text-white px-4 py-2 rounded-lg hover:bg-blue-600 disabled:opacity-50 mb-3"
+            >
+              GET /api/crypto-auth/public
+            </button>
+            {publicDataResult && (
+              <pre className="text-xs bg-gray-900 text-green-400 p-3 rounded overflow-auto max-h-40">
+                {JSON.stringify(publicDataResult, null, 2)}
+              </pre>
+            )}
+          </div>
+
+          {/* Protected Request */}
+          <div className="border border-gray-200 rounded-lg p-4">
+            <h3 className="font-semibold text-gray-800 mb-2">Rota Protegida</h3>
+            <p className="text-sm text-gray-600 mb-3">Requer assinatura criptográfica</p>
+            <button
+              onClick={handleProtectedRequest}
+              disabled={loading || !keys}
+              className="w-full bg-purple-500 text-white px-4 py-2 rounded-lg hover:bg-purple-600 disabled:opacity-50 mb-3"
+            >
+              GET /api/crypto-auth/protected
+            </button>
+            {protectedDataResult && (
+              <pre className="text-xs bg-gray-900 text-green-400 p-3 rounded overflow-auto max-h-40">
+                {JSON.stringify(protectedDataResult, null, 2)}
+              </pre>
+            )}
+          </div>
+        </div>
+      </div>
+
+      {/* How it Works */}
+      <div className="bg-blue-50 rounded-xl p-6">
+        <h2 className="text-xl font-bold text-blue-900 mb-4">🔍 Como Funciona (SEM Sessões)</h2>
+        <div className="space-y-3 text-sm text-blue-800">
+          <div className="flex items-start">
+            <FaCheckCircle className="text-blue-600 mt-1 mr-2 flex-shrink-0" />
+            <div>
+              <strong>1. Geração de Chaves:</strong> Par de chaves Ed25519 gerado LOCALMENTE no navegador
+            </div>
+          </div>
+          <div className="flex items-start">
+            <FaCheckCircle className="text-blue-600 mt-1 mr-2 flex-shrink-0" />
+            <div>
+              <strong>2. Chave Privada:</strong> NUNCA sai do navegador, armazenada em sessionStorage (válida apenas durante a sessão)
+            </div>
+          </div>
+          <div className="flex items-start">
+            <FaCheckCircle className="text-blue-600 mt-1 mr-2 flex-shrink-0" />
+            <div>
+              <strong>3. Assinatura:</strong> Cada requisição é assinada: publicKey + timestamp + nonce + mensagem
+            </div>
+          </div>
+          <div className="flex items-start">
+            <FaCheckCircle className="text-blue-600 mt-1 mr-2 flex-shrink-0" />
+            <div>
+              <strong>4. Validação:</strong> Servidor valida assinatura usando a chave pública recebida
+            </div>
+          </div>
+          <div className="flex items-start">
+            <FaCheckCircle className="text-blue-600 mt-1 mr-2 flex-shrink-0" />
+            <div>
+              <strong>5. Headers Enviados:</strong> x-public-key, x-timestamp, x-nonce, x-signature
+            </div>
+          </div>
+          <div className="flex items-start">
+            <FaCheckCircle className="text-blue-600 mt-1 mr-2 flex-shrink-0" />
+            <div>
+              <strong>6. Sem Sessões:</strong> Servidor NÃO armazena nada, apenas valida assinaturas
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {/* Import Modal */}
+      {showImportModal && (
+        <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
+          <div className="bg-white rounded-xl shadow-2xl p-6 max-w-lg w-full mx-4">
+            <div className="flex items-center justify-between mb-4">
+              <h3 className="text-xl font-bold text-gray-800 flex items-center">
+                <FaFileImport className="mr-2 text-blue-600" />
+                Importar Chave Privada
+              </h3>
+              <button
+                onClick={() => setShowImportModal(false)}
+                className="text-gray-400 hover:text-gray-600"
+              >
+                ✕
+              </button>
+            </div>
+
+            <div className="mb-4">
+              <label className="block text-sm font-medium text-gray-700 mb-2">
+                Chave Privada (64 caracteres hexadecimais)
+              </label>
+              <textarea
+                value={importKey}
+                onChange={(e) => setImportKey(e.target.value)}
+                placeholder="Digite ou cole sua chave privada aqui..."
+                className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent font-mono text-sm resize-none"
+                rows={4}
+              />
+              <p className="text-xs text-gray-500 mt-1">
+                {importKey.trim().length}/64 caracteres
+              </p>
+            </div>
+
+            {importError && (
+              <div className="mb-4 p-3 bg-red-50 border border-red-200 rounded-lg flex items-start">
+                <FaExclamationTriangle className="text-red-600 mt-0.5 mr-2 flex-shrink-0" />
+                <p className="text-sm text-red-700">{importError}</p>
+              </div>
+            )}
+
+            <div className="bg-yellow-50 border border-yellow-200 rounded-lg p-3 mb-4">
+              <div className="flex items-start">
+                <FaExclamationTriangle className="text-yellow-600 mt-0.5 mr-2 flex-shrink-0" />
+                <div className="text-sm text-yellow-800">
+                  <strong>⚠️ Atenção:</strong> Importar uma chave privada substituirá suas chaves atuais.
+                  A chave pública será derivada automaticamente da chave privada.
+                </div>
+              </div>
+            </div>
+
+            <div className="flex gap-3">
+              <button
+                onClick={handleImportKey}
+                disabled={loading || importKey.trim().length !== 64}
+                className="flex-1 bg-blue-600 text-white px-4 py-2 rounded-lg hover:bg-blue-700 disabled:opacity-50 disabled:cursor-not-allowed flex items-center justify-center"
+              >
+                {loading ? (
+                  <>
+                    <FaSync className="animate-spin mr-2" />
+                    Importando...
+                  </>
+                ) : (
+                  <>
+                    <FaFileImport className="mr-2" />
+                    Importar Chave
+                  </>
+                )}
+              </button>
+              <button
+                onClick={() => setShowImportModal(false)}
+                disabled={loading}
+                className="px-4 py-2 border border-gray-300 rounded-lg hover:bg-gray-50 disabled:opacity-50"
+              >
+                Cancelar
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
diff --git a/app/server/index.ts b/app/server/index.ts
index ef4896d9..ccb6320e 100644
--- a/app/server/index.ts
+++ b/app/server/index.ts
@@ -7,6 +7,7 @@ import { helpers } from "@/core/utils/env"
 import { serverConfig } from "@/config/server.config"
 import { appConfig } from "@/config/app.config"
 import { loggerConfig } from "@/config/logger.config"
+import cryptoAuthPlugin from "@/plugins/crypto-auth"
 import "./live/register-components"
 
 // Startup info moved to DEBUG level (set LOG_LEVEL=debug to see details)
@@ -50,6 +51,9 @@ const app = new FluxStackFramework({
 
 // Usar plugins de infraestrutura primeiro (Logger é core, não é plugin)
 
+// Registrar plugin de autenticação ANTES dos outros plugins
+app.use(cryptoAuthPlugin)
+
 // Usar plugins condicionalmente baseado no ambiente
 if (isDevelopment()) {
   app.use(vitePlugin)
diff --git a/app/server/routes/crypto-auth-demo.routes.ts b/app/server/routes/crypto-auth-demo.routes.ts
new file mode 100644
index 00000000..8845cada
--- /dev/null
+++ b/app/server/routes/crypto-auth-demo.routes.ts
@@ -0,0 +1,167 @@
+/**
+ * Rotas de demonstração do Crypto Auth Plugin
+ * ✅ NOVA ABORDAGEM: Middlewares declarativos nas rotas
+ */
+
+import { Elysia, t } from 'elysia'
+import {
+  cryptoAuthRequired,
+  cryptoAuthAdmin,
+  cryptoAuthOptional,
+  cryptoAuthPermissions,
+  getCryptoAuthUser,
+  isCryptoAuthAdmin
+} from '@/plugins/crypto-auth/server'
+
+export const cryptoAuthDemoRoutes = new Elysia({ prefix: '/crypto-auth' })
+
+  // ========================================
+  // 🌐 ROTAS PÚBLICAS (sem middleware)
+  // ========================================
+
+  .get('/public', () => ({
+    success: true,
+    message: 'Esta é uma rota pública - acessível sem autenticação',
+    timestamp: new Date().toISOString(),
+    note: 'Não usa nenhum middleware crypto-auth'
+  }))
+
+  .get('/status', ({ request, headers }) => {
+    const user = getCryptoAuthUser(request)
+
+    return {
+      authenticated: !!user,
+      headers: {
+        hasSignature: !!headers['x-signature'],
+        hasPublicKey: !!headers['x-public-key'],
+        hasTimestamp: !!headers['x-timestamp'],
+        hasNonce: !!headers['x-nonce']
+      },
+      user: user ? {
+        publicKey: user.publicKey.substring(0, 16) + '...',
+        isAdmin: user.isAdmin,
+        permissions: user.permissions
+      } : null,
+      timestamp: new Date().toISOString()
+    }
+  })
+
+  // ========================================
+  // 🌓 ROTA COM AUTH OPCIONAL
+  // ========================================
+
+  .guard({}, (app) =>
+    app.use(cryptoAuthOptional())
+      .get('/feed', ({ request }) => {
+        const user = getCryptoAuthUser(request)
+        const isAuthenticated = !!user
+
+        return {
+          success: true,
+          message: isAuthenticated
+            ? `Feed personalizado para ${user.publicKey.substring(0, 8)}...`
+            : 'Feed público geral',
+          posts: [
+            {
+              id: 1,
+              title: 'Post público',
+              canEdit: isAuthenticated && isCryptoAuthAdmin(request),
+              premium: false
+            },
+            {
+              id: 2,
+              title: 'Post premium',
+              content: isAuthenticated ? 'Conteúdo completo' : 'Conteúdo bloqueado - faça login',
+              premium: true
+            }
+          ],
+          user: user ? {
+            publicKey: user.publicKey.substring(0, 8) + '...',
+            isAdmin: user.isAdmin
+          } : null
+        }
+      })
+  )
+
+  // ========================================
+  // 🔒 ROTAS PROTEGIDAS (require auth)
+  // ========================================
+
+  .guard({}, (app) =>
+    app.use(cryptoAuthRequired())
+      .get('/protected', ({ request }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: 'Acesso autorizado! Assinatura validada.',
+          user: {
+            publicKey: user.publicKey.substring(0, 16) + '...',
+            isAdmin: user.isAdmin,
+            permissions: user.permissions
+          },
+          data: {
+            secretInfo: 'Dados protegidos - só acessível com assinatura válida',
+            userLevel: 'authenticated',
+            timestamp: new Date().toISOString()
+          }
+        }
+      })
+
+      .post('/protected/data', async ({ request, body }) => {
+        const user = getCryptoAuthUser(request)!
+        const postBody = body as { query: string }
+
+        return {
+          success: true,
+          message: 'Dados processados com segurança',
+          receivedFrom: user.publicKey.substring(0, 8) + '...',
+          receivedData: postBody,
+          processedAt: new Date().toISOString()
+        }
+      }, {
+        body: t.Object({
+          query: t.String()
+        })
+      })
+  )
+
+  // ========================================
+  // 👑 ROTAS ADMIN (require admin)
+  // ========================================
+
+  .guard({}, (app) =>
+    app.use(cryptoAuthAdmin())
+      .get('/admin', ({ request }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: 'Acesso admin autorizado',
+          user: {
+            publicKey: user.publicKey.substring(0, 16) + '...',
+            isAdmin: true,
+            permissions: user.permissions
+          },
+          adminData: {
+            systemHealth: 'optimal',
+            totalUsers: 42,
+            message: 'Dados sensíveis de administração'
+          }
+        }
+      })
+
+      .delete('/admin/users/:id', ({ request, params }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: `Usuário ${params.id} deletado por admin`,
+          deletedBy: {
+            publicKey: user.publicKey.substring(0, 8) + '...',
+            isAdmin: true
+          },
+          timestamp: new Date().toISOString()
+        }
+      })
+  )
diff --git a/app/server/routes/example-with-crypto-auth.routes.ts b/app/server/routes/example-with-crypto-auth.routes.ts
new file mode 100644
index 00000000..4559102f
--- /dev/null
+++ b/app/server/routes/example-with-crypto-auth.routes.ts
@@ -0,0 +1,235 @@
+/**
+ * Exemplo de uso dos middlewares crypto-auth
+ * Demonstra como proteger rotas com autenticação criptográfica
+ */
+
+import { Elysia, t } from 'elysia'
+import {
+  cryptoAuthRequired,
+  cryptoAuthAdmin,
+  cryptoAuthPermissions,
+  cryptoAuthOptional,
+  getCryptoAuthUser,
+  isCryptoAuthAdmin
+} from '@/plugins/crypto-auth/server'
+
+// ========================================
+// 1️⃣ ROTAS QUE REQUEREM AUTENTICAÇÃO
+// ========================================
+
+export const protectedRoutes = new Elysia()
+  // ✅ Aplica middleware a TODAS as rotas deste grupo
+  .use(cryptoAuthRequired())
+
+  // Agora TODAS as rotas abaixo requerem autenticação
+  .get('/users/me', ({ request }) => {
+    const user = getCryptoAuthUser(request)!
+
+    return {
+      profile: {
+        publicKey: user.publicKey,
+        isAdmin: user.isAdmin,
+        permissions: user.permissions
+      }
+    }
+  })
+
+  .get('/users', ({ request }) => {
+    const user = getCryptoAuthUser(request)!
+
+    return {
+      users: [
+        { id: 1, name: 'João' },
+        { id: 2, name: 'Maria' }
+      ],
+      requestedBy: user.publicKey.substring(0, 16) + '...'
+    }
+  })
+
+  .post('/posts', ({ request, body }) => {
+    const user = getCryptoAuthUser(request)!
+    const { title, content } = body as { title: string; content: string }
+
+    return {
+      success: true,
+      post: {
+        title,
+        content,
+        author: user.publicKey,
+        createdAt: new Date()
+      }
+    }
+  }, {
+    body: t.Object({
+      title: t.String(),
+      content: t.String()
+    })
+  })
+
+// ========================================
+// 2️⃣ ROTAS QUE REQUEREM ADMIN
+// ========================================
+
+export const adminRoutes = new Elysia()
+  // ✅ Apenas admins podem acessar
+  .use(cryptoAuthAdmin())
+
+  .get('/admin/stats', () => ({
+    totalUsers: 100,
+    totalPosts: 500,
+    systemHealth: 'optimal'
+  }))
+
+  .delete('/admin/users/:id', ({ params, request }) => {
+    const user = getCryptoAuthUser(request)!
+
+    return {
+      success: true,
+      message: `Usuário ${params.id} deletado`,
+      deletedBy: user.publicKey
+    }
+  })
+
+  .post('/admin/broadcast', ({ body }) => ({
+    success: true,
+    message: 'Mensagem enviada para todos os usuários',
+    content: body
+  }), {
+    body: t.Object({
+      message: t.String()
+    })
+  })
+
+// ========================================
+// 3️⃣ ROTAS COM PERMISSÕES ESPECÍFICAS
+// ========================================
+
+export const writeRoutes = new Elysia()
+  // ✅ Requer permissão 'write'
+  .use(cryptoAuthPermissions(['write']))
+
+  .put('/posts/:id', ({ params, body }) => ({
+    success: true,
+    message: `Post ${params.id} atualizado`,
+    data: body
+  }), {
+    body: t.Object({
+      title: t.Optional(t.String()),
+      content: t.Optional(t.String())
+    })
+  })
+
+  .patch('/posts/:id/publish', ({ params }) => ({
+    success: true,
+    message: `Post ${params.id} publicado`
+  }))
+
+// ========================================
+// 4️⃣ ROTAS MISTAS (Opcional)
+// ========================================
+
+export const mixedRoutes = new Elysia()
+  // ✅ Autenticação OPCIONAL - adiciona user se autenticado
+  .use(cryptoAuthOptional())
+
+  // Comportamento diferente se autenticado
+  .get('/posts/:id', ({ request, params }) => {
+    const user = getCryptoAuthUser(request)
+    const isAdmin = isCryptoAuthAdmin(request)
+
+    return {
+      post: {
+        id: params.id,
+        title: 'Título do Post',
+        // Mostra conteúdo completo apenas se autenticado
+        content: user ? 'Conteúdo completo do post...' : 'Prévia...',
+        author: 'João'
+      },
+      viewer: user ? {
+        publicKey: user.publicKey.substring(0, 16) + '...',
+        canEdit: isAdmin,
+        canComment: true
+      } : {
+        canEdit: false,
+        canComment: false
+      }
+    }
+  })
+
+  .get('/posts', ({ request }) => {
+    const user = getCryptoAuthUser(request)
+
+    return {
+      posts: [
+        { id: 1, title: 'Post 1' },
+        { id: 2, title: 'Post 2' }
+      ],
+      authenticated: !!user
+    }
+  })
+
+// ========================================
+// 5️⃣ ROTAS COM VERIFICAÇÃO MANUAL
+// ========================================
+
+export const customRoutes = new Elysia()
+  .use(cryptoAuthRequired())
+
+  .get('/posts/:id/edit', ({ request, params, set }) => {
+    const user = getCryptoAuthUser(request)!
+
+    // Verificação customizada - apenas autor ou admin
+    const post = { id: params.id, authorKey: 'abc123...' } // Buscar do DB
+
+    const canEdit = user.isAdmin || user.publicKey === post.authorKey
+
+    if (!canEdit) {
+      set.status = 403
+      return {
+        error: 'Apenas o autor ou admin podem editar este post'
+      }
+    }
+
+    return {
+      post,
+      canEdit: true
+    }
+  })
+
+// ========================================
+// 6️⃣ COMBINANDO MÚLTIPLOS MIDDLEWARES
+// ========================================
+
+export const combinedRoutes = new Elysia({ prefix: '/api/v1' })
+  // Primeiro grupo - rotas públicas
+  .get('/health', () => ({ status: 'ok' }))
+
+  .get('/posts', () => ({
+    posts: [/* ... */]
+  }))
+
+  // Segundo grupo - rotas protegidas
+  .group('/users', (app) => app
+    .use(cryptoAuthRequired())
+    .get('/', () => ({ users: [] }))
+    .post('/', ({ body }) => ({ created: body }))
+  )
+
+  // Terceiro grupo - rotas admin
+  .group('/admin', (app) => app
+    .use(cryptoAuthAdmin())
+    .get('/stats', () => ({ stats: {} }))
+    .delete('/users/:id', ({ params }) => ({ deleted: params.id }))
+  )
+
+// ========================================
+// 7️⃣ EXPORTAR TODAS AS ROTAS
+// ========================================
+
+export const allExampleRoutes = new Elysia()
+  .use(protectedRoutes)
+  .use(adminRoutes)
+  .use(writeRoutes)
+  .use(mixedRoutes)
+  .use(customRoutes)
+  .use(combinedRoutes)
diff --git a/app/server/routes/exemplo-posts.routes.ts b/app/server/routes/exemplo-posts.routes.ts
new file mode 100644
index 00000000..27323945
--- /dev/null
+++ b/app/server/routes/exemplo-posts.routes.ts
@@ -0,0 +1,161 @@
+/**
+ * 🎓 EXEMPLO PRÁTICO: Como criar rotas com Crypto-Auth
+ *
+ * Este arquivo demonstra como um desenvolvedor cria rotas usando
+ * o sistema de autenticação crypto-auth do FluxStack.
+ */
+
+import { Elysia, t } from 'elysia'
+import {
+  cryptoAuthRequired,
+  cryptoAuthAdmin,
+  cryptoAuthOptional,
+  getCryptoAuthUser
+} from '@/plugins/crypto-auth/server'
+
+// Mock database (simulação)
+const posts = [
+  { id: 1, title: 'Post Público 1', content: 'Conteúdo aberto', public: true },
+  { id: 2, title: 'Post Público 2', content: 'Conteúdo aberto', public: true }
+]
+
+export const exemploPostsRoutes = new Elysia({ prefix: '/exemplo-posts' })
+
+  // ========================================
+  // 🌐 ROTA PÚBLICA - Qualquer um acessa
+  // ========================================
+  .get('/', () => {
+    return {
+      success: true,
+      message: 'Lista pública de posts',
+      posts: posts.filter(p => p.public)
+    }
+  })
+
+  // ========================================
+  // 🌓 ROTA COM AUTH OPCIONAL
+  // Funciona com ou sem autenticação
+  // ========================================
+  .guard({}, (app) =>
+    app.use(cryptoAuthOptional())
+
+      .get('/:id', ({ request, params }) => {
+        const user = getCryptoAuthUser(request)
+        const isAuthenticated = !!user
+        const post = posts.find(p => p.id === parseInt(params.id))
+
+        if (!post) {
+          return { success: false, error: 'Post não encontrado' }
+        }
+
+        return {
+          success: true,
+          post: {
+            ...post,
+            // ✅ Conteúdo extra apenas para autenticados
+            premiumContent: isAuthenticated
+              ? 'Conteúdo premium exclusivo para usuários autenticados!'
+              : null,
+            viewer: isAuthenticated
+              ? `Autenticado: ${user.publicKey.substring(0, 8)}...`
+              : 'Visitante anônimo'
+          }
+        }
+      })
+  )
+
+  // ========================================
+  // 🔒 ROTAS PROTEGIDAS - Requer autenticação
+  // ========================================
+  .guard({}, (app) =>
+    app.use(cryptoAuthRequired())
+
+      // GET /api/exemplo-posts/meus-posts
+      .get('/meus-posts', ({ request }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: `Posts criados por você`,
+          user: {
+            publicKey: user.publicKey.substring(0, 16) + '...',
+            isAdmin: user.isAdmin
+          },
+          posts: [
+            {
+              id: 999,
+              title: 'Meu Post Privado',
+              content: 'Só eu posso ver',
+              author: user.publicKey
+            }
+          ]
+        }
+      })
+
+      // POST /api/exemplo-posts/criar
+      .post('/criar', ({ request, body }) => {
+        const user = getCryptoAuthUser(request)!
+        const { title, content } = body as { title: string; content: string }
+
+        const newPost = {
+          id: Date.now(),
+          title,
+          content,
+          author: user.publicKey,
+          createdAt: new Date().toISOString(),
+          public: false
+        }
+
+        posts.push(newPost)
+
+        return {
+          success: true,
+          message: 'Post criado com sucesso!',
+          post: newPost
+        }
+      }, {
+        body: t.Object({
+          title: t.String({ minLength: 3 }),
+          content: t.String({ minLength: 10 })
+        })
+      })
+  )
+
+  // ========================================
+  // 👑 ROTAS ADMIN - Apenas administradores
+  // ========================================
+  .guard({}, (app) =>
+    app.use(cryptoAuthAdmin())
+
+      // GET /api/exemplo-posts/admin/todos
+      .get('/admin/todos', ({ request }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: 'Painel administrativo',
+          admin: user.publicKey.substring(0, 8) + '...',
+          totalPosts: posts.length,
+          posts: posts // Admin vê tudo
+        }
+      })
+
+      // DELETE /api/exemplo-posts/admin/:id
+      .delete('/admin/:id', ({ request, params }) => {
+        const user = getCryptoAuthUser(request)!
+        const postIndex = posts.findIndex(p => p.id === parseInt(params.id))
+
+        if (postIndex === -1) {
+          return { success: false, error: 'Post não encontrado' }
+        }
+
+        const deletedPost = posts.splice(postIndex, 1)[0]
+
+        return {
+          success: true,
+          message: `Post "${deletedPost.title}" deletado pelo admin`,
+          deletedBy: user.publicKey.substring(0, 8) + '...',
+          deletedPost
+        }
+      })
+  )
diff --git a/app/server/routes/index.ts b/app/server/routes/index.ts
index eee92ae6..f58ecaef 100644
--- a/app/server/routes/index.ts
+++ b/app/server/routes/index.ts
@@ -2,6 +2,8 @@ import { Elysia, t } from "elysia"
 import { usersRoutes } from "./users.routes"
 import { uploadRoutes } from "./upload"
 import { configRoutes } from "./config"
+import { cryptoAuthDemoRoutes } from "./crypto-auth-demo.routes"
+import { exemploPostsRoutes } from "./exemplo-posts.routes"
 
 export const apiRoutes = new Elysia({ prefix: "/api" })
   .get("/", () => ({ message: "🔥 Hot Reload funcionando! FluxStack API v1.4.0 ⚡" }), {
@@ -36,4 +38,6 @@ export const apiRoutes = new Elysia({ prefix: "/api" })
   })
   .use(usersRoutes)
   .use(uploadRoutes)
-  .use(configRoutes)
\ No newline at end of file
+  .use(configRoutes)
+  .use(cryptoAuthDemoRoutes)
+  .use(exemploPostsRoutes)  // ✅ Exemplo de rotas com crypto-auth
\ No newline at end of file
diff --git a/bun.lock b/bun.lock
index cc75a2d1..7d2c2ffa 100644
--- a/bun.lock
+++ b/bun.lock
@@ -6,8 +6,6 @@
       "dependencies": {
         "@elysiajs/eden": "^1.3.2",
         "@elysiajs/swagger": "^1.3.1",
-        "@noble/curves": "^1.2.0",
-        "@noble/hashes": "^1.3.2",
         "@types/http-proxy-middleware": "^1.0.0",
         "@types/ws": "^8.18.1",
         "@vitejs/plugin-react": "^4.6.0",
@@ -32,6 +30,8 @@
       },
       "devDependencies": {
         "@eslint/js": "^9.30.1",
+        "@noble/curves": "1.2.0",
+        "@noble/hashes": "1.3.2",
         "@tailwindcss/vite": "^4.1.13",
         "@testing-library/jest-dom": "^6.6.4",
         "@testing-library/react": "^16.3.0",
@@ -223,9 +223,9 @@
 
     "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="],
 
-    "@noble/curves": ["@noble/curves@1.9.7", "", { "dependencies": { "@noble/hashes": "1.8.0" } }, "sha512-gbKGcRUYIjA3/zCCNaWDciTMFI0dCkvou3TL8Zmy5Nc7sJ47a0jtOeZoTaMxkuqRo9cRhjOdZJXegxYE5FN/xw=="],
+    "@noble/curves": ["@noble/curves@1.2.0", "", { "dependencies": { "@noble/hashes": "1.3.2" } }, "sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw=="],
 
-    "@noble/hashes": ["@noble/hashes@1.8.0", "", {}, "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A=="],
+    "@noble/hashes": ["@noble/hashes@1.3.2", "", {}, "sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ=="],
 
     "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="],
 
diff --git a/config/index.ts b/config/index.ts
index 5298de50..9aaeedc1 100644
--- a/config/index.ts
+++ b/config/index.ts
@@ -27,6 +27,9 @@ export { buildConfig } from './build.config'
 export { appRuntimeConfig } from './runtime.config'
 export { systemConfig, systemRuntimeInfo } from './system.config'
 
+// Plugin configs (re-exported for convenience)
+export { cryptoAuthConfig } from '../plugins/crypto-auth/config'
+
 // Re-export types
 export type { AppConfig } from './app.config'
 export type { DatabaseConfig } from './database.config'
@@ -41,6 +44,9 @@ export type {
   RedisConfig
 } from './services.config'
 
+// Plugin types
+export type { CryptoAuthConfig } from '../plugins/crypto-auth/config'
+
 /**
  * All configs in one object
  */
@@ -52,6 +58,7 @@ import { loggerConfig } from './logger.config'
 import { buildConfig } from './build.config'
 import { appRuntimeConfig } from './runtime.config'
 import { systemConfig, systemRuntimeInfo } from './system.config'
+import { cryptoAuthConfig } from '../plugins/crypto-auth/config'
 
 export const config = {
   app: appConfig,
@@ -62,7 +69,8 @@ export const config = {
   build: buildConfig,
   runtime: appRuntimeConfig,
   system: systemConfig,
-  systemRuntime: systemRuntimeInfo
+  systemRuntime: systemRuntimeInfo,
+  cryptoAuth: cryptoAuthConfig
 }
 
 export default config
diff --git a/core/cli/generators/plugin.ts b/core/cli/generators/plugin.ts
index 31afebe4..2ca272b0 100644
--- a/core/cli/generators/plugin.ts
+++ b/core/cli/generators/plugin.ts
@@ -33,11 +33,12 @@ export class PluginGenerator implements Generator {
 
         console.log(`\n✅ Generated plugin '${options.name}' with ${files.length} files`)
         console.log(`\n📦 Next steps:`)
-        console.log(`   1. Edit plugins/${options.name}/plugin.json with your plugin metadata`)
-        console.log(`   2. Implement your plugin logic in plugins/${options.name}/index.ts`)
-        console.log(`   3. Add server-side code in plugins/${options.name}/server/ (optional)`)
-        console.log(`   4. Add client-side code in plugins/${options.name}/client/ (optional)`)
-        console.log(`   5. Run: bun run cli plugin:deps install`)
+        console.log(`   1. Configure plugin in plugins/${options.name}/config/index.ts`)
+        console.log(`   2. Set environment variables (optional): ${options.name.toUpperCase().replace(/-/g, '_')}_*`)
+        console.log(`   3. Implement your plugin logic in plugins/${options.name}/index.ts`)
+        console.log(`   4. Add server-side code in plugins/${options.name}/server/ (optional)`)
+        console.log(`   5. Add client-side code in plugins/${options.name}/client/ (optional)`)
+        console.log(`   6. Run: bun run dev`)
     }
 
     private getTemplate(templateName?: string): Template {
@@ -59,31 +60,80 @@ export class PluginGenerator implements Generator {
             description: 'Basic plugin template with essential files',
             files: [
                 {
-                    path: 'plugins/{{name}}/plugin.json',
+                    path: 'plugins/{{name}}/package.json',
                     content: `{
-  "name": "{{name}}",
+  "name": "@fluxstack/{{name}}-plugin",
   "version": "1.0.0",
   "description": "{{description}}",
-  "author": "Your Name",
-  "type": "fluxstack-plugin",
   "main": "index.ts",
+  "types": "index.ts",
+  "exports": {
+    ".": {
+      "import": "./index.ts",
+      "types": "./index.ts"
+    },
+    "./config": {
+      "import": "./config/index.ts",
+      "types": "./config/index.ts"
+    }
+  },
+  "keywords": [
+    "fluxstack",
+    "plugin",
+    "{{name}}",
+    "typescript"
+  ],
+  "author": "FluxStack Developer",
+  "license": "MIT",
+  "peerDependencies": {},
   "dependencies": {},
-  "fluxstack": {
-    "minVersion": "1.4.0"
+  "devDependencies": {
+    "typescript": "^5.0.0"
   },
-  "hooks": {
-    "setup": true,
-    "onServerStart": false,
-    "onRequest": false,
-    "onResponse": false,
-    "onError": false
+  "fluxstack": {
+    "plugin": true,
+    "version": "^1.0.0",
+    "hooks": [
+      "setup",
+      "onServerStart"
+    ],
+    "category": "utility",
+    "tags": ["{{name}}"]
   }
 }
+`
+                },
+                {
+                    path: 'plugins/{{name}}/config/index.ts',
+                    content: `/**
+ * {{pascalName}} Plugin Configuration
+ * Declarative config using FluxStack config system
+ */
+
+import { defineConfig, config } from '@/core/utils/config-schema'
+
+const {{camelName}}ConfigSchema = {
+  // Enable/disable plugin
+  enabled: config.boolean('{{constantName}}_ENABLED', true),
+
+  // Add your configuration options here
+  // Example:
+  // apiKey: config.string('{{constantName}}_API_KEY', ''),
+  // timeout: config.number('{{constantName}}_TIMEOUT', 5000),
+  // debug: config.boolean('{{constantName}}_DEBUG', false),
+} as const
+
+export const {{camelName}}Config = defineConfig({{camelName}}ConfigSchema)
+
+export type {{pascalName}}Config = typeof {{camelName}}Config
+export default {{camelName}}Config
 `
                 },
                 {
                     path: 'plugins/{{name}}/index.ts',
                     content: `import type { FluxStackPlugin, PluginContext } from '@/core/types/plugin'
+// ✅ Plugin imports its own configuration
+import { {{camelName}}Config } from './config'
 
 /**
  * {{pascalName}} Plugin
@@ -97,6 +147,12 @@ export class {{pascalName}}Plugin implements FluxStackPlugin {
    * Setup hook - called when plugin is loaded
    */
   async setup(context: PluginContext): Promise<void> {
+    // Check if plugin is enabled
+    if (!{{camelName}}Config.enabled) {
+      context.logger.info(\`[{{name}}] Plugin disabled by configuration\`)
+      return
+    }
+
     console.log(\`[{{name}}] Plugin initialized\`)
 
     // Add your initialization logic here
@@ -107,6 +163,8 @@ export class {{pascalName}}Plugin implements FluxStackPlugin {
    * Server start hook - called when server starts
    */
   async onServerStart?(context: PluginContext): Promise<void> {
+    if (!{{camelName}}Config.enabled) return
+
     console.log(\`[{{name}}] Server started\`)
 
     // Add logic to run when server starts
@@ -116,6 +174,8 @@ export class {{pascalName}}Plugin implements FluxStackPlugin {
    * Request hook - called on each request
    */
   async onRequest?(context: PluginContext, request: Request): Promise<void> {
+    if (!{{camelName}}Config.enabled) return
+
     // Add request processing logic
   }
 
@@ -123,6 +183,8 @@ export class {{pascalName}}Plugin implements FluxStackPlugin {
    * Response hook - called on each response
    */
   async onResponse?(context: PluginContext, response: Response): Promise<void> {
+    if (!{{camelName}}Config.enabled) return
+
     // Add response processing logic
   }
 
@@ -156,17 +218,29 @@ This plugin is already in your FluxStack project. To use it:
    bun run cli plugin:deps install
    \`\`\`
 
+## Configuration
+
+This plugin uses FluxStack's declarative configuration system. Configure it by editing \`config/index.ts\` or by setting environment variables:
+
+\`\`\`bash
+# Enable/disable plugin
+{{constantName}}_ENABLED=true
+
+# Add your environment variables here
+# Example:
+# {{constantName}}_API_KEY=your-api-key
+# {{constantName}}_TIMEOUT=5000
+\`\`\`
+
+The plugin's configuration is located in \`plugins/{{name}}/config/index.ts\` and is self-contained, making the plugin fully portable.
+
 ## Usage
 
 \`\`\`typescript
 // The plugin is automatically loaded by FluxStack
-// Configure it in your app/server/index.ts if needed
+// It imports its own configuration from ./config
 \`\`\`
 
-## Configuration
-
-Add configuration options here.
-
 ## API
 
 Document your plugin's API here.
@@ -184,8 +258,8 @@ This plugin uses the following hooks:
 
 To modify this plugin:
 
-1. Edit \`index.ts\` with your logic
-2. Update \`plugin.json\` with metadata
+1. Edit \`config/index.ts\` to add configuration options
+2. Edit \`index.ts\` with your logic
 3. Test with: \`bun run dev\`
 
 ## License
@@ -204,7 +278,60 @@ MIT
             name: 'server-plugin',
             description: 'Plugin with server-side code',
             files: [
-                ...basic.files,
+                {
+                    path: 'plugins/{{name}}/package.json',
+                    content: `{
+  "name": "@fluxstack/{{name}}-plugin",
+  "version": "1.0.0",
+  "description": "{{description}}",
+  "main": "index.ts",
+  "types": "index.ts",
+  "exports": {
+    ".": {
+      "import": "./index.ts",
+      "types": "./index.ts"
+    },
+    "./config": {
+      "import": "./config/index.ts",
+      "types": "./config/index.ts"
+    },
+    "./server": {
+      "import": "./server/index.ts",
+      "types": "./server/index.ts"
+    }
+  },
+  "keywords": [
+    "fluxstack",
+    "plugin",
+    "{{name}}",
+    "server",
+    "typescript"
+  ],
+  "author": "FluxStack Developer",
+  "license": "MIT",
+  "peerDependencies": {
+    "elysia": "^1.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "fluxstack": {
+    "plugin": true,
+    "version": "^1.0.0",
+    "hooks": [
+      "setup",
+      "onServerStart",
+      "onRequest",
+      "onResponse"
+    ],
+    "category": "utility",
+    "tags": ["{{name}}", "server"]
+  }
+}
+`
+                },
+                ...basic.files.slice(1), // Skip package.json from basic
                 {
                     path: 'plugins/{{name}}/server/index.ts',
                     content: `/**
@@ -233,7 +360,65 @@ export const {{camelName}}Service = new {{pascalName}}Service()
             name: 'client-plugin',
             description: 'Plugin with client-side code',
             files: [
-                ...basic.files,
+                {
+                    path: 'plugins/{{name}}/package.json',
+                    content: `{
+  "name": "@fluxstack/{{name}}-plugin",
+  "version": "1.0.0",
+  "description": "{{description}}",
+  "main": "index.ts",
+  "types": "index.ts",
+  "exports": {
+    ".": {
+      "import": "./index.ts",
+      "types": "./index.ts"
+    },
+    "./config": {
+      "import": "./config/index.ts",
+      "types": "./config/index.ts"
+    },
+    "./client": {
+      "import": "./client/index.ts",
+      "types": "./client/index.ts"
+    }
+  },
+  "keywords": [
+    "fluxstack",
+    "plugin",
+    "{{name}}",
+    "react",
+    "client",
+    "typescript"
+  ],
+  "author": "FluxStack Developer",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": ">=16.8.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "typescript": "^5.0.0"
+  },
+  "fluxstack": {
+    "plugin": true,
+    "version": "^1.0.0",
+    "hooks": [
+      "setup",
+      "onServerStart"
+    ],
+    "category": "utility",
+    "tags": ["{{name}}", "client", "react"]
+  }
+}
+`
+                },
+                ...basic.files.slice(1), // Skip package.json from basic
                 {
                     path: 'plugins/{{name}}/client/index.ts',
                     content: `/**
@@ -265,22 +450,127 @@ export const {{camelName}}Client = new {{pascalName}}Client()
             name: 'full-plugin',
             description: 'Complete plugin with server and client code',
             files: [
-                ...basic.files,
-                ...server.files.slice(basic.files.length), // Add server files
-                ...client.files.slice(basic.files.length), // Add client files
+                {
+                    path: 'plugins/{{name}}/package.json',
+                    content: `{
+  "name": "@fluxstack/{{name}}-plugin",
+  "version": "1.0.0",
+  "description": "{{description}}",
+  "main": "index.ts",
+  "types": "index.ts",
+  "exports": {
+    ".": {
+      "import": "./index.ts",
+      "types": "./index.ts"
+    },
+    "./config": {
+      "import": "./config/index.ts",
+      "types": "./config/index.ts"
+    },
+    "./server": {
+      "import": "./server/index.ts",
+      "types": "./server/index.ts"
+    },
+    "./client": {
+      "import": "./client/index.ts",
+      "types": "./client/index.ts"
+    },
+    "./types": {
+      "import": "./types.ts",
+      "types": "./types.ts"
+    }
+  },
+  "keywords": [
+    "fluxstack",
+    "plugin",
+    "{{name}}",
+    "react",
+    "server",
+    "client",
+    "typescript"
+  ],
+  "author": "FluxStack Developer",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "elysia": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "typescript": "^5.0.0"
+  },
+  "fluxstack": {
+    "plugin": true,
+    "version": "^1.0.0",
+    "hooks": [
+      "setup",
+      "onServerStart",
+      "onRequest",
+      "onResponse",
+      "onError"
+    ],
+    "category": "utility",
+    "tags": ["{{name}}", "server", "client", "react"]
+  }
+}
+`
+                },
+                ...basic.files.slice(1), // Skip package.json from basic
+                {
+                    path: 'plugins/{{name}}/server/index.ts',
+                    content: `/**
+ * Server-side logic for {{pascalName}} plugin
+ */
+
+export class {{pascalName}}Service {
+  async initialize() {
+    console.log(\`[{{name}}] Server service initialized\`)
+  }
+
+  // Add your server-side methods here
+}
+
+export const {{camelName}}Service = new {{pascalName}}Service()
+`
+                },
+                {
+                    path: 'plugins/{{name}}/client/index.ts',
+                    content: `/**
+ * Client-side logic for {{pascalName}} plugin
+ */
+
+export class {{pascalName}}Client {
+  initialize() {
+    console.log(\`[{{name}}] Client initialized\`)
+  }
+
+  // Add your client-side methods here
+}
+
+export const {{camelName}}Client = new {{pascalName}}Client()
+`
+                },
                 {
                     path: 'plugins/{{name}}/types.ts',
                     content: `/**
  * Type definitions for {{pascalName}} plugin
  */
 
-export interface {{pascalName}}Config {
-  // Add your configuration types here
-  enabled: boolean
-}
+// Config types are exported from ./config/index.ts
+// Import them like: import type { {{pascalName}}Config } from './config'
 
 export interface {{pascalName}}Options {
-  // Add your options types here
+  // Add your runtime options types here
+}
+
+export interface {{pascalName}}Event {
+  // Add your event types here
 }
 `
                 }
diff --git a/core/cli/generators/template-engine.ts b/core/cli/generators/template-engine.ts
index 6a953bce..f31e01e0 100644
--- a/core/cli/generators/template-engine.ts
+++ b/core/cli/generators/template-engine.ts
@@ -85,6 +85,7 @@ export class TemplateEngine {
       camelName: this.toCamelCase(options.name),
       pascalName: this.toPascalCase(options.name),
       snakeName: this.toSnakeCase(options.name),
+      constantName: this.toConstantCase(options.name), // SCREAMING_SNAKE_CASE
       timestamp: new Date().toISOString(),
       date: new Date().toLocaleDateString(),
       year: new Date().getFullYear(),
@@ -149,6 +150,10 @@ export class TemplateEngine {
       .replace(/[\s-]+/g, '_')
       .toLowerCase()
   }
+
+  private toConstantCase(str: string): string {
+    return this.toSnakeCase(str).toUpperCase()
+  }
 }
 
 export const templateEngine = new TemplateEngine()
\ No newline at end of file
diff --git a/core/cli/plugin-discovery.ts b/core/cli/plugin-discovery.ts
index e23f1644..6bc88782 100644
--- a/core/cli/plugin-discovery.ts
+++ b/core/cli/plugin-discovery.ts
@@ -10,14 +10,14 @@ export class CliPluginDiscovery {
   async discoverAndRegisterCommands(): Promise<void> {
     // 1. Load built-in plugins with CLI commands
     await this.loadBuiltInPlugins()
-    
+
     // 2. Load local plugins from project
     await this.loadLocalPlugins()
   }
 
   private async loadBuiltInPlugins(): Promise<void> {
     const builtInPluginsDir = join(__dirname, '../plugins/built-in')
-    
+
     if (!existsSync(builtInPluginsDir)) {
       return
     }
@@ -33,7 +33,7 @@ export class CliPluginDiscovery {
           const pluginPath = join(builtInPluginsDir, pluginName, 'index.ts')
           if (existsSync(pluginPath)) {
             const pluginModule = await import(pluginPath)
-            
+
             if (pluginModule.commands) {
               for (const command of pluginModule.commands) {
                 cliRegistry.register(command)
@@ -57,7 +57,7 @@ export class CliPluginDiscovery {
 
   private async loadLocalPlugins(): Promise<void> {
     const localPluginsDir = join(process.cwd(), 'plugins')
-    
+
     if (!existsSync(localPluginsDir)) {
       return
     }
@@ -65,17 +65,18 @@ export class CliPluginDiscovery {
     try {
       const fs = await import('fs')
       const entries = fs.readdirSync(localPluginsDir, { withFileTypes: true })
-      
+
       for (const entry of entries) {
+        // Buscar arquivos .ts/.js diretamente
         if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.js'))) {
           const pluginPath = join(localPluginsDir, entry.name)
-          
+
           try {
             const pluginModule = await import(pluginPath)
             const plugin = pluginModule.default || Object.values(pluginModule).find(
               (exp: any) => exp && typeof exp === 'object' && exp.name && exp.commands
             ) as Plugin
-            
+
             if (plugin && plugin.commands) {
               this.registerPluginCommands(plugin)
             }
@@ -83,6 +84,26 @@ export class CliPluginDiscovery {
             logger.debug(`Failed to load local plugin ${entry.name}:`, error)
           }
         }
+
+        // ✅ Buscar em subdiretórios (plugins/nome-plugin/index.ts)
+        if (entry.isDirectory()) {
+          const pluginIndexPath = join(localPluginsDir, entry.name, 'index.ts')
+
+          if (existsSync(pluginIndexPath)) {
+            try {
+              const pluginModule = await import(pluginIndexPath)
+              const plugin = pluginModule.default || Object.values(pluginModule).find(
+                (exp: any) => exp && typeof exp === 'object' && exp.name && exp.commands
+              ) as Plugin
+
+              if (plugin && plugin.commands) {
+                this.registerPluginCommands(plugin)
+              }
+            } catch (error) {
+              logger.debug(`Failed to load local plugin ${entry.name}:`, error)
+            }
+          }
+        }
       }
     } catch (error) {
       logger.debug('Failed to scan local plugins:', error)
@@ -103,9 +124,9 @@ export class CliPluginDiscovery {
           category: command.category || `Plugin: ${plugin.name}`,
           aliases: command.aliases?.map(alias => `${plugin.name}:${alias}`)
         }
-        
+
         cliRegistry.register(prefixedCommand)
-        
+
         // Also register without prefix if no conflict exists
         if (!cliRegistry.has(command.name)) {
           cliRegistry.register({
@@ -114,10 +135,10 @@ export class CliPluginDiscovery {
           })
         }
       }
-      
+
       this.loadedPlugins.add(plugin.name)
       logger.debug(`Registered ${plugin.commands.length} CLI commands from plugin: ${plugin.name}`)
-      
+
     } catch (error) {
       logger.error(`Failed to register CLI commands for plugin ${plugin.name}:`, error)
     }
@@ -128,4 +149,4 @@ export class CliPluginDiscovery {
   }
 }
 
-export const pluginDiscovery = new CliPluginDiscovery()
\ No newline at end of file
+export const pluginDiscovery = new CliPluginDiscovery()
diff --git a/core/framework/server.ts b/core/framework/server.ts
index 135ca5bc..2e12fe45 100644
--- a/core/framework/server.ts
+++ b/core/framework/server.ts
@@ -469,6 +469,16 @@ export class FluxStackFramework {
         }
       }
 
+      // Mount plugin routes if they have a plugin property
+      for (const pluginName of loadOrder) {
+        const plugin = this.pluginRegistry.get(pluginName)!
+
+        if ((plugin as any).plugin) {
+          this.app.use((plugin as any).plugin)
+          logger.debug(`Plugin '${pluginName}' routes mounted`)
+        }
+      }
+
       // Call onServerStart hooks
       for (const pluginName of loadOrder) {
         const plugin = this.pluginRegistry.get(pluginName)!
diff --git a/core/plugins/dependency-manager.ts b/core/plugins/dependency-manager.ts
index 2169235e..92d64201 100644
--- a/core/plugins/dependency-manager.ts
+++ b/core/plugins/dependency-manager.ts
@@ -136,6 +136,8 @@ export class PluginDependencyManager {
 
   /**
    * Instalar dependências de plugins
+   * NOVA ESTRATÉGIA: Instala no node_modules local do plugin primeiro,
+   * com fallback para o projeto principal
    */
   async installPluginDependencies(resolutions: DependencyResolution[]): Promise<void> {
     if (!this.config.autoInstall) {
@@ -143,44 +145,109 @@ export class PluginDependencyManager {
       return
     }
 
-    const toInstall: PluginDependency[] = []
-    const conflicts: DependencyConflict[] = []
-
-    // Coletar todas as dependências e conflitos
+    // Instalar dependências para cada plugin individualmente
     for (const resolution of resolutions) {
-      toInstall.push(...resolution.dependencies)
-      conflicts.push(...resolution.conflicts)
-    }
+      if (resolution.dependencies.length === 0) continue
+
+      const pluginPath = this.findPluginDirectory(resolution.plugin)
+      if (!pluginPath) {
+        this.logger?.warn(`Não foi possível encontrar diretório do plugin '${resolution.plugin}'`)
+        continue
+      }
 
-    // Resolver conflitos primeiro
-    if (conflicts.length > 0) {
-      await this.resolveConflicts(conflicts)
+      this.logger?.debug(`📦 Instalando dependências localmente para plugin '${resolution.plugin}'`, {
+        plugin: resolution.plugin,
+        path: pluginPath,
+        dependencies: resolution.dependencies.length
+      })
+
+      try {
+        // Instalar APENAS no node_modules local do plugin
+        await this.installPluginDependenciesLocally(pluginPath, resolution.dependencies)
+
+        this.logger?.debug(`✅ Dependências do plugin '${resolution.plugin}' instaladas localmente`)
+      } catch (error) {
+        this.logger?.error(`❌ Erro ao instalar dependências do plugin '${resolution.plugin}'`, { error })
+        // Continuar com outros plugins
+      }
     }
+  }
+
+  /**
+   * Instalar dependências no diretório local do plugin
+   */
+  private async installPluginDependenciesLocally(pluginPath: string, dependencies: PluginDependency[]): Promise<void> {
+    if (dependencies.length === 0) return
+
+    const regularDeps = dependencies.filter(d => d.type === 'dependency')
+    const peerDeps = dependencies.filter(d => d.type === 'peerDependency' && !d.optional)
+
+    const allDeps = [...regularDeps, ...peerDeps]
+    if (allDeps.length === 0) return
 
-    // Filtrar dependências que já estão instaladas
-    const needsInstallation = toInstall.filter(dep => {
-      const installed = this.installedDependencies.get(dep.name)
-      return !installed || !this.isVersionCompatible(installed, dep.version)
+    // Verificar quais dependências já estão instaladas localmente
+    const toInstall = allDeps.filter(dep => {
+      const depPath = join(pluginPath, 'node_modules', dep.name, 'package.json')
+      if (!existsSync(depPath)) {
+        return true // Precisa instalar
+      }
+
+      try {
+        const installedPkg = JSON.parse(readFileSync(depPath, 'utf-8'))
+        const installedVersion = installedPkg.version
+
+        // Verificar se a versão é compatível
+        if (!this.isVersionCompatible(installedVersion, dep.version)) {
+          this.logger?.debug(`📦 Dependência '${dep.name}' está desatualizada (${installedVersion} → ${dep.version})`)
+          return true // Precisa atualizar
+        }
+
+        return false // Já está instalado corretamente
+      } catch (error) {
+        return true // Erro ao ler, melhor reinstalar
+      }
     })
 
-    if (needsInstallation.length === 0) {
-      this.logger?.debug('Todas as dependências de plugins já estão instaladas')
+    if (toInstall.length === 0) {
+      this.logger?.debug(`✅ Todas as dependências do plugin já estão instaladas`)
       return
     }
 
-    this.logger?.debug(`Instalando ${needsInstallation.length} dependências de plugins`, {
-      dependencies: needsInstallation.map(d => `${d.name}@${d.version}`)
-    })
+    const packages = toInstall.map(d => `${d.name}@${d.version}`).join(' ')
+    const command = this.getInstallCommand(packages, false)
+
+    this.logger?.debug(`🔧 Instalando ${toInstall.length} dependência(s): ${command}`, { cwd: pluginPath })
 
     try {
-      await this.installDependencies(needsInstallation)
-      this.logger?.debug('Dependências de plugins instaladas com sucesso')
+      execSync(command, {
+        cwd: pluginPath,
+        stdio: 'inherit'
+      })
+      this.logger?.debug(`✅ Pacotes instalados localmente em ${pluginPath}`)
     } catch (error) {
-      this.logger?.error('Erro ao instalar dependências de plugins', { error })
+      this.logger?.error(`❌ Falha ao instalar dependências localmente`, { error, pluginPath })
       throw error
     }
   }
 
+  /**
+   * Encontrar diretório de um plugin pelo nome
+   */
+  private findPluginDirectory(pluginName: string): string | null {
+    const possiblePaths = [
+      `plugins/${pluginName}`,
+      `core/plugins/built-in/${pluginName}`
+    ]
+
+    for (const path of possiblePaths) {
+      if (existsSync(path)) {
+        return resolve(path)
+      }
+    }
+
+    return null
+  }
+
   /**
    * Detectar conflitos de versão
    */
diff --git a/core/plugins/index.ts b/core/plugins/index.ts
index a01577e3..7d20353e 100644
--- a/core/plugins/index.ts
+++ b/core/plugins/index.ts
@@ -54,6 +54,10 @@ export {
 } from './manager'
 export type { PluginManagerConfig } from './manager'
 
+// Module resolver for plugins
+export { PluginModuleResolver } from './module-resolver'
+export type { ModuleResolverConfig } from './module-resolver'
+
 // Plugin executor
 export {
     PluginExecutor,
diff --git a/core/plugins/manager.ts b/core/plugins/manager.ts
index 5fb11fa3..4105453d 100644
--- a/core/plugins/manager.ts
+++ b/core/plugins/manager.ts
@@ -19,7 +19,7 @@ import type {
 
 type Plugin = FluxStack.Plugin
 import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger/index"
+import type { Logger } from "../utils/logger"
 import { PluginRegistry } from "./registry"
 import { createPluginUtils } from "./config"
 import { FluxStackError } from "../utils/errors"
@@ -422,6 +422,7 @@ export class PluginManager extends EventEmitter {
       // Try to use auto-generated registry for external plugins (if available from build)
       let externalResults: any[] = []
       try {
+        // @ts-expect-error - auto-registry is generated during build, may not exist in dev
         const autoRegistryModule = await import('./auto-registry')
         if (autoRegistryModule.discoveredPlugins && autoRegistryModule.registerDiscoveredPlugins) {
           this.logger.debug('🚀 Using auto-generated external plugins registry')
@@ -432,7 +433,7 @@ export class PluginManager extends EventEmitter {
           }))
         }
       } catch (error) {
-        this.logger.debug('Auto-generated external plugins registry not found, falling back to discovery', { error: error.message })
+        this.logger.debug('Auto-generated external plugins registry not found, falling back to discovery', { error: (error as Error).message })
 
         // Fallback to runtime discovery for external plugins
         this.logger.debug('Discovering external plugins in directory: plugins')
diff --git a/core/plugins/module-resolver.ts b/core/plugins/module-resolver.ts
new file mode 100644
index 00000000..5bd132b0
--- /dev/null
+++ b/core/plugins/module-resolver.ts
@@ -0,0 +1,216 @@
+/**
+ * Module Resolver para Plugins
+ * Implementa resolução em cascata: plugin local → projeto principal
+ */
+
+import { existsSync } from 'fs'
+import { join, resolve } from 'path'
+import type { Logger } from '../utils/logger'
+
+export interface ModuleResolverConfig {
+  projectRoot: string
+  logger?: Logger
+}
+
+export class PluginModuleResolver {
+  private config: ModuleResolverConfig
+  private logger?: Logger
+  private resolveCache: Map<string, string> = new Map()
+
+  constructor(config: ModuleResolverConfig) {
+    this.config = config
+    this.logger = config.logger
+  }
+
+  /**
+   * Resolve um módulo com estratégia em cascata:
+   * 1. node_modules local do plugin
+   * 2. node_modules do projeto principal
+   */
+  resolveModule(moduleName: string, pluginPath: string): string | null {
+    const cacheKey = `${pluginPath}::${moduleName}`
+
+    // Verificar cache
+    if (this.resolveCache.has(cacheKey)) {
+      return this.resolveCache.get(cacheKey)!
+    }
+
+    this.logger?.debug(`Resolvendo módulo '${moduleName}' para plugin em '${pluginPath}'`)
+
+    // 1. Tentar no node_modules local do plugin
+    const localPath = this.tryResolveLocal(moduleName, pluginPath)
+    if (localPath) {
+      this.logger?.debug(`✅ Módulo '${moduleName}' encontrado localmente: ${localPath}`)
+      this.resolveCache.set(cacheKey, localPath)
+      return localPath
+    }
+
+    // 2. Tentar no node_modules do projeto principal
+    const projectPath = this.tryResolveProject(moduleName)
+    if (projectPath) {
+      this.logger?.debug(`✅ Módulo '${moduleName}' encontrado no projeto: ${projectPath}`)
+      this.resolveCache.set(cacheKey, projectPath)
+      return projectPath
+    }
+
+    this.logger?.warn(`❌ Módulo '${moduleName}' não encontrado em nenhum contexto`)
+    return null
+  }
+
+  /**
+   * Tenta resolver no node_modules local do plugin
+   */
+  private tryResolveLocal(moduleName: string, pluginPath: string): string | null {
+    const pluginDir = resolve(pluginPath)
+    const localNodeModules = join(pluginDir, 'node_modules', moduleName)
+
+    if (existsSync(localNodeModules)) {
+      // Verificar se tem package.json para pegar o entry point
+      const packageJsonPath = join(localNodeModules, 'package.json')
+      if (existsSync(packageJsonPath)) {
+        try {
+          const pkg = require(packageJsonPath)
+          const entry = pkg.module || pkg.main || 'index.js'
+          const entryPath = join(localNodeModules, entry)
+
+          if (existsSync(entryPath)) {
+            return entryPath
+          }
+        } catch (error) {
+          this.logger?.debug(`Erro ao ler package.json de '${moduleName}'`, { error })
+        }
+      }
+
+      // Fallback: tentar index.js/index.ts
+      const indexJs = join(localNodeModules, 'index.js')
+      const indexTs = join(localNodeModules, 'index.ts')
+
+      if (existsSync(indexJs)) return indexJs
+      if (existsSync(indexTs)) return indexTs
+
+      return localNodeModules
+    }
+
+    return null
+  }
+
+  /**
+   * Tenta resolver no node_modules do projeto principal
+   */
+  private tryResolveProject(moduleName: string): string | null {
+    const projectNodeModules = join(this.config.projectRoot, 'node_modules', moduleName)
+
+    if (existsSync(projectNodeModules)) {
+      // Verificar se tem package.json para pegar o entry point
+      const packageJsonPath = join(projectNodeModules, 'package.json')
+      if (existsSync(packageJsonPath)) {
+        try {
+          const pkg = require(packageJsonPath)
+          const entry = pkg.module || pkg.main || 'index.js'
+          const entryPath = join(projectNodeModules, entry)
+
+          if (existsSync(entryPath)) {
+            return entryPath
+          }
+        } catch (error) {
+          this.logger?.debug(`Erro ao ler package.json de '${moduleName}'`, { error })
+        }
+      }
+
+      // Fallback: tentar index.js/index.ts
+      const indexJs = join(projectNodeModules, 'index.js')
+      const indexTs = join(projectNodeModules, 'index.ts')
+
+      if (existsSync(indexJs)) return indexJs
+      if (existsSync(indexTs)) return indexTs
+
+      return projectNodeModules
+    }
+
+    return null
+  }
+
+  /**
+   * Resolve sub-paths (ex: @noble/curves/ed25519)
+   */
+  resolveSubpath(moduleName: string, subpath: string, pluginPath: string): string | null {
+    const fullModule = `${moduleName}/${subpath}`
+    const cacheKey = `${pluginPath}::${fullModule}`
+
+    // Verificar cache
+    if (this.resolveCache.has(cacheKey)) {
+      return this.resolveCache.get(cacheKey)!
+    }
+
+    this.logger?.debug(`Resolvendo subpath '${fullModule}' para plugin em '${pluginPath}'`)
+
+    // 1. Tentar no node_modules local do plugin
+    const pluginDir = resolve(pluginPath)
+    const localPath = join(pluginDir, 'node_modules', fullModule)
+
+    if (this.existsWithExtension(localPath)) {
+      const resolvedLocal = this.findFileWithExtension(localPath)
+      if (resolvedLocal) {
+        this.logger?.debug(`✅ Subpath '${fullModule}' encontrado localmente: ${resolvedLocal}`)
+        this.resolveCache.set(cacheKey, resolvedLocal)
+        return resolvedLocal
+      }
+    }
+
+    // 2. Tentar no node_modules do projeto principal
+    const projectPath = join(this.config.projectRoot, 'node_modules', fullModule)
+
+    if (this.existsWithExtension(projectPath)) {
+      const resolvedProject = this.findFileWithExtension(projectPath)
+      if (resolvedProject) {
+        this.logger?.debug(`✅ Subpath '${fullModule}' encontrado no projeto: ${resolvedProject}`)
+        this.resolveCache.set(cacheKey, resolvedProject)
+        return resolvedProject
+      }
+    }
+
+    this.logger?.warn(`❌ Subpath '${fullModule}' não encontrado em nenhum contexto`)
+    return null
+  }
+
+  /**
+   * Verifica se arquivo existe com alguma extensão comum
+   */
+  private existsWithExtension(basePath: string): boolean {
+    const extensions = ['', '.js', '.ts', '.mjs', '.cjs', '.jsx', '.tsx', '/index.js', '/index.ts']
+    return extensions.some(ext => existsSync(basePath + ext))
+  }
+
+  /**
+   * Encontra arquivo com extensão
+   */
+  private findFileWithExtension(basePath: string): string | null {
+    const extensions = ['', '.js', '.ts', '.mjs', '.cjs', '.jsx', '.tsx', '/index.js', '/index.ts']
+
+    for (const ext of extensions) {
+      const fullPath = basePath + ext
+      if (existsSync(fullPath)) {
+        return fullPath
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Limpar cache
+   */
+  clearCache(): void {
+    this.resolveCache.clear()
+  }
+
+  /**
+   * Obter estatísticas
+   */
+  getStats() {
+    return {
+      cachedModules: this.resolveCache.size,
+      projectRoot: this.config.projectRoot
+    }
+  }
+}
diff --git a/core/plugins/registry.ts b/core/plugins/registry.ts
index d355ce87..bbbc1aa8 100644
--- a/core/plugins/registry.ts
+++ b/core/plugins/registry.ts
@@ -2,7 +2,7 @@ import type { FluxStack, PluginManifest, PluginLoadResult, PluginDiscoveryOption
 
 type FluxStackPlugin = FluxStack.Plugin
 import type { FluxStackConfig } from "../config/schema"
-import type { Logger } from "../utils/logger/index"
+import type { Logger } from "../utils/logger"
 import { FluxStackError } from "../utils/errors"
 import { PluginDependencyManager } from "./dependency-manager"
 import { readdir, readFile } from "fs/promises"
@@ -262,6 +262,33 @@ export class PluginRegistry {
       if (existsSync(manifestPath)) {
         const manifestContent = await readFile(manifestPath, 'utf-8')
         manifest = JSON.parse(manifestContent)
+      } else {
+        // Try package.json for npm plugins
+        const packagePath = join(pluginPath, 'package.json')
+        if (existsSync(packagePath)) {
+          try {
+            const packageContent = await readFile(packagePath, 'utf-8')
+            const packageJson = JSON.parse(packageContent)
+
+            if (packageJson.fluxstack) {
+              manifest = {
+                name: packageJson.name,
+                version: packageJson.version,
+                description: packageJson.description || '',
+                author: packageJson.author || '',
+                license: packageJson.license || '',
+                homepage: packageJson.homepage,
+                repository: packageJson.repository,
+                keywords: packageJson.keywords || [],
+                dependencies: packageJson.dependencies || {},
+                peerDependencies: packageJson.peerDependencies,
+                fluxstack: packageJson.fluxstack
+              }
+            }
+          } catch (error) {
+            this.logger?.warn(`Failed to parse package.json in '${pluginPath}'`, { error })
+          }
+        }
       }
 
       // Try to import the plugin
diff --git a/core/utils/logger/index.ts b/core/utils/logger/index.ts
index fd99251d..b23e80ad 100644
--- a/core/utils/logger/index.ts
+++ b/core/utils/logger/index.ts
@@ -23,6 +23,10 @@ export { clearColorCache } from './colors'
 export { clearCallerCache } from './stack-trace'
 export { clearLoggerCache } from './winston-logger'
 
+// Export Logger type from winston
+import type winston from 'winston'
+export type Logger = winston.Logger
+
 // Re-export banner utilities for custom banners
 export { displayStartupBanner, type StartupInfo } from './startup-banner'
 
diff --git a/fluxstack.config.ts b/fluxstack.config.ts
index 0d0e680d..a320748c 100644
--- a/fluxstack.config.ts
+++ b/fluxstack.config.ts
@@ -1,74 +1,261 @@
 /**
  * FluxStack Configuration
- * Enhanced configuration with comprehensive settings and environment support
- * Uses unified environment loader
+ * ✅ Using declarative config system with schema validation and type inference
+ * Laravel-inspired declarative configuration with full type safety
  */
 
 import type { FluxStackConfig } from './core/config/schema'
+import { defineConfig, config as configHelpers } from './core/utils/config-schema'
 import { env, helpers } from './core/utils/env'
 
 console.log(`🔧 Loading FluxStack config for ${env.NODE_ENV} environment`)
 
-// Main FluxStack configuration with dynamic env vars
+// ============================================================================
+// 📋 DECLARATIVE CONFIG SCHEMAS
+// ============================================================================
+
+/**
+ * Application Configuration Schema
+ */
+const appConfigSchema = {
+  name: configHelpers.string('FLUXSTACK_APP_NAME', 'FluxStack', true),
+  version: configHelpers.string('FLUXSTACK_APP_VERSION', '1.0.0', true),
+  description: configHelpers.string('FLUXSTACK_APP_DESCRIPTION', 'A FluxStack application')
+} as const
+
+/**
+ * CORS Configuration Schema
+ */
+const corsConfigSchema = {
+  origins: configHelpers.array('CORS_ORIGINS', ['http://localhost:3000', 'http://localhost:5173']),
+  methods: configHelpers.array('CORS_METHODS', ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS']),
+  headers: configHelpers.array('CORS_HEADERS', ['Content-Type', 'Authorization']),
+  credentials: configHelpers.boolean('CORS_CREDENTIALS', false),
+  maxAge: configHelpers.number('CORS_MAX_AGE', 86400)
+} as const
+
+/**
+ * Server Configuration Schema
+ */
+const serverConfigSchema = {
+  port: configHelpers.number('PORT', 3000, true),
+  host: configHelpers.string('HOST', 'localhost', true),
+  apiPrefix: configHelpers.string('API_PREFIX', '/api', true)
+} as const
+
+/**
+ * Client Proxy Configuration Schema
+ */
+const clientProxyConfigSchema = {
+  target: {
+    type: 'string' as const,
+    env: 'PROXY_TARGET',
+    default: helpers.getServerUrl(),
+    required: false
+  },
+  changeOrigin: configHelpers.boolean('PROXY_CHANGE_ORIGIN', true)
+} as const
+
+/**
+ * Client Build Configuration Schema
+ */
+const clientBuildConfigSchema = {
+  sourceMaps: configHelpers.boolean('CLIENT_SOURCEMAPS', helpers.isDevelopment()),
+  minify: configHelpers.boolean('CLIENT_MINIFY', helpers.isProduction()),
+  target: configHelpers.string('CLIENT_TARGET', 'esnext'),
+  outDir: configHelpers.string('CLIENT_OUTDIR', 'dist/client')
+} as const
+
+/**
+ * Client Configuration Schema
+ */
+const clientConfigSchema = {
+  port: configHelpers.number('VITE_PORT', 5173, true)
+} as const
+
+/**
+ * Build Optimization Configuration Schema
+ */
+const buildOptimizationConfigSchema = {
+  minify: configHelpers.boolean('BUILD_MINIFY', helpers.isProduction()),
+  treeshake: configHelpers.boolean('BUILD_TREESHAKE', helpers.isProduction()),
+  compress: configHelpers.boolean('BUILD_COMPRESS', helpers.isProduction()),
+  splitChunks: configHelpers.boolean('BUILD_SPLIT_CHUNKS', true),
+  bundleAnalyzer: configHelpers.boolean('BUILD_ANALYZER', helpers.isDevelopment())
+} as const
+
+/**
+ * Build Configuration Schema
+ */
+const buildConfigSchema = {
+  target: configHelpers.enum('BUILD_TARGET', ['bun', 'node', 'docker'] as const, 'bun'),
+  outDir: configHelpers.string('BUILD_OUTDIR', 'dist'),
+  sourceMaps: configHelpers.boolean('BUILD_SOURCEMAPS', !helpers.isProduction()),
+  minify: configHelpers.boolean('BUILD_MINIFY', helpers.isProduction()),
+  treeshake: configHelpers.boolean('BUILD_TREESHAKE', helpers.isProduction()),
+  clean: configHelpers.boolean('BUILD_CLEAN', true)
+} as const
+
+/**
+ * Plugins Configuration Schema
+ */
+const pluginsConfigSchema = {
+  enabled: configHelpers.array('FLUXSTACK_PLUGINS_ENABLED', ['logger', 'swagger', 'vite', 'cors', 'static-files', 'crypto-auth']),
+  disabled: configHelpers.array('FLUXSTACK_PLUGINS_DISABLED', [])
+} as const
+
+/**
+ * Logging Configuration Schema
+ */
+const loggingConfigSchema = {
+  level: configHelpers.enum('LOG_LEVEL', ['debug', 'info', 'warn', 'error'] as const, helpers.isDevelopment() ? 'debug' : 'info'),
+  format: configHelpers.enum('LOG_FORMAT', ['json', 'pretty'] as const, helpers.isDevelopment() ? 'pretty' : 'json')
+} as const
+
+/**
+ * Monitoring Metrics Configuration Schema
+ */
+const monitoringMetricsConfigSchema = {
+  enabled: configHelpers.boolean('ENABLE_METRICS', false),
+  collectInterval: configHelpers.number('METRICS_INTERVAL', 5000),
+  httpMetrics: configHelpers.boolean('HTTP_METRICS', true),
+  systemMetrics: configHelpers.boolean('SYSTEM_METRICS', true),
+  customMetrics: configHelpers.boolean('CUSTOM_METRICS', false)
+} as const
+
+/**
+ * Monitoring Profiling Configuration Schema
+ */
+const monitoringProfilingConfigSchema = {
+  enabled: configHelpers.boolean('PROFILING_ENABLED', false),
+  sampleRate: configHelpers.number('PROFILING_SAMPLE_RATE', 0.1),
+  memoryProfiling: configHelpers.boolean('MEMORY_PROFILING', false),
+  cpuProfiling: configHelpers.boolean('CPU_PROFILING', false)
+} as const
+
+/**
+ * Monitoring Configuration Schema
+ */
+const monitoringConfigSchema = {
+  enabled: configHelpers.boolean('ENABLE_MONITORING', false),
+  exporters: configHelpers.array('MONITORING_EXPORTERS', [])
+} as const
+
+/**
+ * Database Configuration Schema (Optional)
+ */
+const databaseConfigSchema = {
+  url: configHelpers.string('DATABASE_URL', ''),
+  host: configHelpers.string('DB_HOST', ''),
+  port: configHelpers.number('DB_PORT', 5432),
+  database: configHelpers.string('DB_NAME', ''),
+  user: configHelpers.string('DB_USER', ''),
+  password: configHelpers.string('DB_PASSWORD', ''),
+  ssl: configHelpers.boolean('DB_SSL', false),
+  poolSize: configHelpers.number('DB_POOL_SIZE', 10)
+} as const
+
+/**
+ * Auth Configuration Schema (Optional)
+ */
+const authConfigSchema = {
+  secret: configHelpers.string('JWT_SECRET', ''),
+  expiresIn: configHelpers.string('JWT_EXPIRES_IN', '24h'),
+  algorithm: configHelpers.string('JWT_ALGORITHM', 'HS256'),
+  issuer: configHelpers.string('JWT_ISSUER', '')
+} as const
+
+/**
+ * Email Configuration Schema (Optional)
+ */
+const emailConfigSchema = {
+  host: configHelpers.string('SMTP_HOST', ''),
+  port: configHelpers.number('SMTP_PORT', 587),
+  user: configHelpers.string('SMTP_USER', ''),
+  password: configHelpers.string('SMTP_PASSWORD', ''),
+  secure: configHelpers.boolean('SMTP_SECURE', false),
+  from: configHelpers.string('SMTP_FROM', '')
+} as const
+
+/**
+ * Storage Configuration Schema (Optional)
+ */
+const storageConfigSchema = {
+  uploadPath: configHelpers.string('UPLOAD_PATH', ''),
+  maxFileSize: configHelpers.number('MAX_FILE_SIZE', 10485760), // 10MB
+  allowedTypes: configHelpers.array('ALLOWED_FILE_TYPES', []),
+  provider: configHelpers.enum('STORAGE_PROVIDER', ['local', 's3', 'gcs'] as const, 'local')
+} as const
+
+// ============================================================================
+// ⚡ LOAD CONFIGURATIONS USING DECLARATIVE SYSTEM
+// ============================================================================
+
+const appConfig = defineConfig(appConfigSchema)
+const corsConfig = defineConfig(corsConfigSchema)
+const serverConfig = defineConfig(serverConfigSchema)
+const clientProxyConfig = defineConfig(clientProxyConfigSchema)
+const clientBuildConfig = defineConfig(clientBuildConfigSchema)
+const clientConfig = defineConfig(clientConfigSchema)
+const buildOptimizationConfig = defineConfig(buildOptimizationConfigSchema)
+const buildConfig = defineConfig(buildConfigSchema)
+const pluginsConfig = defineConfig(pluginsConfigSchema)
+const loggingConfig = defineConfig(loggingConfigSchema)
+const monitoringMetricsConfig = defineConfig(monitoringMetricsConfigSchema)
+const monitoringProfilingConfig = defineConfig(monitoringProfilingConfigSchema)
+const monitoringConfig = defineConfig(monitoringConfigSchema)
+
+// Optional configs (only load if env vars are present)
+const databaseConfig = (env.has('DATABASE_URL') || env.has('DATABASE_HOST'))
+  ? defineConfig(databaseConfigSchema)
+  : undefined
+
+const authConfig = env.has('JWT_SECRET')
+  ? defineConfig(authConfigSchema)
+  : undefined
+
+const emailConfig = env.has('SMTP_HOST')
+  ? defineConfig(emailConfigSchema)
+  : undefined
+
+const storageConfig = (env.has('UPLOAD_PATH') || env.has('STORAGE_PROVIDER'))
+  ? defineConfig(storageConfigSchema)
+  : undefined
+
+// ============================================================================
+// 🚀 MAIN FLUXSTACK CONFIGURATION
+// ============================================================================
+
 export const config: FluxStackConfig = {
   // Application metadata
-  app: {
-    name: env.FLUXSTACK_APP_NAME,        // Direto! (string)
-    version: env.FLUXSTACK_APP_VERSION,  // Direto! (string)
-    description: env.get('FLUXSTACK_APP_DESCRIPTION', 'A FluxStack application')
-  },
+  app: appConfig,
 
   // Server configuration
   server: {
-    port: env.PORT,                      // Direto! (number)
-    host: env.HOST,                      // Direto! (string)
-    apiPrefix: env.API_PREFIX,           // Direto! (string)
-    cors: {
-      origins: env.CORS_ORIGINS,           // Direto! (string[])
-      methods: env.get('CORS_METHODS', ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS']),
-      headers: env.get('CORS_HEADERS', ['Content-Type', 'Authorization']),
-      credentials: env.get('CORS_CREDENTIALS', false),  // boolean casting
-      maxAge: env.get('CORS_MAX_AGE', 86400)           // number casting
-    },
+    ...serverConfig,
+    cors: corsConfig,
     middleware: []
   },
 
   // Client configuration
   client: {
-    port: env.VITE_PORT,                 // Direto! (number)
-    proxy: {
-      target: helpers.getServerUrl(),    // Helper inteligente
-      changeOrigin: env.get('PROXY_CHANGE_ORIGIN', true)
-    },
-    build: {
-      sourceMaps: env.get('CLIENT_SOURCEMAPS', helpers.isDevelopment()),
-      target: env.get('CLIENT_TARGET', 'esnext'),
-      outDir: env.get('CLIENT_OUTDIR', 'dist/client')
-    }
+    ...clientConfig,
+    proxy: clientProxyConfig,
+    build: clientBuildConfig
   },
 
   // Build configuration
   build: {
-    target: env.get('BUILD_TARGET', 'bun'),   // string casting
-    outDir: env.get('BUILD_OUTDIR', 'dist'),  // string
-    optimization: {
-      treeshake: env.get('BUILD_TREESHAKE', helpers.isProduction()),
-      compress: env.get('BUILD_COMPRESS', helpers.isProduction()),
-      splitChunks: env.get('BUILD_SPLIT_CHUNKS', true),
-      bundleAnalyzer: env.get('BUILD_ANALYZER', helpers.isDevelopment())
-    },
-    sourceMaps: env.get('BUILD_SOURCEMAPS', !helpers.isProduction()),
-    clean: env.get('BUILD_CLEAN', true)
+    ...buildConfig,
+    optimization: buildOptimizationConfig
   },
 
   // Plugin configuration
   plugins: {
-    enabled: env.get('FLUXSTACK_PLUGINS_ENABLED', ['logger', 'swagger', 'vite', 'cors', 'static-files', 'crypto-auth']),
-    disabled: env.get('FLUXSTACK_PLUGINS_DISABLED', []),
+    ...pluginsConfig,
     config: {
-      // Plugin-specific configurations can be added here
       logger: {
-        // Logger plugin config will be handled by logging section
+        // Logger plugin config handled by logging section
       },
       swagger: {
         title: env.get('SWAGGER_TITLE', 'FluxStack API'),
@@ -81,95 +268,39 @@ export const config: FluxStackConfig = {
         cacheMaxAge: env.get('STATIC_CACHE_MAX_AGE', 31536000), // 1 year
         enableUploads: env.get('STATIC_ENABLE_UPLOADS', true),
         enablePublic: env.get('STATIC_ENABLE_PUBLIC', true)
-      },
-      'crypto-auth': {
-        enabled: env.get('CRYPTO_AUTH_ENABLED', true),
-        sessionTimeout: env.get('CRYPTO_AUTH_SESSION_TIMEOUT', 1800000), // 30 minutos
-        maxTimeDrift: env.get('CRYPTO_AUTH_MAX_TIME_DRIFT', 300000), // 5 minutos
-        adminKeys: env.get('CRYPTO_AUTH_ADMIN_KEYS', []),
-        protectedRoutes: env.get('CRYPTO_AUTH_PROTECTED_ROUTES', ['/api/admin/*', '/api/protected/*']),
-        publicRoutes: env.get('CRYPTO_AUTH_PUBLIC_ROUTES', ['/api/auth/*', '/api/health', '/api/docs']),
-        enableMetrics: env.get('CRYPTO_AUTH_ENABLE_METRICS', true)
       }
+      // ✅ crypto-auth manages its own configuration
+      // See: plugins/crypto-auth/config/index.ts
     }
   },
 
   // Logging configuration
   logging: {
-    level: env.LOG_LEVEL as any,         // Direto! (com smart default)
-    format: env.get('LOG_FORMAT', helpers.isDevelopment() ? 'pretty' : 'json'),
+    ...loggingConfig,
     transports: [
       {
         type: 'console' as const,
-        level: env.LOG_LEVEL as any,     // Direto! (com smart default)
-        format: env.get('LOG_FORMAT', helpers.isDevelopment() ? 'pretty' : 'json')
+        level: loggingConfig.level,
+        format: loggingConfig.format
       }
     ]
   },
 
   // Monitoring configuration
   monitoring: {
-    enabled: env.ENABLE_MONITORING,      // Direto! (boolean)
-    metrics: {
-      enabled: env.ENABLE_METRICS,       // Direto! (boolean)
-      collectInterval: env.get('METRICS_INTERVAL', 5000),  // number casting
-      httpMetrics: env.get('HTTP_METRICS', true),
-      systemMetrics: env.get('SYSTEM_METRICS', true),
-      customMetrics: env.get('CUSTOM_METRICS', false)
-    },
-    profiling: {
-      enabled: env.get('PROFILING_ENABLED', false),
-      sampleRate: env.get('PROFILING_SAMPLE_RATE', 0.1),   // number casting
-      memoryProfiling: env.get('MEMORY_PROFILING', false),
-      cpuProfiling: env.get('CPU_PROFILING', false)
-    },
-    exporters: env.get('MONITORING_EXPORTERS', [])         // array casting
+    ...monitoringConfig,
+    metrics: monitoringMetricsConfig,
+    profiling: monitoringProfilingConfig
   },
 
-  // Optional database configuration
-  ...(env.has('DATABASE_URL') || env.has('DATABASE_HOST') ? {
-    database: {
-      url: env.DATABASE_URL,               // Direto! (string)
-      host: env.DB_HOST,                   // Direto! (string)
-      port: env.DB_PORT,                   // Direto! (number)
-      database: env.DB_NAME,               // Direto! (string)
-      user: env.DB_USER,                   // Direto! (string)
-      password: env.DB_PASSWORD,           // Direto! (string)
-      ssl: env.DB_SSL,                     // Direto! (boolean)
-      poolSize: env.get('DB_POOL_SIZE', 10)  // number casting
-    }
-  } : {}),
-
-  // Optional authentication configuration
-  ...(env.has('JWT_SECRET') ? {
-    auth: {
-      secret: env.JWT_SECRET,              // Direto! (string)
-      expiresIn: env.get('JWT_EXPIRES_IN', '24h'),
-      algorithm: env.get('JWT_ALGORITHM', 'HS256'),
-      issuer: env.get('JWT_ISSUER')
-    }
-  } : {}),
-
-  // Optional email configuration
-  ...(env.has('SMTP_HOST') ? {
-    email: {
-      host: env.SMTP_HOST,                 // Direto! (string)
-      port: env.SMTP_PORT,                 // Direto! (number)
-      user: env.SMTP_USER,                 // Direto! (string)
-      password: env.SMTP_PASSWORD,         // Direto! (string)
-      secure: env.SMTP_SECURE,             // Direto! (boolean)
-      from: env.get('SMTP_FROM')
-    }
-  } : {}),
-
-  // Optional storage configuration
-  ...(env.has('UPLOAD_PATH') || env.has('STORAGE_PROVIDER') ? {
+  // Optional configurations (only included if env vars are set)
+  ...(databaseConfig ? { database: databaseConfig } : {}),
+  ...(authConfig ? { auth: authConfig } : {}),
+  ...(emailConfig ? { email: emailConfig } : {}),
+  ...(storageConfig ? {
     storage: {
-      uploadPath: env.get('UPLOAD_PATH'),
-      maxFileSize: env.get('MAX_FILE_SIZE', 10485760),  // 10MB default
-      allowedTypes: env.get('ALLOWED_FILE_TYPES', []),  // array casting
-      provider: env.get('STORAGE_PROVIDER', 'local'),
-      config: env.get('STORAGE_CONFIG', {})             // object casting
+      ...storageConfig,
+      config: env.get('STORAGE_CONFIG', {})
     }
   } : {}),
 
@@ -192,6 +323,7 @@ export const config: FluxStackConfig = {
         proxy: { target: 'http://localhost:3000' },
         build: {
           sourceMaps: true,
+          minify: false,
           target: 'es2020',
           outDir: 'dist'
         }
@@ -200,12 +332,15 @@ export const config: FluxStackConfig = {
         target: 'bun',
         outDir: 'dist',
         optimization: {
+          minify: false,
           compress: false,
           treeshake: false,
           splitChunks: false,
           bundleAnalyzer: false
         },
         sourceMaps: true,
+        minify: false,
+        treeshake: false,
         clean: true
       },
       monitoring: {
@@ -243,6 +378,7 @@ export const config: FluxStackConfig = {
         proxy: { target: 'http://localhost:3000' },
         build: {
           sourceMaps: false,
+          minify: true,
           target: 'es2020',
           outDir: 'dist'
         }
@@ -251,12 +387,15 @@ export const config: FluxStackConfig = {
         target: 'bun',
         outDir: 'dist',
         optimization: {
+          minify: true,
           treeshake: false,
           compress: false,
           splitChunks: false,
           bundleAnalyzer: false
         },
         sourceMaps: false,
+        minify: true,
+        treeshake: false,
         clean: true
       },
       monitoring: {
@@ -300,7 +439,7 @@ export const config: FluxStackConfig = {
       client: {
         port: 0, // Use random available port
         proxy: { target: 'http://localhost:3000' },
-        build: { sourceMaps: true, target: 'es2020', outDir: 'dist' }
+        build: { sourceMaps: true, minify: false, target: 'es2020', outDir: 'dist' }
       },
       monitoring: {
         enabled: false,
diff --git a/package.json b/package.json
index bc4b23e7..b2e22db9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "create-fluxstack",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "⚡ Revolutionary full-stack TypeScript framework with Declarative Config System, Elysia + React + Bun",
   "keywords": [
     "framework",
@@ -59,6 +59,8 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.30.1",
+    "@noble/curves": "1.2.0",
+    "@noble/hashes": "1.3.2",
     "@tailwindcss/vite": "^4.1.13",
     "@testing-library/jest-dom": "^6.6.4",
     "@testing-library/react": "^16.3.0",
@@ -86,8 +88,6 @@
   "dependencies": {
     "@elysiajs/eden": "^1.3.2",
     "@elysiajs/swagger": "^1.3.1",
-    "@noble/curves": "^1.2.0",
-    "@noble/hashes": "^1.3.2",
     "@types/http-proxy-middleware": "^1.0.0",
     "@types/ws": "^8.18.1",
     "@vitejs/plugin-react": "^4.6.0",
diff --git a/plugins/crypto-auth/README.md b/plugins/crypto-auth/README.md
index adbf0ad7..4bdfedc9 100644
--- a/plugins/crypto-auth/README.md
+++ b/plugins/crypto-auth/README.md
@@ -1,238 +1,788 @@
-# FluxStack Crypto Auth Plugin
+# 🔐 FluxStack Crypto Auth Plugin
 
-Plugin de autenticação criptográfica baseado em Ed25519 para FluxStack.
+Sistema de autenticação baseado em criptografia **Ed25519** para FluxStack. Autenticação stateless sem sessões, usando assinaturas criptográficas.
 
-## Características
+## 📋 Índice
 
-- 🔐 **Zero-friction auth** - Sem cadastros, senhas ou emails
-- ✅ **Criptografia Ed25519** - Assinatura criptográfica de todas as requisições
-- 🌐 **Cross-platform** - Funciona em qualquer ambiente JavaScript
-- 💾 **Stateless backend** - Não precisa de banco para autenticação
-- 🎨 **Componentes React** - Componentes prontos para uso
-- ⚡ **Integração FluxStack** - Plugin nativo do FluxStack
+- [O Que É](#-o-que-é)
+- [Como Funciona](#-como-funciona)
+- [Instalação](#-instalação)
+- [Configuração](#️-configuração)
+- [Uso Básico](#-uso-básico)
+- [CLI Commands](#-cli-commands)
+- [Middlewares Disponíveis](#-middlewares-disponíveis)
+- [Helpers e Utilitários](#-helpers-e-utilitários)
+- [Fluxo de Autenticação](#-fluxo-de-autenticação)
+- [Segurança](#-segurança)
+- [Troubleshooting](#-troubleshooting)
 
-## Instalação
+---
 
-```bash
-# O plugin já está incluído na pasta plugins/
-# Apenas habilite no fluxstack.config.ts
+## 🎯 O Que É
+
+**Crypto Auth** é um plugin de autenticação que usa **assinaturas digitais Ed25519** ao invés de sessões tradicionais.
+
+### ✨ Principais Características
+
+- ✅ **Stateless**: Sem sessões, sem armazenamento de tokens
+- ✅ **Zero Trust**: Cada requisição é validada independentemente
+- ✅ **Ed25519**: Criptografia de curva elíptica (rápida e segura)
+- ✅ **Anti-Replay**: Proteção contra replay attacks com timestamps e nonces
+- ✅ **Admin Support**: Sistema de permissões com chaves administrativas
+- ✅ **TypeScript**: Totalmente tipado
+- ✅ **CLI Integration**: Geração automática de rotas protegidas
+
+### 🔄 Diferenças vs. Auth Tradicional
+
+| Característica | Auth Tradicional | Crypto Auth |
+|----------------|------------------|-------------|
+| **Armazenamento** | Sessões no servidor | Nenhum |
+| **Escalabilidade** | Limitada (sessões) | Infinita (stateless) |
+| **Segurança** | Token JWT ou session | Assinatura Ed25519 |
+| **Chave privada** | Armazenada no servidor | **NUNCA** sai do cliente |
+| **Performance** | Depende do DB/cache | Ultra-rápida (validação local) |
+
+---
+
+## 🔬 Como Funciona
+
+### 1. **Cliente Gera Par de Chaves (Uma Vez)**
+
+```typescript
+// No navegador (usando TweetNaCl ou similar)
+const keypair = nacl.sign.keyPair()
+
+// Armazenar no localStorage (chave privada NUNCA sai do navegador)
+localStorage.setItem('privateKey', toHex(keypair.secretKey))
+localStorage.setItem('publicKey', toHex(keypair.publicKey))
 ```
 
-## Configuração
+### 2. **Cliente Assina Cada Requisição**
 
-No seu `fluxstack.config.ts`:
+```typescript
+// Para cada request
+const timestamp = Date.now()
+const nonce = generateRandomNonce()
+const message = `${timestamp}:${nonce}:${requestBody}`
+
+// Assinar com chave privada
+const signature = nacl.sign.detached(message, privateKey)
+
+// Enviar headers
+headers = {
+  'x-public-key': publicKeyHex,
+  'x-timestamp': timestamp,
+  'x-nonce': nonce,
+  'x-signature': toHex(signature)
+}
+```
+
+### 3. **Servidor Valida Assinatura**
+
+```typescript
+// Plugin valida automaticamente
+const isValid = nacl.sign.detached.verify(
+  message,
+  signature,
+  publicKey
+)
+
+if (!isValid) {
+  throw new Error('Invalid signature')
+}
+
+// Verificar timestamp (previne replay attacks)
+if (Math.abs(Date.now() - timestamp) > maxTimeDrift) {
+  throw new Error('Timestamp expired')
+}
+```
+
+### 4. **Sem Armazenamento de Estado**
+
+- ✅ Servidor valida usando **apenas** a chave pública enviada
+- ✅ Nenhuma sessão ou token armazenado
+- ✅ Cada requisição é independente
+
+---
+
+## 📦 Instalação
+
+O plugin já vem incluído no FluxStack. Para habilitá-lo:
+
+### 1. **Adicionar ao `fluxstack.config.ts`**
 
 ```typescript
-export const config: FluxStackConfig = {
-  // ... outras configurações
-  
+import { cryptoAuthPlugin } from './plugins/crypto-auth'
+
+export default defineConfig({
   plugins: {
-    enabled: ['crypto-auth'],
+    enabled: [
+      cryptoAuthPlugin
+    ],
     config: {
       'crypto-auth': {
         enabled: true,
-        sessionTimeout: 1800000, // 30 minutos
         maxTimeDrift: 300000, // 5 minutos
         adminKeys: [
-          'sua_chave_publica_admin_aqui'
-        ],
-        protectedRoutes: [
-          '/api/admin/*',
-          '/api/protected/*'
-        ],
-        publicRoutes: [
-          '/api/auth/*',
-          '/api/health',
-          '/api/docs'
+          'a1b2c3d4e5f6...', // Chaves públicas de admins (hex 64 chars)
+          'f6e5d4c3b2a1...'
         ],
         enableMetrics: true
       }
     }
   }
-}
+})
 ```
 
-## Uso no Frontend
+### 2. **Variáveis de Ambiente (Opcional)**
 
-### 1. Configurar o Provider
+```bash
+# .env
+CRYPTO_AUTH_ENABLED=true
+CRYPTO_AUTH_MAX_TIME_DRIFT=300000
+CRYPTO_AUTH_ADMIN_KEYS=a1b2c3d4e5f6...,f6e5d4c3b2a1...
+CRYPTO_AUTH_ENABLE_METRICS=true
+```
 
-```tsx
-import React from 'react'
-import { AuthProvider } from '@/plugins/crypto-auth/client'
+---
 
-function App() {
-  return (
-    <AuthProvider
-      config={{
-        apiBaseUrl: 'http://localhost:3000',
-        storage: 'localStorage'
-      }}
-      onAuthChange={(isAuth, session) => {
-        console.log('Auth changed:', isAuth, session)
-      }}
-    >
-      <YourApp />
-    </AuthProvider>
-  )
+## ⚙️ Configuração
+
+### Schema de Configuração
+
+```typescript
+{
+  enabled: boolean              // Habilitar/desabilitar plugin
+  maxTimeDrift: number          // Máximo drift de tempo (ms) - previne replay
+  adminKeys: string[]           // Chaves públicas de administradores
+  enableMetrics: boolean        // Habilitar logs de métricas
 }
 ```
 
-### 2. Usar o Hook de Autenticação
-
-```tsx
-import React from 'react'
-import { useAuth } from '@/plugins/crypto-auth/client'
-
-function Dashboard() {
-  const { 
-    isAuthenticated, 
-    isAdmin, 
-    permissions, 
-    login, 
-    logout,
-    client 
-  } = useAuth()
-
-  const handleApiCall = async () => {
-    try {
-      const response = await client.fetch('/api/protected/data')
-      const data = await response.json()
-      console.log(data)
-    } catch (error) {
-      console.error('Erro na API:', error)
-    }
-  }
+### Valores Padrão
 
-  if (!isAuthenticated) {
-    return <button onClick={login}>Entrar</button>
-  }
-
-  return (
-    <div>
-      <h1>Dashboard {isAdmin && '(Admin)'}</h1>
-      <p>Permissões: {permissions.join(', ')}</p>
-      <button onClick={handleApiCall}>Chamar API</button>
-      <button onClick={logout}>Sair</button>
-    </div>
-  )
+```typescript
+{
+  enabled: true,
+  maxTimeDrift: 300000,    // 5 minutos
+  adminKeys: [],
+  enableMetrics: true
 }
 ```
 
-### 3. Componentes Prontos
-
-```tsx
-import React from 'react'
-import { 
-  LoginButton, 
-  ProtectedRoute, 
-  SessionInfo 
-} from '@/plugins/crypto-auth/client'
-
-function MyApp() {
-  return (
-    <div>
-      {/* Botão de login/logout */}
-      <LoginButton 
-        onLogin={(session) => console.log('Logado:', session)}
-        onLogout={() => console.log('Deslogado')}
-        showPermissions={true}
-      />
-
-      {/* Rota protegida */}
-      <ProtectedRoute requireAdmin={true}>
-        <AdminPanel />
-      </ProtectedRoute>
-
-      {/* Informações da sessão */}
-      <SessionInfo 
-        showPrivateKey={false}
-        compact={true}
-      />
-    </div>
+---
+
+## 🚀 Uso Básico
+
+### Opção 1: CLI (Recomendado)
+
+```bash
+# Criar rota com auth obrigatória
+bun flux crypto-auth:make:route users
+
+# Criar rota admin-only
+bun flux crypto-auth:make:route admin-panel --auth admin
+
+# Criar rota com auth opcional
+bun flux crypto-auth:make:route blog --auth optional
+
+# Criar rota pública
+bun flux crypto-auth:make:route public-api --auth public
+```
+
+### Opção 2: Manual
+
+```typescript
+// app/server/routes/users.routes.ts
+import { Elysia, t } from 'elysia'
+import { cryptoAuthRequired, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+export const usersRoutes = new Elysia({ prefix: '/users' })
+
+  // ========================================
+  // 🔒 ROTAS PROTEGIDAS
+  // ========================================
+  .guard({}, (app) =>
+    app.use(cryptoAuthRequired())
+
+      .get('/', ({ request }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          message: 'Lista de usuários',
+          authenticatedAs: user.publicKey.substring(0, 8) + '...',
+          isAdmin: user.isAdmin
+        }
+      })
+
+      .post('/', ({ request, body }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          message: 'Usuário criado',
+          createdBy: user.publicKey.substring(0, 8) + '...'
+        }
+      }, {
+        body: t.Object({
+          name: t.String(),
+          email: t.String()
+        })
+      })
   )
-}
 ```
 
-### 4. HOC para Proteção
+### Registrar Rotas
 
-```tsx
-import { withAuth } from '@/plugins/crypto-auth/client'
+```typescript
+// app/server/routes/index.ts
+import { usersRoutes } from './users.routes'
 
-const AdminComponent = () => <div>Área Admin</div>
+export const apiRoutes = new Elysia({ prefix: '/api' })
+  .use(usersRoutes)
+```
 
-// Proteger componente
-const ProtectedAdmin = withAuth(AdminComponent, {
-  requireAdmin: true,
-  requiredPermissions: ['admin']
-})
+---
+
+## 🎛️ CLI Commands
+
+### `crypto-auth:make:route`
+
+Gera arquivos de rotas com proteção crypto-auth automaticamente.
+
+#### **Sintaxe**
+
+```bash
+bun flux crypto-auth:make:route <name> [options]
 ```
 
-## Uso no Backend
+#### **Argumentos**
 
-O plugin automaticamente:
+- `name` - Nome da rota (ex: posts, users, admin)
 
-- Registra rotas de autenticação em `/api/auth/*`
-- Aplica middleware de autenticação nas rotas protegidas
-- Valida assinaturas Ed25519 em cada requisição
-- Gerencia sessões em memória
+#### **Opções**
+
+- `--auth, -a` - Tipo de autenticação (required, admin, optional, public)
+- `--output, -o` - Diretório de saída (padrão: app/server/routes)
+- `--force, -f` - Sobrescrever arquivo existente
+
+#### **Exemplos**
+
+```bash
+# Rota com auth obrigatória
+bun flux crypto-auth:make:route posts
+
+# Rota admin-only com output customizado
+bun flux crypto-auth:make:route admin --auth admin --output src/routes
+
+# Forçar sobrescrita
+bun flux crypto-auth:make:route users --force
+```
 
-### Rotas Automáticas
+#### **Templates Gerados**
 
-- `POST /api/auth/session/init` - Inicializar sessão
-- `POST /api/auth/session/validate` - Validar sessão
-- `GET /api/auth/session/info` - Informações da sessão
-- `POST /api/auth/session/logout` - Encerrar sessão
+| Tipo | Descrição | Rotas Geradas |
+|------|-----------|---------------|
+| `required` | Auth obrigatória | GET, POST, PUT, DELETE (CRUD completo) |
+| `admin` | Apenas admins | GET, POST, DELETE |
+| `optional` | Auth opcional | GET (lista), GET (detalhes com conteúdo extra) |
+| `public` | Sem auth | GET (lista), GET (detalhes) |
 
-### Acessar Usuário nas Rotas
+---
+
+## 🛡️ Middlewares Disponíveis
+
+### 1. `cryptoAuthRequired()`
+
+Autenticação **obrigatória**. Bloqueia requisições não autenticadas.
+
+```typescript
+import { cryptoAuthRequired, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+.guard({}, (app) =>
+  app.use(cryptoAuthRequired())
+    .get('/protected', ({ request }) => {
+      const user = getCryptoAuthUser(request)!  // ✅ Sempre existe
+      return { user }
+    })
+)
+```
+
+**Comportamento:**
+- ✅ Requisição autenticada → Prossegue
+- ❌ Requisição não autenticada → `401 Unauthorized`
+
+---
+
+### 2. `cryptoAuthAdmin()`
+
+Apenas **administradores**. Valida se a chave pública está em `adminKeys`.
 
 ```typescript
-// Em suas rotas FluxStack
-app.get('/api/protected/data', ({ user }) => {
-  // user estará disponível se autenticado
+import { cryptoAuthAdmin, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+.guard({}, (app) =>
+  app.use(cryptoAuthAdmin())
+    .delete('/delete/:id', ({ request }) => {
+      const user = getCryptoAuthUser(request)!  // ✅ Sempre admin
+      return { message: 'Deletado' }
+    })
+)
+```
+
+**Comportamento:**
+- ✅ Chave pública está em `adminKeys` → Prossegue
+- ❌ Não é admin → `403 Forbidden`
+- ❌ Não autenticado → `401 Unauthorized`
+
+---
+
+### 3. `cryptoAuthOptional()`
+
+Autenticação **opcional**. Não bloqueia, mas identifica usuários autenticados.
+
+```typescript
+import { cryptoAuthOptional, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+.guard({}, (app) =>
+  app.use(cryptoAuthOptional())
+    .get('/feed', ({ request }) => {
+      const user = getCryptoAuthUser(request)  // ⚠️ Pode ser null
+
+      if (user) {
+        return {
+          message: 'Feed personalizado',
+          recommendations: [...],
+          user: user.publicKey.substring(0, 8) + '...'
+        }
+      }
+
+      return {
+        message: 'Feed público',
+        trending: [...]
+      }
+    })
+)
+```
+
+**Comportamento:**
+- ✅ Requisição autenticada → `user` disponível
+- ✅ Requisição não autenticada → `user = null`, requisição prossegue
+
+---
+
+### 4. `cryptoAuthPermissions(permissions: string[])`
+
+Valida **permissões customizadas**.
+
+```typescript
+import { cryptoAuthPermissions, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+.guard({}, (app) =>
+  app.use(cryptoAuthPermissions(['write', 'delete']))
+    .put('/edit/:id', ({ request }) => {
+      const user = getCryptoAuthUser(request)!  // ✅ Tem as permissões
+      return { message: 'Editado' }
+    })
+)
+```
+
+**Comportamento:**
+- ✅ Usuário tem todas as permissões → Prossegue
+- ❌ Falta alguma permissão → `403 Forbidden`
+
+> **Nota**: Sistema de permissões requer extensão customizada. Por padrão, apenas `isAdmin` é verificado.
+
+---
+
+## 🔧 Helpers e Utilitários
+
+### `getCryptoAuthUser(request)`
+
+Retorna o usuário autenticado ou `null`.
+
+```typescript
+import { getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+.get('/profile', ({ request }) => {
+  const user = getCryptoAuthUser(request)
+
   if (!user) {
-    return { error: 'Não autenticado' }
+    return { error: 'Not authenticated' }
   }
-  
+
   return {
-    message: 'Dados protegidos',
-    user: {
-      sessionId: user.sessionId,
-      isAdmin: user.isAdmin,
-      permissions: user.permissions
-    }
+    publicKey: user.publicKey,
+    isAdmin: user.isAdmin
   }
 })
 ```
 
-## Como Funciona
+**Retorno:**
+```typescript
+{
+  publicKey: string    // Chave pública do usuário (hex)
+  isAdmin: boolean     // Se é administrador
+} | null
+```
 
-1. **Cliente gera** par de chaves Ed25519 automaticamente
-2. **Session ID** = chave pública (64 chars hex)
-3. **Todas as requisições** são assinadas com a chave privada
-4. **Backend valida** a assinatura Ed25519 em cada request
-5. **Admin access** via chaves públicas autorizadas
+---
 
-## Segurança
+### `isCryptoAuthAuthenticated(request)`
 
-- ✅ Assinatura Ed25519 em todas as requisições
-- ✅ Nonce para prevenir replay attacks  
-- ✅ Validação de timestamp (5 min máximo)
-- ✅ Timeout de sessões (30 min padrão)
-- ✅ Chaves privadas nunca saem do cliente
-- ✅ Stateless - sem dependência de banco de dados
+Verifica se a requisição está autenticada.
 
-## Desenvolvimento
+```typescript
+import { isCryptoAuthAuthenticated } from '@/plugins/crypto-auth/server'
+
+.get('/status', ({ request }) => {
+  const isAuth = isCryptoAuthAuthenticated(request)
+
+  return {
+    authenticated: isAuth,
+    message: isAuth ? 'Você está logado' : 'Você não está logado'
+  }
+})
+```
+
+**Retorno:** `boolean`
+
+---
+
+### `isCryptoAuthAdmin(request)`
+
+Verifica se o usuário é administrador.
+
+```typescript
+import { isCryptoAuthAdmin } from '@/plugins/crypto-auth/server'
+
+.get('/admin-check', ({ request }) => {
+  const isAdmin = isCryptoAuthAdmin(request)
+
+  return {
+    isAdmin,
+    access: isAdmin ? 'granted' : 'denied'
+  }
+})
+```
+
+**Retorno:** `boolean`
+
+---
+
+### `hasCryptoAuthPermission(request, permission)`
+
+Verifica se o usuário tem uma permissão específica.
+
+```typescript
+import { hasCryptoAuthPermission } from '@/plugins/crypto-auth/server'
+
+.get('/can-delete', ({ request }) => {
+  const canDelete = hasCryptoAuthPermission(request, 'delete')
+
+  return { canDelete }
+})
+```
+
+**Retorno:** `boolean`
+
+---
+
+## 🔄 Fluxo de Autenticação
+
+### Diagrama Completo
+
+```
+┌─────────────┐                                    ┌─────────────┐
+│   Cliente   │                                    │   Servidor  │
+│  (Browser)  │                                    │  (Elysia)   │
+└──────┬──────┘                                    └──────┬──────┘
+       │                                                  │
+       │ 1. Gera par de chaves Ed25519 (uma vez)        │
+       │    privateKey, publicKey                        │
+       │    localStorage.setItem(...)                    │
+       │                                                  │
+       │ 2. Para cada request:                           │
+       │    - timestamp = Date.now()                     │
+       │    - nonce = random()                           │
+       │    - message = `${timestamp}:${nonce}:${body}`  │
+       │    - signature = sign(message, privateKey)      │
+       │                                                  │
+       │ 3. Envia request com headers                    │
+       │────────────────────────────────────────────────>│
+       │    x-public-key: <publicKey>                    │
+       │    x-timestamp: <timestamp>                     │
+       │    x-nonce: <nonce>                             │
+       │    x-signature: <signature>                     │
+       │                                                  │
+       │                                                  │ 4. Middleware valida:
+       │                                                  │    - Reconstrói message
+       │                                                  │    - verify(message, signature, publicKey)
+       │                                                  │    - Verifica timestamp
+       │                                                  │    - Verifica se é admin (se necessário)
+       │                                                  │
+       │ 5a. ✅ Válido                                   │
+       │<────────────────────────────────────────────────│
+       │    200 OK { data: ... }                         │
+       │                                                  │
+       │ 5b. ❌ Inválido                                 │
+       │<────────────────────────────────────────────────│
+       │    401 Unauthorized { error: ... }              │
+       │                                                  │
+```
+
+---
+
+## 🔒 Segurança
+
+### ✅ Proteções Implementadas
+
+1. **Anti-Replay Attacks**
+   - Timestamp validation (maxTimeDrift)
+   - Nonce único por requisição
+   - Assinatura inclui timestamp + nonce
+
+2. **Stateless Security**
+   - Sem sessões (não há o que roubar)
+   - Chave privada **NUNCA** sai do cliente
+   - Validação criptográfica a cada request
+
+3. **Admin Protection**
+   - Lista whitelist de chaves públicas administrativas
+   - Validação dupla (auth + isAdmin)
+
+4. **Type Safety**
+   - TypeScript completo
+   - Validação de schemas com TypeBox
+
+### ⚠️ Considerações de Segurança
+
+1. **HTTPS Obrigatório**
+   ```typescript
+   // Sempre use HTTPS em produção
+   if (process.env.NODE_ENV === 'production' && !request.url.startsWith('https')) {
+     throw new Error('HTTPS required')
+   }
+   ```
+
+2. **Rotação de Chaves**
+   ```typescript
+   // Cliente deve permitir rotação de chaves
+   function rotateKeys() {
+     const newKeypair = nacl.sign.keyPair()
+     // Migrar dados assinados com chave antiga
+     // Atualizar localStorage
+   }
+   ```
+
+3. **Rate Limiting**
+   ```typescript
+   // Adicionar rate limiting para prevenir brute force
+   import { rateLimit } from '@/plugins/rate-limit'
+
+   .use(rateLimit({ max: 100, window: '15m' }))
+   .use(cryptoAuthRequired())
+   ```
+
+4. **Admin Keys em Ambiente**
+   ```bash
+   # .env
+   CRYPTO_AUTH_ADMIN_KEYS=key1,key2,key3
+   ```
+
+---
+
+## 🧪 Troubleshooting
+
+### ❌ Erro: "Authentication required"
+
+**Problema**: Requisição sem headers de autenticação.
+
+**Solução**:
+```typescript
+// Cliente deve enviar headers
+headers: {
+  'x-public-key': publicKeyHex,
+  'x-timestamp': Date.now().toString(),
+  'x-nonce': generateNonce(),
+  'x-signature': signatureHex
+}
+```
 
-Para desenvolver o plugin:
+---
 
+### ❌ Erro: "Invalid signature"
+
+**Problema**: Assinatura não corresponde à mensagem.
+
+**Causas comuns**:
+1. Chave privada incorreta
+2. Mensagem reconstruída diferente
+3. Ordem dos campos alterada
+
+**Solução**:
+```typescript
+// Garantir ordem exata dos campos
+const message = `${timestamp}:${nonce}:${JSON.stringify(body)}`
+```
+
+---
+
+### ❌ Erro: "Timestamp drift too large"
+
+**Problema**: Diferença entre timestamp do cliente e servidor excede `maxTimeDrift`.
+
+**Solução**:
+```typescript
+// Sincronizar relógio do cliente com servidor
+const serverTime = await fetch('/api/time').then(r => r.json())
+const timeDrift = Date.now() - serverTime.timestamp
+// Ajustar timestamps futuros
+```
+
+---
+
+### ❌ Erro: "Admin access required"
+
+**Problema**: Usuário não está na lista de `adminKeys`.
+
+**Solução**:
+```typescript
+// Adicionar chave pública ao config
+{
+  'crypto-auth': {
+    adminKeys: [
+      'a1b2c3d4e5f6...',  // Sua chave pública
+    ]
+  }
+}
+```
+
+---
+
+### 🔍 Debug Mode
+
+Habilitar logs detalhados:
+
+```typescript
+// fluxstack.config.ts
+{
+  'crypto-auth': {
+    enableMetrics: true
+  }
+}
+```
+
+Verificar logs:
 ```bash
-# Instalar dependências
-npm install @noble/curves @noble/hashes
+# Requisições autenticadas
+Requisição autenticada {
+  publicKey: "a1b2c3d4...",
+  isAdmin: false,
+  path: "/api/users",
+  method: "GET"
+}
 
-# Para desenvolvimento com React
-npm install --save-dev @types/react react
+# Falhas de autenticação
+Falha na autenticação {
+  error: "Invalid signature",
+  path: "/api/users",
+  method: "POST"
+}
+```
+
+---
+
+## 📚 Recursos Adicionais
+
+### Documentação Relacionada
+
+- [`QUICK-START-CRYPTO-AUTH.md`](../../QUICK-START-CRYPTO-AUTH.md) - Início rápido em 5 minutos
+- [`EXEMPLO-ROTA-PROTEGIDA.md`](../../EXEMPLO-ROTA-PROTEGIDA.md) - Tutorial passo-a-passo
+- [`CRYPTO-AUTH-MIDDLEWARE-GUIDE.md`](../../CRYPTO-AUTH-MIDDLEWARE-GUIDE.md) - Referência de middlewares
+
+### Bibliotecas Cliente Recomendadas
+
+- **JavaScript/TypeScript**: [TweetNaCl.js](https://github.com/dchest/tweetnacl-js)
+- **React**: [@stablelib/ed25519](https://github.com/StableLib/stablelib)
+
+### Exemplo de Cliente
+
+```typescript
+// client-auth.ts
+import nacl from 'tweetnacl'
+import { encodeHex, decodeHex } from 'tweetnacl-util'
+
+export class CryptoAuthClient {
+  private privateKey: Uint8Array
+  private publicKey: Uint8Array
+
+  constructor() {
+    // Carregar ou gerar chaves
+    const stored = localStorage.getItem('cryptoAuthKeys')
+
+    if (stored) {
+      const keys = JSON.parse(stored)
+      this.privateKey = decodeHex(keys.privateKey)
+      this.publicKey = decodeHex(keys.publicKey)
+    } else {
+      const keypair = nacl.sign.keyPair()
+      this.privateKey = keypair.secretKey
+      this.publicKey = keypair.publicKey
+
+      localStorage.setItem('cryptoAuthKeys', JSON.stringify({
+        privateKey: encodeHex(keypair.secretKey),
+        publicKey: encodeHex(keypair.publicKey)
+      }))
+    }
+  }
+
+  async fetch(url: string, options: RequestInit = {}) {
+    const timestamp = Date.now().toString()
+    const nonce = encodeHex(nacl.randomBytes(16))
+    const body = options.body || ''
+
+    const message = `${timestamp}:${nonce}:${body}`
+    const signature = nacl.sign.detached(
+      new TextEncoder().encode(message),
+      this.privateKey
+    )
+
+    const headers = {
+      ...options.headers,
+      'x-public-key': encodeHex(this.publicKey),
+      'x-timestamp': timestamp,
+      'x-nonce': nonce,
+      'x-signature': encodeHex(signature)
+    }
+
+    return fetch(url, { ...options, headers })
+  }
+
+  getPublicKey() {
+    return encodeHex(this.publicKey)
+  }
+}
+
+// Uso
+const authClient = new CryptoAuthClient()
+const response = await authClient.fetch('/api/users', {
+  method: 'POST',
+  body: JSON.stringify({ name: 'João' })
+})
 ```
 
-## Licença
+---
+
+## 🤝 Contribuindo
+
+Para reportar bugs ou sugerir melhorias, abra uma issue no repositório do FluxStack.
+
+---
+
+## 📄 Licença
+
+Este plugin é parte do FluxStack e segue a mesma licença do framework.
+
+---
 
-MIT
\ No newline at end of file
+**Desenvolvido com ❤️ pela FluxStack Team**
diff --git a/plugins/crypto-auth/ai-context.md b/plugins/crypto-auth/ai-context.md
new file mode 100644
index 00000000..68ebf1f6
--- /dev/null
+++ b/plugins/crypto-auth/ai-context.md
@@ -0,0 +1,1282 @@
+# 🔐 Crypto Auth Plugin - AI Context Documentation
+
+> **Plugin de Autenticação Criptográfica FluxStack**
+> Sistema de autenticação **STATELESS** baseado em assinaturas Ed25519
+
+---
+
+## 📖 Índice Rápido
+
+1. [Overview e Conceitos](#overview-e-conceitos)
+2. [Arquitetura do Sistema](#arquitetura-do-sistema)
+3. [Fluxo de Autenticação](#fluxo-de-autenticação)
+4. [Componentes Principais](#componentes-principais)
+5. [Padrões e Boas Práticas](#padrões-e-boas-práticas)
+6. [Troubleshooting](#troubleshooting)
+7. [Exemplos de Uso](#exemplos-de-uso)
+8. [Segurança](#segurança)
+9. [Testes](#testes)
+
+---
+
+## 🎯 Overview e Conceitos
+
+### O que é este plugin?
+
+Sistema de autenticação **SEM SESSÕES** que usa criptografia Ed25519 para validar requisições.
+
+### Conceitos-chave
+
+**🚫 NÃO HÁ SESSÕES NO SERVIDOR**
+- Servidor NÃO armazena estado de autenticação
+- Cada requisição é validada independentemente
+- Chave pública identifica o usuário
+
+**🔑 Par de Chaves Ed25519**
+- **Chave Privada**: NUNCA sai do navegador, armazenada em localStorage
+- **Chave Pública**: Enviada em cada requisição, identifica o usuário
+
+**✍️ Assinatura Digital**
+- Cliente assina cada requisição com chave privada
+- Servidor valida assinatura usando chave pública recebida
+- Assinatura inclui: `publicKey:timestamp:nonce:message`
+
+**🛡️ Proteções**
+- **Replay Attack**: Nonces únicos impedem reutilização de assinaturas
+- **Time Drift**: Timestamps impedem requisições muito antigas (5 min)
+- **Man-in-the-Middle**: Assinaturas são únicas por requisição
+
+---
+
+## 🏗️ Arquitetura do Sistema
+
+### Estrutura de Arquivos
+
+```
+plugins/crypto-auth/
+├── index.ts                    # Plugin principal e hooks
+├── ai-context.md              # Esta documentação
+├── server/
+│   ├── index.ts               # Exports do servidor
+│   ├── CryptoAuthService.ts   # Validação de assinaturas
+│   └── AuthMiddleware.ts      # Middleware de autenticação
+├── client/
+│   ├── index.ts               # Exports do cliente
+│   ├── CryptoAuthClient.ts    # Cliente de autenticação
+│   └── components/
+│       └── AuthProvider.tsx   # React Context Provider
+└── README.md                  # Documentação do usuário
+```
+
+### Fluxo de Dados
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                         CLIENTE                             │
+├─────────────────────────────────────────────────────────────┤
+│ 1. Gera par de chaves Ed25519 (local)                      │
+│    privateKey → NUNCA enviada                               │
+│    publicKey  → Enviada em cada request                     │
+│                                                              │
+│ 2. Para cada requisição:                                    │
+│    - timestamp = Date.now()                                 │
+│    - nonce = crypto.randomBytes(16)                         │
+│    - message = "GET:/api/users"                             │
+│    - fullMessage = publicKey:timestamp:nonce:message        │
+│    - signature = sign(fullMessage, privateKey)              │
+│                                                              │
+│ 3. Headers enviados:                                        │
+│    x-public-key: <publicKey>                                │
+│    x-timestamp: <timestamp>                                 │
+│    x-nonce: <nonce>                                         │
+│    x-signature: <signature>                                 │
+└─────────────────────────────────────────────────────────────┘
+                            ↓
+┌─────────────────────────────────────────────────────────────┐
+│                       SERVIDOR                              │
+├─────────────────────────────────────────────────────────────┤
+│ 1. Plugin Hook onRequest                                    │
+│    - AuthMiddleware.authenticate(context)                   │
+│                                                              │
+│ 2. AuthMiddleware                                           │
+│    - Extrai headers (public-key, timestamp, nonce, sig)     │
+│    - Chama CryptoAuthService.validateRequest()              │
+│                                                              │
+│ 3. CryptoAuthService.validateRequest()                      │
+│    ✓ Valida formato da chave pública                        │
+│    ✓ Verifica time drift (< 5 min)                          │
+│    ✓ Verifica se nonce já foi usado                         │
+│    ✓ Reconstrói mensagem: publicKey:timestamp:nonce:message │
+│    ✓ Verifica assinatura: verify(signature, message, publicKey) │
+│    ✓ Marca nonce como usado                                 │
+│    ✓ Retorna user: { publicKey, isAdmin, permissions }     │
+│                                                              │
+│ 4. Se válido:                                               │
+│    - context.request.user = user                            │
+│    - Processa rota normalmente                              │
+│                                                              │
+│ 5. Se inválido:                                             │
+│    - context.handled = true                                 │
+│    - context.response = 401 Unauthorized                    │
+│    - Rota NÃO é executada                                   │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🔄 Fluxo de Autenticação
+
+### 1. Inicialização do Cliente
+
+```typescript
+// Cliente inicializa automaticamente ou manualmente
+const client = new CryptoAuthClient({
+  autoInit: true,           // Gera chaves automaticamente
+  storage: 'localStorage'   // Onde armazenar chaves
+})
+
+// Se autoInit: true
+//   → Verifica se já existem chaves no localStorage
+//   → Se sim: carrega chaves existentes
+//   → Se não: gera novo par de chaves
+
+// Chaves armazenadas em: localStorage['fluxstack_crypto_keys']
+// Formato: { publicKey, privateKey, createdAt }
+```
+
+### 2. Requisição Assinada
+
+```typescript
+// Método automático (recomendado)
+const response = await client.fetch('/api/users')
+
+// O que acontece internamente:
+// 1. timestamp = Date.now()
+// 2. nonce = generateNonce() // 16 bytes aleatórios
+// 3. message = buildMessage('GET', '/api/users', null)
+//    → "GET:/api/users"
+// 4. fullMessage = `${publicKey}:${timestamp}:${nonce}:${message}`
+// 5. messageHash = sha256(fullMessage)
+// 6. signature = ed25519.sign(messageHash, privateKey)
+// 7. Headers adicionados automaticamente
+```
+
+### 3. Validação no Servidor
+
+```typescript
+// Plugin Hook onRequest (automático)
+onRequest: async (context) => {
+  const authResult = await authMiddleware.authenticate(context)
+
+  if (authResult.success) {
+    // ✅ Usuário autenticado
+    context.request.user = authResult.user
+    // Rota é executada normalmente
+  } else if (authResult.required) {
+    // ❌ Falha na autenticação
+    context.handled = true
+    context.response = new Response(JSON.stringify({
+      success: false,
+      error: authResult.error
+    }), { status: 401 })
+    // Rota NÃO é executada
+  }
+}
+```
+
+### 4. Acesso nas Rotas
+
+```typescript
+// Rotas protegidas podem acessar user
+.get('/api/users', ({ request }) => {
+  const user = (request as any).user
+
+  return {
+    user: {
+      publicKey: user.publicKey,
+      isAdmin: user.isAdmin,
+      permissions: user.permissions
+    }
+  }
+})
+```
+
+---
+
+## 🧩 Componentes Principais
+
+### 1. CryptoAuthService (Backend)
+
+**Localização**: `plugins/crypto-auth/server/CryptoAuthService.ts`
+
+**Responsabilidades**:
+- Validar assinaturas Ed25519
+- Gerenciar nonces (prevenir replay attacks)
+- Verificar drift de tempo
+- Identificar usuários admin
+
+**Métodos Principais**:
+
+```typescript
+class CryptoAuthService {
+  // Validar uma requisição assinada
+  async validateRequest(data: {
+    publicKey: string
+    timestamp: number
+    nonce: string
+    signature: string
+    message?: string
+  }): Promise<AuthResult>
+
+  // Verificar se chave pública é válida (64 hex chars)
+  private isValidPublicKey(publicKey: string): boolean
+
+  // Limpar nonces antigos (executado a cada 5 min)
+  private cleanupOldNonces(): void
+
+  // Retornar estatísticas
+  getStats(): { usedNonces: number; adminKeys: number }
+}
+```
+
+**Estado Interno**:
+```typescript
+private usedNonces: Map<string, number>  // `${publicKey}:${nonce}` → timestamp
+```
+
+**Importante**:
+- `usedNonces` é limpo automaticamente a cada 5 minutos
+- Nonces mais antigos que `maxTimeDrift * 2` são removidos
+- NÃO HÁ armazenamento de sessões!
+
+---
+
+### 2. AuthMiddleware (Backend)
+
+**Localização**: `plugins/crypto-auth/server/AuthMiddleware.ts`
+
+**Responsabilidades**:
+- Verificar se rota requer autenticação
+- Extrair headers de autenticação
+- Chamar CryptoAuthService para validar
+- Decidir se permite acesso
+
+**Métodos Principais**:
+
+```typescript
+class AuthMiddleware {
+  // Autenticar uma requisição
+  async authenticate(context: RequestContext): Promise<{
+    success: boolean
+    required: boolean  // Se autenticação é obrigatória
+    error?: string
+    user?: User
+  }>
+
+  // Verificar se rota está protegida
+  private isProtectedRoute(path: string): boolean
+
+  // Verificar se rota é pública
+  private isPublicRoute(path: string): boolean
+
+  // Extrair headers de auth
+  private extractAuthHeaders(headers): AuthHeaders | null
+
+  // Construir mensagem para validação
+  private buildMessage(context: RequestContext): string
+}
+```
+
+**Lógica de Decisão**:
+```typescript
+// 1. Se rota pública → success: true, required: false
+// 2. Se rota protegida sem headers → success: false, required: true
+// 3. Se rota protegida com headers → valida assinatura
+//    - Se válida → success: true, required: true, user: {...}
+//    - Se inválida → success: false, required: true, error: "..."
+```
+
+---
+
+### 3. CryptoAuthClient (Frontend)
+
+**Localização**: `plugins/crypto-auth/client/CryptoAuthClient.ts`
+
+**Responsabilidades**:
+- Gerar e gerenciar par de chaves
+- Assinar requisições automaticamente
+- Armazenar chaves em localStorage
+
+**Métodos Públicos**:
+
+```typescript
+class CryptoAuthClient {
+  // Inicializar (gerar ou carregar chaves)
+  initialize(): KeyPair
+
+  // Criar novo par de chaves
+  createNewKeys(): KeyPair
+
+  // Fazer requisição autenticada
+  async fetch(url: string, options?: RequestInit): Promise<Response>
+
+  // Obter chaves atuais
+  getKeys(): KeyPair | null
+
+  // Verificar se está inicializado
+  isInitialized(): boolean
+
+  // Limpar chaves (logout)
+  clearKeys(): void
+}
+```
+
+**Métodos Privados**:
+
+```typescript
+// Assinar mensagem
+private signMessage(message: string, timestamp: number, nonce: string): string
+
+// Construir mensagem para assinar
+private buildMessage(method: string, url: string, body?: any): string
+
+// Gerar nonce aleatório
+private generateNonce(): string
+
+// Carregar chaves do storage
+private loadKeys(): KeyPair | null
+
+// Salvar chaves no storage
+private saveKeys(keys: KeyPair): void
+```
+
+**Formato de Mensagem**:
+```typescript
+// Para GET /api/users
+message = "GET:/api/users"
+
+// Para POST /api/users com body
+message = "POST:/api/users:{\"name\":\"João\"}"
+
+// Mensagem completa assinada
+fullMessage = `${publicKey}:${timestamp}:${nonce}:${message}`
+```
+
+---
+
+### 4. AuthProvider (React Component)
+
+**Localização**: `plugins/crypto-auth/client/components/AuthProvider.tsx`
+
+**Responsabilidades**:
+- Prover contexto de autenticação via React Context
+- Gerenciar estado de chaves
+- Callbacks para eventos (onKeysChange, onError)
+
+**Interface**:
+
+```typescript
+export interface AuthContextValue {
+  client: CryptoAuthClient
+  keys: KeyPair | null
+  hasKeys: boolean
+  isLoading: boolean
+  error: string | null
+  createKeys: () => void
+  clearKeys: () => void
+}
+
+// Hook para usar o contexto
+export const useAuth = (): AuthContextValue
+```
+
+**Uso**:
+
+```tsx
+// Wrapper da aplicação
+<AuthProvider
+  config={{ storage: 'localStorage' }}
+  onKeysChange={(hasKeys, keys) => console.log('Keys changed')}
+  onError={(error) => console.error(error)}
+>
+  <App />
+</AuthProvider>
+
+// Dentro de componentes
+function MyComponent() {
+  const { keys, hasKeys, createKeys, clearKeys } = useAuth()
+
+  if (!hasKeys) {
+    return <button onClick={createKeys}>Login</button>
+  }
+
+  return <button onClick={clearKeys}>Logout</button>
+}
+```
+
+---
+
+### 5. Plugin Principal (index.ts)
+
+**Localização**: `plugins/crypto-auth/index.ts`
+
+**Responsabilidades**:
+- Definir schema de configuração
+- Hooks do plugin (setup, onRequest, onResponse, onServerStart)
+- Rotas de informação (/api/auth/info)
+
+**Configuração**:
+
+```typescript
+defaultConfig: {
+  enabled: true,
+  maxTimeDrift: 300000,  // 5 minutos em ms
+  adminKeys: [],         // Array de chaves públicas admin
+  protectedRoutes: [
+    "/api/admin/*",
+    "/api/crypto-auth/protected",
+    "/api/crypto-auth/admin"
+  ],
+  publicRoutes: [
+    "/api/crypto-auth/public",
+    "/api/health",
+    "/api/docs",
+    "/swagger"
+  ],
+  enableMetrics: true
+}
+```
+
+**Hooks**:
+
+```typescript
+// 1. setup - Inicialização
+setup: async (context) => {
+  const authService = new CryptoAuthService(...)
+  const authMiddleware = new AuthMiddleware(...)
+
+  // Armazenar no global para acesso nos hooks
+  (global as any).cryptoAuthService = authService
+  (global as any).cryptoAuthMiddleware = authMiddleware
+}
+
+// 2. onRequest - Validar cada requisição
+onRequest: async (context) => {
+  const authResult = await authMiddleware.authenticate(context)
+
+  if (authResult.success) {
+    context.request.user = authResult.user  // ✅
+  } else if (authResult.required) {
+    context.handled = true                  // ❌
+    context.response = new Response(...)
+  }
+}
+
+// 3. onResponse - Métricas (opcional)
+onResponse: async (context) => {
+  // Log de requisições autenticadas
+}
+
+// 4. onServerStart - Log de status
+onServerStart: async (context) => {
+  logger.info("Crypto Auth plugin ativo")
+}
+```
+
+---
+
+## 📋 Padrões e Boas Práticas
+
+### ✅ Sempre Fazer
+
+1. **Usar cliente nativo para requisições protegidas**
+```typescript
+// ✅ Correto
+const response = await authClient.fetch('/api/protected')
+
+// ❌ Errado - não inclui assinatura
+const response = await fetch('/api/protected')
+```
+
+2. **Verificar se usuário está autenticado nas rotas**
+```typescript
+// ✅ Correto
+.get('/api/users', ({ request }) => {
+  const user = (request as any).user
+  if (!user) {
+    return { error: 'Unauthorized' }
+  }
+  // ...
+})
+```
+
+3. **Adicionar novas rotas protegidas na config**
+```typescript
+// config/app.config.ts
+plugins: {
+  config: {
+    'crypto-auth': {
+      protectedRoutes: [
+        "/api/admin/*",
+        "/api/crypto-auth/protected",
+        "/api/users/*"  // ✅ Nova rota
+      ]
+    }
+  }
+}
+```
+
+4. **Tratar erros de autenticação no frontend**
+```typescript
+try {
+  const response = await authClient.fetch('/api/protected')
+  if (response.status === 401) {
+    // Chaves inválidas, criar novas
+    authClient.clearKeys()
+    authClient.createNewKeys()
+  }
+} catch (error) {
+  console.error('Auth error:', error)
+}
+```
+
+5. **Verificar permissões de admin quando necessário**
+```typescript
+.get('/api/admin/users', ({ request, set }) => {
+  const user = (request as any).user
+
+  if (!user?.isAdmin) {
+    set.status = 403
+    return { error: 'Admin access required' }
+  }
+
+  // Lógica admin
+})
+```
+
+---
+
+### ❌ Nunca Fazer
+
+1. **NÃO enviar chave privada ao servidor**
+```typescript
+// ❌ NUNCA FAZER ISSO!
+await fetch('/api/register', {
+  body: JSON.stringify({
+    privateKey: keys.privateKey  // PERIGO!
+  })
+})
+```
+
+2. **NÃO armazenar sessões no servidor**
+```typescript
+// ❌ Viola arquitetura stateless
+const sessions = new Map()
+sessions.set(publicKey, userData)
+```
+
+3. **NÃO confiar apenas na chave pública**
+```typescript
+// ❌ Permite spoofing
+.get('/api/users', ({ headers }) => {
+  const publicKey = headers['x-public-key']
+  // FALTA: validar assinatura!
+})
+
+// ✅ Correto - middleware já validou
+.get('/api/users', ({ request }) => {
+  const user = (request as any).user  // Validado!
+})
+```
+
+4. **NÃO permitir timestamp muito antigo/futuro**
+```typescript
+// ❌ Vulnerável a replay attack
+const maxTimeDrift = 24 * 60 * 60 * 1000  // 24 horas - MUITO!
+
+// ✅ Correto
+const maxTimeDrift = 5 * 60 * 1000  // 5 minutos
+```
+
+5. **NÃO reutilizar nonces**
+```typescript
+// ❌ Cliente NÃO deve fazer isso
+const nonce = "fixed-nonce"  // Sempre igual!
+
+// ✅ Correto
+const nonce = generateNonce()  // Aleatório sempre
+```
+
+---
+
+## 🔧 Troubleshooting
+
+### Problema 1: "Assinatura inválida"
+
+**Sintomas**: Requisições retornam 401 com erro "Assinatura inválida"
+
+**Causas Possíveis**:
+1. Chaves públicas/privadas não correspondem
+2. Mensagem construída incorretamente
+3. Timestamp/nonce diferentes no cliente e servidor
+4. Corpo da requisição não incluído na assinatura
+
+**Debug**:
+```typescript
+// No cliente - log mensagem assinada
+const fullMessage = `${publicKey}:${timestamp}:${nonce}:${message}`
+console.log('Client message:', fullMessage)
+console.log('Signature:', signature)
+
+// No servidor - log mensagem reconstruída
+const messageToVerify = `${publicKey}:${timestamp}:${nonce}:${message}`
+console.log('Server message:', messageToVerify)
+```
+
+**Solução**:
+- Verificar se cliente e servidor constroem mensagem idêntica
+- Confirmar que timestamp e nonce estão sendo enviados corretamente
+- Para POST/PUT, verificar se body está sendo incluído na mensagem
+
+---
+
+### Problema 2: "Nonce já utilizado"
+
+**Sintomas**: Segunda requisição idêntica retorna 401
+
+**Causa**: Replay attack protection funcionando (comportamento esperado!)
+
+**Quando é bug**:
+- Se acontece com requisições DIFERENTES
+- Se nonce não está sendo gerado aleatoriamente
+
+**Debug**:
+```typescript
+// Verificar geração de nonce
+console.log('Nonce 1:', generateNonce())
+console.log('Nonce 2:', generateNonce())
+// Devem ser SEMPRE diferentes!
+```
+
+**Solução**:
+- Se está testando manualmente, gerar novo nonce a cada tentativa
+- Verificar que `crypto.randomBytes()` está funcionando
+
+---
+
+### Problema 3: "Timestamp inválido ou expirado"
+
+**Sintomas**: Requisições retornam 401 com erro de timestamp
+
+**Causas Possíveis**:
+1. Relógio do cliente desincronizado
+2. Requisição demorou muito para chegar ao servidor
+3. `maxTimeDrift` configurado muito curto
+
+**Debug**:
+```typescript
+const clientTime = Date.now()
+const serverTime = Date.now()  // No servidor
+const drift = Math.abs(serverTime - clientTime)
+console.log('Time drift:', drift, 'ms')
+console.log('Max allowed:', maxTimeDrift, 'ms')
+```
+
+**Solução**:
+- Sincronizar relógio do sistema
+- Aumentar `maxTimeDrift` se necessário (mas não muito!)
+- Verificar latência de rede
+
+---
+
+### Problema 4: "User undefined nas rotas"
+
+**Sintomas**: `request.user` é `undefined` mesmo com autenticação válida
+
+**Causa**: User não está sendo propagado corretamente do middleware
+
+**Debug**:
+```typescript
+// No plugin index.ts - verificar hook onRequest
+if (authResult.success && authResult.user) {
+  context.request.user = authResult.user  // ✅ Deve estar aqui
+  console.log('User set:', authResult.user)
+}
+
+// Na rota
+console.log('User received:', (request as any).user)
+```
+
+**Solução**:
+- Verificar que `context.request.user` está sendo definido no hook
+- Confirmar que middleware está retornando `user` no authResult
+
+---
+
+### Problema 5: Rotas públicas retornando 401
+
+**Sintomas**: Rotas que deveriam ser públicas exigem autenticação
+
+**Causa**: Rota não está na lista de `publicRoutes`
+
+**Debug**:
+```typescript
+// Verificar configuração
+console.log('Public routes:', config.publicRoutes)
+console.log('Request path:', context.path)
+console.log('Is public?:', isPublicRoute(context.path))
+```
+
+**Solução**:
+```typescript
+// config/app.config.ts
+plugins: {
+  config: {
+    'crypto-auth': {
+      publicRoutes: [
+        "/api/health",
+        "/api/docs",
+        "/api/crypto-auth/public",  // Adicionar rota
+        "/swagger"
+      ]
+    }
+  }
+}
+```
+
+---
+
+## 💡 Exemplos de Uso
+
+### Exemplo 1: Requisição Simples
+
+```typescript
+// Cliente
+import { CryptoAuthClient } from '@/plugins/crypto-auth/client'
+
+const client = new CryptoAuthClient({ autoInit: true })
+
+// Fazer requisição protegida
+const response = await client.fetch('/api/users')
+const data = await response.json()
+
+console.log('Users:', data)
+```
+
+```typescript
+// Servidor - Rota
+.get('/api/users', ({ request }) => {
+  const user = (request as any).user
+
+  return {
+    success: true,
+    user: {
+      publicKey: user.publicKey,
+      isAdmin: user.isAdmin
+    },
+    users: [/* ... */]
+  }
+})
+```
+
+---
+
+### Exemplo 2: Requisição POST com Body
+
+```typescript
+// Cliente
+const newUser = { name: 'João', email: 'joao@test.com' }
+
+const response = await client.fetch('/api/users', {
+  method: 'POST',
+  body: JSON.stringify(newUser)
+})
+
+const data = await response.json()
+```
+
+```typescript
+// Servidor
+.post('/api/users', async ({ request, body }) => {
+  const user = (request as any).user
+
+  // Body é assinado automaticamente
+  const newUser = await createUser(body)
+
+  return {
+    success: true,
+    user: newUser,
+    authenticatedBy: user.publicKey
+  }
+})
+```
+
+---
+
+### Exemplo 3: Rota Admin
+
+```typescript
+// Cliente
+const response = await client.fetch('/api/admin/stats')
+
+if (response.status === 403) {
+  console.error('Você não é admin!')
+}
+```
+
+```typescript
+// Servidor
+.get('/api/admin/stats', ({ request, set }) => {
+  const user = (request as any).user
+
+  // Verificar permissões
+  if (!user?.isAdmin) {
+    set.status = 403
+    return {
+      success: false,
+      error: 'Admin access required',
+      yourPermissions: user?.permissions || []
+    }
+  }
+
+  return {
+    success: true,
+    stats: {
+      totalUsers: 100,
+      activeUsers: 50
+    }
+  }
+})
+```
+
+---
+
+### Exemplo 4: React Component com AuthProvider
+
+```tsx
+import { useAuth } from '@/plugins/crypto-auth/client'
+
+function LoginButton() {
+  const { keys, hasKeys, isLoading, createKeys, clearKeys } = useAuth()
+
+  if (isLoading) {
+    return <div>Carregando...</div>
+  }
+
+  if (!hasKeys) {
+    return (
+      <button onClick={createKeys}>
+        Gerar Chaves de Autenticação
+      </button>
+    )
+  }
+
+  return (
+    <div>
+      <p>Autenticado: {keys.publicKey.substring(0, 16)}...</p>
+      <button onClick={clearKeys}>Logout</button>
+    </div>
+  )
+}
+
+function ProtectedData() {
+  const { client, hasKeys } = useAuth()
+  const [data, setData] = useState(null)
+
+  useEffect(() => {
+    if (hasKeys) {
+      client.fetch('/api/protected')
+        .then(r => r.json())
+        .then(setData)
+    }
+  }, [hasKeys])
+
+  return <pre>{JSON.stringify(data, null, 2)}</pre>
+}
+```
+
+---
+
+### Exemplo 5: Adicionar Chave Admin
+
+```typescript
+// 1. Gerar chave pública de um usuário admin
+const adminClient = new CryptoAuthClient()
+const adminKeys = adminClient.createNewKeys()
+console.log('Admin Public Key:', adminKeys.publicKey)
+
+// 2. Adicionar na configuração
+// config/app.config.ts
+plugins: {
+  config: {
+    'crypto-auth': {
+      adminKeys: [
+        "7443b54b3c8e2f1a9d5c6e4b2f8a1d3c9e5b7a2f4d8c1e6b3a9d5c7e2f4b8a1d"
+      ]
+    }
+  }
+}
+
+// 3. Usuário com essa chave pública terá isAdmin: true
+const response = await adminClient.fetch('/api/admin/users')
+// ✅ Acesso permitido
+```
+
+---
+
+## 🔒 Segurança
+
+### Princípios de Segurança
+
+1. **Zero Trust**
+   - Servidor NUNCA confia apenas na chave pública
+   - SEMPRE valida assinatura antes de processar requisição
+
+2. **Defesa em Profundidade**
+   - Validação de formato de chave
+   - Verificação de timestamp
+   - Proteção contra replay (nonces)
+   - Assinatura criptográfica
+
+3. **Least Privilege**
+   - Usuários normais: apenas `read` permission
+   - Admins: `admin`, `read`, `write`, `delete`
+
+---
+
+### Vetores de Ataque e Mitigações
+
+#### 1. Man-in-the-Middle (MITM)
+
+**Ataque**: Interceptar e modificar requisição
+
+**Mitigação**:
+- ✅ Assinatura detecta qualquer modificação
+- ✅ HTTPS obrigatório em produção
+- ✅ Chave privada nunca transmitida
+
+```typescript
+// Atacante modifica mensagem
+Original: "GET:/api/users"
+Modificado: "GET:/api/admin/users"
+
+// Assinatura não corresponde → 401 Unauthorized
+```
+
+---
+
+#### 2. Replay Attack
+
+**Ataque**: Reutilizar requisição válida capturada
+
+**Mitigação**:
+- ✅ Nonces únicos por requisição
+- ✅ Timestamp expira em 5 minutos
+- ✅ Nonces armazenados até expiração
+
+```typescript
+// Atacante captura requisição válida
+Request 1: nonce = "abc123" → ✅ 200 OK
+
+// Tenta reutilizar
+Request 2: nonce = "abc123" → ❌ 401 "Nonce já utilizado"
+```
+
+---
+
+#### 3. Brute Force de Chave Privada
+
+**Ataque**: Tentar adivinhar chave privada
+
+**Mitigação**:
+- ✅ Ed25519 com 256 bits de segurança
+- ✅ 2^256 combinações possíveis
+- ✅ Computacionalmente inviável
+
+---
+
+#### 4. Key Theft (Roubo de Chave)
+
+**Ataque**: Acessar localStorage e roubar chave privada
+
+**Mitigação**:
+- ⚠️ Se atacante tem acesso ao localStorage, chave está comprometida
+- ✅ Usar sempre HTTPS
+- ✅ Implementar Content Security Policy
+- ✅ XSS protection (sanitize inputs)
+
+**Procedimento de Resposta**:
+```typescript
+// 1. Usuário reporta suspeita de roubo
+// 2. Gerar novas chaves
+client.clearKeys()
+client.createNewKeys()
+
+// 3. Revogar chave antiga (se houver blacklist)
+// 4. Notificar usuário
+```
+
+---
+
+#### 5. Time Manipulation
+
+**Ataque**: Modificar relógio do sistema
+
+**Mitigação**:
+- ✅ `maxTimeDrift` limita divergência a 5 minutos
+- ✅ Servidor usa seu próprio timestamp como referência
+
+```typescript
+// Cliente com relógio 1 hora no futuro
+clientTime: 2025-01-01 14:00:00
+serverTime: 2025-01-01 13:00:00
+
+drift = 3600000ms > maxTimeDrift (300000ms)
+→ 401 "Timestamp inválido ou expirado"
+```
+
+---
+
+### Boas Práticas de Segurança
+
+1. **Sempre usar HTTPS em produção**
+```typescript
+// config/server.config.ts
+if (process.env.NODE_ENV === 'production') {
+  config.enforceHTTPS = true
+}
+```
+
+2. **Rotacionar chaves periodicamente**
+```typescript
+// A cada 30 dias, sugerir nova chave
+const keyAge = Date.now() - keys.createdAt.getTime()
+if (keyAge > 30 * 24 * 60 * 60 * 1000) {
+  showRotateKeyDialog()
+}
+```
+
+3. **Rate limiting em rotas sensíveis**
+```typescript
+// Limitar tentativas de autenticação
+const rateLimit = new Map()
+
+.post('/api/auth/verify', ({ headers }) => {
+  const publicKey = headers['x-public-key']
+  const attempts = rateLimit.get(publicKey) || 0
+
+  if (attempts > 10) {
+    return { error: 'Too many attempts' }
+  }
+
+  rateLimit.set(publicKey, attempts + 1)
+})
+```
+
+4. **Logging de eventos de segurança**
+```typescript
+// Log failed auth attempts
+if (!authResult.success) {
+  logger.warn('Failed authentication', {
+    publicKey: publicKey.substring(0, 8) + '...',
+    error: authResult.error,
+    ip: context.headers['x-forwarded-for'],
+    timestamp: new Date()
+  })
+}
+```
+
+---
+
+## 🧪 Testes
+
+### Teste Automatizado
+
+```bash
+# Executar script de teste
+bun run test-crypto-auth.ts
+```
+
+**Saída Esperada**:
+```
+🔐 Testando Autenticação Criptográfica Ed25519
+
+1️⃣ Gerando par de chaves Ed25519...
+   ✅ Chave pública: 7443b54b...
+   ✅ Chave privada: ******** (NUNCA enviar ao servidor!)
+
+2️⃣ Preparando requisição assinada...
+   ✅ Mensagem construída
+
+3️⃣ Assinando mensagem com chave privada...
+   ✅ Assinatura: e29d2819...
+
+4️⃣ Enviando requisição ao servidor...
+   📡 Status: 200
+   ✅ SUCESSO! Assinatura validada
+
+5️⃣ Testando proteção contra replay attack...
+   📡 Replay Status: 401
+   ✅ Proteção funcionando! Replay attack bloqueado
+```
+
+---
+
+### Teste Manual no Frontend
+
+1. Abrir http://localhost:5173
+2. Navegar para "Crypto Auth Demo"
+3. Clicar em "Gerar Novo Par de Chaves"
+4. Verificar chaves exibidas
+5. Clicar em "GET /api/crypto-auth/public" → 200 OK
+6. Clicar em "GET /api/crypto-auth/protected" → 200 OK com dados
+7. Clicar em "Limpar Chaves"
+8. Clicar em "GET /api/crypto-auth/protected" → 401 Unauthorized
+
+---
+
+### Teste de Casos Edge
+
+```typescript
+// Teste 1: Timestamp muito antigo
+const oldTimestamp = Date.now() - (10 * 60 * 1000)  // 10 min atrás
+// Esperado: 401 "Timestamp inválido"
+
+// Teste 2: Chave pública inválida
+const invalidKey = "not-a-hex-string"
+// Esperado: 401 "Chave pública inválida"
+
+// Teste 3: Assinatura incorreta
+const wrongSignature = "0000000000000000000000000000000000000000"
+// Esperado: 401 "Assinatura inválida"
+
+// Teste 4: Nonce reutilizado
+const sameNonce = "abc123"
+// Request 1: 200 OK
+// Request 2: 401 "Nonce já utilizado"
+
+// Teste 5: Usuário não-admin tentando rota admin
+// Esperado: 403 "Permissão negada"
+```
+
+---
+
+## 🔍 Debug e Logging
+
+### Ativar Logs Detalhados
+
+```typescript
+// config/app.config.ts
+plugins: {
+  config: {
+    'crypto-auth': {
+      enableMetrics: true,  // Ativa logs de métricas
+      logLevel: 'debug'     // Nível de log
+    }
+  }
+}
+```
+
+### Logs Úteis
+
+```typescript
+// Cliente
+console.log('Keys:', client.getKeys())
+console.log('Is initialized:', client.isInitialized())
+
+// Middleware
+logger.debug('Authenticating request', {
+  path: context.path,
+  method: context.method,
+  hasAuthHeaders: !!authHeaders
+})
+
+// Service
+logger.info('Request validated', {
+  publicKey: publicKey.substring(0, 8) + '...',
+  isAdmin,
+  permissions
+})
+```
+
+---
+
+## 📚 Referências Técnicas
+
+### Bibliotecas Utilizadas
+
+- **@noble/curves**: Implementação Ed25519
+- **@noble/hashes**: SHA256 e utilitários
+
+### Algoritmos
+
+- **Ed25519**: Curva elíptica para assinatura digital
+- **SHA-256**: Hash da mensagem antes de assinar
+
+### Padrões de Segurança
+
+- **NIST FIPS 186-5**: Digital Signature Standard
+- **RFC 8032**: Edwards-Curve Digital Signature Algorithm (EdDSA)
+
+---
+
+## 🚀 Próximos Passos / Melhorias Futuras
+
+### Funcionalidades Planejadas
+
+1. **Key Rotation Automática**
+   - Sugerir rotação de chaves antigas
+   - Transição suave entre chaves
+
+2. **Blacklist de Chaves**
+   - Revogar chaves comprometidas
+   - Armazenamento distribuído de revogações
+
+3. **Multi-Device Support**
+   - Mesmo usuário, múltiplas chaves
+   - Sincronização de permissões
+
+4. **Audit Log**
+   - Histórico de autenticações
+   - Análise de padrões suspeitos
+
+5. **2FA Opcional**
+   - Adicionar segundo fator além da assinatura
+   - TOTP ou WebAuthn
+
+---
+
+## ✅ Checklist de Manutenção
+
+Ao modificar este plugin, verificar:
+
+- [ ] Testes automatizados passam (`bun run test-crypto-auth.ts`)
+- [ ] Frontend funciona (http://localhost:5173 → Crypto Auth Demo)
+- [ ] Replay attack protection ativo
+- [ ] Timestamp validation funcionando
+- [ ] User context propagado corretamente
+- [ ] Rotas públicas acessíveis sem auth
+- [ ] Rotas protegidas exigem autenticação
+- [ ] Rotas admin verificam `isAdmin`
+- [ ] Nonces sendo limpos periodicamente
+- [ ] Logs de segurança sendo gerados
+- [ ] Documentação atualizada (este arquivo!)
+
+---
+
+## 📞 Suporte
+
+**Logs importantes**: `plugins/crypto-auth/server/*.ts`
+**Testes**: `test-crypto-auth.ts`
+**Exemplos**: `app/client/src/pages/CryptoAuthPage.tsx`
+
+**Arquivos críticos** (não modificar sem entender):
+- `CryptoAuthService.ts` - Validação de assinaturas
+- `AuthMiddleware.ts` - Decisões de autenticação
+- `CryptoAuthClient.ts` - Geração e assinatura
+
+---
+
+**Última atualização**: Janeiro 2025
+**Versão do Plugin**: 1.0.0
+**Compatível com**: FluxStack v1.4.1+
diff --git a/plugins/crypto-auth/bun.lock b/plugins/crypto-auth/bun.lock
new file mode 100644
index 00000000..e1f7f36a
--- /dev/null
+++ b/plugins/crypto-auth/bun.lock
@@ -0,0 +1,35 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "@fluxstack/crypto-auth-plugin",
+      "dependencies": {
+        "@noble/curves": "1.2.0",
+        "@noble/hashes": "1.3.2",
+      },
+      "devDependencies": {
+        "@types/react": "^18.0.0",
+        "typescript": "^5.0.0",
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0",
+      },
+      "optionalPeers": [
+        "react",
+      ],
+    },
+  },
+  "packages": {
+    "@noble/curves": ["@noble/curves@1.2.0", "", { "dependencies": { "@noble/hashes": "1.3.2" } }, "sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw=="],
+
+    "@noble/hashes": ["@noble/hashes@1.3.2", "", {}, "sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ=="],
+
+    "@types/prop-types": ["@types/prop-types@15.7.15", "", {}, "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw=="],
+
+    "@types/react": ["@types/react@18.3.26", "", { "dependencies": { "@types/prop-types": "*", "csstype": "^3.0.2" } }, "sha512-RFA/bURkcKzx/X9oumPG9Vp3D3JUgus/d0b67KB0t5S/raciymilkOa66olh78MUI92QLbEJevO7rvqU/kjwKA=="],
+
+    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+  }
+}
diff --git a/plugins/crypto-auth/cli/make-protected-route.command.ts b/plugins/crypto-auth/cli/make-protected-route.command.ts
new file mode 100644
index 00000000..2b2fb950
--- /dev/null
+++ b/plugins/crypto-auth/cli/make-protected-route.command.ts
@@ -0,0 +1,383 @@
+/**
+ * CLI Command: make:protected-route
+ * Gera rotas protegidas automaticamente
+ */
+
+import type { CliCommand, CliContext } from '@/core/plugins/types'
+import { writeFileSync, existsSync, mkdirSync } from 'fs'
+import { join } from 'path'
+
+const ROUTE_TEMPLATES = {
+  required: (name: string, pascalName: string) => `/**
+ * ${pascalName} Routes
+ * 🔒 Autenticação obrigatória
+ * Auto-gerado pelo comando: flux crypto-auth:make:route ${name} --auth required
+ */
+
+import { Elysia, t } from 'elysia'
+import { cryptoAuthRequired, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+export const ${name}Routes = new Elysia({ prefix: '/${name}' })
+
+  // ========================================
+  // 🔒 ROTAS PROTEGIDAS (autenticação obrigatória)
+  // ========================================
+  .guard({}, (app) =>
+    app.use(cryptoAuthRequired())
+
+      // GET /api/${name}
+      .get('/', ({ request }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: 'Lista de ${name}',
+          user: {
+            publicKey: user.publicKey.substring(0, 16) + '...',
+            isAdmin: user.isAdmin
+          },
+          data: []
+        }
+      })
+
+      // GET /api/${name}/:id
+      .get('/:id', ({ request, params }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: 'Detalhes de ${name}',
+          id: params.id,
+          user: user.publicKey.substring(0, 8) + '...'
+        }
+      })
+
+      // POST /api/${name}
+      .post('/', ({ request, body }) => {
+        const user = getCryptoAuthUser(request)!
+        const data = body as any
+
+        return {
+          success: true,
+          message: '${pascalName} criado com sucesso',
+          createdBy: user.publicKey.substring(0, 8) + '...',
+          data
+        }
+      }, {
+        body: t.Object({
+          // Adicione seus campos aqui
+          name: t.String({ minLength: 3 })
+        })
+      })
+
+      // PUT /api/${name}/:id
+      .put('/:id', ({ request, params, body }) => {
+        const user = getCryptoAuthUser(request)!
+        const data = body as any
+
+        return {
+          success: true,
+          message: '${pascalName} atualizado',
+          id: params.id,
+          updatedBy: user.publicKey.substring(0, 8) + '...',
+          data
+        }
+      }, {
+        body: t.Object({
+          name: t.String({ minLength: 3 })
+        })
+      })
+
+      // DELETE /api/${name}/:id
+      .delete('/:id', ({ request, params }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: '${pascalName} deletado',
+          id: params.id,
+          deletedBy: user.publicKey.substring(0, 8) + '...'
+        }
+      })
+  )
+`,
+
+  admin: (name: string, pascalName: string) => `/**
+ * ${pascalName} Routes
+ * 👑 Apenas administradores
+ * Auto-gerado pelo comando: flux crypto-auth:make:route ${name} --auth admin
+ */
+
+import { Elysia, t } from 'elysia'
+import { cryptoAuthAdmin, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+export const ${name}Routes = new Elysia({ prefix: '/${name}' })
+
+  // ========================================
+  // 👑 ROTAS ADMIN (apenas administradores)
+  // ========================================
+  .guard({}, (app) =>
+    app.use(cryptoAuthAdmin())
+
+      // GET /api/${name}
+      .get('/', ({ request }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: 'Painel administrativo de ${name}',
+          admin: user.publicKey.substring(0, 8) + '...',
+          data: []
+        }
+      })
+
+      // POST /api/${name}
+      .post('/', ({ request, body }) => {
+        const user = getCryptoAuthUser(request)!
+        const data = body as any
+
+        return {
+          success: true,
+          message: '${pascalName} criado pelo admin',
+          admin: user.publicKey.substring(0, 8) + '...',
+          data
+        }
+      }, {
+        body: t.Object({
+          name: t.String({ minLength: 3 })
+        })
+      })
+
+      // DELETE /api/${name}/:id
+      .delete('/:id', ({ request, params }) => {
+        const user = getCryptoAuthUser(request)!
+
+        return {
+          success: true,
+          message: '${pascalName} deletado pelo admin',
+          id: params.id,
+          admin: user.publicKey.substring(0, 8) + '...'
+        }
+      })
+  )
+`,
+
+  optional: (name: string, pascalName: string) => `/**
+ * ${pascalName} Routes
+ * 🌓 Autenticação opcional
+ * Auto-gerado pelo comando: flux crypto-auth:make:route ${name} --auth optional
+ */
+
+import { Elysia } from 'elysia'
+import { cryptoAuthOptional, getCryptoAuthUser } from '@/plugins/crypto-auth/server'
+
+export const ${name}Routes = new Elysia({ prefix: '/${name}' })
+
+  // ========================================
+  // 🌐 ROTA PÚBLICA
+  // ========================================
+  .get('/', () => ({
+    success: true,
+    message: 'Lista pública de ${name}',
+    data: []
+  }))
+
+  // ========================================
+  // 🌓 ROTAS COM AUTH OPCIONAL
+  // ========================================
+  .guard({}, (app) =>
+    app.use(cryptoAuthOptional())
+
+      // GET /api/${name}/:id
+      .get('/:id', ({ request, params }) => {
+        const user = getCryptoAuthUser(request)
+        const isAuthenticated = !!user
+
+        return {
+          success: true,
+          id: params.id,
+          message: isAuthenticated
+            ? \`${pascalName} personalizado para \${user.publicKey.substring(0, 8)}...\`
+            : 'Visualização pública de ${name}',
+          // Conteúdo extra apenas para autenticados
+          premiumContent: isAuthenticated ? 'Conteúdo exclusivo' : null,
+          viewer: isAuthenticated
+            ? user.publicKey.substring(0, 8) + '...'
+            : 'Visitante anônimo'
+        }
+      })
+  )
+`,
+
+  public: (name: string, pascalName: string) => `/**
+ * ${pascalName} Routes
+ * 🌐 Totalmente público
+ * Auto-gerado pelo comando: flux crypto-auth:make:route ${name} --auth public
+ */
+
+import { Elysia } from 'elysia'
+
+export const ${name}Routes = new Elysia({ prefix: '/${name}' })
+
+  // ========================================
+  // 🌐 ROTAS PÚBLICAS
+  // ========================================
+
+  // GET /api/${name}
+  .get('/', () => ({
+    success: true,
+    message: 'Lista de ${name}',
+    data: []
+  }))
+
+  // GET /api/${name}/:id
+  .get('/:id', ({ params }) => ({
+    success: true,
+    id: params.id,
+    message: 'Detalhes de ${name}'
+  }))
+`
+}
+
+function toPascalCase(str: string): string {
+  return str
+    .split(/[-_]/)
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('')
+}
+
+export const makeProtectedRouteCommand: CliCommand = {
+  name: 'crypto-auth:make:route',
+  description: 'Gera um arquivo de rotas com proteção crypto-auth',
+  category: 'Crypto Auth',
+  aliases: ['crypto-auth:generate:route'],
+
+  arguments: [
+    {
+      name: 'name',
+      description: 'Nome da rota (ex: posts, users, admin)',
+      required: true,
+      type: 'string'
+    }
+  ],
+
+  options: [
+    {
+      name: 'auth',
+      short: 'a',
+      description: 'Tipo de autenticação (required, admin, optional, public)',
+      type: 'string',
+      default: 'required',
+      choices: ['required', 'admin', 'optional', 'public']
+    },
+    {
+      name: 'output',
+      short: 'o',
+      description: 'Diretório de saída (padrão: app/server/routes)',
+      type: 'string',
+      default: 'app/server/routes'
+    },
+    {
+      name: 'force',
+      short: 'f',
+      description: 'Sobrescrever arquivo existente',
+      type: 'boolean',
+      default: false
+    }
+  ],
+
+  examples: [
+    'flux crypto-auth:make:route posts',
+    'flux crypto-auth:make:route admin --auth admin',
+    'flux crypto-auth:make:route feed --auth optional',
+    'flux crypto-auth:make:route articles --auth required --force'
+  ],
+
+  handler: async (args, options, context) => {
+    const [name] = args as [string]
+    const { auth, output, force } = options as {
+      auth: 'required' | 'admin' | 'optional' | 'public'
+      output: string
+      force: boolean
+    }
+
+    // Validar nome
+    if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+      console.error('❌ Nome inválido. Use apenas letras minúsculas, números e hífens.')
+      console.error('   Exemplos válidos: posts, my-posts, user-settings')
+      return
+    }
+
+    const pascalName = toPascalCase(name)
+    const fileName = `${name}.routes.ts`
+    const outputDir = join(context.workingDir, output)
+    const filePath = join(outputDir, fileName)
+
+    // Verificar se arquivo existe
+    if (existsSync(filePath) && !force) {
+      console.error(`❌ Arquivo já existe: ${filePath}`)
+      console.error('   Use --force para sobrescrever')
+      return
+    }
+
+    // Criar diretório se não existir
+    if (!existsSync(outputDir)) {
+      mkdirSync(outputDir, { recursive: true })
+    }
+
+    // Gerar código
+    const template = ROUTE_TEMPLATES[auth]
+    const code = template(name, pascalName)
+
+    // Escrever arquivo
+    writeFileSync(filePath, code, 'utf-8')
+
+    console.log(`\n✅ Rota criada com sucesso!`)
+    console.log(`📁 Arquivo: ${filePath}`)
+    console.log(`🔐 Tipo de auth: ${auth}`)
+
+    // Instruções de uso
+    console.log(`\n📋 Próximos passos:`)
+    console.log(`\n1. Importar a rota em app/server/routes/index.ts:`)
+    console.log(`   import { ${name}Routes } from './${name}.routes'`)
+    console.log(`\n2. Registrar no apiRoutes:`)
+    console.log(`   export const apiRoutes = new Elysia({ prefix: '/api' })`)
+    console.log(`     .use(${name}Routes)`)
+    console.log(`\n3. Rotas disponíveis:`)
+
+    const routes = {
+      required: [
+        `GET    /api/${name}`,
+        `GET    /api/${name}/:id`,
+        `POST   /api/${name}`,
+        `PUT    /api/${name}/:id`,
+        `DELETE /api/${name}/:id`
+      ],
+      admin: [
+        `GET    /api/${name}`,
+        `POST   /api/${name}`,
+        `DELETE /api/${name}/:id`
+      ],
+      optional: [
+        `GET    /api/${name}`,
+        `GET    /api/${name}/:id`
+      ],
+      public: [
+        `GET    /api/${name}`,
+        `GET    /api/${name}/:id`
+      ]
+    }
+
+    routes[auth].forEach(route => console.log(`   ${route}`))
+
+    console.log(`\n4. Testar (sem auth):`)
+    console.log(`   curl http://localhost:3000/api/${name}`)
+
+    if (auth !== 'public') {
+      const expectedStatus = auth === 'optional' ? '200 (sem conteúdo premium)' : '401'
+      console.log(`   Esperado: ${expectedStatus}`)
+    }
+
+    console.log(`\n🚀 Pronto! Inicie o servidor com: bun run dev`)
+  }
+}
diff --git a/plugins/crypto-auth/client/CryptoAuthClient.ts b/plugins/crypto-auth/client/CryptoAuthClient.ts
index f4161e07..574cd24b 100644
--- a/plugins/crypto-auth/client/CryptoAuthClient.ts
+++ b/plugins/crypto-auth/client/CryptoAuthClient.ts
@@ -1,27 +1,27 @@
 /**
  * Cliente de Autenticação Criptográfica
- * Gerencia autenticação no lado do cliente
+ * Sistema baseado em assinatura Ed25519 SEM sessões no servidor
+ *
+ * Funcionamento:
+ * 1. Cliente gera par de chaves Ed25519 localmente
+ * 2. Chave privada NUNCA sai do navegador
+ * 3. Cada requisição é assinada automaticamente
+ * 4. Servidor valida assinatura usando chave pública recebida
  */
 
 import { ed25519 } from '@noble/curves/ed25519'
 import { sha256 } from '@noble/hashes/sha256'
 import { bytesToHex, hexToBytes } from '@noble/hashes/utils'
 
-export interface SessionInfo {
-  sessionId: string
+export interface KeyPair {
   publicKey: string
   privateKey: string
-  isAdmin: boolean
-  permissions: string[]
   createdAt: Date
-  lastUsed: Date
 }
 
 export interface AuthConfig {
-  apiBaseUrl?: string
   storage?: 'localStorage' | 'sessionStorage' | 'memory'
   autoInit?: boolean
-  sessionTimeout?: number
 }
 
 export interface SignedRequestOptions extends RequestInit {
@@ -29,16 +29,15 @@ export interface SignedRequestOptions extends RequestInit {
 }
 
 export class CryptoAuthClient {
-  private session: SessionInfo | null = null
+  private keys: KeyPair | null = null
   private config: AuthConfig
   private storage: Storage | Map<string, string>
+  private readonly STORAGE_KEY = 'fluxstack_crypto_keys'
 
   constructor(config: AuthConfig = {}) {
     this.config = {
-      apiBaseUrl: '',
       storage: 'localStorage',
       autoInit: true,
-      sessionTimeout: 1800000, // 30 minutos
       ...config
     }
 
@@ -58,75 +57,43 @@ export class CryptoAuthClient {
   }
 
   /**
-   * Inicializar sessão
+   * Inicializar (gerar ou carregar chaves)
    */
-  async initialize(): Promise<SessionInfo> {
-    // Tentar carregar sessão existente
-    const existingSession = this.loadSession()
-    if (existingSession && this.isSessionValid(existingSession)) {
-      this.session = existingSession
-      return existingSession
+  initialize(): KeyPair {
+    // Tentar carregar chaves existentes
+    const existingKeys = this.loadKeys()
+    if (existingKeys) {
+      this.keys = existingKeys
+      return existingKeys
     }
 
-    // Criar nova sessão
-    return this.createNewSession()
+    // Criar novo par de chaves
+    return this.createNewKeys()
   }
 
   /**
-   * Criar nova sessão
+   * Criar novo par de chaves
+   * NUNCA envia chave privada ao servidor!
    */
-  async createNewSession(): Promise<SessionInfo> {
-    try {
-      // Gerar par de chaves
-      const privateKey = ed25519.utils.randomPrivateKey()
-      const publicKey = ed25519.getPublicKey(privateKey)
-      
-      const sessionId = bytesToHex(publicKey)
-      const privateKeyHex = bytesToHex(privateKey)
-
-      // Registrar sessão no servidor
-      const response = await fetch(`${this.config.apiBaseUrl}/api/auth/session/init`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({
-          publicKey: sessionId
-        })
-      })
-
-      if (!response.ok) {
-        throw new Error(`Erro ao inicializar sessão: ${response.statusText}`)
-      }
-
-      const result = await response.json()
-      if (!result.success) {
-        throw new Error(result.error || 'Erro desconhecido ao inicializar sessão')
-      }
-
-      // Criar objeto de sessão
-      const session: SessionInfo = {
-        sessionId,
-        publicKey: sessionId,
-        privateKey: privateKeyHex,
-        isAdmin: result.user?.isAdmin || false,
-        permissions: result.user?.permissions || ['read'],
-        createdAt: new Date(),
-        lastUsed: new Date()
-      }
+  createNewKeys(): KeyPair {
+    // Gerar par de chaves Ed25519
+    const privateKey = ed25519.utils.randomPrivateKey()
+    const publicKey = ed25519.getPublicKey(privateKey)
+
+    const keys: KeyPair = {
+      publicKey: bytesToHex(publicKey),
+      privateKey: bytesToHex(privateKey),
+      createdAt: new Date()
+    }
 
-      this.session = session
-      this.saveSession(session)
+    this.keys = keys
+    this.saveKeys(keys)
 
-      return session
-    } catch (error) {
-      console.error('Erro ao criar nova sessão:', error)
-      throw error
-    }
+    return keys
   }
 
   /**
-   * Fazer requisição autenticada
+   * Fazer requisição autenticada com assinatura
    */
   async fetch(url: string, options: SignedRequestOptions = {}): Promise<Response> {
     const { skipAuth = false, ...fetchOptions } = options
@@ -135,33 +102,30 @@ export class CryptoAuthClient {
       return fetch(url, fetchOptions)
     }
 
-    if (!this.session) {
-      await this.initialize()
+    if (!this.keys) {
+      this.initialize()
     }
 
-    if (!this.session) {
-      throw new Error('Sessão não inicializada')
+    if (!this.keys) {
+      throw new Error('Chaves não inicializadas')
     }
 
-    // Preparar headers de autenticação
+    // Preparar dados de autenticação
     const timestamp = Date.now()
     const nonce = this.generateNonce()
     const message = this.buildMessage(fetchOptions.method || 'GET', url, fetchOptions.body)
     const signature = this.signMessage(message, timestamp, nonce)
 
+    // Adicionar headers de autenticação
     const headers = {
       'Content-Type': 'application/json',
       ...fetchOptions.headers,
-      'x-session-id': this.session.sessionId,
+      'x-public-key': this.keys.publicKey,
       'x-timestamp': timestamp.toString(),
       'x-nonce': nonce,
       'x-signature': signature
     }
 
-    // Atualizar último uso
-    this.session.lastUsed = new Date()
-    this.saveSession(this.session)
-
     return fetch(url, {
       ...fetchOptions,
       headers
@@ -169,74 +133,102 @@ export class CryptoAuthClient {
   }
 
   /**
-   * Obter informações da sessão atual
+   * Obter chaves atuais
    */
-  getSession(): SessionInfo | null {
-    return this.session
+  getKeys(): KeyPair | null {
+    return this.keys
   }
 
   /**
-   * Verificar se está autenticado
+   * Verificar se tem chaves
    */
-  isAuthenticated(): boolean {
-    return this.session !== null && this.isSessionValid(this.session)
+  isInitialized(): boolean {
+    return this.keys !== null
   }
 
   /**
-   * Verificar se é admin
+   * Limpar chaves (logout)
    */
-  isAdmin(): boolean {
-    return this.session?.isAdmin || false
+  clearKeys(): void {
+    this.keys = null
+    if (this.storage instanceof Map) {
+      this.storage.delete(this.STORAGE_KEY)
+    } else {
+      this.storage.removeItem(this.STORAGE_KEY)
+    }
   }
 
   /**
-   * Obter permissões
+   * Importar chave privada existente
+   * @param privateKeyHex - Chave privada em formato hexadecimal (64 caracteres)
+   * @returns KeyPair com as chaves importadas
+   * @throws Error se a chave privada for inválida
    */
-  getPermissions(): string[] {
-    return this.session?.permissions || []
+  importPrivateKey(privateKeyHex: string): KeyPair {
+    // Validar formato
+    if (!/^[a-fA-F0-9]{64}$/.test(privateKeyHex)) {
+      throw new Error('Chave privada inválida. Deve ter 64 caracteres hexadecimais.')
+    }
+
+    try {
+      // Converter hex para bytes
+      const privateKeyBytes = hexToBytes(privateKeyHex)
+
+      // Derivar chave pública da privada
+      const publicKeyBytes = ed25519.getPublicKey(privateKeyBytes)
+
+      const keys: KeyPair = {
+        publicKey: bytesToHex(publicKeyBytes),
+        privateKey: privateKeyHex.toLowerCase(),
+        createdAt: new Date()
+      }
+
+      this.keys = keys
+      this.saveKeys(keys)
+
+      return keys
+    } catch (error) {
+      throw new Error('Erro ao importar chave privada: ' + (error as Error).message)
+    }
   }
 
   /**
-   * Fazer logout
+   * Exportar chave privada (para backup)
+   * @returns Chave privada em formato hexadecimal
+   * @throws Error se não houver chaves inicializadas
    */
-  async logout(): Promise<void> {
-    if (this.session) {
-      try {
-        await this.fetch(`${this.config.apiBaseUrl}/api/auth/session/logout`, {
-          method: 'POST'
-        })
-      } catch (error) {
-        console.warn('Erro ao fazer logout no servidor:', error)
-      }
-
-      this.session = null
-      this.clearSession()
+  exportPrivateKey(): string {
+    if (!this.keys) {
+      throw new Error('Nenhuma chave inicializada para exportar')
     }
+
+    return this.keys.privateKey
   }
 
   /**
    * Assinar mensagem
    */
   private signMessage(message: string, timestamp: number, nonce: string): string {
-    if (!this.session) {
-      throw new Error('Sessão não inicializada')
+    if (!this.keys) {
+      throw new Error('Chaves não inicializadas')
     }
 
-    const fullMessage = `${this.session.sessionId}:${timestamp}:${nonce}:${message}`
+    // Construir mensagem completa: publicKey:timestamp:nonce:message
+    const fullMessage = `${this.keys.publicKey}:${timestamp}:${nonce}:${message}`
     const messageHash = sha256(new TextEncoder().encode(fullMessage))
-    const privateKeyBytes = hexToBytes(this.session.privateKey)
+
+    const privateKeyBytes = hexToBytes(this.keys.privateKey)
     const signature = ed25519.sign(messageHash, privateKeyBytes)
-    
+
     return bytesToHex(signature)
   }
 
   /**
    * Construir mensagem para assinatura
    */
-  private buildMessage(method: string, url: string, body?: any): string {
-    const urlObj = new URL(url, window.location.origin)
-    let message = `${method}:${urlObj.pathname}`
-    
+  private buildMessage(method: string, url: string, body?: BodyInit | null): string {
+    let message = `${method}:${url}`
+
     if (body) {
       if (typeof body === 'string') {
         message += `:${body}`
@@ -252,74 +244,59 @@ export class CryptoAuthClient {
    * Gerar nonce aleatório
    */
   private generateNonce(): string {
-    const array = new Uint8Array(16)
-    crypto.getRandomValues(array)
-    return bytesToHex(array)
-  }
-
-  /**
-   * Verificar se sessão é válida
-   */
-  private isSessionValid(session: SessionInfo): boolean {
-    const now = Date.now()
-    const sessionAge = now - session.lastUsed.getTime()
-    return sessionAge < (this.config.sessionTimeout || 1800000)
-  }
-
-  /**
-   * Salvar sessão no storage
-   */
-  private saveSession(session: SessionInfo): void {
-    const sessionData = JSON.stringify({
-      ...session,
-      createdAt: session.createdAt.toISOString(),
-      lastUsed: session.lastUsed.toISOString()
-    })
-
-    if (this.storage instanceof Map) {
-      this.storage.set('crypto-auth-session', sessionData)
-    } else {
-      this.storage.setItem('crypto-auth-session', sessionData)
-    }
+    const bytes = new Uint8Array(16)
+    crypto.getRandomValues(bytes)
+    return bytesToHex(bytes)
   }
 
   /**
-   * Carregar sessão do storage
+   * Carregar chaves do storage
    */
-  private loadSession(): SessionInfo | null {
+  private loadKeys(): KeyPair | null {
     try {
-      let sessionData: string | null
+      let data: string | null
 
       if (this.storage instanceof Map) {
-        sessionData = this.storage.get('crypto-auth-session') || null
+        data = this.storage.get(this.STORAGE_KEY) || null
       } else {
-        sessionData = this.storage.getItem('crypto-auth-session')
+        data = this.storage.getItem(this.STORAGE_KEY)
       }
 
-      if (!sessionData) {
+      if (!data) {
         return null
       }
 
-      const parsed = JSON.parse(sessionData)
+      const parsed = JSON.parse(data)
+
       return {
-        ...parsed,
-        createdAt: new Date(parsed.createdAt),
-        lastUsed: new Date(parsed.lastUsed)
+        publicKey: parsed.publicKey,
+        privateKey: parsed.privateKey,
+        createdAt: new Date(parsed.createdAt)
       }
     } catch (error) {
-      console.warn('Erro ao carregar sessão:', error)
+      console.error('Erro ao carregar chaves:', error)
       return null
     }
   }
 
   /**
-   * Limpar sessão do storage
+   * Salvar chaves no storage
    */
-  private clearSession(): void {
-    if (this.storage instanceof Map) {
-      this.storage.delete('crypto-auth-session')
-    } else {
-      this.storage.removeItem('crypto-auth-session')
+  private saveKeys(keys: KeyPair): void {
+    try {
+      const data = JSON.stringify({
+        publicKey: keys.publicKey,
+        privateKey: keys.privateKey,
+        createdAt: keys.createdAt.toISOString()
+      })
+
+      if (this.storage instanceof Map) {
+        this.storage.set(this.STORAGE_KEY, data)
+      } else {
+        this.storage.setItem(this.STORAGE_KEY, data)
+      }
+    } catch (error) {
+      console.error('Erro ao salvar chaves:', error)
     }
   }
-}
\ No newline at end of file
+}
diff --git a/plugins/crypto-auth/client/components/AuthProvider.tsx b/plugins/crypto-auth/client/components/AuthProvider.tsx
index 6f02217e..b270aecc 100644
--- a/plugins/crypto-auth/client/components/AuthProvider.tsx
+++ b/plugins/crypto-auth/client/components/AuthProvider.tsx
@@ -1,22 +1,19 @@
 /**
  * Provedor de Contexto de Autenticação
- * Context Provider React para gerenciar estado de autenticação
+ * Context Provider React para gerenciar chaves criptográficas
  */
 
-import React, { createContext, useContext, useEffect, useState, ReactNode } from 'react'
-import { CryptoAuthClient, SessionInfo, AuthConfig } from '../CryptoAuthClient'
+import React, { createContext, useContext, useEffect, useState, type ReactNode } from 'react'
+import { CryptoAuthClient, type KeyPair, type AuthConfig } from '../CryptoAuthClient'
 
 export interface AuthContextValue {
   client: CryptoAuthClient
-  session: SessionInfo | null
-  isAuthenticated: boolean
-  isAdmin: boolean
-  permissions: string[]
+  keys: KeyPair | null
+  hasKeys: boolean
   isLoading: boolean
   error: string | null
-  login: () => Promise<void>
-  logout: () => Promise<void>
-  refresh: () => Promise<void>
+  createKeys: () => void
+  clearKeys: () => void
 }
 
 const AuthContext = createContext<AuthContextValue | null>(null)
@@ -24,71 +21,59 @@ const AuthContext = createContext<AuthContextValue | null>(null)
 export interface AuthProviderProps {
   children: ReactNode
   config?: AuthConfig
-  onAuthChange?: (isAuthenticated: boolean, session: SessionInfo | null) => void
+  onKeysChange?: (hasKeys: boolean, keys: KeyPair | null) => void
   onError?: (error: string) => void
 }
 
 export const AuthProvider: React.FC<AuthProviderProps> = ({
   children,
   config = {},
-  onAuthChange,
+  onKeysChange,
   onError
 }) => {
   const [client] = useState(() => new CryptoAuthClient({ ...config, autoInit: false }))
-  const [session, setSession] = useState<SessionInfo | null>(null)
+  const [keys, setKeys] = useState<KeyPair | null>(null)
   const [isLoading, setIsLoading] = useState(true)
   const [error, setError] = useState<string | null>(null)
 
-  const isAuthenticated = session !== null && client.isAuthenticated()
-  const isAdmin = session?.isAdmin || false
-  const permissions = session?.permissions || []
+  const hasKeys = keys !== null
 
   useEffect(() => {
-    initializeAuth()
+    initializeKeys()
   }, [])
 
   useEffect(() => {
-    onAuthChange?.(isAuthenticated, session)
-  }, [isAuthenticated, session, onAuthChange])
+    onKeysChange?.(hasKeys, keys)
+  }, [hasKeys, keys, onKeysChange])
 
-  const initializeAuth = async () => {
+  const initializeKeys = () => {
     setIsLoading(true)
     setError(null)
-    
+
     try {
-      const currentSession = client.getSession()
-      if (currentSession && client.isAuthenticated()) {
-        setSession(currentSession)
-      } else {
-        // Tentar inicializar automaticamente se não houver sessão
-        try {
-          const newSession = await client.initialize()
-          setSession(newSession)
-        } catch (initError) {
-          // Falha na inicialização automática é normal se não houver sessão salva
-          console.debug('Inicialização automática falhou:', initError)
-          setSession(null)
-        }
+      const existingKeys = client.getKeys()
+      if (existingKeys) {
+        setKeys(existingKeys)
       }
     } catch (err) {
       const errorMessage = err instanceof Error ? err.message : 'Erro desconhecido'
       setError(errorMessage)
       onError?.(errorMessage)
-      console.error('Erro ao inicializar autenticação:', err)
+      console.error('Erro ao inicializar chaves:', err)
     } finally {
       setIsLoading(false)
     }
   }
 
-  const login = async () => {
+  const createKeys = () => {
     setIsLoading(true)
     setError(null)
-    
+
     try {
-      const newSession = await client.createNewSession()
-      setSession(newSession)
+      const newKeys = client.createNewKeys()
+      setKeys(newKeys)
     } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : 'Erro ao fazer login'
+      const errorMessage = err instanceof Error ? err.message : 'Erro ao criar chaves'
       setError(errorMessage)
       onError?.(errorMessage)
       throw err
@@ -97,60 +82,19 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({
     }
   }
 
-  const logout = async () => {
+  const clearKeys = () => {
     setIsLoading(true)
     setError(null)
-    
-    try {
-      await client.logout()
-      setSession(null)
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : 'Erro ao fazer logout'
-      setError(errorMessage)
-      onError?.(errorMessage)
-      // Mesmo com erro, limpar a sessão local
-      setSession(null)
-    } finally {
-      setIsLoading(false)
-    }
-  }
 
-  const refresh = async () => {
-    setIsLoading(true)
-    setError(null)
-    
     try {
-      // Verificar se a sessão atual ainda é válida
-      const currentSession = client.getSession()
-      if (currentSession && client.isAuthenticated()) {
-        // Tentar fazer uma requisição de teste para validar no servidor
-        const response = await client.fetch('/api/auth/session/info')
-        if (response.ok) {
-          const result = await response.json()
-          if (result.success && result.session) {
-            // Atualizar informações da sessão
-            const updatedSession = {
-              ...currentSession,
-              ...result.session,
-              lastUsed: new Date()
-            }
-            setSession(updatedSession)
-          } else {
-            // Sessão inválida no servidor
-            setSession(null)
-          }
-        } else {
-          // Erro na requisição, sessão pode estar inválida
-          setSession(null)
-        }
-      } else {
-        setSession(null)
-      }
+      client.clearKeys()
+      setKeys(null)
     } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : 'Erro ao atualizar sessão'
+      const errorMessage = err instanceof Error ? err.message : 'Erro ao limpar chaves'
       setError(errorMessage)
       onError?.(errorMessage)
-      setSession(null)
+      // Mesmo com erro, limpar as chaves locais
+      setKeys(null)
     } finally {
       setIsLoading(false)
     }
@@ -158,15 +102,12 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({
 
   const contextValue: AuthContextValue = {
     client,
-    session,
-    isAuthenticated,
-    isAdmin,
-    permissions,
+    keys,
+    hasKeys,
     isLoading,
     error,
-    login,
-    logout,
-    refresh
+    createKeys,
+    clearKeys
   }
 
   return (
diff --git a/plugins/crypto-auth/client/components/LoginButton.tsx b/plugins/crypto-auth/client/components/LoginButton.tsx
index 3c7804a8..1b43c0ea 100644
--- a/plugins/crypto-auth/client/components/LoginButton.tsx
+++ b/plugins/crypto-auth/client/components/LoginButton.tsx
@@ -1,20 +1,19 @@
 /**
  * Componente de Botão de Login
- * Componente React para autenticação criptográfica
+ * Componente React para autenticação criptográfica baseada em keypair
  */
 
 import React, { useState, useEffect } from 'react'
-import { CryptoAuthClient } from '../CryptoAuthClient'
+import { CryptoAuthClient, type KeyPair } from '../CryptoAuthClient'
 
 export interface LoginButtonProps {
-  onLogin?: (session: any) => void
+  onLogin?: (keys: KeyPair) => void
   onLogout?: () => void
   onError?: (error: string) => void
   className?: string
   loginText?: string
   logoutText?: string
   loadingText?: string
-  showPermissions?: boolean
   authClient?: CryptoAuthClient
 }
 
@@ -23,64 +22,63 @@ export const LoginButton: React.FC<LoginButtonProps> = ({
   onLogout,
   onError,
   className = '',
-  loginText = 'Entrar',
-  logoutText = 'Sair',
+  loginText = 'Gerar Chaves',
+  logoutText = 'Limpar Chaves',
   loadingText = 'Carregando...',
-  showPermissions = false,
   authClient
 }) => {
-  const [client] = useState(() => authClient || new CryptoAuthClient())
-  const [isAuthenticated, setIsAuthenticated] = useState(false)
+  const [client] = useState(() => authClient || new CryptoAuthClient({ autoInit: false }))
+  const [hasKeys, setHasKeys] = useState(false)
   const [isLoading, setIsLoading] = useState(false)
-  const [session, setSession] = useState<any>(null)
+  const [keys, setKeys] = useState<KeyPair | null>(null)
 
   useEffect(() => {
-    checkAuthStatus()
+    checkKeysStatus()
   }, [])
 
-  const checkAuthStatus = async () => {
+  const checkKeysStatus = () => {
     try {
-      const currentSession = client.getSession()
-      if (currentSession && client.isAuthenticated()) {
-        setIsAuthenticated(true)
-        setSession(currentSession)
+      const existingKeys = client.getKeys()
+      if (existingKeys) {
+        setHasKeys(true)
+        setKeys(existingKeys)
       } else {
-        setIsAuthenticated(false)
-        setSession(null)
+        setHasKeys(false)
+        setKeys(null)
       }
     } catch (error) {
-      console.error('Erro ao verificar status de autenticação:', error)
-      setIsAuthenticated(false)
-      setSession(null)
+      console.error('Erro ao verificar chaves:', error)
+      setHasKeys(false)
+      setKeys(null)
     }
   }
 
-  const handleLogin = async () => {
+  const handleLogin = () => {
     setIsLoading(true)
     try {
-      const newSession = await client.initialize()
-      setIsAuthenticated(true)
-      setSession(newSession)
-      onLogin?.(newSession)
+      const newKeys = client.createNewKeys()
+      setHasKeys(true)
+      setKeys(newKeys)
+      onLogin?.(newKeys)
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Erro desconhecido'
-      console.error('Erro ao fazer login:', error)
+      console.error('Erro ao gerar chaves:', error)
       onError?.(errorMessage)
     } finally {
       setIsLoading(false)
     }
   }
 
-  const handleLogout = async () => {
+  const handleLogout = () => {
     setIsLoading(true)
     try {
-      await client.logout()
-      setIsAuthenticated(false)
-      setSession(null)
+      client.clearKeys()
+      setHasKeys(false)
+      setKeys(null)
       onLogout?.()
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Erro desconhecido'
-      console.error('Erro ao fazer logout:', error)
+      console.error('Erro ao limpar chaves:', error)
       onError?.(errorMessage)
     } finally {
       setIsLoading(false)
@@ -104,34 +102,19 @@ export const LoginButton: React.FC<LoginButtonProps> = ({
     )
   }
 
-  if (isAuthenticated) {
+  if (hasKeys && keys) {
     return (
       <div className="flex items-center gap-3">
         <div className="flex items-center gap-2">
           <div className="w-2 h-2 bg-green-500 rounded-full"></div>
           <span className="text-sm text-gray-600">
             Autenticado
-            {session?.isAdmin && (
-              <span className="ml-1 px-2 py-0.5 bg-blue-100 text-blue-800 text-xs rounded-full">
-                Admin
-              </span>
-            )}
           </span>
+          <code className="text-xs bg-gray-100 px-2 py-1 rounded">
+            {keys.publicKey.substring(0, 16)}...
+          </code>
         </div>
-        
-        {showPermissions && session?.permissions && (
-          <div className="flex gap-1">
-            {session.permissions.map((permission: string) => (
-              <span
-                key={permission}
-                className="px-2 py-0.5 bg-gray-100 text-gray-700 text-xs rounded-full"
-              >
-                {permission}
-              </span>
-            ))}
-          </div>
-        )}
-        
+
         <button
           onClick={handleLogout}
           className={`${baseClassName} bg-red-600 hover:bg-red-700 text-white focus:ring-red-500 ${className}`}
@@ -152,4 +135,4 @@ export const LoginButton: React.FC<LoginButtonProps> = ({
   )
 }
 
-export default LoginButton
\ No newline at end of file
+export default LoginButton
diff --git a/plugins/crypto-auth/client/components/ProtectedRoute.tsx b/plugins/crypto-auth/client/components/ProtectedRoute.tsx
index b7128e15..85add709 100644
--- a/plugins/crypto-auth/client/components/ProtectedRoute.tsx
+++ b/plugins/crypto-auth/client/components/ProtectedRoute.tsx
@@ -1,15 +1,16 @@
 /**
  * Componente de Rota Protegida
- * Protege componentes que requerem autenticação
+ * Protege componentes que requerem chaves criptográficas no client-side
+ *
+ * NOTA: Este componente apenas verifica se há chaves locais.
+ * A autenticação real acontece no backend via validação de assinatura.
  */
 
-import React, { ReactNode } from 'react'
+import React, { type ReactNode } from 'react'
 import { useAuth } from './AuthProvider'
 
 export interface ProtectedRouteProps {
   children: ReactNode
-  requireAdmin?: boolean
-  requiredPermissions?: string[]
   fallback?: ReactNode
   loadingComponent?: ReactNode
   unauthorizedComponent?: ReactNode
@@ -17,19 +18,17 @@ export interface ProtectedRouteProps {
 
 export const ProtectedRoute: React.FC<ProtectedRouteProps> = ({
   children,
-  requireAdmin = false,
-  requiredPermissions = [],
   fallback,
   loadingComponent,
   unauthorizedComponent
 }) => {
-  const { isAuthenticated, isAdmin, permissions, isLoading, error } = useAuth()
+  const { hasKeys, isLoading, error } = useAuth()
 
   // Componente de loading padrão
   const defaultLoadingComponent = (
     <div className="flex items-center justify-center p-8">
       <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600"></div>
-      <span className="ml-3 text-gray-600">Verificando autenticação...</span>
+      <span className="ml-3 text-gray-600">Verificando chaves...</span>
     </div>
   )
 
@@ -41,14 +40,9 @@ export const ProtectedRoute: React.FC<ProtectedRouteProps> = ({
           <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 15v2m-6 4h12a2 2 0 002-2v-6a2 2 0 00-2-2H6a2 2 0 00-2 2v6a2 2 0 002 2zm10-10V7a4 4 0 00-8 0v4h8z" />
         </svg>
       </div>
-      <h3 className="text-lg font-semibold text-red-800 mb-2">Acesso Negado</h3>
+      <h3 className="text-lg font-semibold text-red-800 mb-2">Chaves Não Encontradas</h3>
       <p className="text-red-600 text-center">
-        {!isAuthenticated 
-          ? 'Você precisa estar autenticado para acessar esta página.'
-          : requireAdmin && !isAdmin
-          ? 'Você precisa de privilégios de administrador para acessar esta página.'
-          : 'Você não tem as permissões necessárias para acessar esta página.'
-        }
+        Você precisa gerar chaves criptográficas para acessar esta página.
       </p>
       {error && (
         <p className="text-red-500 text-sm mt-2">
@@ -58,33 +52,19 @@ export const ProtectedRoute: React.FC<ProtectedRouteProps> = ({
     </div>
   )
 
-  // Mostrar loading enquanto verifica autenticação
+  // Mostrar loading enquanto verifica
   if (isLoading) {
     return <>{loadingComponent || defaultLoadingComponent}</>
   }
 
-  // Verificar se está autenticado
-  if (!isAuthenticated) {
+  // Verificar se tem chaves
+  if (!hasKeys) {
     return <>{unauthorizedComponent || fallback || defaultUnauthorizedComponent}</>
   }
 
-  // Verificar se requer admin
-  if (requireAdmin && !isAdmin) {
-    return <>{unauthorizedComponent || fallback || defaultUnauthorizedComponent}</>
-  }
-
-  // Verificar permissões específicas
-  if (requiredPermissions.length > 0) {
-    const hasRequiredPermissions = requiredPermissions.every(permission => 
-      permissions.includes(permission) || permissions.includes('admin')
-    )
-
-    if (!hasRequiredPermissions) {
-      return <>{unauthorizedComponent || fallback || defaultUnauthorizedComponent}</>
-    }
-  }
-
-  // Usuário autorizado, renderizar children
+  // Tem chaves, renderizar children
+  // NOTA: Isso não garante autenticação no backend!
+  // O backend ainda validará a assinatura em cada requisição.
   return <>{children}</>
 }
 
@@ -102,8 +82,8 @@ export function withAuth<P extends object>(
   )
 
   WrappedComponent.displayName = `withAuth(${Component.displayName || Component.name})`
-  
+
   return WrappedComponent
 }
 
-export default ProtectedRoute
\ No newline at end of file
+export default ProtectedRoute
diff --git a/plugins/crypto-auth/client/components/SessionInfo.tsx b/plugins/crypto-auth/client/components/SessionInfo.tsx
deleted file mode 100644
index d669c5cc..00000000
--- a/plugins/crypto-auth/client/components/SessionInfo.tsx
+++ /dev/null
@@ -1,242 +0,0 @@
-/**
- * Componente de Informações da Sessão
- * Exibe informações detalhadas sobre a sessão atual
- */
-
-import React, { useState } from 'react'
-import { useAuth } from './AuthProvider'
-
-export interface SessionInfoProps {
-  className?: string
-  showPrivateKey?: boolean
-  showFullSessionId?: boolean
-  compact?: boolean
-}
-
-export const SessionInfo: React.FC<SessionInfoProps> = ({
-  className = '',
-  showPrivateKey = false,
-  showFullSessionId = false,
-  compact = false
-}) => {
-  const { session, isAuthenticated, isAdmin, permissions, isLoading } = useAuth()
-  const [showDetails, setShowDetails] = useState(!compact)
-
-  if (isLoading) {
-    return (
-      <div className={`animate-pulse ${className}`}>
-        <div className="h-4 bg-gray-200 rounded w-3/4 mb-2"></div>
-        <div className="h-4 bg-gray-200 rounded w-1/2"></div>
-      </div>
-    )
-  }
-
-  if (!isAuthenticated || !session) {
-    return (
-      <div className={`text-gray-500 ${className}`}>
-        <p>Não autenticado</p>
-      </div>
-    )
-  }
-
-  const formatDate = (date: Date) => {
-    return new Intl.DateTimeFormat('pt-BR', {
-      dateStyle: 'short',
-      timeStyle: 'medium'
-    }).format(date)
-  }
-
-  const truncateId = (id: string, length: number = 8) => {
-    return showFullSessionId ? id : `${id.substring(0, length)}...`
-  }
-
-  const copyToClipboard = async (text: string) => {
-    try {
-      await navigator.clipboard.writeText(text)
-      // Você pode adicionar um toast/notification aqui
-    } catch (err) {
-      console.error('Erro ao copiar para clipboard:', err)
-    }
-  }
-
-  if (compact) {
-    return (
-      <div className={`flex items-center gap-2 ${className}`}>
-        <div className="flex items-center gap-2">
-          <div className="w-2 h-2 bg-green-500 rounded-full"></div>
-          <span className="text-sm font-medium">
-            {truncateId(session.sessionId)}
-          </span>
-          {isAdmin && (
-            <span className="px-2 py-0.5 bg-blue-100 text-blue-800 text-xs rounded-full">
-              Admin
-            </span>
-          )}
-        </div>
-        <button
-          onClick={() => setShowDetails(!showDetails)}
-          className="text-gray-400 hover:text-gray-600 transition-colors"
-        >
-          <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
-          </svg>
-        </button>
-        
-        {showDetails && (
-          <div className="absolute z-10 mt-2 p-4 bg-white border border-gray-200 rounded-lg shadow-lg min-w-80">
-            <SessionDetails 
-              session={session}
-              isAdmin={isAdmin}
-              permissions={permissions}
-              showPrivateKey={showPrivateKey}
-              showFullSessionId={showFullSessionId}
-              onCopy={copyToClipboard}
-            />
-          </div>
-        )}
-      </div>
-    )
-  }
-
-  return (
-    <div className={`bg-white border border-gray-200 rounded-lg p-4 ${className}`}>
-      <SessionDetails 
-        session={session}
-        isAdmin={isAdmin}
-        permissions={permissions}
-        showPrivateKey={showPrivateKey}
-        showFullSessionId={showFullSessionId}
-        onCopy={copyToClipboard}
-      />
-    </div>
-  )
-}
-
-interface SessionDetailsProps {
-  session: any
-  isAdmin: boolean
-  permissions: string[]
-  showPrivateKey: boolean
-  showFullSessionId: boolean
-  onCopy: (text: string) => void
-}
-
-const SessionDetails: React.FC<SessionDetailsProps> = ({
-  session,
-  isAdmin,
-  permissions,
-  showPrivateKey,
-  showFullSessionId,
-  onCopy
-}) => {
-  const formatDate = (date: Date) => {
-    return new Intl.DateTimeFormat('pt-BR', {
-      dateStyle: 'short',
-      timeStyle: 'medium'
-    }).format(date)
-  }
-
-  const CopyButton: React.FC<{ text: string }> = ({ text }) => (
-    <button
-      onClick={() => onCopy(text)}
-      className="ml-2 text-gray-400 hover:text-gray-600 transition-colors"
-      title="Copiar"
-    >
-      <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z" />
-      </svg>
-    </button>
-  )
-
-  return (
-    <div className="space-y-3">
-      <div className="flex items-center justify-between">
-        <h3 className="text-lg font-semibold text-gray-900">Informações da Sessão</h3>
-        <div className="flex items-center gap-2">
-          <div className="w-2 h-2 bg-green-500 rounded-full"></div>
-          <span className="text-sm text-green-600 font-medium">Ativo</span>
-        </div>
-      </div>
-
-      <div className="grid grid-cols-1 gap-3 text-sm">
-        <div>
-          <label className="block text-gray-600 font-medium mb-1">Session ID</label>
-          <div className="flex items-center">
-            <code className="bg-gray-100 px-2 py-1 rounded text-xs font-mono break-all">
-              {showFullSessionId ? session.sessionId : `${session.sessionId.substring(0, 16)}...`}
-            </code>
-            <CopyButton text={session.sessionId} />
-          </div>
-        </div>
-
-        <div>
-          <label className="block text-gray-600 font-medium mb-1">Chave Pública</label>
-          <div className="flex items-center">
-            <code className="bg-gray-100 px-2 py-1 rounded text-xs font-mono break-all">
-              {showFullSessionId ? session.publicKey : `${session.publicKey.substring(0, 16)}...`}
-            </code>
-            <CopyButton text={session.publicKey} />
-          </div>
-        </div>
-
-        {showPrivateKey && (
-          <div>
-            <label className="block text-red-600 font-medium mb-1">
-              Chave Privada
-              <span className="text-xs text-red-500 ml-1">(Confidencial)</span>
-            </label>
-            <div className="flex items-center">
-              <code className="bg-red-50 border border-red-200 px-2 py-1 rounded text-xs font-mono break-all">
-                {session.privateKey.substring(0, 16)}...
-              </code>
-              <CopyButton text={session.privateKey} />
-            </div>
-          </div>
-        )}
-
-        <div className="flex gap-4">
-          <div>
-            <label className="block text-gray-600 font-medium mb-1">Status</label>
-            <div className="flex items-center gap-2">
-              <span className={`px-2 py-1 rounded-full text-xs font-medium ${
-                isAdmin 
-                  ? 'bg-blue-100 text-blue-800' 
-                  : 'bg-green-100 text-green-800'
-              }`}>
-                {isAdmin ? 'Administrador' : 'Usuário'}
-              </span>
-            </div>
-          </div>
-
-          <div>
-            <label className="block text-gray-600 font-medium mb-1">Permissões</label>
-            <div className="flex flex-wrap gap-1">
-              {permissions.map((permission) => (
-                <span
-                  key={permission}
-                  className="px-2 py-0.5 bg-gray-100 text-gray-700 text-xs rounded-full"
-                >
-                  {permission}
-                </span>
-              ))}
-            </div>
-          </div>
-        </div>
-
-        <div className="flex gap-4">
-          <div>
-            <label className="block text-gray-600 font-medium mb-1">Criado em</label>
-            <span className="text-gray-800">{formatDate(session.createdAt)}</span>
-          </div>
-
-          <div>
-            <label className="block text-gray-600 font-medium mb-1">Último uso</label>
-            <span className="text-gray-800">{formatDate(session.lastUsed)}</span>
-          </div>
-        </div>
-      </div>
-    </div>
-  )
-}
-
-export default SessionInfo
\ No newline at end of file
diff --git a/plugins/crypto-auth/client/components/index.ts b/plugins/crypto-auth/client/components/index.ts
index 18369a9f..1092e65b 100644
--- a/plugins/crypto-auth/client/components/index.ts
+++ b/plugins/crypto-auth/client/components/index.ts
@@ -9,7 +9,4 @@ export { AuthProvider, useAuth } from './AuthProvider'
 export type { AuthProviderProps, AuthContextValue } from './AuthProvider'
 
 export { ProtectedRoute, withAuth } from './ProtectedRoute'
-export type { ProtectedRouteProps } from './ProtectedRoute'
-
-export { SessionInfo } from './SessionInfo'
-export type { SessionInfoProps } from './SessionInfo'
\ No newline at end of file
+export type { ProtectedRouteProps } from './ProtectedRoute'
\ No newline at end of file
diff --git a/plugins/crypto-auth/client/index.ts b/plugins/crypto-auth/client/index.ts
index a53facd3..3d9b7ad8 100644
--- a/plugins/crypto-auth/client/index.ts
+++ b/plugins/crypto-auth/client/index.ts
@@ -3,7 +3,7 @@
  */
 
 export { CryptoAuthClient } from './CryptoAuthClient'
-export type { SessionInfo, AuthConfig, SignedRequestOptions } from './CryptoAuthClient'
+export type { KeyPair, AuthConfig, SignedRequestOptions } from './CryptoAuthClient'
 
 // Componentes React
 export * from './components'
diff --git a/plugins/crypto-auth/config/index.ts b/plugins/crypto-auth/config/index.ts
new file mode 100644
index 00000000..385eb91d
--- /dev/null
+++ b/plugins/crypto-auth/config/index.ts
@@ -0,0 +1,34 @@
+/**
+ * Crypto Auth Plugin Configuration
+ * Declarative config using FluxStack config system
+ */
+
+import { defineConfig, config } from '@/core/utils/config-schema'
+
+const cryptoAuthConfigSchema = {
+  // Enable/disable plugin
+  enabled: config.boolean('CRYPTO_AUTH_ENABLED', true),
+
+  // Security settings
+  maxTimeDrift: config.number('CRYPTO_AUTH_MAX_TIME_DRIFT', 300000, false), // 5 minutes in ms
+
+  // Admin keys (array of public keys in hex format)
+  adminKeys: config.array('CRYPTO_AUTH_ADMIN_KEYS', []),
+
+  // Metrics and monitoring
+  enableMetrics: config.boolean('CRYPTO_AUTH_ENABLE_METRICS', true),
+
+  // Session configuration (for future features)
+  sessionTimeout: config.number('CRYPTO_AUTH_SESSION_TIMEOUT', 1800000, false), // 30 minutes
+
+  // Nonce configuration
+  nonceLength: config.number('CRYPTO_AUTH_NONCE_LENGTH', 16, false), // bytes
+
+  // Rate limiting (requests per minute per public key)
+  rateLimitPerMinute: config.number('CRYPTO_AUTH_RATE_LIMIT', 100, false),
+} as const
+
+export const cryptoAuthConfig = defineConfig(cryptoAuthConfigSchema)
+
+export type CryptoAuthConfig = typeof cryptoAuthConfig
+export default cryptoAuthConfig
diff --git a/plugins/crypto-auth/examples/basic-usage.tsx b/plugins/crypto-auth/examples/basic-usage.tsx
deleted file mode 100644
index ff02fd22..00000000
--- a/plugins/crypto-auth/examples/basic-usage.tsx
+++ /dev/null
@@ -1,248 +0,0 @@
-/**
- * Exemplo básico de uso do plugin Crypto Auth
- */
-
-import React from 'react'
-import { 
-  AuthProvider, 
-  useAuth, 
-  LoginButton, 
-  ProtectedRoute, 
-  SessionInfo 
-} from '../client'
-
-// Componente principal da aplicação
-function App() {
-  return (
-    <AuthProvider
-      config={{
-        apiBaseUrl: 'http://localhost:3000',
-        storage: 'localStorage',
-        sessionTimeout: 1800000 // 30 minutos
-      }}
-      onAuthChange={(isAuthenticated, session) => {
-        console.log('Status de autenticação mudou:', { isAuthenticated, session })
-      }}
-      onError={(error) => {
-        console.error('Erro de autenticação:', error)
-      }}
-    >
-      <div className="min-h-screen bg-gray-50">
-        <Header />
-        <main className="container mx-auto px-4 py-8">
-          <Dashboard />
-        </main>
-      </div>
-    </AuthProvider>
-  )
-}
-
-// Header com informações de autenticação
-function Header() {
-  return (
-    <header className="bg-white shadow-sm border-b">
-      <div className="container mx-auto px-4 py-4 flex justify-between items-center">
-        <h1 className="text-2xl font-bold text-gray-900">
-          FluxStack Crypto Auth Demo
-        </h1>
-        
-        <div className="flex items-center gap-4">
-          <SessionInfo compact={true} />
-          <LoginButton 
-            className="px-4 py-2"
-            showPermissions={true}
-            onLogin={(session) => {
-              console.log('Login realizado:', session)
-            }}
-            onLogout={() => {
-              console.log('Logout realizado')
-            }}
-            onError={(error) => {
-              alert(`Erro: ${error}`)
-            }}
-          />
-        </div>
-      </div>
-    </header>
-  )
-}
-
-// Dashboard principal
-function Dashboard() {
-  const { isAuthenticated, isLoading } = useAuth()
-
-  if (isLoading) {
-    return (
-      <div className="flex items-center justify-center py-12">
-        <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600"></div>
-        <span className="ml-3">Carregando...</span>
-      </div>
-    )
-  }
-
-  return (
-    <div className="space-y-8">
-      {/* Área pública */}
-      <PublicSection />
-      
-      {/* Área protegida */}
-      {isAuthenticated && (
-        <ProtectedSection />
-      )}
-      
-      {/* Área admin */}
-      <ProtectedRoute requireAdmin={true}>
-        <AdminSection />
-      </ProtectedRoute>
-    </div>
-  )
-}
-
-// Seção pública
-function PublicSection() {
-  return (
-    <section className="bg-white rounded-lg shadow p-6">
-      <h2 className="text-xl font-semibold mb-4">Área Pública</h2>
-      <p className="text-gray-600 mb-4">
-        Esta seção é visível para todos os usuários, autenticados ou não.
-      </p>
-      <div className="bg-blue-50 border border-blue-200 rounded p-4">
-        <h3 className="font-medium text-blue-900 mb-2">Como funciona:</h3>
-        <ul className="text-blue-800 text-sm space-y-1">
-          <li>• Clique em "Entrar" para gerar automaticamente um par de chaves Ed25519</li>
-          <li>• Sua chave privada fica apenas no seu navegador</li>
-          <li>• Todas as requisições são assinadas criptograficamente</li>
-          <li>• Sem senhas, sem cadastros, sem complicação!</li>
-        </ul>
-      </div>
-    </section>
-  )
-}
-
-// Seção protegida
-function ProtectedSection() {
-  const { client, session, permissions } = useAuth()
-  const [apiData, setApiData] = React.useState<any>(null)
-  const [loading, setLoading] = React.useState(false)
-
-  const callProtectedAPI = async () => {
-    setLoading(true)
-    try {
-      const response = await client.fetch('/api/protected/data', {
-        method: 'POST',
-        body: JSON.stringify({ message: 'Hello from client!' })
-      })
-      
-      if (response.ok) {
-        const data = await response.json()
-        setApiData(data)
-      } else {
-        const error = await response.json()
-        alert(`Erro na API: ${error.error || 'Erro desconhecido'}`)
-      }
-    } catch (error) {
-      console.error('Erro ao chamar API:', error)
-      alert('Erro ao chamar API')
-    } finally {
-      setLoading(false)
-    }
-  }
-
-  return (
-    <section className="bg-white rounded-lg shadow p-6">
-      <h2 className="text-xl font-semibold mb-4">Área Protegida</h2>
-      <p className="text-gray-600 mb-4">
-        Esta seção é visível apenas para usuários autenticados.
-      </p>
-      
-      <div className="grid grid-cols-1 md:grid-cols-2 gap-6">
-        <div>
-          <h3 className="font-medium mb-2">Suas Informações:</h3>
-          <div className="bg-gray-50 rounded p-3 text-sm">
-            <p><strong>Session ID:</strong> {session?.sessionId.substring(0, 16)}...</p>
-            <p><strong>Permissões:</strong> {permissions.join(', ')}</p>
-            <p><strong>Criado em:</strong> {session?.createdAt.toLocaleString()}</p>
-          </div>
-        </div>
-        
-        <div>
-          <h3 className="font-medium mb-2">Testar API Protegida:</h3>
-          <button
-            onClick={callProtectedAPI}
-            disabled={loading}
-            className="bg-blue-600 hover:bg-blue-700 disabled:bg-blue-400 text-white px-4 py-2 rounded transition-colors"
-          >
-            {loading ? 'Carregando...' : 'Chamar API'}
-          </button>
-          
-          {apiData && (
-            <div className="mt-3 bg-green-50 border border-green-200 rounded p-3">
-              <pre className="text-sm text-green-800">
-                {JSON.stringify(apiData, null, 2)}
-              </pre>
-            </div>
-          )}
-        </div>
-      </div>
-    </section>
-  )
-}
-
-// Seção admin
-function AdminSection() {
-  const { client } = useAuth()
-  const [stats, setStats] = React.useState<any>(null)
-
-  React.useEffect(() => {
-    loadStats()
-  }, [])
-
-  const loadStats = async () => {
-    try {
-      const response = await client.fetch('/api/admin/stats')
-      if (response.ok) {
-        const data = await response.json()
-        setStats(data)
-      }
-    } catch (error) {
-      console.error('Erro ao carregar stats:', error)
-    }
-  }
-
-  return (
-    <section className="bg-white rounded-lg shadow p-6 border-l-4 border-red-500">
-      <h2 className="text-xl font-semibold mb-4 text-red-700">
-        Área Administrativa
-      </h2>
-      <p className="text-gray-600 mb-4">
-        Esta seção é visível apenas para administradores.
-      </p>
-      
-      {stats && (
-        <div className="bg-red-50 rounded p-4">
-          <h3 className="font-medium text-red-900 mb-2">Estatísticas do Sistema:</h3>
-          <div className="grid grid-cols-2 md:grid-cols-4 gap-4 text-sm">
-            <div>
-              <div className="text-red-600 font-medium">Sessões Ativas</div>
-              <div className="text-2xl font-bold text-red-900">{stats.activeSessions}</div>
-            </div>
-            <div>
-              <div className="text-red-600 font-medium">Admins Online</div>
-              <div className="text-2xl font-bold text-red-900">{stats.adminSessions}</div>
-            </div>
-            <div>
-              <div className="text-red-600 font-medium">Total Sessões</div>
-              <div className="text-2xl font-bold text-red-900">{stats.totalSessions}</div>
-            </div>
-            <div>
-              <div className="text-red-600 font-medium">Chaves Admin</div>
-              <div className="text-2xl font-bold text-red-900">{stats.adminKeys}</div>
-            </div>
-          </div>
-        </div>
-      )}
-    </section>
-  )
-}
-
-export default App
\ No newline at end of file
diff --git a/plugins/crypto-auth/index.ts b/plugins/crypto-auth/index.ts
index a76de02c..9016d4d7 100644
--- a/plugins/crypto-auth/index.ts
+++ b/plugins/crypto-auth/index.ts
@@ -6,7 +6,15 @@
 import type { FluxStack, PluginContext, RequestContext, ResponseContext } from "../../core/plugins/types"
 
 type Plugin = FluxStack.Plugin
+import { Elysia, t } from "elysia"
 import { CryptoAuthService, AuthMiddleware } from "./server"
+import { makeProtectedRouteCommand } from "./cli/make-protected-route.command"
+
+// ✅ Plugin carrega sua própria configuração (da pasta config/ do plugin)
+import { cryptoAuthConfig } from "./config"
+
+// Store config globally for hooks to access
+let pluginConfig: any = cryptoAuthConfig
 
 export const cryptoAuthPlugin: Plugin = {
   name: "crypto-auth",
@@ -25,30 +33,15 @@ export const cryptoAuthPlugin: Plugin = {
         type: "boolean",
         description: "Habilitar autenticação criptográfica"
       },
-      sessionTimeout: {
-        type: "number",
-        minimum: 300000, // 5 minutos mínimo
-        description: "Timeout da sessão em millisegundos"
-      },
       maxTimeDrift: {
         type: "number",
         minimum: 30000,
-        description: "Máximo drift de tempo permitido em millisegundos"
+        description: "Máximo drift de tempo permitido em millisegundos (previne replay attacks)"
       },
       adminKeys: {
         type: "array",
         items: { type: "string" },
-        description: "Chaves públicas dos administradores"
-      },
-      protectedRoutes: {
-        type: "array",
-        items: { type: "string" },
-        description: "Rotas que requerem autenticação"
-      },
-      publicRoutes: {
-        type: "array",
-        items: { type: "string" },
-        description: "Rotas públicas (não requerem autenticação)"
+        description: "Chaves públicas dos administradores (hex 64 caracteres)"
       },
       enableMetrics: {
         type: "boolean",
@@ -57,174 +50,113 @@ export const cryptoAuthPlugin: Plugin = {
     },
     additionalProperties: false
   },
-  
+
   defaultConfig: {
     enabled: true,
-    sessionTimeout: 1800000, // 30 minutos
     maxTimeDrift: 300000, // 5 minutos
     adminKeys: [],
-    protectedRoutes: ["/api/admin/*", "/api/protected/*"],
-    publicRoutes: ["/api/auth/*", "/api/health", "/api/docs"],
     enableMetrics: true
   },
 
+  // CLI Commands
+  commands: [
+    makeProtectedRouteCommand
+  ],
+
   setup: async (context: PluginContext) => {
-    const config = getPluginConfig(context)
-    
-    if (!config.enabled) {
+    // ✅ Plugin usa sua própria configuração (já importada no topo)
+    if (!cryptoAuthConfig.enabled) {
       context.logger.info('Crypto Auth plugin desabilitado por configuração')
       return
     }
 
-    // Inicializar serviço de autenticação
+    // Inicializar serviço de autenticação (SEM SESSÕES)
     const authService = new CryptoAuthService({
-      sessionTimeout: config.sessionTimeout,
-      maxTimeDrift: config.maxTimeDrift,
-      adminKeys: config.adminKeys,
+      maxTimeDrift: cryptoAuthConfig.maxTimeDrift,
+      adminKeys: cryptoAuthConfig.adminKeys,
       logger: context.logger
     })
 
-    // Inicializar middleware de autenticação
+    // Inicializar middleware de autenticação (sem path matching)
     const authMiddleware = new AuthMiddleware(authService, {
-      protectedRoutes: config.protectedRoutes,
-      publicRoutes: config.publicRoutes,
       logger: context.logger
     })
 
-    // Armazenar instâncias no contexto para uso posterior
-    ;(context as any).authService = authService
-    ;(context as any).authMiddleware = authMiddleware
-
-    // Registrar rotas de autenticação
-    context.app.group("/api/auth", (app: any) => {
-      // Rota para inicializar sessão
-      app.post("/session/init", async ({ body, set }: any) => {
-        try {
-          const result = await authService.initializeSession(body)
-          return result
-        } catch (error) {
-          context.logger.error("Erro ao inicializar sessão", { error })
-          set.status = 500
-          return { success: false, error: "Erro interno do servidor" }
-        }
-      })
-
-      // Rota para validar sessão
-      app.post("/session/validate", async ({ body, set }: any) => {
-        try {
-          const result = await authService.validateSession(body)
-          return result
-        } catch (error) {
-          context.logger.error("Erro ao validar sessão", { error })
-          set.status = 500
-          return { success: false, error: "Erro interno do servidor" }
-        }
-      })
+    // Armazenar instâncias no contexto global
+    ;(global as any).cryptoAuthService = authService
+    ;(global as any).cryptoAuthMiddleware = authMiddleware
 
-      // Rota para obter informações da sessão
-      app.get("/session/info", async ({ headers, set }: any) => {
-        try {
-          const sessionId = headers['x-session-id']
-          if (!sessionId) {
-            set.status = 401
-            return { success: false, error: "Session ID não fornecido" }
-          }
-
-          const sessionInfo = await authService.getSessionInfo(sessionId)
-          return { success: true, session: sessionInfo }
-        } catch (error) {
-          context.logger.error("Erro ao obter informações da sessão", { error })
-          set.status = 500
-          return { success: false, error: "Erro interno do servidor" }
-        }
-      })
-
-      // Rota para logout
-      app.post("/session/logout", async ({ headers, set }: any) => {
-        try {
-          const sessionId = headers['x-session-id']
-          if (!sessionId) {
-            set.status = 401
-            return { success: false, error: "Session ID não fornecido" }
-          }
-
-          await authService.destroySession(sessionId)
-          return { success: true, message: "Sessão encerrada com sucesso" }
-        } catch (error) {
-          context.logger.error("Erro ao encerrar sessão", { error })
-          set.status = 500
-          return { success: false, error: "Erro interno do servidor" }
-        }
-      })
-    })
-
-    context.logger.info("Crypto Auth plugin inicializado com sucesso", {
-      sessionTimeout: config.sessionTimeout,
-      adminKeys: config.adminKeys.length,
-      protectedRoutes: config.protectedRoutes.length
+    context.logger.info("✅ Crypto Auth plugin inicializado", {
+      mode: 'middleware-based',
+      maxTimeDrift: cryptoAuthConfig.maxTimeDrift,
+      adminKeys: cryptoAuthConfig.adminKeys.length,
+      usage: 'Use cryptoAuthRequired(), cryptoAuthAdmin(), cryptoAuthOptional() nas rotas'
     })
   },
 
-  onRequest: async (context: RequestContext) => {
-    const pluginContext = (context as any).pluginContext
-    if (!pluginContext?.authMiddleware) return
-
-    // Aplicar middleware de autenticação
-    const authResult = await pluginContext.authMiddleware.authenticate(context)
-    
-    if (!authResult.success && authResult.required) {
-      // Marcar como handled para evitar processamento adicional
-      ;(context as any).handled = true
-      ;(context as any).authError = authResult.error
-    } else if (authResult.success && authResult.user) {
-      // Adicionar usuário ao contexto
-      ;(context as any).user = authResult.user
-    }
-  },
+  // @ts-ignore - plugin property não está no tipo oficial mas é suportada
+  plugin: new Elysia({ prefix: "/api/auth" })
+    .get("/info", () => ({
+      name: "FluxStack Crypto Auth",
+      description: "Autenticação baseada em assinatura Ed25519",
+      version: "1.0.0",
+      mode: "middleware-based",
+      how_it_works: {
+        step1: "Cliente gera par de chaves Ed25519 (pública + privada) localmente",
+        step2: "Cliente armazena chave privada no navegador (NUNCA envia ao servidor)",
+        step3: "Para cada requisição, cliente assina com chave privada",
+        step4: "Cliente envia: chave pública + assinatura + dados",
+        step5: "Servidor valida assinatura usando chave pública recebida"
+      },
+      required_headers: {
+        "x-public-key": "Chave pública Ed25519 (hex 64 chars)",
+        "x-timestamp": "Timestamp da requisição (milliseconds)",
+        "x-nonce": "Nonce aleatório (previne replay)",
+        "x-signature": "Assinatura Ed25519 da mensagem (hex)"
+      },
+      admin_keys: (global as any).cryptoAuthService?.getStats().adminKeys || 0,
+      usage: {
+        required: "import { cryptoAuthRequired } from '@/plugins/crypto-auth/server'",
+        admin: "import { cryptoAuthAdmin } from '@/plugins/crypto-auth/server'",
+        optional: "import { cryptoAuthOptional } from '@/plugins/crypto-auth/server'",
+        permissions: "import { cryptoAuthPermissions } from '@/plugins/crypto-auth/server'"
+      }
+    })),
 
   onResponse: async (context: ResponseContext) => {
-    const config = getPluginConfig((context as any).pluginContext)
-    
-    if (config.enableMetrics) {
-      // Log métricas de autenticação
-      const user = (context as any).user
-      const authError = (context as any).authError
-      
-      if (user) {
-        ;((context as any).pluginContext?.logger || console).debug("Requisição autenticada", {
-          sessionId: user.sessionId,
-          isAdmin: user.isAdmin,
-          path: context.path,
-          method: context.method,
-          duration: context.duration
-        })
-      } else if (authError) {
-        ;((context as any).pluginContext?.logger || console).warn("Falha na autenticação", {
-          error: authError,
-          path: context.path,
-          method: context.method
-        })
-      }
+    if (!cryptoAuthConfig.enableMetrics) return
+
+    // Log métricas de autenticação
+    const user = (context as any).user
+    const authError = (context as any).authError
+
+    if (user) {
+      console.debug("Requisição autenticada", {
+        publicKey: user.publicKey?.substring(0, 8) + "...",
+        isAdmin: user.isAdmin,
+        path: context.path,
+        method: context.method,
+        duration: context.duration
+      })
+    } else if (authError) {
+      console.warn("Falha na autenticação", {
+        error: authError,
+        path: context.path,
+        method: context.method
+      })
     }
   },
 
   onServerStart: async (context: PluginContext) => {
-    const config = getPluginConfig(context)
-    
-    if (config.enabled) {
-      context.logger.info("Crypto Auth plugin ativo", {
-        protectedRoutes: config.protectedRoutes.length,
-        publicRoutes: config.publicRoutes.length,
-        adminKeys: config.adminKeys.length
+    if (cryptoAuthConfig.enabled) {
+      context.logger.info("✅ Crypto Auth plugin ativo", {
+        mode: 'middleware-based',
+        adminKeys: cryptoAuthConfig.adminKeys.length,
+        maxTimeDrift: `${cryptoAuthConfig.maxTimeDrift}ms`,
+        usage: 'Use cryptoAuthRequired(), cryptoAuthAdmin() nas rotas'
       })
     }
   }
 }
 
-// Helper function para obter configuração do plugin
-function getPluginConfig(context: PluginContext) {
-  const pluginConfig = context.config.plugins.config?.['crypto-auth'] || {}
-  return { ...cryptoAuthPlugin.defaultConfig, ...pluginConfig }
-}
-
 export default cryptoAuthPlugin
\ No newline at end of file
diff --git a/plugins/crypto-auth/package.json b/plugins/crypto-auth/package.json
index fb980c88..19366ad1 100644
--- a/plugins/crypto-auth/package.json
+++ b/plugins/crypto-auth/package.json
@@ -39,14 +39,15 @@
     }
   },
   "dependencies": {
-    "@noble/curves": "^1.2.0",
-    "@noble/hashes": "^1.3.2"
+    "@noble/curves": "1.2.0",
+    "@noble/hashes": "1.3.2"
   },
   "devDependencies": {
     "@types/react": "^18.0.0",
     "typescript": "^5.0.0"
   },
   "fluxstack": {
+    "plugin": true,
     "version": "^1.0.0",
     "hooks": [
       "setup",
diff --git a/plugins/crypto-auth/plugin.json b/plugins/crypto-auth/plugin.json
deleted file mode 100644
index 029de5c7..00000000
--- a/plugins/crypto-auth/plugin.json
+++ /dev/null
@@ -1,29 +0,0 @@
-{
-  "name": "crypto-auth",
-  "version": "1.0.0",
-  "description": "Sistema de autenticação baseado em criptografia Ed25519 para FluxStack",
-  "author": "FluxStack Team",
-  "license": "MIT",
-  "main": "index.ts",
-  "keywords": ["fluxstack", "plugin", "authentication", "ed25519", "cryptography"],
-  "fluxstack": {
-    "plugin": true,
-    "version": "^1.0.0",
-    "category": "auth",
-    "tags": ["authentication", "ed25519", "cryptography", "security"]
-  },
-  "dependencies": {
-    "@noble/curves": "^1.2.0",
-    "@noble/hashes": "^1.3.2",
-    "react": ">=16.8.0"
-  },
-  "peerDependencies": {
-    "react": ">=16.8.0"
-  },
-  "files": [
-    "index.ts",
-    "server/",
-    "client/",
-    "README.md"
-  ]
-}
\ No newline at end of file
diff --git a/plugins/crypto-auth/server/AuthMiddleware.ts b/plugins/crypto-auth/server/AuthMiddleware.ts
index cbccbda4..dd3dba15 100644
--- a/plugins/crypto-auth/server/AuthMiddleware.ts
+++ b/plugins/crypto-auth/server/AuthMiddleware.ts
@@ -1,6 +1,6 @@
 /**
- * Middleware de Autenticação
- * Intercepta requisições e valida autenticação
+ * Middleware de Autenticação Simplificado
+ * Apenas valida autenticação - routing é feito pelos middlewares Elysia
  */
 
 import type { RequestContext } from '../../../core/plugins/types'
@@ -14,57 +14,35 @@ export interface Logger {
 }
 
 export interface AuthMiddlewareConfig {
-    protectedRoutes: string[]
-    publicRoutes: string[]
     logger?: Logger
 }
 
 export interface AuthMiddlewareResult {
     success: boolean
-    required: boolean
     error?: string
     user?: {
-        sessionId: string
+        publicKey: string
         isAdmin: boolean
-        isSuperAdmin: boolean
         permissions: string[]
     }
 }
 
 export class AuthMiddleware {
     private authService: CryptoAuthService
-    private config: AuthMiddlewareConfig
     private logger?: Logger
 
-    constructor(authService: CryptoAuthService, config: AuthMiddlewareConfig) {
+    constructor(authService: CryptoAuthService, config: AuthMiddlewareConfig = {}) {
         this.authService = authService
-        this.config = config
         this.logger = config.logger
     }
 
     /**
-     * Autenticar requisição
+     * Autenticar requisição (sem path matching - é responsabilidade dos middlewares Elysia)
      */
     async authenticate(context: RequestContext): Promise<AuthMiddlewareResult> {
         const path = context.path
         const method = context.method
 
-        // Verificar se a rota é pública
-        if (this.isPublicRoute(path)) {
-            return {
-                success: true,
-                required: false
-            }
-        }
-
-        // Verificar se a rota requer autenticação
-        if (!this.isProtectedRoute(path)) {
-            return {
-                success: true,
-                required: false
-            }
-        }
-
         // Extrair headers de autenticação
         const authHeaders = this.extractAuthHeaders(context.headers)
         if (!authHeaders) {
@@ -76,15 +54,14 @@ export class AuthMiddleware {
 
             return {
                 success: false,
-                required: true,
                 error: "Headers de autenticação obrigatórios"
             }
         }
 
-        // Validar sessão
+        // Validar assinatura da requisição
         try {
-            const validationResult = await this.authService.validateSession({
-                sessionId: authHeaders.sessionId,
+            const validationResult = await this.authService.validateRequest({
+                publicKey: authHeaders.publicKey,
                 timestamp: authHeaders.timestamp,
                 nonce: authHeaders.nonce,
                 signature: authHeaders.signature,
@@ -92,16 +69,15 @@ export class AuthMiddleware {
             })
 
             if (!validationResult.success) {
-                this.logger?.warn("Falha na validação da sessão", {
+                this.logger?.warn("Falha na validação da assinatura", {
                     path,
                     method,
-                    sessionId: authHeaders.sessionId.substring(0, 8) + "...",
+                    publicKey: authHeaders.publicKey.substring(0, 8) + "...",
                     error: validationResult.error
                 })
 
                 return {
                     success: false,
-                    required: true,
                     error: validationResult.error
                 }
             }
@@ -109,13 +85,12 @@ export class AuthMiddleware {
             this.logger?.debug("Requisição autenticada com sucesso", {
                 path,
                 method,
-                sessionId: authHeaders.sessionId.substring(0, 8) + "...",
+                publicKey: authHeaders.publicKey.substring(0, 8) + "...",
                 isAdmin: validationResult.user?.isAdmin
             })
 
             return {
                 success: true,
-                required: true,
                 user: validationResult.user
             }
         } catch (error) {
@@ -127,53 +102,26 @@ export class AuthMiddleware {
 
             return {
                 success: false,
-                required: true,
                 error: "Erro interno de autenticação"
             }
         }
     }
 
-    /**
-     * Verificar se a rota é pública
-     */
-    private isPublicRoute(path: string): boolean {
-        return this.config.publicRoutes.some(route => {
-            if (route.endsWith('/*')) {
-                const prefix = route.slice(0, -2)
-                return path.startsWith(prefix)
-            }
-            return path === route
-        })
-    }
-
-    /**
-     * Verificar se a rota é protegida
-     */
-    private isProtectedRoute(path: string): boolean {
-        return this.config.protectedRoutes.some(route => {
-            if (route.endsWith('/*')) {
-                const prefix = route.slice(0, -2)
-                return path.startsWith(prefix)
-            }
-            return path === route
-        })
-    }
-
     /**
      * Extrair headers de autenticação
      */
     private extractAuthHeaders(headers: Record<string, string>): {
-        sessionId: string
+        publicKey: string
         timestamp: number
         nonce: string
         signature: string
     } | null {
-        const sessionId = headers['x-session-id']
+        const publicKey = headers['x-public-key']
         const timestampStr = headers['x-timestamp']
         const nonce = headers['x-nonce']
         const signature = headers['x-signature']
 
-        if (!sessionId || !timestampStr || !nonce || !signature) {
+        if (!publicKey || !timestampStr || !nonce || !signature) {
             return null
         }
 
@@ -183,7 +131,7 @@ export class AuthMiddleware {
         }
 
         return {
-            sessionId,
+            publicKey,
             timestamp,
             nonce,
             signature
@@ -207,7 +155,7 @@ export class AuthMiddleware {
     }
 
     /**
-     * Verificar se usuário tem permissão para acessar rota
+     * Verificar se usuário tem permissão
      */
     hasPermission(user: any, requiredPermission: string): boolean {
         if (!user || !user.permissions) {
@@ -225,13 +173,9 @@ export class AuthMiddleware {
     }
 
     /**
-     * Obter estatísticas do middleware
+     * Obter estatísticas do serviço de autenticação
      */
     getStats() {
-        return {
-            protectedRoutes: this.config.protectedRoutes.length,
-            publicRoutes: this.config.publicRoutes.length,
-            authService: this.authService.getStats()
-        }
+        return this.authService.getStats()
     }
-}
\ No newline at end of file
+}
diff --git a/plugins/crypto-auth/server/CryptoAuthService.ts b/plugins/crypto-auth/server/CryptoAuthService.ts
index 7419bcc9..e4a1d765 100644
--- a/plugins/crypto-auth/server/CryptoAuthService.ts
+++ b/plugins/crypto-auth/server/CryptoAuthService.ts
@@ -1,11 +1,13 @@
 /**
  * Serviço de Autenticação Criptográfica
- * Implementa autenticação baseada em Ed25519
+ * Implementa autenticação baseada em Ed25519 - SEM SESSÕES
+ * Cada requisição é validada pela assinatura da chave pública
  */
 
 import { ed25519 } from '@noble/curves/ed25519'
 import { sha256 } from '@noble/hashes/sha256'
-import { bytesToHex, hexToBytes } from '@noble/hashes/utils'
+import { hexToBytes } from '@noble/hashes/utils'
+
 export interface Logger {
   debug(message: string, meta?: any): void
   info(message: string, meta?: any): void
@@ -13,221 +15,128 @@ export interface Logger {
   error(message: string, meta?: any): void
 }
 
-export interface SessionData {
-  sessionId: string
-  publicKey: string
-  createdAt: Date
-  lastUsed: Date
-  isAdmin: boolean
-  permissions: string[]
-}
-
 export interface AuthResult {
   success: boolean
-  sessionId?: string
   error?: string
   user?: {
-    sessionId: string
+    publicKey: string
     isAdmin: boolean
-    isSuperAdmin: boolean
     permissions: string[]
   }
 }
 
 export interface CryptoAuthConfig {
-  sessionTimeout: number
   maxTimeDrift: number
   adminKeys: string[]
   logger?: Logger
 }
 
 export class CryptoAuthService {
-  private sessions: Map<string, SessionData> = new Map()
   private config: CryptoAuthConfig
   private logger?: Logger
+  private usedNonces: Map<string, number> = new Map() // Para prevenir replay attacks
 
   constructor(config: CryptoAuthConfig) {
     this.config = config
     this.logger = config.logger
 
-    // Limpar sessões expiradas a cada 5 minutos
+    // Limpar nonces antigos a cada 5 minutos
     setInterval(() => {
-      this.cleanupExpiredSessions()
+      this.cleanupOldNonces()
     }, 5 * 60 * 1000)
   }
 
   /**
-   * Inicializar uma nova sessão
+   * Validar assinatura de requisição
+   * PRINCIPAL: Valida se assinatura é válida para a chave pública fornecida
    */
-  async initializeSession(data: { publicKey?: string }): Promise<AuthResult> {
-    try {
-      let publicKey: string
-
-      if (data.publicKey) {
-        // Validar chave pública fornecida
-        if (!this.isValidPublicKey(data.publicKey)) {
-          return {
-            success: false,
-            error: "Chave pública inválida"
-          }
-        }
-        publicKey = data.publicKey
-      } else {
-        // Gerar novo par de chaves
-        const privateKey = ed25519.utils.randomPrivateKey()
-        publicKey = bytesToHex(ed25519.getPublicKey(privateKey))
-      }
-
-      const sessionId = publicKey
-      const isAdmin = this.config.adminKeys.includes(publicKey)
-
-      const sessionData: SessionData = {
-        sessionId,
-        publicKey,
-        createdAt: new Date(),
-        lastUsed: new Date(),
-        isAdmin,
-        permissions: isAdmin ? ['admin', 'read', 'write'] : ['read']
-      }
-
-      this.sessions.set(sessionId, sessionData)
-
-      this.logger?.info("Nova sessão inicializada", {
-        sessionId: sessionId.substring(0, 8) + "...",
-        isAdmin,
-        permissions: sessionData.permissions
-      })
-
-      return {
-        success: true,
-        sessionId,
-        user: {
-          sessionId,
-          isAdmin,
-          isSuperAdmin: isAdmin,
-          permissions: sessionData.permissions
-        }
-      }
-    } catch (error) {
-      this.logger?.error("Erro ao inicializar sessão", { error })
-      return {
-        success: false,
-        error: "Erro interno ao inicializar sessão"
-      }
-    }
-  }
-
-  /**
-   * Validar uma sessão com assinatura
-   */
-  async validateSession(data: {
-    sessionId: string
+  async validateRequest(data: {
+    publicKey: string
     timestamp: number
     nonce: string
     signature: string
     message?: string
   }): Promise<AuthResult> {
     try {
-      const { sessionId, timestamp, nonce, signature, message = "" } = data
+      const { publicKey, timestamp, nonce, signature, message = "" } = data
 
-      // Verificar se a sessão existe
-      const session = this.sessions.get(sessionId)
-      if (!session) {
+      // Validar chave pública
+      if (!this.isValidPublicKey(publicKey)) {
         return {
           success: false,
-          error: "Sessão não encontrada"
+          error: "Chave pública inválida"
         }
       }
 
-      // Verificar se a sessão não expirou
+      // Verificar drift de tempo (previne replay de requisições antigas)
       const now = Date.now()
-      const sessionAge = now - session.lastUsed.getTime()
-      if (sessionAge > this.config.sessionTimeout) {
-        this.sessions.delete(sessionId)
+      const timeDrift = Math.abs(now - timestamp)
+      if (timeDrift > this.config.maxTimeDrift) {
         return {
           success: false,
-          error: "Sessão expirada"
+          error: "Timestamp inválido ou expirado"
         }
       }
 
-      // Verificar drift de tempo
-      const timeDrift = Math.abs(now - timestamp)
-      if (timeDrift > this.config.maxTimeDrift) {
+      // Verificar nonce (previne replay attacks)
+      const nonceKey = `${publicKey}:${nonce}`
+      if (this.usedNonces.has(nonceKey)) {
         return {
           success: false,
-          error: "Timestamp inválido"
+          error: "Nonce já utilizado (possível replay attack)"
         }
       }
 
       // Construir mensagem para verificação
-      const messageToVerify = `${sessionId}:${timestamp}:${nonce}:${message}`
+      const messageToVerify = `${publicKey}:${timestamp}:${nonce}:${message}`
       const messageHash = sha256(new TextEncoder().encode(messageToVerify))
 
-      // Verificar assinatura
-      const publicKeyBytes = hexToBytes(session.publicKey)
+      // Verificar assinatura usando chave pública
+      const publicKeyBytes = hexToBytes(publicKey)
       const signatureBytes = hexToBytes(signature)
-      
+
       const isValidSignature = ed25519.verify(signatureBytes, messageHash, publicKeyBytes)
-      
+
       if (!isValidSignature) {
+        this.logger?.warn("Assinatura inválida", {
+          publicKey: publicKey.substring(0, 8) + "..."
+        })
         return {
           success: false,
           error: "Assinatura inválida"
         }
       }
 
-      // Atualizar último uso da sessão
-      session.lastUsed = new Date()
+      // Marcar nonce como usado
+      this.usedNonces.set(nonceKey, timestamp)
+
+      // Verificar se é admin
+      const isAdmin = this.config.adminKeys.includes(publicKey)
+      const permissions = isAdmin ? ['admin', 'read', 'write', 'delete'] : ['read']
+
+      this.logger?.debug("Requisição autenticada", {
+        publicKey: publicKey.substring(0, 8) + "...",
+        isAdmin,
+        permissions
+      })
 
       return {
         success: true,
-        sessionId,
         user: {
-          sessionId,
-          isAdmin: session.isAdmin,
-          isSuperAdmin: session.isAdmin,
-          permissions: session.permissions
+          publicKey,
+          isAdmin,
+          permissions
         }
       }
     } catch (error) {
-      this.logger?.error("Erro ao validar sessão", { error })
+      this.logger?.error("Erro ao validar requisição", { error })
       return {
         success: false,
-        error: "Erro interno ao validar sessão"
+        error: "Erro interno ao validar requisição"
       }
     }
   }
 
-  /**
-   * Obter informações da sessão
-   */
-  async getSessionInfo(sessionId: string): Promise<SessionData | null> {
-    const session = this.sessions.get(sessionId)
-    if (!session) {
-      return null
-    }
-
-    // Verificar se não expirou
-    const now = Date.now()
-    const sessionAge = now - session.lastUsed.getTime()
-    if (sessionAge > this.config.sessionTimeout) {
-      this.sessions.delete(sessionId)
-      return null
-    }
-
-    return { ...session }
-  }
-
-  /**
-   * Destruir uma sessão
-   */
-  async destroySession(sessionId: string): Promise<void> {
-    this.sessions.delete(sessionId)
-    this.logger?.info("Sessão destruída", {
-      sessionId: sessionId.substring(0, 8) + "..."
-    })
-  }
-
   /**
    * Verificar se uma chave pública é válida
    */
@@ -245,49 +154,33 @@ export class CryptoAuthService {
   }
 
   /**
-   * Limpar sessões expiradas
+   * Limpar nonces antigos (previne crescimento infinito da memória)
    */
-  private cleanupExpiredSessions(): void {
+  private cleanupOldNonces(): void {
     const now = Date.now()
+    const maxAge = this.config.maxTimeDrift * 2 // Dobro do tempo máximo permitido
     let cleanedCount = 0
 
-    for (const [sessionId, session] of this.sessions.entries()) {
-      const sessionAge = now - session.lastUsed.getTime()
-      if (sessionAge > this.config.sessionTimeout) {
-        this.sessions.delete(sessionId)
+    for (const [nonceKey, timestamp] of this.usedNonces.entries()) {
+      if (now - timestamp > maxAge) {
+        this.usedNonces.delete(nonceKey)
         cleanedCount++
       }
     }
 
     if (cleanedCount > 0) {
-      this.logger?.debug(`Limpeza de sessões: ${cleanedCount} sessões expiradas removidas`)
+      this.logger?.debug(`Limpeza de nonces: ${cleanedCount} nonces antigos removidos`)
     }
   }
 
   /**
-   * Obter estatísticas das sessões
+   * Obter estatísticas do serviço
    */
   getStats() {
-    const now = Date.now()
-    let activeSessions = 0
-    let adminSessions = 0
-
-    for (const session of this.sessions.values()) {
-      const sessionAge = now - session.lastUsed.getTime()
-      if (sessionAge <= this.config.sessionTimeout) {
-        activeSessions++
-        if (session.isAdmin) {
-          adminSessions++
-        }
-      }
-    }
-
     return {
-      totalSessions: this.sessions.size,
-      activeSessions,
-      adminSessions,
-      sessionTimeout: this.config.sessionTimeout,
-      adminKeys: this.config.adminKeys.length
+      usedNoncesCount: this.usedNonces.size,
+      adminKeys: this.config.adminKeys.length,
+      maxTimeDrift: this.config.maxTimeDrift
     }
   }
 }
\ No newline at end of file
diff --git a/plugins/crypto-auth/server/index.ts b/plugins/crypto-auth/server/index.ts
index 6bacaa82..9935ec32 100644
--- a/plugins/crypto-auth/server/index.ts
+++ b/plugins/crypto-auth/server/index.ts
@@ -3,7 +3,20 @@
  */
 
 export { CryptoAuthService } from './CryptoAuthService'
-export type { SessionData, AuthResult, CryptoAuthConfig } from './CryptoAuthService'
+export type { AuthResult, CryptoAuthConfig } from './CryptoAuthService'
 
 export { AuthMiddleware } from './AuthMiddleware'
-export type { AuthMiddlewareConfig, AuthMiddlewareResult } from './AuthMiddleware'
\ No newline at end of file
+export type { AuthMiddlewareConfig, AuthMiddlewareResult } from './AuthMiddleware'
+
+// Middlewares Elysia
+export {
+  cryptoAuthRequired,
+  cryptoAuthAdmin,
+  cryptoAuthPermissions,
+  cryptoAuthOptional,
+  getCryptoAuthUser,
+  isCryptoAuthAuthenticated,
+  isCryptoAuthAdmin,
+  hasCryptoAuthPermission
+} from './middlewares'
+export type { CryptoAuthUser, CryptoAuthMiddlewareOptions } from './middlewares'
\ No newline at end of file
diff --git a/plugins/crypto-auth/server/middlewares.ts b/plugins/crypto-auth/server/middlewares.ts
new file mode 100644
index 00000000..3d38f7b7
--- /dev/null
+++ b/plugins/crypto-auth/server/middlewares.ts
@@ -0,0 +1,19 @@
+/**
+ * Crypto Auth Middlewares
+ * Middlewares Elysia para autenticação criptográfica
+ *
+ * Uso:
+ * ```typescript
+ * import { cryptoAuthRequired, cryptoAuthAdmin } from '@/plugins/crypto-auth/server'
+ *
+ * export const myRoutes = new Elysia()
+ *   .use(cryptoAuthRequired())
+ *   .get('/protected', ({ request }) => {
+ *     const user = getCryptoAuthUser(request)
+ *     return { user }
+ *   })
+ * ```
+ */
+
+// Re-export tudo do módulo middlewares
+export * from './middlewares/index'
diff --git a/plugins/crypto-auth/server/middlewares/cryptoAuthAdmin.ts b/plugins/crypto-auth/server/middlewares/cryptoAuthAdmin.ts
new file mode 100644
index 00000000..9b84fada
--- /dev/null
+++ b/plugins/crypto-auth/server/middlewares/cryptoAuthAdmin.ts
@@ -0,0 +1,65 @@
+/**
+ * Middleware que REQUER privilégios de administrador
+ * Bloqueia requisições não autenticadas (401) ou sem privilégios admin (403)
+ */
+
+import { Elysia } from 'elysia'
+import { createGuard } from '@/core/server/middleware/elysia-helpers'
+import type { Logger } from '@/core/utils/logger'
+import { validateAuthSync, type CryptoAuthUser } from './helpers'
+
+export interface CryptoAuthMiddlewareOptions {
+  logger?: Logger
+}
+
+export const cryptoAuthAdmin = (options: CryptoAuthMiddlewareOptions = {}) => {
+  return new Elysia({ name: 'crypto-auth-admin' })
+    .derive(async ({ request }) => {
+      const result = await validateAuthSync(request as Request, options.logger)
+
+      if (result.success && result.user) {
+        ;(request as any).user = result.user
+      }
+
+      return {}
+    })
+    .use(
+      createGuard({
+        name: 'crypto-auth-admin-check',
+        check: ({ request }) => {
+          const user = (request as any).user as CryptoAuthUser | undefined
+          return user && user.isAdmin
+        },
+        onFail: (set, { request }) => {
+          const user = (request as any).user as CryptoAuthUser | undefined
+
+          if (!user) {
+            set.status = 401
+            return {
+              error: {
+                message: 'Authentication required',
+                code: 'CRYPTO_AUTH_REQUIRED',
+                statusCode: 401
+              }
+            }
+          }
+
+          options.logger?.warn('Admin access denied', {
+            publicKey: user.publicKey.substring(0, 8) + '...',
+            permissions: user.permissions
+          })
+
+          set.status = 403
+          return {
+            error: {
+              message: 'Admin privileges required',
+              code: 'ADMIN_REQUIRED',
+              statusCode: 403,
+              yourPermissions: user.permissions
+            }
+          }
+        }
+      })
+    )
+    .as('plugin')
+}
diff --git a/plugins/crypto-auth/server/middlewares/cryptoAuthOptional.ts b/plugins/crypto-auth/server/middlewares/cryptoAuthOptional.ts
new file mode 100644
index 00000000..106d79c3
--- /dev/null
+++ b/plugins/crypto-auth/server/middlewares/cryptoAuthOptional.ts
@@ -0,0 +1,26 @@
+/**
+ * Middleware OPCIONAL - adiciona user se autenticado, mas não requer
+ * Não bloqueia requisições não autenticadas - permite acesso público
+ */
+
+import { Elysia } from 'elysia'
+import type { Logger } from '@/core/utils/logger'
+import { validateAuthSync } from './helpers'
+
+export interface CryptoAuthMiddlewareOptions {
+  logger?: Logger
+}
+
+export const cryptoAuthOptional = (options: CryptoAuthMiddlewareOptions = {}) => {
+  return new Elysia({ name: 'crypto-auth-optional' })
+    .derive(async ({ request }) => {
+      const result = await validateAuthSync(request as Request, options.logger)
+
+      if (result.success && result.user) {
+        ;(request as any).user = result.user
+      }
+
+      return {}
+    })
+    .as('plugin')
+}
diff --git a/plugins/crypto-auth/server/middlewares/cryptoAuthPermissions.ts b/plugins/crypto-auth/server/middlewares/cryptoAuthPermissions.ts
new file mode 100644
index 00000000..987557bf
--- /dev/null
+++ b/plugins/crypto-auth/server/middlewares/cryptoAuthPermissions.ts
@@ -0,0 +1,76 @@
+/**
+ * Middleware que REQUER permissões específicas
+ * Bloqueia requisições sem as permissões necessárias (403)
+ */
+
+import { Elysia } from 'elysia'
+import { createGuard } from '@/core/server/middleware/elysia-helpers'
+import type { Logger } from '@/core/utils/logger'
+import { validateAuthSync, type CryptoAuthUser } from './helpers'
+
+export interface CryptoAuthMiddlewareOptions {
+  logger?: Logger
+}
+
+export const cryptoAuthPermissions = (
+  requiredPermissions: string[],
+  options: CryptoAuthMiddlewareOptions = {}
+) => {
+  return new Elysia({ name: 'crypto-auth-permissions' })
+    .derive(async ({ request }) => {
+      const result = await validateAuthSync(request as Request, options.logger)
+
+      if (result.success && result.user) {
+        ;(request as any).user = result.user
+      }
+
+      return {}
+    })
+    .use(
+      createGuard({
+        name: 'crypto-auth-permissions-check',
+        check: ({ request }) => {
+          const user = (request as any).user as CryptoAuthUser | undefined
+
+          if (!user) return false
+
+          const userPermissions = user.permissions
+          return requiredPermissions.every(
+            perm => userPermissions.includes(perm) || userPermissions.includes('admin')
+          )
+        },
+        onFail: (set, { request }) => {
+          const user = (request as any).user as CryptoAuthUser | undefined
+
+          if (!user) {
+            set.status = 401
+            return {
+              error: {
+                message: 'Authentication required',
+                code: 'CRYPTO_AUTH_REQUIRED',
+                statusCode: 401
+              }
+            }
+          }
+
+          options.logger?.warn('Permission denied', {
+            publicKey: user.publicKey.substring(0, 8) + '...',
+            required: requiredPermissions,
+            has: user.permissions
+          })
+
+          set.status = 403
+          return {
+            error: {
+              message: 'Insufficient permissions',
+              code: 'PERMISSION_DENIED',
+              statusCode: 403,
+              required: requiredPermissions,
+              yours: user.permissions
+            }
+          }
+        }
+      })
+    )
+    .as('plugin')
+}
diff --git a/plugins/crypto-auth/server/middlewares/cryptoAuthRequired.ts b/plugins/crypto-auth/server/middlewares/cryptoAuthRequired.ts
new file mode 100644
index 00000000..5450141d
--- /dev/null
+++ b/plugins/crypto-auth/server/middlewares/cryptoAuthRequired.ts
@@ -0,0 +1,45 @@
+/**
+ * Middleware que REQUER autenticação
+ * Bloqueia requisições não autenticadas com 401
+ */
+
+import { Elysia } from 'elysia'
+import { createGuard } from '@/core/server/middleware/elysia-helpers'
+import type { Logger } from '@/core/utils/logger'
+import { validateAuthSync } from './helpers'
+
+export interface CryptoAuthMiddlewareOptions {
+  logger?: Logger
+}
+
+export const cryptoAuthRequired = (options: CryptoAuthMiddlewareOptions = {}) => {
+  return new Elysia({ name: 'crypto-auth-required' })
+    .derive(async ({ request }) => {
+      const result = await validateAuthSync(request as Request, options.logger)
+
+      if (result.success && result.user) {
+        ;(request as any).user = result.user
+      }
+
+      return {}
+    })
+    .use(
+      createGuard({
+        name: 'crypto-auth-check',
+        check: ({ request }) => {
+          return !!(request as any).user
+        },
+        onFail: (set) => {
+          set.status = 401
+          return {
+            error: {
+              message: 'Authentication required',
+              code: 'CRYPTO_AUTH_REQUIRED',
+              statusCode: 401
+            }
+          }
+        }
+      })
+    )
+    .as('plugin')
+}
diff --git a/plugins/crypto-auth/server/middlewares/helpers.ts b/plugins/crypto-auth/server/middlewares/helpers.ts
new file mode 100644
index 00000000..3bed8a16
--- /dev/null
+++ b/plugins/crypto-auth/server/middlewares/helpers.ts
@@ -0,0 +1,140 @@
+/**
+ * Crypto Auth Middleware Helpers
+ * Funções compartilhadas para validação de autenticação
+ */
+
+import type { Logger } from '@/core/utils/logger'
+
+export interface CryptoAuthUser {
+  publicKey: string
+  isAdmin: boolean
+  permissions: string[]
+}
+
+/**
+ * Get auth service from global
+ */
+export function getAuthService() {
+  const service = (global as any).cryptoAuthService
+  if (!service) {
+    throw new Error('CryptoAuthService not initialized. Make sure crypto-auth plugin is loaded.')
+  }
+  return service
+}
+
+/**
+ * Get auth middleware from global
+ */
+export function getAuthMiddleware() {
+  const middleware = (global as any).cryptoAuthMiddleware
+  if (!middleware) {
+    throw new Error('AuthMiddleware not initialized. Make sure crypto-auth plugin is loaded.')
+  }
+  return middleware
+}
+
+/**
+ * Extract and validate authentication from request
+ * Versão SÍNCRONA para evitar problemas com Elysia
+ */
+export function extractAuthHeaders(request: Request): {
+  publicKey: string
+  timestamp: number
+  nonce: string
+  signature: string
+} | null {
+  const headers = request.headers
+  const publicKey = headers.get('x-public-key')
+  const timestampStr = headers.get('x-timestamp')
+  const nonce = headers.get('x-nonce')
+  const signature = headers.get('x-signature')
+
+  if (!publicKey || !timestampStr || !nonce || !signature) {
+    return null
+  }
+
+  const timestamp = parseInt(timestampStr, 10)
+  if (isNaN(timestamp)) {
+    return null
+  }
+
+  return { publicKey, timestamp, nonce, signature }
+}
+
+/**
+ * Build message for signature verification
+ */
+export function buildMessage(request: Request): string {
+  const url = new URL(request.url)
+  return `${request.method}:${url.pathname}`
+}
+
+/**
+ * Validate authentication synchronously
+ */
+export async function validateAuthSync(request: Request, logger?: Logger): Promise<{
+  success: boolean
+  user?: CryptoAuthUser
+  error?: string
+}> {
+  try {
+    const authHeaders = extractAuthHeaders(request)
+
+    if (!authHeaders) {
+      return {
+        success: false,
+        error: 'Missing authentication headers'
+      }
+    }
+
+    const authService = getAuthService()
+    const message = buildMessage(request)
+
+    const result = await authService.validateRequest({
+      publicKey: authHeaders.publicKey,
+      timestamp: authHeaders.timestamp,
+      nonce: authHeaders.nonce,
+      signature: authHeaders.signature,
+      message
+    })
+
+    return result
+  } catch (error) {
+    logger?.error('Auth validation error', { error })
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error'
+    }
+  }
+}
+
+/**
+ * Helper: Obter usuário autenticado do request
+ */
+export function getCryptoAuthUser(request: Request): CryptoAuthUser | null {
+  return (request as any).user || null
+}
+
+/**
+ * Helper: Verificar se request está autenticado
+ */
+export function isCryptoAuthAuthenticated(request: Request): boolean {
+  return !!(request as any).user
+}
+
+/**
+ * Helper: Verificar se usuário é admin
+ */
+export function isCryptoAuthAdmin(request: Request): boolean {
+  const user = getCryptoAuthUser(request)
+  return user?.isAdmin || false
+}
+
+/**
+ * Helper: Verificar se usuário tem permissão específica
+ */
+export function hasCryptoAuthPermission(request: Request, permission: string): boolean {
+  const user = getCryptoAuthUser(request)
+  if (!user) return false
+  return user.permissions.includes(permission) || user.permissions.includes('admin')
+}
diff --git a/plugins/crypto-auth/server/middlewares/index.ts b/plugins/crypto-auth/server/middlewares/index.ts
new file mode 100644
index 00000000..f938c2e8
--- /dev/null
+++ b/plugins/crypto-auth/server/middlewares/index.ts
@@ -0,0 +1,22 @@
+/**
+ * Crypto Auth Middlewares
+ * Exports centralizados de todos os middlewares
+ */
+
+// Middlewares
+export { cryptoAuthRequired } from './cryptoAuthRequired'
+export { cryptoAuthAdmin } from './cryptoAuthAdmin'
+export { cryptoAuthOptional } from './cryptoAuthOptional'
+export { cryptoAuthPermissions } from './cryptoAuthPermissions'
+
+// Helpers
+export {
+  getCryptoAuthUser,
+  isCryptoAuthAuthenticated,
+  isCryptoAuthAdmin,
+  hasCryptoAuthPermission,
+  type CryptoAuthUser
+} from './helpers'
+
+// Types
+export type { CryptoAuthMiddlewareOptions } from './cryptoAuthRequired'
diff --git a/test-crypto-auth.ts b/test-crypto-auth.ts
new file mode 100644
index 00000000..0a3c9b69
--- /dev/null
+++ b/test-crypto-auth.ts
@@ -0,0 +1,101 @@
+/**
+ * Script de teste para validar autenticação criptográfica
+ */
+
+import { ed25519 } from '@noble/curves/ed25519'
+import { sha256 } from '@noble/hashes/sha256'
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils'
+
+async function testCryptoAuth() {
+  console.log('🔐 Testando Autenticação Criptográfica Ed25519\n')
+
+  // 1. Gerar par de chaves
+  console.log('1️⃣ Gerando par de chaves Ed25519...')
+  const privateKey = ed25519.utils.randomPrivateKey()
+  const publicKeyBytes = ed25519.getPublicKey(privateKey)
+  const publicKey = bytesToHex(publicKeyBytes)
+  const privateKeyHex = bytesToHex(privateKey)
+
+  console.log(`   ✅ Chave pública: ${publicKey.substring(0, 16)}...`)
+  console.log(`   ✅ Chave privada: ${privateKeyHex.substring(0, 16)}... (NUNCA enviar ao servidor!)\n`)
+
+  // 2. Preparar requisição
+  console.log('2️⃣ Preparando requisição assinada...')
+  const url = '/api/crypto-auth/protected'
+  const method = 'GET'
+  const timestamp = Date.now()
+  const nonce = generateNonce()
+
+  // 3. Construir mensagem para assinar
+  const message = `${method}:${url}`
+  const fullMessage = `${publicKey}:${timestamp}:${nonce}:${message}`
+
+  console.log(`   📝 Mensagem: ${fullMessage.substring(0, 50)}...\n`)
+
+  // 4. Assinar mensagem
+  console.log('3️⃣ Assinando mensagem com chave privada...')
+  const messageHash = sha256(new TextEncoder().encode(fullMessage))
+  const signatureBytes = ed25519.sign(messageHash, privateKey)
+  const signature = bytesToHex(signatureBytes)
+
+  console.log(`   ✅ Assinatura: ${signature.substring(0, 32)}...\n`)
+
+  // 5. Fazer requisição ao servidor
+  console.log('4️⃣ Enviando requisição ao servidor...')
+  const response = await fetch('http://localhost:3000/api/crypto-auth/protected', {
+    method: 'GET',
+    headers: {
+      'x-public-key': publicKey,
+      'x-timestamp': timestamp.toString(),
+      'x-nonce': nonce,
+      'x-signature': signature
+    }
+  })
+
+  const data = await response.json()
+
+  console.log(`   📡 Status: ${response.status}`)
+  console.log(`   📦 Resposta:`, JSON.stringify(data, null, 2))
+
+  if (data.success) {
+    console.log('\n✅ SUCESSO! Assinatura validada corretamente pelo servidor!')
+    console.log(`   👤 Dados protegidos recebidos: ${data.data?.secretInfo}`)
+  } else {
+    console.log('\n❌ ERRO! Assinatura rejeitada pelo servidor')
+    console.log(`   ⚠️  Erro: ${data.error}`)
+  }
+
+  // 6. Testar replay attack (reutilizar mesma assinatura)
+  console.log('\n5️⃣ Testando proteção contra replay attack...')
+  const replayResponse = await fetch('http://localhost:3000/api/crypto-auth/protected', {
+    method: 'GET',
+    headers: {
+      'x-public-key': publicKey,
+      'x-timestamp': timestamp.toString(),
+      'x-nonce': nonce, // Mesmo nonce
+      'x-signature': signature // Mesma assinatura
+    }
+  })
+
+  const replayData = await replayResponse.json()
+
+  console.log(`   📡 Replay Status: ${replayResponse.status}`)
+  console.log(`   📦 Replay Response:`, JSON.stringify(replayData, null, 2))
+
+  if (!replayData.success && replayData.error?.includes('nonce')) {
+    console.log('   ✅ Proteção funcionando! Replay attack bloqueado.')
+  } else if (replayResponse.status === 401) {
+    console.log('   ✅ Proteção funcionando! Replay attack bloqueado (status 401).')
+  } else {
+    console.log('   ⚠️  ATENÇÃO: Replay attack NÃO foi bloqueado!')
+  }
+}
+
+function generateNonce(): string {
+  const bytes = new Uint8Array(16)
+  crypto.getRandomValues(bytes)
+  return bytesToHex(bytes)
+}
+
+// Executar teste
+testCryptoAuth().catch(console.error)