@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosFramework/randomness_config.move

@@ -1,153 +0,0 @@
-/// Structs and functions for on-chain randomness configurations.
-module aptos_framework::randomness_config {
-    use std::string;
-    use aptos_std::copyable_any;
-    use aptos_std::copyable_any::Any;
-    use aptos_std::fixed_point64::FixedPoint64;
-    use aptos_framework::config_buffer;
-    use aptos_framework::system_addresses;
-
-    friend aptos_framework::reconfiguration_with_dkg;
-
-    const EINVALID_CONFIG_VARIANT: u64 = 1;
-
-    /// The configuration of the on-chain randomness feature.
-    struct RandomnessConfig has copy, drop, key, store {
-        /// A config variant packed as an `Any`.
-        /// Currently the variant type is one of the following.
-        /// - `ConfigOff`
-        /// - `ConfigV1`
-        variant: Any,
-    }
-
-    /// A randomness config variant indicating the feature is disabled.
-    struct ConfigOff has copy, drop, store {}
-
-    /// A randomness config variant indicating the feature is enabled.
-    struct ConfigV1 has copy, drop, store {
-        /// Any validator subset should not be able to reconstruct randomness if `subset_power / total_power <= secrecy_threshold`,
-        secrecy_threshold: FixedPoint64,
-        /// Any validator subset should be able to reconstruct randomness if `subset_power / total_power > reconstruction_threshold`.
-        reconstruction_threshold: FixedPoint64,
-    }
-
-    /// A randomness config variant indicating the feature is enabled with fast path.
-    struct ConfigV2 has copy, drop, store {
-        /// Any validator subset should not be able to reconstruct randomness if `subset_power / total_power <= secrecy_threshold`,
-        secrecy_threshold: FixedPoint64,
-        /// Any validator subset should be able to reconstruct randomness if `subset_power / total_power > reconstruction_threshold`.
-        reconstruction_threshold: FixedPoint64,
-        /// Any validator subset should not be able to reconstruct randomness via the fast path if `subset_power / total_power <= fast_path_secrecy_threshold`,
-        fast_path_secrecy_threshold: FixedPoint64,
-    }
-
-    /// Initialize the configuration. Used in genesis or governance.
-    public fun initialize(framework: &signer, config: RandomnessConfig) {
-        system_addresses::assert_aptos_framework(framework);
-        if (!exists<RandomnessConfig>(@aptos_framework)) {
-            move_to(framework, config)
-        }
-    }
-
-    /// This can be called by on-chain governance to update on-chain consensus configs for the next epoch.
-    public fun set_for_next_epoch(framework: &signer, new_config: RandomnessConfig) {
-        system_addresses::assert_aptos_framework(framework);
-        config_buffer::upsert(new_config);
-    }
-
-    /// Only used in reconfigurations to apply the pending `RandomnessConfig`, if there is any.
-    public(friend) fun on_new_epoch(framework: &signer) acquires RandomnessConfig {
-        system_addresses::assert_aptos_framework(framework);
-        if (config_buffer::does_exist<RandomnessConfig>()) {
-            let new_config = config_buffer::extract<RandomnessConfig>();
-            if (exists<RandomnessConfig>(@aptos_framework)) {
-                *borrow_global_mut<RandomnessConfig>(@aptos_framework) = new_config;
-            } else {
-                move_to(framework, new_config);
-            }
-        }
-    }
-
-    /// Check whether on-chain randomness main logic (e.g., `DKGManager`, `RandManager`, `BlockMetadataExt`) is enabled.
-    ///
-    /// NOTE: this returning true does not mean randomness will run.
-    /// The feature works if and only if `consensus_config::validator_txn_enabled() && randomness_config::enabled()`.
-    public fun enabled(): bool acquires RandomnessConfig {
-        if (exists<RandomnessConfig>(@aptos_framework)) {
-            let config = borrow_global<RandomnessConfig>(@aptos_framework);
-            let variant_type_name = *string::bytes(copyable_any::type_name(&config.variant));
-            variant_type_name != b"0x1::randomness_config::ConfigOff"
-        } else {
-            false
-        }
-    }
-
-    /// Create a `ConfigOff` variant.
-    public fun new_off(): RandomnessConfig {
-        RandomnessConfig {
-            variant: copyable_any::pack( ConfigOff {} )
-        }
-    }
-
-    /// Create a `ConfigV1` variant.
-    public fun new_v1(secrecy_threshold: FixedPoint64, reconstruction_threshold: FixedPoint64): RandomnessConfig {
-        RandomnessConfig {
-            variant: copyable_any::pack( ConfigV1 {
-                secrecy_threshold,
-                reconstruction_threshold
-            } )
-        }
-    }
-
-    /// Create a `ConfigV2` variant.
-    public fun new_v2(
-        secrecy_threshold: FixedPoint64,
-        reconstruction_threshold: FixedPoint64,
-        fast_path_secrecy_threshold: FixedPoint64,
-    ): RandomnessConfig {
-        RandomnessConfig {
-            variant: copyable_any::pack( ConfigV2 {
-                secrecy_threshold,
-                reconstruction_threshold,
-                fast_path_secrecy_threshold,
-            } )
-        }
-    }
-
-    /// Get the currently effective randomness configuration object.
-    public fun current(): RandomnessConfig acquires RandomnessConfig {
-        if (exists<RandomnessConfig>(@aptos_framework)) {
-            *borrow_global<RandomnessConfig>(@aptos_framework)
-        } else {
-            new_off()
-        }
-    }
-
-    #[test_only]
-    use aptos_std::fixed_point64;
-
-    #[test_only]
-    fun initialize_for_testing(framework: &signer) {
-        config_buffer::initialize(framework);
-        initialize(framework, new_off());
-    }
-
-    #[test(framework = @0x1)]
-    fun init_buffer_apply(framework: signer) acquires RandomnessConfig {
-        initialize_for_testing(&framework);
-
-        // Enabling.
-        let config = new_v1(
-            fixed_point64::create_from_rational(1, 2),
-            fixed_point64::create_from_rational(2, 3)
-        );
-        set_for_next_epoch(&framework, config);
-        on_new_epoch(&framework);
-        assert!(enabled(), 1);
-
-        // Disabling.
-        set_for_next_epoch(&framework, new_off());
-        on_new_epoch(&framework);
-        assert!(!enabled(), 2);
-    }
-}

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosFramework/randomness_config_seqnum.move

@@ -1,49 +0,0 @@
-/// Randomness stall recovery utils.
-///
-/// When randomness generation is stuck due to a bug, the chain is also stuck. Below is the recovery procedure.
-/// 1. Ensure more than 2/3 stakes are stuck at the same version.
-/// 1. Every validator restarts with `randomness_override_seq_num` set to `X+1` in the node config file,
-///    where `X` is the current `RandomnessConfigSeqNum` on chain.
-/// 1. The chain should then be unblocked.
-/// 1. Once the bug is fixed and the binary + framework have been patched,
-///    a governance proposal is needed to set `RandomnessConfigSeqNum` to be `X+2`.
-module aptos_framework::randomness_config_seqnum {
-    use aptos_framework::config_buffer;
-    use aptos_framework::system_addresses;
-
-    friend aptos_framework::reconfiguration_with_dkg;
-
-    /// If this seqnum is smaller than a validator local override, the on-chain `RandomnessConfig` will be ignored.
-    /// Useful in a chain recovery from randomness stall.
-    struct RandomnessConfigSeqNum has drop, key, store {
-        seq_num: u64,
-    }
-
-    /// Update `RandomnessConfigSeqNum`.
-    /// Used when re-enable randomness after an emergency randomness disable via local override.
-    public fun set_for_next_epoch(framework: &signer, seq_num: u64) {
-        system_addresses::assert_aptos_framework(framework);
-        config_buffer::upsert(RandomnessConfigSeqNum { seq_num });
-    }
-
-    /// Initialize the configuration. Used in genesis or governance.
-    public fun initialize(framework: &signer) {
-        system_addresses::assert_aptos_framework(framework);
-        if (!exists<RandomnessConfigSeqNum>(@aptos_framework)) {
-            move_to(framework, RandomnessConfigSeqNum { seq_num: 0 })
-        }
-    }
-
-    /// Only used in reconfigurations to apply the pending `RandomnessConfig`, if there is any.
-    public(friend) fun on_new_epoch(framework: &signer) acquires RandomnessConfigSeqNum {
-        system_addresses::assert_aptos_framework(framework);
-        if (config_buffer::does_exist<RandomnessConfigSeqNum>()) {
-            let new_config = config_buffer::extract<RandomnessConfigSeqNum>();
-            if (exists<RandomnessConfigSeqNum>(@aptos_framework)) {
-                *borrow_global_mut<RandomnessConfigSeqNum>(@aptos_framework) = new_config;
-            } else {
-                move_to(framework, new_config);
-            }
-        }
-    }
-}

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosFramework/reconfiguration.move

@@ -1,237 +0,0 @@
-/// Publishes configuration information for validators, and issues reconfiguration events
-/// to synchronize configuration changes for the validators.
-module aptos_framework::reconfiguration {
-    use std::error;
-    use std::features;
-    use std::signer;
-
-    use aptos_framework::account;
-    use aptos_framework::event;
-    use aptos_framework::stake;
-    use aptos_framework::system_addresses;
-    use aptos_framework::timestamp;
-    use aptos_framework::chain_status;
-    use aptos_framework::reconfiguration_state;
-    use aptos_framework::storage_gas;
-    use aptos_framework::transaction_fee;
-
-    friend aptos_framework::aptos_governance;
-    friend aptos_framework::block;
-    friend aptos_framework::consensus_config;
-    friend aptos_framework::execution_config;
-    friend aptos_framework::gas_schedule;
-    friend aptos_framework::genesis;
-    friend aptos_framework::version;
-    friend aptos_framework::reconfiguration_with_dkg;
-
-    #[event]
-    /// Event that signals consensus to start a new epoch,
-    /// with new configuration information. This is also called a
-    /// "reconfiguration event"
-    struct NewEpochEvent has drop, store {
-        epoch: u64,
-    }
-
-    #[event]
-    /// Event that signals consensus to start a new epoch,
-    /// with new configuration information. This is also called a
-    /// "reconfiguration event"
-    struct NewEpoch has drop, store {
-        epoch: u64,
-    }
-
-    /// Holds information about state of reconfiguration
-    struct Configuration has key {
-        /// Epoch number
-        epoch: u64,
-        /// Time of last reconfiguration. Only changes on reconfiguration events.
-        last_reconfiguration_time: u64,
-        /// Event handle for reconfiguration events
-        events: event::EventHandle<NewEpochEvent>,
-    }
-
-    /// Reconfiguration will be disabled if this resource is published under the
-    /// aptos_framework system address
-    struct DisableReconfiguration has key {}
-
-    /// The `Configuration` resource is in an invalid state
-    const ECONFIGURATION: u64 = 1;
-    /// A `Reconfiguration` resource is in an invalid state
-    const ECONFIG: u64 = 2;
-    /// A `ModifyConfigCapability` is in a different state than was expected
-    const EMODIFY_CAPABILITY: u64 = 3;
-    /// An invalid block time was encountered.
-    const EINVALID_BLOCK_TIME: u64 = 4;
-    /// An invalid block time was encountered.
-    const EINVALID_GUID_FOR_EVENT: u64 = 5;
-
-    /// Only called during genesis.
-    /// Publishes `Configuration` resource. Can only be invoked by aptos framework account, and only a single time in Genesis.
-    public(friend) fun initialize(aptos_framework: &signer) {
-        system_addresses::assert_aptos_framework(aptos_framework);
-
-        // assert it matches `new_epoch_event_key()`, otherwise the event can't be recognized
-        assert!(account::get_guid_next_creation_num(signer::address_of(aptos_framework)) == 2, error::invalid_state(EINVALID_GUID_FOR_EVENT));
-        move_to<Configuration>(
-            aptos_framework,
-            Configuration {
-                epoch: 0,
-                last_reconfiguration_time: 0,
-                events: account::new_event_handle<NewEpochEvent>(aptos_framework),
-            }
-        );
-    }
-
-    /// Private function to temporarily halt reconfiguration.
-    /// This function should only be used for offline WriteSet generation purpose and should never be invoked on chain.
-    fun disable_reconfiguration(aptos_framework: &signer) {
-        system_addresses::assert_aptos_framework(aptos_framework);
-        assert!(reconfiguration_enabled(), error::invalid_state(ECONFIGURATION));
-        move_to(aptos_framework, DisableReconfiguration {})
-    }
-
-    /// Private function to resume reconfiguration.
-    /// This function should only be used for offline WriteSet generation purpose and should never be invoked on chain.
-    fun enable_reconfiguration(aptos_framework: &signer) acquires DisableReconfiguration {
-        system_addresses::assert_aptos_framework(aptos_framework);
-
-        assert!(!reconfiguration_enabled(), error::invalid_state(ECONFIGURATION));
-        DisableReconfiguration {} = move_from<DisableReconfiguration>(signer::address_of(aptos_framework));
-    }
-
-    fun reconfiguration_enabled(): bool {
-        !exists<DisableReconfiguration>(@aptos_framework)
-    }
-
-    /// Signal validators to start using new configuration. Must be called from friend config modules.
-    public(friend) fun reconfigure() acquires Configuration {
-        // Do not do anything if genesis has not finished.
-        if (chain_status::is_genesis() || timestamp::now_microseconds() == 0 || !reconfiguration_enabled()) {
-            return
-        };
-
-        let config_ref = borrow_global_mut<Configuration>(@aptos_framework);
-        let current_time = timestamp::now_microseconds();
-
-        // Do not do anything if a reconfiguration event is already emitted within this transaction.
-        //
-        // This is OK because:
-        // - The time changes in every non-empty block
-        // - A block automatically ends after a transaction that emits a reconfiguration event, which is guaranteed by
-        //   VM spec that all transactions comming after a reconfiguration transaction will be returned as Retry
-        //   status.
-        // - Each transaction must emit at most one reconfiguration event
-        //
-        // Thus, this check ensures that a transaction that does multiple "reconfiguration required" actions emits only
-        // one reconfiguration event.
-        //
-        if (current_time == config_ref.last_reconfiguration_time) {
-            return
-        };
-
-        reconfiguration_state::on_reconfig_start();
-
-        // Reconfiguration "forces the block" to end, as mentioned above. Therefore, we must process the collected fees
-        // explicitly so that staking can distribute them.
-        //
-        // This also handles the case when a validator is removed due to the governance proposal. In particular, removing
-        // the validator causes a reconfiguration. We explicitly process fees, i.e. we drain aggregatable coin and populate
-        // the fees table, prior to calling `on_new_epoch()`. That call, in turn, distributes transaction fees for all active
-        // and pending_inactive validators, which include any validator that is to be removed.
-        if (features::collect_and_distribute_gas_fees()) {
-            // All transactions after reconfiguration are Retry. Therefore, when the next
-            // block starts and tries to assign/burn collected fees it will be just 0 and
-            // nothing will be assigned.
-            transaction_fee::process_collected_fees();
-        };
-
-        // Call stake to compute the new validator set and distribute rewards and transaction fees.
-        stake::on_new_epoch();
-        storage_gas::on_reconfig();
-
-        assert!(current_time > config_ref.last_reconfiguration_time, error::invalid_state(EINVALID_BLOCK_TIME));
-        config_ref.last_reconfiguration_time = current_time;
-        spec {
-            assume config_ref.epoch + 1 <= MAX_U64;
-        };
-        config_ref.epoch = config_ref.epoch + 1;
-
-        if (std::features::module_event_migration_enabled()) {
-            event::emit(
-                NewEpoch {
-                    epoch: config_ref.epoch,
-                },
-            );
-        };
-        event::emit_event<NewEpochEvent>(
-            &mut config_ref.events,
-            NewEpochEvent {
-                epoch: config_ref.epoch,
-            },
-        );
-
-        reconfiguration_state::on_reconfig_finish();
-    }
-
-    public fun last_reconfiguration_time(): u64 acquires Configuration {
-        borrow_global<Configuration>(@aptos_framework).last_reconfiguration_time
-    }
-
-    public fun current_epoch(): u64 acquires Configuration {
-        borrow_global<Configuration>(@aptos_framework).epoch
-    }
-
-    /// Emit a `NewEpochEvent` event. This function will be invoked by genesis directly to generate the very first
-    /// reconfiguration event.
-    fun emit_genesis_reconfiguration_event() acquires Configuration {
-        let config_ref = borrow_global_mut<Configuration>(@aptos_framework);
-        assert!(config_ref.epoch == 0 && config_ref.last_reconfiguration_time == 0, error::invalid_state(ECONFIGURATION));
-        config_ref.epoch = 1;
-
-        if (std::features::module_event_migration_enabled()) {
-            event::emit(
-                NewEpoch {
-                    epoch: config_ref.epoch,
-                },
-            );
-        };
-        event::emit_event<NewEpochEvent>(
-            &mut config_ref.events,
-            NewEpochEvent {
-                epoch: config_ref.epoch,
-            },
-        );
-    }
-
-    // For tests, skips the guid validation.
-    #[test_only]
-    public fun initialize_for_test(account: &signer) {
-        system_addresses::assert_aptos_framework(account);
-        move_to<Configuration>(
-            account,
-            Configuration {
-                epoch: 0,
-                last_reconfiguration_time: 0,
-                events: account::new_event_handle<NewEpochEvent>(account),
-            }
-        );
-    }
-
-    #[test_only]
-    public fun reconfigure_for_test() acquires Configuration {
-        reconfigure();
-    }
-
-    // This is used together with stake::end_epoch() for testing with last_reconfiguration_time
-    // It must be called each time an epoch changes
-    #[test_only]
-    public fun reconfigure_for_test_custom() acquires Configuration {
-        let config_ref = borrow_global_mut<Configuration>(@aptos_framework);
-        let current_time = timestamp::now_microseconds();
-        if (current_time == config_ref.last_reconfiguration_time) {
-            return
-        };
-        config_ref.last_reconfiguration_time = current_time;
-        config_ref.epoch = config_ref.epoch + 1;
-    }
-}

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosFramework/reconfiguration_state.move

@@ -1,132 +0,0 @@
-/// Reconfiguration meta-state resources and util functions.
-///
-/// WARNING: `reconfiguration_state::initialize()` is required before `RECONFIGURE_WITH_DKG` can be enabled.
-module aptos_framework::reconfiguration_state {
-    use std::error;
-    use std::string;
-    use aptos_std::copyable_any;
-    use aptos_std::copyable_any::Any;
-    use aptos_framework::system_addresses;
-    use aptos_framework::timestamp;
-
-    friend aptos_framework::reconfiguration;
-    friend aptos_framework::reconfiguration_with_dkg;
-    friend aptos_framework::stake;
-
-    const ERECONFIG_NOT_IN_PROGRESS: u64 = 1;
-
-    /// Reconfiguration drivers update this resources to notify other modules of some reconfiguration state.
-    struct State has key {
-        /// The state variant packed as an `Any`.
-        /// Currently the variant type is one of the following.
-        /// - `ReconfigStateInactive`
-        /// - `ReconfigStateActive`
-        variant: Any,
-    }
-
-    /// A state variant indicating no reconfiguration is in progress.
-    struct StateInactive has copy, drop, store {}
-
-    /// A state variant indicating a reconfiguration is in progress.
-    struct StateActive has copy, drop, store {
-        start_time_secs: u64,
-    }
-
-    public fun is_initialized(): bool {
-        exists<State>(@aptos_framework)
-    }
-
-    public fun initialize(fx: &signer) {
-        system_addresses::assert_aptos_framework(fx);
-        if (!exists<State>(@aptos_framework)) {
-            move_to(fx, State {
-                variant: copyable_any::pack(StateInactive {})
-            })
-        }
-    }
-
-    public fun initialize_for_testing(fx: &signer) {
-        initialize(fx)
-    }
-
-    /// Return whether the reconfiguration state is marked "in progress".
-    public(friend) fun is_in_progress(): bool acquires State {
-        if (!exists<State>(@aptos_framework)) {
-            return false
-        };
-
-        let state = borrow_global<State>(@aptos_framework);
-        let variant_type_name = *string::bytes(copyable_any::type_name(&state.variant));
-        variant_type_name == b"0x1::reconfiguration_state::StateActive"
-    }
-
-    /// Called at the beginning of a reconfiguration (either immediate or async)
-    /// to mark the reconfiguration state "in progress" if it is currently "stopped".
-    ///
-    /// Also record the current time as the reconfiguration start time. (Some module, e.g., `stake.move`, needs this info).
-    public(friend) fun on_reconfig_start() acquires State {
-        if (exists<State>(@aptos_framework)) {
-            let state = borrow_global_mut<State>(@aptos_framework);
-            let variant_type_name = *string::bytes(copyable_any::type_name(&state.variant));
-            if (variant_type_name == b"0x1::reconfiguration_state::StateInactive") {
-                state.variant = copyable_any::pack(StateActive {
-                    start_time_secs: timestamp::now_seconds()
-                });
-            }
-        };
-    }
-
-    /// Get the unix time when the currently in-progress reconfiguration started.
-    /// Abort if the reconfiguration state is not "in progress".
-    public(friend) fun start_time_secs(): u64 acquires State {
-        let state = borrow_global<State>(@aptos_framework);
-        let variant_type_name = *string::bytes(copyable_any::type_name(&state.variant));
-        if (variant_type_name == b"0x1::reconfiguration_state::StateActive") {
-            let active = copyable_any::unpack<StateActive>(state.variant);
-            active.start_time_secs
-        } else {
-            abort(error::invalid_state(ERECONFIG_NOT_IN_PROGRESS))
-        }
-    }
-
-    /// Called at the end of every reconfiguration to mark the state as "stopped".
-    /// Abort if the current state is not "in progress".
-    public(friend) fun on_reconfig_finish() acquires State {
-        if (exists<State>(@aptos_framework)) {
-            let state = borrow_global_mut<State>(@aptos_framework);
-            let variant_type_name = *string::bytes(copyable_any::type_name(&state.variant));
-            if (variant_type_name == b"0x1::reconfiguration_state::StateActive") {
-                state.variant = copyable_any::pack(StateInactive {});
-            } else {
-                abort(error::invalid_state(ERECONFIG_NOT_IN_PROGRESS))
-            }
-        }
-    }
-
-    #[test(fx = @aptos_framework)]
-    fun basic(fx: &signer) acquires State {
-        // Setip.
-        timestamp::set_time_has_started_for_testing(fx);
-        initialize(fx);
-
-        // Initially no reconfig is in progress.
-        assert!(!is_in_progress(), 1);
-
-        // "try_start" should work.
-        timestamp::fast_forward_seconds(123);
-        on_reconfig_start();
-        assert!(is_in_progress(), 1);
-        assert!(123 == start_time_secs(), 1);
-
-        // Redundant `try_start` should be no-op.
-        timestamp::fast_forward_seconds(1);
-        on_reconfig_start();
-        assert!(is_in_progress(), 1);
-        assert!(123 == start_time_secs(), 1);
-
-        // A `finish` call should work when the state is marked "in progess".
-        timestamp::fast_forward_seconds(10);
-        on_reconfig_finish();
-        assert!(!is_in_progress(), 1);
-    }
-}

package/src/internal/move/jwks/build/jwk/sources/dependencies/AptosFramework/reconfiguration_with_dkg.move

@@ -1,69 +0,0 @@
-/// Reconfiguration with DKG helper functions.
-module aptos_framework::reconfiguration_with_dkg {
-    use std::features;
-    use std::option;
-    use aptos_framework::consensus_config;
-    use aptos_framework::dkg;
-    use aptos_framework::execution_config;
-    use aptos_framework::gas_schedule;
-    use aptos_framework::jwk_consensus_config;
-    use aptos_framework::jwks;
-    use aptos_framework::keyless_account;
-    use aptos_framework::randomness_api_v0_config;
-    use aptos_framework::randomness_config;
-    use aptos_framework::randomness_config_seqnum;
-    use aptos_framework::reconfiguration;
-    use aptos_framework::reconfiguration_state;
-    use aptos_framework::stake;
-    use aptos_framework::system_addresses;
-    friend aptos_framework::block;
-    friend aptos_framework::aptos_governance;
-
-    /// Trigger a reconfiguration with DKG.
-    /// Do nothing if one is already in progress.
-    public(friend) fun try_start() {
-        let incomplete_dkg_session = dkg::incomplete_session();
-        if (option::is_some(&incomplete_dkg_session)) {
-            let session = option::borrow(&incomplete_dkg_session);
-            if (dkg::session_dealer_epoch(session) == reconfiguration::current_epoch()) {
-                return
-            }
-        };
-        reconfiguration_state::on_reconfig_start();
-        let cur_epoch = reconfiguration::current_epoch();
-        dkg::start(
-            cur_epoch,
-            randomness_config::current(),
-            stake::cur_validator_consensus_infos(),
-            stake::next_validator_consensus_infos(),
-        );
-    }
-
-    /// Clear incomplete DKG session, if it exists.
-    /// Apply buffered on-chain configs (except for ValidatorSet, which is done inside `reconfiguration::reconfigure()`).
-    /// Re-enable validator set changes.
-    /// Run the default reconfiguration to enter the new epoch.
-    public(friend) fun finish(framework: &signer) {
-        system_addresses::assert_aptos_framework(framework);
-        dkg::try_clear_incomplete_session(framework);
-        consensus_config::on_new_epoch(framework);
-        execution_config::on_new_epoch(framework);
-        gas_schedule::on_new_epoch(framework);
-        std::version::on_new_epoch(framework);
-        features::on_new_epoch(framework);
-        jwk_consensus_config::on_new_epoch(framework);
-        jwks::on_new_epoch(framework);
-        keyless_account::on_new_epoch(framework);
-        randomness_config_seqnum::on_new_epoch(framework);
-        randomness_config::on_new_epoch(framework);
-        randomness_api_v0_config::on_new_epoch(framework);
-        reconfiguration::reconfigure();
-    }
-
-    /// Complete the current reconfiguration with DKG.
-    /// Abort if no DKG is in progress.
-    fun finish_with_dkg_result(account: &signer, dkg_result: vector<u8>) {
-        dkg::finish(dkg_result);
-        finish(account);
-    }
-}