@aptos-labs/ts-sdk 3.0.0 → 3.1.0

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

@@ -0,0 +1,153 @@
+/// 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

@@ -0,0 +1,49 @@
+/// 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

@@ -0,0 +1,237 @@
+/// 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

@@ -0,0 +1,132 @@
+/// 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

@@ -0,0 +1,69 @@
+/// 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);
+    }
+}