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 | sh && supply ~/.web3j/

2. Initializing the Spring Challenge

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

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:


3. Making a Good Contract

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

Counter.sol file

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 

    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:

file extensions

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.

Generating Ethereum Address

Copy the personal key and put it within the 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:

Copy your Ethereum handle and submit sending ETH cash:

Copy your Ethereum address and submit sending ETH coins

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


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

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;

public class Web3jConfig 
    personal String ethereumProvider;
    personal String ethereumPrivateKey;

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

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

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

public CounterContract counterContract() 
    CounterContract counterContract;
        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);"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;

public class CounterContractService 

    personal CounterContract counterContract;

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

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

    public void decrement() 
        TransactionReceipt transactionReceipt = counterContract.decrement().ship();"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.