Quicknode

4 de octubre de 2019 — 6 minutos de lectura

Empresas de todo el mundo utilizan Java para crear sistemas escalables que utilizamos en nuestra vida cotidiana. Hoy hablaremos de Web3j, ¡una biblioteca escrita en Java para Ethereum !

¿Qué es Web3j?

Biblioteca Java web3j para acceder a las APIEthereum . Se puede utilizar para desarrollar aplicaciones web, móviles o de cualquier otro tipo. La documentación de web3j describe:

¿Qué es lo que admite Web3j?

Web3j ofrece una amplia compatibilidad con Ethereum :

• Implementación completa de la API de cliente JSON-RPC Ethereuma través de HTTP e IPC

• Compatibilidad con Ethereum

• Generación automática de envoltorios de contratos inteligentes en Java para crear, implementar, realizar transacciones e invocar contratos inteligentes desde código Java nativo (compatible con los formatos de definiciónde Solidity y Truffle )

• API con funcionalidad reactiva para trabajar con filtros

• Compatibilidad con Ethereum Service (ENS)

• Compatibilidad con las API de los clientes «Personal» de Parity y «Personal » de Geth

• Compatibilidad con los estándares de tokens ERC20 y ERC721

• Pruebas de integración exhaustivas que ilustran varios de los escenarios mencionados anteriormente

• Herramientas de línea de comandos

• Compatible con Android

• Compatibilidad con Quorum de JP Morgan a través de web3j-quorum

Además, también es compatible con ENS y Wallet 😎.

Además, es compatible con Quorum: un marco de trabajo de cadena de bloques creado por JPMorgan (¡Chase, el banco!).

Ejemplos de Web3j

Creemos un proyecto y analicemos el código en profundidad. Veremos algunos Ethereum básicos Ethereum y cómo podemos utilizar Web3j para desarrollar Ethereum en Java.

Requisito previo

• Java, versión 8 o superior

• Maven

• Cualquier IDE de Java (yo utilizo la versión Community de IntelliJ)

• Solc (compilador de Solidity)

• A Quicknode Quicknode.com)

• Herramientas de línea de comandos de Web3j

Nota: estamos utilizando Ubuntu Bionic (18.04)

Instalar el compilador Solc

Tenemos que instalar el compilador de Solidity... lo utilizaremos más adelante para compilar nuestro contrato inteligente. Consulta aquí una guía de instalación detallada.

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

Configuración del proyecto

Creemos un nuevo proyecto e importemos la dependencia Web3j mediante Maven.

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

Conexión a Ethereum mediante Web3j

¡Empecemos a jugar!

En primer lugar, nos conectaremos a la Ethereum utilizando Quicknode Web3j.

Nota: Si tienes algún problema al seguir el tutorial, hemos incluido el repositorio de GitHub al final.

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

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

String clientVersion = web3ClientVersion.getWeb3ClientVersion(); System.out.println("Versión del cliente" + clientVersion);

Aquí simplemente nos conectamos a Ethereum mediante Quicknode mostramos la versión Ethereum nuestro Ethereum .

Cómo crear una Ethereum

Vamos a crear ahora un Ethereum utilizando Web3j. Web3j ofrece todas las funciones necesarias para la gestión del monedero. Para ello, utilizaremos WalletUtils.

Aquí especificamos la contraseña de nuestro monedero y la ruta donde se guardará el archivo del monedero. He añadido mi propia contraseña y mi propio directorio según mi sistema.

String walletPassword = "trumpshouldbeimpeached";
String walletDirectory = "/home/batman/wallet/"; //añade la ruta de tu propio directorio de monedero

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

Cargar Ethereum

Ahora veamos cómo podemos cargar el monedero que acabamos de crear y obtener una nueva dirección del mismo.

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

String accountAddress = credentials.getAddress(); System.out.println("Dirección de la cuenta: " + accountAddress);

Suscribirse a Ethereum

Los eventos son una parte importante de Ethereum y sirven como mecanismo de registro de los cambios en el estado Ethereum .

Suscripción a nuevos bloques

Cada pocos segundos (13, de media), se extrae un nuevo Ethereum . Vamos a seguirlo:

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

Suscripción a nuevas transacciones

Los bloques contienen transacciones; también podemos suscribirnos a ellos:

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

Suscripción a las transacciones pendientes

Cada vez que se crea una transacción, primero pasa a la mempool. De la mempool, los mineros seleccionan las transacciones para minarlas. Hasta que un minero selecciona una transacción, esta permanece en estado pendiente. Vamos a suscribirnos ahora a las transacciones pendientes.

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

Suscribirse a los eventos de los contratos inteligentes

Ethereum el uso de contratos inteligentes. Suscribirse a los eventos de los contratos inteligentes es un caso de uso muy importante a la hora de desarrollar dApps (aplicaciones descentralizadas) en Ethereum.

El contrato inteligente SimpleBank.sol

Hemos creado un contrato inteligente de SimpleBank que emite un Depósito cada vez que alguien realiza un ingreso en nuestro 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;
    }
}

Puedes implementar este contrato utilizando Web3j, como veremos en nuestro próximo tutorial.

Por ahora, vamos a desplegar nuestro contrato utilizando Remix (un IDE de Solidity en línea).

Una vez realizado el despliegue, guarda en algún sitio la dirección de tu contrato (la necesitaremos más adelante en el tutorial).

Ahora tenemos que compilar nuestro contrato inteligente SimpleBank.

Para ello, utilizaremos 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>/

Web3j ofrece una herramienta de línea de comandos para generar una clase «wrapper» de Java para tu contrato inteligente de Solidity. Para instalar la herramienta de línea de comandos de Web3j, consulta aquí.

Ahora ya estamos listos para generar nuestra clase de envoltura del contrato inteligente utilizando el siguiente comando:

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

Tras sustituir los argumentos, en mi caso este comando quedó así:

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

Esto generará una clase Java llamada «SimpleBank» en la ruta indicada.

Obtener una instancia de un contrato inteligente

Ahora vamos a obtener una instancia de nuestro contrato inteligente para poder interactuar con él.

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

Nota: Aquí 0x7208b4883a4dF0F3e5cD084F2F9C579e7b622A38 es la dirección de nuestro contrato inteligente, implementado en la Ethereum .

Ahora podemos escuchar Depósito evento de nuestro Web3j.

simpleBank.logDepositMadeEventFlowable(DefaultBlockParameterName.EARLIEST, DefaultBlockParameterName.LATEST).doOnError(error -> System.err.println("El mensaje de error es: " + error.getMessage()))        .subscribe(logDepositMadeEventResponse ->                System.out.println(logDepositMadeEventResponse.amount));

La clase SimpleBank crea un logDepositMadeEventFlowable método que podemos utilizar para suscribirnos a Depósito eventos.

Una vez que tenemos el evento, mostramos el importe del depósito, que se genera junto con el evento de depósito.

En el próximo tutorial, profundizaremos en las transacciones con Web3j y en cómo llamar a los métodos del contrato SimpleBank.

Código completo: aquí tienes el código completo en GitHub.

¿Necesitas ayuda con tu proyecto o tienes alguna duda? Ponte en contacto con nosotros a través de este formulario, en TwitterQuicknode o envíanos un mensaje en Discord.