> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kleros.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Construir con Vea

> Integra la mensajería entre cadenas de Vea con gateways emisores y receptores, VeaInbox y VeaOutbox para transmitir datos entre Arbitrum, Ethereum y Gnosis.

# Construir con Vea

Esta página explica cómo integrar Vea en una aplicación entre cadenas. Para los detalles a nivel de protocolo, consulta la [descripción general de Vea Bridge](https://docs.kleros.io/es/developers/crosschain/vea-bridge.md).

***

## Patrón de integración

Para integrar Vea, despliegas dos contratos gateway:

1. Un **Sender Gateway** en la cadena de envío, que se comunica con VeaInbox
2. Un **Receiver Gateway** en la cadena de recepción, que se comunica con VeaOutbox

```
Sender Gateway (Chain A) -> VeaInbox -> [Vea Bridge] -> VeaOutbox -> Receiver Gateway (Chain B)
```

Para cada par de cadenas de envío y recepción que admite Vea hay un conjunto separado de despliegues de contratos de Vea. En cada cadena hay exactamente un contrato desplegado.

***

## Sender Gateway

El Sender Gateway llama a `sendMessage()` en VeaInbox para iniciar la comunicación entre cadenas.

```solidity theme={null}
interface IVeaInbox {
    function sendMessage(
        address _to,        // address of Receiver Gateway on destination chain
        bytes4 _fnSelector, // function selector to call on Receiver Gateway
        bytes memory _data  // encoded parameters
    ) external;
}
```

Especificas:

* La dirección del contrato de destino en la cadena de recepción (`_to`)
* La función que se llamará en el destino (`_fnSelector`)
* Los parámetros codificados (`_data`)

### Ejemplo: Sender Gateway

```solidity theme={null}
contract SenderGateway {
    IVeaInbox public immutable veaInbox;
    address public immutable receiverGateway;

    constructor(IVeaInbox _veaInbox, address _receiverGateway) {
        veaInbox = _veaInbox;
        receiverGateway = _receiverGateway;
    }

    function sendMyMessage(uint256 _data) external {
        bytes4 selector = IReceiverGateway.receiveMessage.selector;
        bytes memory data = abi.encode(_data);
        veaInbox.sendMessage(receiverGateway, selector, data);
    }
}
```

***

## Receiver Gateway

El Receiver Gateway recibe el mensaje transmitido en la cadena de destino. Vea pasa el `msg.sender` de la cadena de envío como primer argumento de cualquier llamada entre cadenas.

```solidity theme={null}
interface IReceiverGateway {
    function veaOutbox() external view returns (address);
    function senderGateway() external view returns (address);
}
```

Tu función receptora siempre debe incluir `address msgSender` como primer parámetro:

```solidity theme={null}
contract ReceiverGateway is IReceiverGateway {
    address public override veaOutbox;
    address public override senderGateway;

    modifier onlyFromVea() {
        require(msg.sender == veaOutbox, "Only VeaOutbox");
        _;
    }

    function receiveMessage(address msgSender, uint256 _data) external onlyFromVea {
        require(msgSender == senderGateway, "Only SenderGateway");
        // Process _data
    }
}
```

> [!WARNING]
>
> Vea inserta el parámetro `msgSender` por seguridad. Tu interfaz siempre debe tener `address msgSender` como primer argumento. Los parámetros que enviaste van a continuación.

***

## Transmitir los mensajes

Una vez transcurrido el periodo de impugnación, un relayer llama a `verifyAndRelay()` en VeaOutbox para entregar el mensaje al Receiver Gateway.

El SDK de Vea ofrece funciones auxiliares para calcular las pruebas de inclusión de Merkle y obtener los datos de los mensajes que se van a transmitir:

```typescript theme={null}
import VeaSdk from "@kleros/vea-sdk";

// Create client for a specific route
  const vea = VeaSdk.ClientFactory.arbitrumSepoliaToChiadoDevnet(
  "https://sepolia-rollup.arbitrum.io/rpc",
  "https://rpc.chiadochain.net"
  
);

// Get message info by ID
const messageInfo = await vea.getMessageInfo(messageId);

// Calculate proof and relay
// ... relay logic using proof data
```

> [!NOTE]
>
> El SDK está en desarrollo activo. Consulta el [paquete del SDK de Vea](https://github.com/kleros/vea) para ver la API más reciente.

***

## Demo Lightbulb

La [demo Vea Lightbulb](https://docs.vea.ninja/build-xchain-dapps/lightbulb-demo) es una aplicación mínima entre cadenas en la que un interruptor en una cadena controla una bombilla en otra mediante Vea. El [repositorio del tutorial](https://github.com/kleros/vea-lightbulb-tutorial) explica cómo desplegar los contratos para cada par de cadenas.

El estado del puente se puede seguir en [VeaScan](https://veascan.io).

***

## Direcciones de despliegue

Consulta [Direcciones de despliegue de Vea](https://docs.kleros.io/es/developers/crosschain/vea-deployment-addresses.md) para ver las direcciones de los contratos en cada ruta admitida.

***

## Lecturas adicionales

> [card] [Guía de construcción completa](https://docs.vea.ninja/build-xchain-dapps/getting-started)
>
> Guía de integración completa en docs.vea.ninja

> [card] [Demo Lightbulb](https://docs.vea.ninja/build-xchain-dapps/lightbulb-demo)
>
> Aplicación de demostración interactiva entre cadenas

> [card] [Ejecuta un validador](https://docs.vea.ninja/run-a-validator/getting-started)
>
> Ejecuta un nodo validador del puente Vea

> [card] [Arquitectura de Vea Bridge](https://docs.kleros.io/es/developers/crosschain/vea-bridge.md)
>
> Arquitectura del protocolo y tipos de puente


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.