Curso desplegado · teoría + práctica + código

Blockchain de cero a experto.

Ruta completa para aprender blockchain construyendo: criptografía, bloques, consenso, Bitcoin, Ethereum, smart contracts, DeFi, seguridad, rollups y auditoría.

Estudiar código

Aprender → Construir → Auditar

Teoría clara, Python, Elixir, tests, invariantes, ataques y mitigaciones.

Itinerario completo

Fase 0

Cero absoluto.

Fase 1

Criptografía.

Fase 2

Blockchain mínima.

Fase 3

Consenso.

Fase 4

Bitcoin.

Fase 5

Ethereum y smart contracts.

Fase 6

DeFi y riesgo.

Fase 7

Seguridad experta.

Smart contracts como máquinas de estado

Estado persistente + funciones públicas + permisos + eventos + invariantes.

Código formateado

def mint(contract, caller, to, amount) when amount > 0 do
  with :ok <- require_owner(contract, caller),
       :ok <- require_not_paused(contract) do
    updated = %{contract | balances: Map.update(contract.balances, to, amount, &(&1 + amount)), total_supply: contract.total_supply + amount}
    {:ok, emit(updated, {:mint, caller, to, amount})}
  end
end

def transfer(contract, caller, to, amount) when amount > 0 do
  with :ok <- require_not_paused(contract), :ok <- require_balance(contract, caller, amount) do
    balances = contract.balances |> Map.update!(caller, &(&1 - amount)) |> Map.update(to, amount, &(&1 + amount))
    {:ok, emit(%{contract | balances: balances}, {:transfer, caller, to, amount})}
  end
end

def block(index, prev, txs):
    b = {"index": index, "prev": prev, "txs": txs, "nonce": 0}
    while not h(b).startswith("000"):
        b["nonce"] += 1
    b["hash"] = h(b)
    return b

Evaluación

Explicar

Definir sin jerga.

Simular

Modificar parámetros.

Implementar

Crear módulos y tests.

Auditar

Encontrar invariantes rotas.