tornado-contracts/contracts/Governance/v1/Delegation.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import { Core } from './Core.sol';

abstract contract Delegation is Core {
    /// @notice Delegatee records
    mapping(address => address) public delegatedTo;

    event Delegated(address indexed account, address indexed to);
    event Undelegated(address indexed account, address indexed from);

    function delegate(address to) external {
        address previous = delegatedTo[msg.sender];
        require(
            to != msg.sender && to != address(this) && to != address(0) && to != previous,
            'Governance: invalid delegatee'
        );
        if (previous != address(0)) {
            emit Undelegated(msg.sender, previous);
        }
        delegatedTo[msg.sender] = to;
        emit Delegated(msg.sender, to);
    }

    function undelegate() external {
        address previous = delegatedTo[msg.sender];
        require(previous != address(0), 'Governance: tokens are already undelegated');

        delegatedTo[msg.sender] = address(0);
        emit Undelegated(msg.sender, previous);
    }

    function proposeByDelegate(address from, address target, string memory description) external returns (uint256) {
        require(delegatedTo[from] == msg.sender, 'Governance: not authorized');
        return _propose(from, target, description);
    }

    function _propose(address proposer, address target, string memory description) internal virtual returns (uint256);

    function castDelegatedVote(address[] memory from, uint256 proposalId, bool support) external virtual {
        for (uint256 i = 0; i < from.length; i++) {
            require(delegatedTo[from[i]] == msg.sender, 'Governance: not authorized');
            _castVote(from[i], proposalId, support);
        }
        if (lockedBalance[msg.sender] > 0) {
            _castVote(msg.sender, proposalId, support);
        }
    }

    function _castVote(address voter, uint256 proposalId, bool support) internal virtual;
}