Green Building Incentive Contract

What it does:
Rewards property developers and building owners with on-chain incentives for meeting predefined green building and sustainability standards.

Why it matters:
Encourages environmentally responsible construction, reduces carbon footprints, and ensures sustainability incentives are transparent, measurable, and abuse-resistant.

How it works:

Sustainability criteria and incentive amounts are set at deployment
Building owners register their property in the contract
Energy or sustainability compliance is verified by an authorized validator
Eligible properties are marked as compliant on-chain
Incentive funds are released automatically to compliant owners
All incentives and certifications remain publicly auditable

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

/**
 * @title GreenBuildingIncentive
 * @author Nam
 * @notice On-chain incentive system for green and sustainable buildings
 */
contract GreenBuildingIncentive {

    // -------------------- ROLES --------------------

    address public authority;   // city / environmental authority
    address public validator;   // sustainability auditor

    // -------------------- INCENTIVE TERMS --------------------

    uint256 public incentiveAmount;

    // -------------------- BUILDING DATA --------------------

    struct Building {
        address owner;
        bool registered;
        bool compliant;
        bool rewarded;
    }

    mapping(uint256 =&gt; Building) public buildings;

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

    event BuildingRegistered(uint256 indexed buildingId, address indexed owner);
    event BuildingVerified(uint256 indexed buildingId);
    event IncentivePaid(uint256 indexed buildingId, address indexed owner, uint256 amount);

    // -------------------- MODIFIERS --------------------

    modifier onlyAuthority() {
        require(msg.sender == authority, "Not authority");
        _;
    }

    modifier onlyValidator() {
        require(msg.sender == validator, "Not validator");
        _;
    }

    modifier onlyOwner(uint256 _buildingId) {
        require(buildings[_buildingId].owner == msg.sender, "Not owner");
        _;
    }

    // -------------------- CONSTRUCTOR --------------------

    constructor(
        address _validator,
        uint256 _incentiveAmount
    ) {
        require(_validator != address(0), "Invalid validator");

        authority = msg.sender;
        validator = _validator;
        incentiveAmount = _incentiveAmount;
    }

    // -------------------- REGISTRATION --------------------

    /**
     * @notice Register a building for green incentives
     */
    function registerBuilding(uint256 _buildingId)
        external
    {
        require(!buildings[_buildingId].registered, "Already registered");

        buildings[_buildingId] = Building({
            owner: msg.sender,
            registered: true,
            compliant: false,
            rewarded: false
        });

        emit BuildingRegistered(_buildingId, msg.sender);
    }

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

    /**
     * @notice Verify sustainability compliance
     */
    function verifyBuilding(uint256 _buildingId)
        external
        onlyValidator
    {
        Building storage building = buildings[_buildingId];
        require(building.registered, "Building not registered");
        require(!building.compliant, "Already compliant");

        building.compliant = true;
        emit BuildingVerified(_buildingId);
    }

    // -------------------- INCENTIVE PAYOUT --------------------

    /**
     * @notice Claim green building incentive
     */
    function claimIncentive(uint256 _buildingId)
        external
        onlyOwner(_buildingId)
    {
        Building storage building = buildings[_buildingId];
        require(building.compliant, "Not compliant");
        require(!building.rewarded, "Already rewarded");
        require(address(this).balance &gt;= incentiveAmount, "Insufficient funds");

        building.rewarded = true;
        payable(building.owner).transfer(incentiveAmount);

        emit IncentivePaid(_buildingId, building.owner, incentiveAmount);
    }

    // -------------------- FUNDING --------------------

    /**
     * @notice Fund the incentive pool
     */
    function fundIncentives() external payable onlyAuthority {}
}