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

/// @dev Contracts.
import {ERC1155} from "@solbase/src/tokens/ERC1155/ERC1155.sol";

/// @dev Libraries.
import {SafeCastLib} from "@solbase/src/utils/SafeCastLib.sol";

/// @notice Compound-like voting extension for ERC1155.
/// @author z0r0z.eth
abstract contract ERC1155Votes is ERC1155 {
    /// -----------------------------------------------------------------------
    /// Library Usage
    /// -----------------------------------------------------------------------

    using SafeCastLib for uint256;

    /// -----------------------------------------------------------------------
    /// Events
    /// -----------------------------------------------------------------------

    event DelegateChanged(
        address indexed delegator,
        address indexed fromDelegate,
        address indexed toDelegate,
        uint256 id
    );

    event DelegateVotesChanged(
        address indexed delegate,
        uint256 indexed id,
        uint256 previousBalance,
        uint256 newBalance
    );

    /// -----------------------------------------------------------------------
    /// Checkpoint Storage
    /// -----------------------------------------------------------------------

    mapping(address => mapping(uint256 => address)) internal _delegates;

    mapping(address => mapping(uint256 => uint256)) public numCheckpoints;

    mapping(address => mapping(uint256 => mapping(uint256 => Checkpoint)))
        public checkpoints;

    struct Checkpoint {
        uint64 fromTimestamp;
        uint192 votes;
    }

    /// -----------------------------------------------------------------------
    /// Delegation Logic
    /// -----------------------------------------------------------------------

    function delegates(address account, uint256 id)
        public
        view
        virtual
        returns (address)
    {
        address current = _delegates[account][id];

        return current == address(0) ? account : current;
    }

    function getCurrentVotes(address account, uint256 id)
        public
        view
        virtual
        returns (uint256)
    {
        // Won't underflow because decrement only occurs if positive `nCheckpoints`.
        unchecked {
            uint256 nCheckpoints = numCheckpoints[account][id];

            return
                nCheckpoints != 0
                    ? checkpoints[account][id][nCheckpoints - 1].votes
                    : 0;
        }
    }

    function getPriorVotes(
        address account,
        uint256 id,
        uint256 timestamp
    ) public view virtual returns (uint256) {
        require(block.timestamp > timestamp, "UNDETERMINED");

        uint256 nCheckpoints = numCheckpoints[account][id];

        if (nCheckpoints == 0) return 0;

        // Won't underflow because decrement only occurs if positive `nCheckpoints`.
        unchecked {
            // First check most recent balance.
            if (
                checkpoints[account][id][nCheckpoints - 1].fromTimestamp <=
                timestamp
            ) return checkpoints[account][id][nCheckpoints - 1].votes;

            // Next check implicit zero balance.
            if (checkpoints[account][id][0].fromTimestamp > timestamp) return 0;

            uint256 lower;

            uint256 upper = nCheckpoints - 1;

            while (upper > lower) {
                uint256 center = upper - (upper - lower) / 2;

                Checkpoint memory cp = checkpoints[account][id][center];

                if (cp.fromTimestamp == timestamp) {
                    return cp.votes;
                } else if (cp.fromTimestamp < timestamp) {
                    lower = center;
                } else {
                    upper = center - 1;
                }
            }

            return checkpoints[account][id][lower].votes;
        }
    }

    function delegate(address delegatee, uint256 id) public virtual {
        address currentDelegate = delegates(msg.sender, id);

        _delegates[msg.sender][id] = delegatee;

        emit DelegateChanged(msg.sender, currentDelegate, delegatee, id);

        _moveDelegates(
            currentDelegate,
            delegatee,
            id,
            balanceOf[msg.sender][id]
        );
    }

    function _moveDelegates(
        address srcRep,
        address dstRep,
        uint256 id,
        uint256 amount
    ) internal virtual {
        if (srcRep != dstRep && amount != 0) {
            if (srcRep != address(0)) {
                uint256 srcRepNum = numCheckpoints[srcRep][id];

                uint256 srcRepOld = srcRepNum != 0
                    ? checkpoints[srcRep][id][srcRepNum - 1].votes
                    : 0;

                _writeCheckpoint(
                    srcRep,
                    id,
                    srcRepNum,
                    srcRepOld,
                    srcRepOld - amount
                );
            }

            if (dstRep != address(0)) {
                uint256 dstRepNum = numCheckpoints[dstRep][id];

                uint256 dstRepOld = dstRepNum != 0
                    ? checkpoints[dstRep][id][dstRepNum - 1].votes
                    : 0;

                _writeCheckpoint(
                    dstRep,
                    id,
                    dstRepNum,
                    dstRepOld,
                    dstRepOld + amount
                );
            }
        }
    }

    function _writeCheckpoint(
        address delegatee,
        uint256 id,
        uint256 nCheckpoints,
        uint256 oldVotes,
        uint256 newVotes
    ) internal virtual {
        unchecked {
            uint64 timestamp = block.timestamp.safeCastTo64();

            // Won't underflow because decrement only occurs if positive `nCheckpoints`.
            if (
                nCheckpoints != 0 &&
                checkpoints[delegatee][id][nCheckpoints - 1].fromTimestamp ==
                timestamp
            ) {
                checkpoints[delegatee][id][nCheckpoints - 1].votes = newVotes
                    .safeCastTo192();
            } else {
                checkpoints[delegatee][id][nCheckpoints] = Checkpoint(
                    timestamp,
                    newVotes.safeCastTo192()
                );

                // Won't realistically overflow.
                ++numCheckpoints[delegatee][id];
            }
        }

        emit DelegateVotesChanged(delegatee, id, oldVotes, newVotes);
    }
}


An abstract extension for Compound-like ERC1155 voting. Uses gas-optimized dependencies by Solbase.

Compound-like voting extension for ERC1155

This function is used to move a certain amount of votes from one representative (srcRep) to another (dstRep). It first checks if the source and destination representatives are different and if the amount of votes to be moved is not 0. If these conditions are met, it subtracts the amount of votes from the source representative's total and adds it to the destination representative's total. It does this by writing a new checkpoint for each representative, which stores the new total amount of votes. (autogenerated documentation)

This function is used to write a checkpoint for a delegatee's vote count. It takes in the address of the delegatee, the ID of the vote, the number of checkpoints, the old vote count, and the new vote count. It then stores the timestamp, the new vote count, and increments the number of checkpoints for the delegatee. Finally, it emits an event to indicate that the delegatee's vote count has changed. (autogenerated documentation)

This function allows a user to delegate their balance of a particular token (identified by the id parameter) to another user (the delegatee parameter). The function first stores the current delegate in a variable, then updates the _delegates mapping to reflect the new delegate. It then emits an event to notify of the change, and finally calls the _moveDelegates function to transfer the balance from the current delegate to the new delegate. (autogenerated documentation)

This function is used to retrieve the address of a delegate associated with a given account and ID. It takes in two parameters, an address account and a uint256 id, and returns an address. It first looks up the address associated with the account and ID in the _delegates mapping, and if it finds one, it returns that address. If it does not find one, it returns the account address that was passed in. (autogenerated documentation)

This function retrieves the total number of votes for a given account and ID. It does this by first checking the numCheckpoints mapping to get the total number of checkpoints associated with the account and ID. If the number of checkpoints is not 0, it then retrieves the votes from the last checkpoint in the checkpoints mapping. If the number of checkpoints is 0, it returns 0. (autogenerated documentation)

This function is used to retrieve the number of votes a given account had at a given timestamp. It does this by using a binary search algorithm to look through the checkpoints array for the account and id provided. The checkpoints array stores the number of votes the account had at a given timestamp. The function returns the number of votes the account had at the given timestamp, or 0 if the timestamp is before the first checkpoint. (autogenerated documentation)