Python e Blockchain: Criando Smart Contracts Simples
Python, embora não seja a linguagem nativa da maioria das blockchains (como Solidity no Ethereum), é uma ferramenta poderosa para:
Escrever scripts que interagem com blockchains
Testar contratos
Automatizar transações
Simular contratos simples
Neste post, vamos explorar como Python pode ser usado para criar e interagir com smart contracts, incluindo exemplos práticos, bibliotecas, ferramentas e boas práticas.
1. O que são Smart Contracts?
Smart contracts são programas que rodam em uma blockchain e executam regras automaticamente quando condições pré-definidas são atendidas. Características principais:
Imutabilidade: depois de publicado, o código não pode ser alterado.
Automação: executa transações sem intervenção humana.
Segurança: executado no ambiente descentralizado da blockchain.
Transparência: qualquer participante pode auditar o contrato.
Exemplos de uso:
Transferência de tokens automaticamente quando condições são atendidas.
Crowdfunding descentralizado.
Registro de ativos digitais (NFTs).
Sistemas de votação segura.
2. Blockchain e Python
Python não é a linguagem principal de smart contracts em blockchains públicas (como Ethereum, Binance Smart Chain), mas oferece ferramentas para:
Criar simulações de contratos em blockchain local.
Interagir com contratos Ethereum via Web3.py.
Automatizar transações, deploy e testes de contratos.
Criar blockchains privadas para aprendizado ou testes.
2.1 Bibliotecas Python relevantes
| Biblioteca | Função |
|---|---|
| Web3.py | Interação com Ethereum e contratos Solidity |
| Brownie | Framework para desenvolvimento e teste de smart contracts |
| eth-brownie | Deploy, teste e interação local com Ethereum |
| py-solc-x | Compilador de Solidity via Python |
| Ganache CLI | Blockchain Ethereum local para testes |
3. Criando uma blockchain simples em Python
Antes de mergulhar em smart contracts, vamos criar uma blockchain minimalista em Python para fins educativos:
import hashlib
import time
import json
class Block:
def __init__(self, index, timestamp, data, previous_hash):
self.index = index
self.timestamp = timestamp
self.data = data
self.previous_hash = previous_hash
self.hash = self.calc_hash()
def calc_hash(self):
block_string = f"{self.index}{self.timestamp}{self.data}{self.previous_hash}"
return hashlib.sha256(block_string.encode()).hexdigest()
class Blockchain:
def __init__(self):
self.chain = [self.create_genesis_block()]
def create_genesis_block(self):
return Block(0, time.time(), "Genesis Block", "0")
def add_block(self, data):
prev_block = self.chain[-1]
new_block = Block(len(self.chain), time.time(), data, prev_block.hash)
self.chain.append(new_block)
# Testando a blockchain
bc = Blockchain()
bc.add_block({"from": "Alice", "to": "Bob", "amount": 50})
bc.add_block({"from": "Bob", "to": "Charlie", "amount": 25})
for block in bc.chain:
print(vars(block))
Explicação:
Cada bloco tem hash próprio e referencia o bloco anterior.
Essa é uma base conceitual para entender como blockchain funciona.
Podemos adicionar contratos “simples” dentro do campo
data.
4. Introdução a Smart Contracts em Ethereum com Python
4.1 Instalando Web3.py
pip install web3
4.2 Criando um contrato Solidity simples
Arquivo SimpleStorage.sol:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
contract SimpleStorage {
uint256 public storedData;
function set(uint256 x) public {
storedData = x;
}
function get() public view returns (uint256) {
return storedData;
}
}
Descrição:
storedDataarmazena um número.set()atualiza o valor.get()retorna o valor atual.
4.3 Compilando o contrato em Python
from solcx import compile_standard, install_solc
import json
install_solc("0.8.0")
with open("SimpleStorage.sol", "r") as file:
simple_storage_file = file.read()
compiled_sol = compile_standard({
"language": "Solidity",
"sources": {"SimpleStorage.sol": {"content": simple_storage_file}},
"settings": {"outputSelection": {"*": {"*": ["abi", "metadata", "evm.bytecode"]}}}
})
bytecode = compiled_sol['contracts']['SimpleStorage']['SimpleStorage']['evm']['bytecode']['object']
abi = compiled_sol['contracts']['SimpleStorage']['SimpleStorage']['abi']
5. Conectando a blockchain local com Web3.py
Para testes, use Ganache CLI (blockchain Ethereum local):
npm install -g ganache-cli
ganache-cli
Python script para deploy:
from web3 import Web3
w3 = Web3(Web3.HTTPProvider("http://127.0.0.1:8545"))
chain_id = 1337
my_address = "0xYourAddress"
private_key = "0xYourPrivateKey"
SimpleStorage = w3.eth.contract(abi=abi, bytecode=bytecode)
nonce = w3.eth.get_transaction_count(my_address)
transaction = SimpleStorage.constructor().buildTransaction({
"chainId": chain_id,
"from": my_address,
"nonce": nonce,
"gasPrice": w3.eth.gas_price
})
signed_txn = w3.eth.account.sign_transaction(transaction, private_key=private_key)
tx_hash = w3.eth.send_raw_transaction(signed_txn.rawTransaction)
tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
print("Contrato implantado em:", tx_receipt.contractAddress)
Explicação:
Deploy do contrato em blockchain local.
Retorna endereço do contrato para interações futuras.
6. Interagindo com o smart contract
simple_storage = w3.eth.contract(address=tx_receipt.contractAddress, abi=abi)
# Ler valor inicial
print("Valor armazenado:", simple_storage.functions.get().call())
# Atualizar valor
nonce = w3.eth.get_transaction_count(my_address)
tx = simple_storage.functions.set(42).buildTransaction({
"chainId": chain_id,
"from": my_address,
"nonce": nonce,
"gasPrice": w3.eth.gas_price
})
signed_tx = w3.eth.account.sign_transaction(tx, private_key=private_key)
tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
w3.eth.wait_for_transaction_receipt(tx_hash)
# Ler valor atualizado
print("Novo valor armazenado:", simple_storage.functions.get().call())
Dica criativa: você pode criar smart contracts simples para votação, crowdfunding ou registro de ativos digitais, tudo testável localmente com Python.
7. Boas práticas ao desenvolver smart contracts
Teste localmente antes de deploy em rede principal.
Evite loops infinitos ou operações caras (alto consumo de gas).
Segurança: validação de inputs, prevenção de overflow e reentrancy attacks.
Documente contratos: ABI, funções públicas e eventos.
Versionamento: mantenha contratos e scripts Python versionados juntos para auditabilidade.
8. Extensões avançadas
Brownie Framework: automatiza testes, deploy e integração com Python.
Web3.py + Flask / FastAPI: crie APIs que interagem com contratos e disponibilize dados para aplicações web ou dashboards.
Testes automatizados com Pytest e contratos simulados: importante para contratos mais complexos.
Integração com front-end: React ou Vue.js + Web3.py backend para criar DApps completos.
9. Projeto exemplo completo
Objetivo: smart contract simples de votação.
Contrato Solidity:
Voting.sol(candidatos, voto único por address).Python: deploy local com Ganache, interação via Web3.py, contagem de votos.
Dashboards: Streamlit para mostrar resultados em tempo real.
Extras: validação de votos e registro em blockchain de teste para auditabilidade.
Estrutura sugerida:
python-blockchain/
├── contracts/
│ └── Voting.sol
├── scripts/
│ ├── deploy.py
│ └── interact.py
├── tests/
│ └── test_voting.py
├── frontend/
│ └── streamlit_dashboard.py
└── README.md
10. Conclusão
Python é uma ferramenta poderosa para aprendizado, testes e interação com smart contracts, mesmo que não seja a linguagem nativa da maioria das blockchains. Com bibliotecas como Web3.py, py-solc-x e Brownie, é possível:
Criar smart contracts simples
Testar e simular blockchains localmente
Automatizar deploy e interações
Integrar com dashboards e aplicações web
Próximos passos sugeridos:
Experimentar contratos de tokens ERC20 ou NFTs locais.
Criar API Python que expõe dados do contrato para front-end ou sistemas corporativos.
Explorar frameworks como Brownie para testes unitários de contratos complexos.
Comentários
Postar um comentário