Spanish translation

README.es.md

@@ -0,0 +1,13 @@
+# Documentación de Madara
+
+Documentación para Madara, la pila de elección para su próxima cadena de aplicaciones.
+
+## Desarrollo Local
+
+Primero, ejecuta `pnpm i` para instalar las dependencias.
+
+Luego, ejecuta `pnpm dev` para iniciar el servidor de desarrollo y visita localhost:3000.
+
+## Licencia
+
+Este proyecto está licenciado bajo la Licencia MIT.

middleware.js

@@ -0,0 +1 @@
+export { locales as middleware } from 'nextra/locales'

next.config.js

@@ -1,6 +1,11 @@
 const withNextra = require('nextra')({
   theme: 'nextra-theme-docs',
-  themeConfig: './theme.config.tsx',
+  themeConfig: './theme.config.tsx'
 })
 
-module.exports = withNextra()
+module.exports = withNextra({
+  i18n: {
+    locales: ['en', 'es'],
+    defaultLocale: 'en'
+  }
+})

pages/_meta.es.json

@@ -0,0 +1,33 @@
+{
+	"--": {
+		"type": "separator",
+		"title": "Madara Stack"
+	},
+	"index": "Madara",
+	"architecture": "Arquitectura",
+	"why": "Por Que",
+	"---": {
+		"type": "separator",
+		"title": "Construir en Madara"
+	},
+	"build": "Como Empezar",
+	"config": "Configuración",
+	"tools": "Herramientas",
+	"ecosystem": "Ecosistema",
+	"contribute": "Contribuir",
+	"----": {
+		"type": "separator",
+		"title": "Seguridad"
+	},
+	"security": "FAQ",
+	"about": {
+		"title": "Acerca De",
+		"type": "page"
+	},
+	"contact": {
+		"title": "Contacto ↗",
+		"type": "page",
+		"href": "https://t.me/MadaraStarknet",
+		"newWindow": true
+	}
+}

pages/about.es.mdx

@@ -0,0 +1,5 @@
+# Acerca de
+
+Madara es un software de código abierto construido por el Equipo de Exploración de Starkware en colaboración con proyectos como Pragma, Kakarot y Dojo.
+
+Es libre de uso comercial.

pages/architecture.es.mdx

@@ -0,0 +1,115 @@
+import { Callout } from 'nextra-theme-docs'
+
+# 1) ¿Qué es Madara?
+
+**Madara ha sido construido por el Equipo de Exploración de Starkware, también conocido como *[Keep Starknet Strange](https://github.com/keep-starkne)*, para apoyar 
+la [visión de escalado fractal](https://medium.com/starkware/fractal-scaling-from-l2-to-l3-7fe238ecfb4f) que Starkware planteó hace años.**
+
+Hay muchas razones por las que uno querría tener su propio L3 en lugar de construir directamente sobre Starknet:
+
+- Hiper-escalabilidad
+- Mejor control
+- Privacidad
+- Interoperabilidad más barata/simplificada
+
+![fractal-scaling](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*clggLFBseZKhBSf-oEWhzA.jpeg)
+
+Madara abre todo un nuevo campo de innovación; los desarrolladores de aplicaciones pueden experimentar con diferentes soluciones de disponibilidad de datos, algoritmos de consenso y esquemas de prueba.
+
+En la sección `Construir en Madara` encontrará información detallada sobre las distintas soluciones que se están explorando y sus ventajas y desventajas.
+
+## 2) H
+
+El componente central de Madara es la paleta `Starknet`. Proporciona una capa de compatibilidad Starknet para Substrate. 
+Gracias a ella, el código Cairo existente puede ejecutarse sin problemas.
+
+Esta paleta, además del módulo RPC, permite la emulación de bloques Starknet, valida las transacciones codificadas en 
+Starknet y hace posible desplegar una DApp Starknet existente en Madara sin ningún cambio.
+
+## 3) A
+
+Quizás te preguntes cómo podemos asignar bloques de Substrate a bloques de Starknet.
+
+Bueno, utilizamos el método del [bloque envoltorio](https://corepaper.org/substrate/wrapper/) utilizado por primera vez por Parity en frontier,
+la capa de compatibilidad EVM para Substrate.
+
+Wrapper block es una estrategia de Substrate que permite procesar bloques que no se diseñaron originalmente con Substrate en mente.
+
+Añade una ligera sobrecarga de rendimiento, pero es insignificante en comparación con otros componentes del tiempo de ejecución.
+
+## La pila Madara
+
+Por ahora, centrémonos en la visión general de alto nivel y raspemos la superficie de cada una de estas capas.
+
+![stack](../static/img/stack.png)
+
+### Ejecución
+
+La capa de ejecución define la forma en que se ejecutan los bloques y se producen las diferencias de estado. Madara facilita el cambio entre dos cajas de ejecución diferentes, 
+[blockifier](https://github.com/starkware-libs/blockifier) de Starkware y [starknet_in_rust](https://github.com/lambdaclass/starknet_in_rust) de LambdaClass.
+
+
+**Cairo VM**
+
+Bajo el capó, siempre se ejecutará el [Cairo VM](https://github.com/lambdaclass/cairo-rs) que está siendo mantenido por Starkware y LambdaClass en Rust. 
+Cairo (CPU Algebraic Intermediate Representation) es un lenguaje de programación para escribir programas demostrables, donde una parte puede probar a otra que un cierto cálculo se ejecutó correctamente.
+
+- [Cairo Whitepaper](https://eprint.iacr.org/2021/1063) 🐺
+- [Cairo 1 Docs](https://www.cairo-lang.org/docs/v1.0/) 🦀
+- [Cairo Book](https://cairo-book.github.io/) 📒
+
+<Callout type="info" emoji="ℹ️">
+  ! Se están realizando experimentos para modificar la máquina virtual de El Cairo cambiando, por ejemplo, el tamaño de los campos a Ricitos de Oro, lo que podría suponer un importante aumento del rendimiento.
+</Callout>
+
+### Liquidación
+
+Como Validity Rollup, el estado de cualquier cadena de Madara debería poder construirse únicamente mirando su capa de liquidación.<br></br>
+Madara en sí no hace ninguna suposición con respecto a la capa de liquidación elegida.<br></br>
+Si tomamos el ejemplo de un L3, entonces enviaría regularmente una prueba a Starknet para un lote de bloques L3.
+
+<Callout type="info" emoji="ℹ️">
+  ! Por ejemplo, Starknet liquida actualmente cada ~5 horas, sobre todo por el coste que supone liquidar en Ethereum. Mientras que un L3 podría en la práctica liquidar mucho más a menudo en Starknet por una fracción del coste.
+</Callout>
+
+El término de **liquidación** puede ser engañoso, es importante en última instancia hacer la diferencia entre la finalidad **SOFT** y **HARD**.
+
+Una vez que se alcanza la firmeza **HARD**, es decir, que la transacción ha sido probada y verificada en la capa de liquidación, entonces queda grabada en piedra. 
+La finalidad **SOFT** es, en última instancia, mejorar la experiencia del usuario. Sin embargo, veremos que descentralizando la capa de secuenciación podemos aspirar a una finalidad **SOFT** bastante fuerte.
+
+### Secuenciación
+
+La secuenciación es realizada por Madara y puede ser ajustada de diferentes maneras para adaptarse a sus propias necesidades.
+
+Por ejemplo, podría ser un simple FCFS, PGA o esquemas más complejos como Narwhall & Bullshark o [HotStuff](https://github.com/keep-starknet-strange/madara/issues/180).
+
+El orden de las transacciones es bastante importante para garantizar una buena protección MEV y asegurar un orden justo de las transacciones. Aunque, en algunos casos como las cadenas específicas de aplicaciones, se pueden implementar mempools encriptados que garanticen un orden justo.
+
+Madara es por defecto un secuenciador **descentralizado**, múltiples nodos pueden unirse a la red y el consenso por defecto es [GRANDPA  &  BABE](https://docs.substrate.io/learn/consensus/), el utilizado por la mayoría de las parachains polkadot. Creemos que aunque los secuenciadores 
+centralizados son el estándar de la industria por ahora, descentralizar la capa de secuenciación es de suma importancia para tener sistemas realmente resistentes a la censura.
+
+### Disponibilidad de datos
+
+En la actualidad, Starknet funciona en modo rollup, tal y como se describe [aqui](https://docs.starknet.io/documentation/architecture_and_concepts/Data_Availability/on-chain-data/). La disponibilidad de datos (DA) significa que el árbol de estados completo está siempre disponible, 
+lo que proporciona a los usuarios la seguridad de saber que si StarkEx deja de funcionar alguna vez, pueden demostrar la custodia de sus fondos.
+
+En estos momentos se están experimentando diferentes esquemas de DA para Madara:
+
+- Modo Validium: Los datos están disponibles fuera de la cadena. El Comité de Disponibilidad de Datos (DAC) los almacena, proporcionando una solución de confianza.
+- Celestia
+- Eigen DA
+- Modo Rollup
+
+Cada modo DA viene con su propio conjunto de suposiciones y los desarrolladores de aplicaciones son libres de experimentar e ir con lo que se sientan más cómodos.
+
+### Gobernanza
+
+Snapshot X sería la opción principal para el gobierno en Madara, ya que es un sistema de gobierno totalmente en cadena que se basa en pruebas de almacenamiento. 
+Verás en los diferentes hacks de Madara, como el de Turbo VM, por qué las pruebas de almacenamiento serán la primera opción de mecanismo de puente dentro del ecosistema de Madara.
+
+También se están explorando otros mecanismos de gobernanza, como la [paleta de gobernanza](https://github.com/keep-starknet-strange/madara/issues/82) de sustratos nativos. 
+Teniendo en cuenta lo que hemos visto en el pasado, uno de los valores fundamentales de Madara es la gobernanza en la cadena. Creemos sinceramente que la gobernanza debe ser siempre aplicable en la cadena, como ocurre en los ecosistemas Cosmos y Polkadot.
+
+<Callout type="default" emoji="🧩">
+  Una de las mejores características que Madara ofrece gracias a estar construida con Substrate es la actualización sin **tenedores**. Puedes leer más sobre ello
+</Callout>[aquí](https://docs.substrate.io/maintain/runtime-upgrades/#:~:text=To%20perform%20a%20forkless%20runtime,part%20of%20the%20consensus%20process).

pages/build.es.mdx

@@ -0,0 +1,130 @@
+import { Steps } from 'nextra-theme-docs'
+
+# Construir sobre Madara
+
+*Uchiwa Madara*<br></br>
+En esta sección, te guiaremos a través del proceso de construcción para que puedas empezar a hackear sobre la pila Madara. 
+Pasaremos de ejecutar tu cadena localmente a cambiar el algoritmo de consenso e interactuar con contratos inteligentes en tu propia cadena.
+
+## 1.- Empecemos:
+
+<Steps>
+
+### Instalar dependencias
+
+Primero necesitamos asegurarnos de que tienes todo lo necesario para completar este tutorial.
+
+| Dependencia  |  Version | Instalación |
+|---|---|---|
+| Rust  | rustc 1.69.0-nightly  | `curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs \| sh` <br></br>`rustup toolchain install nightly` |
+| nvm  | latest  | `curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh \| bash` |
+| Cairo  | 1.0  | `curl -L https://github.com/franalgaba/cairo-installer/raw/main/bin/cairo-installer \| bash` |  
+
+### 2.- Construir la cadena:
+
+Crearemos un CairoVM Rollup a partir del código fuente de Madara Stack. Podrías usar imágenes docker, pero de esta forma mantenemos la opción de modificar el comportamiento de los componentes si lo necesitas. 
+El código fuente de Madara stack es un monorepo que puedes encontrar [aquí](https://github.com/keep-starknet-strange/madara).
+
+```bash
+cd ~
+git clone [email protected]:keep-starknet-strange/madara.git
+```
+
+A continuación vamos a construir la cadena en modo `release`:
+
+```bash
+cd madara
+cargo build --release
+```
+
+**Cadena de desarrollo de nodo único**
+
+Este comando iniciará la cadena de desarrollo de nodo único con estado no persistente:
+
+```bash
+./target/release/madara --dev
+```
+
+Purgar el estado de la cadena de desarrollo:
+
+```bash
+./target/release/madara purge-chain --dev
+```
+
+Iniciar la cadena de desarrollo con registro detallado:
+
+```bash
+RUST_BACKTRACE=1 ./target/release/madara -ldebug --dev
+```
+
+Si todo funciona correctamente, ¡podemos pasar al siguiente paso y crear nuestro propio estado de génesis!
+
+
+### 3.- Cree su especificación de cadena:
+
+En primer lugar, ejecute este comando para crear una especificación de cadena simple
+
+```bash
+./target/release/madara build-spec > ./infra/chain-sepcs/chain-spec-plain.json
+```
+
+Por defecto, la cadena se ejecutará con la siguiente configuración :
+
+- [GRANDPA & AURA](https://docs.substrate.io/learn/consensus/#default-consensus-models)
+- Un contrato de cuenta de `administrador` en la dirección  `0x0000000000000000000000000000000000000000000000000000000000000001`
+- Un contrato de prueba en la dirección `0x0000000000000000000000000000000000000000000000000000000000001111`
+- Un token de pago (ETH) en la dirección `0x040e59c2c182a58fb0a74349bfa4769cbbcba32547591dd3fb1def8623997d00`
+- La dirección de la cuenta `admin` tiene un saldo `MAX` de fee token
+- Un contrato ERC20 en la dirección `0x040e59c2c182a58fb0a74349bfa4769cbbcba32547591dd3fb1def8623997d00`
+
+Esta especificación de la cadena puede considerarse como la principal fuente de información que se utilizará al conectarse a la cadena.
+
+### 4.- *(No disponible aún) Despliegue sus contratos inteligentes de liquidación*
+
+### 5.- Inicie su cadena
+
+Ahora que ya tenemos todo configurado, ¡por fin podemos poner en marcha la cadena! 🥷
+
+Hay un montón de maneras que usted puede ejecutar la cadena en función del papel que desea tomar :
+- **Nodo completo**<br></br>
+Se sincroniza con la cadena para almacenar el estado más reciente de los bloques y las cabeceras de los bloques más antiguos.
+- **Nodo de archivo**<br></br>
+Mantiene todos los bloques empezando por el bloque génesis con el estado completo disponible para cada bloque.
+- **Nodo RPC**<br></br>
+Expone una interfaz RPC a través de puertos HTTP o WebSocket para que los usuarios puedan leer el estado de la cadena de bloques y enviar transacciones. 
+A menudo hay varios nodos RPC detrás de un equilibrador de carga.
+- **Nodo validador**<br></br>
+Asegura la cadena apostando algún activo elegido y vota en consenso junto con otros validadores.
+
+Cuando desarrolle su cadena, puede simplemente ejecutarla en modo desarrollador:
+
+```bash
+./target/release/madara --dev --execution=native
+```
+	Si sólo te importa exponer el RPC puedes ejecutar lo siguiente :
+
+```bash
+./target/release/madara --unsafe-ws-external --rpc-methods Safe --rpc-cors '*' --ws-max-connections 5000
+```
+
+Si desea guardar todo el estado de la cadena en una carpeta `/tmp/ :
+
+```bash
+./target/release/madara --base-path /tmp/
+```
+
+En este caso, tenga en cuenta que puede purgar el estado de la cadena cuando lo desee ejecutando :
+
+```bash
+./target/release/madara purge-chain --base-path /tmp
+```
+
+### 6.- Despliega una cuenta en tu cadena
+
+Por fin tu cadena está en marcha. ¡Es hora de desplegar tu propia cuenta!
+
+### 7.- Haz algunas transacciones
+
+### 8.- 🥷
+
+</Steps>

pages/config.es.mdx

@@ -0,0 +1,39 @@
+
+# Configuración
+
+En esta sección, veremos los diferentes parámetros que puede ajustar como ingeniero de ejecución para que su blockchain 
+se adapte perfectamente a sus necesidades.
+
+| Parametro | Ubicación  | Interpretación | Predeterminado |
+|---|---|---|---|
+|  MILLISECS_PER_BLOCK |  `crates/runtime/src/config.rs` | Average expected block time targeted. |6000 (ms)  |
+|  BlockHashCount |  `crates/runtime/src/config.rs` | Maximum number of block number to block hash mappings to keep (oldest pruned first). |2400  |
+
+El componente principal de Madara es una paleta de sustrato personalizada llamada `starknet` que puedes encontrar en `crates/pallets/starknet`.
+
+Sin embargo, como se menciona en la introducción, Madara es genérico por esencia. Define un conjunto de tipos en su configuración específicamente 
+los rasgos que deben ser implementados por estos tipos **NO** los tipos en sí mismos. Este concepto tan poderoso le permitirá cambiar fácilmente los componentes centrales de su cadena.
+
+Echemos un vistazo a estos tipos y sus valores por defecto.
+
+```rust
+// `crates/runtime/src/pallets.rs`
+
+// ...
+
+/// Configure the Starknet pallet in pallets/starknet.
+impl pallet_starknet::Config for Runtime {
+    type RuntimeEvent = RuntimeEvent;
+    type StateRoot = pallet_starknet::state_root::IntermediateStateRoot<Self>;
+    type SystemHash = mp_starknet::crypto::hash::pedersen::PedersenHasher;
+    type TimestampProvider = Timestamp;
+    type UnsignedPriority = UnsignedPriority;
+}
+```
+
+| Tipo  | Interpretación | Predeterminado |
+|---|---|---|
+|  RuntimeEvent  | Event type that will be emitted on extrinsics' execution. | Substrate RuntimeEvent |
+|  StateRoot |  Defines how the state root is computed from the state. | [Starknet State Root](https://docs.starknet.io/documentation/architecture_and_concepts/State/starknet-state/#state-commitment) |
+|  SystemHash |  Hashing function used to compute commitments. | Pedersen |
+|  TimestampProvider |  Defines how the timestamp is retrieved (used for block timestamp) | [Timestamp Pallet](https://docs.rs/pallet-timestamp/latest/pallet_timestamp/) |

pages/contribute.mdx → pages/contribute.en.mdx

@@ -24,4 +24,4 @@ Found a bug ? Please submit an [issue](https://github.com/keep-starknet-strange/
 
 ## Documentation
 
-Missing anything in these docs ? Spotted a typo ? Please submit a PR or create an issue on [GitHub](https://github.com/EvolveArt/madara-docs/). As everything we do, we grow together and the more eyes we have looking at it the better it will be.
+Missing anything in these docs ? Spotted a typo ? Please submit a PR or create an issue on [GitHub](https://github.com/EvolveArt/madara-docs/). As everything we do, we grow together and the more eyes we have looking at it the better it will be.

pages/contribute.es.mdx

@@ -0,0 +1,28 @@
+import { Callout } from 'nextra-theme-docs'
+
+# Contribuye a Madara
+
+Madara se ha construido desde el día 1 de la forma más abierta posible, y siempre seguirá los principios que impulsan 
+el ecosistema Starknet desde el día 1. Cualquiera es libre de unirse al grupo de telegram [aquí](https://t.me/MadaraStarknet), 
+venir a chatear, pedir ayuda, ¡discutir cualquier cosa!
+
+También se organizan convocatorias comunitarias periódicas cuya agenda encontrarás siempre en las [discusiones de GitHub](https://github.com/keep-starknet-strange/madara/discussions).
+
+<Callout type="info" emoji="🧪">
+  ¿Tienes una idea de un hack ambicioso relacionado con una capa de la pila? ¿Por ejemplo, un nuevo modo DA o una nueva máquina virtual? 
+  Adelante, crea un debate en el repositorio de GitHub; si todo va bien, te invitaremos a presentarlo en una convocatoria de la comunidad y, a continuación, ¡empieza a ponerlo en práctica!
+</Callout>
+
+## Desarrolladores
+
+Las contribuciones a Madara se recompensan a través de [OnlyDust](https://app.onlydust.xyz/).<br></br>.
+¿Qué significa esto? Significa que usted, como desarrollador, es libre de elegir cualquier tema abierto y enviar un PR. Una vez que el PR se fusiona, 
+se le pagará de acuerdo con el tiempo / dificultad de la PR. Ya hay más de 20 colaboradores y te estamos esperando 😎.
+
+## Búsqueda de errores
+
+¿Has encontrado un error? Por favor, envía una [incidencia](https://github.com/keep-starknet-strange/madara/issues) en GitHub para que cualquier colaborador de código abierto pueda echarle un vistazo y solucionarlo (¡tú también puedes!)
+
+## Documentación
+
+¿Falta algo en la documentación? ¿Ha detectado un error tipográfico? Envíe un PR o cree una incidencia en [GitHub](https://github.com/EvolveArt/madara-docs/). Como todo lo que hacemos, crecemos juntos y cuantos más ojos lo miren, mejor será.