Desarrollando DAOs Interoperables con Mensajería Cross-Chain: Un Tutorial con LayerZero 🌐

Introducción a las DAOs Interoperables y LayerZero ✨

El ecosistema Web3 ha madurado considerablemente, pero un desafío persistente ha sido la fragmentación de la liquidez y la funcionalidad a través de diferentes blockchains. Las Organizaciones Autónomas Descentralizadas (DAOs) no son una excepción. Tradicionalmente, una DAO existe en una única cadena, lo que limita su alcance y la participación de usuarios en otras redes.

Aquí es donde entra el concepto de DAOs interoperables. Imagina una DAO cuya gobernanza, votaciones y tesorería pueden ser accedidas y gestionadas desde múltiples blockchains, sin necesidad de complejos puentes manuales o la migración de activos. Esto abre un mundo de posibilidades para la expansión, la inclusión y la eficiencia de las DAOs.

¿Por qué DAOs Interoperables? 🤔

La necesidad de DAOs interoperables surge de varios factores:

• Expansión del Ecosistema: A medida que nuevas blockchains de capa 1 y capa 2 emergen, las DAOs quieren operar donde están sus usuarios y donde puedan encontrar ventajas, ya sea en costes de transacción, velocidad o acceso a diferentes tipos de activos.
• Optimización de Recursos: Una DAO podría tener su tesorería en una cadena de bajo coste como Polygon para gastos operativos y su gobernanza principal en Ethereum para la máxima seguridad, todo mientras interactúa con una dApp en Avalanche.
• Mayor Alcance y Participación: Al permitir que los miembros participen en la gobernanza desde su cadena preferida, se reduce la barrera de entrada y se fomenta una mayor participación.
• Flexibilidad Estratégica: Una DAO puede adaptar su estrategia rápidamente, desplegando componentes en nuevas cadenas sin reestructurar todo su modelo de gobernanza.

El Rol de LayerZero en la Interoperabilidad 🌉

LayerZero es un protocolo de interoperabilidad omnichain diseñado para permitir la comunicación directa y sin confianza entre contratos inteligentes en diferentes blockchains. A diferencia de los puentes tradicionales que a menudo se basan en custodios o validadores externos, LayerZero utiliza un enfoque más descentralizado y seguro.

¿Cómo funciona LayerZero? 🛠️

LayerZero opera con tres componentes principales:

1. Endpoints: Contratos inteligentes desplegados en cada blockchain compatible que actúan como la interfaz de comunicación para las dApps.
2. Oracle: Un servicio externo (Chainlink por defecto) que lee el bloque de cabecera de la cadena de origen y lo envía a la cadena de destino.
3. Relayer: Un servicio externo que toma la prueba de transacción de la cadena de origen y la envía a la cadena de destino.

La seguridad de LayerZero reside en la independencia del Oracle y el Relayer. Para que una transacción sea válida, tanto el Oracle como el Relayer deben actuar de buena fe. Si uno de ellos intenta censurar o manipular un mensaje, el otro lo detectará y el mensaje no se entregará. Esta separación de responsabilidades minimiza la superficie de ataque.

Arquitectura de una DAO Interoperable con LayerZero 🏛️

Para construir una DAO interoperable, necesitamos diseñar cómo los componentes de la DAO (tesorería, votación, propuesta) interactuarán a través de múltiples cadenas. Un enfoque común es tener una cadena "principal" donde reside la lógica central de gobernanza y luego replicar o referenciar esa lógica en otras cadenas "secundarias".

Componentes Clave 🔑

1. Contrato de Gobernanza Principal: Reside en una cadena (ej. Ethereum) y maneja la lógica central de las propuestas, votaciones y ejecución. Este contrato será el "propietario" de los contratos secundarios en otras cadenas.
2. Contratos de Gobernanza Secundarios (Proxy/Delegados): Desplegados en cadenas secundarias (ej. Polygon, Avalanche), estos contratos actúan como proxies o delegados, permitiendo a los usuarios interactuar con la DAO desde su cadena nativa. Estos contratos envían mensajes al contrato principal a través de LayerZero.
3. Contrato de Tesorería Multi-Chain: Un contrato que gestiona los activos de la DAO en varias cadenas. Podría ser un "puente" de tesorería personalizado o simplemente un conjunto de contratos en cada cadena que el contrato principal de gobernanza puede controlar remotamente.
4. Token de Gobernanza (Opcional pero Común): Un token que representa los derechos de voto y que puede existir nativamente en una cadena o ser un token omnichain (OFT) de LayerZero para transferencias fluidas entre cadenas.

Flujo de Votación Cross-Chain 🗳️

Consideremos un flujo simplificado para una propuesta que se inicia en una cadena secundaria y se vota globalmente:

1. Creación de Propuesta: Un miembro de la DAO crea una propuesta en la cadena secundaria (ej. Polygon) a través del Contrato de Gobernanza Secundario.
2. Mensaje Cross-Chain: El Contrato Secundario utiliza el Endpoint de LayerZero para enviar un mensaje al Contrato de Gobernanza Principal en la cadena principal (ej. Ethereum), informándole sobre la nueva propuesta.
3. Registro de Propuesta: El Contrato Principal registra la propuesta y la pone en un estado "activo" para votación.
4. Votación Global: Los miembros pueden votar desde la cadena principal o desde cualquier cadena secundaria donde haya un Contrato de Gobernanza Secundario. Los votos de las cadenas secundarias se envían al Contrato Principal a través de LayerZero.
5. Recuento y Ejecución: Una vez finalizado el período de votación, el Contrato Principal cuenta los votos y, si la propuesta pasa, ejecuta la acción asociada. Esta acción podría ser en la cadena principal o enviar otro mensaje cross-chain para ejecutar una acción en una cadena secundaria (ej. mover fondos de la tesorería de Polygon).

Implementación Práctica: DAO Simple con LayerZero 🧑‍💻

Para este tutorial, crearemos una versión simplificada de una DAO interoperable. Nos centraremos en la comunicación cross-chain para una función básica de "actualización de parámetro". Tendremos un contrato de gobernanza principal en una cadena y un contrato secundario en otra, que podrá proponer actualizaciones. Usaremos Hardhat para el desarrollo.

Requisitos Previos 📋

Antes de empezar, asegúrate de tener instalados:

• Node.js y npm/yarn
• Hardhat: npm install --save-dev hardhat
• OpenZeppelin Contracts: npm install @openzeppelin/contracts
• LayerZero: npm install @layerzerolabs/lz-evm-sdk-v2

Configura tu hardhat.config.js para dos redes de prueba (ej. Sepolia y Polygon Amoy). Necesitarás las URLs de RPC y las claves privadas de tus cuentas para desplegar.

// hardhat.config.js
require("@nomicfoundation/hardhat-toolbox");
require("@layerzerolabs/hardhat-v2");

const SEPOLIA_RPC_URL = process.env.SEPOLIA_RPC_URL || "";
const AMOY_RPC_URL = process.env.AMOY_RPC_URL || "";
const PRIVATE_KEY = process.env.PRIVATE_KEY || "0xac0974bec39a17e36ba4a6b4d238ff944bac478cdb66f17e06bb777d0609b074"; // Ejemplo, usar dotenv

module.exports = {
  solidity: "0.8.20",
  networks: {
    sepolia: {
      url: SEPOLIA_RPC_URL,
      accounts: [PRIVATE_KEY],
      chainId: 11155111,
    },
    amoy: {
      url: AMOY_RPC_URL,
      accounts: [PRIVATE_KEY],
      chainId: 80002,
    },
  },
  namedAccounts: {
    deployer: {
      default: 0,
    },
  },
};

1. Contrato de Gobernanza Principal (Ethereum - Sepolia) 🥇

Este contrato manejará el estado central y la lógica de la DAO. Tendrá una función para setParameter que solo puede ser llamada si una propuesta ha sido aprobada. Recibirá propuestas cross-chain.

// contracts/MainGovernance.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@layerzerolabs/lz-evm-sdk-v2/contracts/LzApp.sol";

contract MainGovernance is LzApp, Ownable {
    uint256 public someParameter; // Un parámetro que la DAO puede cambiar

    // Estado de la propuesta cross-chain
    struct CrossChainProposal {
        uint32 sourceChainId; // ID de la cadena de origen
        address sourceAddress; // Dirección del contrato secundario
        uint256 newValue; // Nuevo valor propuesto
        bool exists; // Para verificar si la propuesta está activa
        bool approved; // Para la lógica de votación (simplificada aquí)
    }

    // Un mapeo de un identificador de propuesta a su estado
    // Para simplificar, usaremos un único ID de propuesta cross-chain por ahora
    mapping(uint256 => CrossChainProposal) public activeProposals;
    uint256 public nextProposalId = 1; // Contador para IDs de propuesta

    // Evento para cuando se recibe una propuesta cross-chain
    event CrossChainProposalReceived(uint32 indexed sourceChainId, address indexed sourceAddress, uint256 newValue, uint256 proposalId);
    event ParameterUpdated(uint256 oldValue, uint256 newValue);
    event ProposalApproved(uint256 proposalId);

    constructor(address _lzEndpoint) LzApp(_lzEndpoint) Ownable(msg.sender) {
        // Constructor del LzApp necesita la dirección del endpoint de LayerZero en esta cadena
        someParameter = 100; // Valor inicial
    }

    // --- Funciones de gobernanza locales (simplificadas) ---

    // Función para aprobar una propuesta (en un DAO real, esto sería una votación compleja)
    function approveProposal(uint256 _proposalId) public onlyOwner {
        require(activeProposals[_proposalId].exists, "Proposal does not exist.");
        activeProposals[_proposalId].approved = true;
        emit ProposalApproved(_proposalId);
    }

    // Ejecutar la propuesta una vez aprobada
    function executeProposal(uint256 _proposalId) public onlyOwner {
        require(activeProposals[_proposalId].exists, "Proposal does not exist.");
        require(activeProposals[_proposalId].approved, "Proposal not approved.");

        uint256 newValue = activeProposals[_proposalId].newValue;
        uint256 oldValue = someParameter;
        someParameter = newValue;
        emit ParameterUpdated(oldValue, newValue);

        // Eliminar propuesta después de ejecutar
        delete activeProposals[_proposalId];
    }

    // --- Funciones de LayerZero ---

    // Esta función es llamada por LayerZero Endpoint cuando se recibe un mensaje de otra cadena
    // Para este ejemplo, estamos esperando un mensaje que contenga el nuevo valor del parámetro
    function _lzReceive(
        uint32 _srcChainId,
        bytes calldata _srcAddress,
        uint64 _nonce,
        bytes calldata _payload
    ) internal override {
        // _srcAddress es la dirección del contrato que envió el mensaje en la cadena de origen
        // Lo convertimos a address para usarlo en el mapeo
        address sourceContractAddress = address(uint160(bytes20(_srcAddress)));

        // El payload contiene el nuevo valor propuesto
        uint256 newValue = abi.decode(_payload, (uint256));

        // Crear una nueva propuesta
        uint256 currentProposalId = nextProposalId++;
        activeProposals[currentProposalId] = CrossChainProposal({
            sourceChainId: _srcChainId,
            sourceAddress: sourceContractAddress,
            newValue: newValue,
            exists: true,
            approved: false // Debe ser aprobado por gobernanza
        });

        emit CrossChainProposalReceived(_srcChainId, sourceContractAddress, newValue, currentProposalId);
    }

    // --- Funciones de configuración del LzApp ---
    // Estas son necesarias para la seguridad y el ruteo de LayerZero
    // Deben ser configuradas por el propietario (la DAO misma en un sistema real)
    function setMinDstGas(uint32 _dstChainId, uint16 _packetType, uint256 _minGas) public onlyOwner {
        minDstGas[_dstChainId][_packetType] = _minGas;
    }

    function setTrustedRemoteAddress(uint32 _remoteChainId, bytes calldata _remoteAddress) public onlyOwner {
        trustedRemoteAddress[_remoteChainId] = _remoteAddress;
    }

    function setTrustedRemote(uint32 _remoteChainId, bytes calldata _remoteAndLocalAddress) public onlyOwner {
        // El formato de _remoteAndLocalAddress es `bytes _remoteAddress + bytes _localAddress`
        setTrustedRemoteAddress(_remoteChainId, _remoteAndLocalAddress);
        // Aquí puedes agregar lógica para establecer la dirección local si es necesario
    }
}

2. Contrato de Gobernanza Secundario (Polygon - Amoy) 🥈

Este contrato actuará como un proxy en la cadena secundaria. Permitirá a los usuarios proponer un nuevo valor para someParameter en el contrato principal, enviando un mensaje cross-chain a través de LayerZero.

// contracts/SecondaryGovernance.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@layerzerolabs/lz-evm-sdk-v2/contracts/LzApp.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract SecondaryGovernance is LzApp, Ownable {
    address public mainGovernanceAddress; // Dirección del contrato principal en la cadena principal
    uint32 public mainChainId; // ID de la cadena principal

    event ProposalSent(uint32 indexed dstChainId, address indexed mainGovernanceAddress, uint256 newValue, uint256 lzFee);

    constructor(address _lzEndpoint, address _mainGovernanceAddress, uint32 _mainChainId) LzApp(_lzEndpoint) Ownable(msg.sender) {
        mainGovernanceAddress = _mainGovernanceAddress;
        mainChainId = _mainChainId;
    }

    // Función para proponer un nuevo valor para someParameter en la cadena principal
    function proposeParameterChange(uint256 _newValue) public payable {
        // Codificar el nuevo valor para el payload
        bytes memory payload = abi.encode(_newValue);

        // Calcular la tarifa de LayerZero
        // El "type" del paquete es 0 para un envío simple de LzApp.sol
        // El "gasLimit" es la cantidad de gas que el contrato _lzReceive gastará en la cadena de destino
        // El "nativeFee" es la cantidad de gas nativo (ej. ETH en Sepolia) para la transacción cross-chain
        (uint256 nativeFee, ) = lzEndpoint.quote(mainChainId, address(this)._code(), payload, 0);
        
        require(msg.value >= nativeFee, "Not enough native for LayerZero fee.");

        // Enviar el mensaje cross-chain
        // params: destinationChainId, destinationAddress (en bytes), payload, refundAddress, zroPaymentAddress, adapterParams
        _lzSend(
            mainChainId,
            abi.encodePacked(mainGovernanceAddress),
            payload,
            payable(msg.sender),
            address(0x0),
            ""
        );

        emit ProposalSent(mainChainId, mainGovernanceAddress, _newValue, nativeFee);
    }

    // _lzReceive no se usa en el contrato secundario para este flujo, pero debe existir
    function _lzReceive(
        uint32 _srcChainId,
        bytes calldata _srcAddress,
        uint64 _nonce,
        bytes calldata _payload
    ) internal override {
        // Este contrato secundario no espera recibir mensajes del principal en este ejemplo simple.
        // Podría implementarse lógica aquí si la DAO principal enviara notificaciones o comandos.
    }

    // --- Funciones de configuración del LzApp ---
    function setMinDstGas(uint32 _dstChainId, uint16 _packetType, uint256 _minGas) public onlyOwner {
        minDstGas[_dstChainId][_packetType] = _minGas;
    }

    function setTrustedRemoteAddress(uint32 _remoteChainId, bytes calldata _remoteAddress) public onlyOwner {
        trustedRemoteAddress[_remoteChainId] = _remoteAddress;
    }

    function setTrustedRemote(uint32 _remoteChainId, bytes calldata _remoteAndLocalAddress) public onlyOwner {
        setTrustedRemoteAddress(_remoteChainId, _remoteAndLocalAddress);
    }
}

3. Scripts de Despliegue y Configuración 🚀

Necesitamos scripts para desplegar ambos contratos y configurarlos para que "confíen" el uno en el otro. Esto es crucial para la seguridad de LayerZero.

// scripts/deploy.js
const hre = require("hardhat");

// IDs de cadena de LayerZero (LZ Chain IDs) para redes de prueba
const SEPOLIA_LZ_CHAIN_ID = 10161; // Consulta la documentación de LayerZero para los IDs correctos
const AMOY_LZ_CHAIN_ID = 10183;   // Consulta la documentación de LayerZero para los IDs correctos

async function main() {
  const [deployer] = await hre.ethers.getSigners();
  console.log("Deploying contracts with the account:", deployer.address);

  // --- Desplegar MainGovernance en Sepolia ---
  console.log("\n--- Deploying MainGovernance on Sepolia ---");
  await hre.changeNetwork("sepolia");
  const LzEndpointSepolia = await hre.ethers.getContractAt("ILzEndpointV2", "0x6EDCE6540307B2D19a5A92C1D262e316A3dF710D"); // Sepolia Endpoint
  // Nota: Usa el LZ Endpoint de Sepolia de la documentación de LayerZero
  const MainGovernance = await hre.ethers.getContractFactory("MainGovernance");
  const mainGovernance = await MainGovernance.deploy(LzEndpointSepolia.target);
  await mainGovernance.waitForDeployment();
  console.log("MainGovernance deployed to:", mainGovernance.target);

  // --- Desplegar SecondaryGovernance en Amoy ---
  console.log("\n--- Deploying SecondaryGovernance on Amoy ---");
  await hre.changeNetwork("amoy");
  const LzEndpointAmoy = await hre.ethers.getContractAt("ILzEndpointV2", "0x1a44076050125825905E737868f886Fc8DdeB097"); // Amoy Endpoint
  // Nota: Usa el LZ Endpoint de Amoy de la documentación de LayerZero
  const SecondaryGovernance = await hre.ethers.getContractFactory("SecondaryGovernance");
  const secondaryGovernance = await SecondaryGovernance.deploy(LzEndpointAmoy.target, mainGovernance.target, SEPOLIA_LZ_CHAIN_ID);
  await secondaryGovernance.waitForDeployment();
  console.log("SecondaryGovernance deployed to:", secondaryGovernance.target);

  // --- Configurar Trusted Remotes ---
  console.log("\n--- Setting Trusted Remotes ---");

  // Configurar MainGovernance para confiar en SecondaryGovernance
  await hre.changeNetwork("sepolia");
  console.log("Setting trusted remote for MainGovernance (on Sepolia) to SecondaryGovernance (on Amoy)...");
  await (await mainGovernance.setTrustedRemoteAddress(AMOY_LZ_CHAIN_ID, hre.ethers.zeroPadValue(secondaryGovernance.target, 32))).wait();
  console.log("Trusted remote set for MainGovernance.");

  // Configurar SecondaryGovernance para confiar en MainGovernance
  await hre.changeNetwork("amoy");
  console.log("Setting trusted remote for SecondaryGovernance (on Amoy) to MainGovernance (on Sepolia)...");
  await (await secondaryGovernance.setTrustedRemoteAddress(SEPOLIA_LZ_CHAIN_ID, hre.ethers.zeroPadValue(mainGovernance.target, 32))).wait();
  console.log("Trusted remote set for SecondaryGovernance.");

  // --- Configurar tarifas mínimas de gas (importante para que los mensajes pasen) ---
  console.log("\n--- Setting Min Dst Gas ---");

  // MainGovernance necesita saber cuánto gas dar al SecondaryGovernance
  await hre.changeNetwork("sepolia");
  // Para un paquete de tipo 0 (LZ_APP_APP_CONTEXT), un valor seguro es 200,000 gas, ajusta según la complejidad de _lzReceive
  await (await mainGovernance.setMinDstGas(AMOY_LZ_CHAIN_ID, 0, 200000)).wait(); 
  console.log("MinDstGas set for MainGovernance on Sepolia for Amoy.");

  // SecondaryGovernance necesita saber cuánto gas dar al MainGovernance
  await hre.changeNetwork("amoy");
  // Para un paquete de tipo 0 (LZ_APP_APP_CONTEXT), un valor seguro es 200,000 gas, ajusta según la complejidad de _lzReceive
  await (await secondaryGovernance.setMinDstGas(SEPOLIA_LZ_CHAIN_ID, 0, 200000)).wait();
  console.log("MinDstGas set for SecondaryGovernance on Amoy for Sepolia.");

  console.log("\nDeployment and configuration complete!");
  console.log("MainGovernance on Sepolia:", mainGovernance.target);
  console.log("SecondaryGovernance on Amoy:", secondaryGovernance.target);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

4. Interacción y Prueba de la DAO Cross-Chain 🧪

Una vez desplegados y configurados, podemos probar la comunicación cross-chain. Crearemos un script para simular una propuesta desde la cadena secundaria y su aprobación en la principal.

// scripts/interact.js
const hre = require("hardhat");

// Direcciones de contratos y LZ Chain IDs (ajusta con tus valores después del deploy.js)
const MAIN_GOVERNANCE_ADDRESS = "0x..."; // Dirección del MainGovernance desplegado en Sepolia
const SECONDARY_GOVERNANCE_ADDRESS = "0x..."; // Dirección del SecondaryGovernance desplegado en Amoy

const SEPOLIA_LZ_CHAIN_ID = 10161;
const AMOY_LZ_CHAIN_ID = 10183;

async function main() {
  const [deployer] = await hre.ethers.getSigners();

  // --- 1. Proponer un cambio desde Amoy (Cadena Secundaria) ---
  console.log("\n--- 1. Proposing change from Amoy (Secondary Chain) ---");
  await hre.changeNetwork("amoy");
  const secondaryGovernance = await hre.ethers.getContractAt("SecondaryGovernance", SECONDARY_GOVERNANCE_ADDRESS);
  
  const newValue = 42; // Nuevo valor que queremos establecer para someParameter
  console.log(`Proponiendo establecer 'someParameter' a ${newValue} desde Amoy...`);

  // Calcular la tarifa de LayerZero para enviar el mensaje
  // El _code() es una optimización, puedes usar address(this) o un hash del código.
  // Usamos el Endpoint para obtener la tarifa.
  const LzEndpointAmoy = await hre.ethers.getContractAt("ILzEndpointV2", "0x1a44076050125825905E737868f886Fc8DdeB097"); // Amoy Endpoint
  const payload = hre.ethers.utils.defaultAbiCoder.encode(["uint256"], [newValue]);
  const [nativeFee] = await LzEndpointAmoy.quote(SEPOLIA_LZ_CHAIN_ID, hre.ethers.utils.zeroPadValue(SECONDARY_GOVERNANCE_ADDRESS, 32), payload, 0);

  console.log(`LayerZero Native Fee: ${hre.ethers.formatEther(nativeFee)} MATIC`);
  
  const txPropuesta = await secondaryGovernance.proposeParameterChange(newValue, { value: nativeFee });
  await txPropuesta.wait();
  console.log("Propuesta enviada desde Amoy. TX Hash:", txPropuesta.hash);

  // Espera un momento para que LayerZero procese el mensaje
  console.log("Esperando que LayerZero entregue el mensaje a Sepolia (puede tardar unos minutos)...");
  await new Promise(resolve => setTimeout(resolve, 60000)); // Esperar 60 segundos

  // --- 2. Verificar la propuesta en Sepolia (Cadena Principal) ---
  console.log("\n--- 2. Verifying proposal on Sepolia (Main Chain) ---");
  await hre.changeNetwork("sepolia");
  const mainGovernance = await hre.ethers.getContractAt("MainGovernance", MAIN_GOVERNANCE_ADDRESS);

  // En este ejemplo simplificado, la primera propuesta tendrá el ID 1.
  // En un sistema real, buscarías por eventos o implementarías un registro más robusto.
  const proposalId = 1; 
  const proposal = await mainGovernance.activeProposals(proposalId);

  console.log("Estado de la propuesta en Sepolia:");
  console.log("  Existe:", proposal.exists);
  console.log("  Aprobada:", proposal.approved);
  console.log("  Nuevo Valor Propuesto:", proposal.newValue.toString());
  console.log("  Cadena de Origen:", proposal.sourceChainId);

  if (proposal.exists && !proposal.approved) {
    // --- 3. Aprobar la propuesta en Sepolia (Cadena Principal) ---
    console.log("\n--- 3. Approving proposal on Sepolia (Main Chain) ---");
    console.log(`Aprobando propuesta ${proposalId} en Sepolia...`);
    const txAprobar = await mainGovernance.approveProposal(proposalId);
    await txAprobar.wait();
    console.log("Propuesta aprobada en Sepolia. TX Hash:", txAprobar.hash);

    // --- 4. Ejecutar la propuesta en Sepolia (Cadena Principal) ---
    console.log("\n--- 4. Executing proposal on Sepolia (Main Chain) ---");
    console.log(`Ejecutando propuesta ${proposalId} en Sepolia...`);
    const txEjecutar = await mainGovernance.executeProposal(proposalId);
    await txEjecutar.wait();
    console.log("Propuesta ejecutada en Sepolia. TX Hash:", txEjecutar.hash);

    // --- 5. Verificar el parámetro actualizado ---
    console.log("\n--- 5. Verifying updated parameter ---");
    const updatedParameter = await mainGovernance.someParameter();
    console.log("Valor final de 'someParameter' en Sepolia:", updatedParameter.toString());
    if (updatedParameter.toString() === newValue.toString()) {
      console.log("✅ El parámetro se actualizó correctamente de forma cross-chain!");
    } else {
      console.log("❌ El parámetro NO se actualizó como se esperaba.");
    }

  } else if (proposal.exists && proposal.approved) {
    console.log("La propuesta ya fue aprobada.");
    // Intenta ejecutar si no se ejecutó
    const currentParameter = await mainGovernance.someParameter();
    if (currentParameter.toString() !== proposal.newValue.toString()) {
        console.log("Ejecutando propuesta (ya aprobada) en Sepolia...");
        const txEjecutar = await mainGovernance.executeProposal(proposalId);
        await txEjecutar.wait();
        console.log("Propuesta ejecutada. TX Hash:", txEjecutar.hash);
        const updatedParameter = await mainGovernance.someParameter();
        console.log("Valor final de 'someParameter' en Sepolia:", updatedParameter.toString());
    }
  } else {
    console.log("La propuesta aún no ha llegado o no existe. Revisa los logs de LayerZero.");
  }
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Consideraciones Avanzadas y Mejores Prácticas 💡

El ejemplo anterior es una implementación muy simplificada. Una DAO interoperable real necesitaría mucha más robustez.

1. Sistema de Votación y Propuestas Robusto ✅

• Votos Cross-Chain: Implementar un sistema donde los votos emitidos en cadenas secundarias se agreguen de forma segura en la cadena principal. Esto podría implicar el envío de firmas o hashes de voto a través de LayerZero, y luego la verificación en la cadena principal. Protocolos como Snapshot ya permiten votaciones off-chain que podrían integrarse.
• Períodos de Votación: Establecer períodos claros para las propuestas y votaciones, sincronizados entre cadenas (posiblemente usando timestamps o números de bloque relativos si la sincronización es crítica).
• Tipos de Propuesta: La DAO debe poder manejar diversos tipos de propuestas: cambios de parámetros, actualizaciones de contratos, asignación de fondos, etc.

2. Tesorería Multi-Chain y Gestión de Activos 💰

• Tokens Omnichain (OFT): LayerZero ofrece la capacidad de crear "Omnichain Fungible Tokens" (OFTs). Esto permite que el token de gobernanza de la DAO exista de forma nativa en múltiples cadenas sin puentes envueltos. Los miembros pueden transferir sus tokens de voto entre cadenas para participar donde sea más conveniente.
• Estrategias de Tesorería: Una DAO podría mantener diferentes activos en diferentes cadenas por razones estratégicas (ej. stablecoins en una L2, ETH en Ethereum mainnet). Las propuestas de la DAO deberían poder orquestar movimientos de activos cross-chain de forma segura.

3. Seguridad y Confianza 🛡️

• Validación del Origen: Siempre verifica _srcChainId y _srcAddress en la función _lzReceive para asegurarte de que los mensajes provienen de contratos y cadenas esperadas. Esto es crucial para prevenir ataques de suplantación.
• Auditorías: Los contratos interoperables añaden una capa de complejidad. Es imperativo realizar auditorías de seguridad exhaustivas por terceros.
• Gestión de Tarifas: Monitorea y ajusta las tarifas de LayerZero (setMinDstGas) ya que pueden variar con la congestión de la red y el precio del gas. La DAO debería tener un mecanismo para gestionar esto.

4. Experiencia de Usuario (UX) 🎯

• Interfaces Claras: Proporciona interfaces de usuario intuitivas que muestren claramente el estado cross-chain de las propuestas, el origen de los votos y el estado de la tesorería.
• Notificaciones: Implementa sistemas de notificación para alertar a los miembros sobre nuevas propuestas, finalización de votaciones o la ejecución de acciones, independientemente de la cadena en la que estén activos.

Tabla Comparativa: DAO Tradicional vs. Interoperable

Conclusión 🎉

El desarrollo de DAOs interoperables es un paso crucial hacia un ecosistema Web3 verdaderamente unificado y eficiente. Al aprovechar protocolos como LayerZero, las DAOs pueden superar las barreras de las cadenas individuales, expandir su alcance, aumentar la participación y optimizar sus operaciones. Aunque la implementación conlleva una mayor complejidad, los beneficios a largo plazo en términos de flexibilidad, escalabilidad y descentralización global son inmensos.

Esperamos que este tutorial te haya proporcionado una base sólida para empezar a explorar y construir tus propias DAOs interoperables. ¡El futuro es multi-cadena y las DAOs están liderando el camino!