Fair Trade Certification Contract

What it does:
Registers and verifies fair trade certifications for producers and products, ensuring compliance with ethical sourcing, labor, and environmental standards.

Why it matters:
Provides transparency and trust to consumers, prevents fraudulent claims, and supports ethical and sustainable supply chains.

How it works:

  • Producers apply for fair trade certification on-chain

  • Authorized certifiers review applications and approve/reject certifications

  • Each certified product or producer receives an immutable on-chain record or NFT

  • Certificates can include metadata about standards, audit results, and expiration

  • Consumers, auditors, and marketplaces can verify authenticity of certifications

  • Integrates with Supply Chain Traceability and Product Authenticity Verification

  • Public dashboards show certified producers, products, and compliance status

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

import "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title FairTradeCertification
 * @author Nam
 * @notice Manages fair trade certifications for producers and products on-chain
 */
contract FairTradeCertification is Ownable {

    struct Producer {
        string name;
        bool certified;
        uint256 certificationExpiry;
    }

    struct Product {
        string name;
        address producer;
        bool certified;
        uint256 certificationExpiry;
    }

    mapping(address => Producer) public producers; // producer address => info
    mapping(uint256 => Product) public products;   // productId => info
    uint256 public productCount;

    mapping(address => bool) public certifiers;

    // -------------------- EVENTS --------------------

    event CertifierApproved(address certifier);
    event ProducerCertified(address producer, uint256 expiry);
    event ProductCertified(uint256 productId, address producer, uint256 expiry);

    // -------------------- CERTIFIER MANAGEMENT --------------------

    function approveCertifier(address _certifier) external onlyOwner {
        certifiers[_certifier] = true;
        emit CertifierApproved(_certifier);
    }

    function revokeCertifier(address _certifier) external onlyOwner {
        certifiers[_certifier] = false;
    }

    modifier onlyCertifier() {
        require(certifiers[msg.sender], "Not an authorized certifier");
        _;
    }

    // -------------------- PRODUCER CERTIFICATION --------------------

    function certifyProducer(address _producer, string calldata _name, uint256 _duration) external onlyCertifier {
        producers[_producer] = Producer({
            name: _name,
            certified: true,
            certificationExpiry: block.timestamp + _duration
        });

        emit ProducerCertified(_producer, block.timestamp + _duration);
    }

    function isProducerCertified(address _producer) external view returns (bool) {
        return producers[_producer].certified && producers[_producer].certificationExpiry > block.timestamp;
    }

    // -------------------- PRODUCT CERTIFICATION --------------------

    function registerProduct(string calldata _name, address _producer) external onlyCertifier {
        require(producers[_producer].certified, "Producer not certified");

        productCount += 1;
        products[productCount] = Product({
            name: _name,
            producer: _producer,
            certified: true,
            certificationExpiry: producers[_producer].certificationExpiry
        });

        emit ProductCertified(productCount, _producer, producers[_producer].certificationExpiry);
    }

    function isProductCertified(uint256 _productId) external view returns (bool) {
        return products[_productId].certified && products[_productId].certificationExpiry > block.timestamp;
    }
}