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

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

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.

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;
    }
}

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! 👇