1use std::{
5 collections::{BTreeMap, BTreeSet},
6 sync::{
7 Arc, LazyLock,
8 atomic::{AtomicBool, Ordering},
9 },
10};
11
12#[cfg(msim)]
13use std::cell::RefCell;
14#[cfg(not(msim))]
15use std::sync::Mutex;
16
17use clap::*;
18use fastcrypto::encoding::{Base58, Encoding, Hex};
19use move_binary_format::{
20 binary_config::{BinaryConfig, TableConfig},
21 file_format_common::VERSION_1,
22};
23use move_core_types::account_address::AccountAddress;
24use move_vm_config::verifier::VerifierConfig;
25use mysten_common::in_integration_test;
26use serde::{Deserialize, Serialize};
27use serde_with::skip_serializing_none;
28use sui_protocol_config_macros::{
29 ProtocolConfigAccessors, ProtocolConfigFeatureFlagsGetters, ProtocolConfigOverride,
30};
31use tracing::{info, warn};
32
33const MIN_PROTOCOL_VERSION: u64 = 1;
35const MAX_PROTOCOL_VERSION: u64 = 124;
36
37const TESTNET_USDC: &str =
38 "0xa1ec7fc00a6f40db9693ad1415d0c193ad3906494428cf252621037bd7117e29::usdc::USDC";
39
40#[derive(Copy, Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
332pub struct ProtocolVersion(u64);
333
334impl ProtocolVersion {
335 pub const MIN: Self = Self(MIN_PROTOCOL_VERSION);
340
341 pub const MAX: Self = Self(MAX_PROTOCOL_VERSION);
342
343 #[cfg(not(msim))]
344 pub const MAX_ALLOWED: Self = Self::MAX;
345
346 #[cfg(msim)]
348 pub const MAX_ALLOWED: Self = Self(MAX_PROTOCOL_VERSION + 1);
349
350 pub fn new(v: u64) -> Self {
351 Self(v)
352 }
353
354 pub const fn as_u64(&self) -> u64 {
355 self.0
356 }
357
358 pub fn max() -> Self {
361 Self::MAX
362 }
363
364 pub fn prev(self) -> Self {
365 Self(self.0.checked_sub(1).unwrap())
366 }
367}
368
369impl From<u64> for ProtocolVersion {
370 fn from(v: u64) -> Self {
371 Self::new(v)
372 }
373}
374
375impl std::ops::Sub<u64> for ProtocolVersion {
376 type Output = Self;
377 fn sub(self, rhs: u64) -> Self::Output {
378 Self::new(self.0 - rhs)
379 }
380}
381
382impl std::ops::Add<u64> for ProtocolVersion {
383 type Output = Self;
384 fn add(self, rhs: u64) -> Self::Output {
385 Self::new(self.0 + rhs)
386 }
387}
388
389#[derive(
390 Clone, Serialize, Deserialize, Debug, Default, PartialEq, Copy, PartialOrd, Ord, Eq, ValueEnum,
391)]
392pub enum Chain {
393 Mainnet,
394 Testnet,
395 #[default]
396 Unknown,
397}
398
399impl Chain {
400 pub fn as_str(self) -> &'static str {
401 match self {
402 Chain::Mainnet => "mainnet",
403 Chain::Testnet => "testnet",
404 Chain::Unknown => "unknown",
405 }
406 }
407}
408
409pub struct Error(pub String);
410
411#[derive(Default, Clone, Serialize, Deserialize, Debug, ProtocolConfigFeatureFlagsGetters)]
414struct FeatureFlags {
415 #[serde(skip_serializing_if = "is_false")]
418 package_upgrades: bool,
419 #[serde(skip_serializing_if = "is_false")]
422 commit_root_state_digest: bool,
423 #[serde(skip_serializing_if = "is_false")]
425 advance_epoch_start_time_in_safe_mode: bool,
426 #[serde(skip_serializing_if = "is_false")]
429 loaded_child_objects_fixed: bool,
430 #[serde(skip_serializing_if = "is_false")]
433 missing_type_is_compatibility_error: bool,
434 #[serde(skip_serializing_if = "is_false")]
437 scoring_decision_with_validity_cutoff: bool,
438
439 #[serde(skip_serializing_if = "is_false")]
442 consensus_order_end_of_epoch_last: bool,
443
444 #[serde(skip_serializing_if = "is_false")]
446 disallow_adding_abilities_on_upgrade: bool,
447 #[serde(skip_serializing_if = "is_false")]
449 disable_invariant_violation_check_in_swap_loc: bool,
450 #[serde(skip_serializing_if = "is_false")]
453 advance_to_highest_supported_protocol_version: bool,
454 #[serde(skip_serializing_if = "is_false")]
456 ban_entry_init: bool,
457 #[serde(skip_serializing_if = "is_false")]
459 package_digest_hash_module: bool,
460 #[serde(skip_serializing_if = "is_false")]
462 disallow_change_struct_type_params_on_upgrade: bool,
463 #[serde(skip_serializing_if = "is_false")]
465 no_extraneous_module_bytes: bool,
466 #[serde(skip_serializing_if = "is_false")]
468 narwhal_versioned_metadata: bool,
469
470 #[serde(skip_serializing_if = "is_false")]
472 zklogin_auth: bool,
473 #[serde(skip_serializing_if = "ConsensusTransactionOrdering::is_none")]
475 consensus_transaction_ordering: ConsensusTransactionOrdering,
476
477 #[serde(skip_serializing_if = "is_false")]
485 simplified_unwrap_then_delete: bool,
486 #[serde(skip_serializing_if = "is_false")]
488 upgraded_multisig_supported: bool,
489 #[serde(skip_serializing_if = "is_false")]
491 txn_base_cost_as_multiplier: bool,
492
493 #[serde(skip_serializing_if = "is_false")]
495 shared_object_deletion: bool,
496
497 #[serde(skip_serializing_if = "is_false")]
499 narwhal_new_leader_election_schedule: bool,
500
501 #[serde(skip_serializing_if = "is_empty")]
503 zklogin_supported_providers: BTreeSet<String>,
504
505 #[serde(skip_serializing_if = "is_false")]
507 loaded_child_object_format: bool,
508
509 #[serde(skip_serializing_if = "is_false")]
510 enable_jwk_consensus_updates: bool,
511
512 #[serde(skip_serializing_if = "is_false")]
513 end_of_epoch_transaction_supported: bool,
514
515 #[serde(skip_serializing_if = "is_false")]
518 simple_conservation_checks: bool,
519
520 #[serde(skip_serializing_if = "is_false")]
522 loaded_child_object_format_type: bool,
523
524 #[serde(skip_serializing_if = "is_false")]
526 receive_objects: bool,
527
528 #[serde(skip_serializing_if = "is_false")]
530 consensus_checkpoint_signature_key_includes_digest: bool,
531
532 #[serde(skip_serializing_if = "is_false")]
534 random_beacon: bool,
535
536 #[serde(skip_serializing_if = "is_false")]
538 bridge: bool,
539
540 #[serde(skip_serializing_if = "is_false")]
541 enable_effects_v2: bool,
542
543 #[serde(skip_serializing_if = "is_false")]
545 narwhal_certificate_v2: bool,
546
547 #[serde(skip_serializing_if = "is_false")]
549 verify_legacy_zklogin_address: bool,
550
551 #[serde(skip_serializing_if = "is_false")]
553 throughput_aware_consensus_submission: bool,
554
555 #[serde(skip_serializing_if = "is_false")]
557 recompute_has_public_transfer_in_execution: bool,
558
559 #[serde(skip_serializing_if = "is_false")]
561 accept_zklogin_in_multisig: bool,
562
563 #[serde(skip_serializing_if = "is_false")]
565 accept_passkey_in_multisig: bool,
566
567 #[serde(skip_serializing_if = "is_false")]
569 validate_zklogin_public_identifier: bool,
570
571 #[serde(skip_serializing_if = "is_false")]
574 include_consensus_digest_in_prologue: bool,
575
576 #[serde(skip_serializing_if = "is_false")]
578 hardened_otw_check: bool,
579
580 #[serde(skip_serializing_if = "is_false")]
582 allow_receiving_object_id: bool,
583
584 #[serde(skip_serializing_if = "is_false")]
586 enable_poseidon: bool,
587
588 #[serde(skip_serializing_if = "is_false")]
590 enable_coin_deny_list: bool,
591
592 #[serde(skip_serializing_if = "is_false")]
594 enable_group_ops_native_functions: bool,
595
596 #[serde(skip_serializing_if = "is_false")]
598 enable_group_ops_native_function_msm: bool,
599
600 #[serde(skip_serializing_if = "is_false")]
602 enable_ristretto255_group_ops: bool,
603
604 #[serde(skip_serializing_if = "is_false")]
606 enable_verify_bulletproofs_ristretto255: bool,
607
608 #[serde(skip_serializing_if = "is_false")]
610 enable_nitro_attestation: bool,
611
612 #[serde(skip_serializing_if = "is_false")]
614 enable_nitro_attestation_upgraded_parsing: bool,
615
616 #[serde(skip_serializing_if = "is_false")]
618 enable_nitro_attestation_all_nonzero_pcrs_parsing: bool,
619
620 #[serde(skip_serializing_if = "is_false")]
622 enable_nitro_attestation_always_include_required_pcrs_parsing: bool,
623
624 #[serde(skip_serializing_if = "is_false")]
626 reject_mutable_random_on_entry_functions: bool,
627
628 #[serde(skip_serializing_if = "PerObjectCongestionControlMode::is_none")]
630 per_object_congestion_control_mode: PerObjectCongestionControlMode,
631
632 #[serde(skip_serializing_if = "ConsensusChoice::is_narwhal")]
634 consensus_choice: ConsensusChoice,
635
636 #[serde(skip_serializing_if = "ConsensusNetwork::is_anemo")]
638 consensus_network: ConsensusNetwork,
639
640 #[serde(skip_serializing_if = "is_false")]
642 correct_gas_payment_limit_check: bool,
643
644 #[serde(skip_serializing_if = "Option::is_none")]
646 zklogin_max_epoch_upper_bound_delta: Option<u64>,
647
648 #[serde(skip_serializing_if = "is_false")]
650 mysticeti_leader_scoring_and_schedule: bool,
651
652 #[serde(skip_serializing_if = "is_false")]
654 reshare_at_same_initial_version: bool,
655
656 #[serde(skip_serializing_if = "is_false")]
658 resolve_abort_locations_to_package_id: bool,
659
660 #[serde(skip_serializing_if = "is_false")]
664 mysticeti_use_committed_subdag_digest: bool,
665
666 #[serde(skip_serializing_if = "is_false")]
668 enable_vdf: bool,
669
670 #[serde(skip_serializing_if = "is_false")]
675 record_consensus_determined_version_assignments_in_prologue: bool,
676 #[serde(skip_serializing_if = "is_false")]
677 record_consensus_determined_version_assignments_in_prologue_v2: bool,
678
679 #[serde(skip_serializing_if = "is_false")]
681 fresh_vm_on_framework_upgrade: bool,
682
683 #[serde(skip_serializing_if = "is_false")]
691 prepend_prologue_tx_in_consensus_commit_in_checkpoints: bool,
692
693 #[serde(skip_serializing_if = "Option::is_none")]
695 mysticeti_num_leaders_per_round: Option<usize>,
696
697 #[serde(skip_serializing_if = "is_false")]
699 soft_bundle: bool,
700
701 #[serde(skip_serializing_if = "is_false")]
703 enable_coin_deny_list_v2: bool,
704
705 #[serde(skip_serializing_if = "is_false")]
707 passkey_auth: bool,
708
709 #[serde(skip_serializing_if = "is_false")]
711 authority_capabilities_v2: bool,
712
713 #[serde(skip_serializing_if = "is_false")]
715 rethrow_serialization_type_layout_errors: bool,
716
717 #[serde(skip_serializing_if = "is_false")]
719 consensus_distributed_vote_scoring_strategy: bool,
720
721 #[serde(skip_serializing_if = "is_false")]
723 consensus_round_prober: bool,
724
725 #[serde(skip_serializing_if = "is_false")]
727 validate_identifier_inputs: bool,
728
729 #[serde(skip_serializing_if = "is_false")]
731 disallow_self_identifier: bool,
732
733 #[serde(skip_serializing_if = "is_false")]
735 mysticeti_fastpath: bool,
736
737 #[serde(skip_serializing_if = "is_false")]
741 disable_preconsensus_locking: bool,
742
743 #[serde(skip_serializing_if = "is_false")]
745 relocate_event_module: bool,
746
747 #[serde(skip_serializing_if = "is_false")]
749 uncompressed_g1_group_elements: bool,
750
751 #[serde(skip_serializing_if = "is_false")]
752 disallow_new_modules_in_deps_only_packages: bool,
753
754 #[serde(skip_serializing_if = "is_false")]
756 consensus_smart_ancestor_selection: bool,
757
758 #[serde(skip_serializing_if = "is_false")]
760 consensus_round_prober_probe_accepted_rounds: bool,
761
762 #[serde(skip_serializing_if = "is_false")]
764 native_charging_v2: bool,
765
766 #[serde(skip_serializing_if = "is_false")]
769 consensus_linearize_subdag_v2: bool,
770
771 #[serde(skip_serializing_if = "is_false")]
773 convert_type_argument_error: bool,
774
775 #[serde(skip_serializing_if = "is_false")]
777 variant_nodes: bool,
778
779 #[serde(skip_serializing_if = "is_false")]
781 consensus_zstd_compression: bool,
782
783 #[serde(skip_serializing_if = "is_false")]
785 minimize_child_object_mutations: bool,
786
787 #[serde(skip_serializing_if = "is_false")]
789 record_additional_state_digest_in_prologue: bool,
790
791 #[serde(skip_serializing_if = "is_false")]
793 move_native_context: bool,
794
795 #[serde(skip_serializing_if = "is_false")]
798 consensus_median_based_commit_timestamp: bool,
799
800 #[serde(skip_serializing_if = "is_false")]
803 normalize_ptb_arguments: bool,
804
805 #[serde(skip_serializing_if = "is_false")]
807 consensus_batched_block_sync: bool,
808
809 #[serde(skip_serializing_if = "is_false")]
811 enforce_checkpoint_timestamp_monotonicity: bool,
812
813 #[serde(skip_serializing_if = "is_false")]
815 max_ptb_value_size_v2: bool,
816
817 #[serde(skip_serializing_if = "is_false")]
819 resolve_type_input_ids_to_defining_id: bool,
820
821 #[serde(skip_serializing_if = "is_false")]
823 enable_party_transfer: bool,
824
825 #[serde(skip_serializing_if = "is_false")]
827 allow_unbounded_system_objects: bool,
828
829 #[serde(skip_serializing_if = "is_false")]
831 type_tags_in_object_runtime: bool,
832
833 #[serde(skip_serializing_if = "is_false")]
835 enable_accumulators: bool,
836
837 #[serde(skip_serializing_if = "is_false")]
839 enable_coin_reservation_obj_refs: bool,
840
841 #[serde(skip_serializing_if = "is_false")]
844 create_root_accumulator_object: bool,
845
846 #[serde(skip_serializing_if = "is_false")]
848 enable_authenticated_event_streams: bool,
849
850 #[serde(skip_serializing_if = "is_false")]
852 enable_address_balance_gas_payments: bool,
853
854 #[serde(skip_serializing_if = "is_false")]
856 address_balance_gas_check_rgp_at_signing: bool,
857
858 #[serde(skip_serializing_if = "is_false")]
859 address_balance_gas_reject_gas_coin_arg: bool,
860
861 #[serde(skip_serializing_if = "is_false")]
863 enable_multi_epoch_transaction_expiration: bool,
864
865 #[serde(skip_serializing_if = "is_false")]
867 relax_valid_during_for_owned_inputs: bool,
868
869 #[serde(skip_serializing_if = "is_false")]
871 enable_ptb_execution_v2: bool,
872
873 #[serde(skip_serializing_if = "is_false")]
875 better_adapter_type_resolution_errors: bool,
876
877 #[serde(skip_serializing_if = "is_false")]
879 record_time_estimate_processed: bool,
880
881 #[serde(skip_serializing_if = "is_false")]
883 dependency_linkage_error: bool,
884
885 #[serde(skip_serializing_if = "is_false")]
887 additional_multisig_checks: bool,
888
889 #[serde(skip_serializing_if = "is_false")]
891 ignore_execution_time_observations_after_certs_closed: bool,
892
893 #[serde(skip_serializing_if = "is_false")]
897 debug_fatal_on_move_invariant_violation: bool,
898
899 #[serde(skip_serializing_if = "is_false")]
902 allow_private_accumulator_entrypoints: bool,
903
904 #[serde(skip_serializing_if = "is_false")]
906 additional_consensus_digest_indirect_state: bool,
907
908 #[serde(skip_serializing_if = "is_false")]
910 check_for_init_during_upgrade: bool,
911
912 #[serde(skip_serializing_if = "is_false")]
914 per_command_shared_object_transfer_rules: bool,
915
916 #[serde(skip_serializing_if = "is_false")]
918 include_checkpoint_artifacts_digest_in_summary: bool,
919
920 #[serde(skip_serializing_if = "is_false")]
922 use_mfp_txns_in_load_initial_object_debts: bool,
923
924 #[serde(skip_serializing_if = "is_false")]
926 cancel_for_failed_dkg_early: bool,
927
928 #[serde(skip_serializing_if = "is_false")]
930 enable_coin_registry: bool,
931
932 #[serde(skip_serializing_if = "is_false")]
934 abstract_size_in_object_runtime: bool,
935
936 #[serde(skip_serializing_if = "is_false")]
938 object_runtime_charge_cache_load_gas: bool,
939
940 #[serde(skip_serializing_if = "is_false")]
942 additional_borrow_checks: bool,
943
944 #[serde(skip_serializing_if = "is_false")]
946 use_new_commit_handler: bool,
947
948 #[serde(skip_serializing_if = "is_false")]
950 better_loader_errors: bool,
951
952 #[serde(skip_serializing_if = "is_false")]
954 generate_df_type_layouts: bool,
955
956 #[serde(skip_serializing_if = "is_false")]
958 allow_references_in_ptbs: bool,
959
960 #[serde(skip_serializing_if = "is_false")]
962 enable_display_registry: bool,
963
964 #[serde(skip_serializing_if = "is_false")]
966 private_generics_verifier_v2: bool,
967
968 #[serde(skip_serializing_if = "is_false")]
970 deprecate_global_storage_ops_during_deserialization: bool,
971
972 #[serde(skip_serializing_if = "is_false")]
975 enable_non_exclusive_writes: bool,
976
977 #[serde(skip_serializing_if = "is_false")]
979 deprecate_global_storage_ops: bool,
980
981 #[serde(skip_serializing_if = "is_false")]
983 normalize_depth_formula: bool,
984
985 #[serde(skip_serializing_if = "is_false")]
987 consensus_skip_gced_accept_votes: bool,
988
989 #[serde(skip_serializing_if = "is_false")]
991 include_cancelled_randomness_txns_in_prologue: bool,
992
993 #[serde(skip_serializing_if = "is_false")]
995 address_aliases: bool,
996
997 #[serde(skip_serializing_if = "is_false")]
1000 fix_checkpoint_signature_mapping: bool,
1001
1002 #[serde(skip_serializing_if = "is_false")]
1004 enable_object_funds_withdraw: bool,
1005
1006 #[serde(skip_serializing_if = "is_false")]
1008 consensus_skip_gced_blocks_in_direct_finalization: bool,
1009
1010 #[serde(skip_serializing_if = "is_false")]
1012 gas_rounding_halve_digits: bool,
1013
1014 #[serde(skip_serializing_if = "is_false")]
1016 flexible_tx_context_positions: bool,
1017
1018 #[serde(skip_serializing_if = "is_false")]
1020 disable_entry_point_signature_check: bool,
1021
1022 #[serde(skip_serializing_if = "is_false")]
1024 convert_withdrawal_compatibility_ptb_arguments: bool,
1025
1026 #[serde(skip_serializing_if = "is_false")]
1028 restrict_hot_or_not_entry_functions: bool,
1029
1030 #[serde(skip_serializing_if = "is_false")]
1032 split_checkpoints_in_consensus_handler: bool,
1033
1034 #[serde(skip_serializing_if = "is_false")]
1036 consensus_always_accept_system_transactions: bool,
1037
1038 #[serde(skip_serializing_if = "is_false")]
1040 validator_metadata_verify_v2: bool,
1041
1042 #[serde(skip_serializing_if = "is_false")]
1045 defer_unpaid_amplification: bool,
1046
1047 #[serde(skip_serializing_if = "is_false")]
1048 randomize_checkpoint_tx_limit_in_tests: bool,
1049
1050 #[serde(skip_serializing_if = "is_false")]
1052 gasless_transaction_drop_safety: bool,
1053
1054 #[serde(skip_serializing_if = "is_false")]
1056 merge_randomness_into_checkpoint: bool,
1057
1058 #[serde(skip_serializing_if = "is_false")]
1060 use_coin_party_owner: bool,
1061
1062 #[serde(skip_serializing_if = "is_false")]
1063 enable_gasless: bool,
1064
1065 #[serde(skip_serializing_if = "is_false")]
1066 gasless_verify_remaining_balance: bool,
1067
1068 #[serde(skip_serializing_if = "is_false")]
1069 disallow_jump_orphans: bool,
1070
1071 #[serde(skip_serializing_if = "is_false")]
1073 early_return_receive_object_mismatched_type: bool,
1074
1075 #[serde(skip_serializing_if = "is_false")]
1080 timestamp_based_epoch_close: bool,
1081
1082 #[serde(skip_serializing_if = "is_false")]
1085 limit_groth16_pvk_inputs: bool,
1086}
1087
1088fn is_false(b: &bool) -> bool {
1089 !b
1090}
1091
1092fn is_empty(b: &BTreeSet<String>) -> bool {
1093 b.is_empty()
1094}
1095
1096fn is_zero(val: &u64) -> bool {
1097 *val == 0
1098}
1099
1100#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1102pub enum ConsensusTransactionOrdering {
1103 #[default]
1105 None,
1106 ByGasPrice,
1108}
1109
1110impl ConsensusTransactionOrdering {
1111 pub fn is_none(&self) -> bool {
1112 matches!(self, ConsensusTransactionOrdering::None)
1113 }
1114}
1115
1116#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1117pub struct ExecutionTimeEstimateParams {
1118 pub target_utilization: u64,
1120 pub allowed_txn_cost_overage_burst_limit_us: u64,
1124
1125 pub randomness_scalar: u64,
1128
1129 pub max_estimate_us: u64,
1131
1132 pub stored_observations_num_included_checkpoints: u64,
1135
1136 pub stored_observations_limit: u64,
1138
1139 #[serde(skip_serializing_if = "is_zero")]
1142 pub stake_weighted_median_threshold: u64,
1143
1144 #[serde(skip_serializing_if = "is_false")]
1148 pub default_none_duration_for_new_keys: bool,
1149
1150 #[serde(skip_serializing_if = "Option::is_none")]
1152 pub observations_chunk_size: Option<u64>,
1153}
1154
1155#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1157pub enum PerObjectCongestionControlMode {
1158 #[default]
1159 None, TotalGasBudget, TotalTxCount, TotalGasBudgetWithCap, ExecutionTimeEstimate(ExecutionTimeEstimateParams), }
1165
1166impl PerObjectCongestionControlMode {
1167 pub fn is_none(&self) -> bool {
1168 matches!(self, PerObjectCongestionControlMode::None)
1169 }
1170}
1171
1172#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1174pub enum ConsensusChoice {
1175 #[default]
1176 Narwhal,
1177 SwapEachEpoch,
1178 Mysticeti,
1179}
1180
1181impl ConsensusChoice {
1182 pub fn is_narwhal(&self) -> bool {
1183 matches!(self, ConsensusChoice::Narwhal)
1184 }
1185}
1186
1187#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1189pub enum ConsensusNetwork {
1190 #[default]
1191 Anemo,
1192 Tonic,
1193}
1194
1195impl ConsensusNetwork {
1196 pub fn is_anemo(&self) -> bool {
1197 matches!(self, ConsensusNetwork::Anemo)
1198 }
1199}
1200
1201#[skip_serializing_none]
1233#[derive(Clone, Serialize, Debug, ProtocolConfigAccessors, ProtocolConfigOverride)]
1234pub struct ProtocolConfig {
1235 pub version: ProtocolVersion,
1236
1237 feature_flags: FeatureFlags,
1238
1239 max_tx_size_bytes: Option<u64>,
1242
1243 max_input_objects: Option<u64>,
1245
1246 max_size_written_objects: Option<u64>,
1250 max_size_written_objects_system_tx: Option<u64>,
1253
1254 max_serialized_tx_effects_size_bytes: Option<u64>,
1256
1257 max_serialized_tx_effects_size_bytes_system_tx: Option<u64>,
1259
1260 max_gas_payment_objects: Option<u32>,
1262
1263 max_modules_in_publish: Option<u32>,
1265
1266 max_package_dependencies: Option<u32>,
1268
1269 max_arguments: Option<u32>,
1272
1273 max_type_arguments: Option<u32>,
1275
1276 max_type_argument_depth: Option<u32>,
1278
1279 max_pure_argument_size: Option<u32>,
1281
1282 max_programmable_tx_commands: Option<u32>,
1284
1285 move_binary_format_version: Option<u32>,
1288 min_move_binary_format_version: Option<u32>,
1289
1290 binary_module_handles: Option<u16>,
1292 binary_struct_handles: Option<u16>,
1293 binary_function_handles: Option<u16>,
1294 binary_function_instantiations: Option<u16>,
1295 binary_signatures: Option<u16>,
1296 binary_constant_pool: Option<u16>,
1297 binary_identifiers: Option<u16>,
1298 binary_address_identifiers: Option<u16>,
1299 binary_struct_defs: Option<u16>,
1300 binary_struct_def_instantiations: Option<u16>,
1301 binary_function_defs: Option<u16>,
1302 binary_field_handles: Option<u16>,
1303 binary_field_instantiations: Option<u16>,
1304 binary_friend_decls: Option<u16>,
1305 binary_enum_defs: Option<u16>,
1306 binary_enum_def_instantiations: Option<u16>,
1307 binary_variant_handles: Option<u16>,
1308 binary_variant_instantiation_handles: Option<u16>,
1309
1310 max_move_object_size: Option<u64>,
1312
1313 max_move_package_size: Option<u64>,
1316
1317 max_publish_or_upgrade_per_ptb: Option<u64>,
1319
1320 max_tx_gas: Option<u64>,
1322
1323 max_gas_price: Option<u64>,
1325
1326 max_gas_price_rgp_factor_for_aborted_transactions: Option<u64>,
1329
1330 max_gas_computation_bucket: Option<u64>,
1332
1333 gas_rounding_step: Option<u64>,
1335
1336 max_loop_depth: Option<u64>,
1338
1339 max_generic_instantiation_length: Option<u64>,
1341
1342 max_function_parameters: Option<u64>,
1344
1345 max_basic_blocks: Option<u64>,
1347
1348 max_value_stack_size: Option<u64>,
1350
1351 max_type_nodes: Option<u64>,
1353
1354 max_push_size: Option<u64>,
1356
1357 max_struct_definitions: Option<u64>,
1359
1360 max_function_definitions: Option<u64>,
1362
1363 max_fields_in_struct: Option<u64>,
1365
1366 max_dependency_depth: Option<u64>,
1368
1369 max_num_event_emit: Option<u64>,
1371
1372 max_num_new_move_object_ids: Option<u64>,
1374
1375 max_num_new_move_object_ids_system_tx: Option<u64>,
1377
1378 max_num_deleted_move_object_ids: Option<u64>,
1380
1381 max_num_deleted_move_object_ids_system_tx: Option<u64>,
1383
1384 max_num_transferred_move_object_ids: Option<u64>,
1386
1387 max_num_transferred_move_object_ids_system_tx: Option<u64>,
1389
1390 max_event_emit_size: Option<u64>,
1392
1393 max_event_emit_size_total: Option<u64>,
1395
1396 max_move_vector_len: Option<u64>,
1398
1399 max_move_identifier_len: Option<u64>,
1401
1402 max_move_value_depth: Option<u64>,
1404
1405 max_move_enum_variants: Option<u64>,
1407
1408 max_back_edges_per_function: Option<u64>,
1410
1411 max_back_edges_per_module: Option<u64>,
1413
1414 max_verifier_meter_ticks_per_function: Option<u64>,
1416
1417 max_meter_ticks_per_module: Option<u64>,
1419
1420 max_meter_ticks_per_package: Option<u64>,
1422
1423 object_runtime_max_num_cached_objects: Option<u64>,
1427
1428 object_runtime_max_num_cached_objects_system_tx: Option<u64>,
1430
1431 object_runtime_max_num_store_entries: Option<u64>,
1433
1434 object_runtime_max_num_store_entries_system_tx: Option<u64>,
1436
1437 base_tx_cost_fixed: Option<u64>,
1440
1441 package_publish_cost_fixed: Option<u64>,
1444
1445 base_tx_cost_per_byte: Option<u64>,
1448
1449 package_publish_cost_per_byte: Option<u64>,
1451
1452 obj_access_cost_read_per_byte: Option<u64>,
1454
1455 obj_access_cost_mutate_per_byte: Option<u64>,
1457
1458 obj_access_cost_delete_per_byte: Option<u64>,
1460
1461 obj_access_cost_verify_per_byte: Option<u64>,
1471
1472 max_type_to_layout_nodes: Option<u64>,
1474
1475 max_ptb_value_size: Option<u64>,
1477
1478 gas_model_version: Option<u64>,
1481
1482 obj_data_cost_refundable: Option<u64>,
1485
1486 obj_metadata_cost_non_refundable: Option<u64>,
1490
1491 storage_rebate_rate: Option<u64>,
1497
1498 storage_fund_reinvest_rate: Option<u64>,
1501
1502 reward_slashing_rate: Option<u64>,
1505
1506 storage_gas_price: Option<u64>,
1508
1509 accumulator_object_storage_cost: Option<u64>,
1511
1512 max_transactions_per_checkpoint: Option<u64>,
1517
1518 max_checkpoint_size_bytes: Option<u64>,
1522
1523 buffer_stake_for_protocol_upgrade_bps: Option<u64>,
1528
1529 address_from_bytes_cost_base: Option<u64>,
1534 address_to_u256_cost_base: Option<u64>,
1536 address_from_u256_cost_base: Option<u64>,
1538
1539 config_read_setting_impl_cost_base: Option<u64>,
1544 config_read_setting_impl_cost_per_byte: Option<u64>,
1545
1546 dynamic_field_hash_type_and_key_cost_base: Option<u64>,
1549 dynamic_field_hash_type_and_key_type_cost_per_byte: Option<u64>,
1550 dynamic_field_hash_type_and_key_value_cost_per_byte: Option<u64>,
1551 dynamic_field_hash_type_and_key_type_tag_cost_per_byte: Option<u64>,
1552 dynamic_field_add_child_object_cost_base: Option<u64>,
1554 dynamic_field_add_child_object_type_cost_per_byte: Option<u64>,
1555 dynamic_field_add_child_object_value_cost_per_byte: Option<u64>,
1556 dynamic_field_add_child_object_struct_tag_cost_per_byte: Option<u64>,
1557 dynamic_field_borrow_child_object_cost_base: Option<u64>,
1559 dynamic_field_borrow_child_object_child_ref_cost_per_byte: Option<u64>,
1560 dynamic_field_borrow_child_object_type_cost_per_byte: Option<u64>,
1561 dynamic_field_remove_child_object_cost_base: Option<u64>,
1563 dynamic_field_remove_child_object_child_cost_per_byte: Option<u64>,
1564 dynamic_field_remove_child_object_type_cost_per_byte: Option<u64>,
1565 dynamic_field_has_child_object_cost_base: Option<u64>,
1567 dynamic_field_has_child_object_with_ty_cost_base: Option<u64>,
1569 dynamic_field_has_child_object_with_ty_type_cost_per_byte: Option<u64>,
1570 dynamic_field_has_child_object_with_ty_type_tag_cost_per_byte: Option<u64>,
1571
1572 event_emit_cost_base: Option<u64>,
1575 event_emit_value_size_derivation_cost_per_byte: Option<u64>,
1576 event_emit_tag_size_derivation_cost_per_byte: Option<u64>,
1577 event_emit_output_cost_per_byte: Option<u64>,
1578 event_emit_auth_stream_cost: Option<u64>,
1579
1580 object_borrow_uid_cost_base: Option<u64>,
1583 object_delete_impl_cost_base: Option<u64>,
1585 object_record_new_uid_cost_base: Option<u64>,
1587
1588 transfer_transfer_internal_cost_base: Option<u64>,
1591 transfer_party_transfer_internal_cost_base: Option<u64>,
1593 transfer_freeze_object_cost_base: Option<u64>,
1595 transfer_share_object_cost_base: Option<u64>,
1597 transfer_receive_object_cost_base: Option<u64>,
1600 transfer_receive_object_cost_per_byte: Option<u64>,
1601 transfer_receive_object_type_cost_per_byte: Option<u64>,
1602
1603 tx_context_derive_id_cost_base: Option<u64>,
1606 tx_context_fresh_id_cost_base: Option<u64>,
1607 tx_context_sender_cost_base: Option<u64>,
1608 tx_context_epoch_cost_base: Option<u64>,
1609 tx_context_epoch_timestamp_ms_cost_base: Option<u64>,
1610 tx_context_sponsor_cost_base: Option<u64>,
1611 tx_context_rgp_cost_base: Option<u64>,
1612 tx_context_gas_price_cost_base: Option<u64>,
1613 tx_context_gas_budget_cost_base: Option<u64>,
1614 tx_context_ids_created_cost_base: Option<u64>,
1615 tx_context_replace_cost_base: Option<u64>,
1616
1617 types_is_one_time_witness_cost_base: Option<u64>,
1620 types_is_one_time_witness_type_tag_cost_per_byte: Option<u64>,
1621 types_is_one_time_witness_type_cost_per_byte: Option<u64>,
1622
1623 validator_validate_metadata_cost_base: Option<u64>,
1626 validator_validate_metadata_data_cost_per_byte: Option<u64>,
1627
1628 crypto_invalid_arguments_cost: Option<u64>,
1630 bls12381_bls12381_min_sig_verify_cost_base: Option<u64>,
1632 bls12381_bls12381_min_sig_verify_msg_cost_per_byte: Option<u64>,
1633 bls12381_bls12381_min_sig_verify_msg_cost_per_block: Option<u64>,
1634
1635 bls12381_bls12381_min_pk_verify_cost_base: Option<u64>,
1637 bls12381_bls12381_min_pk_verify_msg_cost_per_byte: Option<u64>,
1638 bls12381_bls12381_min_pk_verify_msg_cost_per_block: Option<u64>,
1639
1640 ecdsa_k1_ecrecover_keccak256_cost_base: Option<u64>,
1642 ecdsa_k1_ecrecover_keccak256_msg_cost_per_byte: Option<u64>,
1643 ecdsa_k1_ecrecover_keccak256_msg_cost_per_block: Option<u64>,
1644 ecdsa_k1_ecrecover_sha256_cost_base: Option<u64>,
1645 ecdsa_k1_ecrecover_sha256_msg_cost_per_byte: Option<u64>,
1646 ecdsa_k1_ecrecover_sha256_msg_cost_per_block: Option<u64>,
1647
1648 ecdsa_k1_decompress_pubkey_cost_base: Option<u64>,
1650
1651 ecdsa_k1_secp256k1_verify_keccak256_cost_base: Option<u64>,
1653 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_byte: Option<u64>,
1654 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_block: Option<u64>,
1655 ecdsa_k1_secp256k1_verify_sha256_cost_base: Option<u64>,
1656 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_byte: Option<u64>,
1657 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_block: Option<u64>,
1658
1659 ecdsa_r1_ecrecover_keccak256_cost_base: Option<u64>,
1661 ecdsa_r1_ecrecover_keccak256_msg_cost_per_byte: Option<u64>,
1662 ecdsa_r1_ecrecover_keccak256_msg_cost_per_block: Option<u64>,
1663 ecdsa_r1_ecrecover_sha256_cost_base: Option<u64>,
1664 ecdsa_r1_ecrecover_sha256_msg_cost_per_byte: Option<u64>,
1665 ecdsa_r1_ecrecover_sha256_msg_cost_per_block: Option<u64>,
1666
1667 ecdsa_r1_secp256r1_verify_keccak256_cost_base: Option<u64>,
1669 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_byte: Option<u64>,
1670 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_block: Option<u64>,
1671 ecdsa_r1_secp256r1_verify_sha256_cost_base: Option<u64>,
1672 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_byte: Option<u64>,
1673 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_block: Option<u64>,
1674
1675 ecvrf_ecvrf_verify_cost_base: Option<u64>,
1677 ecvrf_ecvrf_verify_alpha_string_cost_per_byte: Option<u64>,
1678 ecvrf_ecvrf_verify_alpha_string_cost_per_block: Option<u64>,
1679
1680 ed25519_ed25519_verify_cost_base: Option<u64>,
1682 ed25519_ed25519_verify_msg_cost_per_byte: Option<u64>,
1683 ed25519_ed25519_verify_msg_cost_per_block: Option<u64>,
1684
1685 groth16_prepare_verifying_key_bls12381_cost_base: Option<u64>,
1687 groth16_prepare_verifying_key_bn254_cost_base: Option<u64>,
1688
1689 groth16_verify_groth16_proof_internal_bls12381_cost_base: Option<u64>,
1691 groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input: Option<u64>,
1692 groth16_verify_groth16_proof_internal_bn254_cost_base: Option<u64>,
1693 groth16_verify_groth16_proof_internal_bn254_cost_per_public_input: Option<u64>,
1694 groth16_verify_groth16_proof_internal_public_input_cost_per_byte: Option<u64>,
1695
1696 hash_blake2b256_cost_base: Option<u64>,
1698 hash_blake2b256_data_cost_per_byte: Option<u64>,
1699 hash_blake2b256_data_cost_per_block: Option<u64>,
1700
1701 hash_keccak256_cost_base: Option<u64>,
1703 hash_keccak256_data_cost_per_byte: Option<u64>,
1704 hash_keccak256_data_cost_per_block: Option<u64>,
1705
1706 poseidon_bn254_cost_base: Option<u64>,
1708 poseidon_bn254_cost_per_block: Option<u64>,
1709
1710 group_ops_bls12381_decode_scalar_cost: Option<u64>,
1712 group_ops_bls12381_decode_g1_cost: Option<u64>,
1713 group_ops_bls12381_decode_g2_cost: Option<u64>,
1714 group_ops_bls12381_decode_gt_cost: Option<u64>,
1715 group_ops_bls12381_scalar_add_cost: Option<u64>,
1716 group_ops_bls12381_g1_add_cost: Option<u64>,
1717 group_ops_bls12381_g2_add_cost: Option<u64>,
1718 group_ops_bls12381_gt_add_cost: Option<u64>,
1719 group_ops_bls12381_scalar_sub_cost: Option<u64>,
1720 group_ops_bls12381_g1_sub_cost: Option<u64>,
1721 group_ops_bls12381_g2_sub_cost: Option<u64>,
1722 group_ops_bls12381_gt_sub_cost: Option<u64>,
1723 group_ops_bls12381_scalar_mul_cost: Option<u64>,
1724 group_ops_bls12381_g1_mul_cost: Option<u64>,
1725 group_ops_bls12381_g2_mul_cost: Option<u64>,
1726 group_ops_bls12381_gt_mul_cost: Option<u64>,
1727 group_ops_bls12381_scalar_div_cost: Option<u64>,
1728 group_ops_bls12381_g1_div_cost: Option<u64>,
1729 group_ops_bls12381_g2_div_cost: Option<u64>,
1730 group_ops_bls12381_gt_div_cost: Option<u64>,
1731 group_ops_bls12381_g1_hash_to_base_cost: Option<u64>,
1732 group_ops_bls12381_g2_hash_to_base_cost: Option<u64>,
1733 group_ops_bls12381_g1_hash_to_cost_per_byte: Option<u64>,
1734 group_ops_bls12381_g2_hash_to_cost_per_byte: Option<u64>,
1735 group_ops_bls12381_g1_msm_base_cost: Option<u64>,
1736 group_ops_bls12381_g2_msm_base_cost: Option<u64>,
1737 group_ops_bls12381_g1_msm_base_cost_per_input: Option<u64>,
1738 group_ops_bls12381_g2_msm_base_cost_per_input: Option<u64>,
1739 group_ops_bls12381_msm_max_len: Option<u32>,
1740 group_ops_bls12381_pairing_cost: Option<u64>,
1741 group_ops_bls12381_g1_to_uncompressed_g1_cost: Option<u64>,
1742 group_ops_bls12381_uncompressed_g1_to_g1_cost: Option<u64>,
1743 group_ops_bls12381_uncompressed_g1_sum_base_cost: Option<u64>,
1744 group_ops_bls12381_uncompressed_g1_sum_cost_per_term: Option<u64>,
1745 group_ops_bls12381_uncompressed_g1_sum_max_terms: Option<u64>,
1746
1747 group_ops_ristretto_decode_scalar_cost: Option<u64>,
1748 group_ops_ristretto_decode_point_cost: Option<u64>,
1749 group_ops_ristretto_scalar_add_cost: Option<u64>,
1750 group_ops_ristretto_point_add_cost: Option<u64>,
1751 group_ops_ristretto_scalar_sub_cost: Option<u64>,
1752 group_ops_ristretto_point_sub_cost: Option<u64>,
1753 group_ops_ristretto_scalar_mul_cost: Option<u64>,
1754 group_ops_ristretto_point_mul_cost: Option<u64>,
1755 group_ops_ristretto_scalar_div_cost: Option<u64>,
1756 group_ops_ristretto_point_div_cost: Option<u64>,
1757
1758 verify_bulletproofs_ristretto255_base_cost: Option<u64>,
1759 verify_bulletproofs_ristretto255_cost_per_bit_and_commitment: Option<u64>,
1760
1761 hmac_hmac_sha3_256_cost_base: Option<u64>,
1763 hmac_hmac_sha3_256_input_cost_per_byte: Option<u64>,
1764 hmac_hmac_sha3_256_input_cost_per_block: Option<u64>,
1765
1766 check_zklogin_id_cost_base: Option<u64>,
1768 check_zklogin_issuer_cost_base: Option<u64>,
1770
1771 vdf_verify_vdf_cost: Option<u64>,
1772 vdf_hash_to_input_cost: Option<u64>,
1773
1774 nitro_attestation_parse_base_cost: Option<u64>,
1776 nitro_attestation_parse_cost_per_byte: Option<u64>,
1777 nitro_attestation_verify_base_cost: Option<u64>,
1778 nitro_attestation_verify_cost_per_cert: Option<u64>,
1779
1780 bcs_per_byte_serialized_cost: Option<u64>,
1782 bcs_legacy_min_output_size_cost: Option<u64>,
1783 bcs_failure_cost: Option<u64>,
1784
1785 hash_sha2_256_base_cost: Option<u64>,
1786 hash_sha2_256_per_byte_cost: Option<u64>,
1787 hash_sha2_256_legacy_min_input_len_cost: Option<u64>,
1788 hash_sha3_256_base_cost: Option<u64>,
1789 hash_sha3_256_per_byte_cost: Option<u64>,
1790 hash_sha3_256_legacy_min_input_len_cost: Option<u64>,
1791 type_name_get_base_cost: Option<u64>,
1792 type_name_get_per_byte_cost: Option<u64>,
1793 type_name_id_base_cost: Option<u64>,
1794
1795 string_check_utf8_base_cost: Option<u64>,
1796 string_check_utf8_per_byte_cost: Option<u64>,
1797 string_is_char_boundary_base_cost: Option<u64>,
1798 string_sub_string_base_cost: Option<u64>,
1799 string_sub_string_per_byte_cost: Option<u64>,
1800 string_index_of_base_cost: Option<u64>,
1801 string_index_of_per_byte_pattern_cost: Option<u64>,
1802 string_index_of_per_byte_searched_cost: Option<u64>,
1803
1804 vector_empty_base_cost: Option<u64>,
1805 vector_length_base_cost: Option<u64>,
1806 vector_push_back_base_cost: Option<u64>,
1807 vector_push_back_legacy_per_abstract_memory_unit_cost: Option<u64>,
1808 vector_borrow_base_cost: Option<u64>,
1809 vector_pop_back_base_cost: Option<u64>,
1810 vector_destroy_empty_base_cost: Option<u64>,
1811 vector_swap_base_cost: Option<u64>,
1812 debug_print_base_cost: Option<u64>,
1813 debug_print_stack_trace_base_cost: Option<u64>,
1814
1815 execution_version: Option<u64>,
1824
1825 consensus_bad_nodes_stake_threshold: Option<u64>,
1829
1830 max_jwk_votes_per_validator_per_epoch: Option<u64>,
1831 max_age_of_jwk_in_epochs: Option<u64>,
1835
1836 random_beacon_reduction_allowed_delta: Option<u16>,
1840
1841 random_beacon_reduction_lower_bound: Option<u32>,
1844
1845 random_beacon_dkg_timeout_round: Option<u32>,
1848
1849 random_beacon_min_round_interval_ms: Option<u64>,
1851
1852 random_beacon_dkg_version: Option<u64>,
1855
1856 consensus_max_transaction_size_bytes: Option<u64>,
1859 consensus_max_transactions_in_block_bytes: Option<u64>,
1861 consensus_max_num_transactions_in_block: Option<u64>,
1863
1864 consensus_voting_rounds: Option<u32>,
1866
1867 max_accumulated_txn_cost_per_object_in_narwhal_commit: Option<u64>,
1869
1870 max_deferral_rounds_for_congestion_control: Option<u64>,
1873
1874 max_txn_cost_overage_per_object_in_commit: Option<u64>,
1876
1877 allowed_txn_cost_overage_burst_per_object_in_commit: Option<u64>,
1879
1880 min_checkpoint_interval_ms: Option<u64>,
1882
1883 checkpoint_summary_version_specific_data: Option<u64>,
1885
1886 max_soft_bundle_size: Option<u64>,
1888
1889 bridge_should_try_to_finalize_committee: Option<bool>,
1893
1894 max_accumulated_txn_cost_per_object_in_mysticeti_commit: Option<u64>,
1900
1901 max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit: Option<u64>,
1904
1905 consensus_gc_depth: Option<u32>,
1908
1909 gas_budget_based_txn_cost_cap_factor: Option<u64>,
1911
1912 gas_budget_based_txn_cost_absolute_cap_commit_count: Option<u64>,
1914
1915 sip_45_consensus_amplification_threshold: Option<u64>,
1918
1919 use_object_per_epoch_marker_table_v2: Option<bool>,
1922
1923 consensus_commit_rate_estimation_window_size: Option<u32>,
1925
1926 #[serde(skip_serializing_if = "Vec::is_empty")]
1930 aliased_addresses: Vec<AliasedAddress>,
1931
1932 translation_per_command_base_charge: Option<u64>,
1935
1936 translation_per_input_base_charge: Option<u64>,
1939
1940 translation_pure_input_per_byte_charge: Option<u64>,
1942
1943 translation_per_type_node_charge: Option<u64>,
1947
1948 translation_per_reference_node_charge: Option<u64>,
1951
1952 translation_per_linkage_entry_charge: Option<u64>,
1955
1956 max_updates_per_settlement_txn: Option<u32>,
1958
1959 gasless_max_computation_units: Option<u64>,
1961
1962 #[skip_accessor]
1964 gasless_allowed_token_types: Option<Vec<(String, u64)>>,
1965
1966 gasless_max_unused_inputs: Option<u64>,
1970
1971 gasless_max_pure_input_bytes: Option<u64>,
1974
1975 gasless_max_tps: Option<u64>,
1977
1978 #[serde(skip_serializing_if = "Option::is_none")]
1979 #[skip_accessor]
1980 include_special_package_amendments: Option<Arc<Amendments>>,
1981
1982 gasless_max_tx_size_bytes: Option<u64>,
1985}
1986
1987#[derive(Clone, Serialize, Deserialize, Debug)]
1989pub struct AliasedAddress {
1990 pub original: [u8; 32],
1992 pub aliased: [u8; 32],
1994 pub allowed_tx_digests: Vec<[u8; 32]>,
1996}
1997
1998impl ProtocolConfig {
2000 pub fn check_package_upgrades_supported(&self) -> Result<(), Error> {
2013 if self.feature_flags.package_upgrades {
2014 Ok(())
2015 } else {
2016 Err(Error(format!(
2017 "package upgrades are not supported at {:?}",
2018 self.version
2019 )))
2020 }
2021 }
2022
2023 pub fn allow_receiving_object_id(&self) -> bool {
2024 self.feature_flags.allow_receiving_object_id
2025 }
2026
2027 pub fn receiving_objects_supported(&self) -> bool {
2028 self.feature_flags.receive_objects
2029 }
2030
2031 pub fn package_upgrades_supported(&self) -> bool {
2032 self.feature_flags.package_upgrades
2033 }
2034
2035 pub fn check_commit_root_state_digest_supported(&self) -> bool {
2036 self.feature_flags.commit_root_state_digest
2037 }
2038
2039 pub fn get_advance_epoch_start_time_in_safe_mode(&self) -> bool {
2040 self.feature_flags.advance_epoch_start_time_in_safe_mode
2041 }
2042
2043 pub fn loaded_child_objects_fixed(&self) -> bool {
2044 self.feature_flags.loaded_child_objects_fixed
2045 }
2046
2047 pub fn missing_type_is_compatibility_error(&self) -> bool {
2048 self.feature_flags.missing_type_is_compatibility_error
2049 }
2050
2051 pub fn scoring_decision_with_validity_cutoff(&self) -> bool {
2052 self.feature_flags.scoring_decision_with_validity_cutoff
2053 }
2054
2055 pub fn narwhal_versioned_metadata(&self) -> bool {
2056 self.feature_flags.narwhal_versioned_metadata
2057 }
2058
2059 pub fn consensus_order_end_of_epoch_last(&self) -> bool {
2060 self.feature_flags.consensus_order_end_of_epoch_last
2061 }
2062
2063 pub fn disallow_adding_abilities_on_upgrade(&self) -> bool {
2064 self.feature_flags.disallow_adding_abilities_on_upgrade
2065 }
2066
2067 pub fn disable_invariant_violation_check_in_swap_loc(&self) -> bool {
2068 self.feature_flags
2069 .disable_invariant_violation_check_in_swap_loc
2070 }
2071
2072 pub fn advance_to_highest_supported_protocol_version(&self) -> bool {
2073 self.feature_flags
2074 .advance_to_highest_supported_protocol_version
2075 }
2076
2077 pub fn ban_entry_init(&self) -> bool {
2078 self.feature_flags.ban_entry_init
2079 }
2080
2081 pub fn package_digest_hash_module(&self) -> bool {
2082 self.feature_flags.package_digest_hash_module
2083 }
2084
2085 pub fn disallow_change_struct_type_params_on_upgrade(&self) -> bool {
2086 self.feature_flags
2087 .disallow_change_struct_type_params_on_upgrade
2088 }
2089
2090 pub fn no_extraneous_module_bytes(&self) -> bool {
2091 self.feature_flags.no_extraneous_module_bytes
2092 }
2093
2094 pub fn zklogin_auth(&self) -> bool {
2095 self.feature_flags.zklogin_auth
2096 }
2097
2098 pub fn zklogin_supported_providers(&self) -> &BTreeSet<String> {
2099 &self.feature_flags.zklogin_supported_providers
2100 }
2101
2102 pub fn consensus_transaction_ordering(&self) -> ConsensusTransactionOrdering {
2103 self.feature_flags.consensus_transaction_ordering
2104 }
2105
2106 pub fn simplified_unwrap_then_delete(&self) -> bool {
2107 self.feature_flags.simplified_unwrap_then_delete
2108 }
2109
2110 pub fn supports_upgraded_multisig(&self) -> bool {
2111 self.feature_flags.upgraded_multisig_supported
2112 }
2113
2114 pub fn txn_base_cost_as_multiplier(&self) -> bool {
2115 self.feature_flags.txn_base_cost_as_multiplier
2116 }
2117
2118 pub fn shared_object_deletion(&self) -> bool {
2119 self.feature_flags.shared_object_deletion
2120 }
2121
2122 pub fn narwhal_new_leader_election_schedule(&self) -> bool {
2123 self.feature_flags.narwhal_new_leader_election_schedule
2124 }
2125
2126 pub fn loaded_child_object_format(&self) -> bool {
2127 self.feature_flags.loaded_child_object_format
2128 }
2129
2130 pub fn enable_jwk_consensus_updates(&self) -> bool {
2131 let ret = self.feature_flags.enable_jwk_consensus_updates;
2132 if ret {
2133 assert!(self.feature_flags.end_of_epoch_transaction_supported);
2135 }
2136 ret
2137 }
2138
2139 pub fn simple_conservation_checks(&self) -> bool {
2140 self.feature_flags.simple_conservation_checks
2141 }
2142
2143 pub fn loaded_child_object_format_type(&self) -> bool {
2144 self.feature_flags.loaded_child_object_format_type
2145 }
2146
2147 pub fn end_of_epoch_transaction_supported(&self) -> bool {
2148 let ret = self.feature_flags.end_of_epoch_transaction_supported;
2149 if !ret {
2150 assert!(!self.feature_flags.enable_jwk_consensus_updates);
2152 }
2153 ret
2154 }
2155
2156 pub fn recompute_has_public_transfer_in_execution(&self) -> bool {
2157 self.feature_flags
2158 .recompute_has_public_transfer_in_execution
2159 }
2160
2161 pub fn create_authenticator_state_in_genesis(&self) -> bool {
2163 self.enable_jwk_consensus_updates()
2164 }
2165
2166 pub fn random_beacon(&self) -> bool {
2167 self.feature_flags.random_beacon
2168 }
2169
2170 pub fn dkg_version(&self) -> u64 {
2171 self.random_beacon_dkg_version.unwrap_or(1)
2173 }
2174
2175 pub fn enable_bridge(&self) -> bool {
2176 let ret = self.feature_flags.bridge;
2177 if ret {
2178 assert!(self.feature_flags.end_of_epoch_transaction_supported);
2180 }
2181 ret
2182 }
2183
2184 pub fn should_try_to_finalize_bridge_committee(&self) -> bool {
2185 if !self.enable_bridge() {
2186 return false;
2187 }
2188 self.bridge_should_try_to_finalize_committee.unwrap_or(true)
2190 }
2191
2192 pub fn enable_effects_v2(&self) -> bool {
2193 self.feature_flags.enable_effects_v2
2194 }
2195
2196 pub fn narwhal_certificate_v2(&self) -> bool {
2197 self.feature_flags.narwhal_certificate_v2
2198 }
2199
2200 pub fn verify_legacy_zklogin_address(&self) -> bool {
2201 self.feature_flags.verify_legacy_zklogin_address
2202 }
2203
2204 pub fn accept_zklogin_in_multisig(&self) -> bool {
2205 self.feature_flags.accept_zklogin_in_multisig
2206 }
2207
2208 pub fn accept_passkey_in_multisig(&self) -> bool {
2209 self.feature_flags.accept_passkey_in_multisig
2210 }
2211
2212 pub fn validate_zklogin_public_identifier(&self) -> bool {
2213 self.feature_flags.validate_zklogin_public_identifier
2214 }
2215
2216 pub fn zklogin_max_epoch_upper_bound_delta(&self) -> Option<u64> {
2217 self.feature_flags.zklogin_max_epoch_upper_bound_delta
2218 }
2219
2220 pub fn throughput_aware_consensus_submission(&self) -> bool {
2221 self.feature_flags.throughput_aware_consensus_submission
2222 }
2223
2224 pub fn include_consensus_digest_in_prologue(&self) -> bool {
2225 self.feature_flags.include_consensus_digest_in_prologue
2226 }
2227
2228 pub fn record_consensus_determined_version_assignments_in_prologue(&self) -> bool {
2229 self.feature_flags
2230 .record_consensus_determined_version_assignments_in_prologue
2231 }
2232
2233 pub fn record_additional_state_digest_in_prologue(&self) -> bool {
2234 self.feature_flags
2235 .record_additional_state_digest_in_prologue
2236 }
2237
2238 pub fn record_consensus_determined_version_assignments_in_prologue_v2(&self) -> bool {
2239 self.feature_flags
2240 .record_consensus_determined_version_assignments_in_prologue_v2
2241 }
2242
2243 pub fn prepend_prologue_tx_in_consensus_commit_in_checkpoints(&self) -> bool {
2244 self.feature_flags
2245 .prepend_prologue_tx_in_consensus_commit_in_checkpoints
2246 }
2247
2248 pub fn hardened_otw_check(&self) -> bool {
2249 self.feature_flags.hardened_otw_check
2250 }
2251
2252 pub fn enable_poseidon(&self) -> bool {
2253 self.feature_flags.enable_poseidon
2254 }
2255
2256 pub fn enable_coin_deny_list_v1(&self) -> bool {
2257 self.feature_flags.enable_coin_deny_list
2258 }
2259
2260 pub fn enable_accumulators(&self) -> bool {
2261 self.feature_flags.enable_accumulators
2262 }
2263
2264 pub fn enable_coin_reservation_obj_refs(&self) -> bool {
2265 self.new_vm_enabled() && self.feature_flags.enable_coin_reservation_obj_refs
2266 }
2267
2268 pub fn create_root_accumulator_object(&self) -> bool {
2269 self.feature_flags.create_root_accumulator_object
2270 }
2271
2272 pub fn enable_address_balance_gas_payments(&self) -> bool {
2273 self.feature_flags.enable_address_balance_gas_payments
2274 }
2275
2276 pub fn address_balance_gas_check_rgp_at_signing(&self) -> bool {
2277 self.feature_flags.address_balance_gas_check_rgp_at_signing
2278 }
2279
2280 pub fn address_balance_gas_reject_gas_coin_arg(&self) -> bool {
2281 self.feature_flags.address_balance_gas_reject_gas_coin_arg
2282 }
2283
2284 pub fn enable_multi_epoch_transaction_expiration(&self) -> bool {
2285 self.feature_flags.enable_multi_epoch_transaction_expiration
2286 }
2287
2288 pub fn relax_valid_during_for_owned_inputs(&self) -> bool {
2289 self.feature_flags.relax_valid_during_for_owned_inputs
2290 }
2291
2292 pub fn enable_authenticated_event_streams(&self) -> bool {
2293 self.feature_flags.enable_authenticated_event_streams && self.enable_accumulators()
2294 }
2295
2296 pub fn enable_non_exclusive_writes(&self) -> bool {
2297 self.feature_flags.enable_non_exclusive_writes
2298 }
2299
2300 pub fn enable_coin_registry(&self) -> bool {
2301 self.feature_flags.enable_coin_registry
2302 }
2303
2304 pub fn enable_display_registry(&self) -> bool {
2305 self.feature_flags.enable_display_registry
2306 }
2307
2308 pub fn enable_coin_deny_list_v2(&self) -> bool {
2309 self.feature_flags.enable_coin_deny_list_v2
2310 }
2311
2312 pub fn enable_group_ops_native_functions(&self) -> bool {
2313 self.feature_flags.enable_group_ops_native_functions
2314 }
2315
2316 pub fn enable_group_ops_native_function_msm(&self) -> bool {
2317 self.feature_flags.enable_group_ops_native_function_msm
2318 }
2319
2320 pub fn enable_ristretto255_group_ops(&self) -> bool {
2321 self.feature_flags.enable_ristretto255_group_ops
2322 }
2323
2324 pub fn enable_verify_bulletproofs_ristretto255(&self) -> bool {
2325 self.feature_flags.enable_verify_bulletproofs_ristretto255
2326 }
2327
2328 pub fn reject_mutable_random_on_entry_functions(&self) -> bool {
2329 self.feature_flags.reject_mutable_random_on_entry_functions
2330 }
2331
2332 pub fn per_object_congestion_control_mode(&self) -> PerObjectCongestionControlMode {
2333 self.feature_flags.per_object_congestion_control_mode
2334 }
2335
2336 pub fn consensus_choice(&self) -> ConsensusChoice {
2337 self.feature_flags.consensus_choice
2338 }
2339
2340 pub fn consensus_network(&self) -> ConsensusNetwork {
2341 self.feature_flags.consensus_network
2342 }
2343
2344 pub fn correct_gas_payment_limit_check(&self) -> bool {
2345 self.feature_flags.correct_gas_payment_limit_check
2346 }
2347
2348 pub fn reshare_at_same_initial_version(&self) -> bool {
2349 self.feature_flags.reshare_at_same_initial_version
2350 }
2351
2352 pub fn resolve_abort_locations_to_package_id(&self) -> bool {
2353 self.feature_flags.resolve_abort_locations_to_package_id
2354 }
2355
2356 pub fn mysticeti_use_committed_subdag_digest(&self) -> bool {
2357 self.feature_flags.mysticeti_use_committed_subdag_digest
2358 }
2359
2360 pub fn enable_vdf(&self) -> bool {
2361 self.feature_flags.enable_vdf
2362 }
2363
2364 pub fn fresh_vm_on_framework_upgrade(&self) -> bool {
2365 self.feature_flags.fresh_vm_on_framework_upgrade
2366 }
2367
2368 pub fn mysticeti_num_leaders_per_round(&self) -> Option<usize> {
2369 self.feature_flags.mysticeti_num_leaders_per_round
2370 }
2371
2372 pub fn soft_bundle(&self) -> bool {
2373 self.feature_flags.soft_bundle
2374 }
2375
2376 pub fn passkey_auth(&self) -> bool {
2377 self.feature_flags.passkey_auth
2378 }
2379
2380 pub fn authority_capabilities_v2(&self) -> bool {
2381 self.feature_flags.authority_capabilities_v2
2382 }
2383
2384 pub fn max_transaction_size_bytes(&self) -> u64 {
2385 self.consensus_max_transaction_size_bytes
2387 .unwrap_or(256 * 1024)
2388 }
2389
2390 pub fn max_transactions_in_block_bytes(&self) -> u64 {
2391 if cfg!(msim) {
2392 256 * 1024
2393 } else {
2394 self.consensus_max_transactions_in_block_bytes
2395 .unwrap_or(512 * 1024)
2396 }
2397 }
2398
2399 pub fn max_num_transactions_in_block(&self) -> u64 {
2400 if cfg!(msim) {
2401 8
2402 } else {
2403 self.consensus_max_num_transactions_in_block.unwrap_or(512)
2404 }
2405 }
2406
2407 pub fn rethrow_serialization_type_layout_errors(&self) -> bool {
2408 self.feature_flags.rethrow_serialization_type_layout_errors
2409 }
2410
2411 pub fn consensus_distributed_vote_scoring_strategy(&self) -> bool {
2412 self.feature_flags
2413 .consensus_distributed_vote_scoring_strategy
2414 }
2415
2416 pub fn consensus_round_prober(&self) -> bool {
2417 self.feature_flags.consensus_round_prober
2418 }
2419
2420 pub fn validate_identifier_inputs(&self) -> bool {
2421 self.feature_flags.validate_identifier_inputs
2422 }
2423
2424 pub fn gc_depth(&self) -> u32 {
2425 self.consensus_gc_depth.unwrap_or(0)
2426 }
2427
2428 pub fn mysticeti_fastpath(&self) -> bool {
2429 self.feature_flags.mysticeti_fastpath
2430 }
2431
2432 pub fn relocate_event_module(&self) -> bool {
2433 self.feature_flags.relocate_event_module
2434 }
2435
2436 pub fn uncompressed_g1_group_elements(&self) -> bool {
2437 self.feature_flags.uncompressed_g1_group_elements
2438 }
2439
2440 pub fn disallow_new_modules_in_deps_only_packages(&self) -> bool {
2441 self.feature_flags
2442 .disallow_new_modules_in_deps_only_packages
2443 }
2444
2445 pub fn consensus_smart_ancestor_selection(&self) -> bool {
2446 self.feature_flags.consensus_smart_ancestor_selection
2447 }
2448
2449 pub fn disable_preconsensus_locking(&self) -> bool {
2450 self.feature_flags.disable_preconsensus_locking
2451 }
2452
2453 pub fn consensus_round_prober_probe_accepted_rounds(&self) -> bool {
2454 self.feature_flags
2455 .consensus_round_prober_probe_accepted_rounds
2456 }
2457
2458 pub fn native_charging_v2(&self) -> bool {
2459 self.feature_flags.native_charging_v2
2460 }
2461
2462 pub fn consensus_linearize_subdag_v2(&self) -> bool {
2463 let res = self.feature_flags.consensus_linearize_subdag_v2;
2464 assert!(
2465 !res || self.gc_depth() > 0,
2466 "The consensus linearize sub dag V2 requires GC to be enabled"
2467 );
2468 res
2469 }
2470
2471 pub fn consensus_median_based_commit_timestamp(&self) -> bool {
2472 let res = self.feature_flags.consensus_median_based_commit_timestamp;
2473 assert!(
2474 !res || self.gc_depth() > 0,
2475 "The consensus median based commit timestamp requires GC to be enabled"
2476 );
2477 res
2478 }
2479
2480 pub fn consensus_batched_block_sync(&self) -> bool {
2481 self.feature_flags.consensus_batched_block_sync
2482 }
2483
2484 pub fn convert_type_argument_error(&self) -> bool {
2485 self.feature_flags.convert_type_argument_error
2486 }
2487
2488 pub fn variant_nodes(&self) -> bool {
2489 self.feature_flags.variant_nodes
2490 }
2491
2492 pub fn consensus_zstd_compression(&self) -> bool {
2493 self.feature_flags.consensus_zstd_compression
2494 }
2495
2496 pub fn enable_nitro_attestation(&self) -> bool {
2497 self.feature_flags.enable_nitro_attestation
2498 }
2499
2500 pub fn enable_nitro_attestation_upgraded_parsing(&self) -> bool {
2501 self.feature_flags.enable_nitro_attestation_upgraded_parsing
2502 }
2503
2504 pub fn enable_nitro_attestation_all_nonzero_pcrs_parsing(&self) -> bool {
2505 self.feature_flags
2506 .enable_nitro_attestation_all_nonzero_pcrs_parsing
2507 }
2508
2509 pub fn enable_nitro_attestation_always_include_required_pcrs_parsing(&self) -> bool {
2510 self.feature_flags
2511 .enable_nitro_attestation_always_include_required_pcrs_parsing
2512 }
2513
2514 pub fn get_consensus_commit_rate_estimation_window_size(&self) -> u32 {
2515 self.consensus_commit_rate_estimation_window_size
2516 .unwrap_or(0)
2517 }
2518
2519 pub fn consensus_num_requested_prior_commits_at_startup(&self) -> u32 {
2520 let window_size = self.get_consensus_commit_rate_estimation_window_size();
2524 assert!(window_size == 0 || self.record_additional_state_digest_in_prologue());
2526 window_size
2527 }
2528
2529 pub fn minimize_child_object_mutations(&self) -> bool {
2530 self.feature_flags.minimize_child_object_mutations
2531 }
2532
2533 pub fn move_native_context(&self) -> bool {
2534 self.feature_flags.move_native_context
2535 }
2536
2537 pub fn normalize_ptb_arguments(&self) -> bool {
2538 self.feature_flags.normalize_ptb_arguments
2539 }
2540
2541 pub fn enforce_checkpoint_timestamp_monotonicity(&self) -> bool {
2542 self.feature_flags.enforce_checkpoint_timestamp_monotonicity
2543 }
2544
2545 pub fn max_ptb_value_size_v2(&self) -> bool {
2546 self.feature_flags.max_ptb_value_size_v2
2547 }
2548
2549 pub fn resolve_type_input_ids_to_defining_id(&self) -> bool {
2550 self.feature_flags.resolve_type_input_ids_to_defining_id
2551 }
2552
2553 pub fn enable_party_transfer(&self) -> bool {
2554 self.feature_flags.enable_party_transfer
2555 }
2556
2557 pub fn allow_unbounded_system_objects(&self) -> bool {
2558 self.feature_flags.allow_unbounded_system_objects
2559 }
2560
2561 pub fn type_tags_in_object_runtime(&self) -> bool {
2562 self.feature_flags.type_tags_in_object_runtime
2563 }
2564
2565 pub fn enable_ptb_execution_v2(&self) -> bool {
2566 self.feature_flags.enable_ptb_execution_v2
2567 }
2568
2569 pub fn better_adapter_type_resolution_errors(&self) -> bool {
2570 self.feature_flags.better_adapter_type_resolution_errors
2571 }
2572
2573 pub fn record_time_estimate_processed(&self) -> bool {
2574 self.feature_flags.record_time_estimate_processed
2575 }
2576
2577 pub fn ignore_execution_time_observations_after_certs_closed(&self) -> bool {
2578 self.feature_flags
2579 .ignore_execution_time_observations_after_certs_closed
2580 }
2581
2582 pub fn dependency_linkage_error(&self) -> bool {
2583 self.feature_flags.dependency_linkage_error
2584 }
2585
2586 pub fn additional_multisig_checks(&self) -> bool {
2587 self.feature_flags.additional_multisig_checks
2588 }
2589
2590 pub fn debug_fatal_on_move_invariant_violation(&self) -> bool {
2591 self.feature_flags.debug_fatal_on_move_invariant_violation
2592 }
2593
2594 pub fn allow_private_accumulator_entrypoints(&self) -> bool {
2595 self.feature_flags.allow_private_accumulator_entrypoints
2596 }
2597
2598 pub fn additional_consensus_digest_indirect_state(&self) -> bool {
2599 self.feature_flags
2600 .additional_consensus_digest_indirect_state
2601 }
2602
2603 pub fn check_for_init_during_upgrade(&self) -> bool {
2604 self.feature_flags.check_for_init_during_upgrade
2605 }
2606
2607 pub fn per_command_shared_object_transfer_rules(&self) -> bool {
2608 self.feature_flags.per_command_shared_object_transfer_rules
2609 }
2610
2611 pub fn consensus_checkpoint_signature_key_includes_digest(&self) -> bool {
2612 self.feature_flags
2613 .consensus_checkpoint_signature_key_includes_digest
2614 }
2615
2616 pub fn include_checkpoint_artifacts_digest_in_summary(&self) -> bool {
2617 self.feature_flags
2618 .include_checkpoint_artifacts_digest_in_summary
2619 }
2620
2621 pub fn use_mfp_txns_in_load_initial_object_debts(&self) -> bool {
2622 self.feature_flags.use_mfp_txns_in_load_initial_object_debts
2623 }
2624
2625 pub fn cancel_for_failed_dkg_early(&self) -> bool {
2626 self.feature_flags.cancel_for_failed_dkg_early
2627 }
2628
2629 pub fn abstract_size_in_object_runtime(&self) -> bool {
2630 self.feature_flags.abstract_size_in_object_runtime
2631 }
2632
2633 pub fn object_runtime_charge_cache_load_gas(&self) -> bool {
2634 self.feature_flags.object_runtime_charge_cache_load_gas
2635 }
2636
2637 pub fn additional_borrow_checks(&self) -> bool {
2638 self.feature_flags.additional_borrow_checks
2639 }
2640
2641 pub fn use_new_commit_handler(&self) -> bool {
2642 self.feature_flags.use_new_commit_handler
2643 }
2644
2645 pub fn better_loader_errors(&self) -> bool {
2646 self.feature_flags.better_loader_errors
2647 }
2648
2649 pub fn generate_df_type_layouts(&self) -> bool {
2650 self.feature_flags.generate_df_type_layouts
2651 }
2652
2653 pub fn allow_references_in_ptbs(&self) -> bool {
2654 self.feature_flags.allow_references_in_ptbs
2655 }
2656
2657 pub fn private_generics_verifier_v2(&self) -> bool {
2658 self.feature_flags.private_generics_verifier_v2
2659 }
2660
2661 pub fn deprecate_global_storage_ops_during_deserialization(&self) -> bool {
2662 self.feature_flags
2663 .deprecate_global_storage_ops_during_deserialization
2664 }
2665
2666 pub fn enable_observation_chunking(&self) -> bool {
2667 matches!(self.feature_flags.per_object_congestion_control_mode,
2668 PerObjectCongestionControlMode::ExecutionTimeEstimate(ref params)
2669 if params.observations_chunk_size.is_some()
2670 )
2671 }
2672
2673 pub fn deprecate_global_storage_ops(&self) -> bool {
2674 self.feature_flags.deprecate_global_storage_ops
2675 }
2676
2677 pub fn normalize_depth_formula(&self) -> bool {
2678 self.feature_flags.normalize_depth_formula
2679 }
2680
2681 pub fn consensus_skip_gced_accept_votes(&self) -> bool {
2682 self.feature_flags.consensus_skip_gced_accept_votes
2683 }
2684
2685 pub fn include_cancelled_randomness_txns_in_prologue(&self) -> bool {
2686 self.feature_flags
2687 .include_cancelled_randomness_txns_in_prologue
2688 }
2689
2690 pub fn address_aliases(&self) -> bool {
2691 let address_aliases = self.feature_flags.address_aliases;
2692 assert!(
2693 !address_aliases || self.mysticeti_fastpath(),
2694 "Address aliases requires Mysticeti fastpath to be enabled"
2695 );
2696 if address_aliases {
2697 assert!(
2698 self.feature_flags.disable_preconsensus_locking,
2699 "Address aliases requires CertifiedTransaction to be disabled"
2700 );
2701 }
2702 address_aliases
2703 }
2704
2705 pub fn fix_checkpoint_signature_mapping(&self) -> bool {
2706 self.feature_flags.fix_checkpoint_signature_mapping
2707 }
2708
2709 pub fn enable_object_funds_withdraw(&self) -> bool {
2710 self.feature_flags.enable_object_funds_withdraw
2711 }
2712
2713 pub fn gas_rounding_halve_digits(&self) -> bool {
2714 self.feature_flags.gas_rounding_halve_digits
2715 }
2716
2717 pub fn flexible_tx_context_positions(&self) -> bool {
2718 self.feature_flags.flexible_tx_context_positions
2719 }
2720
2721 pub fn disable_entry_point_signature_check(&self) -> bool {
2722 self.feature_flags.disable_entry_point_signature_check
2723 }
2724
2725 pub fn consensus_skip_gced_blocks_in_direct_finalization(&self) -> bool {
2726 self.feature_flags
2727 .consensus_skip_gced_blocks_in_direct_finalization
2728 }
2729
2730 pub fn convert_withdrawal_compatibility_ptb_arguments(&self) -> bool {
2731 self.feature_flags
2732 .convert_withdrawal_compatibility_ptb_arguments
2733 }
2734
2735 pub fn restrict_hot_or_not_entry_functions(&self) -> bool {
2736 self.feature_flags.restrict_hot_or_not_entry_functions
2737 }
2738
2739 pub fn split_checkpoints_in_consensus_handler(&self) -> bool {
2740 self.feature_flags.split_checkpoints_in_consensus_handler
2741 }
2742
2743 pub fn consensus_always_accept_system_transactions(&self) -> bool {
2744 self.feature_flags
2745 .consensus_always_accept_system_transactions
2746 }
2747
2748 pub fn validator_metadata_verify_v2(&self) -> bool {
2749 self.feature_flags.validator_metadata_verify_v2
2750 }
2751
2752 pub fn defer_unpaid_amplification(&self) -> bool {
2753 self.feature_flags.defer_unpaid_amplification
2754 }
2755
2756 pub fn gasless_transaction_drop_safety(&self) -> bool {
2757 self.feature_flags.gasless_transaction_drop_safety
2758 }
2759
2760 pub fn new_vm_enabled(&self) -> bool {
2761 self.execution_version.is_some_and(|v| v >= 4)
2762 }
2763
2764 pub fn merge_randomness_into_checkpoint(&self) -> bool {
2765 self.feature_flags.merge_randomness_into_checkpoint
2766 }
2767
2768 pub fn use_coin_party_owner(&self) -> bool {
2769 self.feature_flags.use_coin_party_owner
2770 }
2771
2772 pub fn enable_gasless(&self) -> bool {
2773 self.feature_flags.enable_gasless
2774 }
2775
2776 pub fn gasless_verify_remaining_balance(&self) -> bool {
2777 self.feature_flags.gasless_verify_remaining_balance
2778 }
2779
2780 pub fn gasless_allowed_token_types(&self) -> &[(String, u64)] {
2781 debug_assert!(self.gasless_allowed_token_types.is_some());
2782 self.gasless_allowed_token_types.as_deref().unwrap_or(&[])
2783 }
2784
2785 pub fn get_gasless_max_unused_inputs(&self) -> u64 {
2786 self.gasless_max_unused_inputs.unwrap_or(u64::MAX)
2787 }
2788
2789 pub fn get_gasless_max_pure_input_bytes(&self) -> u64 {
2790 self.gasless_max_pure_input_bytes.unwrap_or(u64::MAX)
2791 }
2792
2793 pub fn get_gasless_max_tx_size_bytes(&self) -> u64 {
2794 self.gasless_max_tx_size_bytes.unwrap_or(u64::MAX)
2795 }
2796
2797 pub fn disallow_jump_orphans(&self) -> bool {
2798 self.feature_flags.disallow_jump_orphans
2799 }
2800
2801 pub fn early_return_receive_object_mismatched_type(&self) -> bool {
2802 self.feature_flags
2803 .early_return_receive_object_mismatched_type
2804 }
2805
2806 pub fn include_special_package_amendments_as_option(&self) -> &Option<Arc<Amendments>> {
2807 &self.include_special_package_amendments
2808 }
2809
2810 pub fn timestamp_based_epoch_close(&self) -> bool {
2811 self.feature_flags.timestamp_based_epoch_close
2812 }
2813
2814 pub fn limit_groth16_pvk_inputs(&self) -> bool {
2815 self.feature_flags.limit_groth16_pvk_inputs
2816 }
2817}
2818
2819#[cfg(not(msim))]
2820static POISON_VERSION_METHODS: AtomicBool = AtomicBool::new(false);
2821
2822#[cfg(msim)]
2824thread_local! {
2825 static POISON_VERSION_METHODS: AtomicBool = AtomicBool::new(false);
2826}
2827
2828impl ProtocolConfig {
2830 pub fn get_for_version(version: ProtocolVersion, chain: Chain) -> Self {
2832 assert!(
2834 version >= ProtocolVersion::MIN,
2835 "Network protocol version is {:?}, but the minimum supported version by the binary is {:?}. Please upgrade the binary.",
2836 version,
2837 ProtocolVersion::MIN.0,
2838 );
2839 assert!(
2840 version <= ProtocolVersion::MAX_ALLOWED,
2841 "Network protocol version is {:?}, but the maximum supported version by the binary is {:?}. Please upgrade the binary.",
2842 version,
2843 ProtocolVersion::MAX_ALLOWED.0,
2844 );
2845
2846 let mut ret = Self::get_for_version_impl(version, chain);
2847 ret.version = version;
2848
2849 ret = Self::apply_config_override(version, ret);
2850
2851 if std::env::var("SUI_PROTOCOL_CONFIG_OVERRIDE_ENABLE").is_ok() {
2852 warn!(
2853 "overriding ProtocolConfig settings with custom settings; this may break non-local networks"
2854 );
2855 let overrides: ProtocolConfigOptional =
2856 serde_env::from_env_with_prefix("SUI_PROTOCOL_CONFIG_OVERRIDE")
2857 .expect("failed to parse ProtocolConfig override env variables");
2858 overrides.apply_to(&mut ret);
2859 }
2860
2861 ret
2862 }
2863
2864 pub fn get_for_version_if_supported(version: ProtocolVersion, chain: Chain) -> Option<Self> {
2867 if version.0 >= ProtocolVersion::MIN.0 && version.0 <= ProtocolVersion::MAX_ALLOWED.0 {
2868 let mut ret = Self::get_for_version_impl(version, chain);
2869 ret.version = version;
2870 ret = Self::apply_config_override(version, ret);
2871 Some(ret)
2872 } else {
2873 None
2874 }
2875 }
2876
2877 #[cfg(not(msim))]
2878 pub fn poison_get_for_min_version() {
2879 POISON_VERSION_METHODS.store(true, Ordering::Relaxed);
2880 }
2881
2882 #[cfg(not(msim))]
2883 fn load_poison_get_for_min_version() -> bool {
2884 POISON_VERSION_METHODS.load(Ordering::Relaxed)
2885 }
2886
2887 #[cfg(msim)]
2888 pub fn poison_get_for_min_version() {
2889 POISON_VERSION_METHODS.with(|p| p.store(true, Ordering::Relaxed));
2890 }
2891
2892 #[cfg(msim)]
2893 fn load_poison_get_for_min_version() -> bool {
2894 POISON_VERSION_METHODS.with(|p| p.load(Ordering::Relaxed))
2895 }
2896
2897 pub fn get_for_min_version() -> Self {
2900 if Self::load_poison_get_for_min_version() {
2901 panic!("get_for_min_version called on validator");
2902 }
2903 ProtocolConfig::get_for_version(ProtocolVersion::MIN, Chain::Unknown)
2904 }
2905
2906 #[allow(non_snake_case)]
2916 pub fn get_for_max_version_UNSAFE() -> Self {
2917 if Self::load_poison_get_for_min_version() {
2918 panic!("get_for_max_version_UNSAFE called on validator");
2919 }
2920 ProtocolConfig::get_for_version(ProtocolVersion::MAX, Chain::Unknown)
2921 }
2922
2923 fn get_for_version_impl(version: ProtocolVersion, chain: Chain) -> Self {
2924 #[cfg(msim)]
2925 {
2926 if version == ProtocolVersion::MAX_ALLOWED {
2928 let mut config = Self::get_for_version_impl(version - 1, Chain::Unknown);
2929 config.base_tx_cost_fixed = Some(config.base_tx_cost_fixed() + 1000);
2930 return config;
2931 }
2932 }
2933
2934 let mut cfg = Self {
2937 version,
2939
2940 feature_flags: Default::default(),
2942
2943 max_tx_size_bytes: Some(128 * 1024),
2944 max_input_objects: Some(2048),
2946 max_serialized_tx_effects_size_bytes: Some(512 * 1024),
2947 max_serialized_tx_effects_size_bytes_system_tx: Some(512 * 1024 * 16),
2948 max_gas_payment_objects: Some(256),
2949 max_modules_in_publish: Some(128),
2950 max_package_dependencies: None,
2951 max_arguments: Some(512),
2952 max_type_arguments: Some(16),
2953 max_type_argument_depth: Some(16),
2954 max_pure_argument_size: Some(16 * 1024),
2955 max_programmable_tx_commands: Some(1024),
2956 move_binary_format_version: Some(6),
2957 min_move_binary_format_version: None,
2958 binary_module_handles: None,
2959 binary_struct_handles: None,
2960 binary_function_handles: None,
2961 binary_function_instantiations: None,
2962 binary_signatures: None,
2963 binary_constant_pool: None,
2964 binary_identifiers: None,
2965 binary_address_identifiers: None,
2966 binary_struct_defs: None,
2967 binary_struct_def_instantiations: None,
2968 binary_function_defs: None,
2969 binary_field_handles: None,
2970 binary_field_instantiations: None,
2971 binary_friend_decls: None,
2972 binary_enum_defs: None,
2973 binary_enum_def_instantiations: None,
2974 binary_variant_handles: None,
2975 binary_variant_instantiation_handles: None,
2976 max_move_object_size: Some(250 * 1024),
2977 max_move_package_size: Some(100 * 1024),
2978 max_publish_or_upgrade_per_ptb: None,
2979 max_tx_gas: Some(10_000_000_000),
2980 max_gas_price: Some(100_000),
2981 max_gas_price_rgp_factor_for_aborted_transactions: None,
2982 max_gas_computation_bucket: Some(5_000_000),
2983 max_loop_depth: Some(5),
2984 max_generic_instantiation_length: Some(32),
2985 max_function_parameters: Some(128),
2986 max_basic_blocks: Some(1024),
2987 max_value_stack_size: Some(1024),
2988 max_type_nodes: Some(256),
2989 max_push_size: Some(10000),
2990 max_struct_definitions: Some(200),
2991 max_function_definitions: Some(1000),
2992 max_fields_in_struct: Some(32),
2993 max_dependency_depth: Some(100),
2994 max_num_event_emit: Some(256),
2995 max_num_new_move_object_ids: Some(2048),
2996 max_num_new_move_object_ids_system_tx: Some(2048 * 16),
2997 max_num_deleted_move_object_ids: Some(2048),
2998 max_num_deleted_move_object_ids_system_tx: Some(2048 * 16),
2999 max_num_transferred_move_object_ids: Some(2048),
3000 max_num_transferred_move_object_ids_system_tx: Some(2048 * 16),
3001 max_event_emit_size: Some(250 * 1024),
3002 max_move_vector_len: Some(256 * 1024),
3003 max_type_to_layout_nodes: None,
3004 max_ptb_value_size: None,
3005
3006 max_back_edges_per_function: Some(10_000),
3007 max_back_edges_per_module: Some(10_000),
3008 max_verifier_meter_ticks_per_function: Some(6_000_000),
3009 max_meter_ticks_per_module: Some(6_000_000),
3010 max_meter_ticks_per_package: None,
3011
3012 object_runtime_max_num_cached_objects: Some(1000),
3013 object_runtime_max_num_cached_objects_system_tx: Some(1000 * 16),
3014 object_runtime_max_num_store_entries: Some(1000),
3015 object_runtime_max_num_store_entries_system_tx: Some(1000 * 16),
3016 base_tx_cost_fixed: Some(110_000),
3017 package_publish_cost_fixed: Some(1_000),
3018 base_tx_cost_per_byte: Some(0),
3019 package_publish_cost_per_byte: Some(80),
3020 obj_access_cost_read_per_byte: Some(15),
3021 obj_access_cost_mutate_per_byte: Some(40),
3022 obj_access_cost_delete_per_byte: Some(40),
3023 obj_access_cost_verify_per_byte: Some(200),
3024 obj_data_cost_refundable: Some(100),
3025 obj_metadata_cost_non_refundable: Some(50),
3026 gas_model_version: Some(1),
3027 storage_rebate_rate: Some(9900),
3028 storage_fund_reinvest_rate: Some(500),
3029 reward_slashing_rate: Some(5000),
3030 storage_gas_price: Some(1),
3031 accumulator_object_storage_cost: None,
3032 max_transactions_per_checkpoint: Some(10_000),
3033 max_checkpoint_size_bytes: Some(30 * 1024 * 1024),
3034
3035 buffer_stake_for_protocol_upgrade_bps: Some(0),
3038
3039 address_from_bytes_cost_base: Some(52),
3043 address_to_u256_cost_base: Some(52),
3045 address_from_u256_cost_base: Some(52),
3047
3048 config_read_setting_impl_cost_base: None,
3051 config_read_setting_impl_cost_per_byte: None,
3052
3053 dynamic_field_hash_type_and_key_cost_base: Some(100),
3056 dynamic_field_hash_type_and_key_type_cost_per_byte: Some(2),
3057 dynamic_field_hash_type_and_key_value_cost_per_byte: Some(2),
3058 dynamic_field_hash_type_and_key_type_tag_cost_per_byte: Some(2),
3059 dynamic_field_add_child_object_cost_base: Some(100),
3061 dynamic_field_add_child_object_type_cost_per_byte: Some(10),
3062 dynamic_field_add_child_object_value_cost_per_byte: Some(10),
3063 dynamic_field_add_child_object_struct_tag_cost_per_byte: Some(10),
3064 dynamic_field_borrow_child_object_cost_base: Some(100),
3066 dynamic_field_borrow_child_object_child_ref_cost_per_byte: Some(10),
3067 dynamic_field_borrow_child_object_type_cost_per_byte: Some(10),
3068 dynamic_field_remove_child_object_cost_base: Some(100),
3070 dynamic_field_remove_child_object_child_cost_per_byte: Some(2),
3071 dynamic_field_remove_child_object_type_cost_per_byte: Some(2),
3072 dynamic_field_has_child_object_cost_base: Some(100),
3074 dynamic_field_has_child_object_with_ty_cost_base: Some(100),
3076 dynamic_field_has_child_object_with_ty_type_cost_per_byte: Some(2),
3077 dynamic_field_has_child_object_with_ty_type_tag_cost_per_byte: Some(2),
3078
3079 event_emit_cost_base: Some(52),
3082 event_emit_value_size_derivation_cost_per_byte: Some(2),
3083 event_emit_tag_size_derivation_cost_per_byte: Some(5),
3084 event_emit_output_cost_per_byte: Some(10),
3085 event_emit_auth_stream_cost: None,
3086
3087 object_borrow_uid_cost_base: Some(52),
3090 object_delete_impl_cost_base: Some(52),
3092 object_record_new_uid_cost_base: Some(52),
3094
3095 transfer_transfer_internal_cost_base: Some(52),
3098 transfer_party_transfer_internal_cost_base: None,
3100 transfer_freeze_object_cost_base: Some(52),
3102 transfer_share_object_cost_base: Some(52),
3104 transfer_receive_object_cost_base: None,
3105 transfer_receive_object_type_cost_per_byte: None,
3106 transfer_receive_object_cost_per_byte: None,
3107
3108 tx_context_derive_id_cost_base: Some(52),
3111 tx_context_fresh_id_cost_base: None,
3112 tx_context_sender_cost_base: None,
3113 tx_context_epoch_cost_base: None,
3114 tx_context_epoch_timestamp_ms_cost_base: None,
3115 tx_context_sponsor_cost_base: None,
3116 tx_context_rgp_cost_base: None,
3117 tx_context_gas_price_cost_base: None,
3118 tx_context_gas_budget_cost_base: None,
3119 tx_context_ids_created_cost_base: None,
3120 tx_context_replace_cost_base: None,
3121
3122 types_is_one_time_witness_cost_base: Some(52),
3125 types_is_one_time_witness_type_tag_cost_per_byte: Some(2),
3126 types_is_one_time_witness_type_cost_per_byte: Some(2),
3127
3128 validator_validate_metadata_cost_base: Some(52),
3131 validator_validate_metadata_data_cost_per_byte: Some(2),
3132
3133 crypto_invalid_arguments_cost: Some(100),
3135 bls12381_bls12381_min_sig_verify_cost_base: Some(52),
3137 bls12381_bls12381_min_sig_verify_msg_cost_per_byte: Some(2),
3138 bls12381_bls12381_min_sig_verify_msg_cost_per_block: Some(2),
3139
3140 bls12381_bls12381_min_pk_verify_cost_base: Some(52),
3142 bls12381_bls12381_min_pk_verify_msg_cost_per_byte: Some(2),
3143 bls12381_bls12381_min_pk_verify_msg_cost_per_block: Some(2),
3144
3145 ecdsa_k1_ecrecover_keccak256_cost_base: Some(52),
3147 ecdsa_k1_ecrecover_keccak256_msg_cost_per_byte: Some(2),
3148 ecdsa_k1_ecrecover_keccak256_msg_cost_per_block: Some(2),
3149 ecdsa_k1_ecrecover_sha256_cost_base: Some(52),
3150 ecdsa_k1_ecrecover_sha256_msg_cost_per_byte: Some(2),
3151 ecdsa_k1_ecrecover_sha256_msg_cost_per_block: Some(2),
3152
3153 ecdsa_k1_decompress_pubkey_cost_base: Some(52),
3155
3156 ecdsa_k1_secp256k1_verify_keccak256_cost_base: Some(52),
3158 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_byte: Some(2),
3159 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_block: Some(2),
3160 ecdsa_k1_secp256k1_verify_sha256_cost_base: Some(52),
3161 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_byte: Some(2),
3162 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_block: Some(2),
3163
3164 ecdsa_r1_ecrecover_keccak256_cost_base: Some(52),
3166 ecdsa_r1_ecrecover_keccak256_msg_cost_per_byte: Some(2),
3167 ecdsa_r1_ecrecover_keccak256_msg_cost_per_block: Some(2),
3168 ecdsa_r1_ecrecover_sha256_cost_base: Some(52),
3169 ecdsa_r1_ecrecover_sha256_msg_cost_per_byte: Some(2),
3170 ecdsa_r1_ecrecover_sha256_msg_cost_per_block: Some(2),
3171
3172 ecdsa_r1_secp256r1_verify_keccak256_cost_base: Some(52),
3174 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_byte: Some(2),
3175 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_block: Some(2),
3176 ecdsa_r1_secp256r1_verify_sha256_cost_base: Some(52),
3177 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_byte: Some(2),
3178 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_block: Some(2),
3179
3180 ecvrf_ecvrf_verify_cost_base: Some(52),
3182 ecvrf_ecvrf_verify_alpha_string_cost_per_byte: Some(2),
3183 ecvrf_ecvrf_verify_alpha_string_cost_per_block: Some(2),
3184
3185 ed25519_ed25519_verify_cost_base: Some(52),
3187 ed25519_ed25519_verify_msg_cost_per_byte: Some(2),
3188 ed25519_ed25519_verify_msg_cost_per_block: Some(2),
3189
3190 groth16_prepare_verifying_key_bls12381_cost_base: Some(52),
3192 groth16_prepare_verifying_key_bn254_cost_base: Some(52),
3193
3194 groth16_verify_groth16_proof_internal_bls12381_cost_base: Some(52),
3196 groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input: Some(2),
3197 groth16_verify_groth16_proof_internal_bn254_cost_base: Some(52),
3198 groth16_verify_groth16_proof_internal_bn254_cost_per_public_input: Some(2),
3199 groth16_verify_groth16_proof_internal_public_input_cost_per_byte: Some(2),
3200
3201 hash_blake2b256_cost_base: Some(52),
3203 hash_blake2b256_data_cost_per_byte: Some(2),
3204 hash_blake2b256_data_cost_per_block: Some(2),
3205
3206 hash_keccak256_cost_base: Some(52),
3208 hash_keccak256_data_cost_per_byte: Some(2),
3209 hash_keccak256_data_cost_per_block: Some(2),
3210
3211 poseidon_bn254_cost_base: None,
3212 poseidon_bn254_cost_per_block: None,
3213
3214 hmac_hmac_sha3_256_cost_base: Some(52),
3216 hmac_hmac_sha3_256_input_cost_per_byte: Some(2),
3217 hmac_hmac_sha3_256_input_cost_per_block: Some(2),
3218
3219 group_ops_bls12381_decode_scalar_cost: None,
3221 group_ops_bls12381_decode_g1_cost: None,
3222 group_ops_bls12381_decode_g2_cost: None,
3223 group_ops_bls12381_decode_gt_cost: None,
3224 group_ops_bls12381_scalar_add_cost: None,
3225 group_ops_bls12381_g1_add_cost: None,
3226 group_ops_bls12381_g2_add_cost: None,
3227 group_ops_bls12381_gt_add_cost: None,
3228 group_ops_bls12381_scalar_sub_cost: None,
3229 group_ops_bls12381_g1_sub_cost: None,
3230 group_ops_bls12381_g2_sub_cost: None,
3231 group_ops_bls12381_gt_sub_cost: None,
3232 group_ops_bls12381_scalar_mul_cost: None,
3233 group_ops_bls12381_g1_mul_cost: None,
3234 group_ops_bls12381_g2_mul_cost: None,
3235 group_ops_bls12381_gt_mul_cost: None,
3236 group_ops_bls12381_scalar_div_cost: None,
3237 group_ops_bls12381_g1_div_cost: None,
3238 group_ops_bls12381_g2_div_cost: None,
3239 group_ops_bls12381_gt_div_cost: None,
3240 group_ops_bls12381_g1_hash_to_base_cost: None,
3241 group_ops_bls12381_g2_hash_to_base_cost: None,
3242 group_ops_bls12381_g1_hash_to_cost_per_byte: None,
3243 group_ops_bls12381_g2_hash_to_cost_per_byte: None,
3244 group_ops_bls12381_g1_msm_base_cost: None,
3245 group_ops_bls12381_g2_msm_base_cost: None,
3246 group_ops_bls12381_g1_msm_base_cost_per_input: None,
3247 group_ops_bls12381_g2_msm_base_cost_per_input: None,
3248 group_ops_bls12381_msm_max_len: None,
3249 group_ops_bls12381_pairing_cost: None,
3250 group_ops_bls12381_g1_to_uncompressed_g1_cost: None,
3251 group_ops_bls12381_uncompressed_g1_to_g1_cost: None,
3252 group_ops_bls12381_uncompressed_g1_sum_base_cost: None,
3253 group_ops_bls12381_uncompressed_g1_sum_cost_per_term: None,
3254 group_ops_bls12381_uncompressed_g1_sum_max_terms: None,
3255
3256 group_ops_ristretto_decode_scalar_cost: None,
3257 group_ops_ristretto_decode_point_cost: None,
3258 group_ops_ristretto_scalar_add_cost: None,
3259 group_ops_ristretto_point_add_cost: None,
3260 group_ops_ristretto_scalar_sub_cost: None,
3261 group_ops_ristretto_point_sub_cost: None,
3262 group_ops_ristretto_scalar_mul_cost: None,
3263 group_ops_ristretto_point_mul_cost: None,
3264 group_ops_ristretto_scalar_div_cost: None,
3265 group_ops_ristretto_point_div_cost: None,
3266
3267 verify_bulletproofs_ristretto255_base_cost: None,
3268 verify_bulletproofs_ristretto255_cost_per_bit_and_commitment: None,
3269
3270 check_zklogin_id_cost_base: None,
3272 check_zklogin_issuer_cost_base: None,
3274
3275 vdf_verify_vdf_cost: None,
3276 vdf_hash_to_input_cost: None,
3277
3278 nitro_attestation_parse_base_cost: None,
3280 nitro_attestation_parse_cost_per_byte: None,
3281 nitro_attestation_verify_base_cost: None,
3282 nitro_attestation_verify_cost_per_cert: None,
3283
3284 bcs_per_byte_serialized_cost: None,
3285 bcs_legacy_min_output_size_cost: None,
3286 bcs_failure_cost: None,
3287 hash_sha2_256_base_cost: None,
3288 hash_sha2_256_per_byte_cost: None,
3289 hash_sha2_256_legacy_min_input_len_cost: None,
3290 hash_sha3_256_base_cost: None,
3291 hash_sha3_256_per_byte_cost: None,
3292 hash_sha3_256_legacy_min_input_len_cost: None,
3293 type_name_get_base_cost: None,
3294 type_name_get_per_byte_cost: None,
3295 type_name_id_base_cost: None,
3296 string_check_utf8_base_cost: None,
3297 string_check_utf8_per_byte_cost: None,
3298 string_is_char_boundary_base_cost: None,
3299 string_sub_string_base_cost: None,
3300 string_sub_string_per_byte_cost: None,
3301 string_index_of_base_cost: None,
3302 string_index_of_per_byte_pattern_cost: None,
3303 string_index_of_per_byte_searched_cost: None,
3304 vector_empty_base_cost: None,
3305 vector_length_base_cost: None,
3306 vector_push_back_base_cost: None,
3307 vector_push_back_legacy_per_abstract_memory_unit_cost: None,
3308 vector_borrow_base_cost: None,
3309 vector_pop_back_base_cost: None,
3310 vector_destroy_empty_base_cost: None,
3311 vector_swap_base_cost: None,
3312 debug_print_base_cost: None,
3313 debug_print_stack_trace_base_cost: None,
3314
3315 max_size_written_objects: None,
3316 max_size_written_objects_system_tx: None,
3317
3318 max_move_identifier_len: None,
3325 max_move_value_depth: None,
3326 max_move_enum_variants: None,
3327
3328 gas_rounding_step: None,
3329
3330 execution_version: None,
3331
3332 max_event_emit_size_total: None,
3333
3334 consensus_bad_nodes_stake_threshold: None,
3335
3336 max_jwk_votes_per_validator_per_epoch: None,
3337
3338 max_age_of_jwk_in_epochs: None,
3339
3340 random_beacon_reduction_allowed_delta: None,
3341
3342 random_beacon_reduction_lower_bound: None,
3343
3344 random_beacon_dkg_timeout_round: None,
3345
3346 random_beacon_min_round_interval_ms: None,
3347
3348 random_beacon_dkg_version: None,
3349
3350 consensus_max_transaction_size_bytes: None,
3351
3352 consensus_max_transactions_in_block_bytes: None,
3353
3354 consensus_max_num_transactions_in_block: None,
3355
3356 consensus_voting_rounds: None,
3357
3358 max_accumulated_txn_cost_per_object_in_narwhal_commit: None,
3359
3360 max_deferral_rounds_for_congestion_control: None,
3361
3362 max_txn_cost_overage_per_object_in_commit: None,
3363
3364 allowed_txn_cost_overage_burst_per_object_in_commit: None,
3365
3366 min_checkpoint_interval_ms: None,
3367
3368 checkpoint_summary_version_specific_data: None,
3369
3370 max_soft_bundle_size: None,
3371
3372 bridge_should_try_to_finalize_committee: None,
3373
3374 max_accumulated_txn_cost_per_object_in_mysticeti_commit: None,
3375
3376 max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit: None,
3377
3378 consensus_gc_depth: None,
3379
3380 gas_budget_based_txn_cost_cap_factor: None,
3381
3382 gas_budget_based_txn_cost_absolute_cap_commit_count: None,
3383
3384 sip_45_consensus_amplification_threshold: None,
3385
3386 use_object_per_epoch_marker_table_v2: None,
3387
3388 consensus_commit_rate_estimation_window_size: None,
3389
3390 aliased_addresses: vec![],
3391
3392 translation_per_command_base_charge: None,
3393 translation_per_input_base_charge: None,
3394 translation_pure_input_per_byte_charge: None,
3395 translation_per_type_node_charge: None,
3396 translation_per_reference_node_charge: None,
3397 translation_per_linkage_entry_charge: None,
3398
3399 max_updates_per_settlement_txn: None,
3400
3401 gasless_max_computation_units: None,
3402 gasless_allowed_token_types: None,
3403 gasless_max_unused_inputs: None,
3404 gasless_max_pure_input_bytes: None,
3405 gasless_max_tps: None,
3406 include_special_package_amendments: None,
3407 gasless_max_tx_size_bytes: None,
3408 };
3411 for cur in 2..=version.0 {
3412 match cur {
3413 1 => unreachable!(),
3414 2 => {
3415 cfg.feature_flags.advance_epoch_start_time_in_safe_mode = true;
3416 }
3417 3 => {
3418 cfg.gas_model_version = Some(2);
3420 cfg.max_tx_gas = Some(50_000_000_000);
3422 cfg.base_tx_cost_fixed = Some(2_000);
3424 cfg.storage_gas_price = Some(76);
3426 cfg.feature_flags.loaded_child_objects_fixed = true;
3427 cfg.max_size_written_objects = Some(5 * 1000 * 1000);
3430 cfg.max_size_written_objects_system_tx = Some(50 * 1000 * 1000);
3433 cfg.feature_flags.package_upgrades = true;
3434 }
3435 4 => {
3440 cfg.reward_slashing_rate = Some(10000);
3442 cfg.gas_model_version = Some(3);
3444 }
3445 5 => {
3446 cfg.feature_flags.missing_type_is_compatibility_error = true;
3447 cfg.gas_model_version = Some(4);
3448 cfg.feature_flags.scoring_decision_with_validity_cutoff = true;
3449 }
3453 6 => {
3454 cfg.gas_model_version = Some(5);
3455 cfg.buffer_stake_for_protocol_upgrade_bps = Some(5000);
3456 cfg.feature_flags.consensus_order_end_of_epoch_last = true;
3457 }
3458 7 => {
3459 cfg.feature_flags.disallow_adding_abilities_on_upgrade = true;
3460 cfg.feature_flags
3461 .disable_invariant_violation_check_in_swap_loc = true;
3462 cfg.feature_flags.ban_entry_init = true;
3463 cfg.feature_flags.package_digest_hash_module = true;
3464 }
3465 8 => {
3466 cfg.feature_flags
3467 .disallow_change_struct_type_params_on_upgrade = true;
3468 }
3469 9 => {
3470 cfg.max_move_identifier_len = Some(128);
3472 cfg.feature_flags.no_extraneous_module_bytes = true;
3473 cfg.feature_flags
3474 .advance_to_highest_supported_protocol_version = true;
3475 }
3476 10 => {
3477 cfg.max_verifier_meter_ticks_per_function = Some(16_000_000);
3478 cfg.max_meter_ticks_per_module = Some(16_000_000);
3479 }
3480 11 => {
3481 cfg.max_move_value_depth = Some(128);
3482 }
3483 12 => {
3484 cfg.feature_flags.narwhal_versioned_metadata = true;
3485 if chain != Chain::Mainnet {
3486 cfg.feature_flags.commit_root_state_digest = true;
3487 }
3488
3489 if chain != Chain::Mainnet && chain != Chain::Testnet {
3490 cfg.feature_flags.zklogin_auth = true;
3491 }
3492 }
3493 13 => {}
3494 14 => {
3495 cfg.gas_rounding_step = Some(1_000);
3496 cfg.gas_model_version = Some(6);
3497 }
3498 15 => {
3499 cfg.feature_flags.consensus_transaction_ordering =
3500 ConsensusTransactionOrdering::ByGasPrice;
3501 }
3502 16 => {
3503 cfg.feature_flags.simplified_unwrap_then_delete = true;
3504 }
3505 17 => {
3506 cfg.feature_flags.upgraded_multisig_supported = true;
3507 }
3508 18 => {
3509 cfg.execution_version = Some(1);
3510 cfg.feature_flags.txn_base_cost_as_multiplier = true;
3519 cfg.base_tx_cost_fixed = Some(1_000);
3521 }
3522 19 => {
3523 cfg.max_num_event_emit = Some(1024);
3524 cfg.max_event_emit_size_total = Some(
3527 256 * 250 * 1024, );
3529 }
3530 20 => {
3531 cfg.feature_flags.commit_root_state_digest = true;
3532
3533 if chain != Chain::Mainnet {
3534 cfg.feature_flags.narwhal_new_leader_election_schedule = true;
3535 cfg.consensus_bad_nodes_stake_threshold = Some(20);
3536 }
3537 }
3538
3539 21 => {
3540 if chain != Chain::Mainnet {
3541 cfg.feature_flags.zklogin_supported_providers = BTreeSet::from([
3542 "Google".to_string(),
3543 "Facebook".to_string(),
3544 "Twitch".to_string(),
3545 ]);
3546 }
3547 }
3548 22 => {
3549 cfg.feature_flags.loaded_child_object_format = true;
3550 }
3551 23 => {
3552 cfg.feature_flags.loaded_child_object_format_type = true;
3553 cfg.feature_flags.narwhal_new_leader_election_schedule = true;
3554 cfg.consensus_bad_nodes_stake_threshold = Some(20);
3560 }
3561 24 => {
3562 cfg.feature_flags.simple_conservation_checks = true;
3563 cfg.max_publish_or_upgrade_per_ptb = Some(5);
3564
3565 cfg.feature_flags.end_of_epoch_transaction_supported = true;
3566
3567 if chain != Chain::Mainnet {
3568 cfg.feature_flags.enable_jwk_consensus_updates = true;
3569 cfg.max_jwk_votes_per_validator_per_epoch = Some(240);
3571 cfg.max_age_of_jwk_in_epochs = Some(1);
3572 }
3573 }
3574 25 => {
3575 cfg.feature_flags.zklogin_supported_providers = BTreeSet::from([
3577 "Google".to_string(),
3578 "Facebook".to_string(),
3579 "Twitch".to_string(),
3580 ]);
3581 cfg.feature_flags.zklogin_auth = true;
3582
3583 cfg.feature_flags.enable_jwk_consensus_updates = true;
3585 cfg.max_jwk_votes_per_validator_per_epoch = Some(240);
3586 cfg.max_age_of_jwk_in_epochs = Some(1);
3587 }
3588 26 => {
3589 cfg.gas_model_version = Some(7);
3590 if chain != Chain::Mainnet && chain != Chain::Testnet {
3592 cfg.transfer_receive_object_cost_base = Some(52);
3593 cfg.feature_flags.receive_objects = true;
3594 }
3595 }
3596 27 => {
3597 cfg.gas_model_version = Some(8);
3598 }
3599 28 => {
3600 cfg.check_zklogin_id_cost_base = Some(200);
3602 cfg.check_zklogin_issuer_cost_base = Some(200);
3604
3605 if chain != Chain::Mainnet && chain != Chain::Testnet {
3607 cfg.feature_flags.enable_effects_v2 = true;
3608 }
3609 }
3610 29 => {
3611 cfg.feature_flags.verify_legacy_zklogin_address = true;
3612 }
3613 30 => {
3614 if chain != Chain::Mainnet {
3616 cfg.feature_flags.narwhal_certificate_v2 = true;
3617 }
3618
3619 cfg.random_beacon_reduction_allowed_delta = Some(800);
3620 if chain != Chain::Mainnet {
3622 cfg.feature_flags.enable_effects_v2 = true;
3623 }
3624
3625 cfg.feature_flags.zklogin_supported_providers = BTreeSet::default();
3629
3630 cfg.feature_flags.recompute_has_public_transfer_in_execution = true;
3631 }
3632 31 => {
3633 cfg.execution_version = Some(2);
3634 if chain != Chain::Mainnet && chain != Chain::Testnet {
3636 cfg.feature_flags.shared_object_deletion = true;
3637 }
3638 }
3639 32 => {
3640 if chain != Chain::Mainnet {
3642 cfg.feature_flags.accept_zklogin_in_multisig = true;
3643 }
3644 if chain != Chain::Mainnet {
3646 cfg.transfer_receive_object_cost_base = Some(52);
3647 cfg.feature_flags.receive_objects = true;
3648 }
3649 if chain != Chain::Mainnet && chain != Chain::Testnet {
3651 cfg.feature_flags.random_beacon = true;
3652 cfg.random_beacon_reduction_lower_bound = Some(1600);
3653 cfg.random_beacon_dkg_timeout_round = Some(3000);
3654 cfg.random_beacon_min_round_interval_ms = Some(150);
3655 }
3656 if chain != Chain::Testnet && chain != Chain::Mainnet {
3658 cfg.feature_flags.include_consensus_digest_in_prologue = true;
3659 }
3660
3661 cfg.feature_flags.narwhal_certificate_v2 = true;
3663 }
3664 33 => {
3665 cfg.feature_flags.hardened_otw_check = true;
3666 cfg.feature_flags.allow_receiving_object_id = true;
3667
3668 cfg.transfer_receive_object_cost_base = Some(52);
3670 cfg.feature_flags.receive_objects = true;
3671
3672 if chain != Chain::Mainnet {
3674 cfg.feature_flags.shared_object_deletion = true;
3675 }
3676
3677 cfg.feature_flags.enable_effects_v2 = true;
3678 }
3679 34 => {}
3680 35 => {
3681 if chain != Chain::Mainnet && chain != Chain::Testnet {
3683 cfg.feature_flags.enable_poseidon = true;
3684 cfg.poseidon_bn254_cost_base = Some(260);
3685 cfg.poseidon_bn254_cost_per_block = Some(10);
3686 }
3687
3688 cfg.feature_flags.enable_coin_deny_list = true;
3689 }
3690 36 => {
3691 if chain != Chain::Mainnet && chain != Chain::Testnet {
3693 cfg.feature_flags.enable_group_ops_native_functions = true;
3694 cfg.feature_flags.enable_group_ops_native_function_msm = true;
3695 cfg.group_ops_bls12381_decode_scalar_cost = Some(52);
3697 cfg.group_ops_bls12381_decode_g1_cost = Some(52);
3698 cfg.group_ops_bls12381_decode_g2_cost = Some(52);
3699 cfg.group_ops_bls12381_decode_gt_cost = Some(52);
3700 cfg.group_ops_bls12381_scalar_add_cost = Some(52);
3701 cfg.group_ops_bls12381_g1_add_cost = Some(52);
3702 cfg.group_ops_bls12381_g2_add_cost = Some(52);
3703 cfg.group_ops_bls12381_gt_add_cost = Some(52);
3704 cfg.group_ops_bls12381_scalar_sub_cost = Some(52);
3705 cfg.group_ops_bls12381_g1_sub_cost = Some(52);
3706 cfg.group_ops_bls12381_g2_sub_cost = Some(52);
3707 cfg.group_ops_bls12381_gt_sub_cost = Some(52);
3708 cfg.group_ops_bls12381_scalar_mul_cost = Some(52);
3709 cfg.group_ops_bls12381_g1_mul_cost = Some(52);
3710 cfg.group_ops_bls12381_g2_mul_cost = Some(52);
3711 cfg.group_ops_bls12381_gt_mul_cost = Some(52);
3712 cfg.group_ops_bls12381_scalar_div_cost = Some(52);
3713 cfg.group_ops_bls12381_g1_div_cost = Some(52);
3714 cfg.group_ops_bls12381_g2_div_cost = Some(52);
3715 cfg.group_ops_bls12381_gt_div_cost = Some(52);
3716 cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(52);
3717 cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(52);
3718 cfg.group_ops_bls12381_g1_hash_to_cost_per_byte = Some(2);
3719 cfg.group_ops_bls12381_g2_hash_to_cost_per_byte = Some(2);
3720 cfg.group_ops_bls12381_g1_msm_base_cost = Some(52);
3721 cfg.group_ops_bls12381_g2_msm_base_cost = Some(52);
3722 cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(52);
3723 cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(52);
3724 cfg.group_ops_bls12381_msm_max_len = Some(32);
3725 cfg.group_ops_bls12381_pairing_cost = Some(52);
3726 }
3727 cfg.feature_flags.shared_object_deletion = true;
3729
3730 cfg.consensus_max_transaction_size_bytes = Some(256 * 1024); cfg.consensus_max_transactions_in_block_bytes = Some(6 * 1_024 * 1024);
3732 }
3734 37 => {
3735 cfg.feature_flags.reject_mutable_random_on_entry_functions = true;
3736
3737 if chain != Chain::Mainnet {
3739 cfg.feature_flags.include_consensus_digest_in_prologue = true;
3740 }
3741 }
3742 38 => {
3743 cfg.binary_module_handles = Some(100);
3744 cfg.binary_struct_handles = Some(300);
3745 cfg.binary_function_handles = Some(1500);
3746 cfg.binary_function_instantiations = Some(750);
3747 cfg.binary_signatures = Some(1000);
3748 cfg.binary_constant_pool = Some(4000);
3752 cfg.binary_identifiers = Some(10000);
3753 cfg.binary_address_identifiers = Some(100);
3754 cfg.binary_struct_defs = Some(200);
3755 cfg.binary_struct_def_instantiations = Some(100);
3756 cfg.binary_function_defs = Some(1000);
3757 cfg.binary_field_handles = Some(500);
3758 cfg.binary_field_instantiations = Some(250);
3759 cfg.binary_friend_decls = Some(100);
3760 cfg.max_package_dependencies = Some(32);
3762 cfg.max_modules_in_publish = Some(64);
3763 cfg.execution_version = Some(3);
3765 }
3766 39 => {
3767 }
3769 40 => {}
3770 41 => {
3771 cfg.feature_flags.enable_group_ops_native_functions = true;
3773 cfg.group_ops_bls12381_decode_scalar_cost = Some(52);
3775 cfg.group_ops_bls12381_decode_g1_cost = Some(52);
3776 cfg.group_ops_bls12381_decode_g2_cost = Some(52);
3777 cfg.group_ops_bls12381_decode_gt_cost = Some(52);
3778 cfg.group_ops_bls12381_scalar_add_cost = Some(52);
3779 cfg.group_ops_bls12381_g1_add_cost = Some(52);
3780 cfg.group_ops_bls12381_g2_add_cost = Some(52);
3781 cfg.group_ops_bls12381_gt_add_cost = Some(52);
3782 cfg.group_ops_bls12381_scalar_sub_cost = Some(52);
3783 cfg.group_ops_bls12381_g1_sub_cost = Some(52);
3784 cfg.group_ops_bls12381_g2_sub_cost = Some(52);
3785 cfg.group_ops_bls12381_gt_sub_cost = Some(52);
3786 cfg.group_ops_bls12381_scalar_mul_cost = Some(52);
3787 cfg.group_ops_bls12381_g1_mul_cost = Some(52);
3788 cfg.group_ops_bls12381_g2_mul_cost = Some(52);
3789 cfg.group_ops_bls12381_gt_mul_cost = Some(52);
3790 cfg.group_ops_bls12381_scalar_div_cost = Some(52);
3791 cfg.group_ops_bls12381_g1_div_cost = Some(52);
3792 cfg.group_ops_bls12381_g2_div_cost = Some(52);
3793 cfg.group_ops_bls12381_gt_div_cost = Some(52);
3794 cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(52);
3795 cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(52);
3796 cfg.group_ops_bls12381_g1_hash_to_cost_per_byte = Some(2);
3797 cfg.group_ops_bls12381_g2_hash_to_cost_per_byte = Some(2);
3798 cfg.group_ops_bls12381_g1_msm_base_cost = Some(52);
3799 cfg.group_ops_bls12381_g2_msm_base_cost = Some(52);
3800 cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(52);
3801 cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(52);
3802 cfg.group_ops_bls12381_msm_max_len = Some(32);
3803 cfg.group_ops_bls12381_pairing_cost = Some(52);
3804 }
3805 42 => {}
3806 43 => {
3807 cfg.feature_flags.zklogin_max_epoch_upper_bound_delta = Some(30);
3808 cfg.max_meter_ticks_per_package = Some(16_000_000);
3809 }
3810 44 => {
3811 cfg.feature_flags.include_consensus_digest_in_prologue = true;
3813 if chain != Chain::Mainnet {
3815 cfg.feature_flags.consensus_choice = ConsensusChoice::SwapEachEpoch;
3816 }
3817 }
3818 45 => {
3819 if chain != Chain::Testnet && chain != Chain::Mainnet {
3821 cfg.feature_flags.consensus_network = ConsensusNetwork::Tonic;
3822 }
3823
3824 if chain != Chain::Mainnet {
3825 cfg.feature_flags.mysticeti_leader_scoring_and_schedule = true;
3827 }
3828 cfg.min_move_binary_format_version = Some(6);
3829 cfg.feature_flags.accept_zklogin_in_multisig = true;
3830
3831 if chain != Chain::Mainnet && chain != Chain::Testnet {
3835 cfg.feature_flags.bridge = true;
3836 }
3837 }
3838 46 => {
3839 if chain != Chain::Mainnet {
3841 cfg.feature_flags.bridge = true;
3842 }
3843
3844 cfg.feature_flags.reshare_at_same_initial_version = true;
3846 }
3847 47 => {}
3848 48 => {
3849 cfg.feature_flags.consensus_network = ConsensusNetwork::Tonic;
3851
3852 cfg.feature_flags.resolve_abort_locations_to_package_id = true;
3854
3855 if chain != Chain::Mainnet {
3857 cfg.feature_flags.random_beacon = true;
3858 cfg.random_beacon_reduction_lower_bound = Some(1600);
3859 cfg.random_beacon_dkg_timeout_round = Some(3000);
3860 cfg.random_beacon_min_round_interval_ms = Some(200);
3861 }
3862
3863 cfg.feature_flags.mysticeti_use_committed_subdag_digest = true;
3865 }
3866 49 => {
3867 if chain != Chain::Testnet && chain != Chain::Mainnet {
3868 cfg.move_binary_format_version = Some(7);
3869 }
3870
3871 if chain != Chain::Mainnet && chain != Chain::Testnet {
3873 cfg.feature_flags.enable_vdf = true;
3874 cfg.vdf_verify_vdf_cost = Some(1500);
3877 cfg.vdf_hash_to_input_cost = Some(100);
3878 }
3879
3880 if chain != Chain::Testnet && chain != Chain::Mainnet {
3882 cfg.feature_flags
3883 .record_consensus_determined_version_assignments_in_prologue = true;
3884 }
3885
3886 if chain != Chain::Mainnet {
3888 cfg.feature_flags.consensus_choice = ConsensusChoice::Mysticeti;
3889 }
3890
3891 cfg.feature_flags.fresh_vm_on_framework_upgrade = true;
3893 }
3894 50 => {
3895 if chain != Chain::Mainnet {
3897 cfg.checkpoint_summary_version_specific_data = Some(1);
3898 cfg.min_checkpoint_interval_ms = Some(200);
3899 }
3900
3901 if chain != Chain::Testnet && chain != Chain::Mainnet {
3903 cfg.feature_flags
3904 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3905 }
3906
3907 cfg.feature_flags.mysticeti_num_leaders_per_round = Some(1);
3908
3909 cfg.max_deferral_rounds_for_congestion_control = Some(10);
3911 }
3912 51 => {
3913 cfg.random_beacon_dkg_version = Some(1);
3914
3915 if chain != Chain::Testnet && chain != Chain::Mainnet {
3916 cfg.feature_flags.enable_coin_deny_list_v2 = true;
3917 }
3918 }
3919 52 => {
3920 if chain != Chain::Mainnet {
3921 cfg.feature_flags.soft_bundle = true;
3922 cfg.max_soft_bundle_size = Some(5);
3923 }
3924
3925 cfg.config_read_setting_impl_cost_base = Some(100);
3926 cfg.config_read_setting_impl_cost_per_byte = Some(40);
3927
3928 if chain != Chain::Testnet && chain != Chain::Mainnet {
3930 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3931 cfg.feature_flags.per_object_congestion_control_mode =
3932 PerObjectCongestionControlMode::TotalTxCount;
3933 }
3934
3935 cfg.feature_flags.consensus_choice = ConsensusChoice::Mysticeti;
3937
3938 cfg.feature_flags.mysticeti_leader_scoring_and_schedule = true;
3940
3941 cfg.checkpoint_summary_version_specific_data = Some(1);
3943 cfg.min_checkpoint_interval_ms = Some(200);
3944
3945 if chain != Chain::Mainnet {
3947 cfg.feature_flags
3948 .record_consensus_determined_version_assignments_in_prologue = true;
3949 cfg.feature_flags
3950 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3951 }
3952 if chain != Chain::Mainnet {
3954 cfg.move_binary_format_version = Some(7);
3955 }
3956
3957 if chain != Chain::Testnet && chain != Chain::Mainnet {
3958 cfg.feature_flags.passkey_auth = true;
3959 }
3960 cfg.feature_flags.enable_coin_deny_list_v2 = true;
3961 }
3962 53 => {
3963 cfg.bridge_should_try_to_finalize_committee = Some(chain != Chain::Mainnet);
3965
3966 cfg.feature_flags
3968 .record_consensus_determined_version_assignments_in_prologue = true;
3969 cfg.feature_flags
3970 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3971
3972 if chain == Chain::Unknown {
3973 cfg.feature_flags.authority_capabilities_v2 = true;
3974 }
3975
3976 if chain != Chain::Mainnet {
3978 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3979 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(10);
3980 cfg.feature_flags.per_object_congestion_control_mode =
3981 PerObjectCongestionControlMode::TotalTxCount;
3982 }
3983
3984 cfg.bcs_per_byte_serialized_cost = Some(2);
3986 cfg.bcs_legacy_min_output_size_cost = Some(1);
3987 cfg.bcs_failure_cost = Some(52);
3988 cfg.debug_print_base_cost = Some(52);
3989 cfg.debug_print_stack_trace_base_cost = Some(52);
3990 cfg.hash_sha2_256_base_cost = Some(52);
3991 cfg.hash_sha2_256_per_byte_cost = Some(2);
3992 cfg.hash_sha2_256_legacy_min_input_len_cost = Some(1);
3993 cfg.hash_sha3_256_base_cost = Some(52);
3994 cfg.hash_sha3_256_per_byte_cost = Some(2);
3995 cfg.hash_sha3_256_legacy_min_input_len_cost = Some(1);
3996 cfg.type_name_get_base_cost = Some(52);
3997 cfg.type_name_get_per_byte_cost = Some(2);
3998 cfg.string_check_utf8_base_cost = Some(52);
3999 cfg.string_check_utf8_per_byte_cost = Some(2);
4000 cfg.string_is_char_boundary_base_cost = Some(52);
4001 cfg.string_sub_string_base_cost = Some(52);
4002 cfg.string_sub_string_per_byte_cost = Some(2);
4003 cfg.string_index_of_base_cost = Some(52);
4004 cfg.string_index_of_per_byte_pattern_cost = Some(2);
4005 cfg.string_index_of_per_byte_searched_cost = Some(2);
4006 cfg.vector_empty_base_cost = Some(52);
4007 cfg.vector_length_base_cost = Some(52);
4008 cfg.vector_push_back_base_cost = Some(52);
4009 cfg.vector_push_back_legacy_per_abstract_memory_unit_cost = Some(2);
4010 cfg.vector_borrow_base_cost = Some(52);
4011 cfg.vector_pop_back_base_cost = Some(52);
4012 cfg.vector_destroy_empty_base_cost = Some(52);
4013 cfg.vector_swap_base_cost = Some(52);
4014 }
4015 54 => {
4016 cfg.feature_flags.random_beacon = true;
4018 cfg.random_beacon_reduction_lower_bound = Some(1000);
4019 cfg.random_beacon_dkg_timeout_round = Some(3000);
4020 cfg.random_beacon_min_round_interval_ms = Some(500);
4021
4022 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
4024 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(10);
4025 cfg.feature_flags.per_object_congestion_control_mode =
4026 PerObjectCongestionControlMode::TotalTxCount;
4027
4028 cfg.feature_flags.soft_bundle = true;
4030 cfg.max_soft_bundle_size = Some(5);
4031 }
4032 55 => {
4033 cfg.move_binary_format_version = Some(7);
4035
4036 cfg.consensus_max_transactions_in_block_bytes = Some(512 * 1024);
4038 cfg.consensus_max_num_transactions_in_block = Some(512);
4041
4042 cfg.feature_flags.rethrow_serialization_type_layout_errors = true;
4043 }
4044 56 => {
4045 if chain == Chain::Mainnet {
4046 cfg.feature_flags.bridge = true;
4047 }
4048 }
4049 57 => {
4050 cfg.random_beacon_reduction_lower_bound = Some(800);
4052 }
4053 58 => {
4054 if chain == Chain::Mainnet {
4055 cfg.bridge_should_try_to_finalize_committee = Some(true);
4056 }
4057
4058 if chain != Chain::Mainnet && chain != Chain::Testnet {
4059 cfg.feature_flags
4061 .consensus_distributed_vote_scoring_strategy = true;
4062 }
4063 }
4064 59 => {
4065 cfg.feature_flags.consensus_round_prober = true;
4067 }
4068 60 => {
4069 cfg.max_type_to_layout_nodes = Some(512);
4070 cfg.feature_flags.validate_identifier_inputs = true;
4071 }
4072 61 => {
4073 if chain != Chain::Mainnet {
4074 cfg.feature_flags
4076 .consensus_distributed_vote_scoring_strategy = true;
4077 }
4078 cfg.random_beacon_reduction_lower_bound = Some(700);
4080
4081 if chain != Chain::Mainnet && chain != Chain::Testnet {
4082 cfg.feature_flags.mysticeti_fastpath = true;
4084 }
4085 }
4086 62 => {
4087 cfg.feature_flags.relocate_event_module = true;
4088 }
4089 63 => {
4090 cfg.feature_flags.per_object_congestion_control_mode =
4091 PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4092 cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4093 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(18_500_000);
4094 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(240_000_000);
4095 }
4096 64 => {
4097 cfg.feature_flags.per_object_congestion_control_mode =
4098 PerObjectCongestionControlMode::TotalTxCount;
4099 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(40);
4100 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(3);
4101 }
4102 65 => {
4103 cfg.feature_flags
4105 .consensus_distributed_vote_scoring_strategy = true;
4106 }
4107 66 => {
4108 if chain == Chain::Mainnet {
4109 cfg.feature_flags
4111 .consensus_distributed_vote_scoring_strategy = false;
4112 }
4113 }
4114 67 => {
4115 cfg.feature_flags
4117 .consensus_distributed_vote_scoring_strategy = true;
4118 }
4119 68 => {
4120 cfg.group_ops_bls12381_g1_to_uncompressed_g1_cost = Some(26);
4121 cfg.group_ops_bls12381_uncompressed_g1_to_g1_cost = Some(52);
4122 cfg.group_ops_bls12381_uncompressed_g1_sum_base_cost = Some(26);
4123 cfg.group_ops_bls12381_uncompressed_g1_sum_cost_per_term = Some(13);
4124 cfg.group_ops_bls12381_uncompressed_g1_sum_max_terms = Some(2000);
4125
4126 if chain != Chain::Mainnet && chain != Chain::Testnet {
4127 cfg.feature_flags.uncompressed_g1_group_elements = true;
4128 }
4129
4130 cfg.feature_flags.per_object_congestion_control_mode =
4131 PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4132 cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4133 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(18_500_000);
4134 cfg.max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit =
4135 Some(3_700_000); cfg.max_txn_cost_overage_per_object_in_commit = Some(u64::MAX);
4137 cfg.gas_budget_based_txn_cost_absolute_cap_commit_count = Some(50);
4138
4139 cfg.random_beacon_reduction_lower_bound = Some(500);
4141
4142 cfg.feature_flags.disallow_new_modules_in_deps_only_packages = true;
4143 }
4144 69 => {
4145 cfg.consensus_voting_rounds = Some(40);
4147
4148 if chain != Chain::Mainnet && chain != Chain::Testnet {
4149 cfg.feature_flags.consensus_smart_ancestor_selection = true;
4151 }
4152
4153 if chain != Chain::Mainnet {
4154 cfg.feature_flags.uncompressed_g1_group_elements = true;
4155 }
4156 }
4157 70 => {
4158 if chain != Chain::Mainnet {
4159 cfg.feature_flags.consensus_smart_ancestor_selection = true;
4161 cfg.feature_flags
4163 .consensus_round_prober_probe_accepted_rounds = true;
4164 }
4165
4166 cfg.poseidon_bn254_cost_per_block = Some(388);
4167
4168 cfg.gas_model_version = Some(9);
4169 cfg.feature_flags.native_charging_v2 = true;
4170 cfg.bls12381_bls12381_min_sig_verify_cost_base = Some(44064);
4171 cfg.bls12381_bls12381_min_pk_verify_cost_base = Some(49282);
4172 cfg.ecdsa_k1_secp256k1_verify_keccak256_cost_base = Some(1470);
4173 cfg.ecdsa_k1_secp256k1_verify_sha256_cost_base = Some(1470);
4174 cfg.ecdsa_r1_secp256r1_verify_sha256_cost_base = Some(4225);
4175 cfg.ecdsa_r1_secp256r1_verify_keccak256_cost_base = Some(4225);
4176 cfg.ecvrf_ecvrf_verify_cost_base = Some(4848);
4177 cfg.ed25519_ed25519_verify_cost_base = Some(1802);
4178
4179 cfg.ecdsa_r1_ecrecover_keccak256_cost_base = Some(1173);
4181 cfg.ecdsa_r1_ecrecover_sha256_cost_base = Some(1173);
4182 cfg.ecdsa_k1_ecrecover_keccak256_cost_base = Some(500);
4183 cfg.ecdsa_k1_ecrecover_sha256_cost_base = Some(500);
4184
4185 cfg.groth16_prepare_verifying_key_bls12381_cost_base = Some(53838);
4186 cfg.groth16_prepare_verifying_key_bn254_cost_base = Some(82010);
4187 cfg.groth16_verify_groth16_proof_internal_bls12381_cost_base = Some(72090);
4188 cfg.groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input =
4189 Some(8213);
4190 cfg.groth16_verify_groth16_proof_internal_bn254_cost_base = Some(115502);
4191 cfg.groth16_verify_groth16_proof_internal_bn254_cost_per_public_input =
4192 Some(9484);
4193
4194 cfg.hash_keccak256_cost_base = Some(10);
4195 cfg.hash_blake2b256_cost_base = Some(10);
4196
4197 cfg.group_ops_bls12381_decode_scalar_cost = Some(7);
4199 cfg.group_ops_bls12381_decode_g1_cost = Some(2848);
4200 cfg.group_ops_bls12381_decode_g2_cost = Some(3770);
4201 cfg.group_ops_bls12381_decode_gt_cost = Some(3068);
4202
4203 cfg.group_ops_bls12381_scalar_add_cost = Some(10);
4204 cfg.group_ops_bls12381_g1_add_cost = Some(1556);
4205 cfg.group_ops_bls12381_g2_add_cost = Some(3048);
4206 cfg.group_ops_bls12381_gt_add_cost = Some(188);
4207
4208 cfg.group_ops_bls12381_scalar_sub_cost = Some(10);
4209 cfg.group_ops_bls12381_g1_sub_cost = Some(1550);
4210 cfg.group_ops_bls12381_g2_sub_cost = Some(3019);
4211 cfg.group_ops_bls12381_gt_sub_cost = Some(497);
4212
4213 cfg.group_ops_bls12381_scalar_mul_cost = Some(11);
4214 cfg.group_ops_bls12381_g1_mul_cost = Some(4842);
4215 cfg.group_ops_bls12381_g2_mul_cost = Some(9108);
4216 cfg.group_ops_bls12381_gt_mul_cost = Some(27490);
4217
4218 cfg.group_ops_bls12381_scalar_div_cost = Some(91);
4219 cfg.group_ops_bls12381_g1_div_cost = Some(5091);
4220 cfg.group_ops_bls12381_g2_div_cost = Some(9206);
4221 cfg.group_ops_bls12381_gt_div_cost = Some(27804);
4222
4223 cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(2962);
4224 cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(8688);
4225
4226 cfg.group_ops_bls12381_g1_msm_base_cost = Some(62648);
4227 cfg.group_ops_bls12381_g2_msm_base_cost = Some(131192);
4228 cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(1333);
4229 cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(3216);
4230
4231 cfg.group_ops_bls12381_uncompressed_g1_to_g1_cost = Some(677);
4232 cfg.group_ops_bls12381_g1_to_uncompressed_g1_cost = Some(2099);
4233 cfg.group_ops_bls12381_uncompressed_g1_sum_base_cost = Some(77);
4234 cfg.group_ops_bls12381_uncompressed_g1_sum_cost_per_term = Some(26);
4235
4236 cfg.group_ops_bls12381_pairing_cost = Some(26897);
4237 cfg.group_ops_bls12381_uncompressed_g1_sum_max_terms = Some(1200);
4238
4239 cfg.validator_validate_metadata_cost_base = Some(20000);
4240 }
4241 71 => {
4242 cfg.sip_45_consensus_amplification_threshold = Some(5);
4243
4244 cfg.allowed_txn_cost_overage_burst_per_object_in_commit = Some(185_000_000);
4246 }
4247 72 => {
4248 cfg.feature_flags.convert_type_argument_error = true;
4249
4250 cfg.max_tx_gas = Some(50_000_000_000_000);
4253 cfg.max_gas_price = Some(50_000_000_000);
4255
4256 cfg.feature_flags.variant_nodes = true;
4257 }
4258 73 => {
4259 cfg.use_object_per_epoch_marker_table_v2 = Some(true);
4261
4262 if chain != Chain::Mainnet && chain != Chain::Testnet {
4263 cfg.consensus_gc_depth = Some(60);
4266 }
4267
4268 if chain != Chain::Mainnet {
4269 cfg.feature_flags.consensus_zstd_compression = true;
4271 }
4272
4273 cfg.feature_flags.consensus_smart_ancestor_selection = true;
4275 cfg.feature_flags
4277 .consensus_round_prober_probe_accepted_rounds = true;
4278
4279 cfg.feature_flags.per_object_congestion_control_mode =
4281 PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4282 cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4283 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(37_000_000);
4284 cfg.max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit =
4285 Some(7_400_000); cfg.max_txn_cost_overage_per_object_in_commit = Some(u64::MAX);
4287 cfg.gas_budget_based_txn_cost_absolute_cap_commit_count = Some(50);
4288 cfg.allowed_txn_cost_overage_burst_per_object_in_commit = Some(370_000_000);
4289 }
4290 74 => {
4291 if chain != Chain::Mainnet && chain != Chain::Testnet {
4293 cfg.feature_flags.enable_nitro_attestation = true;
4294 }
4295 cfg.nitro_attestation_parse_base_cost = Some(53 * 50);
4296 cfg.nitro_attestation_parse_cost_per_byte = Some(50);
4297 cfg.nitro_attestation_verify_base_cost = Some(49632 * 50);
4298 cfg.nitro_attestation_verify_cost_per_cert = Some(52369 * 50);
4299
4300 cfg.feature_flags.consensus_zstd_compression = true;
4302
4303 if chain != Chain::Mainnet && chain != Chain::Testnet {
4304 cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4305 }
4306 }
4307 75 => {
4308 if chain != Chain::Mainnet {
4309 cfg.feature_flags.passkey_auth = true;
4310 }
4311 }
4312 76 => {
4313 if chain != Chain::Mainnet && chain != Chain::Testnet {
4314 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4315 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4316 }
4317 cfg.feature_flags.minimize_child_object_mutations = true;
4318
4319 if chain != Chain::Mainnet {
4320 cfg.feature_flags.accept_passkey_in_multisig = true;
4321 }
4322 }
4323 77 => {
4324 cfg.feature_flags.uncompressed_g1_group_elements = true;
4325
4326 if chain != Chain::Mainnet {
4327 cfg.consensus_gc_depth = Some(60);
4328 cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4329 }
4330 }
4331 78 => {
4332 cfg.feature_flags.move_native_context = true;
4333 cfg.tx_context_fresh_id_cost_base = Some(52);
4334 cfg.tx_context_sender_cost_base = Some(30);
4335 cfg.tx_context_epoch_cost_base = Some(30);
4336 cfg.tx_context_epoch_timestamp_ms_cost_base = Some(30);
4337 cfg.tx_context_sponsor_cost_base = Some(30);
4338 cfg.tx_context_gas_price_cost_base = Some(30);
4339 cfg.tx_context_gas_budget_cost_base = Some(30);
4340 cfg.tx_context_ids_created_cost_base = Some(30);
4341 cfg.tx_context_replace_cost_base = Some(30);
4342 cfg.gas_model_version = Some(10);
4343
4344 if chain != Chain::Mainnet {
4345 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4346 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4347
4348 cfg.feature_flags.per_object_congestion_control_mode =
4350 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4351 ExecutionTimeEstimateParams {
4352 target_utilization: 30,
4353 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4355 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4357 stored_observations_limit: u64::MAX,
4358 stake_weighted_median_threshold: 0,
4359 default_none_duration_for_new_keys: false,
4360 observations_chunk_size: None,
4361 },
4362 );
4363 }
4364 }
4365 79 => {
4366 if chain != Chain::Mainnet {
4367 cfg.feature_flags.consensus_median_based_commit_timestamp = true;
4368
4369 cfg.consensus_bad_nodes_stake_threshold = Some(30);
4372
4373 cfg.feature_flags.consensus_batched_block_sync = true;
4374
4375 cfg.feature_flags.enable_nitro_attestation = true
4377 }
4378 cfg.feature_flags.normalize_ptb_arguments = true;
4379
4380 cfg.consensus_gc_depth = Some(60);
4381 cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4382 }
4383 80 => {
4384 cfg.max_ptb_value_size = Some(1024 * 1024);
4385 }
4386 81 => {
4387 cfg.feature_flags.consensus_median_based_commit_timestamp = true;
4388 cfg.feature_flags.enforce_checkpoint_timestamp_monotonicity = true;
4389 cfg.consensus_bad_nodes_stake_threshold = Some(30)
4390 }
4391 82 => {
4392 cfg.feature_flags.max_ptb_value_size_v2 = true;
4393 }
4394 83 => {
4395 if chain == Chain::Mainnet {
4396 let aliased: [u8; 32] = Hex::decode(
4398 "0x0b2da327ba6a4cacbe75dddd50e6e8bbf81d6496e92d66af9154c61c77f7332f",
4399 )
4400 .unwrap()
4401 .try_into()
4402 .unwrap();
4403
4404 cfg.aliased_addresses.push(AliasedAddress {
4406 original: Hex::decode("0xcd8962dad278d8b50fa0f9eb0186bfa4cbdecc6d59377214c88d0286a0ac9562").unwrap().try_into().unwrap(),
4407 aliased,
4408 allowed_tx_digests: vec![
4409 Base58::decode("B2eGLFoMHgj93Ni8dAJBfqGzo8EWSTLBesZzhEpTPA4").unwrap().try_into().unwrap(),
4410 ],
4411 });
4412
4413 cfg.aliased_addresses.push(AliasedAddress {
4414 original: Hex::decode("0xe28b50cef1d633ea43d3296a3f6b67ff0312a5f1a99f0af753c85b8b5de8ff06").unwrap().try_into().unwrap(),
4415 aliased,
4416 allowed_tx_digests: vec![
4417 Base58::decode("J4QqSAgp7VrQtQpMy5wDX4QGsCSEZu3U5KuDAkbESAge").unwrap().try_into().unwrap(),
4418 ],
4419 });
4420 }
4421
4422 if chain != Chain::Mainnet {
4425 cfg.feature_flags.resolve_type_input_ids_to_defining_id = true;
4426 cfg.transfer_party_transfer_internal_cost_base = Some(52);
4427
4428 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4430 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4431 cfg.feature_flags.per_object_congestion_control_mode =
4432 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4433 ExecutionTimeEstimateParams {
4434 target_utilization: 30,
4435 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4437 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4439 stored_observations_limit: u64::MAX,
4440 stake_weighted_median_threshold: 0,
4441 default_none_duration_for_new_keys: false,
4442 observations_chunk_size: None,
4443 },
4444 );
4445
4446 cfg.feature_flags.consensus_batched_block_sync = true;
4448
4449 cfg.feature_flags.enable_nitro_attestation_upgraded_parsing = true;
4452 cfg.feature_flags.enable_nitro_attestation = true;
4453 }
4454 }
4455 84 => {
4456 if chain == Chain::Mainnet {
4457 cfg.feature_flags.resolve_type_input_ids_to_defining_id = true;
4458 cfg.transfer_party_transfer_internal_cost_base = Some(52);
4459
4460 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4462 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4463 cfg.feature_flags.per_object_congestion_control_mode =
4464 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4465 ExecutionTimeEstimateParams {
4466 target_utilization: 30,
4467 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4469 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4471 stored_observations_limit: u64::MAX,
4472 stake_weighted_median_threshold: 0,
4473 default_none_duration_for_new_keys: false,
4474 observations_chunk_size: None,
4475 },
4476 );
4477
4478 cfg.feature_flags.consensus_batched_block_sync = true;
4480
4481 cfg.feature_flags.enable_nitro_attestation_upgraded_parsing = true;
4484 cfg.feature_flags.enable_nitro_attestation = true;
4485 }
4486
4487 cfg.feature_flags.per_object_congestion_control_mode =
4489 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4490 ExecutionTimeEstimateParams {
4491 target_utilization: 30,
4492 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4494 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4496 stored_observations_limit: 20,
4497 stake_weighted_median_threshold: 0,
4498 default_none_duration_for_new_keys: false,
4499 observations_chunk_size: None,
4500 },
4501 );
4502 cfg.feature_flags.allow_unbounded_system_objects = true;
4503 }
4504 85 => {
4505 if chain != Chain::Mainnet && chain != Chain::Testnet {
4506 cfg.feature_flags.enable_party_transfer = true;
4507 }
4508
4509 cfg.feature_flags
4510 .record_consensus_determined_version_assignments_in_prologue_v2 = true;
4511 cfg.feature_flags.disallow_self_identifier = true;
4512 cfg.feature_flags.per_object_congestion_control_mode =
4513 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4514 ExecutionTimeEstimateParams {
4515 target_utilization: 50,
4516 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4518 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4520 stored_observations_limit: 20,
4521 stake_weighted_median_threshold: 0,
4522 default_none_duration_for_new_keys: false,
4523 observations_chunk_size: None,
4524 },
4525 );
4526 }
4527 86 => {
4528 cfg.feature_flags.type_tags_in_object_runtime = true;
4529 cfg.max_move_enum_variants = Some(move_core_types::VARIANT_COUNT_MAX);
4530
4531 cfg.feature_flags.per_object_congestion_control_mode =
4533 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4534 ExecutionTimeEstimateParams {
4535 target_utilization: 50,
4536 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4538 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4540 stored_observations_limit: 20,
4541 stake_weighted_median_threshold: 3334,
4542 default_none_duration_for_new_keys: false,
4543 observations_chunk_size: None,
4544 },
4545 );
4546 if chain != Chain::Mainnet {
4548 cfg.feature_flags.enable_party_transfer = true;
4549 }
4550 }
4551 87 => {
4552 if chain == Chain::Mainnet {
4553 cfg.feature_flags.record_time_estimate_processed = true;
4554 }
4555 cfg.feature_flags.better_adapter_type_resolution_errors = true;
4556 }
4557 88 => {
4558 cfg.feature_flags.record_time_estimate_processed = true;
4559 cfg.tx_context_rgp_cost_base = Some(30);
4560 cfg.feature_flags
4561 .ignore_execution_time_observations_after_certs_closed = true;
4562
4563 cfg.feature_flags.per_object_congestion_control_mode =
4566 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4567 ExecutionTimeEstimateParams {
4568 target_utilization: 50,
4569 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4571 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4573 stored_observations_limit: 20,
4574 stake_weighted_median_threshold: 3334,
4575 default_none_duration_for_new_keys: true,
4576 observations_chunk_size: None,
4577 },
4578 );
4579 }
4580 89 => {
4581 cfg.feature_flags.dependency_linkage_error = true;
4582 cfg.feature_flags.additional_multisig_checks = true;
4583 }
4584 90 => {
4585 cfg.max_gas_price_rgp_factor_for_aborted_transactions = Some(100);
4587 cfg.feature_flags.debug_fatal_on_move_invariant_violation = true;
4588 cfg.feature_flags.additional_consensus_digest_indirect_state = true;
4589 cfg.feature_flags.accept_passkey_in_multisig = true;
4590 cfg.feature_flags.passkey_auth = true;
4591 cfg.feature_flags.check_for_init_during_upgrade = true;
4592
4593 if chain != Chain::Mainnet {
4595 cfg.feature_flags.mysticeti_fastpath = true;
4596 }
4597 }
4598 91 => {
4599 cfg.feature_flags.per_command_shared_object_transfer_rules = true;
4600 }
4601 92 => {
4602 cfg.feature_flags.per_command_shared_object_transfer_rules = false;
4603 }
4604 93 => {
4605 cfg.feature_flags
4606 .consensus_checkpoint_signature_key_includes_digest = true;
4607 }
4608 94 => {
4609 cfg.feature_flags.per_object_congestion_control_mode =
4611 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4612 ExecutionTimeEstimateParams {
4613 target_utilization: 50,
4614 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4616 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4618 stored_observations_limit: 18,
4619 stake_weighted_median_threshold: 3334,
4620 default_none_duration_for_new_keys: true,
4621 observations_chunk_size: None,
4622 },
4623 );
4624
4625 cfg.feature_flags.enable_party_transfer = true;
4627 }
4628 95 => {
4629 cfg.type_name_id_base_cost = Some(52);
4630
4631 cfg.max_transactions_per_checkpoint = Some(20_000);
4633 }
4634 96 => {
4635 if chain != Chain::Mainnet && chain != Chain::Testnet {
4637 cfg.feature_flags
4638 .include_checkpoint_artifacts_digest_in_summary = true;
4639 }
4640 cfg.feature_flags.correct_gas_payment_limit_check = true;
4641 cfg.feature_flags.authority_capabilities_v2 = true;
4642 cfg.feature_flags.use_mfp_txns_in_load_initial_object_debts = true;
4643 cfg.feature_flags.cancel_for_failed_dkg_early = true;
4644 cfg.feature_flags.enable_coin_registry = true;
4645
4646 cfg.feature_flags.mysticeti_fastpath = true;
4648 }
4649 97 => {
4650 cfg.feature_flags.additional_borrow_checks = true;
4651 }
4652 98 => {
4653 cfg.event_emit_auth_stream_cost = Some(52);
4654 cfg.feature_flags.better_loader_errors = true;
4655 cfg.feature_flags.generate_df_type_layouts = true;
4656 }
4657 99 => {
4658 cfg.feature_flags.use_new_commit_handler = true;
4659 }
4660 100 => {
4661 cfg.feature_flags.private_generics_verifier_v2 = true;
4662 }
4663 101 => {
4664 cfg.feature_flags.create_root_accumulator_object = true;
4665 cfg.max_updates_per_settlement_txn = Some(100);
4666 if chain != Chain::Mainnet {
4667 cfg.feature_flags.enable_poseidon = true;
4668 }
4669 }
4670 102 => {
4671 cfg.feature_flags.per_object_congestion_control_mode =
4675 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4676 ExecutionTimeEstimateParams {
4677 target_utilization: 50,
4678 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4680 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4682 stored_observations_limit: 180,
4683 stake_weighted_median_threshold: 3334,
4684 default_none_duration_for_new_keys: true,
4685 observations_chunk_size: Some(18),
4686 },
4687 );
4688 cfg.feature_flags.deprecate_global_storage_ops = true;
4689 }
4690 103 => {}
4691 104 => {
4692 cfg.translation_per_command_base_charge = Some(1);
4693 cfg.translation_per_input_base_charge = Some(1);
4694 cfg.translation_pure_input_per_byte_charge = Some(1);
4695 cfg.translation_per_type_node_charge = Some(1);
4696 cfg.translation_per_reference_node_charge = Some(1);
4697 cfg.translation_per_linkage_entry_charge = Some(10);
4698 cfg.gas_model_version = Some(11);
4699 cfg.feature_flags.abstract_size_in_object_runtime = true;
4700 cfg.feature_flags.object_runtime_charge_cache_load_gas = true;
4701 cfg.dynamic_field_hash_type_and_key_cost_base = Some(52);
4702 cfg.dynamic_field_add_child_object_cost_base = Some(52);
4703 cfg.dynamic_field_add_child_object_value_cost_per_byte = Some(1);
4704 cfg.dynamic_field_borrow_child_object_cost_base = Some(52);
4705 cfg.dynamic_field_borrow_child_object_child_ref_cost_per_byte = Some(1);
4706 cfg.dynamic_field_remove_child_object_cost_base = Some(52);
4707 cfg.dynamic_field_remove_child_object_child_cost_per_byte = Some(1);
4708 cfg.dynamic_field_has_child_object_cost_base = Some(52);
4709 cfg.dynamic_field_has_child_object_with_ty_cost_base = Some(52);
4710 cfg.feature_flags.enable_ptb_execution_v2 = true;
4711
4712 cfg.poseidon_bn254_cost_base = Some(260);
4713
4714 cfg.feature_flags.consensus_skip_gced_accept_votes = true;
4715
4716 if chain != Chain::Mainnet {
4717 cfg.feature_flags
4718 .enable_nitro_attestation_all_nonzero_pcrs_parsing = true;
4719 }
4720
4721 cfg.feature_flags
4722 .include_cancelled_randomness_txns_in_prologue = true;
4723 }
4724 105 => {
4725 cfg.feature_flags.enable_multi_epoch_transaction_expiration = true;
4726 cfg.feature_flags.disable_preconsensus_locking = true;
4727
4728 if chain != Chain::Mainnet {
4729 cfg.feature_flags
4730 .enable_nitro_attestation_always_include_required_pcrs_parsing = true;
4731 }
4732 }
4733 106 => {
4734 cfg.accumulator_object_storage_cost = Some(7600);
4736
4737 if chain != Chain::Mainnet && chain != Chain::Testnet {
4738 cfg.feature_flags.enable_accumulators = true;
4739 cfg.feature_flags.enable_address_balance_gas_payments = true;
4740 cfg.feature_flags.enable_authenticated_event_streams = true;
4741 cfg.feature_flags.enable_object_funds_withdraw = true;
4742 }
4743 }
4744 107 => {
4745 cfg.feature_flags
4746 .consensus_skip_gced_blocks_in_direct_finalization = true;
4747
4748 if in_integration_test() {
4750 cfg.consensus_gc_depth = Some(6);
4751 cfg.consensus_max_num_transactions_in_block = Some(8);
4752 }
4753 }
4754 108 => {
4755 cfg.feature_flags.gas_rounding_halve_digits = true;
4756 cfg.feature_flags.flexible_tx_context_positions = true;
4757 cfg.feature_flags.disable_entry_point_signature_check = true;
4758
4759 if chain != Chain::Mainnet {
4760 cfg.feature_flags.address_aliases = true;
4761
4762 cfg.feature_flags.enable_accumulators = true;
4763 cfg.feature_flags.enable_address_balance_gas_payments = true;
4764 }
4765
4766 cfg.feature_flags.enable_poseidon = true;
4767 }
4768 109 => {
4769 cfg.binary_variant_handles = Some(1024);
4770 cfg.binary_variant_instantiation_handles = Some(1024);
4771 cfg.feature_flags.restrict_hot_or_not_entry_functions = true;
4772 }
4773 110 => {
4774 cfg.feature_flags
4775 .enable_nitro_attestation_all_nonzero_pcrs_parsing = true;
4776 cfg.feature_flags
4777 .enable_nitro_attestation_always_include_required_pcrs_parsing = true;
4778 if chain != Chain::Mainnet && chain != Chain::Testnet {
4779 cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4780 }
4781 cfg.feature_flags.validate_zklogin_public_identifier = true;
4782 cfg.feature_flags.fix_checkpoint_signature_mapping = true;
4783 cfg.feature_flags
4784 .consensus_always_accept_system_transactions = true;
4785 if chain != Chain::Mainnet {
4786 cfg.feature_flags.enable_object_funds_withdraw = true;
4787 }
4788 }
4789 111 => {
4790 cfg.feature_flags.validator_metadata_verify_v2 = true;
4791 }
4792 112 => {
4793 cfg.group_ops_ristretto_decode_scalar_cost = Some(7);
4794 cfg.group_ops_ristretto_decode_point_cost = Some(200);
4795 cfg.group_ops_ristretto_scalar_add_cost = Some(10);
4796 cfg.group_ops_ristretto_point_add_cost = Some(500);
4797 cfg.group_ops_ristretto_scalar_sub_cost = Some(10);
4798 cfg.group_ops_ristretto_point_sub_cost = Some(500);
4799 cfg.group_ops_ristretto_scalar_mul_cost = Some(11);
4800 cfg.group_ops_ristretto_point_mul_cost = Some(1200);
4801 cfg.group_ops_ristretto_scalar_div_cost = Some(151);
4802 cfg.group_ops_ristretto_point_div_cost = Some(2500);
4803
4804 if chain != Chain::Mainnet && chain != Chain::Testnet {
4805 cfg.feature_flags.enable_ristretto255_group_ops = true;
4806 }
4807 }
4808 113 => {
4809 cfg.feature_flags.address_balance_gas_check_rgp_at_signing = true;
4810 if chain != Chain::Mainnet && chain != Chain::Testnet {
4811 cfg.feature_flags.defer_unpaid_amplification = true;
4812 }
4813 }
4814 114 => {
4815 cfg.feature_flags.randomize_checkpoint_tx_limit_in_tests = true;
4816 cfg.feature_flags.address_balance_gas_reject_gas_coin_arg = true;
4817 if chain != Chain::Mainnet {
4818 cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4819 cfg.feature_flags.enable_authenticated_event_streams = true;
4820 cfg.feature_flags
4821 .include_checkpoint_artifacts_digest_in_summary = true;
4822 }
4823 }
4824 115 => {
4825 cfg.feature_flags.normalize_depth_formula = true;
4826 }
4827 116 => {
4828 cfg.feature_flags.gasless_transaction_drop_safety = true;
4829 cfg.feature_flags.address_aliases = true;
4830 cfg.feature_flags.relax_valid_during_for_owned_inputs = true;
4831 cfg.feature_flags.defer_unpaid_amplification = false;
4833 cfg.feature_flags.enable_display_registry = true;
4834 }
4835 117 => {}
4836 118 => {
4837 cfg.feature_flags.use_coin_party_owner = true;
4838 }
4839 119 => {
4840 cfg.execution_version = Some(4);
4842 cfg.feature_flags.address_balance_gas_reject_gas_coin_arg = false;
4843 cfg.feature_flags.merge_randomness_into_checkpoint = true;
4844 if chain != Chain::Mainnet {
4845 cfg.feature_flags.enable_gasless = true;
4846 cfg.gasless_max_computation_units = Some(50_000);
4847 cfg.gasless_allowed_token_types = Some(vec![]);
4848 cfg.feature_flags.enable_coin_reservation_obj_refs = true;
4849 cfg.feature_flags
4850 .convert_withdrawal_compatibility_ptb_arguments = true;
4851 }
4852 cfg.gasless_max_unused_inputs = Some(1);
4853 cfg.gasless_max_pure_input_bytes = Some(32);
4854 if chain == Chain::Testnet {
4855 cfg.gasless_allowed_token_types = Some(vec![(TESTNET_USDC.to_string(), 0)]);
4856 }
4857 cfg.transfer_receive_object_cost_per_byte = Some(1);
4858 cfg.transfer_receive_object_type_cost_per_byte = Some(2);
4859 }
4860 120 => {
4861 cfg.feature_flags.disallow_jump_orphans = true;
4862 }
4863 121 => {
4864 if chain != Chain::Mainnet {
4866 cfg.feature_flags.defer_unpaid_amplification = true;
4867 cfg.gasless_max_tps = Some(50);
4868 }
4869 cfg.feature_flags
4870 .early_return_receive_object_mismatched_type = true;
4871 }
4872 122 => {
4873 cfg.feature_flags.defer_unpaid_amplification = true;
4875 cfg.verify_bulletproofs_ristretto255_base_cost = Some(30000);
4877 cfg.verify_bulletproofs_ristretto255_cost_per_bit_and_commitment = Some(6500);
4878 if chain != Chain::Mainnet && chain != Chain::Testnet {
4879 cfg.feature_flags.enable_verify_bulletproofs_ristretto255 = true;
4880 }
4881 cfg.feature_flags.gasless_verify_remaining_balance = true;
4882 cfg.include_special_package_amendments = match chain {
4883 Chain::Mainnet => Some(MAINNET_LINKAGE_AMENDMENTS.clone()),
4884 Chain::Testnet => Some(TESTNET_LINKAGE_AMENDMENTS.clone()),
4885 Chain::Unknown => None,
4886 };
4887 cfg.gasless_max_tx_size_bytes = Some(16 * 1024);
4888 cfg.gasless_max_tps = Some(300);
4889 cfg.gasless_max_computation_units = Some(5_000);
4890 }
4891 123 => {
4892 cfg.gas_model_version = Some(13);
4893 }
4894 124 => {
4895 if chain != Chain::Mainnet && chain != Chain::Testnet {
4896 cfg.feature_flags.timestamp_based_epoch_close = true;
4897 }
4898 cfg.gas_model_version = Some(14);
4899 cfg.feature_flags.limit_groth16_pvk_inputs = true;
4900 }
4901 _ => panic!("unsupported version {:?}", version),
4912 }
4913 }
4914
4915 cfg
4916 }
4917
4918 pub fn apply_seeded_test_overrides(&mut self, seed: &[u8; 32]) {
4919 if !self.feature_flags.randomize_checkpoint_tx_limit_in_tests
4920 || !self.feature_flags.split_checkpoints_in_consensus_handler
4921 {
4922 return;
4923 }
4924
4925 if !mysten_common::in_test_configuration() {
4926 return;
4927 }
4928
4929 use rand::{Rng, SeedableRng, rngs::StdRng};
4930 let mut rng = StdRng::from_seed(*seed);
4931 let max_txns = rng.gen_range(10..=100u64);
4932 info!("seeded test override: max_transactions_per_checkpoint = {max_txns}");
4933 self.max_transactions_per_checkpoint = Some(max_txns);
4934 }
4935
4936 pub fn verifier_config(&self, signing_limits: Option<(usize, usize, usize)>) -> VerifierConfig {
4942 let (
4943 max_back_edges_per_function,
4944 max_back_edges_per_module,
4945 sanity_check_with_regex_reference_safety,
4946 ) = if let Some((
4947 max_back_edges_per_function,
4948 max_back_edges_per_module,
4949 sanity_check_with_regex_reference_safety,
4950 )) = signing_limits
4951 {
4952 (
4953 Some(max_back_edges_per_function),
4954 Some(max_back_edges_per_module),
4955 Some(sanity_check_with_regex_reference_safety),
4956 )
4957 } else {
4958 (None, None, None)
4959 };
4960
4961 let additional_borrow_checks = if signing_limits.is_some() {
4962 true
4964 } else {
4965 self.additional_borrow_checks()
4966 };
4967 let deprecate_global_storage_ops = if signing_limits.is_some() {
4968 true
4970 } else {
4971 self.deprecate_global_storage_ops()
4972 };
4973
4974 VerifierConfig {
4975 max_loop_depth: Some(self.max_loop_depth() as usize),
4976 max_generic_instantiation_length: Some(self.max_generic_instantiation_length() as usize),
4977 max_function_parameters: Some(self.max_function_parameters() as usize),
4978 max_basic_blocks: Some(self.max_basic_blocks() as usize),
4979 max_value_stack_size: self.max_value_stack_size() as usize,
4980 max_type_nodes: Some(self.max_type_nodes() as usize),
4981 max_push_size: Some(self.max_push_size() as usize),
4982 max_dependency_depth: Some(self.max_dependency_depth() as usize),
4983 max_fields_in_struct: Some(self.max_fields_in_struct() as usize),
4984 max_function_definitions: Some(self.max_function_definitions() as usize),
4985 max_data_definitions: Some(self.max_struct_definitions() as usize),
4986 max_constant_vector_len: Some(self.max_move_vector_len()),
4987 max_back_edges_per_function,
4988 max_back_edges_per_module,
4989 max_basic_blocks_in_script: None,
4990 max_identifier_len: self.max_move_identifier_len_as_option(), disallow_self_identifier: self.feature_flags.disallow_self_identifier,
4992 allow_receiving_object_id: self.allow_receiving_object_id(),
4993 reject_mutable_random_on_entry_functions: self
4994 .reject_mutable_random_on_entry_functions(),
4995 bytecode_version: self.move_binary_format_version(),
4996 max_variants_in_enum: self.max_move_enum_variants_as_option(),
4997 additional_borrow_checks,
4998 better_loader_errors: self.better_loader_errors(),
4999 private_generics_verifier_v2: self.private_generics_verifier_v2(),
5000 sanity_check_with_regex_reference_safety: sanity_check_with_regex_reference_safety
5001 .map(|limit| limit as u128),
5002 deprecate_global_storage_ops,
5003 disable_entry_point_signature_check: self.disable_entry_point_signature_check(),
5004 switch_to_regex_reference_safety: false,
5005 disallow_jump_orphans: self.disallow_jump_orphans(),
5006 }
5007 }
5008
5009 pub fn binary_config(
5010 &self,
5011 override_deprecate_global_storage_ops_during_deserialization: Option<bool>,
5012 ) -> BinaryConfig {
5013 let deprecate_global_storage_ops =
5014 override_deprecate_global_storage_ops_during_deserialization
5015 .unwrap_or_else(|| self.deprecate_global_storage_ops());
5016 BinaryConfig::new(
5017 self.move_binary_format_version(),
5018 self.min_move_binary_format_version_as_option()
5019 .unwrap_or(VERSION_1),
5020 self.no_extraneous_module_bytes(),
5021 deprecate_global_storage_ops,
5022 TableConfig {
5023 module_handles: self.binary_module_handles_as_option().unwrap_or(u16::MAX),
5024 datatype_handles: self.binary_struct_handles_as_option().unwrap_or(u16::MAX),
5025 function_handles: self.binary_function_handles_as_option().unwrap_or(u16::MAX),
5026 function_instantiations: self
5027 .binary_function_instantiations_as_option()
5028 .unwrap_or(u16::MAX),
5029 signatures: self.binary_signatures_as_option().unwrap_or(u16::MAX),
5030 constant_pool: self.binary_constant_pool_as_option().unwrap_or(u16::MAX),
5031 identifiers: self.binary_identifiers_as_option().unwrap_or(u16::MAX),
5032 address_identifiers: self
5033 .binary_address_identifiers_as_option()
5034 .unwrap_or(u16::MAX),
5035 struct_defs: self.binary_struct_defs_as_option().unwrap_or(u16::MAX),
5036 struct_def_instantiations: self
5037 .binary_struct_def_instantiations_as_option()
5038 .unwrap_or(u16::MAX),
5039 function_defs: self.binary_function_defs_as_option().unwrap_or(u16::MAX),
5040 field_handles: self.binary_field_handles_as_option().unwrap_or(u16::MAX),
5041 field_instantiations: self
5042 .binary_field_instantiations_as_option()
5043 .unwrap_or(u16::MAX),
5044 friend_decls: self.binary_friend_decls_as_option().unwrap_or(u16::MAX),
5045 enum_defs: self.binary_enum_defs_as_option().unwrap_or(u16::MAX),
5046 enum_def_instantiations: self
5047 .binary_enum_def_instantiations_as_option()
5048 .unwrap_or(u16::MAX),
5049 variant_handles: self.binary_variant_handles_as_option().unwrap_or(u16::MAX),
5050 variant_instantiation_handles: self
5051 .binary_variant_instantiation_handles_as_option()
5052 .unwrap_or(u16::MAX),
5053 },
5054 )
5055 }
5056
5057 #[cfg(not(msim))]
5061 pub fn apply_overrides_for_testing(
5062 override_fn: impl Fn(ProtocolVersion, Self) -> Self + Send + Sync + 'static,
5063 ) -> OverrideGuard {
5064 let mut cur = CONFIG_OVERRIDE.lock().unwrap();
5065 assert!(cur.is_none(), "config override already present");
5066 *cur = Some(Box::new(override_fn));
5067 OverrideGuard
5068 }
5069
5070 #[cfg(msim)]
5074 pub fn apply_overrides_for_testing(
5075 override_fn: impl Fn(ProtocolVersion, Self) -> Self + Send + 'static,
5076 ) -> OverrideGuard {
5077 CONFIG_OVERRIDE.with(|ovr| {
5078 let mut cur = ovr.borrow_mut();
5079 assert!(cur.is_none(), "config override already present");
5080 *cur = Some(Box::new(override_fn));
5081 OverrideGuard
5082 })
5083 }
5084
5085 #[cfg(not(msim))]
5086 fn apply_config_override(version: ProtocolVersion, mut ret: Self) -> Self {
5087 if let Some(override_fn) = CONFIG_OVERRIDE.lock().unwrap().as_ref() {
5088 warn!(
5089 "overriding ProtocolConfig settings with custom settings (you should not see this log outside of tests)"
5090 );
5091 ret = override_fn(version, ret);
5092 }
5093 ret
5094 }
5095
5096 #[cfg(msim)]
5097 fn apply_config_override(version: ProtocolVersion, ret: Self) -> Self {
5098 CONFIG_OVERRIDE.with(|ovr| {
5099 if let Some(override_fn) = &*ovr.borrow() {
5100 warn!(
5101 "overriding ProtocolConfig settings with custom settings (you should not see this log outside of tests)"
5102 );
5103 override_fn(version, ret)
5104 } else {
5105 ret
5106 }
5107 })
5108 }
5109}
5110
5111impl ProtocolConfig {
5115 pub fn set_advance_to_highest_supported_protocol_version_for_testing(&mut self, val: bool) {
5116 self.feature_flags
5117 .advance_to_highest_supported_protocol_version = val
5118 }
5119 pub fn set_commit_root_state_digest_supported_for_testing(&mut self, val: bool) {
5120 self.feature_flags.commit_root_state_digest = val
5121 }
5122 pub fn set_zklogin_auth_for_testing(&mut self, val: bool) {
5123 self.feature_flags.zklogin_auth = val
5124 }
5125 pub fn set_enable_jwk_consensus_updates_for_testing(&mut self, val: bool) {
5126 self.feature_flags.enable_jwk_consensus_updates = val
5127 }
5128 pub fn set_random_beacon_for_testing(&mut self, val: bool) {
5129 self.feature_flags.random_beacon = val
5130 }
5131
5132 pub fn set_upgraded_multisig_for_testing(&mut self, val: bool) {
5133 self.feature_flags.upgraded_multisig_supported = val
5134 }
5135 pub fn set_accept_zklogin_in_multisig_for_testing(&mut self, val: bool) {
5136 self.feature_flags.accept_zklogin_in_multisig = val
5137 }
5138
5139 pub fn set_shared_object_deletion_for_testing(&mut self, val: bool) {
5140 self.feature_flags.shared_object_deletion = val;
5141 }
5142
5143 pub fn set_narwhal_new_leader_election_schedule_for_testing(&mut self, val: bool) {
5144 self.feature_flags.narwhal_new_leader_election_schedule = val;
5145 }
5146
5147 pub fn set_receive_object_for_testing(&mut self, val: bool) {
5148 self.feature_flags.receive_objects = val
5149 }
5150 pub fn set_narwhal_certificate_v2_for_testing(&mut self, val: bool) {
5151 self.feature_flags.narwhal_certificate_v2 = val
5152 }
5153 pub fn set_verify_legacy_zklogin_address_for_testing(&mut self, val: bool) {
5154 self.feature_flags.verify_legacy_zklogin_address = val
5155 }
5156
5157 pub fn set_per_object_congestion_control_mode_for_testing(
5158 &mut self,
5159 val: PerObjectCongestionControlMode,
5160 ) {
5161 self.feature_flags.per_object_congestion_control_mode = val;
5162 }
5163
5164 pub fn set_consensus_choice_for_testing(&mut self, val: ConsensusChoice) {
5165 self.feature_flags.consensus_choice = val;
5166 }
5167
5168 pub fn set_consensus_network_for_testing(&mut self, val: ConsensusNetwork) {
5169 self.feature_flags.consensus_network = val;
5170 }
5171
5172 pub fn set_zklogin_max_epoch_upper_bound_delta_for_testing(&mut self, val: Option<u64>) {
5173 self.feature_flags.zklogin_max_epoch_upper_bound_delta = val
5174 }
5175
5176 pub fn set_disable_bridge_for_testing(&mut self) {
5177 self.feature_flags.bridge = false
5178 }
5179
5180 pub fn set_mysticeti_num_leaders_per_round_for_testing(&mut self, val: Option<usize>) {
5181 self.feature_flags.mysticeti_num_leaders_per_round = val;
5182 }
5183
5184 pub fn set_enable_soft_bundle_for_testing(&mut self, val: bool) {
5185 self.feature_flags.soft_bundle = val;
5186 }
5187
5188 pub fn set_passkey_auth_for_testing(&mut self, val: bool) {
5189 self.feature_flags.passkey_auth = val
5190 }
5191
5192 pub fn set_enable_party_transfer_for_testing(&mut self, val: bool) {
5193 self.feature_flags.enable_party_transfer = val
5194 }
5195
5196 pub fn set_consensus_distributed_vote_scoring_strategy_for_testing(&mut self, val: bool) {
5197 self.feature_flags
5198 .consensus_distributed_vote_scoring_strategy = val;
5199 }
5200
5201 pub fn set_consensus_round_prober_for_testing(&mut self, val: bool) {
5202 self.feature_flags.consensus_round_prober = val;
5203 }
5204
5205 pub fn set_disallow_new_modules_in_deps_only_packages_for_testing(&mut self, val: bool) {
5206 self.feature_flags
5207 .disallow_new_modules_in_deps_only_packages = val;
5208 }
5209
5210 pub fn set_correct_gas_payment_limit_check_for_testing(&mut self, val: bool) {
5211 self.feature_flags.correct_gas_payment_limit_check = val;
5212 }
5213
5214 pub fn set_address_aliases_for_testing(&mut self, val: bool) {
5215 self.feature_flags.address_aliases = val;
5216 }
5217
5218 pub fn set_consensus_round_prober_probe_accepted_rounds(&mut self, val: bool) {
5219 self.feature_flags
5220 .consensus_round_prober_probe_accepted_rounds = val;
5221 }
5222
5223 pub fn set_mysticeti_fastpath_for_testing(&mut self, val: bool) {
5224 self.feature_flags.mysticeti_fastpath = val;
5225 }
5226
5227 pub fn set_accept_passkey_in_multisig_for_testing(&mut self, val: bool) {
5228 self.feature_flags.accept_passkey_in_multisig = val;
5229 }
5230
5231 pub fn set_consensus_batched_block_sync_for_testing(&mut self, val: bool) {
5232 self.feature_flags.consensus_batched_block_sync = val;
5233 }
5234
5235 pub fn set_record_time_estimate_processed_for_testing(&mut self, val: bool) {
5236 self.feature_flags.record_time_estimate_processed = val;
5237 }
5238
5239 pub fn set_prepend_prologue_tx_in_consensus_commit_in_checkpoints_for_testing(
5240 &mut self,
5241 val: bool,
5242 ) {
5243 self.feature_flags
5244 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = val;
5245 }
5246
5247 pub fn enable_accumulators_for_testing(&mut self) {
5248 self.feature_flags.enable_accumulators = true;
5249 }
5250
5251 pub fn disable_accumulators_for_testing(&mut self) {
5252 self.feature_flags.enable_accumulators = false;
5253 self.feature_flags.enable_address_balance_gas_payments = false;
5254 }
5255
5256 pub fn enable_coin_reservation_for_testing(&mut self) {
5257 self.feature_flags.enable_coin_reservation_obj_refs = true;
5258 self.feature_flags
5259 .convert_withdrawal_compatibility_ptb_arguments = true;
5260 self.execution_version = Some(self.execution_version.map_or(4, |v| v.max(4)));
5263 }
5264
5265 pub fn disable_coin_reservation_for_testing(&mut self) {
5266 self.feature_flags.enable_coin_reservation_obj_refs = false;
5267 self.feature_flags
5268 .convert_withdrawal_compatibility_ptb_arguments = false;
5269 }
5270
5271 pub fn create_root_accumulator_object_for_testing(&mut self) {
5272 self.feature_flags.create_root_accumulator_object = true;
5273 }
5274
5275 pub fn disable_create_root_accumulator_object_for_testing(&mut self) {
5276 self.feature_flags.create_root_accumulator_object = false;
5277 }
5278
5279 pub fn enable_address_balance_gas_payments_for_testing(&mut self) {
5280 self.feature_flags.enable_accumulators = true;
5281 self.feature_flags.allow_private_accumulator_entrypoints = true;
5282 self.feature_flags.enable_address_balance_gas_payments = true;
5283 self.feature_flags.address_balance_gas_check_rgp_at_signing = true;
5284 self.feature_flags.address_balance_gas_reject_gas_coin_arg = false;
5285 self.execution_version = Some(self.execution_version.map_or(4, |v| v.max(4)))
5286 }
5287
5288 pub fn disable_address_balance_gas_payments_for_testing(&mut self) {
5289 self.feature_flags.enable_address_balance_gas_payments = false;
5290 }
5291
5292 pub fn enable_gasless_for_testing(&mut self) {
5293 self.enable_address_balance_gas_payments_for_testing();
5294 self.feature_flags.enable_gasless = true;
5295 self.feature_flags.gasless_verify_remaining_balance = true;
5296 self.gasless_max_computation_units = Some(5_000);
5297 self.gasless_allowed_token_types = Some(vec![]);
5298 self.gasless_max_tps = Some(1000);
5299 self.gasless_max_tx_size_bytes = Some(16 * 1024);
5300 }
5301
5302 pub fn disable_gasless_for_testing(&mut self) {
5303 self.feature_flags.enable_gasless = false;
5304 self.gasless_max_computation_units = None;
5305 self.gasless_allowed_token_types = None;
5306 }
5307
5308 pub fn set_gasless_allowed_token_types_for_testing(&mut self, types: Vec<(String, u64)>) {
5309 self.gasless_allowed_token_types = Some(types);
5310 }
5311
5312 pub fn enable_multi_epoch_transaction_expiration_for_testing(&mut self) {
5313 self.feature_flags.enable_multi_epoch_transaction_expiration = true;
5314 }
5315
5316 pub fn enable_authenticated_event_streams_for_testing(&mut self) {
5317 self.enable_accumulators_for_testing();
5318 self.feature_flags.enable_authenticated_event_streams = true;
5319 self.feature_flags
5320 .include_checkpoint_artifacts_digest_in_summary = true;
5321 self.feature_flags.split_checkpoints_in_consensus_handler = true;
5322 }
5323
5324 pub fn disable_authenticated_event_streams_for_testing(&mut self) {
5325 self.feature_flags.enable_authenticated_event_streams = false;
5326 }
5327
5328 pub fn disable_randomize_checkpoint_tx_limit_for_testing(&mut self) {
5329 self.feature_flags.randomize_checkpoint_tx_limit_in_tests = false;
5330 }
5331
5332 pub fn enable_non_exclusive_writes_for_testing(&mut self) {
5333 self.feature_flags.enable_non_exclusive_writes = true;
5334 }
5335
5336 pub fn set_relax_valid_during_for_owned_inputs_for_testing(&mut self, val: bool) {
5337 self.feature_flags.relax_valid_during_for_owned_inputs = val;
5338 }
5339
5340 pub fn set_ignore_execution_time_observations_after_certs_closed_for_testing(
5341 &mut self,
5342 val: bool,
5343 ) {
5344 self.feature_flags
5345 .ignore_execution_time_observations_after_certs_closed = val;
5346 }
5347
5348 pub fn set_consensus_checkpoint_signature_key_includes_digest_for_testing(
5349 &mut self,
5350 val: bool,
5351 ) {
5352 self.feature_flags
5353 .consensus_checkpoint_signature_key_includes_digest = val;
5354 }
5355
5356 pub fn set_cancel_for_failed_dkg_early_for_testing(&mut self, val: bool) {
5357 self.feature_flags.cancel_for_failed_dkg_early = val;
5358 }
5359
5360 pub fn set_use_mfp_txns_in_load_initial_object_debts_for_testing(&mut self, val: bool) {
5361 self.feature_flags.use_mfp_txns_in_load_initial_object_debts = val;
5362 }
5363
5364 pub fn set_authority_capabilities_v2_for_testing(&mut self, val: bool) {
5365 self.feature_flags.authority_capabilities_v2 = val;
5366 }
5367
5368 pub fn allow_references_in_ptbs_for_testing(&mut self) {
5369 self.feature_flags.allow_references_in_ptbs = true;
5370 }
5371
5372 pub fn set_consensus_skip_gced_accept_votes_for_testing(&mut self, val: bool) {
5373 self.feature_flags.consensus_skip_gced_accept_votes = val;
5374 }
5375
5376 pub fn set_enable_object_funds_withdraw_for_testing(&mut self, val: bool) {
5377 self.feature_flags.enable_object_funds_withdraw = val;
5378 }
5379
5380 pub fn set_split_checkpoints_in_consensus_handler_for_testing(&mut self, val: bool) {
5381 self.feature_flags.split_checkpoints_in_consensus_handler = val;
5382 }
5383
5384 pub fn set_merge_randomness_into_checkpoint_for_testing(&mut self, val: bool) {
5385 self.feature_flags.merge_randomness_into_checkpoint = val;
5386 }
5387}
5388
5389#[cfg(not(msim))]
5390type OverrideFn = dyn Fn(ProtocolVersion, ProtocolConfig) -> ProtocolConfig + Send + Sync;
5391
5392#[cfg(not(msim))]
5393static CONFIG_OVERRIDE: Mutex<Option<Box<OverrideFn>>> = Mutex::new(None);
5394
5395#[cfg(msim)]
5396type OverrideFn = dyn Fn(ProtocolVersion, ProtocolConfig) -> ProtocolConfig + Send;
5397
5398#[cfg(msim)]
5399thread_local! {
5400 static CONFIG_OVERRIDE: RefCell<Option<Box<OverrideFn>>> = RefCell::new(None);
5401}
5402
5403#[must_use]
5404pub struct OverrideGuard;
5405
5406#[cfg(not(msim))]
5407impl Drop for OverrideGuard {
5408 fn drop(&mut self) {
5409 info!("restoring override fn");
5410 *CONFIG_OVERRIDE.lock().unwrap() = None;
5411 }
5412}
5413
5414#[cfg(msim)]
5415impl Drop for OverrideGuard {
5416 fn drop(&mut self) {
5417 info!("restoring override fn");
5418 CONFIG_OVERRIDE.with(|ovr| {
5419 *ovr.borrow_mut() = None;
5420 });
5421 }
5422}
5423
5424#[derive(PartialEq, Eq)]
5427pub enum LimitThresholdCrossed {
5428 None,
5429 Soft(u128, u128),
5430 Hard(u128, u128),
5431}
5432
5433pub fn check_limit_in_range<T: Into<V>, U: Into<V>, V: PartialOrd + Into<u128>>(
5436 x: T,
5437 soft_limit: U,
5438 hard_limit: V,
5439) -> LimitThresholdCrossed {
5440 let x: V = x.into();
5441 let soft_limit: V = soft_limit.into();
5442
5443 debug_assert!(soft_limit <= hard_limit);
5444
5445 if x >= hard_limit {
5448 LimitThresholdCrossed::Hard(x.into(), hard_limit.into())
5449 } else if x < soft_limit {
5450 LimitThresholdCrossed::None
5451 } else {
5452 LimitThresholdCrossed::Soft(x.into(), soft_limit.into())
5453 }
5454}
5455
5456#[macro_export]
5457macro_rules! check_limit {
5458 ($x:expr, $hard:expr) => {
5459 check_limit!($x, $hard, $hard)
5460 };
5461 ($x:expr, $soft:expr, $hard:expr) => {
5462 check_limit_in_range($x as u64, $soft, $hard)
5463 };
5464}
5465
5466#[macro_export]
5470macro_rules! check_limit_by_meter {
5471 ($is_metered:expr, $x:expr, $metered_limit:expr, $unmetered_hard_limit:expr, $metric:expr) => {{
5472 let (h, metered_str) = if $is_metered {
5474 ($metered_limit, "metered")
5475 } else {
5476 ($unmetered_hard_limit, "unmetered")
5478 };
5479 use sui_protocol_config::check_limit_in_range;
5480 let result = check_limit_in_range($x as u64, $metered_limit, h);
5481 match result {
5482 LimitThresholdCrossed::None => {}
5483 LimitThresholdCrossed::Soft(_, _) => {
5484 $metric.with_label_values(&[metered_str, "soft"]).inc();
5485 }
5486 LimitThresholdCrossed::Hard(_, _) => {
5487 $metric.with_label_values(&[metered_str, "hard"]).inc();
5488 }
5489 };
5490 result
5491 }};
5492}
5493
5494pub type Amendments = BTreeMap<AccountAddress, BTreeMap<AccountAddress, AccountAddress>>;
5497
5498static MAINNET_LINKAGE_AMENDMENTS: LazyLock<Arc<Amendments>> =
5499 LazyLock::new(|| parse_amendments(include_str!("mainnet_amendments.json")));
5500
5501static TESTNET_LINKAGE_AMENDMENTS: LazyLock<Arc<Amendments>> =
5502 LazyLock::new(|| parse_amendments(include_str!("testnet_amendments.json")));
5503
5504fn parse_amendments(json: &str) -> Arc<Amendments> {
5505 #[derive(serde::Deserialize)]
5506 struct AmendmentEntry {
5507 root: String,
5508 deps: Vec<DepEntry>,
5509 }
5510
5511 #[derive(serde::Deserialize)]
5512 struct DepEntry {
5513 original_id: String,
5514 version_id: String,
5515 }
5516
5517 let entries: Vec<AmendmentEntry> =
5518 serde_json::from_str(json).expect("Failed to parse amendments JSON");
5519 let mut amendments = BTreeMap::new();
5520 for entry in entries {
5521 let root_id = AccountAddress::from_hex_literal(&entry.root).unwrap();
5522 let mut dep_ids = BTreeMap::new();
5523 for dep in entry.deps {
5524 let orig_id = AccountAddress::from_hex_literal(&dep.original_id).unwrap();
5525 let upgraded_id = AccountAddress::from_hex_literal(&dep.version_id).unwrap();
5526 assert!(
5527 dep_ids.insert(orig_id, upgraded_id).is_none(),
5528 "Duplicate original ID in amendments table"
5529 );
5530 }
5531 assert!(
5532 amendments.insert(root_id, dep_ids).is_none(),
5533 "Duplicate root ID in amendments table"
5534 );
5535 }
5536 Arc::new(amendments)
5537}
5538
5539#[cfg(all(test, not(msim)))]
5540mod test {
5541 use insta::assert_yaml_snapshot;
5542
5543 use super::*;
5544
5545 #[test]
5546 fn snapshot_tests() {
5547 println!("\n============================================================================");
5548 println!("! !");
5549 println!("! IMPORTANT: never update snapshots from this test. only add new versions! !");
5550 println!("! !");
5551 println!("============================================================================\n");
5552 for chain_id in &[Chain::Unknown, Chain::Mainnet, Chain::Testnet] {
5553 let chain_str = match chain_id {
5557 Chain::Unknown => "".to_string(),
5558 _ => format!("{:?}_", chain_id),
5559 };
5560 for i in MIN_PROTOCOL_VERSION..=MAX_PROTOCOL_VERSION {
5561 let cur = ProtocolVersion::new(i);
5562 assert_yaml_snapshot!(
5563 format!("{}version_{}", chain_str, cur.as_u64()),
5564 ProtocolConfig::get_for_version(cur, *chain_id)
5565 );
5566 }
5567 }
5568 }
5569
5570 #[test]
5571 fn test_getters() {
5572 let prot: ProtocolConfig =
5573 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5574 assert_eq!(
5575 prot.max_arguments(),
5576 prot.max_arguments_as_option().unwrap()
5577 );
5578 }
5579
5580 #[test]
5581 fn test_setters() {
5582 let mut prot: ProtocolConfig =
5583 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5584 prot.set_max_arguments_for_testing(123);
5585 assert_eq!(prot.max_arguments(), 123);
5586
5587 prot.set_max_arguments_from_str_for_testing("321".to_string());
5588 assert_eq!(prot.max_arguments(), 321);
5589
5590 prot.disable_max_arguments_for_testing();
5591 assert_eq!(prot.max_arguments_as_option(), None);
5592
5593 prot.set_attr_for_testing("max_arguments".to_string(), "456".to_string());
5594 assert_eq!(prot.max_arguments(), 456);
5595 }
5596
5597 #[test]
5598 fn test_get_for_version_if_supported_applies_test_overrides() {
5599 let before =
5600 ProtocolConfig::get_for_version_if_supported(ProtocolVersion::new(1), Chain::Unknown)
5601 .unwrap();
5602
5603 assert!(!before.enable_coin_reservation_obj_refs());
5604
5605 let _guard = ProtocolConfig::apply_overrides_for_testing(|_, mut cfg| {
5606 cfg.enable_coin_reservation_for_testing();
5607 cfg
5608 });
5609
5610 let after =
5611 ProtocolConfig::get_for_version_if_supported(ProtocolVersion::new(1), Chain::Unknown)
5612 .unwrap();
5613
5614 assert!(after.enable_coin_reservation_obj_refs());
5615 }
5616
5617 #[test]
5618 #[should_panic(expected = "unsupported version")]
5619 fn max_version_test() {
5620 let _ = ProtocolConfig::get_for_version_impl(
5623 ProtocolVersion::new(MAX_PROTOCOL_VERSION + 1),
5624 Chain::Unknown,
5625 );
5626 }
5627
5628 #[test]
5629 fn lookup_by_string_test() {
5630 let prot: ProtocolConfig =
5631 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5632 assert!(prot.lookup_attr("some random string".to_string()).is_none());
5634
5635 assert!(
5636 prot.lookup_attr("max_arguments".to_string())
5637 == Some(ProtocolConfigValue::u32(prot.max_arguments())),
5638 );
5639
5640 assert!(
5642 prot.lookup_attr("max_move_identifier_len".to_string())
5643 .is_none()
5644 );
5645
5646 let prot: ProtocolConfig =
5648 ProtocolConfig::get_for_version(ProtocolVersion::new(9), Chain::Unknown);
5649 assert!(
5650 prot.lookup_attr("max_move_identifier_len".to_string())
5651 == Some(ProtocolConfigValue::u64(prot.max_move_identifier_len()))
5652 );
5653
5654 let prot: ProtocolConfig =
5655 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5656 assert!(
5658 prot.attr_map()
5659 .get("max_move_identifier_len")
5660 .unwrap()
5661 .is_none()
5662 );
5663 assert!(
5665 prot.attr_map().get("max_arguments").unwrap()
5666 == &Some(ProtocolConfigValue::u32(prot.max_arguments()))
5667 );
5668
5669 let prot: ProtocolConfig =
5671 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5672 assert!(
5674 prot.feature_flags
5675 .lookup_attr("some random string".to_owned())
5676 .is_none()
5677 );
5678 assert!(
5679 !prot
5680 .feature_flags
5681 .attr_map()
5682 .contains_key("some random string")
5683 );
5684
5685 assert!(
5687 prot.feature_flags
5688 .lookup_attr("package_upgrades".to_owned())
5689 == Some(false)
5690 );
5691 assert!(
5692 prot.feature_flags
5693 .attr_map()
5694 .get("package_upgrades")
5695 .unwrap()
5696 == &false
5697 );
5698 let prot: ProtocolConfig =
5699 ProtocolConfig::get_for_version(ProtocolVersion::new(4), Chain::Unknown);
5700 assert!(
5702 prot.feature_flags
5703 .lookup_attr("package_upgrades".to_owned())
5704 == Some(true)
5705 );
5706 assert!(
5707 prot.feature_flags
5708 .attr_map()
5709 .get("package_upgrades")
5710 .unwrap()
5711 == &true
5712 );
5713 }
5714
5715 #[test]
5716 fn limit_range_fn_test() {
5717 let low = 100u32;
5718 let high = 10000u64;
5719
5720 assert!(check_limit!(1u8, low, high) == LimitThresholdCrossed::None);
5721 assert!(matches!(
5722 check_limit!(255u16, low, high),
5723 LimitThresholdCrossed::Soft(255u128, 100)
5724 ));
5725 assert!(matches!(
5731 check_limit!(2550000u64, low, high),
5732 LimitThresholdCrossed::Hard(2550000, 10000)
5733 ));
5734
5735 assert!(matches!(
5736 check_limit!(2550000u64, high, high),
5737 LimitThresholdCrossed::Hard(2550000, 10000)
5738 ));
5739
5740 assert!(matches!(
5741 check_limit!(1u8, high),
5742 LimitThresholdCrossed::None
5743 ));
5744
5745 assert!(check_limit!(255u16, high) == LimitThresholdCrossed::None);
5746
5747 assert!(matches!(
5748 check_limit!(2550000u64, high),
5749 LimitThresholdCrossed::Hard(2550000, 10000)
5750 ));
5751 }
5752
5753 #[test]
5754 fn linkage_amendments_load() {
5755 let mainnet = LazyLock::force(&MAINNET_LINKAGE_AMENDMENTS);
5756 let testnet = LazyLock::force(&TESTNET_LINKAGE_AMENDMENTS);
5757 assert!(!mainnet.is_empty(), "mainnet amendments must not be empty");
5758 assert!(!testnet.is_empty(), "testnet amendments must not be empty");
5759 }
5760}