1use std::{
5 collections::{BTreeMap, BTreeSet},
6 sync::{
7 Arc, LazyLock,
8 atomic::{AtomicBool, Ordering},
9 },
10};
11
12use std::sync::Mutex;
13
14use clap::*;
15use fastcrypto::encoding::{Base58, Encoding, Hex};
16use move_binary_format::{
17 binary_config::{BinaryConfig, BinaryFormatLimitsProfile, TableConfig},
18 file_format_common::*,
19};
20use move_core_types::account_address::AccountAddress;
21use move_vm_config::verifier::VerifierConfig;
22use mysten_common::in_integration_test;
23use serde::{Deserialize, Serialize};
24use serde_with::skip_serializing_none;
25use sui_protocol_config_macros::{
26 ProtocolConfigAccessors, ProtocolConfigFeatureFlagsGetters, ProtocolConfigOverride,
27};
28use tracing::{info, warn};
29
30pub mod reachability;
31
32#[doc(hidden)]
35pub use antithesis_sdk::linkme;
36#[doc(hidden)]
37pub use mysten_common::assert_reachable_simtest;
38
39const MIN_PROTOCOL_VERSION: u64 = 1;
41const MAX_PROTOCOL_VERSION: u64 = 145;
42
43const TESTNET_USDC: &str =
44 "0xa1ec7fc00a6f40db9693ad1415d0c193ad3906494428cf252621037bd7117e29::usdc::USDC";
45
46const MAINNET_USDC: &str =
47 "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
48const MAINNET_USDSUI: &str =
49 "0x44f838219cf67b058f3b37907b655f226153c18e33dfcd0da559a844fea9b1c1::usdsui::USDSUI";
50const MAINNET_SUI_USDE: &str =
51 "0x41d587e5336f1c86cad50d38a7136db99333bb9bda91cea4ba69115defeb1402::sui_usde::SUI_USDE";
52const MAINNET_USDY: &str =
53 "0x960b531667636f39e85867775f52f6b1f220a058c4de786905bdf761e06a56bb::usdy::USDY";
54const MAINNET_FDUSD: &str =
55 "0xf16e6b723f242ec745dfd7634ad072c42d5c1d9ac9d62a39c381303eaa57693a::fdusd::FDUSD";
56const MAINNET_AUSD: &str =
57 "0x2053d08c1e2bd02791056171aab0fd12bd7cd7efad2ab8f6b9c8902f14df2ff2::ausd::AUSD";
58const MAINNET_USDB: &str =
59 "0xe14726c336e81b32328e92afc37345d159f5b550b09fa92bd43640cfdd0a0cfd::usdb::USDB";
60
61#[derive(Copy, Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
453pub struct ProtocolVersion(u64);
454
455impl ProtocolVersion {
456 pub const MIN: Self = Self(MIN_PROTOCOL_VERSION);
461
462 pub const MAX: Self = Self(MAX_PROTOCOL_VERSION);
463
464 #[cfg(not(msim))]
465 pub const MAX_ALLOWED: Self = Self::MAX;
466
467 #[cfg(msim)]
469 pub const MAX_ALLOWED: Self = Self(MAX_PROTOCOL_VERSION + 1);
470
471 pub fn new(v: u64) -> Self {
472 Self(v)
473 }
474
475 pub const fn as_u64(&self) -> u64 {
476 self.0
477 }
478
479 pub fn max() -> Self {
482 Self::MAX
483 }
484
485 pub fn prev(self) -> Self {
486 Self(self.0.checked_sub(1).unwrap())
487 }
488}
489
490impl From<u64> for ProtocolVersion {
491 fn from(v: u64) -> Self {
492 Self::new(v)
493 }
494}
495
496impl std::ops::Sub<u64> for ProtocolVersion {
497 type Output = Self;
498 fn sub(self, rhs: u64) -> Self::Output {
499 Self::new(self.0 - rhs)
500 }
501}
502
503impl std::ops::Add<u64> for ProtocolVersion {
504 type Output = Self;
505 fn add(self, rhs: u64) -> Self::Output {
506 Self::new(self.0 + rhs)
507 }
508}
509
510#[derive(
511 Clone, Serialize, Deserialize, Debug, Default, PartialEq, Copy, PartialOrd, Ord, Eq, ValueEnum,
512)]
513pub enum Chain {
514 Mainnet,
515 Testnet,
516 #[default]
517 Unknown,
518}
519
520impl Chain {
521 pub fn as_str(self) -> &'static str {
522 match self {
523 Chain::Mainnet => "mainnet",
524 Chain::Testnet => "testnet",
525 Chain::Unknown => "unknown",
526 }
527 }
528}
529
530pub fn max_across_protocol<T: Ord>(f: impl Fn(&ProtocolConfig) -> Option<T>) -> Option<T> {
532 let mut max = None;
533 let mut version = ProtocolVersion::MIN;
534 while version <= ProtocolVersion::MAX {
535 max = max.max(f(&ProtocolConfig::get_for_version(version, Chain::Unknown)));
536 max = max.max(f(&ProtocolConfig::get_for_version(version, Chain::Mainnet)));
537 max = max.max(f(&ProtocolConfig::get_for_version(version, Chain::Testnet)));
538 version = version + 1;
539 }
540 max
541}
542
543pub struct Error(pub String);
544
545#[derive(Default, Clone, Serialize, Deserialize, Debug, ProtocolConfigFeatureFlagsGetters)]
548struct FeatureFlags {
549 #[serde(skip_serializing_if = "is_false")]
552 package_upgrades: bool,
553 #[serde(skip_serializing_if = "is_false")]
556 commit_root_state_digest: bool,
557 #[serde(skip_serializing_if = "is_false")]
559 advance_epoch_start_time_in_safe_mode: bool,
560 #[serde(skip_serializing_if = "is_false")]
563 loaded_child_objects_fixed: bool,
564 #[serde(skip_serializing_if = "is_false")]
567 missing_type_is_compatibility_error: bool,
568 #[serde(skip_serializing_if = "is_false")]
571 scoring_decision_with_validity_cutoff: bool,
572
573 #[serde(skip_serializing_if = "is_false")]
576 consensus_order_end_of_epoch_last: bool,
577
578 #[serde(skip_serializing_if = "is_false")]
582 consensus_slim_block_propagation: bool,
583
584 #[serde(skip_serializing_if = "is_false")]
586 disallow_adding_abilities_on_upgrade: bool,
587 #[serde(skip_serializing_if = "is_false")]
589 disable_invariant_violation_check_in_swap_loc: bool,
590 #[serde(skip_serializing_if = "is_false")]
593 advance_to_highest_supported_protocol_version: bool,
594 #[serde(skip_serializing_if = "is_false")]
596 ban_entry_init: bool,
597 #[serde(skip_serializing_if = "is_false")]
599 package_digest_hash_module: bool,
600 #[serde(skip_serializing_if = "is_false")]
602 disallow_change_struct_type_params_on_upgrade: bool,
603 #[serde(skip_serializing_if = "is_false")]
605 no_extraneous_module_bytes: bool,
606 #[serde(skip_serializing_if = "is_false")]
608 narwhal_versioned_metadata: bool,
609
610 #[serde(skip_serializing_if = "is_false")]
612 zklogin_auth: bool,
613 #[serde(skip_serializing_if = "is_zero")]
616 zklogin_circuit_mode: u64,
617 #[serde(skip_serializing_if = "ConsensusTransactionOrdering::is_none")]
619 consensus_transaction_ordering: ConsensusTransactionOrdering,
620
621 #[serde(skip_serializing_if = "is_false")]
629 simplified_unwrap_then_delete: bool,
630 #[serde(skip_serializing_if = "is_false")]
632 upgraded_multisig_supported: bool,
633 #[serde(skip_serializing_if = "is_false")]
635 txn_base_cost_as_multiplier: bool,
636
637 #[serde(skip_serializing_if = "is_false")]
639 shared_object_deletion: bool,
640
641 #[serde(skip_serializing_if = "is_false")]
643 narwhal_new_leader_election_schedule: bool,
644
645 #[serde(skip_serializing_if = "is_empty")]
647 zklogin_supported_providers: BTreeSet<String>,
648
649 #[serde(skip_serializing_if = "is_false")]
651 loaded_child_object_format: bool,
652
653 #[serde(skip_serializing_if = "is_false")]
654 #[skip_protocol_config_accessor]
655 enable_jwk_consensus_updates: bool,
656
657 #[serde(skip_serializing_if = "is_false")]
658 #[skip_protocol_config_accessor]
659 end_of_epoch_transaction_supported: bool,
660
661 #[serde(skip_serializing_if = "is_false")]
664 simple_conservation_checks: bool,
665
666 #[serde(skip_serializing_if = "is_false")]
668 loaded_child_object_format_type: bool,
669
670 #[serde(skip_serializing_if = "is_false")]
672 receive_objects: bool,
673
674 #[serde(skip_serializing_if = "is_false")]
676 consensus_checkpoint_signature_key_includes_digest: bool,
677
678 #[serde(skip_serializing_if = "is_false")]
680 random_beacon: bool,
681
682 #[serde(skip_serializing_if = "is_false")]
684 #[skip_protocol_config_accessor]
685 bridge: bool,
686
687 #[serde(skip_serializing_if = "is_false")]
688 enable_effects_v2: bool,
689
690 #[serde(skip_serializing_if = "is_false")]
692 narwhal_certificate_v2: bool,
693
694 #[serde(skip_serializing_if = "is_false")]
696 verify_legacy_zklogin_address: bool,
697
698 #[serde(skip_serializing_if = "is_false")]
700 throughput_aware_consensus_submission: bool,
701
702 #[serde(skip_serializing_if = "is_false")]
704 recompute_has_public_transfer_in_execution: bool,
705
706 #[serde(skip_serializing_if = "is_false")]
708 accept_zklogin_in_multisig: bool,
709
710 #[serde(skip_serializing_if = "is_false")]
712 accept_passkey_in_multisig: bool,
713
714 #[serde(skip_serializing_if = "is_false")]
716 validate_zklogin_public_identifier: bool,
717
718 #[serde(skip_serializing_if = "is_false")]
721 include_consensus_digest_in_prologue: bool,
722
723 #[serde(skip_serializing_if = "is_false")]
725 hardened_otw_check: bool,
726
727 #[serde(skip_serializing_if = "is_false")]
729 allow_receiving_object_id: bool,
730
731 #[serde(skip_serializing_if = "is_false")]
733 enable_poseidon: bool,
734
735 #[serde(skip_serializing_if = "is_false")]
737 enable_coin_deny_list: bool,
738
739 #[serde(skip_serializing_if = "is_false")]
741 enable_group_ops_native_functions: bool,
742
743 #[serde(skip_serializing_if = "is_false")]
745 enable_group_ops_native_function_msm: bool,
746
747 #[serde(skip_serializing_if = "is_false")]
749 enable_ristretto255_group_ops: bool,
750
751 #[serde(skip_serializing_if = "is_false")]
753 enable_verify_bulletproofs_ristretto255: bool,
754
755 #[serde(skip_serializing_if = "is_false")]
757 enable_nitro_attestation: bool,
758
759 #[serde(skip_serializing_if = "is_false")]
761 enable_nitro_attestation_upgraded_parsing: bool,
762
763 #[serde(skip_serializing_if = "is_false")]
765 enable_nitro_attestation_all_nonzero_pcrs_parsing: bool,
766
767 #[serde(skip_serializing_if = "is_false")]
769 enable_nitro_attestation_always_include_required_pcrs_parsing: bool,
770
771 #[serde(skip_serializing_if = "is_false")]
774 simplify_nitro_header_validation: bool,
775
776 #[serde(skip_serializing_if = "is_false")]
778 reject_mutable_random_on_entry_functions: bool,
779
780 #[serde(skip_serializing_if = "PerObjectCongestionControlMode::is_none")]
782 per_object_congestion_control_mode: PerObjectCongestionControlMode,
783
784 #[serde(skip_serializing_if = "ConsensusChoice::is_narwhal")]
786 consensus_choice: ConsensusChoice,
787
788 #[serde(skip_serializing_if = "ConsensusNetwork::is_anemo")]
790 consensus_network: ConsensusNetwork,
791
792 #[serde(skip_serializing_if = "is_false")]
794 correct_gas_payment_limit_check: bool,
795
796 #[serde(skip_serializing_if = "Option::is_none")]
798 zklogin_max_epoch_upper_bound_delta: Option<u64>,
799
800 #[serde(skip_serializing_if = "is_false")]
802 mysticeti_leader_scoring_and_schedule: bool,
803
804 #[serde(skip_serializing_if = "is_false")]
806 reshare_at_same_initial_version: bool,
807
808 #[serde(skip_serializing_if = "is_false")]
810 resolve_abort_locations_to_package_id: bool,
811
812 #[serde(skip_serializing_if = "is_false")]
816 mysticeti_use_committed_subdag_digest: bool,
817
818 #[serde(skip_serializing_if = "is_false")]
820 enable_vdf: bool,
821
822 #[serde(skip_serializing_if = "is_false")]
826 record_consensus_determined_version_assignments_in_prologue: bool,
827 #[serde(skip_serializing_if = "is_false")]
830 record_consensus_determined_version_assignments_in_prologue_v2: bool,
831
832 #[serde(skip_serializing_if = "is_false")]
834 fresh_vm_on_framework_upgrade: bool,
835
836 #[serde(skip_serializing_if = "is_false")]
844 prepend_prologue_tx_in_consensus_commit_in_checkpoints: bool,
845
846 #[serde(skip_serializing_if = "Option::is_none")]
848 mysticeti_num_leaders_per_round: Option<usize>,
849
850 #[serde(skip_serializing_if = "is_false")]
852 soft_bundle: bool,
853
854 #[serde(skip_serializing_if = "is_false")]
856 enable_coin_deny_list_v2: bool,
857
858 #[serde(skip_serializing_if = "is_false")]
860 passkey_auth: bool,
861
862 #[serde(skip_serializing_if = "is_false")]
865 mldsa65_auth: bool,
866
867 #[serde(skip_serializing_if = "is_false")]
869 secp256r1_ecrecover_checks_x_below_p: bool,
870
871 #[serde(skip_serializing_if = "is_false")]
874 secp256r1_strict_public_keys: bool,
875
876 #[serde(skip_serializing_if = "is_false")]
878 complete_effects_size_estimate: bool,
879
880 #[serde(skip_serializing_if = "is_false")]
882 authority_capabilities_v2: bool,
883
884 #[serde(skip_serializing_if = "is_false")]
886 rethrow_serialization_type_layout_errors: bool,
887
888 #[serde(skip_serializing_if = "is_false")]
890 consensus_distributed_vote_scoring_strategy: bool,
891
892 #[serde(skip_serializing_if = "is_false")]
894 consensus_round_prober: bool,
895
896 #[serde(skip_serializing_if = "is_false")]
898 validate_identifier_inputs: bool,
899
900 #[serde(skip_serializing_if = "is_false")]
902 disallow_self_identifier: bool,
903
904 #[serde(skip_serializing_if = "is_false")]
906 mysticeti_fastpath: bool,
907
908 #[serde(skip_serializing_if = "is_false")]
912 disable_preconsensus_locking: bool,
913
914 #[serde(skip_serializing_if = "is_false")]
916 relocate_event_module: bool,
917
918 #[serde(skip_serializing_if = "is_false")]
920 uncompressed_g1_group_elements: bool,
921
922 #[serde(skip_serializing_if = "is_false")]
923 disallow_new_modules_in_deps_only_packages: bool,
924
925 #[serde(skip_serializing_if = "is_false")]
927 consensus_smart_ancestor_selection: bool,
928
929 #[serde(skip_serializing_if = "is_false")]
931 consensus_round_prober_probe_accepted_rounds: bool,
932
933 #[serde(skip_serializing_if = "is_false")]
935 native_charging_v2: bool,
936
937 #[serde(skip_serializing_if = "is_false")]
940 #[skip_protocol_config_accessor]
941 consensus_linearize_subdag_v2: bool,
942
943 #[serde(skip_serializing_if = "is_false")]
945 convert_type_argument_error: bool,
946
947 #[serde(skip_serializing_if = "is_false")]
949 variant_nodes: bool,
950
951 #[serde(skip_serializing_if = "is_false")]
953 consensus_zstd_compression: bool,
954
955 #[serde(skip_serializing_if = "is_false")]
957 minimize_child_object_mutations: bool,
958
959 #[serde(skip_serializing_if = "is_false")]
962 record_additional_state_digest_in_prologue: bool,
963
964 #[serde(skip_serializing_if = "is_false")]
966 move_native_context: bool,
967
968 #[serde(skip_serializing_if = "is_false")]
971 #[skip_protocol_config_accessor]
972 consensus_median_based_commit_timestamp: bool,
973
974 #[serde(skip_serializing_if = "is_false")]
977 normalize_ptb_arguments: bool,
978
979 #[serde(skip_serializing_if = "is_false")]
981 consensus_batched_block_sync: bool,
982
983 #[serde(skip_serializing_if = "is_false")]
985 enforce_checkpoint_timestamp_monotonicity: bool,
986
987 #[serde(skip_serializing_if = "is_false")]
989 max_ptb_value_size_v2: bool,
990
991 #[serde(skip_serializing_if = "is_false")]
993 resolve_type_input_ids_to_defining_id: bool,
994
995 #[serde(skip_serializing_if = "is_false")]
997 enable_party_transfer: bool,
998
999 #[serde(skip_serializing_if = "is_false")]
1001 allow_unbounded_system_objects: bool,
1002
1003 #[serde(skip_serializing_if = "is_false")]
1005 type_tags_in_object_runtime: bool,
1006
1007 #[serde(skip_serializing_if = "is_false")]
1009 enable_accumulators: bool,
1010
1011 #[serde(skip_serializing_if = "is_false")]
1013 #[skip_protocol_config_accessor]
1014 enable_coin_reservation_obj_refs: bool,
1015
1016 #[serde(skip_serializing_if = "is_false")]
1019 create_root_accumulator_object: bool,
1020
1021 #[serde(skip_serializing_if = "is_false")]
1023 #[skip_protocol_config_accessor]
1024 enable_authenticated_event_streams: bool,
1025
1026 #[serde(skip_serializing_if = "is_false")]
1028 enable_address_balance_gas_payments: bool,
1029
1030 #[serde(skip_serializing_if = "is_false")]
1032 address_balance_gas_check_rgp_at_signing: bool,
1033
1034 #[serde(skip_serializing_if = "is_false")]
1035 address_balance_gas_reject_gas_coin_arg: bool,
1036
1037 #[serde(skip_serializing_if = "is_false")]
1039 enable_multi_epoch_transaction_expiration: bool,
1040
1041 #[serde(skip_serializing_if = "is_false")]
1043 relax_valid_during_for_owned_inputs: bool,
1044
1045 #[serde(skip_serializing_if = "is_false")]
1047 enable_ptb_execution_v2: bool,
1048
1049 #[serde(skip_serializing_if = "is_false")]
1051 better_adapter_type_resolution_errors: bool,
1052
1053 #[serde(skip_serializing_if = "is_false")]
1055 record_time_estimate_processed: bool,
1056
1057 #[serde(skip_serializing_if = "is_false")]
1059 dependency_linkage_error: bool,
1060
1061 #[serde(skip_serializing_if = "is_false")]
1063 additional_multisig_checks: bool,
1064
1065 #[serde(skip_serializing_if = "is_false")]
1067 ignore_execution_time_observations_after_certs_closed: bool,
1068
1069 #[serde(skip_serializing_if = "is_false")]
1073 debug_fatal_on_move_invariant_violation: bool,
1074
1075 #[serde(skip_serializing_if = "is_false")]
1078 allow_private_accumulator_entrypoints: bool,
1079
1080 #[serde(skip_serializing_if = "is_false")]
1083 additional_consensus_digest_indirect_state: bool,
1084
1085 #[serde(skip_serializing_if = "is_false")]
1087 check_for_init_during_upgrade: bool,
1088
1089 #[serde(skip_serializing_if = "is_false")]
1091 enable_init_on_upgrade: bool,
1092
1093 #[serde(skip_serializing_if = "is_false")]
1095 enable_order_independent_upgrade_init_linkage: bool,
1096
1097 #[serde(skip_serializing_if = "is_false")]
1100 harden_linkage_consistency: bool,
1101
1102 #[serde(skip_serializing_if = "is_false")]
1104 per_command_shared_object_transfer_rules: bool,
1105
1106 #[serde(skip_serializing_if = "is_false")]
1108 validate_ptb_argument_indices: bool,
1109
1110 #[serde(skip_serializing_if = "is_false")]
1112 include_checkpoint_artifacts_digest_in_summary: bool,
1113
1114 #[serde(skip_serializing_if = "is_false")]
1116 use_mfp_txns_in_load_initial_object_debts: bool,
1117
1118 #[serde(skip_serializing_if = "is_false")]
1120 cancel_for_failed_dkg_early: bool,
1121
1122 #[serde(skip_serializing_if = "is_false")]
1124 always_advance_dkg_to_resolution: bool,
1125
1126 #[serde(skip_serializing_if = "is_false")]
1128 allow_dkg_completion_after_timeout: bool,
1129
1130 #[serde(skip_serializing_if = "is_false")]
1132 enable_coin_registry: bool,
1133
1134 #[serde(skip_serializing_if = "is_false")]
1136 abstract_size_in_object_runtime: bool,
1137
1138 #[serde(skip_serializing_if = "is_false")]
1140 object_runtime_charge_cache_load_gas: bool,
1141
1142 #[serde(skip_serializing_if = "is_false")]
1144 additional_borrow_checks: bool,
1145
1146 #[serde(skip_serializing_if = "is_false")]
1148 use_new_commit_handler: bool,
1149
1150 #[serde(skip_serializing_if = "is_false")]
1152 better_loader_errors: bool,
1153
1154 #[serde(skip_serializing_if = "is_false")]
1156 generate_df_type_layouts: bool,
1157
1158 #[serde(skip_serializing_if = "is_false")]
1160 allow_references_in_ptbs: bool,
1161
1162 #[serde(skip_serializing_if = "is_false")]
1169 framework_tx_context_mut_restrictions: bool,
1170
1171 #[serde(skip_serializing_if = "is_false")]
1173 include_function_signatures_in_instantiation_limits: bool,
1174
1175 #[serde(skip_serializing_if = "is_false")]
1180 ptb_tx_context_restrictions: bool,
1181
1182 #[serde(skip_serializing_if = "is_false")]
1184 enable_display_registry: bool,
1185
1186 #[serde(skip_serializing_if = "is_false")]
1188 private_generics_verifier_v2: bool,
1189
1190 #[serde(skip_serializing_if = "is_false")]
1192 deprecate_global_storage_ops_during_deserialization: bool,
1193
1194 #[serde(skip_serializing_if = "is_false")]
1197 enable_non_exclusive_writes: bool,
1198
1199 #[serde(skip_serializing_if = "is_false")]
1201 deprecate_global_storage_ops: bool,
1202
1203 #[serde(skip_serializing_if = "is_false")]
1205 normalize_depth_formula: bool,
1206
1207 #[serde(skip_serializing_if = "is_false")]
1210 charge_ld_const_abstract_size: bool,
1211
1212 #[serde(skip_serializing_if = "is_false")]
1214 consensus_skip_gced_accept_votes: bool,
1215
1216 #[serde(skip_serializing_if = "is_false")]
1219 include_cancelled_randomness_txns_in_prologue: bool,
1220
1221 #[serde(skip_serializing_if = "is_false")]
1223 #[skip_protocol_config_accessor]
1224 address_aliases: bool,
1225
1226 #[serde(skip_serializing_if = "is_false")]
1228 create_forwarding_address_registry: bool,
1229
1230 #[serde(skip_serializing_if = "is_false")]
1232 enable_forwarding_addresses: bool,
1233
1234 #[serde(skip_serializing_if = "is_false")]
1237 fix_checkpoint_signature_mapping: bool,
1238
1239 #[serde(skip_serializing_if = "is_false")]
1241 enable_object_funds_withdraw: bool,
1242
1243 #[serde(skip_serializing_if = "is_false")]
1246 record_net_unsettled_object_withdraws: bool,
1247
1248 #[serde(skip_serializing_if = "is_false")]
1250 consensus_skip_gced_blocks_in_direct_finalization: bool,
1251
1252 #[serde(skip_serializing_if = "is_false")]
1254 gas_rounding_halve_digits: bool,
1255
1256 #[serde(skip_serializing_if = "is_false")]
1258 flexible_tx_context_positions: bool,
1259
1260 #[serde(skip_serializing_if = "is_false")]
1262 disable_entry_point_signature_check: bool,
1263
1264 #[serde(skip_serializing_if = "is_false")]
1266 convert_withdrawal_compatibility_ptb_arguments: bool,
1267
1268 #[serde(skip_serializing_if = "is_false")]
1270 restrict_hot_or_not_entry_functions: bool,
1271
1272 #[serde(skip_serializing_if = "is_false")]
1274 split_checkpoints_in_consensus_handler: bool,
1275
1276 #[serde(skip_serializing_if = "is_false")]
1278 consensus_always_accept_system_transactions: bool,
1279
1280 #[serde(skip_serializing_if = "is_false")]
1282 validator_metadata_verify_v2: bool,
1283
1284 #[serde(skip_serializing_if = "is_false")]
1287 defer_unpaid_amplification: bool,
1288
1289 #[serde(skip_serializing_if = "is_false")]
1292 defer_owned_object_double_spend: bool,
1293
1294 #[serde(skip_serializing_if = "is_false")]
1297 allowed_proposers: bool,
1298
1299 #[serde(skip_serializing_if = "is_false")]
1306 #[skip_protocol_config_accessor]
1307 staggered_submission_signal: bool,
1308
1309 #[serde(skip_serializing_if = "is_false")]
1310 randomize_checkpoint_tx_limit_in_tests: bool,
1311
1312 #[serde(skip_serializing_if = "is_false")]
1314 gasless_transaction_drop_safety: bool,
1315
1316 #[serde(skip_serializing_if = "is_false")]
1319 merge_randomness_into_checkpoint: bool,
1320
1321 #[serde(skip_serializing_if = "is_false")]
1323 use_coin_party_owner: bool,
1324
1325 #[serde(skip_serializing_if = "is_false")]
1326 enable_gasless: bool,
1327
1328 #[serde(skip_serializing_if = "is_false")]
1329 gasless_verify_remaining_balance: bool,
1330
1331 #[serde(skip_serializing_if = "is_false")]
1332 disallow_jump_orphans: bool,
1333
1334 #[serde(skip_serializing_if = "is_false")]
1336 early_return_receive_object_mismatched_type: bool,
1337
1338 #[serde(skip_serializing_if = "is_false")]
1343 timestamp_based_epoch_close: bool,
1344
1345 #[serde(skip_serializing_if = "is_false")]
1348 limit_groth16_pvk_inputs: bool,
1349
1350 #[serde(skip_serializing_if = "is_false")]
1354 check_groth16_pvk_length: bool,
1355
1356 #[serde(skip_serializing_if = "is_false")]
1361 enforce_address_balance_change_invariant: bool,
1362
1363 #[serde(skip_serializing_if = "is_false")]
1365 share_transaction_deny_config_in_consensus: bool,
1366
1367 #[serde(skip_serializing_if = "is_false")]
1369 granular_post_execution_checks: bool,
1370
1371 #[serde(skip_serializing_if = "is_false")]
1373 early_exit_on_iffw: bool,
1374
1375 #[serde(skip_serializing_if = "is_false")]
1377 enable_unified_linkage: bool,
1378
1379 #[serde(skip_serializing_if = "is_false")]
1381 package_publish_charge: bool,
1382
1383 #[serde(skip_serializing_if = "is_false")]
1386 #[skip_protocol_config_accessor]
1387 enable_allowances: bool,
1388
1389 #[serde(skip_serializing_if = "is_false")]
1391 fix_ptb_generated_reads: bool,
1392
1393 #[serde(skip_serializing_if = "is_false")]
1394 check_object_funds_withdraw_in_execution: bool,
1395 #[serde(skip_serializing_if = "is_false")]
1397 memory_safety_invariant_check_v2: bool,
1398
1399 #[serde(skip_serializing_if = "is_false")]
1401 disable_effects_tx_dependencies: bool,
1402
1403 #[serde(skip_serializing_if = "is_false")]
1407 merge_colliding_deferrals: bool,
1408
1409 #[serde(skip_serializing_if = "is_false")]
1413 shuffle_consensus_commit_blocks: bool,
1414
1415 #[serde(skip_serializing_if = "is_false")]
1418 disable_id_leak_verifier: bool,
1419
1420 #[serde(skip_serializing_if = "is_false")]
1425 enable_timestamp_transaction_expiration: bool,
1426}
1427
1428fn is_false(b: &bool) -> bool {
1429 !b
1430}
1431
1432fn is_empty(b: &BTreeSet<String>) -> bool {
1433 b.is_empty()
1434}
1435
1436fn is_zero(val: &u64) -> bool {
1437 *val == 0
1438}
1439
1440#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1442pub enum ConsensusTransactionOrdering {
1443 #[default]
1445 None,
1446 ByGasPrice,
1448}
1449
1450impl ConsensusTransactionOrdering {
1451 pub fn is_none(&self) -> bool {
1452 matches!(self, ConsensusTransactionOrdering::None)
1453 }
1454}
1455
1456#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1457pub struct ExecutionTimeEstimateParams {
1458 pub target_utilization: u64,
1460 pub allowed_txn_cost_overage_burst_limit_us: u64,
1464
1465 pub randomness_scalar: u64,
1468
1469 pub max_estimate_us: u64,
1471
1472 pub stored_observations_num_included_checkpoints: u64,
1475
1476 pub stored_observations_limit: u64,
1478
1479 #[serde(skip_serializing_if = "is_zero")]
1482 pub stake_weighted_median_threshold: u64,
1483
1484 #[serde(skip_serializing_if = "is_false")]
1488 pub default_none_duration_for_new_keys: bool,
1489
1490 #[serde(skip_serializing_if = "Option::is_none")]
1492 pub observations_chunk_size: Option<u64>,
1493}
1494
1495#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1497pub enum PerObjectCongestionControlMode {
1498 #[default]
1499 None, TotalGasBudget, TotalTxCount, TotalGasBudgetWithCap, ExecutionTimeEstimate(ExecutionTimeEstimateParams), }
1505
1506impl PerObjectCongestionControlMode {
1507 pub fn is_none(&self) -> bool {
1508 matches!(self, PerObjectCongestionControlMode::None)
1509 }
1510}
1511
1512#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1514pub enum ConsensusChoice {
1515 #[default]
1516 Narwhal,
1517 SwapEachEpoch,
1518 Mysticeti,
1519}
1520
1521impl ConsensusChoice {
1522 pub fn is_narwhal(&self) -> bool {
1523 matches!(self, ConsensusChoice::Narwhal)
1524 }
1525}
1526
1527#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1529pub enum ConsensusNetwork {
1530 #[default]
1531 Anemo,
1532 Tonic,
1533}
1534
1535impl ConsensusNetwork {
1536 pub fn is_anemo(&self) -> bool {
1537 matches!(self, ConsensusNetwork::Anemo)
1538 }
1539}
1540
1541#[skip_serializing_none]
1573#[derive(Clone, Serialize, Debug, ProtocolConfigAccessors, ProtocolConfigOverride)]
1574pub struct ProtocolConfig {
1575 pub version: ProtocolVersion,
1576
1577 #[serde(skip)]
1582 chain: Chain,
1583
1584 feature_flags: FeatureFlags,
1585
1586 max_tx_size_bytes: Option<u64>,
1589
1590 max_input_objects: Option<u64>,
1592
1593 max_size_written_objects: Option<u64>,
1597 max_size_written_objects_system_tx: Option<u64>,
1600
1601 max_serialized_tx_effects_size_bytes: Option<u64>,
1603
1604 max_serialized_tx_effects_size_bytes_system_tx: Option<u64>,
1606
1607 max_gas_payment_objects: Option<u32>,
1609
1610 max_modules_in_publish: Option<u32>,
1612
1613 max_package_dependencies: Option<u32>,
1615
1616 max_arguments: Option<u32>,
1619
1620 max_type_arguments: Option<u32>,
1622
1623 max_type_argument_depth: Option<u32>,
1625
1626 max_pure_argument_size: Option<u32>,
1628
1629 max_programmable_tx_commands: Option<u32>,
1631
1632 move_binary_format_version: Option<u32>,
1635 min_move_binary_format_version: Option<u32>,
1636
1637 binary_module_handles: Option<u16>,
1639 binary_struct_handles: Option<u16>,
1640 binary_function_handles: Option<u16>,
1641 binary_function_instantiations: Option<u16>,
1642 binary_signatures: Option<u16>,
1643 binary_constant_pool: Option<u16>,
1644 binary_identifiers: Option<u16>,
1645 binary_address_identifiers: Option<u16>,
1646 binary_struct_defs: Option<u16>,
1647 binary_struct_def_instantiations: Option<u16>,
1648 binary_function_defs: Option<u16>,
1649 binary_field_handles: Option<u16>,
1650 binary_field_instantiations: Option<u16>,
1651 binary_friend_decls: Option<u16>,
1652 binary_enum_defs: Option<u16>,
1653 binary_enum_def_instantiations: Option<u16>,
1654 binary_variant_handles: Option<u16>,
1655 binary_variant_instantiation_handles: Option<u16>,
1656
1657 #[skip_accessor]
1659 binary_format_limits_profile: Option<BinaryFormatLimitsProfile>,
1660
1661 max_move_object_size: Option<u64>,
1663
1664 max_move_package_size: Option<u64>,
1667
1668 max_publish_or_upgrade_per_ptb: Option<u64>,
1670
1671 max_tx_gas: Option<u64>,
1673
1674 max_gas_price: Option<u64>,
1676
1677 max_gas_price_rgp_factor_for_aborted_transactions: Option<u64>,
1680
1681 max_gas_computation_bucket: Option<u64>,
1683
1684 gas_rounding_step: Option<u64>,
1686
1687 max_loop_depth: Option<u64>,
1689
1690 max_generic_instantiation_length: Option<u64>,
1692
1693 max_function_parameters: Option<u64>,
1695
1696 max_basic_blocks: Option<u64>,
1698
1699 max_value_stack_size: Option<u64>,
1701
1702 max_type_nodes: Option<u64>,
1704
1705 max_generic_instantiation_type_nodes_per_function: Option<u64>,
1707
1708 max_generic_instantiation_type_nodes_per_module: Option<u64>,
1710
1711 max_accumulator_type_nodes: Option<u64>,
1713
1714 max_push_size: Option<u64>,
1716
1717 max_struct_definitions: Option<u64>,
1719
1720 max_function_definitions: Option<u64>,
1722
1723 max_fields_in_struct: Option<u64>,
1725
1726 max_dependency_depth: Option<u64>,
1728
1729 max_num_event_emit: Option<u64>,
1731
1732 max_num_accumulator_events: Option<u64>,
1736
1737 max_num_new_move_object_ids: Option<u64>,
1739
1740 max_num_new_move_object_ids_system_tx: Option<u64>,
1742
1743 max_num_deleted_move_object_ids: Option<u64>,
1745
1746 max_num_deleted_move_object_ids_system_tx: Option<u64>,
1748
1749 max_num_transferred_move_object_ids: Option<u64>,
1751
1752 max_num_transferred_move_object_ids_system_tx: Option<u64>,
1754
1755 max_event_emit_size: Option<u64>,
1757
1758 max_event_emit_size_total: Option<u64>,
1760
1761 max_move_vector_len: Option<u64>,
1763
1764 max_move_identifier_len: Option<u64>,
1766
1767 max_move_value_depth: Option<u64>,
1769
1770 package_arena_size_in_bytes: Option<u64>,
1773
1774 max_move_enum_variants: Option<u64>,
1776
1777 max_back_edges_per_function: Option<u64>,
1779
1780 max_back_edges_per_module: Option<u64>,
1782
1783 max_verifier_meter_ticks_per_function: Option<u64>,
1785
1786 max_meter_ticks_per_module: Option<u64>,
1788
1789 max_meter_ticks_per_package: Option<u64>,
1791
1792 object_runtime_max_num_cached_objects: Option<u64>,
1796
1797 object_runtime_max_num_cached_objects_system_tx: Option<u64>,
1799
1800 object_runtime_max_loaded_child_value_size: Option<u64>,
1802
1803 object_runtime_max_num_store_entries: Option<u64>,
1805
1806 object_runtime_max_num_store_entries_system_tx: Option<u64>,
1808
1809 base_tx_cost_fixed: Option<u64>,
1812
1813 package_publish_cost_fixed: Option<u64>,
1816
1817 base_tx_cost_per_byte: Option<u64>,
1820
1821 package_publish_cost_per_byte: Option<u64>,
1823
1824 package_publish_charge_fixed: Option<u64>,
1826
1827 package_publish_charge_per_module: Option<u64>,
1829
1830 package_publish_charge_per_dependency: Option<u64>,
1832
1833 obj_access_cost_read_per_byte: Option<u64>,
1835
1836 obj_access_cost_read_per_package_kb: Option<u64>,
1839
1840 obj_access_cost_mutate_per_byte: Option<u64>,
1842
1843 obj_access_cost_delete_per_byte: Option<u64>,
1845
1846 obj_access_cost_verify_per_byte: Option<u64>,
1856
1857 max_type_to_layout_nodes: Option<u64>,
1859
1860 max_ptb_value_size: Option<u64>,
1862
1863 gas_model_version: Option<u64>,
1866
1867 obj_data_cost_refundable: Option<u64>,
1870
1871 obj_metadata_cost_non_refundable: Option<u64>,
1875
1876 storage_rebate_rate: Option<u64>,
1882
1883 storage_fund_reinvest_rate: Option<u64>,
1886
1887 reward_slashing_rate: Option<u64>,
1890
1891 storage_gas_price: Option<u64>,
1893
1894 accumulator_object_storage_cost: Option<u64>,
1896
1897 max_transactions_per_checkpoint: Option<u64>,
1902
1903 max_checkpoint_size_bytes: Option<u64>,
1907
1908 buffer_stake_for_protocol_upgrade_bps: Option<u64>,
1913
1914 address_from_bytes_cost_base: Option<u64>,
1919 address_to_u256_cost_base: Option<u64>,
1921 address_from_u256_cost_base: Option<u64>,
1923
1924 config_read_setting_impl_cost_base: Option<u64>,
1929 config_read_setting_impl_cost_per_byte: Option<u64>,
1930
1931 package_original_package_id_impl_cost_base: Option<u64>,
1932 package_original_package_id_impl_cost_per_byte: Option<u64>,
1933
1934 dynamic_field_hash_type_and_key_cost_base: Option<u64>,
1937 dynamic_field_hash_type_and_key_type_cost_per_byte: Option<u64>,
1938 dynamic_field_hash_type_and_key_value_cost_per_byte: Option<u64>,
1939 dynamic_field_hash_type_and_key_type_tag_cost_per_byte: Option<u64>,
1940 dynamic_field_add_child_object_cost_base: Option<u64>,
1942 dynamic_field_add_child_object_type_cost_per_byte: Option<u64>,
1943 dynamic_field_add_child_object_value_cost_per_byte: Option<u64>,
1944 dynamic_field_add_child_object_struct_tag_cost_per_byte: Option<u64>,
1945 dynamic_field_borrow_child_object_cost_base: Option<u64>,
1947 dynamic_field_borrow_child_object_child_ref_cost_per_byte: Option<u64>,
1948 dynamic_field_borrow_child_object_type_cost_per_byte: Option<u64>,
1949 dynamic_field_remove_child_object_cost_base: Option<u64>,
1951 dynamic_field_remove_child_object_child_cost_per_byte: Option<u64>,
1952 dynamic_field_remove_child_object_type_cost_per_byte: Option<u64>,
1953 dynamic_field_has_child_object_cost_base: Option<u64>,
1955 dynamic_field_has_child_object_with_ty_cost_base: Option<u64>,
1957 dynamic_field_has_child_object_with_ty_type_cost_per_byte: Option<u64>,
1958 dynamic_field_has_child_object_with_ty_type_tag_cost_per_byte: Option<u64>,
1959
1960 scratch_add_cost_base: Option<u64>,
1963 scratch_read_cost_base: Option<u64>,
1965 scratch_read_value_cost: Option<u64>,
1966 scratch_remove_cost_base: Option<u64>,
1968 scratch_exists_cost_base: Option<u64>,
1970 scratch_exists_with_type_cost_base: Option<u64>,
1972 scratch_exists_with_type_type_cost: Option<u64>,
1973 max_scratch_pad_size: Option<u64>,
1975
1976 event_emit_cost_base: Option<u64>,
1979 event_emit_value_size_derivation_cost_per_byte: Option<u64>,
1980 event_emit_tag_size_derivation_cost_per_byte: Option<u64>,
1981 event_emit_output_cost_per_byte: Option<u64>,
1982 event_emit_auth_stream_cost: Option<u64>,
1983
1984 reserve_object_funds_for_withdrawal_cost_base: Option<u64>,
1987 reserve_object_funds_for_withdrawal_cold_read_cost: Option<u64>,
1989
1990 object_borrow_uid_cost_base: Option<u64>,
1993 object_delete_impl_cost_base: Option<u64>,
1995 object_record_new_uid_cost_base: Option<u64>,
1997 object_record_new_uid_from_hash_cost_base: Option<u64>,
2000 object_is_shared_input_cost_base: Option<u64>,
2002
2003 transfer_transfer_internal_cost_base: Option<u64>,
2006 transfer_party_transfer_internal_cost_base: Option<u64>,
2008 transfer_freeze_object_cost_base: Option<u64>,
2010 transfer_share_object_cost_base: Option<u64>,
2012 transfer_receive_object_cost_base: Option<u64>,
2015 transfer_receive_object_cost_per_byte: Option<u64>,
2016 transfer_receive_object_type_cost_per_byte: Option<u64>,
2017
2018 tx_context_derive_id_cost_base: Option<u64>,
2021 tx_context_fresh_id_cost_base: Option<u64>,
2022 tx_context_sender_cost_base: Option<u64>,
2023 tx_context_epoch_cost_base: Option<u64>,
2024 tx_context_epoch_timestamp_ms_cost_base: Option<u64>,
2025 tx_context_sponsor_cost_base: Option<u64>,
2026 tx_context_rgp_cost_base: Option<u64>,
2027 tx_context_gas_price_cost_base: Option<u64>,
2028 tx_context_gas_budget_cost_base: Option<u64>,
2029 tx_context_ids_created_cost_base: Option<u64>,
2030 tx_context_replace_cost_base: Option<u64>,
2031
2032 clock_borrow_cost_base: Option<u64>,
2035
2036 types_is_one_time_witness_cost_base: Option<u64>,
2039 types_is_one_time_witness_type_tag_cost_per_byte: Option<u64>,
2040 types_is_one_time_witness_type_cost_per_byte: Option<u64>,
2041
2042 validator_validate_metadata_cost_base: Option<u64>,
2045 validator_validate_metadata_data_cost_per_byte: Option<u64>,
2046
2047 crypto_invalid_arguments_cost: Option<u64>,
2049 bls12381_bls12381_min_sig_verify_cost_base: Option<u64>,
2051 bls12381_bls12381_min_sig_verify_msg_cost_per_byte: Option<u64>,
2052 bls12381_bls12381_min_sig_verify_msg_cost_per_block: Option<u64>,
2053
2054 bls12381_bls12381_min_pk_verify_cost_base: Option<u64>,
2056 bls12381_bls12381_min_pk_verify_msg_cost_per_byte: Option<u64>,
2057 bls12381_bls12381_min_pk_verify_msg_cost_per_block: Option<u64>,
2058
2059 ecdsa_k1_ecrecover_keccak256_cost_base: Option<u64>,
2061 ecdsa_k1_ecrecover_keccak256_msg_cost_per_byte: Option<u64>,
2062 ecdsa_k1_ecrecover_keccak256_msg_cost_per_block: Option<u64>,
2063 ecdsa_k1_ecrecover_sha256_cost_base: Option<u64>,
2064 ecdsa_k1_ecrecover_sha256_msg_cost_per_byte: Option<u64>,
2065 ecdsa_k1_ecrecover_sha256_msg_cost_per_block: Option<u64>,
2066
2067 ecdsa_k1_decompress_pubkey_cost_base: Option<u64>,
2069
2070 ecdsa_k1_secp256k1_verify_keccak256_cost_base: Option<u64>,
2072 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_byte: Option<u64>,
2073 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_block: Option<u64>,
2074 ecdsa_k1_secp256k1_verify_sha256_cost_base: Option<u64>,
2075 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_byte: Option<u64>,
2076 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_block: Option<u64>,
2077
2078 ecdsa_r1_ecrecover_keccak256_cost_base: Option<u64>,
2080 ecdsa_r1_ecrecover_keccak256_msg_cost_per_byte: Option<u64>,
2081 ecdsa_r1_ecrecover_keccak256_msg_cost_per_block: Option<u64>,
2082 ecdsa_r1_ecrecover_sha256_cost_base: Option<u64>,
2083 ecdsa_r1_ecrecover_sha256_msg_cost_per_byte: Option<u64>,
2084 ecdsa_r1_ecrecover_sha256_msg_cost_per_block: Option<u64>,
2085
2086 ecdsa_r1_secp256r1_verify_keccak256_cost_base: Option<u64>,
2088 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_byte: Option<u64>,
2089 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_block: Option<u64>,
2090 ecdsa_r1_secp256r1_verify_sha256_cost_base: Option<u64>,
2091 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_byte: Option<u64>,
2092 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_block: Option<u64>,
2093
2094 ecvrf_ecvrf_verify_cost_base: Option<u64>,
2096 ecvrf_ecvrf_verify_alpha_string_cost_per_byte: Option<u64>,
2097 ecvrf_ecvrf_verify_alpha_string_cost_per_block: Option<u64>,
2098
2099 ed25519_ed25519_verify_cost_base: Option<u64>,
2101 ed25519_ed25519_verify_msg_cost_per_byte: Option<u64>,
2102 ed25519_ed25519_verify_msg_cost_per_block: Option<u64>,
2103
2104 groth16_prepare_verifying_key_bls12381_cost_base: Option<u64>,
2106 groth16_prepare_verifying_key_bn254_cost_base: Option<u64>,
2107
2108 groth16_verify_groth16_proof_internal_bls12381_cost_base: Option<u64>,
2110 groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input: Option<u64>,
2111 groth16_verify_groth16_proof_internal_bn254_cost_base: Option<u64>,
2112 groth16_verify_groth16_proof_internal_bn254_cost_per_public_input: Option<u64>,
2113 groth16_verify_groth16_proof_internal_public_input_cost_per_byte: Option<u64>,
2114
2115 hash_blake2b256_cost_base: Option<u64>,
2117 hash_blake2b256_data_cost_per_byte: Option<u64>,
2118 hash_blake2b256_data_cost_per_block: Option<u64>,
2119
2120 hash_keccak256_cost_base: Option<u64>,
2122 hash_keccak256_data_cost_per_byte: Option<u64>,
2123 hash_keccak256_data_cost_per_block: Option<u64>,
2124
2125 poseidon_bn254_cost_base: Option<u64>,
2127 poseidon_bn254_cost_per_block: Option<u64>,
2128
2129 group_ops_bls12381_decode_scalar_cost: Option<u64>,
2131 group_ops_bls12381_decode_g1_cost: Option<u64>,
2132 group_ops_bls12381_decode_g2_cost: Option<u64>,
2133 group_ops_bls12381_decode_gt_cost: Option<u64>,
2134 group_ops_bls12381_scalar_add_cost: Option<u64>,
2135 group_ops_bls12381_g1_add_cost: Option<u64>,
2136 group_ops_bls12381_g2_add_cost: Option<u64>,
2137 group_ops_bls12381_gt_add_cost: Option<u64>,
2138 group_ops_bls12381_scalar_sub_cost: Option<u64>,
2139 group_ops_bls12381_g1_sub_cost: Option<u64>,
2140 group_ops_bls12381_g2_sub_cost: Option<u64>,
2141 group_ops_bls12381_gt_sub_cost: Option<u64>,
2142 group_ops_bls12381_scalar_mul_cost: Option<u64>,
2143 group_ops_bls12381_g1_mul_cost: Option<u64>,
2144 group_ops_bls12381_g2_mul_cost: Option<u64>,
2145 group_ops_bls12381_gt_mul_cost: Option<u64>,
2146 group_ops_bls12381_scalar_div_cost: Option<u64>,
2147 group_ops_bls12381_g1_div_cost: Option<u64>,
2148 group_ops_bls12381_g2_div_cost: Option<u64>,
2149 group_ops_bls12381_gt_div_cost: Option<u64>,
2150 group_ops_bls12381_g1_hash_to_base_cost: Option<u64>,
2151 group_ops_bls12381_g2_hash_to_base_cost: Option<u64>,
2152 group_ops_bls12381_g1_hash_to_cost_per_byte: Option<u64>,
2153 group_ops_bls12381_g2_hash_to_cost_per_byte: Option<u64>,
2154 group_ops_bls12381_g1_msm_base_cost: Option<u64>,
2155 group_ops_bls12381_g2_msm_base_cost: Option<u64>,
2156 group_ops_bls12381_g1_msm_base_cost_per_input: Option<u64>,
2157 group_ops_bls12381_g2_msm_base_cost_per_input: Option<u64>,
2158 group_ops_bls12381_msm_max_len: Option<u32>,
2159 group_ops_bls12381_pairing_cost: Option<u64>,
2160 group_ops_bls12381_g1_to_uncompressed_g1_cost: Option<u64>,
2161 group_ops_bls12381_uncompressed_g1_to_g1_cost: Option<u64>,
2162 group_ops_bls12381_uncompressed_g1_sum_base_cost: Option<u64>,
2163 group_ops_bls12381_uncompressed_g1_sum_cost_per_term: Option<u64>,
2164 group_ops_bls12381_uncompressed_g1_sum_max_terms: Option<u64>,
2165
2166 group_ops_ristretto_decode_scalar_cost: Option<u64>,
2167 group_ops_ristretto_decode_point_cost: Option<u64>,
2168 group_ops_ristretto_scalar_add_cost: Option<u64>,
2169 group_ops_ristretto_point_add_cost: Option<u64>,
2170 group_ops_ristretto_scalar_sub_cost: Option<u64>,
2171 group_ops_ristretto_point_sub_cost: Option<u64>,
2172 group_ops_ristretto_scalar_mul_cost: Option<u64>,
2173 group_ops_ristretto_point_mul_cost: Option<u64>,
2174 group_ops_ristretto_scalar_div_cost: Option<u64>,
2175 group_ops_ristretto_point_div_cost: Option<u64>,
2176
2177 verify_bulletproofs_ristretto255_base_cost: Option<u64>,
2178 verify_bulletproofs_ristretto255_cost_per_bit_and_commitment: Option<u64>,
2179 max_bulletproofs_total_bits: Option<u64>,
2182
2183 hmac_hmac_sha3_256_cost_base: Option<u64>,
2185 hmac_hmac_sha3_256_input_cost_per_byte: Option<u64>,
2186 hmac_hmac_sha3_256_input_cost_per_block: Option<u64>,
2187
2188 check_zklogin_id_cost_base: Option<u64>,
2190 check_zklogin_issuer_cost_base: Option<u64>,
2192
2193 vdf_verify_vdf_cost: Option<u64>,
2194 vdf_hash_to_input_cost: Option<u64>,
2195
2196 nitro_attestation_parse_base_cost: Option<u64>,
2198 nitro_attestation_parse_cost_per_byte: Option<u64>,
2199 nitro_attestation_verify_base_cost: Option<u64>,
2200 nitro_attestation_verify_cost_per_cert: Option<u64>,
2201
2202 layout_node_cost: Option<u64>,
2204 layout_node_cost_large_layout_threshold: Option<u64>,
2206
2207 bcs_per_input_abstract_unit_cost: Option<u64>,
2209 bcs_per_byte_serialized_cost: Option<u64>,
2210 bcs_legacy_min_output_size_cost: Option<u64>,
2211 bcs_failure_cost: Option<u64>,
2212
2213 hash_sha2_256_base_cost: Option<u64>,
2214 hash_sha2_256_per_byte_cost: Option<u64>,
2215 hash_sha2_256_legacy_min_input_len_cost: Option<u64>,
2216 hash_sha3_256_base_cost: Option<u64>,
2217 hash_sha3_256_per_byte_cost: Option<u64>,
2218 hash_sha3_256_legacy_min_input_len_cost: Option<u64>,
2219 type_name_get_base_cost: Option<u64>,
2220 type_name_get_per_byte_cost: Option<u64>,
2221 type_name_id_base_cost: Option<u64>,
2222
2223 string_check_utf8_base_cost: Option<u64>,
2224 string_check_utf8_per_byte_cost: Option<u64>,
2225 string_is_char_boundary_base_cost: Option<u64>,
2226 string_sub_string_base_cost: Option<u64>,
2227 string_sub_string_per_byte_cost: Option<u64>,
2228 string_index_of_base_cost: Option<u64>,
2229 string_index_of_per_byte_pattern_cost: Option<u64>,
2230 string_index_of_per_byte_searched_cost: Option<u64>,
2231
2232 vector_empty_base_cost: Option<u64>,
2233 vector_length_base_cost: Option<u64>,
2234 vector_push_back_base_cost: Option<u64>,
2235 vector_push_back_legacy_per_abstract_memory_unit_cost: Option<u64>,
2236 vector_borrow_base_cost: Option<u64>,
2237 vector_pop_back_base_cost: Option<u64>,
2238 vector_destroy_empty_base_cost: Option<u64>,
2239 vector_swap_base_cost: Option<u64>,
2240 vector_reverse_base_cost: Option<u64>,
2241 vector_reverse_per_elem_cost: Option<u64>,
2242 vector_keep_range_base_cost: Option<u64>,
2243 vector_keep_range_per_dropped_elem_cost: Option<u64>,
2244 vector_keep_range_per_moved_elem_cost: Option<u64>,
2245 vector_copy_range_base_cost: Option<u64>,
2246 vector_copy_range_per_abstract_memory_unit_cost: Option<u64>,
2247 vector_replace_range_base_cost: Option<u64>,
2248 vector_replace_range_per_elem_cost: Option<u64>,
2249 debug_print_base_cost: Option<u64>,
2250 debug_print_stack_trace_base_cost: Option<u64>,
2251
2252 #[custom_setter]
2262 execution_version: Option<u64>,
2263
2264 consensus_bad_nodes_stake_threshold: Option<u64>,
2268
2269 max_jwk_votes_per_validator_per_epoch: Option<u64>,
2270 max_age_of_jwk_in_epochs: Option<u64>,
2274
2275 random_beacon_reduction_allowed_delta: Option<u16>,
2279
2280 random_beacon_reduction_lower_bound: Option<u32>,
2283
2284 random_beacon_dkg_timeout_round: Option<u32>,
2287
2288 random_beacon_min_round_interval_ms: Option<u64>,
2290
2291 random_beacon_dkg_version: Option<u64>,
2294
2295 consensus_max_transaction_size_bytes: Option<u64>,
2298 consensus_max_transactions_in_block_bytes: Option<u64>,
2300 consensus_max_num_transactions_in_block: Option<u64>,
2302
2303 consensus_voting_rounds: Option<u32>,
2305
2306 max_accumulated_txn_cost_per_object_in_narwhal_commit: Option<u64>,
2308
2309 max_deferral_rounds_for_congestion_control: Option<u64>,
2312
2313 epoch_close_deadline_ms: Option<u64>,
2318
2319 max_txn_cost_overage_per_object_in_commit: Option<u64>,
2321
2322 allowed_txn_cost_overage_burst_per_object_in_commit: Option<u64>,
2324
2325 min_checkpoint_interval_ms: Option<u64>,
2327
2328 checkpoint_summary_version_specific_data: Option<u64>,
2330
2331 max_soft_bundle_size: Option<u64>,
2333
2334 bridge_should_try_to_finalize_committee: Option<bool>,
2338
2339 max_accumulated_txn_cost_per_object_in_mysticeti_commit: Option<u64>,
2345
2346 max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit: Option<u64>,
2349
2350 consensus_gc_depth: Option<u32>,
2353
2354 gas_budget_based_txn_cost_cap_factor: Option<u64>,
2356
2357 gas_budget_based_txn_cost_absolute_cap_commit_count: Option<u64>,
2359
2360 sip_45_consensus_amplification_threshold: Option<u64>,
2363
2364 staggered_submission_signal_window_commits: Option<u64>,
2367 staggered_submission_signal_min_excess_copies_per_commit: Option<u64>,
2372 staggered_submission_signal_min_consensus_user_transactions_per_commit: Option<u64>,
2378 staggered_submission_signal_exit_dwell_commits: Option<u64>,
2383 staggered_submission_signal_band1_enter_ratio_bps: Option<u64>,
2386 staggered_submission_signal_band1_exit_ratio_bps: Option<u64>,
2387 staggered_submission_signal_band2_enter_ratio_bps: Option<u64>,
2388 staggered_submission_signal_band2_exit_ratio_bps: Option<u64>,
2389
2390 use_object_per_epoch_marker_table_v2: Option<bool>,
2393
2394 consensus_commit_rate_estimation_window_size: Option<u32>,
2396
2397 #[serde(skip_serializing_if = "Vec::is_empty")]
2401 aliased_addresses: Vec<AliasedAddress>,
2402
2403 translation_per_command_base_charge: Option<u64>,
2406
2407 translation_per_input_base_charge: Option<u64>,
2410
2411 translation_pure_input_per_byte_charge: Option<u64>,
2413
2414 translation_per_type_node_charge: Option<u64>,
2418
2419 translation_per_reference_node_charge: Option<u64>,
2422
2423 translation_per_linkage_entry_charge: Option<u64>,
2426
2427 max_updates_per_settlement_txn: Option<u32>,
2429
2430 gasless_max_computation_units: Option<u64>,
2432
2433 gasless_allowed_token_types: Option<Vec<(String, u64)>>,
2435
2436 gasless_max_unused_inputs: Option<u64>,
2440
2441 gasless_max_pure_input_bytes: Option<u64>,
2444
2445 gasless_max_tps: Option<u64>,
2447
2448 #[serde(skip_serializing_if = "Option::is_none")]
2449 #[skip_accessor]
2450 include_special_package_amendments: Option<Arc<Amendments>>,
2451
2452 gasless_max_tx_size_bytes: Option<u64>,
2455
2456 translation_per_live_reference_charge: Option<u64>,
2459
2460 max_ptb_live_references: Option<u64>,
2463
2464 max_ptb_returned_references: Option<u64>,
2467
2468 max_ptb_total_returned_references: Option<u64>,
2471}
2472
2473#[derive(Clone, Serialize, Deserialize, Debug)]
2475pub struct AliasedAddress {
2476 pub original: [u8; 32],
2478 pub aliased: [u8; 32],
2480 pub allowed_tx_digests: Vec<[u8; 32]>,
2482}
2483
2484impl ProtocolConfig {
2486 pub fn chain(&self) -> Chain {
2488 self.chain
2489 }
2490
2491 pub fn check_package_upgrades_supported(&self) -> Result<(), Error> {
2504 if self.feature_flags.package_upgrades {
2505 Ok(())
2506 } else {
2507 Err(Error(format!(
2508 "package upgrades are not supported at {:?}",
2509 self.version
2510 )))
2511 }
2512 }
2513
2514 pub fn zklogin_supported_providers(&self) -> &BTreeSet<String> {
2515 &self.feature_flags.zklogin_supported_providers
2516 }
2517
2518 pub fn zklogin_circuit_mode(&self) -> u64 {
2521 self.feature_flags.zklogin_circuit_mode
2522 }
2523
2524 pub fn consensus_transaction_ordering(&self) -> ConsensusTransactionOrdering {
2525 self.feature_flags.consensus_transaction_ordering
2526 }
2527
2528 pub fn enable_jwk_consensus_updates(&self) -> bool {
2529 let ret = self.feature_flags.enable_jwk_consensus_updates;
2530 if ret {
2531 assert!(self.feature_flags.end_of_epoch_transaction_supported);
2533 }
2534 ret
2535 }
2536
2537 pub fn staggered_submission_signal(&self) -> bool {
2538 let ret = self.feature_flags.staggered_submission_signal;
2539 if ret {
2540 assert!(self.feature_flags.allowed_proposers);
2543 }
2544 ret
2545 }
2546
2547 pub fn end_of_epoch_transaction_supported(&self) -> bool {
2548 let ret = self.feature_flags.end_of_epoch_transaction_supported;
2549 if !ret {
2550 assert!(!self.feature_flags.enable_jwk_consensus_updates);
2552 }
2553 ret
2554 }
2555
2556 pub fn dkg_version(&self) -> u64 {
2557 self.random_beacon_dkg_version.unwrap_or(1)
2559 }
2560
2561 pub fn bridge(&self) -> bool {
2562 let ret = self.feature_flags.bridge;
2563 if ret {
2564 assert!(self.feature_flags.end_of_epoch_transaction_supported);
2566 }
2567 ret
2568 }
2569
2570 pub fn should_try_to_finalize_bridge_committee(&self) -> bool {
2571 if !self.bridge() {
2572 return false;
2573 }
2574 self.bridge_should_try_to_finalize_committee.unwrap_or(true)
2576 }
2577
2578 pub fn zklogin_max_epoch_upper_bound_delta(&self) -> Option<u64> {
2579 self.feature_flags.zklogin_max_epoch_upper_bound_delta
2580 }
2581
2582 pub fn enable_allowances(&self) -> bool {
2583 self.feature_flags.enable_allowances && self.enable_accumulators()
2584 }
2585
2586 pub fn enable_coin_reservation_obj_refs(&self) -> bool {
2587 self.new_vm_enabled() && self.feature_flags.enable_coin_reservation_obj_refs
2588 }
2589
2590 pub fn enable_authenticated_event_streams(&self) -> bool {
2591 self.feature_flags.enable_authenticated_event_streams && self.enable_accumulators()
2592 }
2593
2594 pub fn per_object_congestion_control_mode(&self) -> PerObjectCongestionControlMode {
2595 self.feature_flags.per_object_congestion_control_mode
2596 }
2597
2598 pub fn consensus_choice(&self) -> ConsensusChoice {
2599 self.feature_flags.consensus_choice
2600 }
2601
2602 pub fn consensus_network(&self) -> ConsensusNetwork {
2603 self.feature_flags.consensus_network
2604 }
2605
2606 pub fn mysticeti_num_leaders_per_round(&self) -> Option<usize> {
2607 self.feature_flags.mysticeti_num_leaders_per_round
2608 }
2609
2610 pub fn max_transaction_size_bytes(&self) -> u64 {
2611 self.consensus_max_transaction_size_bytes
2613 .unwrap_or(256 * 1024)
2614 }
2615
2616 pub fn max_transactions_in_block_bytes(&self) -> u64 {
2617 if cfg!(msim) {
2618 256 * 1024
2619 } else {
2620 self.consensus_max_transactions_in_block_bytes
2621 .unwrap_or(512 * 1024)
2622 }
2623 }
2624
2625 pub fn max_num_transactions_in_block(&self) -> u64 {
2626 if cfg!(msim) {
2627 8
2628 } else {
2629 self.consensus_max_num_transactions_in_block.unwrap_or(512)
2630 }
2631 }
2632
2633 pub fn gc_depth(&self) -> u32 {
2634 self.consensus_gc_depth.unwrap_or(0)
2635 }
2636
2637 pub fn consensus_linearize_subdag_v2(&self) -> bool {
2638 let res = self.feature_flags.consensus_linearize_subdag_v2;
2639 assert!(
2640 !res || self.gc_depth() > 0,
2641 "The consensus linearize sub dag V2 requires GC to be enabled"
2642 );
2643 res
2644 }
2645
2646 pub fn consensus_median_based_commit_timestamp(&self) -> bool {
2647 let res = self.feature_flags.consensus_median_based_commit_timestamp;
2648 assert!(
2649 !res || self.gc_depth() > 0,
2650 "The consensus median based commit timestamp requires GC to be enabled"
2651 );
2652 res
2653 }
2654
2655 pub fn get_consensus_commit_rate_estimation_window_size(&self) -> u32 {
2656 self.consensus_commit_rate_estimation_window_size
2657 .unwrap_or(0)
2658 }
2659
2660 pub fn consensus_num_requested_prior_commits_at_startup(&self) -> u32 {
2661 let window_size = self.get_consensus_commit_rate_estimation_window_size();
2665 assert!(window_size == 0 || self.record_additional_state_digest_in_prologue());
2667 window_size
2668 }
2669
2670 pub fn address_aliases(&self) -> bool {
2671 let address_aliases = self.feature_flags.address_aliases;
2672 assert!(
2673 !address_aliases || self.mysticeti_fastpath(),
2674 "Address aliases requires Mysticeti fastpath to be enabled"
2675 );
2676 if address_aliases {
2677 assert!(
2678 self.feature_flags.disable_preconsensus_locking,
2679 "Address aliases requires CertifiedTransaction to be disabled"
2680 );
2681 }
2682 address_aliases
2683 }
2684
2685 pub fn new_vm_enabled(&self) -> bool {
2686 self.execution_version.is_some_and(|v| v >= 4)
2687 }
2688
2689 pub fn gasless_allowed_token_types(&self) -> &[(String, u64)] {
2690 debug_assert!(self.gasless_allowed_token_types.is_some());
2691 self.gasless_allowed_token_types.as_deref().unwrap_or(&[])
2692 }
2693
2694 pub fn get_gasless_max_unused_inputs(&self) -> u64 {
2695 self.gasless_max_unused_inputs.unwrap_or(u64::MAX)
2696 }
2697
2698 pub fn get_gasless_max_pure_input_bytes(&self) -> u64 {
2699 self.gasless_max_pure_input_bytes.unwrap_or(u64::MAX)
2700 }
2701
2702 pub fn get_gasless_max_tx_size_bytes(&self) -> u64 {
2703 self.gasless_max_tx_size_bytes.unwrap_or(u64::MAX)
2704 }
2705
2706 pub fn include_special_package_amendments_as_option(&self) -> &Option<Arc<Amendments>> {
2707 &self.include_special_package_amendments
2708 }
2709}
2710
2711static POISON_VERSION_METHODS: AtomicBool = AtomicBool::new(false);
2712
2713impl ProtocolConfig {
2715 pub fn get_for_version(version: ProtocolVersion, chain: Chain) -> Self {
2717 assert!(
2719 version >= ProtocolVersion::MIN,
2720 "Network protocol version is {:?}, but the minimum supported version by the binary is {:?}. Please upgrade the binary.",
2721 version,
2722 ProtocolVersion::MIN.0,
2723 );
2724 assert!(
2725 version <= ProtocolVersion::MAX_ALLOWED,
2726 "Network protocol version is {:?}, but the maximum supported version by the binary is {:?}. Please upgrade the binary.",
2727 version,
2728 ProtocolVersion::MAX_ALLOWED.0,
2729 );
2730
2731 let mut ret = Self::get_for_version_impl(version, chain);
2732 ret.version = version;
2733 ret.chain = chain;
2734
2735 ret = Self::apply_config_override(version, ret);
2736
2737 if std::env::var("SUI_PROTOCOL_CONFIG_OVERRIDE_ENABLE").is_ok() {
2738 warn!(
2739 "overriding ProtocolConfig settings with custom settings; this may break non-local networks"
2740 );
2741 let overrides: ProtocolConfigOptional =
2742 serde_env::from_env_with_prefix("SUI_PROTOCOL_CONFIG_OVERRIDE")
2743 .expect("failed to parse ProtocolConfig override env variables");
2744 overrides.apply_to(&mut ret);
2745 }
2746
2747 ret
2748 }
2749
2750 pub fn get_for_version_if_supported(version: ProtocolVersion, chain: Chain) -> Option<Self> {
2753 if version.0 >= ProtocolVersion::MIN.0 && version.0 <= ProtocolVersion::MAX_ALLOWED.0 {
2754 let mut ret = Self::get_for_version_impl(version, chain);
2755 ret.version = version;
2756 ret.chain = chain;
2757 ret = Self::apply_config_override(version, ret);
2758 Some(ret)
2759 } else {
2760 None
2761 }
2762 }
2763
2764 pub fn poison_get_for_min_version() {
2765 POISON_VERSION_METHODS.store(true, Ordering::Relaxed);
2766 }
2767
2768 fn load_poison_get_for_min_version() -> bool {
2769 POISON_VERSION_METHODS.load(Ordering::Relaxed)
2770 }
2771
2772 pub fn get_for_min_version() -> Self {
2775 if Self::load_poison_get_for_min_version() {
2776 panic!("get_for_min_version called on validator");
2777 }
2778 ProtocolConfig::get_for_version(ProtocolVersion::MIN, Chain::Unknown)
2779 }
2780
2781 #[allow(non_snake_case)]
2791 pub fn get_for_max_version_UNSAFE() -> Self {
2792 if Self::load_poison_get_for_min_version() {
2793 panic!("get_for_max_version_UNSAFE called on validator");
2794 }
2795 ProtocolConfig::get_for_version(ProtocolVersion::MAX, Chain::Unknown)
2796 }
2797
2798 fn get_for_version_impl(version: ProtocolVersion, chain: Chain) -> Self {
2799 #[cfg(msim)]
2800 {
2801 if version == ProtocolVersion::MAX_ALLOWED {
2803 let mut config = Self::get_for_version_impl(version - 1, Chain::Unknown);
2804 config.base_tx_cost_fixed = Some(config.base_tx_cost_fixed() + 1000);
2805 return config;
2806 }
2807 }
2808
2809 let mut cfg = Self {
2812 version,
2814 chain,
2815
2816 feature_flags: Default::default(),
2818
2819 max_tx_size_bytes: Some(128 * 1024),
2820 max_input_objects: Some(2048),
2822 max_serialized_tx_effects_size_bytes: Some(512 * 1024),
2823 max_serialized_tx_effects_size_bytes_system_tx: Some(512 * 1024 * 16),
2824 max_gas_payment_objects: Some(256),
2825 max_modules_in_publish: Some(128),
2826 max_package_dependencies: None,
2827 max_arguments: Some(512),
2828 max_type_arguments: Some(16),
2829 max_type_argument_depth: Some(16),
2830 max_pure_argument_size: Some(16 * 1024),
2831 max_programmable_tx_commands: Some(1024),
2832 move_binary_format_version: Some(6),
2833 min_move_binary_format_version: None,
2834 binary_module_handles: None,
2835 binary_struct_handles: None,
2836 binary_function_handles: None,
2837 binary_function_instantiations: None,
2838 binary_signatures: None,
2839 binary_constant_pool: None,
2840 binary_identifiers: None,
2841 binary_address_identifiers: None,
2842 binary_struct_defs: None,
2843 binary_struct_def_instantiations: None,
2844 binary_function_defs: None,
2845 binary_field_handles: None,
2846 binary_field_instantiations: None,
2847 binary_friend_decls: None,
2848 binary_enum_defs: None,
2849 binary_enum_def_instantiations: None,
2850 binary_variant_handles: None,
2851 binary_variant_instantiation_handles: None,
2852 binary_format_limits_profile: None,
2853 max_move_object_size: Some(250 * 1024),
2854 max_move_package_size: Some(100 * 1024),
2855 max_publish_or_upgrade_per_ptb: None,
2856 max_tx_gas: Some(10_000_000_000),
2857 max_gas_price: Some(100_000),
2858 max_gas_price_rgp_factor_for_aborted_transactions: None,
2859 max_gas_computation_bucket: Some(5_000_000),
2860 max_loop_depth: Some(5),
2861 max_generic_instantiation_length: Some(32),
2862 max_function_parameters: Some(128),
2863 max_basic_blocks: Some(1024),
2864 max_value_stack_size: Some(1024),
2865 max_type_nodes: Some(256),
2866 max_generic_instantiation_type_nodes_per_function: None,
2867 max_generic_instantiation_type_nodes_per_module: None,
2868 max_accumulator_type_nodes: None,
2869 max_push_size: Some(10000),
2870 max_struct_definitions: Some(200),
2871 max_function_definitions: Some(1000),
2872 max_fields_in_struct: Some(32),
2873 max_dependency_depth: Some(100),
2874 max_num_event_emit: Some(256),
2875 max_num_accumulator_events: None,
2876 max_num_new_move_object_ids: Some(2048),
2877 max_num_new_move_object_ids_system_tx: Some(2048 * 16),
2878 max_num_deleted_move_object_ids: Some(2048),
2879 max_num_deleted_move_object_ids_system_tx: Some(2048 * 16),
2880 max_num_transferred_move_object_ids: Some(2048),
2881 max_num_transferred_move_object_ids_system_tx: Some(2048 * 16),
2882 max_event_emit_size: Some(250 * 1024),
2883 max_move_vector_len: Some(256 * 1024),
2884 max_type_to_layout_nodes: None,
2885 max_ptb_value_size: None,
2886
2887 max_back_edges_per_function: Some(10_000),
2888 max_back_edges_per_module: Some(10_000),
2889 max_verifier_meter_ticks_per_function: Some(6_000_000),
2890 max_meter_ticks_per_module: Some(6_000_000),
2891 max_meter_ticks_per_package: None,
2892
2893 object_runtime_max_num_cached_objects: Some(1000),
2894 object_runtime_max_num_cached_objects_system_tx: Some(1000 * 16),
2895 object_runtime_max_loaded_child_value_size: None,
2896 object_runtime_max_num_store_entries: Some(1000),
2897 object_runtime_max_num_store_entries_system_tx: Some(1000 * 16),
2898 base_tx_cost_fixed: Some(110_000),
2899 package_publish_cost_fixed: Some(1_000),
2900 base_tx_cost_per_byte: Some(0),
2901 package_publish_cost_per_byte: Some(80),
2902 package_publish_charge_fixed: None,
2903 package_publish_charge_per_module: None,
2904 package_publish_charge_per_dependency: None,
2905 obj_access_cost_read_per_byte: Some(15),
2906 obj_access_cost_read_per_package_kb: None,
2907 obj_access_cost_mutate_per_byte: Some(40),
2908 obj_access_cost_delete_per_byte: Some(40),
2909 obj_access_cost_verify_per_byte: Some(200),
2910 obj_data_cost_refundable: Some(100),
2911 obj_metadata_cost_non_refundable: Some(50),
2912 gas_model_version: Some(1),
2913 storage_rebate_rate: Some(9900),
2914 storage_fund_reinvest_rate: Some(500),
2915 reward_slashing_rate: Some(5000),
2916 storage_gas_price: Some(1),
2917 accumulator_object_storage_cost: None,
2918 max_transactions_per_checkpoint: Some(10_000),
2919 max_checkpoint_size_bytes: Some(30 * 1024 * 1024),
2920
2921 buffer_stake_for_protocol_upgrade_bps: Some(0),
2924
2925 address_from_bytes_cost_base: Some(52),
2929 address_to_u256_cost_base: Some(52),
2931 address_from_u256_cost_base: Some(52),
2933
2934 config_read_setting_impl_cost_base: None,
2937 config_read_setting_impl_cost_per_byte: None,
2938
2939 package_original_package_id_impl_cost_base: None,
2940 package_original_package_id_impl_cost_per_byte: None,
2941
2942 dynamic_field_hash_type_and_key_cost_base: Some(100),
2945 dynamic_field_hash_type_and_key_type_cost_per_byte: Some(2),
2946 dynamic_field_hash_type_and_key_value_cost_per_byte: Some(2),
2947 dynamic_field_hash_type_and_key_type_tag_cost_per_byte: Some(2),
2948 dynamic_field_add_child_object_cost_base: Some(100),
2950 dynamic_field_add_child_object_type_cost_per_byte: Some(10),
2951 dynamic_field_add_child_object_value_cost_per_byte: Some(10),
2952 dynamic_field_add_child_object_struct_tag_cost_per_byte: Some(10),
2953 dynamic_field_borrow_child_object_cost_base: Some(100),
2955 dynamic_field_borrow_child_object_child_ref_cost_per_byte: Some(10),
2956 dynamic_field_borrow_child_object_type_cost_per_byte: Some(10),
2957 dynamic_field_remove_child_object_cost_base: Some(100),
2959 dynamic_field_remove_child_object_child_cost_per_byte: Some(2),
2960 dynamic_field_remove_child_object_type_cost_per_byte: Some(2),
2961 dynamic_field_has_child_object_cost_base: Some(100),
2963 dynamic_field_has_child_object_with_ty_cost_base: Some(100),
2965 dynamic_field_has_child_object_with_ty_type_cost_per_byte: Some(2),
2966 dynamic_field_has_child_object_with_ty_type_tag_cost_per_byte: Some(2),
2967
2968 scratch_add_cost_base: None,
2970 scratch_read_cost_base: None,
2971 scratch_read_value_cost: None,
2972 scratch_remove_cost_base: None,
2973 scratch_exists_cost_base: None,
2974 scratch_exists_with_type_cost_base: None,
2975 scratch_exists_with_type_type_cost: None,
2976 max_scratch_pad_size: None,
2977
2978 event_emit_cost_base: Some(52),
2981 event_emit_value_size_derivation_cost_per_byte: Some(2),
2982 event_emit_tag_size_derivation_cost_per_byte: Some(5),
2983 event_emit_output_cost_per_byte: Some(10),
2984 event_emit_auth_stream_cost: None,
2985
2986 reserve_object_funds_for_withdrawal_cost_base: None,
2988 reserve_object_funds_for_withdrawal_cold_read_cost: None,
2989
2990 object_borrow_uid_cost_base: Some(52),
2993 object_delete_impl_cost_base: Some(52),
2995 object_record_new_uid_cost_base: Some(52),
2997 object_record_new_uid_from_hash_cost_base: None,
3000 object_is_shared_input_cost_base: None,
3003
3004 transfer_transfer_internal_cost_base: Some(52),
3007 transfer_party_transfer_internal_cost_base: None,
3009 transfer_freeze_object_cost_base: Some(52),
3011 transfer_share_object_cost_base: Some(52),
3013 transfer_receive_object_cost_base: None,
3014 transfer_receive_object_type_cost_per_byte: None,
3015 transfer_receive_object_cost_per_byte: None,
3016
3017 tx_context_derive_id_cost_base: Some(52),
3020 tx_context_fresh_id_cost_base: None,
3021 tx_context_sender_cost_base: None,
3022 tx_context_epoch_cost_base: None,
3023 tx_context_epoch_timestamp_ms_cost_base: None,
3024 tx_context_sponsor_cost_base: None,
3025 tx_context_rgp_cost_base: None,
3026 tx_context_gas_price_cost_base: None,
3027 tx_context_gas_budget_cost_base: None,
3028 tx_context_ids_created_cost_base: None,
3029 tx_context_replace_cost_base: None,
3030
3031 clock_borrow_cost_base: None,
3033
3034 types_is_one_time_witness_cost_base: Some(52),
3037 types_is_one_time_witness_type_tag_cost_per_byte: Some(2),
3038 types_is_one_time_witness_type_cost_per_byte: Some(2),
3039
3040 validator_validate_metadata_cost_base: Some(52),
3043 validator_validate_metadata_data_cost_per_byte: Some(2),
3044
3045 crypto_invalid_arguments_cost: Some(100),
3047 bls12381_bls12381_min_sig_verify_cost_base: Some(52),
3049 bls12381_bls12381_min_sig_verify_msg_cost_per_byte: Some(2),
3050 bls12381_bls12381_min_sig_verify_msg_cost_per_block: Some(2),
3051
3052 bls12381_bls12381_min_pk_verify_cost_base: Some(52),
3054 bls12381_bls12381_min_pk_verify_msg_cost_per_byte: Some(2),
3055 bls12381_bls12381_min_pk_verify_msg_cost_per_block: Some(2),
3056
3057 ecdsa_k1_ecrecover_keccak256_cost_base: Some(52),
3059 ecdsa_k1_ecrecover_keccak256_msg_cost_per_byte: Some(2),
3060 ecdsa_k1_ecrecover_keccak256_msg_cost_per_block: Some(2),
3061 ecdsa_k1_ecrecover_sha256_cost_base: Some(52),
3062 ecdsa_k1_ecrecover_sha256_msg_cost_per_byte: Some(2),
3063 ecdsa_k1_ecrecover_sha256_msg_cost_per_block: Some(2),
3064
3065 ecdsa_k1_decompress_pubkey_cost_base: Some(52),
3067
3068 ecdsa_k1_secp256k1_verify_keccak256_cost_base: Some(52),
3070 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_byte: Some(2),
3071 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_block: Some(2),
3072 ecdsa_k1_secp256k1_verify_sha256_cost_base: Some(52),
3073 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_byte: Some(2),
3074 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_block: Some(2),
3075
3076 ecdsa_r1_ecrecover_keccak256_cost_base: Some(52),
3078 ecdsa_r1_ecrecover_keccak256_msg_cost_per_byte: Some(2),
3079 ecdsa_r1_ecrecover_keccak256_msg_cost_per_block: Some(2),
3080 ecdsa_r1_ecrecover_sha256_cost_base: Some(52),
3081 ecdsa_r1_ecrecover_sha256_msg_cost_per_byte: Some(2),
3082 ecdsa_r1_ecrecover_sha256_msg_cost_per_block: Some(2),
3083
3084 ecdsa_r1_secp256r1_verify_keccak256_cost_base: Some(52),
3086 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_byte: Some(2),
3087 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_block: Some(2),
3088 ecdsa_r1_secp256r1_verify_sha256_cost_base: Some(52),
3089 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_byte: Some(2),
3090 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_block: Some(2),
3091
3092 ecvrf_ecvrf_verify_cost_base: Some(52),
3094 ecvrf_ecvrf_verify_alpha_string_cost_per_byte: Some(2),
3095 ecvrf_ecvrf_verify_alpha_string_cost_per_block: Some(2),
3096
3097 ed25519_ed25519_verify_cost_base: Some(52),
3099 ed25519_ed25519_verify_msg_cost_per_byte: Some(2),
3100 ed25519_ed25519_verify_msg_cost_per_block: Some(2),
3101
3102 groth16_prepare_verifying_key_bls12381_cost_base: Some(52),
3104 groth16_prepare_verifying_key_bn254_cost_base: Some(52),
3105
3106 groth16_verify_groth16_proof_internal_bls12381_cost_base: Some(52),
3108 groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input: Some(2),
3109 groth16_verify_groth16_proof_internal_bn254_cost_base: Some(52),
3110 groth16_verify_groth16_proof_internal_bn254_cost_per_public_input: Some(2),
3111 groth16_verify_groth16_proof_internal_public_input_cost_per_byte: Some(2),
3112
3113 hash_blake2b256_cost_base: Some(52),
3115 hash_blake2b256_data_cost_per_byte: Some(2),
3116 hash_blake2b256_data_cost_per_block: Some(2),
3117
3118 hash_keccak256_cost_base: Some(52),
3120 hash_keccak256_data_cost_per_byte: Some(2),
3121 hash_keccak256_data_cost_per_block: Some(2),
3122
3123 poseidon_bn254_cost_base: None,
3124 poseidon_bn254_cost_per_block: None,
3125
3126 hmac_hmac_sha3_256_cost_base: Some(52),
3128 hmac_hmac_sha3_256_input_cost_per_byte: Some(2),
3129 hmac_hmac_sha3_256_input_cost_per_block: Some(2),
3130
3131 group_ops_bls12381_decode_scalar_cost: None,
3133 group_ops_bls12381_decode_g1_cost: None,
3134 group_ops_bls12381_decode_g2_cost: None,
3135 group_ops_bls12381_decode_gt_cost: None,
3136 group_ops_bls12381_scalar_add_cost: None,
3137 group_ops_bls12381_g1_add_cost: None,
3138 group_ops_bls12381_g2_add_cost: None,
3139 group_ops_bls12381_gt_add_cost: None,
3140 group_ops_bls12381_scalar_sub_cost: None,
3141 group_ops_bls12381_g1_sub_cost: None,
3142 group_ops_bls12381_g2_sub_cost: None,
3143 group_ops_bls12381_gt_sub_cost: None,
3144 group_ops_bls12381_scalar_mul_cost: None,
3145 group_ops_bls12381_g1_mul_cost: None,
3146 group_ops_bls12381_g2_mul_cost: None,
3147 group_ops_bls12381_gt_mul_cost: None,
3148 group_ops_bls12381_scalar_div_cost: None,
3149 group_ops_bls12381_g1_div_cost: None,
3150 group_ops_bls12381_g2_div_cost: None,
3151 group_ops_bls12381_gt_div_cost: None,
3152 group_ops_bls12381_g1_hash_to_base_cost: None,
3153 group_ops_bls12381_g2_hash_to_base_cost: None,
3154 group_ops_bls12381_g1_hash_to_cost_per_byte: None,
3155 group_ops_bls12381_g2_hash_to_cost_per_byte: None,
3156 group_ops_bls12381_g1_msm_base_cost: None,
3157 group_ops_bls12381_g2_msm_base_cost: None,
3158 group_ops_bls12381_g1_msm_base_cost_per_input: None,
3159 group_ops_bls12381_g2_msm_base_cost_per_input: None,
3160 group_ops_bls12381_msm_max_len: None,
3161 group_ops_bls12381_pairing_cost: None,
3162 group_ops_bls12381_g1_to_uncompressed_g1_cost: None,
3163 group_ops_bls12381_uncompressed_g1_to_g1_cost: None,
3164 group_ops_bls12381_uncompressed_g1_sum_base_cost: None,
3165 group_ops_bls12381_uncompressed_g1_sum_cost_per_term: None,
3166 group_ops_bls12381_uncompressed_g1_sum_max_terms: None,
3167
3168 group_ops_ristretto_decode_scalar_cost: None,
3169 group_ops_ristretto_decode_point_cost: None,
3170 group_ops_ristretto_scalar_add_cost: None,
3171 group_ops_ristretto_point_add_cost: None,
3172 group_ops_ristretto_scalar_sub_cost: None,
3173 group_ops_ristretto_point_sub_cost: None,
3174 group_ops_ristretto_scalar_mul_cost: None,
3175 group_ops_ristretto_point_mul_cost: None,
3176 group_ops_ristretto_scalar_div_cost: None,
3177 group_ops_ristretto_point_div_cost: None,
3178
3179 verify_bulletproofs_ristretto255_base_cost: None,
3180 verify_bulletproofs_ristretto255_cost_per_bit_and_commitment: None,
3181 max_bulletproofs_total_bits: None,
3182
3183 check_zklogin_id_cost_base: None,
3185 check_zklogin_issuer_cost_base: None,
3187
3188 vdf_verify_vdf_cost: None,
3189 vdf_hash_to_input_cost: None,
3190
3191 nitro_attestation_parse_base_cost: None,
3193 nitro_attestation_parse_cost_per_byte: None,
3194 nitro_attestation_verify_base_cost: None,
3195 nitro_attestation_verify_cost_per_cert: None,
3196
3197 layout_node_cost: None,
3198 layout_node_cost_large_layout_threshold: None,
3199 bcs_per_input_abstract_unit_cost: None,
3200 bcs_per_byte_serialized_cost: None,
3201 bcs_legacy_min_output_size_cost: None,
3202 bcs_failure_cost: None,
3203 hash_sha2_256_base_cost: None,
3204 hash_sha2_256_per_byte_cost: None,
3205 hash_sha2_256_legacy_min_input_len_cost: None,
3206 hash_sha3_256_base_cost: None,
3207 hash_sha3_256_per_byte_cost: None,
3208 hash_sha3_256_legacy_min_input_len_cost: None,
3209 type_name_get_base_cost: None,
3210 type_name_get_per_byte_cost: None,
3211 type_name_id_base_cost: None,
3212 string_check_utf8_base_cost: None,
3213 string_check_utf8_per_byte_cost: None,
3214 string_is_char_boundary_base_cost: None,
3215 string_sub_string_base_cost: None,
3216 string_sub_string_per_byte_cost: None,
3217 string_index_of_base_cost: None,
3218 string_index_of_per_byte_pattern_cost: None,
3219 string_index_of_per_byte_searched_cost: None,
3220 vector_empty_base_cost: None,
3221 vector_length_base_cost: None,
3222 vector_push_back_base_cost: None,
3223 vector_push_back_legacy_per_abstract_memory_unit_cost: None,
3224 vector_borrow_base_cost: None,
3225 vector_pop_back_base_cost: None,
3226 vector_destroy_empty_base_cost: None,
3227 vector_swap_base_cost: None,
3228 vector_reverse_base_cost: None,
3229 vector_reverse_per_elem_cost: None,
3230 vector_keep_range_base_cost: None,
3231 vector_keep_range_per_dropped_elem_cost: None,
3232 vector_keep_range_per_moved_elem_cost: None,
3233 vector_copy_range_base_cost: None,
3234 vector_copy_range_per_abstract_memory_unit_cost: None,
3235 vector_replace_range_base_cost: None,
3236 vector_replace_range_per_elem_cost: None,
3237 debug_print_base_cost: None,
3238 debug_print_stack_trace_base_cost: None,
3239
3240 max_size_written_objects: None,
3241 max_size_written_objects_system_tx: None,
3242
3243 max_move_identifier_len: None,
3250 max_move_value_depth: None,
3251 package_arena_size_in_bytes: None,
3252 max_move_enum_variants: None,
3253
3254 gas_rounding_step: None,
3255
3256 execution_version: None,
3257
3258 max_event_emit_size_total: None,
3259
3260 consensus_bad_nodes_stake_threshold: None,
3261
3262 max_jwk_votes_per_validator_per_epoch: None,
3263
3264 max_age_of_jwk_in_epochs: None,
3265
3266 random_beacon_reduction_allowed_delta: None,
3267
3268 random_beacon_reduction_lower_bound: None,
3269
3270 random_beacon_dkg_timeout_round: None,
3271
3272 random_beacon_min_round_interval_ms: None,
3273
3274 random_beacon_dkg_version: None,
3275
3276 consensus_max_transaction_size_bytes: None,
3277
3278 consensus_max_transactions_in_block_bytes: None,
3279
3280 consensus_max_num_transactions_in_block: None,
3281
3282 consensus_voting_rounds: None,
3283
3284 max_accumulated_txn_cost_per_object_in_narwhal_commit: None,
3285
3286 max_deferral_rounds_for_congestion_control: None,
3287
3288 epoch_close_deadline_ms: None,
3289
3290 max_txn_cost_overage_per_object_in_commit: None,
3291
3292 allowed_txn_cost_overage_burst_per_object_in_commit: None,
3293
3294 min_checkpoint_interval_ms: None,
3295
3296 checkpoint_summary_version_specific_data: None,
3297
3298 max_soft_bundle_size: None,
3299
3300 bridge_should_try_to_finalize_committee: None,
3301
3302 max_accumulated_txn_cost_per_object_in_mysticeti_commit: None,
3303
3304 max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit: None,
3305
3306 consensus_gc_depth: None,
3307
3308 gas_budget_based_txn_cost_cap_factor: None,
3309
3310 gas_budget_based_txn_cost_absolute_cap_commit_count: None,
3311
3312 sip_45_consensus_amplification_threshold: None,
3313 staggered_submission_signal_window_commits: None,
3314 staggered_submission_signal_min_excess_copies_per_commit: None,
3315 staggered_submission_signal_min_consensus_user_transactions_per_commit: None,
3316 staggered_submission_signal_exit_dwell_commits: None,
3317 staggered_submission_signal_band1_enter_ratio_bps: None,
3318 staggered_submission_signal_band1_exit_ratio_bps: None,
3319 staggered_submission_signal_band2_enter_ratio_bps: None,
3320 staggered_submission_signal_band2_exit_ratio_bps: None,
3321
3322 use_object_per_epoch_marker_table_v2: None,
3323
3324 consensus_commit_rate_estimation_window_size: None,
3325
3326 aliased_addresses: vec![],
3327
3328 translation_per_command_base_charge: None,
3329 translation_per_input_base_charge: None,
3330 translation_pure_input_per_byte_charge: None,
3331 translation_per_type_node_charge: None,
3332 translation_per_reference_node_charge: None,
3333 translation_per_linkage_entry_charge: None,
3334 translation_per_live_reference_charge: None,
3335 max_ptb_live_references: None,
3336 max_ptb_returned_references: None,
3337 max_ptb_total_returned_references: None,
3338
3339 max_updates_per_settlement_txn: None,
3340
3341 gasless_max_computation_units: None,
3342 gasless_allowed_token_types: None,
3343 gasless_max_unused_inputs: None,
3344 gasless_max_pure_input_bytes: None,
3345 gasless_max_tps: None,
3346 include_special_package_amendments: None,
3347 gasless_max_tx_size_bytes: None,
3348 };
3351 for cur in 2..=version.0 {
3352 match cur {
3353 1 => unreachable!(),
3354 2 => {
3355 cfg.feature_flags.advance_epoch_start_time_in_safe_mode = true;
3356 }
3357 3 => {
3358 cfg.gas_model_version = Some(2);
3360 cfg.max_tx_gas = Some(50_000_000_000);
3362 cfg.base_tx_cost_fixed = Some(2_000);
3364 cfg.storage_gas_price = Some(76);
3366 cfg.feature_flags.loaded_child_objects_fixed = true;
3367 cfg.max_size_written_objects = Some(5 * 1000 * 1000);
3370 cfg.max_size_written_objects_system_tx = Some(50 * 1000 * 1000);
3373 cfg.feature_flags.package_upgrades = true;
3374 }
3375 4 => {
3380 cfg.reward_slashing_rate = Some(10000);
3382 cfg.gas_model_version = Some(3);
3384 }
3385 5 => {
3386 cfg.feature_flags.missing_type_is_compatibility_error = true;
3387 cfg.gas_model_version = Some(4);
3388 cfg.feature_flags.scoring_decision_with_validity_cutoff = true;
3389 }
3393 6 => {
3394 cfg.gas_model_version = Some(5);
3395 cfg.buffer_stake_for_protocol_upgrade_bps = Some(5000);
3396 cfg.feature_flags.consensus_order_end_of_epoch_last = true;
3397 }
3398 7 => {
3399 cfg.feature_flags.disallow_adding_abilities_on_upgrade = true;
3400 cfg.feature_flags
3401 .disable_invariant_violation_check_in_swap_loc = true;
3402 cfg.feature_flags.ban_entry_init = true;
3403 cfg.feature_flags.package_digest_hash_module = true;
3404 }
3405 8 => {
3406 cfg.feature_flags
3407 .disallow_change_struct_type_params_on_upgrade = true;
3408 }
3409 9 => {
3410 cfg.max_move_identifier_len = Some(128);
3412 cfg.feature_flags.no_extraneous_module_bytes = true;
3413 cfg.feature_flags
3414 .advance_to_highest_supported_protocol_version = true;
3415 }
3416 10 => {
3417 cfg.max_verifier_meter_ticks_per_function = Some(16_000_000);
3418 cfg.max_meter_ticks_per_module = Some(16_000_000);
3419 }
3420 11 => {
3421 cfg.max_move_value_depth = Some(128);
3422 }
3423 12 => {
3424 cfg.feature_flags.narwhal_versioned_metadata = true;
3425 if chain != Chain::Mainnet {
3426 cfg.feature_flags.commit_root_state_digest = true;
3427 }
3428
3429 if chain != Chain::Mainnet && chain != Chain::Testnet {
3430 cfg.feature_flags.zklogin_auth = true;
3431 }
3432 }
3433 13 => {}
3434 14 => {
3435 cfg.gas_rounding_step = Some(1_000);
3436 cfg.gas_model_version = Some(6);
3437 }
3438 15 => {
3439 cfg.feature_flags.consensus_transaction_ordering =
3440 ConsensusTransactionOrdering::ByGasPrice;
3441 }
3442 16 => {
3443 cfg.feature_flags.simplified_unwrap_then_delete = true;
3444 }
3445 17 => {
3446 cfg.feature_flags.upgraded_multisig_supported = true;
3447 }
3448 18 => {
3449 cfg.execution_version = Some(1);
3450 cfg.feature_flags.txn_base_cost_as_multiplier = true;
3459 cfg.base_tx_cost_fixed = Some(1_000);
3461 }
3462 19 => {
3463 cfg.max_num_event_emit = Some(1024);
3464 cfg.max_event_emit_size_total = Some(
3467 256 * 250 * 1024, );
3469 }
3470 20 => {
3471 cfg.feature_flags.commit_root_state_digest = true;
3472
3473 if chain != Chain::Mainnet {
3474 cfg.feature_flags.narwhal_new_leader_election_schedule = true;
3475 cfg.consensus_bad_nodes_stake_threshold = Some(20);
3476 }
3477 }
3478
3479 21 => {
3480 if chain != Chain::Mainnet {
3481 cfg.feature_flags.zklogin_supported_providers = BTreeSet::from([
3482 "Google".to_string(),
3483 "Facebook".to_string(),
3484 "Twitch".to_string(),
3485 ]);
3486 }
3487 }
3488 22 => {
3489 cfg.feature_flags.loaded_child_object_format = true;
3490 }
3491 23 => {
3492 cfg.feature_flags.loaded_child_object_format_type = true;
3493 cfg.feature_flags.narwhal_new_leader_election_schedule = true;
3494 cfg.consensus_bad_nodes_stake_threshold = Some(20);
3500 }
3501 24 => {
3502 cfg.feature_flags.simple_conservation_checks = true;
3503 cfg.max_publish_or_upgrade_per_ptb = Some(5);
3504
3505 cfg.feature_flags.end_of_epoch_transaction_supported = true;
3506
3507 if chain != Chain::Mainnet {
3508 cfg.feature_flags.enable_jwk_consensus_updates = true;
3509 cfg.max_jwk_votes_per_validator_per_epoch = Some(240);
3511 cfg.max_age_of_jwk_in_epochs = Some(1);
3512 }
3513 }
3514 25 => {
3515 cfg.feature_flags.zklogin_supported_providers = BTreeSet::from([
3517 "Google".to_string(),
3518 "Facebook".to_string(),
3519 "Twitch".to_string(),
3520 ]);
3521 cfg.feature_flags.zklogin_auth = true;
3522
3523 cfg.feature_flags.enable_jwk_consensus_updates = true;
3525 cfg.max_jwk_votes_per_validator_per_epoch = Some(240);
3526 cfg.max_age_of_jwk_in_epochs = Some(1);
3527 }
3528 26 => {
3529 cfg.gas_model_version = Some(7);
3530 if chain != Chain::Mainnet && chain != Chain::Testnet {
3532 cfg.transfer_receive_object_cost_base = Some(52);
3533 cfg.feature_flags.receive_objects = true;
3534 }
3535 }
3536 27 => {
3537 cfg.gas_model_version = Some(8);
3538 }
3539 28 => {
3540 cfg.check_zklogin_id_cost_base = Some(200);
3542 cfg.check_zklogin_issuer_cost_base = Some(200);
3544
3545 if chain != Chain::Mainnet && chain != Chain::Testnet {
3547 cfg.feature_flags.enable_effects_v2 = true;
3548 }
3549 }
3550 29 => {
3551 cfg.feature_flags.verify_legacy_zklogin_address = true;
3552 }
3553 30 => {
3554 if chain != Chain::Mainnet {
3556 cfg.feature_flags.narwhal_certificate_v2 = true;
3557 }
3558
3559 cfg.random_beacon_reduction_allowed_delta = Some(800);
3560 if chain != Chain::Mainnet {
3562 cfg.feature_flags.enable_effects_v2 = true;
3563 }
3564
3565 cfg.feature_flags.zklogin_supported_providers = BTreeSet::default();
3569
3570 cfg.feature_flags.recompute_has_public_transfer_in_execution = true;
3571 }
3572 31 => {
3573 cfg.execution_version = Some(2);
3574 if chain != Chain::Mainnet && chain != Chain::Testnet {
3576 cfg.feature_flags.shared_object_deletion = true;
3577 }
3578 }
3579 32 => {
3580 if chain != Chain::Mainnet {
3582 cfg.feature_flags.accept_zklogin_in_multisig = true;
3583 }
3584 if chain != Chain::Mainnet {
3586 cfg.transfer_receive_object_cost_base = Some(52);
3587 cfg.feature_flags.receive_objects = true;
3588 }
3589 if chain != Chain::Mainnet && chain != Chain::Testnet {
3591 cfg.feature_flags.random_beacon = true;
3592 cfg.random_beacon_reduction_lower_bound = Some(1600);
3593 cfg.random_beacon_dkg_timeout_round = Some(3000);
3594 cfg.random_beacon_min_round_interval_ms = Some(150);
3595 }
3596 if chain != Chain::Testnet && chain != Chain::Mainnet {
3598 cfg.feature_flags.include_consensus_digest_in_prologue = true;
3599 }
3600
3601 cfg.feature_flags.narwhal_certificate_v2 = true;
3603 }
3604 33 => {
3605 cfg.feature_flags.hardened_otw_check = true;
3606 cfg.feature_flags.allow_receiving_object_id = true;
3607
3608 cfg.transfer_receive_object_cost_base = Some(52);
3610 cfg.feature_flags.receive_objects = true;
3611
3612 if chain != Chain::Mainnet {
3614 cfg.feature_flags.shared_object_deletion = true;
3615 }
3616
3617 cfg.feature_flags.enable_effects_v2 = true;
3618 }
3619 34 => {}
3620 35 => {
3621 if chain != Chain::Mainnet && chain != Chain::Testnet {
3623 cfg.feature_flags.enable_poseidon = true;
3624 cfg.poseidon_bn254_cost_base = Some(260);
3625 cfg.poseidon_bn254_cost_per_block = Some(10);
3626 }
3627
3628 cfg.feature_flags.enable_coin_deny_list = true;
3629 }
3630 36 => {
3631 if chain != Chain::Mainnet && chain != Chain::Testnet {
3633 cfg.feature_flags.enable_group_ops_native_functions = true;
3634 cfg.feature_flags.enable_group_ops_native_function_msm = true;
3635 cfg.group_ops_bls12381_decode_scalar_cost = Some(52);
3637 cfg.group_ops_bls12381_decode_g1_cost = Some(52);
3638 cfg.group_ops_bls12381_decode_g2_cost = Some(52);
3639 cfg.group_ops_bls12381_decode_gt_cost = Some(52);
3640 cfg.group_ops_bls12381_scalar_add_cost = Some(52);
3641 cfg.group_ops_bls12381_g1_add_cost = Some(52);
3642 cfg.group_ops_bls12381_g2_add_cost = Some(52);
3643 cfg.group_ops_bls12381_gt_add_cost = Some(52);
3644 cfg.group_ops_bls12381_scalar_sub_cost = Some(52);
3645 cfg.group_ops_bls12381_g1_sub_cost = Some(52);
3646 cfg.group_ops_bls12381_g2_sub_cost = Some(52);
3647 cfg.group_ops_bls12381_gt_sub_cost = Some(52);
3648 cfg.group_ops_bls12381_scalar_mul_cost = Some(52);
3649 cfg.group_ops_bls12381_g1_mul_cost = Some(52);
3650 cfg.group_ops_bls12381_g2_mul_cost = Some(52);
3651 cfg.group_ops_bls12381_gt_mul_cost = Some(52);
3652 cfg.group_ops_bls12381_scalar_div_cost = Some(52);
3653 cfg.group_ops_bls12381_g1_div_cost = Some(52);
3654 cfg.group_ops_bls12381_g2_div_cost = Some(52);
3655 cfg.group_ops_bls12381_gt_div_cost = Some(52);
3656 cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(52);
3657 cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(52);
3658 cfg.group_ops_bls12381_g1_hash_to_cost_per_byte = Some(2);
3659 cfg.group_ops_bls12381_g2_hash_to_cost_per_byte = Some(2);
3660 cfg.group_ops_bls12381_g1_msm_base_cost = Some(52);
3661 cfg.group_ops_bls12381_g2_msm_base_cost = Some(52);
3662 cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(52);
3663 cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(52);
3664 cfg.group_ops_bls12381_msm_max_len = Some(32);
3665 cfg.group_ops_bls12381_pairing_cost = Some(52);
3666 }
3667 cfg.feature_flags.shared_object_deletion = true;
3669
3670 cfg.consensus_max_transaction_size_bytes = Some(256 * 1024); cfg.consensus_max_transactions_in_block_bytes = Some(6 * 1_024 * 1024);
3672 }
3674 37 => {
3675 cfg.feature_flags.reject_mutable_random_on_entry_functions = true;
3676
3677 if chain != Chain::Mainnet {
3679 cfg.feature_flags.include_consensus_digest_in_prologue = true;
3680 }
3681 }
3682 38 => {
3683 cfg.binary_module_handles = Some(100);
3684 cfg.binary_struct_handles = Some(300);
3685 cfg.binary_function_handles = Some(1500);
3686 cfg.binary_function_instantiations = Some(750);
3687 cfg.binary_signatures = Some(1000);
3688 cfg.binary_constant_pool = Some(4000);
3692 cfg.binary_identifiers = Some(10000);
3693 cfg.binary_address_identifiers = Some(100);
3694 cfg.binary_struct_defs = Some(200);
3695 cfg.binary_struct_def_instantiations = Some(100);
3696 cfg.binary_function_defs = Some(1000);
3697 cfg.binary_field_handles = Some(500);
3698 cfg.binary_field_instantiations = Some(250);
3699 cfg.binary_friend_decls = Some(100);
3700 cfg.max_package_dependencies = Some(32);
3702 cfg.max_modules_in_publish = Some(64);
3703 cfg.execution_version = Some(3);
3705 }
3706 39 => {
3707 }
3709 40 => {}
3710 41 => {
3711 cfg.feature_flags.enable_group_ops_native_functions = true;
3713 cfg.group_ops_bls12381_decode_scalar_cost = Some(52);
3715 cfg.group_ops_bls12381_decode_g1_cost = Some(52);
3716 cfg.group_ops_bls12381_decode_g2_cost = Some(52);
3717 cfg.group_ops_bls12381_decode_gt_cost = Some(52);
3718 cfg.group_ops_bls12381_scalar_add_cost = Some(52);
3719 cfg.group_ops_bls12381_g1_add_cost = Some(52);
3720 cfg.group_ops_bls12381_g2_add_cost = Some(52);
3721 cfg.group_ops_bls12381_gt_add_cost = Some(52);
3722 cfg.group_ops_bls12381_scalar_sub_cost = Some(52);
3723 cfg.group_ops_bls12381_g1_sub_cost = Some(52);
3724 cfg.group_ops_bls12381_g2_sub_cost = Some(52);
3725 cfg.group_ops_bls12381_gt_sub_cost = Some(52);
3726 cfg.group_ops_bls12381_scalar_mul_cost = Some(52);
3727 cfg.group_ops_bls12381_g1_mul_cost = Some(52);
3728 cfg.group_ops_bls12381_g2_mul_cost = Some(52);
3729 cfg.group_ops_bls12381_gt_mul_cost = Some(52);
3730 cfg.group_ops_bls12381_scalar_div_cost = Some(52);
3731 cfg.group_ops_bls12381_g1_div_cost = Some(52);
3732 cfg.group_ops_bls12381_g2_div_cost = Some(52);
3733 cfg.group_ops_bls12381_gt_div_cost = Some(52);
3734 cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(52);
3735 cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(52);
3736 cfg.group_ops_bls12381_g1_hash_to_cost_per_byte = Some(2);
3737 cfg.group_ops_bls12381_g2_hash_to_cost_per_byte = Some(2);
3738 cfg.group_ops_bls12381_g1_msm_base_cost = Some(52);
3739 cfg.group_ops_bls12381_g2_msm_base_cost = Some(52);
3740 cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(52);
3741 cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(52);
3742 cfg.group_ops_bls12381_msm_max_len = Some(32);
3743 cfg.group_ops_bls12381_pairing_cost = Some(52);
3744 }
3745 42 => {}
3746 43 => {
3747 cfg.feature_flags.zklogin_max_epoch_upper_bound_delta = Some(30);
3748 cfg.max_meter_ticks_per_package = Some(16_000_000);
3749 }
3750 44 => {
3751 cfg.feature_flags.include_consensus_digest_in_prologue = true;
3753 if chain != Chain::Mainnet {
3755 cfg.feature_flags.consensus_choice = ConsensusChoice::SwapEachEpoch;
3756 }
3757 }
3758 45 => {
3759 if chain != Chain::Testnet && chain != Chain::Mainnet {
3761 cfg.feature_flags.consensus_network = ConsensusNetwork::Tonic;
3762 }
3763
3764 if chain != Chain::Mainnet {
3765 cfg.feature_flags.mysticeti_leader_scoring_and_schedule = true;
3767 }
3768 cfg.min_move_binary_format_version = Some(6);
3769 cfg.feature_flags.accept_zklogin_in_multisig = true;
3770
3771 if chain != Chain::Mainnet && chain != Chain::Testnet {
3775 cfg.feature_flags.bridge = true;
3776 }
3777 }
3778 46 => {
3779 if chain != Chain::Mainnet {
3781 cfg.feature_flags.bridge = true;
3782 }
3783
3784 cfg.feature_flags.reshare_at_same_initial_version = true;
3786 }
3787 47 => {}
3788 48 => {
3789 cfg.feature_flags.consensus_network = ConsensusNetwork::Tonic;
3791
3792 cfg.feature_flags.resolve_abort_locations_to_package_id = true;
3794
3795 if chain != Chain::Mainnet {
3797 cfg.feature_flags.random_beacon = true;
3798 cfg.random_beacon_reduction_lower_bound = Some(1600);
3799 cfg.random_beacon_dkg_timeout_round = Some(3000);
3800 cfg.random_beacon_min_round_interval_ms = Some(200);
3801 }
3802
3803 cfg.feature_flags.mysticeti_use_committed_subdag_digest = true;
3805 }
3806 49 => {
3807 if chain != Chain::Testnet && chain != Chain::Mainnet {
3808 cfg.move_binary_format_version = Some(7);
3809 }
3810
3811 if chain != Chain::Mainnet && chain != Chain::Testnet {
3813 cfg.feature_flags.enable_vdf = true;
3814 cfg.vdf_verify_vdf_cost = Some(1500);
3817 cfg.vdf_hash_to_input_cost = Some(100);
3818 }
3819
3820 if chain != Chain::Testnet && chain != Chain::Mainnet {
3822 cfg.feature_flags
3823 .record_consensus_determined_version_assignments_in_prologue = true;
3824 }
3825
3826 if chain != Chain::Mainnet {
3828 cfg.feature_flags.consensus_choice = ConsensusChoice::Mysticeti;
3829 }
3830
3831 cfg.feature_flags.fresh_vm_on_framework_upgrade = true;
3833 }
3834 50 => {
3835 if chain != Chain::Mainnet {
3837 cfg.checkpoint_summary_version_specific_data = Some(1);
3838 cfg.min_checkpoint_interval_ms = Some(200);
3839 }
3840
3841 if chain != Chain::Testnet && chain != Chain::Mainnet {
3843 cfg.feature_flags
3844 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3845 }
3846
3847 cfg.feature_flags.mysticeti_num_leaders_per_round = Some(1);
3848
3849 cfg.max_deferral_rounds_for_congestion_control = Some(10);
3851 }
3852 51 => {
3853 cfg.random_beacon_dkg_version = Some(1);
3854
3855 if chain != Chain::Testnet && chain != Chain::Mainnet {
3856 cfg.feature_flags.enable_coin_deny_list_v2 = true;
3857 }
3858 }
3859 52 => {
3860 if chain != Chain::Mainnet {
3861 cfg.feature_flags.soft_bundle = true;
3862 cfg.max_soft_bundle_size = Some(5);
3863 }
3864
3865 cfg.config_read_setting_impl_cost_base = Some(100);
3866 cfg.config_read_setting_impl_cost_per_byte = Some(40);
3867
3868 if chain != Chain::Testnet && chain != Chain::Mainnet {
3870 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3871 cfg.feature_flags.per_object_congestion_control_mode =
3872 PerObjectCongestionControlMode::TotalTxCount;
3873 }
3874
3875 cfg.feature_flags.consensus_choice = ConsensusChoice::Mysticeti;
3877
3878 cfg.feature_flags.mysticeti_leader_scoring_and_schedule = true;
3880
3881 cfg.checkpoint_summary_version_specific_data = Some(1);
3883 cfg.min_checkpoint_interval_ms = Some(200);
3884
3885 if chain != Chain::Mainnet {
3887 cfg.feature_flags
3888 .record_consensus_determined_version_assignments_in_prologue = true;
3889 cfg.feature_flags
3890 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3891 }
3892 if chain != Chain::Mainnet {
3894 cfg.move_binary_format_version = Some(7);
3895 }
3896
3897 if chain != Chain::Testnet && chain != Chain::Mainnet {
3898 cfg.feature_flags.passkey_auth = true;
3899 }
3900 cfg.feature_flags.enable_coin_deny_list_v2 = true;
3901 }
3902 53 => {
3903 cfg.bridge_should_try_to_finalize_committee = Some(chain != Chain::Mainnet);
3905
3906 cfg.feature_flags
3908 .record_consensus_determined_version_assignments_in_prologue = true;
3909 cfg.feature_flags
3910 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3911
3912 if chain == Chain::Unknown {
3913 cfg.feature_flags.authority_capabilities_v2 = true;
3914 }
3915
3916 if chain != Chain::Mainnet {
3918 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3919 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(10);
3920 cfg.feature_flags.per_object_congestion_control_mode =
3921 PerObjectCongestionControlMode::TotalTxCount;
3922 }
3923
3924 cfg.bcs_per_byte_serialized_cost = Some(2);
3926 cfg.bcs_legacy_min_output_size_cost = Some(1);
3927 cfg.bcs_failure_cost = Some(52);
3928 cfg.debug_print_base_cost = Some(52);
3929 cfg.debug_print_stack_trace_base_cost = Some(52);
3930 cfg.hash_sha2_256_base_cost = Some(52);
3931 cfg.hash_sha2_256_per_byte_cost = Some(2);
3932 cfg.hash_sha2_256_legacy_min_input_len_cost = Some(1);
3933 cfg.hash_sha3_256_base_cost = Some(52);
3934 cfg.hash_sha3_256_per_byte_cost = Some(2);
3935 cfg.hash_sha3_256_legacy_min_input_len_cost = Some(1);
3936 cfg.type_name_get_base_cost = Some(52);
3937 cfg.type_name_get_per_byte_cost = Some(2);
3938 cfg.string_check_utf8_base_cost = Some(52);
3939 cfg.string_check_utf8_per_byte_cost = Some(2);
3940 cfg.string_is_char_boundary_base_cost = Some(52);
3941 cfg.string_sub_string_base_cost = Some(52);
3942 cfg.string_sub_string_per_byte_cost = Some(2);
3943 cfg.string_index_of_base_cost = Some(52);
3944 cfg.string_index_of_per_byte_pattern_cost = Some(2);
3945 cfg.string_index_of_per_byte_searched_cost = Some(2);
3946 cfg.vector_empty_base_cost = Some(52);
3947 cfg.vector_length_base_cost = Some(52);
3948 cfg.vector_push_back_base_cost = Some(52);
3949 cfg.vector_push_back_legacy_per_abstract_memory_unit_cost = Some(2);
3950 cfg.vector_borrow_base_cost = Some(52);
3951 cfg.vector_pop_back_base_cost = Some(52);
3952 cfg.vector_destroy_empty_base_cost = Some(52);
3953 cfg.vector_swap_base_cost = Some(52);
3954 }
3955 54 => {
3956 cfg.feature_flags.random_beacon = true;
3958 cfg.random_beacon_reduction_lower_bound = Some(1000);
3959 cfg.random_beacon_dkg_timeout_round = Some(3000);
3960 cfg.random_beacon_min_round_interval_ms = Some(500);
3961
3962 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3964 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(10);
3965 cfg.feature_flags.per_object_congestion_control_mode =
3966 PerObjectCongestionControlMode::TotalTxCount;
3967
3968 cfg.feature_flags.soft_bundle = true;
3970 cfg.max_soft_bundle_size = Some(5);
3971 }
3972 55 => {
3973 cfg.move_binary_format_version = Some(7);
3975
3976 cfg.consensus_max_transactions_in_block_bytes = Some(512 * 1024);
3978 cfg.consensus_max_num_transactions_in_block = Some(512);
3981
3982 cfg.feature_flags.rethrow_serialization_type_layout_errors = true;
3983 }
3984 56 => {
3985 if chain == Chain::Mainnet {
3986 cfg.feature_flags.bridge = true;
3987 }
3988 }
3989 57 => {
3990 cfg.random_beacon_reduction_lower_bound = Some(800);
3992 }
3993 58 => {
3994 if chain == Chain::Mainnet {
3995 cfg.bridge_should_try_to_finalize_committee = Some(true);
3996 }
3997
3998 if chain != Chain::Mainnet && chain != Chain::Testnet {
3999 cfg.feature_flags
4001 .consensus_distributed_vote_scoring_strategy = true;
4002 }
4003 }
4004 59 => {
4005 cfg.feature_flags.consensus_round_prober = true;
4007 }
4008 60 => {
4009 cfg.max_type_to_layout_nodes = Some(512);
4010 cfg.feature_flags.validate_identifier_inputs = true;
4011 }
4012 61 => {
4013 if chain != Chain::Mainnet {
4014 cfg.feature_flags
4016 .consensus_distributed_vote_scoring_strategy = true;
4017 }
4018 cfg.random_beacon_reduction_lower_bound = Some(700);
4020
4021 if chain != Chain::Mainnet && chain != Chain::Testnet {
4022 cfg.feature_flags.mysticeti_fastpath = true;
4024 }
4025 }
4026 62 => {
4027 cfg.feature_flags.relocate_event_module = true;
4028 }
4029 63 => {
4030 cfg.feature_flags.per_object_congestion_control_mode =
4031 PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4032 cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4033 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(18_500_000);
4034 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(240_000_000);
4035 }
4036 64 => {
4037 cfg.feature_flags.per_object_congestion_control_mode =
4038 PerObjectCongestionControlMode::TotalTxCount;
4039 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(40);
4040 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(3);
4041 }
4042 65 => {
4043 cfg.feature_flags
4045 .consensus_distributed_vote_scoring_strategy = true;
4046 }
4047 66 => {
4048 if chain == Chain::Mainnet {
4049 cfg.feature_flags
4051 .consensus_distributed_vote_scoring_strategy = false;
4052 }
4053 }
4054 67 => {
4055 cfg.feature_flags
4057 .consensus_distributed_vote_scoring_strategy = true;
4058 }
4059 68 => {
4060 cfg.group_ops_bls12381_g1_to_uncompressed_g1_cost = Some(26);
4061 cfg.group_ops_bls12381_uncompressed_g1_to_g1_cost = Some(52);
4062 cfg.group_ops_bls12381_uncompressed_g1_sum_base_cost = Some(26);
4063 cfg.group_ops_bls12381_uncompressed_g1_sum_cost_per_term = Some(13);
4064 cfg.group_ops_bls12381_uncompressed_g1_sum_max_terms = Some(2000);
4065
4066 if chain != Chain::Mainnet && chain != Chain::Testnet {
4067 cfg.feature_flags.uncompressed_g1_group_elements = true;
4068 }
4069
4070 cfg.feature_flags.per_object_congestion_control_mode =
4071 PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4072 cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4073 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(18_500_000);
4074 cfg.max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit =
4075 Some(3_700_000); cfg.max_txn_cost_overage_per_object_in_commit = Some(u64::MAX);
4077 cfg.gas_budget_based_txn_cost_absolute_cap_commit_count = Some(50);
4078
4079 cfg.random_beacon_reduction_lower_bound = Some(500);
4081
4082 cfg.feature_flags.disallow_new_modules_in_deps_only_packages = true;
4083 }
4084 69 => {
4085 cfg.consensus_voting_rounds = Some(40);
4087
4088 if chain != Chain::Mainnet && chain != Chain::Testnet {
4089 cfg.feature_flags.consensus_smart_ancestor_selection = true;
4091 }
4092
4093 if chain != Chain::Mainnet {
4094 cfg.feature_flags.uncompressed_g1_group_elements = true;
4095 }
4096 }
4097 70 => {
4098 if chain != Chain::Mainnet {
4099 cfg.feature_flags.consensus_smart_ancestor_selection = true;
4101 cfg.feature_flags
4103 .consensus_round_prober_probe_accepted_rounds = true;
4104 }
4105
4106 cfg.poseidon_bn254_cost_per_block = Some(388);
4107
4108 cfg.gas_model_version = Some(9);
4109 cfg.feature_flags.native_charging_v2 = true;
4110 cfg.bls12381_bls12381_min_sig_verify_cost_base = Some(44064);
4111 cfg.bls12381_bls12381_min_pk_verify_cost_base = Some(49282);
4112 cfg.ecdsa_k1_secp256k1_verify_keccak256_cost_base = Some(1470);
4113 cfg.ecdsa_k1_secp256k1_verify_sha256_cost_base = Some(1470);
4114 cfg.ecdsa_r1_secp256r1_verify_sha256_cost_base = Some(4225);
4115 cfg.ecdsa_r1_secp256r1_verify_keccak256_cost_base = Some(4225);
4116 cfg.ecvrf_ecvrf_verify_cost_base = Some(4848);
4117 cfg.ed25519_ed25519_verify_cost_base = Some(1802);
4118
4119 cfg.ecdsa_r1_ecrecover_keccak256_cost_base = Some(1173);
4121 cfg.ecdsa_r1_ecrecover_sha256_cost_base = Some(1173);
4122 cfg.ecdsa_k1_ecrecover_keccak256_cost_base = Some(500);
4123 cfg.ecdsa_k1_ecrecover_sha256_cost_base = Some(500);
4124
4125 cfg.groth16_prepare_verifying_key_bls12381_cost_base = Some(53838);
4126 cfg.groth16_prepare_verifying_key_bn254_cost_base = Some(82010);
4127 cfg.groth16_verify_groth16_proof_internal_bls12381_cost_base = Some(72090);
4128 cfg.groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input =
4129 Some(8213);
4130 cfg.groth16_verify_groth16_proof_internal_bn254_cost_base = Some(115502);
4131 cfg.groth16_verify_groth16_proof_internal_bn254_cost_per_public_input =
4132 Some(9484);
4133
4134 cfg.hash_keccak256_cost_base = Some(10);
4135 cfg.hash_blake2b256_cost_base = Some(10);
4136
4137 cfg.group_ops_bls12381_decode_scalar_cost = Some(7);
4139 cfg.group_ops_bls12381_decode_g1_cost = Some(2848);
4140 cfg.group_ops_bls12381_decode_g2_cost = Some(3770);
4141 cfg.group_ops_bls12381_decode_gt_cost = Some(3068);
4142
4143 cfg.group_ops_bls12381_scalar_add_cost = Some(10);
4144 cfg.group_ops_bls12381_g1_add_cost = Some(1556);
4145 cfg.group_ops_bls12381_g2_add_cost = Some(3048);
4146 cfg.group_ops_bls12381_gt_add_cost = Some(188);
4147
4148 cfg.group_ops_bls12381_scalar_sub_cost = Some(10);
4149 cfg.group_ops_bls12381_g1_sub_cost = Some(1550);
4150 cfg.group_ops_bls12381_g2_sub_cost = Some(3019);
4151 cfg.group_ops_bls12381_gt_sub_cost = Some(497);
4152
4153 cfg.group_ops_bls12381_scalar_mul_cost = Some(11);
4154 cfg.group_ops_bls12381_g1_mul_cost = Some(4842);
4155 cfg.group_ops_bls12381_g2_mul_cost = Some(9108);
4156 cfg.group_ops_bls12381_gt_mul_cost = Some(27490);
4157
4158 cfg.group_ops_bls12381_scalar_div_cost = Some(91);
4159 cfg.group_ops_bls12381_g1_div_cost = Some(5091);
4160 cfg.group_ops_bls12381_g2_div_cost = Some(9206);
4161 cfg.group_ops_bls12381_gt_div_cost = Some(27804);
4162
4163 cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(2962);
4164 cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(8688);
4165
4166 cfg.group_ops_bls12381_g1_msm_base_cost = Some(62648);
4167 cfg.group_ops_bls12381_g2_msm_base_cost = Some(131192);
4168 cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(1333);
4169 cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(3216);
4170
4171 cfg.group_ops_bls12381_uncompressed_g1_to_g1_cost = Some(677);
4172 cfg.group_ops_bls12381_g1_to_uncompressed_g1_cost = Some(2099);
4173 cfg.group_ops_bls12381_uncompressed_g1_sum_base_cost = Some(77);
4174 cfg.group_ops_bls12381_uncompressed_g1_sum_cost_per_term = Some(26);
4175
4176 cfg.group_ops_bls12381_pairing_cost = Some(26897);
4177 cfg.group_ops_bls12381_uncompressed_g1_sum_max_terms = Some(1200);
4178
4179 cfg.validator_validate_metadata_cost_base = Some(20000);
4180 }
4181 71 => {
4182 cfg.sip_45_consensus_amplification_threshold = Some(5);
4183
4184 cfg.allowed_txn_cost_overage_burst_per_object_in_commit = Some(185_000_000);
4186 }
4187 72 => {
4188 cfg.feature_flags.convert_type_argument_error = true;
4189
4190 cfg.max_tx_gas = Some(50_000_000_000_000);
4193 cfg.max_gas_price = Some(50_000_000_000);
4195
4196 cfg.feature_flags.variant_nodes = true;
4197 }
4198 73 => {
4199 cfg.use_object_per_epoch_marker_table_v2 = Some(true);
4201
4202 if chain != Chain::Mainnet && chain != Chain::Testnet {
4203 cfg.consensus_gc_depth = Some(60);
4206 }
4207
4208 if chain != Chain::Mainnet {
4209 cfg.feature_flags.consensus_zstd_compression = true;
4211 }
4212
4213 cfg.feature_flags.consensus_smart_ancestor_selection = true;
4215 cfg.feature_flags
4217 .consensus_round_prober_probe_accepted_rounds = true;
4218
4219 cfg.feature_flags.per_object_congestion_control_mode =
4221 PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4222 cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4223 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(37_000_000);
4224 cfg.max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit =
4225 Some(7_400_000); cfg.max_txn_cost_overage_per_object_in_commit = Some(u64::MAX);
4227 cfg.gas_budget_based_txn_cost_absolute_cap_commit_count = Some(50);
4228 cfg.allowed_txn_cost_overage_burst_per_object_in_commit = Some(370_000_000);
4229 }
4230 74 => {
4231 if chain != Chain::Mainnet && chain != Chain::Testnet {
4233 cfg.feature_flags.enable_nitro_attestation = true;
4234 }
4235 cfg.nitro_attestation_parse_base_cost = Some(53 * 50);
4236 cfg.nitro_attestation_parse_cost_per_byte = Some(50);
4237 cfg.nitro_attestation_verify_base_cost = Some(49632 * 50);
4238 cfg.nitro_attestation_verify_cost_per_cert = Some(52369 * 50);
4239
4240 cfg.feature_flags.consensus_zstd_compression = true;
4242
4243 if chain != Chain::Mainnet && chain != Chain::Testnet {
4244 cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4245 }
4246 }
4247 75 => {
4248 if chain != Chain::Mainnet {
4249 cfg.feature_flags.passkey_auth = true;
4250 }
4251 }
4252 76 => {
4253 if chain != Chain::Mainnet && chain != Chain::Testnet {
4254 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4255 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4256 }
4257 cfg.feature_flags.minimize_child_object_mutations = true;
4258
4259 if chain != Chain::Mainnet {
4260 cfg.feature_flags.accept_passkey_in_multisig = true;
4261 }
4262 }
4263 77 => {
4264 cfg.feature_flags.uncompressed_g1_group_elements = true;
4265
4266 if chain != Chain::Mainnet {
4267 cfg.consensus_gc_depth = Some(60);
4268 cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4269 }
4270 }
4271 78 => {
4272 cfg.feature_flags.move_native_context = true;
4273 cfg.tx_context_fresh_id_cost_base = Some(52);
4274 cfg.tx_context_sender_cost_base = Some(30);
4275 cfg.tx_context_epoch_cost_base = Some(30);
4276 cfg.tx_context_epoch_timestamp_ms_cost_base = Some(30);
4277 cfg.tx_context_sponsor_cost_base = Some(30);
4278 cfg.tx_context_gas_price_cost_base = Some(30);
4279 cfg.tx_context_gas_budget_cost_base = Some(30);
4280 cfg.tx_context_ids_created_cost_base = Some(30);
4281 cfg.tx_context_replace_cost_base = Some(30);
4282 cfg.gas_model_version = Some(10);
4283
4284 if chain != Chain::Mainnet {
4285 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4286 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4287
4288 cfg.feature_flags.per_object_congestion_control_mode =
4290 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4291 ExecutionTimeEstimateParams {
4292 target_utilization: 30,
4293 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4295 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4297 stored_observations_limit: u64::MAX,
4298 stake_weighted_median_threshold: 0,
4299 default_none_duration_for_new_keys: false,
4300 observations_chunk_size: None,
4301 },
4302 );
4303 }
4304 }
4305 79 => {
4306 if chain != Chain::Mainnet {
4307 cfg.feature_flags.consensus_median_based_commit_timestamp = true;
4308
4309 cfg.consensus_bad_nodes_stake_threshold = Some(30);
4312
4313 cfg.feature_flags.consensus_batched_block_sync = true;
4314
4315 cfg.feature_flags.enable_nitro_attestation = true
4317 }
4318 cfg.feature_flags.normalize_ptb_arguments = true;
4319
4320 cfg.consensus_gc_depth = Some(60);
4321 cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4322 }
4323 80 => {
4324 cfg.max_ptb_value_size = Some(1024 * 1024);
4325 }
4326 81 => {
4327 cfg.feature_flags.consensus_median_based_commit_timestamp = true;
4328 cfg.feature_flags.enforce_checkpoint_timestamp_monotonicity = true;
4329 cfg.consensus_bad_nodes_stake_threshold = Some(30)
4330 }
4331 82 => {
4332 cfg.feature_flags.max_ptb_value_size_v2 = true;
4333 }
4334 83 => {
4335 if chain == Chain::Mainnet {
4336 let aliased: [u8; 32] = Hex::decode(
4338 "0x0b2da327ba6a4cacbe75dddd50e6e8bbf81d6496e92d66af9154c61c77f7332f",
4339 )
4340 .unwrap()
4341 .try_into()
4342 .unwrap();
4343
4344 cfg.aliased_addresses.push(AliasedAddress {
4346 original: Hex::decode("0xcd8962dad278d8b50fa0f9eb0186bfa4cbdecc6d59377214c88d0286a0ac9562").unwrap().try_into().unwrap(),
4347 aliased,
4348 allowed_tx_digests: vec![
4349 Base58::decode("B2eGLFoMHgj93Ni8dAJBfqGzo8EWSTLBesZzhEpTPA4").unwrap().try_into().unwrap(),
4350 ],
4351 });
4352
4353 cfg.aliased_addresses.push(AliasedAddress {
4354 original: Hex::decode("0xe28b50cef1d633ea43d3296a3f6b67ff0312a5f1a99f0af753c85b8b5de8ff06").unwrap().try_into().unwrap(),
4355 aliased,
4356 allowed_tx_digests: vec![
4357 Base58::decode("J4QqSAgp7VrQtQpMy5wDX4QGsCSEZu3U5KuDAkbESAge").unwrap().try_into().unwrap(),
4358 ],
4359 });
4360 }
4361
4362 if chain != Chain::Mainnet {
4365 cfg.feature_flags.resolve_type_input_ids_to_defining_id = true;
4366 cfg.transfer_party_transfer_internal_cost_base = Some(52);
4367
4368 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4370 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4371 cfg.feature_flags.per_object_congestion_control_mode =
4372 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4373 ExecutionTimeEstimateParams {
4374 target_utilization: 30,
4375 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4377 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4379 stored_observations_limit: u64::MAX,
4380 stake_weighted_median_threshold: 0,
4381 default_none_duration_for_new_keys: false,
4382 observations_chunk_size: None,
4383 },
4384 );
4385
4386 cfg.feature_flags.consensus_batched_block_sync = true;
4388
4389 cfg.feature_flags.enable_nitro_attestation_upgraded_parsing = true;
4392 cfg.feature_flags.enable_nitro_attestation = true;
4393 }
4394 }
4395 84 => {
4396 if chain == Chain::Mainnet {
4397 cfg.feature_flags.resolve_type_input_ids_to_defining_id = true;
4398 cfg.transfer_party_transfer_internal_cost_base = Some(52);
4399
4400 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4402 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4403 cfg.feature_flags.per_object_congestion_control_mode =
4404 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4405 ExecutionTimeEstimateParams {
4406 target_utilization: 30,
4407 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4409 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4411 stored_observations_limit: u64::MAX,
4412 stake_weighted_median_threshold: 0,
4413 default_none_duration_for_new_keys: false,
4414 observations_chunk_size: None,
4415 },
4416 );
4417
4418 cfg.feature_flags.consensus_batched_block_sync = true;
4420
4421 cfg.feature_flags.enable_nitro_attestation_upgraded_parsing = true;
4424 cfg.feature_flags.enable_nitro_attestation = true;
4425 }
4426
4427 cfg.feature_flags.per_object_congestion_control_mode =
4429 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4430 ExecutionTimeEstimateParams {
4431 target_utilization: 30,
4432 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4434 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4436 stored_observations_limit: 20,
4437 stake_weighted_median_threshold: 0,
4438 default_none_duration_for_new_keys: false,
4439 observations_chunk_size: None,
4440 },
4441 );
4442 cfg.feature_flags.allow_unbounded_system_objects = true;
4443 }
4444 85 => {
4445 if chain != Chain::Mainnet && chain != Chain::Testnet {
4446 cfg.feature_flags.enable_party_transfer = true;
4447 }
4448
4449 cfg.feature_flags
4450 .record_consensus_determined_version_assignments_in_prologue_v2 = true;
4451 cfg.feature_flags.disallow_self_identifier = true;
4452 cfg.feature_flags.per_object_congestion_control_mode =
4453 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4454 ExecutionTimeEstimateParams {
4455 target_utilization: 50,
4456 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4458 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4460 stored_observations_limit: 20,
4461 stake_weighted_median_threshold: 0,
4462 default_none_duration_for_new_keys: false,
4463 observations_chunk_size: None,
4464 },
4465 );
4466 }
4467 86 => {
4468 cfg.feature_flags.type_tags_in_object_runtime = true;
4469 cfg.max_move_enum_variants = Some(move_core_types::VARIANT_COUNT_MAX);
4470
4471 cfg.feature_flags.per_object_congestion_control_mode =
4473 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4474 ExecutionTimeEstimateParams {
4475 target_utilization: 50,
4476 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4478 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4480 stored_observations_limit: 20,
4481 stake_weighted_median_threshold: 3334,
4482 default_none_duration_for_new_keys: false,
4483 observations_chunk_size: None,
4484 },
4485 );
4486 if chain != Chain::Mainnet {
4488 cfg.feature_flags.enable_party_transfer = true;
4489 }
4490 }
4491 87 => {
4492 if chain == Chain::Mainnet {
4493 cfg.feature_flags.record_time_estimate_processed = true;
4494 }
4495 cfg.feature_flags.better_adapter_type_resolution_errors = true;
4496 }
4497 88 => {
4498 cfg.feature_flags.record_time_estimate_processed = true;
4499 cfg.tx_context_rgp_cost_base = Some(30);
4500 cfg.feature_flags
4501 .ignore_execution_time_observations_after_certs_closed = true;
4502
4503 cfg.feature_flags.per_object_congestion_control_mode =
4506 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4507 ExecutionTimeEstimateParams {
4508 target_utilization: 50,
4509 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4511 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4513 stored_observations_limit: 20,
4514 stake_weighted_median_threshold: 3334,
4515 default_none_duration_for_new_keys: true,
4516 observations_chunk_size: None,
4517 },
4518 );
4519 }
4520 89 => {
4521 cfg.feature_flags.dependency_linkage_error = true;
4522 cfg.feature_flags.additional_multisig_checks = true;
4523 }
4524 90 => {
4525 cfg.max_gas_price_rgp_factor_for_aborted_transactions = Some(100);
4527 cfg.feature_flags.debug_fatal_on_move_invariant_violation = true;
4528 cfg.feature_flags.additional_consensus_digest_indirect_state = true;
4529 cfg.feature_flags.accept_passkey_in_multisig = true;
4530 cfg.feature_flags.passkey_auth = true;
4531 cfg.feature_flags.check_for_init_during_upgrade = true;
4532
4533 if chain != Chain::Mainnet {
4535 cfg.feature_flags.mysticeti_fastpath = true;
4536 }
4537 }
4538 91 => {
4539 cfg.feature_flags.per_command_shared_object_transfer_rules = true;
4540 }
4541 92 => {
4542 cfg.feature_flags.per_command_shared_object_transfer_rules = false;
4543 }
4544 93 => {
4545 cfg.feature_flags
4546 .consensus_checkpoint_signature_key_includes_digest = true;
4547 }
4548 94 => {
4549 cfg.feature_flags.per_object_congestion_control_mode =
4551 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4552 ExecutionTimeEstimateParams {
4553 target_utilization: 50,
4554 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4556 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4558 stored_observations_limit: 18,
4559 stake_weighted_median_threshold: 3334,
4560 default_none_duration_for_new_keys: true,
4561 observations_chunk_size: None,
4562 },
4563 );
4564
4565 cfg.feature_flags.enable_party_transfer = true;
4567 }
4568 95 => {
4569 cfg.type_name_id_base_cost = Some(52);
4570
4571 cfg.max_transactions_per_checkpoint = Some(20_000);
4573 }
4574 96 => {
4575 if chain != Chain::Mainnet && chain != Chain::Testnet {
4577 cfg.feature_flags
4578 .include_checkpoint_artifacts_digest_in_summary = true;
4579 }
4580 cfg.feature_flags.correct_gas_payment_limit_check = true;
4581 cfg.feature_flags.authority_capabilities_v2 = true;
4582 cfg.feature_flags.use_mfp_txns_in_load_initial_object_debts = true;
4583 cfg.feature_flags.cancel_for_failed_dkg_early = true;
4584 cfg.feature_flags.enable_coin_registry = true;
4585
4586 cfg.feature_flags.mysticeti_fastpath = true;
4588 }
4589 97 => {
4590 cfg.feature_flags.additional_borrow_checks = true;
4591 }
4592 98 => {
4593 cfg.event_emit_auth_stream_cost = Some(52);
4594 cfg.feature_flags.better_loader_errors = true;
4595 cfg.feature_flags.generate_df_type_layouts = true;
4596 }
4597 99 => {
4598 cfg.feature_flags.use_new_commit_handler = true;
4599 }
4600 100 => {
4601 cfg.feature_flags.private_generics_verifier_v2 = true;
4602 }
4603 101 => {
4604 cfg.feature_flags.create_root_accumulator_object = true;
4605 cfg.max_updates_per_settlement_txn = Some(100);
4606 if chain != Chain::Mainnet {
4607 cfg.feature_flags.enable_poseidon = true;
4608 }
4609 }
4610 102 => {
4611 cfg.feature_flags.per_object_congestion_control_mode =
4615 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4616 ExecutionTimeEstimateParams {
4617 target_utilization: 50,
4618 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4620 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4622 stored_observations_limit: 180,
4623 stake_weighted_median_threshold: 3334,
4624 default_none_duration_for_new_keys: true,
4625 observations_chunk_size: Some(18),
4626 },
4627 );
4628 cfg.feature_flags.deprecate_global_storage_ops = true;
4629 }
4630 103 => {}
4631 104 => {
4632 cfg.translation_per_command_base_charge = Some(1);
4633 cfg.translation_per_input_base_charge = Some(1);
4634 cfg.translation_pure_input_per_byte_charge = Some(1);
4635 cfg.translation_per_type_node_charge = Some(1);
4636 cfg.translation_per_reference_node_charge = Some(1);
4637 cfg.translation_per_linkage_entry_charge = Some(10);
4638 cfg.gas_model_version = Some(11);
4639 cfg.feature_flags.abstract_size_in_object_runtime = true;
4640 cfg.feature_flags.object_runtime_charge_cache_load_gas = true;
4641 cfg.dynamic_field_hash_type_and_key_cost_base = Some(52);
4642 cfg.dynamic_field_add_child_object_cost_base = Some(52);
4643 cfg.dynamic_field_add_child_object_value_cost_per_byte = Some(1);
4644 cfg.dynamic_field_borrow_child_object_cost_base = Some(52);
4645 cfg.dynamic_field_borrow_child_object_child_ref_cost_per_byte = Some(1);
4646 cfg.dynamic_field_remove_child_object_cost_base = Some(52);
4647 cfg.dynamic_field_remove_child_object_child_cost_per_byte = Some(1);
4648 cfg.dynamic_field_has_child_object_cost_base = Some(52);
4649 cfg.dynamic_field_has_child_object_with_ty_cost_base = Some(52);
4650 cfg.feature_flags.enable_ptb_execution_v2 = true;
4651
4652 cfg.poseidon_bn254_cost_base = Some(260);
4653
4654 cfg.feature_flags.consensus_skip_gced_accept_votes = true;
4655
4656 if chain != Chain::Mainnet {
4657 cfg.feature_flags
4658 .enable_nitro_attestation_all_nonzero_pcrs_parsing = true;
4659 }
4660
4661 cfg.feature_flags
4662 .include_cancelled_randomness_txns_in_prologue = true;
4663 }
4664 105 => {
4665 cfg.feature_flags.enable_multi_epoch_transaction_expiration = true;
4666 cfg.feature_flags.disable_preconsensus_locking = true;
4667
4668 if chain != Chain::Mainnet {
4669 cfg.feature_flags
4670 .enable_nitro_attestation_always_include_required_pcrs_parsing = true;
4671 }
4672 }
4673 106 => {
4674 cfg.accumulator_object_storage_cost = Some(7600);
4676
4677 if chain != Chain::Mainnet && chain != Chain::Testnet {
4678 cfg.feature_flags.enable_accumulators = true;
4679 cfg.feature_flags.enable_address_balance_gas_payments = true;
4680 cfg.feature_flags.enable_authenticated_event_streams = true;
4681 cfg.feature_flags.enable_object_funds_withdraw = true;
4682 }
4683 }
4684 107 => {
4685 cfg.feature_flags
4686 .consensus_skip_gced_blocks_in_direct_finalization = true;
4687
4688 if in_integration_test() {
4690 cfg.consensus_gc_depth = Some(6);
4691 cfg.consensus_max_num_transactions_in_block = Some(8);
4692 }
4693 }
4694 108 => {
4695 cfg.feature_flags.gas_rounding_halve_digits = true;
4696 cfg.feature_flags.flexible_tx_context_positions = true;
4697 cfg.feature_flags.disable_entry_point_signature_check = true;
4698
4699 if chain != Chain::Mainnet {
4700 cfg.feature_flags.address_aliases = true;
4701
4702 cfg.feature_flags.enable_accumulators = true;
4703 cfg.feature_flags.enable_address_balance_gas_payments = true;
4704 }
4705
4706 cfg.feature_flags.enable_poseidon = true;
4707 }
4708 109 => {
4709 cfg.binary_variant_handles = Some(1024);
4710 cfg.binary_variant_instantiation_handles = Some(1024);
4711 cfg.feature_flags.restrict_hot_or_not_entry_functions = true;
4712 }
4713 110 => {
4714 cfg.feature_flags
4715 .enable_nitro_attestation_all_nonzero_pcrs_parsing = true;
4716 cfg.feature_flags
4717 .enable_nitro_attestation_always_include_required_pcrs_parsing = true;
4718 if chain != Chain::Mainnet && chain != Chain::Testnet {
4719 cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4720 }
4721 cfg.feature_flags.validate_zklogin_public_identifier = true;
4722 cfg.feature_flags.fix_checkpoint_signature_mapping = true;
4723 cfg.feature_flags
4724 .consensus_always_accept_system_transactions = true;
4725 if chain != Chain::Mainnet {
4726 cfg.feature_flags.enable_object_funds_withdraw = true;
4727 }
4728 }
4729 111 => {
4730 cfg.feature_flags.validator_metadata_verify_v2 = true;
4731 }
4732 112 => {
4733 cfg.group_ops_ristretto_decode_scalar_cost = Some(7);
4734 cfg.group_ops_ristretto_decode_point_cost = Some(200);
4735 cfg.group_ops_ristretto_scalar_add_cost = Some(10);
4736 cfg.group_ops_ristretto_point_add_cost = Some(500);
4737 cfg.group_ops_ristretto_scalar_sub_cost = Some(10);
4738 cfg.group_ops_ristretto_point_sub_cost = Some(500);
4739 cfg.group_ops_ristretto_scalar_mul_cost = Some(11);
4740 cfg.group_ops_ristretto_point_mul_cost = Some(1200);
4741 cfg.group_ops_ristretto_scalar_div_cost = Some(151);
4742 cfg.group_ops_ristretto_point_div_cost = Some(2500);
4743
4744 if chain != Chain::Mainnet && chain != Chain::Testnet {
4745 cfg.feature_flags.enable_ristretto255_group_ops = true;
4746 }
4747 }
4748 113 => {
4749 cfg.feature_flags.address_balance_gas_check_rgp_at_signing = true;
4750 if chain != Chain::Mainnet && chain != Chain::Testnet {
4751 cfg.feature_flags.defer_unpaid_amplification = true;
4752 }
4753 }
4754 114 => {
4755 cfg.feature_flags.randomize_checkpoint_tx_limit_in_tests = true;
4756 cfg.feature_flags.address_balance_gas_reject_gas_coin_arg = true;
4757 if chain != Chain::Mainnet {
4758 cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4759 cfg.feature_flags.enable_authenticated_event_streams = true;
4760 cfg.feature_flags
4761 .include_checkpoint_artifacts_digest_in_summary = true;
4762 }
4763 }
4764 115 => {
4765 cfg.feature_flags.normalize_depth_formula = true;
4766 }
4767 116 => {
4768 cfg.feature_flags.gasless_transaction_drop_safety = true;
4769 cfg.feature_flags.address_aliases = true;
4770 cfg.feature_flags.relax_valid_during_for_owned_inputs = true;
4771 cfg.feature_flags.defer_unpaid_amplification = false;
4773 cfg.feature_flags.enable_display_registry = true;
4774 }
4775 117 => {}
4776 118 => {
4777 cfg.feature_flags.use_coin_party_owner = true;
4778 }
4779 119 => {
4780 cfg.execution_version = Some(4);
4782 cfg.feature_flags.address_balance_gas_reject_gas_coin_arg = false;
4783 cfg.feature_flags.merge_randomness_into_checkpoint = true;
4784 if chain != Chain::Mainnet {
4785 cfg.feature_flags.enable_gasless = true;
4786 cfg.gasless_max_computation_units = Some(50_000);
4787 cfg.gasless_allowed_token_types = Some(vec![]);
4788 cfg.feature_flags.enable_coin_reservation_obj_refs = true;
4789 cfg.feature_flags
4790 .convert_withdrawal_compatibility_ptb_arguments = true;
4791 }
4792 cfg.gasless_max_unused_inputs = Some(1);
4793 cfg.gasless_max_pure_input_bytes = Some(32);
4794 if chain == Chain::Testnet {
4795 cfg.gasless_allowed_token_types = Some(vec![(TESTNET_USDC.to_string(), 0)]);
4796 }
4797 cfg.transfer_receive_object_cost_per_byte = Some(1);
4798 cfg.transfer_receive_object_type_cost_per_byte = Some(2);
4799 }
4800 120 => {
4801 cfg.feature_flags.disallow_jump_orphans = true;
4802 }
4803 121 => {
4804 if chain != Chain::Mainnet {
4806 cfg.feature_flags.defer_unpaid_amplification = true;
4807 cfg.gasless_max_tps = Some(50);
4808 }
4809 cfg.feature_flags
4810 .early_return_receive_object_mismatched_type = true;
4811 }
4812 122 => {
4813 cfg.feature_flags.defer_unpaid_amplification = true;
4815 cfg.verify_bulletproofs_ristretto255_base_cost = Some(30000);
4817 cfg.verify_bulletproofs_ristretto255_cost_per_bit_and_commitment = Some(6500);
4818 if chain != Chain::Mainnet && chain != Chain::Testnet {
4819 cfg.feature_flags.enable_verify_bulletproofs_ristretto255 = true;
4820 }
4821 cfg.feature_flags.gasless_verify_remaining_balance = true;
4822 cfg.include_special_package_amendments = match chain {
4823 Chain::Mainnet => Some(MAINNET_LINKAGE_AMENDMENTS.clone()),
4824 Chain::Testnet => Some(TESTNET_LINKAGE_AMENDMENTS.clone()),
4825 Chain::Unknown => None,
4826 };
4827 cfg.gasless_max_tx_size_bytes = Some(16 * 1024);
4828 cfg.gasless_max_tps = Some(300);
4829 cfg.gasless_max_computation_units = Some(5_000);
4830 }
4831 123 => {
4832 cfg.gas_model_version = Some(13);
4833 }
4834 124 => {
4835 if chain != Chain::Mainnet && chain != Chain::Testnet {
4836 cfg.feature_flags.timestamp_based_epoch_close = true;
4837 }
4838 cfg.gas_model_version = Some(14);
4839 cfg.feature_flags.limit_groth16_pvk_inputs = true;
4840
4841 cfg.feature_flags.enable_accumulators = true;
4847 cfg.feature_flags.enable_address_balance_gas_payments = true;
4848 cfg.feature_flags.enable_authenticated_event_streams = true;
4849 cfg.feature_flags.enable_coin_reservation_obj_refs = true;
4850 cfg.feature_flags.enable_object_funds_withdraw = true;
4851 cfg.feature_flags
4852 .convert_withdrawal_compatibility_ptb_arguments = true;
4853 cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4854 cfg.feature_flags
4855 .include_checkpoint_artifacts_digest_in_summary = true;
4856 cfg.feature_flags.enable_gasless = true;
4857
4858 if chain == Chain::Mainnet {
4863 cfg.gasless_allowed_token_types = Some(vec![
4864 (MAINNET_USDC.to_string(), 10_000),
4865 (MAINNET_USDSUI.to_string(), 10_000),
4866 (MAINNET_SUI_USDE.to_string(), 10_000),
4867 (MAINNET_USDY.to_string(), 10_000),
4868 (MAINNET_FDUSD.to_string(), 10_000),
4869 (MAINNET_AUSD.to_string(), 10_000),
4870 (MAINNET_USDB.to_string(), 10_000),
4871 ]);
4872 }
4873 }
4874 125 => {
4875 cfg.feature_flags.granular_post_execution_checks = true;
4876 if chain != Chain::Mainnet {
4877 cfg.feature_flags.timestamp_based_epoch_close = true;
4878 }
4879 }
4880 126 => {
4881 cfg.feature_flags.early_exit_on_iffw = true;
4882 }
4883 127 => {
4884 cfg.feature_flags.always_advance_dkg_to_resolution = true;
4885
4886 cfg.verify_bulletproofs_ristretto255_base_cost = Some(23866);
4887 cfg.verify_bulletproofs_ristretto255_cost_per_bit_and_commitment = Some(1324);
4888 cfg.group_ops_ristretto_decode_scalar_cost = Some(5);
4889 cfg.group_ops_ristretto_decode_point_cost = Some(216);
4890 cfg.group_ops_ristretto_scalar_add_cost = Some(2);
4891 cfg.group_ops_ristretto_point_add_cost = Some(8);
4892 cfg.group_ops_ristretto_scalar_sub_cost = Some(2);
4893 cfg.group_ops_ristretto_point_sub_cost = Some(8);
4894 cfg.group_ops_ristretto_scalar_mul_cost = Some(5);
4895 cfg.group_ops_ristretto_point_mul_cost = Some(1763);
4896 cfg.group_ops_ristretto_scalar_div_cost = Some(557);
4897 cfg.group_ops_ristretto_point_div_cost = Some(2244);
4898
4899 if chain != Chain::Mainnet {
4900 cfg.feature_flags.enable_ristretto255_group_ops = true;
4901 cfg.feature_flags.enable_verify_bulletproofs_ristretto255 = true;
4902 }
4903
4904 cfg.feature_flags.timestamp_based_epoch_close = true;
4905 }
4906 128 => {
4907 cfg.max_generic_instantiation_type_nodes_per_function = Some(10_000);
4908 cfg.max_generic_instantiation_type_nodes_per_module = Some(500_000);
4909 cfg.binary_enum_defs = Some(200);
4910 cfg.binary_enum_def_instantiations = Some(100);
4911 }
4912 129 => {
4913 cfg.feature_flags.enable_unified_linkage = true;
4914 }
4915 130 => {
4916 cfg.feature_flags.record_net_unsettled_object_withdraws = true;
4917 cfg.feature_flags.enable_init_on_upgrade = true;
4918 cfg.epoch_close_deadline_ms = Some(120_000);
4919 cfg.scratch_add_cost_base = Some(13);
4920 cfg.scratch_read_cost_base = Some(13);
4921 cfg.scratch_read_value_cost = Some(1);
4922 cfg.scratch_remove_cost_base = Some(13);
4923 cfg.scratch_exists_cost_base = Some(13);
4924 cfg.scratch_exists_with_type_cost_base = Some(13);
4925 cfg.scratch_exists_with_type_type_cost = Some(1);
4926 let max_commands = cfg.max_programmable_tx_commands() as u64;
4927 cfg.max_scratch_pad_size = Some(16 * max_commands);
4928 if chain != Chain::Mainnet && chain != Chain::Testnet {
4930 cfg.feature_flags.zklogin_circuit_mode = 1;
4931 }
4932 }
4933 131 => {
4934 cfg.feature_flags.share_transaction_deny_config_in_consensus = true;
4935 cfg.feature_flags.framework_tx_context_mut_restrictions = true;
4936 }
4937 132 => {
4938 if chain != Chain::Mainnet && chain != Chain::Testnet {
4939 cfg.feature_flags.defer_owned_object_double_spend = true;
4940 cfg.feature_flags.create_forwarding_address_registry = true;
4941 }
4942 cfg.object_record_new_uid_from_hash_cost_base = Some(1);
4943 cfg.feature_flags
4944 .enable_order_independent_upgrade_init_linkage = true;
4945 }
4946 133 => {
4947 cfg.feature_flags
4948 .include_function_signatures_in_instantiation_limits = true;
4949 cfg.max_accumulator_type_nodes = Some(16);
4950 }
4951 134 => {
4952 if chain != Chain::Mainnet {
4959 cfg.package_original_package_id_impl_cost_base = Some(52);
4960 let package_read_cost_per_byte = cfg.obj_access_cost_read_per_byte();
4961 cfg.package_original_package_id_impl_cost_per_byte =
4962 Some(package_read_cost_per_byte);
4963
4964 cfg.consensus_max_transactions_in_block_bytes = Some(288 * 1024);
4965 cfg.consensus_max_num_transactions_in_block = Some(128);
4966 }
4967
4968 if chain == Chain::Mainnet {
4969 cfg.feature_flags.defer_unpaid_amplification = false;
4970 }
4971 }
4972 135 => {
4973 cfg.package_original_package_id_impl_cost_base = Some(52);
4976 let package_read_cost_per_byte = cfg.obj_access_cost_read_per_byte();
4977 cfg.package_original_package_id_impl_cost_per_byte =
4978 Some(package_read_cost_per_byte);
4979
4980 cfg.consensus_max_transactions_in_block_bytes = Some(288 * 1024);
4981 cfg.consensus_max_num_transactions_in_block = Some(128);
4982
4983 cfg.feature_flags.defer_unpaid_amplification = false;
4984 }
4985 136 => {
4986 cfg.feature_flags.ptb_tx_context_restrictions = true;
4987
4988 cfg.translation_per_live_reference_charge = Some(1);
4989 cfg.max_ptb_live_references = Some(64);
4990 cfg.max_ptb_returned_references = Some(16);
4991 cfg.max_ptb_total_returned_references = Some(256);
4992
4993 if chain != Chain::Mainnet && chain != Chain::Testnet {
4994 cfg.feature_flags.allowed_proposers = true;
4995 }
4996 cfg.feature_flags.harden_linkage_consistency = true;
4997
4998 cfg.package_arena_size_in_bytes = Some(10_000_000);
4999 }
5000 137 => {
5001 cfg.verify_bulletproofs_ristretto255_cost_per_bit_and_commitment = Some(621);
5002 cfg.max_bulletproofs_total_bits = Some(1024);
5003
5004 if chain != Chain::Mainnet {
5005 cfg.feature_flags.enable_allowances = true;
5006 }
5007 cfg.feature_flags.fix_ptb_generated_reads = true;
5008 cfg.feature_flags.charge_ld_const_abstract_size = true;
5009 if chain != Chain::Mainnet && chain != Chain::Testnet {
5010 cfg.feature_flags.check_object_funds_withdraw_in_execution = true;
5011 }
5012 cfg.reserve_object_funds_for_withdrawal_cost_base = Some(52);
5013 cfg.reserve_object_funds_for_withdrawal_cold_read_cost = Some(184);
5016
5017 cfg.feature_flags.allowed_proposers = true;
5018
5019 cfg.feature_flags.validate_ptb_argument_indices = true;
5020 cfg.feature_flags.memory_safety_invariant_check_v2 = true;
5021 }
5022 138 => {
5023 cfg.gas_model_version = Some(15);
5024 cfg.feature_flags.enable_allowances = true;
5025 if chain != Chain::Mainnet {
5026 cfg.feature_flags.check_object_funds_withdraw_in_execution = true;
5027 cfg.feature_flags.disable_effects_tx_dependencies = true;
5028 }
5029 cfg.feature_flags.merge_colliding_deferrals = true;
5030 if chain == Chain::Mainnet {
5032 cfg.storage_rebate_rate = Some(9999);
5033 }
5034 }
5035 139 => {
5036 if chain != Chain::Mainnet && chain != Chain::Testnet {
5037 cfg.feature_flags.enable_forwarding_addresses = true;
5038 cfg.feature_flags.mldsa65_auth = true;
5039 }
5040 cfg.storage_rebate_rate = Some(9999);
5041 if chain != Chain::Mainnet {
5042 cfg.feature_flags.allow_dkg_completion_after_timeout = true;
5043 }
5044 cfg.obj_access_cost_read_per_package_kb = Some(154);
5046 }
5047 140 => {
5048 cfg.staggered_submission_signal_window_commits = Some(300);
5051 cfg.staggered_submission_signal_min_excess_copies_per_commit = Some(2);
5052 cfg.staggered_submission_signal_exit_dwell_commits = Some(6000);
5053 cfg.staggered_submission_signal_band1_enter_ratio_bps = Some(1000);
5054 cfg.staggered_submission_signal_band1_exit_ratio_bps = Some(500);
5055 cfg.staggered_submission_signal_band2_enter_ratio_bps = Some(5000);
5056 cfg.staggered_submission_signal_band2_exit_ratio_bps = Some(2500);
5057
5058 cfg.vector_reverse_base_cost = Some(52);
5059 cfg.vector_reverse_per_elem_cost = Some(8);
5060 cfg.vector_keep_range_base_cost = Some(52);
5061 cfg.vector_keep_range_per_dropped_elem_cost = Some(1);
5062 cfg.vector_keep_range_per_moved_elem_cost = Some(8);
5063 cfg.vector_copy_range_base_cost = Some(52);
5064 cfg.vector_replace_range_base_cost = Some(52);
5065 cfg.vector_replace_range_per_elem_cost = Some(8);
5066
5067 if chain != Chain::Mainnet && chain != Chain::Testnet {
5068 cfg.feature_flags.shuffle_consensus_commit_blocks = true;
5069 }
5070
5071 cfg.feature_flags.allow_references_in_ptbs = true;
5072 cfg.feature_flags.disable_id_leak_verifier = true;
5073 cfg.feature_flags.check_object_funds_withdraw_in_execution = true;
5074 cfg.feature_flags.disable_effects_tx_dependencies = true;
5075 }
5076 141 => {
5077 cfg.feature_flags.complete_effects_size_estimate = true;
5078 cfg.max_num_accumulator_events = Some(1024);
5079 }
5080 142 => {
5081 cfg.clock_borrow_cost_base = Some(52);
5082 cfg.feature_flags.check_groth16_pvk_length = true;
5083 cfg.object_is_shared_input_cost_base = Some(52);
5084 cfg.feature_flags.secp256r1_ecrecover_checks_x_below_p = true;
5085 cfg.binary_format_limits_profile = Some(BinaryFormatLimitsProfile::V1);
5086 cfg.feature_flags.defer_owned_object_double_spend = true;
5087 }
5088 143 => {
5089 cfg.execution_version = Some(5);
5090 cfg.package_arena_size_in_bytes = Some(20_000_000);
5091 cfg.feature_flags.simplify_nitro_header_validation = true;
5092 cfg.feature_flags.enable_forwarding_addresses = false;
5093 cfg.feature_flags.package_publish_charge = true;
5094 cfg.package_publish_charge_fixed = Some(1_000_000_000);
5095 cfg.package_publish_charge_per_module = Some(10_000_000);
5096 cfg.package_publish_charge_per_dependency = Some(10_000_000);
5097 if chain != Chain::Mainnet {
5098 cfg.feature_flags.mldsa65_auth = true;
5099 }
5100 cfg.layout_node_cost = Some(16);
5101 cfg.layout_node_cost_large_layout_threshold = Some(64);
5102 cfg.bcs_per_input_abstract_unit_cost = Some(20);
5103 cfg.vector_copy_range_per_abstract_memory_unit_cost = Some(1);
5104 }
5105 144 => {
5106 if chain != Chain::Mainnet && chain != Chain::Testnet {
5107 cfg.feature_flags.enable_timestamp_transaction_expiration = true;
5108 }
5109 cfg.object_runtime_max_loaded_child_value_size = Some(5_000_000);
5110
5111 cfg.feature_flags.staggered_submission_signal = true;
5112 cfg.staggered_submission_signal_window_commits = Some(600);
5124 cfg.staggered_submission_signal_min_consensus_user_transactions_per_commit =
5125 Some(1000);
5126 if chain == Chain::Testnet {
5127 cfg.staggered_submission_signal_min_consensus_user_transactions_per_commit = Some(5);
5133 }
5134 }
5135 145 => {
5136 cfg.feature_flags.secp256r1_strict_public_keys = true;
5137 }
5138 _ => panic!("unsupported version {:?}", version),
5149 }
5150 }
5151
5152 cfg
5153 }
5154
5155 pub fn apply_seeded_test_overrides(&mut self, seed: &[u8; 32]) {
5156 if !self.feature_flags.randomize_checkpoint_tx_limit_in_tests
5157 || !self.feature_flags.split_checkpoints_in_consensus_handler
5158 {
5159 return;
5160 }
5161
5162 if !mysten_common::in_test_configuration() {
5163 return;
5164 }
5165
5166 use rand::{Rng, SeedableRng, rngs::StdRng};
5167 let mut rng = StdRng::from_seed(*seed);
5168 let max_txns = rng.gen_range(10..=100u64);
5169 info!("seeded test override: max_transactions_per_checkpoint = {max_txns}");
5170 self.max_transactions_per_checkpoint = Some(max_txns);
5171 }
5172
5173 pub fn verifier_config(&self, signing_limits: Option<(usize, usize, usize)>) -> VerifierConfig {
5179 let (
5180 max_back_edges_per_function,
5181 max_back_edges_per_module,
5182 sanity_check_with_regex_reference_safety,
5183 ) = if let Some((
5184 max_back_edges_per_function,
5185 max_back_edges_per_module,
5186 sanity_check_with_regex_reference_safety,
5187 )) = signing_limits
5188 {
5189 (
5190 Some(max_back_edges_per_function),
5191 Some(max_back_edges_per_module),
5192 Some(sanity_check_with_regex_reference_safety),
5193 )
5194 } else {
5195 (None, None, None)
5196 };
5197
5198 let additional_borrow_checks = if signing_limits.is_some() {
5199 true
5201 } else {
5202 self.additional_borrow_checks()
5203 };
5204 let deprecate_global_storage_ops = if signing_limits.is_some() {
5205 true
5207 } else {
5208 self.deprecate_global_storage_ops()
5209 };
5210
5211 VerifierConfig {
5212 max_loop_depth: Some(self.max_loop_depth() as usize),
5213 max_generic_instantiation_length: Some(self.max_generic_instantiation_length() as usize),
5214 max_function_parameters: Some(self.max_function_parameters() as usize),
5215 max_basic_blocks: Some(self.max_basic_blocks() as usize),
5216 max_value_stack_size: self.max_value_stack_size() as usize,
5217 max_type_nodes: Some(self.max_type_nodes() as usize),
5218 max_generic_instantiation_type_nodes_per_function: self
5219 .max_generic_instantiation_type_nodes_per_function_as_option()
5220 .map(|v| v as usize),
5221 max_generic_instantiation_type_nodes_per_module: self
5222 .max_generic_instantiation_type_nodes_per_module_as_option()
5223 .map(|v| v as usize),
5224 include_function_signatures_in_instantiation_limits: self
5225 .include_function_signatures_in_instantiation_limits(),
5226 max_push_size: Some(self.max_push_size() as usize),
5227 max_dependency_depth: Some(self.max_dependency_depth() as usize),
5228 max_fields_in_struct: Some(self.max_fields_in_struct() as usize),
5229 max_function_definitions: Some(self.max_function_definitions() as usize),
5230 max_data_definitions: Some(self.max_struct_definitions() as usize),
5231 max_constant_vector_len: Some(self.max_move_vector_len()),
5232 max_back_edges_per_function,
5233 max_back_edges_per_module,
5234 max_basic_blocks_in_script: None,
5235 max_identifier_len: self.max_move_identifier_len_as_option(), disallow_self_identifier: self.feature_flags.disallow_self_identifier,
5237 allow_receiving_object_id: self.allow_receiving_object_id(),
5238 reject_mutable_random_on_entry_functions: self
5239 .reject_mutable_random_on_entry_functions(),
5240 bytecode_version: self.move_binary_format_version(),
5241 max_variants_in_enum: self.max_move_enum_variants_as_option(),
5242 additional_borrow_checks,
5243 better_loader_errors: self.better_loader_errors(),
5244 private_generics_verifier_v2: self.private_generics_verifier_v2(),
5245 sanity_check_with_regex_reference_safety: sanity_check_with_regex_reference_safety
5246 .map(|limit| limit as u128),
5247 deprecate_global_storage_ops,
5248 disable_entry_point_signature_check: self.disable_entry_point_signature_check(),
5249 disable_id_leak_verifier: self.disable_id_leak_verifier(),
5250 switch_to_regex_reference_safety: false,
5251 framework_tx_context_mut_restrictions: self.framework_tx_context_mut_restrictions(),
5252 disallow_jump_orphans: self.disallow_jump_orphans(),
5253 }
5254 }
5255
5256 pub fn binary_config(
5257 &self,
5258 override_deprecate_global_storage_ops_during_deserialization: Option<bool>,
5259 ) -> BinaryConfig {
5260 let deprecate_global_storage_ops =
5261 override_deprecate_global_storage_ops_during_deserialization
5262 .unwrap_or_else(|| self.deprecate_global_storage_ops());
5263 BinaryConfig::new(
5264 self.move_binary_format_version(),
5265 self.min_move_binary_format_version_as_option()
5266 .unwrap_or(VERSION_1),
5267 self.no_extraneous_module_bytes(),
5268 deprecate_global_storage_ops,
5269 TableConfig {
5270 module_handles: self.binary_module_handles_as_option().unwrap_or(u16::MAX),
5271 datatype_handles: self.binary_struct_handles_as_option().unwrap_or(u16::MAX),
5272 function_handles: self.binary_function_handles_as_option().unwrap_or(u16::MAX),
5273 function_instantiations: self
5274 .binary_function_instantiations_as_option()
5275 .unwrap_or(u16::MAX),
5276 signatures: self.binary_signatures_as_option().unwrap_or(u16::MAX),
5277 constant_pool: self.binary_constant_pool_as_option().unwrap_or(u16::MAX),
5278 identifiers: self.binary_identifiers_as_option().unwrap_or(u16::MAX),
5279 address_identifiers: self
5280 .binary_address_identifiers_as_option()
5281 .unwrap_or(u16::MAX),
5282 struct_defs: self.binary_struct_defs_as_option().unwrap_or(u16::MAX),
5283 struct_def_instantiations: self
5284 .binary_struct_def_instantiations_as_option()
5285 .unwrap_or(u16::MAX),
5286 function_defs: self.binary_function_defs_as_option().unwrap_or(u16::MAX),
5287 field_handles: self.binary_field_handles_as_option().unwrap_or(u16::MAX),
5288 field_instantiations: self
5289 .binary_field_instantiations_as_option()
5290 .unwrap_or(u16::MAX),
5291 friend_decls: self.binary_friend_decls_as_option().unwrap_or(u16::MAX),
5292 enum_defs: self.binary_enum_defs_as_option().unwrap_or(u16::MAX),
5293 enum_def_instantiations: self
5294 .binary_enum_def_instantiations_as_option()
5295 .unwrap_or(u16::MAX),
5296 variant_handles: self.binary_variant_handles_as_option().unwrap_or(u16::MAX),
5297 variant_instantiation_handles: self
5298 .binary_variant_instantiation_handles_as_option()
5299 .unwrap_or(u16::MAX),
5300 },
5301 self.binary_format_limits(),
5302 )
5303 }
5304
5305 pub fn binary_format_limits(
5306 &self,
5307 ) -> &'static move_binary_format::binary_config::BinaryFormatLimits {
5308 self.binary_format_limits_profile
5309 .unwrap_or(BinaryFormatLimitsProfile::LEGACY)
5310 .limits()
5311 }
5312
5313 pub fn apply_overrides_for_testing(
5317 override_fn: impl Fn(ProtocolVersion, Self) -> Self + Send + Sync + 'static,
5318 ) -> OverrideGuard {
5319 let mut cur = CONFIG_OVERRIDE.lock().unwrap();
5320 assert!(cur.is_none(), "config override already present");
5321 *cur = Some(Box::new(override_fn));
5322 OverrideGuard
5323 }
5324
5325 #[cfg(feature = "testing")]
5329 pub fn apply_base_overrides_for_testing(
5330 override_fn: impl Fn(ProtocolVersion, Self) -> Self + Send + Sync + 'static,
5331 ) -> BaseOverrideGuard {
5332 info!("installing base ProtocolConfig override for testing");
5333 let override_fn: Arc<OverrideFn> = Arc::new(override_fn);
5334 BASE_CONFIG_OVERRIDES
5335 .lock()
5336 .unwrap()
5337 .push(override_fn.clone());
5338 BaseOverrideGuard { override_fn }
5339 }
5340
5341 fn apply_config_override(version: ProtocolVersion, mut ret: Self) -> Self {
5342 #[cfg(feature = "testing")]
5344 {
5345 let fns = BASE_CONFIG_OVERRIDES.lock().unwrap().clone();
5346 for override_fn in fns {
5347 ret = override_fn(version, ret);
5348 }
5349 }
5350 if let Some(override_fn) = CONFIG_OVERRIDE.lock().unwrap().as_ref() {
5351 warn!(
5352 "overriding ProtocolConfig settings with custom settings (you should not see this log outside of tests)"
5353 );
5354 ret = override_fn(version, ret);
5355 }
5356 ret
5357 }
5358}
5359
5360impl ProtocolConfig {
5364 pub fn set_execution_version_for_testing(&mut self, val: u64) {
5368 let current = self.execution_version.unwrap_or(0);
5369 assert!(
5370 val >= current,
5371 "cannot downgrade execution_version from {current} to {val}: running an old \
5372 executor against a newer protocol config/framework is unsupported. To test \
5373 frozen executor behavior, start from the last protocol version of that executor \
5374 instead, so genesis loads the matching framework snapshot (see \
5375 test_address_balance_gas_v3_accumulator_sign)."
5376 );
5377 self.execution_version = Some(val);
5378 }
5379
5380 pub fn set_zklogin_circuit_mode_for_testing(&mut self, val: u64) {
5383 self.feature_flags.zklogin_circuit_mode = val
5384 }
5385
5386 pub fn set_per_object_congestion_control_mode_for_testing(
5387 &mut self,
5388 val: PerObjectCongestionControlMode,
5389 ) {
5390 self.feature_flags.per_object_congestion_control_mode = val;
5391 }
5392
5393 pub fn set_consensus_choice_for_testing(&mut self, val: ConsensusChoice) {
5394 self.feature_flags.consensus_choice = val;
5395 }
5396
5397 pub fn set_consensus_network_for_testing(&mut self, val: ConsensusNetwork) {
5398 self.feature_flags.consensus_network = val;
5399 }
5400
5401 pub fn set_zklogin_max_epoch_upper_bound_delta_for_testing(&mut self, val: Option<u64>) {
5402 self.feature_flags.zklogin_max_epoch_upper_bound_delta = val
5403 }
5404
5405 pub fn set_mysticeti_num_leaders_per_round_for_testing(&mut self, val: Option<usize>) {
5406 self.feature_flags.mysticeti_num_leaders_per_round = val;
5407 }
5408
5409 pub fn disable_accumulators_for_testing(&mut self) {
5410 self.feature_flags.enable_accumulators = false;
5411 self.feature_flags.enable_address_balance_gas_payments = false;
5412 }
5413
5414 pub fn enable_coin_reservation_for_testing(&mut self) {
5415 self.feature_flags.enable_coin_reservation_obj_refs = true;
5416 self.feature_flags
5417 .convert_withdrawal_compatibility_ptb_arguments = true;
5418 self.execution_version = Some(self.execution_version.map_or(4, |v| v.max(4)));
5421 }
5422
5423 pub fn disable_coin_reservation_for_testing(&mut self) {
5424 self.feature_flags.enable_coin_reservation_obj_refs = false;
5425 self.feature_flags
5426 .convert_withdrawal_compatibility_ptb_arguments = false;
5427 }
5428
5429 pub fn enable_address_balance_gas_payments_for_testing(&mut self) {
5430 self.feature_flags.enable_accumulators = true;
5431 self.feature_flags.allow_private_accumulator_entrypoints = true;
5432 self.feature_flags.enable_address_balance_gas_payments = true;
5433 self.feature_flags.address_balance_gas_check_rgp_at_signing = true;
5434 self.feature_flags.address_balance_gas_reject_gas_coin_arg = false;
5435 self.execution_version = Some(self.execution_version.map_or(4, |v| v.max(4)))
5436 }
5437
5438 pub fn enable_gasless_for_testing(&mut self) {
5439 self.enable_address_balance_gas_payments_for_testing();
5440 self.feature_flags.enable_gasless = true;
5441 self.feature_flags.gasless_verify_remaining_balance = true;
5442 self.gasless_max_computation_units = Some(5_000);
5443 self.gasless_allowed_token_types = Some(vec![]);
5444 self.gasless_max_tps = Some(1000);
5445 self.gasless_max_tx_size_bytes = Some(16 * 1024);
5446 }
5447
5448 pub fn disable_gasless_for_testing(&mut self) {
5449 self.feature_flags.enable_gasless = false;
5450 self.gasless_max_computation_units = None;
5451 self.gasless_allowed_token_types = None;
5452 }
5453
5454 pub fn enable_authenticated_event_streams_for_testing(&mut self) {
5455 self.feature_flags.enable_accumulators = true;
5456 self.feature_flags.enable_authenticated_event_streams = true;
5457 self.feature_flags
5458 .include_checkpoint_artifacts_digest_in_summary = true;
5459 self.feature_flags.split_checkpoints_in_consensus_handler = true;
5460 }
5461}
5462
5463type OverrideFn = dyn Fn(ProtocolVersion, ProtocolConfig) -> ProtocolConfig + Send + Sync;
5464
5465static CONFIG_OVERRIDE: Mutex<Option<Box<OverrideFn>>> = Mutex::new(None);
5466
5467#[must_use]
5468pub struct OverrideGuard;
5469
5470impl Drop for OverrideGuard {
5471 fn drop(&mut self) {
5472 info!("restoring override fn");
5473 *CONFIG_OVERRIDE.lock().unwrap() = None;
5474 }
5475}
5476
5477#[cfg(feature = "testing")]
5478static BASE_CONFIG_OVERRIDES: Mutex<Vec<Arc<OverrideFn>>> = Mutex::new(Vec::new());
5479
5480#[cfg(feature = "testing")]
5481#[must_use]
5482pub struct BaseOverrideGuard {
5483 override_fn: Arc<OverrideFn>,
5484}
5485
5486#[cfg(feature = "testing")]
5487impl Drop for BaseOverrideGuard {
5488 fn drop(&mut self) {
5489 BASE_CONFIG_OVERRIDES
5490 .lock()
5491 .unwrap()
5492 .retain(|f| !Arc::ptr_eq(f, &self.override_fn));
5493 }
5494}
5495
5496#[derive(PartialEq, Eq)]
5499pub enum LimitThresholdCrossed {
5500 None,
5501 Soft(u128, u128),
5502 Hard(u128, u128),
5503}
5504
5505pub fn check_limit_in_range<T: Into<V>, U: Into<V>, V: PartialOrd + Into<u128>>(
5508 x: T,
5509 soft_limit: U,
5510 hard_limit: V,
5511) -> LimitThresholdCrossed {
5512 let x: V = x.into();
5513 let soft_limit: V = soft_limit.into();
5514
5515 debug_assert!(soft_limit <= hard_limit);
5516
5517 if x >= hard_limit {
5520 LimitThresholdCrossed::Hard(x.into(), hard_limit.into())
5521 } else if x < soft_limit {
5522 LimitThresholdCrossed::None
5523 } else {
5524 LimitThresholdCrossed::Soft(x.into(), soft_limit.into())
5525 }
5526}
5527
5528#[macro_export]
5529macro_rules! assert_set {
5530 ($protocol_config:expr, $($flag:ident),+ $(,)?) => {{
5531 let protocol_config = $protocol_config;
5532 $(
5533 assert!(
5534 protocol_config.$flag(),
5535 "protocol config flag `{}` must be set",
5536 stringify!($flag),
5537 );
5538 )+
5539 }};
5540}
5541
5542#[macro_export]
5543macro_rules! check_limit {
5544 ($x:expr, $hard:expr) => {
5545 check_limit!($x, $hard, $hard)
5546 };
5547 ($x:expr, $soft:expr, $hard:expr) => {
5548 check_limit_in_range($x as u64, $soft, $hard)
5549 };
5550}
5551
5552#[macro_export]
5556macro_rules! check_limit_by_meter {
5557 ($is_metered:expr, $x:expr, $metered_limit:expr, $unmetered_hard_limit:expr, $metric:expr) => {{
5558 let (h, metered_str) = if $is_metered {
5560 ($metered_limit, "metered")
5561 } else {
5562 ($unmetered_hard_limit, "unmetered")
5564 };
5565 use sui_protocol_config::check_limit_in_range;
5566 let result = check_limit_in_range($x as u64, $metered_limit, h);
5567 match result {
5568 LimitThresholdCrossed::None => {}
5569 LimitThresholdCrossed::Soft(_, _) => {
5570 $metric.with_label_values(&[metered_str, "soft"]).inc();
5571 }
5572 LimitThresholdCrossed::Hard(_, _) => {
5573 $metric.with_label_values(&[metered_str, "hard"]).inc();
5574 }
5575 };
5576 result
5577 }};
5578}
5579
5580pub type Amendments = BTreeMap<AccountAddress, BTreeMap<AccountAddress, AccountAddress>>;
5583
5584static MAINNET_LINKAGE_AMENDMENTS: LazyLock<Arc<Amendments>> =
5585 LazyLock::new(|| parse_amendments(include_str!("mainnet_amendments.json")));
5586
5587static TESTNET_LINKAGE_AMENDMENTS: LazyLock<Arc<Amendments>> =
5588 LazyLock::new(|| parse_amendments(include_str!("testnet_amendments.json")));
5589
5590fn parse_amendments(json: &str) -> Arc<Amendments> {
5591 #[derive(serde::Deserialize)]
5592 struct AmendmentEntry {
5593 root: String,
5594 deps: Vec<DepEntry>,
5595 }
5596
5597 #[derive(serde::Deserialize)]
5598 struct DepEntry {
5599 original_id: String,
5600 version_id: String,
5601 }
5602
5603 let entries: Vec<AmendmentEntry> =
5604 serde_json::from_str(json).expect("Failed to parse amendments JSON");
5605 let mut amendments = BTreeMap::new();
5606 for entry in entries {
5607 let root_id = AccountAddress::from_hex_literal(&entry.root).unwrap();
5608 let mut dep_ids = BTreeMap::new();
5609 for dep in entry.deps {
5610 let orig_id = AccountAddress::from_hex_literal(&dep.original_id).unwrap();
5611 let upgraded_id = AccountAddress::from_hex_literal(&dep.version_id).unwrap();
5612 assert!(
5613 dep_ids.insert(orig_id, upgraded_id).is_none(),
5614 "Duplicate original ID in amendments table"
5615 );
5616 }
5617 assert!(
5618 amendments.insert(root_id, dep_ids).is_none(),
5619 "Duplicate root ID in amendments table"
5620 );
5621 }
5622 Arc::new(amendments)
5623}
5624
5625#[cfg(all(test, not(msim)))]
5626mod test {
5627 use insta::assert_yaml_snapshot;
5628
5629 use super::*;
5630
5631 #[test]
5632 fn snapshot_tests() {
5633 println!("\n============================================================================");
5634 println!("! !");
5635 println!("! IMPORTANT: never update snapshots from this test. only add new versions! !");
5636 println!("! !");
5637 println!("============================================================================\n");
5638 for chain_id in &[Chain::Unknown, Chain::Mainnet, Chain::Testnet] {
5639 let chain_str = match chain_id {
5643 Chain::Unknown => "".to_string(),
5644 _ => format!("{:?}_", chain_id),
5645 };
5646 for i in MIN_PROTOCOL_VERSION..=MAX_PROTOCOL_VERSION {
5647 let cur = ProtocolVersion::new(i);
5648 assert_yaml_snapshot!(
5649 format!("{}version_{}", chain_str, cur.as_u64()),
5650 ProtocolConfig::get_for_version(cur, *chain_id)
5651 );
5652 }
5653 }
5654 }
5655
5656 #[test]
5657 fn binary_format_limits_profile_matches_protocol_version() {
5658 let v141 = ProtocolConfig::get_for_version(ProtocolVersion::new(141), Chain::Unknown);
5659 assert_eq!(
5660 v141.binary_format_limits(),
5661 BinaryFormatLimitsProfile::LEGACY.limits()
5662 );
5663
5664 let v142 = ProtocolConfig::get_for_version(ProtocolVersion::new(142), Chain::Unknown);
5665 assert_eq!(
5666 v142.binary_format_limits(),
5667 BinaryFormatLimitsProfile::V1.limits()
5668 );
5669 }
5670
5671 #[test]
5672 fn test_getters() {
5673 let prot: ProtocolConfig =
5674 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5675 assert_eq!(
5676 prot.max_arguments(),
5677 prot.max_arguments_as_option().unwrap()
5678 );
5679 }
5680
5681 #[test]
5682 fn vector_bulk_native_gas_costs_start_at_version_140() {
5683 for chain in [Chain::Unknown, Chain::Mainnet, Chain::Testnet] {
5684 let before = ProtocolConfig::get_for_version(ProtocolVersion::new(139), chain);
5685 assert_eq!(before.vector_reverse_base_cost_as_option(), None);
5686 assert_eq!(before.vector_reverse_per_elem_cost_as_option(), None);
5687 assert_eq!(before.vector_keep_range_base_cost_as_option(), None);
5688 assert_eq!(
5689 before.vector_keep_range_per_dropped_elem_cost_as_option(),
5690 None
5691 );
5692 assert_eq!(
5693 before.vector_keep_range_per_moved_elem_cost_as_option(),
5694 None
5695 );
5696 assert_eq!(before.vector_copy_range_base_cost_as_option(), None);
5697 assert_eq!(before.vector_replace_range_base_cost_as_option(), None);
5698 assert_eq!(before.vector_replace_range_per_elem_cost_as_option(), None);
5699
5700 let active = ProtocolConfig::get_for_version(ProtocolVersion::new(140), chain);
5701 assert_eq!(active.vector_reverse_base_cost_as_option(), Some(52));
5702 assert_eq!(active.vector_reverse_per_elem_cost_as_option(), Some(8));
5703 assert_eq!(active.vector_keep_range_base_cost_as_option(), Some(52));
5704 assert_eq!(
5705 active.vector_keep_range_per_dropped_elem_cost_as_option(),
5706 Some(1)
5707 );
5708 assert_eq!(
5709 active.vector_keep_range_per_moved_elem_cost_as_option(),
5710 Some(8)
5711 );
5712 assert_eq!(active.vector_copy_range_base_cost_as_option(), Some(52));
5713 assert_eq!(active.vector_replace_range_base_cost_as_option(), Some(52));
5714 assert_eq!(
5715 active.vector_replace_range_per_elem_cost_as_option(),
5716 Some(8)
5717 );
5718 }
5719 }
5720
5721 #[test]
5722 fn test_setters() {
5723 let mut prot: ProtocolConfig =
5724 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5725 prot.set_max_arguments_for_testing(123);
5726 assert_eq!(prot.max_arguments(), 123);
5727
5728 prot.set_max_arguments_from_str_for_testing("321".to_string());
5729 assert_eq!(prot.max_arguments(), 321);
5730
5731 prot.disable_max_arguments_for_testing();
5732 assert_eq!(prot.max_arguments_as_option(), None);
5733
5734 prot.set_attr_for_testing("max_arguments".to_string(), "456".to_string());
5735 assert_eq!(prot.max_arguments(), 456);
5736 }
5737
5738 #[test]
5739 fn test_execution_version_setter_allows_upgrade() {
5740 let mut prot = ProtocolConfig::get_for_max_version_UNSAFE();
5741 let current = prot.execution_version();
5742 prot.set_execution_version_for_testing(current);
5743 prot.set_execution_version_for_testing(current + 1);
5744 assert_eq!(prot.execution_version(), current + 1);
5745 }
5746
5747 #[test]
5748 #[should_panic(expected = "cannot downgrade execution_version")]
5749 fn test_execution_version_setter_panics_on_downgrade() {
5750 let mut prot = ProtocolConfig::get_for_max_version_UNSAFE();
5751 let current = prot.execution_version();
5752 prot.set_execution_version_for_testing(current - 1);
5753 }
5754
5755 #[test]
5756 fn test_feature_flag_setter_by_string() {
5757 let mut prot: ProtocolConfig =
5758 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5759 assert!(!prot.zklogin_auth());
5760 prot.set_feature_flag_for_testing("zklogin_auth".to_string(), true);
5761 assert!(prot.zklogin_auth());
5762 prot.set_feature_flag_for_testing("zklogin_auth".to_string(), false);
5763 assert!(!prot.zklogin_auth());
5764 }
5765
5766 #[test]
5767 #[should_panic(expected = "unknown feature flag")]
5768 fn test_feature_flag_setter_unknown_flag() {
5769 let mut prot: ProtocolConfig =
5770 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5771 prot.set_feature_flag_for_testing("some random string".to_string(), true);
5772 }
5773
5774 #[test]
5775 fn test_get_for_version_if_supported_applies_test_overrides() {
5776 let before =
5777 ProtocolConfig::get_for_version_if_supported(ProtocolVersion::new(1), Chain::Unknown)
5778 .unwrap();
5779
5780 assert!(!before.enable_coin_reservation_obj_refs());
5781
5782 let _guard = ProtocolConfig::apply_overrides_for_testing(|_, mut cfg| {
5783 cfg.enable_coin_reservation_for_testing();
5784 cfg
5785 });
5786
5787 let after =
5788 ProtocolConfig::get_for_version_if_supported(ProtocolVersion::new(1), Chain::Unknown)
5789 .unwrap();
5790
5791 assert!(after.enable_coin_reservation_obj_refs());
5792 }
5793
5794 #[test]
5795 #[should_panic(expected = "unsupported version")]
5796 fn max_version_test() {
5797 let _ = ProtocolConfig::get_for_version_impl(
5800 ProtocolVersion::new(MAX_PROTOCOL_VERSION + 1),
5801 Chain::Unknown,
5802 );
5803 }
5804
5805 #[test]
5806 fn lookup_by_string_test() {
5807 let prot: ProtocolConfig =
5808 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5809 assert!(prot.lookup_attr("some random string".to_string()).is_none());
5811
5812 assert!(
5813 prot.lookup_attr("max_arguments".to_string())
5814 == Some(ProtocolConfigValue::u32(prot.max_arguments())),
5815 );
5816
5817 assert!(
5819 prot.lookup_attr("max_move_identifier_len".to_string())
5820 .is_none()
5821 );
5822
5823 let prot: ProtocolConfig =
5825 ProtocolConfig::get_for_version(ProtocolVersion::new(9), Chain::Unknown);
5826 assert!(
5827 prot.lookup_attr("max_move_identifier_len".to_string())
5828 == Some(ProtocolConfigValue::u64(prot.max_move_identifier_len()))
5829 );
5830
5831 let prot: ProtocolConfig =
5832 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5833 assert!(
5835 prot.attr_map()
5836 .get("max_move_identifier_len")
5837 .unwrap()
5838 .is_none()
5839 );
5840 assert!(
5842 prot.attr_map().get("max_arguments").unwrap()
5843 == &Some(ProtocolConfigValue::u32(prot.max_arguments()))
5844 );
5845
5846 let prot: ProtocolConfig =
5848 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5849 assert!(
5851 prot.feature_flags
5852 .lookup_attr("some random string".to_owned())
5853 .is_none()
5854 );
5855 assert!(
5856 !prot
5857 .feature_flags
5858 .attr_map()
5859 .contains_key("some random string")
5860 );
5861
5862 assert!(
5864 prot.feature_flags
5865 .lookup_attr("package_upgrades".to_owned())
5866 == Some(false)
5867 );
5868 assert!(
5869 prot.feature_flags
5870 .attr_map()
5871 .get("package_upgrades")
5872 .unwrap()
5873 == &false
5874 );
5875 let prot: ProtocolConfig =
5876 ProtocolConfig::get_for_version(ProtocolVersion::new(4), Chain::Unknown);
5877 assert!(
5879 prot.feature_flags
5880 .lookup_attr("package_upgrades".to_owned())
5881 == Some(true)
5882 );
5883 assert!(
5884 prot.feature_flags
5885 .attr_map()
5886 .get("package_upgrades")
5887 .unwrap()
5888 == &true
5889 );
5890 }
5891
5892 #[test]
5893 fn limit_range_fn_test() {
5894 let low = 100u32;
5895 let high = 10000u64;
5896
5897 assert!(check_limit!(1u8, low, high) == LimitThresholdCrossed::None);
5898 assert!(matches!(
5899 check_limit!(255u16, low, high),
5900 LimitThresholdCrossed::Soft(255u128, 100)
5901 ));
5902 assert!(matches!(
5908 check_limit!(2550000u64, low, high),
5909 LimitThresholdCrossed::Hard(2550000, 10000)
5910 ));
5911
5912 assert!(matches!(
5913 check_limit!(2550000u64, high, high),
5914 LimitThresholdCrossed::Hard(2550000, 10000)
5915 ));
5916
5917 assert!(matches!(
5918 check_limit!(1u8, high),
5919 LimitThresholdCrossed::None
5920 ));
5921
5922 assert!(check_limit!(255u16, high) == LimitThresholdCrossed::None);
5923
5924 assert!(matches!(
5925 check_limit!(2550000u64, high),
5926 LimitThresholdCrossed::Hard(2550000, 10000)
5927 ));
5928 }
5929
5930 #[test]
5931 fn linkage_amendments_load() {
5932 let mainnet = LazyLock::force(&MAINNET_LINKAGE_AMENDMENTS);
5933 let testnet = LazyLock::force(&TESTNET_LINKAGE_AMENDMENTS);
5934 assert!(!mainnet.is_empty(), "mainnet amendments must not be empty");
5935 assert!(!testnet.is_empty(), "testnet amendments must not be empty");
5936 }
5937
5938 #[test]
5939 fn render_scalar_fields_use_precision_safe_encoding() {
5940 use mysten_common::rpc_format::Unmetered;
5941
5942 let config = ProtocolConfig::get_for_max_version_UNSAFE();
5943 let rendered = config
5944 .render::<serde_json::Value>(&mut Unmetered)
5945 .expect("render should succeed");
5946
5947 let max_args = rendered
5948 .get("max_arguments")
5949 .expect("max_arguments set at max version");
5950 assert!(
5951 max_args.is_number(),
5952 "u32 should render as number, got {max_args:?}",
5953 );
5954
5955 let max_tx_size = rendered
5956 .get("max_tx_size_bytes")
5957 .expect("max_tx_size_bytes set at max version");
5958 assert!(
5959 max_tx_size.is_string(),
5960 "u64 should render as string, got {max_tx_size:?}",
5961 );
5962 }
5963
5964 #[test]
5965 fn render_includes_non_scalar_gasless_allowlist_as_json() {
5966 use mysten_common::rpc_format::Unmetered;
5967 use serde_json::json;
5968
5969 let mut config = ProtocolConfig::get_for_max_version_UNSAFE();
5970 config.set_gasless_allowed_token_types_for_testing(vec![
5971 ("0xa::usdc::USDC".to_string(), 10_000),
5972 ("0xb::usdt::USDT".to_string(), 0),
5973 ]);
5974
5975 let rendered = config
5976 .render::<serde_json::Value>(&mut Unmetered)
5977 .expect("render should succeed under Unmetered budget");
5978 let allowlist = rendered
5979 .get("gasless_allowed_token_types")
5980 .expect("entry should be present after the testing setter");
5981
5982 assert_eq!(
5985 allowlist,
5986 &json!([["0xa::usdc::USDC", "10000"], ["0xb::usdt::USDT", "0"],]),
5987 );
5988 }
5989
5990 #[test]
5991 fn render_targets_prost_value_for_grpc() {
5992 use mysten_common::rpc_format::Unmetered;
5993 use prost_types::value::Kind;
5994
5995 let mut config = ProtocolConfig::get_for_max_version_UNSAFE();
5996 config.set_gasless_allowed_token_types_for_testing(vec![(
5997 "0xa::usdc::USDC".to_string(),
5998 10_000,
5999 )]);
6000
6001 let rendered = config
6002 .render::<prost_types::Value>(&mut Unmetered)
6003 .expect("render to prost Value should succeed");
6004 let allowlist = rendered
6005 .get("gasless_allowed_token_types")
6006 .expect("entry should be present after the testing setter");
6007
6008 let Some(Kind::ListValue(outer)) = &allowlist.kind else {
6010 panic!(
6011 "expected ListValue at the top level, got {:?}",
6012 allowlist.kind
6013 );
6014 };
6015 assert_eq!(outer.values.len(), 1, "one allowlisted entry");
6016 let Some(Kind::ListValue(entry)) = &outer.values[0].kind else {
6017 panic!("expected each entry to be a ListValue");
6018 };
6019 assert_eq!(entry.values.len(), 2, "entry has (coin_type, amount)");
6020
6021 let Some(Kind::StringValue(coin_type)) = &entry.values[0].kind else {
6022 panic!("expected coin_type as StringValue");
6023 };
6024 assert_eq!(coin_type, "0xa::usdc::USDC");
6025
6026 let Some(Kind::StringValue(amount)) = &entry.values[1].kind else {
6028 panic!(
6029 "expected minimum_transfer_amount as StringValue (precision-safe u64); got {:?}",
6030 entry.values[1].kind,
6031 );
6032 };
6033 assert_eq!(amount, "10000");
6034 }
6035
6036 #[test]
6037 fn render_emits_null_for_unset_protocol_versions() {
6038 use mysten_common::rpc_format::Unmetered;
6039
6040 let config = ProtocolConfig::get_for_version(1.into(), Chain::Unknown);
6041 let rendered = config
6042 .render::<serde_json::Value>(&mut Unmetered)
6043 .expect("render should succeed");
6044 let entry = rendered
6048 .get("gasless_allowed_token_types")
6049 .expect("key should be present for every protocol version");
6050 assert!(
6051 entry.is_null(),
6052 "value should be null for pre-feature protocol version, got {entry:?}",
6053 );
6054 }
6055}