Logistics Performance Incentive

What it does:
Rewards logistics providers, carriers, or warehouse operators for meeting efficiency, timeliness, and reliability metrics using smart contracts.

Why it matters:
Encourages faster deliveries, reduces errors, promotes accountability, and ensures transparent, auditable incentive payments.

How it works:

Logistics providers register on-chain and are assigned KPIs or targets
Performance data (delivery times, accuracy, condition compliance) is logged via IoT or authorized participants
Smart contracts calculate incentives based on predefined rules
Rewards are automatically distributed as tokens or payments to qualifying providers
Historical performance is recorded for auditing and reputation scoring
Integrates with Supply Chain Traceability, Cold Chain Monitoring, and Inventory Management
Dashboards display performance metrics, rewards, and rankings

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

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

/**
 * @title LogisticsPerformanceIncentive
 * @author Nam
 * @notice Rewards logistics providers based on performance metrics tracked on-chain
 */
contract LogisticsPerformanceIncentive is Ownable {

    struct Provider {
        string name;
        bool registered;
        uint256 totalRewards;
    }

    struct PerformanceEvent {
        uint256 timestamp;
        string description;
        uint256 score; // e.g., 0-100
        address reporter;
    }

    mapping(address =&gt; Provider) public providers;
    mapping(address =&gt; PerformanceEvent[]) public performanceEvents;

    mapping(address =&gt; bool) public authorizedReporters;

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

    event ProviderRegistered(address provider, string name);
    event PerformanceLogged(address provider, uint256 score, string description, address reporter);
    event RewardDistributed(address provider, uint256 amount);
    event ReporterApproved(address reporter);

    // -------------------- REPORTER MANAGEMENT --------------------

    function approveReporter(address _reporter) external onlyOwner {
        authorizedReporters[_reporter] = true;
        emit ReporterApproved(_reporter);
    }

    function revokeReporter(address _reporter) external onlyOwner {
        authorizedReporters[_reporter] = false;
    }

    modifier onlyReporter() {
        require(authorizedReporters[msg.sender], "Not an authorized reporter");
        _;
    }

    // -------------------- PROVIDER MANAGEMENT --------------------

    function registerProvider(address _provider, string calldata _name) external onlyOwner {
        require(!providers[_provider].registered, "Provider already registered");
        providers[_provider] = Provider({
            name: _name,
            registered: true,
            totalRewards: 0
        });

        emit ProviderRegistered(_provider, _name);
    }

    // -------------------- PERFORMANCE LOGGING --------------------

    function logPerformance(address _provider, uint256 _score, string calldata _description) external onlyReporter {
        require(providers[_provider].registered, "Provider not registered");

        performanceEvents[_provider].push(PerformanceEvent({
            timestamp: block.timestamp,
            description: _description,
            score: _score,
            reporter: msg.sender
        }));

        emit PerformanceLogged(_provider, _score, _description, msg.sender);
    }

    // -------------------- REWARD DISTRIBUTION --------------------

    function distributeReward(address _provider, uint256 _amount) external onlyOwner {
        require(providers[_provider].registered, "Provider not registered");
        providers[_provider].totalRewards += _amount;

        payable(_provider).transfer(_amount);
        emit RewardDistributed(_provider, _amount);
    }

    // -------------------- VIEW FUNCTIONS --------------------

    function getPerformanceEvents(address _provider) external view returns (PerformanceEvent[] memory) {
        return performanceEvents[_provider];
    }

    function getTotalRewards(address _provider) external view returns (uint256) {
        return providers[_provider].totalRewards;
    }

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

    receive() external payable {}
}