Introdução ao EthereumJ
1. Introdução
2. Sobre Ethereum
Ethereum é umcryptocurrency que aproveita um banco de dados ponto a ponto distribuído na forma deblockchain programável, a Máquina Virtual Ethereum (EVM). Ele é sincronizado e operado por meio denodes distintos, mas conectados.
A partir de 2017,Nodes sincronizablockchain por consenso, cria moedas por mineração (proof of work), verifica transações, executasmart contracts escrito emSolidity e executa o EVM.
Oblockchain é dividido emblocks que contémaccount states (incluindo transações entreaccounts) eproof of work.
3. OEthereum Facade
A classeorg.ethereum.facade.Ethereum abstrai e une muitos pacotes de EthereumJ em uma interface fácil de usar.
É possível se conectar a um nó para sincronizar com a rede geral e, uma vez conectado, podemos trabalhar com o blockchain.
Criar um objeto de fachada é tão fácil quanto:
Ethereum ethereum = EthereumFactory.createEthereum();4. Conectando-se à Rede Ethereum
Para conectar-se à rede, devemos primeiro conectar a um nó, i.e. um servidor executando o cliente oficial. Os nós são representados pela classeorg.ethereum.net.rlpx.Node.
Oorg.ethereum.listener.EthereumListenerAdapter lida com eventos de blockchain detectados por nosso cliente após a conexão a um nó ter sido estabelecida com sucesso.
4.1. Conectando-se à Rede Ethereum
Vamos nos conectar a um nó na rede. Isso pode ser feito manualmente:
String ip = "http://localhost";
int port = 8345;
String nodeId = "a4de274d3a159e10c2c9a68c326511236381b84c9ec...";
ethereum.connect(ip, port, nodeId);A conexão à rede também pode ser feita automaticamente usando um bean:
public class EthBean {
private Ethereum ethereum;
public void start() {
ethereum = EthereumFactory.createEthereum();
ethereum.addListener(new EthListener(ethereum));
}
public Block getBestBlock() {
return ethereum.getBlockchain().getBestBlock();
}
public BigInteger getTotalDifficulty() {
return ethereum.getBlockchain().getTotalDifficulty();
}
}Podemos então injetar nossoEthBean em nossa configuração de aplicativo. Em seguida, ele se conecta automaticamente à rede Ethereum e começa a baixar o blockchain.
Na verdade, a maior parte do processamento de conexão é convenientemente agrupada e abstraída meramente adicionando uma instânciaorg.ethereum.listener.EthereumListenerAdapter à nossa instânciaorg.ethereum.facade.Ethereum criada, como fizemos em nosso métodostart() acima:
EthBean eBean = new EthBean();
Executors.newSingleThreadExecutor().submit(eBean::start);4.2. Lidando com Blockchain usando um ouvinte
Também podemos criar uma subclasse deEthereumListenerAdapter para manipular eventos de blockchain detectados por nosso cliente.
Para realizar esta etapa, precisaremos tornar nosso listener de subclasse:
public class EthListener extends EthereumListenerAdapter {
private void out(String t) {
l.info(t);
}
//...
@Override
public void onBlock(Block block, List receipts) {
if (syncDone) {
out("Net hash rate: " + calcNetHashRate(block));
out("Block difficulty: " + block.getDifficultyBI().toString());
out("Block transactions: " + block.getTransactionsList().toString());
out("Best block (last block): " + ethereum
.getBlockchain()
.getBestBlock().toString());
out("Total difficulty: " + ethereum
.getBlockchain()
.getTotalDifficulty().toString());
}
}
@Override
public void onSyncDone(SyncState state) {
out("onSyncDone " + state);
if (!syncDone) {
out(" ** SYNC DONE ** ");
syncDone = true;
}
}
}O métodoonBlock() é acionado em qualquer novo bloco recebido (seja antigo ou atual). EthereumJ representa e trata blocos usando a classeorg.ethereum.core.Block.
O métodoonSyncDone() dispara quando a sincronização é concluída, atualizando nossos dados locais do Ethereum.
5. Trabalhando com o Blockchain
Agora que podemos nos conectar à rede Ethereum e trabalhar diretamente com o blockchain, vamos mergulhar em várias operações básicas, mas ainda assim muito importantes, que usaremos com frequência.
5.1. Enviando uma transação
Agora que estamos conectados ao blockchain, podemos enviar uma transação. Enviar umTransaction é relativamente fácil, mas criar umTransaction real é um tópico longo por si só:
ethereum.submitTransaction(new Transaction(new byte[]));5.2. Acesse o objetoBlockchain
The O método[.pl-en]# getBlockchain#() retorna um objeto de fachadaBlockchain com getters para buscar dificuldades de rede atuais eBlocks específicos.
Como configuramos nossoEthereumListener na seção 4.3, podemos acessar o blockchain usando o método acima:
ethereum.getBlockchain();5.3. Retorno de um endereço de conta Ethereum
Também podemos retornar um EthereumAddress.
Para obter um EthereumAccount –, primeiro precisamos autenticar um par de chaves pública e privada no blockchain.
Vamos criar uma nova chave com um novo par de chaves aleatórias:
org.ethereum.crypto.ECKey key = new ECKey();E vamos criar uma chave a partir de uma determinada chave privada:
org.ethereum.crypto.ECKey key = ECKey.fromPivate(privKey);Podemos então usar nossa chave para inicializar umAccount. Ao chamar.init(), definimos umECKey e oAddress associado no objetoAccount:
org.ethereum.core.Account account = new Account();
account.init(key);6. Outra Funcionalidade
Existem duas outras funcionalidades principais fornecidas pela estrutura que não cobriremos aqui, mas que vale a pena mencionar.
Primeiro, temos a capacidade de compilar e executar contratos inteligentes do Solidity. No entanto, criar contratos no Solidity e, posteriormente, compilá-los e executá-los é um tópico abrangente.
Segundo, embora a estrutura suporte mineração limitada usando uma CPU, o uso de uma mineradora de GPU é a abordagem recomendada, dada a falta de rentabilidade da primeira.
Tópicos mais avançados sobre o próprio Ethereum podem ser encontrados nodocs oficial.
7. Conclusão
Neste tutorial rápido, mostramos como conectar-se à rede Ethereum e vários métodos importantes para trabalhar com o blockchain.
Como sempre, o código usado neste exemplo pode ser encontradoover on GitHub.