Building a Supply-Chain Management Smart Contract Using QuickNode RPC.

Prerequisites;

• What is a Supply Chain Management.
• Key features and components of a Supply Chain Management Smart Contract.
• Use cases of a Supply Chain Management Smart Contract.
• Benefits of a Supply Chain Management Smart Contract.
• Writing a Supply Chain Management Smart contract.
• Deployment with QuickNode RPC.

In this article, I would be explaining what a SCM(supply chain management system) is, also would be creating a SCM Smart contract & deploying on Sepolia testnest using QuickNode RPC.

What is a Supply Chain Management ?

A Supply chain management (SCM) is management of the flow of goods, data, and finances related to a product or service, from the procurement of raw materials to the delivery of the product at its final destination.

In a more details, It refers to the process of overseeing and managing the flow of goods, information, and services as they move from the supplier to the manufacturer, then to the wholesaler, and ultimately to the retailer and end consumer. The goal of SCM is to optimize the overall efficiency and effectiveness of this complex network of interconnected activities.

A Supply Chain Management (SCM) System Smart Contract is a blockchain-based program that automates and manages various aspects of the supply chain process. It serves as a self-executing contract with the terms and conditions of the supply chain process encoded within it.

KEY FEATURES AND COMPONENTS OF SUPPLY CHAIN MANAGEMENT SMART CONTRACT.

1. Product Tracking: It makes the tracking of products through different stages of the supply chain very accurate, from production to distribution and delivery.
2. State Management: The SCM Smart contract maintains the current status of a product, which can include states like “created,” “in transit,” “delivered,” etc.
3. Ownership and Authorization: It establishes rules for ownership and authorization, determining who has the authority to perform specific actions within the supply chain.
4. Events and Logging: The smart contract logs important events, actions, and state changes within the supply chain, providing a transparent history.
5. Validation and Error Handling: It includes checks and validations to ensure that only valid data and actions are accepted by the smart contract.
6. Time-Stamped Transactions: Timestamps are often included to record when specific actions occur, creating a chronological history of the product’s journey.
7. Integration with IoT Devices: In some cases though, the smart contract can be connected to IoT (Internet of Things) devices for real-time data collection and updates.
8. External Data Sources (Oracles): It may utilize oracles to fetch real-world data and verify it against the data stored on the blockchain.
9. Provenance and Traceability: The smart contract helps in establishing the complete history and journey of a product, including all the parties it passed through.
10. Escrow Services : An escrow system can be implemented for handling payments and ensuring that conditions are met before funds are released.
11. Tokenization (Optional): This is an optional component, products themselves can be tokenized for purposes such as fractional ownership or trading.
12. Compliance and Regulatory Features : It may include features to ensure compliance with industry-specific regulations and standards.
13. Governance Mechanism (Optional): A system for making important decisions related to the supply chain, such as protocol upgrades or contract amendments, can be implemented.

USE CASES OF A SUPPLY CHAIN MANAGEMENT SMART CONTRACT.

Below are some important uses:

1. Food Safety and Traceability:

• SCM smart contracts can be used to track the journey of food products from farm to table. This ensures food safety by quickly identifying and addressing any contamination or quality issues.

2. Pharmaceuticals and Healthcare:

• Ensuring the authenticity and integrity of pharmaceutical products is critical. SCM smart contracts can verify the provenance of medicines, reducing the risk of counterfeit drugs.

3. High-Value Goods (e.g., Luxury Items, Art):

• SCM smart contracts can be used to track the authenticity and ownership history of high-value items, preventing counterfeits and providing assurance to buyers.

4. Automotive Industry:

• For car manufacturers, SCM smart contracts can track the sourcing of parts and components, ensuring compliance with quality standards and safety regulations.

5. Supply Chain Finance:

• Smart contracts can automate payment processes based on predefined milestones or delivery conditions, reducing administrative overhead and improving cash flow.

6. Logistics and Freight Management:

• SCM smart contracts can automate the release of payments upon successful delivery, reducing disputes and ensuring timely compensation for carriers.

7. Warranty and After-Sales Service:

• Smart contracts can automatically validate warranties based on product registration or delivery confirmation, streamlining the after-sales service process.

8. Ethical Sourcing and Fair Trade:

• SCM smart contracts can verify the authenticity of fair trade and ethically sourced products, providing consumers with assurance about the origins of the goods.

9. Cross-Border Trade and Import/Export:

• Smart contracts can automate customs processes, track goods across international borders, and ensure compliance with trade regulations.

10. Agricultural Supply Chains:

• SCM smart contracts can track the production and distribution of agricultural products, providing transparency on factors like origin, farming practices, and organic certifications.

11. Fashion and Apparel Industry:

• Smart contracts can verify the authenticity of designer clothing and accessories, ensuring customers receive genuine products.

12. Energy and Sustainability:

• SCM smart contracts can track the origin and production methods of renewable energy sources, ensuring adherence to sustainability goals and regulatory standards.

BENEFITS OF SUPPLY CHAIN MANAGEMENT SMART CONTRACT.

1. Transparency and Traceability:

• SCM smart contracts provide a tamper-proof ledger of all transactions and movements within the supply chain. This transparency allows stakeholders to trace the journey of products from origin to destination, ensuring authenticity and quality.

2. Reduced Fraud and Counterfeits:

• By verifying the authenticity of products and recording their provenance on the blockchain, The SCM smart contracts help in preventing counterfeits and ensuring that consumers receive genuine goods.

3. Automation and Efficiency:

• Smart contracts automate various processes, such as payment releases upon successful delivery, reducing manual paperwork, administrative tasks, and the potential for human error.

4. Faster Transactions and Settlements:

• Payments and settlements can be executed automatically based on predefined conditions being met. This accelerates the payment process, reducing delays and enhancing cash flow.

5. Improved Inventory Management:

• SCM smart contracts can also provide real-time visibility into inventory levels and demand trends, enabling more accurate forecasting and reducing excess stock.

6. Enhanced Compliance and Accountability:

• Smart contracts can be programmed to enforce compliance with regulatory standards, industry-specific requirements, and contractual agreements, ensuring all parties adhere to predefined rules.

7. Streamlined Auditing and Reporting:

• The immutable nature of blockchain allows for easy and accurate auditing of supply chain activities. Reports generated from the blockchain data provide a comprehensive view of operations.

8. Cost Reduction:

• Automation, transparency, and efficiency improvements lead to cost savings in various aspects of the supply chain, including reduced administrative expenses, fewer disputes, and optimized inventory management.

9. Mitigation of Disputes and Discrepancies:

• With clear, transparent, and verifiable records on the blockchain, disputes related to deliveries, payments, or product quality can be resolved more efficiently and with greater confidence.

10. Enhanced Trust and Customer Confidence:

• Providing customers with transparent information about the products they purchase builds trust. SCM smart contracts enable businesses to offer proof of authenticity and ethical sourcing.

11. Easier Recall Management:

• In the event of a product recall, SCM smart contracts facilitate the rapid identification and removal of affected products from the supply chain, minimizing potential harm and liability.

12. Sustainable and Ethical Sourcing:

• Smart contracts can verify and authenticate products with specific certifications (e.g., organic, fair trade) or ensure compliance with sustainability practices, meeting the demands of eco-conscious consumers.

WRITING A SUPPLY CHAIN MANAGEMNET SMART CONTRACT.

Hey, enough of the fundamentals, its time to go technical!

Below is a Supply chain management smart contract code;

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

contract SupplyChain {
    address public owner;
    uint public productId;
    
    enum State { Created, InTransit, Delivered }
    State public currentState;
    
    struct Product {
        string name;
        uint quantity;
        address producer;
        address distributor;
        address retailer;
    }
    
    mapping(uint => Product) public products;

    event ProductCreated(uint productId, string name, uint quantity, address producer, address distributor, address retailer);
    event StateChanged(uint productId, State newState);
    event QuantityUpdated(uint productId, uint newQuantity);
    event OwnershipTransferred(address newOwner);

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }

    modifier inState(State state) {
        require(currentState == state, "Invalid state for this operation");
        _;
    }

    modifier validProduct(uint _productId) {
        require(products[_productId].producer != address(0), "Product does not exist");
        _;
    }

    constructor() {
        owner = msg.sender;
    }

    function createProduct(string memory _name, uint _quantity, address _producer, address _distributor, address _retailer) public onlyOwner {
        productId++;
        products[productId] = Product({
            name: _name,
            quantity: _quantity,
            producer: _producer,
            distributor: _distributor,
            retailer: _retailer
        });
        
        currentState = State.Created;
        
        emit ProductCreated(productId, _name, _quantity, _producer, _distributor, _retailer);
    }

    function changeState(uint _productId, State _newState) public onlyOwner validProduct(_productId) {
        currentState = _newState;
        emit StateChanged(_productId, _newState);
    }

    function updateQuantity(uint _productId, uint _newQuantity) public onlyOwner validProduct(_productId) {
        products[_productId].quantity = _newQuantity;
        emit QuantityUpdated(_productId, _newQuantity);
    }

    function transferOwnership(address _newOwner) public onlyOwner {
        owner = _newOwner;
        emit OwnershipTransferred(_newOwner);
    }

    function getProductDetails(uint _productId) public view returns (string memory, uint, address, address, address) {
        Product storage product = products[_productId];
        return (product.name, product.quantity, product.producer, product.distributor, product.retailer);
    }
}

A detailed explanation of the code above;

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

• // SPDX-License-Identifier: MIT: This is a comment indicating the license under which the contract is distributed. In this case, it's MIT, which is a permissive open-source license.
• pragma solidity ^0.8.0;: This specifies that the contract should be compiled using a Solidity compiler version equal to or greater than 0.8.0. It ensures compatibility with the language features used in the contract.

contract SupplyChain {

• contract SupplyChain {: This line starts the definition of a new contract named SupplyChain.

address public owner;
    uint public productId;

• address public owner;: This declares a public state variable owner of type address. It will store the address of the owner of the contract.
• uint public productId;: This declares a public state variable productId of type uint (unsigned integer). It will be used to keep track of product IDs.

enum State { Created, InTransit, Delivered }
    State public currentState;

• enum State { ... }: This defines an enumeration type named State, which can take one of three values: Created, InTransit, or Delivered. This enum will be used to represent the current state of a product.
• State public currentState;: This declares a public state variable currentState of type State. It will store the current state of the product.

struct Product {
        string name;
        uint quantity;
        address producer;
        address distributor;
        address retailer;
    }

• struct Product { ... }: This defines a struct named Product which represents the structure of a product. It has five attributes: name, quantity, producer, distributor, and retailer.

mapping(uint => Product) public products;

• mapping(uint => Product) public products;: This creates a mapping named products where product IDs (uint) are associated with product details (Product structs). The mapping is marked as public, meaning it can be accessed from outside the contract.

event ProductCreated(uint productId, string name, uint quantity, address producer, address distributor, address retailer);
    event StateChanged(uint productId, State newState);
    event QuantityUpdated(uint productId, uint newQuantity);
    event OwnershipTransferred(address newOwner);

• event ProductCreated(...);, event StateChanged(...);, event QuantityUpdated(...);, and event OwnershipTransferred(...);: These lines define four events (ProductCreated, StateChanged, QuantityUpdated, and OwnershipTransferred). Events are used to emit information that can be captured by external systems. They will notify external parties about important changes in the contract.

modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }

• modifier onlyOwner() { ... }: This is a custom modifier named onlyOwner. Modifiers are used to add conditions to functions. In this case, it checks if the caller is the owner. If not, it reverts with the specified error message.

modifier inState(State state) {
        require(currentState == state, "Invalid state for this operation");
        _;
    }

• modifier inState(State state) { ... }: This is another custom modifier named inState. It checks if the currentState matches the provided state argument. If not, it reverts with the specified error message.

modifier validProduct(uint _productId) {
        require(products[_productId].producer != address(0), "Product does not exist");
        _;
    }

• modifier validProduct(uint _productId) { ... }: This is a third custom modifier named validProduct. It checks if a product with the given _productId exists. If not, it reverts with the specified error message.

constructor() {
        owner = msg.sender;
    }

• constructor() { ... }: This is the constructor function, which runs once when the contract is deployed. In this case, it sets the deployer's address (msg.sender) as the owner of the contract.

function createProduct(string memory _name, uint _quantity, address _producer, address _distributor, address _retailer) public onlyOwner {
        productId++;
        products[productId] = Product({
            name: _name,
            quantity: _quantity,
            producer: _producer,
            distributor: _distributor,
            retailer: _retailer
        });
        
        currentState = State.Created;
        
        emit ProductCreated(productId, _name, _quantity, _producer, _distributor, _retailer);
    }

• function createProduct(... { ... }: This function allows the owner to create a new product. It takes five arguments: _name, _quantity, _producer, _distributor, and _retailer.
• productId++;: This increments the productId by 1 to generate a unique ID for the new product.
• products[productId] = Product({ ... });: This creates a new Product struct and assigns it to the newly generated productId. It initializes the product with the provided information.
• currentState = State.Created;: This sets the current state of the product to Created.
• emit ProductCreated(...);: This emits the ProductCreated event to notify external systems that a new product has been created.

function changeState(uint _productId, State _newState) public onlyOwner validProduct(_productId) {
        currentState = _newState;
        emit StateChanged(_productId, _newState);
    }

• function changeState(... { ... }: This function allows the owner to change the state of a product. It takes two arguments: _productId and _newState.
• currentState = _newState;: This updates the current state of the product to the new state specified in _newState.
• emit StateChanged(...);: This emits the StateChanged event to notify external systems that the state of a product has changed.

function updateQuantity(uint _productId, uint _newQuantity) public onlyOwner validProduct(_productId) {
        products[_productId].quantity = _newQuantity;
        emit QuantityUpdated(_productId, _newQuantity);
    }

• function updateQuantity(... { ... }: This function allows the owner to update the quantity of a product. It takes two arguments: _productId and _newQuantity.
• products[_productId].quantity = _newQuantity;: This updates the quantity of the specified product with the new quantity provided.
• emit QuantityUpdated(...);: This emits the QuantityUpdated event to notify external systems that the quantity of a product has been updated.

function transferOwnership(address _newOwner) public onlyOwner {
        owner = _newOwner;
        emit OwnershipTransferred(_newOwner);
    }

• function transferOwnership(... { ... }: This function allows the owner to transfer ownership of the contract to a new address. It takes one argument: _newOwner.
• owner = _newOwner;: This updates the owner's address to the new address specified in _newOwner.
• emit OwnershipTransferred(...);: This emits the OwnershipTransferred event to notify external systems that ownership of the contract has been transferred.

function getProductDetails(uint _productId) public view returns (string memory, uint, address, address, address) {
        Product storage product = products[_productId];
        return (product.name, product.quantity, product.producer, product.distributor, product.retailer);
    }

• function getProductDetails(... { ... }: This function allows anyone to retrieve the details of a product based on its ID. It takes one argument: _productId.
• Product storage product = products[_productId];: This creates a storage reference to the product with the specified _productId.
• return (..., ..., ..., ..., ...);: This returns a tuple containing the name, quantity, producer address, distributor address, and retailer address of the product.

Lets write this code in our REMIX IDE.

DEPLOYMENT WITH QUICKNODE RPC.

STEP 1.

Create a new sepolia node on QuickNode. You would have to navigate to the QuickNode Dashboard and click on “Create”.

Then after, make sure you click on the Ethereum chain. Check a screenshoot below;

Click on Sepolia:

Then click on ‘continue’ to proceed. Finally click on ‘create endpoint’ to get your Sepolia url.

STEP 2.

Click on “Add network”. Follow the instructions on how to add the RPC url to your wallet browser.

Click on “Add network manually”.

STEP 3.

Enter a name (any) since your using QuickNode , you can use ‘QKN’ copy/paste your Web3 endpoint (be sure to include the “/” at the end!), enter ChainID and click “Save”.

We are using Sepolia Teastnet, so its advisable to use sepolia chain ID, Which is ‘11155111’.

Finally, you would get the below result.

Perfect! We are almost finished, Now we would be requesting some Eth from Sepolia Testnet so as to be able to deploy our smart contract.

STEP 4.

Now to get gas fees, we are going to be using https://faucet.quicknode.com/drip. Below is the procedure.

Then connect wallet and get some Eth.

After doing this, you would get the result below:

With this, we are ready to deploy our Supply chain management smart contract.

Deploying smart contract code to sepolia testnet.

Click on ‘confirm’ to finalize transactions.

Conclusion

Congratulations on successfully creating your very own Supply chain management Smart contract on the Ethereum network! .

Subscribe to QuickNode newsletter for more articles and guides on Ethereum. If you have any feedback, feel free to reach out to us via Twitter. You can always chat with us on our Discord community server, featuring some of the coolest developers you’ll ever meet :)