diff --git a/astro.config.mjs b/astro.config.mjs
index 65feba5..09eed00 100644
--- a/astro.config.mjs
+++ b/astro.config.mjs
@@ -4,7 +4,21 @@ import starlight from '@astrojs/starlight';
export default defineConfig({
integrations: [
starlight({
- title: 'VSC Documentation',
+ title: {
+ en: 'VSC Documentation',
+ 'es': 'VSC Documentación',
+ },
+ defaultLocale: 'root',
+ locales: {
+ root: {
+ label: 'English',
+ lang: 'en',
+ },
+ 'es': {
+ label: 'Español',
+ lang: 'es',
+ },
+ },
social: [
{ icon: 'github', label: 'GitHub', href: 'https://github.com/vsc-eco' }
],
diff --git a/src/content/docs/FAQ.md b/src/content/docs/FAQ.md
index 785995f..4872ab1 100644
--- a/src/content/docs/FAQ.md
+++ b/src/content/docs/FAQ.md
@@ -19,4 +19,6 @@ VSC uses WebAssembly (or WASM) to power it's smart contracts. WASM enables devel
Mainnet has launched March 31st 2025.
## What does VSC stand for?
-Virtual Smart Chain
\ No newline at end of file
+Virtual Smart Chain
+
+**Note:** VSC (Virtual Smart Chain) changed its name to **Magi Network**. You can find more information [here](https://peakd.com/vsc/@vsc.network/vsc-is-now-magi-network-rebrand-announcement).
diff --git a/src/content/docs/es/03_Native Asset Mapping.md b/src/content/docs/es/03_Native Asset Mapping.md
new file mode 100644
index 0000000..a398b5d
--- /dev/null
+++ b/src/content/docs/es/03_Native Asset Mapping.md
@@ -0,0 +1,29 @@
+---
+title: Asignación de Activos Nativos
+sidebar:
+ order: 4
+---
+
+**La Asignación de activos nativo _(Native Asset Mapping)_** es la principal característica innovadora del protocolo VSC que permite a los usuarios enviar y recibir activos nativos entre direcciones de billetera de distintas cadenas de bloques, a través de VSC, reduciendo las preocupaciones sobre la compatibilidad de cadenas.
+
+Permite a los usuarios enviar, por ejemplo, **SOL de una billetera de Solana a una dirección de billetera de Ethereum**. El receptor recibe **SOL nativo**, visible y utilizable en VSC cuando inicia sesión con su billetera de Ethereum. Los *tokens* SOL recibidos permanecen en la bóveda VSC en la red principal de Solana y están asegurados por el sistema de validadores del protocolo VSC. Al completar la transacción, la propiedad de esos *tokens* se transfiere a la cuenta que recibe el SOL.
+
+## Cómo funciona
+
+La asignación de activos nativo vincula la dirección de una única billetera del usuario (por ejemplo, ETH) a su cuenta VSC, permitiéndole recibir activos nativos desde cualquier *blockchain* compatible, incluso si esos activos se originan en una cadena diferente a la billetera que conectó.
+
+1. El usuario se conecta a VSC utilizando una billetera, por ejemplo, su billetera de Solana.
+2. El emisor deposita *tokens* Sol en VSC. En la opción "transferir", el emisor introduce la dirección ETH del receptor. (Esto difiere de los intercambios atómicos entre cadenas, otra funcionalidad clave de VSC).
+3. VSC asigna el activo entrante a la dirección ETH en su registro interno. (Las transferencias dentro de VSC **no incurren en tarifas de transacción directas para los usuarios**).
+4. El receptor inicia sesión con su billetera ETH y ve el activo depositado (por ejemplo, SOL).
+5. El receptor ahora puede **intercambiar**, **retirar** o **usar** el activo dentro de VSC.
+
+## Implicaciones
+
+Con la asignación de activos nativo, solo necesitas compartir una única dirección de billetera para recibir pagos, independientemente de la red en la que se encuentren el emisor o tú, el receptor. No hay necesidad de administrar múltiples billeteras ni de preocuparse por la compatibilidad entre *blockchains*. Los usuarios ya no tienen que pensar en qué red están ellos o los demás. Los fondos se pueden enviar y recibir sin problemas, sin fricción, confusión o la necesidad de conocimiento técnico. Este modelo establece un nuevo estándar para la experiencia del usuario (UX) en el mundo cripto. **Este enfoque busca simplificar la experiencia del usuario al reducir la fragmentación entre _blockchains_, avanzando hacia un sistema más unificado diseñado para una mayor usabilidad**.
+
+- Hace que las transacciones criptomonedas sean tan sencillas como enviar un correo electrónico a una sola dirección.
+- Elimina la necesidad de activos envueltos _(wrapped assets)_ custodiados y del **salto entre cadenas _(chain-hopping)_**.
+- Abstrae la complejidad técnica de las transacciones en criptomonedas.
+- Potencia los pagos globales, la adopción por parte de comercios y el uso de remesas.
+- Permite que VSC sirva como una capa de liquidación unificada dentro de su red de *blockchains* compatibles. El protocolo VSC mantiene el registro de quién posee qué, a lo largo de todas las cadenas compatibles, de forma definitiva, con irrevocabilidad.
diff --git a/src/content/docs/es/04_Feeless In-Protocol Transactions.md b/src/content/docs/es/04_Feeless In-Protocol Transactions.md
new file mode 100644
index 0000000..52e92b5
--- /dev/null
+++ b/src/content/docs/es/04_Feeless In-Protocol Transactions.md
@@ -0,0 +1,64 @@
+---
+title: Transacciones dentro del protocolo sin comisiones
+sidebar:
+ order: 5
+---
+
+VSC ofrece a los usuarios una **experiencia sin comisiones** para las interacciones en la cadena al adoptar un sistema similar al **sistema de crédito de recursos (RC) de la _blockchain_ de Hive**, el cual asigna ancho de banda en lugar de cobrar las tarifas de gas tradicionales. Este enfoque elimina las tarifas de gas tradicionales de la experiencia del usuario mientras preserva la descentralización y la integridad de la red. Permite una incorporación y un uso escalables y de baja fricción, adecuados para aplicaciones masivas. La diferencia es que VSC utiliza HBD como base para la distribución de RC, mientras que Hive utiliza HIVE en *staking* (HP).
+
+## ¿Qué son los créditos de recursos *(Resource Credits - RC)*?
+
+VSC utiliza un modelo de **crédito de recursos (RC)** en lugar de las tarifas de transacción convencionales. Los RC actúan como un sistema interno de asignación de ancho de banda, asegurando el uso justo de la red sin requerir pagos en un *token* nativo por cada acción.
+
+- Los RC **no son _tokens_ comerciables**.
+- Están **vinculados a la cantidad de HBD** que posee una cuenta.
+- Los RC a menudo son delegados automáticamente a los usuarios por las dApps y otros proyectos asociados a Hive, como VSC, creando una experiencia instantánea sin gas *(gasless)*.
+- Cada cuenta de usuario tiene un fondo de RC que **se regenera con el tiempo** a una tasa de aproximadamente el 25% por día, alcanzando su capacidad máxima en unos 4 días si no se utiliza.
+
+Los RC se **consumen** cuando un usuario realiza acciones en la cadena, tales como:
+
+- Transferir *tokens*
+- Publicar o comentar
+- Firmar transacciones
+- Interactuar con contratos inteligentes o dApps construidas sobre Hive
+
+## Cómo VSC utiliza los créditos de recursos (RC)
+
+VSC está construido sobre la *blockchain* de Hive y **utiliza directamente el sistema de RC de Hive** para cubrir los costes computacionales y de ancho de banda de las transacciones de los usuarios. En lugar de cobrar tarifas de gas, VSC se basa en estos créditos que se regeneran, lo que permite:
+
+- **Interacciones de usuario efectivamente sin comisiones bajo condiciones de uso típicas:** Los usuarios no necesitan poseer ni gastar ningún *token* para interactuar con la red.
+
+- **Incorporación simplificada:** Sin compras de *tokens* iniciales ni gestión compleja de tarifas, ideal para usuarios no familiarizados con las criptomonedas.
+
+- **Escalabilidad predecible:** Dado que los RC se regeneran y están vinculados al *stake* de la cuenta, las aplicaciones pueden modelar las necesidades de recursos a lo largo del tiempo y delegar poder en consecuencia.
+
+
+## Implicaciones para desarrolladores y usuarios
+
+### Para usuarios
+
+- **Sin tarifas de gas:** La interacción con VSC no requiere que el usuario gaste HIVE, HBD o cualquier otro *token* para las transacciones.
+- **Regeneración automática:** Los RC se recargan con el tiempo.
+- **Límites basados en el uso:** El uso intensivo agota temporalmente los RC; la actividad se reanuda a medida que se recargan, o el usuario deposita más HBD. Actualmente, poseer valores de HBD de un solo dígito en dólares cubre el uso promedio diario de transacciones. Generalmente, esto no es un problema debido a que proyectos como VSC o las dApps de Hive cubren el gasto de RC de los usuarios.
+
+### Para desarrolladores
+
+- **Modelos de delegación:** Las aplicaciones pueden delegar Hive Power a los usuarios o a cuentas de servicio para garantizar una disponibilidad adecuada de RC.
+- **Experiencia de usuario sin comisiones:** Permite el diseño de aplicaciones amigables para el público masivo sin la fricción de las tarifas de transacción.
+- **Planificación de capacidad:** Los desarrolladores pueden estimar la cantidad de Hive Power necesaria para soportar un volumen determinado de actividad basándose en los perfiles de uso de RC. A medida que la actividad de los usuarios crece, las aplicaciones se benefician de una mayor interacción, formando un sistema simbiótico en el que el uso y el aprovisionamiento de recursos se refuerzan mutuamente.
+
+## Consideraciones
+
+Aunque el modelo de creditos de recursos (RC) ofrece una experiencia sin comisión, es importante señalar que:
+
+- **El uso de alta frecuencia** puede llevar al agotamiento temporal de los RC. Esto no conlleva una tarifa, pero retrasa las transacciones posteriores hasta que los RC se recarguen.
+- **Las aplicaciones deben gestionar el HBD de forma efectiva**, ya sea manteniendo reservas o utilizando la delegación para dar soporte a los usuarios activos.
+- **El acceso respaldado por _stake_** favorece la sostenibilidad y reduce el abuso, alineando los incentivos con la salud de la red.
+
+---
+
+## Conclusión
+
+La adopción por parte de VSC del sistema RC de Hive permite una experiencia de *blockchain* sin comisiones, escalable y fácil de usar. Al abstraer las tarifas de gas y utilizar créditos regenerativos, VSC proporciona una plataforma para la adopción masiva sin comprometer la descentralización o el rendimiento.
+
+Para los desarrolladores, este modelo fomenta una gestión reflexiva de los recursos al tiempo que abre la puerta a aplicaciones tan fluidas como los servicios web tradicionales.
diff --git a/src/content/docs/es/05_Stablecoin (HBD) as the Base Asset.md b/src/content/docs/es/05_Stablecoin (HBD) as the Base Asset.md
new file mode 100644
index 0000000..010b56b
--- /dev/null
+++ b/src/content/docs/es/05_Stablecoin (HBD) as the Base Asset.md
@@ -0,0 +1,42 @@
+---
+title: Moneda estable (HBD) como activo base
+sidebar:
+ order: 6
+---
+
+VSC emplea Hive Backed Dollars (HBD), una moneda estable algorítmica, como el activo base en todos los fondos de liquidez. Este diseño estandariza las rutas de enrutamiento, simplifica el suministro de liquidez y reduce la exposición al riesgo debido a que todos los fondos solo tienen volatilidad de un solo lado. Al usar HBD como par común, los proveedores de liquidez solo están expuestos al rendimiento de su activo volátil elegido, emparejado con HBD. Esto resulta en una cartera que refleja el rendimiento del único activo volátil en lugar de múltiples fuentes de volatilidad de precios, mejorando la previsibilidad y la gestión del riesgo.
+
+## Fundamentos del diseño
+
+### Suministro de liquidez simplificado
+
+Al emparejar cada activo frente a HBD, VSC reduce la complejidad del suministro de liquidez. Los proveedores de liquidez solo necesitan aportar HBD y un único activo adicional, lo que disminuye la barrera de entrada y concentra la liquidez de manera más efectiva.
+
+### Enrutamiento eficiente
+
+El uso de HBD como intermediario universal permite intercambios de activos de forma sencilla. Por ejemplo, el intercambio de **Activo A** por **Activo B** implica dos pasos: `Activo A → HBD → Activo B`. Esto reduce el número total de fondos requeridos de O(n²) a O(n), donde *n* es el número de activos, mejorando la eficiencia del capital y la simplicidad del enrutamiento.
+
+
+| Número de activos (ej. BTC, ETH, HIVE) | Fondos requeridos (pares arbitrarios) | Fondos requeridos (activo base HBD) |
+|----------------------------------------|---------------------------------------|-------------------------------------|
+| n | fondos = n * (n - 1) / 2 | n = fondos |
+| 12 | 66 | 12 |
+| 36 | 630 | 36 |
+| 100 | 4,950 | 100 |
+
+
+### Estabilidad y previsibilidad
+
+El HBD está diseñado para mantener un valor estable, lo que proporciona una base predecible para los fondos de liquidez. Esta estabilidad reduce la exposición a las perturbaciones de volatilidad que se observan a menudo en los sistemas que utilizan *tokens* volátiles como pares base, protegiendo a los proveedores de liquidez y a los traders de las fluctuaciones repentinas de precios.
+
+- **Reducción de la fragmentación del fondo:** Emparejar activos con HBD disminuye el número de fondos de liquidez necesarios, lo que puede ayudar a concentrar la liquidez y mejorar la eficiencia del capital.
+
+- **Fijación de precios simplificada:** La fijación de precios es más sencilla cuando se basa en un activo estable, ya que depende principalmente del valor relativo entre HBD y el activo emparejado.
+
+---
+
+## Consideraciones
+
+- **Profundidad de Liquidez:** Mantener suficiente liquidez de HBD es esencial para garantizar intercambios eficientes y reducir el deslizamiento en todo el ecosistema.
+- **Mantenimiento de la paridad de la moneda estable:** La efectividad de este modelo se basa en que el HBD mantenga su paridad. La *blockchain* de Hive incluye mecanismos integrados y múltiples salvaguardas diseñadas para monitorear y preservar la estabilidad del HBD a lo largo del tiempo.
+- **Compatibilidad entre cadenas _(Cross-Chain)_:** El soporte para activos de otras *blockchains* depende del desarrollo y la implementación de bóvedas específicas e integraciones de validadores para cada cadena, lo que permite su emparejamiento seguro con HBD.
diff --git a/src/content/docs/es/Block-explorers.md b/src/content/docs/es/Block-explorers.md
new file mode 100644
index 0000000..6e1e970
--- /dev/null
+++ b/src/content/docs/es/Block-explorers.md
@@ -0,0 +1,37 @@
+---
+title: Exploradores de bloques
+sidebar:
+ order: 15
+---
+
+*Por ahora, tenemos un explorador de bloques maduro en nuestro ecosistema.*
+
+[https://vsc.techcoderx.com/](https://vsc.techcoderx.com/)
+
+El explorador de bloques fue creado y es mantenido por _techcoderx_.
+
+Expone varias métricas de la red VSC, sobre las que daremos más detalles a continuación.
+
+### Información del bloque
+
+Inspecciona la estructura del bloque de la red VSC en [/blocks](https://vsc.techcoderx.com/blocks).
+
+Haz clic en un hash de bloque para obtener una vista detallada de su contenido. Puedes, por ejemplo, inspeccionar las transacciones incluidas.
+
+### Vista de transacción
+
+Al hacer clic en los hashes de transacción en varias partes del explorador de bloques, se le dirige a la vista de transacción.
+
+Dependiendo del tipo de transacción, esta expone diversa información que es importante en el contexto actual.
+
+Por ejemplo, una invocación de contrato le mostraría el punto de entrada (o acción del contrato) que se ejecutó, así como los parámetros (o el cuerpo de la llamada - *payload*).
+
+Como nota adicional, cuando una invocación de contrato es exitosa y produce una transacción de salida de contrato, el resultado de la transacción de salida del contrato también se muestra en la transacción de invocación del contrato, ¡lo que permite una experiencia de usuario más fluida!
+
+### Información del testigos *(witness)*.
+
+Si alojas un nodo VSC, puedes comprobar si tu nodo está registrado y actualizado en [/witnesses](https://vsc.techcoderx.com/witnesses).
+
+### Información del contrato
+
+Puede comprobar si su contrato se ha implementado correctamente en la red VSC consultando [/contracts](https://vsc.techcoderx.com/contracts).
diff --git a/src/content/docs/es/FAQ.md b/src/content/docs/es/FAQ.md
new file mode 100644
index 0000000..89cbc1d
--- /dev/null
+++ b/src/content/docs/es/FAQ.md
@@ -0,0 +1,26 @@
+---
+title: Preguntas frecuentes
+sidebar:
+ order: 16
+---
+
+## ¿Tiene VSC un *token*?
+
+No, VSC utiliza los *tokens* nativos de Hive para todas las transacciones en la red. Planeamos lanzar un *token* una vez que el proyecto sea autosostenible mediante un lanzamiento justo.
+
+## ¿Cuándo podré desplegar mi *token* en VSC?
+
+No tenemos un cronograma específico para esto. Una vez que se lancen los primeros pools de HBD en el tercer o cuarto trimestre de 2025, definiremos los estándares de *tokens* públicos y crearemos una implementación de referencia para cada uno de esos estándares.
+
+## ¿Cómo funcionan los contratos inteligentes en VSC?
+
+VSC utiliza WebAssembly (o WASM) para impulsar sus contratos inteligentes. WASM permite a los desarrolladores escribir contratos inteligentes en cualquier lenguaje compatible con WASM. Los desarrolladores aprovechan miles de librerías y herramientas ya existentes.
+
+## ¿Cuándo es el lanzamiento de la *mainnet*?
+
+La *Mainnet* se lanzó el 31 de marzo de 2025.
+
+## ¿Qué significa VSC?
+Virtual Smart Chain
+
+**Nota:** VSC (Virtual Smart Chain) cambió de nombre a **Magi Network**. Puedes encontrar más información [aquí](https://peakd.com/vsc/@vsc.network/vsc-is-now-magi-network-rebrand-announcement).
diff --git a/src/content/docs/es/How To/Deploy a validator.md b/src/content/docs/es/How To/Deploy a validator.md
new file mode 100644
index 0000000..6bd3878
--- /dev/null
+++ b/src/content/docs/es/How To/Deploy a validator.md
@@ -0,0 +1,41 @@
+---
+title: Cómo desplegar un nodo validador de VSC
+sidebar:
+ order: 9
+---
+
+Este repositorio aloja el archivo Docker Compose necesario para desplegar el nodo VSC.
+
+## Requisitos previos
+
+Requisitos:
+- Cuenta de Hive (mínimo de 100 HP para los creditos de recursos - RC).
+- 2000 Hive vinculado a tu nodo VSC (necesario para participar en el consenso).
+- Conocimiento técnico en el uso de una interfaz de línea de comandos (CLI).
+- Docker y docker-compose instalados. Consulta [https://docs.docker.com/get-docker/](https://docs.docker.com/get-docker/) para ver la guía de instalación de Docker.
+
+Los requisitos del sistema son muy bajos; en el futuro, los requisitos aumentarán a medida que se incremente el uso de la red.
+
+Requisitos del sistema:
+- Raspberry pi 4 o superior.
+- 4 núcleos, 8 GB de RAM o superior.
+
+## Configuración
+
+1. Instalar [Docker](https://docs.docker.com/get-docker/) y [Docker compose v2](https://docs.docker.com/compose/install/).
+2. `git clone https://github.com/vsc-eco/vsc-deployment` Clona este repositorio como un usuario normal (no como root/administrador) en la ubicación deseada. Es crucial asegurarse de que el usuario de Docker tenga permisos de escritura en el directorio donde planeas iniciar el archivo Docker Compose.
+3. `docker compose run init` Inicializar los archivos de configuración
+4. Edita el archivo de configuración ubicado en `./data/config/identityConfig.json` y asegúrate de agregar tu nombre de usuario de Hive y tu clave activa *(active key)*.
+4. `docker compose up -d` Inicia los contenedores de Docker. Esto añadirá un servidor GraphQL en el puerto 8080, una instancia de MongoDB en el puerto 27021 y una conexión libp2p en el puerto 10720.
+
+## Puesta en marcha
+
+Para lanzar el nodo, ejecuta `docker compose up -d` desde la línea de comandos (o `docker-compose up -d`, dependiendo de tu versión de Docker Compose).
+
+Para la observación de registros en tiempo real, usa `docker logs go-vsc-node -f`.
+
+## Mantenimiento
+
+El nodo está diseñado para auto-actualizarse según sea necesario. Sin embargo, en raras ocasiones, la configuración de despliegue puede requerir actualizaciones manuales no cubiertas por las actualizaciones automáticas. Si tal situación surge, informaremos a la comunidad a través de nuestros canales de comunicación habituales: [discord](http://discord.gg/yvGXZsQTU6) y [twitter](https://x.com/magi_network).
+
+Puedes deshabilitar las actualizaciones automáticas configurando la variable de entorno `AUTO_UPDATE` como *false*. Sin embargo, recomendamos mantener esta función habilitada para garantizar que el nodo esté siempre actualizado. En nuestro ecosistema en rápida evolución, es crucial mantener el nodo actualizado para una salud óptima de la red.
diff --git a/src/content/docs/es/How To/How to use vsc api outline.md b/src/content/docs/es/How To/How to use vsc api outline.md
new file mode 100644
index 0000000..04115db
--- /dev/null
+++ b/src/content/docs/es/How To/How to use vsc api outline.md
@@ -0,0 +1,24 @@
+---
+title: Cómo usar la API de VSC (Resumen)
+sidebar:
+ order: 20
+---
+
+
+1. **Resumen general**
+ - ¿Qué es la API y dónde se puede acceder a ella?
+
+2. **Primera consulta**
+ - Ejemplo básico de consulta GraphQL.
+
+3. **Filtración de datos**
+ - Cómo utilizar filtros en consultas.
+
+4. **Respuestas y errores**
+ - Comprensión de los resultados y errores comunes.
+
+5. **Consultas avanzadas**
+ - Variables, paginación, consultas múltiples.
+
+6. **Integración**
+ - Cómo llamar a la API desde tu aplicación.
diff --git a/src/content/docs/es/How To/create a token.mdx b/src/content/docs/es/How To/create a token.mdx
new file mode 100644
index 0000000..66f2fc9
--- /dev/null
+++ b/src/content/docs/es/How To/create a token.mdx
@@ -0,0 +1,84 @@
+---
+title: Crear un Token
+sidebar:
+ order: 12
+---
+
+import { Aside } from '@astrojs/starlight/components'
+
+Este tutorial describe el proceso de creación de un *token* fungible básico en VSC.
+
+
+
+## Configuración
+
+Clona la plantilla del contrato Go:
+
+```sh
+git clone https://github.com/vsc-eco/go-contract-template your-token
+cd your-token
+```
+
+## Escribe tu contrato de *token*
+
+
+
+Se ha incluido un contrato de *token* de ejemplo en el archivo [`examples/token/main.go`](https://github.com/vsc-eco/go-contract-template/blob/main/examples/token/main.go). Puedes copiar este archivo a `contract/main.go` para usarlo como punto de partida.
+
+```sh
+cp examples/token/main.go contract
+```
+El contrato de *token* cuenta con funciones de acuñación/quema *(mint/burn)* con límite de suministro *(supply cap)*, transferencia y cambio de propiedad. Actualiza las siguientes constantes al inicio del archivo con los valores deseados:
+
+```go title="main.go"
+const MaxSupply = 1000000
+const Precision = 3
+const Symbol = "TOKEN"
+const Creator = "hive:vaultec.vsc"
+```
+
+
+
+## Desplegar *token*
+
+Compila tu contrato de *token*:
+
+```sh
+tinygo build -gc=custom -scheduler=none -panic=trap -no-debug -target=wasm-unknown -o build/main.wasm contract/main.go
+wasm-tools strip -o build/main-striped.wasm build/main.wasm
+```
+
+A continuación, despliegue el contrato:
+
+```sh
+# If not done already, init config and fill in deployer active key
+vsc-contract-deploy -init
+
+# Deploy token
+vsc-contract-deploy -wasmPath build/main-striped.wasm -name "your token name"
+```
+
+## Inicializar *token*
+
+Llama a la función `init` desde la dirección propietaria de tu contrato de *token*, según lo especificado en la constante `Creator`. El cuerpo de la llamada *(payload)* a contrato no es relevante aquí.
+
+## Acuñar *tokens*
+
+Llama a la función `mint`, donde el cuerpo de la llamada *(payload)* es la cantidad a acuñar. Los tokens acuñados serán enviados a tu dirección.
+
+## Quemar *tokens*
+
+Llama a la función `burn`, donde el cuerpo de la llamada *(payload)* es la cantidad a quemar. Los *tokens* serán quemados de la dirección que realiza la llamada.
+
+## Transferir *tokens*
+
+Llama a la función `transfer`, donde el cuerpo de la llamada *(payload)* es una cadena separada por comas de la dirección de destino y la cantidad.
+
+Por ejemplo, para transferir 10 monedas a `did:pkh:eip155:1:0xtoaddresshere`, el cuerpo de la llamada *(payload)* debe ser `did:pkh:eip155:1:0xtoaddresshere,10`.
diff --git a/src/content/docs/es/How To/generate-wallet.md b/src/content/docs/es/How To/generate-wallet.md
new file mode 100644
index 0000000..4018133
--- /dev/null
+++ b/src/content/docs/es/How To/generate-wallet.md
@@ -0,0 +1,17 @@
+---
+title: Generar billetera
+sidebar:
+ order: 10
+---
+
+VSC en su Capa 2 soporta billeteras compatibles con _ed25519_. Estas se denominan cuentas ligeras *(lite accounts)* en el contexto de VSC. Se pueden generar de varias maneras. A continuación, se presentan las opciones recomendadas actualmente.
+
+## Generador oficial de billeteras
+
+La forma oficial y recomendada de generar una cuenta ligera es a través del repositorio del generador de billeteras.
+
+Está basado en NodeJS y es bastante ligero.
+
+Clona el repositorio, instala los módulos de Node y ejecuta el generador.
+
+Echa un vistazo al [repositorio aquí](https://github.com/vsc-eco/wallet-generator).
diff --git a/src/content/docs/es/How To/index.md b/src/content/docs/es/How To/index.md
new file mode 100644
index 0000000..5181c54
--- /dev/null
+++ b/src/content/docs/es/How To/index.md
@@ -0,0 +1,12 @@
+---
+title: Resumen
+sidebar:
+ label: Resumen
+ order: 8
+---
+
+¡Bienvenido a la sección **"Cómo hacer"**! Aquí encontrarás guías breves y prácticas para ayudarte a usar VSC y a construir con él de forma efectiva.
+
+Ya sea que estés ejecutando un validador VSC, desplegando contratos inteligentes en VSC, o integrándote con nuestro protocolo, estas guías están diseñadas para que empieces a trabajar rápidamente.
+
+Explora las guías a continuación y empieza a construir con confianza.
diff --git a/src/content/docs/es/How To/smart contract development.mdx b/src/content/docs/es/How To/smart contract development.mdx
new file mode 100644
index 0000000..af079ff
--- /dev/null
+++ b/src/content/docs/es/How To/smart contract development.mdx
@@ -0,0 +1,288 @@
+---
+title: Escribir, probar e desplegar un contrato inteligente
+sidebar:
+ order: 11
+---
+
+import { Aside, FileTree, Tabs, TabItem } from '@astrojs/starlight/components'
+
+Esta es una breve visión general del desarrollo de contratos inteligentes de VSC con Go.
+
+## Configuración del entorno
+
+### Requisitos previos
+- [Golang](https://go.dev/dl)
+- [Git](https://git-scm.com/downloads)
+- [TinyGo](https://tinygo.org/getting-started/install)
+- [Wasm Edge](https://wasmedge.org/docs/start/install)
+- [Wabt](https://github.com/WebAssembly/wabt) o [Wasm Tools](https://github.com/bytecodealliance/wasm-tools)
+
+### Instalar dependencias
+
+
+
+```sh
+git clone https://github.com/vsc-eco/go-vsc-node
+cd go-vsc-node
+go mod download
+go build -buildvcs=false -o vsc-contract-deploy vsc-node/cmd/contract-deployer
+```
+Esto generará un ejecutable llamado `vsc-contract-deploy`. Puedes moverlo a tu directorio `PATH` (es decir, `/usr/bin` para Linux o `/usr/local/bin` para macOS).
+
+---
+
+## Escribiendo tu primer contrato
+
+### Configuración
+
+Clona la plantilla del contrato Go:
+
+```sh
+git clone https://github.com/vsc-eco/go-contract-template
+```
+
+### Estructura del proyecto
+
+
+- contract Aquí va tu código de contrato.
+ - main.go
+- runtime
+ - gc_leaking_exported.go
+- sdk
+ - address.go
+ - env.go
+ - sdk.go
+- test
+ - contract_test.go
+- .gitignore
+- go.mod
+- go.sum
+
+
+### Contrato "Hola Mundo" *(Hello World)*
+
+El siguiente contrato demuestra cómo llamar a los métodos del SDK para interactuar con la base de datos del contrato y definir exportaciones WASM para marcar una función como invocable *(callable)* por cuentas de VSC u otros contratos.
+
+Obtén más información sobre los métodos del SDK de contratos de Go [aquí](/es/references/sdk).
+
+```go title="main.go"
+package main
+
+import "contract-template/sdk"
+
+//go:wasmexport hello_world
+func HelloWorld(a *string) *string {
+ ret := "Hello world"
+ return &ret
+}
+
+//go:wasmexport setString
+func SetString(a *string) *string {
+ sdk.StateSetObject("myString", *a)
+ return a
+}
+
+//go:wasmexport getString
+func GetString(a *string) *string {
+ return sdk.StateGetObject("myString")
+}
+```
+
+---
+
+## Compilar contrato
+
+Para compilar tu contrato:
+
+```sh
+tinygo build -gc=custom -scheduler=none -panic=trap -no-debug -target=wasm-unknown -o artifacts/main.wasm contract/main.go
+```
+
+
+
+Para eliminar los metadatos del binario WASM de salida y reducir el tamaño del archivo:
+
+
+
+ ```sh
+ wasm-strip -o artifacts/main-striped.wasm artifacts/main.wasm
+ ```
+
+
+ ```sh
+ wasm-tools strip -o artifacts/main-striped.wasm artifacts/main.wasm
+ ```
+
+
+
+Para inspeccionar el ensamblado WASM de salida:
+
+
+
+ ```sh
+ wasm2wat artifacts/main.wasm
+ ```
+
+
+ ```sh
+ wasm-tools print artifacts/main.wasm
+ ```
+
+
+
+---
+
+## Probar y depurar contrato
+
+Proporcionamos un entorno de prueba de contratos para que ejecutes llamadas a contratos en un motor de estado que se asemeja a la red en vivo. Tu código de prueba de contratos se verá algo como esto:
+
+```go
+package contract_test
+
+import (
+ "encoding/json"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/vsc-eco/go-vsc-node/lib/test_utils"
+ "github.com/vsc-eco/go-vsc-node/modules/db/vsc/contracts"
+ ledgerDb "github.com/vsc-eco/go-vsc-node/modules/db/vsc/ledger"
+ stateEngine "github.com/vsc-eco/go-vsc-node/modules/state-processing"
+)
+
+//go:embed artifacts/main.wasm
+var ContractWasm []byte
+
+func TestContract(t *testing.T) {
+ ct := test_utils.NewContractTest()
+ ct.RegisterContract("vsccontractid", ContractWasm)
+ ct.Deposit("hive:someone", 1000, ledgerDb.AssetHive) // depósito de 1 HIVE
+ ct.Deposit("hive:someone", 1000, ledgerDb.AssetHbd) // ddepósito de 1 HBD
+
+ result, gasUsed, logs := ct.Call(stateEngine.TxVscCallContract{
+ Self: stateEngine.TxSelf{
+ TxId: "sometxid",
+ BlockId: "abcdef",
+ Index: 69,
+ OpIndex: 0,
+ Timestamp: "2025-09-03T00:00:00",
+ RequiredAuths: []string{"hive:someone"},
+ RequiredPostingAuths: []string{},
+ },
+ ContractId: contractId,
+ Action: "yourMethodName",
+ Payload: json.RawMessage([]byte("1000")),
+ RcLimit: 1000,
+ Intents: []contracts.Intent{{
+ Type: "transfer.allow",
+ Args: map[string]string{
+ "limit": "1.000",
+ "token": "hive",
+ },
+ }},
+ })
+ assert.True(t, result.Success) // asegura que la ejecución del contrato fue exitosa
+ assert.LessOrEqual(t, gasUsed, uint(10000000)) // asegura que esta llamada no utiliza más de 10M de gas WASM
+ assert.GreaterOrEqual(t, len(logs), 1) // asegura que se emitió al menos 1 registro.
+}
+```
+Obtén más información sobre los métodos proporcionados por las utilidades de prueba de contratos [aquí](/es/references/sdk/#herramientas-de-prueba-de-contratos).
+
+---
+
+## Desplegar contrato
+
+
+
+En primer lugar, inicializa la configuración del desplegador *(deployer)*:
+
+```sh
+vsc-contract-deploy -init
+```
+
+Esto generará algunos archivos de configuración en la carpeta `data/config` de tu directorio actual. Inserta tu nombre de usuario de Hive y la clave activa de la cuenta del desplegador en `identityConfig.json`:
+
+```json title="identityConfig.json"
+{
+ "BlsPrivKeySeed": "9e264692ced37...",
+ "HiveActiveKey": "ADD_YOUR_PRIVATE_WIF",
+ "HiveUsername": "ADD_YOUR_USERNAME",
+ "Libp2pPrivKey": "125cd98aed75d..."
+}
+```
+
+Luego, despliega tu contrato en VSC:
+
+```sh
+vsc-contract-deploy -wasmPath artifacts/main-striped.wasm -name "my first contract"
+```
+
+Debería ver un resultado similar a este:
+
+```
+WASM_CODE: 1130 [0 97 115 109 1 0 0 0 1 9] ...
+peer ID: 12D3KooWS7N7zmrkMHxGX9ibNXbKk4byfkx8ckEhfgXM8eQcgBtK
+NAT Status {Private}
+12D3KooWS7N7zmrkMHxGX9ibNXbKk4byfkx8ckEhfgXM8eQcgBtK pubsub /vsc/mainnet/data-availability/v1 peers: 20
+pubsub handling error: message did not add any signatures
+pubsub handling error: message did not add any signatures
+pubsub handling error: message did not add any signatures
+pubsub handling error: message did not add any signatures
+pubsub handling error: message did not add any signatures
+pubsub handling error: message did not add any signatures
+pubsub handling error: message did not add any signatures
+pubsub handling error: message did not add any signatures
+{bafkreibwwj3fypek5uz6l3scacy47yw3b2adgbxmfab2ybmkarljaggbey {i_TLUMJVJb6n6X-5_lKvBibiLvP0RUVz2tn20KJTw5Q_lQ-tcVt9jrZr4s1WVga1CR7q0Ldnrc-EjNpqgaY7GpnhE2d3pC3nfNhUKkmN1za6h9SwCEUuo3CByNnmnqYE __f9}}
+{"__v":"0.1","code":"bafkreibwwj3fypek5uz6l3scacy47yw3b2adgbxmfab2ybmkarljaggbey","description":"","name":"go test","net_id":"vsc-mainnet","owner":"techcoderx.vsc","runtime":"go","storage_proof":{"hash":"bafkreibwwj3fypek5uz6l3scacy47yw3b2adgbxmfab2ybmkarljaggbey","signature":{"sig":"i_TLUMJVJb6n6X-5_lKvBibiLvP0RUVz2tn20KJTw5Q_lQ-tcVt9jrZr4s1WVga1CR7q0Ldnrc-EjNpqgaY7GpnhE2d3pC3nfNhUKkmN1za6h9SwCEUuo3CByNnmnqYE","bv":"__f9"}}}
+pubsub handling error: message did not add any signatures
+pubsub handling error: message did not add any signatures
+tx id: bef70add6d21cd812cf68da2caee72da05de48b4
+contract id: vsc1Bem8RnoLgGPP7E2MBN52ekrdVqy2LNpSqF
+Error in subscription: subscription cancelled
+```
+
+---
+
+## Llamar a contrato
+
+Los contratos pueden ser llamados desde capa 1 (L1) utilizando cuentas de Hive o en VSC utilizando cuentas fuera de cadena *(off-chain)*.
+
+### Llamar desde capa 1 (L1)
+
+La invocación de contratos desde L1 implica el envío de una `custom_json_operation` con `vsc.call` como su ID y el siguiente formato JSON:
+
+```json
+{
+ "net_id": "vsc-mainnet",
+ "contract_id": "vsc1...",
+ "action": "methodName",
+ "payload": "your payload string here",
+ "rc_limit": 2000,
+ "intents": []
+}
+```
+[Aquí](https://hivehub.dev/tx/8e384c116bdc6c585340a36ba29bdd67652358c2) puede verse un ejemplo de transacción.
+
+### Intents
+
+Una transacción de llamada a contrato puede incluir una lista de `intents` que autorizan al contrato a gastar hasta una cantidad específica de activos de tu cuenta. Por ejemplo, una intent de permiso de 1 HIVE puede especificarse de la siguiente manera:
+
+```json
+{
+ "type": "transfer.allow",
+ "args": {
+ "limit": "1.000",
+ "token": "hive"
+ }
+}
+```
diff --git a/src/content/docs/es/References/account-types.md b/src/content/docs/es/References/account-types.md
new file mode 100644
index 0000000..ddf59b0
--- /dev/null
+++ b/src/content/docs/es/References/account-types.md
@@ -0,0 +1,23 @@
+---
+title: Tipos de cuenta
+sidebar:
+ order: 10
+---
+
+La red VSC admite varios tipos de cuenta para la autenticación.
+
+## DID | Clave pública/privada
+
+Puedes autenticarte con un par de clave pública/privada compatible con _ed25519_. Para un tutorial sobre cómo generar dichas claves, consulta [este documento](../../how-to/generate-wallet/).
+
+## Hive
+
+Puedes usar directamente tu cuenta de [HIVE](https://hive.io/) para comunicarte con la red VSC.
+
+Para registrar una cuenta HIVE, necesitas que alguien con una cuenta existente te invite a la red. Esto también se ofrece como un servicio por varios proveedores. Para obtener más información, consulta la [página de registro de HIVE](https://signup.hive.io/).
+
+## Ethereum (ETH)
+
+Sí, admitimos bileteras basados en Ethereum.
+
+Crea tu billetera de Ethereum a través de un [proveedor conocido](https://ethereum.org/en/wallets/) que te dé acceso a tus claves. Solo admitimos billeteras de autocustodia.
diff --git a/src/content/docs/es/References/api.md b/src/content/docs/es/References/api.md
new file mode 100644
index 0000000..b4f515d
--- /dev/null
+++ b/src/content/docs/es/References/api.md
@@ -0,0 +1,145 @@
+---
+title: API
+sidebar:
+ order: 11
+---
+
+
+#### *NOTA: ESTA SECCIÓN NO HA SIDO ACTUALIZADA PARA LA RED PRINCIPAL (MAINNET) VSC (PROCEDER CON PRECAUCIÓN)*
+
+# Documentación de la API
+
+La API de VSC se puede usar para recuperar diversos tipos de información sobre la red VSC. Es el bloque de construcción central a la hora de crear aplicaciones sobre VSC.
+
+Basada en GraphQL, proporciona opciones flexibles para recuperar datos. Te permite definir la estructura de datos que deseas recibir. Puedes leer más sobre GraphQL [aquí](https://graphql.org/learn/). Está activada por defecto en todos los nodos VSC bajo la ruta `NODE_IP:1337/api/v1/graphql`.
+
+Esta URL se utiliza para consultas en el código, pero también se puede acceder a ella en el navegador (explorador GraphiQL).
+
+Tenemos una API pública, accesible para todos en [https://api.vsc.eco/api/v1/graphql](https://api.vsc.eco/api/v1/graphql).
+
+Este documento se centra en las funcionalidades que ofrece la API. Ten en cuenta que el estado de la API cambia frecuentemente en estas etapas tempranas de desarrollo, por lo que este documento podría no estar actualizado. Si una consulta no funciona o crees que falta una característica por completo, ¡no dudes en contactar al equipo de desarrollo de VSC en [Discord](http://discord.gg/yvGXZsQTU6)!
+
+## Opciones de filtro
+
+Diversas consultas admiten filtros para ayudarte a acotar tu búsqueda. A continuación, se enumeran los ejemplos de datos de entrada para dichos filtros.
+
+## Contract state
+
+Permite recuperar los datos (IPFS) almacenados por una ejecución de contrato. Te da la capacidad de recuperar datos de ejecuciones de contrato específicas y, por lo tanto, también tienes la posibilidad de inspeccionar ejecuciones pasadas, las cuales ya no representan el estado actual del contrato.
+
+Como dato de entrada, toma la ID del `contract output` (un tipo de transacción VSC). Puedes encontrar las ID, por ejemplo, [en el explorador de bloques](https://vsc.techcoderx.com/block-by-hash/bafyreigzaqrifacmjw4ecwt2jolu46ommphf3wcow22tjg7fodem7gheoa) (la transacción única).
+
+Ejemplo de consulta:
+```txt
+{
+ contractState(id:"bafyreiazuqoxbhmkeygxf5tiifbvy6czjjyk4vot7nproi646gxp6rgcny"){
+ id
+ stateKeys
+ }
+}
+```
+
+## Contract output
+
+Este *endpoint* te ayuda a encontrar los datos de transacción del `contract output` que necesitas para consultar el estado de la ejecución de tu contrato. Por lo tanto, normalmente estas dos consultas se ejecutan secuencialmente.
+
+Generalmente, este *endpoint* se consulta utilizando las opciones de filtro disponibles. Sin ellas, solo devuelve las últimas salidas de contrato, lo cual no es una consulta fiable para obtener los resultados de contrato que te interesan.
+
+Filtros admitidos
+
+**byInput** -> [ID de la llamada al contrato](https://vsc.techcoderx.com/block-by-hash/bafyreic3mmkxy4fw2b23qu73lnbpcnqfn5tcgu623gnj6jyvsfw6xl6yom),
+por ejemplo: `bafyreidwbhe7qrxt2ocpdruikfu3fjktoihgra3ybec3ecni6yd2jlh73e`
+
+**byOutput** -> [ID de la salida del contrato](https://vsc.techcoderx.com/block-by-hash/bafyreigzaqrifacmjw4ecwt2jolu46ommphf3wcow22tjg7fodem7gheoa),
+por ejemplo: `bafyreiazuqoxbhmkeygxf5tiifbvy6czjjyk4vot7nproi646gxp6rgcny`
+
+**byContract** -> Dirección del contrato,
+por ejemplo: `vs41q9c3yg9af6z8ptpc29pujuc9lj99qkwha2vdmwx7ketnyxtlpgv0d97pguchqe9s`
+
+> Dato útil: Este es el método más conveniente para obtener la ID del resultado del contrato que representa el estado actual del contrato. Recupera las salidas del contrato por la ID del contrato, ordena por antigüedad, especifica que devuelva solo la ID y limita la consulta a una sola entrada. El resultado debería ser la ID de la salida del contrato que representa el estado actual.
+
+Ejemplo de consulta:
+
+```txt
+{
+ findContractOutput(filterOptions: {byContract: "vs41q9c3yg9af6z8ptpc29pujuc9lj99qkwha2vdmwx7ketnyxtlpgv0d97pguchqe9s", limit: 1}) {
+ outputs {
+ id
+ }
+ }
+}
+```
+
+## Find transaction
+Esta consulta se puede usar para encontrar datos generales de transacciones. Esta consulta, a diferencia de la consulta `contract output`, no se limita a encontrar solo salidas de contrato, sino todo tipo de transacciones (incluidas las no confirmadas).
+
+
+Filtros admitidos
+
+**byId** -> ID de la transacción,
+por ejemplo: `bafyreidwbhe7qrxt2ocpdruikfu3fjktoihgra3ybec3ecni6yd2jlh73e`
+
+**byStatus** -> Estado de confirmación de la transacción,
+por ejemplo: `CONFIRMED`, `UNCONFIRMED`
+
+**byContract** -> Dirección del contrato,
+por ejemplo: `vs41q9c3yg9af6z8ptpc29pujuc9lj99qkwha2vdmwx7ketnyxtlpgv0d97pguchqe9s`
+
+**byAccount** -> Cuenta,
+por ejemplo: `did:key:z6Mkfn53NL5m9ncAprAUQpAhceUECRTfiZ7VV3xEcpKERJC4`
+
+**byOpCategory** -> Categoría de la operación de transacción,
+por ejemplo: `call_contract`
+
+**byAction** -> Punto de entrada invocado en el contrato,
+por ejemplo: `processXYZ`, `mint`, `testJSON`
+
+Ejemplo de consulta:
+
+```txt
+{
+ findTransaction(filterOptions: {byContract: "vs41q9c3yg9af6z8ptpc29pujuc9lj99qkwha2vdmwx7ketnyxtlpgv0d97pguchqe9s", limit: 1}) {
+ txs {
+ id
+ first_seen
+ anchored_height
+ }
+ }
+}
+```
+
+## Local node info
+
+Esta consulta se puede usar para determinar la identidad de un nodo.
+
+```txt
+{
+ localNodeInfo {
+ peer_id
+ }
+}
+```
+
+## Get Account balance
+
+Este *endpoint* proporciona los balances de la cuenta que están vinculados a la dirección suministrada.
+
+```txt
+{
+ getAccountBalance(account: "hive:vaultec") {
+ account
+ tokens {
+ HBD
+ HIVE
+ }
+ }
+}
+```
+
+## Submit Transaction V1
+
+Este *endpoint* se utiliza para enviar transacciones al nodo VSC. Si deseas ingresar transacciones a través de este *endpoint*, utiliza el [cliente VSC](https://github.com/vsc-eco/client) u obtén inspiración de su base de código.
+
+## Otros *endpoints*
+
+Los otros *endpoints* disponibles están dirigidos principalmente a la operación del nodo y a usuarios avanzados de la red VSC. No se utilizan comúnmente en la operación normal. Si tienes preguntas sobre estos *endpoints*, consulta a los desarrolladores de VSC.
diff --git a/src/content/docs/es/References/client.md b/src/content/docs/es/References/client.md
new file mode 100644
index 0000000..33e7a19
--- /dev/null
+++ b/src/content/docs/es/References/client.md
@@ -0,0 +1,67 @@
+---
+title: Cliente VSC
+sidebar:
+ order: 12
+---
+
+
+#### *NOTA: ESTA SECCIÓN NO HA SIDO ACTUALIZADA PARA LA RED PRINCIPAL (MAINNET) VSC (PROCEDER CON PRECAUCIÓN)*
+
+# Cliente VSC
+
+Los clientes VSC son librerías que ofrecen un conjunto de envoltorios *(wrappers)* y capas de abstracción para comunicarse más fácilmente con la red VSC.
+
+## Cliente VSC de Javascript
+
+La documentación de la API se puede encontrar [aquí](https://vsc-eco.github.io/client/).
+
+### Instalación
+
+El [cliente javascript VSC](https://github.com/vsc-eco/client) se puede instalar a través de [_npm_](https://www.npmjs.com/package/@vsc.eco/client).
+
+`npm i @vsc.eco/client`
+
+### Inicios de sesión en la cuenta
+
+Puedes elegir entre varios métodos de inicio de sesión para autenticarte en la red VSC. A continuación se enumeran las opciones actualmente disponibles para este cliente.
+
+Para obtener más información, como crear una cuenta para un tipo de cuenta específico, visita [este documento](../../references/account-types/).
+
+#### DID | Clave pública/privada
+
+Puedes usar tu billetera compatible con _ed25519_ generado con el cliente VSC de la siguiente manera:
+
+1. Convierte la clave privada a bytes hexadecimales.
+2. Registra un nuevo _Ed25519Provider_ con _converted secret_.
+3. Genera un DID y autentícalo.
+4. Inicia sesión en el cliente VSC.
+
+```js reference
+https://github.com/vsc-eco/client/blob/main/src/tests/testBench.ts#L11-L20
+```
+
+En el ejemplo anterior la clave privada que se utiliza es **44ab29dc82f227322cb924cdc66815da8edc9cb0b409f5ced26ced57e6077aa6**.
+
+#### Ethereum (ETH)
+
+Puedes usar tu billetera de Ethereum con el cliente VSC siguiendo los pasos a continuación:
+
+1. Aplica el hash sha256 a tu clave privada y conviértela a hexadecimal.
+2. Haz referencia a la cuenta en el proveedor Web3.
+3. Usa el proveedor para autenticar tu cliente VSC.
+
+```js reference
+https://github.com/vsc-eco/client/blob/main/src/tests/ethTest.ts#L15-L46
+```
+
+En el ejemplo anterior, la clave privada que se utiliza es **44ab29dc82f227322cb924cdc66815da8edc9cb0b409f5ced26ced57e6077aa6**.
+
+### Funcionalidades
+
+#### Invocar contratos
+
+Puedes invocar contratos a través del cliente VSC. Tenemos una [guía separada](../../tutorials/invoke-contract/) sobre cómo hacerlo.
+
+#### Llamadas a la API
+
+Aún no hemos implementado abstracciones API en el cliente VSC.
diff --git a/src/content/docs/es/References/index.md b/src/content/docs/es/References/index.md
new file mode 100644
index 0000000..5688f7f
--- /dev/null
+++ b/src/content/docs/es/References/index.md
@@ -0,0 +1,7 @@
+---
+title: Referencias
+sidebar:
+ order: 9
+---
+
+Esta sección contiene material de referencia técnica para VSC, incluidos los protocolos específicos, las reglas colaterales, la mecánica de *staking* y las constantes del sistema. Úsala cuando necesites detalles exactos sobre cómo funcionan las cosas "bajo el capó" (internamente).
diff --git a/src/content/docs/es/References/sdk.mdx b/src/content/docs/es/References/sdk.mdx
new file mode 100644
index 0000000..769af2d
--- /dev/null
+++ b/src/content/docs/es/References/sdk.mdx
@@ -0,0 +1,431 @@
+---
+title: SDK
+sidebar:
+ order: 13
+---
+
+import { Aside } from '@astrojs/starlight/components'
+
+El SDK de VSC es una librería que abstrae diversas funcionalidades que son útiles en el contexto de escribir un contrato inteligente VSC.
+
+
+
+## SDK de contrato en Go
+
+El [SDK de contrato en Go](https://github.com/vsc-eco/go-contract-template) implementa *runtime* y las funciones de SDK necesarias para el entorno de contratos inteligentes VSC.
+
+### Ejemplo de uso
+
+```go
+package main
+
+import (
+ "contract-template/sdk"
+)
+
+//go:wasmexport entrypoint
+func Entrypoint(a *string) *string {
+ sdk.Log(*a)
+ sdk.Log("Entrypoint logged")
+ return a
+}
+```
+
+### Métodos SDK
+
+Los siguientes métodos están dentro del *namespace* `sdk`. Todos los parámetros y tipos de retorno son de tipo `*string`.
+
+#### Log
+
+Registra un *string* con fines de depuración *(debugging)*. Los registros emitidos también se adjuntarán al *contract output*, lo cual puede ser útil para aplicaciones externas (es decir, indexadores).
+
+```go
+//go:wasmexport entrypoint
+func Entrypoint(a *string) *string {
+ // ...
+ sdk.Log(*a)
+ sdk.Log("hello world")
+ // ...
+}
+```
+
+#### SetObject
+
+Establece el valor de una clave en la base de datos del contrato.
+
+```go
+//go:wasmexport setString
+func SetString(a *string) *string {
+ // ...
+ sdk.StateSetObject("myString", *a)
+ // ...
+}
+```
+
+#### GetObject
+
+Recupera el valor de una clave de la base de datos del contrato.
+
+```go
+//go:wasmexport getString
+func GetString(a *string) *string {
+ // ...
+ value := sdk.StateGetObject("myString")
+ // ...
+}
+```
+
+#### DelObject
+
+Elimina el valor de una clave en la base de datos del contrato.
+
+```go
+//go:wasmexport clearString
+func ClearString(a *string) *string {
+ // ...
+ sdk.StateDeleteObject("myString")
+ // ...
+}
+```
+
+#### GetEnv
+
+Recupera las variables de entorno del tiempo de ejecución actual, devolviendo un objeto con la [estructura `Env`](https://github.com/vsc-eco/go-contract-template/blob/main/sdk/env.go).
+
+```go
+//go:wasmexport dumpEnv
+func DumpEnv(a *string) *string {
+ // ...
+ envs := sdk.GetEnv()
+ // ...
+}
+```
+
+#### GetEnvKey
+
+Recupera una variable de entorno por clave. La lista de nombres de variables se enumera a [continuación](#variables-de-entorno).
+
+```go
+//go:wasmexport dumpEnvKey
+func DumpEnvKey(a *string) *string {
+ // ...
+ contract_id := sdk.GetEnvKey("contract.id")
+ // ...
+}
+```
+
+#### GetBalance
+
+Recupera el balance de cualquier cuenta o contrato de VSC.
+
+```go
+//go:wasmexport getBalance
+func GetBalance(a *string) *string {
+ // ...
+ bal := sdk.GetBalance("hive:vaultec.vsc", sdk.AssetHive) // Resultado en términos de mHIVE/mHBD
+ // ...
+}
+```
+
+#### Draw
+
+Transfiere activos de la cuenta del emisor al contrato hasta el límite especificado en las `intents`. La transacción debe estar firmada utilizando la autoridad activa para las cuentas Hive.
+
+```go
+//go:wasmexport drawBalance
+func DrawBalance(a *string) *string {
+ // ...
+ sdk.HiveDraw(1000, sdk.AssetHive) // Extrae 1 HIVE de la cuenta del emisor.
+ // ...
+}
+```
+
+#### Transfer
+
+Transfiere activos del contrato a otra cuenta.
+
+```go
+//go:wasmexport transferBalance
+func TransferBalance(a *string) *string {
+ // ...
+ sdk.HiveTransfer("hive:vaultec.vsc", 1000, sdk.AssetHive) // Transfiere 1 HIVE desde el contrato
+ // ...
+}
+```
+
+#### Withdraw
+
+Desvincular activos del contrato a una cuenta Hive específica.
+
+```go
+//go:wasmexport unmapBalance
+func UnmapBalance(a *string) *string {
+ // ...
+ sdk.HiveWithdraw("hive:vaultec.vsc", 1000, sdk.AssetHive) // Retirar 1 HIVE del contrato
+ // ...
+}
+```
+
+#### Contract State Get
+
+Lee el valor de una clave del estado de otro contrato.
+
+```go
+//go:wasmexport contractGetString
+func ContractGetString(a *string) *string {
+ // ...
+ value := sdk.ContractStateGet("anotherContractId", "myString")
+ // ...
+}
+```
+
+#### Contract Call
+
+Llamar a otro contrato, devolviendo el valor resultante al emisor.
+
+
+
+```go
+//go:wasmexport contractCall
+func ContractCall(a *string) *string {
+ // ...
+ // Llamar a otro contrato con una asignación de 1 HIVE, permitiendo que el otro contrato retire hasta 1 HIVE de este contrato.
+ ret := sdk.ContractCall("anotherContractId", "methodName", "payload", &sdk.ContractCallOptions{
+ Intents: []sdk.Intent{{
+ Type: "transfer.allow",
+ Args: map[string]string{
+ "token": "hive",
+ "limit": "1.000",
+ },
+ }},
+ })
+
+ // Call another contract without options.
+ ret2 := sdk.ContractCall("anotherContractId", "methodName2", "payload", nil)
+ // ...
+}
+```
+
+#### Abort
+
+Aborta la ejecución del contrato y revierte la transacción.
+
+```go
+//go:wasmexport abortMe
+func AbortMe(a *string) *string {
+ // ...
+ sdk.Abort("something went wrong")
+ // ...
+}
+```
+
+#### Revert
+
+Aborta la ejecución del contrato y revierte la transacción de la misma manera que `sdk.Abort()`, pero con un símbolo de error.
+
+```go
+//go:wasmexport revertMe
+func RevertMe(a *string) *string {
+ // ...
+ sdk.Revert("something went wrong", "some_error_code")
+ // ...
+}
+```
+
+## Variables de entorno
+
+|Variable|Descripción|
+|-|-|
+|`contract.id`|ID del contrato actual|
+|`contract.owner`|Propietario del contrato actual|
+|`tx.id`|ID de la transacción|
+|`tx.index`|Posición de la transacción en el bloque|
+|`tx.op_index`|Posición de la operación en la transacción|
+|`block.id`|ID del bloque L1 en el que se incluye la transacción. Para las transacciones fuera de la cadena *(offchain)*, esto se refiere a la ID del bloque L1 del bloque VSC en el que se incluyó la transacción.|
+|`block.height`|Número de bloque L1 en el que se incluye la transacción. Para las transacciones fuera de la cadena *(offchain)*, esto se refiere al número de bloque L1 del bloque VSC en el que se incluyó la transacción.|
+|`block.timestamp`|Marca de tiempo de cuándo se incluyó la transacción (es decir, `2025-07-26T14:10:42`).|
+|`msg.sender`|Dirección del remitente de la transacción. Debe ser una dirección de usuario. Si hay múltiples, se devuelve la primera cuenta especificada en `required_auths` o en `required_posting_auths`.|
+|`msg.required_auths`|El campo `required_auths` de la transacción.|
+|`msg.required_posting_auths`|El campo `required_posting_auths` de la transacción.|
+|`msg.caller`|La dirección que está llamando al contrato. Puede ser una ID de contrato o una dirección de usuario.|
+|`intents`|Lista de *intents* pasadas a la transacción (es decir, asignación de *tokens*).|
+
+## Códigos de error
+
+|Código|Descripción|
+|-|-|
+|`runtime_error`|Error genérico del tiempo de ejecución WASM.|
+|`runtime_abort`|Ejecución de la transacción abortada en tiempo de ejecución.|
+|`ic_invalid_payload`|*Payload* de la llamada entre contratos no válida.|
+|`ic_contract_not_found`|El contrato llamado por otro contrato no existe.|
+|`ic_contract_get_error`|Ocurrió un error al obtener la información del contrato durante la llamada entre contratos.|
+|`ic_code_fetch_error`|Ocurrió un error al obtener el código del contrato durante la llamada entre contratos.|
+|`ic_cid_decode_error`|Ocurrió un error al decodificar el CID del código del contrato durante la llamada entre contratos.|
+|`ic_recursion_limit_hit`|Límite de profundidad de recursión de llamada entre contratos alcanzado.|
+|`gas_limit_hit`|Límite de gas WASM excedido debido a un límite insuficiente de RC.|
+|`sdk_error`|Error genérico de llamada al SDK.|
+|`missing_required_auth`|Falta la autoridad requerida.|
+|`env_var_error`|Error al serializar o analizar las variables de entorno.|
+|`ledger_error`|Error al ejecutar la transferencia de *tokens* (es decir, debido a balance insuficiente).|
+|`ledger_intent_error`|Faltan intenciones o se intenta retirar saldos por encima del límite especificado.|
+|`wasm_init_error`|Error al inicializar el contexto de ejecución WASM.|
+|`wasm_ret_error`|La llamada al contrato no devolvió exactamente un valor.|
+|`wasm_function_not_found`|Se intenta llamar a un método inexistente.|
+|`unknown_error`|Errores generados en tiempo de ejecución sin un código de error especificado.|
+
+## Herramientas de prueba de contratos
+
+Las herramientas de prueba de contratos proporcionan un entorno de pruebas que te permite ejecutar tus contratos.
+
+
+### Instanciación
+
+Crea un nuevo entorno de prueba de contratos.
+
+```go
+import (
+ "encoding/json"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/vsc-eco/go-vsc-node/lib/test_utils"
+ "github.com/vsc-eco/go-vsc-node/modules/db/vsc/contracts"
+ ledgerDb "github.com/vsc-eco/go-vsc-node/modules/db/vsc/ledger"
+ stateEngine "github.com/vsc-eco/go-vsc-node/modules/state-processing"
+)
+
+func TestContract(t *testing.T) {
+ ct := test_utils.NewContractTest()
+}
+```
+
+### Increment Blocks
+
+Incrementa un número especificado de bloques L1 en el entorno de pruebas de contratos. La altura del bloque comienza desde 0 durante la instanciación.
+
+```go
+func TestContract(t *testing.T) {
+ // ...
+ ct.IncrementBlocks(20)
+ // ...
+}
+```
+
+### Register Contract
+
+Vincula un código de bytes WASM a una ID de contrato con un propietario especificado.
+
+```go
+//go:embed artifacts/main.wasm
+var ContractWasm []byte
+
+func TestContract(t *testing.T) {
+ // ...
+ ct.RegisterContract("vsccontractid", "hive:someone", ContractWasm)
+ // ...
+}
+```
+
+### Call Contract
+
+Ejecuta una transacción de llamada al contrato. Devuelve el resultado de la llamada, el gas utilizado y los registros emitidos.
+
+```go
+func TestContract(t *testing.T) {
+ // ...
+ result, gasUsed, logs := ct.Call(stateEngine.TxVscCallContract{
+ Self: stateEngine.TxSelf{
+ TxId: "sometxid",
+ BlockId: "abcdef",
+ Index: 69,
+ OpIndex: 0,
+ Timestamp: "2025-09-03T00:00:00",
+ RequiredAuths: []string{"hive:someone"},
+ RequiredPostingAuths: []string{},
+ },
+ ContractId: contractId,
+ Action: "yourMethodName",
+ Payload: json.RawMessage([]byte("1000")),
+ RcLimit: 1000,
+ Intents: []contracts.Intent{{
+ Type: "transfer.allow",
+ Args: map[string]string{
+ "limit": "1.000",
+ "token": "hive",
+ },
+ }},
+ })
+ assert.True(t, result.Success)
+ assert.LessOrEqual(t, gasUsed, uint(10000000))
+ assert.GreaterOrEqual(t, len(logs), 1)
+ // ...
+}
+```
+
+### Deposit
+
+Añadir fondos a una cuenta en el ledger.
+
+```go
+func TestContract(t *testing.T) {
+ // ...
+ ct.Deposit("hive:someone", 1000, ledgerDb.AssetHive) // deposit 1 HIVE
+ ct.Deposit("hive:someone", 1000, ledgerDb.AssetHbd) // deposit 1 HBD
+ // ...
+}
+```
+
+### Get Balance
+
+Recupera el balance actual de una cuenta.
+
+```go
+func TestContract(t *testing.T) {
+ // ...
+ bal := ct.GetBalance("hive:someone", ledgerDb.AssetHive)
+ assert.Equal(t, int64(1000), bal)
+ // ...
+}
+```
+
+### State Set
+
+Establece el valor de una clave en el almacenamiento de estado del contrato.
+
+```go
+func TestContract(t *testing.T) {
+ // ...
+ ct.StateSet("vsccontractid", "someKey", "hi")
+ // ...
+}
+```
+
+### State Get
+
+Recupera el valor de una clave del almacenamiento de estado del contrato.
+
+```go
+func TestContract(t *testing.T) {
+ // ...
+ val := ct.StateGet("vsccontractid", "someKey")
+ assert.Equal(t, "hi", val)
+ // ...
+}
+```
+
+### State Delete
+
+Elimina el valor de una clave en el almacenamiento de estado del contrato.
+
+```go
+func TestContract(t *testing.T) {
+ // ...
+ ct.StateDelete("vsccontractid", "someKey")
+ assert.Equal(t, "", ct.StateGet("vsccontractid", "someKey"))
+ // ...
+}
+```
diff --git a/src/content/docs/es/Roles/arbitrageurs.md b/src/content/docs/es/Roles/arbitrageurs.md
new file mode 100644
index 0000000..99924a2
--- /dev/null
+++ b/src/content/docs/es/Roles/arbitrageurs.md
@@ -0,0 +1,18 @@
+---
+title: Arbitrajistas
+sidebar:
+ order: 10
+---
+
+*Capitalizan las diferencias de precio entre los fondos de liquidez y las cadenas para obtener ganancias.*
+
+Los arbitrajistas aprovechan las discrepancias de precios entre los fondos de liquidez y a través de las cadenas *(across chains)* dentro del ecosistema VSC. Al ejecutar rápidamente operaciones *(trades)* entre fondos o cadenas, obtienen ganancias de las diferencias en los precios de los activos. La infraestructura descentralizada entre cadenas *(cross-chain)* y la compatibilidad con activos nativos de VSC permiten a los arbitrajistas identificar y sacar provecho de las ineficiencias de precios sin depender de servicios de terceros.
+
+
+Los beneficios clave incluyen:
+
+- **Oportunidades entre cadenas:** Obtener ganancias de las diferencias de precio a través de múltiples cadenas conectadas a VSC.
+- **Comercio de activos nativos:** Comerciar con activos nativos reales (por ejemplo, BTC, ETH).
+- **Descentralizado y seguro:** Operar en un entorno sin la necesidad de una autoridad central o un tercero de confianza *(trustless)* y asegurado por validadores, garantizando la seguridad y transparencia de la operación.
+
+Los arbitrajistas ayudan a mantener el equilibrio de precios a lo largo del ecosistema VSC al actuar sobre las ineficiencias del mercado, impulsando la liquidez y la estabilidad.
diff --git a/src/content/docs/es/Roles/dapp-users.md b/src/content/docs/es/Roles/dapp-users.md
new file mode 100644
index 0000000..8b6a28b
--- /dev/null
+++ b/src/content/docs/es/Roles/dapp-users.md
@@ -0,0 +1,24 @@
+---
+title: Usuarios de dApps
+sidebar:
+ order: 8
+---
+
+*Interacción con aplicaciones descentralizadas.*
+
+Los usuarios de aplicaciones descentralizadas (dApps) son individuos que interactúan directamente con aplicaciones descentralizadas construidas en la red VSC. Estas aplicaciones abarcan desde herramientas de finanzas descentralizadas (DeFi) y servicios de pago hasta juegos, plataformas de NFT, herramientas de remesas y más, todas impulsadas por **contratos inteligentes basados en WebAssembly** sobre una infraestructura segura, sin comisiones y descentralizada.
+
+Lo que distingue a VSC para los usuarios es la experiencia de **activos nativos**. Gracias a la **Asignación de Activos Nativos**, los usuarios pueden interactuar con las dApps utilizando activos reales y nativos como BTC, ETH.
+
+Los usuarios de aplicaciones descentralizadas (dApps) en VSC se benefician de maneras clave:
+
+- **Propiedad de activos nativos**.
+- **Experiencia sin comisiones:** Una vez que los activos están dentro de VSC, los usuarios pueden moverlos e interactuar con ellos a través de dApps **sin pagar ninguna comisión de red**.
+- **Experiencia de usuario interoperable:** Un usuario con una billetera de ETH puede interactuar sin problemas con aplicaciones que involucren activos basados en Bitcoin o Solana, sin la necesidad de carteras o cadenas adicionales.
+- **Seguro y descentralizado:** Todas las interacciones ocurren en la cadena *(on-chain)* y están aseguradas por la red de validadores de VSC, lo que elimina la dependencia de servidores centralizados o custodios.
+
+Esto crea una experiencia de usuario fundamentalmente más fluida y poderosa: menos fricción y sin necesidad de gestionar múltiples billeteras para cada cadena de bloques individual.
+
+Las dApps de VSC se comportan como si estuvieras interactuando con una única cadena universal, aunque por debajo estés trabajando con muchos activos nativos diferentes.
+
+En esencia, los usuarios de dApps en VSC obtienen acceso a una **experiencia _blockchain_ de próxima generación:** aplicaciones descentralizadas que son agnósticas a la cadena *(chain-agnostic)*, operación sin comisiones y capaces de manejar activos criptográficos reales y nativos sin problemas.
diff --git a/src/content/docs/es/Roles/developers.md b/src/content/docs/es/Roles/developers.md
new file mode 100644
index 0000000..53e2536
--- /dev/null
+++ b/src/content/docs/es/Roles/developers.md
@@ -0,0 +1,38 @@
+---
+title: Desarrolladores
+sidebar:
+ order: 7
+---
+
+# Construye aplicaciones descentralizadas (dApps) en VSC
+
+Los desarrolladores en VSC obtienen una poderosa ventaja. Cualquier aplicación que construyan es instantáneamente **interoperable con todas las _blockchains_ compatibles**. VSC actúa como un centro entre cadenas *(cross-chain)*, lo que significa que tu proyecto no está aislado a un solo ecosistema. En su lugar, es accesible de forma nativa para usuarios de múltiples cadenas, incluidas Bitcoin, Ethereum, Solana, Hive y otras.
+
+## Interoperabilidad de billeteras
+
+Gracias a la **interoperabilidad de billeteras**, cualquier dirección de billetera, independientemente de la cadena a la que pertenezca, puede invertir, interactuar o comprar activos inmediatamente desde tu dApp respectiva. Un titular de Bitcoin puede financiar un juego, unirse a un protocolo DeFi o comprar NFTs, todo de forma directa y sin necesidad de intercambiar *(swap)* por un *token* compatible de antemano.
+
+## Contratos inteligentes basados en WebAssembly
+
+VSC permite a los desarrolladores construir poderosas aplicaciones descentralizadas utilizando **contratos inteligentes basados en WebAssembly (Wasm)**, que son seguros, rápidos y compatibles con múltiples lenguajes de programación. Estos contratos inteligentes operan directamente en la infraestructura descentralizada de VSC, ofreciendo control total y flexibilidad sin puntos centrales de fallo.
+
+## Asignación de Activos Nativos *(Native Asset Mapping)*
+
+Un avance importante para los desarrolladores en VSC es la **asignación de activos nativos**. Esto permite que los contratos inteligentes interactúen con los activos nativos (como BTC, ETH, Hive y SOL) **dentro** del entorno del contrato inteligente.
+
+Esta capacidad significa que los desarrolladores pueden construir dApps avanzadas que utilizan activos nativos de manera fluida, ya sean para pagos, juegos, herramientas DeFi o incluso intercambios descentralizados (DEXs). Estas aplicaciones pueden mover y gestionar activos nativos en tiempo real con la misma facilidad, o en muchos casos con mayor facilidad, que los *tokens* nativos en una única cadena.
+
+## Arquitectura interna de cero comisiones *(Zero-Fee Internal Architecture)*
+
+Lo que hace que esto sea aún más potente es la **arquitectura interna de cero comisiones** de VSC. Los usuarios solo pagan una vez al entrar o salir de VSC, es decir, la transacción en cadena *(on-chain)* para depositar o retirar un activo como BTC o ETH. Pero dentro de VSC, **todos los movimientos de activos están libres de comisiones gracias al uso del sistema único de crédito de recursos de VSC**. Esto permite experiencias de usuario más fluidas y reduce drásticamente los costes operativos.
+
+## Resumen para Desarrolladores
+
+En resumen, los desarrolladores pueden:
+
+- Utilizar BTC, ETH, SOL nativos directamente en contratos inteligentes.
+- Construir DEXs, sistemas de pago y herramientas de gestión de activos con soporte completo para monedas nativas.
+- Eliminar las comisiones internas del protocolo, mejorando la experiencia de usuario (UX) y la escalabilidad.
+
+
+VSC ofrece una experiencia de desarrollador radicalmente diferente: **programabilidad de activos nativos, arquitectura de cero comisiones, todo en un solo sistema**.
diff --git a/src/content/docs/es/Roles/index.md b/src/content/docs/es/Roles/index.md
new file mode 100644
index 0000000..f371e45
--- /dev/null
+++ b/src/content/docs/es/Roles/index.md
@@ -0,0 +1,16 @@
+---
+title: Resumen general
+sidebar:
+ order: 3
+---
+
+
+En el ecosistema de VSC, existen varios roles importantes:
+
+1. **Proveedores de liquidez (LPs):** Aportan activos a los fondos de liquidez y ganan ingresos de comisiones por transacción.
+2. **Emisores y receptores (a través de la asignación de activos nativos).**
+3. **Validadores:** Aseguran la red al bloquear *(staking)* *tokens* de HIVE y verificar las transacciones.
+4. **Desarrolladores:** Construyen aplicaciones descentralizadas (dApps) utilizando los contratos inteligentes de VSC.
+5. **Usuarios de dApps:** Interactúan con las aplicaciones descentralizadas.
+6. **Traders (comerciantes):** Ejecutan intercambios de activos entre cadenas *(cross-chain asset swaps)*.
+7. **Arbitrajistas:** Capitalizan las diferencias de precio a través de los fondos de liquidez y las cadenas para obtener ganancias.
diff --git a/src/content/docs/es/Roles/liquidity-providers.md b/src/content/docs/es/Roles/liquidity-providers.md
new file mode 100644
index 0000000..e0eca1b
--- /dev/null
+++ b/src/content/docs/es/Roles/liquidity-providers.md
@@ -0,0 +1,87 @@
+---
+title: Proveedores de Liquidez (LPs)
+sidebar:
+ order: 4
+---
+
+## ¿Qué son los proveedores de liquidez?
+
+Los proveedores de liquidez (LPs) son usuarios que añaden *tokens* a los fondos de liquidez de VSC. Sus contribuciones hacen posible los intercambios entre cadenas *(cross-chain swaps)* y el comercio descentralizado. A cambio de suministrar activos, los proveedores de liquidez obtienen ingresos por comisiones y pueden ser elegibles para recompensas adicionales. Los proveedores de liquidez son fundamentales para el ecosistema VSC, proporcionando el capital que impulsa los creadores de mercado automatizados (AMM), la liquidación entre cadenas y el enrutamiento eficiente de *tokens*.
+
+A diferencia de los intercambios centralizados, donde unos pocos creadores de mercado controlan la liquidez, VSC abre la puerta para que cualquiera se convierta en un proveedor de liquidez y gane recompensas proporcionando liquidez.
+
+## El rol de los proveedores de liquidez en VSC
+
+En VSC, los proveedores de liquidez (LPs) aportan liquidez a los fondos de activos duales, siempre con HBD (Hive Backed Dollars) en un lado. Cada fondo empareja un activo volátil (como BTC, ETH, Hive o SOL) con HBD.
+
+Por ejemplo, el fondo BTC/HBD consiste en Bitcoin y HBD. Cuando los usuarios quieren intercambiar BTC por ETH, el protocolo enruta a través de HBD (BTC → HBD → ETH), lo que simplifica la lógica de enrutamiento.
+
+Este diseño proporciona dos beneficios clave:
+
+- Reducción del riesgo de exposición para los proveedores de liquidez, quienes solo necesitan lidiar con un activo volátil.
+
+- Enrutamiento simplificado y estandarizado para los intercambios entre cadenas *(cross-chain swaps)*.
+
+## Cómo funciona la provisión de liquidez
+
+**Emparejamiento de sus activos:**
+
+Para convertirse en un proveedor de liquidez (LPs), debe suministrar un valor equivalente en USD de:
+
+- Un *token* volátil (por ejemplo, BTC, HIVE)
+- HBD (Hive Backed Dollars)
+
+Por ejemplo, si el precio de BTC es de $100,000, usted añadiría el equivalente a $100,000 en BTC y $100,000 en HBD al fondo.
+
+**Depósito en el fondo:**
+
+Una vez depositados:
+
+- Usted recibe *tokens* LP que representan su participación en el fondo.
+- Estos *tokens* pueden ser canjeados en cualquier momento para retirar sus activos subyacentes y los ingresos generados por comisiones.
+
+**Facilitando intercambios *(swaps)*:**
+
+A medida que los usuarios realizan intercambios (por ejemplo, ETH por SOL), su fondo se utiliza para procesar una porción de esa operación. Esto cambia el balance de *tokens* en el fondo, y usted gana una comisión por suministrar la liquidez utilizada en la transacción.
+
+## Ganar recompensas
+
+Los proveedores de liquidez (LPs) son recompensado a través de dos mecanismos principales:
+
+**1. Comisiones por intercambio _(swap fees)_**
+
+Una porción de cada comisión por intercambio se distribuye proporcionalmente a todos los proveedores de liquidez en el fondo.
+
+**2. Programas de incentivoss**
+
+VSC también puede introducir recompensas adicionales en forma de *tokens* de gobernanza o incentivos del protocolo para fomentar una mayor liquidez en los fondos clave.
+
+## Retiro de liquidez
+
+La liquidez se puede retirar en cualquier momento canjeando (quemando) los *tokens* LP. Al retirar, usted recibirá:
+
+- Su porción de ambos *tokens* en el fondo.
+- Su parte de las comisiones por intercambio acumuladas.
+
+## Herramientas para los proveedores de liquidez (LPs)
+
+- **Altera:** Es la interfaz principal de VSC para la provisión de liquidez. A través de Altera, los usuarios pueden monitorizar posiciones, hacer seguimiento del rendimiento *(yield)* e interactuar directamente con los fondos de liquidez de manera segura e intuitiva. Altera es una interfaz de trading descentralizado con soporte para funciones avanzadas de proveedores de liquidez, análisis e integración de gobernanza.
+
+## Cómo convertirse en un proveedor de liquidez (LPs) - Paso a paso
+
+1. **Adquirir HBD y un *token* compatible:** Obtenga HBD a través del DEX de Hive o integraciones, y el *token* correspondiente (por ejemplo, BTC, ETH) desde un exchange compatible.
+2. **Conectar una billetera:** Utilice una billetera compatible con Hive, una billetera compatible con EVM, o una billetera de su elección para acceder a la aplicación Altera.
+3. **Seleccionar un fondo:** Use Altera para elegir un fondo de liquidez que se ajuste a su estrategia (por ejemplo, BTC/HBD, ETH/HBD).
+4. **Depositar activos:** Suministre un valor equivalente en USD de ambos activos y confirme su depósito para recibir *tokens* LP.
+5. **Ganar y monitorea:** Una vez depositada, su liquidez genera ingresos por comisiones de intercambio de forma pasiva. Use Altera para monitorear el rendimiento, las comisiones y la exposición.
+
+## Pérdida temporal *(Impermanent loss)*
+
+La pérdida temporal ocurre cuando el precio de los *tokens* en un fondo de liquidez cambia en comparación con el momento en que usted los depositó. Esto puede causar que su valor de retiro sea inferior a si simplemente hubiera mantenido *(holding)* los *tokens*. Las comisiones y las recompensas pueden compensar esta pérdida, pero es importante ser consciente de este riesgo al proveer liquidez.
+
+## Conclusiones finales
+
+Proveer liquidez en VSC es una forma fundamental de participar y apoyar la red. Con la exposición a la volatilidad de un solo lado y la estabilidad de HBD en cada fondo, VSC ofrece una experiencia de proveedor de liquidez (LPs) más predecible y con riesgo gestionado que muchos creadores de mercado automatizados (AMM) tradicionales.
+
+Ya sea que esté buscando ingresos pasivos, una exposición más diversificada a los mercados de criptomonedas o una forma de contribuir a la infraestructura descentralizada, ser proveedor de liquidez en VSC está diseñado para ser abierto, seguro y gratificante.
+
diff --git a/src/content/docs/es/Roles/senders-and-receivers.md b/src/content/docs/es/Roles/senders-and-receivers.md
new file mode 100644
index 0000000..9dd8235
--- /dev/null
+++ b/src/content/docs/es/Roles/senders-and-receivers.md
@@ -0,0 +1,35 @@
+---
+title: Remitentes y destinatarios
+sidebar:
+ order: 5
+---
+
+*Transferencia de valor sin comisiones a través de la asignación de activos nativos dentro de VSC.*
+
+Los **remitentes y destinatarios** son usuarios que utilizan VSC para enviar valor **entre direcciones de billeteras en diferentes _blockchain_ que están conectadas a VSC**, como por ejemplo, enviar BTC a una dirección de billetera Ethereum, sin necesidad de utilizar puentes *(bridges)* tradicionales, intercambios *(swaps)* o fondos de liquidez. Todo esto sucede **dentro de VSC**, utilizando su sistema de contabilidad interno y la abstracción de la capa de billetera *(wallet-layer abstraction)*, impulsado por la **asignación de activos nativos**.
+
+### Lo que permite la Asignación de Activos Nativos
+
+La **asignación de activos nativos** es el mecanismo de VSC para vincular direcciones de billetera en diferentes *blockchains* y permitir la transferencia de los respectivos activos nativos entre esas billeteras. Permite a los usuarios:
+
+- Conectar billeteras de diferentes *blockchains* (BTC, ETH, SOL, etc.) a VSC.
+- Enviar activos nativos (por ejemplo, BTC) a una dirección de billetera conectada y asociada con otra *blockchain* (por ejemplo, una billetera ETH).
+- Recibir activos nativos.
+
+El remitente paga una comisión de red única para depositar el activo en VSC; el protocolo gestiona el cambio en el libro de contabilidad interno, y el destinatario puede enviar ese activo a cualquier otra dirección de billetera conectada a VSC.
+
+### Características clave de esta función
+
+- **Movimiento de valor a nivel de protocolo** – sin puentes o intermediarios externos.
+- **Recibir BTC nativo en una billetera ETH conectado** (y viceversa).
+- **Los usuarios pagan una comisión solo al depositar o retirar fondos de VSC;** todas las transferencias internas entre billeteras conectadas son **sin comisiones** (las transferencias dentro de VSC son sin comisiones).
+- **Los destinatarios deben conectarse a VSC para acceder a los fondos** (el sistema resuelve automáticamente el depósito a su dirección asignada).
+- **Los destinatarios pueden retirar fondos después de completar un intercambio *(swap)* al activo de su elección**.
+- **Todos los activos permanecen nativos en todo momento**.
+
+### Implicaciones y casos de uso
+
+- **Remesas:** Un usuario en el país A puede enviar BTC directamente a la billetera ETH de alguien en el país B.
+- **Pagos:** Los clientes pueden pagar con la dirección de billetera que posean; los comerciantes reciben el pago en la dirección de billetera que tengan sin comisiones dentro de VSC.
+- **Abstracción de billetera:** Los usuarios no necesitan saber qué cadena está usando alguien; simplemente envían a su billetera conectado.
+- **Simplificación de la experiencia de usuario:** No hay necesidad de hacer intercambios *(swaps)*, usar puentes *(bridges)*, ni siquiera saber qué activo prefiere un destinatario; VSC lo resuelve.
diff --git a/src/content/docs/es/Roles/traders.md b/src/content/docs/es/Roles/traders.md
new file mode 100644
index 0000000..4158655
--- /dev/null
+++ b/src/content/docs/es/Roles/traders.md
@@ -0,0 +1,25 @@
+---
+title: Comerciantes
+sidebar:
+ order: 9
+---
+
+*Realizan intercambios de activos entre cadenas.*
+
+Los comerciantes *(traders)* son usuarios que desean intercambiar un activo nativo por otro, como Bitcoin por Ethereum, sin depender de *exchanges* centralizados (CEX), activos envueltos *(wrapped)* o *tokens* sintéticos. VSC permite esto a través de su capa de liquidez dentro del protocolo, lo que facilita intercambios directos entre activos nativos de una manera descentralizada y con confianza minimizada *(trust-minimized)*.
+
+Cuando un comerciante *(trader)* inicia un intercambio (swap), envía su activo nativo (por ejemplo, BTC) a la bóveda de VSC asegurado en la cadena principal de Bitcoin por el sistema de validadores de VSC. Luego, VSC procesa la transacción extrayendo de los fondos de liquidez disponibles y dirigiendo el activo de salida (por ejemplo, ETH) a la billetera de destino del comerciante. Esto sucede de manera transparente y segura a través de las cadenas *(across chains)*, mientras que el comerciante solo necesita firmar una única transacción desde su billetera.
+
+VSC garantiza que los comerciantes *(trades)* siempre reciban activos nativos en ambos extremos intercambio. Esta es una diferencia fundamental con respecto a los sistemas que dependen de activos envueltos *(wrapped)* o puenteados *(bridged)*, los cuales introducen riesgos significativos de confianza y custodia. En su lugar, VSC mantiene un sistema descentralizado basado en contratos inteligentes que puede interactuar de forma nativa con cadenas externas utilizando bóvedas de entrada y salida, junto con lógica de enrutamiento inteligente. Cada intercambio es atómico *(atomic swap)* y o bien se completa totalmente o bien falla, lo que elimina el riesgo de ejecuciones parciales o fondos bloqueados.
+
+
+Los comerciantes *(traders)* se benefician de:
+
+- **Simplicidad:** Los usuarios no necesitan entender los detalles técnicos de cómo funciona la comunicación entre cadenas. Simplemente inician un intercambio.
+- **Seguridad:** Los fondos permanecen sin custodia durante todo el proceso. La red de validadores de VSC supervisa el proceso para garantizar la integridad.
+- **Transparencia:** Toda la lógica del intercambio y el movimiento de fondos suceden en la cadena, verificable por cualquiera.
+- **Liquidación nativa:** Los comerciantes siempre terminan con *tokens* nativos reales (por ejemplo, BTC nativo o ETH nativo), nunca variantes envueltas.
+- **Descentralización:** No hay necesidad de depender de terceros o fuentes de liquidez centralizadas. El protocolo maneja todo.
+
+El comercio o intercambio *(trading)* en VSC es un caso de uso clave para los usuarios que buscan interactuar con múltiples ecosistemas blockchain desde un sistema unificado sin sacrificar los beneficios de la descentralización, la custodia y la integridad de los activos. A medida que la liquidez crece, los intercambios se vuelven más rápidos, más profundos y más eficientes, dando soporte no solo a individuos, sino también a dApps, sistemas de pago y arbitrajistas.
+
diff --git a/src/content/docs/es/Roles/validators.md b/src/content/docs/es/Roles/validators.md
new file mode 100644
index 0000000..3c368a7
--- /dev/null
+++ b/src/content/docs/es/Roles/validators.md
@@ -0,0 +1,21 @@
+---
+title: Validadores
+sidebar:
+ order: 6
+---
+
+*Garantizando la seguridad del protocolo VSC a través del bloqueo (staking) de HIVE y la participación en el consenso.*
+
+Los validadores son responsables de **asegurar la red VSC**, mantener el consenso y validar todos los cambios de estado, incluidos los depósitos, los retiros y las acciones dentro del protocolo como los intercambios *(swaps)* o las transferencias asignadas. Ejecutan el software de validador VSC y participan en el mecanismo de consenso mediante el **bloqueo *(staking)* de _tokens_ HIVE**, lo que alinea sus incentivos con la integridad del sistema.
+
+### Responsabilidades del Validador
+
+- **Confirmar depósitos de activos** de cadenas conectadas y reflejarlos en el libro mayor *(ledger)* de VSC.
+- **Validar acciones dentro del protocolo** (intercambios, transferencias, lógica de acuñación/quema) con precisión.
+- **Procesar retiros** y firmar transacciones de activos nativos para transferencias salientes.
+- **Mantener el consenso** sobre el estado de VSC, usando Hive como la fuente final de la verdad.
+- **Gobernar los cambios de protocolo** mediante la participación en actualizaciones y configuración.
+
+### Por qué los validadores son importantes
+
+Los validadores son la columna vertebral del diseño *trustless* (sin la necesidad de una autoridad central o un tercero de confianza) en VSC. Dado que VSC no depende de puentes *(bridges)* o actores centralizados, la **validación honesta** es clave para mantener la seguridad de los activos y la descentralización de las operaciones. Su *staking* de HIVE asegura que tienen un interés en juego y permite que el protocolo penalice o elimine a los actores maliciosos.
diff --git a/src/content/docs/es/Technology/Cross-Chain Arhitecture.md b/src/content/docs/es/Technology/Cross-Chain Arhitecture.md
new file mode 100644
index 0000000..b1d00ba
--- /dev/null
+++ b/src/content/docs/es/Technology/Cross-Chain Arhitecture.md
@@ -0,0 +1,74 @@
+---
+title: Arquitectura Cross-Chain
+sidebar:
+ order: 8
+---
+
+Esta sección describe cómo VSC se interconecta con *blockchains* externas, procesa las transacciones entrantes, gestiona las bóvedas y garantiza la seguridad durante las operaciones de cadena cruzada *(Cross-Chain)*.
+
+## Interfaz con cadenas externas
+
+VSC se interconecta con cadenas externas a través de una combinación de:
+
+- **Clientes ligeros de _blockchain_.**
+- **Pruebas de conocimiento cero _(Zero-knowledge proofs - ZKPs)_.**
+- **Esquemas de firma umbral (TSS).**
+
+Estos componentes permiten a VSC operar sin la necesidad de una autoridad central o un tercero de confianza *(trustlessly)* y sin custodios centralizados. Esta arquitectura elimina la necesidad de custodios centralizados, permitiendo a los usuarios interactuar con *blockchains* externas sin renunciar al control de sus activos.
+
+## Flujo de transacciones entrantes
+
+Las transacciones entrantes de cadenas externas se procesan de la siguiente manera:
+
+1. **Los retransmisores _(relays)_** monitorean e indexan eventos o transacciones en las cadenas compatibles.
+2. Estas transacciones son **transmitidas a la red VSC**, donde son validadas utilizando el cliente ligero de *blockchain* apropiado.
+3. Una vez validada, la transacción desencadena una operación en VSC, como por ejemplo:
+
+ - La acuñación de un *token* *(Minting)*.
+ - La ejecución de un intercambio *(swap)*.
+ - La realización de una llamada a contrato *(contract call)*.
+
+Esto garantiza que las acciones externas se reflejen de forma segura dentro del ecosistema VSC.
+
+## Estructura de bóveda
+
+A cada cadena externa compatible se le asigna una **bóveda dedicada** en VSC. Las bóvedas son contratos inteligentes que:
+
+- Funcionan de manera similar a carteras inteligentes *(smart wallets)*.
+- Supervisan los saldos en cadenas externas.
+- Operan de manera totalmente descentralizada **sin un único punto de control**.
+
+Las bóvedas dedicadas por cadena proporcionan aislamiento de fallos, limitando el impacto de los fallos específicos de la cadena en el sistema VSC en general.
+
+### Lógica específica de Bitcoin
+
+Para Bitcoin, las bóvedas rastrean las UTXO *(Unspent Transaction Outputs)* en la red principal de Bitcoin. El contrato inteligente de la bóveda mantiene:
+
+- Un registro de las UTXO entrantes confirmadas y validadas.
+- La autoridad para determinar qué UTXO se pueden gastar.
+
+Esto permite el manejo seguro de las entradas y salidas de Bitcoin directamente desde la capa de contratos VSC.
+
+## Coordinación del movimiento de activos
+
+Una vez que las transacciones entrantes son validadas, los activos son:
+
+- **Acreditados** a la bóveda VSC pertinente.
+- **Gestionados** por el contrato de la bóveda.
+- **Desembolsados** en solicitudes salientes al gastar UTXO o realizar una acción equivalente en la cadena externa.
+
+Este sistema permite un movimiento fluido de activos y auditable entre VSC y las cadenas externas.
+
+## Mecanismos de seguridad y respaldo
+
+Las bóvedas están aseguradas por una **mayoría cualificada de 2/3** de los validadores que utilizan TSS (Esquemas de Firma Umbral). Los validadores deben estar garantizados con colateral, que actúa como una garantía de seguridad. Este diseño de respaldo minimiza el riesgo del usuario, garantizando la seguridad de los activos incluso en condiciones volátiles.
+
+### Condiciones de emergencia
+
+Si el colateral resulta insuficiente o los validadores son comprometidos, se desencadena un **mecanismo de respaldo**. Esto puede implicar:
+
+- Mover los activos de VSC a la respectiva cadena L1 (Capa 1).
+- Convertir los activos a una forma más segura.
+- Detener la actividad de la bóveda temporalmente.
+
+Este mecanismo está modelado de forma similar al sistema de **manejo de emergencias de Chainflip**.
diff --git a/src/content/docs/es/Technology/Execution Environment.md b/src/content/docs/es/Technology/Execution Environment.md
new file mode 100644
index 0000000..4f9868f
--- /dev/null
+++ b/src/content/docs/es/Technology/Execution Environment.md
@@ -0,0 +1,52 @@
+---
+title: Entorno de Ejecución
+sidebar:
+ order: 9
+---
+
+VSC ejecuta transacciones y lógica de contratos inteligentes utilizando un entorno de ejecución determinista y de alto rendimiento construido sobre estándares modernos de arquitectura *blockchain*. Esta sección describe la estructura de la máquina de estado del protocolo, la capa de ejecución y las herramientas compatibles.
+
+## Estructura central de la máquina de estado
+
+VSC sigue un **diseño tipo _rollup_**, donde las transacciones se procesan en lotes y se aplican a un estado de cadena compartido. Este enfoque proporciona una clara separación entre la ejecución y el consenso, permitiendo que el sistema tenga:
+
+- Transiciones de estado deterministas.
+- Procesamiento de lotes eficiente.
+- Lógica de ejecución modular separada del consenso central.
+
+Este diseño permite que VSC evolucione de forma independiente en la capa de ejecución sin perturbar la lógica de consenso o las integraciones externas.
+
+## Validación de transacciones
+
+La validación de transacciones y las actualizaciones de estado en VSC se basan en una **estructura similar a la tolerancia a fallos bizantinos (BFT)**. Los validadores procesan las transacciones entrantes y aplican los cambios de estado solo después de que se alcanza un acuerdo de mayoría cualificada. Esto garantiza:
+
+- Tolerancia a fallos ante la presencia de nodos que se comportan mal o están desconectados.
+- Acuerdo sobre el orden de las transacciones válidas.
+- Garantías de consistencia y seguridad típicas de los modelos de consenso BFT.
+
+Esto asegura que la red puede mantener la integridad operativa incluso cuando una parte de los validadores está comprometida o falla.
+
+## Entorno de ejecución de contratos inteligentes
+
+VSC soporta contratos inteligentes compilados a **WebAssembly (WASM)**, lo que permite a los desarrolladores construir lógica en cadena *(on-chain)* en un formato independiente de la plataforma *(platform-agnostic)*. Los contratos WASM se ejecutan en un entorno aislado que impone:
+
+- Comportamiento determinista.
+- Límites de *stack* y memoria.
+- Aislamiento del entorno de ejecución del *host*.
+
+Los desarrolladores se benefician de resultados de ejecución consistentes sin necesidad de aprender un lenguaje específico de dominio.
+
+## Soporte de lenguajes y herramientas
+
+Actualmente, VSC soporta el desarrollo de contratos en:
+
+- **Golang:** – Adecuado para contratos de bajo nivel o centrados en el sistema.
+- ~~**AssemblyScript:** Un lenguaje similar a TypeScript con una huella ligera *(lightweight footprint)* y compatibilidad con WebAssembly.~~
+
+Los contratos pueden ser compilados a WASM y desplegados en la red VSC utilizando SDKs o las herramientas de desarrollo proporcionadas por el protocolo. Apoyar lenguajes familiares y de alto rendimiento reduce la barrera de entrada y el tiempo de implementación *(time-to-deploy)* para nuevas aplicaciones.
+
+## Características de ejecución
+
+- Todas las interacciones con contratos inteligentes son **sin comisiones**, respaldadas por el modelo de créditos de recursos de Hive.
+- La ejecución de los contratos es determinista, lo que se garantiza mediante las restricciones del entorno de ejecución de WASM.
+- Las APIs internas de VSC proporcionan acceso a las funciones centrales de la *blockchain*, a los estados de activos externos y a la lógica de las bóvedas desde dentro de los contratos inteligentes.
diff --git a/src/content/docs/es/Technology/Validator Operations.md b/src/content/docs/es/Technology/Validator Operations.md
new file mode 100644
index 0000000..994fb98
--- /dev/null
+++ b/src/content/docs/es/Technology/Validator Operations.md
@@ -0,0 +1,49 @@
+---
+title: Operaciones del validador
+sidebar:
+ order: 10
+---
+
+Esta sección describe las responsabilidades operacionales de los validadores dentro de la red VSC y detalla la arquitectura de seguridad del sistema de bóvedas.
+
+## Roles y responsabilidades del validador
+
+Los validadores en la red VSC tienen las siguientes tareas:
+
+- **Procesamiento de transacciones:** Los validadores reciben y procesan transacciones, ejecutando la lógica asociada del contrato inteligente dentro del entorno de ejecución de VSC.
+
+- **Gestión de estado:** Después de la ejecución, los validadores actualizan el estado local para reflejar los resultados de las transacciones procesadas.
+
+- **Producción de bloques:** Los validadores agregan las transacciones procesadas en bloques y proponen estos bloques a la red para su inclusión en la *blockchain*.
+
+- **Participación en el consenso:** Los validadores participan en el mecanismo de consenso de la red para acordar el estado canónico de la cadena, asegurando la consistencia en todo el sistema distribuido.
+
+## Arquitectura de seguridad de la bóveda
+
+El sistema de bóvedas VSC gestiona de forma segura los activos digitales de cadena cruzada *(cross-chain)* utilizando el control de validación descentralizado y la lógica de contratos inteligentes en cadena. Cada bóveda rastrea y gestiona los activos en su respectiva *blockchain* externa (por ejemplo, las UTXO de Bitcoin) sin depender de un operador central.
+
+Las medidas de seguridad clave incluyen:
+
+- **Control descentralizado:** Una red de validadores, garantizados con colateral, gestiona colectivamente las operaciones de la bóveda a través del consenso, previniendo puntos únicos de fallo.
+
+- **Verificación de transacciones:** Las transacciones entrantes y salientes son validadas y confirmadas en la *blockchain* externa pertinente antes de ser procesadas por la bóveda.
+
+- **Seguridad respaldada por colateral:** Los validadores deben mantener un colateral suficiente. Si el colateral es insuficiente, o si se detecta un comportamiento malicioso, se aplican penalizaciones de confiscación *(slashing)* y los protocolos de emergencia permiten la retirada segura o la recuperación de activos para proteger a los usuarios.
+
+- **Instancias de bóveda dedicadas:** Cada *blockchain* compatible tiene su propia instancia de bóveda dedicada, gestionada de forma independiente por los validadores.
+
+Estos mecanismos garantizan la integridad, seguridad y fiabilidad de los activos almacenados y transaccionados a través de las bóvedas VSC.
+
+Estas características de seguridad salvaguardan colectivamente los activos gestionados dentro de la bóveda VSC, alineándose con las mejores prácticas para la gestión de activos digitales.
+
+## Incorporación y mantenimiento del validador
+
+Para convertirse en un validador activo en la red VSC, las entidades deben:
+
+1. **Registro:** Presentar una solicitud de registro de validador, proporcionando la identificación necesaria y la información de cumplimiento.
+
+2. **Configuración de infraestructura:** Desplegar y configurar el *software* del nodo validador de acuerdo con las especificaciones descritas en la documentación de VSC.
+
+3. **Operación continua:** Mantener el nodo validador, asegurando una alta disponibilidad, actualizaciones de *software* oportunas y el cumplimiento de los parámetros de rendimiento.
+
+Los procedimientos y requisitos detallados para la incorporación y el mantenimiento de validadores están especificados en la documentación del validador de VSC.
diff --git a/src/content/docs/es/Technology/index.md b/src/content/docs/es/Technology/index.md
new file mode 100644
index 0000000..46d4381
--- /dev/null
+++ b/src/content/docs/es/Technology/index.md
@@ -0,0 +1,12 @@
+---
+title: Resumen tecnológico
+sidebar:
+ label: Resumen
+ order: 7
+---
+
+El conjunto de tecnologías de VSC está diseñado para permitir una funcionalidad segura y descentralizada de cadena cruzada *(cross-chain)* y un desarrollo fluido de dApps. Combina contratos inteligentes basados en WebAssembly, pruebas de conocimiento cero *(zero-knowledge proofs)*, esquemas de firma umbral *(threshold signature schemes)* e infraestructura de bóveda descentralizada para admitir la interoperabilidad de activos nativos con cadenas como Bitcoin, Ethereum, Hive y Solana.
+
+Los validadores desempeñan un papel central en el mantenimiento de la red, el procesamiento de transacciones, la seguridad de las bóvedas y el logro del consenso. Las bóvedas son contratos inteligentes descentralizados que albergan y gestionan activos de cadenas externas con una alta tolerancia a fallos y una seguridad respaldada por *slashing* (mecanismo de penalización).
+
+Juntos, esta arquitectura permite a VSC ofrecer una plataforma de contratos inteligentes sin la necesidad de una autoridad central o un tercero de confianza *(trustless)*, sin comisiones *(feeless)* y componible, capaz de mover e interactuar con activos nativos entre ecosistemas.
diff --git a/src/content/docs/es/index.mdx b/src/content/docs/es/index.mdx
new file mode 100644
index 0000000..74ff388
--- /dev/null
+++ b/src/content/docs/es/index.mdx
@@ -0,0 +1,41 @@
+---
+title: Introducción
+sidebar:
+ order: 1
+---
+
+import { Aside } from '@astrojs/starlight/components';
+
+
+
+> *Esta documentación ofrece una visión técnica general de VSC (Virtual Smart Chain), un protocolo descentralizado para la custodia y el intercambio de activos entre cadenas, la liquidación y la ejecución de contratos inteligentes. VSC conecta cadenas EVM y no-EVM a través de bóvedas gestionadas por validadores y sistema de enrutamiento unificado basado en *stablecoin* que utiliza HBD. VSC permite transacciones sin comisiones, soporte de activos nativos y lógica entre cadenas componible en un único entorno de confianza minimizada.*
+
+Construida como una capa de liquidación sin comisiones y de alto rendimiento, VSC aprovecha los **contratos inteligentes de WebAssembly**, las **pruebas de conocimiento cero _(zero-knowledge proofs)_**, las **bóvedas gestionadas por validadores** y un **modelo de activo nativo respaldado por garantía (colateral)** que reduce la fragmentación de la liquidez en todos los ecosistemas.
+
+Todos los intercambios se enrutan a través de un único activo base, una *stablecoin* (moneda estable), **HBD (Hive Backed Dollars). Usar HBD expone a los proveedores de liquidez (LPs) a una volatilidad de un solo lado**, lo que hace que la provisión de liquidez en VSC sea **más predecible y eficiente** tanto para participantes institucionales como minoristas.
+
+A diferencia de otros protocolos entre cadenas limitados a mecanismos de intercambio básicos, VSC soporta la **ejecución de contratos inteligentes**, lo que permite a los desarrolladores crear aplicaciones descentralizadas, entre cadenas y componibles, dentro del propio protocolo.
+
+## Características principales del protocolo:
+
+- **Soporte nativo de activos multicadena:** Activos de las *blockchains* soportadas (incluyendo Bitcoin, Solana, Ethereum y otras) se depositan directamente en **bóvedas en cadena** aseguradas por los validadores de VSC. Se exige a estos validadores que hagan *staking* de **HVE** como garantía (colateral) económica, asegurando la seguridad y la rendición de cuentas.
+
+- **Contratos inteligentes a través de WebAssembly (WASM):** Los desarrolladores pueden crear lógica potente en cadena utilizando contratos basados en WASM, con acceso a activos nativo de múltiples cadenas.
+
+- **Arquitectura de pruebas de conocimiento cero _(Zero-Knowledge Proofs - ZKPs)_:** Las ZKPs se utilizan para validar las interacciones de cadenas externas y mantener la verificabilidad entre sistemas, sin comprometer la velocidad ni la privacidad del usuario.
+
+- **Interoperabilidad universal de billeteras:** Los usuarios pueden interactuar con el protocolo utilizando billeteras de cualquier *blockchain* soportada, eliminando la necesidad de gestionar múltiples cuentas o formatos.
+
+- **Capa de identidad centrada en el usuario:** Mediante la integración nativa de Hive, los usuarios se benefician de nombres de usuario legibles, abstracción de cuentas e inicio de sesión social, lo que permite una simplicidad Web2 sin sacrificar la descentralización.
+
+## Innovaciones de próxima generación de VSC
+
+VSC presenta varios componentes arquitectónicos novedosos para abordar las limitaciones comunes en los protocolos entre cadenas existentes, con el fin de ofrecer un ecosistema unificado, escalable y amigable para los desarrolladores.
+
+Estas innovaciones abordan limitaciones persistentes en la interoperabilidad, la experiencia del usuario y la fragmentación de la liquidez. Estos componentes tienen como objetivo simplificar el desarrollo y mejorar la experiencia del usuario en entornos multicadena.
+
+- **Asignación de activos nativos:** VSC permite que los activos de diferentes *blockchains* (por ejemplo, BTC, SOL, Hive, ETH) se bloqueen de forma segura en sus cadenas nativas y se asignen a direcciones conectadas a VSC. Por ejemplo: esto permite que las direcciones de billeteras de Ethereum mantengan Bitcoin (BTC) nativo, que las direcciones de billeteras de Solana mantengan Ethereum (ETH) nativo, y viceversa, todo mientras se aprovecha la red descentralizada de validadores de VSC para una interoperabilidad entre cadenas fluida.
+
+- **Transacciones sin comisiones dentro del protocolo:** VSC elimina las comisiones de gas para los usuarios al utilizar el modelo de **crédito de recursos** de Hive. Estos créditos se regeneran con el tiempo y se consumen cuando un usuario realiza acciones en cadena, como transferir *tokens*, interactuar con contratos inteligentes o firmar transacciones. Este sistema permite interacciones verdaderamente sin comisiones, lo que posiciona a VSC de forma única para ofrecer una experiencia sin gas, ideal para incorporar usuarios convencionales y escalar el uso sin fricción.
+
+- **La *Stablecoin* (HBD) como activo base en todos los pares:** Los fondos de liquidez *(liquidity pools)* en VSC emparejan cada activo con **HBD**, una *stablecoin* algorítmica con una trayectoria de una década de tiempo de actividad y estabilidad. Esto estandariza las rutas de enrutamiento y simplifica la provisión de liquidez a través de activos y cadenas, al mismo tiempo que previene los choques de volatilidad y evita la necesidad de exponerse a un activo volátil secundario.
diff --git a/src/content/docs/es/using-vsc.md b/src/content/docs/es/using-vsc.md
new file mode 100644
index 0000000..518a196
--- /dev/null
+++ b/src/content/docs/es/using-vsc.md
@@ -0,0 +1,47 @@
+---
+title: Usando VSC
+sidebar:
+ order: 2
+---
+
+*Introducción a los conceptos que ayudan a comprender los servicios que VSC puede proporcionar.*
+
+## Creadores de mercado automatizados *(Automated Market Makers - AMMs)* y fondos de liquidez
+
+**Los Creadores de Mercado Automatizados (AMMs)** son un componente clave del ecosistema de finanzas descentralizadas (DeFi) de VSC. Los AMMs permiten a los usuarios intercambiar activos automáticamente a través de fondos de liquidez, sin necesidad de libros de órdenes centralizados o creadores de mercado tradicionales. Este sistema proporciona liquidez en el protocolo VSC, lo que permite realizar intercambios de activos entre cadenas *(asset swaps across chains)*.
+
+## ¿Qué Son los fondos de liquidez (LPs)?
+
+Los fondos de liquidez (LPs) son colecciones de dos o más activos *(tokens)* que están bloqueados en un contrato inteligente. Estos fondos son utilizados por los **creadores de mercado automatizados (AMMs)** para facilitar el comercio descentralizado y asegurar la liquidez para los usuarios que interactúan con el protocolo.
+
+En VSC, los fondos de liquidez están diseñados para emparejar un activo volátil (como Bitcoin, Ethereum, Solana, etc.) con un activo estable: **HBD (Hive Backed Dollars)**. Esta estructura tiene como objetivo gestionar el riesgo de la volatilidad en la provisión de liquidez, haciéndola más predecible para los usuarios que aportan dicha liquidez.
+
+## Creación y emparejamiento del fondo de liquidez (LP)
+
+Todo fondo de liquidez en VSC implica emparejar un activo volátil (como BTC, ETH, SOL) con **HBD**. Por ejemplo, un fondo de liquidez **BTC/HBD** contendría tanto *tokens* BTC como HBD. Al proporcionar liquidez a este fondo, los proveedores de liquidez (LPs) depositan valores iguales de ambos activos (por ejemplo, una cantidad de BTC y una cantidad equivalente de HBD) en el fondo.
+
+## El rol de HBD
+
+**HBD**, la *stablecoin* de VSC, funciona como el **activo base** en todos los fondos de liquidez. Esto significa que cada par de liquidez incluye a **HBD** como uno de los activos.
+
+El rol de HBD como *stablecoin* mitiga los riesgos asociados a la volatilidad. Dado que HBD está respaldado algorítmicamente, los proveedores de liquidez (LPs) están expuestos a una volatilidad de un solo lado - la del activo volátil en el par (por ejemplo, BTC, ETH, HIVE). Esto reduce la complejidad de cubrirse *(hedging)* contra múltiples activos volátiles.
+
+## Algoritmo del creador de mercado automatizado (AMM)
+
+VSC utiliza un algoritmo de **creador de mercado automatizado (AMM)** para mantener el balance de los activos en el fondo de liquidez. Cuando un usuario realiza un intercambio *(trade)* (por ejemplo, intercambiar BTC por HBD o viceversa), el AMM ajusta la proporción de activos en el fondo automáticamente.
+
+## Ingresos por comisiones *(Earning Fees)*
+
+Los proveedores de liquidez (LPs) son recompensados con ingresos de comisiones por transacción en proporción a su contribución al fondo *(pool)*. Cada vez que alguien intercambia activos a través del fondo, se cobra una pequeña comisión, que es distribuida entre los LPs como recompensa por suministrar liquidez.
+
+Los proveedores de liquidez (LPs) pueden obtener recompensas de forma continua, haciendo de la provisión de liquidez una oportunidad de ingreso pasivo dentro del ecosistema de VSC.
+
+## Ejecutar un nodo y bloquear *(staking)* HIVE como garantía
+
+Para participar en los mecanismos de validación y seguridad de VSC, los usuarios pueden optar por ejecutar un **nodo validador** o bloquear *(stake)* HIVE como garantía.
+
+- **Ejecutar un Nodo:** Para convertirse en un validador en la red descentralizada de VSC, los usuarios deben ejecutar un nodo que participe activamente en la verificación de transacciones y en la seguridad de los activos bloqueados en la plataforma. Ejecutar un nodo contribuye al sistema de validación descentralizada de VSC y garantiza el funcionamiento correcto del protocolo.
+
+- **Bloquear *(Staking)* HIVE:** Se requiere que los validadores mantengan bloqueado *(stake)* un mínimo de **2.000 _tokens_ HIVE** como garantía. Esta garantía se utiliza para asegurar la red e incentivar el comportamiento honesto. Los validadores que actúen de forma maliciosa o no cumplan con sus obligaciones *(duties)* pueden perder parte del sus HIVE bloqueados.
+
+- **Interacción con VSC (ALTERA):** Altera es la primera dApp (aplicación descentralizada) de VSC, una plataforma para gestionar activos e intercambios entre cadenas *(cross-chain swaps)* dentro de VSC. Permite a los usuarios llevar a cabo la gestión de activos, ejecutar intercambios entre cadenas e interactuar con el ecosistema VSC. Altera es compatible con transacciones y seguimiento de activos a través de múltiples *blockchains*, proporcionando una interfaz unificada que simplifica las actividades de finanzas descentralizadas (DeFi) sin requerir que los usuarios gestionen los detalles técnicos de cada *blockchain* individual.
diff --git a/src/content/docs/index.mdx b/src/content/docs/index.mdx
index fa2ba19..4c5cc91 100644
--- a/src/content/docs/index.mdx
+++ b/src/content/docs/index.mdx
@@ -4,6 +4,10 @@ sidebar:
order: 1
---
+import { Aside } from '@astrojs/starlight/components';
+
+
+
*This documentation provides a technical overview of VSC (Virtual Smart Chain), a decentralized protocol for cross-chain asset custody and swaps, settlement, and smart contract execution. VSC connects EVM and non-EVM chains through validator-managed vaults and a unified stablecoin-based routing system using HBD. VSC enables feeless transactions, native asset support, and composable cross-chain logic in a single trust-minimized environment.*