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 = 143;
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)]
444pub struct ProtocolVersion(u64);
445
446impl ProtocolVersion {
447 pub const MIN: Self = Self(MIN_PROTOCOL_VERSION);
452
453 pub const MAX: Self = Self(MAX_PROTOCOL_VERSION);
454
455 #[cfg(not(msim))]
456 pub const MAX_ALLOWED: Self = Self::MAX;
457
458 #[cfg(msim)]
460 pub const MAX_ALLOWED: Self = Self(MAX_PROTOCOL_VERSION + 1);
461
462 pub fn new(v: u64) -> Self {
463 Self(v)
464 }
465
466 pub const fn as_u64(&self) -> u64 {
467 self.0
468 }
469
470 pub fn max() -> Self {
473 Self::MAX
474 }
475
476 pub fn prev(self) -> Self {
477 Self(self.0.checked_sub(1).unwrap())
478 }
479}
480
481impl From<u64> for ProtocolVersion {
482 fn from(v: u64) -> Self {
483 Self::new(v)
484 }
485}
486
487impl std::ops::Sub<u64> for ProtocolVersion {
488 type Output = Self;
489 fn sub(self, rhs: u64) -> Self::Output {
490 Self::new(self.0 - rhs)
491 }
492}
493
494impl std::ops::Add<u64> for ProtocolVersion {
495 type Output = Self;
496 fn add(self, rhs: u64) -> Self::Output {
497 Self::new(self.0 + rhs)
498 }
499}
500
501#[derive(
502 Clone, Serialize, Deserialize, Debug, Default, PartialEq, Copy, PartialOrd, Ord, Eq, ValueEnum,
503)]
504pub enum Chain {
505 Mainnet,
506 Testnet,
507 #[default]
508 Unknown,
509}
510
511impl Chain {
512 pub fn as_str(self) -> &'static str {
513 match self {
514 Chain::Mainnet => "mainnet",
515 Chain::Testnet => "testnet",
516 Chain::Unknown => "unknown",
517 }
518 }
519}
520
521pub fn max_across_protocol<T: Ord>(f: impl Fn(&ProtocolConfig) -> Option<T>) -> Option<T> {
523 let mut max = None;
524 let mut version = ProtocolVersion::MIN;
525 while version <= ProtocolVersion::MAX {
526 max = max.max(f(&ProtocolConfig::get_for_version(version, Chain::Unknown)));
527 max = max.max(f(&ProtocolConfig::get_for_version(version, Chain::Mainnet)));
528 max = max.max(f(&ProtocolConfig::get_for_version(version, Chain::Testnet)));
529 version = version + 1;
530 }
531 max
532}
533
534pub struct Error(pub String);
535
536#[derive(Default, Clone, Serialize, Deserialize, Debug, ProtocolConfigFeatureFlagsGetters)]
539struct FeatureFlags {
540 #[serde(skip_serializing_if = "is_false")]
543 package_upgrades: bool,
544 #[serde(skip_serializing_if = "is_false")]
547 commit_root_state_digest: bool,
548 #[serde(skip_serializing_if = "is_false")]
550 advance_epoch_start_time_in_safe_mode: bool,
551 #[serde(skip_serializing_if = "is_false")]
554 loaded_child_objects_fixed: bool,
555 #[serde(skip_serializing_if = "is_false")]
558 missing_type_is_compatibility_error: bool,
559 #[serde(skip_serializing_if = "is_false")]
562 scoring_decision_with_validity_cutoff: bool,
563
564 #[serde(skip_serializing_if = "is_false")]
567 consensus_order_end_of_epoch_last: bool,
568
569 #[serde(skip_serializing_if = "is_false")]
573 consensus_slim_block_propagation: bool,
574
575 #[serde(skip_serializing_if = "is_false")]
577 disallow_adding_abilities_on_upgrade: bool,
578 #[serde(skip_serializing_if = "is_false")]
580 disable_invariant_violation_check_in_swap_loc: bool,
581 #[serde(skip_serializing_if = "is_false")]
584 advance_to_highest_supported_protocol_version: bool,
585 #[serde(skip_serializing_if = "is_false")]
587 ban_entry_init: bool,
588 #[serde(skip_serializing_if = "is_false")]
590 package_digest_hash_module: bool,
591 #[serde(skip_serializing_if = "is_false")]
593 disallow_change_struct_type_params_on_upgrade: bool,
594 #[serde(skip_serializing_if = "is_false")]
596 no_extraneous_module_bytes: bool,
597 #[serde(skip_serializing_if = "is_false")]
599 narwhal_versioned_metadata: bool,
600
601 #[serde(skip_serializing_if = "is_false")]
603 zklogin_auth: bool,
604 #[serde(skip_serializing_if = "is_zero")]
607 zklogin_circuit_mode: u64,
608 #[serde(skip_serializing_if = "ConsensusTransactionOrdering::is_none")]
610 consensus_transaction_ordering: ConsensusTransactionOrdering,
611
612 #[serde(skip_serializing_if = "is_false")]
620 simplified_unwrap_then_delete: bool,
621 #[serde(skip_serializing_if = "is_false")]
623 upgraded_multisig_supported: bool,
624 #[serde(skip_serializing_if = "is_false")]
626 txn_base_cost_as_multiplier: bool,
627
628 #[serde(skip_serializing_if = "is_false")]
630 shared_object_deletion: bool,
631
632 #[serde(skip_serializing_if = "is_false")]
634 narwhal_new_leader_election_schedule: bool,
635
636 #[serde(skip_serializing_if = "is_empty")]
638 zklogin_supported_providers: BTreeSet<String>,
639
640 #[serde(skip_serializing_if = "is_false")]
642 loaded_child_object_format: bool,
643
644 #[serde(skip_serializing_if = "is_false")]
645 #[skip_protocol_config_accessor]
646 enable_jwk_consensus_updates: bool,
647
648 #[serde(skip_serializing_if = "is_false")]
649 #[skip_protocol_config_accessor]
650 end_of_epoch_transaction_supported: bool,
651
652 #[serde(skip_serializing_if = "is_false")]
655 simple_conservation_checks: bool,
656
657 #[serde(skip_serializing_if = "is_false")]
659 loaded_child_object_format_type: bool,
660
661 #[serde(skip_serializing_if = "is_false")]
663 receive_objects: bool,
664
665 #[serde(skip_serializing_if = "is_false")]
667 consensus_checkpoint_signature_key_includes_digest: bool,
668
669 #[serde(skip_serializing_if = "is_false")]
671 random_beacon: bool,
672
673 #[serde(skip_serializing_if = "is_false")]
675 #[skip_protocol_config_accessor]
676 bridge: bool,
677
678 #[serde(skip_serializing_if = "is_false")]
679 enable_effects_v2: bool,
680
681 #[serde(skip_serializing_if = "is_false")]
683 narwhal_certificate_v2: bool,
684
685 #[serde(skip_serializing_if = "is_false")]
687 verify_legacy_zklogin_address: bool,
688
689 #[serde(skip_serializing_if = "is_false")]
691 throughput_aware_consensus_submission: bool,
692
693 #[serde(skip_serializing_if = "is_false")]
695 recompute_has_public_transfer_in_execution: bool,
696
697 #[serde(skip_serializing_if = "is_false")]
699 accept_zklogin_in_multisig: bool,
700
701 #[serde(skip_serializing_if = "is_false")]
703 accept_passkey_in_multisig: bool,
704
705 #[serde(skip_serializing_if = "is_false")]
707 validate_zklogin_public_identifier: bool,
708
709 #[serde(skip_serializing_if = "is_false")]
712 include_consensus_digest_in_prologue: bool,
713
714 #[serde(skip_serializing_if = "is_false")]
716 hardened_otw_check: bool,
717
718 #[serde(skip_serializing_if = "is_false")]
720 allow_receiving_object_id: bool,
721
722 #[serde(skip_serializing_if = "is_false")]
724 enable_poseidon: bool,
725
726 #[serde(skip_serializing_if = "is_false")]
728 enable_coin_deny_list: bool,
729
730 #[serde(skip_serializing_if = "is_false")]
732 enable_group_ops_native_functions: bool,
733
734 #[serde(skip_serializing_if = "is_false")]
736 enable_group_ops_native_function_msm: bool,
737
738 #[serde(skip_serializing_if = "is_false")]
740 enable_ristretto255_group_ops: bool,
741
742 #[serde(skip_serializing_if = "is_false")]
744 enable_verify_bulletproofs_ristretto255: bool,
745
746 #[serde(skip_serializing_if = "is_false")]
748 enable_nitro_attestation: bool,
749
750 #[serde(skip_serializing_if = "is_false")]
752 enable_nitro_attestation_upgraded_parsing: bool,
753
754 #[serde(skip_serializing_if = "is_false")]
756 enable_nitro_attestation_all_nonzero_pcrs_parsing: bool,
757
758 #[serde(skip_serializing_if = "is_false")]
760 enable_nitro_attestation_always_include_required_pcrs_parsing: bool,
761
762 #[serde(skip_serializing_if = "is_false")]
765 simplify_nitro_header_validation: bool,
766
767 #[serde(skip_serializing_if = "is_false")]
769 reject_mutable_random_on_entry_functions: bool,
770
771 #[serde(skip_serializing_if = "PerObjectCongestionControlMode::is_none")]
773 per_object_congestion_control_mode: PerObjectCongestionControlMode,
774
775 #[serde(skip_serializing_if = "ConsensusChoice::is_narwhal")]
777 consensus_choice: ConsensusChoice,
778
779 #[serde(skip_serializing_if = "ConsensusNetwork::is_anemo")]
781 consensus_network: ConsensusNetwork,
782
783 #[serde(skip_serializing_if = "is_false")]
785 correct_gas_payment_limit_check: bool,
786
787 #[serde(skip_serializing_if = "Option::is_none")]
789 zklogin_max_epoch_upper_bound_delta: Option<u64>,
790
791 #[serde(skip_serializing_if = "is_false")]
793 mysticeti_leader_scoring_and_schedule: bool,
794
795 #[serde(skip_serializing_if = "is_false")]
797 reshare_at_same_initial_version: bool,
798
799 #[serde(skip_serializing_if = "is_false")]
801 resolve_abort_locations_to_package_id: bool,
802
803 #[serde(skip_serializing_if = "is_false")]
807 mysticeti_use_committed_subdag_digest: bool,
808
809 #[serde(skip_serializing_if = "is_false")]
811 enable_vdf: bool,
812
813 #[serde(skip_serializing_if = "is_false")]
817 record_consensus_determined_version_assignments_in_prologue: bool,
818 #[serde(skip_serializing_if = "is_false")]
821 record_consensus_determined_version_assignments_in_prologue_v2: bool,
822
823 #[serde(skip_serializing_if = "is_false")]
825 fresh_vm_on_framework_upgrade: bool,
826
827 #[serde(skip_serializing_if = "is_false")]
835 prepend_prologue_tx_in_consensus_commit_in_checkpoints: bool,
836
837 #[serde(skip_serializing_if = "Option::is_none")]
839 mysticeti_num_leaders_per_round: Option<usize>,
840
841 #[serde(skip_serializing_if = "is_false")]
843 soft_bundle: bool,
844
845 #[serde(skip_serializing_if = "is_false")]
847 enable_coin_deny_list_v2: bool,
848
849 #[serde(skip_serializing_if = "is_false")]
851 passkey_auth: bool,
852
853 #[serde(skip_serializing_if = "is_false")]
856 mldsa65_auth: bool,
857
858 #[serde(skip_serializing_if = "is_false")]
860 secp256r1_ecrecover_checks_x_below_p: bool,
861
862 #[serde(skip_serializing_if = "is_false")]
864 complete_effects_size_estimate: bool,
865
866 #[serde(skip_serializing_if = "is_false")]
868 authority_capabilities_v2: bool,
869
870 #[serde(skip_serializing_if = "is_false")]
872 rethrow_serialization_type_layout_errors: bool,
873
874 #[serde(skip_serializing_if = "is_false")]
876 consensus_distributed_vote_scoring_strategy: bool,
877
878 #[serde(skip_serializing_if = "is_false")]
880 consensus_round_prober: bool,
881
882 #[serde(skip_serializing_if = "is_false")]
884 validate_identifier_inputs: bool,
885
886 #[serde(skip_serializing_if = "is_false")]
888 disallow_self_identifier: bool,
889
890 #[serde(skip_serializing_if = "is_false")]
892 mysticeti_fastpath: bool,
893
894 #[serde(skip_serializing_if = "is_false")]
898 disable_preconsensus_locking: bool,
899
900 #[serde(skip_serializing_if = "is_false")]
902 relocate_event_module: bool,
903
904 #[serde(skip_serializing_if = "is_false")]
906 uncompressed_g1_group_elements: bool,
907
908 #[serde(skip_serializing_if = "is_false")]
909 disallow_new_modules_in_deps_only_packages: bool,
910
911 #[serde(skip_serializing_if = "is_false")]
913 consensus_smart_ancestor_selection: bool,
914
915 #[serde(skip_serializing_if = "is_false")]
917 consensus_round_prober_probe_accepted_rounds: bool,
918
919 #[serde(skip_serializing_if = "is_false")]
921 native_charging_v2: bool,
922
923 #[serde(skip_serializing_if = "is_false")]
926 #[skip_protocol_config_accessor]
927 consensus_linearize_subdag_v2: bool,
928
929 #[serde(skip_serializing_if = "is_false")]
931 convert_type_argument_error: bool,
932
933 #[serde(skip_serializing_if = "is_false")]
935 variant_nodes: bool,
936
937 #[serde(skip_serializing_if = "is_false")]
939 consensus_zstd_compression: bool,
940
941 #[serde(skip_serializing_if = "is_false")]
943 minimize_child_object_mutations: bool,
944
945 #[serde(skip_serializing_if = "is_false")]
948 record_additional_state_digest_in_prologue: bool,
949
950 #[serde(skip_serializing_if = "is_false")]
952 move_native_context: bool,
953
954 #[serde(skip_serializing_if = "is_false")]
957 #[skip_protocol_config_accessor]
958 consensus_median_based_commit_timestamp: bool,
959
960 #[serde(skip_serializing_if = "is_false")]
963 normalize_ptb_arguments: bool,
964
965 #[serde(skip_serializing_if = "is_false")]
967 consensus_batched_block_sync: bool,
968
969 #[serde(skip_serializing_if = "is_false")]
971 enforce_checkpoint_timestamp_monotonicity: bool,
972
973 #[serde(skip_serializing_if = "is_false")]
975 max_ptb_value_size_v2: bool,
976
977 #[serde(skip_serializing_if = "is_false")]
979 resolve_type_input_ids_to_defining_id: bool,
980
981 #[serde(skip_serializing_if = "is_false")]
983 enable_party_transfer: bool,
984
985 #[serde(skip_serializing_if = "is_false")]
987 allow_unbounded_system_objects: bool,
988
989 #[serde(skip_serializing_if = "is_false")]
991 type_tags_in_object_runtime: bool,
992
993 #[serde(skip_serializing_if = "is_false")]
995 enable_accumulators: bool,
996
997 #[serde(skip_serializing_if = "is_false")]
999 #[skip_protocol_config_accessor]
1000 enable_coin_reservation_obj_refs: bool,
1001
1002 #[serde(skip_serializing_if = "is_false")]
1005 create_root_accumulator_object: bool,
1006
1007 #[serde(skip_serializing_if = "is_false")]
1009 #[skip_protocol_config_accessor]
1010 enable_authenticated_event_streams: bool,
1011
1012 #[serde(skip_serializing_if = "is_false")]
1014 enable_address_balance_gas_payments: bool,
1015
1016 #[serde(skip_serializing_if = "is_false")]
1018 address_balance_gas_check_rgp_at_signing: bool,
1019
1020 #[serde(skip_serializing_if = "is_false")]
1021 address_balance_gas_reject_gas_coin_arg: bool,
1022
1023 #[serde(skip_serializing_if = "is_false")]
1025 enable_multi_epoch_transaction_expiration: bool,
1026
1027 #[serde(skip_serializing_if = "is_false")]
1029 relax_valid_during_for_owned_inputs: bool,
1030
1031 #[serde(skip_serializing_if = "is_false")]
1033 enable_ptb_execution_v2: bool,
1034
1035 #[serde(skip_serializing_if = "is_false")]
1037 better_adapter_type_resolution_errors: bool,
1038
1039 #[serde(skip_serializing_if = "is_false")]
1041 record_time_estimate_processed: bool,
1042
1043 #[serde(skip_serializing_if = "is_false")]
1045 dependency_linkage_error: bool,
1046
1047 #[serde(skip_serializing_if = "is_false")]
1049 additional_multisig_checks: bool,
1050
1051 #[serde(skip_serializing_if = "is_false")]
1053 ignore_execution_time_observations_after_certs_closed: bool,
1054
1055 #[serde(skip_serializing_if = "is_false")]
1059 debug_fatal_on_move_invariant_violation: bool,
1060
1061 #[serde(skip_serializing_if = "is_false")]
1064 allow_private_accumulator_entrypoints: bool,
1065
1066 #[serde(skip_serializing_if = "is_false")]
1069 additional_consensus_digest_indirect_state: bool,
1070
1071 #[serde(skip_serializing_if = "is_false")]
1073 check_for_init_during_upgrade: bool,
1074
1075 #[serde(skip_serializing_if = "is_false")]
1077 enable_init_on_upgrade: bool,
1078
1079 #[serde(skip_serializing_if = "is_false")]
1081 enable_order_independent_upgrade_init_linkage: bool,
1082
1083 #[serde(skip_serializing_if = "is_false")]
1086 harden_linkage_consistency: bool,
1087
1088 #[serde(skip_serializing_if = "is_false")]
1090 per_command_shared_object_transfer_rules: bool,
1091
1092 #[serde(skip_serializing_if = "is_false")]
1094 validate_ptb_argument_indices: bool,
1095
1096 #[serde(skip_serializing_if = "is_false")]
1098 include_checkpoint_artifacts_digest_in_summary: bool,
1099
1100 #[serde(skip_serializing_if = "is_false")]
1102 use_mfp_txns_in_load_initial_object_debts: bool,
1103
1104 #[serde(skip_serializing_if = "is_false")]
1106 cancel_for_failed_dkg_early: bool,
1107
1108 #[serde(skip_serializing_if = "is_false")]
1110 always_advance_dkg_to_resolution: bool,
1111
1112 #[serde(skip_serializing_if = "is_false")]
1114 allow_dkg_completion_after_timeout: bool,
1115
1116 #[serde(skip_serializing_if = "is_false")]
1118 enable_coin_registry: bool,
1119
1120 #[serde(skip_serializing_if = "is_false")]
1122 abstract_size_in_object_runtime: bool,
1123
1124 #[serde(skip_serializing_if = "is_false")]
1126 object_runtime_charge_cache_load_gas: bool,
1127
1128 #[serde(skip_serializing_if = "is_false")]
1130 additional_borrow_checks: bool,
1131
1132 #[serde(skip_serializing_if = "is_false")]
1134 use_new_commit_handler: bool,
1135
1136 #[serde(skip_serializing_if = "is_false")]
1138 better_loader_errors: bool,
1139
1140 #[serde(skip_serializing_if = "is_false")]
1142 generate_df_type_layouts: bool,
1143
1144 #[serde(skip_serializing_if = "is_false")]
1146 allow_references_in_ptbs: bool,
1147
1148 #[serde(skip_serializing_if = "is_false")]
1155 framework_tx_context_mut_restrictions: bool,
1156
1157 #[serde(skip_serializing_if = "is_false")]
1159 include_function_signatures_in_instantiation_limits: bool,
1160
1161 #[serde(skip_serializing_if = "is_false")]
1166 ptb_tx_context_restrictions: bool,
1167
1168 #[serde(skip_serializing_if = "is_false")]
1170 enable_display_registry: bool,
1171
1172 #[serde(skip_serializing_if = "is_false")]
1174 private_generics_verifier_v2: bool,
1175
1176 #[serde(skip_serializing_if = "is_false")]
1178 deprecate_global_storage_ops_during_deserialization: bool,
1179
1180 #[serde(skip_serializing_if = "is_false")]
1183 enable_non_exclusive_writes: bool,
1184
1185 #[serde(skip_serializing_if = "is_false")]
1187 deprecate_global_storage_ops: bool,
1188
1189 #[serde(skip_serializing_if = "is_false")]
1191 normalize_depth_formula: bool,
1192
1193 #[serde(skip_serializing_if = "is_false")]
1196 charge_ld_const_abstract_size: bool,
1197
1198 #[serde(skip_serializing_if = "is_false")]
1200 consensus_skip_gced_accept_votes: bool,
1201
1202 #[serde(skip_serializing_if = "is_false")]
1205 include_cancelled_randomness_txns_in_prologue: bool,
1206
1207 #[serde(skip_serializing_if = "is_false")]
1209 #[skip_protocol_config_accessor]
1210 address_aliases: bool,
1211
1212 #[serde(skip_serializing_if = "is_false")]
1214 create_forwarding_address_registry: bool,
1215
1216 #[serde(skip_serializing_if = "is_false")]
1218 enable_forwarding_addresses: bool,
1219
1220 #[serde(skip_serializing_if = "is_false")]
1223 fix_checkpoint_signature_mapping: bool,
1224
1225 #[serde(skip_serializing_if = "is_false")]
1227 enable_object_funds_withdraw: bool,
1228
1229 #[serde(skip_serializing_if = "is_false")]
1232 record_net_unsettled_object_withdraws: bool,
1233
1234 #[serde(skip_serializing_if = "is_false")]
1236 consensus_skip_gced_blocks_in_direct_finalization: bool,
1237
1238 #[serde(skip_serializing_if = "is_false")]
1240 gas_rounding_halve_digits: bool,
1241
1242 #[serde(skip_serializing_if = "is_false")]
1244 flexible_tx_context_positions: bool,
1245
1246 #[serde(skip_serializing_if = "is_false")]
1248 disable_entry_point_signature_check: bool,
1249
1250 #[serde(skip_serializing_if = "is_false")]
1252 convert_withdrawal_compatibility_ptb_arguments: bool,
1253
1254 #[serde(skip_serializing_if = "is_false")]
1256 restrict_hot_or_not_entry_functions: bool,
1257
1258 #[serde(skip_serializing_if = "is_false")]
1260 split_checkpoints_in_consensus_handler: bool,
1261
1262 #[serde(skip_serializing_if = "is_false")]
1264 consensus_always_accept_system_transactions: bool,
1265
1266 #[serde(skip_serializing_if = "is_false")]
1268 validator_metadata_verify_v2: bool,
1269
1270 #[serde(skip_serializing_if = "is_false")]
1273 defer_unpaid_amplification: bool,
1274
1275 #[serde(skip_serializing_if = "is_false")]
1278 defer_owned_object_double_spend: bool,
1279
1280 #[serde(skip_serializing_if = "is_false")]
1283 allowed_proposers: bool,
1284
1285 #[serde(skip_serializing_if = "is_false")]
1291 #[skip_protocol_config_accessor]
1292 staggered_submission_signal: bool,
1293
1294 #[serde(skip_serializing_if = "is_false")]
1295 randomize_checkpoint_tx_limit_in_tests: bool,
1296
1297 #[serde(skip_serializing_if = "is_false")]
1299 gasless_transaction_drop_safety: bool,
1300
1301 #[serde(skip_serializing_if = "is_false")]
1304 merge_randomness_into_checkpoint: bool,
1305
1306 #[serde(skip_serializing_if = "is_false")]
1308 use_coin_party_owner: bool,
1309
1310 #[serde(skip_serializing_if = "is_false")]
1311 enable_gasless: bool,
1312
1313 #[serde(skip_serializing_if = "is_false")]
1314 gasless_verify_remaining_balance: bool,
1315
1316 #[serde(skip_serializing_if = "is_false")]
1317 disallow_jump_orphans: bool,
1318
1319 #[serde(skip_serializing_if = "is_false")]
1321 early_return_receive_object_mismatched_type: bool,
1322
1323 #[serde(skip_serializing_if = "is_false")]
1328 timestamp_based_epoch_close: bool,
1329
1330 #[serde(skip_serializing_if = "is_false")]
1333 limit_groth16_pvk_inputs: bool,
1334
1335 #[serde(skip_serializing_if = "is_false")]
1339 check_groth16_pvk_length: bool,
1340
1341 #[serde(skip_serializing_if = "is_false")]
1346 enforce_address_balance_change_invariant: bool,
1347
1348 #[serde(skip_serializing_if = "is_false")]
1350 share_transaction_deny_config_in_consensus: bool,
1351
1352 #[serde(skip_serializing_if = "is_false")]
1354 granular_post_execution_checks: bool,
1355
1356 #[serde(skip_serializing_if = "is_false")]
1358 early_exit_on_iffw: bool,
1359
1360 #[serde(skip_serializing_if = "is_false")]
1362 enable_unified_linkage: bool,
1363
1364 #[serde(skip_serializing_if = "is_false")]
1366 package_publish_charge: bool,
1367
1368 #[serde(skip_serializing_if = "is_false")]
1371 #[skip_protocol_config_accessor]
1372 enable_allowances: bool,
1373
1374 #[serde(skip_serializing_if = "is_false")]
1376 fix_ptb_generated_reads: bool,
1377
1378 #[serde(skip_serializing_if = "is_false")]
1379 check_object_funds_withdraw_in_execution: bool,
1380 #[serde(skip_serializing_if = "is_false")]
1382 memory_safety_invariant_check_v2: bool,
1383
1384 #[serde(skip_serializing_if = "is_false")]
1386 disable_effects_tx_dependencies: bool,
1387
1388 #[serde(skip_serializing_if = "is_false")]
1392 merge_colliding_deferrals: bool,
1393
1394 #[serde(skip_serializing_if = "is_false")]
1398 shuffle_consensus_commit_blocks: bool,
1399
1400 #[serde(skip_serializing_if = "is_false")]
1403 disable_id_leak_verifier: bool,
1404}
1405
1406fn is_false(b: &bool) -> bool {
1407 !b
1408}
1409
1410fn is_empty(b: &BTreeSet<String>) -> bool {
1411 b.is_empty()
1412}
1413
1414fn is_zero(val: &u64) -> bool {
1415 *val == 0
1416}
1417
1418#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1420pub enum ConsensusTransactionOrdering {
1421 #[default]
1423 None,
1424 ByGasPrice,
1426}
1427
1428impl ConsensusTransactionOrdering {
1429 pub fn is_none(&self) -> bool {
1430 matches!(self, ConsensusTransactionOrdering::None)
1431 }
1432}
1433
1434#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1435pub struct ExecutionTimeEstimateParams {
1436 pub target_utilization: u64,
1438 pub allowed_txn_cost_overage_burst_limit_us: u64,
1442
1443 pub randomness_scalar: u64,
1446
1447 pub max_estimate_us: u64,
1449
1450 pub stored_observations_num_included_checkpoints: u64,
1453
1454 pub stored_observations_limit: u64,
1456
1457 #[serde(skip_serializing_if = "is_zero")]
1460 pub stake_weighted_median_threshold: u64,
1461
1462 #[serde(skip_serializing_if = "is_false")]
1466 pub default_none_duration_for_new_keys: bool,
1467
1468 #[serde(skip_serializing_if = "Option::is_none")]
1470 pub observations_chunk_size: Option<u64>,
1471}
1472
1473#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1475pub enum PerObjectCongestionControlMode {
1476 #[default]
1477 None, TotalGasBudget, TotalTxCount, TotalGasBudgetWithCap, ExecutionTimeEstimate(ExecutionTimeEstimateParams), }
1483
1484impl PerObjectCongestionControlMode {
1485 pub fn is_none(&self) -> bool {
1486 matches!(self, PerObjectCongestionControlMode::None)
1487 }
1488}
1489
1490#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1492pub enum ConsensusChoice {
1493 #[default]
1494 Narwhal,
1495 SwapEachEpoch,
1496 Mysticeti,
1497}
1498
1499impl ConsensusChoice {
1500 pub fn is_narwhal(&self) -> bool {
1501 matches!(self, ConsensusChoice::Narwhal)
1502 }
1503}
1504
1505#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1507pub enum ConsensusNetwork {
1508 #[default]
1509 Anemo,
1510 Tonic,
1511}
1512
1513impl ConsensusNetwork {
1514 pub fn is_anemo(&self) -> bool {
1515 matches!(self, ConsensusNetwork::Anemo)
1516 }
1517}
1518
1519#[skip_serializing_none]
1551#[derive(Clone, Serialize, Debug, ProtocolConfigAccessors, ProtocolConfigOverride)]
1552pub struct ProtocolConfig {
1553 pub version: ProtocolVersion,
1554
1555 #[serde(skip)]
1560 chain: Chain,
1561
1562 feature_flags: FeatureFlags,
1563
1564 max_tx_size_bytes: Option<u64>,
1567
1568 max_input_objects: Option<u64>,
1570
1571 max_size_written_objects: Option<u64>,
1575 max_size_written_objects_system_tx: Option<u64>,
1578
1579 max_serialized_tx_effects_size_bytes: Option<u64>,
1581
1582 max_serialized_tx_effects_size_bytes_system_tx: Option<u64>,
1584
1585 max_gas_payment_objects: Option<u32>,
1587
1588 max_modules_in_publish: Option<u32>,
1590
1591 max_package_dependencies: Option<u32>,
1593
1594 max_arguments: Option<u32>,
1597
1598 max_type_arguments: Option<u32>,
1600
1601 max_type_argument_depth: Option<u32>,
1603
1604 max_pure_argument_size: Option<u32>,
1606
1607 max_programmable_tx_commands: Option<u32>,
1609
1610 move_binary_format_version: Option<u32>,
1613 min_move_binary_format_version: Option<u32>,
1614
1615 binary_module_handles: Option<u16>,
1617 binary_struct_handles: Option<u16>,
1618 binary_function_handles: Option<u16>,
1619 binary_function_instantiations: Option<u16>,
1620 binary_signatures: Option<u16>,
1621 binary_constant_pool: Option<u16>,
1622 binary_identifiers: Option<u16>,
1623 binary_address_identifiers: Option<u16>,
1624 binary_struct_defs: Option<u16>,
1625 binary_struct_def_instantiations: Option<u16>,
1626 binary_function_defs: Option<u16>,
1627 binary_field_handles: Option<u16>,
1628 binary_field_instantiations: Option<u16>,
1629 binary_friend_decls: Option<u16>,
1630 binary_enum_defs: Option<u16>,
1631 binary_enum_def_instantiations: Option<u16>,
1632 binary_variant_handles: Option<u16>,
1633 binary_variant_instantiation_handles: Option<u16>,
1634
1635 #[skip_accessor]
1637 binary_format_limits_profile: Option<BinaryFormatLimitsProfile>,
1638
1639 max_move_object_size: Option<u64>,
1641
1642 max_move_package_size: Option<u64>,
1645
1646 max_publish_or_upgrade_per_ptb: Option<u64>,
1648
1649 max_tx_gas: Option<u64>,
1651
1652 max_gas_price: Option<u64>,
1654
1655 max_gas_price_rgp_factor_for_aborted_transactions: Option<u64>,
1658
1659 max_gas_computation_bucket: Option<u64>,
1661
1662 gas_rounding_step: Option<u64>,
1664
1665 max_loop_depth: Option<u64>,
1667
1668 max_generic_instantiation_length: Option<u64>,
1670
1671 max_function_parameters: Option<u64>,
1673
1674 max_basic_blocks: Option<u64>,
1676
1677 max_value_stack_size: Option<u64>,
1679
1680 max_type_nodes: Option<u64>,
1682
1683 max_generic_instantiation_type_nodes_per_function: Option<u64>,
1685
1686 max_generic_instantiation_type_nodes_per_module: Option<u64>,
1688
1689 max_accumulator_type_nodes: Option<u64>,
1691
1692 max_push_size: Option<u64>,
1694
1695 max_struct_definitions: Option<u64>,
1697
1698 max_function_definitions: Option<u64>,
1700
1701 max_fields_in_struct: Option<u64>,
1703
1704 max_dependency_depth: Option<u64>,
1706
1707 max_num_event_emit: Option<u64>,
1709
1710 max_num_accumulator_events: Option<u64>,
1714
1715 max_num_new_move_object_ids: Option<u64>,
1717
1718 max_num_new_move_object_ids_system_tx: Option<u64>,
1720
1721 max_num_deleted_move_object_ids: Option<u64>,
1723
1724 max_num_deleted_move_object_ids_system_tx: Option<u64>,
1726
1727 max_num_transferred_move_object_ids: Option<u64>,
1729
1730 max_num_transferred_move_object_ids_system_tx: Option<u64>,
1732
1733 max_event_emit_size: Option<u64>,
1735
1736 max_event_emit_size_total: Option<u64>,
1738
1739 max_move_vector_len: Option<u64>,
1741
1742 max_move_identifier_len: Option<u64>,
1744
1745 max_move_value_depth: Option<u64>,
1747
1748 package_arena_size_in_bytes: Option<u64>,
1751
1752 max_move_enum_variants: Option<u64>,
1754
1755 max_back_edges_per_function: Option<u64>,
1757
1758 max_back_edges_per_module: Option<u64>,
1760
1761 max_verifier_meter_ticks_per_function: Option<u64>,
1763
1764 max_meter_ticks_per_module: Option<u64>,
1766
1767 max_meter_ticks_per_package: Option<u64>,
1769
1770 object_runtime_max_num_cached_objects: Option<u64>,
1774
1775 object_runtime_max_num_cached_objects_system_tx: Option<u64>,
1777
1778 object_runtime_max_num_store_entries: Option<u64>,
1780
1781 object_runtime_max_num_store_entries_system_tx: Option<u64>,
1783
1784 base_tx_cost_fixed: Option<u64>,
1787
1788 package_publish_cost_fixed: Option<u64>,
1791
1792 base_tx_cost_per_byte: Option<u64>,
1795
1796 package_publish_cost_per_byte: Option<u64>,
1798
1799 package_publish_charge_fixed: Option<u64>,
1801
1802 package_publish_charge_per_module: Option<u64>,
1804
1805 package_publish_charge_per_dependency: Option<u64>,
1807
1808 obj_access_cost_read_per_byte: Option<u64>,
1810
1811 obj_access_cost_read_per_package_kb: Option<u64>,
1814
1815 obj_access_cost_mutate_per_byte: Option<u64>,
1817
1818 obj_access_cost_delete_per_byte: Option<u64>,
1820
1821 obj_access_cost_verify_per_byte: Option<u64>,
1831
1832 max_type_to_layout_nodes: Option<u64>,
1834
1835 max_ptb_value_size: Option<u64>,
1837
1838 gas_model_version: Option<u64>,
1841
1842 obj_data_cost_refundable: Option<u64>,
1845
1846 obj_metadata_cost_non_refundable: Option<u64>,
1850
1851 storage_rebate_rate: Option<u64>,
1857
1858 storage_fund_reinvest_rate: Option<u64>,
1861
1862 reward_slashing_rate: Option<u64>,
1865
1866 storage_gas_price: Option<u64>,
1868
1869 accumulator_object_storage_cost: Option<u64>,
1871
1872 max_transactions_per_checkpoint: Option<u64>,
1877
1878 max_checkpoint_size_bytes: Option<u64>,
1882
1883 buffer_stake_for_protocol_upgrade_bps: Option<u64>,
1888
1889 address_from_bytes_cost_base: Option<u64>,
1894 address_to_u256_cost_base: Option<u64>,
1896 address_from_u256_cost_base: Option<u64>,
1898
1899 config_read_setting_impl_cost_base: Option<u64>,
1904 config_read_setting_impl_cost_per_byte: Option<u64>,
1905
1906 package_original_package_id_impl_cost_base: Option<u64>,
1907 package_original_package_id_impl_cost_per_byte: Option<u64>,
1908
1909 dynamic_field_hash_type_and_key_cost_base: Option<u64>,
1912 dynamic_field_hash_type_and_key_type_cost_per_byte: Option<u64>,
1913 dynamic_field_hash_type_and_key_value_cost_per_byte: Option<u64>,
1914 dynamic_field_hash_type_and_key_type_tag_cost_per_byte: Option<u64>,
1915 dynamic_field_add_child_object_cost_base: Option<u64>,
1917 dynamic_field_add_child_object_type_cost_per_byte: Option<u64>,
1918 dynamic_field_add_child_object_value_cost_per_byte: Option<u64>,
1919 dynamic_field_add_child_object_struct_tag_cost_per_byte: Option<u64>,
1920 dynamic_field_borrow_child_object_cost_base: Option<u64>,
1922 dynamic_field_borrow_child_object_child_ref_cost_per_byte: Option<u64>,
1923 dynamic_field_borrow_child_object_type_cost_per_byte: Option<u64>,
1924 dynamic_field_remove_child_object_cost_base: Option<u64>,
1926 dynamic_field_remove_child_object_child_cost_per_byte: Option<u64>,
1927 dynamic_field_remove_child_object_type_cost_per_byte: Option<u64>,
1928 dynamic_field_has_child_object_cost_base: Option<u64>,
1930 dynamic_field_has_child_object_with_ty_cost_base: Option<u64>,
1932 dynamic_field_has_child_object_with_ty_type_cost_per_byte: Option<u64>,
1933 dynamic_field_has_child_object_with_ty_type_tag_cost_per_byte: Option<u64>,
1934
1935 scratch_add_cost_base: Option<u64>,
1938 scratch_read_cost_base: Option<u64>,
1940 scratch_read_value_cost: Option<u64>,
1941 scratch_remove_cost_base: Option<u64>,
1943 scratch_exists_cost_base: Option<u64>,
1945 scratch_exists_with_type_cost_base: Option<u64>,
1947 scratch_exists_with_type_type_cost: Option<u64>,
1948 max_scratch_pad_size: Option<u64>,
1950
1951 event_emit_cost_base: Option<u64>,
1954 event_emit_value_size_derivation_cost_per_byte: Option<u64>,
1955 event_emit_tag_size_derivation_cost_per_byte: Option<u64>,
1956 event_emit_output_cost_per_byte: Option<u64>,
1957 event_emit_auth_stream_cost: Option<u64>,
1958
1959 reserve_object_funds_for_withdrawal_cost_base: Option<u64>,
1962 reserve_object_funds_for_withdrawal_cold_read_cost: Option<u64>,
1964
1965 object_borrow_uid_cost_base: Option<u64>,
1968 object_delete_impl_cost_base: Option<u64>,
1970 object_record_new_uid_cost_base: Option<u64>,
1972 object_record_new_uid_from_hash_cost_base: Option<u64>,
1975 object_is_shared_input_cost_base: Option<u64>,
1977
1978 transfer_transfer_internal_cost_base: Option<u64>,
1981 transfer_party_transfer_internal_cost_base: Option<u64>,
1983 transfer_freeze_object_cost_base: Option<u64>,
1985 transfer_share_object_cost_base: Option<u64>,
1987 transfer_receive_object_cost_base: Option<u64>,
1990 transfer_receive_object_cost_per_byte: Option<u64>,
1991 transfer_receive_object_type_cost_per_byte: Option<u64>,
1992
1993 tx_context_derive_id_cost_base: Option<u64>,
1996 tx_context_fresh_id_cost_base: Option<u64>,
1997 tx_context_sender_cost_base: Option<u64>,
1998 tx_context_epoch_cost_base: Option<u64>,
1999 tx_context_epoch_timestamp_ms_cost_base: Option<u64>,
2000 tx_context_sponsor_cost_base: Option<u64>,
2001 tx_context_rgp_cost_base: Option<u64>,
2002 tx_context_gas_price_cost_base: Option<u64>,
2003 tx_context_gas_budget_cost_base: Option<u64>,
2004 tx_context_ids_created_cost_base: Option<u64>,
2005 tx_context_replace_cost_base: Option<u64>,
2006
2007 clock_borrow_cost_base: Option<u64>,
2010
2011 types_is_one_time_witness_cost_base: Option<u64>,
2014 types_is_one_time_witness_type_tag_cost_per_byte: Option<u64>,
2015 types_is_one_time_witness_type_cost_per_byte: Option<u64>,
2016
2017 validator_validate_metadata_cost_base: Option<u64>,
2020 validator_validate_metadata_data_cost_per_byte: Option<u64>,
2021
2022 crypto_invalid_arguments_cost: Option<u64>,
2024 bls12381_bls12381_min_sig_verify_cost_base: Option<u64>,
2026 bls12381_bls12381_min_sig_verify_msg_cost_per_byte: Option<u64>,
2027 bls12381_bls12381_min_sig_verify_msg_cost_per_block: Option<u64>,
2028
2029 bls12381_bls12381_min_pk_verify_cost_base: Option<u64>,
2031 bls12381_bls12381_min_pk_verify_msg_cost_per_byte: Option<u64>,
2032 bls12381_bls12381_min_pk_verify_msg_cost_per_block: Option<u64>,
2033
2034 ecdsa_k1_ecrecover_keccak256_cost_base: Option<u64>,
2036 ecdsa_k1_ecrecover_keccak256_msg_cost_per_byte: Option<u64>,
2037 ecdsa_k1_ecrecover_keccak256_msg_cost_per_block: Option<u64>,
2038 ecdsa_k1_ecrecover_sha256_cost_base: Option<u64>,
2039 ecdsa_k1_ecrecover_sha256_msg_cost_per_byte: Option<u64>,
2040 ecdsa_k1_ecrecover_sha256_msg_cost_per_block: Option<u64>,
2041
2042 ecdsa_k1_decompress_pubkey_cost_base: Option<u64>,
2044
2045 ecdsa_k1_secp256k1_verify_keccak256_cost_base: Option<u64>,
2047 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_byte: Option<u64>,
2048 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_block: Option<u64>,
2049 ecdsa_k1_secp256k1_verify_sha256_cost_base: Option<u64>,
2050 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_byte: Option<u64>,
2051 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_block: Option<u64>,
2052
2053 ecdsa_r1_ecrecover_keccak256_cost_base: Option<u64>,
2055 ecdsa_r1_ecrecover_keccak256_msg_cost_per_byte: Option<u64>,
2056 ecdsa_r1_ecrecover_keccak256_msg_cost_per_block: Option<u64>,
2057 ecdsa_r1_ecrecover_sha256_cost_base: Option<u64>,
2058 ecdsa_r1_ecrecover_sha256_msg_cost_per_byte: Option<u64>,
2059 ecdsa_r1_ecrecover_sha256_msg_cost_per_block: Option<u64>,
2060
2061 ecdsa_r1_secp256r1_verify_keccak256_cost_base: Option<u64>,
2063 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_byte: Option<u64>,
2064 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_block: Option<u64>,
2065 ecdsa_r1_secp256r1_verify_sha256_cost_base: Option<u64>,
2066 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_byte: Option<u64>,
2067 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_block: Option<u64>,
2068
2069 ecvrf_ecvrf_verify_cost_base: Option<u64>,
2071 ecvrf_ecvrf_verify_alpha_string_cost_per_byte: Option<u64>,
2072 ecvrf_ecvrf_verify_alpha_string_cost_per_block: Option<u64>,
2073
2074 ed25519_ed25519_verify_cost_base: Option<u64>,
2076 ed25519_ed25519_verify_msg_cost_per_byte: Option<u64>,
2077 ed25519_ed25519_verify_msg_cost_per_block: Option<u64>,
2078
2079 groth16_prepare_verifying_key_bls12381_cost_base: Option<u64>,
2081 groth16_prepare_verifying_key_bn254_cost_base: Option<u64>,
2082
2083 groth16_verify_groth16_proof_internal_bls12381_cost_base: Option<u64>,
2085 groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input: Option<u64>,
2086 groth16_verify_groth16_proof_internal_bn254_cost_base: Option<u64>,
2087 groth16_verify_groth16_proof_internal_bn254_cost_per_public_input: Option<u64>,
2088 groth16_verify_groth16_proof_internal_public_input_cost_per_byte: Option<u64>,
2089
2090 hash_blake2b256_cost_base: Option<u64>,
2092 hash_blake2b256_data_cost_per_byte: Option<u64>,
2093 hash_blake2b256_data_cost_per_block: Option<u64>,
2094
2095 hash_keccak256_cost_base: Option<u64>,
2097 hash_keccak256_data_cost_per_byte: Option<u64>,
2098 hash_keccak256_data_cost_per_block: Option<u64>,
2099
2100 poseidon_bn254_cost_base: Option<u64>,
2102 poseidon_bn254_cost_per_block: Option<u64>,
2103
2104 group_ops_bls12381_decode_scalar_cost: Option<u64>,
2106 group_ops_bls12381_decode_g1_cost: Option<u64>,
2107 group_ops_bls12381_decode_g2_cost: Option<u64>,
2108 group_ops_bls12381_decode_gt_cost: Option<u64>,
2109 group_ops_bls12381_scalar_add_cost: Option<u64>,
2110 group_ops_bls12381_g1_add_cost: Option<u64>,
2111 group_ops_bls12381_g2_add_cost: Option<u64>,
2112 group_ops_bls12381_gt_add_cost: Option<u64>,
2113 group_ops_bls12381_scalar_sub_cost: Option<u64>,
2114 group_ops_bls12381_g1_sub_cost: Option<u64>,
2115 group_ops_bls12381_g2_sub_cost: Option<u64>,
2116 group_ops_bls12381_gt_sub_cost: Option<u64>,
2117 group_ops_bls12381_scalar_mul_cost: Option<u64>,
2118 group_ops_bls12381_g1_mul_cost: Option<u64>,
2119 group_ops_bls12381_g2_mul_cost: Option<u64>,
2120 group_ops_bls12381_gt_mul_cost: Option<u64>,
2121 group_ops_bls12381_scalar_div_cost: Option<u64>,
2122 group_ops_bls12381_g1_div_cost: Option<u64>,
2123 group_ops_bls12381_g2_div_cost: Option<u64>,
2124 group_ops_bls12381_gt_div_cost: Option<u64>,
2125 group_ops_bls12381_g1_hash_to_base_cost: Option<u64>,
2126 group_ops_bls12381_g2_hash_to_base_cost: Option<u64>,
2127 group_ops_bls12381_g1_hash_to_cost_per_byte: Option<u64>,
2128 group_ops_bls12381_g2_hash_to_cost_per_byte: Option<u64>,
2129 group_ops_bls12381_g1_msm_base_cost: Option<u64>,
2130 group_ops_bls12381_g2_msm_base_cost: Option<u64>,
2131 group_ops_bls12381_g1_msm_base_cost_per_input: Option<u64>,
2132 group_ops_bls12381_g2_msm_base_cost_per_input: Option<u64>,
2133 group_ops_bls12381_msm_max_len: Option<u32>,
2134 group_ops_bls12381_pairing_cost: Option<u64>,
2135 group_ops_bls12381_g1_to_uncompressed_g1_cost: Option<u64>,
2136 group_ops_bls12381_uncompressed_g1_to_g1_cost: Option<u64>,
2137 group_ops_bls12381_uncompressed_g1_sum_base_cost: Option<u64>,
2138 group_ops_bls12381_uncompressed_g1_sum_cost_per_term: Option<u64>,
2139 group_ops_bls12381_uncompressed_g1_sum_max_terms: Option<u64>,
2140
2141 group_ops_ristretto_decode_scalar_cost: Option<u64>,
2142 group_ops_ristretto_decode_point_cost: Option<u64>,
2143 group_ops_ristretto_scalar_add_cost: Option<u64>,
2144 group_ops_ristretto_point_add_cost: Option<u64>,
2145 group_ops_ristretto_scalar_sub_cost: Option<u64>,
2146 group_ops_ristretto_point_sub_cost: Option<u64>,
2147 group_ops_ristretto_scalar_mul_cost: Option<u64>,
2148 group_ops_ristretto_point_mul_cost: Option<u64>,
2149 group_ops_ristretto_scalar_div_cost: Option<u64>,
2150 group_ops_ristretto_point_div_cost: Option<u64>,
2151
2152 verify_bulletproofs_ristretto255_base_cost: Option<u64>,
2153 verify_bulletproofs_ristretto255_cost_per_bit_and_commitment: Option<u64>,
2154 max_bulletproofs_total_bits: Option<u64>,
2157
2158 hmac_hmac_sha3_256_cost_base: Option<u64>,
2160 hmac_hmac_sha3_256_input_cost_per_byte: Option<u64>,
2161 hmac_hmac_sha3_256_input_cost_per_block: Option<u64>,
2162
2163 check_zklogin_id_cost_base: Option<u64>,
2165 check_zklogin_issuer_cost_base: Option<u64>,
2167
2168 vdf_verify_vdf_cost: Option<u64>,
2169 vdf_hash_to_input_cost: Option<u64>,
2170
2171 nitro_attestation_parse_base_cost: Option<u64>,
2173 nitro_attestation_parse_cost_per_byte: Option<u64>,
2174 nitro_attestation_verify_base_cost: Option<u64>,
2175 nitro_attestation_verify_cost_per_cert: Option<u64>,
2176
2177 bcs_per_byte_serialized_cost: Option<u64>,
2179 bcs_legacy_min_output_size_cost: Option<u64>,
2180 bcs_failure_cost: Option<u64>,
2181
2182 hash_sha2_256_base_cost: Option<u64>,
2183 hash_sha2_256_per_byte_cost: Option<u64>,
2184 hash_sha2_256_legacy_min_input_len_cost: Option<u64>,
2185 hash_sha3_256_base_cost: Option<u64>,
2186 hash_sha3_256_per_byte_cost: Option<u64>,
2187 hash_sha3_256_legacy_min_input_len_cost: Option<u64>,
2188 type_name_get_base_cost: Option<u64>,
2189 type_name_get_per_byte_cost: Option<u64>,
2190 type_name_id_base_cost: Option<u64>,
2191
2192 string_check_utf8_base_cost: Option<u64>,
2193 string_check_utf8_per_byte_cost: Option<u64>,
2194 string_is_char_boundary_base_cost: Option<u64>,
2195 string_sub_string_base_cost: Option<u64>,
2196 string_sub_string_per_byte_cost: Option<u64>,
2197 string_index_of_base_cost: Option<u64>,
2198 string_index_of_per_byte_pattern_cost: Option<u64>,
2199 string_index_of_per_byte_searched_cost: Option<u64>,
2200
2201 vector_empty_base_cost: Option<u64>,
2202 vector_length_base_cost: Option<u64>,
2203 vector_push_back_base_cost: Option<u64>,
2204 vector_push_back_legacy_per_abstract_memory_unit_cost: Option<u64>,
2205 vector_borrow_base_cost: Option<u64>,
2206 vector_pop_back_base_cost: Option<u64>,
2207 vector_destroy_empty_base_cost: Option<u64>,
2208 vector_swap_base_cost: Option<u64>,
2209 vector_reverse_base_cost: Option<u64>,
2210 vector_reverse_per_elem_cost: Option<u64>,
2211 vector_keep_range_base_cost: Option<u64>,
2212 vector_keep_range_per_dropped_elem_cost: Option<u64>,
2213 vector_keep_range_per_moved_elem_cost: Option<u64>,
2214 vector_copy_range_base_cost: Option<u64>,
2215 vector_replace_range_base_cost: Option<u64>,
2216 vector_replace_range_per_elem_cost: Option<u64>,
2217 debug_print_base_cost: Option<u64>,
2218 debug_print_stack_trace_base_cost: Option<u64>,
2219
2220 #[custom_setter]
2230 execution_version: Option<u64>,
2231
2232 consensus_bad_nodes_stake_threshold: Option<u64>,
2236
2237 max_jwk_votes_per_validator_per_epoch: Option<u64>,
2238 max_age_of_jwk_in_epochs: Option<u64>,
2242
2243 random_beacon_reduction_allowed_delta: Option<u16>,
2247
2248 random_beacon_reduction_lower_bound: Option<u32>,
2251
2252 random_beacon_dkg_timeout_round: Option<u32>,
2255
2256 random_beacon_min_round_interval_ms: Option<u64>,
2258
2259 random_beacon_dkg_version: Option<u64>,
2262
2263 consensus_max_transaction_size_bytes: Option<u64>,
2266 consensus_max_transactions_in_block_bytes: Option<u64>,
2268 consensus_max_num_transactions_in_block: Option<u64>,
2270
2271 consensus_voting_rounds: Option<u32>,
2273
2274 max_accumulated_txn_cost_per_object_in_narwhal_commit: Option<u64>,
2276
2277 max_deferral_rounds_for_congestion_control: Option<u64>,
2280
2281 epoch_close_deadline_ms: Option<u64>,
2286
2287 max_txn_cost_overage_per_object_in_commit: Option<u64>,
2289
2290 allowed_txn_cost_overage_burst_per_object_in_commit: Option<u64>,
2292
2293 min_checkpoint_interval_ms: Option<u64>,
2295
2296 checkpoint_summary_version_specific_data: Option<u64>,
2298
2299 max_soft_bundle_size: Option<u64>,
2301
2302 bridge_should_try_to_finalize_committee: Option<bool>,
2306
2307 max_accumulated_txn_cost_per_object_in_mysticeti_commit: Option<u64>,
2313
2314 max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit: Option<u64>,
2317
2318 consensus_gc_depth: Option<u32>,
2321
2322 gas_budget_based_txn_cost_cap_factor: Option<u64>,
2324
2325 gas_budget_based_txn_cost_absolute_cap_commit_count: Option<u64>,
2327
2328 sip_45_consensus_amplification_threshold: Option<u64>,
2331
2332 staggered_submission_signal_window_commits: Option<u64>,
2335 staggered_submission_signal_min_excess_copies_per_commit: Option<u64>,
2337 staggered_submission_signal_exit_dwell_commits: Option<u64>,
2340 staggered_submission_signal_band1_enter_ratio_bps: Option<u64>,
2343 staggered_submission_signal_band1_exit_ratio_bps: Option<u64>,
2344 staggered_submission_signal_band2_enter_ratio_bps: Option<u64>,
2345 staggered_submission_signal_band2_exit_ratio_bps: Option<u64>,
2346
2347 use_object_per_epoch_marker_table_v2: Option<bool>,
2350
2351 consensus_commit_rate_estimation_window_size: Option<u32>,
2353
2354 #[serde(skip_serializing_if = "Vec::is_empty")]
2358 aliased_addresses: Vec<AliasedAddress>,
2359
2360 translation_per_command_base_charge: Option<u64>,
2363
2364 translation_per_input_base_charge: Option<u64>,
2367
2368 translation_pure_input_per_byte_charge: Option<u64>,
2370
2371 translation_per_type_node_charge: Option<u64>,
2375
2376 translation_per_reference_node_charge: Option<u64>,
2379
2380 translation_per_linkage_entry_charge: Option<u64>,
2383
2384 max_updates_per_settlement_txn: Option<u32>,
2386
2387 gasless_max_computation_units: Option<u64>,
2389
2390 gasless_allowed_token_types: Option<Vec<(String, u64)>>,
2392
2393 gasless_max_unused_inputs: Option<u64>,
2397
2398 gasless_max_pure_input_bytes: Option<u64>,
2401
2402 gasless_max_tps: Option<u64>,
2404
2405 #[serde(skip_serializing_if = "Option::is_none")]
2406 #[skip_accessor]
2407 include_special_package_amendments: Option<Arc<Amendments>>,
2408
2409 gasless_max_tx_size_bytes: Option<u64>,
2412
2413 translation_per_live_reference_charge: Option<u64>,
2416
2417 max_ptb_live_references: Option<u64>,
2420
2421 max_ptb_returned_references: Option<u64>,
2424
2425 max_ptb_total_returned_references: Option<u64>,
2428}
2429
2430#[derive(Clone, Serialize, Deserialize, Debug)]
2432pub struct AliasedAddress {
2433 pub original: [u8; 32],
2435 pub aliased: [u8; 32],
2437 pub allowed_tx_digests: Vec<[u8; 32]>,
2439}
2440
2441impl ProtocolConfig {
2443 pub fn chain(&self) -> Chain {
2445 self.chain
2446 }
2447
2448 pub fn check_package_upgrades_supported(&self) -> Result<(), Error> {
2461 if self.feature_flags.package_upgrades {
2462 Ok(())
2463 } else {
2464 Err(Error(format!(
2465 "package upgrades are not supported at {:?}",
2466 self.version
2467 )))
2468 }
2469 }
2470
2471 pub fn zklogin_supported_providers(&self) -> &BTreeSet<String> {
2472 &self.feature_flags.zklogin_supported_providers
2473 }
2474
2475 pub fn zklogin_circuit_mode(&self) -> u64 {
2478 self.feature_flags.zklogin_circuit_mode
2479 }
2480
2481 pub fn consensus_transaction_ordering(&self) -> ConsensusTransactionOrdering {
2482 self.feature_flags.consensus_transaction_ordering
2483 }
2484
2485 pub fn enable_jwk_consensus_updates(&self) -> bool {
2486 let ret = self.feature_flags.enable_jwk_consensus_updates;
2487 if ret {
2488 assert!(self.feature_flags.end_of_epoch_transaction_supported);
2490 }
2491 ret
2492 }
2493
2494 pub fn staggered_submission_signal(&self) -> bool {
2495 let ret = self.feature_flags.staggered_submission_signal;
2496 if ret {
2497 assert!(self.feature_flags.allowed_proposers);
2500 }
2501 ret
2502 }
2503
2504 pub fn end_of_epoch_transaction_supported(&self) -> bool {
2505 let ret = self.feature_flags.end_of_epoch_transaction_supported;
2506 if !ret {
2507 assert!(!self.feature_flags.enable_jwk_consensus_updates);
2509 }
2510 ret
2511 }
2512
2513 pub fn dkg_version(&self) -> u64 {
2514 self.random_beacon_dkg_version.unwrap_or(1)
2516 }
2517
2518 pub fn bridge(&self) -> bool {
2519 let ret = self.feature_flags.bridge;
2520 if ret {
2521 assert!(self.feature_flags.end_of_epoch_transaction_supported);
2523 }
2524 ret
2525 }
2526
2527 pub fn should_try_to_finalize_bridge_committee(&self) -> bool {
2528 if !self.bridge() {
2529 return false;
2530 }
2531 self.bridge_should_try_to_finalize_committee.unwrap_or(true)
2533 }
2534
2535 pub fn zklogin_max_epoch_upper_bound_delta(&self) -> Option<u64> {
2536 self.feature_flags.zklogin_max_epoch_upper_bound_delta
2537 }
2538
2539 pub fn enable_allowances(&self) -> bool {
2540 self.feature_flags.enable_allowances && self.enable_accumulators()
2541 }
2542
2543 pub fn enable_coin_reservation_obj_refs(&self) -> bool {
2544 self.new_vm_enabled() && self.feature_flags.enable_coin_reservation_obj_refs
2545 }
2546
2547 pub fn enable_authenticated_event_streams(&self) -> bool {
2548 self.feature_flags.enable_authenticated_event_streams && self.enable_accumulators()
2549 }
2550
2551 pub fn per_object_congestion_control_mode(&self) -> PerObjectCongestionControlMode {
2552 self.feature_flags.per_object_congestion_control_mode
2553 }
2554
2555 pub fn consensus_choice(&self) -> ConsensusChoice {
2556 self.feature_flags.consensus_choice
2557 }
2558
2559 pub fn consensus_network(&self) -> ConsensusNetwork {
2560 self.feature_flags.consensus_network
2561 }
2562
2563 pub fn mysticeti_num_leaders_per_round(&self) -> Option<usize> {
2564 self.feature_flags.mysticeti_num_leaders_per_round
2565 }
2566
2567 pub fn max_transaction_size_bytes(&self) -> u64 {
2568 self.consensus_max_transaction_size_bytes
2570 .unwrap_or(256 * 1024)
2571 }
2572
2573 pub fn max_transactions_in_block_bytes(&self) -> u64 {
2574 if cfg!(msim) {
2575 256 * 1024
2576 } else {
2577 self.consensus_max_transactions_in_block_bytes
2578 .unwrap_or(512 * 1024)
2579 }
2580 }
2581
2582 pub fn max_num_transactions_in_block(&self) -> u64 {
2583 if cfg!(msim) {
2584 8
2585 } else {
2586 self.consensus_max_num_transactions_in_block.unwrap_or(512)
2587 }
2588 }
2589
2590 pub fn gc_depth(&self) -> u32 {
2591 self.consensus_gc_depth.unwrap_or(0)
2592 }
2593
2594 pub fn consensus_linearize_subdag_v2(&self) -> bool {
2595 let res = self.feature_flags.consensus_linearize_subdag_v2;
2596 assert!(
2597 !res || self.gc_depth() > 0,
2598 "The consensus linearize sub dag V2 requires GC to be enabled"
2599 );
2600 res
2601 }
2602
2603 pub fn consensus_median_based_commit_timestamp(&self) -> bool {
2604 let res = self.feature_flags.consensus_median_based_commit_timestamp;
2605 assert!(
2606 !res || self.gc_depth() > 0,
2607 "The consensus median based commit timestamp requires GC to be enabled"
2608 );
2609 res
2610 }
2611
2612 pub fn get_consensus_commit_rate_estimation_window_size(&self) -> u32 {
2613 self.consensus_commit_rate_estimation_window_size
2614 .unwrap_or(0)
2615 }
2616
2617 pub fn consensus_num_requested_prior_commits_at_startup(&self) -> u32 {
2618 let window_size = self.get_consensus_commit_rate_estimation_window_size();
2622 assert!(window_size == 0 || self.record_additional_state_digest_in_prologue());
2624 window_size
2625 }
2626
2627 pub fn address_aliases(&self) -> bool {
2628 let address_aliases = self.feature_flags.address_aliases;
2629 assert!(
2630 !address_aliases || self.mysticeti_fastpath(),
2631 "Address aliases requires Mysticeti fastpath to be enabled"
2632 );
2633 if address_aliases {
2634 assert!(
2635 self.feature_flags.disable_preconsensus_locking,
2636 "Address aliases requires CertifiedTransaction to be disabled"
2637 );
2638 }
2639 address_aliases
2640 }
2641
2642 pub fn new_vm_enabled(&self) -> bool {
2643 self.execution_version.is_some_and(|v| v >= 4)
2644 }
2645
2646 pub fn gasless_allowed_token_types(&self) -> &[(String, u64)] {
2647 debug_assert!(self.gasless_allowed_token_types.is_some());
2648 self.gasless_allowed_token_types.as_deref().unwrap_or(&[])
2649 }
2650
2651 pub fn get_gasless_max_unused_inputs(&self) -> u64 {
2652 self.gasless_max_unused_inputs.unwrap_or(u64::MAX)
2653 }
2654
2655 pub fn get_gasless_max_pure_input_bytes(&self) -> u64 {
2656 self.gasless_max_pure_input_bytes.unwrap_or(u64::MAX)
2657 }
2658
2659 pub fn get_gasless_max_tx_size_bytes(&self) -> u64 {
2660 self.gasless_max_tx_size_bytes.unwrap_or(u64::MAX)
2661 }
2662
2663 pub fn include_special_package_amendments_as_option(&self) -> &Option<Arc<Amendments>> {
2664 &self.include_special_package_amendments
2665 }
2666}
2667
2668static POISON_VERSION_METHODS: AtomicBool = AtomicBool::new(false);
2669
2670impl ProtocolConfig {
2672 pub fn get_for_version(version: ProtocolVersion, chain: Chain) -> Self {
2674 assert!(
2676 version >= ProtocolVersion::MIN,
2677 "Network protocol version is {:?}, but the minimum supported version by the binary is {:?}. Please upgrade the binary.",
2678 version,
2679 ProtocolVersion::MIN.0,
2680 );
2681 assert!(
2682 version <= ProtocolVersion::MAX_ALLOWED,
2683 "Network protocol version is {:?}, but the maximum supported version by the binary is {:?}. Please upgrade the binary.",
2684 version,
2685 ProtocolVersion::MAX_ALLOWED.0,
2686 );
2687
2688 let mut ret = Self::get_for_version_impl(version, chain);
2689 ret.version = version;
2690 ret.chain = chain;
2691
2692 ret = Self::apply_config_override(version, ret);
2693
2694 if std::env::var("SUI_PROTOCOL_CONFIG_OVERRIDE_ENABLE").is_ok() {
2695 warn!(
2696 "overriding ProtocolConfig settings with custom settings; this may break non-local networks"
2697 );
2698 let overrides: ProtocolConfigOptional =
2699 serde_env::from_env_with_prefix("SUI_PROTOCOL_CONFIG_OVERRIDE")
2700 .expect("failed to parse ProtocolConfig override env variables");
2701 overrides.apply_to(&mut ret);
2702 }
2703
2704 ret
2705 }
2706
2707 pub fn get_for_version_if_supported(version: ProtocolVersion, chain: Chain) -> Option<Self> {
2710 if version.0 >= ProtocolVersion::MIN.0 && version.0 <= ProtocolVersion::MAX_ALLOWED.0 {
2711 let mut ret = Self::get_for_version_impl(version, chain);
2712 ret.version = version;
2713 ret.chain = chain;
2714 ret = Self::apply_config_override(version, ret);
2715 Some(ret)
2716 } else {
2717 None
2718 }
2719 }
2720
2721 pub fn poison_get_for_min_version() {
2722 POISON_VERSION_METHODS.store(true, Ordering::Relaxed);
2723 }
2724
2725 fn load_poison_get_for_min_version() -> bool {
2726 POISON_VERSION_METHODS.load(Ordering::Relaxed)
2727 }
2728
2729 pub fn get_for_min_version() -> Self {
2732 if Self::load_poison_get_for_min_version() {
2733 panic!("get_for_min_version called on validator");
2734 }
2735 ProtocolConfig::get_for_version(ProtocolVersion::MIN, Chain::Unknown)
2736 }
2737
2738 #[allow(non_snake_case)]
2748 pub fn get_for_max_version_UNSAFE() -> Self {
2749 if Self::load_poison_get_for_min_version() {
2750 panic!("get_for_max_version_UNSAFE called on validator");
2751 }
2752 ProtocolConfig::get_for_version(ProtocolVersion::MAX, Chain::Unknown)
2753 }
2754
2755 fn get_for_version_impl(version: ProtocolVersion, chain: Chain) -> Self {
2756 #[cfg(msim)]
2757 {
2758 if version == ProtocolVersion::MAX_ALLOWED {
2760 let mut config = Self::get_for_version_impl(version - 1, Chain::Unknown);
2761 config.base_tx_cost_fixed = Some(config.base_tx_cost_fixed() + 1000);
2762 return config;
2763 }
2764 }
2765
2766 let mut cfg = Self {
2769 version,
2771 chain,
2772
2773 feature_flags: Default::default(),
2775
2776 max_tx_size_bytes: Some(128 * 1024),
2777 max_input_objects: Some(2048),
2779 max_serialized_tx_effects_size_bytes: Some(512 * 1024),
2780 max_serialized_tx_effects_size_bytes_system_tx: Some(512 * 1024 * 16),
2781 max_gas_payment_objects: Some(256),
2782 max_modules_in_publish: Some(128),
2783 max_package_dependencies: None,
2784 max_arguments: Some(512),
2785 max_type_arguments: Some(16),
2786 max_type_argument_depth: Some(16),
2787 max_pure_argument_size: Some(16 * 1024),
2788 max_programmable_tx_commands: Some(1024),
2789 move_binary_format_version: Some(6),
2790 min_move_binary_format_version: None,
2791 binary_module_handles: None,
2792 binary_struct_handles: None,
2793 binary_function_handles: None,
2794 binary_function_instantiations: None,
2795 binary_signatures: None,
2796 binary_constant_pool: None,
2797 binary_identifiers: None,
2798 binary_address_identifiers: None,
2799 binary_struct_defs: None,
2800 binary_struct_def_instantiations: None,
2801 binary_function_defs: None,
2802 binary_field_handles: None,
2803 binary_field_instantiations: None,
2804 binary_friend_decls: None,
2805 binary_enum_defs: None,
2806 binary_enum_def_instantiations: None,
2807 binary_variant_handles: None,
2808 binary_variant_instantiation_handles: None,
2809 binary_format_limits_profile: None,
2810 max_move_object_size: Some(250 * 1024),
2811 max_move_package_size: Some(100 * 1024),
2812 max_publish_or_upgrade_per_ptb: None,
2813 max_tx_gas: Some(10_000_000_000),
2814 max_gas_price: Some(100_000),
2815 max_gas_price_rgp_factor_for_aborted_transactions: None,
2816 max_gas_computation_bucket: Some(5_000_000),
2817 max_loop_depth: Some(5),
2818 max_generic_instantiation_length: Some(32),
2819 max_function_parameters: Some(128),
2820 max_basic_blocks: Some(1024),
2821 max_value_stack_size: Some(1024),
2822 max_type_nodes: Some(256),
2823 max_generic_instantiation_type_nodes_per_function: None,
2824 max_generic_instantiation_type_nodes_per_module: None,
2825 max_accumulator_type_nodes: None,
2826 max_push_size: Some(10000),
2827 max_struct_definitions: Some(200),
2828 max_function_definitions: Some(1000),
2829 max_fields_in_struct: Some(32),
2830 max_dependency_depth: Some(100),
2831 max_num_event_emit: Some(256),
2832 max_num_accumulator_events: None,
2833 max_num_new_move_object_ids: Some(2048),
2834 max_num_new_move_object_ids_system_tx: Some(2048 * 16),
2835 max_num_deleted_move_object_ids: Some(2048),
2836 max_num_deleted_move_object_ids_system_tx: Some(2048 * 16),
2837 max_num_transferred_move_object_ids: Some(2048),
2838 max_num_transferred_move_object_ids_system_tx: Some(2048 * 16),
2839 max_event_emit_size: Some(250 * 1024),
2840 max_move_vector_len: Some(256 * 1024),
2841 max_type_to_layout_nodes: None,
2842 max_ptb_value_size: None,
2843
2844 max_back_edges_per_function: Some(10_000),
2845 max_back_edges_per_module: Some(10_000),
2846 max_verifier_meter_ticks_per_function: Some(6_000_000),
2847 max_meter_ticks_per_module: Some(6_000_000),
2848 max_meter_ticks_per_package: None,
2849
2850 object_runtime_max_num_cached_objects: Some(1000),
2851 object_runtime_max_num_cached_objects_system_tx: Some(1000 * 16),
2852 object_runtime_max_num_store_entries: Some(1000),
2853 object_runtime_max_num_store_entries_system_tx: Some(1000 * 16),
2854 base_tx_cost_fixed: Some(110_000),
2855 package_publish_cost_fixed: Some(1_000),
2856 base_tx_cost_per_byte: Some(0),
2857 package_publish_cost_per_byte: Some(80),
2858 package_publish_charge_fixed: None,
2859 package_publish_charge_per_module: None,
2860 package_publish_charge_per_dependency: None,
2861 obj_access_cost_read_per_byte: Some(15),
2862 obj_access_cost_read_per_package_kb: None,
2863 obj_access_cost_mutate_per_byte: Some(40),
2864 obj_access_cost_delete_per_byte: Some(40),
2865 obj_access_cost_verify_per_byte: Some(200),
2866 obj_data_cost_refundable: Some(100),
2867 obj_metadata_cost_non_refundable: Some(50),
2868 gas_model_version: Some(1),
2869 storage_rebate_rate: Some(9900),
2870 storage_fund_reinvest_rate: Some(500),
2871 reward_slashing_rate: Some(5000),
2872 storage_gas_price: Some(1),
2873 accumulator_object_storage_cost: None,
2874 max_transactions_per_checkpoint: Some(10_000),
2875 max_checkpoint_size_bytes: Some(30 * 1024 * 1024),
2876
2877 buffer_stake_for_protocol_upgrade_bps: Some(0),
2880
2881 address_from_bytes_cost_base: Some(52),
2885 address_to_u256_cost_base: Some(52),
2887 address_from_u256_cost_base: Some(52),
2889
2890 config_read_setting_impl_cost_base: None,
2893 config_read_setting_impl_cost_per_byte: None,
2894
2895 package_original_package_id_impl_cost_base: None,
2896 package_original_package_id_impl_cost_per_byte: None,
2897
2898 dynamic_field_hash_type_and_key_cost_base: Some(100),
2901 dynamic_field_hash_type_and_key_type_cost_per_byte: Some(2),
2902 dynamic_field_hash_type_and_key_value_cost_per_byte: Some(2),
2903 dynamic_field_hash_type_and_key_type_tag_cost_per_byte: Some(2),
2904 dynamic_field_add_child_object_cost_base: Some(100),
2906 dynamic_field_add_child_object_type_cost_per_byte: Some(10),
2907 dynamic_field_add_child_object_value_cost_per_byte: Some(10),
2908 dynamic_field_add_child_object_struct_tag_cost_per_byte: Some(10),
2909 dynamic_field_borrow_child_object_cost_base: Some(100),
2911 dynamic_field_borrow_child_object_child_ref_cost_per_byte: Some(10),
2912 dynamic_field_borrow_child_object_type_cost_per_byte: Some(10),
2913 dynamic_field_remove_child_object_cost_base: Some(100),
2915 dynamic_field_remove_child_object_child_cost_per_byte: Some(2),
2916 dynamic_field_remove_child_object_type_cost_per_byte: Some(2),
2917 dynamic_field_has_child_object_cost_base: Some(100),
2919 dynamic_field_has_child_object_with_ty_cost_base: Some(100),
2921 dynamic_field_has_child_object_with_ty_type_cost_per_byte: Some(2),
2922 dynamic_field_has_child_object_with_ty_type_tag_cost_per_byte: Some(2),
2923
2924 scratch_add_cost_base: None,
2926 scratch_read_cost_base: None,
2927 scratch_read_value_cost: None,
2928 scratch_remove_cost_base: None,
2929 scratch_exists_cost_base: None,
2930 scratch_exists_with_type_cost_base: None,
2931 scratch_exists_with_type_type_cost: None,
2932 max_scratch_pad_size: None,
2933
2934 event_emit_cost_base: Some(52),
2937 event_emit_value_size_derivation_cost_per_byte: Some(2),
2938 event_emit_tag_size_derivation_cost_per_byte: Some(5),
2939 event_emit_output_cost_per_byte: Some(10),
2940 event_emit_auth_stream_cost: None,
2941
2942 reserve_object_funds_for_withdrawal_cost_base: None,
2944 reserve_object_funds_for_withdrawal_cold_read_cost: None,
2945
2946 object_borrow_uid_cost_base: Some(52),
2949 object_delete_impl_cost_base: Some(52),
2951 object_record_new_uid_cost_base: Some(52),
2953 object_record_new_uid_from_hash_cost_base: None,
2956 object_is_shared_input_cost_base: None,
2959
2960 transfer_transfer_internal_cost_base: Some(52),
2963 transfer_party_transfer_internal_cost_base: None,
2965 transfer_freeze_object_cost_base: Some(52),
2967 transfer_share_object_cost_base: Some(52),
2969 transfer_receive_object_cost_base: None,
2970 transfer_receive_object_type_cost_per_byte: None,
2971 transfer_receive_object_cost_per_byte: None,
2972
2973 tx_context_derive_id_cost_base: Some(52),
2976 tx_context_fresh_id_cost_base: None,
2977 tx_context_sender_cost_base: None,
2978 tx_context_epoch_cost_base: None,
2979 tx_context_epoch_timestamp_ms_cost_base: None,
2980 tx_context_sponsor_cost_base: None,
2981 tx_context_rgp_cost_base: None,
2982 tx_context_gas_price_cost_base: None,
2983 tx_context_gas_budget_cost_base: None,
2984 tx_context_ids_created_cost_base: None,
2985 tx_context_replace_cost_base: None,
2986
2987 clock_borrow_cost_base: None,
2989
2990 types_is_one_time_witness_cost_base: Some(52),
2993 types_is_one_time_witness_type_tag_cost_per_byte: Some(2),
2994 types_is_one_time_witness_type_cost_per_byte: Some(2),
2995
2996 validator_validate_metadata_cost_base: Some(52),
2999 validator_validate_metadata_data_cost_per_byte: Some(2),
3000
3001 crypto_invalid_arguments_cost: Some(100),
3003 bls12381_bls12381_min_sig_verify_cost_base: Some(52),
3005 bls12381_bls12381_min_sig_verify_msg_cost_per_byte: Some(2),
3006 bls12381_bls12381_min_sig_verify_msg_cost_per_block: Some(2),
3007
3008 bls12381_bls12381_min_pk_verify_cost_base: Some(52),
3010 bls12381_bls12381_min_pk_verify_msg_cost_per_byte: Some(2),
3011 bls12381_bls12381_min_pk_verify_msg_cost_per_block: Some(2),
3012
3013 ecdsa_k1_ecrecover_keccak256_cost_base: Some(52),
3015 ecdsa_k1_ecrecover_keccak256_msg_cost_per_byte: Some(2),
3016 ecdsa_k1_ecrecover_keccak256_msg_cost_per_block: Some(2),
3017 ecdsa_k1_ecrecover_sha256_cost_base: Some(52),
3018 ecdsa_k1_ecrecover_sha256_msg_cost_per_byte: Some(2),
3019 ecdsa_k1_ecrecover_sha256_msg_cost_per_block: Some(2),
3020
3021 ecdsa_k1_decompress_pubkey_cost_base: Some(52),
3023
3024 ecdsa_k1_secp256k1_verify_keccak256_cost_base: Some(52),
3026 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_byte: Some(2),
3027 ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_block: Some(2),
3028 ecdsa_k1_secp256k1_verify_sha256_cost_base: Some(52),
3029 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_byte: Some(2),
3030 ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_block: Some(2),
3031
3032 ecdsa_r1_ecrecover_keccak256_cost_base: Some(52),
3034 ecdsa_r1_ecrecover_keccak256_msg_cost_per_byte: Some(2),
3035 ecdsa_r1_ecrecover_keccak256_msg_cost_per_block: Some(2),
3036 ecdsa_r1_ecrecover_sha256_cost_base: Some(52),
3037 ecdsa_r1_ecrecover_sha256_msg_cost_per_byte: Some(2),
3038 ecdsa_r1_ecrecover_sha256_msg_cost_per_block: Some(2),
3039
3040 ecdsa_r1_secp256r1_verify_keccak256_cost_base: Some(52),
3042 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_byte: Some(2),
3043 ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_block: Some(2),
3044 ecdsa_r1_secp256r1_verify_sha256_cost_base: Some(52),
3045 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_byte: Some(2),
3046 ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_block: Some(2),
3047
3048 ecvrf_ecvrf_verify_cost_base: Some(52),
3050 ecvrf_ecvrf_verify_alpha_string_cost_per_byte: Some(2),
3051 ecvrf_ecvrf_verify_alpha_string_cost_per_block: Some(2),
3052
3053 ed25519_ed25519_verify_cost_base: Some(52),
3055 ed25519_ed25519_verify_msg_cost_per_byte: Some(2),
3056 ed25519_ed25519_verify_msg_cost_per_block: Some(2),
3057
3058 groth16_prepare_verifying_key_bls12381_cost_base: Some(52),
3060 groth16_prepare_verifying_key_bn254_cost_base: Some(52),
3061
3062 groth16_verify_groth16_proof_internal_bls12381_cost_base: Some(52),
3064 groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input: Some(2),
3065 groth16_verify_groth16_proof_internal_bn254_cost_base: Some(52),
3066 groth16_verify_groth16_proof_internal_bn254_cost_per_public_input: Some(2),
3067 groth16_verify_groth16_proof_internal_public_input_cost_per_byte: Some(2),
3068
3069 hash_blake2b256_cost_base: Some(52),
3071 hash_blake2b256_data_cost_per_byte: Some(2),
3072 hash_blake2b256_data_cost_per_block: Some(2),
3073
3074 hash_keccak256_cost_base: Some(52),
3076 hash_keccak256_data_cost_per_byte: Some(2),
3077 hash_keccak256_data_cost_per_block: Some(2),
3078
3079 poseidon_bn254_cost_base: None,
3080 poseidon_bn254_cost_per_block: None,
3081
3082 hmac_hmac_sha3_256_cost_base: Some(52),
3084 hmac_hmac_sha3_256_input_cost_per_byte: Some(2),
3085 hmac_hmac_sha3_256_input_cost_per_block: Some(2),
3086
3087 group_ops_bls12381_decode_scalar_cost: None,
3089 group_ops_bls12381_decode_g1_cost: None,
3090 group_ops_bls12381_decode_g2_cost: None,
3091 group_ops_bls12381_decode_gt_cost: None,
3092 group_ops_bls12381_scalar_add_cost: None,
3093 group_ops_bls12381_g1_add_cost: None,
3094 group_ops_bls12381_g2_add_cost: None,
3095 group_ops_bls12381_gt_add_cost: None,
3096 group_ops_bls12381_scalar_sub_cost: None,
3097 group_ops_bls12381_g1_sub_cost: None,
3098 group_ops_bls12381_g2_sub_cost: None,
3099 group_ops_bls12381_gt_sub_cost: None,
3100 group_ops_bls12381_scalar_mul_cost: None,
3101 group_ops_bls12381_g1_mul_cost: None,
3102 group_ops_bls12381_g2_mul_cost: None,
3103 group_ops_bls12381_gt_mul_cost: None,
3104 group_ops_bls12381_scalar_div_cost: None,
3105 group_ops_bls12381_g1_div_cost: None,
3106 group_ops_bls12381_g2_div_cost: None,
3107 group_ops_bls12381_gt_div_cost: None,
3108 group_ops_bls12381_g1_hash_to_base_cost: None,
3109 group_ops_bls12381_g2_hash_to_base_cost: None,
3110 group_ops_bls12381_g1_hash_to_cost_per_byte: None,
3111 group_ops_bls12381_g2_hash_to_cost_per_byte: None,
3112 group_ops_bls12381_g1_msm_base_cost: None,
3113 group_ops_bls12381_g2_msm_base_cost: None,
3114 group_ops_bls12381_g1_msm_base_cost_per_input: None,
3115 group_ops_bls12381_g2_msm_base_cost_per_input: None,
3116 group_ops_bls12381_msm_max_len: None,
3117 group_ops_bls12381_pairing_cost: None,
3118 group_ops_bls12381_g1_to_uncompressed_g1_cost: None,
3119 group_ops_bls12381_uncompressed_g1_to_g1_cost: None,
3120 group_ops_bls12381_uncompressed_g1_sum_base_cost: None,
3121 group_ops_bls12381_uncompressed_g1_sum_cost_per_term: None,
3122 group_ops_bls12381_uncompressed_g1_sum_max_terms: None,
3123
3124 group_ops_ristretto_decode_scalar_cost: None,
3125 group_ops_ristretto_decode_point_cost: None,
3126 group_ops_ristretto_scalar_add_cost: None,
3127 group_ops_ristretto_point_add_cost: None,
3128 group_ops_ristretto_scalar_sub_cost: None,
3129 group_ops_ristretto_point_sub_cost: None,
3130 group_ops_ristretto_scalar_mul_cost: None,
3131 group_ops_ristretto_point_mul_cost: None,
3132 group_ops_ristretto_scalar_div_cost: None,
3133 group_ops_ristretto_point_div_cost: None,
3134
3135 verify_bulletproofs_ristretto255_base_cost: None,
3136 verify_bulletproofs_ristretto255_cost_per_bit_and_commitment: None,
3137 max_bulletproofs_total_bits: None,
3138
3139 check_zklogin_id_cost_base: None,
3141 check_zklogin_issuer_cost_base: None,
3143
3144 vdf_verify_vdf_cost: None,
3145 vdf_hash_to_input_cost: None,
3146
3147 nitro_attestation_parse_base_cost: None,
3149 nitro_attestation_parse_cost_per_byte: None,
3150 nitro_attestation_verify_base_cost: None,
3151 nitro_attestation_verify_cost_per_cert: None,
3152
3153 bcs_per_byte_serialized_cost: None,
3154 bcs_legacy_min_output_size_cost: None,
3155 bcs_failure_cost: None,
3156 hash_sha2_256_base_cost: None,
3157 hash_sha2_256_per_byte_cost: None,
3158 hash_sha2_256_legacy_min_input_len_cost: None,
3159 hash_sha3_256_base_cost: None,
3160 hash_sha3_256_per_byte_cost: None,
3161 hash_sha3_256_legacy_min_input_len_cost: None,
3162 type_name_get_base_cost: None,
3163 type_name_get_per_byte_cost: None,
3164 type_name_id_base_cost: None,
3165 string_check_utf8_base_cost: None,
3166 string_check_utf8_per_byte_cost: None,
3167 string_is_char_boundary_base_cost: None,
3168 string_sub_string_base_cost: None,
3169 string_sub_string_per_byte_cost: None,
3170 string_index_of_base_cost: None,
3171 string_index_of_per_byte_pattern_cost: None,
3172 string_index_of_per_byte_searched_cost: None,
3173 vector_empty_base_cost: None,
3174 vector_length_base_cost: None,
3175 vector_push_back_base_cost: None,
3176 vector_push_back_legacy_per_abstract_memory_unit_cost: None,
3177 vector_borrow_base_cost: None,
3178 vector_pop_back_base_cost: None,
3179 vector_destroy_empty_base_cost: None,
3180 vector_swap_base_cost: None,
3181 vector_reverse_base_cost: None,
3182 vector_reverse_per_elem_cost: None,
3183 vector_keep_range_base_cost: None,
3184 vector_keep_range_per_dropped_elem_cost: None,
3185 vector_keep_range_per_moved_elem_cost: None,
3186 vector_copy_range_base_cost: None,
3187 vector_replace_range_base_cost: None,
3188 vector_replace_range_per_elem_cost: None,
3189 debug_print_base_cost: None,
3190 debug_print_stack_trace_base_cost: None,
3191
3192 max_size_written_objects: None,
3193 max_size_written_objects_system_tx: None,
3194
3195 max_move_identifier_len: None,
3202 max_move_value_depth: None,
3203 package_arena_size_in_bytes: None,
3204 max_move_enum_variants: None,
3205
3206 gas_rounding_step: None,
3207
3208 execution_version: None,
3209
3210 max_event_emit_size_total: None,
3211
3212 consensus_bad_nodes_stake_threshold: None,
3213
3214 max_jwk_votes_per_validator_per_epoch: None,
3215
3216 max_age_of_jwk_in_epochs: None,
3217
3218 random_beacon_reduction_allowed_delta: None,
3219
3220 random_beacon_reduction_lower_bound: None,
3221
3222 random_beacon_dkg_timeout_round: None,
3223
3224 random_beacon_min_round_interval_ms: None,
3225
3226 random_beacon_dkg_version: None,
3227
3228 consensus_max_transaction_size_bytes: None,
3229
3230 consensus_max_transactions_in_block_bytes: None,
3231
3232 consensus_max_num_transactions_in_block: None,
3233
3234 consensus_voting_rounds: None,
3235
3236 max_accumulated_txn_cost_per_object_in_narwhal_commit: None,
3237
3238 max_deferral_rounds_for_congestion_control: None,
3239
3240 epoch_close_deadline_ms: None,
3241
3242 max_txn_cost_overage_per_object_in_commit: None,
3243
3244 allowed_txn_cost_overage_burst_per_object_in_commit: None,
3245
3246 min_checkpoint_interval_ms: None,
3247
3248 checkpoint_summary_version_specific_data: None,
3249
3250 max_soft_bundle_size: None,
3251
3252 bridge_should_try_to_finalize_committee: None,
3253
3254 max_accumulated_txn_cost_per_object_in_mysticeti_commit: None,
3255
3256 max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit: None,
3257
3258 consensus_gc_depth: None,
3259
3260 gas_budget_based_txn_cost_cap_factor: None,
3261
3262 gas_budget_based_txn_cost_absolute_cap_commit_count: None,
3263
3264 sip_45_consensus_amplification_threshold: None,
3265 staggered_submission_signal_window_commits: None,
3266 staggered_submission_signal_min_excess_copies_per_commit: None,
3267 staggered_submission_signal_exit_dwell_commits: None,
3268 staggered_submission_signal_band1_enter_ratio_bps: None,
3269 staggered_submission_signal_band1_exit_ratio_bps: None,
3270 staggered_submission_signal_band2_enter_ratio_bps: None,
3271 staggered_submission_signal_band2_exit_ratio_bps: None,
3272
3273 use_object_per_epoch_marker_table_v2: None,
3274
3275 consensus_commit_rate_estimation_window_size: None,
3276
3277 aliased_addresses: vec![],
3278
3279 translation_per_command_base_charge: None,
3280 translation_per_input_base_charge: None,
3281 translation_pure_input_per_byte_charge: None,
3282 translation_per_type_node_charge: None,
3283 translation_per_reference_node_charge: None,
3284 translation_per_linkage_entry_charge: None,
3285 translation_per_live_reference_charge: None,
3286 max_ptb_live_references: None,
3287 max_ptb_returned_references: None,
3288 max_ptb_total_returned_references: None,
3289
3290 max_updates_per_settlement_txn: None,
3291
3292 gasless_max_computation_units: None,
3293 gasless_allowed_token_types: None,
3294 gasless_max_unused_inputs: None,
3295 gasless_max_pure_input_bytes: None,
3296 gasless_max_tps: None,
3297 include_special_package_amendments: None,
3298 gasless_max_tx_size_bytes: None,
3299 };
3302 for cur in 2..=version.0 {
3303 match cur {
3304 1 => unreachable!(),
3305 2 => {
3306 cfg.feature_flags.advance_epoch_start_time_in_safe_mode = true;
3307 }
3308 3 => {
3309 cfg.gas_model_version = Some(2);
3311 cfg.max_tx_gas = Some(50_000_000_000);
3313 cfg.base_tx_cost_fixed = Some(2_000);
3315 cfg.storage_gas_price = Some(76);
3317 cfg.feature_flags.loaded_child_objects_fixed = true;
3318 cfg.max_size_written_objects = Some(5 * 1000 * 1000);
3321 cfg.max_size_written_objects_system_tx = Some(50 * 1000 * 1000);
3324 cfg.feature_flags.package_upgrades = true;
3325 }
3326 4 => {
3331 cfg.reward_slashing_rate = Some(10000);
3333 cfg.gas_model_version = Some(3);
3335 }
3336 5 => {
3337 cfg.feature_flags.missing_type_is_compatibility_error = true;
3338 cfg.gas_model_version = Some(4);
3339 cfg.feature_flags.scoring_decision_with_validity_cutoff = true;
3340 }
3344 6 => {
3345 cfg.gas_model_version = Some(5);
3346 cfg.buffer_stake_for_protocol_upgrade_bps = Some(5000);
3347 cfg.feature_flags.consensus_order_end_of_epoch_last = true;
3348 }
3349 7 => {
3350 cfg.feature_flags.disallow_adding_abilities_on_upgrade = true;
3351 cfg.feature_flags
3352 .disable_invariant_violation_check_in_swap_loc = true;
3353 cfg.feature_flags.ban_entry_init = true;
3354 cfg.feature_flags.package_digest_hash_module = true;
3355 }
3356 8 => {
3357 cfg.feature_flags
3358 .disallow_change_struct_type_params_on_upgrade = true;
3359 }
3360 9 => {
3361 cfg.max_move_identifier_len = Some(128);
3363 cfg.feature_flags.no_extraneous_module_bytes = true;
3364 cfg.feature_flags
3365 .advance_to_highest_supported_protocol_version = true;
3366 }
3367 10 => {
3368 cfg.max_verifier_meter_ticks_per_function = Some(16_000_000);
3369 cfg.max_meter_ticks_per_module = Some(16_000_000);
3370 }
3371 11 => {
3372 cfg.max_move_value_depth = Some(128);
3373 }
3374 12 => {
3375 cfg.feature_flags.narwhal_versioned_metadata = true;
3376 if chain != Chain::Mainnet {
3377 cfg.feature_flags.commit_root_state_digest = true;
3378 }
3379
3380 if chain != Chain::Mainnet && chain != Chain::Testnet {
3381 cfg.feature_flags.zklogin_auth = true;
3382 }
3383 }
3384 13 => {}
3385 14 => {
3386 cfg.gas_rounding_step = Some(1_000);
3387 cfg.gas_model_version = Some(6);
3388 }
3389 15 => {
3390 cfg.feature_flags.consensus_transaction_ordering =
3391 ConsensusTransactionOrdering::ByGasPrice;
3392 }
3393 16 => {
3394 cfg.feature_flags.simplified_unwrap_then_delete = true;
3395 }
3396 17 => {
3397 cfg.feature_flags.upgraded_multisig_supported = true;
3398 }
3399 18 => {
3400 cfg.execution_version = Some(1);
3401 cfg.feature_flags.txn_base_cost_as_multiplier = true;
3410 cfg.base_tx_cost_fixed = Some(1_000);
3412 }
3413 19 => {
3414 cfg.max_num_event_emit = Some(1024);
3415 cfg.max_event_emit_size_total = Some(
3418 256 * 250 * 1024, );
3420 }
3421 20 => {
3422 cfg.feature_flags.commit_root_state_digest = true;
3423
3424 if chain != Chain::Mainnet {
3425 cfg.feature_flags.narwhal_new_leader_election_schedule = true;
3426 cfg.consensus_bad_nodes_stake_threshold = Some(20);
3427 }
3428 }
3429
3430 21 => {
3431 if chain != Chain::Mainnet {
3432 cfg.feature_flags.zklogin_supported_providers = BTreeSet::from([
3433 "Google".to_string(),
3434 "Facebook".to_string(),
3435 "Twitch".to_string(),
3436 ]);
3437 }
3438 }
3439 22 => {
3440 cfg.feature_flags.loaded_child_object_format = true;
3441 }
3442 23 => {
3443 cfg.feature_flags.loaded_child_object_format_type = true;
3444 cfg.feature_flags.narwhal_new_leader_election_schedule = true;
3445 cfg.consensus_bad_nodes_stake_threshold = Some(20);
3451 }
3452 24 => {
3453 cfg.feature_flags.simple_conservation_checks = true;
3454 cfg.max_publish_or_upgrade_per_ptb = Some(5);
3455
3456 cfg.feature_flags.end_of_epoch_transaction_supported = true;
3457
3458 if chain != Chain::Mainnet {
3459 cfg.feature_flags.enable_jwk_consensus_updates = true;
3460 cfg.max_jwk_votes_per_validator_per_epoch = Some(240);
3462 cfg.max_age_of_jwk_in_epochs = Some(1);
3463 }
3464 }
3465 25 => {
3466 cfg.feature_flags.zklogin_supported_providers = BTreeSet::from([
3468 "Google".to_string(),
3469 "Facebook".to_string(),
3470 "Twitch".to_string(),
3471 ]);
3472 cfg.feature_flags.zklogin_auth = true;
3473
3474 cfg.feature_flags.enable_jwk_consensus_updates = true;
3476 cfg.max_jwk_votes_per_validator_per_epoch = Some(240);
3477 cfg.max_age_of_jwk_in_epochs = Some(1);
3478 }
3479 26 => {
3480 cfg.gas_model_version = Some(7);
3481 if chain != Chain::Mainnet && chain != Chain::Testnet {
3483 cfg.transfer_receive_object_cost_base = Some(52);
3484 cfg.feature_flags.receive_objects = true;
3485 }
3486 }
3487 27 => {
3488 cfg.gas_model_version = Some(8);
3489 }
3490 28 => {
3491 cfg.check_zklogin_id_cost_base = Some(200);
3493 cfg.check_zklogin_issuer_cost_base = Some(200);
3495
3496 if chain != Chain::Mainnet && chain != Chain::Testnet {
3498 cfg.feature_flags.enable_effects_v2 = true;
3499 }
3500 }
3501 29 => {
3502 cfg.feature_flags.verify_legacy_zklogin_address = true;
3503 }
3504 30 => {
3505 if chain != Chain::Mainnet {
3507 cfg.feature_flags.narwhal_certificate_v2 = true;
3508 }
3509
3510 cfg.random_beacon_reduction_allowed_delta = Some(800);
3511 if chain != Chain::Mainnet {
3513 cfg.feature_flags.enable_effects_v2 = true;
3514 }
3515
3516 cfg.feature_flags.zklogin_supported_providers = BTreeSet::default();
3520
3521 cfg.feature_flags.recompute_has_public_transfer_in_execution = true;
3522 }
3523 31 => {
3524 cfg.execution_version = Some(2);
3525 if chain != Chain::Mainnet && chain != Chain::Testnet {
3527 cfg.feature_flags.shared_object_deletion = true;
3528 }
3529 }
3530 32 => {
3531 if chain != Chain::Mainnet {
3533 cfg.feature_flags.accept_zklogin_in_multisig = true;
3534 }
3535 if chain != Chain::Mainnet {
3537 cfg.transfer_receive_object_cost_base = Some(52);
3538 cfg.feature_flags.receive_objects = true;
3539 }
3540 if chain != Chain::Mainnet && chain != Chain::Testnet {
3542 cfg.feature_flags.random_beacon = true;
3543 cfg.random_beacon_reduction_lower_bound = Some(1600);
3544 cfg.random_beacon_dkg_timeout_round = Some(3000);
3545 cfg.random_beacon_min_round_interval_ms = Some(150);
3546 }
3547 if chain != Chain::Testnet && chain != Chain::Mainnet {
3549 cfg.feature_flags.include_consensus_digest_in_prologue = true;
3550 }
3551
3552 cfg.feature_flags.narwhal_certificate_v2 = true;
3554 }
3555 33 => {
3556 cfg.feature_flags.hardened_otw_check = true;
3557 cfg.feature_flags.allow_receiving_object_id = true;
3558
3559 cfg.transfer_receive_object_cost_base = Some(52);
3561 cfg.feature_flags.receive_objects = true;
3562
3563 if chain != Chain::Mainnet {
3565 cfg.feature_flags.shared_object_deletion = true;
3566 }
3567
3568 cfg.feature_flags.enable_effects_v2 = true;
3569 }
3570 34 => {}
3571 35 => {
3572 if chain != Chain::Mainnet && chain != Chain::Testnet {
3574 cfg.feature_flags.enable_poseidon = true;
3575 cfg.poseidon_bn254_cost_base = Some(260);
3576 cfg.poseidon_bn254_cost_per_block = Some(10);
3577 }
3578
3579 cfg.feature_flags.enable_coin_deny_list = true;
3580 }
3581 36 => {
3582 if chain != Chain::Mainnet && chain != Chain::Testnet {
3584 cfg.feature_flags.enable_group_ops_native_functions = true;
3585 cfg.feature_flags.enable_group_ops_native_function_msm = true;
3586 cfg.group_ops_bls12381_decode_scalar_cost = Some(52);
3588 cfg.group_ops_bls12381_decode_g1_cost = Some(52);
3589 cfg.group_ops_bls12381_decode_g2_cost = Some(52);
3590 cfg.group_ops_bls12381_decode_gt_cost = Some(52);
3591 cfg.group_ops_bls12381_scalar_add_cost = Some(52);
3592 cfg.group_ops_bls12381_g1_add_cost = Some(52);
3593 cfg.group_ops_bls12381_g2_add_cost = Some(52);
3594 cfg.group_ops_bls12381_gt_add_cost = Some(52);
3595 cfg.group_ops_bls12381_scalar_sub_cost = Some(52);
3596 cfg.group_ops_bls12381_g1_sub_cost = Some(52);
3597 cfg.group_ops_bls12381_g2_sub_cost = Some(52);
3598 cfg.group_ops_bls12381_gt_sub_cost = Some(52);
3599 cfg.group_ops_bls12381_scalar_mul_cost = Some(52);
3600 cfg.group_ops_bls12381_g1_mul_cost = Some(52);
3601 cfg.group_ops_bls12381_g2_mul_cost = Some(52);
3602 cfg.group_ops_bls12381_gt_mul_cost = Some(52);
3603 cfg.group_ops_bls12381_scalar_div_cost = Some(52);
3604 cfg.group_ops_bls12381_g1_div_cost = Some(52);
3605 cfg.group_ops_bls12381_g2_div_cost = Some(52);
3606 cfg.group_ops_bls12381_gt_div_cost = Some(52);
3607 cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(52);
3608 cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(52);
3609 cfg.group_ops_bls12381_g1_hash_to_cost_per_byte = Some(2);
3610 cfg.group_ops_bls12381_g2_hash_to_cost_per_byte = Some(2);
3611 cfg.group_ops_bls12381_g1_msm_base_cost = Some(52);
3612 cfg.group_ops_bls12381_g2_msm_base_cost = Some(52);
3613 cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(52);
3614 cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(52);
3615 cfg.group_ops_bls12381_msm_max_len = Some(32);
3616 cfg.group_ops_bls12381_pairing_cost = Some(52);
3617 }
3618 cfg.feature_flags.shared_object_deletion = true;
3620
3621 cfg.consensus_max_transaction_size_bytes = Some(256 * 1024); cfg.consensus_max_transactions_in_block_bytes = Some(6 * 1_024 * 1024);
3623 }
3625 37 => {
3626 cfg.feature_flags.reject_mutable_random_on_entry_functions = true;
3627
3628 if chain != Chain::Mainnet {
3630 cfg.feature_flags.include_consensus_digest_in_prologue = true;
3631 }
3632 }
3633 38 => {
3634 cfg.binary_module_handles = Some(100);
3635 cfg.binary_struct_handles = Some(300);
3636 cfg.binary_function_handles = Some(1500);
3637 cfg.binary_function_instantiations = Some(750);
3638 cfg.binary_signatures = Some(1000);
3639 cfg.binary_constant_pool = Some(4000);
3643 cfg.binary_identifiers = Some(10000);
3644 cfg.binary_address_identifiers = Some(100);
3645 cfg.binary_struct_defs = Some(200);
3646 cfg.binary_struct_def_instantiations = Some(100);
3647 cfg.binary_function_defs = Some(1000);
3648 cfg.binary_field_handles = Some(500);
3649 cfg.binary_field_instantiations = Some(250);
3650 cfg.binary_friend_decls = Some(100);
3651 cfg.max_package_dependencies = Some(32);
3653 cfg.max_modules_in_publish = Some(64);
3654 cfg.execution_version = Some(3);
3656 }
3657 39 => {
3658 }
3660 40 => {}
3661 41 => {
3662 cfg.feature_flags.enable_group_ops_native_functions = true;
3664 cfg.group_ops_bls12381_decode_scalar_cost = Some(52);
3666 cfg.group_ops_bls12381_decode_g1_cost = Some(52);
3667 cfg.group_ops_bls12381_decode_g2_cost = Some(52);
3668 cfg.group_ops_bls12381_decode_gt_cost = Some(52);
3669 cfg.group_ops_bls12381_scalar_add_cost = Some(52);
3670 cfg.group_ops_bls12381_g1_add_cost = Some(52);
3671 cfg.group_ops_bls12381_g2_add_cost = Some(52);
3672 cfg.group_ops_bls12381_gt_add_cost = Some(52);
3673 cfg.group_ops_bls12381_scalar_sub_cost = Some(52);
3674 cfg.group_ops_bls12381_g1_sub_cost = Some(52);
3675 cfg.group_ops_bls12381_g2_sub_cost = Some(52);
3676 cfg.group_ops_bls12381_gt_sub_cost = Some(52);
3677 cfg.group_ops_bls12381_scalar_mul_cost = Some(52);
3678 cfg.group_ops_bls12381_g1_mul_cost = Some(52);
3679 cfg.group_ops_bls12381_g2_mul_cost = Some(52);
3680 cfg.group_ops_bls12381_gt_mul_cost = Some(52);
3681 cfg.group_ops_bls12381_scalar_div_cost = Some(52);
3682 cfg.group_ops_bls12381_g1_div_cost = Some(52);
3683 cfg.group_ops_bls12381_g2_div_cost = Some(52);
3684 cfg.group_ops_bls12381_gt_div_cost = Some(52);
3685 cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(52);
3686 cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(52);
3687 cfg.group_ops_bls12381_g1_hash_to_cost_per_byte = Some(2);
3688 cfg.group_ops_bls12381_g2_hash_to_cost_per_byte = Some(2);
3689 cfg.group_ops_bls12381_g1_msm_base_cost = Some(52);
3690 cfg.group_ops_bls12381_g2_msm_base_cost = Some(52);
3691 cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(52);
3692 cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(52);
3693 cfg.group_ops_bls12381_msm_max_len = Some(32);
3694 cfg.group_ops_bls12381_pairing_cost = Some(52);
3695 }
3696 42 => {}
3697 43 => {
3698 cfg.feature_flags.zklogin_max_epoch_upper_bound_delta = Some(30);
3699 cfg.max_meter_ticks_per_package = Some(16_000_000);
3700 }
3701 44 => {
3702 cfg.feature_flags.include_consensus_digest_in_prologue = true;
3704 if chain != Chain::Mainnet {
3706 cfg.feature_flags.consensus_choice = ConsensusChoice::SwapEachEpoch;
3707 }
3708 }
3709 45 => {
3710 if chain != Chain::Testnet && chain != Chain::Mainnet {
3712 cfg.feature_flags.consensus_network = ConsensusNetwork::Tonic;
3713 }
3714
3715 if chain != Chain::Mainnet {
3716 cfg.feature_flags.mysticeti_leader_scoring_and_schedule = true;
3718 }
3719 cfg.min_move_binary_format_version = Some(6);
3720 cfg.feature_flags.accept_zklogin_in_multisig = true;
3721
3722 if chain != Chain::Mainnet && chain != Chain::Testnet {
3726 cfg.feature_flags.bridge = true;
3727 }
3728 }
3729 46 => {
3730 if chain != Chain::Mainnet {
3732 cfg.feature_flags.bridge = true;
3733 }
3734
3735 cfg.feature_flags.reshare_at_same_initial_version = true;
3737 }
3738 47 => {}
3739 48 => {
3740 cfg.feature_flags.consensus_network = ConsensusNetwork::Tonic;
3742
3743 cfg.feature_flags.resolve_abort_locations_to_package_id = true;
3745
3746 if chain != Chain::Mainnet {
3748 cfg.feature_flags.random_beacon = true;
3749 cfg.random_beacon_reduction_lower_bound = Some(1600);
3750 cfg.random_beacon_dkg_timeout_round = Some(3000);
3751 cfg.random_beacon_min_round_interval_ms = Some(200);
3752 }
3753
3754 cfg.feature_flags.mysticeti_use_committed_subdag_digest = true;
3756 }
3757 49 => {
3758 if chain != Chain::Testnet && chain != Chain::Mainnet {
3759 cfg.move_binary_format_version = Some(7);
3760 }
3761
3762 if chain != Chain::Mainnet && chain != Chain::Testnet {
3764 cfg.feature_flags.enable_vdf = true;
3765 cfg.vdf_verify_vdf_cost = Some(1500);
3768 cfg.vdf_hash_to_input_cost = Some(100);
3769 }
3770
3771 if chain != Chain::Testnet && chain != Chain::Mainnet {
3773 cfg.feature_flags
3774 .record_consensus_determined_version_assignments_in_prologue = true;
3775 }
3776
3777 if chain != Chain::Mainnet {
3779 cfg.feature_flags.consensus_choice = ConsensusChoice::Mysticeti;
3780 }
3781
3782 cfg.feature_flags.fresh_vm_on_framework_upgrade = true;
3784 }
3785 50 => {
3786 if chain != Chain::Mainnet {
3788 cfg.checkpoint_summary_version_specific_data = Some(1);
3789 cfg.min_checkpoint_interval_ms = Some(200);
3790 }
3791
3792 if chain != Chain::Testnet && chain != Chain::Mainnet {
3794 cfg.feature_flags
3795 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3796 }
3797
3798 cfg.feature_flags.mysticeti_num_leaders_per_round = Some(1);
3799
3800 cfg.max_deferral_rounds_for_congestion_control = Some(10);
3802 }
3803 51 => {
3804 cfg.random_beacon_dkg_version = Some(1);
3805
3806 if chain != Chain::Testnet && chain != Chain::Mainnet {
3807 cfg.feature_flags.enable_coin_deny_list_v2 = true;
3808 }
3809 }
3810 52 => {
3811 if chain != Chain::Mainnet {
3812 cfg.feature_flags.soft_bundle = true;
3813 cfg.max_soft_bundle_size = Some(5);
3814 }
3815
3816 cfg.config_read_setting_impl_cost_base = Some(100);
3817 cfg.config_read_setting_impl_cost_per_byte = Some(40);
3818
3819 if chain != Chain::Testnet && chain != Chain::Mainnet {
3821 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3822 cfg.feature_flags.per_object_congestion_control_mode =
3823 PerObjectCongestionControlMode::TotalTxCount;
3824 }
3825
3826 cfg.feature_flags.consensus_choice = ConsensusChoice::Mysticeti;
3828
3829 cfg.feature_flags.mysticeti_leader_scoring_and_schedule = true;
3831
3832 cfg.checkpoint_summary_version_specific_data = Some(1);
3834 cfg.min_checkpoint_interval_ms = Some(200);
3835
3836 if chain != Chain::Mainnet {
3838 cfg.feature_flags
3839 .record_consensus_determined_version_assignments_in_prologue = true;
3840 cfg.feature_flags
3841 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3842 }
3843 if chain != Chain::Mainnet {
3845 cfg.move_binary_format_version = Some(7);
3846 }
3847
3848 if chain != Chain::Testnet && chain != Chain::Mainnet {
3849 cfg.feature_flags.passkey_auth = true;
3850 }
3851 cfg.feature_flags.enable_coin_deny_list_v2 = true;
3852 }
3853 53 => {
3854 cfg.bridge_should_try_to_finalize_committee = Some(chain != Chain::Mainnet);
3856
3857 cfg.feature_flags
3859 .record_consensus_determined_version_assignments_in_prologue = true;
3860 cfg.feature_flags
3861 .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3862
3863 if chain == Chain::Unknown {
3864 cfg.feature_flags.authority_capabilities_v2 = true;
3865 }
3866
3867 if chain != Chain::Mainnet {
3869 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3870 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(10);
3871 cfg.feature_flags.per_object_congestion_control_mode =
3872 PerObjectCongestionControlMode::TotalTxCount;
3873 }
3874
3875 cfg.bcs_per_byte_serialized_cost = Some(2);
3877 cfg.bcs_legacy_min_output_size_cost = Some(1);
3878 cfg.bcs_failure_cost = Some(52);
3879 cfg.debug_print_base_cost = Some(52);
3880 cfg.debug_print_stack_trace_base_cost = Some(52);
3881 cfg.hash_sha2_256_base_cost = Some(52);
3882 cfg.hash_sha2_256_per_byte_cost = Some(2);
3883 cfg.hash_sha2_256_legacy_min_input_len_cost = Some(1);
3884 cfg.hash_sha3_256_base_cost = Some(52);
3885 cfg.hash_sha3_256_per_byte_cost = Some(2);
3886 cfg.hash_sha3_256_legacy_min_input_len_cost = Some(1);
3887 cfg.type_name_get_base_cost = Some(52);
3888 cfg.type_name_get_per_byte_cost = Some(2);
3889 cfg.string_check_utf8_base_cost = Some(52);
3890 cfg.string_check_utf8_per_byte_cost = Some(2);
3891 cfg.string_is_char_boundary_base_cost = Some(52);
3892 cfg.string_sub_string_base_cost = Some(52);
3893 cfg.string_sub_string_per_byte_cost = Some(2);
3894 cfg.string_index_of_base_cost = Some(52);
3895 cfg.string_index_of_per_byte_pattern_cost = Some(2);
3896 cfg.string_index_of_per_byte_searched_cost = Some(2);
3897 cfg.vector_empty_base_cost = Some(52);
3898 cfg.vector_length_base_cost = Some(52);
3899 cfg.vector_push_back_base_cost = Some(52);
3900 cfg.vector_push_back_legacy_per_abstract_memory_unit_cost = Some(2);
3901 cfg.vector_borrow_base_cost = Some(52);
3902 cfg.vector_pop_back_base_cost = Some(52);
3903 cfg.vector_destroy_empty_base_cost = Some(52);
3904 cfg.vector_swap_base_cost = Some(52);
3905 }
3906 54 => {
3907 cfg.feature_flags.random_beacon = true;
3909 cfg.random_beacon_reduction_lower_bound = Some(1000);
3910 cfg.random_beacon_dkg_timeout_round = Some(3000);
3911 cfg.random_beacon_min_round_interval_ms = Some(500);
3912
3913 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3915 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(10);
3916 cfg.feature_flags.per_object_congestion_control_mode =
3917 PerObjectCongestionControlMode::TotalTxCount;
3918
3919 cfg.feature_flags.soft_bundle = true;
3921 cfg.max_soft_bundle_size = Some(5);
3922 }
3923 55 => {
3924 cfg.move_binary_format_version = Some(7);
3926
3927 cfg.consensus_max_transactions_in_block_bytes = Some(512 * 1024);
3929 cfg.consensus_max_num_transactions_in_block = Some(512);
3932
3933 cfg.feature_flags.rethrow_serialization_type_layout_errors = true;
3934 }
3935 56 => {
3936 if chain == Chain::Mainnet {
3937 cfg.feature_flags.bridge = true;
3938 }
3939 }
3940 57 => {
3941 cfg.random_beacon_reduction_lower_bound = Some(800);
3943 }
3944 58 => {
3945 if chain == Chain::Mainnet {
3946 cfg.bridge_should_try_to_finalize_committee = Some(true);
3947 }
3948
3949 if chain != Chain::Mainnet && chain != Chain::Testnet {
3950 cfg.feature_flags
3952 .consensus_distributed_vote_scoring_strategy = true;
3953 }
3954 }
3955 59 => {
3956 cfg.feature_flags.consensus_round_prober = true;
3958 }
3959 60 => {
3960 cfg.max_type_to_layout_nodes = Some(512);
3961 cfg.feature_flags.validate_identifier_inputs = true;
3962 }
3963 61 => {
3964 if chain != Chain::Mainnet {
3965 cfg.feature_flags
3967 .consensus_distributed_vote_scoring_strategy = true;
3968 }
3969 cfg.random_beacon_reduction_lower_bound = Some(700);
3971
3972 if chain != Chain::Mainnet && chain != Chain::Testnet {
3973 cfg.feature_flags.mysticeti_fastpath = true;
3975 }
3976 }
3977 62 => {
3978 cfg.feature_flags.relocate_event_module = true;
3979 }
3980 63 => {
3981 cfg.feature_flags.per_object_congestion_control_mode =
3982 PerObjectCongestionControlMode::TotalGasBudgetWithCap;
3983 cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
3984 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(18_500_000);
3985 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(240_000_000);
3986 }
3987 64 => {
3988 cfg.feature_flags.per_object_congestion_control_mode =
3989 PerObjectCongestionControlMode::TotalTxCount;
3990 cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(40);
3991 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(3);
3992 }
3993 65 => {
3994 cfg.feature_flags
3996 .consensus_distributed_vote_scoring_strategy = true;
3997 }
3998 66 => {
3999 if chain == Chain::Mainnet {
4000 cfg.feature_flags
4002 .consensus_distributed_vote_scoring_strategy = false;
4003 }
4004 }
4005 67 => {
4006 cfg.feature_flags
4008 .consensus_distributed_vote_scoring_strategy = true;
4009 }
4010 68 => {
4011 cfg.group_ops_bls12381_g1_to_uncompressed_g1_cost = Some(26);
4012 cfg.group_ops_bls12381_uncompressed_g1_to_g1_cost = Some(52);
4013 cfg.group_ops_bls12381_uncompressed_g1_sum_base_cost = Some(26);
4014 cfg.group_ops_bls12381_uncompressed_g1_sum_cost_per_term = Some(13);
4015 cfg.group_ops_bls12381_uncompressed_g1_sum_max_terms = Some(2000);
4016
4017 if chain != Chain::Mainnet && chain != Chain::Testnet {
4018 cfg.feature_flags.uncompressed_g1_group_elements = true;
4019 }
4020
4021 cfg.feature_flags.per_object_congestion_control_mode =
4022 PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4023 cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4024 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(18_500_000);
4025 cfg.max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit =
4026 Some(3_700_000); cfg.max_txn_cost_overage_per_object_in_commit = Some(u64::MAX);
4028 cfg.gas_budget_based_txn_cost_absolute_cap_commit_count = Some(50);
4029
4030 cfg.random_beacon_reduction_lower_bound = Some(500);
4032
4033 cfg.feature_flags.disallow_new_modules_in_deps_only_packages = true;
4034 }
4035 69 => {
4036 cfg.consensus_voting_rounds = Some(40);
4038
4039 if chain != Chain::Mainnet && chain != Chain::Testnet {
4040 cfg.feature_flags.consensus_smart_ancestor_selection = true;
4042 }
4043
4044 if chain != Chain::Mainnet {
4045 cfg.feature_flags.uncompressed_g1_group_elements = true;
4046 }
4047 }
4048 70 => {
4049 if chain != Chain::Mainnet {
4050 cfg.feature_flags.consensus_smart_ancestor_selection = true;
4052 cfg.feature_flags
4054 .consensus_round_prober_probe_accepted_rounds = true;
4055 }
4056
4057 cfg.poseidon_bn254_cost_per_block = Some(388);
4058
4059 cfg.gas_model_version = Some(9);
4060 cfg.feature_flags.native_charging_v2 = true;
4061 cfg.bls12381_bls12381_min_sig_verify_cost_base = Some(44064);
4062 cfg.bls12381_bls12381_min_pk_verify_cost_base = Some(49282);
4063 cfg.ecdsa_k1_secp256k1_verify_keccak256_cost_base = Some(1470);
4064 cfg.ecdsa_k1_secp256k1_verify_sha256_cost_base = Some(1470);
4065 cfg.ecdsa_r1_secp256r1_verify_sha256_cost_base = Some(4225);
4066 cfg.ecdsa_r1_secp256r1_verify_keccak256_cost_base = Some(4225);
4067 cfg.ecvrf_ecvrf_verify_cost_base = Some(4848);
4068 cfg.ed25519_ed25519_verify_cost_base = Some(1802);
4069
4070 cfg.ecdsa_r1_ecrecover_keccak256_cost_base = Some(1173);
4072 cfg.ecdsa_r1_ecrecover_sha256_cost_base = Some(1173);
4073 cfg.ecdsa_k1_ecrecover_keccak256_cost_base = Some(500);
4074 cfg.ecdsa_k1_ecrecover_sha256_cost_base = Some(500);
4075
4076 cfg.groth16_prepare_verifying_key_bls12381_cost_base = Some(53838);
4077 cfg.groth16_prepare_verifying_key_bn254_cost_base = Some(82010);
4078 cfg.groth16_verify_groth16_proof_internal_bls12381_cost_base = Some(72090);
4079 cfg.groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input =
4080 Some(8213);
4081 cfg.groth16_verify_groth16_proof_internal_bn254_cost_base = Some(115502);
4082 cfg.groth16_verify_groth16_proof_internal_bn254_cost_per_public_input =
4083 Some(9484);
4084
4085 cfg.hash_keccak256_cost_base = Some(10);
4086 cfg.hash_blake2b256_cost_base = Some(10);
4087
4088 cfg.group_ops_bls12381_decode_scalar_cost = Some(7);
4090 cfg.group_ops_bls12381_decode_g1_cost = Some(2848);
4091 cfg.group_ops_bls12381_decode_g2_cost = Some(3770);
4092 cfg.group_ops_bls12381_decode_gt_cost = Some(3068);
4093
4094 cfg.group_ops_bls12381_scalar_add_cost = Some(10);
4095 cfg.group_ops_bls12381_g1_add_cost = Some(1556);
4096 cfg.group_ops_bls12381_g2_add_cost = Some(3048);
4097 cfg.group_ops_bls12381_gt_add_cost = Some(188);
4098
4099 cfg.group_ops_bls12381_scalar_sub_cost = Some(10);
4100 cfg.group_ops_bls12381_g1_sub_cost = Some(1550);
4101 cfg.group_ops_bls12381_g2_sub_cost = Some(3019);
4102 cfg.group_ops_bls12381_gt_sub_cost = Some(497);
4103
4104 cfg.group_ops_bls12381_scalar_mul_cost = Some(11);
4105 cfg.group_ops_bls12381_g1_mul_cost = Some(4842);
4106 cfg.group_ops_bls12381_g2_mul_cost = Some(9108);
4107 cfg.group_ops_bls12381_gt_mul_cost = Some(27490);
4108
4109 cfg.group_ops_bls12381_scalar_div_cost = Some(91);
4110 cfg.group_ops_bls12381_g1_div_cost = Some(5091);
4111 cfg.group_ops_bls12381_g2_div_cost = Some(9206);
4112 cfg.group_ops_bls12381_gt_div_cost = Some(27804);
4113
4114 cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(2962);
4115 cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(8688);
4116
4117 cfg.group_ops_bls12381_g1_msm_base_cost = Some(62648);
4118 cfg.group_ops_bls12381_g2_msm_base_cost = Some(131192);
4119 cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(1333);
4120 cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(3216);
4121
4122 cfg.group_ops_bls12381_uncompressed_g1_to_g1_cost = Some(677);
4123 cfg.group_ops_bls12381_g1_to_uncompressed_g1_cost = Some(2099);
4124 cfg.group_ops_bls12381_uncompressed_g1_sum_base_cost = Some(77);
4125 cfg.group_ops_bls12381_uncompressed_g1_sum_cost_per_term = Some(26);
4126
4127 cfg.group_ops_bls12381_pairing_cost = Some(26897);
4128 cfg.group_ops_bls12381_uncompressed_g1_sum_max_terms = Some(1200);
4129
4130 cfg.validator_validate_metadata_cost_base = Some(20000);
4131 }
4132 71 => {
4133 cfg.sip_45_consensus_amplification_threshold = Some(5);
4134
4135 cfg.allowed_txn_cost_overage_burst_per_object_in_commit = Some(185_000_000);
4137 }
4138 72 => {
4139 cfg.feature_flags.convert_type_argument_error = true;
4140
4141 cfg.max_tx_gas = Some(50_000_000_000_000);
4144 cfg.max_gas_price = Some(50_000_000_000);
4146
4147 cfg.feature_flags.variant_nodes = true;
4148 }
4149 73 => {
4150 cfg.use_object_per_epoch_marker_table_v2 = Some(true);
4152
4153 if chain != Chain::Mainnet && chain != Chain::Testnet {
4154 cfg.consensus_gc_depth = Some(60);
4157 }
4158
4159 if chain != Chain::Mainnet {
4160 cfg.feature_flags.consensus_zstd_compression = true;
4162 }
4163
4164 cfg.feature_flags.consensus_smart_ancestor_selection = true;
4166 cfg.feature_flags
4168 .consensus_round_prober_probe_accepted_rounds = true;
4169
4170 cfg.feature_flags.per_object_congestion_control_mode =
4172 PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4173 cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4174 cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(37_000_000);
4175 cfg.max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit =
4176 Some(7_400_000); cfg.max_txn_cost_overage_per_object_in_commit = Some(u64::MAX);
4178 cfg.gas_budget_based_txn_cost_absolute_cap_commit_count = Some(50);
4179 cfg.allowed_txn_cost_overage_burst_per_object_in_commit = Some(370_000_000);
4180 }
4181 74 => {
4182 if chain != Chain::Mainnet && chain != Chain::Testnet {
4184 cfg.feature_flags.enable_nitro_attestation = true;
4185 }
4186 cfg.nitro_attestation_parse_base_cost = Some(53 * 50);
4187 cfg.nitro_attestation_parse_cost_per_byte = Some(50);
4188 cfg.nitro_attestation_verify_base_cost = Some(49632 * 50);
4189 cfg.nitro_attestation_verify_cost_per_cert = Some(52369 * 50);
4190
4191 cfg.feature_flags.consensus_zstd_compression = true;
4193
4194 if chain != Chain::Mainnet && chain != Chain::Testnet {
4195 cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4196 }
4197 }
4198 75 => {
4199 if chain != Chain::Mainnet {
4200 cfg.feature_flags.passkey_auth = true;
4201 }
4202 }
4203 76 => {
4204 if chain != Chain::Mainnet && chain != Chain::Testnet {
4205 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4206 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4207 }
4208 cfg.feature_flags.minimize_child_object_mutations = true;
4209
4210 if chain != Chain::Mainnet {
4211 cfg.feature_flags.accept_passkey_in_multisig = true;
4212 }
4213 }
4214 77 => {
4215 cfg.feature_flags.uncompressed_g1_group_elements = true;
4216
4217 if chain != Chain::Mainnet {
4218 cfg.consensus_gc_depth = Some(60);
4219 cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4220 }
4221 }
4222 78 => {
4223 cfg.feature_flags.move_native_context = true;
4224 cfg.tx_context_fresh_id_cost_base = Some(52);
4225 cfg.tx_context_sender_cost_base = Some(30);
4226 cfg.tx_context_epoch_cost_base = Some(30);
4227 cfg.tx_context_epoch_timestamp_ms_cost_base = Some(30);
4228 cfg.tx_context_sponsor_cost_base = Some(30);
4229 cfg.tx_context_gas_price_cost_base = Some(30);
4230 cfg.tx_context_gas_budget_cost_base = Some(30);
4231 cfg.tx_context_ids_created_cost_base = Some(30);
4232 cfg.tx_context_replace_cost_base = Some(30);
4233 cfg.gas_model_version = Some(10);
4234
4235 if chain != Chain::Mainnet {
4236 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4237 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4238
4239 cfg.feature_flags.per_object_congestion_control_mode =
4241 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4242 ExecutionTimeEstimateParams {
4243 target_utilization: 30,
4244 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4246 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4248 stored_observations_limit: u64::MAX,
4249 stake_weighted_median_threshold: 0,
4250 default_none_duration_for_new_keys: false,
4251 observations_chunk_size: None,
4252 },
4253 );
4254 }
4255 }
4256 79 => {
4257 if chain != Chain::Mainnet {
4258 cfg.feature_flags.consensus_median_based_commit_timestamp = true;
4259
4260 cfg.consensus_bad_nodes_stake_threshold = Some(30);
4263
4264 cfg.feature_flags.consensus_batched_block_sync = true;
4265
4266 cfg.feature_flags.enable_nitro_attestation = true
4268 }
4269 cfg.feature_flags.normalize_ptb_arguments = true;
4270
4271 cfg.consensus_gc_depth = Some(60);
4272 cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4273 }
4274 80 => {
4275 cfg.max_ptb_value_size = Some(1024 * 1024);
4276 }
4277 81 => {
4278 cfg.feature_flags.consensus_median_based_commit_timestamp = true;
4279 cfg.feature_flags.enforce_checkpoint_timestamp_monotonicity = true;
4280 cfg.consensus_bad_nodes_stake_threshold = Some(30)
4281 }
4282 82 => {
4283 cfg.feature_flags.max_ptb_value_size_v2 = true;
4284 }
4285 83 => {
4286 if chain == Chain::Mainnet {
4287 let aliased: [u8; 32] = Hex::decode(
4289 "0x0b2da327ba6a4cacbe75dddd50e6e8bbf81d6496e92d66af9154c61c77f7332f",
4290 )
4291 .unwrap()
4292 .try_into()
4293 .unwrap();
4294
4295 cfg.aliased_addresses.push(AliasedAddress {
4297 original: Hex::decode("0xcd8962dad278d8b50fa0f9eb0186bfa4cbdecc6d59377214c88d0286a0ac9562").unwrap().try_into().unwrap(),
4298 aliased,
4299 allowed_tx_digests: vec![
4300 Base58::decode("B2eGLFoMHgj93Ni8dAJBfqGzo8EWSTLBesZzhEpTPA4").unwrap().try_into().unwrap(),
4301 ],
4302 });
4303
4304 cfg.aliased_addresses.push(AliasedAddress {
4305 original: Hex::decode("0xe28b50cef1d633ea43d3296a3f6b67ff0312a5f1a99f0af753c85b8b5de8ff06").unwrap().try_into().unwrap(),
4306 aliased,
4307 allowed_tx_digests: vec![
4308 Base58::decode("J4QqSAgp7VrQtQpMy5wDX4QGsCSEZu3U5KuDAkbESAge").unwrap().try_into().unwrap(),
4309 ],
4310 });
4311 }
4312
4313 if chain != Chain::Mainnet {
4316 cfg.feature_flags.resolve_type_input_ids_to_defining_id = true;
4317 cfg.transfer_party_transfer_internal_cost_base = Some(52);
4318
4319 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4321 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4322 cfg.feature_flags.per_object_congestion_control_mode =
4323 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4324 ExecutionTimeEstimateParams {
4325 target_utilization: 30,
4326 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4328 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4330 stored_observations_limit: u64::MAX,
4331 stake_weighted_median_threshold: 0,
4332 default_none_duration_for_new_keys: false,
4333 observations_chunk_size: None,
4334 },
4335 );
4336
4337 cfg.feature_flags.consensus_batched_block_sync = true;
4339
4340 cfg.feature_flags.enable_nitro_attestation_upgraded_parsing = true;
4343 cfg.feature_flags.enable_nitro_attestation = true;
4344 }
4345 }
4346 84 => {
4347 if chain == Chain::Mainnet {
4348 cfg.feature_flags.resolve_type_input_ids_to_defining_id = true;
4349 cfg.transfer_party_transfer_internal_cost_base = Some(52);
4350
4351 cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4353 cfg.consensus_commit_rate_estimation_window_size = Some(10);
4354 cfg.feature_flags.per_object_congestion_control_mode =
4355 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4356 ExecutionTimeEstimateParams {
4357 target_utilization: 30,
4358 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4360 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4362 stored_observations_limit: u64::MAX,
4363 stake_weighted_median_threshold: 0,
4364 default_none_duration_for_new_keys: false,
4365 observations_chunk_size: None,
4366 },
4367 );
4368
4369 cfg.feature_flags.consensus_batched_block_sync = true;
4371
4372 cfg.feature_flags.enable_nitro_attestation_upgraded_parsing = true;
4375 cfg.feature_flags.enable_nitro_attestation = true;
4376 }
4377
4378 cfg.feature_flags.per_object_congestion_control_mode =
4380 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4381 ExecutionTimeEstimateParams {
4382 target_utilization: 30,
4383 allowed_txn_cost_overage_burst_limit_us: 100_000, randomness_scalar: 20,
4385 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4387 stored_observations_limit: 20,
4388 stake_weighted_median_threshold: 0,
4389 default_none_duration_for_new_keys: false,
4390 observations_chunk_size: None,
4391 },
4392 );
4393 cfg.feature_flags.allow_unbounded_system_objects = true;
4394 }
4395 85 => {
4396 if chain != Chain::Mainnet && chain != Chain::Testnet {
4397 cfg.feature_flags.enable_party_transfer = true;
4398 }
4399
4400 cfg.feature_flags
4401 .record_consensus_determined_version_assignments_in_prologue_v2 = true;
4402 cfg.feature_flags.disallow_self_identifier = true;
4403 cfg.feature_flags.per_object_congestion_control_mode =
4404 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4405 ExecutionTimeEstimateParams {
4406 target_utilization: 50,
4407 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4409 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4411 stored_observations_limit: 20,
4412 stake_weighted_median_threshold: 0,
4413 default_none_duration_for_new_keys: false,
4414 observations_chunk_size: None,
4415 },
4416 );
4417 }
4418 86 => {
4419 cfg.feature_flags.type_tags_in_object_runtime = true;
4420 cfg.max_move_enum_variants = Some(move_core_types::VARIANT_COUNT_MAX);
4421
4422 cfg.feature_flags.per_object_congestion_control_mode =
4424 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4425 ExecutionTimeEstimateParams {
4426 target_utilization: 50,
4427 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4429 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4431 stored_observations_limit: 20,
4432 stake_weighted_median_threshold: 3334,
4433 default_none_duration_for_new_keys: false,
4434 observations_chunk_size: None,
4435 },
4436 );
4437 if chain != Chain::Mainnet {
4439 cfg.feature_flags.enable_party_transfer = true;
4440 }
4441 }
4442 87 => {
4443 if chain == Chain::Mainnet {
4444 cfg.feature_flags.record_time_estimate_processed = true;
4445 }
4446 cfg.feature_flags.better_adapter_type_resolution_errors = true;
4447 }
4448 88 => {
4449 cfg.feature_flags.record_time_estimate_processed = true;
4450 cfg.tx_context_rgp_cost_base = Some(30);
4451 cfg.feature_flags
4452 .ignore_execution_time_observations_after_certs_closed = true;
4453
4454 cfg.feature_flags.per_object_congestion_control_mode =
4457 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4458 ExecutionTimeEstimateParams {
4459 target_utilization: 50,
4460 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4462 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4464 stored_observations_limit: 20,
4465 stake_weighted_median_threshold: 3334,
4466 default_none_duration_for_new_keys: true,
4467 observations_chunk_size: None,
4468 },
4469 );
4470 }
4471 89 => {
4472 cfg.feature_flags.dependency_linkage_error = true;
4473 cfg.feature_flags.additional_multisig_checks = true;
4474 }
4475 90 => {
4476 cfg.max_gas_price_rgp_factor_for_aborted_transactions = Some(100);
4478 cfg.feature_flags.debug_fatal_on_move_invariant_violation = true;
4479 cfg.feature_flags.additional_consensus_digest_indirect_state = true;
4480 cfg.feature_flags.accept_passkey_in_multisig = true;
4481 cfg.feature_flags.passkey_auth = true;
4482 cfg.feature_flags.check_for_init_during_upgrade = true;
4483
4484 if chain != Chain::Mainnet {
4486 cfg.feature_flags.mysticeti_fastpath = true;
4487 }
4488 }
4489 91 => {
4490 cfg.feature_flags.per_command_shared_object_transfer_rules = true;
4491 }
4492 92 => {
4493 cfg.feature_flags.per_command_shared_object_transfer_rules = false;
4494 }
4495 93 => {
4496 cfg.feature_flags
4497 .consensus_checkpoint_signature_key_includes_digest = true;
4498 }
4499 94 => {
4500 cfg.feature_flags.per_object_congestion_control_mode =
4502 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4503 ExecutionTimeEstimateParams {
4504 target_utilization: 50,
4505 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4507 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4509 stored_observations_limit: 18,
4510 stake_weighted_median_threshold: 3334,
4511 default_none_duration_for_new_keys: true,
4512 observations_chunk_size: None,
4513 },
4514 );
4515
4516 cfg.feature_flags.enable_party_transfer = true;
4518 }
4519 95 => {
4520 cfg.type_name_id_base_cost = Some(52);
4521
4522 cfg.max_transactions_per_checkpoint = Some(20_000);
4524 }
4525 96 => {
4526 if chain != Chain::Mainnet && chain != Chain::Testnet {
4528 cfg.feature_flags
4529 .include_checkpoint_artifacts_digest_in_summary = true;
4530 }
4531 cfg.feature_flags.correct_gas_payment_limit_check = true;
4532 cfg.feature_flags.authority_capabilities_v2 = true;
4533 cfg.feature_flags.use_mfp_txns_in_load_initial_object_debts = true;
4534 cfg.feature_flags.cancel_for_failed_dkg_early = true;
4535 cfg.feature_flags.enable_coin_registry = true;
4536
4537 cfg.feature_flags.mysticeti_fastpath = true;
4539 }
4540 97 => {
4541 cfg.feature_flags.additional_borrow_checks = true;
4542 }
4543 98 => {
4544 cfg.event_emit_auth_stream_cost = Some(52);
4545 cfg.feature_flags.better_loader_errors = true;
4546 cfg.feature_flags.generate_df_type_layouts = true;
4547 }
4548 99 => {
4549 cfg.feature_flags.use_new_commit_handler = true;
4550 }
4551 100 => {
4552 cfg.feature_flags.private_generics_verifier_v2 = true;
4553 }
4554 101 => {
4555 cfg.feature_flags.create_root_accumulator_object = true;
4556 cfg.max_updates_per_settlement_txn = Some(100);
4557 if chain != Chain::Mainnet {
4558 cfg.feature_flags.enable_poseidon = true;
4559 }
4560 }
4561 102 => {
4562 cfg.feature_flags.per_object_congestion_control_mode =
4566 PerObjectCongestionControlMode::ExecutionTimeEstimate(
4567 ExecutionTimeEstimateParams {
4568 target_utilization: 50,
4569 allowed_txn_cost_overage_burst_limit_us: 500_000, randomness_scalar: 20,
4571 max_estimate_us: 1_500_000, stored_observations_num_included_checkpoints: 10,
4573 stored_observations_limit: 180,
4574 stake_weighted_median_threshold: 3334,
4575 default_none_duration_for_new_keys: true,
4576 observations_chunk_size: Some(18),
4577 },
4578 );
4579 cfg.feature_flags.deprecate_global_storage_ops = true;
4580 }
4581 103 => {}
4582 104 => {
4583 cfg.translation_per_command_base_charge = Some(1);
4584 cfg.translation_per_input_base_charge = Some(1);
4585 cfg.translation_pure_input_per_byte_charge = Some(1);
4586 cfg.translation_per_type_node_charge = Some(1);
4587 cfg.translation_per_reference_node_charge = Some(1);
4588 cfg.translation_per_linkage_entry_charge = Some(10);
4589 cfg.gas_model_version = Some(11);
4590 cfg.feature_flags.abstract_size_in_object_runtime = true;
4591 cfg.feature_flags.object_runtime_charge_cache_load_gas = true;
4592 cfg.dynamic_field_hash_type_and_key_cost_base = Some(52);
4593 cfg.dynamic_field_add_child_object_cost_base = Some(52);
4594 cfg.dynamic_field_add_child_object_value_cost_per_byte = Some(1);
4595 cfg.dynamic_field_borrow_child_object_cost_base = Some(52);
4596 cfg.dynamic_field_borrow_child_object_child_ref_cost_per_byte = Some(1);
4597 cfg.dynamic_field_remove_child_object_cost_base = Some(52);
4598 cfg.dynamic_field_remove_child_object_child_cost_per_byte = Some(1);
4599 cfg.dynamic_field_has_child_object_cost_base = Some(52);
4600 cfg.dynamic_field_has_child_object_with_ty_cost_base = Some(52);
4601 cfg.feature_flags.enable_ptb_execution_v2 = true;
4602
4603 cfg.poseidon_bn254_cost_base = Some(260);
4604
4605 cfg.feature_flags.consensus_skip_gced_accept_votes = true;
4606
4607 if chain != Chain::Mainnet {
4608 cfg.feature_flags
4609 .enable_nitro_attestation_all_nonzero_pcrs_parsing = true;
4610 }
4611
4612 cfg.feature_flags
4613 .include_cancelled_randomness_txns_in_prologue = true;
4614 }
4615 105 => {
4616 cfg.feature_flags.enable_multi_epoch_transaction_expiration = true;
4617 cfg.feature_flags.disable_preconsensus_locking = true;
4618
4619 if chain != Chain::Mainnet {
4620 cfg.feature_flags
4621 .enable_nitro_attestation_always_include_required_pcrs_parsing = true;
4622 }
4623 }
4624 106 => {
4625 cfg.accumulator_object_storage_cost = Some(7600);
4627
4628 if chain != Chain::Mainnet && chain != Chain::Testnet {
4629 cfg.feature_flags.enable_accumulators = true;
4630 cfg.feature_flags.enable_address_balance_gas_payments = true;
4631 cfg.feature_flags.enable_authenticated_event_streams = true;
4632 cfg.feature_flags.enable_object_funds_withdraw = true;
4633 }
4634 }
4635 107 => {
4636 cfg.feature_flags
4637 .consensus_skip_gced_blocks_in_direct_finalization = true;
4638
4639 if in_integration_test() {
4641 cfg.consensus_gc_depth = Some(6);
4642 cfg.consensus_max_num_transactions_in_block = Some(8);
4643 }
4644 }
4645 108 => {
4646 cfg.feature_flags.gas_rounding_halve_digits = true;
4647 cfg.feature_flags.flexible_tx_context_positions = true;
4648 cfg.feature_flags.disable_entry_point_signature_check = true;
4649
4650 if chain != Chain::Mainnet {
4651 cfg.feature_flags.address_aliases = true;
4652
4653 cfg.feature_flags.enable_accumulators = true;
4654 cfg.feature_flags.enable_address_balance_gas_payments = true;
4655 }
4656
4657 cfg.feature_flags.enable_poseidon = true;
4658 }
4659 109 => {
4660 cfg.binary_variant_handles = Some(1024);
4661 cfg.binary_variant_instantiation_handles = Some(1024);
4662 cfg.feature_flags.restrict_hot_or_not_entry_functions = true;
4663 }
4664 110 => {
4665 cfg.feature_flags
4666 .enable_nitro_attestation_all_nonzero_pcrs_parsing = true;
4667 cfg.feature_flags
4668 .enable_nitro_attestation_always_include_required_pcrs_parsing = true;
4669 if chain != Chain::Mainnet && chain != Chain::Testnet {
4670 cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4671 }
4672 cfg.feature_flags.validate_zklogin_public_identifier = true;
4673 cfg.feature_flags.fix_checkpoint_signature_mapping = true;
4674 cfg.feature_flags
4675 .consensus_always_accept_system_transactions = true;
4676 if chain != Chain::Mainnet {
4677 cfg.feature_flags.enable_object_funds_withdraw = true;
4678 }
4679 }
4680 111 => {
4681 cfg.feature_flags.validator_metadata_verify_v2 = true;
4682 }
4683 112 => {
4684 cfg.group_ops_ristretto_decode_scalar_cost = Some(7);
4685 cfg.group_ops_ristretto_decode_point_cost = Some(200);
4686 cfg.group_ops_ristretto_scalar_add_cost = Some(10);
4687 cfg.group_ops_ristretto_point_add_cost = Some(500);
4688 cfg.group_ops_ristretto_scalar_sub_cost = Some(10);
4689 cfg.group_ops_ristretto_point_sub_cost = Some(500);
4690 cfg.group_ops_ristretto_scalar_mul_cost = Some(11);
4691 cfg.group_ops_ristretto_point_mul_cost = Some(1200);
4692 cfg.group_ops_ristretto_scalar_div_cost = Some(151);
4693 cfg.group_ops_ristretto_point_div_cost = Some(2500);
4694
4695 if chain != Chain::Mainnet && chain != Chain::Testnet {
4696 cfg.feature_flags.enable_ristretto255_group_ops = true;
4697 }
4698 }
4699 113 => {
4700 cfg.feature_flags.address_balance_gas_check_rgp_at_signing = true;
4701 if chain != Chain::Mainnet && chain != Chain::Testnet {
4702 cfg.feature_flags.defer_unpaid_amplification = true;
4703 }
4704 }
4705 114 => {
4706 cfg.feature_flags.randomize_checkpoint_tx_limit_in_tests = true;
4707 cfg.feature_flags.address_balance_gas_reject_gas_coin_arg = true;
4708 if chain != Chain::Mainnet {
4709 cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4710 cfg.feature_flags.enable_authenticated_event_streams = true;
4711 cfg.feature_flags
4712 .include_checkpoint_artifacts_digest_in_summary = true;
4713 }
4714 }
4715 115 => {
4716 cfg.feature_flags.normalize_depth_formula = true;
4717 }
4718 116 => {
4719 cfg.feature_flags.gasless_transaction_drop_safety = true;
4720 cfg.feature_flags.address_aliases = true;
4721 cfg.feature_flags.relax_valid_during_for_owned_inputs = true;
4722 cfg.feature_flags.defer_unpaid_amplification = false;
4724 cfg.feature_flags.enable_display_registry = true;
4725 }
4726 117 => {}
4727 118 => {
4728 cfg.feature_flags.use_coin_party_owner = true;
4729 }
4730 119 => {
4731 cfg.execution_version = Some(4);
4733 cfg.feature_flags.address_balance_gas_reject_gas_coin_arg = false;
4734 cfg.feature_flags.merge_randomness_into_checkpoint = true;
4735 if chain != Chain::Mainnet {
4736 cfg.feature_flags.enable_gasless = true;
4737 cfg.gasless_max_computation_units = Some(50_000);
4738 cfg.gasless_allowed_token_types = Some(vec![]);
4739 cfg.feature_flags.enable_coin_reservation_obj_refs = true;
4740 cfg.feature_flags
4741 .convert_withdrawal_compatibility_ptb_arguments = true;
4742 }
4743 cfg.gasless_max_unused_inputs = Some(1);
4744 cfg.gasless_max_pure_input_bytes = Some(32);
4745 if chain == Chain::Testnet {
4746 cfg.gasless_allowed_token_types = Some(vec![(TESTNET_USDC.to_string(), 0)]);
4747 }
4748 cfg.transfer_receive_object_cost_per_byte = Some(1);
4749 cfg.transfer_receive_object_type_cost_per_byte = Some(2);
4750 }
4751 120 => {
4752 cfg.feature_flags.disallow_jump_orphans = true;
4753 }
4754 121 => {
4755 if chain != Chain::Mainnet {
4757 cfg.feature_flags.defer_unpaid_amplification = true;
4758 cfg.gasless_max_tps = Some(50);
4759 }
4760 cfg.feature_flags
4761 .early_return_receive_object_mismatched_type = true;
4762 }
4763 122 => {
4764 cfg.feature_flags.defer_unpaid_amplification = true;
4766 cfg.verify_bulletproofs_ristretto255_base_cost = Some(30000);
4768 cfg.verify_bulletproofs_ristretto255_cost_per_bit_and_commitment = Some(6500);
4769 if chain != Chain::Mainnet && chain != Chain::Testnet {
4770 cfg.feature_flags.enable_verify_bulletproofs_ristretto255 = true;
4771 }
4772 cfg.feature_flags.gasless_verify_remaining_balance = true;
4773 cfg.include_special_package_amendments = match chain {
4774 Chain::Mainnet => Some(MAINNET_LINKAGE_AMENDMENTS.clone()),
4775 Chain::Testnet => Some(TESTNET_LINKAGE_AMENDMENTS.clone()),
4776 Chain::Unknown => None,
4777 };
4778 cfg.gasless_max_tx_size_bytes = Some(16 * 1024);
4779 cfg.gasless_max_tps = Some(300);
4780 cfg.gasless_max_computation_units = Some(5_000);
4781 }
4782 123 => {
4783 cfg.gas_model_version = Some(13);
4784 }
4785 124 => {
4786 if chain != Chain::Mainnet && chain != Chain::Testnet {
4787 cfg.feature_flags.timestamp_based_epoch_close = true;
4788 }
4789 cfg.gas_model_version = Some(14);
4790 cfg.feature_flags.limit_groth16_pvk_inputs = true;
4791
4792 cfg.feature_flags.enable_accumulators = true;
4798 cfg.feature_flags.enable_address_balance_gas_payments = true;
4799 cfg.feature_flags.enable_authenticated_event_streams = true;
4800 cfg.feature_flags.enable_coin_reservation_obj_refs = true;
4801 cfg.feature_flags.enable_object_funds_withdraw = true;
4802 cfg.feature_flags
4803 .convert_withdrawal_compatibility_ptb_arguments = true;
4804 cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4805 cfg.feature_flags
4806 .include_checkpoint_artifacts_digest_in_summary = true;
4807 cfg.feature_flags.enable_gasless = true;
4808
4809 if chain == Chain::Mainnet {
4814 cfg.gasless_allowed_token_types = Some(vec![
4815 (MAINNET_USDC.to_string(), 10_000),
4816 (MAINNET_USDSUI.to_string(), 10_000),
4817 (MAINNET_SUI_USDE.to_string(), 10_000),
4818 (MAINNET_USDY.to_string(), 10_000),
4819 (MAINNET_FDUSD.to_string(), 10_000),
4820 (MAINNET_AUSD.to_string(), 10_000),
4821 (MAINNET_USDB.to_string(), 10_000),
4822 ]);
4823 }
4824 }
4825 125 => {
4826 cfg.feature_flags.granular_post_execution_checks = true;
4827 if chain != Chain::Mainnet {
4828 cfg.feature_flags.timestamp_based_epoch_close = true;
4829 }
4830 }
4831 126 => {
4832 cfg.feature_flags.early_exit_on_iffw = true;
4833 }
4834 127 => {
4835 cfg.feature_flags.always_advance_dkg_to_resolution = true;
4836
4837 cfg.verify_bulletproofs_ristretto255_base_cost = Some(23866);
4838 cfg.verify_bulletproofs_ristretto255_cost_per_bit_and_commitment = Some(1324);
4839 cfg.group_ops_ristretto_decode_scalar_cost = Some(5);
4840 cfg.group_ops_ristretto_decode_point_cost = Some(216);
4841 cfg.group_ops_ristretto_scalar_add_cost = Some(2);
4842 cfg.group_ops_ristretto_point_add_cost = Some(8);
4843 cfg.group_ops_ristretto_scalar_sub_cost = Some(2);
4844 cfg.group_ops_ristretto_point_sub_cost = Some(8);
4845 cfg.group_ops_ristretto_scalar_mul_cost = Some(5);
4846 cfg.group_ops_ristretto_point_mul_cost = Some(1763);
4847 cfg.group_ops_ristretto_scalar_div_cost = Some(557);
4848 cfg.group_ops_ristretto_point_div_cost = Some(2244);
4849
4850 if chain != Chain::Mainnet {
4851 cfg.feature_flags.enable_ristretto255_group_ops = true;
4852 cfg.feature_flags.enable_verify_bulletproofs_ristretto255 = true;
4853 }
4854
4855 cfg.feature_flags.timestamp_based_epoch_close = true;
4856 }
4857 128 => {
4858 cfg.max_generic_instantiation_type_nodes_per_function = Some(10_000);
4859 cfg.max_generic_instantiation_type_nodes_per_module = Some(500_000);
4860 cfg.binary_enum_defs = Some(200);
4861 cfg.binary_enum_def_instantiations = Some(100);
4862 }
4863 129 => {
4864 cfg.feature_flags.enable_unified_linkage = true;
4865 }
4866 130 => {
4867 cfg.feature_flags.record_net_unsettled_object_withdraws = true;
4868 cfg.feature_flags.enable_init_on_upgrade = true;
4869 cfg.epoch_close_deadline_ms = Some(120_000);
4870 cfg.scratch_add_cost_base = Some(13);
4871 cfg.scratch_read_cost_base = Some(13);
4872 cfg.scratch_read_value_cost = Some(1);
4873 cfg.scratch_remove_cost_base = Some(13);
4874 cfg.scratch_exists_cost_base = Some(13);
4875 cfg.scratch_exists_with_type_cost_base = Some(13);
4876 cfg.scratch_exists_with_type_type_cost = Some(1);
4877 let max_commands = cfg.max_programmable_tx_commands() as u64;
4878 cfg.max_scratch_pad_size = Some(16 * max_commands);
4879 if chain != Chain::Mainnet && chain != Chain::Testnet {
4881 cfg.feature_flags.zklogin_circuit_mode = 1;
4882 }
4883 }
4884 131 => {
4885 cfg.feature_flags.share_transaction_deny_config_in_consensus = true;
4886 cfg.feature_flags.framework_tx_context_mut_restrictions = true;
4887 }
4888 132 => {
4889 if chain != Chain::Mainnet && chain != Chain::Testnet {
4890 cfg.feature_flags.defer_owned_object_double_spend = true;
4891 cfg.feature_flags.create_forwarding_address_registry = true;
4892 }
4893 cfg.object_record_new_uid_from_hash_cost_base = Some(1);
4894 cfg.feature_flags
4895 .enable_order_independent_upgrade_init_linkage = true;
4896 }
4897 133 => {
4898 cfg.feature_flags
4899 .include_function_signatures_in_instantiation_limits = true;
4900 cfg.max_accumulator_type_nodes = Some(16);
4901 }
4902 134 => {
4903 if chain != Chain::Mainnet {
4910 cfg.package_original_package_id_impl_cost_base = Some(52);
4911 let package_read_cost_per_byte = cfg.obj_access_cost_read_per_byte();
4912 cfg.package_original_package_id_impl_cost_per_byte =
4913 Some(package_read_cost_per_byte);
4914
4915 cfg.consensus_max_transactions_in_block_bytes = Some(288 * 1024);
4916 cfg.consensus_max_num_transactions_in_block = Some(128);
4917 }
4918
4919 if chain == Chain::Mainnet {
4920 cfg.feature_flags.defer_unpaid_amplification = false;
4921 }
4922 }
4923 135 => {
4924 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 cfg.feature_flags.defer_unpaid_amplification = false;
4935 }
4936 136 => {
4937 cfg.feature_flags.ptb_tx_context_restrictions = true;
4938
4939 cfg.translation_per_live_reference_charge = Some(1);
4940 cfg.max_ptb_live_references = Some(64);
4941 cfg.max_ptb_returned_references = Some(16);
4942 cfg.max_ptb_total_returned_references = Some(256);
4943
4944 if chain != Chain::Mainnet && chain != Chain::Testnet {
4945 cfg.feature_flags.allowed_proposers = true;
4946 }
4947 cfg.feature_flags.harden_linkage_consistency = true;
4948
4949 cfg.package_arena_size_in_bytes = Some(10_000_000);
4950 }
4951 137 => {
4952 cfg.verify_bulletproofs_ristretto255_cost_per_bit_and_commitment = Some(621);
4953 cfg.max_bulletproofs_total_bits = Some(1024);
4954
4955 if chain != Chain::Mainnet {
4956 cfg.feature_flags.enable_allowances = true;
4957 }
4958 cfg.feature_flags.fix_ptb_generated_reads = true;
4959 cfg.feature_flags.charge_ld_const_abstract_size = true;
4960 if chain != Chain::Mainnet && chain != Chain::Testnet {
4961 cfg.feature_flags.check_object_funds_withdraw_in_execution = true;
4962 }
4963 cfg.reserve_object_funds_for_withdrawal_cost_base = Some(52);
4964 cfg.reserve_object_funds_for_withdrawal_cold_read_cost = Some(184);
4967
4968 cfg.feature_flags.allowed_proposers = true;
4969
4970 cfg.feature_flags.validate_ptb_argument_indices = true;
4971 cfg.feature_flags.memory_safety_invariant_check_v2 = true;
4972 }
4973 138 => {
4974 cfg.gas_model_version = Some(15);
4975 cfg.feature_flags.enable_allowances = true;
4976 if chain != Chain::Mainnet {
4977 cfg.feature_flags.check_object_funds_withdraw_in_execution = true;
4978 cfg.feature_flags.disable_effects_tx_dependencies = true;
4979 }
4980 cfg.feature_flags.merge_colliding_deferrals = true;
4981 if chain == Chain::Mainnet {
4983 cfg.storage_rebate_rate = Some(9999);
4984 }
4985 }
4986 139 => {
4987 if chain != Chain::Mainnet && chain != Chain::Testnet {
4988 cfg.feature_flags.enable_forwarding_addresses = true;
4989 cfg.feature_flags.mldsa65_auth = true;
4990 }
4991 cfg.storage_rebate_rate = Some(9999);
4992 if chain != Chain::Mainnet {
4993 cfg.feature_flags.allow_dkg_completion_after_timeout = true;
4994 }
4995 cfg.obj_access_cost_read_per_package_kb = Some(154);
4997 }
4998 140 => {
4999 cfg.staggered_submission_signal_window_commits = Some(300);
5002 cfg.staggered_submission_signal_min_excess_copies_per_commit = Some(2);
5003 cfg.staggered_submission_signal_exit_dwell_commits = Some(6000);
5004 cfg.staggered_submission_signal_band1_enter_ratio_bps = Some(1000);
5005 cfg.staggered_submission_signal_band1_exit_ratio_bps = Some(500);
5006 cfg.staggered_submission_signal_band2_enter_ratio_bps = Some(5000);
5007 cfg.staggered_submission_signal_band2_exit_ratio_bps = Some(2500);
5008
5009 cfg.vector_reverse_base_cost = Some(52);
5010 cfg.vector_reverse_per_elem_cost = Some(8);
5011 cfg.vector_keep_range_base_cost = Some(52);
5012 cfg.vector_keep_range_per_dropped_elem_cost = Some(1);
5013 cfg.vector_keep_range_per_moved_elem_cost = Some(8);
5014 cfg.vector_copy_range_base_cost = Some(52);
5015 cfg.vector_replace_range_base_cost = Some(52);
5016 cfg.vector_replace_range_per_elem_cost = Some(8);
5017
5018 if chain != Chain::Mainnet && chain != Chain::Testnet {
5019 cfg.feature_flags.shuffle_consensus_commit_blocks = true;
5020 }
5021
5022 cfg.feature_flags.allow_references_in_ptbs = true;
5023 cfg.feature_flags.disable_id_leak_verifier = true;
5024 cfg.feature_flags.check_object_funds_withdraw_in_execution = true;
5025 cfg.feature_flags.disable_effects_tx_dependencies = true;
5026 }
5027 141 => {
5028 cfg.feature_flags.complete_effects_size_estimate = true;
5029 cfg.max_num_accumulator_events = Some(1024);
5030 }
5031 142 => {
5032 cfg.clock_borrow_cost_base = Some(52);
5033 cfg.feature_flags.check_groth16_pvk_length = true;
5034 cfg.object_is_shared_input_cost_base = Some(52);
5035 cfg.feature_flags.secp256r1_ecrecover_checks_x_below_p = true;
5036 cfg.binary_format_limits_profile = Some(BinaryFormatLimitsProfile::V1);
5037 cfg.feature_flags.defer_owned_object_double_spend = true;
5038 }
5039 143 => {
5040 cfg.execution_version = Some(5);
5041 cfg.package_arena_size_in_bytes = Some(20_000_000);
5042 cfg.feature_flags.simplify_nitro_header_validation = true;
5043 cfg.feature_flags.enable_forwarding_addresses = false;
5044 cfg.feature_flags.package_publish_charge = true;
5045 cfg.package_publish_charge_fixed = Some(1_000_000_000);
5046 cfg.package_publish_charge_per_module = Some(10_000_000);
5047 cfg.package_publish_charge_per_dependency = Some(10_000_000);
5048 }
5049 _ => panic!("unsupported version {:?}", version),
5060 }
5061 }
5062
5063 cfg
5064 }
5065
5066 pub fn apply_seeded_test_overrides(&mut self, seed: &[u8; 32]) {
5067 if !self.feature_flags.randomize_checkpoint_tx_limit_in_tests
5068 || !self.feature_flags.split_checkpoints_in_consensus_handler
5069 {
5070 return;
5071 }
5072
5073 if !mysten_common::in_test_configuration() {
5074 return;
5075 }
5076
5077 use rand::{Rng, SeedableRng, rngs::StdRng};
5078 let mut rng = StdRng::from_seed(*seed);
5079 let max_txns = rng.gen_range(10..=100u64);
5080 info!("seeded test override: max_transactions_per_checkpoint = {max_txns}");
5081 self.max_transactions_per_checkpoint = Some(max_txns);
5082 }
5083
5084 pub fn verifier_config(&self, signing_limits: Option<(usize, usize, usize)>) -> VerifierConfig {
5090 let (
5091 max_back_edges_per_function,
5092 max_back_edges_per_module,
5093 sanity_check_with_regex_reference_safety,
5094 ) = if let Some((
5095 max_back_edges_per_function,
5096 max_back_edges_per_module,
5097 sanity_check_with_regex_reference_safety,
5098 )) = signing_limits
5099 {
5100 (
5101 Some(max_back_edges_per_function),
5102 Some(max_back_edges_per_module),
5103 Some(sanity_check_with_regex_reference_safety),
5104 )
5105 } else {
5106 (None, None, None)
5107 };
5108
5109 let additional_borrow_checks = if signing_limits.is_some() {
5110 true
5112 } else {
5113 self.additional_borrow_checks()
5114 };
5115 let deprecate_global_storage_ops = if signing_limits.is_some() {
5116 true
5118 } else {
5119 self.deprecate_global_storage_ops()
5120 };
5121
5122 VerifierConfig {
5123 max_loop_depth: Some(self.max_loop_depth() as usize),
5124 max_generic_instantiation_length: Some(self.max_generic_instantiation_length() as usize),
5125 max_function_parameters: Some(self.max_function_parameters() as usize),
5126 max_basic_blocks: Some(self.max_basic_blocks() as usize),
5127 max_value_stack_size: self.max_value_stack_size() as usize,
5128 max_type_nodes: Some(self.max_type_nodes() as usize),
5129 max_generic_instantiation_type_nodes_per_function: self
5130 .max_generic_instantiation_type_nodes_per_function_as_option()
5131 .map(|v| v as usize),
5132 max_generic_instantiation_type_nodes_per_module: self
5133 .max_generic_instantiation_type_nodes_per_module_as_option()
5134 .map(|v| v as usize),
5135 include_function_signatures_in_instantiation_limits: self
5136 .include_function_signatures_in_instantiation_limits(),
5137 max_push_size: Some(self.max_push_size() as usize),
5138 max_dependency_depth: Some(self.max_dependency_depth() as usize),
5139 max_fields_in_struct: Some(self.max_fields_in_struct() as usize),
5140 max_function_definitions: Some(self.max_function_definitions() as usize),
5141 max_data_definitions: Some(self.max_struct_definitions() as usize),
5142 max_constant_vector_len: Some(self.max_move_vector_len()),
5143 max_back_edges_per_function,
5144 max_back_edges_per_module,
5145 max_basic_blocks_in_script: None,
5146 max_identifier_len: self.max_move_identifier_len_as_option(), disallow_self_identifier: self.feature_flags.disallow_self_identifier,
5148 allow_receiving_object_id: self.allow_receiving_object_id(),
5149 reject_mutable_random_on_entry_functions: self
5150 .reject_mutable_random_on_entry_functions(),
5151 bytecode_version: self.move_binary_format_version(),
5152 max_variants_in_enum: self.max_move_enum_variants_as_option(),
5153 additional_borrow_checks,
5154 better_loader_errors: self.better_loader_errors(),
5155 private_generics_verifier_v2: self.private_generics_verifier_v2(),
5156 sanity_check_with_regex_reference_safety: sanity_check_with_regex_reference_safety
5157 .map(|limit| limit as u128),
5158 deprecate_global_storage_ops,
5159 disable_entry_point_signature_check: self.disable_entry_point_signature_check(),
5160 disable_id_leak_verifier: self.disable_id_leak_verifier(),
5161 switch_to_regex_reference_safety: false,
5162 framework_tx_context_mut_restrictions: self.framework_tx_context_mut_restrictions(),
5163 disallow_jump_orphans: self.disallow_jump_orphans(),
5164 }
5165 }
5166
5167 pub fn binary_config(
5168 &self,
5169 override_deprecate_global_storage_ops_during_deserialization: Option<bool>,
5170 ) -> BinaryConfig {
5171 let deprecate_global_storage_ops =
5172 override_deprecate_global_storage_ops_during_deserialization
5173 .unwrap_or_else(|| self.deprecate_global_storage_ops());
5174 BinaryConfig::new(
5175 self.move_binary_format_version(),
5176 self.min_move_binary_format_version_as_option()
5177 .unwrap_or(VERSION_1),
5178 self.no_extraneous_module_bytes(),
5179 deprecate_global_storage_ops,
5180 TableConfig {
5181 module_handles: self.binary_module_handles_as_option().unwrap_or(u16::MAX),
5182 datatype_handles: self.binary_struct_handles_as_option().unwrap_or(u16::MAX),
5183 function_handles: self.binary_function_handles_as_option().unwrap_or(u16::MAX),
5184 function_instantiations: self
5185 .binary_function_instantiations_as_option()
5186 .unwrap_or(u16::MAX),
5187 signatures: self.binary_signatures_as_option().unwrap_or(u16::MAX),
5188 constant_pool: self.binary_constant_pool_as_option().unwrap_or(u16::MAX),
5189 identifiers: self.binary_identifiers_as_option().unwrap_or(u16::MAX),
5190 address_identifiers: self
5191 .binary_address_identifiers_as_option()
5192 .unwrap_or(u16::MAX),
5193 struct_defs: self.binary_struct_defs_as_option().unwrap_or(u16::MAX),
5194 struct_def_instantiations: self
5195 .binary_struct_def_instantiations_as_option()
5196 .unwrap_or(u16::MAX),
5197 function_defs: self.binary_function_defs_as_option().unwrap_or(u16::MAX),
5198 field_handles: self.binary_field_handles_as_option().unwrap_or(u16::MAX),
5199 field_instantiations: self
5200 .binary_field_instantiations_as_option()
5201 .unwrap_or(u16::MAX),
5202 friend_decls: self.binary_friend_decls_as_option().unwrap_or(u16::MAX),
5203 enum_defs: self.binary_enum_defs_as_option().unwrap_or(u16::MAX),
5204 enum_def_instantiations: self
5205 .binary_enum_def_instantiations_as_option()
5206 .unwrap_or(u16::MAX),
5207 variant_handles: self.binary_variant_handles_as_option().unwrap_or(u16::MAX),
5208 variant_instantiation_handles: self
5209 .binary_variant_instantiation_handles_as_option()
5210 .unwrap_or(u16::MAX),
5211 },
5212 self.binary_format_limits(),
5213 )
5214 }
5215
5216 pub fn binary_format_limits(
5217 &self,
5218 ) -> &'static move_binary_format::binary_config::BinaryFormatLimits {
5219 self.binary_format_limits_profile
5220 .unwrap_or(BinaryFormatLimitsProfile::LEGACY)
5221 .limits()
5222 }
5223
5224 pub fn apply_overrides_for_testing(
5228 override_fn: impl Fn(ProtocolVersion, Self) -> Self + Send + Sync + 'static,
5229 ) -> OverrideGuard {
5230 let mut cur = CONFIG_OVERRIDE.lock().unwrap();
5231 assert!(cur.is_none(), "config override already present");
5232 *cur = Some(Box::new(override_fn));
5233 OverrideGuard
5234 }
5235
5236 #[cfg(feature = "testing")]
5240 pub fn apply_base_overrides_for_testing(
5241 override_fn: impl Fn(ProtocolVersion, Self) -> Self + Send + Sync + 'static,
5242 ) -> BaseOverrideGuard {
5243 info!("installing base ProtocolConfig override for testing");
5244 let override_fn: Arc<OverrideFn> = Arc::new(override_fn);
5245 BASE_CONFIG_OVERRIDES
5246 .lock()
5247 .unwrap()
5248 .push(override_fn.clone());
5249 BaseOverrideGuard { override_fn }
5250 }
5251
5252 fn apply_config_override(version: ProtocolVersion, mut ret: Self) -> Self {
5253 #[cfg(feature = "testing")]
5255 {
5256 let fns = BASE_CONFIG_OVERRIDES.lock().unwrap().clone();
5257 for override_fn in fns {
5258 ret = override_fn(version, ret);
5259 }
5260 }
5261 if let Some(override_fn) = CONFIG_OVERRIDE.lock().unwrap().as_ref() {
5262 warn!(
5263 "overriding ProtocolConfig settings with custom settings (you should not see this log outside of tests)"
5264 );
5265 ret = override_fn(version, ret);
5266 }
5267 ret
5268 }
5269}
5270
5271impl ProtocolConfig {
5275 pub fn set_execution_version_for_testing(&mut self, val: u64) {
5279 let current = self.execution_version.unwrap_or(0);
5280 assert!(
5281 val >= current,
5282 "cannot downgrade execution_version from {current} to {val}: running an old \
5283 executor against a newer protocol config/framework is unsupported. To test \
5284 frozen executor behavior, start from the last protocol version of that executor \
5285 instead, so genesis loads the matching framework snapshot (see \
5286 test_address_balance_gas_v3_accumulator_sign)."
5287 );
5288 self.execution_version = Some(val);
5289 }
5290
5291 pub fn set_zklogin_circuit_mode_for_testing(&mut self, val: u64) {
5294 self.feature_flags.zklogin_circuit_mode = val
5295 }
5296
5297 pub fn set_per_object_congestion_control_mode_for_testing(
5298 &mut self,
5299 val: PerObjectCongestionControlMode,
5300 ) {
5301 self.feature_flags.per_object_congestion_control_mode = val;
5302 }
5303
5304 pub fn set_consensus_choice_for_testing(&mut self, val: ConsensusChoice) {
5305 self.feature_flags.consensus_choice = val;
5306 }
5307
5308 pub fn set_consensus_network_for_testing(&mut self, val: ConsensusNetwork) {
5309 self.feature_flags.consensus_network = val;
5310 }
5311
5312 pub fn set_zklogin_max_epoch_upper_bound_delta_for_testing(&mut self, val: Option<u64>) {
5313 self.feature_flags.zklogin_max_epoch_upper_bound_delta = val
5314 }
5315
5316 pub fn set_mysticeti_num_leaders_per_round_for_testing(&mut self, val: Option<usize>) {
5317 self.feature_flags.mysticeti_num_leaders_per_round = val;
5318 }
5319
5320 pub fn disable_accumulators_for_testing(&mut self) {
5321 self.feature_flags.enable_accumulators = false;
5322 self.feature_flags.enable_address_balance_gas_payments = false;
5323 }
5324
5325 pub fn enable_coin_reservation_for_testing(&mut self) {
5326 self.feature_flags.enable_coin_reservation_obj_refs = true;
5327 self.feature_flags
5328 .convert_withdrawal_compatibility_ptb_arguments = true;
5329 self.execution_version = Some(self.execution_version.map_or(4, |v| v.max(4)));
5332 }
5333
5334 pub fn disable_coin_reservation_for_testing(&mut self) {
5335 self.feature_flags.enable_coin_reservation_obj_refs = false;
5336 self.feature_flags
5337 .convert_withdrawal_compatibility_ptb_arguments = false;
5338 }
5339
5340 pub fn enable_address_balance_gas_payments_for_testing(&mut self) {
5341 self.feature_flags.enable_accumulators = true;
5342 self.feature_flags.allow_private_accumulator_entrypoints = true;
5343 self.feature_flags.enable_address_balance_gas_payments = true;
5344 self.feature_flags.address_balance_gas_check_rgp_at_signing = true;
5345 self.feature_flags.address_balance_gas_reject_gas_coin_arg = false;
5346 self.execution_version = Some(self.execution_version.map_or(4, |v| v.max(4)))
5347 }
5348
5349 pub fn enable_gasless_for_testing(&mut self) {
5350 self.enable_address_balance_gas_payments_for_testing();
5351 self.feature_flags.enable_gasless = true;
5352 self.feature_flags.gasless_verify_remaining_balance = true;
5353 self.gasless_max_computation_units = Some(5_000);
5354 self.gasless_allowed_token_types = Some(vec![]);
5355 self.gasless_max_tps = Some(1000);
5356 self.gasless_max_tx_size_bytes = Some(16 * 1024);
5357 }
5358
5359 pub fn disable_gasless_for_testing(&mut self) {
5360 self.feature_flags.enable_gasless = false;
5361 self.gasless_max_computation_units = None;
5362 self.gasless_allowed_token_types = None;
5363 }
5364
5365 pub fn enable_authenticated_event_streams_for_testing(&mut self) {
5366 self.feature_flags.enable_accumulators = true;
5367 self.feature_flags.enable_authenticated_event_streams = true;
5368 self.feature_flags
5369 .include_checkpoint_artifacts_digest_in_summary = true;
5370 self.feature_flags.split_checkpoints_in_consensus_handler = true;
5371 }
5372}
5373
5374type OverrideFn = dyn Fn(ProtocolVersion, ProtocolConfig) -> ProtocolConfig + Send + Sync;
5375
5376static CONFIG_OVERRIDE: Mutex<Option<Box<OverrideFn>>> = Mutex::new(None);
5377
5378#[must_use]
5379pub struct OverrideGuard;
5380
5381impl Drop for OverrideGuard {
5382 fn drop(&mut self) {
5383 info!("restoring override fn");
5384 *CONFIG_OVERRIDE.lock().unwrap() = None;
5385 }
5386}
5387
5388#[cfg(feature = "testing")]
5389static BASE_CONFIG_OVERRIDES: Mutex<Vec<Arc<OverrideFn>>> = Mutex::new(Vec::new());
5390
5391#[cfg(feature = "testing")]
5392#[must_use]
5393pub struct BaseOverrideGuard {
5394 override_fn: Arc<OverrideFn>,
5395}
5396
5397#[cfg(feature = "testing")]
5398impl Drop for BaseOverrideGuard {
5399 fn drop(&mut self) {
5400 BASE_CONFIG_OVERRIDES
5401 .lock()
5402 .unwrap()
5403 .retain(|f| !Arc::ptr_eq(f, &self.override_fn));
5404 }
5405}
5406
5407#[derive(PartialEq, Eq)]
5410pub enum LimitThresholdCrossed {
5411 None,
5412 Soft(u128, u128),
5413 Hard(u128, u128),
5414}
5415
5416pub fn check_limit_in_range<T: Into<V>, U: Into<V>, V: PartialOrd + Into<u128>>(
5419 x: T,
5420 soft_limit: U,
5421 hard_limit: V,
5422) -> LimitThresholdCrossed {
5423 let x: V = x.into();
5424 let soft_limit: V = soft_limit.into();
5425
5426 debug_assert!(soft_limit <= hard_limit);
5427
5428 if x >= hard_limit {
5431 LimitThresholdCrossed::Hard(x.into(), hard_limit.into())
5432 } else if x < soft_limit {
5433 LimitThresholdCrossed::None
5434 } else {
5435 LimitThresholdCrossed::Soft(x.into(), soft_limit.into())
5436 }
5437}
5438
5439#[macro_export]
5440macro_rules! assert_set {
5441 ($protocol_config:expr, $($flag:ident),+ $(,)?) => {{
5442 let protocol_config = $protocol_config;
5443 $(
5444 assert!(
5445 protocol_config.$flag(),
5446 "protocol config flag `{}` must be set",
5447 stringify!($flag),
5448 );
5449 )+
5450 }};
5451}
5452
5453#[macro_export]
5454macro_rules! check_limit {
5455 ($x:expr, $hard:expr) => {
5456 check_limit!($x, $hard, $hard)
5457 };
5458 ($x:expr, $soft:expr, $hard:expr) => {
5459 check_limit_in_range($x as u64, $soft, $hard)
5460 };
5461}
5462
5463#[macro_export]
5467macro_rules! check_limit_by_meter {
5468 ($is_metered:expr, $x:expr, $metered_limit:expr, $unmetered_hard_limit:expr, $metric:expr) => {{
5469 let (h, metered_str) = if $is_metered {
5471 ($metered_limit, "metered")
5472 } else {
5473 ($unmetered_hard_limit, "unmetered")
5475 };
5476 use sui_protocol_config::check_limit_in_range;
5477 let result = check_limit_in_range($x as u64, $metered_limit, h);
5478 match result {
5479 LimitThresholdCrossed::None => {}
5480 LimitThresholdCrossed::Soft(_, _) => {
5481 $metric.with_label_values(&[metered_str, "soft"]).inc();
5482 }
5483 LimitThresholdCrossed::Hard(_, _) => {
5484 $metric.with_label_values(&[metered_str, "hard"]).inc();
5485 }
5486 };
5487 result
5488 }};
5489}
5490
5491pub type Amendments = BTreeMap<AccountAddress, BTreeMap<AccountAddress, AccountAddress>>;
5494
5495static MAINNET_LINKAGE_AMENDMENTS: LazyLock<Arc<Amendments>> =
5496 LazyLock::new(|| parse_amendments(include_str!("mainnet_amendments.json")));
5497
5498static TESTNET_LINKAGE_AMENDMENTS: LazyLock<Arc<Amendments>> =
5499 LazyLock::new(|| parse_amendments(include_str!("testnet_amendments.json")));
5500
5501fn parse_amendments(json: &str) -> Arc<Amendments> {
5502 #[derive(serde::Deserialize)]
5503 struct AmendmentEntry {
5504 root: String,
5505 deps: Vec<DepEntry>,
5506 }
5507
5508 #[derive(serde::Deserialize)]
5509 struct DepEntry {
5510 original_id: String,
5511 version_id: String,
5512 }
5513
5514 let entries: Vec<AmendmentEntry> =
5515 serde_json::from_str(json).expect("Failed to parse amendments JSON");
5516 let mut amendments = BTreeMap::new();
5517 for entry in entries {
5518 let root_id = AccountAddress::from_hex_literal(&entry.root).unwrap();
5519 let mut dep_ids = BTreeMap::new();
5520 for dep in entry.deps {
5521 let orig_id = AccountAddress::from_hex_literal(&dep.original_id).unwrap();
5522 let upgraded_id = AccountAddress::from_hex_literal(&dep.version_id).unwrap();
5523 assert!(
5524 dep_ids.insert(orig_id, upgraded_id).is_none(),
5525 "Duplicate original ID in amendments table"
5526 );
5527 }
5528 assert!(
5529 amendments.insert(root_id, dep_ids).is_none(),
5530 "Duplicate root ID in amendments table"
5531 );
5532 }
5533 Arc::new(amendments)
5534}
5535
5536#[cfg(all(test, not(msim)))]
5537mod test {
5538 use insta::assert_yaml_snapshot;
5539
5540 use super::*;
5541
5542 #[test]
5543 fn snapshot_tests() {
5544 println!("\n============================================================================");
5545 println!("! !");
5546 println!("! IMPORTANT: never update snapshots from this test. only add new versions! !");
5547 println!("! !");
5548 println!("============================================================================\n");
5549 for chain_id in &[Chain::Unknown, Chain::Mainnet, Chain::Testnet] {
5550 let chain_str = match chain_id {
5554 Chain::Unknown => "".to_string(),
5555 _ => format!("{:?}_", chain_id),
5556 };
5557 for i in MIN_PROTOCOL_VERSION..=MAX_PROTOCOL_VERSION {
5558 let cur = ProtocolVersion::new(i);
5559 assert_yaml_snapshot!(
5560 format!("{}version_{}", chain_str, cur.as_u64()),
5561 ProtocolConfig::get_for_version(cur, *chain_id)
5562 );
5563 }
5564 }
5565 }
5566
5567 #[test]
5568 fn binary_format_limits_profile_matches_protocol_version() {
5569 let v141 = ProtocolConfig::get_for_version(ProtocolVersion::new(141), Chain::Unknown);
5570 assert_eq!(
5571 v141.binary_format_limits(),
5572 BinaryFormatLimitsProfile::LEGACY.limits()
5573 );
5574
5575 let v142 = ProtocolConfig::get_for_version(ProtocolVersion::new(142), Chain::Unknown);
5576 assert_eq!(
5577 v142.binary_format_limits(),
5578 BinaryFormatLimitsProfile::V1.limits()
5579 );
5580 }
5581
5582 #[test]
5583 fn test_getters() {
5584 let prot: ProtocolConfig =
5585 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5586 assert_eq!(
5587 prot.max_arguments(),
5588 prot.max_arguments_as_option().unwrap()
5589 );
5590 }
5591
5592 #[test]
5593 fn vector_bulk_native_gas_costs_start_at_version_140() {
5594 for chain in [Chain::Unknown, Chain::Mainnet, Chain::Testnet] {
5595 let before = ProtocolConfig::get_for_version(ProtocolVersion::new(139), chain);
5596 assert_eq!(before.vector_reverse_base_cost_as_option(), None);
5597 assert_eq!(before.vector_reverse_per_elem_cost_as_option(), None);
5598 assert_eq!(before.vector_keep_range_base_cost_as_option(), None);
5599 assert_eq!(
5600 before.vector_keep_range_per_dropped_elem_cost_as_option(),
5601 None
5602 );
5603 assert_eq!(
5604 before.vector_keep_range_per_moved_elem_cost_as_option(),
5605 None
5606 );
5607 assert_eq!(before.vector_copy_range_base_cost_as_option(), None);
5608 assert_eq!(before.vector_replace_range_base_cost_as_option(), None);
5609 assert_eq!(before.vector_replace_range_per_elem_cost_as_option(), None);
5610
5611 let active = ProtocolConfig::get_for_version(ProtocolVersion::new(140), chain);
5612 assert_eq!(active.vector_reverse_base_cost_as_option(), Some(52));
5613 assert_eq!(active.vector_reverse_per_elem_cost_as_option(), Some(8));
5614 assert_eq!(active.vector_keep_range_base_cost_as_option(), Some(52));
5615 assert_eq!(
5616 active.vector_keep_range_per_dropped_elem_cost_as_option(),
5617 Some(1)
5618 );
5619 assert_eq!(
5620 active.vector_keep_range_per_moved_elem_cost_as_option(),
5621 Some(8)
5622 );
5623 assert_eq!(active.vector_copy_range_base_cost_as_option(), Some(52));
5624 assert_eq!(active.vector_replace_range_base_cost_as_option(), Some(52));
5625 assert_eq!(
5626 active.vector_replace_range_per_elem_cost_as_option(),
5627 Some(8)
5628 );
5629 }
5630 }
5631
5632 #[test]
5633 fn test_setters() {
5634 let mut prot: ProtocolConfig =
5635 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5636 prot.set_max_arguments_for_testing(123);
5637 assert_eq!(prot.max_arguments(), 123);
5638
5639 prot.set_max_arguments_from_str_for_testing("321".to_string());
5640 assert_eq!(prot.max_arguments(), 321);
5641
5642 prot.disable_max_arguments_for_testing();
5643 assert_eq!(prot.max_arguments_as_option(), None);
5644
5645 prot.set_attr_for_testing("max_arguments".to_string(), "456".to_string());
5646 assert_eq!(prot.max_arguments(), 456);
5647 }
5648
5649 #[test]
5650 fn test_execution_version_setter_allows_upgrade() {
5651 let mut prot = ProtocolConfig::get_for_max_version_UNSAFE();
5652 let current = prot.execution_version();
5653 prot.set_execution_version_for_testing(current);
5654 prot.set_execution_version_for_testing(current + 1);
5655 assert_eq!(prot.execution_version(), current + 1);
5656 }
5657
5658 #[test]
5659 #[should_panic(expected = "cannot downgrade execution_version")]
5660 fn test_execution_version_setter_panics_on_downgrade() {
5661 let mut prot = ProtocolConfig::get_for_max_version_UNSAFE();
5662 let current = prot.execution_version();
5663 prot.set_execution_version_for_testing(current - 1);
5664 }
5665
5666 #[test]
5667 fn test_feature_flag_setter_by_string() {
5668 let mut prot: ProtocolConfig =
5669 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5670 assert!(!prot.zklogin_auth());
5671 prot.set_feature_flag_for_testing("zklogin_auth".to_string(), true);
5672 assert!(prot.zklogin_auth());
5673 prot.set_feature_flag_for_testing("zklogin_auth".to_string(), false);
5674 assert!(!prot.zklogin_auth());
5675 }
5676
5677 #[test]
5678 #[should_panic(expected = "unknown feature flag")]
5679 fn test_feature_flag_setter_unknown_flag() {
5680 let mut prot: ProtocolConfig =
5681 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5682 prot.set_feature_flag_for_testing("some random string".to_string(), true);
5683 }
5684
5685 #[test]
5686 fn test_get_for_version_if_supported_applies_test_overrides() {
5687 let before =
5688 ProtocolConfig::get_for_version_if_supported(ProtocolVersion::new(1), Chain::Unknown)
5689 .unwrap();
5690
5691 assert!(!before.enable_coin_reservation_obj_refs());
5692
5693 let _guard = ProtocolConfig::apply_overrides_for_testing(|_, mut cfg| {
5694 cfg.enable_coin_reservation_for_testing();
5695 cfg
5696 });
5697
5698 let after =
5699 ProtocolConfig::get_for_version_if_supported(ProtocolVersion::new(1), Chain::Unknown)
5700 .unwrap();
5701
5702 assert!(after.enable_coin_reservation_obj_refs());
5703 }
5704
5705 #[test]
5706 #[should_panic(expected = "unsupported version")]
5707 fn max_version_test() {
5708 let _ = ProtocolConfig::get_for_version_impl(
5711 ProtocolVersion::new(MAX_PROTOCOL_VERSION + 1),
5712 Chain::Unknown,
5713 );
5714 }
5715
5716 #[test]
5717 fn lookup_by_string_test() {
5718 let prot: ProtocolConfig =
5719 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5720 assert!(prot.lookup_attr("some random string".to_string()).is_none());
5722
5723 assert!(
5724 prot.lookup_attr("max_arguments".to_string())
5725 == Some(ProtocolConfigValue::u32(prot.max_arguments())),
5726 );
5727
5728 assert!(
5730 prot.lookup_attr("max_move_identifier_len".to_string())
5731 .is_none()
5732 );
5733
5734 let prot: ProtocolConfig =
5736 ProtocolConfig::get_for_version(ProtocolVersion::new(9), Chain::Unknown);
5737 assert!(
5738 prot.lookup_attr("max_move_identifier_len".to_string())
5739 == Some(ProtocolConfigValue::u64(prot.max_move_identifier_len()))
5740 );
5741
5742 let prot: ProtocolConfig =
5743 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5744 assert!(
5746 prot.attr_map()
5747 .get("max_move_identifier_len")
5748 .unwrap()
5749 .is_none()
5750 );
5751 assert!(
5753 prot.attr_map().get("max_arguments").unwrap()
5754 == &Some(ProtocolConfigValue::u32(prot.max_arguments()))
5755 );
5756
5757 let prot: ProtocolConfig =
5759 ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5760 assert!(
5762 prot.feature_flags
5763 .lookup_attr("some random string".to_owned())
5764 .is_none()
5765 );
5766 assert!(
5767 !prot
5768 .feature_flags
5769 .attr_map()
5770 .contains_key("some random string")
5771 );
5772
5773 assert!(
5775 prot.feature_flags
5776 .lookup_attr("package_upgrades".to_owned())
5777 == Some(false)
5778 );
5779 assert!(
5780 prot.feature_flags
5781 .attr_map()
5782 .get("package_upgrades")
5783 .unwrap()
5784 == &false
5785 );
5786 let prot: ProtocolConfig =
5787 ProtocolConfig::get_for_version(ProtocolVersion::new(4), Chain::Unknown);
5788 assert!(
5790 prot.feature_flags
5791 .lookup_attr("package_upgrades".to_owned())
5792 == Some(true)
5793 );
5794 assert!(
5795 prot.feature_flags
5796 .attr_map()
5797 .get("package_upgrades")
5798 .unwrap()
5799 == &true
5800 );
5801 }
5802
5803 #[test]
5804 fn limit_range_fn_test() {
5805 let low = 100u32;
5806 let high = 10000u64;
5807
5808 assert!(check_limit!(1u8, low, high) == LimitThresholdCrossed::None);
5809 assert!(matches!(
5810 check_limit!(255u16, low, high),
5811 LimitThresholdCrossed::Soft(255u128, 100)
5812 ));
5813 assert!(matches!(
5819 check_limit!(2550000u64, low, high),
5820 LimitThresholdCrossed::Hard(2550000, 10000)
5821 ));
5822
5823 assert!(matches!(
5824 check_limit!(2550000u64, high, high),
5825 LimitThresholdCrossed::Hard(2550000, 10000)
5826 ));
5827
5828 assert!(matches!(
5829 check_limit!(1u8, high),
5830 LimitThresholdCrossed::None
5831 ));
5832
5833 assert!(check_limit!(255u16, high) == LimitThresholdCrossed::None);
5834
5835 assert!(matches!(
5836 check_limit!(2550000u64, high),
5837 LimitThresholdCrossed::Hard(2550000, 10000)
5838 ));
5839 }
5840
5841 #[test]
5842 fn linkage_amendments_load() {
5843 let mainnet = LazyLock::force(&MAINNET_LINKAGE_AMENDMENTS);
5844 let testnet = LazyLock::force(&TESTNET_LINKAGE_AMENDMENTS);
5845 assert!(!mainnet.is_empty(), "mainnet amendments must not be empty");
5846 assert!(!testnet.is_empty(), "testnet amendments must not be empty");
5847 }
5848
5849 #[test]
5850 fn render_scalar_fields_use_precision_safe_encoding() {
5851 use mysten_common::rpc_format::Unmetered;
5852
5853 let config = ProtocolConfig::get_for_max_version_UNSAFE();
5854 let rendered = config
5855 .render::<serde_json::Value>(&mut Unmetered)
5856 .expect("render should succeed");
5857
5858 let max_args = rendered
5859 .get("max_arguments")
5860 .expect("max_arguments set at max version");
5861 assert!(
5862 max_args.is_number(),
5863 "u32 should render as number, got {max_args:?}",
5864 );
5865
5866 let max_tx_size = rendered
5867 .get("max_tx_size_bytes")
5868 .expect("max_tx_size_bytes set at max version");
5869 assert!(
5870 max_tx_size.is_string(),
5871 "u64 should render as string, got {max_tx_size:?}",
5872 );
5873 }
5874
5875 #[test]
5876 fn render_includes_non_scalar_gasless_allowlist_as_json() {
5877 use mysten_common::rpc_format::Unmetered;
5878 use serde_json::json;
5879
5880 let mut config = ProtocolConfig::get_for_max_version_UNSAFE();
5881 config.set_gasless_allowed_token_types_for_testing(vec![
5882 ("0xa::usdc::USDC".to_string(), 10_000),
5883 ("0xb::usdt::USDT".to_string(), 0),
5884 ]);
5885
5886 let rendered = config
5887 .render::<serde_json::Value>(&mut Unmetered)
5888 .expect("render should succeed under Unmetered budget");
5889 let allowlist = rendered
5890 .get("gasless_allowed_token_types")
5891 .expect("entry should be present after the testing setter");
5892
5893 assert_eq!(
5896 allowlist,
5897 &json!([["0xa::usdc::USDC", "10000"], ["0xb::usdt::USDT", "0"],]),
5898 );
5899 }
5900
5901 #[test]
5902 fn render_targets_prost_value_for_grpc() {
5903 use mysten_common::rpc_format::Unmetered;
5904 use prost_types::value::Kind;
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(),
5909 10_000,
5910 )]);
5911
5912 let rendered = config
5913 .render::<prost_types::Value>(&mut Unmetered)
5914 .expect("render to prost Value should succeed");
5915 let allowlist = rendered
5916 .get("gasless_allowed_token_types")
5917 .expect("entry should be present after the testing setter");
5918
5919 let Some(Kind::ListValue(outer)) = &allowlist.kind else {
5921 panic!(
5922 "expected ListValue at the top level, got {:?}",
5923 allowlist.kind
5924 );
5925 };
5926 assert_eq!(outer.values.len(), 1, "one allowlisted entry");
5927 let Some(Kind::ListValue(entry)) = &outer.values[0].kind else {
5928 panic!("expected each entry to be a ListValue");
5929 };
5930 assert_eq!(entry.values.len(), 2, "entry has (coin_type, amount)");
5931
5932 let Some(Kind::StringValue(coin_type)) = &entry.values[0].kind else {
5933 panic!("expected coin_type as StringValue");
5934 };
5935 assert_eq!(coin_type, "0xa::usdc::USDC");
5936
5937 let Some(Kind::StringValue(amount)) = &entry.values[1].kind else {
5939 panic!(
5940 "expected minimum_transfer_amount as StringValue (precision-safe u64); got {:?}",
5941 entry.values[1].kind,
5942 );
5943 };
5944 assert_eq!(amount, "10000");
5945 }
5946
5947 #[test]
5948 fn render_emits_null_for_unset_protocol_versions() {
5949 use mysten_common::rpc_format::Unmetered;
5950
5951 let config = ProtocolConfig::get_for_version(1.into(), Chain::Unknown);
5952 let rendered = config
5953 .render::<serde_json::Value>(&mut Unmetered)
5954 .expect("render should succeed");
5955 let entry = rendered
5959 .get("gasless_allowed_token_types")
5960 .expect("key should be present for every protocol version");
5961 assert!(
5962 entry.is_null(),
5963 "value should be null for pre-feature protocol version, got {entry:?}",
5964 );
5965 }
5966}