Code Structure & Playbooks

function availableDepositLimit(address) public view override returns (uint256) {
    return IERC4626(address(sDAI /* or sUSDS */)).maxDeposit(address(this));
}

function availableWithdrawLimit(address) public view override returns (uint256) {
    return IERC4626(address(sDAI /* or sUSDS */)).maxWithdraw(address(this));
}

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

import {BaseAllocationMechanism} from "./BaseAllocationMechanism.sol";
import {IERC20} from "./interfaces/IERC20.sol";

contract OnePersonOneVoteMechanism is BaseAllocationMechanism {
    bytes32 private constant OPOV_SLOT = keccak256("tam.mechanism.1p1v.storage.v1");

    struct OPOV {
        mapping(address => bool) registered;
        uint256 registeredCount;
        mapping(uint256 => mapping(address => bool)) voted;
        mapping(uint256 => uint256) forVotes;
        mapping(uint256 => uint256) againstVotes;
        uint256 totalForVotesSucceeded;
        uint256 quorumNum;
        uint256 quorumDen;
    }

    function _s() private pure returns (OPOV storage s) {
        bytes32 slot = OPOV_SLOT;
        assembly { s.slot := slot }
    }

    function setQuorum(uint256 num, uint256 den) external {
        require(msg.sender == address(_tokenizedAllocation().owner()), "!owner");
        require(den > 0 && num <= den, "bad quorum");
        OPOV storage s = _s();
        s.quorumNum = num; s.quorumDen = den;
    }
}

function _beforeSignupHook(address user) internal override returns (bool ok) {
    OPOV storage s = _s();
    if (!s.registered[user]) { s.registered[user] = true; s.registeredCount += 1; }
    return true;
}

function _getVotingPowerHook(address user, uint256) internal view override returns (uint256) {
    return _tokenizedAllocation().votingPower(user) == 0 ? 1 : 0;
}

function _beforeProposeHook(address proposer) internal view override returns (bool) {
    address mgmt = _tokenizedAllocation().management();
    address keep = _tokenizedAllocation().keeper();
    return (proposer == mgmt || proposer == keep);
}

enum VoteType { Against, For, Abstain }

function _processVoteHook(
    uint256 pid,
    address voter,
    VoteType choice,
    uint256 weight,
    uint256 oldPower
) internal override returns (uint256 newPower) {
    OPOV storage s = _s();
    require(!s.voted[pid][voter], "already voted");
    require(weight == 1, "1p1v: weight must be 1");
    s.voted[pid][voter] = true;
    if (choice == VoteType.For)       s.forVotes[pid]     += 1;
    else if (choice == VoteType.Against) s.againstVotes[pid] += 1;
    require(oldPower >= 1, "insufficient power");
    return oldPower - 1;
}

function _hasQuorumHook(uint256 pid) internal view override returns (bool) {
    OPOV storage s = _s();
    uint256 minVotes = (s.registeredCount * s.quorumNum) / s.quorumDen;
    return s.forVotes[pid] >= minVotes && s.forVotes[pid] > s.againstVotes[pid];
}

function _beforeFinalizeVoteTallyHook() internal override returns (bool) {
    OPOV storage s = _s();
    s.totalForVotesSucceeded = 0;
    uint256 n = _getProposalCount();
    for (uint256 pid = 1; pid <= n; pid++) {
        if (_hasQuorumHook(pid)) { s.totalForVotesSucceeded += s.forVotes[pid]; }
    }
    return true;
}

function _convertVotesToShares(uint256 pid) internal view override returns (uint256) {
    OPOV storage s = _s();
    require(s.totalForVotesSucceeded > 0, "no passing proposals");
    uint256 assets = (_tokenizedAllocation().totalAssets() * s.forVotes[pid])
                     / s.totalForVotesSucceeded;
    return assets;
}

function _availableWithdrawLimit(address) internal view override returns (uint256) {
    (uint48 start, uint48 grace) = (_tokenizedAllocation().globalRedemptionStart(),
                                    _tokenizedAllocation().gracePeriod());
    uint256 nowTs = block.timestamp;
    if (nowTs < start || nowTs > start + grace) return 0;
    return type(uint256).max;
}

function _requestCustomDistributionHook(address, uint256)
    internal override returns (bool handled, uint256 assetsTransferred)
{
    return (false, 0);
}

address public immutable TOKENIZED_STRATEGY_ADDRESS;
IERC20 internal immutable asset;
ITokenizedStrategy internal immutable TokenizedStrategy;

modifier onlySelf() {
    _onlySelf();
    _;
}

constructor(
    address _asset,
    string memory _name,
    address _management,
    address _keeper,
    address _emergencyAdmin,
    address _donationAddress,
    bool _enableBurning,
    address _tokenizedStrategyAddress
) {
    TOKENIZED_STRATEGY_ADDRESS = _tokenizedStrategyAddress;
    asset = IERC20(_asset);
    TokenizedStrategy = ITokenizedStrategy(address(this));
    // delegatecall init storage via _delegateCall(...)
}

bool public doHealthCheck = true;
uint16 private _profitLimitRatio = uint16(MAX_BPS); // default 100%
uint16 private _lossLimitRatio;                     // default 0

function harvestAndReport()
    external
    override
    onlySelf
    returns (uint256 _totalAssets)
{
    _totalAssets = super.harvestAndReport();
    if (doHealthCheck) {
        _executeHealthCheck(_totalAssets);
    }
}

function _executeHealthCheck(uint256 _totalAssets) internal virtual {
    // Child implementations compare _totalAssets vs last report,
    // revert when profit/loss breaches configured basis-point bands.
}

function updateDebt(
    mapping(address => StrategyParams) storage strategies,
    uint256 totalIdle,
    uint256 totalDebt,
    address strategy,
    uint256 targetDebt,
    uint256 maxLoss,
    uint256 minimumTotalIdle,
    address asset,
    bool isShutdown
) external returns (UpdateDebtResult memory result);

function safeApprove(address token, address spender, uint256 amount) external {
    (bool success, bytes memory data) =
        token.call(abi.encodeWithSelector(IERC20.approve.selector, spender, amount));
    if (!success || (data.length > 0 && !abi.decode(data, (bool)))) {
        revert ApprovalFailed();
    }
}

function _hasAccess(address staker) internal view returns (bool) {
    if (accessMode == AccessMode.NONE) return true;
    if (accessMode == AccessMode.ALLOWSET) return allowset.contains(staker);
    if (accessMode == AccessMode.BLOCKSET) return !blockset.contains(staker);
    return false;
}

function getEarningPower(uint256 stakedAmount, address staker, address)
    external
    view
    override
    returns (uint256 earningPower)
{
    if (!_hasAccess(staker)) return 0;
    return stakedAmount > type(uint96).max ? type(uint96).max : stakedAmount;
}

function getNewEarningPower(
    uint256 stakedAmount,
    address staker,
    address,
    uint256 oldEarningPower
) external view override returns (uint256 newPower, bool qualifies) {
    newPower = _hasAccess(staker)
        ? (stakedAmount > type(uint96).max ? type(uint96).max : stakedAmount)
        : 0;
    qualifies = newPower != oldEarningPower;
}

function _fetchOrDeploySurrogate(address delegatee)
    internal
    override
    returns (DelegationSurrogate surrogate)
{
    surrogate = _surrogates[delegatee];
    if (address(surrogate) != address(0)) return surrogate;

    bytes32 salt = keccak256(abi.encode(delegatee));
    surrogate = new DelegationSurrogate{salt: salt}(VOTING_TOKEN, delegatee);
    _surrogates[delegatee] = surrogate;

    emit SurrogateDeployed(delegatee, address(surrogate));
    return surrogate;
}

function report()
    public
    override(TokenizedStrategy)
    nonReentrant
    onlyKeepers
    returns (uint256 profit, uint256 loss)
{
    StrategyData storage S = _strategyStorage();
    YieldSkimmingStorage storage YS = _strategyYieldSkimmingStorage();

    uint256 currentRate = _currentRateRay();
    uint256 totalValue = _totalAssetsValue(S, currentRate);
    uint256 totalDebt = YS.totalUserDebtInAssetValue + YS.dragonRouterDebtInAssetValue;

    if (totalValue >= totalDebt) {
        profit = totalValue - totalDebt;
        _mintDragonDonation(S, YS, profit, currentRate);
    } else {
        uint256 lossValue = totalDebt - totalValue;
        loss = _handleDragonLossProtection(S, YS, lossValue, currentRate);
    }

    YS.lastReportedRate = currentRate;
    emit Harvest(msg.sender, currentRate);
}