Eco-Friendly Business Certification

What it does:
Certifies businesses that meet predefined environmental and sustainability standards, issuing verifiable on-chain proof of eco-friendly compliance.

Why it matters:
Eliminates greenwashing, increases consumer trust, enables transparent ESG reporting, and creates globally verifiable sustainability credentials for businesses.

How it works:

  • Businesses apply for eco-friendly certification on-chain

  • Certification criteria and scoring standards are publicly defined

  • Approved auditors or oracles verify business practices and data

  • Verification results are recorded immutably on-chain

  • Certified businesses receive a digital sustainability certificate

  • Certification status can expire and require re-verification

  • Anyone can publicly verify certification authenticity and history

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

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

/**
 * @title EcoFriendlyBusinessCertification
 * @author Nam
 * @notice Issues verifiable on-chain sustainability certifications for businesses
 */
contract EcoFriendlyBusinessCertification is Ownable {

    struct Certification {
        bool certified;
        uint256 issuedAt;
        uint256 expiresAt;
        string auditReportURI; // IPFS link to audit details
    }

    mapping(address => Certification) public certifications;
    mapping(address => bool) public approvedAuditors;

    uint256 public certificationPeriod = 365 days;

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

    event AuditorApproved(address indexed auditor);
    event AuditorRevoked(address indexed auditor);
    event BusinessCertified(address indexed business, uint256 expiresAt);
    event CertificationRevoked(address indexed business);

    // -------------------- AUDITOR MANAGEMENT --------------------

    function approveAuditor(address _auditor) external onlyOwner {
        approvedAuditors[_auditor] = true;
        emit AuditorApproved(_auditor);
    }

    function revokeAuditor(address _auditor) external onlyOwner {
        approvedAuditors[_auditor] = false;
        emit AuditorRevoked(_auditor);
    }

    // -------------------- CERTIFICATION --------------------

    function certifyBusiness(
        address _business,
        string calldata _auditReportURI
    ) external {
        require(approvedAuditors[msg.sender], "Not authorized auditor");

        certifications[_business] = Certification({
            certified: true,
            issuedAt: block.timestamp,
            expiresAt: block.timestamp + certificationPeriod,
            auditReportURI: _auditReportURI
        });

        emit BusinessCertified(_business, block.timestamp + certificationPeriod);
    }

    function revokeCertification(address _business) external {
        require(approvedAuditors[msg.sender] || msg.sender == owner(), "Not authorized");
        certifications[_business].certified = false;

        emit CertificationRevoked(_business);
    }

    // -------------------- VERIFICATION --------------------

    function isCertified(address _business) external view returns (bool) {
        Certification memory c = certifications[_business];
        return c.certified && block.timestamp <= c.expiresAt;
    }
}