Blockchain-Backed Risk Pooling and Self-Regulation Protocol for Alternative Payment Providers (DeMI)

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

interface IERC20 {
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);

    function transfer(
        address to,
        uint256 amount
    ) external returns (bool);

    function balanceOf(
        address account
    ) external view returns (uint256);

    function allowance(
        address owner,
        address spender
    ) external view returns (uint256);
}

contract DeMISROConsensusPool {
    struct MerchantProfile {
        uint256 totalVol;
        uint256 totalChb;
        uint256 riskTier;
        uint256 dynRate;
        uint256 totalContributed;
        uint256 claimsPaid;
    }

    struct EmergencyProposal {
        bytes32 targetMid;
        uint256 voteCnt;
        uint256 timestamp;
        bool executed;
        mapping(address => bool) hasVoted;
    }

    uint256 public constant BASE_RATE = 30;
    uint256 public constant MAX_CLAIM =
        500 * 10**6;
    uint256 public constant STOP_LOSS = 40;

    IERC20 public immutable token;
    uint256 public totalReserves;
    uint256 public monthlyClaims;
    uint256 public lastReset;
    bool public frozen;

    address[] public governors;
    mapping(address => bool) public isGov;
    uint256 public immutable threshold;

    mapping(address => bool) public embassies;
    mapping(bytes32 => MerchantProfile)
        public merchants;
    mapping(bytes32 => bool) public batches;
    mapping(uint256 => EmergencyProposal)
        public proposals;
    uint256 public propCnt;

    event EmbAuth(address indexed emb, bool st);
    event BatchProc(
        bytes32 indexed mid,
        bytes32 indexed root,
        uint256 contrib
    );
    event ClaimSettled(
        bytes32 indexed mid,
        uint256 amt,
        address indexed rec
    );
    event Rebate(
        address indexed val,
        uint256 amt
    );
    event Emergency(string reason);
    event Resume(
        uint256 indexed pid,
        uint256 votes
    );
    event PropInit(
        uint256 indexed pid,
        bytes32 indexed mid
    );

    modifier onlyGov() {
        require(isGov[msg.sender], "!gov");
        _;
    }

    modifier onlyNode() {
        require(
            embassies[msg.sender]
            || isGov[msg.sender],
            "!node"
        );
        _;
    }

    modifier whenNotFrozen() {
        require(!frozen, "frozen");
        _;
    }

    constructor(
        address _tok,
        address[] memory _govs,
        uint256 _thr
    ) {
        require(_tok != address(0), "!tok");
        require(_govs.length >= _thr, "!len");
        require(_thr > 0, "!thr");
        token = IERC20(_tok);
        threshold = _thr;
        lastReset = block.timestamp;
        for (uint256 i = 0;
             i < _govs.length;
             i++) {
            address g = _govs[i];
            require(g != address(0), "!adr");
            require(!isGov[g], "dup");
            isGov[g] = true;
            governors.push(g);
        }
    }

    function setEmbassy(
        address _emb,
        bool _st
    ) external onlyGov {
        require(_emb != address(0), "!emb");
        embassies[_emb] = _st;
        emit EmbAuth(_emb, _st);
    }

    function initiateRescue(
        bytes32 _mid
    ) external onlyNode returns (uint256) {
        require(frozen, "!frozen");
        propCnt++;
        EmergencyProposal storage p =
            proposals[propCnt];
        p.targetMid = _mid;
        p.voteCnt = 1;
        p.timestamp = block.timestamp;
        p.hasVoted[msg.sender] = true;
        emit PropInit(propCnt, _mid);
        return propCnt;
    }

    function voteRescue(
        uint256 _pid
    ) external onlyNode {
        require(frozen, "!frozen");
        EmergencyProposal storage p =
            proposals[_pid];
        require(!p.executed, "done");
        require(!p.hasVoted[msg.sender], "vtd");
        require(
            block.timestamp
            <= p.timestamp + 7 days,
            "exp"
        );
        p.hasVoted[msg.sender] = true;
        p.voteCnt++;
        if (p.voteCnt >= threshold) {
            p.executed = true;
            frozen = false;
            monthlyClaims = 0;
            lastReset = block.timestamp;
            emit Resume(_pid, p.voteCnt);
        }
    }

    function processBatch(
        bytes32 _mid,
        bytes32 _root,
        uint256 _vol,
        uint256 _chb
    ) external onlyNode whenNotFrozen {
        require(!batches[_root], "dup");
        require(_mid != bytes32(0), "!mid");
        MerchantProfile storage m =
            merchants[_mid];
        m.totalVol += _vol;
        m.totalChb += _chb;
        if (m.totalVol > 0) {
            uint256 r =
                (m.totalChb * 10000)
                / m.totalVol;
            if (r > 100) {
                m.riskTier = 3;
                m.dynRate = BASE_RATE * 3;
            } else if (r > 20) {
                m.riskTier = 2;
                m.dynRate = BASE_RATE * 2;
            } else {
                m.riskTier = 1;
                m.dynRate = BASE_RATE;
            }
        } else {
            m.dynRate = BASE_RATE;
        }
        uint256 contrib =
            (_vol * m.dynRate) / 10000;
        batches[_root] = true;
        if (contrib > 0) {
            uint256 alw =
                token.allowance(
                    msg.sender, address(this));
            require(alw >= contrib, "!alw");
            m.totalContributed += contrib;
            totalReserves += contrib;
            require(
                token.transferFrom(
                    msg.sender,
                    address(this),
                    contrib
                ),
                "!tf"
            );
        }
        emit BatchProc(_mid, _root, contrib);
    }

    function claim(
        bytes32 _mid,
        uint256 _amt,
        address _rec
    ) external onlyNode whenNotFrozen {
        require(_amt <= MAX_CLAIM, "!cap");
        require(_rec != address(0), "!rec");
        if (block.timestamp
            >= lastReset + 30 days) {
            monthlyClaims = 0;
            lastReset = block.timestamp;
        }
        MerchantProfile storage m =
            merchants[_mid];
        uint256 lim = m.totalContributed * 2;
        require(
            m.claimsPaid + _amt <= lim,
            "!lim"
        );
        uint256 stop =
            (totalReserves * STOP_LOSS) / 100;
        if (monthlyClaims + _amt > stop) {
            frozen = true;
            emit Emergency("stop-loss");
            revert("!stop");
        }
        m.claimsPaid += _amt;
        monthlyClaims += _amt;
        require(totalReserves >= _amt, "!res");
        totalReserves -= _amt;
        require(
            token.transfer(_rec, _amt),
            "!pay"
        );
        emit ClaimSettled(_mid, _amt, _rec);
    }

    function depositRebate(
        uint256 _amt
    ) external whenNotFrozen {
        require(_amt > 0, "!amt");
        totalReserves += _amt;
        require(
            token.transferFrom(
                msg.sender,
                address(this),
                _amt
            ),
            "!reb"
        );
        emit Rebate(msg.sender, _amt);
    }
}