Curso de programación y análisis de smart contracts: Ethereum y Cardano

Repositorio de trabajo del curso: el entorno, el código de ejemplo y la base de los talleres. Las slides se publican acá antes de cada clase.

Son 9 clases que recorren el desarrollo y la seguridad de smart contracts en las dos cadenas, contrastando el modelo de cuentas de Ethereum con el modelo EUTXO de Cardano.

Tesis del curso: cómo se escribe y cómo se rompe un contrato es una consecuencia directa del modelo de ejecución de la cadena. Todo lo demás —Solidity, Aiken, las vulnerabilidades, las herramientas— cuelga de esa distinción.

Empezar

1. Clonar (con el submódulo)

forge-std viaja como submódulo de git. Sin --recurse-submodules los tests de Ethereum no compilan:

git clone --recurse-submodules <URL-DE-ESTE-REPO>
cd curso-smartcontracts-alumnos

¿Ya clonaste sin eso? Se arregla con:

git submodule update --init --recursive

2. Construir la imagen del entorno

Incluye todas las herramientas de las 9 clases ya preparadas con cachés listas, para que la clase no se frene por problemas de instalación. El entorno funciona con Podman o con Docker, pero en los laboratorios se prefiere Podman.

Opcional: si no tenés Podman, Docker también sirve; la idea es la misma. La recomendación del curso es usar Podman en local y en el laboratorio.

Instalación rápida de Podman (Ubuntu/Debian):

sudo apt update
sudo apt install -y podman
podman --version

Si usás macOS, también podés instalarlo con Homebrew:

brew install podman

Podes crearla asi:

./scripts/build-image.sh arm64      # Apple Silicon
./scripts/build-image.sh amd64      # labs Intel

O levantar una imagen comprimida de aca: Repo Imagenes Podman y despues hacer:

podman load -i path-a-imagen 

Y cambiarle el nombre. Por ejemplo:

podman tag <IMAGE_ID_O_NOMBRE_ACTUAL> curso-sc:arm64

Y para entrar:

(si tenes arm)

podman run -it --rm -u root -v "$PWD":/curso:z curso-sc:arm64

(si tenes amd64)

podman run -it --rm -u root -v "$PWD":/curso:z curso-sc:amd64

El -v monta tu clon del repositorio dentro del contenedor en /curso. De esta forma, los cambios que hagas se guardan en tu directorio local y, cuando haya material nuevo, podés actualizarlo con git pull sin necesidad de reconstruir la imagen. Agregamos --userns=keep-id al ejecutar el contenedor para preservar los permisos de tu usuario sobre el directorio montado.

Guía completa —opcionales, servir las slides, anvil, demos— en docs/entorno-contenedor.md.

Si estas en el Laboratorio vas a tener que usar docker. Para eso tener que migrar la imagen:

chmod +x ./scripts/podman2docker.sh
./scripts/podman2docker.sh

Anota el nombre de la imagen (empieza con sha256:elNroDeImagen

Luego podes usar

docker run -it --rm -u root --name curso --network="host" -v "$PWD":/curso:z elNroDeImagen

3. Verificar que quedó bien

cd /curso/ethereum && forge test --no-match-contract AlcanciaTest    # 12 en verde y 2 SKIP (el taller de la Clase 7)
cd /curso/cardano  && aiken check -m claim -m cancel                 # 7 tests en verde

AlcanciaTest se excluye a propósito: son los tests de la actividad de la Clase 3 y arrancan en rojo. Completarlos es el ejercicio.

Instalación manual (sin contenedor)

• Ethereum: Foundry (forge, anvil) — ver ethereum/README.md
• Cardano: Aiken — ver cardano/README.md

Qué hay acá

.
├── Containerfile              # La imagen del entorno (Podman/Docker)
├── Containerfile.devnet       # Devnet local de Cardano (Yaci)
├── PROXIMAS-CLASES.md         # Qué material falta y cuándo llega
├── docs/
│   ├── entorno-contenedor.md  # Guía completa del entorno
│   └── slides/clase-NN/       # Diapositivas (placeholders hasta cada clase)
├── ethereum/                  # Proyecto Foundry
│   ├── src/Vault.sol          # Se construye en la Clase 3, se audita en la 7
│   ├── src/Alcancia.sol       # La actividad de la Clase 3 (con TODOs)
│   └── offchain/              # Bonus: Hardhat + ethers + chai
├── cardano/                   # Proyecto Aiken
│   ├── validators/escrow.ak   # Se construye en la Clase 5, se audita en la 8
│   ├── validators/vesting_vulnerable.ak  # El taller de la Clase 9 (con TODOs)
│   ├── Taller-Clase9.md       # Las consignas del taller de la Clase 9
│   └── offchain/              # Mesh: transacciones reales contra un devnet local
└── scripts/                   # build-image, devnet, demos, exportar slides

Ojo: las versiones vulnerables de las Clases 6 a 9 ya están (VaultVulnerable.sol, escrow_vulnerable.ak, vesting_vulnerable.ak); las arregladas no se publican: se escriben en los talleres. Ver PROXIMAS-CLASES.md.

Los dos hilos conductores

• Vault (Ethereum): se construye en la Clase 3 → se audita y explota en la Clase 7
• Escrow (Cardano): se construye en la Clase 5 → se audita en la Clase 9

Ver una transacción EUTXO en vivo (Clase 4)

./scripts/demo-tx-cardano.sh                          # el validator decidiendo, sin tocar la red
./scripts/devnet.sh up                                # un devnet local de Cardano (Yaci)…
cd cardano/offchain && npm install && npm run demo    # …y transacciones de verdad

Y para la Clase 8, con el mismo mecanismo: ./scripts/demo-bugs-cardano.sh, el catálogo de bugs EUTXO (double satisfaction, tiempo, minting) con los validators decidiendo sobre cada transacción.

Taller de análisis (Clase 7)

Encontrar los bugs del VaultVulnerable, escribir el exploit y el fix, y verificarlos. Las consignas están en ethereum/README.md.

cd ethereum
slither src/VaultVulnerable.sol                               # análisis estático
forge test --match-path test/VaultVulnerable.t.sol -vvvv      # sus PoCs (arrancan en SKIP)
halmos --contract VaultVulnerableHalmos                       # la solvencia, con halmos

halmos viene en la imagen a partir de la versión que lo agregó: si tu imagen es anterior, reconstruila (paso 2).

Taller de análisis (Clase 9)

Auditar el vesting_vulnerable, demostrar sus dos bugs con tests, escribir las propiedades que los destapan y el fix. Las consignas están en cardano/Taller-Clase9.md.

cd cardano
aiken check -m v2_                  # lo que anda (5 tests)
aiken check -m poc_ -m prop_        # los PoCs y las propiedades: los escribís vos (arrancan en rojo)

La primera vez, aiken check baja aiken-lang/fuzz de GitHub; la imagen reconstruida ya lo trae.

Y en el repaso, la double satisfaction del escrow en una cadena de verdad, con el devnet de la Clase 5: ./scripts/devnet.sh up y cd cardano/offchain && npm run demo-double.

Mantenerse al día

Las slides y el material de las clases de análisis se van sumando. Antes de cada clase:

git pull

Referencias principales

• Mastering Ethereum, 2ª edición (2025) — Antonopoulos, Wood et al.
• "I Can Aiken" (John Greene) — Aiken hands-on, sin Haskell
• Cyfrin Updraft (updraft.cyfrin.io) — auditoría, seguridad y verificación formal
• Mastering Cardano (IOG) — https://github.com/input-output-hk/mastering-cardano
• Cardano Developer Portal y documentación de Aiken

Licencia

Pendiente de elegir. Sugerencia habitual para material educativo: código bajo MIT y contenido (slides) bajo CC BY-SA 4.0.