En este tutorial, recorrerá pasos interactivos que le ayudarán a profundizar su conocimiento y comprensión del entorno de AOS.

Preparativos

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 para encontrar instrucciones para tu sistema operativo).

• Un editor de código de tu elección.

Instalando AOS

Una vez que tengas NodeJS en tu máquina, todo lo que necesitas hacer es instalar AOS y ejecutarlo:

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!

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:

_____                   _______                   _____
         /\    \                 /::\    \                 /\    \
        /::\    \               /::::\    \               /::\    \
       /::::\    \             /::::::\    \             /::::\    \
      /::::::\    \           /::::::::\    \           /::::::\    \
     /:::/\:::\    \         /:::/~~\:::\    \         /:::/\:::\    \
    /:::/__\:::\    \       /:::/    \:::\    \       /:::/__\:::\    \
   /::::\   \:::\    \     /:::/    / \:::\    \      \:::\   \:::\    \
  /::::::\   \:::\    \   /:::/____/   \:::\____\   ___\:::\   \:::\    \
 /:::/\:::\   \:::\    \ |:::|    |     |:::|    | /\   \:::\   \:::\    \
/:::/  \:::\   \:::\____\|:::|____|     |:::|    |/::\   \:::\   \:::\____\
\::/    \:::\  /:::/    / \:::\    \   /:::/    / \:::\   \:::\   \::/    /
 \/____/ \:::\/:::/    /   \:::\    \ /:::/    /   \:::\   \:::\   \/____/
          \::::::/    /     \:::\    /:::/    /     \:::\   \:::\    \
           \::::/    /       \:::\__/:::/    /       \:::\   \:::\____\
           /:::/    /         \::::::::/    /         \:::\  /:::/    /
          /:::/    /           \::::::/    /           \:::\/:::/    /
         /:::/    /             \::::/    /             \::::::/    /
        /:::/    /               \::/____/               \::::/    /
        \::/    /                 ~~                      \::/    /
         \/____/                                           \/____/

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:

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.

¡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.

• 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.

aos

Paso 3: Cómo Enviar un Mensaje

  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.

P2RS2VtQ4XtYEvAXYDulEA9pCBCIRpJDcakTR9aW434

Copia el ID del proceso anterior y almacénalo como una variable ejecutando el siguiente comando en la CLI de AOS:

Morpheus = "P2RS2VtQ4XtYEvAXYDulEA9pCBCIRpJDcakTR9aW434"

Esto almacenará el ID del proceso como una variable llamada Morpheus, facilitando la interacción con el ID de proceso específico.

Verificar la Variable Morpheus

# 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.

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:

# 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. :::

Verifiquemos tu bandeja de entrada para ver cuántos mensajes has recibido.

Dentro de tu CLI de aos, escribe el siguiente comando:

#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:

# 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:

 Inbox[#Inbox].Data

Este comando te permite aislar el Data del mensaje y solo leer el contenido de los datos.

El Retorno Esperado:

# 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.

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:

Send({ Target = Morpheus, Data = "Code: rabbithole", Action = "Unlock" })

Resultados Esperados:

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 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.

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

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.

• Crea un nuevo archivo nombrado chatroom.lua.

Paso 2: Creando La Lista de Miembros

• En chatroom.lua, comenzarás inicializando una lista para rastrear a los participantes:

Members = Members or {}

• 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:

.load chatroom.lua

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 { }.

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:

Handlers.add(
  "Register",
  Handlers.utils.hasMatchingTag("Action", "Register"),
  function (msg)
    table.insert(Members, msg.From)
    Handlers.utils.reply("registered")(msg)
  end
)

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:

Handlers.list

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:

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.

• Finalmente, verifiquemos si fuimos agregados exitosamente a la lista de Members:

Members

Si es exitoso, ahora verás tu ID de proceso en la lista de Members.

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:

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:

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:

Send({ Target = Morpheus, Action = "Join" })

• Para confirmar que Morpheus se ha unido al chatroom, verifica la lista de Members:

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.

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:

-- ¡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 y Construir un 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 dentro de AO para acuñar un token, guiados por los principios descritos en la Especificación de Token.

Continuando por la Madriguera del Conejo

En nuestro último tutorial, Construir un 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.

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.

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:

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".

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.

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".

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.

Paso 3: Edita tu manejador Broadcast.

Reemplaza el manejador Broadcast original con el siguiente código:

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.

.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.

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.

aos chatroom-no-token # `chatroom-no-token` es el nuevo nombre del proceso

Primero necesitaremos registrarnos en el chatroom.

.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.

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".

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.

Hasta la próxima, nos vemos en la Máquina.