Building a Blockchain-Powered Supply Chain Management System

In the world of modern commerce, supply chain management is a critical component of success. Companies need to track the movement of goods and ensure transparency and efficiency throughout the process. This is where blockchain technology comes in, offering a transparent, tamper-proof ledger for supply chain data. In this tutorial, we'll show you how to create a blockchain-powered supply chain management system using QuickNode, a leading blockchain infrastructure provider.

Introduction

The Significance of Supply Chain Management

Supply chain management involves the coordination of activities, information, and resources across the entire supply chain, from raw material suppliers to manufacturers to distributors and retailers. It ensures that products move efficiently from their point of origin to the end consumer. Effective supply chain management can reduce costs, improve product quality, and enhance customer satisfaction.

The Role of Blockchain

Blockchain technology has gained attention for its potential to revolutionize supply chain management. It provides a secure, immutable ledger that records transactions and data. In a supply chain context, blockchain offers benefits such as transparency, traceability, and trust. It allows all participants in the supply chain to access a shared ledger, reducing disputes and fraud.

QuickNode for Blockchain Infrastructure

QuickNode is a robust blockchain infrastructure provider that simplifies the process of connecting your application to the Ethereum blockchain. It offers reliable and high-performance Ethereum nodes, making it an ideal choice for blockchain development projects.

Prerequisites

Before we get started, ensure you have the following tools and technologies installed:

Node.js and npm
Solidity (for smart contract development)
A code editor (e.g., Visual Studio Code)
QuickNode account (sign up at QuickNode)

Smart Contract Development

In this section, we'll create a basic smart contract for our supply chain management system. The contract will allow us to add products to the blockchain and track their movement.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SupplyChain {
    struct Product {
        uint256 id;
        string name;
        string origin;
        string trackingInfo;
        address owner;
    }

    mapping(uint256 => Product) public products;
    uint256 public productCount;

    event ProductAdded(uint256 id, string name, string origin);
    event ProductTransferred(uint256 id, address newOwner);

    function addProduct(string memory _name, string memory _origin) public {
        productCount++;
        products[productCount] = Product(productCount, _name, _origin, "", msg.sender);
        emit ProductAdded(productCount, _name, _origin);
    }

    function transferProduct(uint256 _id, address _newOwner, string memory _trackingInfo) public {
        Product storage product = products[_id];
        require(product.owner == msg.sender, "Only the owner can transfer the product");
        product.owner = _newOwner;
        product.trackingInfo = _trackingInfo;
        emit ProductTransferred(_id, _newOwner);
    }
}

This smart contract defines the structure of a product and provides functions for adding products and transferring ownership.

Configuring QuickNode

QuickNode will serve as our gateway to the Ethereum blockchain. Follow these steps to configure QuickNode for your project:

Sign up for a QuickNode account at QuickNode.
Once you have an account, obtain your API credentials from the QuickNode dashboard.
Install the web3.js library using npm:
```
 npm install web3
```

In your JavaScript or Node.js application, import web3 and configure it to use your QuickNode API:

 const Web3 = require('web3');

 const web3 = new Web3(new Web3.providers.HttpProvider('YOUR_QUICKNODE_API_URL'));

Replace 'YOUR_QUICKNODE_API_URL' with the API URL provided by QuickNode.

User Interface Development

Next, let's build a simple web interface for our supply chain management system. We'll use HTML, CSS, and JavaScript to create a user-friendly front end.

HTML (index.html)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Supply Chain Management</title>
    <link rel="stylesheet" href="styles.css">
</head>
<body>
    <h1>Supply Chain Management System</h1>
    <button id="addProductBtn">Add Product</button>
    <button id="transferProductBtn">Transfer Product</button>
    <div id="productDetails"></div>
    <script src="app.js"></script>
</body>
</html>

CSS (styles.css)

body {
    font-family: Arial, sans-serif;
    text-align: center;
}

h1 {
    color: #333;
}

button {
    padding: 10px 20px;
    font-size: 16px;
    margin: 10px;
}

#productDetails {
    border: 1px solid #333;
    padding: 10px;
    margin: 20px auto;
    max-width: 400px;
}

JavaScript (app.js)

document.addEventListener('DOMContentLoaded', () => {
    const addProductBtn = document.getElementById('addProductBtn');
    const transferProductBtn = document.getElementById('transferProductBtn');
    const productDetails = document.getElementById('productDetails');

    addProductBtn.addEventListener('click', () => {
        // Implement product addition logic here
    });

    transferProductBtn.addEventListener('click', () => {
        // Implement product transfer logic here
    });
});

This basic UI includes buttons for adding and transferring products. We'll implement the logic for these actions in the JavaScript code.

Interacting with the Smart Contract

Now, let's connect our user interface to the Ethereum blockchain and interact with the smart contract we created earlier. We'll use the web3.js library to send transactions to the contract.

Adding Products

To add a product to the blockchain, we'll need to:

Capture product details (name and origin) from the user.
Send a transaction to the smart contract's addProduct function with the captured data.

Here's the JavaScript code for adding products:

addProductBtn.addEventListener('click', async () => {
    const name = prompt('Enter product name:');
    const origin = prompt('Enter product origin:');

    try {
        const accounts = await web3.eth.getAccounts();
        const contract = new web3.eth.Contract(abi, contractAddress);

        await contract.methods.addProduct(name, origin).send({ from: accounts[0] });

        alert('Product added successfully!');
    } catch (error) {
        console.error(error);
        alert('Failed to add product.');
    }
});

In this code, we capture the product name and origin from the user, interact with the smart contract's addProduct function, and display a success or failure message.

Transferring Products

Transferring a product to a new owner requires:

Capturing the product ID and new owner's address.
Sending a transaction to the smart contract's transferProduct function with the captured data.

Here's the JavaScript code for transferring products:

transferProductBtn.addEventListener('click', async () => {
    const productId = prompt('Enter product ID:');
    const newOwner = prompt('Enter new owner address:');
    const trackingInfo = prompt('Enter tracking information:');

    try {
        const accounts = await web3.eth.getAccounts();
        const contract = new web3.eth.Contract(abi, contractAddress);

        await contract.methods.transferProduct(productId, newOwner, trackingInfo).send({ from: accounts[0] });

        alert('Product transferred successfully!');
    } catch (error) {
        console.error(error);
        alert('Failed to transfer product.');
    }
});

This code captures the product ID, new owner's address, and tracking information, and then initiates the transfer process.

Adding Products to the Supply Chain

Now that our user interface is ready and we can interact with the smart contract, let's add products to our blockchain-based supply chain.

Open the HTML file (index.html) in a web browser.
Click the "Add Product" button.
Enter the product name, origin, and confirm.
You will receive a confirmation message when the product is added successfully.

Product Tracking

One of the key advantages of blockchain-based supply chain management is the ability to track products transparently. To track a product:

Click the "Transfer Product" button.
Enter the product ID, new owner's address, and tracking information.
Confirm the transfer.
You will receive a confirmation message when the product is transferred.

Conclusion

Congratulations! You've successfully created a blockchain-powered supply chain management system using QuickNode. This system allows you to add products to the blockchain, track their movement, and verify product authenticity.

Blockchain technology has the potential to revolutionize supply chain management by enhancing transparency, security, and efficiency. With QuickNode's robust infrastructure, you can build and deploy blockchain applications that transform industries.

Explore more blockchain use cases and consider QuickNode for your future projects. Happy coding!

Appendix

I'd love to connect with you on Twitter | LinkedIn | Portfolio.

About QuickNode

QuickNode is building infrastructure to support the future of Web3. Since 2017, we've worked with hundreds of developers and companies, helping scale dApps and providing high-performance access to 24+ blockchains. Subscribe to our newsletter for more content like this, and stay in the loop with what's happening in Web3!‌

Building a Blockchain-Powered Supply Chain Management System with QuickNode

Table of contents