Quicknode

4 de outubro de 2019 — 6 min de leitura

Empresas de todo o mundo utilizam Java para criar sistemas escaláveis que fazemos uso no nosso dia-a-dia. Hoje, vamos falar sobre o Web3j – uma biblioteca escrita em Java para Ethereum !

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:

O que é que o Web3j suporta?

O Web3j oferece um amplo suporte ao Ethereum :

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

• Compatibilidade com Ethereum

• 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

• Suporte ao Ethereum Service (ENS)

• Suporte às APIs do cliente «Personal» da Parity e do cliente «Personal» do Geth

• Suporte aos padrões de tokens ERC20 e ERC721

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

• Ferramentas de linha de comandos

• Compatível com Android

• Suporte para o Quorum do JP Morgan através do web3j-quorum

Além disso, também oferece suporte ao ENS e à Wallet 😎.

Além disso, é compatível com o Quorum: uma plataforma de blockchain criada pelo JPMorgan (o Chase, o banco!).

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>

Ligar-se à Ethereum utilizando o Web3j

Vamos começar a jogar!

Em primeiro lugar, vamos estabelecer ligação à Ethereum da Ethereum utilizando Quicknode o 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);

Aqui, estamos simplesmente a ligar-nos à Ethereum utilizando Quicknode a apresentar a versão do nosso Ethereum .

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

Os eventos são uma parte importante da Ethereum e funcionam como um mecanismo de registo das alterações no estado Ethereum .

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 é o endereço do nosso contrato inteligente, implementado na Ethereum da Ethereum .

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!