> ## 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.

# Inicio rápido

> Instala los contratos de Kleros, implementa la interfaz arbitrable y crea tu primera disputa con IArbitratorV2 de V2 o ERC-792 de V1 en Arbitrum o Ethereum.

El arbitraje de Kleros puede integrarse en cualquiera de las dos versiones del protocolo:

* **V1** utiliza el estándar de arbitraje ERC-792 (`IArbitrable` / `IArbitrator`) en la red principal de Ethereum y en Gnosis Chain. Consulta [ERC-792](https://docs.kleros.io/es/developers/arbitrable-apps/erc-792.md) y [ERC-1497](https://docs.kleros.io/es/developers/arbitrable-apps/erc-1497.md) para ver los estándares completos de V1.
* **V2** utiliza `IArbitrableV2` / `IArbitratorV2` en Arbitrum, con plantillas de disputa y compatibilidad entre cadenas.

Los pasos siguientes muestran ambas. Elige la versión que corresponda a la red en la que vas a desplegar. Para ver las direcciones de los contratos, consulta [Direcciones de despliegue V2](https://docs.kleros.io/es/reference/contracts/deployment-addresses.md) y [Direcciones de despliegue V1](https://docs.kleros.io/es/reference/contracts/deployment-addresses-v1.md).

## Instalación

```bash npm theme={null}
npm install @kleros/kleros-v2-contracts
```

```bash yarn theme={null}
yarn add @kleros/kleros-v2-contracts
```

```bash forge theme={null}
# Foundry: install the npm package, then map the import path
npm install @kleros/kleros-v2-contracts
echo "@kleros/kleros-v2-contracts/=node_modules/@kleros/kleros-v2-contracts/" >> remappings.txt
```

## Direcciones de los contratos (Arbitrum One)

```solidity theme={null}
// Core contracts
address constant KLEROS_CORE = 0x991d2df165670b9cac3B022f4B68D65b664222ea; // proxy
address constant DISPUTE_KIT_CLASSIC = 0x70B464be85A547144C72485eBa2577E5D3A45421; // proxy

// For cross-chain disputes, see the Gateways reference: /reference/contracts/gateways
```

> [!WARNING]
>
> Verifica siempre las direcciones con [Direcciones de despliegue V2](https://docs.kleros.io/es/reference/contracts/deployment-addresses.md) y con el [repositorio oficial](https://github.com/kleros/kleros-v2) antes de desplegar en producción.

## Integración mínima

### Paso 1: implementa la interfaz arbitrable

> [tab] V2 (IArbitrableV2)
>
> ```solidity theme={null}
> // SPDX-License-Identifier: MIT
> pragma solidity ^0.8.0;
>
> import "@kleros/kleros-v2-contracts/arbitration/interfaces/IArbitrableV2.sol";
> import "@kleros/kleros-v2-contracts/arbitration/interfaces/IArbitratorV2.sol";
>
> contract MyArbitrable is IArbitrableV2 {
>     IArbitratorV2 public immutable arbitrator;
>
>     mapping(uint256 => uint256) public externalIDtoLocalID;
>     mapping(uint256 => bool) public resolved;
>
>     constructor(IArbitratorV2 _arbitrator) {
>         arbitrator = _arbitrator;
>     }
>
>     function createDispute(
>         bytes calldata _extraData
>     ) external payable returns (uint256 disputeID) {
>         uint256 cost = arbitrator.arbitrationCost(_extraData);
>         require(msg.value >= cost, "Insufficient fee");
>
>         disputeID = arbitrator.createDispute{value: cost}(
>             2,          // numberOfChoices (e.g., 2 for binary)
>             _extraData  // court parameters
>         );
>
>         // Map arbitrator's ID to your local tracking
>         externalIDtoLocalID[disputeID] = /* your local ID */;
>
>         emit DisputeRequest(arbitrator, disputeID, /* params */);
>     }
>
>     function rule(uint256 _disputeID, uint256 _ruling) external override {
>         require(msg.sender == address(arbitrator), "Only arbitrator");
>         require(!resolved[_disputeID], "Already resolved");
>
>         resolved[_disputeID] = true;
>
>         // Execute your business logic based on _ruling
>         // 0 = refused to rule, 1+ = actual ruling choices
>
>         emit Ruling(arbitrator, _disputeID, _ruling);
>     }
> }
> ```

> [tab] V1 (ERC-792)
>
> ```solidity theme={null}
> // SPDX-License-Identifier: MIT
> pragma solidity ^0.7.0;
>
> import "@kleros/erc-792/contracts/IArbitrable.sol";
> import "@kleros/erc-792/contracts/IArbitrator.sol";
> import "@kleros/erc-792/contracts/erc-1497/IEvidence.sol";
>
> contract MyArbitrable is IArbitrable, IEvidence {
>     IArbitrator public arbitrator;
>
>     mapping(uint256 => bool) public resolved;
>
>     constructor(IArbitrator _arbitrator) {
>         arbitrator = _arbitrator;
>     }
>
>     function createDispute(
>         bytes memory _extraData,
>         string memory _metaEvidence
>     ) public payable returns (uint256 disputeID) {
>         uint256 cost = arbitrator.arbitrationCost(_extraData);
>         require(msg.value >= cost, "Insufficient fee");
>
>         // numberOfChoices (e.g., 2 for binary) + court params in _extraData
>         disputeID = arbitrator.createDispute{value: cost}(2, _extraData);
>
>         emit MetaEvidence(disputeID, _metaEvidence);
>         emit Dispute(arbitrator, disputeID, disputeID, disputeID);
>     }
>
>     function rule(uint256 _disputeID, uint256 _ruling) external override {
>         require(msg.sender == address(arbitrator), "Only arbitrator");
>         require(!resolved[_disputeID], "Already resolved");
>
>         resolved[_disputeID] = true;
>
>         // Execute your business logic based on _ruling
>         // 0 = refused to rule, 1+ = actual ruling choices
>
>         emit Ruling(arbitrator, _disputeID, _ruling);
>     }
> }
> ```

### Paso 2: codifica los datos adicionales

El parámetro `extraData` especifica el tribunal y el número de jurados:

```solidity theme={null}
function getExtraData(
    uint96 courtID,
    uint256 minJurors
) public pure returns (bytes memory) {
    return abi.encodePacked(courtID, minJurors);
}

// Example: General Court (ID 1) with 3 jurors
bytes memory extraData = getExtraData(1, 3);
```

### Paso 3: obtén el coste del arbitraje

```solidity theme={null}
function getArbitrationCost(bytes calldata extraData) external view returns (uint256) {
    return arbitrator.arbitrationCost(extraData);
}
```

## ID de los tribunales

| Tribunal | ID | Stake mínimo | Caso de uso |
| - | - | - | - |
| General | 1 | 200 PNK | Predeterminado, disputas generales |
| Blockchain Technical | Más alto | Disputas de contratos inteligentes | |
| Curation | Variable | Disputas de registros | |

> [!TIP]
>
> Empieza con el **General Court (ID: 1)** para las pruebas. Usa `minJurors = 3` en la mayoría de los casos.

## Plantillas de disputa

Los jurados necesitan contexto. Crea una plantilla que describa la disputa:

```json theme={null}
{
  "title": "Payment Dispute: Order #1234",
  "description": "Buyer claims goods not delivered...",
  "question": "Should the escrowed funds be released to the seller?",
  "answers": [
    { "id": "0x1", "title": "Yes", "description": "Release to seller" },
    { "id": "0x2", "title": "No", "description": "Refund to buyer" }
  ]
}
```

Registra las plantillas en la cadena o haz referencia a ellas mediante una URI de IPFS.

## Pruebas

**1. Usa Arbitrum Sepolia**

Despliega primero en testnet. Consigue ETH de Arbitrum Sepolia en un faucet público, como los de la [lista de faucets de Arbitrum](https://docs.arbitrum.io/for-devs/dev-tools-and-resources/chain-info)

**2. Consigue PNK de prueba**

El PNK de testnet está disponible en el faucet de Kleros

**3. Crea una disputa de prueba**

Llama a `createDispute()` con ETH de prueba para las tasas

## SDK (opcional)

Para la integración en el frontend, usa el Kleros SDK (`npm install @kleros/kleros-sdk`):

```typescript theme={null}
import { getDispute } from '@kleros/kleros-sdk';

// Read a dispute's details, populated from its dispute template
const dispute = await getDispute({
  disputeId: 123n,
  coreSubgraph: '<Kleros Core subgraph URL>',
  dtrSubgraph: '<Dispute Template Registry subgraph URL>',
});
```

Las URL de los subgraphs aparecen en [Endpoints del subgraph](https://docs.kleros.io/es/developers/subgraph/endpoints.md). Las evidencias se envían en la cadena a través del EvidenceModule; consulta [Direcciones de despliegue V2](https://docs.kleros.io/es/reference/contracts/deployment-addresses.md).

## Próximos pasos

> [card] [Análisis detallado de la arquitectura](https://docs.kleros.io/es/developers/architecture.md)
>
> Comprende cómo funcionan juntos KlerosCore, los Dispute Kits y el Sortition Module


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