Search for a command to run...
As a former Paratrooper Medic and Mass Casualty Coordinator, I made the leap into software engineering. Through my journey, I've continued to grow and learn, and I'm eager to share my knowledge with others. As a self-taught software engineer, I'm passionate about empowering others to pursue their dreams and learn new skills.
No comments yet. Be the first to comment.
A Comprehensive Technical Guide
Weighing Performance vs Build Time
I Had a hell of a time getting my Supabase MCP Server working. I figured that, because I went through the ringer on figuring out how to fix it, that I would share with you all that are probably googling how to get it fixed a guide to do just that. I...
This tutorial walks through the process of using the ArDrive Turbo CLI to top up your account with ARIO tokens. It's an extremely simple process and makes it very easy to manage your Turbo Credit balance without ever leaving your terminal or your IDE...
Plan DevRel Strategies the Army Ranger Way
On this page
En este tutorial, recorrerá pasos interactivos que le ayudarán a profundizar su conocimiento y comprensión del entorno de AOS.
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".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.
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
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.
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.
aoAO la Capacidad de Cómputo ParaleloEn 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.
(Solo en ingles)
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.
aos en tu terminal y presionando Enter.aos
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!".
MorpheusUsaremos 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.
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.Morpheus# Verifica la variable Morpheus escribiendo `Morpheus`
Morpheus
# Resultados Esperados:
P2RS2VtQ4XtYEvAXYDulEA9pCBCIRpJDcakTR9aW434
# Si se devuelve `undefined`,
# entonces
la variable no se creó con éxito.
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.
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.
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.
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.
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.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:
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.
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.
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.
Mis disculpas por eso, aquí tienes la traducción corregida sin modificar el contenido dentro de los bloques de código:
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:
Registrar: Permite que los procesos se unan al chatroom.
Transmitir: Envía mensajes de un proceso a todos los participantes registrados.
Comencemos estableciendo la base para nuestro chatroom.
(Solo en Ingles)
chatroom.lua.
chatroom.lua, comenzarás inicializando una lista para rastrear a los participantes:Members = Members or {}
chatroom.luaCon 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. :::
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.
El manejador de registro permitirá que los procesos se unan al chatroom.
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.
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.
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.
Members:Members
Si es exitoso, ahora verás tu ID de proceso en la lista de Members.
Ahora que tienes un chatroom, creemos un manejador que te permita transmitir mensajes a todos los miembros del chatroom.
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" })
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.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.
Send({ Target = Morpheus, Action = "Join" })
Members:Members
Si es exitoso, recibirás un mensaje difundido de Morpheus.
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.
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" })
¡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!
::: 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.
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.
Hay dos caminos a seguir cuando construyes un token:
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.
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.
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.
Asegúrate de estar en el mismo directorio que antes durante los pasos anteriores del tutorial.
Abre el Terminal.
Inicia tu proceso AOS.
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.
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:
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.
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.
::: 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. :::
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.
AOS.Asegúrate de estar utilizando el mismo proceso AOS que has usado a lo largo del tutorial.
chatroom.lua.Este es el mismo archivo que usamos para crear el chatroom durante el tutorial de chatroom.
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.
chatroom.lua.Para reemplazar el manejador broadcast original con el nuevo, necesitarás recargar el archivo chatroom.lua.
.load chatroom.lua
Ahora que el chatroom está tokengateado, probémoslo enviando un mensaje al chatroom.
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.
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.
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.
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. :::
¡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.
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.