Python y Blockchain: Cómo Crear un Smart Contract con Web3.py

La tecnología blockchain ha revolucionado la forma en que concebimos las transacciones digitales, la seguridad de los datos y la ejecución de contratos autónomos. Los smart contracts (contratos inteligentes) son una de las aplicaciones más poderosas de blockchain, permitiendo acuerdos auto-ejecutables sin intermediarios.

En este artículo, exploraremos cómo Python puede integrarse con blockchain para crear y desplegar un smart contract utilizando Web3.py, la biblioteca más popular para interactuar con Ethereum y otras redes descentralizadas.

¿Qué aprenderás?

• Conceptos básicos de blockchain y smart contracts.
• Configuración del entorno de desarrollo con Python y Web3.py.
• Escritura y despliegue de un smart contract en la red Ethereum (testnet).
• Interacción con el contrato desde Python.

---

1. Fundamentos de Blockchain y Smart Contracts

1.1 ¿Qué es Blockchain?

Blockchain es una base de datos distribuida que registra transacciones de manera inmutable, transparente y segura mediante criptografía. Cada bloque contiene un conjunto de transacciones y está enlazado al anterior, formando una cadena.

🔹 Características clave:

• Descentralización: No hay una entidad central que controle la red.
• Inmutabilidad: Los datos no pueden alterarse una vez registrados.
• Consenso: Las transacciones se validan mediante algoritmos (Proof of Work, Proof of Stake).

1.2 ¿Qué son los Smart Contracts?

Un smart contract es un programa almacenado en la blockchain que se ejecuta automáticamente cuando se cumplen ciertas condiciones.

🔹 Ejemplos de uso:

• Finanzas descentralizadas (DeFi): Préstamos automatizados.
• NFTs: Contratos para tokens no fungibles.
• Votación electrónica: Sistemas transparentes y auditables.

---

2. Configuración del Entorno de Desarrollo

2.1 Requisitos Previos

• Python 3.8+ instalado.
• Conocimientos básicos de programación en Python.
• Cuenta en Infura (para conexión con Ethereum).
• Metamask (billetera Ethereum).

2.2 Instalación de Dependencias

pip install web3 solcx

• Web3.py: Biblioteca para interactuar con Ethereum.
• Solcx: Compilador de Solidity (lenguaje para smart contracts).

2.3 Configuración de Infura y MetaMask

1. Crea un proyecto en Infura y obtén tu API Key para la testnet (Ropsten, Goerli o Sepolia).
2. Configura MetaMask y obtén tu clave privada (solo para desarrollo, nunca la expongas en producción).

---

3. Creación de un Smart Contract Básico en Solidity

3.1 Estructura de un Smart Contract

Usaremos Solidity, el lenguaje más popular para contratos en Ethereum.

📄 Ejemplo: Contrato de almacenamiento simple (Storage.sol)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 private storedData;

    function set(uint256 x) public {
        storedData = x;
    }

    function get() public view returns (uint256) {
        return storedData;
    }
}

🔹 Explicación:

• set(x): Guarda un número en la blockchain.
• get(): Lee el número almacenado.

3.2 Compilación del Contrato con Solcx

from solcx import compile_standard, install_solc

install_solc("0.8.0")  # Instala la versión de Solidity

compiled_sol = compile_standard(
    {
        "language": "Solidity",
        "sources": {"Storage.sol": {"content": open("Storage.sol").read()}},
        "settings": {"outputSelection": {"*": {"*": ["abi", "evm.bytecode"]}}},
    },
    solc_version="0.8.0",
)

# Guarda el ABI y el bytecode
abi = compiled_sol["contracts"]["Storage.sol"]["SimpleStorage"]["abi"]
bytecode = compiled_sol["contracts"]["Storage.sol"]["SimpleStorage"]["evm"]["bytecode"]["object"]

---

4. Despliegue del Smart Contract en Ethereum

4.1 Conexión con la Blockchain usando Web3.py

from web3 import Web3

# Configuración de Web3 (usando Infura)
infura_url = "https://sepolia.infura.io/v3/TU_API_KEY"
w3 = Web3(Web3.HTTPProvider(infura_url))

# Verifica la conexión
print(f"Conectado: {w3.is_connected()}")

4.2 Despliegue del Contrato

# Configura la cuenta (usando clave privada de MetaMask)
private_key = "TU_CLAVE_PRIVADA"
account = w3.eth.account.from_key(private_key)

# Prepara la transacción
contract = w3.eth.contract(abi=abi, bytecode=bytecode)
txn = contract.constructor().build_transaction({
    "chainId": 11155111,  # Sepolia Testnet
    "gas": 2000000,
    "gasPrice": w3.to_wei("50", "gwei"),
    "nonce": w3.eth.get_transaction_count(account.address),
})

# Firma y envía la transacción
signed_txn = account.sign_transaction(txn)
txn_hash = w3.eth.send_raw_transaction(signed_txn.rawTransaction)
txn_receipt = w3.eth.wait_for_transaction_receipt(txn_hash)

print(f"Contrato desplegado en: {txn_receipt.contractAddress}")

---

5. Interacción con el Smart Contract desde Python

5.1 Llamando a las Funciones del Contrato

# Conecta al contrato usando su dirección
contract_address = txn_receipt.contractAddress
contract_instance = w3.eth.contract(address=contract_address, abi=abi)

# Ejecuta la función set()
txn = contract_instance.functions.set(42).build_transaction({
    "chainId": 11155111,
    "gas": 2000000,
    "gasPrice": w3.to_wei("50", "gwei"),
    "nonce": w3.eth.get_transaction_count(account.address),
})
signed_txn = account.sign_transaction(txn)
txn_hash = w3.eth.send_raw_transaction(signed_txn.rawTransaction)
txn_receipt = w3.eth.wait_for_transaction_receipt(txn_hash)

# Lee el valor con get()
value = contract_instance.functions.get().call()
print(f"Valor almacenado: {value}")  # Output: 42

---

6. Conclusiones y Siguientes Pasos

Hemos creado y desplegado un smart contract en la blockchain de Ethereum usando Python y Web3.py. Este es solo el comienzo; puedes explorar:

• Integración con DeFi (Uniswap, Aave).
• Desarrollo de NFTs con Python.
• Optimización de gas y seguridad en contratos.

La combinación de Python y blockchain abre un mundo de posibilidades para desarrolladores. ¡Sigue experimentando y construyendo! 🚀

---

Recursos Adicionales

• Documentación oficial de Web3.py
• Solidity Docs
• Infura (Para nodos Ethereum)

¿Te gustaría profundizar en algún tema en particular? ¡Déjalo en los comentarios! 👇