Building a Blockchain-Based Supply Chain System Using the Ethereum Stack Print

  • 0


In this guide, we're going to walk through creating a simple blockchain-based supply chain system using the Ethereum stack. Our aim is to create a decentralized application (DApp) that allows us to track items through a supply chain.

Setting Up Your Development Environment

Firstly, ensure that your development environment is set up. You should have Node.js and npm installed. Install the Truffle suite, which provides a development environment for Ethereum, using npm:

npm install -g truffle

Also, install Ganache, a personal Ethereum blockchain which you can use to run tests, execute commands, and inspect state while controlling how the chain operates.

Setting Up Your Project

Initialize a new truffle project:

mkdir supply_chain
cd supply_chain
truffle init

This will create a basic truffle project structure. You'll mainly be working in the 'contracts' and 'migrations' directories.

Writing the Smart Contract

Create a new file in the 'contracts' directory named 'SupplyChain.sol'. Here's a simplified version of what the smart contract could look like:

pragma solidity >=0.5.16 <0.9.0;

contract SupplyChain {
// owner of the contract
address public owner;

// product counter
uint public productIndex;

// map the product counter to a product
mapping (uint => Product) public products;

// enum to maintain the product status
enum ProductStatus { Created, Paid, Shipped, Received }

// product structure
struct Product {
uint id;
string name;
uint price;
ProductStatus status;
address payable owner;

constructor() public {
owner = msg.sender;
productIndex = 0;

event LogProductCreated(uint indexed _productId);
event LogProductPaid(uint indexed _productId);

function createProduct(string memory _name, uint _price) public {
products[productIndex] = Product(productIndex, _name, _price, ProductStatus.Created, msg.sender);
emit LogProductCreated(productIndex);

function payProduct(uint _productId) public payable {
Product memory _product = products[_productId];
require(msg.value >= _product.price, "Not enough funds sent");
_product.status = ProductStatus.Paid;
emit LogProductPaid(_productId);

// more functions could be added to change product status to shipped and received.

This contract creates and allows payment for products, each of which has a status indicating where it is in the supply chain.

Deploying the Smart Contract

Create a new file in the 'migrations' directory named '2_deploy_contracts.js', with the following content:

const SupplyChain = artifacts.require("SupplyChain");

module.exports = function(deployer) {

You can then deploy the contract to your Ganache network using:

truffle migrate --reset

**Interacting with the Smart Contract**

You can interact with the smart contract using the Truffle console:

truffle console

Then in the console, you can command as follows:

let instance = await SupplyChain.deployed()
let accounts = await web3.eth.getAccounts()

To create a product:

await instance.createProduct("Product 1", web3.utils.toWei("0.01", "ether"), { from: accounts[0] })

To pay for a product:

await instance.payProduct(0, { from: accounts[1], value: web3.utils.toWei("0.01", "ether") })


In this guide, we've shown how to create a basic supply chain system using Ethereum. The system allows for products to be added and paid for. Although it's a simple application, it demonstrates how blockchain can bring transparency and decentralization to the supply chain industry. You can extend this example by allowing for the status of a product to be updated, reflecting when it has been shipped and received.

Remember that this code should not be used in production - it's a simplified example and hasn't been audited for security.

Was this answer helpful?

« Back