harb/onchain/src/Stake.sol

// SPDX-License-Identifier: GPL-3.0-or-later

pragma solidity ^0.8.19;

import {IERC20} from "@openzeppelin/token/ERC20/ERC20.sol";
import "@openzeppelin/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/token/ERC20/extensions/ERC20Permit.sol";
import {SafeERC20} from "@openzeppelin/token/ERC20/utils/SafeERC20.sol";
import {Math} from "@openzeppelin/utils/math/Math.sol";
import "./Harb.sol";

error ExceededAvailableStake(address receiver, uint256 stakeWanted, uint256 availableStake);
error TooMuchSnatch(address receiver, uint256 stakeWanted, uint256 availableStake, uint256 smallestShare);

contract Stake {
    using Math for uint256;

    uint256 internal DECIMAL_OFFSET = 5 + 2;
    uint256 internal constant MAX_STAKE = 20; // 20% of HARB supply
    uint256 internal constant TAX_RATE_BASE = 100;
    uint256 internal constant TAX_FLOOR_DURATION = 60 * 60 * 24 * 3; //this duration is the minimum basis for fee calculation, regardless of actual holding time.
    uint256[] public TAX_RATES = [1, 3, 5, 8, 12, 18, 24, 30, 40, 50, 60, 80, 100, 130, 180, 250, 320, 420, 540, 700, 920, 1200, 1600, 2000, 2600, 3400, 4400, 5700, 7500, 9700];
    /**
     * @dev Attempted to deposit more assets than the max amount for `receiver`.
     */

    error TaxTooLow(address receiver, uint64 taxRateWanted, uint64 taxRateMet, uint256 positionId);
    error SharesTooLow(address receiver, uint256 assets, uint256 sharesWanted, uint256 minStake);
    error NoPermission(address requester, address owner);
    error PositionNotFound(uint256 positionId, address requester);

    event PositionCreated(uint256 indexed positionId, address indexed owner, uint256 share, uint32 creationTime, uint32 taxRate);
    event TaxPaid(uint256 indexed positionId, address indexed owner, uint256 taxAmount);
    event PositionRemoved(uint256 indexed positionId, uint256 share, uint32 lastTaxTime);
    event PositionShrunk(uint256 indexed positionId, uint256 share, uint32 lastTaxTime, uint256 sharesTaken);

    struct StakingPosition {
        uint256 share;
        address owner;
        uint32 creationTime;
        uint32 lastTaxTime;
        uint32 taxRate; // e.g. value of 60 = 60% tax per year
    }

    uint256 public immutable totalSupply;
    Harb private immutable harb;
    address private immutable taxPool;
    uint256 public outstandingStake;
    uint256 public nextPositionId;
    mapping(uint256 => StakingPosition) public positions;

    constructor(address _harb) {
        harb = Harb(_harb);

        totalSupply = 10 ** (harb.decimals() + DECIMAL_OFFSET);
        taxPool = Harb(_harb).TAX_POOL();
        nextPositionId = 654321;
    }

    function authorizedStake() private view returns (uint256) {
        return totalSupply * MAX_STAKE / 100;
    }

    function assetsToShares(uint256 assets) public view returns (uint256) {
        return assets.mulDiv(totalSupply, harb.totalSupply(), Math.Rounding.Down);
        //return assets.mulDiv(totalSupply, harb.totalSupply() + 1, rounding);
    }

    function sharesToAssets(uint256 shares) public view returns (uint256) {
        //return shares.mulDiv(harb.totalSupply() + 1, totalSupply, rounding);
        // TODO: should the average total supply be used for this calculation?
        return shares.mulDiv(harb.totalSupply(), totalSupply, Math.Rounding.Down);
    }

    function permitAndSnatch(
        uint256 assets,
        address receiver,
        uint32 taxRate,
        uint256[] calldata positionsToSnatch,
        // address owner,
        // address spender,
        // uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external
        returns (uint256 positionId)
    {
        ERC20Permit(address(harb)).permit(receiver, address(this), assets, deadline, v, r, s);
        return snatch(assets, receiver, taxRate, positionsToSnatch);
    }

    /**
     * TODO: deal with metatransactions: While these are generally available
     * via msg.sender and msg.data, they should not be accessed in such a direct
     * manner, since when dealing with meta-transactions the account sending and
     * paying for execution may not be the actual sender (as far as an application
     * is concerned).
     */
    function snatch(uint256 assets, address receiver, uint32 taxRate, uint256[] calldata positionsToSnatch)
        public
        returns (uint256 positionId)
    {
        // check lower boundary
        uint256 sharesWanted = assetsToShares(assets);
        {
            // check that position size is at least minStake
            // to prevent excessive fragmentation, increasing snatch cost
            uint256 minStake = harb.previousTotalSupply() / 3000;
            if (sharesWanted < minStake) {
                revert SharesTooLow(receiver, assets, sharesWanted, minStake);
            }
        }
        require(taxRate < TAX_RATES.length, "tax rate out of bounds");

        uint256 smallestPositionShare = totalSupply;
        uint256 availableStake = authorizedStake() - outstandingStake;

        if (positionsToSnatch.length >= 2) {
            // run through all but last positions to snatch
            for (uint256 i = 0; i < positionsToSnatch.length - 1; i++) {
                StakingPosition storage pos = positions[positionsToSnatch[i]];
                if (pos.creationTime == 0) {
                    revert PositionNotFound(positionsToSnatch[i], receiver);
                }
                // check that tax lower
                if (taxRate <= pos.taxRate) {
                    revert TaxTooLow(receiver, taxRate, pos.taxRate, i);
                }
                if (pos.share < smallestPositionShare) {
                    smallestPositionShare = pos.share;
                }
                // dissolve position
                // TODO: what if someone calls payTax and exitPosition in the same transaction?
                _payTax(positionsToSnatch[i], pos, 0);
                _exitPosition(positionsToSnatch[i], pos);
            }
        }
        availableStake = authorizedStake() - outstandingStake;

        if (positionsToSnatch.length > 0) {
            // handle last position, either shrink or snatch
            uint256 index = positionsToSnatch.length - 1;
            StakingPosition storage lastPos = positions[positionsToSnatch[index]];
            if (lastPos.creationTime == 0) {
                //TODO:
                revert PositionNotFound(positionsToSnatch[index], receiver);
            }
            // check that tax lower
            if (taxRate <= lastPos.taxRate) {
                revert TaxTooLow(receiver, taxRate, lastPos.taxRate, index);
            }
            if (lastPos.share < smallestPositionShare) {
                smallestPositionShare = lastPos.share;
            }
            // dissolve position
            _payTax(positionsToSnatch[index], lastPos, 0);
            if (availableStake > sharesWanted) {
                revert TooMuchSnatch(receiver, sharesWanted, availableStake, smallestPositionShare);
            }
            uint256 lastSharesNeeded = sharesWanted - availableStake;
            if (lastSharesNeeded > lastPos.share * 80 / 100) {
                _exitPosition(positionsToSnatch[index], lastPos);
            } else {
                _shrinkPosition(positionsToSnatch[index], lastPos, lastSharesNeeded);
            }
        }
        availableStake = authorizedStake() - outstandingStake;

        if (sharesWanted > availableStake) {
            revert ExceededAvailableStake(receiver, sharesWanted, availableStake);
        }

        // avoid greeving where more positions are freed than needed.
        if (availableStake - sharesWanted > smallestPositionShare) {
            revert TooMuchSnatch(receiver, sharesWanted, availableStake, smallestPositionShare);
        }

        // transfer
        SafeERC20.safeTransferFrom(harb, msg.sender, address(this), assets);

        // mint
        positionId = nextPositionId++;
        StakingPosition storage sp = positions[positionId];
        sp.share = sharesWanted;
        sp.owner = receiver;
        sp.lastTaxTime = uint32(block.timestamp);
        sp.creationTime = uint32(block.timestamp);
        sp.taxRate = taxRate;

        outstandingStake += sharesWanted;
        emit PositionCreated(positionId, sp.owner, sp.share, sp.creationTime, sp.taxRate);
    }

    function changeTax(uint256 positionId, uint32 taxRate) public {
        require(taxRate < TAX_RATES.length, "tax rate out of bounds");
        StakingPosition storage pos = positions[positionId];
        if (pos.creationTime == 0) {
            revert PositionNotFound(positionId, msg.sender);
        }
        if (pos.owner != msg.sender) {
            revert NoPermission(msg.sender, pos.owner);
        }
        // to prevent snatch-and-change grieving attack, pay TAX_FLOOR_DURATION
        require(taxRate > pos.taxRate, "tax too low to snatch");
        _payTax(positionId, pos, TAX_FLOOR_DURATION);
        pos.taxRate = taxRate;
    }

    function exitPosition(uint256 positionId) public {
        StakingPosition storage pos = positions[positionId];
        if (pos.creationTime == 0) {
            revert PositionNotFound(positionId, msg.sender);
        }
        if (pos.owner != msg.sender) {
            revert NoPermission(msg.sender, pos.owner);
        }
        // to prevent snatch-and-exit grieving attack, pay TAX_FLOOR_DURATION
        _payTax(positionId, pos, TAX_FLOOR_DURATION);
        _exitPosition(positionId, pos);
    }

    // TODO: write a bot that calls this function regularly
    function payTax(uint256 positionId) public {
        StakingPosition storage pos = positions[positionId];
        // TODO: what if someone calls payTax and exitPosition in the same transaction?
        _payTax(positionId, pos, 0);
    }

    function taxDue(uint256 positionId, uint256 taxFloorDuration) public view returns (uint256 amountDue) {
        StakingPosition storage pos = positions[positionId];
        // ihet = Implied Holding Expiry Timestamp
        uint256 ihet = (block.timestamp - pos.creationTime < taxFloorDuration)
            ? pos.creationTime + taxFloorDuration
            : block.timestamp;
        uint256 elapsedTime = ihet - pos.lastTaxTime;
        uint256 assetsBefore = sharesToAssets(pos.share);
        amountDue = assetsBefore * TAX_RATES[pos.taxRate] * elapsedTime / (365 * 24 * 60 * 60) / TAX_RATE_BASE;
    }

    function _payTax(uint256 positionId, StakingPosition storage pos, uint256 taxFloorDuration) private {
        // ihet = Implied Holding Expiry Timestamp
        uint256 ihet = (block.timestamp - pos.creationTime < taxFloorDuration)
            ? pos.creationTime + taxFloorDuration
            : block.timestamp;
        uint256 elapsedTime = ihet - pos.lastTaxTime;
        uint256 assetsBefore = sharesToAssets(pos.share);
        uint256 taxAmountDue = assetsBefore * TAX_RATES[pos.taxRate] * elapsedTime / (365 * 24 * 60 * 60) / TAX_RATE_BASE;
        if (taxAmountDue >= assetsBefore) {
            // can not pay more tax than value of position
            taxAmountDue = assetsBefore;
        }
        SafeERC20.safeTransfer(harb, taxPool, taxAmountDue);
        emit TaxPaid(positionId, pos.owner, taxAmountDue);
        if (assetsBefore - taxAmountDue > 0) {
            // if something left over, update storage
            uint256 shareAfterTax = assetsToShares(assetsBefore - taxAmountDue);
            outstandingStake -= pos.share - shareAfterTax;
            pos.share = shareAfterTax;
            pos.lastTaxTime = uint32(block.timestamp);
        } else {
            // if nothing left over, liquidate position
            outstandingStake -= pos.share;
            emit PositionRemoved(positionId, pos.share, pos.lastTaxTime);
            delete pos.owner;
            delete pos.creationTime;
        }
    }

    function _exitPosition(uint256 positionId, StakingPosition storage pos) private {
        outstandingStake -= pos.share;
        address owner = pos.owner;
        uint256 assets = sharesToAssets(pos.share);
        emit PositionRemoved(positionId, pos.share, pos.lastTaxTime);
        delete pos.owner;
        delete pos.creationTime;
        SafeERC20.safeTransfer(harb, owner, assets);
    }

    function _shrinkPosition(uint256 positionId, StakingPosition storage pos, uint256 sharesToTake) private {
        require (sharesToTake < pos.share, "position too small");
        uint256 assets = sharesToAssets(sharesToTake);
        pos.share -= sharesToTake;
        emit PositionShrunk(positionId, pos.share, pos.lastTaxTime, sharesToTake);
        SafeERC20.safeTransfer(harb, pos.owner, assets);
    }
}