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 = 144;
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)]
446pub struct ProtocolVersion(u64);
447
448impl ProtocolVersion {
449 pub const MIN: Self = Self(MIN_PROTOCOL_VERSION);
454
455 pub const MAX: Self = Self(MAX_PROTOCOL_VERSION);
456
457 #[cfg(not(msim))]
458 pub const MAX_ALLOWED: Self = Self::MAX;
459
460 #[cfg(msim)]
462 pub const MAX_ALLOWED: Self = Self(MAX_PROTOCOL_VERSION + 1);
463
464 pub fn new(v: u64) -> Self {
465 Self(v)
466 }
467
468 pub const fn as_u64(&self) -> u64 {
469 self.0
470 }
471
472 pub fn max() -> Self {
475 Self::MAX
476 }
477
478 pub fn prev(self) -> Self {
479 Self(self.0.checked_sub(1).unwrap())
480 }
481}
482
483impl From<u64> for ProtocolVersion {
484 fn from(v: u64) -> Self {
485 Self::new(v)
486 }
487}
488
489impl std::ops::Sub<u64> for ProtocolVersion {
490 type Output = Self;
491 fn sub(self, rhs: u64) -> Self::Output {
492 Self::new(self.0 - rhs)
493 }
494}
495
496impl std::ops::Add<u64> for ProtocolVersion {
497 type Output = Self;
498 fn add(self, rhs: u64) -> Self::Output {
499 Self::new(self.0 + rhs)
500 }
501}
502
503#[derive(
504 Clone, Serialize, Deserialize, Debug, Default, PartialEq, Copy, PartialOrd, Ord, Eq, ValueEnum,
505)]
506pub enum Chain {
507 Mainnet,
508 Testnet,
509 #[default]
510 Unknown,
511}
512
513impl Chain {
514 pub fn as_str(self) -> &'static str {
515 match self {
516 Chain::Mainnet => "mainnet",
517 Chain::Testnet => "testnet",
518 Chain::Unknown => "unknown",
519 }
520 }
521}
522
523pub fn max_across_protocol<T: Ord>(f: impl Fn(&ProtocolConfig) -> Option<T>) -> Option<T> {
525 let mut max = None;
526 let mut version = ProtocolVersion::MIN;
527 while version <= ProtocolVersion::MAX {
528 max = max.max(f(&ProtocolConfig::get_for_version(version, Chain::Unknown)));
529 max = max.max(f(&ProtocolConfig::get_for_version(version, Chain::Mainnet)));
530 max = max.max(f(&ProtocolConfig::get_for_version(version, Chain::Testnet)));
531 version = version + 1;
532 }
533 max
534}
535
536pub struct Error(pub String);
537
538#[derive(Default, Clone, Serialize, Deserialize, Debug, ProtocolConfigFeatureFlagsGetters)]
541struct FeatureFlags {
542 #[serde(skip_serializing_if = "is_false")]
545 package_upgrades: bool,
546 #[serde(skip_serializing_if = "is_false")]
549 commit_root_state_digest: bool,
550 #[serde(skip_serializing_if = "is_false")]
552 advance_epoch_start_time_in_safe_mode: bool,
553 #[serde(skip_serializing_if = "is_false")]
556 loaded_child_objects_fixed: bool,
557 #[serde(skip_serializing_if = "is_false")]
560 missing_type_is_compatibility_error: bool,
561 #[serde(skip_serializing_if = "is_false")]
564 scoring_decision_with_validity_cutoff: bool,
565
566 #[serde(skip_serializing_if = "is_false")]
569 consensus_order_end_of_epoch_last: bool,
570
571 #[serde(skip_serializing_if = "is_false")]
575 consensus_slim_block_propagation: bool,
576
577 #[serde(skip_serializing_if = "is_false")]
579 disallow_adding_abilities_on_upgrade: bool,
580 #[serde(skip_serializing_if = "is_false")]
582 disable_invariant_violation_check_in_swap_loc: bool,
583 #[serde(skip_serializing_if = "is_false")]
586 advance_to_highest_supported_protocol_version: bool,
587 #[serde(skip_serializing_if = "is_false")]
589 ban_entry_init: bool,
590 #[serde(skip_serializing_if = "is_false")]
592 package_digest_hash_module: bool,
593 #[serde(skip_serializing_if = "is_false")]
595 disallow_change_struct_type_params_on_upgrade: bool,
596 #[serde(skip_serializing_if = "is_false")]
598 no_extraneous_module_bytes: bool,
599 #[serde(skip_serializing_if = "is_false")]
601 narwhal_versioned_metadata: bool,
602
603 #[serde(skip_serializing_if = "is_false")]
605 zklogin_auth: bool,
606 #[serde(skip_serializing_if = "is_zero")]
609 zklogin_circuit_mode: u64,
610 #[serde(skip_serializing_if = "ConsensusTransactionOrdering::is_none")]
612 consensus_transaction_ordering: ConsensusTransactionOrdering,
613
614 #[serde(skip_serializing_if = "is_false")]
622 simplified_unwrap_then_delete: bool,
623 #[serde(skip_serializing_if = "is_false")]
625 upgraded_multisig_supported: bool,
626 #[serde(skip_serializing_if = "is_false")]
628 txn_base_cost_as_multiplier: bool,
629
630 #[serde(skip_serializing_if = "is_false")]
632 shared_object_deletion: bool,
633
634 #[serde(skip_serializing_if = "is_false")]
636 narwhal_new_leader_election_schedule: bool,
637
638 #[serde(skip_serializing_if = "is_empty")]
640 zklogin_supported_providers: BTreeSet<String>,
641
642 #[serde(skip_serializing_if = "is_false")]
644 loaded_child_object_format: bool,
645
646 #[serde(skip_serializing_if = "is_false")]
647 #[skip_protocol_config_accessor]
648 enable_jwk_consensus_updates: bool,
649
650 #[serde(skip_serializing_if = "is_false")]
651 #[skip_protocol_config_accessor]
652 end_of_epoch_transaction_supported: bool,
653
654 #[serde(skip_serializing_if = "is_false")]
657 simple_conservation_checks: bool,
658
659 #[serde(skip_serializing_if = "is_false")]
661 loaded_child_object_format_type: bool,
662
663 #[serde(skip_serializing_if = "is_false")]
665 receive_objects: bool,
666
667 #[serde(skip_serializing_if = "is_false")]
669 consensus_checkpoint_signature_key_includes_digest: bool,
670
671 #[serde(skip_serializing_if = "is_false")]
673 random_beacon: bool,
674
675 #[serde(skip_serializing_if = "is_false")]
677 #[skip_protocol_config_accessor]
678 bridge: bool,
679
680 #[serde(skip_serializing_if = "is_false")]
681 enable_effects_v2: bool,
682
683 #[serde(skip_serializing_if = "is_false")]
685 narwhal_certificate_v2: bool,
686
687 #[serde(skip_serializing_if = "is_false")]
689 verify_legacy_zklogin_address: bool,
690
691 #[serde(skip_serializing_if = "is_false")]
693 throughput_aware_consensus_submission: bool,
694
695 #[serde(skip_serializing_if = "is_false")]
697 recompute_has_public_transfer_in_execution: bool,
698
699 #[serde(skip_serializing_if = "is_false")]
701 accept_zklogin_in_multisig: bool,
702
703 #[serde(skip_serializing_if = "is_false")]
705 accept_passkey_in_multisig: bool,
706
707 #[serde(skip_serializing_if = "is_false")]
709 validate_zklogin_public_identifier: bool,
710
711 #[serde(skip_serializing_if = "is_false")]
714 include_consensus_digest_in_prologue: bool,
715
716 #[serde(skip_serializing_if = "is_false")]
718 hardened_otw_check: bool,
719
720 #[serde(skip_serializing_if = "is_false")]
722 allow_receiving_object_id: bool,
723
724 #[serde(skip_serializing_if = "is_false")]
726 enable_poseidon: bool,
727
728 #[serde(skip_serializing_if = "is_false")]
730 enable_coin_deny_list: bool,
731
732 #[serde(skip_serializing_if = "is_false")]
734 enable_group_ops_native_functions: bool,
735
736 #[serde(skip_serializing_if = "is_false")]
738 enable_group_ops_native_function_msm: bool,
739
740 #[serde(skip_serializing_if = "is_false")]
742 enable_ristretto255_group_ops: bool,
743
744 #[serde(skip_serializing_if = "is_false")]
746 enable_verify_bulletproofs_ristretto255: bool,
747
748 #[serde(skip_serializing_if = "is_false")]
750 enable_nitro_attestation: bool,
751
752 #[serde(skip_serializing_if = "is_false")]
754 enable_nitro_attestation_upgraded_parsing: bool,
755
756 #[serde(skip_serializing_if = "is_false")]
758 enable_nitro_attestation_all_nonzero_pcrs_parsing: bool,
759
760 #[serde(skip_serializing_if = "is_false")]
762 enable_nitro_attestation_always_include_required_pcrs_parsing: bool,
763
764 #[serde(skip_serializing_if = "is_false")]
767 simplify_nitro_header_validation: bool,
768
769 #[serde(skip_serializing_if = "is_false")]
771 reject_mutable_random_on_entry_functions: bool,
772
773 #[serde(skip_serializing_if = "PerObjectCongestionControlMode::is_none")]
775 per_object_congestion_control_mode: PerObjectCongestionControlMode,
776
777 #[serde(skip_serializing_if = "ConsensusChoice::is_narwhal")]
779 consensus_choice: ConsensusChoice,
780
781 #[serde(skip_serializing_if = "ConsensusNetwork::is_anemo")]
783 consensus_network: ConsensusNetwork,
784
785 #[serde(skip_serializing_if = "is_false")]
787 correct_gas_payment_limit_check: bool,
788
789 #[serde(skip_serializing_if = "Option::is_none")]
791 zklogin_max_epoch_upper_bound_delta: Option<u64>,
792
793 #[serde(skip_serializing_if = "is_false")]
795 mysticeti_leader_scoring_and_schedule: bool,
796
797 #[serde(skip_serializing_if = "is_false")]
799 reshare_at_same_initial_version: bool,
800
801 #[serde(skip_serializing_if = "is_false")]
803 resolve_abort_locations_to_package_id: bool,
804
805 #[serde(skip_serializing_if = "is_false")]
809 mysticeti_use_committed_subdag_digest: bool,
810
811 #[serde(skip_serializing_if = "is_false")]
813 enable_vdf: bool,
814
815 #[serde(skip_serializing_if = "is_false")]
819 record_consensus_determined_version_assignments_in_prologue: bool,
820 #[serde(skip_serializing_if = "is_false")]
823 record_consensus_determined_version_assignments_in_prologue_v2: bool,
824
825 #[serde(skip_serializing_if = "is_false")]
827 fresh_vm_on_framework_upgrade: bool,
828
829 #[serde(skip_serializing_if = "is_false")]
837 prepend_prologue_tx_in_consensus_commit_in_checkpoints: bool,
838
839 #[serde(skip_serializing_if = "Option::is_none")]
841 mysticeti_num_leaders_per_round: Option<usize>,
842
843 #[serde(skip_serializing_if = "is_false")]
845 soft_bundle: bool,
846
847 #[serde(skip_serializing_if = "is_false")]
849 enable_coin_deny_list_v2: bool,
850
851 #[serde(skip_serializing_if = "is_false")]
853 passkey_auth: bool,
854
855 #[serde(skip_serializing_if = "is_false")]
858 mldsa65_auth: bool,
859
860 #[serde(skip_serializing_if = "is_false")]
862 secp256r1_ecrecover_checks_x_below_p: bool,
863
864 #[serde(skip_serializing_if = "is_false")]
866 complete_effects_size_estimate: bool,
867
868 #[serde(skip_serializing_if = "is_false")]
870 authority_capabilities_v2: bool,
871
872 #[serde(skip_serializing_if = "is_false")]
874 rethrow_serialization_type_layout_errors: bool,
875
876 #[serde(skip_serializing_if = "is_false")]
878 consensus_distributed_vote_scoring_strategy: bool,
879
880 #[serde(skip_serializing_if = "is_false")]
882 consensus_round_prober: bool,
883
884 #[serde(skip_serializing_if = "is_false")]
886 validate_identifier_inputs: bool,
887
888 #[serde(skip_serializing_if = "is_false")]
890 disallow_self_identifier: bool,
891
892 #[serde(skip_serializing_if = "is_false")]
894 mysticeti_fastpath: bool,
895
896 #[serde(skip_serializing_if = "is_false")]
900 disable_preconsensus_locking: bool,
901
902 #[serde(skip_serializing_if = "is_false")]
904 relocate_event_module: bool,
905
906 #[serde(skip_serializing_if = "is_false")]
908 uncompressed_g1_group_elements: bool,
909
910 #[serde(skip_serializing_if = "is_false")]
911 disallow_new_modules_in_deps_only_packages: bool,
912
913 #[serde(skip_serializing_if = "is_false")]
915 consensus_smart_ancestor_selection: bool,
916
917 #[serde(skip_serializing_if = "is_false")]
919 consensus_round_prober_probe_accepted_rounds: bool,
920
921 #[serde(skip_serializing_if = "is_false")]
923 native_charging_v2: bool,
924
925 #[serde(skip_serializing_if = "is_false")]
928 #[skip_protocol_config_accessor]
929 consensus_linearize_subdag_v2: bool,
930
931 #[serde(skip_serializing_if = "is_false")]
933 convert_type_argument_error: bool,
934
935 #[serde(skip_serializing_if = "is_false")]
937 variant_nodes: bool,
938
939 #[serde(skip_serializing_if = "is_false")]
941 consensus_zstd_compression: bool,
942
943 #[serde(skip_serializing_if = "is_false")]
945 minimize_child_object_mutations: bool,
946
947 #[serde(skip_serializing_if = "is_false")]
950 record_additional_state_digest_in_prologue: bool,
951
952 #[serde(skip_serializing_if = "is_false")]
954 move_native_context: bool,
955
956 #[serde(skip_serializing_if = "is_false")]
959 #[skip_protocol_config_accessor]
960 consensus_median_based_commit_timestamp: bool,
961
962 #[serde(skip_serializing_if = "is_false")]
965 normalize_ptb_arguments: bool,
966
967 #[serde(skip_serializing_if = "is_false")]
969 consensus_batched_block_sync: bool,
970
971 #[serde(skip_serializing_if = "is_false")]
973 enforce_checkpoint_timestamp_monotonicity: bool,
974
975 #[serde(skip_serializing_if = "is_false")]
977 max_ptb_value_size_v2: bool,
978
979 #[serde(skip_serializing_if = "is_false")]
981 resolve_type_input_ids_to_defining_id: bool,
982
983 #[serde(skip_serializing_if = "is_false")]
985 enable_party_transfer: bool,
986
987 #[serde(skip_serializing_if = "is_false")]
989 allow_unbounded_system_objects: bool,
990
991 #[serde(skip_serializing_if = "is_false")]
993 type_tags_in_object_runtime: bool,
994
995 #[serde(skip_serializing_if = "is_false")]
997 enable_accumulators: bool,
998
999 #[serde(skip_serializing_if = "is_false")]
1001 #[skip_protocol_config_accessor]
1002 enable_coin_reservation_obj_refs: bool,
1003
1004 #[serde(skip_serializing_if = "is_false")]
1007 create_root_accumulator_object: bool,
1008
1009 #[serde(skip_serializing_if = "is_false")]
1011 #[skip_protocol_config_accessor]
1012 enable_authenticated_event_streams: bool,
1013
1014 #[serde(skip_serializing_if = "is_false")]
1016 enable_address_balance_gas_payments: bool,
1017
1018 #[serde(skip_serializing_if = "is_false")]
1020 address_balance_gas_check_rgp_at_signing: bool,
1021
1022 #[serde(skip_serializing_if = "is_false")]
1023 address_balance_gas_reject_gas_coin_arg: bool,
1024
1025 #[serde(skip_serializing_if = "is_false")]
1027 enable_multi_epoch_transaction_expiration: bool,
1028
1029 #[serde(skip_serializing_if = "is_false")]
1031 relax_valid_during_for_owned_inputs: bool,
1032
1033 #[serde(skip_serializing_if = "is_false")]
1035 enable_ptb_execution_v2: bool,
1036
1037 #[serde(skip_serializing_if = "is_false")]
1039 better_adapter_type_resolution_errors: bool,
1040
1041 #[serde(skip_serializing_if = "is_false")]
1043 record_time_estimate_processed: bool,
1044
1045 #[serde(skip_serializing_if = "is_false")]
1047 dependency_linkage_error: bool,
1048
1049 #[serde(skip_serializing_if = "is_false")]
1051 additional_multisig_checks: bool,
1052
1053 #[serde(skip_serializing_if = "is_false")]
1055 ignore_execution_time_observations_after_certs_closed: bool,
1056
1057 #[serde(skip_serializing_if = "is_false")]
1061 debug_fatal_on_move_invariant_violation: bool,
1062
1063 #[serde(skip_serializing_if = "is_false")]
1066 allow_private_accumulator_entrypoints: bool,
1067
1068 #[serde(skip_serializing_if = "is_false")]
1071 additional_consensus_digest_indirect_state: bool,
1072
1073 #[serde(skip_serializing_if = "is_false")]
1075 check_for_init_during_upgrade: bool,
1076
1077 #[serde(skip_serializing_if = "is_false")]
1079 enable_init_on_upgrade: bool,
1080
1081 #[serde(skip_serializing_if = "is_false")]
1083 enable_order_independent_upgrade_init_linkage: bool,
1084
1085 #[serde(skip_serializing_if = "is_false")]
1088 harden_linkage_consistency: bool,
1089
1090 #[serde(skip_serializing_if = "is_false")]
1092 per_command_shared_object_transfer_rules: bool,
1093
1094 #[serde(skip_serializing_if = "is_false")]
1096 validate_ptb_argument_indices: bool,
1097
1098 #[serde(skip_serializing_if = "is_false")]
1100 include_checkpoint_artifacts_digest_in_summary: bool,
1101
1102 #[serde(skip_serializing_if = "is_false")]
1104 use_mfp_txns_in_load_initial_object_debts: bool,
1105
1106 #[serde(skip_serializing_if = "is_false")]
1108 cancel_for_failed_dkg_early: bool,
1109
1110 #[serde(skip_serializing_if = "is_false")]
1112 always_advance_dkg_to_resolution: bool,
1113
1114 #[serde(skip_serializing_if = "is_false")]
1116 allow_dkg_completion_after_timeout: bool,
1117
1118 #[serde(skip_serializing_if = "is_false")]
1120 enable_coin_registry: bool,
1121
1122 #[serde(skip_serializing_if = "is_false")]
1124 abstract_size_in_object_runtime: bool,
1125
1126 #[serde(skip_serializing_if = "is_false")]
1128 object_runtime_charge_cache_load_gas: bool,
1129
1130 #[serde(skip_serializing_if = "is_false")]
1132 additional_borrow_checks: bool,
1133
1134 #[serde(skip_serializing_if = "is_false")]
1136 use_new_commit_handler: bool,
1137
1138 #[serde(skip_serializing_if = "is_false")]
1140 better_loader_errors: bool,
1141
1142 #[serde(skip_serializing_if = "is_false")]
1144 generate_df_type_layouts: bool,
1145
1146 #[serde(skip_serializing_if = "is_false")]
1148 allow_references_in_ptbs: bool,
1149
1150 #[serde(skip_serializing_if = "is_false")]
1157 framework_tx_context_mut_restrictions: bool,
1158
1159 #[serde(skip_serializing_if = "is_false")]
1161 include_function_signatures_in_instantiation_limits: bool,
1162
1163 #[serde(skip_serializing_if = "is_false")]
1168 ptb_tx_context_restrictions: bool,
1169
1170 #[serde(skip_serializing_if = "is_false")]
1172 enable_display_registry: bool,
1173
1174 #[serde(skip_serializing_if = "is_false")]
1176 private_generics_verifier_v2: bool,
1177
1178 #[serde(skip_serializing_if = "is_false")]
1180 deprecate_global_storage_ops_during_deserialization: bool,
1181
1182 #[serde(skip_serializing_if = "is_false")]
1185 enable_non_exclusive_writes: bool,
1186
1187 #[serde(skip_serializing_if = "is_false")]
1189 deprecate_global_storage_ops: bool,
1190
1191 #[serde(skip_serializing_if = "is_false")]
1193 normalize_depth_formula: bool,
1194
1195 #[serde(skip_serializing_if = "is_false")]
1198 charge_ld_const_abstract_size: bool,
1199
1200 #[serde(skip_serializing_if = "is_false")]
1202 consensus_skip_gced_accept_votes: bool,
1203
1204 #[serde(skip_serializing_if = "is_false")]
1207 include_cancelled_randomness_txns_in_prologue: bool,
1208
1209 #[serde(skip_serializing_if = "is_false")]
1211 #[skip_protocol_config_accessor]
1212 address_aliases: bool,
1213
1214 #[serde(skip_serializing_if = "is_false")]
1216 create_forwarding_address_registry: bool,
1217
1218 #[serde(skip_serializing_if = "is_false")]
1220 enable_forwarding_addresses: bool,
1221
1222 #[serde(skip_serializing_if = "is_false")]
1225 fix_checkpoint_signature_mapping: bool,
1226
1227 #[serde(skip_serializing_if = "is_false")]
1229 enable_object_funds_withdraw: bool,
1230
1231 #[serde(skip_serializing_if = "is_false")]
1234 record_net_unsettled_object_withdraws: bool,
1235
1236 #[serde(skip_serializing_if = "is_false")]
1238 consensus_skip_gced_blocks_in_direct_finalization: bool,
1239
1240 #[serde(skip_serializing_if = "is_false")]
1242 gas_rounding_halve_digits: bool,
1243
1244 #[serde(skip_serializing_if = "is_false")]
1246 flexible_tx_context_positions: bool,
1247
1248 #[serde(skip_serializing_if = "is_false")]
1250 disable_entry_point_signature_check: bool,
1251
1252 #[serde(skip_serializing_if = "is_false")]
1254 convert_withdrawal_compatibility_ptb_arguments: bool,
1255
1256 #[serde(skip_serializing_if = "is_false")]
1258 restrict_hot_or_not_entry_functions: bool,
1259
1260 #[serde(skip_serializing_if = "is_false")]
1262 split_checkpoints_in_consensus_handler: bool,
1263
1264 #[serde(skip_serializing_if = "is_false")]
1266 consensus_always_accept_system_transactions: bool,
1267
1268 #[serde(skip_serializing_if = "is_false")]
1270 validator_metadata_verify_v2: bool,
1271
1272 #[serde(skip_serializing_if = "is_false")]
1275 defer_unpaid_amplification: bool,
1276
1277 #[serde(skip_serializing_if = "is_false")]
1280 defer_owned_object_double_spend: bool,
1281
1282 #[serde(skip_serializing_if = "is_false")]
1285 allowed_proposers: bool,
1286
1287 #[serde(skip_serializing_if = "is_false")]
1293 #[skip_protocol_config_accessor]
1294 staggered_submission_signal: bool,
1295
1296 #[serde(skip_serializing_if = "is_false")]
1297 randomize_checkpoint_tx_limit_in_tests: bool,
1298
1299 #[serde(skip_serializing_if = "is_false")]
1301 gasless_transaction_drop_safety: bool,
1302
1303 #[serde(skip_serializing_if = "is_false")]
1306 merge_randomness_into_checkpoint: bool,
1307
1308 #[serde(skip_serializing_if = "is_false")]
1310 use_coin_party_owner: bool,
1311
1312 #[serde(skip_serializing_if = "is_false")]
1313 enable_gasless: bool,
1314
1315 #[serde(skip_serializing_if = "is_false")]
1316 gasless_verify_remaining_balance: bool,
1317
1318 #[serde(skip_serializing_if = "is_false")]
1319 disallow_jump_orphans: bool,
1320
1321 #[serde(skip_serializing_if = "is_false")]
1323 early_return_receive_object_mismatched_type: bool,
1324
1325 #[serde(skip_serializing_if = "is_false")]
1330 timestamp_based_epoch_close: bool,
1331
1332 #[serde(skip_serializing_if = "is_false")]
1335 limit_groth16_pvk_inputs: bool,
1336
1337 #[serde(skip_serializing_if = "is_false")]
1341 check_groth16_pvk_length: bool,
1342
1343 #[serde(skip_serializing_if = "is_false")]
1348 enforce_address_balance_change_invariant: bool,
1349
1350 #[serde(skip_serializing_if = "is_false")]
1352 share_transaction_deny_config_in_consensus: bool,
1353
1354 #[serde(skip_serializing_if = "is_false")]
1356 granular_post_execution_checks: bool,
1357
1358 #[serde(skip_serializing_if = "is_false")]
1360 early_exit_on_iffw: bool,
1361
1362 #[serde(skip_serializing_if = "is_false")]
1364 enable_unified_linkage: bool,
1365
1366 #[serde(skip_serializing_if = "is_false")]
1368 package_publish_charge: bool,
1369
1370 #[serde(skip_serializing_if = "is_false")]
1373 #[skip_protocol_config_accessor]
1374 enable_allowances: bool,
1375
1376 #[serde(skip_serializing_if = "is_false")]
1378 fix_ptb_generated_reads: bool,
1379
1380 #[serde(skip_serializing_if = "is_false")]
1381 check_object_funds_withdraw_in_execution: bool,
1382 #[serde(skip_serializing_if = "is_false")]
1384 memory_safety_invariant_check_v2: bool,
1385
1386 #[serde(skip_serializing_if = "is_false")]
1388 disable_effects_tx_dependencies: bool,
1389
1390 #[serde(skip_serializing_if = "is_false")]
1394 merge_colliding_deferrals: bool,
1395
1396 #[serde(skip_serializing_if = "is_false")]
1400 shuffle_consensus_commit_blocks: bool,
1401
1402 #[serde(skip_serializing_if = "is_false")]
1405 disable_id_leak_verifier: bool,
1406
1407 #[serde(skip_serializing_if = "is_false")]
1412 enable_timestamp_transaction_expiration: bool,
1413}
1414
1415fn is_false(b: &bool) -> bool {
1416 !b
1417}
1418
1419fn is_empty(b: &BTreeSet<String>) -> bool {
1420 b.is_empty()
1421}
1422
1423fn is_zero(val: &u64) -> bool {
1424 *val == 0
1425}
1426
1427#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1429pub enum ConsensusTransactionOrdering {
1430 #[default]
1432 None,
1433 ByGasPrice,
1435}
1436
1437impl ConsensusTransactionOrdering {
1438 pub fn is_none(&self) -> bool {
1439 matches!(self, ConsensusTransactionOrdering::None)
1440 }
1441}
1442
1443#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1444pub struct ExecutionTimeEstimateParams {
1445 pub target_utilization: u64,
1447 pub allowed_txn_cost_overage_burst_limit_us: u64,
1451
1452 pub randomness_scalar: u64,
1455
1456 pub max_estimate_us: u64,
1458
1459 pub stored_observations_num_included_checkpoints: u64,
1462
1463 pub stored_observations_limit: u64,
1465
1466 #[serde(skip_serializing_if = "is_zero")]
1469 pub stake_weighted_median_threshold: u64,
1470
1471 #[serde(skip_serializing_if = "is_false")]
1475 pub default_none_duration_for_new_keys: bool,
1476
1477 #[serde(skip_serializing_if = "Option::is_none")]
1479 pub observations_chunk_size: Option<u64>,
1480}
1481
1482#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1484pub enum PerObjectCongestionControlMode {
1485 #[default]
1486 None, TotalGasBudget, TotalTxCount, TotalGasBudgetWithCap, ExecutionTimeEstimate(ExecutionTimeEstimateParams), }
1492
1493impl PerObjectCongestionControlMode {
1494 pub fn is_none(&self) -> bool {
1495 matches!(self, PerObjectCongestionControlMode::None)
1496 }
1497}
1498
1499#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1501pub enum ConsensusChoice {
1502 #[default]
1503 Narwhal,
1504 SwapEachEpoch,
1505 Mysticeti,
1506}
1507
1508impl ConsensusChoice {
1509 pub fn is_narwhal(&self) -> bool {
1510 matches!(self, ConsensusChoice::Narwhal)
1511 }
1512}
1513
1514#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1516pub enum ConsensusNetwork {
1517 #[default]
1518 Anemo,
1519 Tonic,
1520}
1521
1522impl ConsensusNetwork {
1523 pub fn is_anemo(&self) -> bool {
1524 matches!(self, ConsensusNetwork::Anemo)
1525 }
1526}
1527
1528#[skip_serializing_none]
1560#[derive(Clone, Serialize, Debug, ProtocolConfigAccessors, ProtocolConfigOverride)]
1561pub struct ProtocolConfig {
1562 pub version: ProtocolVersion,
1563
1564 #[serde(skip)]
1569 chain: Chain,
1570
1571 feature_flags: FeatureFlags,
1572
1573 max_tx_size_bytes: Option<u64>,
1576
1577 max_input_objects: Option<u64>,
1579
1580 max_size_written_objects: Option<u64>,
1584 max_size_written_objects_system_tx: Option<u64>,
1587
1588 max_serialized_tx_effects_size_bytes: Option<u64>,
1590
1591 max_serialized_tx_effects_size_bytes_system_tx: Option<u64>,
1593
1594 max_gas_payment_objects: Option<u32>,
1596
1597 max_modules_in_publish: Option<u32>,
1599
1600 max_package_dependencies: Option<u32>,
1602
1603 max_arguments: Option<u32>,
1606
1607 max_type_arguments: Option<u32>,
1609
1610 max_type_argument_depth: Option<u32>,
1612
1613 max_pure_argument_size: Option<u32>,
1615
1616 max_programmable_tx_commands: Option<u32>,
1618
1619 move_binary_format_version: Option<u32>,
1622 min_move_binary_format_version: Option<u32>,
1623
1624 binary_module_handles: Option<u16>,
1626 binary_struct_handles: Option<u16>,
1627 binary_function_handles: Option<u16>,
1628 binary_function_instantiations: Option<u16>,
1629 binary_signatures: Option<u16>,
1630 binary_constant_pool: Option<u16>,
1631 binary_identifiers: Option<u16>,
1632 binary_address_identifiers: Option<u16>,
1633 binary_struct_defs: Option<u16>,
1634 binary_struct_def_instantiations: Option<u16>,
1635 binary_function_defs: Option<u16>,
1636 binary_field_handles: Option<u16>,
1637 binary_field_instantiations: Option<u16>,
1638 binary_friend_decls: Option<u16>,
1639 binary_enum_defs: Option<u16>,
1640 binary_enum_def_instantiations: Option<u16>,
1641 binary_variant_handles: Option<u16>,
1642 binary_variant_instantiation_handles: Option<u16>,
1643
1644 #[skip_accessor]
1646 binary_format_limits_profile: Option<BinaryFormatLimitsProfile>,
1647
1648 max_move_object_size: Option<u64>,
1650
1651 max_move_package_size: Option<u64>,
1654
1655 max_publish_or_upgrade_per_ptb: Option<u64>,
1657
1658 max_tx_gas: Option<u64>,
1660
1661 max_gas_price: Option<u64>,
1663
1664 max_gas_price_rgp_factor_for_aborted_transactions: Option<u64>,
1667
1668 max_gas_computation_bucket: Option<u64>,
1670
1671 gas_rounding_step: Option<u64>,
1673
1674 max_loop_depth: Option<u64>,
1676
1677 max_generic_instantiation_length: Option<u64>,
1679
1680 max_function_parameters: Option<u64>,
1682
1683 max_basic_blocks: Option<u64>,
1685
1686 max_value_stack_size: Option<u64>,
1688
1689 max_type_nodes: Option<u64>,
1691
1692 max_generic_instantiation_type_nodes_per_function: Option<u64>,
1694
1695 max_generic_instantiation_type_nodes_per_module: Option<u64>,
1697
1698 max_accumulator_type_nodes: Option<u64>,
1700
1701 max_push_size: Option<u64>,
1703
1704 max_struct_definitions: Option<u64>,
1706
1707 max_function_definitions: Option<u64>,
1709
1710 max_fields_in_struct: Option<u64>,
1712
1713 max_dependency_depth: Option<u64>,
1715
1716 max_num_event_emit: Option<u64>,
1718
1719 max_num_accumulator_events: Option<u64>,
1723
1724 max_num_new_move_object_ids: Option<u64>,
1726
1727 max_num_new_move_object_ids_system_tx: Option<u64>,
1729
1730 max_num_deleted_move_object_ids: Option<u64>,
1732
1733 max_num_deleted_move_object_ids_system_tx: Option<u64>,
1735
1736 max_num_transferred_move_object_ids: Option<u64>,
1738
1739 max_num_transferred_move_object_ids_system_tx: Option<u64>,
1741
1742 max_event_emit_size: Option<u64>,
1744
1745 max_event_emit_size_total: Option<u64>,
1747
1748 max_move_vector_len: Option<u64>,
1750
1751 max_move_identifier_len: Option<u64>,
1753
1754 max_move_value_depth: Option<u64>,
1756
1757 package_arena_size_in_bytes: Option<u64>,
1760
1761 max_move_enum_variants: Option<u64>,
1763
1764 max_back_edges_per_function: Option<u64>,
1766
1767 max_back_edges_per_module: Option<u64>,
1769
1770 max_verifier_meter_ticks_per_function: Option<u64>,
1772
1773 max_meter_ticks_per_module: Option<u64>,
1775
1776 max_meter_ticks_per_package: Option<u64>,
1778
1779 object_runtime_max_num_cached_objects: Option<u64>,
1783
1784 object_runtime_max_num_cached_objects_system_tx: Option<u64>,
1786
1787 object_runtime_max_num_store_entries: Option<u64>,
1789
1790 object_runtime_max_num_store_entries_system_tx: Option<u64>,
1792
1793 base_tx_cost_fixed: Option<u64>,
1796
1797 package_publish_cost_fixed: Option<u64>,
1800
1801 base_tx_cost_per_byte: Option<u64>,
1804
1805 package_publish_cost_per_byte: Option<u64>,
1807
1808 package_publish_charge_fixed: Option<u64>,
1810
1811 package_publish_charge_per_module: Option<u64>,
1813
1814 package_publish_charge_per_dependency: Option<u64>,
1816
1817 obj_access_cost_read_per_byte: Option<u64>,
1819
1820 obj_access_cost_read_per_package_kb: Option<u64>,
1823
1824 obj_access_cost_mutate_per_byte: Option<u64>,
1826
1827 obj_access_cost_delete_per_byte: Option<u64>,
1829
1830 obj_access_cost_verify_per_byte: Option<u64>,
1840
1841 max_type_to_layout_nodes: Option<u64>,
1843
1844 max_ptb_value_size: Option<u64>,
1846
1847 gas_model_version: Option<u64>,
1850
1851 obj_data_cost_refundable: Option<u64>,
1854
1855 obj_metadata_cost_non_refundable: Option<u64>,
1859
1860 storage_rebate_rate: Option<u64>,
1866
1867 storage_fund_reinvest_rate: Option<u64>,
1870
1871 reward_slashing_rate: Option<u64>,
1874
1875 storage_gas_price: Option<u64>,
1877
1878 accumulator_object_storage_cost: Option<u64>,
1880
1881 max_transactions_per_checkpoint: Option<u64>,
1886
1887 max_checkpoint_size_bytes: Option<u64>,
1891
1892 buffer_stake_for_protocol_upgrade_bps: Option<u64>,
1897
1898 address_from_bytes_cost_base: Option<u64>,
1903 address_to_u256_cost_base: Option<u64>,
1905 address_from_u256_cost_base: Option<u64>,
1907
1908 config_read_setting_impl_cost_base: Option<u64>,
1913 config_read_setting_impl_cost_per_byte: Option<u64>,
1914
1915 package_original_package_id_impl_cost_base: Option<u64>,
1916 package_original_package_id_impl_cost_per_byte: Option<u64>,
1917
1918 dynamic_field_hash_type_and_key_cost_base: Option<u64>,
1921 dynamic_field_hash_type_and_key_type_cost_per_byte: Option<u64>,
1922 dynamic_field_hash_type_and_key_value_cost_per_byte: Option<u64>,
1923 dynamic_field_hash_type_and_key_type_tag_cost_per_byte: Option<u64>,
1924 dynamic_field_add_child_object_cost_base: Option<u64>,
1926 dynamic_field_add_child_object_type_cost_per_byte: Option<u64>,
1927 dynamic_field_add_child_object_value_cost_per_byte: Option<u64>,
1928 dynamic_field_add_child_object_struct_tag_cost_per_byte: Option<u64>,
1929 dynamic_field_borrow_child_object_cost_base: Option<u64>,
1931 dynamic_field_borrow_child_object_child_ref_cost_per_byte: Option<u64>,
1932 dynamic_field_borrow_child_object_type_cost_per_byte: Option<u64>,
1933 dynamic_field_remove_child_object_cost_base: Option<u64>,
1935 dynamic_field_remove_child_object_child_cost_per_byte: Option<u64>,
1936 dynamic_field_remove_child_object_type_cost_per_byte: Option<u64>,
1937 dynamic_field_has_child_object_cost_base: Option<u64>,
1939 dynamic_field_has_child_object_with_ty_cost_base: Option<u64>,
1941 dynamic_field_has_child_object_with_ty_type_cost_per_byte: Option<u64>,
1942 dynamic_field_has_child_object_with_ty_type_tag_cost_per_byte: Option<u64>,
1943
1944 scratch_add_cost_base: Option<u64>,
1947 scratch_read_cost_base: Option<u64>,
1949 scratch_read_value_cost: Option<u64>,
1950 scratch_remove_cost_base: Option<u64>,
1952 scratch_exists_cost_base: Option<u64>,
1954 scratch_exists_with_type_cost_base: Option<u64>,
1956 scratch_exists_with_type_type_cost: Option<u64>,
1957 max_scratch_pad_size: Option<u64>,
1959
1960 event_emit_cost_base: Option<u64>,
1963 event_emit_value_size_derivation_cost_per_byte: Option<u64>,
1964 event_emit_tag_size_derivation_cost_per_byte: Option<u64>,
1965 event_emit_output_cost_per_byte: Option<u64>,
1966 event_emit_auth_stream_cost: Option<u64>,
1967
1968 reserve_object_funds_for_withdrawal_cost_base: Option<u64>,
1971 reserve_object_funds_for_withdrawal_cold_read_cost: Option<u64>,
1973
1974 object_borrow_uid_cost_base: Option<u64>,
1977 object_delete_impl_cost_base: Option<u64>,
1979 object_record_new_uid_cost_base: Option<u64>,
1981 object_record_new_uid_from_hash_cost_base: Option<u64>,
1984 object_is_shared_input_cost_base: Option<u64>,
1986
1987 transfer_transfer_internal_cost_base: Option<u64>,
1990 transfer_party_transfer_internal_cost_base: Option<u64>,
1992 transfer_freeze_object_cost_base: Option<u64>,
1994 transfer_share_object_cost_base: Option<u64>,
1996 transfer_receive_object_cost_base: Option<u64>,
1999 transfer_receive_object_cost_per_byte: Option<u64>,
2000 transfer_receive_object_type_cost_per_byte: Option<u64>,
2001
2002 tx_context_derive_id_cost_base: Option<u64>,
2005 tx_context_fresh_id_cost_base: Option<u64>,
2006 tx_context_sender_cost_base: Option<u64>,
2007 tx_context_epoch_cost_base: Option<u64>,
2008 tx_context_epoch_timestamp_ms_cost_base: Option<u64>,
2009 tx_context_sponsor_cost_base: Option<u64>,
2010 tx_context_rgp_cost_base: Option<u64>,
2011 tx_context_gas_price_cost_base: Option<u64>,
2012 tx_context_gas_budget_cost_base: Option<u64>,
2013 tx_context_ids_created_cost_base: Option<u64>,
2014 tx_context_replace_cost_base: Option<u64>,
2015
2016 clock_borrow_cost_base: Option<u64>,
2019
2020 types_is_one_time_witness_cost_base: Option<u64>,
2023 types_is_one_time_witness_type_tag_cost_per_byte: Option<u64>,
2024 types_is_one_time_witness_type_cost_per_byte: Option<u64>,
2025
2026 validator_validate_metadata_cost_base: Option<u64>,
2029 validator_validate_metadata_data_cost_per_byte: Option<u64>,
2030
2031 crypto_invalid_arguments_cost: Option<u64>,
2033 bls12381_bls12381_min_sig_verify_cost_base: Option<u64>,
2035 bls12381_bls12381_min_sig_verify_msg_cost_per_byte: Option<u64>,
2036 bls12381_bls12381_min_sig_verify_msg_cost_per_block: Option<u64>,
2037
2038 bls12381_bls12381_min_pk_verify_cost_base: Option<u64>,
2040 bls12381_bls12381_min_pk_verify_msg_cost_per_byte: Option<u64>,
2041 bls12381_bls12381_min_pk_verify_msg_cost_per_block: Option<u64>,
2042
2043 ecdsa_k1_ecrecover_keccak256_cost_base: Option<u64>,
2045 ecdsa_k1_ecrecover_keccak256_msg_cost_per_byte: Option<u64>,
2046 ecdsa_k1_ecrecover_keccak256_msg_cost_per_block: Option<u64>,
2047 ecdsa_k1_ecrecover_sha256_cost_base: Option<u64>,
2048 ecdsa_k1_ecrecover_sha256_msg_cost_per_byte: Option<u64>,
2049 ecdsa_k1_ecrecover_sha256_msg_cost_per_block: Option<u64>,
2050
2051 ecdsa_k1_decompress_pubkey_cost_base: Option<u64>,
2053
2054 ecdsa_k1_secp256k1_verify_keccak256_cost_base: Option<u64>,
2056 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_byte: Option<u64>,
2057 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_block: Option<u64>,
2058 ecdsa_k1_secp256k1_verify_sha256_cost_base: Option<u64>,
2059 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_byte: Option<u64>,
2060 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_block: Option<u64>,
2061
2062 ecdsa_r1_ecrecover_keccak256_cost_base: Option<u64>,
2064 ecdsa_r1_ecrecover_keccak256_msg_cost_per_byte: Option<u64>,
2065 ecdsa_r1_ecrecover_keccak256_msg_cost_per_block: Option<u64>,
2066 ecdsa_r1_ecrecover_sha256_cost_base: Option<u64>,
2067 ecdsa_r1_ecrecover_sha256_msg_cost_per_byte: Option<u64>,
2068 ecdsa_r1_ecrecover_sha256_msg_cost_per_block: Option<u64>,
2069
2070 ecdsa_r1_secp256r1_verify_keccak256_cost_base: Option<u64>,
2072 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_byte: Option<u64>,
2073 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_block: Option<u64>,
2074 ecdsa_r1_secp256r1_verify_sha256_cost_base: Option<u64>,
2075 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_byte: Option<u64>,
2076 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_block: Option<u64>,
2077
2078 ecvrf_ecvrf_verify_cost_base: Option<u64>,
2080 ecvrf_ecvrf_verify_alpha_string_cost_per_byte: Option<u64>,
2081 ecvrf_ecvrf_verify_alpha_string_cost_per_block: Option<u64>,
2082
2083 ed25519_ed25519_verify_cost_base: Option<u64>,
2085 ed25519_ed25519_verify_msg_cost_per_byte: Option<u64>,
2086 ed25519_ed25519_verify_msg_cost_per_block: Option<u64>,
2087
2088 groth16_prepare_verifying_key_bls12381_cost_base: Option<u64>,
2090 groth16_prepare_verifying_key_bn254_cost_base: Option<u64>,
2091
2092 groth16_verify_groth16_proof_internal_bls12381_cost_base: Option<u64>,
2094 groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input: Option<u64>,
2095 groth16_verify_groth16_proof_internal_bn254_cost_base: Option<u64>,
2096 groth16_verify_groth16_proof_internal_bn254_cost_per_public_input: Option<u64>,
2097 groth16_verify_groth16_proof_internal_public_input_cost_per_byte: Option<u64>,
2098
2099 hash_blake2b256_cost_base: Option<u64>,
2101 hash_blake2b256_data_cost_per_byte: Option<u64>,
2102 hash_blake2b256_data_cost_per_block: Option<u64>,
2103
2104 hash_keccak256_cost_base: Option<u64>,
2106 hash_keccak256_data_cost_per_byte: Option<u64>,
2107 hash_keccak256_data_cost_per_block: Option<u64>,
2108
2109 poseidon_bn254_cost_base: Option<u64>,
2111 poseidon_bn254_cost_per_block: Option<u64>,
2112
2113 group_ops_bls12381_decode_scalar_cost: Option<u64>,
2115 group_ops_bls12381_decode_g1_cost: Option<u64>,
2116 group_ops_bls12381_decode_g2_cost: Option<u64>,
2117 group_ops_bls12381_decode_gt_cost: Option<u64>,
2118 group_ops_bls12381_scalar_add_cost: Option<u64>,
2119 group_ops_bls12381_g1_add_cost: Option<u64>,
2120 group_ops_bls12381_g2_add_cost: Option<u64>,
2121 group_ops_bls12381_gt_add_cost: Option<u64>,
2122 group_ops_bls12381_scalar_sub_cost: Option<u64>,
2123 group_ops_bls12381_g1_sub_cost: Option<u64>,
2124 group_ops_bls12381_g2_sub_cost: Option<u64>,
2125 group_ops_bls12381_gt_sub_cost: Option<u64>,
2126 group_ops_bls12381_scalar_mul_cost: Option<u64>,
2127 group_ops_bls12381_g1_mul_cost: Option<u64>,
2128 group_ops_bls12381_g2_mul_cost: Option<u64>,
2129 group_ops_bls12381_gt_mul_cost: Option<u64>,
2130 group_ops_bls12381_scalar_div_cost: Option<u64>,
2131 group_ops_bls12381_g1_div_cost: Option<u64>,
2132 group_ops_bls12381_g2_div_cost: Option<u64>,
2133 group_ops_bls12381_gt_div_cost: Option<u64>,
2134 group_ops_bls12381_g1_hash_to_base_cost: Option<u64>,
2135 group_ops_bls12381_g2_hash_to_base_cost: Option<u64>,
2136 group_ops_bls12381_g1_hash_to_cost_per_byte: Option<u64>,
2137 group_ops_bls12381_g2_hash_to_cost_per_byte: Option<u64>,
2138 group_ops_bls12381_g1_msm_base_cost: Option<u64>,
2139 group_ops_bls12381_g2_msm_base_cost: Option<u64>,
2140 group_ops_bls12381_g1_msm_base_cost_per_input: Option<u64>,
2141 group_ops_bls12381_g2_msm_base_cost_per_input: Option<u64>,
2142 group_ops_bls12381_msm_max_len: Option<u32>,
2143 group_ops_bls12381_pairing_cost: Option<u64>,
2144 group_ops_bls12381_g1_to_uncompressed_g1_cost: Option<u64>,
2145 group_ops_bls12381_uncompressed_g1_to_g1_cost: Option<u64>,
2146 group_ops_bls12381_uncompressed_g1_sum_base_cost: Option<u64>,
2147 group_ops_bls12381_uncompressed_g1_sum_cost_per_term: Option<u64>,
2148 group_ops_bls12381_uncompressed_g1_sum_max_terms: Option<u64>,
2149
2150 group_ops_ristretto_decode_scalar_cost: Option<u64>,
2151 group_ops_ristretto_decode_point_cost: Option<u64>,
2152 group_ops_ristretto_scalar_add_cost: Option<u64>,
2153 group_ops_ristretto_point_add_cost: Option<u64>,
2154 group_ops_ristretto_scalar_sub_cost: Option<u64>,
2155 group_ops_ristretto_point_sub_cost: Option<u64>,
2156 group_ops_ristretto_scalar_mul_cost: Option<u64>,
2157 group_ops_ristretto_point_mul_cost: Option<u64>,
2158 group_ops_ristretto_scalar_div_cost: Option<u64>,
2159 group_ops_ristretto_point_div_cost: Option<u64>,
2160
2161 verify_bulletproofs_ristretto255_base_cost: Option<u64>,
2162 verify_bulletproofs_ristretto255_cost_per_bit_and_commitment: Option<u64>,
2163 max_bulletproofs_total_bits: Option<u64>,
2166
2167 hmac_hmac_sha3_256_cost_base: Option<u64>,
2169 hmac_hmac_sha3_256_input_cost_per_byte: Option<u64>,
2170 hmac_hmac_sha3_256_input_cost_per_block: Option<u64>,
2171
2172 check_zklogin_id_cost_base: Option<u64>,
2174 check_zklogin_issuer_cost_base: Option<u64>,
2176
2177 vdf_verify_vdf_cost: Option<u64>,
2178 vdf_hash_to_input_cost: Option<u64>,
2179
2180 nitro_attestation_parse_base_cost: Option<u64>,
2182 nitro_attestation_parse_cost_per_byte: Option<u64>,
2183 nitro_attestation_verify_base_cost: Option<u64>,
2184 nitro_attestation_verify_cost_per_cert: Option<u64>,
2185
2186 layout_node_cost: Option<u64>,
2188 layout_node_cost_large_layout_threshold: Option<u64>,
2190
2191 bcs_per_byte_serialized_cost: Option<u64>,
2193 bcs_legacy_min_output_size_cost: Option<u64>,
2194 bcs_failure_cost: Option<u64>,
2195
2196 hash_sha2_256_base_cost: Option<u64>,
2197 hash_sha2_256_per_byte_cost: Option<u64>,
2198 hash_sha2_256_legacy_min_input_len_cost: Option<u64>,
2199 hash_sha3_256_base_cost: Option<u64>,
2200 hash_sha3_256_per_byte_cost: Option<u64>,
2201 hash_sha3_256_legacy_min_input_len_cost: Option<u64>,
2202 type_name_get_base_cost: Option<u64>,
2203 type_name_get_per_byte_cost: Option<u64>,
2204 type_name_id_base_cost: Option<u64>,
2205
2206 string_check_utf8_base_cost: Option<u64>,
2207 string_check_utf8_per_byte_cost: Option<u64>,
2208 string_is_char_boundary_base_cost: Option<u64>,
2209 string_sub_string_base_cost: Option<u64>,
2210 string_sub_string_per_byte_cost: Option<u64>,
2211 string_index_of_base_cost: Option<u64>,
2212 string_index_of_per_byte_pattern_cost: Option<u64>,
2213 string_index_of_per_byte_searched_cost: Option<u64>,
2214
2215 vector_empty_base_cost: Option<u64>,
2216 vector_length_base_cost: Option<u64>,
2217 vector_push_back_base_cost: Option<u64>,
2218 vector_push_back_legacy_per_abstract_memory_unit_cost: Option<u64>,
2219 vector_borrow_base_cost: Option<u64>,
2220 vector_pop_back_base_cost: Option<u64>,
2221 vector_destroy_empty_base_cost: Option<u64>,
2222 vector_swap_base_cost: Option<u64>,
2223 vector_reverse_base_cost: Option<u64>,
2224 vector_reverse_per_elem_cost: Option<u64>,
2225 vector_keep_range_base_cost: Option<u64>,
2226 vector_keep_range_per_dropped_elem_cost: Option<u64>,
2227 vector_keep_range_per_moved_elem_cost: Option<u64>,
2228 vector_copy_range_base_cost: Option<u64>,
2229 vector_replace_range_base_cost: Option<u64>,
2230 vector_replace_range_per_elem_cost: Option<u64>,
2231 debug_print_base_cost: Option<u64>,
2232 debug_print_stack_trace_base_cost: Option<u64>,
2233
2234 #[custom_setter]
2244 execution_version: Option<u64>,
2245
2246 consensus_bad_nodes_stake_threshold: Option<u64>,
2250
2251 max_jwk_votes_per_validator_per_epoch: Option<u64>,
2252 max_age_of_jwk_in_epochs: Option<u64>,
2256
2257 random_beacon_reduction_allowed_delta: Option<u16>,
2261
2262 random_beacon_reduction_lower_bound: Option<u32>,
2265
2266 random_beacon_dkg_timeout_round: Option<u32>,
2269
2270 random_beacon_min_round_interval_ms: Option<u64>,
2272
2273 random_beacon_dkg_version: Option<u64>,
2276
2277 consensus_max_transaction_size_bytes: Option<u64>,
2280 consensus_max_transactions_in_block_bytes: Option<u64>,
2282 consensus_max_num_transactions_in_block: Option<u64>,
2284
2285 consensus_voting_rounds: Option<u32>,
2287
2288 max_accumulated_txn_cost_per_object_in_narwhal_commit: Option<u64>,
2290
2291 max_deferral_rounds_for_congestion_control: Option<u64>,
2294
2295 epoch_close_deadline_ms: Option<u64>,
2300
2301 max_txn_cost_overage_per_object_in_commit: Option<u64>,
2303
2304 allowed_txn_cost_overage_burst_per_object_in_commit: Option<u64>,
2306
2307 min_checkpoint_interval_ms: Option<u64>,
2309
2310 checkpoint_summary_version_specific_data: Option<u64>,
2312
2313 max_soft_bundle_size: Option<u64>,
2315
2316 bridge_should_try_to_finalize_committee: Option<bool>,
2320
2321 max_accumulated_txn_cost_per_object_in_mysticeti_commit: Option<u64>,
2327
2328 max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit: Option<u64>,
2331
2332 consensus_gc_depth: Option<u32>,
2335
2336 gas_budget_based_txn_cost_cap_factor: Option<u64>,
2338
2339 gas_budget_based_txn_cost_absolute_cap_commit_count: Option<u64>,
2341
2342 sip_45_consensus_amplification_threshold: Option<u64>,
2345
2346 staggered_submission_signal_window_commits: Option<u64>,
2349 staggered_submission_signal_min_excess_copies_per_commit: Option<u64>,
2351 staggered_submission_signal_exit_dwell_commits: Option<u64>,
2354 staggered_submission_signal_band1_enter_ratio_bps: Option<u64>,
2357 staggered_submission_signal_band1_exit_ratio_bps: Option<u64>,
2358 staggered_submission_signal_band2_enter_ratio_bps: Option<u64>,
2359 staggered_submission_signal_band2_exit_ratio_bps: Option<u64>,
2360
2361 use_object_per_epoch_marker_table_v2: Option<bool>,
2364
2365 consensus_commit_rate_estimation_window_size: Option<u32>,
2367
2368 #[serde(skip_serializing_if = "Vec::is_empty")]
2372 aliased_addresses: Vec<AliasedAddress>,
2373
2374 translation_per_command_base_charge: Option<u64>,
2377
2378 translation_per_input_base_charge: Option<u64>,
2381
2382 translation_pure_input_per_byte_charge: Option<u64>,
2384
2385 translation_per_type_node_charge: Option<u64>,
2389
2390 translation_per_reference_node_charge: Option<u64>,
2393
2394 translation_per_linkage_entry_charge: Option<u64>,
2397
2398 max_updates_per_settlement_txn: Option<u32>,
2400
2401 gasless_max_computation_units: Option<u64>,
2403
2404 gasless_allowed_token_types: Option<Vec<(String, u64)>>,
2406
2407 gasless_max_unused_inputs: Option<u64>,
2411
2412 gasless_max_pure_input_bytes: Option<u64>,
2415
2416 gasless_max_tps: Option<u64>,
2418
2419 #[serde(skip_serializing_if = "Option::is_none")]
2420 #[skip_accessor]
2421 include_special_package_amendments: Option<Arc<Amendments>>,
2422
2423 gasless_max_tx_size_bytes: Option<u64>,
2426
2427 translation_per_live_reference_charge: Option<u64>,
2430
2431 max_ptb_live_references: Option<u64>,
2434
2435 max_ptb_returned_references: Option<u64>,
2438
2439 max_ptb_total_returned_references: Option<u64>,
2442}
2443
2444#[derive(Clone, Serialize, Deserialize, Debug)]
2446pub struct AliasedAddress {
2447 pub original: [u8; 32],
2449 pub aliased: [u8; 32],
2451 pub allowed_tx_digests: Vec<[u8; 32]>,
2453}
2454
2455impl ProtocolConfig {
2457 pub fn chain(&self) -> Chain {
2459 self.chain
2460 }
2461
2462 pub fn check_package_upgrades_supported(&self) -> Result<(), Error> {
2475 if self.feature_flags.package_upgrades {
2476 Ok(())
2477 } else {
2478 Err(Error(format!(
2479 "package upgrades are not supported at {:?}",
2480 self.version
2481 )))
2482 }
2483 }
2484
2485 pub fn zklogin_supported_providers(&self) -> &BTreeSet<String> {
2486 &self.feature_flags.zklogin_supported_providers
2487 }
2488
2489 pub fn zklogin_circuit_mode(&self) -> u64 {
2492 self.feature_flags.zklogin_circuit_mode
2493 }
2494
2495 pub fn consensus_transaction_ordering(&self) -> ConsensusTransactionOrdering {
2496 self.feature_flags.consensus_transaction_ordering
2497 }
2498
2499 pub fn enable_jwk_consensus_updates(&self) -> bool {
2500 let ret = self.feature_flags.enable_jwk_consensus_updates;
2501 if ret {
2502 assert!(self.feature_flags.end_of_epoch_transaction_supported);
2504 }
2505 ret
2506 }
2507
2508 pub fn staggered_submission_signal(&self) -> bool {
2509 let ret = self.feature_flags.staggered_submission_signal;
2510 if ret {
2511 assert!(self.feature_flags.allowed_proposers);
2514 }
2515 ret
2516 }
2517
2518 pub fn end_of_epoch_transaction_supported(&self) -> bool {
2519 let ret = self.feature_flags.end_of_epoch_transaction_supported;
2520 if !ret {
2521 assert!(!self.feature_flags.enable_jwk_consensus_updates);
2523 }
2524 ret
2525 }
2526
2527 pub fn dkg_version(&self) -> u64 {
2528 self.random_beacon_dkg_version.unwrap_or(1)
2530 }
2531
2532 pub fn bridge(&self) -> bool {
2533 let ret = self.feature_flags.bridge;
2534 if ret {
2535 assert!(self.feature_flags.end_of_epoch_transaction_supported);
2537 }
2538 ret
2539 }
2540
2541 pub fn should_try_to_finalize_bridge_committee(&self) -> bool {
2542 if !self.bridge() {
2543 return false;
2544 }
2545 self.bridge_should_try_to_finalize_committee.unwrap_or(true)
2547 }
2548
2549 pub fn zklogin_max_epoch_upper_bound_delta(&self) -> Option<u64> {
2550 self.feature_flags.zklogin_max_epoch_upper_bound_delta
2551 }
2552
2553 pub fn enable_allowances(&self) -> bool {
2554 self.feature_flags.enable_allowances && self.enable_accumulators()
2555 }
2556
2557 pub fn enable_coin_reservation_obj_refs(&self) -> bool {
2558 self.new_vm_enabled() && self.feature_flags.enable_coin_reservation_obj_refs
2559 }
2560
2561 pub fn enable_authenticated_event_streams(&self) -> bool {
2562 self.feature_flags.enable_authenticated_event_streams && self.enable_accumulators()
2563 }
2564
2565 pub fn per_object_congestion_control_mode(&self) -> PerObjectCongestionControlMode {
2566 self.feature_flags.per_object_congestion_control_mode
2567 }
2568
2569 pub fn consensus_choice(&self) -> ConsensusChoice {
2570 self.feature_flags.consensus_choice
2571 }
2572
2573 pub fn consensus_network(&self) -> ConsensusNetwork {
2574 self.feature_flags.consensus_network
2575 }
2576
2577 pub fn mysticeti_num_leaders_per_round(&self) -> Option<usize> {
2578 self.feature_flags.mysticeti_num_leaders_per_round
2579 }
2580
2581 pub fn max_transaction_size_bytes(&self) -> u64 {
2582 self.consensus_max_transaction_size_bytes
2584 .unwrap_or(256 * 1024)
2585 }
2586
2587 pub fn max_transactions_in_block_bytes(&self) -> u64 {
2588 if cfg!(msim) {
2589 256 * 1024
2590 } else {
2591 self.consensus_max_transactions_in_block_bytes
2592 .unwrap_or(512 * 1024)
2593 }
2594 }
2595
2596 pub fn max_num_transactions_in_block(&self) -> u64 {
2597 if cfg!(msim) {
2598 8
2599 } else {
2600 self.consensus_max_num_transactions_in_block.unwrap_or(512)
2601 }
2602 }
2603
2604 pub fn gc_depth(&self) -> u32 {
2605 self.consensus_gc_depth.unwrap_or(0)
2606 }
2607
2608 pub fn consensus_linearize_subdag_v2(&self) -> bool {
2609 let res = self.feature_flags.consensus_linearize_subdag_v2;
2610 assert!(
2611 !res || self.gc_depth() > 0,
2612 "The consensus linearize sub dag V2 requires GC to be enabled"
2613 );
2614 res
2615 }
2616
2617 pub fn consensus_median_based_commit_timestamp(&self) -> bool {
2618 let res = self.feature_flags.consensus_median_based_commit_timestamp;
2619 assert!(
2620 !res || self.gc_depth() > 0,
2621 "The consensus median based commit timestamp requires GC to be enabled"
2622 );
2623 res
2624 }
2625
2626 pub fn get_consensus_commit_rate_estimation_window_size(&self) -> u32 {
2627 self.consensus_commit_rate_estimation_window_size
2628 .unwrap_or(0)
2629 }
2630
2631 pub fn consensus_num_requested_prior_commits_at_startup(&self) -> u32 {
2632 let window_size = self.get_consensus_commit_rate_estimation_window_size();
2636 assert!(window_size == 0 || self.record_additional_state_digest_in_prologue());
2638 window_size
2639 }
2640
2641 pub fn address_aliases(&self) -> bool {
2642 let address_aliases = self.feature_flags.address_aliases;
2643 assert!(
2644 !address_aliases || self.mysticeti_fastpath(),
2645 "Address aliases requires Mysticeti fastpath to be enabled"
2646 );
2647 if address_aliases {
2648 assert!(
2649 self.feature_flags.disable_preconsensus_locking,
2650 "Address aliases requires CertifiedTransaction to be disabled"
2651 );
2652 }
2653 address_aliases
2654 }
2655
2656 pub fn new_vm_enabled(&self) -> bool {
2657 self.execution_version.is_some_and(|v| v >= 4)
2658 }
2659
2660 pub fn gasless_allowed_token_types(&self) -> &[(String, u64)] {
2661 debug_assert!(self.gasless_allowed_token_types.is_some());
2662 self.gasless_allowed_token_types.as_deref().unwrap_or(&[])
2663 }
2664
2665 pub fn get_gasless_max_unused_inputs(&self) -> u64 {
2666 self.gasless_max_unused_inputs.unwrap_or(u64::MAX)
2667 }
2668
2669 pub fn get_gasless_max_pure_input_bytes(&self) -> u64 {
2670 self.gasless_max_pure_input_bytes.unwrap_or(u64::MAX)
2671 }
2672
2673 pub fn get_gasless_max_tx_size_bytes(&self) -> u64 {
2674 self.gasless_max_tx_size_bytes.unwrap_or(u64::MAX)
2675 }
2676
2677 pub fn include_special_package_amendments_as_option(&self) -> &Option<Arc<Amendments>> {
2678 &self.include_special_package_amendments
2679 }
2680}
2681
2682static POISON_VERSION_METHODS: AtomicBool = AtomicBool::new(false);
2683
2684impl ProtocolConfig {
2686 pub fn get_for_version(version: ProtocolVersion, chain: Chain) -> Self {
2688 assert!(
2690 version >= ProtocolVersion::MIN,
2691 "Network protocol version is {:?}, but the minimum supported version by the binary is {:?}. Please upgrade the binary.",
2692 version,
2693 ProtocolVersion::MIN.0,
2694 );
2695 assert!(
2696 version <= ProtocolVersion::MAX_ALLOWED,
2697 "Network protocol version is {:?}, but the maximum supported version by the binary is {:?}. Please upgrade the binary.",
2698 version,
2699 ProtocolVersion::MAX_ALLOWED.0,
2700 );
2701
2702 let mut ret = Self::get_for_version_impl(version, chain);
2703 ret.version = version;
2704 ret.chain = chain;
2705
2706 ret = Self::apply_config_override(version, ret);
2707
2708 if std::env::var("SUI_PROTOCOL_CONFIG_OVERRIDE_ENABLE").is_ok() {
2709 warn!(
2710 "overriding ProtocolConfig settings with custom settings; this may break non-local networks"
2711 );
2712 let overrides: ProtocolConfigOptional =
2713 serde_env::from_env_with_prefix("SUI_PROTOCOL_CONFIG_OVERRIDE")
2714 .expect("failed to parse ProtocolConfig override env variables");
2715 overrides.apply_to(&mut ret);
2716 }
2717
2718 ret
2719 }
2720
2721 pub fn get_for_version_if_supported(version: ProtocolVersion, chain: Chain) -> Option<Self> {
2724 if version.0 >= ProtocolVersion::MIN.0 && version.0 <= ProtocolVersion::MAX_ALLOWED.0 {
2725 let mut ret = Self::get_for_version_impl(version, chain);
2726 ret.version = version;
2727 ret.chain = chain;
2728 ret = Self::apply_config_override(version, ret);
2729 Some(ret)
2730 } else {
2731 None
2732 }
2733 }
2734
2735 pub fn poison_get_for_min_version() {
2736 POISON_VERSION_METHODS.store(true, Ordering::Relaxed);
2737 }
2738
2739 fn load_poison_get_for_min_version() -> bool {
2740 POISON_VERSION_METHODS.load(Ordering::Relaxed)
2741 }
2742
2743 pub fn get_for_min_version() -> Self {
2746 if Self::load_poison_get_for_min_version() {
2747 panic!("get_for_min_version called on validator");
2748 }
2749 ProtocolConfig::get_for_version(ProtocolVersion::MIN, Chain::Unknown)
2750 }
2751
2752 #[allow(non_snake_case)]
2762 pub fn get_for_max_version_UNSAFE() -> Self {
2763 if Self::load_poison_get_for_min_version() {
2764 panic!("get_for_max_version_UNSAFE called on validator");
2765 }
2766 ProtocolConfig::get_for_version(ProtocolVersion::MAX, Chain::Unknown)
2767 }
2768
2769 fn get_for_version_impl(version: ProtocolVersion, chain: Chain) -> Self {
2770 #[cfg(msim)]
2771 {
2772 if version == ProtocolVersion::MAX_ALLOWED {
2774 let mut config = Self::get_for_version_impl(version - 1, Chain::Unknown);
2775 config.base_tx_cost_fixed = Some(config.base_tx_cost_fixed() + 1000);
2776 return config;
2777 }
2778 }
2779
2780 let mut cfg = Self {
2783 version,
2785 chain,
2786
2787 feature_flags: Default::default(),
2789
2790 max_tx_size_bytes: Some(128 * 1024),
2791 max_input_objects: Some(2048),
2793 max_serialized_tx_effects_size_bytes: Some(512 * 1024),
2794 max_serialized_tx_effects_size_bytes_system_tx: Some(512 * 1024 * 16),
2795 max_gas_payment_objects: Some(256),
2796 max_modules_in_publish: Some(128),
2797 max_package_dependencies: None,
2798 max_arguments: Some(512),
2799 max_type_arguments: Some(16),
2800 max_type_argument_depth: Some(16),
2801 max_pure_argument_size: Some(16 * 1024),
2802 max_programmable_tx_commands: Some(1024),
2803 move_binary_format_version: Some(6),
2804 min_move_binary_format_version: None,
2805 binary_module_handles: None,
2806 binary_struct_handles: None,
2807 binary_function_handles: None,
2808 binary_function_instantiations: None,
2809 binary_signatures: None,
2810 binary_constant_pool: None,
2811 binary_identifiers: None,
2812 binary_address_identifiers: None,
2813 binary_struct_defs: None,
2814 binary_struct_def_instantiations: None,
2815 binary_function_defs: None,
2816 binary_field_handles: None,
2817 binary_field_instantiations: None,
2818 binary_friend_decls: None,
2819 binary_enum_defs: None,
2820 binary_enum_def_instantiations: None,
2821 binary_variant_handles: None,
2822 binary_variant_instantiation_handles: None,
2823 binary_format_limits_profile: None,
2824 max_move_object_size: Some(250 * 1024),
2825 max_move_package_size: Some(100 * 1024),
2826 max_publish_or_upgrade_per_ptb: None,
2827 max_tx_gas: Some(10_000_000_000),
2828 max_gas_price: Some(100_000),
2829 max_gas_price_rgp_factor_for_aborted_transactions: None,
2830 max_gas_computation_bucket: Some(5_000_000),
2831 max_loop_depth: Some(5),
2832 max_generic_instantiation_length: Some(32),
2833 max_function_parameters: Some(128),
2834 max_basic_blocks: Some(1024),
2835 max_value_stack_size: Some(1024),
2836 max_type_nodes: Some(256),
2837 max_generic_instantiation_type_nodes_per_function: None,
2838 max_generic_instantiation_type_nodes_per_module: None,
2839 max_accumulator_type_nodes: None,
2840 max_push_size: Some(10000),
2841 max_struct_definitions: Some(200),
2842 max_function_definitions: Some(1000),
2843 max_fields_in_struct: Some(32),
2844 max_dependency_depth: Some(100),
2845 max_num_event_emit: Some(256),
2846 max_num_accumulator_events: None,
2847 max_num_new_move_object_ids: Some(2048),
2848 max_num_new_move_object_ids_system_tx: Some(2048 * 16),
2849 max_num_deleted_move_object_ids: Some(2048),
2850 max_num_deleted_move_object_ids_system_tx: Some(2048 * 16),
2851 max_num_transferred_move_object_ids: Some(2048),
2852 max_num_transferred_move_object_ids_system_tx: Some(2048 * 16),
2853 max_event_emit_size: Some(250 * 1024),
2854 max_move_vector_len: Some(256 * 1024),
2855 max_type_to_layout_nodes: None,
2856 max_ptb_value_size: None,
2857
2858 max_back_edges_per_function: Some(10_000),
2859 max_back_edges_per_module: Some(10_000),
2860 max_verifier_meter_ticks_per_function: Some(6_000_000),
2861 max_meter_ticks_per_module: Some(6_000_000),
2862 max_meter_ticks_per_package: None,
2863
2864 object_runtime_max_num_cached_objects: Some(1000),
2865 object_runtime_max_num_cached_objects_system_tx: Some(1000 * 16),
2866 object_runtime_max_num_store_entries: Some(1000),
2867 object_runtime_max_num_store_entries_system_tx: Some(1000 * 16),
2868 base_tx_cost_fixed: Some(110_000),
2869 package_publish_cost_fixed: Some(1_000),
2870 base_tx_cost_per_byte: Some(0),
2871 package_publish_cost_per_byte: Some(80),
2872 package_publish_charge_fixed: None,
2873 package_publish_charge_per_module: None,
2874 package_publish_charge_per_dependency: None,
2875 obj_access_cost_read_per_byte: Some(15),
2876 obj_access_cost_read_per_package_kb: None,
2877 obj_access_cost_mutate_per_byte: Some(40),
2878 obj_access_cost_delete_per_byte: Some(40),
2879 obj_access_cost_verify_per_byte: Some(200),
2880 obj_data_cost_refundable: Some(100),
2881 obj_metadata_cost_non_refundable: Some(50),
2882 gas_model_version: Some(1),
2883 storage_rebate_rate: Some(9900),
2884 storage_fund_reinvest_rate: Some(500),
2885 reward_slashing_rate: Some(5000),
2886 storage_gas_price: Some(1),
2887 accumulator_object_storage_cost: None,
2888 max_transactions_per_checkpoint: Some(10_000),
2889 max_checkpoint_size_bytes: Some(30 * 1024 * 1024),
2890
2891 buffer_stake_for_protocol_upgrade_bps: Some(0),
2894
2895 address_from_bytes_cost_base: Some(52),
2899 address_to_u256_cost_base: Some(52),
2901 address_from_u256_cost_base: Some(52),
2903
2904 config_read_setting_impl_cost_base: None,
2907 config_read_setting_impl_cost_per_byte: None,
2908
2909 package_original_package_id_impl_cost_base: None,
2910 package_original_package_id_impl_cost_per_byte: None,
2911
2912 dynamic_field_hash_type_and_key_cost_base: Some(100),
2915 dynamic_field_hash_type_and_key_type_cost_per_byte: Some(2),
2916 dynamic_field_hash_type_and_key_value_cost_per_byte: Some(2),
2917 dynamic_field_hash_type_and_key_type_tag_cost_per_byte: Some(2),
2918 dynamic_field_add_child_object_cost_base: Some(100),
2920 dynamic_field_add_child_object_type_cost_per_byte: Some(10),
2921 dynamic_field_add_child_object_value_cost_per_byte: Some(10),
2922 dynamic_field_add_child_object_struct_tag_cost_per_byte: Some(10),
2923 dynamic_field_borrow_child_object_cost_base: Some(100),
2925 dynamic_field_borrow_child_object_child_ref_cost_per_byte: Some(10),
2926 dynamic_field_borrow_child_object_type_cost_per_byte: Some(10),
2927 dynamic_field_remove_child_object_cost_base: Some(100),
2929 dynamic_field_remove_child_object_child_cost_per_byte: Some(2),
2930 dynamic_field_remove_child_object_type_cost_per_byte: Some(2),
2931 dynamic_field_has_child_object_cost_base: Some(100),
2933 dynamic_field_has_child_object_with_ty_cost_base: Some(100),
2935 dynamic_field_has_child_object_with_ty_type_cost_per_byte: Some(2),
2936 dynamic_field_has_child_object_with_ty_type_tag_cost_per_byte: Some(2),
2937
2938 scratch_add_cost_base: None,
2940 scratch_read_cost_base: None,
2941 scratch_read_value_cost: None,
2942 scratch_remove_cost_base: None,
2943 scratch_exists_cost_base: None,
2944 scratch_exists_with_type_cost_base: None,
2945 scratch_exists_with_type_type_cost: None,
2946 max_scratch_pad_size: None,
2947
2948 event_emit_cost_base: Some(52),
2951 event_emit_value_size_derivation_cost_per_byte: Some(2),
2952 event_emit_tag_size_derivation_cost_per_byte: Some(5),
2953 event_emit_output_cost_per_byte: Some(10),
2954 event_emit_auth_stream_cost: None,
2955
2956 reserve_object_funds_for_withdrawal_cost_base: None,
2958 reserve_object_funds_for_withdrawal_cold_read_cost: None,
2959
2960 object_borrow_uid_cost_base: Some(52),
2963 object_delete_impl_cost_base: Some(52),
2965 object_record_new_uid_cost_base: Some(52),
2967 object_record_new_uid_from_hash_cost_base: None,
2970 object_is_shared_input_cost_base: None,
2973
2974 transfer_transfer_internal_cost_base: Some(52),
2977 transfer_party_transfer_internal_cost_base: None,
2979 transfer_freeze_object_cost_base: Some(52),
2981 transfer_share_object_cost_base: Some(52),
2983 transfer_receive_object_cost_base: None,
2984 transfer_receive_object_type_cost_per_byte: None,
2985 transfer_receive_object_cost_per_byte: None,
2986
2987 tx_context_derive_id_cost_base: Some(52),
2990 tx_context_fresh_id_cost_base: None,
2991 tx_context_sender_cost_base: None,
2992 tx_context_epoch_cost_base: None,
2993 tx_context_epoch_timestamp_ms_cost_base: None,
2994 tx_context_sponsor_cost_base: None,
2995 tx_context_rgp_cost_base: None,
2996 tx_context_gas_price_cost_base: None,
2997 tx_context_gas_budget_cost_base: None,
2998 tx_context_ids_created_cost_base: None,
2999 tx_context_replace_cost_base: None,
3000
3001 clock_borrow_cost_base: None,
3003
3004 types_is_one_time_witness_cost_base: Some(52),
3007 types_is_one_time_witness_type_tag_cost_per_byte: Some(2),
3008 types_is_one_time_witness_type_cost_per_byte: Some(2),
3009
3010 validator_validate_metadata_cost_base: Some(52),
3013 validator_validate_metadata_data_cost_per_byte: Some(2),
3014
3015 crypto_invalid_arguments_cost: Some(100),
3017 bls12381_bls12381_min_sig_verify_cost_base: Some(52),
3019 bls12381_bls12381_min_sig_verify_msg_cost_per_byte: Some(2),
3020 bls12381_bls12381_min_sig_verify_msg_cost_per_block: Some(2),
3021
3022 bls12381_bls12381_min_pk_verify_cost_base: Some(52),
3024 bls12381_bls12381_min_pk_verify_msg_cost_per_byte: Some(2),
3025 bls12381_bls12381_min_pk_verify_msg_cost_per_block: Some(2),
3026
3027 ecdsa_k1_ecrecover_keccak256_cost_base: Some(52),
3029 ecdsa_k1_ecrecover_keccak256_msg_cost_per_byte: Some(2),
3030 ecdsa_k1_ecrecover_keccak256_msg_cost_per_block: Some(2),
3031 ecdsa_k1_ecrecover_sha256_cost_base: Some(52),
3032 ecdsa_k1_ecrecover_sha256_msg_cost_per_byte: Some(2),
3033 ecdsa_k1_ecrecover_sha256_msg_cost_per_block: Some(2),
3034
3035 ecdsa_k1_decompress_pubkey_cost_base: Some(52),
3037
3038 ecdsa_k1_secp256k1_verify_keccak256_cost_base: Some(52),
3040 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_byte: Some(2),
3041 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_block: Some(2),
3042 ecdsa_k1_secp256k1_verify_sha256_cost_base: Some(52),
3043 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_byte: Some(2),
3044 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_block: Some(2),
3045
3046 ecdsa_r1_ecrecover_keccak256_cost_base: Some(52),
3048 ecdsa_r1_ecrecover_keccak256_msg_cost_per_byte: Some(2),
3049 ecdsa_r1_ecrecover_keccak256_msg_cost_per_block: Some(2),
3050 ecdsa_r1_ecrecover_sha256_cost_base: Some(52),
3051 ecdsa_r1_ecrecover_sha256_msg_cost_per_byte: Some(2),
3052 ecdsa_r1_ecrecover_sha256_msg_cost_per_block: Some(2),
3053
3054 ecdsa_r1_secp256r1_verify_keccak256_cost_base: Some(52),
3056 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_byte: Some(2),
3057 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_block: Some(2),
3058 ecdsa_r1_secp256r1_verify_sha256_cost_base: Some(52),
3059 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_byte: Some(2),
3060 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_block: Some(2),
3061
3062 ecvrf_ecvrf_verify_cost_base: Some(52),
3064 ecvrf_ecvrf_verify_alpha_string_cost_per_byte: Some(2),
3065 ecvrf_ecvrf_verify_alpha_string_cost_per_block: Some(2),
3066
3067 ed25519_ed25519_verify_cost_base: Some(52),
3069 ed25519_ed25519_verify_msg_cost_per_byte: Some(2),
3070 ed25519_ed25519_verify_msg_cost_per_block: Some(2),
3071
3072 groth16_prepare_verifying_key_bls12381_cost_base: Some(52),
3074 groth16_prepare_verifying_key_bn254_cost_base: Some(52),
3075
3076 groth16_verify_groth16_proof_internal_bls12381_cost_base: Some(52),
3078 groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input: Some(2),
3079 groth16_verify_groth16_proof_internal_bn254_cost_base: Some(52),
3080 groth16_verify_groth16_proof_internal_bn254_cost_per_public_input: Some(2),
3081 groth16_verify_groth16_proof_internal_public_input_cost_per_byte: Some(2),
3082
3083 hash_blake2b256_cost_base: Some(52),
3085 hash_blake2b256_data_cost_per_byte: Some(2),
3086 hash_blake2b256_data_cost_per_block: Some(2),
3087
3088 hash_keccak256_cost_base: Some(52),
3090 hash_keccak256_data_cost_per_byte: Some(2),
3091 hash_keccak256_data_cost_per_block: Some(2),
3092
3093 poseidon_bn254_cost_base: None,
3094 poseidon_bn254_cost_per_block: None,
3095
3096 hmac_hmac_sha3_256_cost_base: Some(52),
3098 hmac_hmac_sha3_256_input_cost_per_byte: Some(2),
3099 hmac_hmac_sha3_256_input_cost_per_block: Some(2),
3100
3101 group_ops_bls12381_decode_scalar_cost: None,
3103 group_ops_bls12381_decode_g1_cost: None,
3104 group_ops_bls12381_decode_g2_cost: None,
3105 group_ops_bls12381_decode_gt_cost: None,
3106 group_ops_bls12381_scalar_add_cost: None,
3107 group_ops_bls12381_g1_add_cost: None,
3108 group_ops_bls12381_g2_add_cost: None,
3109 group_ops_bls12381_gt_add_cost: None,
3110 group_ops_bls12381_scalar_sub_cost: None,
3111 group_ops_bls12381_g1_sub_cost: None,
3112 group_ops_bls12381_g2_sub_cost: None,
3113 group_ops_bls12381_gt_sub_cost: None,
3114 group_ops_bls12381_scalar_mul_cost: None,
3115 group_ops_bls12381_g1_mul_cost: None,
3116 group_ops_bls12381_g2_mul_cost: None,
3117 group_ops_bls12381_gt_mul_cost: None,
3118 group_ops_bls12381_scalar_div_cost: None,
3119 group_ops_bls12381_g1_div_cost: None,
3120 group_ops_bls12381_g2_div_cost: None,
3121 group_ops_bls12381_gt_div_cost: None,
3122 group_ops_bls12381_g1_hash_to_base_cost: None,
3123 group_ops_bls12381_g2_hash_to_base_cost: None,
3124 group_ops_bls12381_g1_hash_to_cost_per_byte: None,
3125 group_ops_bls12381_g2_hash_to_cost_per_byte: None,
3126 group_ops_bls12381_g1_msm_base_cost: None,
3127 group_ops_bls12381_g2_msm_base_cost: None,
3128 group_ops_bls12381_g1_msm_base_cost_per_input: None,
3129 group_ops_bls12381_g2_msm_base_cost_per_input: None,
3130 group_ops_bls12381_msm_max_len: None,
3131 group_ops_bls12381_pairing_cost: None,
3132 group_ops_bls12381_g1_to_uncompressed_g1_cost: None,
3133 group_ops_bls12381_uncompressed_g1_to_g1_cost: None,
3134 group_ops_bls12381_uncompressed_g1_sum_base_cost: None,
3135 group_ops_bls12381_uncompressed_g1_sum_cost_per_term: None,
3136 group_ops_bls12381_uncompressed_g1_sum_max_terms: None,
3137
3138 group_ops_ristretto_decode_scalar_cost: None,
3139 group_ops_ristretto_decode_point_cost: None,
3140 group_ops_ristretto_scalar_add_cost: None,
3141 group_ops_ristretto_point_add_cost: None,
3142 group_ops_ristretto_scalar_sub_cost: None,
3143 group_ops_ristretto_point_sub_cost: None,
3144 group_ops_ristretto_scalar_mul_cost: None,
3145 group_ops_ristretto_point_mul_cost: None,
3146 group_ops_ristretto_scalar_div_cost: None,
3147 group_ops_ristretto_point_div_cost: None,
3148
3149 verify_bulletproofs_ristretto255_base_cost: None,
3150 verify_bulletproofs_ristretto255_cost_per_bit_and_commitment: None,
3151 max_bulletproofs_total_bits: None,
3152
3153 check_zklogin_id_cost_base: None,
3155 check_zklogin_issuer_cost_base: None,
3157
3158 vdf_verify_vdf_cost: None,
3159 vdf_hash_to_input_cost: None,
3160
3161 nitro_attestation_parse_base_cost: None,
3163 nitro_attestation_parse_cost_per_byte: None,
3164 nitro_attestation_verify_base_cost: None,
3165 nitro_attestation_verify_cost_per_cert: None,
3166
3167 layout_node_cost: None,
3168 layout_node_cost_large_layout_threshold: None,
3169 bcs_per_byte_serialized_cost: None,
3170 bcs_legacy_min_output_size_cost: None,
3171 bcs_failure_cost: None,
3172 hash_sha2_256_base_cost: None,
3173 hash_sha2_256_per_byte_cost: None,
3174 hash_sha2_256_legacy_min_input_len_cost: None,
3175 hash_sha3_256_base_cost: None,
3176 hash_sha3_256_per_byte_cost: None,
3177 hash_sha3_256_legacy_min_input_len_cost: None,
3178 type_name_get_base_cost: None,
3179 type_name_get_per_byte_cost: None,
3180 type_name_id_base_cost: None,
3181 string_check_utf8_base_cost: None,
3182 string_check_utf8_per_byte_cost: None,
3183 string_is_char_boundary_base_cost: None,
3184 string_sub_string_base_cost: None,
3185 string_sub_string_per_byte_cost: None,
3186 string_index_of_base_cost: None,
3187 string_index_of_per_byte_pattern_cost: None,
3188 string_index_of_per_byte_searched_cost: None,
3189 vector_empty_base_cost: None,
3190 vector_length_base_cost: None,
3191 vector_push_back_base_cost: None,
3192 vector_push_back_legacy_per_abstract_memory_unit_cost: None,
3193 vector_borrow_base_cost: None,
3194 vector_pop_back_base_cost: None,
3195 vector_destroy_empty_base_cost: None,
3196 vector_swap_base_cost: None,
3197 vector_reverse_base_cost: None,
3198 vector_reverse_per_elem_cost: None,
3199 vector_keep_range_base_cost: None,
3200 vector_keep_range_per_dropped_elem_cost: None,
3201 vector_keep_range_per_moved_elem_cost: None,
3202 vector_copy_range_base_cost: None,
3203 vector_replace_range_base_cost: None,
3204 vector_replace_range_per_elem_cost: None,
3205 debug_print_base_cost: None,
3206 debug_print_stack_trace_base_cost: None,
3207
3208 max_size_written_objects: None,
3209 max_size_written_objects_system_tx: None,
3210
3211 max_move_identifier_len: None,
3218 max_move_value_depth: None,
3219 package_arena_size_in_bytes: None,
3220 max_move_enum_variants: None,
3221
3222 gas_rounding_step: None,
3223
3224 execution_version: None,
3225
3226 max_event_emit_size_total: None,
3227
3228 consensus_bad_nodes_stake_threshold: None,
3229
3230 max_jwk_votes_per_validator_per_epoch: None,
3231
3232 max_age_of_jwk_in_epochs: None,
3233
3234 random_beacon_reduction_allowed_delta: None,
3235
3236 random_beacon_reduction_lower_bound: None,
3237
3238 random_beacon_dkg_timeout_round: None,
3239
3240 random_beacon_min_round_interval_ms: None,
3241
3242 random_beacon_dkg_version: None,
3243
3244 consensus_max_transaction_size_bytes: None,
3245
3246 consensus_max_transactions_in_block_bytes: None,
3247
3248 consensus_max_num_transactions_in_block: None,
3249
3250 consensus_voting_rounds: None,
3251
3252 max_accumulated_txn_cost_per_object_in_narwhal_commit: None,
3253
3254 max_deferral_rounds_for_congestion_control: None,
3255
3256 epoch_close_deadline_ms: None,
3257
3258 max_txn_cost_overage_per_object_in_commit: None,
3259
3260 allowed_txn_cost_overage_burst_per_object_in_commit: None,
3261
3262 min_checkpoint_interval_ms: None,
3263
3264 checkpoint_summary_version_specific_data: None,
3265
3266 max_soft_bundle_size: None,
3267
3268 bridge_should_try_to_finalize_committee: None,
3269
3270 max_accumulated_txn_cost_per_object_in_mysticeti_commit: None,
3271
3272 max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit: None,
3273
3274 consensus_gc_depth: None,
3275
3276 gas_budget_based_txn_cost_cap_factor: None,
3277
3278 gas_budget_based_txn_cost_absolute_cap_commit_count: None,
3279
3280 sip_45_consensus_amplification_threshold: None,
3281 staggered_submission_signal_window_commits: None,
3282 staggered_submission_signal_min_excess_copies_per_commit: None,
3283 staggered_submission_signal_exit_dwell_commits: None,
3284 staggered_submission_signal_band1_enter_ratio_bps: None,
3285 staggered_submission_signal_band1_exit_ratio_bps: None,
3286 staggered_submission_signal_band2_enter_ratio_bps: None,
3287 staggered_submission_signal_band2_exit_ratio_bps: None,
3288
3289 use_object_per_epoch_marker_table_v2: None,
3290
3291 consensus_commit_rate_estimation_window_size: None,
3292
3293 aliased_addresses: vec![],
3294
3295 translation_per_command_base_charge: None,
3296 translation_per_input_base_charge: None,
3297 translation_pure_input_per_byte_charge: None,
3298 translation_per_type_node_charge: None,
3299 translation_per_reference_node_charge: None,
3300 translation_per_linkage_entry_charge: None,
3301 translation_per_live_reference_charge: None,
3302 max_ptb_live_references: None,
3303 max_ptb_returned_references: None,
3304 max_ptb_total_returned_references: None,
3305
3306 max_updates_per_settlement_txn: None,
3307
3308 gasless_max_computation_units: None,
3309 gasless_allowed_token_types: None,
3310 gasless_max_unused_inputs: None,
3311 gasless_max_pure_input_bytes: None,
3312 gasless_max_tps: None,
3313 include_special_package_amendments: None,
3314 gasless_max_tx_size_bytes: None,
3315 };
3318 for cur in 2..=version.0 {
3319 match cur {
3320 1 => unreachable!(),
3321 2 => {
3322 cfg.feature_flags.advance_epoch_start_time_in_safe_mode = true;
3323 }
3324 3 => {
3325 cfg.gas_model_version = Some(2);
3327 cfg.max_tx_gas = Some(50_000_000_000);
3329 cfg.base_tx_cost_fixed = Some(2_000);
3331 cfg.storage_gas_price = Some(76);
3333 cfg.feature_flags.loaded_child_objects_fixed = true;
3334 cfg.max_size_written_objects = Some(5 * 1000 * 1000);
3337 cfg.max_size_written_objects_system_tx = Some(50 * 1000 * 1000);
3340 cfg.feature_flags.package_upgrades = true;
3341 }
3342 4 => {
3347 cfg.reward_slashing_rate = Some(10000);
3349 cfg.gas_model_version = Some(3);
3351 }
3352 5 => {
3353 cfg.feature_flags.missing_type_is_compatibility_error = true;
3354 cfg.gas_model_version = Some(4);
3355 cfg.feature_flags.scoring_decision_with_validity_cutoff = true;
3356 }
3360 6 => {
3361 cfg.gas_model_version = Some(5);
3362 cfg.buffer_stake_for_protocol_upgrade_bps = Some(5000);
3363 cfg.feature_flags.consensus_order_end_of_epoch_last = true;
3364 }
3365 7 => {
3366 cfg.feature_flags.disallow_adding_abilities_on_upgrade = true;
3367 cfg.feature_flags
3368 .disable_invariant_violation_check_in_swap_loc = true;
3369 cfg.feature_flags.ban_entry_init = true;
3370 cfg.feature_flags.package_digest_hash_module = true;
3371 }
3372 8 => {
3373 cfg.feature_flags
3374 .disallow_change_struct_type_params_on_upgrade = true;
3375 }
3376 9 => {
3377 cfg.max_move_identifier_len = Some(128);
3379 cfg.feature_flags.no_extraneous_module_bytes = true;
3380 cfg.feature_flags
3381 .advance_to_highest_supported_protocol_version = true;
3382 }
3383 10 => {
3384 cfg.max_verifier_meter_ticks_per_function = Some(16_000_000);
3385 cfg.max_meter_ticks_per_module = Some(16_000_000);
3386 }
3387 11 => {
3388 cfg.max_move_value_depth = Some(128);
3389 }
3390 12 => {
3391 cfg.feature_flags.narwhal_versioned_metadata = true;
3392 if chain != Chain::Mainnet {
3393 cfg.feature_flags.commit_root_state_digest = true;
3394 }
3395
3396 if chain != Chain::Mainnet && chain != Chain::Testnet {
3397 cfg.feature_flags.zklogin_auth = true;
3398 }
3399 }
3400 13 => {}
3401 14 => {
3402 cfg.gas_rounding_step = Some(1_000);
3403 cfg.gas_model_version = Some(6);
3404 }
3405 15 => {
3406 cfg.feature_flags.consensus_transaction_ordering =
3407 ConsensusTransactionOrdering::ByGasPrice;
3408 }
3409 16 => {
3410 cfg.feature_flags.simplified_unwrap_then_delete = true;
3411 }
3412 17 => {
3413 cfg.feature_flags.upgraded_multisig_supported = true;
3414 }
3415 18 => {
3416 cfg.execution_version = Some(1);
3417 cfg.feature_flags.txn_base_cost_as_multiplier = true;
3426 cfg.base_tx_cost_fixed = Some(1_000);
3428 }
3429 19 => {
3430 cfg.max_num_event_emit = Some(1024);
3431 cfg.max_event_emit_size_total = Some(
3434 256 * 250 * 1024, );
3436 }
3437 20 => {
3438 cfg.feature_flags.commit_root_state_digest = true;
3439
3440 if chain != Chain::Mainnet {
3441 cfg.feature_flags.narwhal_new_leader_election_schedule = true;
3442 cfg.consensus_bad_nodes_stake_threshold = Some(20);
3443 }
3444 }
3445
3446 21 => {
3447 if chain != Chain::Mainnet {
3448 cfg.feature_flags.zklogin_supported_providers = BTreeSet::from([
3449 "Google".to_string(),
3450 "Facebook".to_string(),
3451 "Twitch".to_string(),
3452 ]);
3453 }
3454 }
3455 22 => {
3456 cfg.feature_flags.loaded_child_object_format = true;
3457 }
3458 23 => {
3459 cfg.feature_flags.loaded_child_object_format_type = true;
3460 cfg.feature_flags.narwhal_new_leader_election_schedule = true;
3461 cfg.consensus_bad_nodes_stake_threshold = Some(20);
3467 }
3468 24 => {
3469 cfg.feature_flags.simple_conservation_checks = true;
3470 cfg.max_publish_or_upgrade_per_ptb = Some(5);
3471
3472 cfg.feature_flags.end_of_epoch_transaction_supported = true;
3473
3474 if chain != Chain::Mainnet {
3475 cfg.feature_flags.enable_jwk_consensus_updates = true;
3476 cfg.max_jwk_votes_per_validator_per_epoch = Some(240);
3478 cfg.max_age_of_jwk_in_epochs = Some(1);
3479 }
3480 }
3481 25 => {
3482 cfg.feature_flags.zklogin_supported_providers = BTreeSet::from([
3484 "Google".to_string(),
3485 "Facebook".to_string(),
3486 "Twitch".to_string(),
3487 ]);
3488 cfg.feature_flags.zklogin_auth = true;
3489
3490 cfg.feature_flags.enable_jwk_consensus_updates = true;
3492 cfg.max_jwk_votes_per_validator_per_epoch = Some(240);
3493 cfg.max_age_of_jwk_in_epochs = Some(1);
3494 }
3495 26 => {
3496 cfg.gas_model_version = Some(7);
3497 if chain != Chain::Mainnet && chain != Chain::Testnet {
3499 cfg.transfer_receive_object_cost_base = Some(52);
3500 cfg.feature_flags.receive_objects = true;
3501 }
3502 }
3503 27 => {
3504 cfg.gas_model_version = Some(8);
3505 }
3506 28 => {
3507 cfg.check_zklogin_id_cost_base = Some(200);
3509 cfg.check_zklogin_issuer_cost_base = Some(200);
3511
3512 if chain != Chain::Mainnet && chain != Chain::Testnet {
3514 cfg.feature_flags.enable_effects_v2 = true;
3515 }
3516 }
3517 29 => {
3518 cfg.feature_flags.verify_legacy_zklogin_address = true;
3519 }
3520 30 => {
3521 if chain != Chain::Mainnet {
3523 cfg.feature_flags.narwhal_certificate_v2 = true;
3524 }
3525
3526 cfg.random_beacon_reduction_allowed_delta = Some(800);
3527 if chain != Chain::Mainnet {
3529 cfg.feature_flags.enable_effects_v2 = true;
3530 }
3531
3532 cfg.feature_flags.zklogin_supported_providers = BTreeSet::default();
3536
3537 cfg.feature_flags.recompute_has_public_transfer_in_execution = true;
3538 }
3539 31 => {
3540 cfg.execution_version = Some(2);
3541 if chain != Chain::Mainnet && chain != Chain::Testnet {
3543 cfg.feature_flags.shared_object_deletion = true;
3544 }
3545 }
3546 32 => {
3547 if chain != Chain::Mainnet {
3549 cfg.feature_flags.accept_zklogin_in_multisig = true;
3550 }
3551 if chain != Chain::Mainnet {
3553 cfg.transfer_receive_object_cost_base = Some(52);
3554 cfg.feature_flags.receive_objects = true;
3555 }
3556 if chain != Chain::Mainnet && chain != Chain::Testnet {
3558 cfg.feature_flags.random_beacon = true;
3559 cfg.random_beacon_reduction_lower_bound = Some(1600);
3560 cfg.random_beacon_dkg_timeout_round = Some(3000);
3561 cfg.random_beacon_min_round_interval_ms = Some(150);
3562 }
3563 if chain != Chain::Testnet && chain != Chain::Mainnet {
3565 cfg.feature_flags.include_consensus_digest_in_prologue = true;
3566 }
3567
3568 cfg.feature_flags.narwhal_certificate_v2 = true;
3570 }
3571 33 => {
3572 cfg.feature_flags.hardened_otw_check = true;
3573 cfg.feature_flags.allow_receiving_object_id = true;
3574
3575 cfg.transfer_receive_object_cost_base = Some(52);
3577 cfg.feature_flags.receive_objects = true;
3578
3579 if chain != Chain::Mainnet {
3581 cfg.feature_flags.shared_object_deletion = true;
3582 }
3583
3584 cfg.feature_flags.enable_effects_v2 = true;
3585 }
3586 34 => {}
3587 35 => {
3588 if chain != Chain::Mainnet && chain != Chain::Testnet {
3590 cfg.feature_flags.enable_poseidon = true;
3591 cfg.poseidon_bn254_cost_base = Some(260);
3592 cfg.poseidon_bn254_cost_per_block = Some(10);
3593 }
3594
3595 cfg.feature_flags.enable_coin_deny_list = true;
3596 }
3597 36 => {
3598 if chain != Chain::Mainnet && chain != Chain::Testnet {
3600 cfg.feature_flags.enable_group_ops_native_functions = true;
3601 cfg.feature_flags.enable_group_ops_native_function_msm = true;
3602 cfg.group_ops_bls12381_decode_scalar_cost = Some(52);
3604 cfg.group_ops_bls12381_decode_g1_cost = Some(52);
3605 cfg.group_ops_bls12381_decode_g2_cost = Some(52);
3606 cfg.group_ops_bls12381_decode_gt_cost = Some(52);
3607 cfg.group_ops_bls12381_scalar_add_cost = Some(52);
3608 cfg.group_ops_bls12381_g1_add_cost = Some(52);
3609 cfg.group_ops_bls12381_g2_add_cost = Some(52);
3610 cfg.group_ops_bls12381_gt_add_cost = Some(52);
3611 cfg.group_ops_bls12381_scalar_sub_cost = Some(52);
3612 cfg.group_ops_bls12381_g1_sub_cost = Some(52);
3613 cfg.group_ops_bls12381_g2_sub_cost = Some(52);
3614 cfg.group_ops_bls12381_gt_sub_cost = Some(52);
3615 cfg.group_ops_bls12381_scalar_mul_cost = Some(52);
3616 cfg.group_ops_bls12381_g1_mul_cost = Some(52);
3617 cfg.group_ops_bls12381_g2_mul_cost = Some(52);
3618 cfg.group_ops_bls12381_gt_mul_cost = Some(52);
3619 cfg.group_ops_bls12381_scalar_div_cost = Some(52);
3620 cfg.group_ops_bls12381_g1_div_cost = Some(52);
3621 cfg.group_ops_bls12381_g2_div_cost = Some(52);
3622 cfg.group_ops_bls12381_gt_div_cost = Some(52);
3623 cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(52);
3624 cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(52);
3625 cfg.group_ops_bls12381_g1_hash_to_cost_per_byte = Some(2);
3626 cfg.group_ops_bls12381_g2_hash_to_cost_per_byte = Some(2);
3627 cfg.group_ops_bls12381_g1_msm_base_cost = Some(52);
3628 cfg.group_ops_bls12381_g2_msm_base_cost = Some(52);
3629 cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(52);
3630 cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(52);
3631 cfg.group_ops_bls12381_msm_max_len = Some(32);
3632 cfg.group_ops_bls12381_pairing_cost = Some(52);
3633 }
3634 cfg.feature_flags.shared_object_deletion = true;
3636
3637 cfg.consensus_max_transaction_size_bytes = Some(256 * 1024); cfg.consensus_max_transactions_in_block_bytes = Some(6 * 1_024 * 1024);
3639 }
3641 37 => {
3642 cfg.feature_flags.reject_mutable_random_on_entry_functions = true;
3643
3644 if chain != Chain::Mainnet {
3646 cfg.feature_flags.include_consensus_digest_in_prologue = true;
3647 }
3648 }
3649 38 => {
3650 cfg.binary_module_handles = Some(100);
3651 cfg.binary_struct_handles = Some(300);
3652 cfg.binary_function_handles = Some(1500);
3653 cfg.binary_function_instantiations = Some(750);
3654 cfg.binary_signatures = Some(1000);
3655 cfg.binary_constant_pool = Some(4000);
3659 cfg.binary_identifiers = Some(10000);
3660 cfg.binary_address_identifiers = Some(100);
3661 cfg.binary_struct_defs = Some(200);
3662 cfg.binary_struct_def_instantiations = Some(100);
3663 cfg.binary_function_defs = Some(1000);
3664 cfg.binary_field_handles = Some(500);
3665 cfg.binary_field_instantiations = Some(250);
3666 cfg.binary_friend_decls = Some(100);
3667 cfg.max_package_dependencies = Some(32);
3669 cfg.max_modules_in_publish = Some(64);
3670 cfg.execution_version = Some(3);
3672 }
3673 39 => {
3674 }
3676 40 => {}
3677 41 => {
3678 cfg.feature_flags.enable_group_ops_native_functions = true;
3680 cfg.group_ops_bls12381_decode_scalar_cost = Some(52);
3682 cfg.group_ops_bls12381_decode_g1_cost = Some(52);
3683 cfg.group_ops_bls12381_decode_g2_cost = Some(52);
3684 cfg.group_ops_bls12381_decode_gt_cost = Some(52);
3685 cfg.group_ops_bls12381_scalar_add_cost = Some(52);
3686 cfg.group_ops_bls12381_g1_add_cost = Some(52);
3687 cfg.group_ops_bls12381_g2_add_cost = Some(52);
3688 cfg.group_ops_bls12381_gt_add_cost = Some(52);
3689 cfg.group_ops_bls12381_scalar_sub_cost = Some(52);
3690 cfg.group_ops_bls12381_g1_sub_cost = Some(52);
3691 cfg.group_ops_bls12381_g2_sub_cost = Some(52);
3692 cfg.group_ops_bls12381_gt_sub_cost = Some(52);
3693 cfg.group_ops_bls12381_scalar_mul_cost = Some(52);
3694 cfg.group_ops_bls12381_g1_mul_cost = Some(52);
3695 cfg.group_ops_bls12381_g2_mul_cost = Some(52);
3696 cfg.group_ops_bls12381_gt_mul_cost = Some(52);
3697 cfg.group_ops_bls12381_scalar_div_cost = Some(52);
3698 cfg.group_ops_bls12381_g1_div_cost = Some(52);
3699 cfg.group_ops_bls12381_g2_div_cost = Some(52);
3700 cfg.group_ops_bls12381_gt_div_cost = Some(52);
3701 cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(52);
3702 cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(52);
3703 cfg.group_ops_bls12381_g1_hash_to_cost_per_byte = Some(2);
3704 cfg.group_ops_bls12381_g2_hash_to_cost_per_byte = Some(2);
3705 cfg.group_ops_bls12381_g1_msm_base_cost = Some(52);
3706 cfg.group_ops_bls12381_g2_msm_base_cost = Some(52);
3707 cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(52);
3708 cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(52);
3709 cfg.group_ops_bls12381_msm_max_len = Some(32);
3710 cfg.group_ops_bls12381_pairing_cost = Some(52);
3711 }
3712 42 => {}
3713 43 => {
3714 cfg.feature_flags.zklogin_max_epoch_upper_bound_delta = Some(30);
3715 cfg.max_meter_ticks_per_package = Some(16_000_000);
3716 }
3717 44 => {
3718 cfg.feature_flags.include_consensus_digest_in_prologue = true;
3720 if chain != Chain::Mainnet {
3722 cfg.feature_flags.consensus_choice = ConsensusChoice::SwapEachEpoch;
3723 }
3724 }
3725 45 => {
3726 if chain != Chain::Testnet && chain != Chain::Mainnet {
3728 cfg.feature_flags.consensus_network = ConsensusNetwork::Tonic;
3729 }
3730
3731 if chain != Chain::Mainnet {
3732 cfg.feature_flags.mysticeti_leader_scoring_and_schedule = true;
3734 }
3735 cfg.min_move_binary_format_version = Some(6);
3736 cfg.feature_flags.accept_zklogin_in_multisig = true;
3737
3738 if chain != Chain::Mainnet && chain != Chain::Testnet {
3742 cfg.feature_flags.bridge = true;
3743 }
3744 }
3745 46 => {
3746 if chain != Chain::Mainnet {
3748 cfg.feature_flags.bridge = true;
3749 }
3750
3751 cfg.feature_flags.reshare_at_same_initial_version = true;
3753 }
3754 47 => {}
3755 48 => {
3756 cfg.feature_flags.consensus_network = ConsensusNetwork::Tonic;
3758
3759 cfg.feature_flags.resolve_abort_locations_to_package_id = true;
3761
3762 if chain != Chain::Mainnet {
3764 cfg.feature_flags.random_beacon = true;
3765 cfg.random_beacon_reduction_lower_bound = Some(1600);
3766 cfg.random_beacon_dkg_timeout_round = Some(3000);
3767 cfg.random_beacon_min_round_interval_ms = Some(200);
3768 }
3769
3770 cfg.feature_flags.mysticeti_use_committed_subdag_digest = true;
3772 }
3773 49 => {
3774 if chain != Chain::Testnet && chain != Chain::Mainnet {
3775 cfg.move_binary_format_version = Some(7);
3776 }
3777
3778 if chain != Chain::Mainnet && chain != Chain::Testnet {
3780 cfg.feature_flags.enable_vdf = true;
3781 cfg.vdf_verify_vdf_cost = Some(1500);
3784 cfg.vdf_hash_to_input_cost = Some(100);
3785 }
3786
3787 if chain != Chain::Testnet && chain != Chain::Mainnet {
3789 cfg.feature_flags
3790 .record_consensus_determined_version_assignments_in_prologue = true;
3791 }
3792
3793 if chain != Chain::Mainnet {
3795 cfg.feature_flags.consensus_choice = ConsensusChoice::Mysticeti;
3796 }
3797
3798 cfg.feature_flags.fresh_vm_on_framework_upgrade = true;
3800 }
3801 50 => {
3802 if chain != Chain::Mainnet {
3804 cfg.checkpoint_summary_version_specific_data = Some(1);
3805 cfg.min_checkpoint_interval_ms = Some(200);
3806 }
3807
3808 if chain != Chain::Testnet && chain != Chain::Mainnet {
3810 cfg.feature_flags
3811 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3812 }
3813
3814 cfg.feature_flags.mysticeti_num_leaders_per_round = Some(1);
3815
3816 cfg.max_deferral_rounds_for_congestion_control = Some(10);
3818 }
3819 51 => {
3820 cfg.random_beacon_dkg_version = Some(1);
3821
3822 if chain != Chain::Testnet && chain != Chain::Mainnet {
3823 cfg.feature_flags.enable_coin_deny_list_v2 = true;
3824 }
3825 }
3826 52 => {
3827 if chain != Chain::Mainnet {
3828 cfg.feature_flags.soft_bundle = true;
3829 cfg.max_soft_bundle_size = Some(5);
3830 }
3831
3832 cfg.config_read_setting_impl_cost_base = Some(100);
3833 cfg.config_read_setting_impl_cost_per_byte = Some(40);
3834
3835 if chain != Chain::Testnet && chain != Chain::Mainnet {
3837 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3838 cfg.feature_flags.per_object_congestion_control_mode =
3839 PerObjectCongestionControlMode::TotalTxCount;
3840 }
3841
3842 cfg.feature_flags.consensus_choice = ConsensusChoice::Mysticeti;
3844
3845 cfg.feature_flags.mysticeti_leader_scoring_and_schedule = true;
3847
3848 cfg.checkpoint_summary_version_specific_data = Some(1);
3850 cfg.min_checkpoint_interval_ms = Some(200);
3851
3852 if chain != Chain::Mainnet {
3854 cfg.feature_flags
3855 .record_consensus_determined_version_assignments_in_prologue = true;
3856 cfg.feature_flags
3857 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3858 }
3859 if chain != Chain::Mainnet {
3861 cfg.move_binary_format_version = Some(7);
3862 }
3863
3864 if chain != Chain::Testnet && chain != Chain::Mainnet {
3865 cfg.feature_flags.passkey_auth = true;
3866 }
3867 cfg.feature_flags.enable_coin_deny_list_v2 = true;
3868 }
3869 53 => {
3870 cfg.bridge_should_try_to_finalize_committee = Some(chain != Chain::Mainnet);
3872
3873 cfg.feature_flags
3875 .record_consensus_determined_version_assignments_in_prologue = true;
3876 cfg.feature_flags
3877 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3878
3879 if chain == Chain::Unknown {
3880 cfg.feature_flags.authority_capabilities_v2 = true;
3881 }
3882
3883 if chain != Chain::Mainnet {
3885 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3886 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(10);
3887 cfg.feature_flags.per_object_congestion_control_mode =
3888 PerObjectCongestionControlMode::TotalTxCount;
3889 }
3890
3891 cfg.bcs_per_byte_serialized_cost = Some(2);
3893 cfg.bcs_legacy_min_output_size_cost = Some(1);
3894 cfg.bcs_failure_cost = Some(52);
3895 cfg.debug_print_base_cost = Some(52);
3896 cfg.debug_print_stack_trace_base_cost = Some(52);
3897 cfg.hash_sha2_256_base_cost = Some(52);
3898 cfg.hash_sha2_256_per_byte_cost = Some(2);
3899 cfg.hash_sha2_256_legacy_min_input_len_cost = Some(1);
3900 cfg.hash_sha3_256_base_cost = Some(52);
3901 cfg.hash_sha3_256_per_byte_cost = Some(2);
3902 cfg.hash_sha3_256_legacy_min_input_len_cost = Some(1);
3903 cfg.type_name_get_base_cost = Some(52);
3904 cfg.type_name_get_per_byte_cost = Some(2);
3905 cfg.string_check_utf8_base_cost = Some(52);
3906 cfg.string_check_utf8_per_byte_cost = Some(2);
3907 cfg.string_is_char_boundary_base_cost = Some(52);
3908 cfg.string_sub_string_base_cost = Some(52);
3909 cfg.string_sub_string_per_byte_cost = Some(2);
3910 cfg.string_index_of_base_cost = Some(52);
3911 cfg.string_index_of_per_byte_pattern_cost = Some(2);
3912 cfg.string_index_of_per_byte_searched_cost = Some(2);
3913 cfg.vector_empty_base_cost = Some(52);
3914 cfg.vector_length_base_cost = Some(52);
3915 cfg.vector_push_back_base_cost = Some(52);
3916 cfg.vector_push_back_legacy_per_abstract_memory_unit_cost = Some(2);
3917 cfg.vector_borrow_base_cost = Some(52);
3918 cfg.vector_pop_back_base_cost = Some(52);
3919 cfg.vector_destroy_empty_base_cost = Some(52);
3920 cfg.vector_swap_base_cost = Some(52);
3921 }
3922 54 => {
3923 cfg.feature_flags.random_beacon = true;
3925 cfg.random_beacon_reduction_lower_bound = Some(1000);
3926 cfg.random_beacon_dkg_timeout_round = Some(3000);
3927 cfg.random_beacon_min_round_interval_ms = Some(500);
3928
3929 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3931 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(10);
3932 cfg.feature_flags.per_object_congestion_control_mode =
3933 PerObjectCongestionControlMode::TotalTxCount;
3934
3935 cfg.feature_flags.soft_bundle = true;
3937 cfg.max_soft_bundle_size = Some(5);
3938 }
3939 55 => {
3940 cfg.move_binary_format_version = Some(7);
3942
3943 cfg.consensus_max_transactions_in_block_bytes = Some(512 * 1024);
3945 cfg.consensus_max_num_transactions_in_block = Some(512);
3948
3949 cfg.feature_flags.rethrow_serialization_type_layout_errors = true;
3950 }
3951 56 => {
3952 if chain == Chain::Mainnet {
3953 cfg.feature_flags.bridge = true;
3954 }
3955 }
3956 57 => {
3957 cfg.random_beacon_reduction_lower_bound = Some(800);
3959 }
3960 58 => {
3961 if chain == Chain::Mainnet {
3962 cfg.bridge_should_try_to_finalize_committee = Some(true);
3963 }
3964
3965 if chain != Chain::Mainnet && chain != Chain::Testnet {
3966 cfg.feature_flags
3968 .consensus_distributed_vote_scoring_strategy = true;
3969 }
3970 }
3971 59 => {
3972 cfg.feature_flags.consensus_round_prober = true;
3974 }
3975 60 => {
3976 cfg.max_type_to_layout_nodes = Some(512);
3977 cfg.feature_flags.validate_identifier_inputs = true;
3978 }
3979 61 => {
3980 if chain != Chain::Mainnet {
3981 cfg.feature_flags
3983 .consensus_distributed_vote_scoring_strategy = true;
3984 }
3985 cfg.random_beacon_reduction_lower_bound = Some(700);
3987
3988 if chain != Chain::Mainnet && chain != Chain::Testnet {
3989 cfg.feature_flags.mysticeti_fastpath = true;
3991 }
3992 }
3993 62 => {
3994 cfg.feature_flags.relocate_event_module = true;
3995 }
3996 63 => {
3997 cfg.feature_flags.per_object_congestion_control_mode =
3998 PerObjectCongestionControlMode::TotalGasBudgetWithCap;
3999 cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4000 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(18_500_000);
4001 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(240_000_000);
4002 }
4003 64 => {
4004 cfg.feature_flags.per_object_congestion_control_mode =
4005 PerObjectCongestionControlMode::TotalTxCount;
4006 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(40);
4007 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(3);
4008 }
4009 65 => {
4010 cfg.feature_flags
4012 .consensus_distributed_vote_scoring_strategy = true;
4013 }
4014 66 => {
4015 if chain == Chain::Mainnet {
4016 cfg.feature_flags
4018 .consensus_distributed_vote_scoring_strategy = false;
4019 }
4020 }
4021 67 => {
4022 cfg.feature_flags
4024 .consensus_distributed_vote_scoring_strategy = true;
4025 }
4026 68 => {
4027 cfg.group_ops_bls12381_g1_to_uncompressed_g1_cost = Some(26);
4028 cfg.group_ops_bls12381_uncompressed_g1_to_g1_cost = Some(52);
4029 cfg.group_ops_bls12381_uncompressed_g1_sum_base_cost = Some(26);
4030 cfg.group_ops_bls12381_uncompressed_g1_sum_cost_per_term = Some(13);
4031 cfg.group_ops_bls12381_uncompressed_g1_sum_max_terms = Some(2000);
4032
4033 if chain != Chain::Mainnet && chain != Chain::Testnet {
4034 cfg.feature_flags.uncompressed_g1_group_elements = true;
4035 }
4036
4037 cfg.feature_flags.per_object_congestion_control_mode =
4038 PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4039 cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4040 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(18_500_000);
4041 cfg.max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit =
4042 Some(3_700_000); cfg.max_txn_cost_overage_per_object_in_commit = Some(u64::MAX);
4044 cfg.gas_budget_based_txn_cost_absolute_cap_commit_count = Some(50);
4045
4046 cfg.random_beacon_reduction_lower_bound = Some(500);
4048
4049 cfg.feature_flags.disallow_new_modules_in_deps_only_packages = true;
4050 }
4051 69 => {
4052 cfg.consensus_voting_rounds = Some(40);
4054
4055 if chain != Chain::Mainnet && chain != Chain::Testnet {
4056 cfg.feature_flags.consensus_smart_ancestor_selection = true;
4058 }
4059
4060 if chain != Chain::Mainnet {
4061 cfg.feature_flags.uncompressed_g1_group_elements = true;
4062 }
4063 }
4064 70 => {
4065 if chain != Chain::Mainnet {
4066 cfg.feature_flags.consensus_smart_ancestor_selection = true;
4068 cfg.feature_flags
4070 .consensus_round_prober_probe_accepted_rounds = true;
4071 }
4072
4073 cfg.poseidon_bn254_cost_per_block = Some(388);
4074
4075 cfg.gas_model_version = Some(9);
4076 cfg.feature_flags.native_charging_v2 = true;
4077 cfg.bls12381_bls12381_min_sig_verify_cost_base = Some(44064);
4078 cfg.bls12381_bls12381_min_pk_verify_cost_base = Some(49282);
4079 cfg.ecdsa_k1_secp256k1_verify_keccak256_cost_base = Some(1470);
4080 cfg.ecdsa_k1_secp256k1_verify_sha256_cost_base = Some(1470);
4081 cfg.ecdsa_r1_secp256r1_verify_sha256_cost_base = Some(4225);
4082 cfg.ecdsa_r1_secp256r1_verify_keccak256_cost_base = Some(4225);
4083 cfg.ecvrf_ecvrf_verify_cost_base = Some(4848);
4084 cfg.ed25519_ed25519_verify_cost_base = Some(1802);
4085
4086 cfg.ecdsa_r1_ecrecover_keccak256_cost_base = Some(1173);
4088 cfg.ecdsa_r1_ecrecover_sha256_cost_base = Some(1173);
4089 cfg.ecdsa_k1_ecrecover_keccak256_cost_base = Some(500);
4090 cfg.ecdsa_k1_ecrecover_sha256_cost_base = Some(500);
4091
4092 cfg.groth16_prepare_verifying_key_bls12381_cost_base = Some(53838);
4093 cfg.groth16_prepare_verifying_key_bn254_cost_base = Some(82010);
4094 cfg.groth16_verify_groth16_proof_internal_bls12381_cost_base = Some(72090);
4095 cfg.groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input =
4096 Some(8213);
4097 cfg.groth16_verify_groth16_proof_internal_bn254_cost_base = Some(115502);
4098 cfg.groth16_verify_groth16_proof_internal_bn254_cost_per_public_input =
4099 Some(9484);
4100
4101 cfg.hash_keccak256_cost_base = Some(10);
4102 cfg.hash_blake2b256_cost_base = Some(10);
4103
4104 cfg.group_ops_bls12381_decode_scalar_cost = Some(7);
4106 cfg.group_ops_bls12381_decode_g1_cost = Some(2848);
4107 cfg.group_ops_bls12381_decode_g2_cost = Some(3770);
4108 cfg.group_ops_bls12381_decode_gt_cost = Some(3068);
4109
4110 cfg.group_ops_bls12381_scalar_add_cost = Some(10);
4111 cfg.group_ops_bls12381_g1_add_cost = Some(1556);
4112 cfg.group_ops_bls12381_g2_add_cost = Some(3048);
4113 cfg.group_ops_bls12381_gt_add_cost = Some(188);
4114
4115 cfg.group_ops_bls12381_scalar_sub_cost = Some(10);
4116 cfg.group_ops_bls12381_g1_sub_cost = Some(1550);
4117 cfg.group_ops_bls12381_g2_sub_cost = Some(3019);
4118 cfg.group_ops_bls12381_gt_sub_cost = Some(497);
4119
4120 cfg.group_ops_bls12381_scalar_mul_cost = Some(11);
4121 cfg.group_ops_bls12381_g1_mul_cost = Some(4842);
4122 cfg.group_ops_bls12381_g2_mul_cost = Some(9108);
4123 cfg.group_ops_bls12381_gt_mul_cost = Some(27490);
4124
4125 cfg.group_ops_bls12381_scalar_div_cost = Some(91);
4126 cfg.group_ops_bls12381_g1_div_cost = Some(5091);
4127 cfg.group_ops_bls12381_g2_div_cost = Some(9206);
4128 cfg.group_ops_bls12381_gt_div_cost = Some(27804);
4129
4130 cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(2962);
4131 cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(8688);
4132
4133 cfg.group_ops_bls12381_g1_msm_base_cost = Some(62648);
4134 cfg.group_ops_bls12381_g2_msm_base_cost = Some(131192);
4135 cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(1333);
4136 cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(3216);
4137
4138 cfg.group_ops_bls12381_uncompressed_g1_to_g1_cost = Some(677);
4139 cfg.group_ops_bls12381_g1_to_uncompressed_g1_cost = Some(2099);
4140 cfg.group_ops_bls12381_uncompressed_g1_sum_base_cost = Some(77);
4141 cfg.group_ops_bls12381_uncompressed_g1_sum_cost_per_term = Some(26);
4142
4143 cfg.group_ops_bls12381_pairing_cost = Some(26897);
4144 cfg.group_ops_bls12381_uncompressed_g1_sum_max_terms = Some(1200);
4145
4146 cfg.validator_validate_metadata_cost_base = Some(20000);
4147 }
4148 71 => {
4149 cfg.sip_45_consensus_amplification_threshold = Some(5);
4150
4151 cfg.allowed_txn_cost_overage_burst_per_object_in_commit = Some(185_000_000);
4153 }
4154 72 => {
4155 cfg.feature_flags.convert_type_argument_error = true;
4156
4157 cfg.max_tx_gas = Some(50_000_000_000_000);
4160 cfg.max_gas_price = Some(50_000_000_000);
4162
4163 cfg.feature_flags.variant_nodes = true;
4164 }
4165 73 => {
4166 cfg.use_object_per_epoch_marker_table_v2 = Some(true);
4168
4169 if chain != Chain::Mainnet && chain != Chain::Testnet {
4170 cfg.consensus_gc_depth = Some(60);
4173 }
4174
4175 if chain != Chain::Mainnet {
4176 cfg.feature_flags.consensus_zstd_compression = true;
4178 }
4179
4180 cfg.feature_flags.consensus_smart_ancestor_selection = true;
4182 cfg.feature_flags
4184 .consensus_round_prober_probe_accepted_rounds = true;
4185
4186 cfg.feature_flags.per_object_congestion_control_mode =
4188 PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4189 cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4190 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(37_000_000);
4191 cfg.max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit =
4192 Some(7_400_000); cfg.max_txn_cost_overage_per_object_in_commit = Some(u64::MAX);
4194 cfg.gas_budget_based_txn_cost_absolute_cap_commit_count = Some(50);
4195 cfg.allowed_txn_cost_overage_burst_per_object_in_commit = Some(370_000_000);
4196 }
4197 74 => {
4198 if chain != Chain::Mainnet && chain != Chain::Testnet {
4200 cfg.feature_flags.enable_nitro_attestation = true;
4201 }
4202 cfg.nitro_attestation_parse_base_cost = Some(53 * 50);
4203 cfg.nitro_attestation_parse_cost_per_byte = Some(50);
4204 cfg.nitro_attestation_verify_base_cost = Some(49632 * 50);
4205 cfg.nitro_attestation_verify_cost_per_cert = Some(52369 * 50);
4206
4207 cfg.feature_flags.consensus_zstd_compression = true;
4209
4210 if chain != Chain::Mainnet && chain != Chain::Testnet {
4211 cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4212 }
4213 }
4214 75 => {
4215 if chain != Chain::Mainnet {
4216 cfg.feature_flags.passkey_auth = true;
4217 }
4218 }
4219 76 => {
4220 if chain != Chain::Mainnet && chain != Chain::Testnet {
4221 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4222 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4223 }
4224 cfg.feature_flags.minimize_child_object_mutations = true;
4225
4226 if chain != Chain::Mainnet {
4227 cfg.feature_flags.accept_passkey_in_multisig = true;
4228 }
4229 }
4230 77 => {
4231 cfg.feature_flags.uncompressed_g1_group_elements = true;
4232
4233 if chain != Chain::Mainnet {
4234 cfg.consensus_gc_depth = Some(60);
4235 cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4236 }
4237 }
4238 78 => {
4239 cfg.feature_flags.move_native_context = true;
4240 cfg.tx_context_fresh_id_cost_base = Some(52);
4241 cfg.tx_context_sender_cost_base = Some(30);
4242 cfg.tx_context_epoch_cost_base = Some(30);
4243 cfg.tx_context_epoch_timestamp_ms_cost_base = Some(30);
4244 cfg.tx_context_sponsor_cost_base = Some(30);
4245 cfg.tx_context_gas_price_cost_base = Some(30);
4246 cfg.tx_context_gas_budget_cost_base = Some(30);
4247 cfg.tx_context_ids_created_cost_base = Some(30);
4248 cfg.tx_context_replace_cost_base = Some(30);
4249 cfg.gas_model_version = Some(10);
4250
4251 if chain != Chain::Mainnet {
4252 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4253 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4254
4255 cfg.feature_flags.per_object_congestion_control_mode =
4257 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4258 ExecutionTimeEstimateParams {
4259 target_utilization: 30,
4260 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4262 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4264 stored_observations_limit: u64::MAX,
4265 stake_weighted_median_threshold: 0,
4266 default_none_duration_for_new_keys: false,
4267 observations_chunk_size: None,
4268 },
4269 );
4270 }
4271 }
4272 79 => {
4273 if chain != Chain::Mainnet {
4274 cfg.feature_flags.consensus_median_based_commit_timestamp = true;
4275
4276 cfg.consensus_bad_nodes_stake_threshold = Some(30);
4279
4280 cfg.feature_flags.consensus_batched_block_sync = true;
4281
4282 cfg.feature_flags.enable_nitro_attestation = true
4284 }
4285 cfg.feature_flags.normalize_ptb_arguments = true;
4286
4287 cfg.consensus_gc_depth = Some(60);
4288 cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4289 }
4290 80 => {
4291 cfg.max_ptb_value_size = Some(1024 * 1024);
4292 }
4293 81 => {
4294 cfg.feature_flags.consensus_median_based_commit_timestamp = true;
4295 cfg.feature_flags.enforce_checkpoint_timestamp_monotonicity = true;
4296 cfg.consensus_bad_nodes_stake_threshold = Some(30)
4297 }
4298 82 => {
4299 cfg.feature_flags.max_ptb_value_size_v2 = true;
4300 }
4301 83 => {
4302 if chain == Chain::Mainnet {
4303 let aliased: [u8; 32] = Hex::decode(
4305 "0x0b2da327ba6a4cacbe75dddd50e6e8bbf81d6496e92d66af9154c61c77f7332f",
4306 )
4307 .unwrap()
4308 .try_into()
4309 .unwrap();
4310
4311 cfg.aliased_addresses.push(AliasedAddress {
4313 original: Hex::decode("0xcd8962dad278d8b50fa0f9eb0186bfa4cbdecc6d59377214c88d0286a0ac9562").unwrap().try_into().unwrap(),
4314 aliased,
4315 allowed_tx_digests: vec![
4316 Base58::decode("B2eGLFoMHgj93Ni8dAJBfqGzo8EWSTLBesZzhEpTPA4").unwrap().try_into().unwrap(),
4317 ],
4318 });
4319
4320 cfg.aliased_addresses.push(AliasedAddress {
4321 original: Hex::decode("0xe28b50cef1d633ea43d3296a3f6b67ff0312a5f1a99f0af753c85b8b5de8ff06").unwrap().try_into().unwrap(),
4322 aliased,
4323 allowed_tx_digests: vec![
4324 Base58::decode("J4QqSAgp7VrQtQpMy5wDX4QGsCSEZu3U5KuDAkbESAge").unwrap().try_into().unwrap(),
4325 ],
4326 });
4327 }
4328
4329 if chain != Chain::Mainnet {
4332 cfg.feature_flags.resolve_type_input_ids_to_defining_id = true;
4333 cfg.transfer_party_transfer_internal_cost_base = Some(52);
4334
4335 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4337 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4338 cfg.feature_flags.per_object_congestion_control_mode =
4339 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4340 ExecutionTimeEstimateParams {
4341 target_utilization: 30,
4342 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4344 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4346 stored_observations_limit: u64::MAX,
4347 stake_weighted_median_threshold: 0,
4348 default_none_duration_for_new_keys: false,
4349 observations_chunk_size: None,
4350 },
4351 );
4352
4353 cfg.feature_flags.consensus_batched_block_sync = true;
4355
4356 cfg.feature_flags.enable_nitro_attestation_upgraded_parsing = true;
4359 cfg.feature_flags.enable_nitro_attestation = true;
4360 }
4361 }
4362 84 => {
4363 if chain == Chain::Mainnet {
4364 cfg.feature_flags.resolve_type_input_ids_to_defining_id = true;
4365 cfg.transfer_party_transfer_internal_cost_base = Some(52);
4366
4367 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4369 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4370 cfg.feature_flags.per_object_congestion_control_mode =
4371 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4372 ExecutionTimeEstimateParams {
4373 target_utilization: 30,
4374 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4376 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4378 stored_observations_limit: u64::MAX,
4379 stake_weighted_median_threshold: 0,
4380 default_none_duration_for_new_keys: false,
4381 observations_chunk_size: None,
4382 },
4383 );
4384
4385 cfg.feature_flags.consensus_batched_block_sync = true;
4387
4388 cfg.feature_flags.enable_nitro_attestation_upgraded_parsing = true;
4391 cfg.feature_flags.enable_nitro_attestation = true;
4392 }
4393
4394 cfg.feature_flags.per_object_congestion_control_mode =
4396 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4397 ExecutionTimeEstimateParams {
4398 target_utilization: 30,
4399 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4401 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4403 stored_observations_limit: 20,
4404 stake_weighted_median_threshold: 0,
4405 default_none_duration_for_new_keys: false,
4406 observations_chunk_size: None,
4407 },
4408 );
4409 cfg.feature_flags.allow_unbounded_system_objects = true;
4410 }
4411 85 => {
4412 if chain != Chain::Mainnet && chain != Chain::Testnet {
4413 cfg.feature_flags.enable_party_transfer = true;
4414 }
4415
4416 cfg.feature_flags
4417 .record_consensus_determined_version_assignments_in_prologue_v2 = true;
4418 cfg.feature_flags.disallow_self_identifier = true;
4419 cfg.feature_flags.per_object_congestion_control_mode =
4420 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4421 ExecutionTimeEstimateParams {
4422 target_utilization: 50,
4423 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4425 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4427 stored_observations_limit: 20,
4428 stake_weighted_median_threshold: 0,
4429 default_none_duration_for_new_keys: false,
4430 observations_chunk_size: None,
4431 },
4432 );
4433 }
4434 86 => {
4435 cfg.feature_flags.type_tags_in_object_runtime = true;
4436 cfg.max_move_enum_variants = Some(move_core_types::VARIANT_COUNT_MAX);
4437
4438 cfg.feature_flags.per_object_congestion_control_mode =
4440 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4441 ExecutionTimeEstimateParams {
4442 target_utilization: 50,
4443 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4445 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4447 stored_observations_limit: 20,
4448 stake_weighted_median_threshold: 3334,
4449 default_none_duration_for_new_keys: false,
4450 observations_chunk_size: None,
4451 },
4452 );
4453 if chain != Chain::Mainnet {
4455 cfg.feature_flags.enable_party_transfer = true;
4456 }
4457 }
4458 87 => {
4459 if chain == Chain::Mainnet {
4460 cfg.feature_flags.record_time_estimate_processed = true;
4461 }
4462 cfg.feature_flags.better_adapter_type_resolution_errors = true;
4463 }
4464 88 => {
4465 cfg.feature_flags.record_time_estimate_processed = true;
4466 cfg.tx_context_rgp_cost_base = Some(30);
4467 cfg.feature_flags
4468 .ignore_execution_time_observations_after_certs_closed = true;
4469
4470 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: true,
4483 observations_chunk_size: None,
4484 },
4485 );
4486 }
4487 89 => {
4488 cfg.feature_flags.dependency_linkage_error = true;
4489 cfg.feature_flags.additional_multisig_checks = true;
4490 }
4491 90 => {
4492 cfg.max_gas_price_rgp_factor_for_aborted_transactions = Some(100);
4494 cfg.feature_flags.debug_fatal_on_move_invariant_violation = true;
4495 cfg.feature_flags.additional_consensus_digest_indirect_state = true;
4496 cfg.feature_flags.accept_passkey_in_multisig = true;
4497 cfg.feature_flags.passkey_auth = true;
4498 cfg.feature_flags.check_for_init_during_upgrade = true;
4499
4500 if chain != Chain::Mainnet {
4502 cfg.feature_flags.mysticeti_fastpath = true;
4503 }
4504 }
4505 91 => {
4506 cfg.feature_flags.per_command_shared_object_transfer_rules = true;
4507 }
4508 92 => {
4509 cfg.feature_flags.per_command_shared_object_transfer_rules = false;
4510 }
4511 93 => {
4512 cfg.feature_flags
4513 .consensus_checkpoint_signature_key_includes_digest = true;
4514 }
4515 94 => {
4516 cfg.feature_flags.per_object_congestion_control_mode =
4518 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4519 ExecutionTimeEstimateParams {
4520 target_utilization: 50,
4521 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4523 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4525 stored_observations_limit: 18,
4526 stake_weighted_median_threshold: 3334,
4527 default_none_duration_for_new_keys: true,
4528 observations_chunk_size: None,
4529 },
4530 );
4531
4532 cfg.feature_flags.enable_party_transfer = true;
4534 }
4535 95 => {
4536 cfg.type_name_id_base_cost = Some(52);
4537
4538 cfg.max_transactions_per_checkpoint = Some(20_000);
4540 }
4541 96 => {
4542 if chain != Chain::Mainnet && chain != Chain::Testnet {
4544 cfg.feature_flags
4545 .include_checkpoint_artifacts_digest_in_summary = true;
4546 }
4547 cfg.feature_flags.correct_gas_payment_limit_check = true;
4548 cfg.feature_flags.authority_capabilities_v2 = true;
4549 cfg.feature_flags.use_mfp_txns_in_load_initial_object_debts = true;
4550 cfg.feature_flags.cancel_for_failed_dkg_early = true;
4551 cfg.feature_flags.enable_coin_registry = true;
4552
4553 cfg.feature_flags.mysticeti_fastpath = true;
4555 }
4556 97 => {
4557 cfg.feature_flags.additional_borrow_checks = true;
4558 }
4559 98 => {
4560 cfg.event_emit_auth_stream_cost = Some(52);
4561 cfg.feature_flags.better_loader_errors = true;
4562 cfg.feature_flags.generate_df_type_layouts = true;
4563 }
4564 99 => {
4565 cfg.feature_flags.use_new_commit_handler = true;
4566 }
4567 100 => {
4568 cfg.feature_flags.private_generics_verifier_v2 = true;
4569 }
4570 101 => {
4571 cfg.feature_flags.create_root_accumulator_object = true;
4572 cfg.max_updates_per_settlement_txn = Some(100);
4573 if chain != Chain::Mainnet {
4574 cfg.feature_flags.enable_poseidon = true;
4575 }
4576 }
4577 102 => {
4578 cfg.feature_flags.per_object_congestion_control_mode =
4582 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4583 ExecutionTimeEstimateParams {
4584 target_utilization: 50,
4585 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4587 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4589 stored_observations_limit: 180,
4590 stake_weighted_median_threshold: 3334,
4591 default_none_duration_for_new_keys: true,
4592 observations_chunk_size: Some(18),
4593 },
4594 );
4595 cfg.feature_flags.deprecate_global_storage_ops = true;
4596 }
4597 103 => {}
4598 104 => {
4599 cfg.translation_per_command_base_charge = Some(1);
4600 cfg.translation_per_input_base_charge = Some(1);
4601 cfg.translation_pure_input_per_byte_charge = Some(1);
4602 cfg.translation_per_type_node_charge = Some(1);
4603 cfg.translation_per_reference_node_charge = Some(1);
4604 cfg.translation_per_linkage_entry_charge = Some(10);
4605 cfg.gas_model_version = Some(11);
4606 cfg.feature_flags.abstract_size_in_object_runtime = true;
4607 cfg.feature_flags.object_runtime_charge_cache_load_gas = true;
4608 cfg.dynamic_field_hash_type_and_key_cost_base = Some(52);
4609 cfg.dynamic_field_add_child_object_cost_base = Some(52);
4610 cfg.dynamic_field_add_child_object_value_cost_per_byte = Some(1);
4611 cfg.dynamic_field_borrow_child_object_cost_base = Some(52);
4612 cfg.dynamic_field_borrow_child_object_child_ref_cost_per_byte = Some(1);
4613 cfg.dynamic_field_remove_child_object_cost_base = Some(52);
4614 cfg.dynamic_field_remove_child_object_child_cost_per_byte = Some(1);
4615 cfg.dynamic_field_has_child_object_cost_base = Some(52);
4616 cfg.dynamic_field_has_child_object_with_ty_cost_base = Some(52);
4617 cfg.feature_flags.enable_ptb_execution_v2 = true;
4618
4619 cfg.poseidon_bn254_cost_base = Some(260);
4620
4621 cfg.feature_flags.consensus_skip_gced_accept_votes = true;
4622
4623 if chain != Chain::Mainnet {
4624 cfg.feature_flags
4625 .enable_nitro_attestation_all_nonzero_pcrs_parsing = true;
4626 }
4627
4628 cfg.feature_flags
4629 .include_cancelled_randomness_txns_in_prologue = true;
4630 }
4631 105 => {
4632 cfg.feature_flags.enable_multi_epoch_transaction_expiration = true;
4633 cfg.feature_flags.disable_preconsensus_locking = true;
4634
4635 if chain != Chain::Mainnet {
4636 cfg.feature_flags
4637 .enable_nitro_attestation_always_include_required_pcrs_parsing = true;
4638 }
4639 }
4640 106 => {
4641 cfg.accumulator_object_storage_cost = Some(7600);
4643
4644 if chain != Chain::Mainnet && chain != Chain::Testnet {
4645 cfg.feature_flags.enable_accumulators = true;
4646 cfg.feature_flags.enable_address_balance_gas_payments = true;
4647 cfg.feature_flags.enable_authenticated_event_streams = true;
4648 cfg.feature_flags.enable_object_funds_withdraw = true;
4649 }
4650 }
4651 107 => {
4652 cfg.feature_flags
4653 .consensus_skip_gced_blocks_in_direct_finalization = true;
4654
4655 if in_integration_test() {
4657 cfg.consensus_gc_depth = Some(6);
4658 cfg.consensus_max_num_transactions_in_block = Some(8);
4659 }
4660 }
4661 108 => {
4662 cfg.feature_flags.gas_rounding_halve_digits = true;
4663 cfg.feature_flags.flexible_tx_context_positions = true;
4664 cfg.feature_flags.disable_entry_point_signature_check = true;
4665
4666 if chain != Chain::Mainnet {
4667 cfg.feature_flags.address_aliases = true;
4668
4669 cfg.feature_flags.enable_accumulators = true;
4670 cfg.feature_flags.enable_address_balance_gas_payments = true;
4671 }
4672
4673 cfg.feature_flags.enable_poseidon = true;
4674 }
4675 109 => {
4676 cfg.binary_variant_handles = Some(1024);
4677 cfg.binary_variant_instantiation_handles = Some(1024);
4678 cfg.feature_flags.restrict_hot_or_not_entry_functions = true;
4679 }
4680 110 => {
4681 cfg.feature_flags
4682 .enable_nitro_attestation_all_nonzero_pcrs_parsing = true;
4683 cfg.feature_flags
4684 .enable_nitro_attestation_always_include_required_pcrs_parsing = true;
4685 if chain != Chain::Mainnet && chain != Chain::Testnet {
4686 cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4687 }
4688 cfg.feature_flags.validate_zklogin_public_identifier = true;
4689 cfg.feature_flags.fix_checkpoint_signature_mapping = true;
4690 cfg.feature_flags
4691 .consensus_always_accept_system_transactions = true;
4692 if chain != Chain::Mainnet {
4693 cfg.feature_flags.enable_object_funds_withdraw = true;
4694 }
4695 }
4696 111 => {
4697 cfg.feature_flags.validator_metadata_verify_v2 = true;
4698 }
4699 112 => {
4700 cfg.group_ops_ristretto_decode_scalar_cost = Some(7);
4701 cfg.group_ops_ristretto_decode_point_cost = Some(200);
4702 cfg.group_ops_ristretto_scalar_add_cost = Some(10);
4703 cfg.group_ops_ristretto_point_add_cost = Some(500);
4704 cfg.group_ops_ristretto_scalar_sub_cost = Some(10);
4705 cfg.group_ops_ristretto_point_sub_cost = Some(500);
4706 cfg.group_ops_ristretto_scalar_mul_cost = Some(11);
4707 cfg.group_ops_ristretto_point_mul_cost = Some(1200);
4708 cfg.group_ops_ristretto_scalar_div_cost = Some(151);
4709 cfg.group_ops_ristretto_point_div_cost = Some(2500);
4710
4711 if chain != Chain::Mainnet && chain != Chain::Testnet {
4712 cfg.feature_flags.enable_ristretto255_group_ops = true;
4713 }
4714 }
4715 113 => {
4716 cfg.feature_flags.address_balance_gas_check_rgp_at_signing = true;
4717 if chain != Chain::Mainnet && chain != Chain::Testnet {
4718 cfg.feature_flags.defer_unpaid_amplification = true;
4719 }
4720 }
4721 114 => {
4722 cfg.feature_flags.randomize_checkpoint_tx_limit_in_tests = true;
4723 cfg.feature_flags.address_balance_gas_reject_gas_coin_arg = true;
4724 if chain != Chain::Mainnet {
4725 cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4726 cfg.feature_flags.enable_authenticated_event_streams = true;
4727 cfg.feature_flags
4728 .include_checkpoint_artifacts_digest_in_summary = true;
4729 }
4730 }
4731 115 => {
4732 cfg.feature_flags.normalize_depth_formula = true;
4733 }
4734 116 => {
4735 cfg.feature_flags.gasless_transaction_drop_safety = true;
4736 cfg.feature_flags.address_aliases = true;
4737 cfg.feature_flags.relax_valid_during_for_owned_inputs = true;
4738 cfg.feature_flags.defer_unpaid_amplification = false;
4740 cfg.feature_flags.enable_display_registry = true;
4741 }
4742 117 => {}
4743 118 => {
4744 cfg.feature_flags.use_coin_party_owner = true;
4745 }
4746 119 => {
4747 cfg.execution_version = Some(4);
4749 cfg.feature_flags.address_balance_gas_reject_gas_coin_arg = false;
4750 cfg.feature_flags.merge_randomness_into_checkpoint = true;
4751 if chain != Chain::Mainnet {
4752 cfg.feature_flags.enable_gasless = true;
4753 cfg.gasless_max_computation_units = Some(50_000);
4754 cfg.gasless_allowed_token_types = Some(vec![]);
4755 cfg.feature_flags.enable_coin_reservation_obj_refs = true;
4756 cfg.feature_flags
4757 .convert_withdrawal_compatibility_ptb_arguments = true;
4758 }
4759 cfg.gasless_max_unused_inputs = Some(1);
4760 cfg.gasless_max_pure_input_bytes = Some(32);
4761 if chain == Chain::Testnet {
4762 cfg.gasless_allowed_token_types = Some(vec![(TESTNET_USDC.to_string(), 0)]);
4763 }
4764 cfg.transfer_receive_object_cost_per_byte = Some(1);
4765 cfg.transfer_receive_object_type_cost_per_byte = Some(2);
4766 }
4767 120 => {
4768 cfg.feature_flags.disallow_jump_orphans = true;
4769 }
4770 121 => {
4771 if chain != Chain::Mainnet {
4773 cfg.feature_flags.defer_unpaid_amplification = true;
4774 cfg.gasless_max_tps = Some(50);
4775 }
4776 cfg.feature_flags
4777 .early_return_receive_object_mismatched_type = true;
4778 }
4779 122 => {
4780 cfg.feature_flags.defer_unpaid_amplification = true;
4782 cfg.verify_bulletproofs_ristretto255_base_cost = Some(30000);
4784 cfg.verify_bulletproofs_ristretto255_cost_per_bit_and_commitment = Some(6500);
4785 if chain != Chain::Mainnet && chain != Chain::Testnet {
4786 cfg.feature_flags.enable_verify_bulletproofs_ristretto255 = true;
4787 }
4788 cfg.feature_flags.gasless_verify_remaining_balance = true;
4789 cfg.include_special_package_amendments = match chain {
4790 Chain::Mainnet => Some(MAINNET_LINKAGE_AMENDMENTS.clone()),
4791 Chain::Testnet => Some(TESTNET_LINKAGE_AMENDMENTS.clone()),
4792 Chain::Unknown => None,
4793 };
4794 cfg.gasless_max_tx_size_bytes = Some(16 * 1024);
4795 cfg.gasless_max_tps = Some(300);
4796 cfg.gasless_max_computation_units = Some(5_000);
4797 }
4798 123 => {
4799 cfg.gas_model_version = Some(13);
4800 }
4801 124 => {
4802 if chain != Chain::Mainnet && chain != Chain::Testnet {
4803 cfg.feature_flags.timestamp_based_epoch_close = true;
4804 }
4805 cfg.gas_model_version = Some(14);
4806 cfg.feature_flags.limit_groth16_pvk_inputs = true;
4807
4808 cfg.feature_flags.enable_accumulators = true;
4814 cfg.feature_flags.enable_address_balance_gas_payments = true;
4815 cfg.feature_flags.enable_authenticated_event_streams = true;
4816 cfg.feature_flags.enable_coin_reservation_obj_refs = true;
4817 cfg.feature_flags.enable_object_funds_withdraw = true;
4818 cfg.feature_flags
4819 .convert_withdrawal_compatibility_ptb_arguments = true;
4820 cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4821 cfg.feature_flags
4822 .include_checkpoint_artifacts_digest_in_summary = true;
4823 cfg.feature_flags.enable_gasless = true;
4824
4825 if chain == Chain::Mainnet {
4830 cfg.gasless_allowed_token_types = Some(vec![
4831 (MAINNET_USDC.to_string(), 10_000),
4832 (MAINNET_USDSUI.to_string(), 10_000),
4833 (MAINNET_SUI_USDE.to_string(), 10_000),
4834 (MAINNET_USDY.to_string(), 10_000),
4835 (MAINNET_FDUSD.to_string(), 10_000),
4836 (MAINNET_AUSD.to_string(), 10_000),
4837 (MAINNET_USDB.to_string(), 10_000),
4838 ]);
4839 }
4840 }
4841 125 => {
4842 cfg.feature_flags.granular_post_execution_checks = true;
4843 if chain != Chain::Mainnet {
4844 cfg.feature_flags.timestamp_based_epoch_close = true;
4845 }
4846 }
4847 126 => {
4848 cfg.feature_flags.early_exit_on_iffw = true;
4849 }
4850 127 => {
4851 cfg.feature_flags.always_advance_dkg_to_resolution = true;
4852
4853 cfg.verify_bulletproofs_ristretto255_base_cost = Some(23866);
4854 cfg.verify_bulletproofs_ristretto255_cost_per_bit_and_commitment = Some(1324);
4855 cfg.group_ops_ristretto_decode_scalar_cost = Some(5);
4856 cfg.group_ops_ristretto_decode_point_cost = Some(216);
4857 cfg.group_ops_ristretto_scalar_add_cost = Some(2);
4858 cfg.group_ops_ristretto_point_add_cost = Some(8);
4859 cfg.group_ops_ristretto_scalar_sub_cost = Some(2);
4860 cfg.group_ops_ristretto_point_sub_cost = Some(8);
4861 cfg.group_ops_ristretto_scalar_mul_cost = Some(5);
4862 cfg.group_ops_ristretto_point_mul_cost = Some(1763);
4863 cfg.group_ops_ristretto_scalar_div_cost = Some(557);
4864 cfg.group_ops_ristretto_point_div_cost = Some(2244);
4865
4866 if chain != Chain::Mainnet {
4867 cfg.feature_flags.enable_ristretto255_group_ops = true;
4868 cfg.feature_flags.enable_verify_bulletproofs_ristretto255 = true;
4869 }
4870
4871 cfg.feature_flags.timestamp_based_epoch_close = true;
4872 }
4873 128 => {
4874 cfg.max_generic_instantiation_type_nodes_per_function = Some(10_000);
4875 cfg.max_generic_instantiation_type_nodes_per_module = Some(500_000);
4876 cfg.binary_enum_defs = Some(200);
4877 cfg.binary_enum_def_instantiations = Some(100);
4878 }
4879 129 => {
4880 cfg.feature_flags.enable_unified_linkage = true;
4881 }
4882 130 => {
4883 cfg.feature_flags.record_net_unsettled_object_withdraws = true;
4884 cfg.feature_flags.enable_init_on_upgrade = true;
4885 cfg.epoch_close_deadline_ms = Some(120_000);
4886 cfg.scratch_add_cost_base = Some(13);
4887 cfg.scratch_read_cost_base = Some(13);
4888 cfg.scratch_read_value_cost = Some(1);
4889 cfg.scratch_remove_cost_base = Some(13);
4890 cfg.scratch_exists_cost_base = Some(13);
4891 cfg.scratch_exists_with_type_cost_base = Some(13);
4892 cfg.scratch_exists_with_type_type_cost = Some(1);
4893 let max_commands = cfg.max_programmable_tx_commands() as u64;
4894 cfg.max_scratch_pad_size = Some(16 * max_commands);
4895 if chain != Chain::Mainnet && chain != Chain::Testnet {
4897 cfg.feature_flags.zklogin_circuit_mode = 1;
4898 }
4899 }
4900 131 => {
4901 cfg.feature_flags.share_transaction_deny_config_in_consensus = true;
4902 cfg.feature_flags.framework_tx_context_mut_restrictions = true;
4903 }
4904 132 => {
4905 if chain != Chain::Mainnet && chain != Chain::Testnet {
4906 cfg.feature_flags.defer_owned_object_double_spend = true;
4907 cfg.feature_flags.create_forwarding_address_registry = true;
4908 }
4909 cfg.object_record_new_uid_from_hash_cost_base = Some(1);
4910 cfg.feature_flags
4911 .enable_order_independent_upgrade_init_linkage = true;
4912 }
4913 133 => {
4914 cfg.feature_flags
4915 .include_function_signatures_in_instantiation_limits = true;
4916 cfg.max_accumulator_type_nodes = Some(16);
4917 }
4918 134 => {
4919 if chain != Chain::Mainnet {
4926 cfg.package_original_package_id_impl_cost_base = Some(52);
4927 let package_read_cost_per_byte = cfg.obj_access_cost_read_per_byte();
4928 cfg.package_original_package_id_impl_cost_per_byte =
4929 Some(package_read_cost_per_byte);
4930
4931 cfg.consensus_max_transactions_in_block_bytes = Some(288 * 1024);
4932 cfg.consensus_max_num_transactions_in_block = Some(128);
4933 }
4934
4935 if chain == Chain::Mainnet {
4936 cfg.feature_flags.defer_unpaid_amplification = false;
4937 }
4938 }
4939 135 => {
4940 cfg.package_original_package_id_impl_cost_base = Some(52);
4943 let package_read_cost_per_byte = cfg.obj_access_cost_read_per_byte();
4944 cfg.package_original_package_id_impl_cost_per_byte =
4945 Some(package_read_cost_per_byte);
4946
4947 cfg.consensus_max_transactions_in_block_bytes = Some(288 * 1024);
4948 cfg.consensus_max_num_transactions_in_block = Some(128);
4949
4950 cfg.feature_flags.defer_unpaid_amplification = false;
4951 }
4952 136 => {
4953 cfg.feature_flags.ptb_tx_context_restrictions = true;
4954
4955 cfg.translation_per_live_reference_charge = Some(1);
4956 cfg.max_ptb_live_references = Some(64);
4957 cfg.max_ptb_returned_references = Some(16);
4958 cfg.max_ptb_total_returned_references = Some(256);
4959
4960 if chain != Chain::Mainnet && chain != Chain::Testnet {
4961 cfg.feature_flags.allowed_proposers = true;
4962 }
4963 cfg.feature_flags.harden_linkage_consistency = true;
4964
4965 cfg.package_arena_size_in_bytes = Some(10_000_000);
4966 }
4967 137 => {
4968 cfg.verify_bulletproofs_ristretto255_cost_per_bit_and_commitment = Some(621);
4969 cfg.max_bulletproofs_total_bits = Some(1024);
4970
4971 if chain != Chain::Mainnet {
4972 cfg.feature_flags.enable_allowances = true;
4973 }
4974 cfg.feature_flags.fix_ptb_generated_reads = true;
4975 cfg.feature_flags.charge_ld_const_abstract_size = true;
4976 if chain != Chain::Mainnet && chain != Chain::Testnet {
4977 cfg.feature_flags.check_object_funds_withdraw_in_execution = true;
4978 }
4979 cfg.reserve_object_funds_for_withdrawal_cost_base = Some(52);
4980 cfg.reserve_object_funds_for_withdrawal_cold_read_cost = Some(184);
4983
4984 cfg.feature_flags.allowed_proposers = true;
4985
4986 cfg.feature_flags.validate_ptb_argument_indices = true;
4987 cfg.feature_flags.memory_safety_invariant_check_v2 = true;
4988 }
4989 138 => {
4990 cfg.gas_model_version = Some(15);
4991 cfg.feature_flags.enable_allowances = true;
4992 if chain != Chain::Mainnet {
4993 cfg.feature_flags.check_object_funds_withdraw_in_execution = true;
4994 cfg.feature_flags.disable_effects_tx_dependencies = true;
4995 }
4996 cfg.feature_flags.merge_colliding_deferrals = true;
4997 if chain == Chain::Mainnet {
4999 cfg.storage_rebate_rate = Some(9999);
5000 }
5001 }
5002 139 => {
5003 if chain != Chain::Mainnet && chain != Chain::Testnet {
5004 cfg.feature_flags.enable_forwarding_addresses = true;
5005 cfg.feature_flags.mldsa65_auth = true;
5006 }
5007 cfg.storage_rebate_rate = Some(9999);
5008 if chain != Chain::Mainnet {
5009 cfg.feature_flags.allow_dkg_completion_after_timeout = true;
5010 }
5011 cfg.obj_access_cost_read_per_package_kb = Some(154);
5013 }
5014 140 => {
5015 cfg.staggered_submission_signal_window_commits = Some(300);
5018 cfg.staggered_submission_signal_min_excess_copies_per_commit = Some(2);
5019 cfg.staggered_submission_signal_exit_dwell_commits = Some(6000);
5020 cfg.staggered_submission_signal_band1_enter_ratio_bps = Some(1000);
5021 cfg.staggered_submission_signal_band1_exit_ratio_bps = Some(500);
5022 cfg.staggered_submission_signal_band2_enter_ratio_bps = Some(5000);
5023 cfg.staggered_submission_signal_band2_exit_ratio_bps = Some(2500);
5024
5025 cfg.vector_reverse_base_cost = Some(52);
5026 cfg.vector_reverse_per_elem_cost = Some(8);
5027 cfg.vector_keep_range_base_cost = Some(52);
5028 cfg.vector_keep_range_per_dropped_elem_cost = Some(1);
5029 cfg.vector_keep_range_per_moved_elem_cost = Some(8);
5030 cfg.vector_copy_range_base_cost = Some(52);
5031 cfg.vector_replace_range_base_cost = Some(52);
5032 cfg.vector_replace_range_per_elem_cost = Some(8);
5033
5034 if chain != Chain::Mainnet && chain != Chain::Testnet {
5035 cfg.feature_flags.shuffle_consensus_commit_blocks = true;
5036 }
5037
5038 cfg.feature_flags.allow_references_in_ptbs = true;
5039 cfg.feature_flags.disable_id_leak_verifier = true;
5040 cfg.feature_flags.check_object_funds_withdraw_in_execution = true;
5041 cfg.feature_flags.disable_effects_tx_dependencies = true;
5042 }
5043 141 => {
5044 cfg.feature_flags.complete_effects_size_estimate = true;
5045 cfg.max_num_accumulator_events = Some(1024);
5046 }
5047 142 => {
5048 cfg.clock_borrow_cost_base = Some(52);
5049 cfg.feature_flags.check_groth16_pvk_length = true;
5050 cfg.object_is_shared_input_cost_base = Some(52);
5051 cfg.feature_flags.secp256r1_ecrecover_checks_x_below_p = true;
5052 cfg.binary_format_limits_profile = Some(BinaryFormatLimitsProfile::V1);
5053 cfg.feature_flags.defer_owned_object_double_spend = true;
5054 }
5055 143 => {
5056 cfg.execution_version = Some(5);
5057 cfg.package_arena_size_in_bytes = Some(20_000_000);
5058 cfg.feature_flags.simplify_nitro_header_validation = true;
5059 cfg.feature_flags.enable_forwarding_addresses = false;
5060 cfg.feature_flags.package_publish_charge = true;
5061 cfg.package_publish_charge_fixed = Some(1_000_000_000);
5062 cfg.package_publish_charge_per_module = Some(10_000_000);
5063 cfg.package_publish_charge_per_dependency = Some(10_000_000);
5064 if chain != Chain::Mainnet {
5065 cfg.feature_flags.mldsa65_auth = true;
5066 }
5067 cfg.layout_node_cost = Some(16);
5068 cfg.layout_node_cost_large_layout_threshold = Some(64);
5069 }
5070 144 => {
5071 if chain != Chain::Mainnet && chain != Chain::Testnet {
5072 cfg.feature_flags.enable_timestamp_transaction_expiration = true;
5073 }
5074 }
5075 _ => panic!("unsupported version {:?}", version),
5086 }
5087 }
5088
5089 cfg
5090 }
5091
5092 pub fn apply_seeded_test_overrides(&mut self, seed: &[u8; 32]) {
5093 if !self.feature_flags.randomize_checkpoint_tx_limit_in_tests
5094 || !self.feature_flags.split_checkpoints_in_consensus_handler
5095 {
5096 return;
5097 }
5098
5099 if !mysten_common::in_test_configuration() {
5100 return;
5101 }
5102
5103 use rand::{Rng, SeedableRng, rngs::StdRng};
5104 let mut rng = StdRng::from_seed(*seed);
5105 let max_txns = rng.gen_range(10..=100u64);
5106 info!("seeded test override: max_transactions_per_checkpoint = {max_txns}");
5107 self.max_transactions_per_checkpoint = Some(max_txns);
5108 }
5109
5110 pub fn verifier_config(&self, signing_limits: Option<(usize, usize, usize)>) -> VerifierConfig {
5116 let (
5117 max_back_edges_per_function,
5118 max_back_edges_per_module,
5119 sanity_check_with_regex_reference_safety,
5120 ) = if let Some((
5121 max_back_edges_per_function,
5122 max_back_edges_per_module,
5123 sanity_check_with_regex_reference_safety,
5124 )) = signing_limits
5125 {
5126 (
5127 Some(max_back_edges_per_function),
5128 Some(max_back_edges_per_module),
5129 Some(sanity_check_with_regex_reference_safety),
5130 )
5131 } else {
5132 (None, None, None)
5133 };
5134
5135 let additional_borrow_checks = if signing_limits.is_some() {
5136 true
5138 } else {
5139 self.additional_borrow_checks()
5140 };
5141 let deprecate_global_storage_ops = if signing_limits.is_some() {
5142 true
5144 } else {
5145 self.deprecate_global_storage_ops()
5146 };
5147
5148 VerifierConfig {
5149 max_loop_depth: Some(self.max_loop_depth() as usize),
5150 max_generic_instantiation_length: Some(self.max_generic_instantiation_length() as usize),
5151 max_function_parameters: Some(self.max_function_parameters() as usize),
5152 max_basic_blocks: Some(self.max_basic_blocks() as usize),
5153 max_value_stack_size: self.max_value_stack_size() as usize,
5154 max_type_nodes: Some(self.max_type_nodes() as usize),
5155 max_generic_instantiation_type_nodes_per_function: self
5156 .max_generic_instantiation_type_nodes_per_function_as_option()
5157 .map(|v| v as usize),
5158 max_generic_instantiation_type_nodes_per_module: self
5159 .max_generic_instantiation_type_nodes_per_module_as_option()
5160 .map(|v| v as usize),
5161 include_function_signatures_in_instantiation_limits: self
5162 .include_function_signatures_in_instantiation_limits(),
5163 max_push_size: Some(self.max_push_size() as usize),
5164 max_dependency_depth: Some(self.max_dependency_depth() as usize),
5165 max_fields_in_struct: Some(self.max_fields_in_struct() as usize),
5166 max_function_definitions: Some(self.max_function_definitions() as usize),
5167 max_data_definitions: Some(self.max_struct_definitions() as usize),
5168 max_constant_vector_len: Some(self.max_move_vector_len()),
5169 max_back_edges_per_function,
5170 max_back_edges_per_module,
5171 max_basic_blocks_in_script: None,
5172 max_identifier_len: self.max_move_identifier_len_as_option(), disallow_self_identifier: self.feature_flags.disallow_self_identifier,
5174 allow_receiving_object_id: self.allow_receiving_object_id(),
5175 reject_mutable_random_on_entry_functions: self
5176 .reject_mutable_random_on_entry_functions(),
5177 bytecode_version: self.move_binary_format_version(),
5178 max_variants_in_enum: self.max_move_enum_variants_as_option(),
5179 additional_borrow_checks,
5180 better_loader_errors: self.better_loader_errors(),
5181 private_generics_verifier_v2: self.private_generics_verifier_v2(),
5182 sanity_check_with_regex_reference_safety: sanity_check_with_regex_reference_safety
5183 .map(|limit| limit as u128),
5184 deprecate_global_storage_ops,
5185 disable_entry_point_signature_check: self.disable_entry_point_signature_check(),
5186 disable_id_leak_verifier: self.disable_id_leak_verifier(),
5187 switch_to_regex_reference_safety: false,
5188 framework_tx_context_mut_restrictions: self.framework_tx_context_mut_restrictions(),
5189 disallow_jump_orphans: self.disallow_jump_orphans(),
5190 }
5191 }
5192
5193 pub fn binary_config(
5194 &self,
5195 override_deprecate_global_storage_ops_during_deserialization: Option<bool>,
5196 ) -> BinaryConfig {
5197 let deprecate_global_storage_ops =
5198 override_deprecate_global_storage_ops_during_deserialization
5199 .unwrap_or_else(|| self.deprecate_global_storage_ops());
5200 BinaryConfig::new(
5201 self.move_binary_format_version(),
5202 self.min_move_binary_format_version_as_option()
5203 .unwrap_or(VERSION_1),
5204 self.no_extraneous_module_bytes(),
5205 deprecate_global_storage_ops,
5206 TableConfig {
5207 module_handles: self.binary_module_handles_as_option().unwrap_or(u16::MAX),
5208 datatype_handles: self.binary_struct_handles_as_option().unwrap_or(u16::MAX),
5209 function_handles: self.binary_function_handles_as_option().unwrap_or(u16::MAX),
5210 function_instantiations: self
5211 .binary_function_instantiations_as_option()
5212 .unwrap_or(u16::MAX),
5213 signatures: self.binary_signatures_as_option().unwrap_or(u16::MAX),
5214 constant_pool: self.binary_constant_pool_as_option().unwrap_or(u16::MAX),
5215 identifiers: self.binary_identifiers_as_option().unwrap_or(u16::MAX),
5216 address_identifiers: self
5217 .binary_address_identifiers_as_option()
5218 .unwrap_or(u16::MAX),
5219 struct_defs: self.binary_struct_defs_as_option().unwrap_or(u16::MAX),
5220 struct_def_instantiations: self
5221 .binary_struct_def_instantiations_as_option()
5222 .unwrap_or(u16::MAX),
5223 function_defs: self.binary_function_defs_as_option().unwrap_or(u16::MAX),
5224 field_handles: self.binary_field_handles_as_option().unwrap_or(u16::MAX),
5225 field_instantiations: self
5226 .binary_field_instantiations_as_option()
5227 .unwrap_or(u16::MAX),
5228 friend_decls: self.binary_friend_decls_as_option().unwrap_or(u16::MAX),
5229 enum_defs: self.binary_enum_defs_as_option().unwrap_or(u16::MAX),
5230 enum_def_instantiations: self
5231 .binary_enum_def_instantiations_as_option()
5232 .unwrap_or(u16::MAX),
5233 variant_handles: self.binary_variant_handles_as_option().unwrap_or(u16::MAX),
5234 variant_instantiation_handles: self
5235 .binary_variant_instantiation_handles_as_option()
5236 .unwrap_or(u16::MAX),
5237 },
5238 self.binary_format_limits(),
5239 )
5240 }
5241
5242 pub fn binary_format_limits(
5243 &self,
5244 ) -> &'static move_binary_format::binary_config::BinaryFormatLimits {
5245 self.binary_format_limits_profile
5246 .unwrap_or(BinaryFormatLimitsProfile::LEGACY)
5247 .limits()
5248 }
5249
5250 pub fn apply_overrides_for_testing(
5254 override_fn: impl Fn(ProtocolVersion, Self) -> Self + Send + Sync + 'static,
5255 ) -> OverrideGuard {
5256 let mut cur = CONFIG_OVERRIDE.lock().unwrap();
5257 assert!(cur.is_none(), "config override already present");
5258 *cur = Some(Box::new(override_fn));
5259 OverrideGuard
5260 }
5261
5262 #[cfg(feature = "testing")]
5266 pub fn apply_base_overrides_for_testing(
5267 override_fn: impl Fn(ProtocolVersion, Self) -> Self + Send + Sync + 'static,
5268 ) -> BaseOverrideGuard {
5269 info!("installing base ProtocolConfig override for testing");
5270 let override_fn: Arc<OverrideFn> = Arc::new(override_fn);
5271 BASE_CONFIG_OVERRIDES
5272 .lock()
5273 .unwrap()
5274 .push(override_fn.clone());
5275 BaseOverrideGuard { override_fn }
5276 }
5277
5278 fn apply_config_override(version: ProtocolVersion, mut ret: Self) -> Self {
5279 #[cfg(feature = "testing")]
5281 {
5282 let fns = BASE_CONFIG_OVERRIDES.lock().unwrap().clone();
5283 for override_fn in fns {
5284 ret = override_fn(version, ret);
5285 }
5286 }
5287 if let Some(override_fn) = CONFIG_OVERRIDE.lock().unwrap().as_ref() {
5288 warn!(
5289 "overriding ProtocolConfig settings with custom settings (you should not see this log outside of tests)"
5290 );
5291 ret = override_fn(version, ret);
5292 }
5293 ret
5294 }
5295}
5296
5297impl ProtocolConfig {
5301 pub fn set_execution_version_for_testing(&mut self, val: u64) {
5305 let current = self.execution_version.unwrap_or(0);
5306 assert!(
5307 val >= current,
5308 "cannot downgrade execution_version from {current} to {val}: running an old \
5309 executor against a newer protocol config/framework is unsupported. To test \
5310 frozen executor behavior, start from the last protocol version of that executor \
5311 instead, so genesis loads the matching framework snapshot (see \
5312 test_address_balance_gas_v3_accumulator_sign)."
5313 );
5314 self.execution_version = Some(val);
5315 }
5316
5317 pub fn set_zklogin_circuit_mode_for_testing(&mut self, val: u64) {
5320 self.feature_flags.zklogin_circuit_mode = val
5321 }
5322
5323 pub fn set_per_object_congestion_control_mode_for_testing(
5324 &mut self,
5325 val: PerObjectCongestionControlMode,
5326 ) {
5327 self.feature_flags.per_object_congestion_control_mode = val;
5328 }
5329
5330 pub fn set_consensus_choice_for_testing(&mut self, val: ConsensusChoice) {
5331 self.feature_flags.consensus_choice = val;
5332 }
5333
5334 pub fn set_consensus_network_for_testing(&mut self, val: ConsensusNetwork) {
5335 self.feature_flags.consensus_network = val;
5336 }
5337
5338 pub fn set_zklogin_max_epoch_upper_bound_delta_for_testing(&mut self, val: Option<u64>) {
5339 self.feature_flags.zklogin_max_epoch_upper_bound_delta = val
5340 }
5341
5342 pub fn set_mysticeti_num_leaders_per_round_for_testing(&mut self, val: Option<usize>) {
5343 self.feature_flags.mysticeti_num_leaders_per_round = val;
5344 }
5345
5346 pub fn disable_accumulators_for_testing(&mut self) {
5347 self.feature_flags.enable_accumulators = false;
5348 self.feature_flags.enable_address_balance_gas_payments = false;
5349 }
5350
5351 pub fn enable_coin_reservation_for_testing(&mut self) {
5352 self.feature_flags.enable_coin_reservation_obj_refs = true;
5353 self.feature_flags
5354 .convert_withdrawal_compatibility_ptb_arguments = true;
5355 self.execution_version = Some(self.execution_version.map_or(4, |v| v.max(4)));
5358 }
5359
5360 pub fn disable_coin_reservation_for_testing(&mut self) {
5361 self.feature_flags.enable_coin_reservation_obj_refs = false;
5362 self.feature_flags
5363 .convert_withdrawal_compatibility_ptb_arguments = false;
5364 }
5365
5366 pub fn enable_address_balance_gas_payments_for_testing(&mut self) {
5367 self.feature_flags.enable_accumulators = true;
5368 self.feature_flags.allow_private_accumulator_entrypoints = true;
5369 self.feature_flags.enable_address_balance_gas_payments = true;
5370 self.feature_flags.address_balance_gas_check_rgp_at_signing = true;
5371 self.feature_flags.address_balance_gas_reject_gas_coin_arg = false;
5372 self.execution_version = Some(self.execution_version.map_or(4, |v| v.max(4)))
5373 }
5374
5375 pub fn enable_gasless_for_testing(&mut self) {
5376 self.enable_address_balance_gas_payments_for_testing();
5377 self.feature_flags.enable_gasless = true;
5378 self.feature_flags.gasless_verify_remaining_balance = true;
5379 self.gasless_max_computation_units = Some(5_000);
5380 self.gasless_allowed_token_types = Some(vec![]);
5381 self.gasless_max_tps = Some(1000);
5382 self.gasless_max_tx_size_bytes = Some(16 * 1024);
5383 }
5384
5385 pub fn disable_gasless_for_testing(&mut self) {
5386 self.feature_flags.enable_gasless = false;
5387 self.gasless_max_computation_units = None;
5388 self.gasless_allowed_token_types = None;
5389 }
5390
5391 pub fn enable_authenticated_event_streams_for_testing(&mut self) {
5392 self.feature_flags.enable_accumulators = true;
5393 self.feature_flags.enable_authenticated_event_streams = true;
5394 self.feature_flags
5395 .include_checkpoint_artifacts_digest_in_summary = true;
5396 self.feature_flags.split_checkpoints_in_consensus_handler = true;
5397 }
5398}
5399
5400type OverrideFn = dyn Fn(ProtocolVersion, ProtocolConfig) -> ProtocolConfig + Send + Sync;
5401
5402static CONFIG_OVERRIDE: Mutex<Option<Box<OverrideFn>>> = Mutex::new(None);
5403
5404#[must_use]
5405pub struct OverrideGuard;
5406
5407impl Drop for OverrideGuard {
5408 fn drop(&mut self) {
5409 info!("restoring override fn");
5410 *CONFIG_OVERRIDE.lock().unwrap() = None;
5411 }
5412}
5413
5414#[cfg(feature = "testing")]
5415static BASE_CONFIG_OVERRIDES: Mutex<Vec<Arc<OverrideFn>>> = Mutex::new(Vec::new());
5416
5417#[cfg(feature = "testing")]
5418#[must_use]
5419pub struct BaseOverrideGuard {
5420 override_fn: Arc<OverrideFn>,
5421}
5422
5423#[cfg(feature = "testing")]
5424impl Drop for BaseOverrideGuard {
5425 fn drop(&mut self) {
5426 BASE_CONFIG_OVERRIDES
5427 .lock()
5428 .unwrap()
5429 .retain(|f| !Arc::ptr_eq(f, &self.override_fn));
5430 }
5431}
5432
5433#[derive(PartialEq, Eq)]
5436pub enum LimitThresholdCrossed {
5437 None,
5438 Soft(u128, u128),
5439 Hard(u128, u128),
5440}
5441
5442pub fn check_limit_in_range<T: Into<V>, U: Into<V>, V: PartialOrd + Into<u128>>(
5445 x: T,
5446 soft_limit: U,
5447 hard_limit: V,
5448) -> LimitThresholdCrossed {
5449 let x: V = x.into();
5450 let soft_limit: V = soft_limit.into();
5451
5452 debug_assert!(soft_limit <= hard_limit);
5453
5454 if x >= hard_limit {
5457 LimitThresholdCrossed::Hard(x.into(), hard_limit.into())
5458 } else if x < soft_limit {
5459 LimitThresholdCrossed::None
5460 } else {
5461 LimitThresholdCrossed::Soft(x.into(), soft_limit.into())
5462 }
5463}
5464
5465#[macro_export]
5466macro_rules! assert_set {
5467 ($protocol_config:expr, $($flag:ident),+ $(,)?) => {{
5468 let protocol_config = $protocol_config;
5469 $(
5470 assert!(
5471 protocol_config.$flag(),
5472 "protocol config flag `{}` must be set",
5473 stringify!($flag),
5474 );
5475 )+
5476 }};
5477}
5478
5479#[macro_export]
5480macro_rules! check_limit {
5481 ($x:expr, $hard:expr) => {
5482 check_limit!($x, $hard, $hard)
5483 };
5484 ($x:expr, $soft:expr, $hard:expr) => {
5485 check_limit_in_range($x as u64, $soft, $hard)
5486 };
5487}
5488
5489#[macro_export]
5493macro_rules! check_limit_by_meter {
5494 ($is_metered:expr, $x:expr, $metered_limit:expr, $unmetered_hard_limit:expr, $metric:expr) => {{
5495 let (h, metered_str) = if $is_metered {
5497 ($metered_limit, "metered")
5498 } else {
5499 ($unmetered_hard_limit, "unmetered")
5501 };
5502 use sui_protocol_config::check_limit_in_range;
5503 let result = check_limit_in_range($x as u64, $metered_limit, h);
5504 match result {
5505 LimitThresholdCrossed::None => {}
5506 LimitThresholdCrossed::Soft(_, _) => {
5507 $metric.with_label_values(&[metered_str, "soft"]).inc();
5508 }
5509 LimitThresholdCrossed::Hard(_, _) => {
5510 $metric.with_label_values(&[metered_str, "hard"]).inc();
5511 }
5512 };
5513 result
5514 }};
5515}
5516
5517pub type Amendments = BTreeMap<AccountAddress, BTreeMap<AccountAddress, AccountAddress>>;
5520
5521static MAINNET_LINKAGE_AMENDMENTS: LazyLock<Arc<Amendments>> =
5522 LazyLock::new(|| parse_amendments(include_str!("mainnet_amendments.json")));
5523
5524static TESTNET_LINKAGE_AMENDMENTS: LazyLock<Arc<Amendments>> =
5525 LazyLock::new(|| parse_amendments(include_str!("testnet_amendments.json")));
5526
5527fn parse_amendments(json: &str) -> Arc<Amendments> {
5528 #[derive(serde::Deserialize)]
5529 struct AmendmentEntry {
5530 root: String,
5531 deps: Vec<DepEntry>,
5532 }
5533
5534 #[derive(serde::Deserialize)]
5535 struct DepEntry {
5536 original_id: String,
5537 version_id: String,
5538 }
5539
5540 let entries: Vec<AmendmentEntry> =
5541 serde_json::from_str(json).expect("Failed to parse amendments JSON");
5542 let mut amendments = BTreeMap::new();
5543 for entry in entries {
5544 let root_id = AccountAddress::from_hex_literal(&entry.root).unwrap();
5545 let mut dep_ids = BTreeMap::new();
5546 for dep in entry.deps {
5547 let orig_id = AccountAddress::from_hex_literal(&dep.original_id).unwrap();
5548 let upgraded_id = AccountAddress::from_hex_literal(&dep.version_id).unwrap();
5549 assert!(
5550 dep_ids.insert(orig_id, upgraded_id).is_none(),
5551 "Duplicate original ID in amendments table"
5552 );
5553 }
5554 assert!(
5555 amendments.insert(root_id, dep_ids).is_none(),
5556 "Duplicate root ID in amendments table"
5557 );
5558 }
5559 Arc::new(amendments)
5560}
5561
5562#[cfg(all(test, not(msim)))]
5563mod test {
5564 use insta::assert_yaml_snapshot;
5565
5566 use super::*;
5567
5568 #[test]
5569 fn snapshot_tests() {
5570 println!("\n============================================================================");
5571 println!("! !");
5572 println!("! IMPORTANT: never update snapshots from this test. only add new versions! !");
5573 println!("! !");
5574 println!("============================================================================\n");
5575 for chain_id in &[Chain::Unknown, Chain::Mainnet, Chain::Testnet] {
5576 let chain_str = match chain_id {
5580 Chain::Unknown => "".to_string(),
5581 _ => format!("{:?}_", chain_id),
5582 };
5583 for i in MIN_PROTOCOL_VERSION..=MAX_PROTOCOL_VERSION {
5584 let cur = ProtocolVersion::new(i);
5585 assert_yaml_snapshot!(
5586 format!("{}version_{}", chain_str, cur.as_u64()),
5587 ProtocolConfig::get_for_version(cur, *chain_id)
5588 );
5589 }
5590 }
5591 }
5592
5593 #[test]
5594 fn binary_format_limits_profile_matches_protocol_version() {
5595 let v141 = ProtocolConfig::get_for_version(ProtocolVersion::new(141), Chain::Unknown);
5596 assert_eq!(
5597 v141.binary_format_limits(),
5598 BinaryFormatLimitsProfile::LEGACY.limits()
5599 );
5600
5601 let v142 = ProtocolConfig::get_for_version(ProtocolVersion::new(142), Chain::Unknown);
5602 assert_eq!(
5603 v142.binary_format_limits(),
5604 BinaryFormatLimitsProfile::V1.limits()
5605 );
5606 }
5607
5608 #[test]
5609 fn test_getters() {
5610 let prot: ProtocolConfig =
5611 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5612 assert_eq!(
5613 prot.max_arguments(),
5614 prot.max_arguments_as_option().unwrap()
5615 );
5616 }
5617
5618 #[test]
5619 fn vector_bulk_native_gas_costs_start_at_version_140() {
5620 for chain in [Chain::Unknown, Chain::Mainnet, Chain::Testnet] {
5621 let before = ProtocolConfig::get_for_version(ProtocolVersion::new(139), chain);
5622 assert_eq!(before.vector_reverse_base_cost_as_option(), None);
5623 assert_eq!(before.vector_reverse_per_elem_cost_as_option(), None);
5624 assert_eq!(before.vector_keep_range_base_cost_as_option(), None);
5625 assert_eq!(
5626 before.vector_keep_range_per_dropped_elem_cost_as_option(),
5627 None
5628 );
5629 assert_eq!(
5630 before.vector_keep_range_per_moved_elem_cost_as_option(),
5631 None
5632 );
5633 assert_eq!(before.vector_copy_range_base_cost_as_option(), None);
5634 assert_eq!(before.vector_replace_range_base_cost_as_option(), None);
5635 assert_eq!(before.vector_replace_range_per_elem_cost_as_option(), None);
5636
5637 let active = ProtocolConfig::get_for_version(ProtocolVersion::new(140), chain);
5638 assert_eq!(active.vector_reverse_base_cost_as_option(), Some(52));
5639 assert_eq!(active.vector_reverse_per_elem_cost_as_option(), Some(8));
5640 assert_eq!(active.vector_keep_range_base_cost_as_option(), Some(52));
5641 assert_eq!(
5642 active.vector_keep_range_per_dropped_elem_cost_as_option(),
5643 Some(1)
5644 );
5645 assert_eq!(
5646 active.vector_keep_range_per_moved_elem_cost_as_option(),
5647 Some(8)
5648 );
5649 assert_eq!(active.vector_copy_range_base_cost_as_option(), Some(52));
5650 assert_eq!(active.vector_replace_range_base_cost_as_option(), Some(52));
5651 assert_eq!(
5652 active.vector_replace_range_per_elem_cost_as_option(),
5653 Some(8)
5654 );
5655 }
5656 }
5657
5658 #[test]
5659 fn test_setters() {
5660 let mut prot: ProtocolConfig =
5661 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5662 prot.set_max_arguments_for_testing(123);
5663 assert_eq!(prot.max_arguments(), 123);
5664
5665 prot.set_max_arguments_from_str_for_testing("321".to_string());
5666 assert_eq!(prot.max_arguments(), 321);
5667
5668 prot.disable_max_arguments_for_testing();
5669 assert_eq!(prot.max_arguments_as_option(), None);
5670
5671 prot.set_attr_for_testing("max_arguments".to_string(), "456".to_string());
5672 assert_eq!(prot.max_arguments(), 456);
5673 }
5674
5675 #[test]
5676 fn test_execution_version_setter_allows_upgrade() {
5677 let mut prot = ProtocolConfig::get_for_max_version_UNSAFE();
5678 let current = prot.execution_version();
5679 prot.set_execution_version_for_testing(current);
5680 prot.set_execution_version_for_testing(current + 1);
5681 assert_eq!(prot.execution_version(), current + 1);
5682 }
5683
5684 #[test]
5685 #[should_panic(expected = "cannot downgrade execution_version")]
5686 fn test_execution_version_setter_panics_on_downgrade() {
5687 let mut prot = ProtocolConfig::get_for_max_version_UNSAFE();
5688 let current = prot.execution_version();
5689 prot.set_execution_version_for_testing(current - 1);
5690 }
5691
5692 #[test]
5693 fn test_feature_flag_setter_by_string() {
5694 let mut prot: ProtocolConfig =
5695 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5696 assert!(!prot.zklogin_auth());
5697 prot.set_feature_flag_for_testing("zklogin_auth".to_string(), true);
5698 assert!(prot.zklogin_auth());
5699 prot.set_feature_flag_for_testing("zklogin_auth".to_string(), false);
5700 assert!(!prot.zklogin_auth());
5701 }
5702
5703 #[test]
5704 #[should_panic(expected = "unknown feature flag")]
5705 fn test_feature_flag_setter_unknown_flag() {
5706 let mut prot: ProtocolConfig =
5707 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5708 prot.set_feature_flag_for_testing("some random string".to_string(), true);
5709 }
5710
5711 #[test]
5712 fn test_get_for_version_if_supported_applies_test_overrides() {
5713 let before =
5714 ProtocolConfig::get_for_version_if_supported(ProtocolVersion::new(1), Chain::Unknown)
5715 .unwrap();
5716
5717 assert!(!before.enable_coin_reservation_obj_refs());
5718
5719 let _guard = ProtocolConfig::apply_overrides_for_testing(|_, mut cfg| {
5720 cfg.enable_coin_reservation_for_testing();
5721 cfg
5722 });
5723
5724 let after =
5725 ProtocolConfig::get_for_version_if_supported(ProtocolVersion::new(1), Chain::Unknown)
5726 .unwrap();
5727
5728 assert!(after.enable_coin_reservation_obj_refs());
5729 }
5730
5731 #[test]
5732 #[should_panic(expected = "unsupported version")]
5733 fn max_version_test() {
5734 let _ = ProtocolConfig::get_for_version_impl(
5737 ProtocolVersion::new(MAX_PROTOCOL_VERSION + 1),
5738 Chain::Unknown,
5739 );
5740 }
5741
5742 #[test]
5743 fn lookup_by_string_test() {
5744 let prot: ProtocolConfig =
5745 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5746 assert!(prot.lookup_attr("some random string".to_string()).is_none());
5748
5749 assert!(
5750 prot.lookup_attr("max_arguments".to_string())
5751 == Some(ProtocolConfigValue::u32(prot.max_arguments())),
5752 );
5753
5754 assert!(
5756 prot.lookup_attr("max_move_identifier_len".to_string())
5757 .is_none()
5758 );
5759
5760 let prot: ProtocolConfig =
5762 ProtocolConfig::get_for_version(ProtocolVersion::new(9), Chain::Unknown);
5763 assert!(
5764 prot.lookup_attr("max_move_identifier_len".to_string())
5765 == Some(ProtocolConfigValue::u64(prot.max_move_identifier_len()))
5766 );
5767
5768 let prot: ProtocolConfig =
5769 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5770 assert!(
5772 prot.attr_map()
5773 .get("max_move_identifier_len")
5774 .unwrap()
5775 .is_none()
5776 );
5777 assert!(
5779 prot.attr_map().get("max_arguments").unwrap()
5780 == &Some(ProtocolConfigValue::u32(prot.max_arguments()))
5781 );
5782
5783 let prot: ProtocolConfig =
5785 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5786 assert!(
5788 prot.feature_flags
5789 .lookup_attr("some random string".to_owned())
5790 .is_none()
5791 );
5792 assert!(
5793 !prot
5794 .feature_flags
5795 .attr_map()
5796 .contains_key("some random string")
5797 );
5798
5799 assert!(
5801 prot.feature_flags
5802 .lookup_attr("package_upgrades".to_owned())
5803 == Some(false)
5804 );
5805 assert!(
5806 prot.feature_flags
5807 .attr_map()
5808 .get("package_upgrades")
5809 .unwrap()
5810 == &false
5811 );
5812 let prot: ProtocolConfig =
5813 ProtocolConfig::get_for_version(ProtocolVersion::new(4), Chain::Unknown);
5814 assert!(
5816 prot.feature_flags
5817 .lookup_attr("package_upgrades".to_owned())
5818 == Some(true)
5819 );
5820 assert!(
5821 prot.feature_flags
5822 .attr_map()
5823 .get("package_upgrades")
5824 .unwrap()
5825 == &true
5826 );
5827 }
5828
5829 #[test]
5830 fn limit_range_fn_test() {
5831 let low = 100u32;
5832 let high = 10000u64;
5833
5834 assert!(check_limit!(1u8, low, high) == LimitThresholdCrossed::None);
5835 assert!(matches!(
5836 check_limit!(255u16, low, high),
5837 LimitThresholdCrossed::Soft(255u128, 100)
5838 ));
5839 assert!(matches!(
5845 check_limit!(2550000u64, low, high),
5846 LimitThresholdCrossed::Hard(2550000, 10000)
5847 ));
5848
5849 assert!(matches!(
5850 check_limit!(2550000u64, high, high),
5851 LimitThresholdCrossed::Hard(2550000, 10000)
5852 ));
5853
5854 assert!(matches!(
5855 check_limit!(1u8, high),
5856 LimitThresholdCrossed::None
5857 ));
5858
5859 assert!(check_limit!(255u16, high) == LimitThresholdCrossed::None);
5860
5861 assert!(matches!(
5862 check_limit!(2550000u64, high),
5863 LimitThresholdCrossed::Hard(2550000, 10000)
5864 ));
5865 }
5866
5867 #[test]
5868 fn linkage_amendments_load() {
5869 let mainnet = LazyLock::force(&MAINNET_LINKAGE_AMENDMENTS);
5870 let testnet = LazyLock::force(&TESTNET_LINKAGE_AMENDMENTS);
5871 assert!(!mainnet.is_empty(), "mainnet amendments must not be empty");
5872 assert!(!testnet.is_empty(), "testnet amendments must not be empty");
5873 }
5874
5875 #[test]
5876 fn render_scalar_fields_use_precision_safe_encoding() {
5877 use mysten_common::rpc_format::Unmetered;
5878
5879 let config = ProtocolConfig::get_for_max_version_UNSAFE();
5880 let rendered = config
5881 .render::<serde_json::Value>(&mut Unmetered)
5882 .expect("render should succeed");
5883
5884 let max_args = rendered
5885 .get("max_arguments")
5886 .expect("max_arguments set at max version");
5887 assert!(
5888 max_args.is_number(),
5889 "u32 should render as number, got {max_args:?}",
5890 );
5891
5892 let max_tx_size = rendered
5893 .get("max_tx_size_bytes")
5894 .expect("max_tx_size_bytes set at max version");
5895 assert!(
5896 max_tx_size.is_string(),
5897 "u64 should render as string, got {max_tx_size:?}",
5898 );
5899 }
5900
5901 #[test]
5902 fn render_includes_non_scalar_gasless_allowlist_as_json() {
5903 use mysten_common::rpc_format::Unmetered;
5904 use serde_json::json;
5905
5906 let mut config = ProtocolConfig::get_for_max_version_UNSAFE();
5907 config.set_gasless_allowed_token_types_for_testing(vec![
5908 ("0xa::usdc::USDC".to_string(), 10_000),
5909 ("0xb::usdt::USDT".to_string(), 0),
5910 ]);
5911
5912 let rendered = config
5913 .render::<serde_json::Value>(&mut Unmetered)
5914 .expect("render should succeed under Unmetered budget");
5915 let allowlist = rendered
5916 .get("gasless_allowed_token_types")
5917 .expect("entry should be present after the testing setter");
5918
5919 assert_eq!(
5922 allowlist,
5923 &json!([["0xa::usdc::USDC", "10000"], ["0xb::usdt::USDT", "0"],]),
5924 );
5925 }
5926
5927 #[test]
5928 fn render_targets_prost_value_for_grpc() {
5929 use mysten_common::rpc_format::Unmetered;
5930 use prost_types::value::Kind;
5931
5932 let mut config = ProtocolConfig::get_for_max_version_UNSAFE();
5933 config.set_gasless_allowed_token_types_for_testing(vec![(
5934 "0xa::usdc::USDC".to_string(),
5935 10_000,
5936 )]);
5937
5938 let rendered = config
5939 .render::<prost_types::Value>(&mut Unmetered)
5940 .expect("render to prost Value should succeed");
5941 let allowlist = rendered
5942 .get("gasless_allowed_token_types")
5943 .expect("entry should be present after the testing setter");
5944
5945 let Some(Kind::ListValue(outer)) = &allowlist.kind else {
5947 panic!(
5948 "expected ListValue at the top level, got {:?}",
5949 allowlist.kind
5950 );
5951 };
5952 assert_eq!(outer.values.len(), 1, "one allowlisted entry");
5953 let Some(Kind::ListValue(entry)) = &outer.values[0].kind else {
5954 panic!("expected each entry to be a ListValue");
5955 };
5956 assert_eq!(entry.values.len(), 2, "entry has (coin_type, amount)");
5957
5958 let Some(Kind::StringValue(coin_type)) = &entry.values[0].kind else {
5959 panic!("expected coin_type as StringValue");
5960 };
5961 assert_eq!(coin_type, "0xa::usdc::USDC");
5962
5963 let Some(Kind::StringValue(amount)) = &entry.values[1].kind else {
5965 panic!(
5966 "expected minimum_transfer_amount as StringValue (precision-safe u64); got {:?}",
5967 entry.values[1].kind,
5968 );
5969 };
5970 assert_eq!(amount, "10000");
5971 }
5972
5973 #[test]
5974 fn render_emits_null_for_unset_protocol_versions() {
5975 use mysten_common::rpc_format::Unmetered;
5976
5977 let config = ProtocolConfig::get_for_version(1.into(), Chain::Unknown);
5978 let rendered = config
5979 .render::<serde_json::Value>(&mut Unmetered)
5980 .expect("render should succeed");
5981 let entry = rendered
5985 .get("gasless_allowed_token_types")
5986 .expect("key should be present for every protocol version");
5987 assert!(
5988 entry.is_null(),
5989 "value should be null for pre-feature protocol version, got {entry:?}",
5990 );
5991 }
5992}