NEXALO es un ecosistema de 8 contratos inteligentes interconectados desplegados en BNB Smart Chain (BSC). Todos los contratos están compilados con Solidity 0.8.20 usando la opción via-ir y el optimizador a 200 runs.

┌─────────────────────────────────────────────────┐
│                  NexumManager                    │
│         (Core — VRFConsumerBaseV2)               │
│  ┌─────────┬──────────┬──────────┬────────────┐  │
│  │ Products│ Rounds   │ VRF     │ Settlement │  │
│  │ (6)     │ (state)  │ (rand)  │ (auto)     │  │
│  └────┬────┴────┬─────┴────┬────┴─────┬──────┘  │
└───────┼─────────┼──────────┼──────────┼──────────┘
        │         │          │          │
   ┌────▼───┐ ┌──▼─────┐ ┌─▼──────┐ ┌─▼──────────┐
   │NXLToken│ │Referral│ │Treasury│ │Ambassador  │
   │(ERC20) │ │Network │ │  BTC   │ │ Registry   │
   └────────┘ └────────┘ └────────┘ └────────────┘
        │                    │
   ┌────▼───┐           ┌───▼────┐
   │Staking │           │Buyback │
   │(WBTC)  │           │Contract│
   └────────┘           └────────┘
              

Cada contrato tiene una responsabilidad única (Single Responsibility Principle) y se comunica con los demás a través de interfaces definidas. El NexumManager es el hub central que orquesta la lógica de lotería, distribución de fondos y settlement.

Todos los contratos heredan de OpenZeppelin v5 y siguen las mejores prácticas de seguridad:

NXLToken es un ERC-20 con supply fijo de 100,000,000 NXL y mecanismos de vesting integrados.

// Solo NexumManager puede distribuir rewards
function distributeReward(address to, uint256 amount) external onlyNexumManager

// setNexumManager solo se puede llamar UNA vez
function setNexumManager(address _mgr) external onlyOwner

// Vesting lineal con cliff
function claimFounderVesting() external  // Solo founder, lineal 2 años
function claimPartnerVesting() external  // Solo partner, lineal 1 año

// Checkpoints para snapshot de balances (votación/DAO futuro)
function _afterTokenTransfer() // actualiza checkpoints automáticamente

El contrato más complejo del ecosistema. Gestiona 6 productos de lotería con rondas independientes, cada uno con su propio pool de premios y configuración de tickets.

1. OPEN       → Usuarios compran tickets (buyTickets)
2. FUNDED     → Liquidez completa, se solicita VRF
3. VRF_SENT   → Esperando número aleatorio de Chainlink
4. SETTLING   → Distribuyendo premios (settlement en chunks)
5. SETTLED    → Ronda cerrada, nueva ronda abre automáticamente

// Función principal de compra
function buyTickets(
    uint256 productId,     // 0-5
    uint256[] ticketNums,  // números elegidos
    address referrer       // address(0) si sin referido
) external nonReentrant

Cuando una ronda se completa, el 100% de los fondos se distribuye automáticamente según reglas fijas e inmutables:

La distribución es atómica — ocurre en la misma transacción que el settlement. No hay intermediarios, delays, ni custodia manual de fondos.

NEXALO utiliza Chainlink VRF v2 para generar números aleatorios criptográficamente verificables. Esto garantiza que nadie — ni el equipo, ni los mineros, ni Chainlink — puede predecir o manipular el resultado.

// Solicitud VRF (automática cuando ronda completa)
function requestRandomWords() internal {
    VRFCoordinatorV2Interface(vrfCoordinator)
        .requestRandomWords(
            keyHash,          // BSC VRF key
            subscriptionId,   // Chainlink subscription
            3,                // confirmaciones
            500000,           // gas limit callback
            1                 // 1 palabra aleatoria
        );
}

// Callback de Chainlink (solo el Coordinator puede llamar)
function fulfillRandomWords(
    uint256 requestId,
    uint256[] memory randomWords
) internal override {
    // Selección de ganador: randomWord % totalTickets
    // Settlement automático
}

El timeout VRF protege contra fallos del oráculo: si Chainlink no responde en el tiempo configurado, el owner puede re-solicitar o manejar la ronda. Tras finalizeAutonomy(), esta protección opera sin intervención.

Sistema de referidos de 3 niveles con protecciones anti-gaming:

Protecciones integradas: anti-ciclos (A→B→C→A no permitido), un solo referrer por usuario, validación de zero address, y pagos automáticos en USDT en el mismo bloque de la compra.

El 10% de cada ticket alimenta un fondo DAO que acumula USDT para convertir en WBTC. Los holders de NXL pueden redimir sus tokens por WBTC proporcionalmente durante ventanas de redención anuales.

// Estrategias DeFi integradas
interface IYieldStrategy {
    function deposit(uint256 amount) external;
    function withdraw(uint256 amount) external;
    function totalDeposited() view returns (uint256);
    function harvest() external returns (uint256);
}

// Implementaciones:
// - AaveStrategy: Lending en Aave v3
// - VenusStrategy: Lending en Venus Protocol

Los usuarios pueden hacer stake de NXL y recibir rendimientos en WBTC provenientes de la tesorería. El contrato usa ReentrancyGuard y Ownable2Step para máxima seguridad.

El protocolo ha pasado por un pipeline de seguridad exhaustivo con 6 herramientas profesionales:

Para interactuar con el protocolo desde tu dApp o script:

npm install ethers@6 wagmi viem @reown/appkit

import { parseUnits } from 'viem';

// 1. Approve USDT para NexumManager
await usdtContract.write.approve([
  NEXUM_MANAGER_ADDRESS,
  parseUnits('10', 18)  // 10 USDT
]);

// 2. Comprar tickets
await nexumManager.write.buyTickets([
  0,                    // productId: FLASH
  [42, 100, 777],       // ticket numbers
  referrerAddress       // o address(0) si no hay referido
]);

// Obtener información de ronda actual
const round = await nexumManager.read.getCurrentRound([productId]);
// Returns: { roundId, ticketsSold, totalFunded, status, winner, ... }

// Verificar si un ticket ganó
const isWinner = await nexumManager.read.isWinner([
  productId, roundId, ticketNumber
]);

// El ganador reclama su premio
await nexumManager.write.claimPrize([productId, roundId]);

// Verificar balance de premios pendientes
const pending = await nexumManager.read.getPendingPrize([
  userAddress, productId, roundId
]);