Quicknode

4 de outubro de 2019 — 6 min de leitura

Enterprises all over the world use Java to build scalable systems which we use in our daily lives. Today, we will talk about Web3j – a library written in Java for Ethereum developers!

O que é o Web3j?

Biblioteca Java web3j para disponibilizar as APIsEthereum RPCEthereum . Pode utilizá-la para desenvolver aplicações web, móveis ou de qualquer outro tipo. A documentação do web3j descreve:

What does Web3j support?

Web3j has rich support of Ethereum JSON-RPC:

• Implementação completa da API do cliente JSON-RPC Ethereumatravés de HTTP e IPC

• Ethereum wallet support

• Geração automática de wrappers de contratos inteligentes em Java para criar, implementar, efetuar transações e chamar contratos inteligentes a partir de código Java nativo (formatos de definiçãoSolidity e Truffle suportados)

• API com funcionalidades reativas para trabalhar com filtros

• Ethereum Name Service (ENS) support

• Support for Parity’s Personal, and Geth’s Personal client APIs

• Support for ERC20 and ERC721 token standards

• Testes de integração abrangentes que demonstram vários dos cenários acima referidos

• Ferramentas de linha de comandos

• Compatível com Android

• Support for JP Morgan’s Quorum via web3j-quorum

Additionally, it also provides ENS and Wallet support 😎.

Moreover, it supports Quorum: a blockchain framework created by JPMorgan (Chase, the bank!).

Exemplos do Web3j

Vamos criar um projeto e analisar o código em profundidade. Vamos ver alguns Ethereum básicos Ethereum e como podemos utilizar o Web3j para criar Ethereum em Java.

Pré-requisito

• Java, versão 8 ou superior

• Maven

• Qualquer IDE Java (estou a utilizar a versão Community do IntelliJ)

• Solc (compilador Solidity)

• A Quicknode Quicknode.com)

• Ferramentas de linha de comandos do Web3j

Nota: estamos a utilizar o Ubuntu Bionic (18.04)

Instalar o compilador Solc

Precisamos de instalar o compilador Solidity... vamos utilizá-lo para compilar o nosso contrato inteligente mais tarde. Consulte aqui um guia de instalação detalhado.

sudo add-apt-repository ppa:ethereum
sudo apt-get update
sudo apt-get install solc

Configurar o projeto

Vamos criar um novo projeto e importar a dependência Web3j utilizando o Maven.

<!-- https://mvnrepository.com/artifact/org.web3j/core -->
<dependency>    
   <groupId>org.web3j</groupId>    
   <artifactId>core</artifactId>    
   <version>4.5.5</version>
</dependency>

Connecting to Ethereum Blockchain using Web3j

Vamos começar a jogar!

First, we will connect to the Ethereum blockchain using Quicknode and Web3j.

Nota: Se tiver alguma dificuldade em seguir o tutorial, incluímos o repositório do GitHub no final.

Web3j web3 = Web3j.build(new HttpService("YOUR_QUICKNODE_URL"));

Web3ClientVersion web3ClientVersion = web3.web3ClientVersion().send();

String clientVersion = web3ClientVersion.getWeb3ClientVersion(); System.out.println("Versão do cliente" + clientVersion);

Here we are simply connecting to Ethereum blockchain using Quicknode and printing our Ethereum client version.

Criar uma Ethereum

Vamos criar agora uma Ethereum utilizando o Web3j. O Web3j oferece funcionalidades completas de gestão de carteiras. Para o efeito, iremos utilizar o WalletUtils.

Aqui estamos a definir a palavra-passe da nossa carteira e o caminho onde o ficheiro da carteira será guardado. Adicionei a minha própria palavra-passe e o meu próprio diretório, de acordo com o meu sistema.

String walletPassword = "trumpshouldbeimpeached";
String walletDirectory = "/home/batman/wallet/"; // adicione o caminho do seu próprio diretório da carteira

String walletName = WalletUtils.generateNewWalletFile(walletPassword, new File(walletDirectory)); System.out.println(walletName);

Carregar Ethereum

Agora vamos ver como podemos carregar a nossa carteira que acabámos de criar e obter um novo endereço a partir dela.

Credentials credentials = WalletUtils.loadCredentials(walletPassword, walletDirectory + "/" + walletName);

String accountAddress = credentials.getAddress(); System.out.println("Endereço da conta: " + accountAddress);

Inscrição em Ethereum

Events are important part of Ethereum blockchain and serve as a logging mechanism for Ethereum blockchain State changes.

Subscrição de novos blocos

A cada poucos segundos (13, em média), é minerado um novo Ethereum . Vamos acompanhar isso:

Subscription subscription = (Subscription) web3.blockFlowable(false).subscribe(block -> {    System.out.println(block.getBlock().getHash());});

Subscrição de novas transações

Os blocos contêm transações; também podemos subscrevê-las:

Subscription subscription = (Subscription) web3.transactionFlowable().subscribe(tx -> {    System.out.println(tx.getHash());});

Subscrição de transações pendentes

Sempre que é criada uma transação, esta passa primeiro pela mempool. A partir do mempool, os mineradores selecionam as transações para minerar. Até que um minerador selecione uma transação, esta permanece no estado «pendente». Vamos subscrever agora as transações pendentes.

Subscription subscription = (Subscription)web3.pendingTransactionFlowable().subscribe(tx -> {   System.out.println(tx.getHash());});

Subscrever eventos de contratos inteligentes

Ethereum a utilização de contratos inteligentes. A subscrição de eventos de contratos inteligentes constitui um caso de utilização muito importante na criação de dApps (aplicações descentralizadas) na Ethereum.

O contrato inteligente SimpleBank.sol

Criámos um contrato inteligente do SimpleBank que emite um Depósito sempre que alguém efetuar um depósito no nosso banco.

pragma solidity ^0.5.8;

contract SimpleBank {
    uint8 private clientCount;
    mapping (address => uint) private balances;
    address public owner;

    event LogDepositMade(address indexed accountAddress, uint amount);

    constructor() public payable {
        owner = msg.sender;
        clientCount = 0;
    }


    function enroll() public returns (uint) {
        if (clientCount < 3) {
            clientCount++;
            balances[msg.sender] = 10 ether;
        }
        return balances[msg.sender];
    }


    function deposit() public payable returns (uint) {
        balances[msg.sender] += msg.value;
        emit LogDepositMade(msg.sender, msg.value);
        return balances[msg.sender];
    }


    function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
        // Check enough balance available, otherwise just return balance
        if (withdrawAmount <= balances[msg.sender]) {
            balances[msg.sender] -= withdrawAmount;
            msg.sender.transfer(withdrawAmount);
        }
        return balances[msg.sender];
    }


    function balance() public view returns (uint) {
        return balances[msg.sender];
    }

    function depositsBalance() public view returns (uint) {
        return address(this).balance;
    }
}

Pode implementar este contrato utilizando o Web3j, o que veremos no nosso próximo tutorial.

Por enquanto, vamos implementar o nosso contrato utilizando o Remix (um IDE online para Solidity).

Após a implementação, guarde o endereço do seu contrato num local qualquer (vamos precisar dele mais à frente neste tutorial).

Agora precisamos de compilar o nosso contrato inteligente SimpleBank.

Para isso, vamos utilizar solc compilador.

Here replace <contract>.sol with our SimpleBank.sol, and also provide an output directory:

$ solc <contract>.sol --bin --abi --optimize -o <output-dir>/

O Web3j disponibiliza uma ferramenta de linha de comandos para gerar uma classe Java Wrapper para o seu contrato inteligente em Solidity. Para instalar a ferramenta de linha de comandos do Web3j, consulte aqui.

Agora estamos prontos para gerar a nossa classe de envoltório do contrato inteligente utilizando o comando abaixo:

web3j solidity generate -b /path/to/<smart-contract>.bin -a /path/to/<smart-contract>.abi -o /path/to/src/main/java -p com.your.organisation.name

Depois de substituir os argumentos, no meu caso, este comando ficou assim:

web3j solidity generate -b SimpleBank/SimpleBank.bin -a SimpleBank/SimpleBank.abi -o ~quicknode-p com.simplebank

Isto irá gerar uma classe Java chamada SimpleBank no caminho indicado.

Obter uma instância de um contrato inteligente

Agora, vamos criar uma instância do nosso contrato inteligente para podermos interagir com ele.

SimpleBank simpleBank = SimpleBank.load("0x7208b4883a4dF0F3e5cD084F2F9C579e7b622A38", web3, credentials, new DefaultGasProvider());

Nota: Aqui 0x7208b4883a4dF0F3e5cD084F2F9C579e7b622A38 is our Smart Contract address, deployed on the Ethereum blockchain.

Agora podemos ouvir Depósito evento do nosso Web3j.

simpleBank.logDepositMadeEventFlowable(DefaultBlockParameterName.EARLIEST, DefaultBlockParameterName.LATEST).doOnError(error -> System.err.println("A mensagem de erro é: " + error.getMessage()))        .subscribe(logDepositMadeEventResponse ->                System.out.println(logDepositMadeEventResponse.amount));

A classe SimpleBank cria um logDepositMadeEventFlowable método que podemos utilizar para subscrever Depósito eventos.

Assim que tivermos o evento, imprimimos o montante do depósito, que é emitido juntamente com o evento de depósito.

No próximo tutorial, vamos aprofundar o tema das transações com o Web3j e da chamada de métodos do contrato SimpleBank.

Código completo — Aqui está o código completo no GitHub.

Precisa de ajuda com o seu projeto ou tem alguma dúvida? Contacte-nos através deste formulário, no TwitterQuicknode ou envie-nos uma mensagem no Discord!