reconfiguration_with_dkg - [testnet]

此内容尚不支持你的语言。

Reconfiguration with DKG helper functions.

use 0x1::chunky_dkg;
use 0x1::chunky_dkg_config;
use 0x1::consensus_config;
use 0x1::decryption;
use 0x1::dkg;
use 0x1::execution_config;
use 0x1::features;
use 0x1::gas_schedule;
use 0x1::jwk_consensus_config;
use 0x1::jwks;
use 0x1::keyless_account;
use 0x1::option;
use 0x1::randomness_api_v0_config;
use 0x1::randomness_config;
use 0x1::randomness_config_seqnum;
use 0x1::reconfiguration;
use 0x1::reconfiguration_state;
use 0x1::stake;
use 0x1::system_addresses;
use 0x1::validator_consensus_info;
use 0x1::version;

Functions

try_start

Trigger a reconfiguration with DKG. Do nothing if one is already in progress.

public(friend) fun try_start()

Implementation

public(friend) fun try_start() {
    let incomplete_dkg_session = dkg::incomplete_session();
    if (incomplete_dkg_session.is_some()) {
        let session = incomplete_dkg_session.borrow();
        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()
    );
}

try_start_with_chunky_dkg

Trigger a reconfiguration with DKG and Chunky DKG. Do nothing if reconfiguration is already in progress; otherwise start both DKG and Chunky DKG.

public(friend) fun try_start_with_chunky_dkg()

Implementation

public(friend) fun try_start_with_chunky_dkg() {
    if (reconfiguration_state::is_in_progress()) { 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()
    );
    chunky_dkg::start(
        cur_epoch,
        chunky_dkg_config::current(),
        stake::cur_validator_consensus_infos(),
        stake::next_validator_consensus_infos()
    );
}

finish

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)

Implementation

public(friend) fun finish(framework: &signer) {
    system_addresses::assert_aptos_framework(framework);
    dkg::try_clear_incomplete_session(framework);
    chunky_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);
    decryption::on_new_epoch(framework);
    reconfiguration::reconfigure();
}

maybe_finish_reconfig_with_chunky_dkg

Call finish(account) only when (1) reconfiguration is in progress, and (2) both DKG and Chunky DKG have no in-progress session. Guard (1) ensures we never run reconfiguration twice (after the first finish(account), reconfig is no longer in progress).

fun maybe_finish_reconfig_with_chunky_dkg(account: &signer)

Implementation

fun maybe_finish_reconfig_with_chunky_dkg(account: &signer) {
    if (!reconfiguration_state::is_in_progress()) { return };
    let dkg_incomplete = dkg::incomplete_session();
    let chunky_incomplete = chunky_dkg::incomplete_session();
    if (dkg_incomplete.is_none() && chunky_incomplete.is_none()) {
        finish(account);
    }
}

finish_with_dkg_result

Complete the current DKG session with the given result. Aborts if no DKG session is in progress. If Chunky DKG is enabled, finish(account) is invoked only once both DKG and Chunky DKG have no in-progress session; otherwise finish(account) is invoked immediately.

fun finish_with_dkg_result(account: &signer, dkg_result: vector<u8>)

Implementation

fun finish_with_dkg_result(account: &signer, dkg_result: vector<u8>) {
    dkg::finish(dkg_result);
    if (chunky_dkg_config::enabled()) {
        maybe_finish_reconfig_with_chunky_dkg(account);
    } else {
        finish(account);
    }
}

finish_with_chunky_dkg_result

Complete the current Chunky DKG session with the given result. No-op if Chunky DKG is not enabled. Buffers the derived encryption key for the next epoch. finish(account) is invoked only when both DKG and Chunky DKG have no in-progress session (via maybe_finish_reconfig_with_chunky_dkg).

fun finish_with_chunky_dkg_result(account: &signer, chunky_dkg_result: vector<u8>, encryption_key: vector<u8>)

Implementation

fun finish_with_chunky_dkg_result(
    account: &signer, chunky_dkg_result: vector<u8>, encryption_key: vector<u8>
) {
    if (!chunky_dkg_config::enabled()) {
        return;
    };

    chunky_dkg::finish(chunky_dkg_result);
    let next_epoch = reconfiguration::current_epoch() + 1;
    decryption::set_for_next_epoch(next_epoch, encryption_key);
    maybe_finish_reconfig_with_chunky_dkg(account);
}

Specification

pragma verify = true;

try_start

public(friend) fun try_start()

pragma verify_duration_estimate = 120;
requires exists<reconfiguration::Configuration>(@aptos_framework);
requires chain_status::is_operating();
include stake::ResourceRequirement;
include stake::GetReconfigStartTimeRequirement;
include features::spec_periodical_reward_rate_decrease_enabled() ==>
    staking_config::StakingRewardsConfigEnabledRequirement;
aborts_if false;
pragma verify_duration_estimate = 600;

try_start_with_chunky_dkg

public(friend) fun try_start_with_chunky_dkg()

pragma verify = false;

finish

public(friend) fun finish(framework: &signer)

pragma verify_duration_estimate = 1500;
include FinishRequirement;
aborts_if false;

schema FinishRequirement {
    framework: signer;
    requires signer::address_of(framework) == @aptos_framework;
    requires chain_status::is_operating();
    requires exists<CoinInfo<AptosCoin>>(@aptos_framework);
    include staking_config::StakingRewardsConfigRequirement;
    requires exists<features::Features>(@std);
    include config_buffer::OnNewEpochRequirement<version::Version>;
    include config_buffer::OnNewEpochRequirement<gas_schedule::GasScheduleV2>;
    include config_buffer::OnNewEpochRequirement<execution_config::ExecutionConfig>;
    include config_buffer::OnNewEpochRequirement<consensus_config::ConsensusConfig>;
    include config_buffer::OnNewEpochRequirement<jwks::SupportedOIDCProviders>;
    include config_buffer::OnNewEpochRequirement<randomness_config::RandomnessConfig>;
    include config_buffer::OnNewEpochRequirement<randomness_config_seqnum::RandomnessConfigSeqNum>;
    include config_buffer::OnNewEpochRequirement<randomness_api_v0_config::AllowCustomMaxGasFlag>;
    include config_buffer::OnNewEpochRequirement<randomness_api_v0_config::RequiredGasDeposit>;
    include config_buffer::OnNewEpochRequirement<jwk_consensus_config::JWKConsensusConfig>;
    include config_buffer::OnNewEpochRequirement<keyless_account::Configuration>;
    include config_buffer::OnNewEpochRequirement<keyless_account::Groth16VerificationKey>;
}

maybe_finish_reconfig_with_chunky_dkg

fun maybe_finish_reconfig_with_chunky_dkg(account: &signer)

pragma verify = false;

finish_with_dkg_result

fun finish_with_dkg_result(account: &signer, dkg_result: vector<u8>)

pragma verify_duration_estimate = 1500;
include FinishRequirement { framework: account };
requires dkg::has_incomplete_session();
aborts_if false;

finish_with_chunky_dkg_result

fun finish_with_chunky_dkg_result(account: &signer, chunky_dkg_result: vector<u8>, encryption_key: vector<u8>)

pragma verify = false;