use crate::config::RuntimeConfig;
use crate::parameter_table::{ParameterTable, ParameterTableDiff};
use near_primitives_core::types::ProtocolVersion;
use std::collections::BTreeMap;
use std::ops::Bound;
use std::sync::Arc;
macro_rules! include_config {
($file:expr) => {
include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/res/runtime_configs/", $file))
};
}
static BASE_CONFIG: &str = include_config!("parameters.yaml");
static CONFIG_DIFFS: &[(ProtocolVersion, &str)] = &[
(35, include_config!("35.yaml")),
(42, include_config!("42.yaml")),
(46, include_config!("46.yaml")),
(48, include_config!("48.yaml")),
(49, include_config!("49.yaml")),
(50, include_config!("50.yaml")),
(52, include_config!("52.yaml")),
(53, include_config!("53.yaml")),
(55, include_config!("55.yaml")),
(57, include_config!("57.yaml")),
(59, include_config!("59.yaml")),
(61, include_config!("61.yaml")),
(62, include_config!("62.yaml")),
(63, include_config!("63.yaml")),
(64, include_config!("64.yaml")),
(129, include_config!("129.yaml")),
(138, include_config!("138.yaml")),
];
pub static INITIAL_TESTNET_CONFIG: &str = include_config!("parameters_testnet.yaml");
#[derive(Clone, Debug)]
pub struct RuntimeConfigStore {
store: BTreeMap<ProtocolVersion, Arc<RuntimeConfig>>,
}
impl RuntimeConfigStore {
pub fn new(genesis_runtime_config: Option<&RuntimeConfig>) -> Self {
let mut params: ParameterTable =
BASE_CONFIG.parse().expect("Failed parsing base parameter file.");
let mut store = BTreeMap::new();
#[cfg(not(feature = "calimero_zero_storage"))]
{
let initial_config = RuntimeConfig::new(¶ms).unwrap_or_else(|err| panic!("Failed generating `RuntimeConfig` from parameters for base parameter file. Error: {err}"));
store.insert(0, Arc::new(initial_config));
}
#[cfg(feature = "calimero_zero_storage")]
{
let mut initial_config = RuntimeConfig::new(¶ms).unwrap_or_else(|err| panic!("Failed generating `RuntimeConfig` from parameters for base parameter file. Error: {err}"));
initial_config.fees.storage_usage_config.storage_amount_per_byte = 0;
store.insert(0, Arc::new(initial_config));
}
for (protocol_version, diff_bytes) in CONFIG_DIFFS {
let diff :ParameterTableDiff= diff_bytes.parse().unwrap_or_else(|err| panic!("Failed parsing runtime parameters diff for version {protocol_version}. Error: {err}"));
params.apply_diff(diff).unwrap_or_else(|err| panic!("Failed applying diff to `RuntimeConfig` for version {protocol_version}. Error: {err}"));
#[cfg(not(feature = "calimero_zero_storage"))]
store.insert(
*protocol_version,
Arc::new(RuntimeConfig::new(¶ms).unwrap_or_else(|err| panic!("Failed generating `RuntimeConfig` from parameters for version {protocol_version}. Error: {err}"))),
);
#[cfg(feature = "calimero_zero_storage")]
{
let mut runtime_config = RuntimeConfig::new(¶ms).unwrap_or_else(|err| panic!("Failed generating `RuntimeConfig` from parameters for version {protocol_version}. Error: {err}"));
runtime_config.fees.storage_usage_config.storage_amount_per_byte = 0;
store.insert(*protocol_version, Arc::new(runtime_config));
}
}
if let Some(runtime_config) = genesis_runtime_config {
let mut config = runtime_config.clone();
store.insert(0, Arc::new(config.clone()));
config.fees.storage_usage_config.storage_amount_per_byte = 10u128.pow(19);
store.insert(42, Arc::new(config));
}
Self { store }
}
pub fn for_chain_id(chain_id: &str) -> Self {
match chain_id {
near_primitives_core::chains::TESTNET => {
let genesis_runtime_config = RuntimeConfig::initial_testnet_config();
Self::new(Some(&genesis_runtime_config))
}
_ => Self::new(None),
}
}
pub fn with_one_config(runtime_config: RuntimeConfig) -> Self {
Self { store: BTreeMap::from_iter([(0, Arc::new(runtime_config))].iter().cloned()) }
}
pub fn test() -> Self {
Self::with_one_config(RuntimeConfig::test())
}
pub fn free() -> Self {
Self::with_one_config(RuntimeConfig::free())
}
pub fn get_config(&self, protocol_version: ProtocolVersion) -> &Arc<RuntimeConfig> {
self.store
.range((Bound::Unbounded, Bound::Included(protocol_version)))
.next_back()
.unwrap_or_else(|| {
panic!("Not found RuntimeConfig for protocol version {}", protocol_version)
})
.1
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::cost::{ActionCosts, ExtCosts};
use near_primitives_core::version::ProtocolFeature::{
LowerDataReceiptAndEcrecoverBaseCost, LowerStorageCost, LowerStorageKeyLimit,
};
use std::collections::HashSet;
const GENESIS_PROTOCOL_VERSION: ProtocolVersion = 29;
const RECEIPTS_DEPTH: u64 = 63;
#[test]
fn all_configs_are_specified() {
let file_versions =
std::fs::read_dir(concat!(env!("CARGO_MANIFEST_DIR"), "/res/runtime_configs/"))
.expect("can open config directory");
let mut files = file_versions
.into_iter()
.map(|de| {
de.expect("direntry should read successfully")
.path()
.file_name()
.expect("direntry should have a filename")
.to_string_lossy()
.into_owned()
})
.collect::<HashSet<_>>();
for (ver, _) in super::CONFIG_DIFFS {
assert!(files.remove(&format!("{ver}.yaml")), "{ver}.yaml file is missing?");
}
for file in files {
let Some((name, "yaml")) = file.rsplit_once(".") else { continue };
let Ok(version_num) = name.parse::<u32>() else { continue };
panic!("CONFIG_DIFFS does not contain reference to the {version_num}.yaml file!");
}
}
#[test]
fn test_max_prepaid_gas() {
let store = RuntimeConfigStore::new(None);
for (protocol_version, config) in store.store.iter() {
assert!(
config.wasm_config.limit_config.max_total_prepaid_gas
/ config.fees.min_receipt_with_function_call_gas()
<= 63,
"The maximum desired depth of receipts for protocol version {} should be at most {}",
protocol_version,
RECEIPTS_DEPTH
);
}
}
#[test]
#[cfg(not(feature = "calimero_zero_storage"))]
fn test_lower_storage_cost() {
let store = RuntimeConfigStore::new(None);
let base_cfg = store.get_config(GENESIS_PROTOCOL_VERSION);
let new_cfg = store.get_config(LowerStorageCost.protocol_version());
assert!(base_cfg.storage_amount_per_byte() > new_cfg.storage_amount_per_byte());
}
#[test]
fn test_override_account_length() {
let base_store = RuntimeConfigStore::new(None);
let base_cfg = base_store.get_config(GENESIS_PROTOCOL_VERSION);
assert_eq!(base_cfg.account_creation_config.min_allowed_top_level_account_length, 32);
let mut cfg = base_cfg.as_ref().clone();
cfg.account_creation_config.min_allowed_top_level_account_length = 0;
let new_store = RuntimeConfigStore::new(Some(&cfg));
let new_cfg = new_store.get_config(GENESIS_PROTOCOL_VERSION);
assert_eq!(new_cfg.account_creation_config.min_allowed_top_level_account_length, 0);
}
#[test]
fn test_lower_data_receipt_cost() {
let store = RuntimeConfigStore::new(None);
let base_cfg = store.get_config(LowerStorageCost.protocol_version());
let new_cfg = store.get_config(LowerDataReceiptAndEcrecoverBaseCost.protocol_version());
assert!(
base_cfg.fees.fee(ActionCosts::new_data_receipt_base).send_sir
> new_cfg.fees.fee(ActionCosts::new_data_receipt_base).send_sir
);
assert!(
base_cfg.fees.fee(ActionCosts::new_data_receipt_byte).send_sir
> new_cfg.fees.fee(ActionCosts::new_data_receipt_byte).send_sir
);
}
#[test]
#[cfg(not(feature = "calimero_zero_storage"))]
fn test_override_runtime_config() {
let store = RuntimeConfigStore::new(None);
let config = store.get_config(0);
let mut base_params = BASE_CONFIG.parse().unwrap();
let base_config = RuntimeConfig::new(&base_params).unwrap();
assert_eq!(config.as_ref(), &base_config);
let config = store.get_config(LowerStorageCost.protocol_version());
assert_eq!(base_config.storage_amount_per_byte(), 100_000_000_000_000_000_000u128);
assert_eq!(config.storage_amount_per_byte(), 10_000_000_000_000_000_000u128);
assert_eq!(config.fees.fee(ActionCosts::new_data_receipt_base).send_sir, 4_697_339_419_375);
assert_ne!(config.as_ref(), &base_config);
assert_ne!(
config.as_ref(),
store.get_config(LowerStorageCost.protocol_version() - 1).as_ref()
);
for (ver, diff) in &CONFIG_DIFFS[..] {
if *ver <= LowerStorageCost.protocol_version() {
base_params.apply_diff(diff.parse().unwrap()).unwrap();
}
}
let expected_config = RuntimeConfig::new(&base_params).unwrap();
assert_eq!(**config, expected_config);
let config = store.get_config(LowerDataReceiptAndEcrecoverBaseCost.protocol_version());
assert_eq!(config.fees.fee(ActionCosts::new_data_receipt_base).send_sir, 36_486_732_312);
for (ver, diff) in &CONFIG_DIFFS[..] {
if *ver <= LowerStorageCost.protocol_version() {
continue;
} else if *ver <= LowerDataReceiptAndEcrecoverBaseCost.protocol_version() {
base_params.apply_diff(diff.parse().unwrap()).unwrap();
}
}
let expected_config = RuntimeConfig::new(&base_params).unwrap();
assert_eq!(config.as_ref(), &expected_config);
}
#[test]
fn test_lower_ecrecover_base_cost() {
let store = RuntimeConfigStore::new(None);
let base_cfg = store.get_config(LowerStorageCost.protocol_version());
let new_cfg = store.get_config(LowerDataReceiptAndEcrecoverBaseCost.protocol_version());
assert!(
base_cfg.wasm_config.ext_costs.gas_cost(ExtCosts::ecrecover_base)
> new_cfg.wasm_config.ext_costs.gas_cost(ExtCosts::ecrecover_base)
);
}
#[test]
fn test_lower_max_length_storage_key() {
let store = RuntimeConfigStore::new(None);
let base_cfg = store.get_config(LowerStorageKeyLimit.protocol_version() - 1);
let new_cfg = store.get_config(LowerStorageKeyLimit.protocol_version());
assert!(
base_cfg.wasm_config.limit_config.max_length_storage_key
> new_cfg.wasm_config.limit_config.max_length_storage_key
);
}
#[test]
#[cfg(not(feature = "nightly"))]
#[cfg(not(feature = "calimero_zero_storage"))]
fn test_json_unchanged() {
use crate::view::RuntimeConfigView;
use near_primitives_core::version::PROTOCOL_VERSION;
let store = RuntimeConfigStore::new(None);
let mut any_failure = false;
for version in store.store.keys() {
let snapshot_name = format!("{version}.json");
let config_view = RuntimeConfigView::from(store.get_config(*version).as_ref().clone());
any_failure |= std::panic::catch_unwind(|| {
insta::assert_json_snapshot!(snapshot_name, config_view, { ".wasm_config.vm_kind" => "<REDACTED>"});
})
.is_err();
}
{
let mut params: ParameterTable = BASE_CONFIG.parse().unwrap();
for (_, diff_bytes) in
CONFIG_DIFFS.iter().filter(|(version, _)| *version <= PROTOCOL_VERSION)
{
params.apply_diff(diff_bytes.parse().unwrap()).unwrap();
}
insta::with_settings!({
snapshot_path => "../res/runtime_configs",
prepend_module_to_snapshot => false,
description => "THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.",
omit_expression => true,
}, {
any_failure |= std::panic::catch_unwind(|| {
insta::assert_display_snapshot!("parameters", params);
}).is_err();
});
}
let params = INITIAL_TESTNET_CONFIG.parse().unwrap();
let new_genesis_runtime_config = RuntimeConfig::new(¶ms).unwrap();
let testnet_store = RuntimeConfigStore::new(Some(&new_genesis_runtime_config));
for version in testnet_store.store.keys() {
let snapshot_name = format!("testnet_{version}.json");
let config_view = RuntimeConfigView::from(store.get_config(*version).as_ref().clone());
any_failure |= std::panic::catch_unwind(|| {
insta::assert_json_snapshot!(snapshot_name, config_view, { ".wasm_config.vm_kind" => "<REDACTED>"});
})
.is_err();
}
if any_failure {
panic!("some snapshot assertions failed");
}
}
#[test]
#[cfg(feature = "calimero_zero_storage")]
fn test_calimero_storage_costs_zero() {
let store = RuntimeConfigStore::new(None);
for (_, config) in store.store.iter() {
assert_eq!(config.storage_amount_per_byte(), 0u128);
}
}
}