create-dubhe 0.1.13 → 1.2.0-pre.51

package/template/101/aptos-template/contracts/counter/build/counter/sources/dependencies/AptosFramework/aptos_governance.move

@@ -1,1390 +0,0 @@
-///
-/// AptosGovernance represents the on-chain governance of the Aptos network. Voting power is calculated based on the
-/// current epoch's voting power of the proposer or voter's backing stake pool. In addition, for it to count,
-/// the stake pool's lockup needs to be at least as long as the proposal's duration.
-///
-/// It provides the following flow:
-/// 1. Proposers can create a proposal by calling AptosGovernance::create_proposal. The proposer's backing stake pool
-/// needs to have the minimum proposer stake required. Off-chain components can subscribe to CreateProposalEvent to
-/// track proposal creation and proposal ids.
-/// 2. Voters can vote on a proposal. Their voting power is derived from the backing stake pool. A stake pool can vote
-/// on a proposal multiple times as long as the total voting power of these votes doesn't exceed its total voting power.
-module aptos_framework::aptos_governance {
-    use std::error;
-    use std::option;
-    use std::signer;
-    use std::string::{Self, String, utf8};
-    use std::vector;
-    use std::features;
-
-    use aptos_std::math64::min;
-    use aptos_std::simple_map::{Self, SimpleMap};
-    use aptos_std::smart_table::{Self, SmartTable};
-    use aptos_std::table::{Self, Table};
-
-    use aptos_framework::account::{Self, SignerCapability, create_signer_with_capability};
-    use aptos_framework::coin;
-    use aptos_framework::event::{Self, EventHandle};
-    use aptos_framework::governance_proposal::{Self, GovernanceProposal};
-    use aptos_framework::stake;
-    use aptos_framework::staking_config;
-    use aptos_framework::system_addresses;
-    use aptos_framework::aptos_coin::{Self, AptosCoin};
-    use aptos_framework::consensus_config;
-    use aptos_framework::randomness_config;
-    use aptos_framework::reconfiguration_with_dkg;
-    use aptos_framework::timestamp;
-    use aptos_framework::voting;
-
-    /// The specified stake pool does not have sufficient stake to create a proposal
-    const EINSUFFICIENT_PROPOSER_STAKE: u64 = 1;
-    /// This account is not the designated voter of the specified stake pool
-    const ENOT_DELEGATED_VOTER: u64 = 2;
-    /// The specified stake pool does not have long enough remaining lockup to create a proposal or vote
-    const EINSUFFICIENT_STAKE_LOCKUP: u64 = 3;
-    /// The specified stake pool has already been used to vote on the same proposal
-    const EALREADY_VOTED: u64 = 4;
-    /// The specified stake pool must be part of the validator set
-    const ENO_VOTING_POWER: u64 = 5;
-    /// Proposal is not ready to be resolved. Waiting on time or votes
-    const EPROPOSAL_NOT_RESOLVABLE_YET: u64 = 6;
-    /// The proposal has not been resolved yet
-    const EPROPOSAL_NOT_RESOLVED_YET: u64 = 8;
-    /// Metadata location cannot be longer than 256 chars
-    const EMETADATA_LOCATION_TOO_LONG: u64 = 9;
-    /// Metadata hash cannot be longer than 256 chars
-    const EMETADATA_HASH_TOO_LONG: u64 = 10;
-    /// Account is not authorized to call this function.
-    const EUNAUTHORIZED: u64 = 11;
-    /// The stake pool is using voting power more than it has.
-    const EVOTING_POWER_OVERFLOW: u64 = 12;
-    /// Partial voting feature hasn't been properly initialized.
-    const EPARTIAL_VOTING_NOT_INITIALIZED: u64 = 13;
-    /// The proposal in the argument is not a partial voting proposal.
-    const ENOT_PARTIAL_VOTING_PROPOSAL: u64 = 14;
-
-    /// This matches the same enum const in voting. We have to duplicate it as Move doesn't have support for enums yet.
-    const PROPOSAL_STATE_SUCCEEDED: u64 = 1;
-
-    const MAX_U64: u64 = 18446744073709551615;
-
-    /// Proposal metadata attribute keys.
-    const METADATA_LOCATION_KEY: vector<u8> = b"metadata_location";
-    const METADATA_HASH_KEY: vector<u8> = b"metadata_hash";
-
-    /// Store the SignerCapabilities of accounts under the on-chain governance's control.
-    struct GovernanceResponsbility has key {
-        signer_caps: SimpleMap<address, SignerCapability>,
-    }
-
-    /// Configurations of the AptosGovernance, set during Genesis and can be updated by the same process offered
-    /// by this AptosGovernance module.
-    struct GovernanceConfig has key {
-        min_voting_threshold: u128,
-        required_proposer_stake: u64,
-        voting_duration_secs: u64,
-    }
-
-    struct RecordKey has copy, drop, store {
-        stake_pool: address,
-        proposal_id: u64,
-    }
-
-    /// Records to track the proposals each stake pool has been used to vote on.
-    struct VotingRecords has key {
-        votes: Table<RecordKey, bool>
-    }
-
-    /// Records to track the voting power usage of each stake pool on each proposal.
-    struct VotingRecordsV2 has key {
-        votes: SmartTable<RecordKey, u64>
-    }
-
-    /// Used to track which execution script hashes have been approved by governance.
-    /// This is required to bypass cases where the execution scripts exceed the size limit imposed by mempool.
-    struct ApprovedExecutionHashes has key {
-        hashes: SimpleMap<u64, vector<u8>>,
-    }
-
-    /// Events generated by interactions with the AptosGovernance module.
-    struct GovernanceEvents has key {
-        create_proposal_events: EventHandle<CreateProposalEvent>,
-        update_config_events: EventHandle<UpdateConfigEvent>,
-        vote_events: EventHandle<VoteEvent>,
-    }
-
-    /// Event emitted when a proposal is created.
-    struct CreateProposalEvent has drop, store {
-        proposer: address,
-        stake_pool: address,
-        proposal_id: u64,
-        execution_hash: vector<u8>,
-        proposal_metadata: SimpleMap<String, vector<u8>>,
-    }
-
-    /// Event emitted when there's a vote on a proposa;
-    struct VoteEvent has drop, store {
-        proposal_id: u64,
-        voter: address,
-        stake_pool: address,
-        num_votes: u64,
-        should_pass: bool,
-    }
-
-    /// Event emitted when the governance configs are updated.
-    struct UpdateConfigEvent has drop, store {
-        min_voting_threshold: u128,
-        required_proposer_stake: u64,
-        voting_duration_secs: u64,
-    }
-
-    #[event]
-    /// Event emitted when a proposal is created.
-    struct CreateProposal has drop, store {
-        proposer: address,
-        stake_pool: address,
-        proposal_id: u64,
-        execution_hash: vector<u8>,
-        proposal_metadata: SimpleMap<String, vector<u8>>,
-    }
-
-    #[event]
-    /// Event emitted when there's a vote on a proposa;
-    struct Vote has drop, store {
-        proposal_id: u64,
-        voter: address,
-        stake_pool: address,
-        num_votes: u64,
-        should_pass: bool,
-    }
-
-    #[event]
-    /// Event emitted when the governance configs are updated.
-    struct UpdateConfig has drop, store {
-        min_voting_threshold: u128,
-        required_proposer_stake: u64,
-        voting_duration_secs: u64,
-    }
-
-    /// Can be called during genesis or by the governance itself.
-    /// Stores the signer capability for a given address.
-    public fun store_signer_cap(
-        aptos_framework: &signer,
-        signer_address: address,
-        signer_cap: SignerCapability,
-    ) acquires GovernanceResponsbility {
-        system_addresses::assert_aptos_framework(aptos_framework);
-        system_addresses::assert_framework_reserved(signer_address);
-
-        if (!exists<GovernanceResponsbility>(@aptos_framework)) {
-            move_to(
-                aptos_framework,
-                GovernanceResponsbility { signer_caps: simple_map::create<address, SignerCapability>() }
-            );
-        };
-
-        let signer_caps = &mut borrow_global_mut<GovernanceResponsbility>(@aptos_framework).signer_caps;
-        simple_map::add(signer_caps, signer_address, signer_cap);
-    }
-
-    /// Initializes the state for Aptos Governance. Can only be called during Genesis with a signer
-    /// for the aptos_framework (0x1) account.
-    /// This function is private because it's called directly from the vm.
-    fun initialize(
-        aptos_framework: &signer,
-        min_voting_threshold: u128,
-        required_proposer_stake: u64,
-        voting_duration_secs: u64,
-    ) {
-        system_addresses::assert_aptos_framework(aptos_framework);
-
-        voting::register<GovernanceProposal>(aptos_framework);
-        move_to(aptos_framework, GovernanceConfig {
-            voting_duration_secs,
-            min_voting_threshold,
-            required_proposer_stake,
-        });
-        move_to(aptos_framework, GovernanceEvents {
-            create_proposal_events: account::new_event_handle<CreateProposalEvent>(aptos_framework),
-            update_config_events: account::new_event_handle<UpdateConfigEvent>(aptos_framework),
-            vote_events: account::new_event_handle<VoteEvent>(aptos_framework),
-        });
-        move_to(aptos_framework, VotingRecords {
-            votes: table::new(),
-        });
-        move_to(aptos_framework, ApprovedExecutionHashes {
-            hashes: simple_map::create<u64, vector<u8>>(),
-        })
-    }
-
-    /// Update the governance configurations. This can only be called as part of resolving a proposal in this same
-    /// AptosGovernance.
-    public fun update_governance_config(
-        aptos_framework: &signer,
-        min_voting_threshold: u128,
-        required_proposer_stake: u64,
-        voting_duration_secs: u64,
-    ) acquires GovernanceConfig, GovernanceEvents {
-        system_addresses::assert_aptos_framework(aptos_framework);
-
-        let governance_config = borrow_global_mut<GovernanceConfig>(@aptos_framework);
-        governance_config.voting_duration_secs = voting_duration_secs;
-        governance_config.min_voting_threshold = min_voting_threshold;
-        governance_config.required_proposer_stake = required_proposer_stake;
-
-        if (std::features::module_event_migration_enabled()) {
-            event::emit(
-                UpdateConfig {
-                    min_voting_threshold,
-                    required_proposer_stake,
-                    voting_duration_secs
-                },
-            )
-        } else {
-            let events = borrow_global_mut<GovernanceEvents>(@aptos_framework);
-            event::emit_event<UpdateConfigEvent>(
-                &mut events.update_config_events,
-                UpdateConfigEvent {
-                    min_voting_threshold,
-                    required_proposer_stake,
-                    voting_duration_secs
-                },
-            );
-        };
-    }
-
-    /// Initializes the state for Aptos Governance partial voting. Can only be called through Aptos governance
-    /// proposals with a signer for the aptos_framework (0x1) account.
-    public fun initialize_partial_voting(
-        aptos_framework: &signer,
-    ) {
-        system_addresses::assert_aptos_framework(aptos_framework);
-
-        move_to(aptos_framework, VotingRecordsV2 {
-            votes: smart_table::new(),
-        });
-    }
-
-    #[view]
-    public fun get_voting_duration_secs(): u64 acquires GovernanceConfig {
-        borrow_global<GovernanceConfig>(@aptos_framework).voting_duration_secs
-    }
-
-    #[view]
-    public fun get_min_voting_threshold(): u128 acquires GovernanceConfig {
-        borrow_global<GovernanceConfig>(@aptos_framework).min_voting_threshold
-    }
-
-    #[view]
-    public fun get_required_proposer_stake(): u64 acquires GovernanceConfig {
-        borrow_global<GovernanceConfig>(@aptos_framework).required_proposer_stake
-    }
-
-    #[view]
-    /// Return true if a stake pool has already voted on a proposal before partial governance voting is enabled.
-    public fun has_entirely_voted(stake_pool: address, proposal_id: u64): bool acquires VotingRecords {
-        let record_key = RecordKey {
-            stake_pool,
-            proposal_id,
-        };
-        // If a stake pool has already voted on a proposal before partial governance voting is enabled,
-        // there is a record in VotingRecords.
-        let voting_records = borrow_global<VotingRecords>(@aptos_framework);
-        table::contains(&voting_records.votes, record_key)
-    }
-
-    #[view]
-    /// Return remaining voting power of a stake pool on a proposal.
-    /// Note: a stake pool's voting power on a proposal could increase over time(e.g. rewards/new stake).
-    public fun get_remaining_voting_power(
-        stake_pool: address,
-        proposal_id: u64
-    ): u64 acquires VotingRecords, VotingRecordsV2 {
-        assert_voting_initialization();
-
-        let proposal_expiration = voting::get_proposal_expiration_secs<GovernanceProposal>(
-            @aptos_framework,
-            proposal_id
-        );
-        let lockup_until = stake::get_lockup_secs(stake_pool);
-        // The voter's stake needs to be locked up at least as long as the proposal's expiration.
-        // Also no one can vote on a expired proposal.
-        if (proposal_expiration > lockup_until || timestamp::now_seconds() > proposal_expiration) {
-            return 0
-        };
-
-        // If a stake pool has already voted on a proposal before partial governance voting is enabled, the stake pool
-        // cannot vote on the proposal even after partial governance voting is enabled.
-        if (has_entirely_voted(stake_pool, proposal_id)) {
-            return 0
-        };
-        let record_key = RecordKey {
-            stake_pool,
-            proposal_id,
-        };
-        let used_voting_power = 0u64;
-        if (features::partial_governance_voting_enabled()) {
-            let voting_records_v2 = borrow_global<VotingRecordsV2>(@aptos_framework);
-            used_voting_power = *smart_table::borrow_with_default(&voting_records_v2.votes, record_key, &0);
-        };
-        get_voting_power(stake_pool) - used_voting_power
-    }
-
-    /// Create a single-step proposal with the backing `stake_pool`.
-    /// @param execution_hash Required. This is the hash of the resolution script. When the proposal is resolved,
-    /// only the exact script with matching hash can be successfully executed.
-    public entry fun create_proposal(
-        proposer: &signer,
-        stake_pool: address,
-        execution_hash: vector<u8>,
-        metadata_location: vector<u8>,
-        metadata_hash: vector<u8>,
-    ) acquires GovernanceConfig, GovernanceEvents {
-        create_proposal_v2(proposer, stake_pool, execution_hash, metadata_location, metadata_hash, false);
-    }
-
-    /// Create a single-step or multi-step proposal with the backing `stake_pool`.
-    /// @param execution_hash Required. This is the hash of the resolution script. When the proposal is resolved,
-    /// only the exact script with matching hash can be successfully executed.
-    public entry fun create_proposal_v2(
-        proposer: &signer,
-        stake_pool: address,
-        execution_hash: vector<u8>,
-        metadata_location: vector<u8>,
-        metadata_hash: vector<u8>,
-        is_multi_step_proposal: bool,
-    ) acquires GovernanceConfig, GovernanceEvents {
-        create_proposal_v2_impl(
-            proposer,
-            stake_pool,
-            execution_hash,
-            metadata_location,
-            metadata_hash,
-            is_multi_step_proposal
-        );
-    }
-
-    /// Create a single-step or multi-step proposal with the backing `stake_pool`.
-    /// @param execution_hash Required. This is the hash of the resolution script. When the proposal is resolved,
-    /// only the exact script with matching hash can be successfully executed.
-    /// Return proposal_id when a proposal is successfully created.
-    public fun create_proposal_v2_impl(
-        proposer: &signer,
-        stake_pool: address,
-        execution_hash: vector<u8>,
-        metadata_location: vector<u8>,
-        metadata_hash: vector<u8>,
-        is_multi_step_proposal: bool,
-    ): u64 acquires GovernanceConfig, GovernanceEvents {
-        let proposer_address = signer::address_of(proposer);
-        assert!(
-            stake::get_delegated_voter(stake_pool) == proposer_address,
-            error::invalid_argument(ENOT_DELEGATED_VOTER)
-        );
-
-        // The proposer's stake needs to be at least the required bond amount.
-        let governance_config = borrow_global<GovernanceConfig>(@aptos_framework);
-        let stake_balance = get_voting_power(stake_pool);
-        assert!(
-            stake_balance >= governance_config.required_proposer_stake,
-            error::invalid_argument(EINSUFFICIENT_PROPOSER_STAKE),
-        );
-
-        // The proposer's stake needs to be locked up at least as long as the proposal's voting period.
-        let current_time = timestamp::now_seconds();
-        let proposal_expiration = current_time + governance_config.voting_duration_secs;
-        assert!(
-            stake::get_lockup_secs(stake_pool) >= proposal_expiration,
-            error::invalid_argument(EINSUFFICIENT_STAKE_LOCKUP),
-        );
-
-        // Create and validate proposal metadata.
-        let proposal_metadata = create_proposal_metadata(metadata_location, metadata_hash);
-
-        // We want to allow early resolution of proposals if more than 50% of the total supply of the network coins
-        // has voted. This doesn't take into subsequent inflation/deflation (rewards are issued every epoch and gas fees
-        // are burnt after every transaction), but inflation/delation is very unlikely to have a major impact on total
-        // supply during the voting period.
-        let total_voting_token_supply = coin::supply<AptosCoin>();
-        let early_resolution_vote_threshold = option::none<u128>();
-        if (option::is_some(&total_voting_token_supply)) {
-            let total_supply = *option::borrow(&total_voting_token_supply);
-            // 50% + 1 to avoid rounding errors.
-            early_resolution_vote_threshold = option::some(total_supply / 2 + 1);
-        };
-
-        let proposal_id = voting::create_proposal_v2(
-            proposer_address,
-            @aptos_framework,
-            governance_proposal::create_proposal(),
-            execution_hash,
-            governance_config.min_voting_threshold,
-            proposal_expiration,
-            early_resolution_vote_threshold,
-            proposal_metadata,
-            is_multi_step_proposal,
-        );
-
-        if (std::features::module_event_migration_enabled()) {
-            event::emit(
-                CreateProposal {
-                    proposal_id,
-                    proposer: proposer_address,
-                    stake_pool,
-                    execution_hash,
-                    proposal_metadata,
-                },
-            );
-        } else {
-            let events = borrow_global_mut<GovernanceEvents>(@aptos_framework);
-            event::emit_event<CreateProposalEvent>(
-                &mut events.create_proposal_events,
-                CreateProposalEvent {
-                    proposal_id,
-                    proposer: proposer_address,
-                    stake_pool,
-                    execution_hash,
-                    proposal_metadata,
-                },
-            );
-        };
-        proposal_id
-    }
-
-    /// Vote on proposal with proposal_id and all voting power from multiple stake_pools.
-    public entry fun batch_vote(
-        voter: &signer,
-        stake_pools: vector<address>,
-        proposal_id: u64,
-        should_pass: bool,
-    ) acquires ApprovedExecutionHashes, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        vector::for_each(stake_pools, |stake_pool| {
-            vote_internal(voter, stake_pool, proposal_id, MAX_U64, should_pass);
-        });
-    }
-
-    /// Batch vote on proposal with proposal_id and specified voting power from multiple stake_pools.
-    public entry fun batch_partial_vote(
-        voter: &signer,
-        stake_pools: vector<address>,
-        proposal_id: u64,
-        voting_power: u64,
-        should_pass: bool,
-    ) acquires ApprovedExecutionHashes, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        vector::for_each(stake_pools, |stake_pool| {
-            vote_internal(voter, stake_pool, proposal_id, voting_power, should_pass);
-        });
-    }
-
-    /// Vote on proposal with `proposal_id` and all voting power from `stake_pool`.
-    public entry fun vote(
-        voter: &signer,
-        stake_pool: address,
-        proposal_id: u64,
-        should_pass: bool,
-    ) acquires ApprovedExecutionHashes, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        vote_internal(voter, stake_pool, proposal_id, MAX_U64, should_pass);
-    }
-
-    /// Vote on proposal with `proposal_id` and specified voting power from `stake_pool`.
-    public entry fun partial_vote(
-        voter: &signer,
-        stake_pool: address,
-        proposal_id: u64,
-        voting_power: u64,
-        should_pass: bool,
-    ) acquires ApprovedExecutionHashes, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        vote_internal(voter, stake_pool, proposal_id, voting_power, should_pass);
-    }
-
-    /// Vote on proposal with `proposal_id` and specified voting_power from `stake_pool`.
-    /// If voting_power is more than all the left voting power of `stake_pool`, use all the left voting power.
-    /// If a stake pool has already voted on a proposal before partial governance voting is enabled, the stake pool
-    /// cannot vote on the proposal even after partial governance voting is enabled.
-    fun vote_internal(
-        voter: &signer,
-        stake_pool: address,
-        proposal_id: u64,
-        voting_power: u64,
-        should_pass: bool,
-    ) acquires ApprovedExecutionHashes, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        let voter_address = signer::address_of(voter);
-        assert!(stake::get_delegated_voter(stake_pool) == voter_address, error::invalid_argument(ENOT_DELEGATED_VOTER));
-
-        // The voter's stake needs to be locked up at least as long as the proposal's expiration.
-        let proposal_expiration = voting::get_proposal_expiration_secs<GovernanceProposal>(
-            @aptos_framework,
-            proposal_id
-        );
-        assert!(
-            stake::get_lockup_secs(stake_pool) >= proposal_expiration,
-            error::invalid_argument(EINSUFFICIENT_STAKE_LOCKUP),
-        );
-
-        // If a stake pool has already voted on a proposal before partial governance voting is enabled,
-        // `get_remaining_voting_power` returns 0.
-        let staking_pool_voting_power = get_remaining_voting_power(stake_pool, proposal_id);
-        voting_power = min(voting_power, staking_pool_voting_power);
-
-        // Short-circuit if the voter has no voting power.
-        assert!(voting_power > 0, error::invalid_argument(ENO_VOTING_POWER));
-
-        voting::vote<GovernanceProposal>(
-            &governance_proposal::create_empty_proposal(),
-            @aptos_framework,
-            proposal_id,
-            voting_power,
-            should_pass,
-        );
-
-        let record_key = RecordKey {
-            stake_pool,
-            proposal_id,
-        };
-        if (features::partial_governance_voting_enabled()) {
-            let voting_records_v2 = borrow_global_mut<VotingRecordsV2>(@aptos_framework);
-            let used_voting_power = smart_table::borrow_mut_with_default(&mut voting_records_v2.votes, record_key, 0);
-            // This calculation should never overflow because the used voting cannot exceed the total voting power of this stake pool.
-            *used_voting_power = *used_voting_power + voting_power;
-        } else {
-            let voting_records = borrow_global_mut<VotingRecords>(@aptos_framework);
-            assert!(
-                !table::contains(&voting_records.votes, record_key),
-                error::invalid_argument(EALREADY_VOTED));
-            table::add(&mut voting_records.votes, record_key, true);
-        };
-
-        if (std::features::module_event_migration_enabled()) {
-            event::emit(
-                Vote {
-                    proposal_id,
-                    voter: voter_address,
-                    stake_pool,
-                    num_votes: voting_power,
-                    should_pass,
-                },
-            );
-        } else {
-            let events = borrow_global_mut<GovernanceEvents>(@aptos_framework);
-            event::emit_event<VoteEvent>(
-                &mut events.vote_events,
-                VoteEvent {
-                    proposal_id,
-                    voter: voter_address,
-                    stake_pool,
-                    num_votes: voting_power,
-                    should_pass,
-                },
-            );
-        };
-
-        let proposal_state = voting::get_proposal_state<GovernanceProposal>(@aptos_framework, proposal_id);
-        if (proposal_state == PROPOSAL_STATE_SUCCEEDED) {
-            add_approved_script_hash(proposal_id);
-        }
-    }
-
-    public entry fun add_approved_script_hash_script(proposal_id: u64) acquires ApprovedExecutionHashes {
-        add_approved_script_hash(proposal_id)
-    }
-
-    /// Add the execution script hash of a successful governance proposal to the approved list.
-    /// This is needed to bypass the mempool transaction size limit for approved governance proposal transactions that
-    /// are too large (e.g. module upgrades).
-    public fun add_approved_script_hash(proposal_id: u64) acquires ApprovedExecutionHashes {
-        let approved_hashes = borrow_global_mut<ApprovedExecutionHashes>(@aptos_framework);
-
-        // Ensure the proposal can be resolved.
-        let proposal_state = voting::get_proposal_state<GovernanceProposal>(@aptos_framework, proposal_id);
-        assert!(proposal_state == PROPOSAL_STATE_SUCCEEDED, error::invalid_argument(EPROPOSAL_NOT_RESOLVABLE_YET));
-
-        let execution_hash = voting::get_execution_hash<GovernanceProposal>(@aptos_framework, proposal_id);
-
-        // If this is a multi-step proposal, the proposal id will already exist in the ApprovedExecutionHashes map.
-        // We will update execution hash in ApprovedExecutionHashes to be the next_execution_hash.
-        if (simple_map::contains_key(&approved_hashes.hashes, &proposal_id)) {
-            let current_execution_hash = simple_map::borrow_mut(&mut approved_hashes.hashes, &proposal_id);
-            *current_execution_hash = execution_hash;
-        } else {
-            simple_map::add(&mut approved_hashes.hashes, proposal_id, execution_hash);
-        }
-    }
-
-    /// Resolve a successful single-step proposal. This would fail if the proposal is not successful (not enough votes or more no
-    /// than yes).
-    public fun resolve(
-        proposal_id: u64,
-        signer_address: address
-    ): signer acquires ApprovedExecutionHashes, GovernanceResponsbility {
-        voting::resolve<GovernanceProposal>(@aptos_framework, proposal_id);
-        remove_approved_hash(proposal_id);
-        get_signer(signer_address)
-    }
-
-    /// Resolve a successful multi-step proposal. This would fail if the proposal is not successful.
-    public fun resolve_multi_step_proposal(
-        proposal_id: u64,
-        signer_address: address,
-        next_execution_hash: vector<u8>
-    ): signer acquires GovernanceResponsbility, ApprovedExecutionHashes {
-        voting::resolve_proposal_v2<GovernanceProposal>(@aptos_framework, proposal_id, next_execution_hash);
-        // If the current step is the last step of this multi-step proposal,
-        // we will remove the execution hash from the ApprovedExecutionHashes map.
-        if (vector::length(&next_execution_hash) == 0) {
-            remove_approved_hash(proposal_id);
-        } else {
-            // If the current step is not the last step of this proposal,
-            // we replace the current execution hash with the next execution hash
-            // in the ApprovedExecutionHashes map.
-            add_approved_script_hash(proposal_id)
-        };
-        get_signer(signer_address)
-    }
-
-    /// Remove an approved proposal's execution script hash.
-    public fun remove_approved_hash(proposal_id: u64) acquires ApprovedExecutionHashes {
-        assert!(
-            voting::is_resolved<GovernanceProposal>(@aptos_framework, proposal_id),
-            error::invalid_argument(EPROPOSAL_NOT_RESOLVED_YET),
-        );
-
-        let approved_hashes = &mut borrow_global_mut<ApprovedExecutionHashes>(@aptos_framework).hashes;
-        if (simple_map::contains_key(approved_hashes, &proposal_id)) {
-            simple_map::remove(approved_hashes, &proposal_id);
-        };
-    }
-
-    /// Manually reconfigure. Called at the end of a governance txn that alters on-chain configs.
-    ///
-    /// WARNING: this function always ensures a reconfiguration starts, but when the reconfiguration finishes depends.
-    /// - If feature `RECONFIGURE_WITH_DKG` is disabled, it finishes immediately.
-    ///   - At the end of the calling transaction, we will be in a new epoch.
-    /// - If feature `RECONFIGURE_WITH_DKG` is enabled, it starts DKG, and the new epoch will start in a block prologue after DKG finishes.
-    ///
-    /// This behavior affects when an update of an on-chain config (e.g. `ConsensusConfig`, `Features`) takes effect,
-    /// since such updates are applied whenever we enter an new epoch.
-    public entry fun reconfigure(aptos_framework: &signer) {
-        system_addresses::assert_aptos_framework(aptos_framework);
-        if (consensus_config::validator_txn_enabled() && randomness_config::enabled()) {
-            reconfiguration_with_dkg::try_start();
-        } else {
-            reconfiguration_with_dkg::finish(aptos_framework);
-        }
-    }
-
-    /// Change epoch immediately.
-    /// If `RECONFIGURE_WITH_DKG` is enabled and we are in the middle of a DKG,
-    /// stop waiting for DKG and enter the new epoch without randomness.
-    ///
-    /// WARNING: currently only used by tests. In most cases you should use `reconfigure()` instead.
-    /// TODO: migrate these tests to be aware of async reconfiguration.
-    public entry fun force_end_epoch(aptos_framework: &signer) {
-        system_addresses::assert_aptos_framework(aptos_framework);
-        reconfiguration_with_dkg::finish(aptos_framework);
-    }
-
-    /// `force_end_epoch()` equivalent but only called in testnet,
-    /// where the core resources account exists and has been granted power to mint Aptos coins.
-    public entry fun force_end_epoch_test_only(aptos_framework: &signer) acquires GovernanceResponsbility {
-        let core_signer = get_signer_testnet_only(aptos_framework, @0x1);
-        system_addresses::assert_aptos_framework(&core_signer);
-        reconfiguration_with_dkg::finish(&core_signer);
-    }
-
-    /// Update feature flags and also trigger reconfiguration.
-    public fun toggle_features(aptos_framework: &signer, enable: vector<u64>, disable: vector<u64>) {
-        system_addresses::assert_aptos_framework(aptos_framework);
-        features::change_feature_flags_for_next_epoch(aptos_framework, enable, disable);
-        reconfigure(aptos_framework);
-    }
-
-    /// Only called in testnet where the core resources account exists and has been granted power to mint Aptos coins.
-    public fun get_signer_testnet_only(
-        core_resources: &signer, signer_address: address): signer acquires GovernanceResponsbility {
-        system_addresses::assert_core_resource(core_resources);
-        // Core resources account only has mint capability in tests/testnets.
-        assert!(aptos_coin::has_mint_capability(core_resources), error::unauthenticated(EUNAUTHORIZED));
-        get_signer(signer_address)
-    }
-
-    #[view]
-    /// Return the voting power a stake pool has with respect to governance proposals.
-    public fun get_voting_power(pool_address: address): u64 {
-        let allow_validator_set_change = staking_config::get_allow_validator_set_change(&staking_config::get());
-        if (allow_validator_set_change) {
-            let (active, _, pending_active, pending_inactive) = stake::get_stake(pool_address);
-            // We calculate the voting power as total non-inactive stakes of the pool. Even if the validator is not in the
-            // active validator set, as long as they have a lockup (separately checked in create_proposal and voting), their
-            // stake would still count in their voting power for governance proposals.
-            active + pending_active + pending_inactive
-        } else {
-            stake::get_current_epoch_voting_power(pool_address)
-        }
-    }
-
-    /// Return a signer for making changes to 0x1 as part of on-chain governance proposal process.
-    fun get_signer(signer_address: address): signer acquires GovernanceResponsbility {
-        let governance_responsibility = borrow_global<GovernanceResponsbility>(@aptos_framework);
-        let signer_cap = simple_map::borrow(&governance_responsibility.signer_caps, &signer_address);
-        create_signer_with_capability(signer_cap)
-    }
-
-    fun create_proposal_metadata(
-        metadata_location: vector<u8>,
-        metadata_hash: vector<u8>
-    ): SimpleMap<String, vector<u8>> {
-        assert!(string::length(&utf8(metadata_location)) <= 256, error::invalid_argument(EMETADATA_LOCATION_TOO_LONG));
-        assert!(string::length(&utf8(metadata_hash)) <= 256, error::invalid_argument(EMETADATA_HASH_TOO_LONG));
-
-        let metadata = simple_map::create<String, vector<u8>>();
-        simple_map::add(&mut metadata, utf8(METADATA_LOCATION_KEY), metadata_location);
-        simple_map::add(&mut metadata, utf8(METADATA_HASH_KEY), metadata_hash);
-        metadata
-    }
-
-    fun assert_voting_initialization() {
-        if (features::partial_governance_voting_enabled()) {
-            assert!(exists<VotingRecordsV2>(@aptos_framework), error::invalid_state(EPARTIAL_VOTING_NOT_INITIALIZED));
-        };
-    }
-
-    #[test_only]
-    public entry fun create_proposal_for_test(
-        proposer: &signer,
-        multi_step: bool,
-    ) acquires GovernanceConfig, GovernanceEvents {
-        let execution_hash = vector::empty<u8>();
-        vector::push_back(&mut execution_hash, 1);
-        if (multi_step) {
-            create_proposal_v2(
-                proposer,
-                signer::address_of(proposer),
-                execution_hash,
-                b"",
-                b"",
-                true,
-            );
-        } else {
-            create_proposal(
-                proposer,
-                signer::address_of(proposer),
-                execution_hash,
-                b"",
-                b"",
-            );
-        };
-    }
-
-    #[test_only]
-    public fun resolve_proposal_for_test(
-        proposal_id: u64,
-        signer_address: address,
-        multi_step: bool,
-        finish_multi_step_execution: bool
-    ): signer acquires ApprovedExecutionHashes, GovernanceResponsbility {
-        if (multi_step) {
-            let execution_hash = vector::empty<u8>();
-            vector::push_back(&mut execution_hash, 1);
-
-            if (finish_multi_step_execution) {
-                resolve_multi_step_proposal(proposal_id, signer_address, vector::empty<u8>())
-            } else {
-                resolve_multi_step_proposal(proposal_id, signer_address, execution_hash)
-            }
-        } else {
-            resolve(proposal_id, signer_address)
-        }
-    }
-
-    #[test_only]
-    /// Force reconfigure. To be called at the end of a proposal that alters on-chain configs.
-    public fun toggle_features_for_test(enable: vector<u64>, disable: vector<u64>) {
-        toggle_features(&account::create_signer_for_test(@0x1), enable, disable);
-    }
-
-    #[test_only]
-    public entry fun test_voting_generic(
-        aptos_framework: signer,
-        proposer: signer,
-        yes_voter: signer,
-        no_voter: signer,
-        multi_step: bool,
-        use_generic_resolve_function: bool,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        setup_voting(&aptos_framework, &proposer, &yes_voter, &no_voter);
-
-        let execution_hash = vector::empty<u8>();
-        vector::push_back(&mut execution_hash, 1);
-
-        create_proposal_for_test(&proposer, multi_step);
-
-        vote(&yes_voter, signer::address_of(&yes_voter), 0, true);
-        vote(&no_voter, signer::address_of(&no_voter), 0, false);
-
-        test_resolving_proposal_generic(aptos_framework, use_generic_resolve_function, execution_hash);
-    }
-
-    #[test_only]
-    public entry fun test_resolving_proposal_generic(
-        aptos_framework: signer,
-        use_generic_resolve_function: bool,
-        execution_hash: vector<u8>,
-    ) acquires ApprovedExecutionHashes, GovernanceResponsbility {
-        // Once expiration time has passed, the proposal should be considered resolve now as there are more yes votes
-        // than no.
-        timestamp::update_global_time_for_test(100001000000);
-        let proposal_state = voting::get_proposal_state<GovernanceProposal>(signer::address_of(&aptos_framework), 0);
-        assert!(proposal_state == PROPOSAL_STATE_SUCCEEDED, proposal_state);
-
-        // Add approved script hash.
-        add_approved_script_hash(0);
-        let approved_hashes = borrow_global<ApprovedExecutionHashes>(@aptos_framework).hashes;
-        assert!(*simple_map::borrow(&approved_hashes, &0) == execution_hash, 0);
-
-        // Resolve the proposal.
-        let account = resolve_proposal_for_test(0, @aptos_framework, use_generic_resolve_function, true);
-        assert!(signer::address_of(&account) == @aptos_framework, 1);
-        assert!(voting::is_resolved<GovernanceProposal>(@aptos_framework, 0), 2);
-        let approved_hashes = borrow_global<ApprovedExecutionHashes>(@aptos_framework).hashes;
-        assert!(!simple_map::contains_key(&approved_hashes, &0), 3);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, yes_voter = @0x234, no_voter = @345)]
-    public entry fun test_voting(
-        aptos_framework: signer,
-        proposer: signer,
-        yes_voter: signer,
-        no_voter: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        test_voting_generic(aptos_framework, proposer, yes_voter, no_voter, false, false);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, yes_voter = @0x234, no_voter = @345)]
-    public entry fun test_voting_multi_step(
-        aptos_framework: signer,
-        proposer: signer,
-        yes_voter: signer,
-        no_voter: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        test_voting_generic(aptos_framework, proposer, yes_voter, no_voter, true, true);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, yes_voter = @0x234, no_voter = @345)]
-    #[expected_failure(abort_code = 0x5000a, location = aptos_framework::voting)]
-    public entry fun test_voting_multi_step_cannot_use_single_step_resolve(
-        aptos_framework: signer,
-        proposer: signer,
-        yes_voter: signer,
-        no_voter: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        test_voting_generic(aptos_framework, proposer, yes_voter, no_voter, true, false);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, yes_voter = @0x234, no_voter = @345)]
-    public entry fun test_voting_single_step_can_use_generic_resolve_function(
-        aptos_framework: signer,
-        proposer: signer,
-        yes_voter: signer,
-        no_voter: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        test_voting_generic(aptos_framework, proposer, yes_voter, no_voter, false, true);
-    }
-
-    #[test_only]
-    public entry fun test_can_remove_approved_hash_if_executed_directly_via_voting_generic(
-        aptos_framework: signer,
-        proposer: signer,
-        yes_voter: signer,
-        no_voter: signer,
-        multi_step: bool,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        setup_voting(&aptos_framework, &proposer, &yes_voter, &no_voter);
-
-        create_proposal_for_test(&proposer, multi_step);
-        vote(&yes_voter, signer::address_of(&yes_voter), 0, true);
-        vote(&no_voter, signer::address_of(&no_voter), 0, false);
-
-        // Add approved script hash.
-        timestamp::update_global_time_for_test(100001000000);
-        add_approved_script_hash(0);
-
-        // Resolve the proposal.
-        if (multi_step) {
-            let execution_hash = vector::empty<u8>();
-            let next_execution_hash = vector::empty<u8>();
-            vector::push_back(&mut execution_hash, 1);
-            voting::resolve_proposal_v2<GovernanceProposal>(@aptos_framework, 0, next_execution_hash);
-            assert!(voting::is_resolved<GovernanceProposal>(@aptos_framework, 0), 0);
-            if (vector::length(&next_execution_hash) == 0) {
-                remove_approved_hash(0);
-            } else {
-                add_approved_script_hash(0)
-            };
-        } else {
-            voting::resolve<GovernanceProposal>(@aptos_framework, 0);
-            assert!(voting::is_resolved<GovernanceProposal>(@aptos_framework, 0), 0);
-            remove_approved_hash(0);
-        };
-        let approved_hashes = borrow_global<ApprovedExecutionHashes>(@aptos_framework).hashes;
-        assert!(!simple_map::contains_key(&approved_hashes, &0), 1);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, yes_voter = @0x234, no_voter = @345)]
-    public entry fun test_can_remove_approved_hash_if_executed_directly_via_voting(
-        aptos_framework: signer,
-        proposer: signer,
-        yes_voter: signer,
-        no_voter: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        test_can_remove_approved_hash_if_executed_directly_via_voting_generic(
-            aptos_framework,
-            proposer,
-            yes_voter,
-            no_voter,
-            false
-        );
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, yes_voter = @0x234, no_voter = @345)]
-    public entry fun test_can_remove_approved_hash_if_executed_directly_via_voting_multi_step(
-        aptos_framework: signer,
-        proposer: signer,
-        yes_voter: signer,
-        no_voter: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        test_can_remove_approved_hash_if_executed_directly_via_voting_generic(
-            aptos_framework,
-            proposer,
-            yes_voter,
-            no_voter,
-            true
-        );
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, voter_1 = @0x234, voter_2 = @345)]
-    #[expected_failure(abort_code = 0x10004, location = aptos_framework::voting)]
-    public entry fun test_cannot_double_vote(
-        aptos_framework: signer,
-        proposer: signer,
-        voter_1: signer,
-        voter_2: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        setup_voting(&aptos_framework, &proposer, &voter_1, &voter_2);
-
-        create_proposal(
-            &proposer,
-            signer::address_of(&proposer),
-            b"",
-            b"",
-            b"",
-        );
-
-        // Double voting should throw an error.
-        vote(&voter_1, signer::address_of(&voter_1), 0, true);
-        vote(&voter_1, signer::address_of(&voter_1), 0, true);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, voter_1 = @0x234, voter_2 = @345)]
-    #[expected_failure(abort_code = 0x10004, location = aptos_framework::voting)]
-    public entry fun test_cannot_double_vote_with_different_voter_addresses(
-        aptos_framework: signer,
-        proposer: signer,
-        voter_1: signer,
-        voter_2: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        setup_voting(&aptos_framework, &proposer, &voter_1, &voter_2);
-
-        create_proposal(
-            &proposer,
-            signer::address_of(&proposer),
-            b"",
-            b"",
-            b"",
-        );
-
-        // Double voting should throw an error for 2 different voters if they still use the same stake pool.
-        vote(&voter_1, signer::address_of(&voter_1), 0, true);
-        stake::set_delegated_voter(&voter_1, signer::address_of(&voter_2));
-        vote(&voter_2, signer::address_of(&voter_1), 0, true);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, voter_1 = @0x234, voter_2 = @345)]
-    public entry fun test_stake_pool_can_vote_on_partial_voting_proposal_many_times(
-        aptos_framework: signer,
-        proposer: signer,
-        voter_1: signer,
-        voter_2: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        setup_partial_voting(&aptos_framework, &proposer, &voter_1, &voter_2);
-        let execution_hash = vector::empty<u8>();
-        vector::push_back(&mut execution_hash, 1);
-        let proposer_addr = signer::address_of(&proposer);
-        let voter_1_addr = signer::address_of(&voter_1);
-        let voter_2_addr = signer::address_of(&voter_2);
-
-        create_proposal_for_test(&proposer, true);
-
-        partial_vote(&voter_1, voter_1_addr, 0, 5, true);
-        partial_vote(&voter_1, voter_1_addr, 0, 3, true);
-        partial_vote(&voter_1, voter_1_addr, 0, 2, true);
-
-        assert!(get_remaining_voting_power(proposer_addr, 0) == 100, 0);
-        assert!(get_remaining_voting_power(voter_1_addr, 0) == 10, 1);
-        assert!(get_remaining_voting_power(voter_2_addr, 0) == 10, 2);
-
-        test_resolving_proposal_generic(aptos_framework, true, execution_hash);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, voter_1 = @0x234, voter_2 = @345)]
-    #[expected_failure(abort_code = 0x3, location = Self)]
-    public entry fun test_stake_pool_can_vote_with_partial_voting_power(
-        aptos_framework: signer,
-        proposer: signer,
-        voter_1: signer,
-        voter_2: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        setup_partial_voting(&aptos_framework, &proposer, &voter_1, &voter_2);
-        let execution_hash = vector::empty<u8>();
-        vector::push_back(&mut execution_hash, 1);
-        let proposer_addr = signer::address_of(&proposer);
-        let voter_1_addr = signer::address_of(&voter_1);
-        let voter_2_addr = signer::address_of(&voter_2);
-
-        create_proposal_for_test(&proposer, true);
-
-        partial_vote(&voter_1, voter_1_addr, 0, 9, true);
-
-        assert!(get_remaining_voting_power(proposer_addr, 0) == 100, 0);
-        assert!(get_remaining_voting_power(voter_1_addr, 0) == 11, 1);
-        assert!(get_remaining_voting_power(voter_2_addr, 0) == 10, 2);
-
-        // No enough Yes. The proposal cannot be resolved.
-        test_resolving_proposal_generic(aptos_framework, true, execution_hash);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, voter_1 = @0x234, voter_2 = @345)]
-    public entry fun test_batch_vote(
-        aptos_framework: signer,
-        proposer: signer,
-        voter_1: signer,
-        voter_2: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        features::change_feature_flags_for_testing(&aptos_framework, vector[features::get_coin_to_fungible_asset_migration_feature()], vector[]);
-        setup_partial_voting(&aptos_framework, &proposer, &voter_1, &voter_2);
-        let execution_hash = vector::empty<u8>();
-        vector::push_back(&mut execution_hash, 1);
-        let voter_1_addr = signer::address_of(&voter_1);
-        let voter_2_addr = signer::address_of(&voter_2);
-        stake::set_delegated_voter(&voter_2, voter_1_addr);
-        create_proposal_for_test(&proposer, true);
-        batch_vote(&voter_1, vector[voter_1_addr, voter_2_addr], 0, true);
-        test_resolving_proposal_generic(aptos_framework, true, execution_hash);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, voter_1 = @0x234, voter_2 = @345)]
-    public entry fun test_batch_partial_vote(
-        aptos_framework: signer,
-        proposer: signer,
-        voter_1: signer,
-        voter_2: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        features::change_feature_flags_for_testing(&aptos_framework, vector[features::get_coin_to_fungible_asset_migration_feature()], vector[]);
-        setup_partial_voting(&aptos_framework, &proposer, &voter_1, &voter_2);
-        let execution_hash = vector::empty<u8>();
-        vector::push_back(&mut execution_hash, 1);
-        let voter_1_addr = signer::address_of(&voter_1);
-        let voter_2_addr = signer::address_of(&voter_2);
-        stake::set_delegated_voter(&voter_2, voter_1_addr);
-        create_proposal_for_test(&proposer, true);
-        batch_partial_vote(&voter_1, vector[voter_1_addr, voter_2_addr], 0, 9, true);
-        test_resolving_proposal_generic(aptos_framework, true, execution_hash);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, voter_1 = @0x234, voter_2 = @345)]
-    public entry fun test_stake_pool_can_vote_only_with_its_own_voting_power(
-        aptos_framework: signer,
-        proposer: signer,
-        voter_1: signer,
-        voter_2: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        setup_partial_voting(&aptos_framework, &proposer, &voter_1, &voter_2);
-        let execution_hash = vector::empty<u8>();
-        vector::push_back(&mut execution_hash, 1);
-        let proposer_addr = signer::address_of(&proposer);
-        let voter_1_addr = signer::address_of(&voter_1);
-        let voter_2_addr = signer::address_of(&voter_2);
-
-        create_proposal_for_test(&proposer, true);
-
-        partial_vote(&voter_1, voter_1_addr, 0, 9, true);
-        // The total voting power of voter_1 is 20. It can only vote with 20 voting power even we pass 30 as the argument.
-        partial_vote(&voter_1, voter_1_addr, 0, 30, true);
-
-        assert!(get_remaining_voting_power(proposer_addr, 0) == 100, 0);
-        assert!(get_remaining_voting_power(voter_1_addr, 0) == 0, 1);
-        assert!(get_remaining_voting_power(voter_2_addr, 0) == 10, 2);
-
-        test_resolving_proposal_generic(aptos_framework, true, execution_hash);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, voter_1 = @0x234, voter_2 = @345)]
-    public entry fun test_stake_pool_can_vote_before_and_after_partial_governance_voting_enabled(
-        aptos_framework: signer,
-        proposer: signer,
-        voter_1: signer,
-        voter_2: signer,
-    ) acquires ApprovedExecutionHashes, GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        setup_voting(&aptos_framework, &proposer, &voter_1, &voter_2);
-        let execution_hash = vector::empty<u8>();
-        vector::push_back(&mut execution_hash, 1);
-        let proposer_addr = signer::address_of(&proposer);
-        let voter_1_addr = signer::address_of(&voter_1);
-        let voter_2_addr = signer::address_of(&voter_2);
-
-        create_proposal_for_test(&proposer, true);
-        vote(&voter_1, voter_1_addr, 0, true);
-        assert!(get_remaining_voting_power(proposer_addr, 0) == 100, 0);
-        assert!(get_remaining_voting_power(voter_1_addr, 0) == 0, 1);
-        assert!(get_remaining_voting_power(voter_2_addr, 0) == 10, 2);
-
-        initialize_partial_voting(&aptos_framework);
-        features::change_feature_flags_for_testing(&aptos_framework, vector[features::get_partial_governance_voting()], vector[]);
-
-        coin::register<AptosCoin>(&voter_1);
-        coin::register<AptosCoin>(&voter_2);
-        stake::add_stake(&voter_1, 20);
-        stake::add_stake(&voter_2, 5);
-
-        // voter1 has already voted before partial governance voting is enalbed. So it cannot vote even after adding stake.
-        // voter2's voting poewr increase after adding stake.
-        assert!(get_remaining_voting_power(proposer_addr, 0) == 100, 0);
-        assert!(get_remaining_voting_power(voter_1_addr, 0) == 0, 1);
-        assert!(get_remaining_voting_power(voter_2_addr, 0) == 15, 2);
-
-        test_resolving_proposal_generic(aptos_framework, true, execution_hash);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, voter_1 = @0x234, voter_2 = @345)]
-    public entry fun test_no_remaining_voting_power_about_proposal_expiration_time(
-        aptos_framework: signer,
-        proposer: signer,
-        voter_1: signer,
-        voter_2: signer,
-    ) acquires GovernanceConfig, GovernanceResponsbility, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        setup_voting_with_initialized_stake(&aptos_framework, &proposer, &voter_1, &voter_2);
-        let execution_hash = vector::empty<u8>();
-        vector::push_back(&mut execution_hash, 1);
-        let proposer_addr = signer::address_of(&proposer);
-        let voter_1_addr = signer::address_of(&voter_1);
-        let voter_2_addr = signer::address_of(&voter_2);
-
-        create_proposal_for_test(&proposer, true);
-        assert!(get_remaining_voting_power(proposer_addr, 0) == 100, 0);
-        assert!(get_remaining_voting_power(voter_1_addr, 0) == 0, 1);
-        assert!(get_remaining_voting_power(voter_2_addr, 0) == 0, 2);
-
-        // 500 seconds later, lockup period of voter_1 and voter_2 is reset.
-        timestamp::fast_forward_seconds(440);
-        stake::end_epoch();
-        assert!(get_remaining_voting_power(proposer_addr, 0) == 100, 0);
-        assert!(get_remaining_voting_power(voter_1_addr, 0) == 20, 1);
-        assert!(get_remaining_voting_power(voter_2_addr, 0) == 10, 2);
-
-        // 501 seconds later, the proposal expires.
-        timestamp::fast_forward_seconds(441);
-        stake::end_epoch();
-        assert!(get_remaining_voting_power(proposer_addr, 0) == 0, 0);
-        assert!(get_remaining_voting_power(voter_1_addr, 0) == 0, 1);
-        assert!(get_remaining_voting_power(voter_2_addr, 0) == 0, 2);
-    }
-
-    #[test_only]
-    public fun setup_voting(
-        aptos_framework: &signer,
-        proposer: &signer,
-        yes_voter: &signer,
-        no_voter: &signer,
-    ) acquires GovernanceResponsbility {
-        use std::vector;
-        use aptos_framework::account;
-        use aptos_framework::coin;
-        use aptos_framework::aptos_coin::{Self, AptosCoin};
-
-        timestamp::set_time_has_started_for_testing(aptos_framework);
-        account::create_account_for_test(signer::address_of(aptos_framework));
-        account::create_account_for_test(signer::address_of(proposer));
-        account::create_account_for_test(signer::address_of(yes_voter));
-        account::create_account_for_test(signer::address_of(no_voter));
-
-        // Initialize the governance.
-        staking_config::initialize_for_test(aptos_framework, 0, 1000, 2000, true, 0, 1, 100);
-        initialize(aptos_framework, 10, 100, 1000);
-        store_signer_cap(
-            aptos_framework,
-            @aptos_framework,
-            account::create_test_signer_cap(@aptos_framework),
-        );
-
-        // Initialize the stake pools for proposer and voters.
-        let active_validators = vector::empty<address>();
-        vector::push_back(&mut active_validators, signer::address_of(proposer));
-        vector::push_back(&mut active_validators, signer::address_of(yes_voter));
-        vector::push_back(&mut active_validators, signer::address_of(no_voter));
-        let (_sk_1, pk_1, _pop_1) = stake::generate_identity();
-        let (_sk_2, pk_2, _pop_2) = stake::generate_identity();
-        let (_sk_3, pk_3, _pop_3) = stake::generate_identity();
-        let pks = vector[pk_1, pk_2, pk_3];
-        stake::create_validator_set(aptos_framework, active_validators, pks);
-
-        let (burn_cap, mint_cap) = aptos_coin::initialize_for_test(aptos_framework);
-        // Spread stake among active and pending_inactive because both need to be accounted for when computing voting
-        // power.
-        coin::register<AptosCoin>(proposer);
-        coin::deposit(signer::address_of(proposer), coin::mint(100, &mint_cap));
-        coin::register<AptosCoin>(yes_voter);
-        coin::deposit(signer::address_of(yes_voter), coin::mint(20, &mint_cap));
-        coin::register<AptosCoin>(no_voter);
-        coin::deposit(signer::address_of(no_voter), coin::mint(10, &mint_cap));
-        stake::create_stake_pool(proposer, coin::mint(50, &mint_cap), coin::mint(50, &mint_cap), 10000);
-        stake::create_stake_pool(yes_voter, coin::mint(10, &mint_cap), coin::mint(10, &mint_cap), 10000);
-        stake::create_stake_pool(no_voter, coin::mint(5, &mint_cap), coin::mint(5, &mint_cap), 10000);
-        coin::destroy_mint_cap<AptosCoin>(mint_cap);
-        coin::destroy_burn_cap<AptosCoin>(burn_cap);
-    }
-
-    #[test_only]
-    public fun setup_voting_with_initialized_stake(
-        aptos_framework: &signer,
-        proposer: &signer,
-        yes_voter: &signer,
-        no_voter: &signer,
-    ) acquires GovernanceResponsbility {
-        use aptos_framework::account;
-        use aptos_framework::coin;
-        use aptos_framework::aptos_coin::AptosCoin;
-
-        timestamp::set_time_has_started_for_testing(aptos_framework);
-        account::create_account_for_test(signer::address_of(aptos_framework));
-        account::create_account_for_test(signer::address_of(proposer));
-        account::create_account_for_test(signer::address_of(yes_voter));
-        account::create_account_for_test(signer::address_of(no_voter));
-
-        // Initialize the governance.
-        stake::initialize_for_test_custom(aptos_framework, 0, 1000, 2000, true, 0, 1, 1000);
-        initialize(aptos_framework, 10, 100, 1000);
-        store_signer_cap(
-            aptos_framework,
-            @aptos_framework,
-            account::create_test_signer_cap(@aptos_framework),
-        );
-
-        // Initialize the stake pools for proposer and voters.
-        // Spread stake among active and pending_inactive because both need to be accounted for when computing voting
-        // power.
-        coin::register<AptosCoin>(proposer);
-        coin::deposit(signer::address_of(proposer), stake::mint_coins(100));
-        coin::register<AptosCoin>(yes_voter);
-        coin::deposit(signer::address_of(yes_voter), stake::mint_coins(20));
-        coin::register<AptosCoin>(no_voter);
-        coin::deposit(signer::address_of(no_voter), stake::mint_coins(10));
-
-        let (_sk_1, pk_1, pop_1) = stake::generate_identity();
-        let (_sk_2, pk_2, pop_2) = stake::generate_identity();
-        let (_sk_3, pk_3, pop_3) = stake::generate_identity();
-        stake::initialize_test_validator(&pk_2, &pop_2, yes_voter, 20, true, false);
-        stake::initialize_test_validator(&pk_3, &pop_3, no_voter, 10, true, false);
-        stake::end_epoch();
-        timestamp::fast_forward_seconds(1440);
-        stake::initialize_test_validator(&pk_1, &pop_1, proposer, 100, true, false);
-        stake::end_epoch();
-    }
-
-    #[test_only]
-    public fun setup_partial_voting(
-        aptos_framework: &signer,
-        proposer: &signer,
-        voter_1: &signer,
-        voter_2: &signer,
-    ) acquires GovernanceResponsbility {
-        initialize_partial_voting(aptos_framework);
-        features::change_feature_flags_for_testing(aptos_framework, vector[features::get_partial_governance_voting()], vector[]);
-        setup_voting(aptos_framework, proposer, voter_1, voter_2);
-    }
-
-    #[test(aptos_framework = @aptos_framework)]
-    public entry fun test_update_governance_config(
-        aptos_framework: signer,
-    ) acquires GovernanceConfig, GovernanceEvents {
-        account::create_account_for_test(signer::address_of(&aptos_framework));
-        initialize(&aptos_framework, 1, 2, 3);
-        update_governance_config(&aptos_framework, 10, 20, 30);
-
-        let config = borrow_global<GovernanceConfig>(@aptos_framework);
-        assert!(config.min_voting_threshold == 10, 0);
-        assert!(config.required_proposer_stake == 20, 1);
-        assert!(config.voting_duration_secs == 30, 3);
-    }
-
-    #[test(account = @0x123)]
-    #[expected_failure(abort_code = 0x50003, location = aptos_framework::system_addresses)]
-    public entry fun test_update_governance_config_unauthorized_should_fail(
-        account: signer) acquires GovernanceConfig, GovernanceEvents {
-        initialize(&account, 1, 2, 3);
-        update_governance_config(&account, 10, 20, 30);
-    }
-
-    #[test(aptos_framework = @aptos_framework, proposer = @0x123, yes_voter = @0x234, no_voter = @345)]
-    public entry fun test_replace_execution_hash(
-        aptos_framework: signer,
-        proposer: signer,
-        yes_voter: signer,
-        no_voter: signer,
-    ) acquires GovernanceResponsbility, GovernanceConfig, ApprovedExecutionHashes, VotingRecords, VotingRecordsV2, GovernanceEvents {
-        setup_voting(&aptos_framework, &proposer, &yes_voter, &no_voter);
-
-        create_proposal_for_test(&proposer, true);
-        vote(&yes_voter, signer::address_of(&yes_voter), 0, true);
-        vote(&no_voter, signer::address_of(&no_voter), 0, false);
-
-        // Add approved script hash.
-        timestamp::update_global_time_for_test(100001000000);
-        add_approved_script_hash(0);
-
-        // Resolve the proposal.
-        let execution_hash = vector::empty<u8>();
-        let next_execution_hash = vector::empty<u8>();
-        vector::push_back(&mut execution_hash, 1);
-        vector::push_back(&mut next_execution_hash, 10);
-
-        voting::resolve_proposal_v2<GovernanceProposal>(@aptos_framework, 0, next_execution_hash);
-
-        if (vector::length(&next_execution_hash) == 0) {
-            remove_approved_hash(0);
-        } else {
-            add_approved_script_hash(0)
-        };
-
-        let approved_hashes = borrow_global<ApprovedExecutionHashes>(@aptos_framework).hashes;
-        assert!(*simple_map::borrow(&approved_hashes, &0) == vector[10u8, ], 1);
-    }
-
-    #[test_only]
-    public fun initialize_for_test(
-        aptos_framework: &signer,
-        min_voting_threshold: u128,
-        required_proposer_stake: u64,
-        voting_duration_secs: u64,
-    ) {
-        initialize(aptos_framework, min_voting_threshold, required_proposer_stake, voting_duration_secs);
-    }
-
-    #[verify_only]
-    public fun initialize_for_verification(
-        aptos_framework: &signer,
-        min_voting_threshold: u128,
-        required_proposer_stake: u64,
-        voting_duration_secs: u64,
-    ) {
-        initialize(aptos_framework, min_voting_threshold, required_proposer_stake, voting_duration_secs);
-    }
-}