FolioGovernor Contract

contract FolioGovernor is
    GovernorUpgradeable,
    GovernorSettingsUpgradeable,
    GovernorCountingSimpleUpgradeable,
    GovernorVotesUpgradeable,
    GovernorVotesQuorumFractionUpgradeable,
    GovernorTimelockControlUpgradeable

function initialize(
    IVotes _token,
    TimelockControllerUpgradeable _timelock,
    uint48 _votingDelay,
    uint32 _votingPeriod,
    uint256 _proposalThreshold,
    uint256 _quorumFraction
) external initializer

function proposalThreshold() public view returns (uint256) {
    uint256 threshold = super.proposalThreshold(); // D18{1}
    uint256 pastSupply = Math.max(1, token().getPastTotalSupply(clock() - 1));

    // CEIL to ensure thresholds near 0% don't get rounded down to 0
    return (threshold * pastSupply + (1e18 - 1)) / 1e18;
}

function quorumDenominator() public pure override returns (uint256) {
    return 1e18; // Use 18 decimals for percentage precision
}

address[] memory targets = new address[](1);
targets[0] = address(folio);

uint256[] memory values = new uint256[](1);
values[0] = 0;

bytes[] memory calldatas = new bytes[](1);
calldatas[0] = abi.encodeWithSignature(
    "setMintFee(uint256)",
    0.01e18 // 1% mint fee
);

string memory description = "Proposal: Set mint fee to 1%";

uint256 proposalId = governor.propose(
    targets,
    values,
    calldatas,
    description
);

// Vote options: Against (0), For (1), Abstain (2)
governor.castVote(proposalId, 1); // Vote For

// Or vote with reason
governor.castVoteWithReason(
    proposalId,
    1,
    "This improves protocol sustainability"
);

governor.queue(
    targets,
    values,
    calldatas,
    keccak256(bytes(description))
);

governor.execute(
    targets,
    values,
    calldatas,
    keccak256(bytes(description))
);

enum ProposalState {
    Pending,      // Waiting for voting delay to pass
    Active,       // Currently accepting votes
    Canceled,     // Canceled by proposer or guardian
    Defeated,     // Failed to reach quorum or majority
    Succeeded,    // Passed, ready to queue
    Queued,       // Queued in timelock
    Expired,      // Timelock expired without execution
    Executed      // Successfully executed
}

uint256 votingPower = token.getPastVotes(voter, proposalSnapshot);

// Delegate to another address
token.delegate(delegateAddress);

// Self-delegate to activate own voting power
token.delegate(msg.sender);

1. Proposal succeeds → Queue in timelock
2. Wait for timelock delay (e.g., 2 days)
3. Execute proposal

// Guardians have CANCELLER_ROLE on timelock
timelock.cancel(operationId);

function setVotingDelay(uint256 newVotingDelay) external onlyGovernance

function setVotingPeriod(uint256 newVotingPeriod) external onlyGovernance

function setProposalThreshold(uint256 newProposalThreshold) external onlyGovernance

function updateQuorumNumerator(uint256 newQuorumNumerator) external onlyGovernance

function state(uint256 proposalId) public view returns (ProposalState)

function hasVoted(uint256 proposalId, address account) public view returns (bool)

function proposalVotes(uint256 proposalId) public view returns (
    uint256 againstVotes,
    uint256 forVotes,
    uint256 abstainVotes
)