randomness_config - [devnet]

Structs and functions for on-chain randomness configurations.

use 0x1::config_buffer;
use 0x1::copyable_any;
use 0x1::fixed_point64;
use 0x1::string;
use 0x1::system_addresses;

Constants

const EINVALID_CONFIG_VARIANT: u64 = 1;

Structs

ConfigOff

A randomness config variant indicating the feature is disabled.

struct ConfigOff has copy, drop, store

Fields

dummy_field: bool

ConfigV1

A randomness config variant indicating the feature is enabled.

struct ConfigV1 has copy, drop, store

Fields

secrecy_threshold: fixed_point64::FixedPoint64

Any validator subset should not be able to reconstruct randomness if subset_power / total_power <= secrecy_threshold,

reconstruction_threshold: fixed_point64::FixedPoint64

Any validator subset should be able to reconstruct randomness if subset_power / total_power > reconstruction_threshold.

ConfigV2

A randomness config variant indicating the feature is enabled with fast path.

struct ConfigV2 has copy, drop, store

Fields

secrecy_threshold: fixed_point64::FixedPoint64

Any validator subset should not be able to reconstruct randomness if subset_power / total_power <= secrecy_threshold,

reconstruction_threshold: fixed_point64::FixedPoint64

Any validator subset should be able to reconstruct randomness if subset_power / total_power > reconstruction_threshold.

fast_path_secrecy_threshold: fixed_point64::FixedPoint64

Any validator subset should not be able to reconstruct randomness via the fast path if subset_power / total_power <= fast_path_secrecy_threshold,

Resources

RandomnessConfig

The configuration of the on-chain randomness feature.

struct RandomnessConfig has copy, drop, store, key

Fields

variant: copyable_any::Any

A config variant packed as an Any. Currently the variant type is one of the following. - ConfigOff - ConfigV1

Functions

initialize

Initialize the configuration. Used in genesis or governance.

public fun initialize(framework: &signer, config: randomness_config::RandomnessConfig)

Implementation

public fun initialize(framework: &signer, config: RandomnessConfig) {
    system_addresses::assert_aptos_framework(framework);
    if (!exists<RandomnessConfig>(@aptos_framework)) {
        move_to(framework, config)
    }
}

set_for_next_epoch

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: randomness_config::RandomnessConfig)

Implementation

public fun set_for_next_epoch(framework: &signer, new_config: RandomnessConfig) {
    system_addresses::assert_aptos_framework(framework);
    config_buffer::upsert(new_config);
}

on_new_epoch

Only used in reconfigurations to apply the pending RandomnessConfig, if there is any.

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

Implementation

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_v2<RandomnessConfig>();
        if (exists<RandomnessConfig>(@aptos_framework)) {
            *borrow_global_mut<RandomnessConfig>(@aptos_framework) = new_config;
        } else {
            move_to(framework, new_config);
        }
    }
}

enabled

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

Implementation

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
    }
}

new_off

Create a ConfigOff variant.

public fun new_off(): randomness_config::RandomnessConfig

Implementation

public fun new_off(): RandomnessConfig {
    RandomnessConfig {
        variant: copyable_any::pack( ConfigOff {} )
    }
}

new_v1

Create a ConfigV1 variant.

public fun new_v1(secrecy_threshold: fixed_point64::FixedPoint64, reconstruction_threshold: fixed_point64::FixedPoint64): randomness_config::RandomnessConfig

Implementation

public fun new_v1(secrecy_threshold: FixedPoint64, reconstruction_threshold: FixedPoint64): RandomnessConfig {
    RandomnessConfig {
        variant: copyable_any::pack( ConfigV1 {
            secrecy_threshold,
            reconstruction_threshold
        } )
    }
}

new_v2

Create a ConfigV2 variant.

public fun new_v2(secrecy_threshold: fixed_point64::FixedPoint64, reconstruction_threshold: fixed_point64::FixedPoint64, fast_path_secrecy_threshold: fixed_point64::FixedPoint64): randomness_config::RandomnessConfig

Implementation

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,
        } )
    }
}

current

Get the currently effective randomness configuration object.

public fun current(): randomness_config::RandomnessConfig

Implementation

public fun current(): RandomnessConfig acquires RandomnessConfig {
    if (exists<RandomnessConfig>(@aptos_framework)) {
        *borrow_global<RandomnessConfig>(@aptos_framework)
    } else {
        new_off()
    }
}

Specification

on_new_epoch

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

requires @aptos_framework == std::signer::address_of(framework);
include config_buffer::OnNewEpochRequirement<RandomnessConfig>;
aborts_if false;

current

public fun current(): randomness_config::RandomnessConfig

aborts_if false;