Blockchain y Web3 en 2025: La Revolución Descentralizada Ya Está Aquí

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract StakingPool is ReentrancyGuard, Ownable {
    IERC20 public stakingToken;
    IERC20 public rewardToken;

    uint256 public rewardRate = 100; // 100 tokens per second
    uint256 public lastUpdateTime;
    uint256 public rewardPerTokenStored;

    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;
    mapping(address => uint256) public balances;

    uint256 public totalSupply;

    event Staked(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardsClaimed(address indexed user, uint256 reward);

    constructor(IERC20 _stakingToken, IERC20 _rewardToken) {
        stakingToken = _stakingToken;
        rewardToken = _rewardToken;
    }

    function rewardPerToken() public view returns (uint256) {
        if (totalSupply == 0) {
            return rewardPerTokenStored;
        }
        return rewardPerTokenStored +
            (((block.timestamp - lastUpdateTime) * rewardRate * 1e18) / totalSupply);
    }

    function earned(address account) public view returns (uint256) {
        return (balances[account] *
            (rewardPerToken() - userRewardPerTokenPaid[account])) / 1e18 +
            rewards[account];
    }

    modifier updateReward(address account) {
        rewardPerTokenStored = rewardPerToken();
        lastUpdateTime = block.timestamp;

        if (account != address(0)) {
            rewards[account] = earned(account);
            userRewardPerTokenPaid[account] = rewardPerTokenStored;
        }
        _;
    }

    function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
        require(amount > 0, "Cannot stake 0");

        totalSupply += amount;
        balances[msg.sender] += amount;

        stakingToken.transferFrom(msg.sender, address(this), amount);
        emit Staked(msg.sender, amount);
    }

    function withdraw(uint256 amount) external nonReentrant updateReward(msg.sender) {
        require(amount > 0, "Cannot withdraw 0");
        require(balances[msg.sender] >= amount, "Insufficient balance");

        totalSupply -= amount;
        balances[msg.sender] -= amount;

        stakingToken.transfer(msg.sender, amount);
        emit Withdrawn(msg.sender, amount);
    }

    function claimRewards() external nonReentrant updateReward(msg.sender) {
        uint256 reward = rewards[msg.sender];
        require(reward > 0, "No rewards available");

        rewards[msg.sender] = 0;
        rewardToken.transfer(msg.sender, reward);
        emit RewardsClaimed(msg.sender, reward);
    }
}

import { useState, useEffect } from 'react';
import { ethers } from 'ethers';
import StakingPoolABI from './contracts/StakingPool.json';

const STAKING_CONTRACT_ADDRESS = "0x..."; // Tu contrato desplegado
const STAKING_TOKEN_ADDRESS = "0x...";

export default function StakingApp() {
  const [provider, setProvider] = useState(null);
  const [signer, setSigner] = useState(null);
  const [contract, setContract] = useState(null);
  const [account, setAccount] = useState('');
  const [stakingBalance, setStakingBalance] = useState('0');
  const [earnedRewards, setEarnedRewards] = useState('0');
  const [stakeAmount, setStakeAmount] = useState('');

  useEffect(() => {
    initializeWeb3();
  }, []);

  const initializeWeb3 = async () => {
    if (typeof window.ethereum !== 'undefined') {
      try {
        // Conectar a MetaMask
        await window.ethereum.request({ method: 'eth_requestAccounts' });

        const provider = new ethers.providers.Web3Provider(window.ethereum);
        const signer = provider.getSigner();
        const address = await signer.getAddress();

        // Inicializar contrato
        const contract = new ethers.Contract(
          STAKING_CONTRACT_ADDRESS,
          StakingPoolABI.abi,
          signer
        );

        setProvider(provider);
        setSigner(signer);
        setContract(contract);
        setAccount(address);

        // Cargar datos iniciales
        loadUserData(contract, address);
      } catch (error) {
        console.error('Error conectando a Web3:', error);
      }
    } else {
      alert('Por favor instala MetaMask');
    }
  };

  const loadUserData = async (contract, address) => {
    try {
      const balance = await contract.balances(address);
      const earned = await contract.earned(address);

      setStakingBalance(ethers.utils.formatEther(balance));
      setEarnedRewards(ethers.utils.formatEther(earned));
    } catch (error) {
      console.error('Error cargando datos:', error);
    }
  };

  const handleStake = async () => {
    if (!contract || !stakeAmount) return;

    try {
      const amount = ethers.utils.parseEther(stakeAmount);

      // Primero aprobar tokens
      const tokenContract = new ethers.Contract(
        STAKING_TOKEN_ADDRESS,
        ['function approve(address spender, uint256 amount) external returns (bool)'],
        signer
      );

      const approveTx = await tokenContract.approve(STAKING_CONTRACT_ADDRESS, amount);
      await approveTx.wait();

      // Luego hacer stake
      const stakeTx = await contract.stake(amount);
      await stakeTx.wait();

      // Recargar datos
      loadUserData(contract, account);
      setStakeAmount('');

      alert('Stake exitoso!');
    } catch (error) {
      console.error('Error en stake:', error);
      alert('Error: ' + error.message);
    }
  };

  const handleClaimRewards = async () => {
    if (!contract) return;

    try {
      const claimTx = await contract.claimRewards();
      await claimTx.wait();

      loadUserData(contract, account);
      alert('Rewards reclamadas!');
    } catch (error) {
      console.error('Error reclamando rewards:', error);
    }
  };

  return (
    <div className="max-w-md mx-auto bg-white rounded-lg shadow-lg p-6">
      <h2 className="text-2xl font-bold mb-6">DeFi Staking Pool</h2>

      {account ? (
        <div className="space-y-6">
          <div className="bg-gray-50 p-4 rounded">
            <p className="text-sm text-gray-600">Wallet conectada:</p>
            <p className="font-mono text-sm">{account.slice(0,6)}...{account.slice(-4)}</p>
          </div>

          <div className="grid grid-cols-2 gap-4">
            <div className="bg-blue-50 p-4 rounded">
              <p className="text-sm text-blue-600">Staking Balance</p>
              <p className="text-xl font-bold">{parseFloat(stakingBalance).toFixed(4)}</p>
            </div>
            <div className="bg-green-50 p-4 rounded">
              <p className="text-sm text-green-600">Rewards Earned</p>
              <p className="text-xl font-bold">{parseFloat(earnedRewards).toFixed(4)}</p>
            </div>
          </div>

          <div className="space-y-4">
            <div>
              <label className="block text-sm font-medium mb-2">Cantidad a Stakear</label>
              <input
                type="number"
                value={stakeAmount}
                onChange={(e) => setStakeAmount(e.target.value)}
                className="w-full border rounded-md px-3 py-2"
                placeholder="0.0"
              />
            </div>

            <button
              onClick={handleStake}
              className="w-full bg-blue-600 text-white py-2 rounded-md hover:bg-blue-700"
            >
              Stake Tokens
            </button>

            <button
              onClick={handleClaimRewards}
              className="w-full bg-green-600 text-white py-2 rounded-md hover:bg-green-700"
              disabled={parseFloat(earnedRewards) === 0}
            >
              Claim Rewards ({parseFloat(earnedRewards).toFixed(4)})
            </button>
          </div>
        </div>
      ) : (
        <button
          onClick={initializeWeb3}
          className="w-full bg-orange-600 text-white py-3 rounded-md hover:bg-orange-700"
        >
          Conectar Wallet
        </button>
      )}
    </div>
  );
}

Protocolos de Cross-Chain 2025:

• • Polkadot Parachains: Interoperabilidad nativa entre blockchains especializadas
• • Cosmos IBC: Protocolo de comunicación inter-blockchain escalable
• • LayerZero: Protocolo omnichain para dApps multi-blockchain
• • Chainlink CCIP: Cross-Chain Interoperability Protocol para empresas
• • Wormhole: Bridge generic para transferencia de assets y data