IGovernance Interface

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/**
 * @title IGovernance
 * @notice Interface for the Governance contract
 * @dev Deployed at: 0x0ebCFa07497B44e66859F82AC2c8f1187F0154cf (BSC Mainnet)
 *
 * This contract manages on-chain governance for the FarmTruth oracle system.
 * Token holders can create proposals, vote, and update oracle parameters.
 *
 * @custom:see contracts/Governance.sol
 */
interface IGovernance {

    // ============ Enums ============

    /**
     * @notice Types of proposals that can be created
     * @param PARAMETER_CHANGE Update oracle economic parameters
     * @param TIE_EXTENSION_UPDATE Update tie extension period
     * @param INDICATIVE Non-binding signaling proposal
     */
    enum ProposalType { PARAMETER_CHANGE, TIE_EXTENSION_UPDATE, INDICATIVE }

    /**
     * @notice Types of votes that can be cast
     * @param FOR Support the proposal
     * @param AGAINST Oppose the proposal
     * @param ABSTAIN Neutral position
     * @param VETO Strong opposition (burns proposer's deposit if >50%)
     */
    enum VoteType { FOR, AGAINST, ABSTAIN, VETO }

    // ============ State Variables ============

    /**
     * @notice The ERC20 token used for governance voting
     */
    function governanceToken() external view returns (IERC20);

    /**
     * @notice Burn address for vetoed proposal deposits
     */
    function BURN_ADDRESS() external view returns (address);

    /**
     * @notice Total number of proposals created
     */
    function proposalCount() external view returns (uint256);

    /**
     * @notice Deposit required to create a proposal (default: 100,000 tokens)
     * @dev Can be updated via PARAMETER_CHANGE proposal
     */
    function proposalCreationDeposit() external view returns (uint256);

    /**
     * @notice Duration of voting period in blocks (default: 115,200 blocks ~1 day)
     * @dev Can be updated via PARAMETER_CHANGE proposal
     */
    function votingPeriod() external view returns (uint256);

    /**
     * @notice Minimum percentage of total supply required for quorum (default: 10%)
     * @dev Can be updated via PARAMETER_CHANGE proposal
     */
    function quorumPercentage() external view returns (uint256);

    /**
     * @notice Duration of tie extension period in blocks (default: 28,800 blocks ~6 hours)
     * @dev Can be updated via TIE_EXTENSION_UPDATE proposal
     */
    function tieExtensionPeriod() external view returns (uint256);
}

bytes memory data = abi.encode(
    uint256 newDeposit,
    uint256 newVotingPeriod,
    uint256 newQuorum
);

bytes memory data = abi.encode(uint256 newPeriod);

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

import "./IGovernance.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract GovernanceReader {
    IGovernance public immutable governance;

    constructor(address _governance) {
        governance = IGovernance(_governance);
    }

    /// @notice Get all current governance parameters
    function getCurrentParameters() external view returns (
        uint256 creationDeposit,
        uint256 votingPeriod,
        uint256 quorum,
        uint256 tieExtension
    ) {
        return (
            governance.proposalCreationDeposit(),
            governance.votingPeriod(),
            governance.quorumPercentage(),
            governance.tieExtensionPeriod()
        );
    }

    /// @notice Get the governance token address
    function getTokenAddress() external view returns (address) {
        return address(governance.governanceToken());
    }

    /// @notice Check total proposals created
    function getProposalCount() external view returns (uint256) {
        return governance.proposalCount();
    }
}

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

import "./IDecentralizedOracle.sol";
import "./IGovernance.sol";

contract OracleWithGovernance {
    IDecentralizedOracle public immutable oracle;
    IGovernance public immutable governance;

    constructor(address _oracle) {
        oracle = IDecentralizedOracle(_oracle);
        governance = oracle.governance();
    }

    /// @notice Get required deposit to create an oracle query
    function getOracleCreationCost() external view returns (uint256) {
        return governance.proposalCreationDeposit();
    }

    /// @notice Get the voting token used by both governance and oracle
    function getVotingToken() external view returns (address) {
        return address(governance.governanceToken());
    }
}