거버넌스

바이프로스트 네트워크는 BFC 보유자들이 관리하는 탈중앙화 네트워크입니다. 바이프로스트 네트워크의 거버넌스 프로토콜의 핵심에서, BFC 보유자들은 자신들의 스테이킹 양에 비례하는 지분 가중 투표 시스템을 통해 커뮤니티가 제안한 레퍼렌덤 (referenda)에 투표함으로써 네트워크 변경 사항을 반영합니다.

거버넌스와 관련된 모든 작업은 다음 거버넌스 컨트랙트 (Governance contract)를 통해 수행할 수 있습니다.

Governance contract

• address: 0x0000000000000000000000000000000000000800

• 솔리디티 컴파일러가 이 기능을 지원하지 않으므로, 아래 인터페이스를 통해 메서드를 호출하는 것을 권장합니다.

// SPDX-License-Identifier: GPL-3.0-only
pragma solidity >=0.8.0;

/**
 * @title Pallet Governance Interface
 *
 * The interface through which solidity contracts will interact with governance related pallets
 * Address :    0x0000000000000000000000000000000000000800
 */

interface Governance {
    struct ongoing_referendum_info_meta_data {
        uint256 end;
        bytes32 proposal_hash;
        uint256 threshold;
        uint256 delay;
        uint256 ayes;
        uint256 nays;
        uint256 turnout;
    }

    struct finished_referendum_info_meta_data {
        bool approved;
        uint256 end;
    }

    /**
     * Get The total number of public proposals
     * Selector: 56fdf547
     * @return The total number of public proposals
     */
    function public_prop_count() external view returns (uint256);

    /**
     * Get details of the deposit for a proposal.
     * Selector: a30305e9
     * @param prop_index The index of the proposal you are interested in
     * @return (total deposit, initial deposit, depositors)
     */
    function deposit_of(uint256 prop_index)
        external
        view
        returns (
            uint256,
            uint256,
            address[] memory
        );

    /**
     * Get details of the votes for a referendum.
     * Selector: 09daa4d8
     * @param ref_index The index of the referendum you are interested in
     * @return (referenda index, voters, voting powers, voting sides, convictions)
     */
    function voting_of(uint256 ref_index)
        external
        view
        returns (
            uint256,
            address[] memory,
            uint256[] memory,
            bool[] memory,
            uint256[] memory
        );

    /**
     * Get details of the votes for the given account.
     * Selector: 198a1bd9
     * @param account The account address you are interested in
     * @return A tuple including:
     * * The index of voted referendas (removable)
     * * The raw votes submitted for each referenda (conviction not applied)
     * * The voting side of each referenda (true: aye, false: nay)
     * * The conviction multiplier of each votes (0~6)
     * * The delegated amount of votes received for this account (conviction applied)
     * * The delegated raw amount of votes received for this account (conviction not applied)
     * * The block number that expires the locked balance
     * * The balance locked to the network
     */
    function account_votes(address account)
        external
        view
        returns (
            uint256[] memory,
            uint256[] memory,
            bool[] memory,
            uint256[] memory,
            uint256,
            uint256,
            uint256,
            uint256
        );

    /**
     * Get the index of the lowest unbaked referendum
     * Selector: 0388f282
     * @return The lowest referendum index representing an unbaked referendum.
     */
    function lowest_unbaked() external view returns (uint256);

    /**
     * Get the details about an ongoing referendum.
     * Selector: 8b93d11a
     *
     * @dev This, along with `finished_referendum_info`, wraps the pallet's `referendum_info`
     * function. It is necessary to split it into two here because Solidity only has c-style enums.
     * @param ref_index The index of the referendum you are interested in
     * @return A tuple including:
     * * The block when voting on this referendum will end
     * * The proposal hash
     * * The biasing mechanism 0-SuperMajorityApprove, 1-SuperMajorityAgainst, 2-SimpleMajority
     * * The delay between passing and launching
     * * The total aye vote (including conviction)
     * * The total nay vote (including conviction)
     * * The total turnout (not including conviction)
     */
    function ongoing_referendum_info(uint256 ref_index)
        external
        view
        returns (ongoing_referendum_info_meta_data memory);

    /**
     * Get the details about a finished referendum.
     * Selector: b1fd383f
     *
     * @dev This, along with `ongoing_referendum_info`, wraps the pallet's `referendum_info`
     * function. It is necessary to split it into two here because Solidity only has c-style enums.
     * @param ref_index The index of the referendum you are interested in
     * @return A tuple including whether the referendum passed, and the block at which it finished.
     */
    function finished_referendum_info(uint256 ref_index)
        external
        view
        returns (finished_referendum_info_meta_data memory);

    /**
     * Make a new proposal
     * Selector: 7824e7d1
     *
     * @param proposal_hash The hash of the proposal you are making
     * @param value The number of tokens to be locked behind this proposal.
     */
    function propose(bytes32 proposal_hash, uint256 value) external;

    /**
     * Signal agreement (endorsement) with a proposal
     * Selector: c7a76601
     *
     * @dev No amount is necessary here. Seconds are always for the same amount that the original
     * proposer locked. You may second multiple times.
     *
     * @param prop_index index of the proposal you want to second
     * @param seconds_upper_bound A number greater than or equal to the current number of seconds.
     * This is necessary for calculating the weight of the call.
     */
    function second(uint256 prop_index, uint256 seconds_upper_bound) external;

    /**
     * Vote on a referendum.
     * Selector: f56cb3b3
     *
     * @param ref_index index of the referendum you want to vote in
     * @param aye `true` is a vote to enact the proposal; `false` is a vote to keep the status quo.
     * @param vote_amount The number of tokens you are willing to lock if you get your way
     * @param conviction How strongly you want to vote. Higher conviction means longer lock time.
     * This must be an integer in the range 0 to 6
     *
     * @dev This function only supposrts `Standard` votes where you either vote aye or nay.
     * It does not support `Split` votes where you vote on both sides. If such a need
     * arises, we should add an additional function to this interface called `split_vote`.
     */
    function vote(
        uint256 ref_index,
        bool aye,
        uint256 vote_amount,
        uint256 conviction
    ) external;

    /** Remove a vote for a referendum.
     * Selector: 2042f50b
     *
     * @dev Locks get complex when votes are removed. See pallet-democracy's docs for details.
     * @param ref_index The index of the referendum you are interested in
     */
    function remove_vote(uint256 ref_index) external;

    /**
     * Delegate voting power to another account.
     * Selector: 0185921e
     *
     * @dev The balance delegated is locked for as long as it is delegated, and thereafter for the
     * time appropriate for the conviction's lock period.
     * @param target The account to whom the vote shall be delegated.
     * @param conviction The conviction with which you are delegating.
     * This must be an integer in the range 0 to 6
     * @param amount The number of tokens whose voting power shall be delegated.
     */
    function delegate(
        address target,
        uint256 conviction,
        uint256 amount
    ) external;

    /**
     * Undelegate voting power
     * Selector: cb37b8ea
     *
     * @dev Tokens may be unlocked once the lock period corresponding to the conviction with which
     * the delegation was issued has elapsed.
     */
    function undelegate() external;

    /**
     * Unlock tokens that have an expired lock.
     * Selector: 2f6c493c
     *
     * @param target The account whose tokens should be unlocked. This may be any account.
     */
    function unlock(address target) external;

    /**
     * Register the preimage for an upcoming proposal. This doesn't require the proposal to be
     * in the dispatch queue but does require a deposit, returned once enacted.
     * Selector: 200881f5
     *
     * @param encoded_proposal The scale-encoded proposal whose hash has been submitted on-chain.
     */
    function note_preimage(bytes memory encoded_proposal) external;

    /**
     * Register the preimage for an upcoming proposal. This requires the proposal to be
     * in the dispatch queue. No deposit is needed. When this call is successful, i.e.
     * the preimage has not been uploaded before and matches some imminent proposal,
     * no fee is paid.
     * Selector: cf205f96
     *
     * @param encoded_proposal The scale-encoded proposal whose hash has been submitted on-chain.
     */
    function note_imminent_preimage(bytes memory encoded_proposal) external;
}