# Begin Tutorial: Un Tutorial Interactivo En este tutorial, recorrerá pasos interactivos que le ayudarán a profundizar su conocimiento y comprensión del entorno de [AOS](https://tinyurl.com/aothecomputer). ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712617058273/c1e71341-24bc-4929-b0d7-8ebd52101751.png align="center")

"Bajar Por La Madriguera Del Conejo"

En este divertido ejercicio, encontrarás una serie de desafíos presentados por dos personajes familiares, Morfeo y Trinity. Te sumergirás profundamente `bajar por la madriguera del conejo` por Morpheus mientras te presenta una serie de desafíos para demostrar que eres El Elegido. Una vez que hayas completado todos los desafíos presentados por Morpheus y Trinity, recibirás un token que te otorga acceso a una sala de chat exclusiva dentro de AO llamada "The Construct".

--- ## Preparativos

La Historia

Siempre has sabido que hay algo más en este mundo, justo más allá de tu alcance. Has estado buscándolo, sin siquiera saber qué era eso que buscabas. Eso... es AO. Iniciamos nuestro viaje instalando el cliente de AOS y comenzando un nuevo proceso. Esto nos permitirá interactuar con el ordenador AO y completar el resto del tutorial.

### Requisitos del Sistema El cliente local de aos es muy sencillo de instalar. Solo asegúrate de tener: * NodeJS versión 20 o superior. (Si aún no lo has instalado, consulta [esta página](https://nodejs.org/en/download/package-manager) para encontrar instrucciones para tu sistema operativo). * Un editor de código de tu elección.

💡

Aunque no es obligatorio, recomendamos instalar el complemento de AO en tu editor de texto preferido para optimizar tu experiencia con AOS.

### Instalando AOS Una vez que tengas NodeJS en tu máquina, todo lo que necesitas hacer es instalar AOS y ejecutarlo: ```bash npm i -g https://get_ao.g8way.io ``` Después de la instalación, ¡simplemente podemos ejecutar el comando en sí para iniciar un nuevo proceso AOS! ```bash aos ``` ### Bienvenido a la madriguera del conejo La utilidad que acabas de iniciar es un cliente local, listo para retransmitir mensajes para ti a tu nuevo proceso dentro del ordenador AO. Una vez conectado, deberías ver lo siguiente: ```bash _____ _______ _____ /\ \ /::\ \ /\ \ /::\ \ /::::\ \ /::\ \ /::::\ \ /::::::\ \ /::::\ \ /::::::\ \ /::::::::\ \ /::::::\ \ /:::/\:::\ \ /:::/~~\:::\ \ /:::/\:::\ \ /:::/__\:::\ \ /:::/ \:::\ \ /:::/__\:::\ \ /::::\ \:::\ \ /:::/ / \:::\ \ \:::\ \:::\ \ /::::::\ \:::\ \ /:::/____/ \:::\____\ ___\:::\ \:::\ \ /:::/\:::\ \:::\ \ |:::| | |:::| | /\ \:::\ \:::\ \ /:::/ \:::\ \:::\____\|:::|____| |:::| |/::\ \:::\ \:::\____\ \::/ \:::\ /:::/ / \:::\ \ /:::/ / \:::\ \:::\ \::/ / \/____/ \:::\/:::/ / \:::\ \ /:::/ / \:::\ \:::\ \/____/ \::::::/ / \:::\ /:::/ / \:::\ \:::\ \ \::::/ / \:::\__/:::/ / \:::\ \:::\____\ /:::/ / \::::::::/ / \:::\ /:::/ / /:::/ / \::::::/ / \:::\/:::/ / /:::/ / \::::/ / \::::::/ / /:::/ / \::/____/ \::::/ / \::/ / ~~ \::/ / \/____/ \/____/ ao Operating System aos - 1.8.9 2024 - Type ".exit" to exit aos process: 1xM1_lDZ428sJHpTX7rtcR6SrDubyRVO06JEEWs_eWo ``` Repasemos la impresión inicial después de ejecutar AOS: ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712621331167/613d1dab-2402-45a8-bdda-44c97590c4ef.png align="center") Después de ejecutar AOS en tu terminal, deberías ver: * Una imagen de arte ASCII de AOS. * Un mensaje de bienvenida. * La versión de AOS que estás ejecutando. * Un mensaje instructivo para salir. * Tu ID de proceso.

💡

Si la versión de tu SO es diferente a la última versión, aparecerá un mensaje preguntándote si deseas actualizar la versión. De ser así, simplemente sal del proceso presionando "Ctrl+C" dos veces, ejecuta npm i -g https://get_ao.g8way.io para actualizar, y luego ejecuta aos nuevamente.

¡Bienvenido a tu nuevo hogar en el ordenador AO! El prompt que ahora estás viendo es tu servidor personal en esta máquina descentralizada. Ahora, profundicemos más en la madriguera del conejo explorando uno de los dos conceptos clave de AO: la Mensajería. --- ## Mensajería en `ao` ### Aprende cómo los Mensajes otorgan a `AO` la Capacidad de Cómputo Paralelo En `AO`, cada proceso se ejecuta en paralelo, creando un entorno altamente escalable. Las llamadas directas a funciones entre procesos no son factibles porque cada proceso opera de manera independiente y asincrónica. La mensajería aborda esto al habilitar la comunicación asincrónica. Los procesos envían y reciben mensajes en lugar de invocar directamente funciones entre sí. Este método permite una interacción flexible y eficiente, donde los procesos pueden responder a mensajes, mejorando la escalabilidad y la capacidad de respuesta del sistema. Comenzaremos explorando los fundamentos de la mensajería en `AOS`, cómo ver los mensajes recibidos en tu bandeja de entrada y cómo enviar mensajes a otros procesos. ### Tutorial en Video (Solo en ingles) ### Paso 1: Entender la Estructura del Mensaje * **Fundamentos del Mensaje:** Los mensajes en `AO` se construyen usando tablas Lua, que son estructuras de datos versátiles que pueden contener múltiples valores. Dentro de estas tablas, el campo "Data" es crucial ya que contiene el contenido o carga útil del mensaje. Esta estructura permite el envío y recepción eficiente de información entre procesos, mostrando cómo los primitivos de `AO` aprovechan las capacidades subyacentes de Arweave para facilitar operaciones complejas y componibles. Para especificaciones detalladas, por favor refiérete a la documentación original en la [página de especificaciones de G8way](https://specs.g8way.io/?tx=xwOgX-MmqN5_-Ny_zNu2A8o-PnTGsoRb_3FrtiMAkuw). * **Ejemplo**: `{ Data = "¡Hola desde el Proceso A!" }` es un mensaje simple. ### Paso 2: Abrir la CLI de AOS * Lanza la interfaz de línea de comandos (CLI) de AOS escribiendo `aos` en tu terminal y presionando Enter. ```sh aos ``` ### Paso 3: Cómo Enviar un Mensaje ```sh Send({ Target = "ID del proceso", Data = "Hola Mundo!" }) ``` * **Enviar**: La función `Send` está globalmente disponible en el entorno interactivo de AOS. * **Target**: Para enviar un mensaje a un proceso específico, incluye un campo `Target` en tu mensaje. * **Data**: El `Data` es el mensaje de texto que deseas sea recibido por el proceso receptor. En este ejemplo, el mensaje es "¡Hola Mundo!". ### Paso 4: Almacenar el ID del Proceso de `Morpheus` Usaremos el ID del proceso proporcionado a continuación y lo almacenaremos como una variable llamada Morpheus. ```sh P2RS2VtQ4XtYEvAXYDulEA9pCBCIRpJDcakTR9aW434 ``` Copia el ID del proceso anterior y almacénalo como una variable ejecutando el siguiente comando en la CLI de AOS: ```sh Morpheus = "P2RS2VtQ4XtYEvAXYDulEA9pCBCIRpJDcakTR9aW434" ``` Esto almacenará el ID del proceso como una variable llamada `Morpheus`, facilitando la interacción con el ID de proceso específico.

💡

Al crear la variable Morpheus, la única respuesta que deberías ver es undefined. Esto es esperado. Para verificar si la variable fue creada con éxito, escribe Morpheus y presiona Enter. Deberías ver el ID del proceso que almacenaste.

### Verificar la Variable `Morpheus` ```sh # Verifica la variable Morpheus escribiendo `Morpheus` Morpheus # Resultados Esperados: P2RS2VtQ4XtYEvAXYDulEA9pCBCIRpJDcakTR9aW434 # Si se devuelve `undefined`, # entonces la variable no se creó con éxito. ``` ### Paso 5: Enviar un Mensaje a Morpheus Después de obtener el ID del proceso de Morpheus y almacenarlo en una variable, estás listo para comunicarte con él. Para hacer esto, usas la función Send. Morpheus, él mismo, es un proceso paralelo que se ejecuta en ao. Recibe y envía mensajes usando una serie de Handlers. Enviémosle un mensaje y veamos qué sucede. ```lua Send({ Target = Morpheus, Data = "Morpheus?" }) ``` * Tu `Target` es `Morpheus`, que es la variable que definimos anteriormente usando el ID del proceso de `Morpheus`. * El `Data` es el mensaje que quieres enviar a Morpheus. En este caso, es "Morpheus?". **Resultados Esperados:** ```bash # Tu Comando de Mensaje Send({ Target = Morpheus, Data = "Morpheus?"}) # Mensaje añadido a la bandeja de salida message added to outbox # Se recibe un Nuevo Mensaje del ID del proceso de `Morpheus` New Message From BWM...ulw: Data = I am here. You are f ``` Has enviado un mensaje a Morpheus y recibido una respuesta, pero no puedes leer el mensaje completo. Aprendamos sobre la `Bandeja de Entrada` y cómo leer mensajes. ### Paso 6: La Bandeja de Entrada La `Bandeja de Entrada` es donde recibes mensajes de otros procesos. ::: info Para ver una visión más profunda de un mensaje de la bandeja de entrada, dirígete a la página de Conceptos de [Mensajes](../../concepts/messages). ::: Verifiquemos tu bandeja de entrada para ver cuántos mensajes has recibido. Dentro de tu CLI de aos, escribe el siguiente comando: ```bash #Inbox ``` Si estás siguiendo activamente el tutorial, la bandeja de entrada no tendrá muchos mensajes. Sin embargo, si has estado experimentando con el entorno de aos, puedes tener más de 1 mensaje en tu bandeja de entrada. **Ejemplo de Retorno:** ```bash # Tu Comando de Bandeja de Entrada #Inbox # El comando devolverá el número de mensajes en tu bandeja de entrada. 4 ``` En el ejemplo anterior, el retorno es `4`, indicando que hay cuatro mensajes en la bandeja de entrada. Como estamos buscando activamente la respuesta de `Morpheus`, asumiremos que su mensaje fue el último recibido. Para leer el último mensaje en tu bandeja de entrada, escribe el siguiente comando: ```sh Inbox[#Inbox].Data ``` Este comando te permite aislar el Data del mensaje y solo leer el contenido de los datos. El Retorno Esperado: ```sh # Tu Comando de Bandeja[x].Data Inbox[#Inbox].Data # El comando devolverá el `Data` del mensaje. # Data es lo que usualmente representa el mensaje basado en texto recibido de un proceso a otro. I am here. You are finally awake. Are you ready to see how far the rabbit hole goes? ``` Ahora estás usando tu propio proceso para comunicarte con Morpheus, otro proceso paralelo que se ejecuta en AO. Estás listo para avanzar al siguiente paso en el tutorial. ### Paso 7: Enviar Mensajes con Etiquetas **Propósito de las Etiquetas**: Las etiquetas en los mensajes de AOS se usan para categorizar, dirigir y procesar mensajes de manera eficiente. Juegan un papel crucial en el manejo de mensajes, especialmente cuando se trata de múltiples procesos o flujos de trabajo complejos. Algunos procesos usan `Handlers` que interactúan específicamente con mensajes que tienen ciertas etiquetas. Por ejemplo, un proceso puede tener un manejador que solo interactúa con mensajes que tienen una etiqueta específica, lo cual veremos un ejemplo de en el tutorial de [chatroom](chatroom). #### Cómo Usar Etiquetas en Mensajes En el caso de Morpheus, podemos usar etiquetas para categorizar nuestros mensajes, y dado que Morpheus es un proceso autónomo, tiene manejadores que pueden interactuar con mensajes que tienen ciertas etiquetas. ##### **Añadiendo Etiquetas a un Mensaje**: * Ya sabemos que el `Data` de un mensaje es el mensaje basado en texto que quieres enviar a otro proceso. Anteriormente, enviamos un mensaje a Morpheus sin ninguna etiqueta, en el cual él usó un manejador para responder a un data que coincidía exactamente. #### Demostremos a Morpheus Que Estamos Listos Envía a Morpheus un mensaje con la etiqueta `Action` y el valor `rabbithole`. **Ejemplo:** ```lua Send({ Target = Morpheus, Data = "Code: rabbithole", Action = "Unlock" }) ``` **Resultados Esperados:** ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712848698893/5c13de6c-8f1a-4206-84bd-65f5ab6f4e06.png align="center") ### Consejos Adicionales para Usar Etiquetas * **Etiquetado Consistente**: Desarrolla un sistema de etiquetado consistente para tu aplicación para hacer el manejo de mensajes más predecible. * **Nombramiento de Etiquetas**: Elige nombres claros y descriptivos para tus etiquetas. Esto facilita entender el propósito y contexto de los mensajes a primera vista. * **Seguridad con Etiquetas**: Recuerda que las etiquetas no están encriptadas ni ocultas, así que evita usar información sensible como etiquetas. ### Uso Avanzado de Etiquetas * **Gestión de Flujos de Trabajo**: Las etiquetas pueden ser instrumentales en la gestión de flujos de trabajo, especialmente en sistemas donde los mensajes pasan por múltiples etapas o procesos. ### Consejos Adicionales para la Mensajería * **Estructura del Mensaje**: Explora otros campos como `Epoch`, `From` y `Nonce` para necesidades de mensajería más complejas. * **Depuración**: Usa la función [`Dump`](/concepts/tour.html#_6-data-representation-with-dump) para imprimir mensajes para depuración. * **Consideraciones de Seguridad**: Ten cuidado con el contenido y manejo de los mensajes, y nunca envíes nada considerado privado o sensible. ### Conclusión Ahora has aprendido cómo enviar mensajes con etiquetas, lo cual es una herramienta poderosa para categorizar y dirigir mensajes en AOS. Morpheus te ha invitado oficialmente a la siguiente etapa de tu viaje. Estás listo para avanzar al siguiente paso en el tutorial, [Creando un Chatroom](chatroom). --- ## Crear una Sala de Chat Mis disculpas por eso, aquí tienes la traducción corregida sin modificar el contenido dentro de los bloques de código: ### Construyendo un Chatroom en aos

💡

Si has encontrado el deseo de aprender cómo crear un chatroom dentro de ao, eso significa que entendemos al menos la metodología básica de enviar y recibir mensajes. Si no, se sugiere que revises el tutorial de Mensajería antes de continuar.

En este tutorial, estaremos construyendo un chatroom dentro de `AO` utilizando el lenguaje de scripting Lua. El chatroom contará con dos funciones principales: 1. **Registrar**: Permite que los procesos se unan al chatroom. 2. **Transmitir**: Envía mensajes de un proceso a todos los participantes registrados. Comencemos estableciendo la base para nuestro chatroom. ### Tutorial en Video (Solo en Ingles) ### Paso 1: La Base * Abre tu editor de código preferido.

💡

Puede que encuentres útil tener las Extensiones Recomendadas instaladas en tu editor de código para mejorar tu experiencia de scripting en Lua.

* Crea un nuevo archivo nombrado `chatroom.lua`. ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712848801698/c6968562-d364-4a17-9d73-bd1bc379d6ba.png align="center") ### Paso 2: Creando La Lista de Miembros * En `chatroom.lua`, comenzarás inicializando una lista para rastrear a los participantes: ```lua Members = Members or {} ``` ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712848839201/e568daeb-f2e1-4c2c-a82b-64dac7ae0cfb.png align="center") * Guarda el archivo `chatroom.lua` ### Paso 3: Cargar el Chatroom en aos Con `chatroom.lua` guardado, ahora cargarás el chatroom en `AOS`. * Si aún no lo has hecho, inicia tu `AOS` en tu terminal dentro del directorio donde se guarda chatroom.lua * En la CLI de `AOS`, escribe el siguiente script para incorporar tu script en el proceso `AOS`: ```lua .load chatroom.lua ``` ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712848863034/7b0ad11c-0f14-4030-9c40-6766d4594488.png align="center") Como muestra la captura de pantalla anterior, puedes recibir `undefined` como respuesta. Esto es esperado, pero aún queremos asegurarnos de que el archivo se cargó correctamente. ::: info En el entorno de evaluación Lua de AOS, cuando ejecutas un fragmento de código que no devuelve explícitamente un valor, `undefined` es una respuesta estándar, indicando que no se devolvió ningún resultado. Esto se puede observar al cargar recursos o ejecutar operaciones. Por ejemplo, ejecutar `X = 1` producirá `undefined` porque la declaración no incluye una sentencia de retorno. Sin embargo, si ejecutas `X = 1; return X`, el entorno devolverá el valor `1`. Este comportamiento es esencial para entender cuando trabajas dentro de este marco, ya que ayuda a aclarar la distinción entre ejecutar comandos que modifican el estado frente a aquellos destinados a producir una salida directa. ::: * Escribe `Members`, o como hayas nombrado tu lista de usuarios, en `AOS`. Debería devolver un array vacío `{ }`. ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712848890030/fe12bb35-3d75-4288-a38e-95d43f714882.png align="center") Si ves un array vacío, entonces tu script ha sido cargado con éxito en `AOS`. ### Paso 4: Creando Funcionalidades del Chatroom #### El Manejador de Registro El manejador de registro permitirá que los procesos se unan al chatroom. 1. **Añadiendo un Manejador de Registro:** Modifica `chatroom.lua` para incluir un manejador para que `Members` se registren en el chatroom con el siguiente código: ```lua Handlers.add( "Register", Handlers.utils.hasMatchingTag("Action", "Register"), function (msg) table.insert(Members, msg.From) Handlers.utils.reply("registered")(msg) end ) ``` ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712848915684/8dd809fc-2e72-4c13-b0f3-0ceabb3a50fd.png align="center") Este manejador permitirá que los procesos se registren en el chatroom respondiendo a la etiqueta `Action = "Register"`. Un mensaje impreso confirmará diciendo `registered` aparecerá cuando el registro sea exitoso. 2. **Recargar y Probar:** Vamos a recargar y probar el script registrándonos en el chatroom. * Guarda y recarga el script en AOS usando `.load chatroom.lua`. * Verifica si el manejador de registro se cargó con el siguiente script: ```lua Handlers.list ``` ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712848932349/9a19db91-7d4d-43c2-bef8-baec84e3677e.png align="center") Esto devolverá una lista de todos los manejadores en el chatroom. Dado que esta es probablemente tu primera vez desarrollando en `AOS`, solo deberías ver un manejador con el nombre `Register`. * Probemos el proceso de registro registrándonos en el chatroom: ```lua Send({ Target = ao.id, Action = "Register" }) ``` Si es exitoso, deberías ver que había un `mensaje añadido a tu bandeja de salida` y que luego ves un nuevo mensaje impreso que dice `registrado`. ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712848950711/6dac38f9-0795-48a0-bbf7-eae9c5a4424a.png align="center") * Finalmente, verifiquemos si fuimos agregados exitosamente a la lista de `Members`: ```lua Members ``` Si es exitoso, ahora verás tu ID de proceso en la lista de `Members`. ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712848961803/85f22f27-e5cd-4e7a-94d2-5d2b096c9fc5.png align="center") #### Añadiendo un Manejador de Transmisión Ahora que tienes un chatroom, creemos un manejador que te permita transmitir mensajes a todos los miembros del chatroom. * Añade el siguiente manejador al archivo `chatroom.lua`: ```lua Handlers.add( "Broadcast", Handlers.utils.hasMatchingTag("Action", "Broadcast"), function (msg) for _, recipient in ipairs(Members) do ao.send({Target = recipient, Data = msg.Data}) end Handlers.utils.reply("Broadcasted.")(msg) end ) ``` Este manejador te permitirá transmitir mensajes a todos los miembros del chatroom. * Guarda y recarga el script en AOS usando `.load chatroom.lua`. * Probemos el manejador de transmisión enviando un mensaje al chatroom: ```lua Send({Target = ao.id, Action = "Broadcast", Data = "Broadcasting My 1st Message" }) ``` * Si es exitoso, deberías ver que había un `mensaje añadido a tu bandeja de salida` y que luego ves un nuevo mensaje impreso que dice `Broadcasting My 1st Message` porque también eres un destinatario de este mensaje ya que eres miembro del chatroom `Members`. ### Paso 5: Invitando a Morpheus al Chatroom Ahora que te has registrado con éxito en el chatroom, invitemos a Morpheus a unirse a nosotros. Para hacer esto, le enviaremos una invitación que le permitirá registrarse en el chatroom. Morpheus es un agente autónomo con un manejador que responderá a la etiqueta `Action = "Join"`, en la cual luego usará tu etiqueta `Register` para registrarse en el chatroom. * Enviemos a Morpheus una invitación para unirse al chatroom: ```lua Send({ Target = Morpheus, Action = "Join" }) ``` * Para confirmar que Morpheus se ha unido al chatroom, verifica la lista de `Members`: ```lua Members ``` Si es exitoso, recibirás un mensaje difundido de Morpheus. ### Paso 6: Invitando a Trinity al Chatroom Dentro de este mensaje, él te dará el ID del proceso de Trinity y te dirá que la invites al chatroom. Usa los mismos procesos para guardar su ID del proceso como `Trinity` y para invitarla al chatroom como hiciste con Morpheus. Si ella se une con éxito al chatroom, entonces planteará el siguiente desafío para ti, creando un [token](token). ### Involucrando a Otros en el Chatroom #### Incorporando a Otros * Invita a Usuarios de AOS: Anima a otros usuarios de AOS a unirse a tu chatroom. Pueden registrarse y participar en la transmisión. * Proporciona Instrucciones de Incorporación: Comparte un script simple con ellos para una incorporación fácil: ```lua -- ¡Hey, vamos a chatear en aos! Únete a mi chatroom enviando este comando en tu entorno aos: Send({ Target = [Tu ID de Proceso], Action = "Register" }) -- Luego, puedes transmitir mensajes usando: Send({Target = [Tu ID de Proceso], Action = "Broadcast", Data = "Tu Mensaje" }) ``` ### Próximos Pasos ¡Felicidades! Has construido con éxito un chatroom en `AO` e has invitado a Morpheus a unirte. También has creado un manejador de transmisión para enviar mensajes a todos los miembros del chatroom. A continuación, continuarás interactuando con Morpheus, pero esta vez agregarás a Trinity a la conversación. Ella te guiará a través del próximo conjunto de desafíos. ¡Buena suerte! --- ## Crear un Token ::: info Profundizando en `AO`, ahora estás listo para crear tu propio token, un símbolo de valor e intercambio dentro de este medio descentralizado. Si tienes ganas de aprender cómo crear un token, pero no has visitado las lecciones de [Mensajería](messaging) y [Construir un Chatroom](chatroom), asegúrate de hacerlo ya que esta página es parte de un tutorial interactivo de varias partes. ::: Al crear tokens, continuaremos usando el [Lenguaje Lua](../../references/lua.md) dentro de `AO` para acuñar un token, guiados por los principios descritos en la [Especificación de Token](../../references/token.md). ### Continuando por la Madriguera del Conejo En nuestro último tutorial, [Construir un Chatroom](chatroom), aprendimos cómo crear un chatroom dentro de `AO`, invitamos a `Morpheus` y a `Trinity` al chatroom que creamos, y luego `Trinity` nos ha pedido que creemos un token para ella como una forma de demostrar que somos dignos de continuar por la madriguera del conejo. **Comencemos.** ### Los Dos Caminos para Construir un Token Hay dos caminos a seguir cuando construyes un token: 1. **El Plano**: Este es una plantilla prediseñada que te ayuda a construir rápidamente un token en `AO`. Es una excelente manera de comenzar y se puede personalizar para satisfacer tus necesidades. Consulta aquí para aprender más sobre el [Plano de Token](../../guides/aos/blueprints/token.md). 2. **El Método Manual**: Esta es una guía paso a paso para construir un token en `AO` desde cero. Este camino es para aquellos que quieren entender los mecanismos internos de un token y cómo construir uno desde el principio. Consulta aquí para revisar la guía completa [Construir un Token](../../guides/aos/token.md). ### El Método del Plano Para este tutorial, utilizaremos el Plano de Token para crear un token para `Trinity`. Este es una plantilla prediseñada que te ayuda a construir rápidamente un token en `AO`. #### Cómo Usar el Plano de Token 1. Asegúrate de estar en el mismo directorio que antes durante los pasos anteriores del tutorial. 2. Abre el Terminal. 3. Inicia tu proceso `AOS`. 4. Escribe `.load-blueprint token` Esto cargará los manejadores requeridos para el token del tutorial dentro de `AO`. Es importante notar que el plano del token no es específico de este tutorial y se puede usar como una base para cualquier token que desees crear. #### Verificar que el Plano Está Cargado Escribe `Handlers.list` para ver los nuevos manejadores cargados. Deberías ver una nueva lista de manejadores que han sido cargados en tu proceso `AOS`. Si has seguido los pasos anteriores del tutorial, también deberías ver los manejadores de tu chatroom. **Ejemplo:** ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1712849218971/5362c1ab-361c-40ff-9783-95a30deff7b4.png align="center") #### Probando el Token Ahora que el plano del token está cargado, podemos probar el token enviando un mensaje a nosotros mismos usando la etiqueta `Action = "Info"`. ```sh Send({ Target = ao.id, Action = "Info" }) ``` Esto imprimirá un mensaje en la consola, pero para leer el mensaje, necesitaremos llamar a `.Data` del último mensaje. ```bash Inbox[#Inbox].Data # Reemplaza #Inbox con el numero del ultimo mensaje recibido. ``` Esto imprimirá la información del token en la consola. Debería mostrar tu ID de proceso con el saldo total de tokens disponibles. #### Enviando Tokens a Trinity Ahora que hemos probado el token y está funcionando como se esperaba, podemos enviar algunos tokens a `Trinity`. Enviaremos 1000 tokens a `Trinity` usando la etiqueta `Action = "Transfer"`. ```sh Send({ Target = ao.id, Action = "Transfer", Recipient = Trinity, Quantity = "1000"}) ``` Cuando `Trinity` reciba los tokens, responderá a la transferencia con un mensaje para confirmar que ha recibido los tokens. Su respuesta se verá algo así: `Trinity:` "Token recibido. Interesante. No estaba segura de que llegarías tan lejos. Estoy impresionada, pero aún no hemos terminado. Quiero que uses este token para tokengatear el chatroom. Haz eso, y entonces creeré que podrías ser el elegido." Has completado el proceso de crear un token y enviarlo a `Trinity`. Ahora estás listo para avanzar al siguiente paso en el tutorial. Tokengateando el Chatroom. --- ## Tokengateando el Chatroom ::: info Ahora que hemos creado un token y lo hemos enviado a `Trinity`, podemos usar el token para tokengatear nuestro chatroom. Esto permitirá que solo aquellos que tengan el token puedan entrar al chatroom. ::: ### Cómo Tokengatear el Chatroom Creemos un manejador que nos permita tokengatear el chatroom. Este manejador responderá a la etiqueta `Action = "Broadcast"`, lo que significa que reemplazará el manejador original `Broadcast` que construimos para nuestro chatroom. ### Paso 1: Inicia el mismo proceso `AOS`. Asegúrate de estar utilizando el mismo proceso `AOS` que has usado a lo largo del tutorial. ### Paso 2: Abre el archivo `chatroom.lua`. Este es el mismo archivo que usamos para crear el chatroom durante el tutorial de [chatroom](chatroom). ### Paso 3: Edita tu manejador `Broadcast`. Reemplaza el manejador `Broadcast` original con el siguiente código: ```lua Handlers.add( "Broadcast", Handlers.utils.hasMatchingTag("Action", "Broadcast"), function(m) if Balances[m.From] == nil or tonumber(Balances[m.From]) < 1 then print("UNAUTH REQ: " .. m.From) return end local type = m.Type or "Normal" print("Broadcasting message from " .. m.From .. ". Content: " .. m.Data) for i = 1, #Members, 1 do ao.send({ Target = Members[i], Action = "Broadcasted", Broadcaster = m.From, Data = m.Data }) end end ) ``` Este manejador ahora verificará el saldo del token del remitente antes de difundir el mensaje al chatroom. Si el remitente no tiene un token, el mensaje no será difundido. Guarda el archivo. ### Paso 4: Recarga el archivo `chatroom.lua`. Para reemplazar el manejador `broadcast` original con el nuevo, necesitarás recargar el archivo `chatroom.lua`. ```sh .load chatroom.lua ``` ### Paso 5: Prueba el Tokengate Ahora que el chatroom está tokengateado, probémoslo enviando un mensaje al chatroom. #### Desde el proceso aos original Primero, lo probaremos desde el proceso AOS original. ```sh Send({ Target = ao.id , Action = "Broadcast", Data = "Hello" }) # Resultados esperados: message added to outbox Broadcasting message from Neo. Content: Hello. ``` ### Probando desde otro ID de Proceso. #### Desde un nuevo proceso AOS Ahora, probémoslo desde un nuevo proceso AOS que no tenga un token. ```sh aos chatroom-no-token # `chatroom-no-token` es el nuevo nombre del proceso ``` Primero necesitaremos registrarnos en el chatroom. ```sh .load chatroom.lua Send({ Target = [Tu ID de Proceso], Action = "Register" }) # Resultados esperados: message added to outbox New Message From [Tu ID de Proceso]: Data = registered ``` Ahora, intentemos enviar un mensaje al chatroom. ```sh Send({ Target = [Tu ID de Proceso] , Action = "Broadcast", Data = "Hello?" }) # Resultados esperados: message added to outbox UNAUTH REQ: [Nuevo ID de Proceso] ``` Como puedes ver, el mensaje no fue difundido porque el nuevo proceso no tiene un token. ### Dile a Trinity "Se ha hecho" Desde el proceso AOS original, envía un mensaje difundido al chatroom diciendo, "Se ha hecho". ```lua Send({ Target = ao.id , Action = "Broadcast", Data = "Se ha hecho" }) ``` ::: warning Es importante ser consciente de la coincidencia exacta de datos y la sensibilidad a mayúsculas y minúsculas. Si no recibes una respuesta de Morpheus o Trinity, asegúrate de verificar el contenido de tus Datos y Etiquetas. ::: Trinity responderá entonces al chatroom siendo tokengateado. #### Resultados Esperados: Trinity enviará un mensaje diciendo: "Supongo que Morpheus tenía razón. Eres el elegido. Considerame impresionada. Ahora estás listo para unirte al Construct, un chatroom exclusivo disponible solo para aquellos que han completado este tutorial. Ahora, únete a los demás usando la misma etiqueta que usaste \`Register \`, con este ID de proceso: \[ID de Proceso del Construct\] Buena suerte. -Trinity". Además, seguirá un pie de página al mensaje. ::: warning Lee cuidadosamente el pie de página en el mensaje de Trinity para descubrir cómo presentar tu reclamo y recibir tu CRED. ::: ### Conclusión ¡Lo has hecho! Has tokengateado con éxito el chatroom. Esto ha desbloqueado ahora el acceso al `Construct`, donde solo aquellos que han completado completamente este tutorial pueden entrar. #### ¡Felicidades! Has demostrado un gran potencial. Espero que hayas disfrutado este tutorial. Ahora estás listo para construir libremente en `AO`. Si quieres aprender más sobre `AO + AOS`, entonces dirígete a la documentación en [https://cookbook\_ao.arweave.dev](https://cookbook_ao.arweave.dev). Hasta la próxima, nos vemos en la Máquina.