Ethical Sourcing Verification

What it does:
Verifies and records the ethical sourcing of materials and products on-chain, ensuring compliance with labor, environmental, and fair trade standards.

Why it matters:
Increases consumer trust, prevents fraudulent sourcing claims, supports sustainable practices, and provides auditable evidence for regulators and marketplaces.

How it works:

  • Suppliers register materials, production batches, or products on-chain

  • Authorized verifiers audit and approve the ethical compliance

  • Each approved batch or product receives an immutable on-chain certification

  • Metadata includes sourcing details, audit results, and expiration of verification

  • Consumers, auditors, and marketplaces can verify authenticity easily

  • Integrates with Supply Chain Traceability, Fair Trade Certification, and marketplaces

  • Dashboards show verified suppliers, batches, and compliance status

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

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

/**
 * @title EthicalSourcingVerification
 * @author Nam
 * @notice Verifies ethical sourcing of suppliers and products on-chain
 */
contract EthicalSourcingVerification is Ownable {

    struct Supplier {
        string name;
        bool verified;
        uint256 verificationExpiry;
    }

    struct Product {
        string name;
        address supplier;
        bool verified;
        uint256 verificationExpiry;
    }

    mapping(address => Supplier) public suppliers;
    mapping(uint256 => Product) public products;
    uint256 public productCount;

    mapping(address => bool) public verifiers;

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

    event VerifierApproved(address verifier);
    event SupplierVerified(address supplier, uint256 expiry);
    event ProductVerified(uint256 productId, address supplier, uint256 expiry);

    // -------------------- VERIFIER MANAGEMENT --------------------

    function approveVerifier(address _verifier) external onlyOwner {
        verifiers[_verifier] = true;
        emit VerifierApproved(_verifier);
    }

    function revokeVerifier(address _verifier) external onlyOwner {
        verifiers[_verifier] = false;
    }

    modifier onlyVerifier() {
        require(verifiers[msg.sender], "Not an authorized verifier");
        _;
    }

    // -------------------- SUPPLIER VERIFICATION --------------------

    function verifySupplier(address _supplier, string calldata _name, uint256 _duration) external onlyVerifier {
        suppliers[_supplier] = Supplier({
            name: _name,
            verified: true,
            verificationExpiry: block.timestamp + _duration
        });

        emit SupplierVerified(_supplier, block.timestamp + _duration);
    }

    function isSupplierVerified(address _supplier) external view returns (bool) {
        return suppliers[_supplier].verified && suppliers[_supplier].verificationExpiry > block.timestamp;
    }

    // -------------------- PRODUCT VERIFICATION --------------------

    function registerProduct(string calldata _name, address _supplier) external onlyVerifier {
        require(suppliers[_supplier].verified, "Supplier not verified");

        productCount += 1;
        products[productCount] = Product({
            name: _name,
            supplier: _supplier,
            verified: true,
            verificationExpiry: suppliers[_supplier].verificationExpiry
        });

        emit ProductVerified(productCount, _supplier, suppliers[_supplier].verificationExpiry);
    }

    function isProductVerified(uint256 _productId) external view returns (bool) {
        return products[_productId].verified && products[_productId].verificationExpiry > block.timestamp;
    }
}