blockchaindistributed-systems30 de junio de 2025schedule8 min de lectura

El Stack Off-Chain que tu Protocolo DeFi No Puede Ignorar

Los smart contracts gestionan las reglas. Todo lo demás — keepers de liquidación, relayers de precios, indexadores, monitoreo — vive off-chain. Aquí está la infraestructura de producción que hace que los protocolos DeFi realmente funcionen, construida con los mismos patrones de sistemas distribuidos de cualquier backend de alta fiabilidad.

Eliecer Sánchez
Eliecer Sánchez

Chief Architect

Diagrama de infraestructura Web3 backend distribuida

Todo protocolo DeFi tiene un secreto a voces: el smart contract es la parte más pequeña del sistema.

El código Solidity o Rust que vive on-chain gestiona los invariantes — qué está permitido, qué no, qué cambios de estado son válidos. Pero un protocolo de préstamos que no liquida posiciones subcapitalizadas a tiempo, un AMM que no puede actualizar sus price feeds bajo congestión, o un bridge que silenciosamente pierde eventos durante un reorg — ninguno de estos falla a nivel de smart contract. Fallan en la infraestructura off-chain que la mayoría de equipos construye como una ocurrencia tardía.

Este artículo trata sobre esa infraestructura: keeper bots, indexadores on-chain, pipelines de event listeners, y los patrones operacionales que separan los protocolos que sobreviven bajo estrés de los que no.

Qué Significa “Off-Chain” en la Práctica

La EVM (y Solana, y cualquier otra plataforma de smart contracts) es una máquina de estados. Transiciona estados de forma determinista en respuesta a transacciones. Pero una máquina de estados no puede iniciar nada — solo responde a inputs. Alguien o algo tiene que enviar esas transacciones.

La infraestructura off-chain es el conjunto de servicios que:

  1. Observan el estado de la cadena en busca de condiciones que requieran acción
  2. Calculan qué acción tomar (y cuándo)
  3. Envían transacciones que disparan la lógica on-chain
  4. Indexan eventos on-chain para que tu aplicación pueda consultar el historial sin re-escanear la cadena

Para un protocolo de préstamos típico, esto implica:

  • Un keeper de liquidación que monitorea health factors y envía transacciones de liquidación cuando las posiciones se subcapitalizan
  • Un relayer de price feeds que empuja actualizaciones de oracle on-chain antes de que caduquen
  • Un indexador de eventos que rastrea depósitos, préstamos, repagos y liquidaciones para el frontend y analytics
  • Una capa de monitoreo que alerta sobre reorgs, eventos perdidos y fallos del keeper

Falla cualquiera de estos y el protocolo se rompe — no lentamente, sino de maneras que cuestan dinero real a los usuarios.

Construyendo un Keeper de Liquidación con Elixir

Un keeper de liquidación es un gran ejemplo porque los requisitos parecen simples pero las restricciones de producción son brutales. Necesitas:

  • Sondear o suscribirte al estado de la cadena de forma continua
  • Calcular health factors para miles de posiciones
  • Enviar transacciones de liquidación con precios de gas competitivos durante picos
  • Manejar reorgs sin doble envío ni posiciones perdidas
  • Recuperarte de fallos de RPC sin perder posiciones

Este es un problema OTP de manual. Cada posición bajo monitoreo puede ser un proceso supervisado. La detección de reorgs es un GenServer que rastrea el último bloque finalizado. El pipeline de envío es un consumidor Broadway con backpressure.

defmodule Keeper.PositionMonitor do
  use GenServer

  @check_interval 12_000  # un bloque ETH

  def start_link(position_id) do
    GenServer.start_link(__MODULE__, position_id,
      name: {:via, Registry, {Keeper.Registry, {:position, position_id}}}
    )
  end

  def init(position_id) do
    schedule_check()
    {:ok, %{position_id: position_id, last_health: nil}}
  end

  def handle_info(:check, %{position_id: id} = state) do
    with {:ok, health_factor} <- Keeper.Chain.get_health_factor(id),
         true <- health_factor < Decimal.new("1.0") do
      Keeper.LiquidationQueue.enqueue(id, health_factor)
    end

    schedule_check()
    {:noreply, %{state | last_health: health_factor}}
  end

  defp schedule_check, do: Process.send_after(self(), :check, @check_interval)
end

Cada posición corre como un proceso supervisado independiente. Si uno falla — mala respuesta de RPC, nil inesperado en el cálculo del health factor — el supervisor lo reinicia. El resto de posiciones continúa sin verse afectado.

La cola de liquidación alimenta un pipeline Broadway que maneja el envío real de transacciones:

defmodule Keeper.LiquidationPipeline do
  use Broadway

  def start_link(_opts) do
    Broadway.start_link(__MODULE__,
      name: __MODULE__,
      producer: [
        module: {Broadway.DummyProducer, []},
        concurrency: 1
      ],
      processors: [
        default: [concurrency: 5]  # 5 intentos de liquidación en paralelo
      ]
    )
  end

  def handle_message(_, %{data: {position_id, health_factor}} = msg, _) do
    case Keeper.Executor.liquidate(position_id) do
      {:ok, tx_hash} ->
        Logger.info("Liquidado #{position_id}: #{tx_hash}")
        msg

      {:error, :already_liquidated} ->
        # Perdimos la carrera — otro keeper llegó primero
        Broadway.Message.failed(msg, :race_condition)

      {:error, reason} ->
        Broadway.Message.failed(msg, reason)
    end
  end
end

El concurrency: 5 en processors significa que podemos intentar cinco liquidaciones simultáneamente — importante cuando una caída del mercado crea cientos de posiciones liquidables a la vez. El modelo de backpressure de Broadway también evita que saturemos a nuestro proveedor RPC con solicitudes.

Manejo de Reorgs: La Parte que Todos se Saltan

Un reorg de Ethereum ocurre cuando la red reorganiza su punta de cadena — bloques que creías confirmados se reemplazan. Para un keeper, esto significa:

  • Una liquidación que enviaste en el bloque N puede estar en un bloque que se reorganiza
  • Posiciones que creías liquidadas pueden “des-liquidarse” en la nueva punta de cadena
  • Eventos que indexaste de bloques revertidos deben eliminarse

La mayoría de implementaciones de keepers que he auditado manejan el camino feliz e ignoran los reorgs por completo. Esto está bien hasta que ocurre un reorg durante alta volatilidad — exactamente cuando tu keeper es más crítico.

defmodule Keeper.ChainMonitor do
  use GenServer

  @reorg_depth 12  # considerar bloques finales después de 12 confirmaciones

  def init(_) do
    {:ok, %{finalized_block: 0, pending: %{}}}
  end

  def handle_info({:new_block, block}, state) do
    # Verificar si algún bloque pendiente fue reorgado
    {valid, reorged} = state.pending
      |> Map.split_with(fn {_hash, number} ->
        number <= block.number - @reorg_depth or
        Keeper.Chain.block_exists?(hash)
      end)

    # Reprocesar posiciones afectadas por bloques reorgados
    Enum.each(reorged, fn {_hash, _number} ->
      Keeper.PositionReconciler.reconcile_affected_positions()
    end)

    new_pending = valid |> Map.put(block.hash, block.number)
    {:noreply, %{state | pending: new_pending, finalized_block: block.number - @reorg_depth}}
  end
end

La clave: no tratar nada como final hasta que tenga al menos 12 bloques de profundidad. Mantener un mapa de bloques pendientes. Cuando veas un bloque a profundidad 12 que ya no existe en la cadena, tuviste un reorg — reconcilia.

Indexación: ¿Por Qué No Usar Solo The Graph?

The Graph es excelente para patrones estándar de ERC-20 y ERC-721. Para lógica de protocolo compleja — enrutamiento multi-hop, agregación de estado cross-contract, consultas condicionales — a menudo necesitas un indexador personalizado.

La arquitectura es más simple de lo que parece:

defmodule Indexer.EventListener do
  use GenServer

  def init(config) do
    {:ok, filter_id} = Indexer.RPC.subscribe_logs(%{
      address: config.contract_address,
      topics: config.event_topics
    })

    {:ok, %{filter_id: filter_id, last_block: config.from_block}}
  end

  def handle_info(:poll, state) do
    {:ok, logs} = Indexer.RPC.get_filter_changes(state.filter_id)

    logs
    |> Enum.map(&Indexer.Decoder.decode_log/1)
    |> Enum.each(&Indexer.Store.upsert_event/1)

    schedule_poll()
    {:noreply, %{state | last_block: max_block(logs, state.last_block)}}
  end
end

Almacena los eventos decodificados en Postgres. Indexa por número de bloque, hash de transacción y los campos de dominio que consultes. Un protocolo de préstamos típicamente necesita consultas como “todos los eventos de borrow para la cuenta X” y “depósitos totales por activo en los últimos 7 días” — ninguna es barata de calcular re-escaneando el historial de la cadena cada vez.

El detalle importante: siempre almacena el número de bloque y el log index junto a cada evento. Esto es lo que te permite manejar reorgs — cuando el bloque 14.502 es reorgado, eliminas todos los eventos donde block_number = 14502 y re-indexas desde ese bloque.

Qué Falla Realmente en Producción

Después de correr keepers e indexadores en mainnet en múltiples protocolos, esto es lo que causa incidentes reales:

Fallos del proveedor RPC. Los setups de proveedor único fallan. Usa al menos dos — Alchemy e Infura, o uno gestionado y un nodo propio. Cambia en caso de fallo. El patrón de circuit breaker de Elixir aplica directamente aquí.

Picos de precio de gas durante cascadas de liquidación. Cuando múltiples posiciones se vuelven liquidables simultáneamente (una caída flash), el precio del gas puede subir 10–50x en segundos. Tu keeper necesita precios de gas dinámicos — ya sea ajuste de tip EIP-1559 o un gas oracle. Un keeper que envía con baseFee + 1 gwei durante un pico nunca se incluirá.

Acumulación de memoria en indexadores de larga ejecución. Los indexadores que procesan millones de eventos acumulan estado con el tiempo. Perfila el tamaño del heap después de 72 horas de operación continua, no solo durante el desarrollo. Los procesos GenServer en Elixir tienen su propio GC, lo que ayuda — pero la cola de escritura en Postgres todavía puede acumularse si tu indexador procesa más rápido de lo que puede escribir.

Eventos perdidos durante reconexiones de websocket RPC. Las conexiones websocket se cortan. Durante la ventana de reconexión, pierdes eventos. La solución: siempre mantén un cursor last_indexed_block y rellena los eventos perdidos al reconectar usando el método RPC eth_getLogs con un rango de bloques.

Checklist para Producción

Antes de salir en vivo:

  • Dos proveedores RPC independientes con failover automático
  • Detección de reorgs con profundidad de finalidad configurable (12 para mainnet, 3 para rollups optimistas)
  • Estrategia de competencia del keeper — ¿estás protegido contra MEV, o aceptas la carrera?
  • Integración con gas oracle con límites mínimos y máximos
  • Backfill de eventos al reiniciar el indexador
  • Alerta sobre heartbeats perdidos de procesos keeper
  • Despliegue separado para indexador (lectura) y keeper (escritura) — tienen modos de fallo y características de escalado diferentes

El protocolo on-chain es la parte fácil. La infraestructura off-chain es donde los protocolos realmente viven o mueren.

Eliecer Sánchez

Escrito por

Eliecer Sánchez

Chief Architect

Ver Perfilopen_in_new