> For the complete documentation index, see [llms.txt](https://es-kb.topopool.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://es-kb.topopool.com/primeros-pasos/direcciones-payment-y-stake.md).

# Direcciones de payment y stake

Antes de registrar el pool necesitas dos cosas: una dirección de pago para cubrir las transacciones y depósitos, y una dirección de stake que vincularás al pool como pledge.

***

## 1. Generar las claves de pago

```bash
cardano-cli address key-gen \
  --verification-key-file $HOME/keys/payment.vkey \
  --signing-key-file      $HOME/keys/payment.skey
```

```bash
chmod 400 $HOME/keys/payment.skey
```

***

## 2. Generar las claves de stake

```bash
cardano-cli stake-address key-gen \
  --verification-key-file $HOME/keys/stake.vkey \
  --signing-key-file      $HOME/keys/stake.skey
```

```bash
chmod 400 $HOME/keys/stake.skey
```

***

## 3. Construir las direcciones

### Dirección de pago (con staking vinculado)

```bash
cardano-cli address build \
  --payment-verification-key-file $HOME/keys/payment.vkey \
  --stake-verification-key-file   $HOME/keys/stake.vkey \
  --mainnet \
  --out-file $HOME/keys/payment.addr
```

### Dirección de stake

```bash
cardano-cli stake-address build \
  --stake-verification-key-file $HOME/keys/stake.vkey \
  --mainnet \
  --out-file $HOME/keys/stake.addr
```

Guarda los valores:

```bash
cat $HOME/keys/payment.addr
# addr1qx...

cat $HOME/keys/stake.addr
# stake1u...
```

***

## 4. Crear el certificado de registro de stake

```bash
cardano-cli stake-address registration-certificate \
  --stake-verification-key-file $HOME/keys/stake.vkey \
  --key-reg-deposit-amt 2000000 \
  --out-file $HOME/tx/stake.cert
```

{% hint style="info" %}
**Era Conway (cardano-cli 10+):** el flag `--key-reg-deposit-amt` es obligatorio. El depósito es **2 ADA (2 000 000 lovelace)** y se recupera si cancelas el registro de stake en el futuro.
{% endhint %}

***

## 5. Fondear la dirección de pago

Transfiere ADA a la dirección `payment.addr` antes de continuar. Necesitas fondos suficientes para:

* Depósito de registro de stake: 2 ADA
* Depósito de registro del pool: 500 ADA
* Fees de transacciones: \~2–3 ADA en total
* Pledge (lo que hayas decidido comprometer)

{% hint style="warning" %}
**Mínimo operativo recomendado: 504 ADA** en la dirección de pago antes de proceder con el registro del pool.
{% endhint %}

Una vez transferido, consulta el UTxO para verificar:

```bash
cardano-cli query utxo \
  --address $(cat $HOME/keys/payment.addr) \
  --mainnet
```

La salida tendrá este aspecto:

```
                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
441c5b06...22ee0065     0        49992783811 lovelace + TxOutDatumNone
```

Anota el `TxHash` y el `TxIx` — los necesitarás para construir la transacción.

***

## 6. Registrar la dirección de stake

### Consultar los parámetros del protocolo

```bash
cardano-cli query protocol-parameters \
  --mainnet \
  --out-file $HOME/tx/protocol.json
```

### Construir la transacción

```bash
cardano-cli transaction build-raw \
  --tx-in <TXHASH>#<TXIX> \
  --tx-out $(cat $HOME/keys/payment.addr)+<CAMBIO> \
  --ttl <SLOT_LIMITE> \
  --fee <FEE> \
  --certificate-file $HOME/tx/stake.cert \
  --out-file $HOME/tx/tx.raw
```

{% hint style="info" %}
**¿Por qué `build-raw` y no `build`?** El comando `cardano-cli transaction build` auto-balancea la transacción y es más cómodo, pero requiere un nodo sincronizado accesible. `build-raw` es más explícito y te obliga a entender exactamente qué estás firmando. Ambos son válidos.
{% endhint %}

### Calcular el fee

```bash
cardano-cli transaction calculate-min-fee \
  --tx-body-file      $HOME/tx/tx.raw \
  --tx-in-count       1 \
  --tx-out-count      1 \
  --witness-count     2 \
  --mainnet \
  --protocol-params-file $HOME/tx/protocol.json
```

Reconstruye la transacción con el fee real y el cambio correcto:

```
CAMBIO = UTXO_LOVELACE - 2000000 (depósito) - FEE
```

### Firmar

```bash
cardano-cli transaction sign \
  --tx-body-file      $HOME/tx/tx.raw \
  --signing-key-file  $HOME/keys/payment.skey \
  --signing-key-file  $HOME/keys/stake.skey \
  --mainnet \
  --out-file $HOME/tx/tx.signed
```

### Enviar

```bash
cardano-cli transaction submit \
  --tx-file $HOME/tx/tx.signed \
  --mainnet
```

***

## Verificar el registro

Espera unos segundos y comprueba:

```bash
cardano-cli query stake-address-info \
  --address $(cat $HOME/keys/stake.addr) \
  --mainnet
```

Si el registro fue exitoso verás la dirección con `rewardAccountBalance` (inicialmente 0).

***

## Flujo completo resumido

```
Generar payment keys
       ↓
Generar stake keys
       ↓
Construir payment.addr y stake.addr
       ↓
Fondear payment.addr (mínimo ~504 ADA)
       ↓
Crear stake.cert (con --key-reg-deposit-amt 2000000)
       ↓
Construir → Firmar → Enviar tx con stake.cert
       ↓
Verificar con query stake-address-info
```