Blockchain Real-Time Shipment Tracking: Integrating PostgresSQL with an Ethereum Smart Contract using REST API and Java Quarkus Framework

Introduction

In today’s fast-paced world, companies are increasingly using blockchain technology for their business processes. This technology offers numerous benefits such as immutability, decentralization, and security. Ethereum is a popular blockchain platform that provides a programmable smart contract platform, which can be used to automate various business processes. In this article, we will discuss how to integrate an external system, specifically PostgresSQL, with a shipment tracking ethereum smart contract in real-time.

Architecture decision

Before we begin, it is essential to consider some best practices when designing the architecture for this integration. Firstly, we must ensure that the architecture is scalable, flexible, and modular. This means that we should design our system in such a way that it can handle a large number of requests, can be easily modified or extended, and can be broken down into smaller components that can be managed independently.

Secondly, we must ensure that the system is secure. This involves using secure communication protocols, such as HTTPS or SSL, and implementing security measures such as authentication and authorization. We must also ensure that the data transmitted between the external system and the smart contract is encrypted.

Thirdly, we must consider the data storage and retrieval requirements. In this case, we will be using PostgresSQL as our external system, which is a popular open-source relational database. We will use the database to store and retrieve data related to the shipment tracking process. Therefore, we must ensure that the database schema is well-designed, normalized, and optimized for performance.

Lastly, we must consider the integration approach. We can use either REST or Websocket APIs for integrating the external system with the smart contract. REST APIs are commonly used for integrating external systems with smart contracts as they are simple, easy to use, and widely supported. On the other hand, Websocket APIs offer real-time communication and are suitable for use cases where real-time updates are required.

Integration using REST API

In this section, we will discuss how to integrate an external system, specifically PostgresSQL, with a shipment tracking ethereum smart contract using a REST API.

Step 1: Define the smart contract

The first step is to define the smart contract. We will use Solidity, a high-level programming language, to write our smart contract. The smart contract will have the following functions:

1. AddShipment: This function will add a new shipment to the contract.
2. UpdateShipment: This function will update an existing shipment’s status.
3. GetShipment: This function will retrieve the current status of a shipment.

Here is the sample code for the smart contract:

pragma solidity ^0.8.0;

contract ShipmentTracker {

    struct Shipment {
        uint id;
        string status;
    }

    mapping(uint => Shipment) shipments;

    function addShipment(uint id, string memory status) public {
        shipments[id] = Shipment(id, status);
    }

    function updateShipment(uint id, string memory status) public {
        require(shipments[id].id != 0, "Shipment does not exist.");
        shipments[id].status = status;
    }

    function getShipment(uint id) public view returns (string memory) {
        require(shipments[id].id != 0, "Shipment does not exist.");
        return shipments[id].status;
    }
}

Step 2: Set up the REST API

The next step is to set up the REST API. We will use Java and the Quarkus framework to create a simple API that will allow us to interact with the smart contract.

Here is the sample code for the API:

import javax.inject.Inject;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;

import org.eclipse.microprofile.rest.client.inject.RestClient;
import org.web3j.abi.datatypes.Address;
import org.web3j.abi.datatypes.generated.Uint256;
import org.web3j.protocol.Web3j;
import org.web3j.protocol.core.DefaultBlockParameter;
import org.web3j.protocol.core.methods.response.TransactionReceipt;
import org.web3j.tx.gas.DefaultGasProvider;

@Path("/shipment")
public class ShipmentResource {
    @Inject
    @RestClient
    private ShipmentTrackerService shipmentTrackerService;

    @Inject
    private Web3j web3j;

    @POST
    @Consumes(MediaType.APPLICATION_JSON)
    public String addShipment(Shipment shipment) throws Exception {
        TransactionReceipt receipt = shipmentTrackerService.addShipment(
            new Address(shipment.getId()),
            new Uint256(shipment.getStatus())
        ).send();
        return "Shipment added successfully. Transaction hash: " + receipt.getTransactionHash();
    }

    @PUT
    @Path("/{id}")
    @Consumes(MediaType.APPLICATION_JSON)
    public String updateShipment(@PathParam("id") String id, Shipment shipment) throws Exception {
        TransactionReceipt receipt = shipmentTrackerService.updateShipment(
            new Address(id),
            new Uint256(shipment.getStatus())
        ).send();
        return "Shipment updated successfully. Transaction hash: " + receipt.getTransactionHash();
    }

    @GET
    @Path("/{id}")
    @Produces(MediaType.APPLICATION_JSON)
    public Shipment getShipment(@PathParam("id") String id) throws Exception {
        Uint256 status = shipmentTrackerService.getShipment(new Address(id)).send();
        return new Shipment(id, status.getValue().intValue());
    }
}

In this code, we’re using the Quarkus @Inject annotation to inject the ShipmentTrackerService REST client and the Web3j instance into the resource class. The ShipmentTrackerService interface defines the methods for interacting with the Ethereum smart contract using the web3j library.

The addShipment() method sends a transaction to add a new shipment to the smart contract. The updateShipment() method sends a transaction to update an existing shipment. The getShipment() method retrieves the status of a shipment from the smart contract.

Note that this code assumes that the ShipmentTrackerService REST client is already generated based on the smart contract’s ABI using a tool like web3j-maven-plugin.

Also, ensure to include the required dependencies in your pom.xml file, including the quarkus-rest-client and web3j-core dependencies.

Cybersecurity

When it comes to cybersecurity, there are several measures that we can take to secure our smart contract against potential threats. Here are some best practices that we can follow:

1. Use secure coding practices to prevent common vulnerabilities such as reentrancy attacks, integer overflows, and buffer overflows.
2. Use a secure development environment, such as Truffle, to develop and test the smart contract.
3. Use multi-signature wallets to prevent unauthorized access to the smart contract.
4. Use secure communication protocols, such as HTTPS or SSL, to ensure that the data transmitted between the external system and the smart contract is encrypted.
5. Implement authentication and authorization mechanisms to prevent unauthorized access to the smart contract.

Conclusion

In conclusion, integrating an external system such as PostgresSQL with a shipment tracking Ethereum smart contract in real-time requires careful planning and consideration of various factors such as architecture, security, and API integration. The architecture decision should follow best practices to ensure efficient and effective communication between the systems, while also ensuring that the smart contract is secured against cybersecurity threats.

To achieve real-time integration, we discussed the use of either REST or WebSockets for API integration. In this article, we provided a sample Java code using the Quarkus framework to interact with the smart contract through a REST API.

In order to ensure the security of the smart contract, we highlighted some best practices such as avoiding hardcoded keys and keeping the contract code simple and straightforward. We also suggested the use of automated testing tools and techniques, such as fuzzing, to identify and fix any potential vulnerabilities in the smart contract code.

Overall, integrating an external system with an Ethereum smart contract can be challenging, but with careful planning and adherence to best practices, it can be a valuable solution for real-time shipment tracking.

References:

1. Ethereum: https://ethereum.org/
2. Quarkus: https://quarkus.io/
3. Web3j: https://docs.web3j.io/
4. Solidity: https://docs.soliditylang.org/en/latest/
5. OpenZeppelin: https://openzeppelin.com/
6. Smart Contract Security Best Practices: https://consensys.github.io/smart-contract-best-practices/