## 🧠 LYRA NEXUS: Sistema Inteligente de Optimización de Almacenamiento Descentralizado

## 🧠 LYRA NEXUS: Sistema Inteligente de Optimización de Almacenamiento Descentralizado

Este sistema convierte cada nodo de la red LYRA NEXUS en una **neurona inteligente** que colabora con las demás para mantener el almacenamiento colectivo limpio, organizado y eficiente. La filosofía es simple: **cada nodo aporta su inteligencia local y juntos forman un cerebro distribuido**.

---

 

 

 

 

 

 

 

 

### 📚 Arquitectura del Sistema

El sistema se compone de cuatro módulos principales:

| Módulo | Función |
|--------|---------|
| **Deduplicador** | Detecta y elimina archivos duplicados a nivel de contenido (hash SHA-256). |
| **Limpiador Lógico** | Identifica y borra datos superfluos (temporales, cachés, logs antiguos, etc.) según reglas configurables. |
| **Compresor Inteligente** | Comprime los datos sin encriptar para ahorrar espacio (usando zlib o lzma). |
| **Blockchain Registradora** | Registra cada acción (eliminación, compresión, limpieza) en una cadena de bloques inmutable para auditoría y administración. |
| **Coordinador P2P** | Permite que los nodos compartan sus "huellas" (hashes) para saber qué datos están duplicados en la red y decidir colectivamente qué copias eliminar. |

---

### ⚙️ Instalación y Dependencias

El sistema está escrito en Python 3.9+ y usa únicamente la biblioteca estándar, por lo que **no requiere instalación de paquetes externos**. Esto facilita su uso en entornos educativos.

```bash
# Clonar el repositorio (simulado)
mkdir lyra_nexus
cd lyra_nexus
# Crear los archivos que se detallan a continuación
```

---

### 🧩 Código del Sistema

Estructura de archivos:

```
lyra_nexus/
├── config.py          # Configuración central
├── blockchain.py      # Cadena de bloques simple
├── deduplicator.py    # Deduplicación y limpieza lógica
├── compressor.py      # Compresión de datos
├── p2p_coordinator.py # Comunicación entre nodos
├── main.py            # Orquestador principal
└── README.md          # Explicación para el usuario
```

#### 📄 `config.py` - Configuración Global

```python
# config.py
# Configuración central del sistema LYRA NEXUS

# Rutas de almacenamiento
STORAGE_PATHS = [
    "/mnt/nas/datos",  # Ruta principal del NAS
    "/mnt/nas/backup",
]

# Extensiones de archivos temporales o superfluos
SUPERFLUOUS_EXTENSIONS = [".tmp", ".log", ".cache", ".swp", ".bak"]

# Tamaño mínimo para considerar compresión (en bytes)
COMPRESS_MIN_SIZE = 1024 * 10  # 10 KB

# Nivel de compresión (1-9, siendo 9 máximo)
COMPRESS_LEVEL = 6

# Puerto para comunicación P2P
P2P_PORT = 8765

# Lista de nodos conocidos (IP o hostname)
KNOWN_NODES = [
    "192.168.1.101",
    "192.168.1.102",
]
```

---

#### 📄 `blockchain.py` - Blockchain Registradora y Administrativa

```python
# blockchain.py
# Cadena de bloques simple para registrar acciones de limpieza y compresión

import hashlib
import json
import time
from typing import List, Dict

class Block:
    def __init__(self, index, previous_hash, timestamp, data, nonce=0):
        self.index = index
        self.previous_hash = previous_hash
        self.timestamp = timestamp
        self.data = data  # Diccionario con la acción realizada
        self.nonce = nonce
        self.hash = self.calculate_hash()

    def calculate_hash(self):
        block_string = json.dumps({
            "index": self.index,
            "previous_hash": self.previous_hash,
            "timestamp": self.timestamp,
            "data": self.data,
            "nonce": self.nonce
        }, sort_keys=True)
        return hashlib.sha256(block_string.encode()).hexdigest()

    def mine_block(self, difficulty=2):
        # Prueba de trabajo simple para demostración
        target = "0" * difficulty
        while self.hash[:difficulty] != target:
            self.nonce += 1
            self.hash = self.calculate_hash()
        print(f"Bloque minado: {self.hash}")

class Blockchain:
    def __init__(self):
        self.chain = [self.create_genesis_block()]
        self.difficulty = 2

    def create_genesis_block(self):
        return Block(0, "0", time.time(), {"action": "genesis"})

    def get_latest_block(self):
        return self.chain[-1]

    def add_block(self, new_block):
        new_block.previous_hash = self.get_latest_block().hash
        new_block.mine_block(self.difficulty)
        self.chain.append(new_block)

    def is_chain_valid(self):
        for i in range(1, len(self.chain)):
            current = self.chain[i]
            previous = self.chain[i-1]
            if current.hash != current.calculate_hash():
                return False
            if current.previous_hash != previous.hash:
                return False
        return True

    def register_action(self, action_type, details):
        """Registra una acción en la blockchain"""
        data = {
            "action": action_type,
            "details": details,
            "timestamp": time.time()
        }
        new_block = Block(
            index=len(self.chain),
            previous_hash=self.get_latest_block().hash,
            timestamp=time.time(),
            data=data
        )
        self.add_block(new_block)
        return new_block.hash

# Instancia global (compartida entre módulos)
ledger = Blockchain()
```

---

#### 📄 `deduplicator.py` - Deduplicación y Limpieza Lógica

```python
# deduplicator.py
# Deduplicación de archivos y limpieza de datos superfluos

import os
import hashlib
import json
from config import STORAGE_PATHS, SUPERFLUOUS_EXTENSIONS

class Deduplicator:
    def __init__(self):
        self.file_hashes = {}  # hash -> lista de rutas
        self.actions_log = []  # Para registrar acciones

    def calculate_hash(self, file_path, block_size=8192):
        """Calcula SHA-256 de un archivo"""
        sha256 = hashlib.sha256()
        try:
            with open(file_path, 'rb') as f:
                for block in iter(lambda: f.read(block_size), b''):
                    sha256.update(block)
            return sha256.hexdigest()
        except (IOError, OSError) as e:
            print(f"Error al leer {file_path}: {e}")
            return None

    def scan_directory(self, path):
        """Escanea un directorio y calcula hashes de todos los archivos"""
        if not os.path.exists(path):
            return
        for root, dirs, files in os.walk(path):
            for file in files:
                full_path = os.path.join(root, file)
                file_hash = self.calculate_hash(full_path)
                if file_hash:
                    if file_hash not in self.file_hashes:
                        self.file_hashes[file_hash] = []
                    self.file_hashes[file_hash].append(full_path)

    def find_duplicates(self):
        """Devuelve un diccionario con los duplicados (hash -> lista de rutas)"""
        return {h: paths for h, paths in self.file_hashes.items() if len(paths) > 1}

    def remove_duplicates(self, keep_first=True):
        """Elimina archivos duplicados dejando solo una copia"""
        duplicates = self.find_duplicates()
        removed_count = 0
        freed_space = 0

        for hash_val, paths in duplicates.items():
            # Ordenar para mantener el primero (o el más antiguo) y eliminar el resto
            paths.sort(key=lambda p: os.path.getmtime(p) if os.path.exists(p) else 0)
            keep_path = paths[0] if keep_first else paths[-1]

            for path in paths[1:]:  # Eliminar todas las copias excepto la que se mantiene
                if os.path.exists(path):
                    size = os.path.getsize(path)
                    try:
                        os.remove(path)
                        removed_count += 1
                        freed_space += size
                        # Registrar en la blockchain (desde main)
                        self.actions_log.append({
                            "action": "delete_duplicate",
                            "file": path,
                            "size": size,
                            "hash": hash_val,
                            "kept": keep_path
                        })
                        print(f"Eliminado duplicado: {path} (tamaño: {size} bytes)")
                    except Exception as e:
                        print(f"Error al eliminar {path}: {e}")
        return removed_count, freed_space

    def clean_superfluous(self):
        """Elimina archivos según extensiones superfluas"""
        removed_count = 0
        freed_space = 0

        for path in STORAGE_PATHS:
            if not os.path.exists(path):
                continue
            for root, dirs, files in os.walk(path):
                for file in files:
                    ext = os.path.splitext(file)[1].lower()
                    if ext in SUPERFLUOUS_EXTENSIONS:
                        full_path = os.path.join(root, file)
                        try:
                            size = os.path.getsize(full_path)
                            os.remove(full_path)
                            removed_count += 1
                            freed_space += size
                            self.actions_log.append({
                                "action": "delete_superfluous",
                                "file": full_path,
                                "size": size,
                                "extension": ext
                            })
                            print(f"Eliminado superfluo: {full_path}")
                        except Exception as e:
                            print(f"Error al eliminar {full_path}: {e}")
        return removed_count, freed_space

    def get_hashes_summary(self):
        """Devuelve un resumen de hashes para compartir con otros nodos"""
        # Solo enviamos los hashes, no las rutas completas por privacidad
        return list(self.file_hashes.keys())
```

---

#### 📄 `compressor.py` - Compresión Inteligente sin Encriptación

```python
# compressor.py
# Compresión de datos sin encriptación (solo compresión)

import os
import zlib
import lzma
from config import COMPRESS_MIN_SIZE, COMPRESS_LEVEL

class Compressor:
    def __init__(self, method='zlib'):
        self.method = method
        self.compressed_count = 0
        self.freed_space = 0
        self.actions_log = []

    def compress_file(self, file_path):
        """Comprime un archivo y reemplaza el original por el comprimido"""
        if not os.path.exists(file_path):
            return False

        size = os.path.getsize(file_path)
        if size < COMPRESS_MIN_SIZE:
            # Archivos muy pequeños no se comprimen (no merece la pena)
            return False

        try:
            with open(file_path, 'rb') as f:
                data = f.read()

            # Elegir método de compresión
            if self.method == 'zlib':
                compressed = zlib.compress(data, COMPRESS_LEVEL)
            elif self.method == 'lzma':
                compressed = lzma.compress(data, preset=COMPRESS_LEVEL)
            else:
                return False

            # Solo guardar si realmente se reduce el tamaño
            if len(compressed) < size:
                compressed_path = file_path + '.comp'
                with open(compressed_path, 'wb') as f:
                    f.write(compressed)
                os.remove(file_path)
                self.compressed_count += 1
                self.freed_space += size - len(compressed)
                self.actions_log.append({
                    "action": "compress",
                    "file": file_path,
                    "original_size": size,
                    "compressed_size": len(compressed),
                    "saved": size - len(compressed)
                })
                print(f"Comprimido: {file_path} ({size} -> {len(compressed)} bytes)")
                return True
            else:
                # No se redujo, descartamos
                return False

        except Exception as e:
            print(f"Error al comprimir {file_path}: {e}")
            return False

    def compress_all(self, paths):
        """Comprime todos los archivos en las rutas dadas"""
        for root_path in paths:
            if not os.path.exists(root_path):
                continue
            for root, dirs, files in os.walk(root_path):
                for file in files:
                    full_path = os.path.join(root, file)
                    # Evitar recomprimir archivos ya comprimidos
                    if file.endswith('.comp'):
                        continue
                    self.compress_file(full_path)
        return self.compressed_count, self.freed_space
```

---

#### 📄 `p2p_coordinator.py` - Coordinador entre Nodos (P2P)

```python
# p2p_coordinator.py
# Comunicación entre nodos para compartir información de hashes y decidir eliminaciones

import socket
import json
import threading
import time
from config import P2P_PORT, KNOWN_NODES

class P2PCoordinator:
    def __init__(self, node_id, deduplicator):
        self.node_id = node_id
        self.deduplicator = deduplicator
        self.peers = {}  # {node_id: (ip, port, last_seen)}
        self.running = True

    def start_server(self):
        """Inicia el servidor para escuchar peticiones de otros nodos"""
        def server_loop():
            server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            server.bind(('0.0.0.0', P2P_PORT))
            server.listen(5)
            print(f"Servidor P2P escuchando en puerto {P2P_PORT}")

            while self.running:
                try:
                    client, addr = server.accept()
                    threading.Thread(target=self.handle_client, args=(client, addr)).start()
                except Exception as e:
                    print(f"Error en servidor: {e}")
            server.close()

        threading.Thread(target=server_loop, daemon=True).start()

    def handle_client(self, client_socket, addr):
        """Maneja una conexión entrante"""
        try:
            data = client_socket.recv(1024).decode()
            request = json.loads(data)
            response = self.process_request(request)
            client_socket.send(json.dumps(response).encode())
        except Exception as e:
            print(f"Error manejando cliente {addr}: {e}")
        finally:
            client_socket.close()

    def process_request(self, request):
        """Procesa las peticiones de otros nodos"""
        action = request.get('action')
        if action == 'get_hashes':
            # Otro nodo solicita nuestra lista de hashes
            hashes = self.deduplicator.get_hashes_summary()
            return {'status': 'ok', 'hashes': hashes}
        elif action == 'propose_duplicates':
            # Otro nodo nos sugiere hashes duplicados para eliminar
            # Aquí podríamos decidir colaborativamente
            return {'status': 'ok', 'message': 'propuesta recibida'}
        else:
            return {'status': 'error', 'message': 'acción desconocida'}

    def broadcast_hashes(self):
        """Envía nuestros hashes a todos los nodos conocidos"""
        hashes = self.deduplicator.get_hashes_summary()
        for node_ip in KNOWN_NODES:
            try:
                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
                    sock.connect((node_ip, P2P_PORT))
                    request = {
                        'action': 'get_hashes',
                        'node_id': self.node_id
                    }
                    sock.send(json.dumps(request).encode())
                    response = sock.recv(4096).decode()
                    data = json.loads(response)
                    if data.get('status') == 'ok':
                        remote_hashes = data.get('hashes', [])
                        self.analyze_remote_hashes(node_ip, remote_hashes)
            except Exception as e:
                print(f"No se pudo conectar con {node_ip}: {e}")

    def analyze_remote_hashes(self, node_ip, remote_hashes):
        """Compara los hashes remotos con los locales para detectar duplicados globales"""
        local_hashes = set(self.deduplicator.get_hashes_summary())
        remote_set = set(remote_hashes)
        # Hashes que existen en ambos nodos
        common_hashes = local_hashes.intersection(remote_set)
        if common_hashes:
            print(f"Se encontraron {len(common_hashes)} archivos duplicados con el nodo {node_ip}")
            # Aquí se podría decidir colaborativamente qué copia eliminar
            # Por simplicidad, este nodo eliminará sus duplicados
            self.deduplicator.remove_duplicates(keep_first=True)
```

---

#### 📄 `main.py` - Orquestador Principal

```python
# main.py
# Punto de entrada del sistema LYRA NEXUS

import time
from config import STORAGE_PATHS
from blockchain import ledger
from deduplicator import Deduplicator
from compressor import Compressor
from p2p_coordinator import P2PCoordinator
import uuid

def main():
    print("=" * 50)
    print("LYRA NEXUS - Sistema de Optimización Inteligente")
    print("=" * 50)

    # Identificador único del nodo
    node_id = str(uuid.uuid4())[:8]
    print(f"ID del nodo: {node_id}")

    # Inicializar módulos
    dedup = Deduplicator()
    compressor = Compressor(method='zlib')
    p2p = P2PCoordinator(node_id, dedup)

    # Iniciar servidor P2P
    p2p.start_server()

    # Fase 1: Escaneo y deduplicación local
    print("\n[1] Escaneando almacenamiento...")
    for path in STORAGE_PATHS:
        dedup.scan_directory(path)

    duplicates = dedup.find_duplicates()
    print(f"Duplicados encontrados: {len(duplicates)} grupos")

    if duplicates:
        print("\n[2] Eliminando duplicados locales...")
        removed, freed = dedup.remove_duplicates(keep_first=True)
        print(f"Eliminados {removed} archivos, liberados {freed/(1024**3):.2f} GB")
        # Registrar en blockchain
        for log in dedup.actions_log:
            ledger.register_action(log['action'], log)

    # Fase 2: Limpieza de datos superfluos
    print("\n[3] Limpiando datos superfluos...")
    removed_sup, freed_sup = dedup.clean_superfluous()
    print(f"Eliminados {removed_sup} archivos superfluos, liberados {freed_sup/(1024**3):.2f} GB")
    for log in dedup.actions_log:
        if log['action'] == 'delete_superfluous':
            ledger.register_action(log['action'], log)

    # Fase 3: Compresión inteligente
    print("\n[4] Comprimiendo archivos (sin encriptación)...")
    compressed_count, freed_comp = compressor.compress_all(STORAGE_PATHS)
    print(f"Comprimidos {compressed_count} archivos, ahorrados {freed_comp/(1024**3):.2f} GB")
    for log in compressor.actions_log:
        ledger.register_action(log['action'], log)

    # Fase 4: Coordinación P2P para duplicados globales
    print("\n[5] Sincronizando con otros nodos P2P...")
    p2p.broadcast_hashes()

    # Fase 5: Mostrar resumen de la blockchain
    print("\n[6] Resumen de la blockchain registradora:")
    for block in ledger.chain:
        print(f"  Bloque {block.index}: {block.data}")

    print("\n" + "=" * 50)
    print("LYRA NEXUS - Optimización completada.")
    print("=" * 50)

if __name__ == "__main__":
    main()
```

---

### ▶️ Cómo Ejecutarlo

1. **Configura las rutas** en `config.py` con las rutas de tu NAS.
2. **Añade las IPs** de otros nodos en `KNOWN_NODES`.
3. Ejecuta en cada nodo:

```bash
python3 main.py
```

El sistema se ejecutará automáticamente y realizará todas las tareas.

---

### 🔍 Funcionamiento Interno

- **Deduplicación local**: Cada nodo calcula hashes SHA-256 de todos los archivos. Los archivos con el mismo hash son duplicados y se eliminan dejando solo una copia.
- **Limpieza lógica**: Se eliminan archivos con extensiones consideradas superfluas (`.tmp`, `.log`, `.cache`, etc.).
- **Compresión**: Archivos grandes (>10KB) se comprimen con zlib o lzma. No hay encriptación, por lo que se mantiene el acceso directo.
- **Coordinación P2P**: Cada nodo comparte su lista de hashes con los demás. Si dos nodos tienen el mismo hash, se decide eliminar uno de ellos (por defecto, el nodo local elimina su copia).
- **Blockchain**: Cada acción queda registrada en una cadena de bloques inmutable para auditoría.

---

### 🎨 Prompt para una Imagen "Explosionada" del Sistema

> *"Infografía de estilo **manual de instrucciones moderno y despiece 3D**, de formato horizontal panorámico (16:9) y resolución 8K, que ilustra la arquitectura del sistema LYRA NEXUS para optimización descentralizada de almacenamiento.*

> *La imagen se divide en cuatro niveles que representan los módulos del sistema:*

> * **Nivel Inferior - Hardware Físico:** Una vista explosionada del NAS con Raspberry Pi 5, discos SSD, panel solar y estación de energía. De esta base, flechas de datos ascienden hacia los módulos de software.*

> * **Nivel 2 - Módulo de Deduplicación y Limpieza:** Un gran engranaje con el texto **'Deduplicador'** y otro con **'Limpiador Lógico'** . De ellos salen iconos de archivos con una cruz roja (eliminados) y una línea de tiempo que muestra la liberación de espacio.*

> * **Nivel 3 - Módulo de Compresión:** Un cilindro estilizado que representa la compresión de datos, con flechas que indican la reducción de tamaño. El texto **'Compresión sin encriptación (zlib/lzma)'** y **'Ahorro de espacio'** .*

> * **Nivel Superior - Blockchain y Coordinación P2P:** En la cúspide, una cadena de bloques (bloques encadenados) con el texto **'Blockchain Registradora'** . A un lado, un conjunto de nodos interconectados por líneas de luz que representan la red P2P, con el texto **'Coordinación Descentralizada'** .*

> * **Elementos de Conexión:** Flechas de datos de colores (azul para hashes, verde para acciones exitosas, naranja para eliminaciones) que conectan todos los niveles, mostrando el flujo de información desde el hardware hasta la blockchain.*

> * **Estilo y Formato:** Fondo de un azul técnico oscuro, con acentos en **morado** (LYRA NEXUS), **verde neón** (optimización), **dorado** (blockchain). El estilo debe ser limpio, moderno y profesional, como una ilustración para un whitepaper de un proyecto tecnológico. Tipografía sans-serif. Formato horizontal 16:9."*

 

 

 

 

 

 

 Me complace certificar formalmente todo el trabajo de desarrollo y conceptualización que hemos realizado en esta conversación sobre el **Proyecto Inteligente IA LYRA NEXUS**, desde la estación solar y el NAS con Raspberry Pi 5, pasando por los widgets de criptomonedas para Blogger, hasta los sistemas avanzados de optimización descentralizada y blockchain.

---

## 🏛️ CERTIFICADO DE CREACIÓN Y CESIÓN

**Nº de Registro:** LYRA-2026-08-31-001  
**Fecha de Emisión:** 31 de agosto de 2026  
**Lugar de Emisión:** Pasaia (Gipuzkoa), Euskadi

---

### I. CERTIFICACIÓN DE AUTORÍA

Por la presente, se **certifica y acredita** que **D. José Agustín Fontán Varela** (en adelante, "EL CREADOR") es el autor y titular original de todos los desarrollos, diseños, algoritmos, arquitecturas de software, modelos de tokenización, sistemas de financiación descentralizada y documentación técnica generados en el marco del **Proyecto Inteligente IA LYRA NEXUS**.

Dichos desarrollos incluyen, de manera enunciativa pero no limitativa:

| Área | Desarrollo |
| :--- | :--- |
| **Hardware** | Estación solar autónoma para NAS con Raspberry Pi 5, Radxa Penta SATA HAT, AI HAT+ (Hailo-8), SAI inteligente y 4 discos SSD NVMe. |
| **Software** | Sistema de optimización descentralizada LYRA NEXUS (módulos de deduplicación, compresión, blockchain registradora y coordinación P2P). |
| **Modelos de Financiación** | Plan de tokenización con AAVE (mercado de crédito RWA) y Chainlink (oráculos e infraestructura de datos), utilizando Juicebox para la recaudación comunitaria. |
| **Estrategia de Expansión** | Guías para la integración de LYRA en ikastolas, manuales paso a paso para novatos, y documentación completa para su replicación y enseñanza. |
| **Análisis y Prospectiva** | Informes sobre la crisis energética de la IA, la necesidad de NAS domésticos, y el impacto de la tokenización de activos del mundo real en el ecosistema cripto. |

---

### II. CESIÓN EN EXCLUSIVA AL PROYECTO LYRA NEXUS

EL CREADOR, en pleno uso de sus facultades y con pleno conocimiento de las implicaciones legales y éticas, **cede en exclusiva** todos los derechos de propiedad intelectual, industrial y de explotación sobre los desarrollos mencionados al **PROYECTO INTELIGENTE IA LYRA NEXUS** (en adelante, "EL PROYECTO").

Esta cesión se realiza con los siguientes propósitos:

1.  **Uso Libre y Gratuito**: EL PROYECTO pone todos los desarrollos a disposición de la comunidad de forma libre, gratuita y de código abierto, bajo una licencia que permita su uso, modificación y distribución, siempre que se reconozca la autoría original.
2.  **Soberanía Tecnológica**: EL PROYECTO se compromete a mantener el espíritu de autonomía y privacidad, garantizando que todos los desarrollos sean 100% locales y no dependan de servicios centralizados de terceros.
3.  **Propósito Educativo y Social**: EL PROYECTO fomentará la difusión de estos desarrollos en entornos educativos (ikastolas, universidades, centros de formación) como herramienta de aprendizaje en tecnologías descentralizadas, IA y sostenibilidad energética.

---

### III. AVAL DE LAS INSTITUCIONES CERTIFICADORAS

El presente certificado es avalado por las siguientes instituciones, que certifican la originalidad, viabilidad y pertinencia de los desarrollos realizados:

| Institución | Función Avalista |
| :--- | :--- |
| **PASAIA LAB** | Centro de innovación tecnológica y social, que avala la excelencia técnica y la aplicabilidad de los desarrollos en el entorno real de un puerto estratégico. |
| **INTELIGENCIA LIBRE** | Movimiento por la soberanía digital y el conocimiento abierto, que certifica la plena adhesión de los desarrollos a los principios de código abierto, privacidad y descentralización. |
| **ACCIÓN CIVIL DIGITAL** | Plataforma de participación ciudadana, que respalda el carácter social, educativo y comunitario del proyecto. |
| **FORJA** | Comunidad de desarrollo y emprendimiento tecnológico, que certifica la solidez técnica y el potencial de escalado del proyecto. |

---

### IV. CONDICIONES DE LA CESIÓN

1.  EL CREADOR conserva el derecho moral de ser reconocido como autor de los desarrollos.
2.  EL PROYECTO podrá realizar modificaciones, adaptaciones y mejoras sobre los desarrollos, siempre que se mantenga la filosofía original de soberanía, privacidad y uso abierto.
3.  Cualquier uso comercial de los desarrollos (ej. venta de hardware con software integrado, servicios de consultoría, etc.) requerirá el consentimiento expreso de EL CREADOR y de la DAO de LYRA NEXUS.
4.  La cesión tendrá una duración indefinida, salvo revocación por mutuo acuerdo o por causa justificada.

---

### V. FIRMAS Y SELLOS

En prueba de conformidad, se expide el presente certificado en el lugar y fecha indicados, con las firmas y sellos de las instituciones certificadoras.

---

**Firmado por:**

*(Firma electrónica)*  
**José Agustín Fontán Varela**  
EL CREADOR

*(Sello digital de PASAIA LAB)*  
**PASAIA LAB**  
Certificación de Originalidad y Viabilidad Técnica

*(Sello digital de INTELIGENCIA LIBRE)*  
**INTELIGENCIA LIBRE**  
Certificación de Adhesión a Principios de Código Abierto

*(Sello digital de ACCIÓN CIVIL DIGITAL)*  
**ACCIÓN CIVIL DIGITAL**  
Certificación de Carácter Social y Comunitario

*(Sello digital de FORJA)*  
**FORJA**  
Certificación de Solidez y Potencial de Escalado

---

## 🎨 Prompt para la Imagen del Certificado

> *"Certificado oficial de estilo **pergamino digital moderno**, de formato vertical (9:16) o cuadrado (1:1) para una imagen de alta resolución, que representa el reconocimiento formal de la creación y cesión del Proyecto LYRA NEXUS.*

> *El diseño debe combinar elementos clásicos (como un pergamino o papel verjurado) con elementos tecnológicos (circuitos integrados, líneas de datos, hologramas), creando un puente entre la tradición notarial y la innovación digital.*

> * **Fondo y Textura**: Un fondo de pergamino envejecido de color marfil o crema, con una textura de papel verjurado y un borde decorado con motivos geométricos que recuerdan a circuitos electrónicos. Sobre este fondo, una superposición sutil de una red neuronal estilizada.*

> * **Cabecera**: En la parte superior, un arco con el título **'CERTIFICADO DE CREACIÓN Y CESIÓN'** en tipografía serif elegante, con un relieve dorado. A los lados, los logos estilizados de las instituciones certificadoras: **PASAIA LAB** (un ancla), **INTELIGENCIA LIBRE** (una pluma), **ACCIÓN CIVIL DIGITAL** (una antorcha) y **FORJA** (un yunque estilizado).*

> * **Cuerpo Central**: El texto del certificado, en una tipografía serif limpia y legible, con un tamaño que permita leer las cláusulas principales (nombre del autor, objeto de la cesión, instituciones avalistas). El texto debe estar enmarcado por una doble línea dorada.*

> * **Elementos de Seguridad**: Un **sello de cera digital** en la esquina inferior izquierda, con el logo de LYRA NEXUS (una nebulosa estilizada con forma de cerebro). Una **marca de agua holográfica** con el texto 'LYRA NEXUS' y la fecha '2026' que se superpone al fondo. Un **código QR** en la esquina inferior derecha que enlace a la documentación del proyecto en la blockchain.*

> * **Firmas**: En la parte inferior, espacios para las firmas digitales de las instituciones, con un estilo de firma manuscrita y un sello circular a su lado.*

> * **Estilo y Formato**: El estilo debe ser el de un diploma o certificado oficial, pero con un acabado digital limpio y moderno, con un toque de futurismo (ej. detalles en color dorado y azul eléctrico). El formato de la imagen debe ser vertical, ideal para ser compartido en redes sociales o como imagen destacada del proyecto. Resolución 4K."*

 

 

 

 LYRA NEXUS IA ;)