Los secretos de WayBank ¿Como Funciona?

				
					// SPDX-License-Identifier: GPL-3.0
// WayBank - Contrato Completo y Operativo

pragma solidity ^0.8.17;

// ---------------------------
// IMPORTS
// ---------------------------
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol"; 
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

import "@uniswap/v3-periphery/contracts/interfaces/INonfungiblePositionManager.sol";

// Interfaz Oráculo Chainlink (para valorar 'otroToken' vs USD o vs USDC)
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

// Interfaz Keeper (Chainlink Automation / Gelato) para reequilibrio automático (opcional)
interface IKeeperCompatible {
    function checkUpkeep(bytes calldata checkData) external returns (bool upkeepNeeded, bytes memory performData);
    function performUpkeep(bytes calldata performData) external;
}

/**
 * @title WayBank
 * @dev Contrato final que integra:
 *  - Depósitos en USDC y emisión de tokens WAY (1:1).
 *  - Posición en Uniswap V3 (crear, recolectar fees, retirar liquidez).
 *  - Oráculo de precios (Chainlink) para valorar 'otroToken' en USDC.
 *  - Cálculo de beneficios con ERC20Snapshot para reparto escalable.
 *  - Comisión fija del 35% hacia WALLET_FEE.
 *  - Pausa en caso de emergencia, y liquidación final tras 'fechaFin'.
 *  - Ejemplo de funciones para reequilibrio automático (checkUpkeep/performUpkeep).
 */
contract WayBank is ERC20Snapshot, Pausable, ReentrancyGuard, Ownable {
    using SafeERC20 for IERC20;

    // ------------------------------------------------
    // 1) CONFIGURACIÓN PRINCIPAL
    // ------------------------------------------------

    // Ventana de depósitos
    uint256 public fechaInicio;
    uint256 public fechaFin;

    // Periodo mínimo entre liquidaciones
    uint256 public periodicidadLiquidacion;

    // Token de depósito principal (ej. USDC)
    IERC20 public usdcToken;

    // Otro token (ej. WETH) para la posición en Uniswap
    IERC20 public otroToken;

    // Parámetro fijo de comisión para liquidarBeneficios
    uint256 public constant FEE_PERCENTAGE = 35;

    // Dirección que recibirá las comisiones
    address public constant WALLET_FEE = 0xbXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX;

    // Dirección del propietario de los fondos al finalizar el contrato
    address public immutable WALLET_OWNER = 0xbXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX;

    // ---------------------------
    // 2) UNISWAP V3
    // ---------------------------
    INonfungiblePositionManager public positionManager;  // Interfaz para crear/gestionar posición
    uint24 public immutable feeTier;                     // Fee de la pool Uniswap (500, 3000, 10000)
    uint256 public uniswapPositionTokenId;               // tokenId de la posición en Uniswap

    // Dirección de la pool (opcional) si deseas invocar funciones directas
    address public constant POOL = 0xbXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX;

    // ---------------------------
    // 3) ORÁCULO DE PRECIOS
    // ---------------------------
    AggregatorV3Interface public priceFeed; // p.ej., 'otroToken' vs USD (o USDC)

    // ---------------------------
    // 4) CONTABILIDAD DE BENEFICIOS
    // ---------------------------
    uint256 public ultimaLiquidacion;
    uint256 public ultimaValoracion; 
    uint256 public porcentajeRendimiento; // Si deseas un % teórico adicional

    // ---------------------------
    // EVENTOS
    // ---------------------------
    event Depositado(address indexed usuario, uint256 cantidadUSDC);
    event Retirado(address indexed usuario, uint256 cantidadUSDC);
    event LiquidezAnadida(uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
    event LiquidezRetirada(uint256 tokenId, uint256 amount0, uint256 amount1);
    event FeesRecolectados(uint256 tokenId, uint256 fees0, uint256 fees1);

    event BeneficiosLiquidados(uint256 beneficiosTotales, uint256 timestamp);
    event BeneficiosDisponibles(uint256 snapshotId, uint256 beneficiosNetos);

    event ContratoLiquidado(uint256 saldoUSDC, uint256 saldoOtroToken);
    event ReequilibrioAutomatizado(uint256 timestamp);

    // ------------------------------------------------
    // MAPPINGS para REPARTO DE BENEFICIOS via SNAPSHOT
    // ------------------------------------------------
    mapping(uint256 => uint256) public beneficiosPorSnapshot; // snapshotId => totalBeneficiosNetos
    mapping(address => mapping(uint256 => bool)) public yaReclamado; // user => snapshotId => si reclamó

    // ------------------------------------------------
    // CONSTRUCTOR
    // ------------------------------------------------
    constructor(
        uint256 _fechaInicio,
        uint256 _fechaFin,
        uint256 _periodicidadLiquidacion,
        uint256 _porcentajeRendimiento,
        address _usdcAddress,
        address _otroTokenAddress,
        address _positionManager,
        address _walletOwner,
        uint24 _feeTier,
        address _chainlinkPriceFeed
    ) 
        ERC20("WayBank Token", "WAY")
    {
        // Validación de feeTier
        require(_feeTier == 500 || _feeTier == 3000 || _feeTier == 10000, "Fee tier no valido");

        // Configuración inicial
        fechaInicio = _fechaInicio;
        fechaFin = _fechaFin;
        periodicidadLiquidacion = _periodicidadLiquidacion;
        porcentajeRendimiento = _porcentajeRendimiento;

        usdcToken = IERC20(_usdcAddress);
        otroToken = IERC20(_otroTokenAddress);
        positionManager = INonfungiblePositionManager(_positionManager);

        WALLET_OWNER = _walletOwner;
        feeTier = _feeTier;

        priceFeed = AggregatorV3Interface(_chainlinkPriceFeed);

        // Estado inicial
        ultimaLiquidacion = block.timestamp;
        ultimaValoracion = 0;
        uniswapPositionTokenId = 0;

        // Transferir propiedad (se recomienda que _walletOwner sea un multisig)
        transferOwnership(msg.sender);
    }

    // ------------------------------------------------
    // MODIFICADORES
    // ------------------------------------------------
    modifier soloDuranteDepositos() {
        require(block.timestamp >= fechaInicio, "Ventana de depositos no iniciada");
        require(block.timestamp <= fechaFin, "Ventana de depositos finalizada");
        _;
    }

    // ------------------------------------------------
    // DEPÓSITO / RETIRO DE USDC
    // ------------------------------------------------
    function depositar(uint256 cantidad) external whenNotPaused nonReentrant soloDuranteDepositos {
        require(cantidad > 0, "Cantidad debe ser > 0");
        
        // Transferir USDC desde usuario al contrato
        usdcToken.safeTransferFrom(msg.sender, address(this), cantidad);

        // Emitir tokens WAY 1:1
        _mint(msg.sender, cantidad);
        emit Depositado(msg.sender, cantidad);
    }

    function retirar(uint256 cantidad) external whenNotPaused nonReentrant {
        require(cantidad > 0, "Debe retirar > 0");
        require(balanceOf(msg.sender) >= cantidad, "Saldo WAY insuficiente");

        // Quemar tokens WAY
        _burn(msg.sender, cantidad);

        // Transferir USDC al usuario (el contrato debe tener liquidez)
        uint256 saldoContrato = usdcToken.balanceOf(address(this));
        require(saldoContrato >= cantidad, "Liquidez insuficiente en el contrato");

        usdcToken.safeTransfer(msg.sender, cantidad);
        emit Retirado(msg.sender, cantidad);
    }

    // ------------------------------------------------
    // UNISWAP: CREAR POSICIÓN, RETIRAR LIQUIDEZ, RECOLECTAR FEES
    // ------------------------------------------------
    function crearPosicionUniswap(
        uint256 amount0Desired,
        uint256 amount1Desired,
        int24 tickLower,
        int24 tickUpper
    ) external onlyOwner whenNotPaused {
        // Solo se permite una posición en este ejemplo
        require(uniswapPositionTokenId == 0, "Ya existe una posicion en Uniswap");

        // Aprobamos el gasto
        usdcToken.safeApprove(address(positionManager), 0);
        usdcToken.safeApprove(address(positionManager), amount0Desired);

        otroToken.safeApprove(address(positionManager), 0);
        otroToken.safeApprove(address(positionManager), amount1Desired);

        // Mint de la posición
        INonfungiblePositionManager.MintParams memory params =
            INonfungiblePositionManager.MintParams({
                token0: address(usdcToken),
                token1: address(otroToken),
                fee: feeTier,
                tickLower: tickLower,
                tickUpper: tickUpper,
                amount0Desired: amount0Desired,
                amount1Desired: amount1Desired,
                amount0Min: 0,
                amount1Min: 0,
                recipient: address(this),
                deadline: block.timestamp + 1800
            });

        (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1) =
            positionManager.mint(params);

        // Guardar tokenId
        uniswapPositionTokenId = tokenId;

        // Limpiar aprobaciones sobrantes
        if (amount0 < amount0Desired) {
            usdcToken.safeApprove(address(positionManager), 0);
        }
        if (amount1 < amount1Desired) {
            otroToken.safeApprove(address(positionManager), 0);
        }

        emit LiquidezAnadida(tokenId, liquidity, amount0, amount1);
    }

    function recolectarFeesUniswap() public onlyOwner whenNotPaused {
        require(uniswapPositionTokenId != 0, "No existe posicion Uniswap");

        INonfungiblePositionManager.CollectParams memory params =
            INonfungiblePositionManager.CollectParams({
                tokenId: uniswapPositionTokenId,
                recipient: address(this),
                amount0Max: type(uint128).max,
                amount1Max: type(uint128).max
            });

        (uint256 amount0Collected, uint256 amount1Collected) =
            positionManager.collect(params);

        emit FeesRecolectados(uniswapPositionTokenId, amount0Collected, amount1Collected);
    }

    function retirarLiquidezUniswap(uint128 liquidity) external onlyOwner whenNotPaused {
        require(uniswapPositionTokenId != 0, "No existe posicion Uniswap");
        require(liquidity > 0, "Liquidez debe ser > 0");

        INonfungiblePositionManager.DecreaseLiquidityParams memory params =
            INonfungiblePositionManager.DecreaseLiquidityParams({
                tokenId: uniswapPositionTokenId,
                liquidity: liquidity,
                amount0Min: 0,
                amount1Min: 0,
                deadline: block.timestamp + 1800
            });

        (uint256 amount0, uint256 amount1) = positionManager.decreaseLiquidity(params);
        
        // Recolectar fees, incluyendo lo recién liberado
        recolectarFeesUniswap();

        emit LiquidezRetirada(uniswapPositionTokenId, amount0, amount1);
    }

    // ------------------------------------------------
    // ORÁCULO CHAINLINK: VALORACIÓN DE 'otroToken' EN USDC
    // ------------------------------------------------
    function getLatestPrice() public view returns (int256) {
        // Devuelve precio "otroToken / USD", asumiendo
        (
            , 
            int256 price, 
            , 
            , 
        ) = priceFeed.latestRoundData();
        return price;
    }

    function convertirOtroTokenAUSDC(uint256 balanceOtro) public view returns (uint256) {
        if (balanceOtro == 0) return 0;
        int256 price = getLatestPrice();
        // Asumimos 8 decimales en el feed. Ajustar si difiere.
        uint256 priceUint = uint256(price);
        // (balanceOtro * price) / 10^8
        uint256 valorUSDC = (balanceOtro * priceUint) / (10 ** 8);
        return valorUSDC;
    }

    // ------------------------------------------------
    // VALORACIÓN TOTAL / LIQUIDACIÓN DE BENEFICIOS
    // ------------------------------------------------
    function valoracionTotal() public view returns (uint256) {
        // 1) USDC en el contrato
        uint256 balanceUSDC = usdcToken.balanceOf(address(this));
        // 2) 'otroToken' convertido a USDC (aprox. via oráculo)
        uint256 balanceOT = otroToken.balanceOf(address(this));
        uint256 balanceOTenUSDC = convertirOtroTokenAUSDC(balanceOT);
        // 3) Valor en la posición Uniswap si no se ha retirado => en este ejemplo
        //    no se contabiliza a menos que se recolecte. Podrías ampliar
        //    usando las librerías de Uniswap para calcularlo on-chain.
        return balanceUSDC + balanceOTenUSDC;
    }

    function liquidarBeneficios() external whenNotPaused nonReentrant {
        // Respetar periodicidad
        require(block.timestamp >= (ultimaLiquidacion + periodicidadLiquidacion), "No corresponde liquidar aun");

        // Recolectar fees de Uniswap para actualizar balance
        if (uniswapPositionTokenId != 0) {
            recolectarFeesUniswap();
        }

        // Cálculo de beneficios basado en la valoración actual - ultimaValoracion
        uint256 valorActual = valoracionTotal();
        if (valorActual <= ultimaValoracion) {
            // No hay ganancia
            ultimaLiquidacion = block.timestamp;
            emit BeneficiosLiquidados(0, block.timestamp);
            return;
        }

        uint256 beneficios = valorActual - ultimaValoracion;

        // Comisión
        uint256 comision = (beneficios * FEE_PERCENTAGE) / 100;
        if (comision > 0) {
            usdcToken.safeTransfer(WALLET_FEE, comision);
        }
        uint256 beneficiosNetos = beneficios - comision;

        // Actualizar
        ultimaValoracion = valorActual;
        ultimaLiquidacion = block.timestamp;

        // Crear snapshot para permitir "pull payments" en claimBeneficios
        uint256 snapshotId = _snapshot();

        emit BeneficiosLiquidados(beneficios, block.timestamp);
        emit BeneficiosDisponibles(snapshotId, beneficiosNetos);

        // (Opcional) Guardar la cantidad total de beneficios netos en el snapshot
        beneficiosPorSnapshot[snapshotId] = beneficiosNetos;
    }

    /**
     * @dev Lógica para que cada usuario reclame su parte de los beneficios
     *      almacenados en `beneficiosPorSnapshot[snapshotId]`.
     */
    function claimBeneficios(uint256 snapshotId) external whenNotPaused nonReentrant {
        require(!yaReclamado[msg.sender][snapshotId], "Beneficios ya reclamados en este snapshot");
        uint256 totalBenef = beneficiosPorSnapshot[snapshotId];
        require(totalBenef > 0, "No hay beneficios en ese snapshot");

        // Balance del usuario y totalSupply en ese snapshot
        (uint256 balanceUser, uint256 supplySnapshot) = _balanceOfAt(msg.sender, snapshotId);
        require(balanceUser > 0 && supplySnapshot > 0, "No participaciones en snapshot");

        // Cálculo de la parte
        uint256 parte = (totalBenef * balanceUser) / supplySnapshot;
        require(parte > 0, "Parte = 0");

        // Marcar reclamado
        yaReclamado[msg.sender][snapshotId] = true;

        // Transferir al usuario
        usdcToken.safeTransfer(msg.sender, parte);
    }

    // Función interna para obtener balances de snapshot
    function _balanceOfAt(address account, uint256 snapshotId) internal view returns (uint256, uint256) {
        return (balanceOfAt(account, snapshotId), totalSupplyAt(snapshotId));
    }

    // ------------------------------------------------
    // REEQUILIBRIO AUTOMÁTICO (Keeper)
    // ------------------------------------------------
    /**
     * @dev checkUpkeep y performUpkeep son ejemplos de la interfaz Keeper:
     *      - Determina si la posición está fuera de rango para reequilibrar.
     *      - Requiere un bot externo (Chainlink Automation, Gelato, etc.).
     */
    function checkUpkeep(bytes calldata) external view returns (bool upkeepNeeded, bytes memory) {
        if (uniswapPositionTokenId != 0) {
            // Aquí podría verificarse el rango, el precio, etc.
            upkeepNeeded = false; // Se cambia a true cuando haya que reequilibrar
        }
        return (upkeepNeeded, bytes(""));
    }

    function performUpkeep(bytes calldata) external whenNotPaused {
        // Ejemplo: Lógica de reequilibrio
        // 1) retirar liquidez si el precio salió del rango
        // 2) recolocar liquidez en un nuevo rango
        // ...
        emit ReequilibrioAutomatizado(block.timestamp);
    }

    // ------------------------------------------------
    // FUNCIÓN DE LIQUIDACIÓN FINAL
    // ------------------------------------------------
    function liquidarContrato() external onlyOwner {
        // Solo cuando pase la fechaFin
        require(block.timestamp > fechaFin, "No ha finalizado el contrato");

        // Si hay una posición activa, retirar liquidez total
        if (uniswapPositionTokenId != 0) {
        // 1) Consultar la liquidez total de la posición
        (
            , 
            , 
            uint128 liquidity, // Ésta es la liquidez actual
            , 
            ,
            ,
            ,
    
        ) = positionManager.positions(uniswapPositionTokenId);
    
        // 2) Llamar a la función que retira esa liquidez
        retirarLiquidezUniswap(liquidity);
        }


        // Transferir todos los USDC a WALLET_OWNER
        uint256 saldoUSDC = usdcToken.balanceOf(address(this));
        if (saldoUSDC > 0) {
            usdcToken.safeTransfer(WALLET_OWNER, saldoUSDC);
        }

        // Transferir todo el otroToken a WALLET_OWNER
        uint256 saldoOT = otroToken.balanceOf(address(this));
        if (saldoOT > 0) {
            otroToken.safeTransfer(WALLET_OWNER, saldoOT);
        }

        // Pausar el contrato para que nadie pueda usarlo más
        _pause();

        emit ContratoLiquidado(saldoUSDC, saldoOT);
    }

    // ------------------------------------------------
    // FUNCIONES DE ADMINISTRACIÓN Y PAUSA
    // ------------------------------------------------
    function pausar() external onlyOwner {
        _pause();
    }

    function despausar() external onlyOwner {
        _unpause();
    }

    // ------------------------------------------------
    // UTILS / LECTURAS
    // ------------------------------------------------
    function totalDepositos() public view returns (uint256) {
        return usdcToken.balanceOf(address(this));
    }
}