Deploying Good Contract on Ethereum Blockchain

On this tutorial, we’ll discover ways to deploy and work together with an Ethereum Good contract utilizing Web3j and Spring.

What Is a Good Contract?

A Good contract is an algorithm for sure actions built-in into the blockchain code. It’s deployed on the Ethereum blockchain community and robotically executes predefined actions when particular situations within the contract are met.

What Is Solidity?

Solidity is an object-oriented programming language for creating Good contracts. Studying and utilizing Solidity is straightforward if you’re already accustomed to Java or C. Solidity has built-in options particularly associated to the blockchain. They will let you withdraw and ship “cash” (ETH), get the handle of the one who invoked the Good contract, and make calls to different Good contracts utilizing their addresses.

What Is Web3j?

Web3j is a light-weight Java library that permits you to work with the Ethereum blockchain, offering the flexibility to handle transactions and generate type-safe wrappers for Good contracts.

1. Putting in Solc and Web3j

Solc is the compiler for Solidity. To put in it, run the next command:

To generate the wrapper code of a Good contract, we have to set up Web3j:

curl -L get.web3j.io | sh && supply ~/.web3j/supply.sh

2. Initializing the Spring Challenge

To rapidly begin a undertaking, you should use Spring Initializr:

Obtain the undertaking by clicking the “Generate” button and open it with a handy IDE. Add the Web3j dependency within the pom.xml:

<dependency>
    <groupId>org.web3j</groupId>
    <artifactId>core</artifactId>
    <model>4.10.0</model>
</dependency>

3. Making a Good Contract

Let’s create the Counter.sol file as a Good contract in your undertaking:

The primary line in a contract units the model of the supply code that will probably be taken into consideration by the compiler:

For this instance, we’ll create a contract with the Counter title utilizing the contract key phrase:

contract Counter 
    uint personal depend = 0;

We’ve declared the depend state variable with knowledge sort uint as an unsigned integer. With the personal entry modifier, as in Java, this subject can solely be referred to as inside the present contract.

Subsequent, let’s add two features for incrementing and decrementing the depend variable. As well as, we add the getter technique for the depend variable with the view modifier that ensures the contract’s state received’t be modified:

pragma solidity ^0.8.20;

contract Counter 
    uint personal depend = 0;

    perform increment() public 
        depend += 1;
    

    perform decrement() public 
        count--;
    

    perform getCount() public view returns (uint) 
        return depend;
    

4. Compiling the Good Contract and Making a Web3j Wrapper

To compile the listed Good contract, we’ll use the beforehand put in solc library:

solcjs Counter.sol --bin --abi --optimize -o ../artifacts

This can create two information with .abi and .bin extensions within the artifacts folder:

To transform the generated .abi and .bin information right into a Java class with technique signatures from the contract, we’ll make the most of the Web3j generator:

web3j generate solidity -b Counter_sol_Counter.bin -a Counter_sol_Counter.abi -o ../java -p com.instance.smartcontract

After execution, within the src/important/java/org/instance listing, you must have a brand new class named Counter_sol_Counter. Let’s rename it to CounterContract:

5. Producing Ethereum Deal with

To generate an Ethereum handle and personal key, you should use this website.

Copy the personal key and put it within the software.properties as ethereum.private-key property:

I’ll be deploying our contract to the Sepolia testnet (you may as well use Goerli or Kovan as an alternative). To be able to deploy a Good contract and pay for transaction charges, we’ll want a bit little bit of ETH on the Sepolia testnet. Listed below are a number of taps the place you’ll be able to obtain check cash:

https://sepoliafaucet.com/

https://faucet.sepolia.dev/

https://sepolia-faucet.pk910.de/

https://www.infura.io/faucet/sepolia

Copy your Ethereum handle and submit sending ETH cash:

Lastly, we’ll add the URL of Sepolia’s JSON-RPC endpoint in software.properties:

ethereum.private-key=<your_ethereum_private_key>
ethereum.supplier=https://eth-sepolia.g.alchemy.com/v2/demo

6. Java Configuration

Let’s create the Web3jConfig class, through which we declare beans for org.web3j.protocol.Web3j and org.web3j.crypto.Credentials utilizing the parameters from software.properties:

package deal com.instance.smartcontract;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.manufacturing facility.annotation.Worth;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.web3j.crypto.Credentials;
import org.web3j.protocol.Web3j;
import org.web3j.protocol.http.HttpService;

@Configuration
@Slf4j
public class Web3jConfig 
    @Worth("$ethereum.supplier")
    personal String ethereumProvider;
    @Worth("$ethereum.private-key")
    personal String ethereumPrivateKey;

    @Bean
    public Web3j web3j() 
        return Web3j.construct(new HttpService(ethereumProvider));
    

    @Bean
    public Credentials credentials() 
        return Credentials.create(ethereumPrivateKey);
    

Subsequent, we declare a bean for the CounterContract, that will probably be deployed throughout initialization:

@Bean
public CounterContract counterContract() 
    CounterContract counterContract;
    strive 
        counterContract = CounterContract.deploy(web3j(), credentials(), new DefaultGasProvider()).ship();
        // counter = Counter.load(counterContractAddress, web3j(), credentials(), new DefaultGasProvider());
     catch (Exception e) 
        log.error("Error whereas deploying a contract", e);
        throw new RuntimeException(e);
    
    log.data("Counter contract has been deployed: ", counterContract.getContractAddress());
    return counterContract;

To make use of features of the deployed Good contract, let’s create the CounterContractService class with the injected CounterContract in it:

package deal com.instance.smartcontract;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.manufacturing facility.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.web3j.protocol.core.strategies.response.TransactionReceipt;

import java.math.BigInteger;

@Service
@Slf4j
public class CounterContractService 

    @Autowired
    personal CounterContract counterContract;

    @SneakyThrows
    public BigInteger getCount() 
        return counterContract.getCount().ship();
    

    @SneakyThrows
    public void increment() 
        TransactionReceipt transactionReceipt = counterContract.increment().ship();
        log.data("increment transaction : ", transactionReceipt.getTransactionHash());
    

    @SneakyThrows
    public void decrement() 
        TransactionReceipt transactionReceipt = counterContract.decrement().ship();
        log.data("decrement transaction : ", transactionReceipt.getTransactionHash());
    

7. Wrap Up

At this level, the essential implementation of a Good contract is prepared. After launching the applying, within the logs, you’ll see the handle of the deployed contract, which you’ll hint within the Etherscan Explorer for Sepolia.

The supply code is on the market on GitHub.