ERC20Buffered.sol

pragma solidity ^0.8.0;

 contract AtomicityGuard {

    // address => block => status
    uint256 private constant _ENTERED = 1;

    mapping(address => mapping( uint256 => uint256)) ledger;

    modifier nonAtomic() {
         _nonAtomicBefore();
        _;
    }

    function _nonAtomicBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(ledger[msg.sender][block.number] != _ENTERED, "AtomicityGuard: same block");

        ledger[msg.sender][block.number] = _ENTERED;
    }
}

abstract contract BufferGuard is AtomicityGuard {

    // address => block => status
    uint256 private blockBuffer;
    uint256 private constant _ENTERED = 1;

    mapping(address => uint256) lastSeen;

    constructor(uint256 _buff) {
        blockBuffer = _buff;
    }

    modifier buffered() {
        console.log(lastSeen[msg.sender]);
        console.log(block.number);
        _buffered();
        _;
    }

    function _buffered() private nonAtomic {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        if(lastSeen[msg.sender] > 0) {
            require(block.number > lastSeen[msg.sender] + blockBuffer, "BufferGuard: not buffered");
        }

        lastSeen[msg.sender] = block.number;
    }

    function _saveCheckpoint(address user) internal virtual returns (bool) {
        lastSeen[user] = block.number;
        return true;
    }
}


abstract contract ERC20Buffered is BufferGuard {

    function _mint(address account, uint256 amount) internal virtual override {
        super._mint(account, amount);
        super._saveCheckpoint(account);
    }

    function _burn(address account, uint256 amount) internal virtual override {
        super._burn(account, amount);
        super._saveCheckpoint(account);
    }

    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual override {
        super._afterTokenTransfer(from, to, amount);
        super._saveCheckpoint(to);
    }
}