KIP 81: Implementing the on-chain governance voting method

interface IAddressBook {
    /// @dev Returns all addresses in the AddressBook.
    ///
    /// Each GC's addresses are stored in the same index of the three arrays.
    /// i.e. GC[i] is described in (nodeIds[i], stakingContracts[i], rewardAddresses[i])
    /// However, a GC may operate multiple staking contracts. In this case,
    /// the GC occupies multiple indices with the same reward address.
    ///
    /// @return nodeIds           GC consensus node address list
    /// @return stakingContracts  GC staking contract address list
    /// @return rewardAddresses   GC reward recipient address list
    /// @return pocAddress        PoC(KGF) recipient address
    /// @return kirAddress        KIR recepient address
    function getAllAddressInfo() external view returns(
        address[] memory nodeIds,
        address[] memory stakingContracts,
        address[] memory rewardAddresses,
        address pocAddress,
        address kirAddress);
}

abstract contract CnStakingV2 {
    event UpdateStakingTracker(address stakingTracker);
    event UpdateVoterAddress(address voterAddress);

    IStakingTracker public stakingTracker;
    address public voterAddress;

    /// @dev Set the initial stakingTracker address
    /// Emits an UpdateStakingTracker event.
    /// This function only works before contract initialization
    function setStakingTracker(address _tracker) external beforeInit;

    /// @dev Update the StakingTracker address this contract points to
    /// Emits an UpdateStakingTracker event.
    function submitUpdateStakingTracker(address _tracker) external;
    function updateStakingTracker(address _tracker) external onlyMultisigTx;

    /// @dev Update the voter address of this GC
    /// Emits an UpdateVoterAddress event.
    function submitUpdateVoterAddress(address _addr) external;
    function updateVoterAddress(address _addr) external onlyMultisigTx;
}

abstract contract CnStakingV2 {
    function depositLockupStakingAndInit() payable beforeInit() {
        // ...
        stakingTracker.refreshStake(address(this));
    }
    function stakeKlay() payable {
        // ...
        stakingTracker.refreshStake(address(this));
    }
    function withdrawLockupStaking(address _to, uint256 _value) {
        // ...
        _to.transfer(_value);
        stakingTracker.refreshStake(address(this));
    }
    function withdrawApprovedStaking(uint256 _approvedWithdrawalId) {
        // ...
        _to.transfer(_value);
        stakingTracker.refreshStake(address(this));
    }
    function updateVoterAddress(address _addr) {
        // ...
        voterAddress = _addr;
        stakingTracker.refreshVoter(address(this));
    }
}

interface IStakingTracker {
    /// @dev Re-evaluate Tracker contents related to the staking contract
    /// @param staking  The CnStaking contract address
    function refreshStake(address staking) external;

    /// @dev Update a GC's voter address from the given address
    /// @param staking  The CnStaking contract address
    function refreshVoter(address staking) external;
}

abstract contract CnStakingV2 {
    uint256 constant public VERSION = 2;
}

abstract contract StakingTracker {
    struct Tracker {
        // Tracker is only updated if trackStart <= block.number < trackEnd.
        uint256 trackStart;
        uint256 trackEnd;

        // List of eligible nodes and their staking addresses.
        // Initialized by createTracker().
        // Note that even if a GC member's stake falls below MIN_STAKE,
        // eligibleNodes is not updated accordingly. The eligibleNodes denotes
        // the number of eligible nodes at the initial recording (i.e. createTracker()).
        address[] nodeIds; // Representative nodeIds of all GC members
        mapping(address => address) rewardToNodeId;  // reward address to representative nodeId
        mapping(address => address) stakingToNodeId; // staking contract to representative nodeId
        uint256 eligibleNodes; // number of GC members with at least 1 vote

        // Balances and voting powers.
        // Initialized by createTracker() and updated by refreshStake().
        mapping(address => uint256) stakingBalances; // staking contract balance
        mapping(address => uint256) nodeBalances;    // total staking balance of a GC member
        mapping(address => uint256) nodeVotes;       // voting powers of a GC member
        uint256 totalVotes;                          // total voting powers of all GC members
    }

    // Tracker objects. Added by createTracker().
    mapping(uint256 => Tracker) private trackers; // trackerId => Tracker
    uint256[] private allTrackerIds;

    // 1-to-1 mapping between nodeId and voter account.
    // Updated by refreshVoter().
    mapping(address => address) private nodeIdToVoter; // nodeId => voterAddr
    mapping(address => address) private voterToNodeId; // voterAddr => nodeId

    // Minimum staking amount to have 1 vote
    function MIN_STAKE() external view returns(uint256);

    /// @dev Creates a new Tracker and populate initial values from AddressBook
    function createTracker(uint256 trackStart, uint256 trackEnd)
        external returns(uint256 trackerId);

    /// @dev Re-evaluate Tracker contents related to the staking contract
    /// Anyone can call this function, but `staking` must be a staking contract
    /// registered to the AddressBook.
    function refreshStake(address staking) external;

    /// @dev Re-evaluate voter account mapping related to the staking contract
    /// Anyone can call this function, but `staking` must be a staking contract
    /// registered to the AddressBook.
    /// Note that two different nodes cannot appoint the same voter address.
    function refreshVoter(address staking) external;

    /// @dev Return integer fields of a tracker
    function getTrackerSummary(uint256 trackerId) external view returns(
        uint256 trackStart,
        uint256 trackEnd,
        uint256 numNodes,
        uint256 totalVotes,
        uint256 eligibleNodes);

    /// @dev Return balances and votes of all nodes stored in a tracker
    function getAllTrackedNodes(uint256 trackerId) external view returns(
        address[] memory nodeIds,
        uint256[] memory nodeBalances,
        uint256[] memory nodeVotes);

    /// @dev Return the balance and votes of a specified node
    function getTrackedNode(uint256 trackerId, address nodeId) external view returns(
        uint256 nodeBalance,
        uint256 nodeVotes);

    /// @dev Find the node who owns the given voter account
    function getNodeFromVoter(address voter) external view returns(address nodeId);

    /// @dev Find the voter account of the given node
    function getVoterFromNode(address nodeId) external view returns(address voter);
}

abstract contract StakingTracker {
    function createTracker(uint256 trackStart, uint256 trackEnd)
        external override returns(uint256 trackerId)
    {
        trackerId = allTrackerIds.length + 1;
        allTrackerIds.push(trackerId);

        Tracker storage tracker = trackers[trackerId];
        tracker.trackStart = trackStart;
        tracker.trackEnd = trackEnd;
        populateFromAddressBook(tracker);
        calcAllVotes(tracker);
        return trackerId;
    }

    function populateFromAddressBook(Tracker storage tracker) private {
        (address[] memory nodeIds,
         address[] memory stakingContracts,
         address[] memory rewardAddrs, , ) =
            IAddressBook(ADDRESS_BOOK_ADDRESS()).getAllAddressInfo();

        // Group staking contracts by common reward address
        for (uint256 i = 0; i < nodeIds.length; i++) {
            address n = nodeIds[i];
            address s = stakingContracts[i];
            address r = rewardAddrs[i];
            if (tracker.rewardToNodeId[r] == address(0)) { // fresh rewardAddr
                tracker.nodeIds.push(n);
                tracker.rewardToNodeId[r] = n;
            } else { // previously appeared rewardAddr
                n = tracker.rewardToNodeId[r];
            }
            tracker.stakingToNodeId[s] = n;
            tracker.stakingBalances[s] = s.balance;
            tracker.nodeBalances[n] += s.balance;
        }
    }

    function calcAllVotes(Tracker storage tracker) private {
        uint256 eligibleNodes = 0;
        for (uint256 i = 0; i < tracker.nodeIds.length; i++) {
            if (isNodeEligible(trackerId, tracker.nodeIds[i])) {
                eligibleNodes ++;
            }
        }

        tracker.eligibleNodes = eligibleNodes;
        tracker.totalVotes = 0;

        for (uint256 i = 0; i < tracker.nodeIds.length; i++) {
            address nodeId = tracker.nodeIds[i];
            uint256 nodeBalance = tracker.nodeBalances[nodeId];
            uint256 votes = calcVotes(tracker.eligibleNodes, nodeBalance);
            tracker.nodeVotes[nodeId] = votes;
            tracker.totalVotes += votes;
        }
    }

    function calcVotes(uint256 eligibleNodes, uint256 balance) private view returns(uint256) {
        uint256 voteCap = 1;
        if (eligibleNodes > 1) {
            voteCap = eligibleNodes - 1;
        }
        uint256 votes = balance / MIN_STAKE();
        if (votes > voteCap) {
            votes = voteCap;
        }
        return votes;
    }

    function refreshStake(address staking) external override {
        for (uint256 i = 0; i < allTrackerIds.length; i++) {
            uint256 trackerId = allTrackerIds[i];
            Tracker storage tracker = trackers[trackerId];
            if (tracker.trackStart <= block.number && block.number < tracker.trackEnd) {
                updateTracker(tracker, staking);
            }
        }
    }

    function updateTracker(Tracker storage tracker, address staking) private {
        // Check that `staking` is valid GC contract
        address nodeId = tracker.stakingToNodeId[staking];
        if (nodeId == address(0)) {
            return;
        }

        // Update balance
        uint256 oldBalance = tracker.stakingBalances[staking];
        uint256 newBalance = address(staking).balance;
        tracker.stakingBalances[staking] = newBalance;
        tracker.nodeBalances[nodeId] -= oldBalance;
        tracker.nodeBalances[nodeId] += newBalance;
        uint256 nodeBalance = tracker.nodeBalances[nodeId];

        // Update votes
        uint256 oldVotes = tracker.nodeVotes[nodeId];
        uint256 newVotes = calcVotes(tracker.eligibleNodes, nodeBalance);
        tracker.nodeVotes[nodeId] = newVotes;
        tracker.totalVotes -= oldVotes;
        tracker.totalVotes += newVotes;
    }

    function refreshVoter(address staking) external {
        address nodeId = resolveStakingFromAddressBook(staking);
        require(nodeId != address(0), "not a staking contract");

        // Unlink existing two-way mapping
        address oldVoter = nodeIdToVoter[nodeId];
        if (oldVoter != address(0)) {
            voterToNodeId[oldVoter] = address(0);
            nodeIdToVoter[nodeId] = address(0);
        }
        // Create new mapping
        address newVoter = ICnStakingV2(staking).getVoterAddress();
        if (newVoter != address(0)) {
            require(voterToNodeId[newVoter] == address(0),
                    "Voter address already taken");
            voterToNodeId[newVoter] = nodeId;
            nodeIdToVoter[nodeId] = newVoter;
        }
    }

    function resolveStakingFromAddressBook(address staking)
        private view returns(address)
    {
        (address[] memory nodeIds,
         address[] memory stakingContracts,
         address[] memory rewardAddrs, , ) =
            IAddressBook(ADDRESS_BOOK_ADDRESS()).getAllAddressInfo();

        address rewardAddr;
        for (uint256 i = 0; i < nodeIds.length; i++) {
            if (stakingContracts[i] == staking) {
                rewardAddr = rewardAddrs[i];
                break;
            }
        }
        for (uint256 i = 0; i < nodeIds.length; i++) {
            if (rewardAddrs[i] == rewardAddr) {
                return nodeIds[i];
            }
        }
        return address(0);
    }

interface Voting {
    enum ProposalState { Pending, Active, Canceled, Failed, Passed,
                         Queued, Expired, Executed }
    enum VoteChoice { No, Yes, Abstain }

    struct Receipt {
        bool hasVoted;
        uint8 choice;
        uint256 votes;
    }

    // events

    /// @dev Emitted when a proposal is created
    /// @param signatures  Array of empty strings; for compatibility with OpenZeppelin
    event ProposalCreated(
        uint256 proposalId, address proposer,
        address[] targets, uint256[] values, string[] signatures, bytes[] calldatas,
        uint256 voteStart, uint256 voteEnd, string description);

    /// @dev Emitted when a proposal is canceled
    event ProposalCanceled(uint256 proposalId);

    /// @dev Emitted when a proposal is queued
    /// @param eta  The block number where transaction becomes executable.
    event ProposalQueued(uint256 proposalId, uint256 eta);

    /// @dev Emitted when a proposal is executed
    event ProposalExecuted(uint256 proposalId);

    /// @dev Emitted when a vote is cast
    /// @param reason  An empty string; for compatibility with OpenZeppelin
    event VoteCast(address indexed voter, uint256 proposalId,
                   uint8 choice, uint256 votes, string reason);

    // mutator functions

    /// @dev Create a Proposal
    /// If secretariat is null, any GC with at least 1 vote can propose.
    /// Otherwise only secretariat can propose.
    /// Default timing parameters are used.
    function propose(
        string description,
        address[] targets,
        uint256[] values,
        bytes[] calldatas) external returns (uint256 proposalId);

    /// @dev Cancel a proposal
    /// The proposal must be in one of Pending, Active, Passed, or Queued state.
    /// Only the proposer of the proposal can cancel the proposal.
    function cancel(uint256 proposalId) external;

    /// @dev Cast a vote to a proposal
    /// The proposal must be in Active state
    /// A same voter can call this function again to change choice.
    /// choice must be one of VoteChoice.
    function castVote(uint256 proposalId, uint8 choice) external;

    /// @dev Queue a passed proposal
    /// The proposal must be in Passed state
    /// Current block must be before `queueDeadline` of this proposal
    /// If secretariat is null, any GC with at least 1 vote can queue.
    /// Otherwise only secretariat can queue.
    function queue(uint256 proposalId) external;

    /// @dev Execute a queued proposal
    /// The proposal must be in Queued state
    /// Current block must be after `eta` and before `execDeadline` of this proposal
    /// If secretariat is null, any GC with at least 1 vote can execute.
    /// Otherwise only secretariat can execute.
    function execute(uint256 proposalId) external payable;

    /// @dev Set secretariat account
    /// Must be called by address(this), i.e. via governance proposal.
    function updateSecretariat(address _new) external;

    // getter functions

    /// @dev The secretariat account
    function secretariat() external view returns(address);

    /// @dev Delay from proposal submission to voting start in block numbers
    function votingDelay() external view returns(uint256);

    /// @dev Duration of the voting in block numbers
    function votingPeriod() external view returns(uint256);

    /// @dev Grace period to queue() passed proposals in block numbers
    function queueTimeout() external view returns(uint256);

    /// @dev A minimum delay before a queued transaction can be executed in block numbers
    function execDelay() external view returns(uint256);

    /// @dev Grace period to execute() queued proposals since `execDelay` in block numbers
    function execTimeout() external view returns(uint256);

    /// @dev State of a proposal
    function state(uint256 proposalId) external view returns (ProposalState);

    /// @dev Check if a proposal is passed
    function checkQuorum(uint256 proposalId) external view returns(bool);

    /// @dev General contents of a proposal
    function getProposalContent(uint256 proposalId) external view returns(
        uint256 id,
        address proposer,
        string memory description
    );

    /// @dev Transactions in a proposal
    /// @return signatures  Array of empty strings; for compatibility with OpenZeppelin
    function function getActions(uint256 proposalId) external view returns(
        address[] memory targets,
        uint256[] memory values,
        string[] memory signatures,
        bytes[] memory calldatas
    );

    /// @dev Timing and state related properties of a proposal
    function getProposalSchedule(uint256 proposalId) external view returns(
        uint256 voteStart,      // propose()d block + votingDelay
        uint256 voteEnd,        // voteStart + votingPeriod
        uint256 queueDeadline,  // voteEnd + queueTimeout
        uint256 eta,            // queue()d block + execDelay
        uint256 execDeadline,   // queue()d block + execDelay + execTimeout
        bool canceled,          // true if successfully cancel()ed
        bool queued,            // true if successfully queue()d
        bool executed           // true if successfully execute()d
    );

    /// @dev Vote counting related properties of a proposal
    function getProposalTally(uint256 proposalId) external view returns(
        uint256 totalYes,
        uint256 totalNo,
        uint256 totalAbstain,
        uint256 quorumCount,      // required number of voters
        uint256 quorumPower,      // required number of voting powers
        address[] memory voters,  // list of nodeIds who voted
    )

    /// @dev Individual vote receipt
    function getReceipt(uint256 proposalId, address voter)
        external view returns(Receipt memory);
}

abstract contract Voting {
    struct Proposal {
        uint256 trackerId;  // StakingTracker trackerId created in propose()
        uint256 totalYes;
        uint256 totalNo;
        uint256 totalAbstain;
        address[] voters;
        mapping(address => Receipt) receipts;
    }
    mapping(uint256 => Proposal) proposals;
    IStakingTracker stakingTracker;

    function castVote(uint256 proposalId, uint8 choice) external {
        Proposal storage p = proposals[proposalId];

        address nodeId = stakingTracker.getNodeFromVoter(msg.sender);
        ( , uint256 votes) = stakingTracker.getTrackedNode(p.trackerId, nodeId);

        // Revoke vote if exists
        if (p.receipts[nodeId].hasVoted) {
            uint8 oldChoice = p.receipts[nodeId].choice;
            if (oldChoice == VoteChoice.Yes) { p.totalYes -= votes; }
            if (oldChoice == VoteChoice.No) { p.totalNo -= votes; }
            if (oldChoice == VoteChoice.Abstain) { p.totalAbstain -= votes; }
        }
        // Record new vote
        p.receipts[nodeId].hasVoted = true;
        p.receipts[nodeId].choice = choice;
        p.receipts[nodeId].votes = votes;
        if (choice == VoteChoice.Yes) { p.totalYes += votes; }
        if (choice == VoteChoice.No) { p.totalNo += votes; }
        if (choice == VoteChoice.Abstain) { p.totalAbstain += votes; }
        if (!p.receipts[nodeId].hasVoted) { p.voters.push(nodeId); }
    }

    function checkQuorum(uint256 proposalId) external view returns(bool) {
        Proposal storage p = proposals[proposalId];

        ( , , , uint256 totalVotes, uint256 eligibleNodes) =
            stakingTracker.getTrackerSummary(p.trackerId);

        bool countQuorum = (p.voters.length >= (eligibleNodes / 3));
        bool powerQuorum = ((p.totalYes + p.totalNo + p.totalAbstain) > (totalVotes / 3));
        bool majorityYes = (p.totalYes > (p.totalNo + p.totalAbstain));
        return ((countQuorum || powerQuorum) && majorityYes);
    }
}

abstract contract Voting {
    struct Proposal {
        uint256 voteStart;      // propose()d block + votingDelay
        uint256 voteEnd;        // voteStart + votingPeriod
        uint256 queueDeadline;  // voteEnd + queueTimeout
        uint256 eta;            // queue()d block + execDelay
        uint256 execDeadline;   // queue()d block + execDelay + execTimeout
        bool canceled;          // true if successfully cancel()ed
        bool queued;            // true if successfully queue()d
        bool executed;          // true if successfully execute()d
    }
    mapping(uint256 => Proposal) proposals;

    function state(uint256 proposalId) external view returns (ProposalState) {
        Proposal storage p = proposals[proposalId];

        if (p.executed) {
            return ProposalState.Executed;
        } else if (p.canceled) {
            return ProposalState.Canceled;
        } else if (block.number < p.voteStart) {
            return ProposalState.Pending;
        } else if (block.number <= p.voteEnd) {
            return ProposalState.Active;
        } else if (!checkQuorum(proposalId)) {
            return ProposalState.Failed;
        }

        if (!p.queued) {
            if (block.number <= p.queueDeadline) {
                return ProposalState.Passed;
            } else {
                return ProposalState.Expired;
            }
        } else {
            if (block.number <= p.execDeadline) {
                return ProposalState.Queued;
            } else {
                return ProposalState.Expired;
            }
        }
    }
}

abstract contract Voting {
    struct Proposal {
        address[] targets;
        uint256[] values;
        bytes[] calldatas;

    }
    mapping(uint256 => Proposal) proposals;

    function execute(uint256 proposalId) external payable {
        Proposal storage p = proposals[proposalId];

        for (uint256 i = 0; i < p.targets.length; i++) {
            (bool success, bytes memory result) =
                    p.targets[i].call{value: p.values[i]}(p.calldatas[i]);
            require(success, "Transaction failed");
        }
    }
}