Indexador

El indexador de Adrift es un servicio especializado que:

• Indexa eventos en cadena del appchain de Adrift y cadenas subyacentes.
• Agrega y expone el estado del juego (jugadores, registros, ganadores, etc.) a través de una API amigable para desarrolladores.
• Lee de los contratos y eventos de la cadena del secuenciador de Syndicate para potenciar mecánicas de juego justas, verificables y resistentes a manipulaciones.

Arquitectura

+-------------------------------------------------------------------------------------+
|                                    Adrift Frontend                                  |
+-------------------------------------------------------------------------------------+
+-------------------------------------------------------------------------------------+
|                                      Indexer/API                                    |
+-------------------------------------------------------------------------------------+
+-------------------------------------------------------------------------------------+
|                                  Adrift Smart Contracts                             |
|                                     (Pacifica chain)                                |
+-------------------------------------------------------------------------------------+
+-----------------------------------------+ +-----------------------------------------+
|       Syndicate Sequencing Chain        | |          Randomness Providers           |
|             (Risa Testnet)              | |          (Lit, drand, local)            |
+-----------------------------------------+ +-----------------------------------------+

• Indexación de eventos: Utiliza Ponder para escuchar eventos de contratos inteligentes en el appchain de Adrift (Pacifica) y la cadena del secuenciador subyacente (Risa Testnet).
• Base de datos: Almacena datos indexados en una base de datos Postgres.
• Capa de API: Expone endpoints REST (usando Hono) para que la aplicación Adrift y otros clientes consulten el estado del juego y activen acciones.
• Integración de aleatoriedad: Aprovecha Lit Protocol y drand para inyectar aleatoriedad verificable en el secuenciador, impulsando eventos del juego.

Contratos clave indexados

• AdriftFactory

  // ponder.config.ts
  contracts: {
    AdriftFactory: {
      chain: "pacifica",
      abi: AdriftFactoryAbi,
      address: env.FACTORY_ADDRESS,
      startBlock: env.START_BLOCK
    },
    // ...
  }
  
  // src/index.ts
  ponder.on("AdriftFactory:AdriftCreated", async ({ event, context }) => {
    // Handles new game creation
  })

  Indexa la fábrica para detectar y comenzar a rastrear nuevos juegos a medida que se crean.

• Adrift

  // ponder.config.ts
  Adrift: {
    chain: "pacifica",
    abi: AdriftAbi,
    address: factory({
      address: env.FACTORY_ADDRESS,
      event: parseAbiItem("event AdriftCreated(address indexed gameAddress, ...)") ,
      parameter: "gameAddress"
    }),
    startBlock: env.START_BLOCK
  }
  
  // src/index.ts
  ponder.on("Adrift:PlayerRegistered", ...)
  ponder.on("Adrift:PlayerCheckedIn", ...)
  ponder.on("Adrift:GameStartTimeSet", ...)
  ponder.on("Adrift:GameEnded", ...)

  Indexa todos los eventos del juego para cada contrato Adrift implementado.

• AdriftBundler

  // ponder.config.ts
  AdriftBundler: {
    chain: "risa",
    abi: AdriftBundlerAbi,
    address: env.BUNDLER_ADDRESS,
    startBlock: "latest"
  }
  // src/index.ts

  Indexa el mempool del secuenciador y eventos de aleatoriedad en la cadena Risa.

Modelo de datos

• Game: Rastrea el estado del juego, tiempos de inicio/fin, ganador, etc.
• Player: Direcciones de jugadores registrados.
• GamePlayer: Relaciones jugador-juego, estado de registro, descalificación, etc.
• Checkins: Eventos individuales de registro, mejoras/penalizaciones, marcas de tiempo.

Cómo la aplicación Adrift utiliza el indexador

El frontend de Adrift interactúa con la API del indexador para:

• Unirse al juego: Llama a /join para registrar un jugador en la cadena.
• Obtener el estado del jugador: Llama a /player/:address para obtener el estado de registro, próximo tiempo de registro, descalificación, etc.
• Tabla de clasificación: Llama a /leaderboard para obtener los mejores jugadores y el estado del juego.
• Latido: Llama a /heartbeat para automatizar la descalificación y detección del ganador.

Todo el estado del juego mostrado en la interfaz de usuario está alimentado por la API del indexador, que se mantiene sincronizada con la cadena mediante Ponder.

Referencia de la API

POST /join

• Registra a un jugador para el juego actual.
• Cuerpo: { playerAddress: string }
• Devuelve: { success: boolean, hash: string }

GET /player/:address

• Obtiene el estado del jugador, registros de entrada y estado.
• Devuelve: { data: { ...playerState } }

GET /leaderboard

• Obtiene los mejores jugadores y el estado del juego.
• Devuelve: { data: { topPlayers: [...], ...gameState } }

GET /heartbeat

• Activa la descalificación de jugadores inactivos y la detección del ganador.
• Devuelve: { data: { action: string, ... } }

Más información

• Documentación de Ponder
• Protocolo Lit
• drand

Esta guía debería ayudarte a entender, ejecutar y extender el indexador Adrift, y aprovechar el diseño del secuenciador de Syndicate para tus propios proyectos.