sui_protocol_config/
lib.rs

1// Copyright (c) Mysten Labs, Inc.
2// SPDX-License-Identifier: Apache-2.0
3
4use std::{
5    collections::{BTreeMap, BTreeSet},
6    sync::{
7        Arc, LazyLock,
8        atomic::{AtomicBool, Ordering},
9    },
10};
11
12#[cfg(msim)]
13use std::cell::RefCell;
14#[cfg(not(msim))]
15use std::sync::Mutex;
16
17use clap::*;
18use fastcrypto::encoding::{Base58, Encoding, Hex};
19use move_binary_format::{
20    binary_config::{BinaryConfig, TableConfig},
21    file_format_common::VERSION_1,
22};
23use move_core_types::account_address::AccountAddress;
24use move_vm_config::verifier::VerifierConfig;
25use mysten_common::in_integration_test;
26use serde::{Deserialize, Serialize};
27use serde_with::skip_serializing_none;
28use sui_protocol_config_macros::{
29    ProtocolConfigAccessors, ProtocolConfigFeatureFlagsGetters, ProtocolConfigOverride,
30};
31use tracing::{info, warn};
32
33/// The minimum and maximum protocol versions supported by this build.
34const MIN_PROTOCOL_VERSION: u64 = 1;
35const MAX_PROTOCOL_VERSION: u64 = 122;
36
37const TESTNET_USDC: &str =
38    "0xa1ec7fc00a6f40db9693ad1415d0c193ad3906494428cf252621037bd7117e29::usdc::USDC";
39
40// Record history of protocol version allocations here:
41//
42// Version 1: Original version.
43// Version 2: Framework changes, including advancing epoch_start_time in safemode.
44// Version 3: gas model v2, including all sui conservation fixes. Fix for loaded child object
45//            changes, enable package upgrades, add limits on `max_size_written_objects`,
46//            `max_size_written_objects_system_tx`
47// Version 4: New reward slashing rate. Framework changes to skip stake susbidy when the epoch
48//            length is short.
49// Version 5: Package upgrade compatibility error fix. New gas cost table. New scoring decision
50//            mechanism that includes up to f scoring authorities.
51// Version 6: Change to how bytes are charged in the gas meter, increase buffer stake to 0.5f
52// Version 7: Disallow adding new abilities to types during package upgrades,
53//            disable_invariant_violation_check_in_swap_loc,
54//            disable init functions becoming entry,
55//            hash module bytes individually before computing package digest.
56// Version 8: Disallow changing abilities and type constraints for type parameters in structs
57//            during upgrades.
58// Version 9: Limit the length of Move idenfitiers to 128.
59//            Disallow extraneous module bytes,
60//            advance_to_highest_supported_protocol_version,
61// Version 10:increase bytecode verifier `max_verifier_meter_ticks_per_function` and
62//            `max_meter_ticks_per_module` limits each from 6_000_000 to 16_000_000. sui-system
63//            framework changes.
64// Version 11: Introduce `std::type_name::get_with_original_ids` to the system frameworks. Bound max depth of values within the VM.
65// Version 12: Changes to deepbook in framework to add API for querying marketplace.
66//             Change NW Batch to use versioned metadata field.
67//             Changes to sui-system package to add PTB-friendly unstake function, and minor cleanup.
68// Version 13: System package change deprecating `0xdee9::clob` and `0xdee9::custodian`, replaced by
69//             `0xdee9::clob_v2` and `0xdee9::custodian_v2`.
70// Version 14: Introduce a config variable to allow charging of computation to be either
71//             bucket base or rounding up. The presence of `gas_rounding_step` (or `None`)
72//             decides whether rounding is applied or not.
73// Version 15: Add reordering of user transactions by gas price after consensus.
74//             Add `sui::table_vec::drop` to the framework via a system package upgrade.
75// Version 16: Enabled simplified_unwrap_then_delete feature flag, which allows the execution engine
76//             to no longer consult the object store when generating unwrapped_then_deleted in the
77//             effects; this also allows us to stop including wrapped tombstones in accumulator.
78//             Add self-matching prevention for deepbook.
79// Version 17: Enable upgraded multisig support.
80// Version 18: Introduce execution layer versioning, preserve all existing behaviour in v0.
81//             Gas minimum charges moved to be a multiplier over the reference gas price. In this
82//             protocol version the multiplier is the same as the lowest bucket of computation
83//             such that the minimum transaction cost is the same as the minimum computation
84//             bucket.
85//             Add a feature flag to indicate the changes semantics of `base_tx_cost_fixed`.
86// Version 19: Changes to sui-system package to enable liquid staking.
87//             Add limit for total size of events.
88//             Increase limit for number of events emitted to 1024.
89// Version 20: Enables the flag `narwhal_new_leader_election_schedule` for the new narwhal leader
90//             schedule algorithm for enhanced fault tolerance and sets the bad node stake threshold
91//             value. Both values are set for all the environments except mainnet.
92// Version 21: ZKLogin known providers.
93// Version 22: Child object format change.
94// Version 23: Enabling the flag `narwhal_new_leader_election_schedule` for the new narwhal leader
95//             schedule algorithm for enhanced fault tolerance and sets the bad node stake threshold
96//             value for mainnet.
97// Version 24: Re-enable simple gas conservation checks.
98//             Package publish/upgrade number in a single transaction limited.
99//             JWK / authenticator state flags.
100// Version 25: Add sui::table_vec::swap and sui::table_vec::swap_remove to system packages.
101// Version 26: New gas model version.
102//             Add support for receiving objects off of other objects in devnet only.
103// Version 28: Add sui::zklogin::verify_zklogin_id and related functions to sui framework.
104//             Enable transaction effects v2 in devnet.
105// Version 29: Add verify_legacy_zklogin_address flag to sui framework, this add ability to verify
106//             transactions from a legacy zklogin address.
107// Version 30: Enable Narwhal CertificateV2
108//             Add support for random beacon.
109//             Enable transaction effects v2 in testnet.
110//             Deprecate supported oauth providers from protocol config and rely on node config
111//             instead.
112//             In execution, has_public_transfer is recomputed when loading the object.
113//             Add support for shared obj deletion and receiving objects off of other objects in devnet only.
114// Version 31: Add support for shared object deletion in devnet only.
115//             Add support for getting object ID referenced by receiving object in sui framework.
116//             Create new execution layer version, and preserve previous behavior in v1.
117//             Update semantics of `sui::transfer::receive` and add `sui::transfer::public_receive`.
118// Version 32: Add delete functions for VerifiedID and VerifiedIssuer.
119//             Add sui::token module to sui framework.
120//             Enable transfer to object in testnet.
121//             Enable Narwhal CertificateV2 on mainnet
122//             Make critbit tree and order getters public in deepbook.
123// Version 33: Add support for `receiving_object_id` function in framework
124//             Hardened OTW check.
125//             Enable transfer-to-object in mainnet.
126//             Enable shared object deletion in testnet.
127//             Enable effects v2 in mainnet.
128// Version 34: Framework changes for random beacon.
129// Version 35: Add poseidon hash function.
130//             Enable coin deny list.
131// Version 36: Enable group operations native functions in devnet.
132//             Enable shared object deletion in mainnet.
133//             Set the consensus accepted transaction size and the included transactions size in the proposed block.
134// Version 37: Reject entry functions with mutable Random.
135// Version 38: Introduce limits for binary tables size.
136// Version 39: Allow skipped epochs for randomness updates.
137//             Extra version to fix `test_upgrade_compatibility` simtest.
138// Version 40:
139// Version 41: Enable group operations native functions in testnet and mainnet (without msm).
140// Version 42: Migrate sui framework and related code to Move 2024
141// Version 43: Introduce the upper bound delta config for a zklogin signature's max epoch.
142//             Introduce an explicit parameter for the tick limit per package (previously this was
143//             represented by the parameter for the tick limit per module).
144// Version 44: Enable consensus fork detection on mainnet.
145//             Switch between Narwhal and Mysticeti consensus in tests, devnet and testnet.
146// Version 45: Use tonic networking for Mysticeti consensus.
147//             Set min Move binary format version to 6.
148//             Enable transactions to be signed with zkLogin inside multisig signature.
149//             Add native bridge.
150//             Enable native bridge in devnet
151//             Enable Leader Scoring & Schedule Change for Mysticeti consensus on testnet.
152// Version 46: Enable native bridge in testnet
153//             Enable resharing at the same initial shared version.
154// Version 47: Deepbook changes (framework update)
155// Version 48: Use tonic networking for Mysticeti.
156//             Resolve Move abort locations to the package id instead of the runtime module ID.
157//             Enable random beacon in testnet.
158//             Use new VM when verifying framework packages.
159// Version 49: Enable Move enums on devnet.
160//             Enable VDF in devnet
161//             Enable consensus commit prologue V3 in devnet.
162//             Run Mysticeti consensus by default.
163// Version 50: Add update_node_url to native bridge,
164//             New Move stdlib integer modules
165//             Enable checkpoint batching in testnet.
166//             Prepose consensus commit prologue in checkpoints.
167//             Set number of leaders per round for Mysticeti commits.
168// Version 51: Switch to DKG V1.
169//             Enable deny list v2 on devnet.
170// Version 52: Emit `CommitteeMemberUrlUpdateEvent` when updating bridge node url.
171//             std::config native functions.
172//             Modified sui-system package to enable withdrawal of stake before it becomes active.
173//             Enable soft bundle in devnet and testnet.
174//             Core macro visibility in sui core framework.
175//             Enable checkpoint batching in mainnet.
176//             Enable Mysticeti on mainnet.
177//             Enable Leader Scoring & Schedule Change for Mysticeti consensus on mainnet.
178//             Turn on count based shared object congestion control in devnet.
179//             Enable consensus commit prologue V3 in testnet.
180//             Enable enums on testnet.
181//             Add support for passkey in devnet.
182//             Enable deny list v2 on testnet and mainnet.
183// Version 53: Add feature flag to decide whether to attempt to finalize bridge committee
184//             Enable consensus commit prologue V3 on testnet.
185//             Turn on shared object congestion control in testnet.
186//             Update stdlib natives costs
187// Version 54: Enable random beacon on mainnet.
188//             Enable soft bundle on mainnet.
189// Version 55: Enable enums on mainnet.
190//             Rethrow serialization type layout errors instead of converting them.
191// Version 56: Enable bridge on mainnet.
192//             Note: do not use version 56 for any new features.
193// Version 57: Reduce minimum number of random beacon shares.
194// Version 58: Optimize boolean binops
195//             Finalize bridge committee on mainnet.
196//             Switch to distributed vote scoring in consensus in devnet
197// Version 59: Enable round prober in consensus.
198// Version 60: Validation of public inputs for Groth16 verification.
199//             Enable configuration of maximum number of type nodes in a type layout.
200// Version 61: Switch to distributed vote scoring in consensus in testnet
201//             Further reduce minimum number of random beacon shares.
202//             Add feature flag for Mysticeti fastpath.
203// Version 62: Makes the event's sending module package upgrade-aware.
204// Version 63: Enable gas based congestion control in consensus commit.
205// Version 64: Revert congestion control change.
206// Version 65: Enable distributed vote scoring in mainnet.
207// Version 66: Revert distributed vote scoring in mainnet.
208//             Framework fix for fungible staking book-keeping.
209// Version 67: Re-enable distributed vote scoring in mainnet.
210// Version 68: Add G1Uncompressed group to group ops.
211//             Update to Move stdlib.
212//             Enable gas based congestion control with overage.
213//             Further reduce minimum number of random beacon shares.
214//             Disallow adding new modules in `deps-only` packages.
215// Version 69: Sets number of rounds allowed for fastpath voting in consensus.
216//             Enable smart ancestor selection in devnet.
217//             Enable G1Uncompressed group in testnet.
218// Version 70: Enable smart ancestor selection in testnet.
219//             Enable probing for accepted rounds in round prober in testnet
220//             Add new gas model version to update charging of native functions.
221//             Add std::uq64_64 module to Move stdlib.
222//             Improve gas/wall time efficiency of some Move stdlib vector functions
223// Version 71: [SIP-45] Enable consensus amplification.
224// Version 72: Fix issue where `convert_type_argument_error` wasn't being used in all cases.
225//             Max gas budget moved to 50_000 SUI
226//             Max gas price moved to 50 SUI
227//             Variants as type nodes.
228// Version 73: Enable new marker table version.
229//             Enable consensus garbage collection and new commit rule for devnet.
230//             Enable zstd compression for consensus tonic network in testnet.
231//             Enable smart ancestor selection in mainnet.
232//             Enable probing for accepted rounds in round prober in mainnet
233// Version 74: Enable load_nitro_attestation move function in sui framework in devnet.
234//             Enable all gas costs for load_nitro_attestation.
235//             Enable zstd compression for consensus tonic network in mainnet.
236//             Enable the new commit rule for devnet.
237// Version 75: Enable passkey auth in testnet.
238// Version 76: Deprecate Deepbook V2 order placement and deposit.
239//             Removes unnecessary child object mutations
240//             Enable passkey auth in multisig for testnet.
241// Version 77: Enable uncompressed point group ops on mainnet.
242//             Enable consensus garbage collection for testnet
243//             Enable the new consensus commit rule for testnet.
244// Version 78: Make `TxContext` Move API native
245//             Enable execution time estimate mode for congestion control on testnet.
246// Version 79: Enable median based commit timestamp in consensus on testnet.
247//             Increase threshold for bad nodes that won't be considered leaders in consensus in testnet
248//             Enable load_nitro_attestation move function in sui framework in testnet.
249//             Enable consensus garbage collection for mainnet
250//             Enable the new consensus commit rule for mainnet.
251// Version 80: Bound size of values created in the adapter.
252// Version 81: Enable median based commit timestamp in consensus on mainnet.
253//             Enforce checkpoint timestamps are non-decreasing for testnet and mainnet.
254//             Increase threshold for bad nodes that won't be considered leaders in consensus in mainnet
255// Version 82: Relax bounding of size of values created in the adapter.
256// Version 83: Resolve `TypeInput` IDs to defining ID when converting to `TypeTag`s in the adapter.
257//             Enable execution time estimate mode for congestion control on mainnet.
258//             Enable nitro attestation upgraded parsing and mainnet.
259// Version 84: Limit number of stored execution time observations between epochs.
260// Version 85: Enable party transfer in devnet.
261// Version 86: Use type tags in the object runtime and adapter instead of `Type`s.
262//             Make variant count limit explicit in protocol config.
263//             Enable party transfer in testnet.
264// Version 87: Enable better type resolution errors in the adapter.
265// Version 88: Update `sui-system` package to use `calculate_rewards` function.
266//             Define the cost for the native Move function `rgp`.
267//             Ignore execution time observations after validator stops accepting certs.
268// Version 89: Add additional signature checks
269//             Add additional linkage checks
270// Version 90: Standard library improvements.
271//             Enable `debug_fatal` on Move invariant violations.
272//             Enable passkey and passkey inside multisig for mainnet.
273// Version 91: Minor changes in Sui Framework. Include CheckpointDigest in consensus dedup key for checkpoint signatures (V2).
274// Version 92: Disable checking shared object transfer restrictions per command = false
275// Version 93: Enable CheckpointDigest in consensus dedup key for checkpoint signatures.
276// Version 94: Decrease stored observations limit by 10% to stay within system object size limit.
277//             Enable party transfer on mainnet.
278// Version 95: Change type name id base cost to 52, increase max transactions per checkpoint to 20000.
279// Version 96: Enable authority capabilities v2.
280//             Fix bug where MFP transaction shared inputs' debts were not loaded
281//             Create Coin Registry object
282//             Enable checkpoint artifacts digest in devnet.
283// Version 97: Enable additional borrow checks
284// Version 98: Add authenticated event streams support via emit_authenticated function.
285//             Add better error messages to the loader.
286// Version 99: Enable new commit handler.
287// Version 100: Framework update
288// Version 101: Framework update
289//              Set max updates per settlement txn to 100.
290// Version 103: Framework update: internal Coin methods
291// Version 104: Framework update: CoinRegistry follow up for Coin methods
292//              Enable all non-zero PCRs parsing for nitro attestation native function in Devnet and Testnet.
293// Version 105: Framework update: address aliases
294//              Enable multi-epoch transaction expiration.
295//              Enable always include required PCRs (0-4 & 8) parsing even if they are zeros for
296//              nitro attestation native function in Devnet and Testnet.
297// Version 106: Framework update: accumulator storage fund calculations
298//              Enable address balances on devnet
299// Version 108: Enable new digit based gas rounding.
300//              Support TxContext in all parameter positions.
301//              Disable entry point signature check.
302//              Enable address aliases on testnet.
303//              Enable poseidon_bn254 on mainnet.
304// Version 109: Update where we set bounds for some binary tables to be a bit more idiomatic.
305// Version 110: Enable parsing on all nonzero custom pcrs in nitro attestation parsing native
306//              function on mainnet.
307//              split_checkpoints_in_consensus_handler in devnet
308//              Enable additional validation on zkLogin public identifier.
309// Version 111: Validator metadata
310// Version 112: Enable Ristretto255 in devnet.
311// Version 113: Validate gas price >= RGP at signing for address balance gas payments.
312// Version 114: Gate seeded test overrides for checkpoint tx limit behind feature flag.
313// Version 115: Gasless transaction drop safety.
314//              Enable address aliases on mainnet.
315//              Relax ValidDuring requirement for transactions with owned inputs.
316// Version 116: Enable Display Registry.
317//              Disable defer_unpaid_amplification (debugging).
318// Version 117: Update Sui System metadata handling.
319// Version 118: Adds `transfer_migration_cap` to display registry
320// Version 119: Enable the new VM.
321// Version 120: Disallow unused jump tables
322// Version 121: Re-enable defer_unpaid_amplification (devnet + testnet).
323// Version 122: Framework update: vector::empty is deprecated.
324//              Enable bulletproofs verification on devnet.
325
326#[derive(Copy, Clone, Debug, Hash, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
327pub struct ProtocolVersion(u64);
328
329impl ProtocolVersion {
330    // The minimum and maximum protocol version supported by this binary. Counterintuitively, this constant may
331    // change over time as support for old protocol versions is removed from the source. This
332    // ensures that when a new network (such as a testnet) is created, its genesis committee will
333    // use a protocol version that is actually supported by the binary.
334    pub const MIN: Self = Self(MIN_PROTOCOL_VERSION);
335
336    pub const MAX: Self = Self(MAX_PROTOCOL_VERSION);
337
338    #[cfg(not(msim))]
339    pub const MAX_ALLOWED: Self = Self::MAX;
340
341    // We create one additional "fake" version in simulator builds so that we can test upgrades.
342    #[cfg(msim)]
343    pub const MAX_ALLOWED: Self = Self(MAX_PROTOCOL_VERSION + 1);
344
345    pub fn new(v: u64) -> Self {
346        Self(v)
347    }
348
349    pub const fn as_u64(&self) -> u64 {
350        self.0
351    }
352
353    // For serde deserialization - we don't define a Default impl because there isn't a single
354    // universally appropriate default value.
355    pub fn max() -> Self {
356        Self::MAX
357    }
358
359    pub fn prev(self) -> Self {
360        Self(self.0.checked_sub(1).unwrap())
361    }
362}
363
364impl From<u64> for ProtocolVersion {
365    fn from(v: u64) -> Self {
366        Self::new(v)
367    }
368}
369
370impl std::ops::Sub<u64> for ProtocolVersion {
371    type Output = Self;
372    fn sub(self, rhs: u64) -> Self::Output {
373        Self::new(self.0 - rhs)
374    }
375}
376
377impl std::ops::Add<u64> for ProtocolVersion {
378    type Output = Self;
379    fn add(self, rhs: u64) -> Self::Output {
380        Self::new(self.0 + rhs)
381    }
382}
383
384#[derive(
385    Clone, Serialize, Deserialize, Debug, Default, PartialEq, Copy, PartialOrd, Ord, Eq, ValueEnum,
386)]
387pub enum Chain {
388    Mainnet,
389    Testnet,
390    #[default]
391    Unknown,
392}
393
394impl Chain {
395    pub fn as_str(self) -> &'static str {
396        match self {
397            Chain::Mainnet => "mainnet",
398            Chain::Testnet => "testnet",
399            Chain::Unknown => "unknown",
400        }
401    }
402}
403
404pub struct Error(pub String);
405
406// TODO: There are quite a few non boolean values in the feature flags. We should move them out.
407/// Records on/off feature flags that may vary at each protocol version.
408#[derive(Default, Clone, Serialize, Deserialize, Debug, ProtocolConfigFeatureFlagsGetters)]
409struct FeatureFlags {
410    // Add feature flags here, e.g.:
411    // new_protocol_feature: bool,
412    #[serde(skip_serializing_if = "is_false")]
413    package_upgrades: bool,
414    // If true, validators will commit to the root state digest
415    // in end of epoch checkpoint proposals
416    #[serde(skip_serializing_if = "is_false")]
417    commit_root_state_digest: bool,
418    // Pass epoch start time to advance_epoch safe mode function.
419    #[serde(skip_serializing_if = "is_false")]
420    advance_epoch_start_time_in_safe_mode: bool,
421    // If true, apply the fix to correctly capturing loaded child object versions in execution's
422    // object runtime.
423    #[serde(skip_serializing_if = "is_false")]
424    loaded_child_objects_fixed: bool,
425    // If true, treat missing types in the upgraded modules when creating an upgraded package as a
426    // compatibility error.
427    #[serde(skip_serializing_if = "is_false")]
428    missing_type_is_compatibility_error: bool,
429    // If true, then the scoring decision mechanism will not get disabled when we do have more than
430    // f low scoring authorities, but it will simply flag as low scoring only up to f authorities.
431    #[serde(skip_serializing_if = "is_false")]
432    scoring_decision_with_validity_cutoff: bool,
433
434    // DEPRECATED: this was an ephemeral feature flag only used by consensus handler, which has now
435    // been deployed everywhere.
436    #[serde(skip_serializing_if = "is_false")]
437    consensus_order_end_of_epoch_last: bool,
438
439    // Disallow adding abilities to types during package upgrades.
440    #[serde(skip_serializing_if = "is_false")]
441    disallow_adding_abilities_on_upgrade: bool,
442    // Disables unnecessary invariant check in the Move VM when swapping the value out of a local
443    #[serde(skip_serializing_if = "is_false")]
444    disable_invariant_violation_check_in_swap_loc: bool,
445    // advance to highest supported protocol version at epoch change, instead of the next consecutive
446    // protocol version.
447    #[serde(skip_serializing_if = "is_false")]
448    advance_to_highest_supported_protocol_version: bool,
449    // If true, disallow entry modifiers on entry functions
450    #[serde(skip_serializing_if = "is_false")]
451    ban_entry_init: bool,
452    // If true, hash module bytes individually when calculating package digests for upgrades
453    #[serde(skip_serializing_if = "is_false")]
454    package_digest_hash_module: bool,
455    // If true, disallow changing struct type parameters during package upgrades
456    #[serde(skip_serializing_if = "is_false")]
457    disallow_change_struct_type_params_on_upgrade: bool,
458    // If true, checks no extra bytes in a compiled module
459    #[serde(skip_serializing_if = "is_false")]
460    no_extraneous_module_bytes: bool,
461    // If true, then use the versioned metadata format in narwhal entities.
462    #[serde(skip_serializing_if = "is_false")]
463    narwhal_versioned_metadata: bool,
464
465    // Enable zklogin auth
466    #[serde(skip_serializing_if = "is_false")]
467    zklogin_auth: bool,
468    // How we order transactions coming out of consensus before sending to execution.
469    #[serde(skip_serializing_if = "ConsensusTransactionOrdering::is_none")]
470    consensus_transaction_ordering: ConsensusTransactionOrdering,
471
472    // Previously, the unwrapped_then_deleted field in TransactionEffects makes a distinction between
473    // whether an object has existed in the store previously (i.e. whether there is a tombstone).
474    // Such dependency makes effects generation inefficient, and requires us to include wrapped
475    // tombstone in state root hash.
476    // To prepare for effects V2, with this flag set to true, we simplify the definition of
477    // unwrapped_then_deleted to always include unwrapped then deleted objects,
478    // regardless of their previous state in the store.
479    #[serde(skip_serializing_if = "is_false")]
480    simplified_unwrap_then_delete: bool,
481    // Enable upgraded multisig support
482    #[serde(skip_serializing_if = "is_false")]
483    upgraded_multisig_supported: bool,
484    // If true minimum txn charge is a multiplier of the gas price
485    #[serde(skip_serializing_if = "is_false")]
486    txn_base_cost_as_multiplier: bool,
487
488    // If true, the ability to delete shared objects is in effect
489    #[serde(skip_serializing_if = "is_false")]
490    shared_object_deletion: bool,
491
492    // If true, then the new algorithm for the leader election schedule will be used
493    #[serde(skip_serializing_if = "is_false")]
494    narwhal_new_leader_election_schedule: bool,
495
496    // A list of supported OIDC providers that can be used for zklogin.
497    #[serde(skip_serializing_if = "is_empty")]
498    zklogin_supported_providers: BTreeSet<String>,
499
500    // If true, use the new child object format
501    #[serde(skip_serializing_if = "is_false")]
502    loaded_child_object_format: bool,
503
504    #[serde(skip_serializing_if = "is_false")]
505    enable_jwk_consensus_updates: bool,
506
507    #[serde(skip_serializing_if = "is_false")]
508    end_of_epoch_transaction_supported: bool,
509
510    // Perform simple conservation checks keeping into account out of gas scenarios
511    // while charging for storage.
512    #[serde(skip_serializing_if = "is_false")]
513    simple_conservation_checks: bool,
514
515    // If true, use the new child object format type logging
516    #[serde(skip_serializing_if = "is_false")]
517    loaded_child_object_format_type: bool,
518
519    // Enable receiving sent objects
520    #[serde(skip_serializing_if = "is_false")]
521    receive_objects: bool,
522
523    // If true, include CheckpointDigest in consensus dedup key for checkpoint signatures (V2).
524    #[serde(skip_serializing_if = "is_false")]
525    consensus_checkpoint_signature_key_includes_digest: bool,
526
527    // Enable random beacon protocol
528    #[serde(skip_serializing_if = "is_false")]
529    random_beacon: bool,
530
531    // Enable bridge protocol
532    #[serde(skip_serializing_if = "is_false")]
533    bridge: bool,
534
535    #[serde(skip_serializing_if = "is_false")]
536    enable_effects_v2: bool,
537
538    // If true, then use CertificateV2 in narwhal.
539    #[serde(skip_serializing_if = "is_false")]
540    narwhal_certificate_v2: bool,
541
542    // If true, allow verify with legacy zklogin address
543    #[serde(skip_serializing_if = "is_false")]
544    verify_legacy_zklogin_address: bool,
545
546    // Enable throughput aware consensus submission
547    #[serde(skip_serializing_if = "is_false")]
548    throughput_aware_consensus_submission: bool,
549
550    // If true, recompute has_public_transfer from the type instead of what is stored in the object
551    #[serde(skip_serializing_if = "is_false")]
552    recompute_has_public_transfer_in_execution: bool,
553
554    // If true, multisig containing zkLogin sig is accepted.
555    #[serde(skip_serializing_if = "is_false")]
556    accept_zklogin_in_multisig: bool,
557
558    // If true, multisig containing passkey sig is accepted.
559    #[serde(skip_serializing_if = "is_false")]
560    accept_passkey_in_multisig: bool,
561
562    // If true, additional zkLogin public identifier structure is validated.
563    #[serde(skip_serializing_if = "is_false")]
564    validate_zklogin_public_identifier: bool,
565
566    // If true, consensus prologue transaction also includes the consensus output digest.
567    // It can be used to detect consensus output folk.
568    #[serde(skip_serializing_if = "is_false")]
569    include_consensus_digest_in_prologue: bool,
570
571    // If true, use the hardened OTW check
572    #[serde(skip_serializing_if = "is_false")]
573    hardened_otw_check: bool,
574
575    // If true allow calling receiving_object_id function
576    #[serde(skip_serializing_if = "is_false")]
577    allow_receiving_object_id: bool,
578
579    // Enable the poseidon hash function
580    #[serde(skip_serializing_if = "is_false")]
581    enable_poseidon: bool,
582
583    // If true, enable the coin deny list.
584    #[serde(skip_serializing_if = "is_false")]
585    enable_coin_deny_list: bool,
586
587    // Enable native functions for group operations.
588    #[serde(skip_serializing_if = "is_false")]
589    enable_group_ops_native_functions: bool,
590
591    // Enable native function for msm.
592    #[serde(skip_serializing_if = "is_false")]
593    enable_group_ops_native_function_msm: bool,
594
595    // Enable group operations for Ristretto255
596    #[serde(skip_serializing_if = "is_false")]
597    enable_ristretto255_group_ops: bool,
598
599    // Enable native functions for group operations.
600    #[serde(skip_serializing_if = "is_false")]
601    enable_verify_bulletproofs_ristretto255: bool,
602
603    // Enable nitro attestation.
604    #[serde(skip_serializing_if = "is_false")]
605    enable_nitro_attestation: bool,
606
607    // Enable upgraded parsing of nitro attestation that interprets pcrs as a map.
608    #[serde(skip_serializing_if = "is_false")]
609    enable_nitro_attestation_upgraded_parsing: bool,
610
611    // Enable upgraded parsing of nitro attestation containing all nonzero PCRs.
612    #[serde(skip_serializing_if = "is_false")]
613    enable_nitro_attestation_all_nonzero_pcrs_parsing: bool,
614
615    // Enable upgraded parsing of nitro attestation to always include required PCRs, even when all zeros.
616    #[serde(skip_serializing_if = "is_false")]
617    enable_nitro_attestation_always_include_required_pcrs_parsing: bool,
618
619    // Reject functions with mutable Random.
620    #[serde(skip_serializing_if = "is_false")]
621    reject_mutable_random_on_entry_functions: bool,
622
623    // Controls the behavior of per object congestion control in consensus handler.
624    #[serde(skip_serializing_if = "PerObjectCongestionControlMode::is_none")]
625    per_object_congestion_control_mode: PerObjectCongestionControlMode,
626
627    // The consensus protocol to be used for the epoch.
628    #[serde(skip_serializing_if = "ConsensusChoice::is_narwhal")]
629    consensus_choice: ConsensusChoice,
630
631    // Consensus network to use.
632    #[serde(skip_serializing_if = "ConsensusNetwork::is_anemo")]
633    consensus_network: ConsensusNetwork,
634
635    // If true, use the correct (<=) comparison for max_gas_payment_objects instead of (<)
636    #[serde(skip_serializing_if = "is_false")]
637    correct_gas_payment_limit_check: bool,
638
639    // Set the upper bound allowed for max_epoch in zklogin signature.
640    #[serde(skip_serializing_if = "Option::is_none")]
641    zklogin_max_epoch_upper_bound_delta: Option<u64>,
642
643    // Controls leader scoring & schedule change in Mysticeti consensus.
644    #[serde(skip_serializing_if = "is_false")]
645    mysticeti_leader_scoring_and_schedule: bool,
646
647    // Enable resharing of shared objects using the same initial shared version
648    #[serde(skip_serializing_if = "is_false")]
649    reshare_at_same_initial_version: bool,
650
651    // Resolve Move abort locations to the package id instead of the runtime module ID.
652    #[serde(skip_serializing_if = "is_false")]
653    resolve_abort_locations_to_package_id: bool,
654
655    // Enables the use of the Mysticeti committed sub dag digest to the `ConsensusCommitInfo` in checkpoints.
656    // When disabled the default digest is used instead. It's important to have this guarded behind
657    // a flag as it will lead to checkpoint forks.
658    #[serde(skip_serializing_if = "is_false")]
659    mysticeti_use_committed_subdag_digest: bool,
660
661    // Enable VDF
662    #[serde(skip_serializing_if = "is_false")]
663    enable_vdf: bool,
664
665    // Controls whether consensus handler should record consensus determined shared object version
666    // assignments in consensus commit prologue transaction.
667    // The purpose of doing this is to enable replaying transaction without transaction effects.
668    // V2 also records initial shared versions for consensus objects.
669    #[serde(skip_serializing_if = "is_false")]
670    record_consensus_determined_version_assignments_in_prologue: bool,
671    #[serde(skip_serializing_if = "is_false")]
672    record_consensus_determined_version_assignments_in_prologue_v2: bool,
673
674    // Run verification of framework upgrades using a new/fresh VM.
675    #[serde(skip_serializing_if = "is_false")]
676    fresh_vm_on_framework_upgrade: bool,
677
678    // When set to true, the consensus commit prologue transaction will be placed first
679    // in a consensus commit in checkpoints.
680    // If a checkpoint contains multiple consensus commit, say [cm1][cm2]. The each commit's
681    // consensus commit prologue will be the first transaction in each segment:
682    //     [ccp1, rest cm1][ccp2, rest cm2]
683    // The reason to prepose the prologue transaction is to provide information for transaction
684    // cancellation.
685    #[serde(skip_serializing_if = "is_false")]
686    prepend_prologue_tx_in_consensus_commit_in_checkpoints: bool,
687
688    // Set number of leaders per round for Mysticeti commits.
689    #[serde(skip_serializing_if = "Option::is_none")]
690    mysticeti_num_leaders_per_round: Option<usize>,
691
692    // Enable Soft Bundle (SIP-19).
693    #[serde(skip_serializing_if = "is_false")]
694    soft_bundle: bool,
695
696    // If true, enable the coin deny list V2.
697    #[serde(skip_serializing_if = "is_false")]
698    enable_coin_deny_list_v2: bool,
699
700    // Enable passkey auth (SIP-9)
701    #[serde(skip_serializing_if = "is_false")]
702    passkey_auth: bool,
703
704    // Use AuthorityCapabilitiesV2
705    #[serde(skip_serializing_if = "is_false")]
706    authority_capabilities_v2: bool,
707
708    // Rethrow type layout errors during serialization instead of trying to convert them.
709    #[serde(skip_serializing_if = "is_false")]
710    rethrow_serialization_type_layout_errors: bool,
711
712    // Use distributed vote leader scoring strategy in consensus.
713    #[serde(skip_serializing_if = "is_false")]
714    consensus_distributed_vote_scoring_strategy: bool,
715
716    // Probe rounds received by peers from every authority.
717    #[serde(skip_serializing_if = "is_false")]
718    consensus_round_prober: bool,
719
720    // Validate identifier inputs separately
721    #[serde(skip_serializing_if = "is_false")]
722    validate_identifier_inputs: bool,
723
724    // Disallow self identifier
725    #[serde(skip_serializing_if = "is_false")]
726    disallow_self_identifier: bool,
727
728    // Enables Mysticeti fastpath.
729    #[serde(skip_serializing_if = "is_false")]
730    mysticeti_fastpath: bool,
731
732    // If true, disable pre-consensus locking for owned objects.
733    // All transactions go through consensus, and owned object conflict detection
734    // happens post-consensus via lock acquisition.
735    #[serde(skip_serializing_if = "is_false")]
736    disable_preconsensus_locking: bool,
737
738    // Makes the event's sending module version-aware.
739    #[serde(skip_serializing_if = "is_false")]
740    relocate_event_module: bool,
741
742    // Enable uncompressed group elements in BLS123-81 G1
743    #[serde(skip_serializing_if = "is_false")]
744    uncompressed_g1_group_elements: bool,
745
746    #[serde(skip_serializing_if = "is_false")]
747    disallow_new_modules_in_deps_only_packages: bool,
748
749    // Use smart ancestor selection in consensus.
750    #[serde(skip_serializing_if = "is_false")]
751    consensus_smart_ancestor_selection: bool,
752
753    // Probe accepted rounds in round prober.
754    #[serde(skip_serializing_if = "is_false")]
755    consensus_round_prober_probe_accepted_rounds: bool,
756
757    // Enable v2 native charging for natives.
758    #[serde(skip_serializing_if = "is_false")]
759    native_charging_v2: bool,
760
761    // Enables the new logic for collecting the subdag in the consensus linearizer. The new logic does not stop the recursion at the highest
762    // committed round for each authority, but allows to commit uncommitted blocks up to gc round (excluded) for that authority.
763    #[serde(skip_serializing_if = "is_false")]
764    consensus_linearize_subdag_v2: bool,
765
766    // Properly convert certain type argument errors in the execution layer.
767    #[serde(skip_serializing_if = "is_false")]
768    convert_type_argument_error: bool,
769
770    // Variants count as nodes
771    #[serde(skip_serializing_if = "is_false")]
772    variant_nodes: bool,
773
774    // If true, enable zstd compression for consensus tonic network.
775    #[serde(skip_serializing_if = "is_false")]
776    consensus_zstd_compression: bool,
777
778    // If true, enables the optimizations for child object mutations, removing unnecessary mutations
779    #[serde(skip_serializing_if = "is_false")]
780    minimize_child_object_mutations: bool,
781
782    // If true, record the additional state digest in the consensus commit prologue.
783    #[serde(skip_serializing_if = "is_false")]
784    record_additional_state_digest_in_prologue: bool,
785
786    // If true, enable `TxContext` Move API to go native.
787    #[serde(skip_serializing_if = "is_false")]
788    move_native_context: bool,
789
790    // If true, then it (1) will not enforce monotonicity checks for a block's ancestors and (2) calculates the commit's timestamp based on the
791    // weighted by stake median timestamp of the leader's ancestors.
792    #[serde(skip_serializing_if = "is_false")]
793    consensus_median_based_commit_timestamp: bool,
794
795    // If true, enables the normalization of PTB arguments but does not yet enable splatting
796    // `Result`s of length not equal to 1
797    #[serde(skip_serializing_if = "is_false")]
798    normalize_ptb_arguments: bool,
799
800    // If true, enabled batched block sync in consensus.
801    #[serde(skip_serializing_if = "is_false")]
802    consensus_batched_block_sync: bool,
803
804    // If true, enforces checkpoint timestamps are non-decreasing.
805    #[serde(skip_serializing_if = "is_false")]
806    enforce_checkpoint_timestamp_monotonicity: bool,
807
808    // If true, enables better errors and bounds for max ptb values
809    #[serde(skip_serializing_if = "is_false")]
810    max_ptb_value_size_v2: bool,
811
812    // If true, resolves all type input ids to be defining ID based in the adapter
813    #[serde(skip_serializing_if = "is_false")]
814    resolve_type_input_ids_to_defining_id: bool,
815
816    // Enable native function for party transfer
817    #[serde(skip_serializing_if = "is_false")]
818    enable_party_transfer: bool,
819
820    // Allow objects created or mutated in system transactions to exceed the max object size limit.
821    #[serde(skip_serializing_if = "is_false")]
822    allow_unbounded_system_objects: bool,
823
824    // Signifies the cut-over of using type tags instead of `Type`s in the object runtime.
825    #[serde(skip_serializing_if = "is_false")]
826    type_tags_in_object_runtime: bool,
827
828    // Enable accumulators
829    #[serde(skip_serializing_if = "is_false")]
830    enable_accumulators: bool,
831
832    // Enable coin reservation
833    #[serde(skip_serializing_if = "is_false")]
834    enable_coin_reservation_obj_refs: bool,
835
836    // If true, create the root accumulator object in the change epoch transaction.
837    // This must be enabled and shipped before `enable_accumulators` is set to true.
838    #[serde(skip_serializing_if = "is_false")]
839    create_root_accumulator_object: bool,
840
841    // Enable authenticated event streams
842    #[serde(skip_serializing_if = "is_false")]
843    enable_authenticated_event_streams: bool,
844
845    // Enable address balance gas payments
846    #[serde(skip_serializing_if = "is_false")]
847    enable_address_balance_gas_payments: bool,
848
849    // Validate gas price >= RGP at signing for address balance gas payments
850    #[serde(skip_serializing_if = "is_false")]
851    address_balance_gas_check_rgp_at_signing: bool,
852
853    #[serde(skip_serializing_if = "is_false")]
854    address_balance_gas_reject_gas_coin_arg: bool,
855
856    // Enable multi-epoch transaction expiration (max 1 epoch difference)
857    #[serde(skip_serializing_if = "is_false")]
858    enable_multi_epoch_transaction_expiration: bool,
859
860    // Relax ValidDuring expiration requirement for transactions with owned inputs
861    #[serde(skip_serializing_if = "is_false")]
862    relax_valid_during_for_owned_inputs: bool,
863
864    // Enable statically type checked ptb execution
865    #[serde(skip_serializing_if = "is_false")]
866    enable_ptb_execution_v2: bool,
867
868    // Provide better type resolution errors in the adapter.
869    #[serde(skip_serializing_if = "is_false")]
870    better_adapter_type_resolution_errors: bool,
871
872    // If true, record the time estimate processed in the consensus commit prologue.
873    #[serde(skip_serializing_if = "is_false")]
874    record_time_estimate_processed: bool,
875
876    // If true enable additional linkage checks.
877    #[serde(skip_serializing_if = "is_false")]
878    dependency_linkage_error: bool,
879
880    // If true enable additional multisig checks.
881    #[serde(skip_serializing_if = "is_false")]
882    additional_multisig_checks: bool,
883
884    // If true, ignore execution time observations after certs are closed.
885    #[serde(skip_serializing_if = "is_false")]
886    ignore_execution_time_observations_after_certs_closed: bool,
887
888    // If true use `debug_fatal` to report invariant violations.
889    // `debug_fatal` panics in debug builds and breaks tests/behavior based on older
890    // protocol versions (see make_vec_non_existent_type_v71.move)
891    #[serde(skip_serializing_if = "is_false")]
892    debug_fatal_on_move_invariant_violation: bool,
893
894    // DO NOT ENABLE THIS FOR PRODUCTION NETWORKS. used for testing only.
895    // Allow private accumulator entrypoints
896    #[serde(skip_serializing_if = "is_false")]
897    allow_private_accumulator_entrypoints: bool,
898
899    // If true, include indirect state in the additional consensus digest.
900    #[serde(skip_serializing_if = "is_false")]
901    additional_consensus_digest_indirect_state: bool,
902
903    // Check for `init` for new modules to a package on upgrade.
904    #[serde(skip_serializing_if = "is_false")]
905    check_for_init_during_upgrade: bool,
906
907    // Check shared object transfer restrictions per command.
908    #[serde(skip_serializing_if = "is_false")]
909    per_command_shared_object_transfer_rules: bool,
910
911    // Enable including checkpoint artifacts digest in the summary.
912    #[serde(skip_serializing_if = "is_false")]
913    include_checkpoint_artifacts_digest_in_summary: bool,
914
915    // If true, use MFP txns in load initial object debts.
916    #[serde(skip_serializing_if = "is_false")]
917    use_mfp_txns_in_load_initial_object_debts: bool,
918
919    // If true, cancel randomness-using txns when DKG has failed *before* doing other congestion checks.
920    #[serde(skip_serializing_if = "is_false")]
921    cancel_for_failed_dkg_early: bool,
922
923    // Enable coin registry protocol
924    #[serde(skip_serializing_if = "is_false")]
925    enable_coin_registry: bool,
926
927    // Use abstract size in the object runtime instead the legacy value size.
928    #[serde(skip_serializing_if = "is_false")]
929    abstract_size_in_object_runtime: bool,
930
931    // If true charge for loads into the cache (i.e., fetches from storage) in the object runtime.
932    #[serde(skip_serializing_if = "is_false")]
933    object_runtime_charge_cache_load_gas: bool,
934
935    // If true, perform additional borrow checks
936    #[serde(skip_serializing_if = "is_false")]
937    additional_borrow_checks: bool,
938
939    // If true, use the new commit handler.
940    #[serde(skip_serializing_if = "is_false")]
941    use_new_commit_handler: bool,
942
943    // If true return a better error message when we encounter a loader error.
944    #[serde(skip_serializing_if = "is_false")]
945    better_loader_errors: bool,
946
947    // If true generate layouts for dynamic fields
948    #[serde(skip_serializing_if = "is_false")]
949    generate_df_type_layouts: bool,
950
951    // If true, allow Move functions called in PTBs to return references
952    #[serde(skip_serializing_if = "is_false")]
953    allow_references_in_ptbs: bool,
954
955    // Enable display registry protocol
956    #[serde(skip_serializing_if = "is_false")]
957    enable_display_registry: bool,
958
959    // If true, enable private generics verifier v2
960    #[serde(skip_serializing_if = "is_false")]
961    private_generics_verifier_v2: bool,
962
963    // If true, deprecate global storage ops during Move module deserialization
964    #[serde(skip_serializing_if = "is_false")]
965    deprecate_global_storage_ops_during_deserialization: bool,
966
967    // If true, enable non-exclusive writes for user transactions.
968    // DO NOT ENABLE outside of the transaction test runner.
969    #[serde(skip_serializing_if = "is_false")]
970    enable_non_exclusive_writes: bool,
971
972    // If true, deprecate global storage ops everywhere.
973    #[serde(skip_serializing_if = "is_false")]
974    deprecate_global_storage_ops: bool,
975
976    // If true, normalize depth formula to not be empty for zero depth.
977    #[serde(skip_serializing_if = "is_false")]
978    normalize_depth_formula: bool,
979
980    // If true, skip GC'ed accept votes in CommitFinalizer.
981    #[serde(skip_serializing_if = "is_false")]
982    consensus_skip_gced_accept_votes: bool,
983
984    // If true, include cancelled randomness txns in the consensus commit prologue.
985    #[serde(skip_serializing_if = "is_false")]
986    include_cancelled_randomness_txns_in_prologue: bool,
987
988    // Enables address aliases.
989    #[serde(skip_serializing_if = "is_false")]
990    address_aliases: bool,
991
992    // Corrects signature-to-signer mapping in CheckpointContentsV2.
993    // TODO: remove old code and deprecate once in mainnet.
994    #[serde(skip_serializing_if = "is_false")]
995    fix_checkpoint_signature_mapping: bool,
996
997    // If true, enable object funds withdraw.
998    #[serde(skip_serializing_if = "is_false")]
999    enable_object_funds_withdraw: bool,
1000
1001    // If true, skip GC'ed blocks in direct finalization.
1002    #[serde(skip_serializing_if = "is_false")]
1003    consensus_skip_gced_blocks_in_direct_finalization: bool,
1004
1005    // If true, uses a new rounding mechanism for gas calculations, replacing the step-based one
1006    #[serde(skip_serializing_if = "is_false")]
1007    gas_rounding_halve_digits: bool,
1008
1009    // If true, enable tx contexts in all argument positions
1010    #[serde(skip_serializing_if = "is_false")]
1011    flexible_tx_context_positions: bool,
1012
1013    // If true, disable entry point signature check.
1014    #[serde(skip_serializing_if = "is_false")]
1015    disable_entry_point_signature_check: bool,
1016
1017    // If true, convert withdrawal compatibility PTB arguments to coins at the start of the PTB.
1018    #[serde(skip_serializing_if = "is_false")]
1019    convert_withdrawal_compatibility_ptb_arguments: bool,
1020
1021    // If true, additional restrictions for hot or not entry functions are enforced.
1022    #[serde(skip_serializing_if = "is_false")]
1023    restrict_hot_or_not_entry_functions: bool,
1024
1025    // If true, split checkpoints in consensus handler.
1026    #[serde(skip_serializing_if = "is_false")]
1027    split_checkpoints_in_consensus_handler: bool,
1028
1029    // If true, always accept committed system transactions.
1030    #[serde(skip_serializing_if = "is_false")]
1031    consensus_always_accept_system_transactions: bool,
1032
1033    // If true perform consistent verification of metadata
1034    #[serde(skip_serializing_if = "is_false")]
1035    validator_metadata_verify_v2: bool,
1036
1037    // If true, defer transactions with unpaid consensus amplification
1038    // (where duplicate count exceeds gas_price / RGP + 1)
1039    #[serde(skip_serializing_if = "is_false")]
1040    defer_unpaid_amplification: bool,
1041
1042    #[serde(skip_serializing_if = "is_false")]
1043    randomize_checkpoint_tx_limit_in_tests: bool,
1044
1045    // If true, mark the gas coin as uninitialized in drop safety when there is no gas coin.
1046    #[serde(skip_serializing_if = "is_false")]
1047    gasless_transaction_drop_safety: bool,
1048
1049    // When split-checkpoints enabled, merge randomness and non-randomness schedulables together.
1050    #[serde(skip_serializing_if = "is_false")]
1051    merge_randomness_into_checkpoint: bool,
1052
1053    // If true, use coin party owner information.
1054    #[serde(skip_serializing_if = "is_false")]
1055    use_coin_party_owner: bool,
1056
1057    #[serde(skip_serializing_if = "is_false")]
1058    enable_gasless: bool,
1059
1060    #[serde(skip_serializing_if = "is_false")]
1061    gasless_verify_remaining_balance: bool,
1062
1063    #[serde(skip_serializing_if = "is_false")]
1064    disallow_jump_orphans: bool,
1065
1066    // If true, return early on type mismatch in receive_object.
1067    #[serde(skip_serializing_if = "is_false")]
1068    early_return_receive_object_mismatched_type: bool,
1069}
1070
1071fn is_false(b: &bool) -> bool {
1072    !b
1073}
1074
1075fn is_empty(b: &BTreeSet<String>) -> bool {
1076    b.is_empty()
1077}
1078
1079fn is_zero(val: &u64) -> bool {
1080    *val == 0
1081}
1082
1083/// Ordering mechanism for transactions in one Narwhal consensus output.
1084#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1085pub enum ConsensusTransactionOrdering {
1086    /// No ordering. Transactions are processed in the order they appear in the consensus output.
1087    #[default]
1088    None,
1089    /// Order transactions by gas price, highest first.
1090    ByGasPrice,
1091}
1092
1093impl ConsensusTransactionOrdering {
1094    pub fn is_none(&self) -> bool {
1095        matches!(self, ConsensusTransactionOrdering::None)
1096    }
1097}
1098
1099#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1100pub struct ExecutionTimeEstimateParams {
1101    // Targeted per-object utilization as an integer percentage (1-100).
1102    pub target_utilization: u64,
1103    // Schedule up to this much extra work (in microseconds) per object,
1104    // but don't allow more than a single transaction to exceed this
1105    // burst limit.
1106    pub allowed_txn_cost_overage_burst_limit_us: u64,
1107
1108    // For separate budget for randomness-using tx, the above limits are
1109    // used with this integer-percentage scaling factor (1-100).
1110    pub randomness_scalar: u64,
1111
1112    // Absolute maximum allowed transaction duration estimate (in microseconds).
1113    pub max_estimate_us: u64,
1114
1115    // Number of the final checkpoints in an epoch whose observations should be
1116    // stored for use in the next epoch.
1117    pub stored_observations_num_included_checkpoints: u64,
1118
1119    // Absolute limit on the number of saved observations at end of epoch.
1120    pub stored_observations_limit: u64,
1121
1122    // Requires observations from at least this amount of stake in order to use
1123    // observation-based execution time estimates instead of the default.
1124    #[serde(skip_serializing_if = "is_zero")]
1125    pub stake_weighted_median_threshold: u64,
1126
1127    // For backwards compatibility with old behavior we use a zero default duration when adding
1128    // new execution time observation keys and a zero generation when loading stored observations.
1129    // This can be removed once set to "true" on mainnet.
1130    #[serde(skip_serializing_if = "is_false")]
1131    pub default_none_duration_for_new_keys: bool,
1132
1133    // Number of observations per chunk. When None, chunking is disabled.
1134    #[serde(skip_serializing_if = "Option::is_none")]
1135    pub observations_chunk_size: Option<u64>,
1136}
1137
1138// The config for per object congestion control in consensus handler.
1139#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1140pub enum PerObjectCongestionControlMode {
1141    #[default]
1142    None, // Deprecated.
1143    TotalGasBudget,                                     // Deprecated.
1144    TotalTxCount,                                       // Deprecated.
1145    TotalGasBudgetWithCap,                              // Deprecated.
1146    ExecutionTimeEstimate(ExecutionTimeEstimateParams), // Use execution time estimate as execution cost.
1147}
1148
1149impl PerObjectCongestionControlMode {
1150    pub fn is_none(&self) -> bool {
1151        matches!(self, PerObjectCongestionControlMode::None)
1152    }
1153}
1154
1155// Configuration options for consensus algorithm.
1156#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1157pub enum ConsensusChoice {
1158    #[default]
1159    Narwhal,
1160    SwapEachEpoch,
1161    Mysticeti,
1162}
1163
1164impl ConsensusChoice {
1165    pub fn is_narwhal(&self) -> bool {
1166        matches!(self, ConsensusChoice::Narwhal)
1167    }
1168}
1169
1170// Configuration options for consensus network.
1171#[derive(Default, Copy, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
1172pub enum ConsensusNetwork {
1173    #[default]
1174    Anemo,
1175    Tonic,
1176}
1177
1178impl ConsensusNetwork {
1179    pub fn is_anemo(&self) -> bool {
1180        matches!(self, ConsensusNetwork::Anemo)
1181    }
1182}
1183
1184/// Constants that change the behavior of the protocol.
1185///
1186/// The value of each constant here must be fixed for a given protocol version. To change the value
1187/// of a constant, advance the protocol version, and add support for it in `get_for_version` under
1188/// the new version number.
1189/// (below).
1190///
1191/// To add a new field to this struct, use the following procedure:
1192/// - Advance the protocol version.
1193/// - Add the field as a private `Option<T>` to the struct.
1194/// - Initialize the field to `None` in prior protocol versions.
1195/// - Initialize the field to `Some(val)` for your new protocol version.
1196/// - Add a public getter that simply unwraps the field.
1197/// - Two public getters of the form `field(&self) -> field_type`
1198///     and `field_as_option(&self) -> Option<field_type>` will be automatically generated for you.
1199/// Example for a field: `new_constant: Option<u64>`
1200/// ```rust,ignore
1201///      pub fn new_constant(&self) -> u64 {
1202///         self.new_constant.expect(Self::CONSTANT_ERR_MSG)
1203///     }
1204///      pub fn new_constant_as_option(&self) -> Option<u64> {
1205///         self.new_constant.expect(Self::CONSTANT_ERR_MSG)
1206///     }
1207/// ```
1208/// With `pub fn new_constant(&self) -> u64`, if the constant is accessed in a protocol version
1209/// in which it is not defined, the validator will crash. (Crashing is necessary because
1210/// this type of error would almost always result in forking if not prevented here).
1211/// If you don't want the validator to crash, you can use the
1212/// `pub fn new_constant_as_option(&self) -> Option<u64>` getter, which will
1213/// return `None` if the field is not defined at that version.
1214/// - If you want a customized getter, you can add a method in the impl.
1215#[skip_serializing_none]
1216#[derive(Clone, Serialize, Debug, ProtocolConfigAccessors, ProtocolConfigOverride)]
1217pub struct ProtocolConfig {
1218    pub version: ProtocolVersion,
1219
1220    feature_flags: FeatureFlags,
1221
1222    // ==== Transaction input limits ====
1223    /// Maximum serialized size of a transaction (in bytes).
1224    max_tx_size_bytes: Option<u64>,
1225
1226    /// Maximum number of input objects to a transaction. Enforced by the transaction input checker
1227    max_input_objects: Option<u64>,
1228
1229    /// Max size of objects a transaction can write to disk after completion. Enforce by the Sui adapter.
1230    /// This is the sum of the serialized size of all objects written to disk.
1231    /// The max size of individual objects on the other hand is `max_move_object_size`.
1232    max_size_written_objects: Option<u64>,
1233    /// Max size of objects a system transaction can write to disk after completion. Enforce by the Sui adapter.
1234    /// Similar to `max_size_written_objects` but for system transactions.
1235    max_size_written_objects_system_tx: Option<u64>,
1236
1237    /// Maximum size of serialized transaction effects.
1238    max_serialized_tx_effects_size_bytes: Option<u64>,
1239
1240    /// Maximum size of serialized transaction effects for system transactions.
1241    max_serialized_tx_effects_size_bytes_system_tx: Option<u64>,
1242
1243    /// Maximum number of gas payment objects for a transaction.
1244    max_gas_payment_objects: Option<u32>,
1245
1246    /// Maximum number of modules in a Publish transaction.
1247    max_modules_in_publish: Option<u32>,
1248
1249    /// Maximum number of transitive dependencies in a package when publishing.
1250    max_package_dependencies: Option<u32>,
1251
1252    /// Maximum number of arguments in a move call or a ProgrammableTransaction's
1253    /// TransferObjects command.
1254    max_arguments: Option<u32>,
1255
1256    /// Maximum number of total type arguments, computed recursively.
1257    max_type_arguments: Option<u32>,
1258
1259    /// Maximum depth of an individual type argument.
1260    max_type_argument_depth: Option<u32>,
1261
1262    /// Maximum size of a Pure CallArg.
1263    max_pure_argument_size: Option<u32>,
1264
1265    /// Maximum number of Commands in a ProgrammableTransaction.
1266    max_programmable_tx_commands: Option<u32>,
1267
1268    // ==== Move VM, Move bytecode verifier, and execution limits ===
1269    /// Maximum Move bytecode version the VM understands. All older versions are accepted.
1270    move_binary_format_version: Option<u32>,
1271    min_move_binary_format_version: Option<u32>,
1272
1273    /// Configuration controlling binary tables size.
1274    binary_module_handles: Option<u16>,
1275    binary_struct_handles: Option<u16>,
1276    binary_function_handles: Option<u16>,
1277    binary_function_instantiations: Option<u16>,
1278    binary_signatures: Option<u16>,
1279    binary_constant_pool: Option<u16>,
1280    binary_identifiers: Option<u16>,
1281    binary_address_identifiers: Option<u16>,
1282    binary_struct_defs: Option<u16>,
1283    binary_struct_def_instantiations: Option<u16>,
1284    binary_function_defs: Option<u16>,
1285    binary_field_handles: Option<u16>,
1286    binary_field_instantiations: Option<u16>,
1287    binary_friend_decls: Option<u16>,
1288    binary_enum_defs: Option<u16>,
1289    binary_enum_def_instantiations: Option<u16>,
1290    binary_variant_handles: Option<u16>,
1291    binary_variant_instantiation_handles: Option<u16>,
1292
1293    /// Maximum size of the `contents` part of an object, in bytes. Enforced by the Sui adapter when effects are produced.
1294    max_move_object_size: Option<u64>,
1295
1296    // TODO: Option<increase to 500 KB. currently, publishing a package > 500 KB exceeds the max computation gas cost
1297    /// Maximum size of a Move package object, in bytes. Enforced by the Sui adapter at the end of a publish transaction.
1298    max_move_package_size: Option<u64>,
1299
1300    /// Max number of publish or upgrade commands allowed in a programmable transaction block.
1301    max_publish_or_upgrade_per_ptb: Option<u64>,
1302
1303    /// Maximum gas budget in MIST that a transaction can use.
1304    max_tx_gas: Option<u64>,
1305
1306    /// Maximum amount of the proposed gas price in MIST (defined in the transaction).
1307    max_gas_price: Option<u64>,
1308
1309    /// For aborted txns, we cap the gas price at a factor of RGP. This lowers risk of setting higher priority gas price
1310    /// if there's a chance the txn will abort.
1311    max_gas_price_rgp_factor_for_aborted_transactions: Option<u64>,
1312
1313    /// The max computation bucket for gas. This is the max that can be charged for computation.
1314    max_gas_computation_bucket: Option<u64>,
1315
1316    // Define the value used to round up computation gas charges
1317    gas_rounding_step: Option<u64>,
1318
1319    /// Maximum number of nested loops. Enforced by the Move bytecode verifier.
1320    max_loop_depth: Option<u64>,
1321
1322    /// Maximum number of type arguments that can be bound to generic type parameters. Enforced by the Move bytecode verifier.
1323    max_generic_instantiation_length: Option<u64>,
1324
1325    /// Maximum number of parameters that a Move function can have. Enforced by the Move bytecode verifier.
1326    max_function_parameters: Option<u64>,
1327
1328    /// Maximum number of basic blocks that a Move function can have. Enforced by the Move bytecode verifier.
1329    max_basic_blocks: Option<u64>,
1330
1331    /// Maximum stack size value. Enforced by the Move bytecode verifier.
1332    max_value_stack_size: Option<u64>,
1333
1334    /// Maximum number of "type nodes", a metric for how big a SignatureToken will be when expanded into a fully qualified type. Enforced by the Move bytecode verifier.
1335    max_type_nodes: Option<u64>,
1336
1337    /// Maximum number of push instructions in one function. Enforced by the Move bytecode verifier.
1338    max_push_size: Option<u64>,
1339
1340    /// Maximum number of struct definitions in a module. Enforced by the Move bytecode verifier.
1341    max_struct_definitions: Option<u64>,
1342
1343    /// Maximum number of function definitions in a module. Enforced by the Move bytecode verifier.
1344    max_function_definitions: Option<u64>,
1345
1346    /// Maximum number of fields allowed in a struct definition. Enforced by the Move bytecode verifier.
1347    max_fields_in_struct: Option<u64>,
1348
1349    /// Maximum dependency depth. Enforced by the Move linker when loading dependent modules.
1350    max_dependency_depth: Option<u64>,
1351
1352    /// Maximum number of Move events that a single transaction can emit. Enforced by the VM during execution.
1353    max_num_event_emit: Option<u64>,
1354
1355    /// Maximum number of new IDs that a single transaction can create. Enforced by the VM during execution.
1356    max_num_new_move_object_ids: Option<u64>,
1357
1358    /// Maximum number of new IDs that a single system transaction can create. Enforced by the VM during execution.
1359    max_num_new_move_object_ids_system_tx: Option<u64>,
1360
1361    /// Maximum number of IDs that a single transaction can delete. Enforced by the VM during execution.
1362    max_num_deleted_move_object_ids: Option<u64>,
1363
1364    /// Maximum number of IDs that a single system transaction can delete. Enforced by the VM during execution.
1365    max_num_deleted_move_object_ids_system_tx: Option<u64>,
1366
1367    /// Maximum number of IDs that a single transaction can transfer. Enforced by the VM during execution.
1368    max_num_transferred_move_object_ids: Option<u64>,
1369
1370    /// Maximum number of IDs that a single system transaction can transfer. Enforced by the VM during execution.
1371    max_num_transferred_move_object_ids_system_tx: Option<u64>,
1372
1373    /// Maximum size of a Move user event. Enforced by the VM during execution.
1374    max_event_emit_size: Option<u64>,
1375
1376    /// Maximum size of a Move user event. Enforced by the VM during execution.
1377    max_event_emit_size_total: Option<u64>,
1378
1379    /// Maximum length of a vector in Move. Enforced by the VM during execution, and for constants, by the verifier.
1380    max_move_vector_len: Option<u64>,
1381
1382    /// Maximum length of an `Identifier` in Move. Enforced by the bytecode verifier at signing.
1383    max_move_identifier_len: Option<u64>,
1384
1385    /// Maximum depth of a Move value within the VM.
1386    max_move_value_depth: Option<u64>,
1387
1388    /// Maximum number of variants in an enum. Enforced by the bytecode verifier at signing.
1389    max_move_enum_variants: Option<u64>,
1390
1391    /// Maximum number of back edges in Move function. Enforced by the bytecode verifier at signing.
1392    max_back_edges_per_function: Option<u64>,
1393
1394    /// Maximum number of back edges in Move module. Enforced by the bytecode verifier at signing.
1395    max_back_edges_per_module: Option<u64>,
1396
1397    /// Maximum number of meter `ticks` spent verifying a Move function. Enforced by the bytecode verifier at signing.
1398    max_verifier_meter_ticks_per_function: Option<u64>,
1399
1400    /// Maximum number of meter `ticks` spent verifying a Move module. Enforced by the bytecode verifier at signing.
1401    max_meter_ticks_per_module: Option<u64>,
1402
1403    /// Maximum number of meter `ticks` spent verifying a Move package. Enforced by the bytecode verifier at signing.
1404    max_meter_ticks_per_package: Option<u64>,
1405
1406    // === Object runtime internal operation limits ====
1407    // These affect dynamic fields
1408    /// Maximum number of cached objects in the object runtime ObjectStore. Enforced by object runtime during execution
1409    object_runtime_max_num_cached_objects: Option<u64>,
1410
1411    /// Maximum number of cached objects in the object runtime ObjectStore in system transaction. Enforced by object runtime during execution
1412    object_runtime_max_num_cached_objects_system_tx: Option<u64>,
1413
1414    /// Maximum number of stored objects accessed by object runtime ObjectStore. Enforced by object runtime during execution
1415    object_runtime_max_num_store_entries: Option<u64>,
1416
1417    /// Maximum number of stored objects accessed by object runtime ObjectStore in system transaction. Enforced by object runtime during execution
1418    object_runtime_max_num_store_entries_system_tx: Option<u64>,
1419
1420    // === Execution gas costs ====
1421    /// Base cost for any Sui transaction
1422    base_tx_cost_fixed: Option<u64>,
1423
1424    /// Additional cost for a transaction that publishes a package
1425    /// i.e., the base cost of such a transaction is base_tx_cost_fixed + package_publish_cost_fixed
1426    package_publish_cost_fixed: Option<u64>,
1427
1428    /// Cost per byte of a Move call transaction
1429    /// i.e., the cost of such a transaction is base_cost + (base_tx_cost_per_byte * size)
1430    base_tx_cost_per_byte: Option<u64>,
1431
1432    /// Cost per byte for a transaction that publishes a package
1433    package_publish_cost_per_byte: Option<u64>,
1434
1435    // Per-byte cost of reading an object during transaction execution
1436    obj_access_cost_read_per_byte: Option<u64>,
1437
1438    // Per-byte cost of writing an object during transaction execution
1439    obj_access_cost_mutate_per_byte: Option<u64>,
1440
1441    // Per-byte cost of deleting an object during transaction execution
1442    obj_access_cost_delete_per_byte: Option<u64>,
1443
1444    /// Per-byte cost charged for each input object to a transaction.
1445    /// Meant to approximate the cost of checking locks for each object
1446    // TODO: Option<I'm not sure that this cost makes sense. Checking locks is "free"
1447    // in the sense that an invalid tx that can never be committed/pay gas can
1448    // force validators to check an arbitrary number of locks. If those checks are
1449    // "free" for invalid transactions, why charge for them in valid transactions
1450    // TODO: Option<if we keep this, I think we probably want it to be a fixed cost rather
1451    // than a per-byte cost. checking an object lock should not require loading an
1452    // entire object, just consulting an ID -> tx digest map
1453    obj_access_cost_verify_per_byte: Option<u64>,
1454
1455    // Maximal nodes which are allowed when converting to a type layout.
1456    max_type_to_layout_nodes: Option<u64>,
1457
1458    // Maximal size in bytes that a PTB value can be
1459    max_ptb_value_size: Option<u64>,
1460
1461    // === Gas version. gas model ===
1462    /// Gas model version, what code we are using to charge gas
1463    gas_model_version: Option<u64>,
1464
1465    // === Storage gas costs ===
1466    /// Per-byte cost of storing an object in the Sui global object store. Some of this cost may be refundable if the object is later freed
1467    obj_data_cost_refundable: Option<u64>,
1468
1469    // Per-byte cost of storing an object in the Sui transaction log (e.g., in CertifiedTransactionEffects)
1470    // This depends on the size of various fields including the effects
1471    // TODO: Option<I don't fully understand this^ and more details would be useful
1472    obj_metadata_cost_non_refundable: Option<u64>,
1473
1474    // === Tokenomics ===
1475
1476    // TODO: Option<this should be changed to u64.
1477    /// Sender of a txn that touches an object will get this percent of the storage rebate back.
1478    /// In basis point.
1479    storage_rebate_rate: Option<u64>,
1480
1481    /// 5% of the storage fund's share of rewards are reinvested into the storage fund.
1482    /// In basis point.
1483    storage_fund_reinvest_rate: Option<u64>,
1484
1485    /// The share of rewards that will be slashed and redistributed is 50%.
1486    /// In basis point.
1487    reward_slashing_rate: Option<u64>,
1488
1489    /// Unit gas price, Mist per internal gas unit.
1490    storage_gas_price: Option<u64>,
1491
1492    /// Per-object storage cost for accumulator objects, used during end-of-epoch accounting.
1493    accumulator_object_storage_cost: Option<u64>,
1494
1495    // === Core Protocol ===
1496    /// Max number of transactions per checkpoint.
1497    /// Note that this is a protocol constant and not a config as validators must have this set to
1498    /// the same value, otherwise they *will* fork.
1499    max_transactions_per_checkpoint: Option<u64>,
1500
1501    /// Max size of a checkpoint in bytes.
1502    /// Note that this is a protocol constant and not a config as validators must have this set to
1503    /// the same value, otherwise they *will* fork.
1504    max_checkpoint_size_bytes: Option<u64>,
1505
1506    /// A protocol upgrade always requires 2f+1 stake to agree. We support a buffer of additional
1507    /// stake (as a fraction of f, expressed in basis points) that is required before an upgrade
1508    /// can happen automatically. 10000bps would indicate that complete unanimity is required (all
1509    /// 3f+1 must vote), while 0bps would indicate that 2f+1 is sufficient.
1510    buffer_stake_for_protocol_upgrade_bps: Option<u64>,
1511
1512    // === Native Function Costs ===
1513
1514    // `address` module
1515    // Cost params for the Move native function `address::from_bytes(bytes: vector<u8>)`
1516    address_from_bytes_cost_base: Option<u64>,
1517    // Cost params for the Move native function `address::to_u256(address): u256`
1518    address_to_u256_cost_base: Option<u64>,
1519    // Cost params for the Move native function `address::from_u256(u256): address`
1520    address_from_u256_cost_base: Option<u64>,
1521
1522    // `config` module
1523    // Cost params for the Move native function `read_setting_impl<Name: copy + drop + store,
1524    // SettingValue: key + store, SettingDataValue: store, Value: copy + drop + store,
1525    // >(config: address, name: address, current_epoch: u64): Option<Value>`
1526    config_read_setting_impl_cost_base: Option<u64>,
1527    config_read_setting_impl_cost_per_byte: Option<u64>,
1528
1529    // `dynamic_field` module
1530    // Cost params for the Move native function `hash_type_and_key<K: copy + drop + store>(parent: address, k: K): address`
1531    dynamic_field_hash_type_and_key_cost_base: Option<u64>,
1532    dynamic_field_hash_type_and_key_type_cost_per_byte: Option<u64>,
1533    dynamic_field_hash_type_and_key_value_cost_per_byte: Option<u64>,
1534    dynamic_field_hash_type_and_key_type_tag_cost_per_byte: Option<u64>,
1535    // Cost params for the Move native function `add_child_object<Child: key>(parent: address, child: Child)`
1536    dynamic_field_add_child_object_cost_base: Option<u64>,
1537    dynamic_field_add_child_object_type_cost_per_byte: Option<u64>,
1538    dynamic_field_add_child_object_value_cost_per_byte: Option<u64>,
1539    dynamic_field_add_child_object_struct_tag_cost_per_byte: Option<u64>,
1540    // Cost params for the Move native function `borrow_child_object_mut<Child: key>(parent: &mut UID, id: address): &mut Child`
1541    dynamic_field_borrow_child_object_cost_base: Option<u64>,
1542    dynamic_field_borrow_child_object_child_ref_cost_per_byte: Option<u64>,
1543    dynamic_field_borrow_child_object_type_cost_per_byte: Option<u64>,
1544    // Cost params for the Move native function `remove_child_object<Child: key>(parent: address, id: address): Child`
1545    dynamic_field_remove_child_object_cost_base: Option<u64>,
1546    dynamic_field_remove_child_object_child_cost_per_byte: Option<u64>,
1547    dynamic_field_remove_child_object_type_cost_per_byte: Option<u64>,
1548    // Cost params for the Move native function `has_child_object(parent: address, id: address): bool`
1549    dynamic_field_has_child_object_cost_base: Option<u64>,
1550    // Cost params for the Move native function `has_child_object_with_ty<Child: key>(parent: address, id: address): bool`
1551    dynamic_field_has_child_object_with_ty_cost_base: Option<u64>,
1552    dynamic_field_has_child_object_with_ty_type_cost_per_byte: Option<u64>,
1553    dynamic_field_has_child_object_with_ty_type_tag_cost_per_byte: Option<u64>,
1554
1555    // `event` module
1556    // Cost params for the Move native function `event::emit<T: copy + drop>(event: T)`
1557    event_emit_cost_base: Option<u64>,
1558    event_emit_value_size_derivation_cost_per_byte: Option<u64>,
1559    event_emit_tag_size_derivation_cost_per_byte: Option<u64>,
1560    event_emit_output_cost_per_byte: Option<u64>,
1561    event_emit_auth_stream_cost: Option<u64>,
1562
1563    //  `object` module
1564    // Cost params for the Move native function `borrow_uid<T: key>(obj: &T): &UID`
1565    object_borrow_uid_cost_base: Option<u64>,
1566    // Cost params for the Move native function `delete_impl(id: address)`
1567    object_delete_impl_cost_base: Option<u64>,
1568    // Cost params for the Move native function `record_new_uid(id: address)`
1569    object_record_new_uid_cost_base: Option<u64>,
1570
1571    // Transfer
1572    // Cost params for the Move native function `transfer_impl<T: key>(obj: T, recipient: address)`
1573    transfer_transfer_internal_cost_base: Option<u64>,
1574    // Cost params for the Move native function `party_transfer_impl<T: key>(obj: T, party_members: vector<address>)`
1575    transfer_party_transfer_internal_cost_base: Option<u64>,
1576    // Cost params for the Move native function `freeze_object<T: key>(obj: T)`
1577    transfer_freeze_object_cost_base: Option<u64>,
1578    // Cost params for the Move native function `share_object<T: key>(obj: T)`
1579    transfer_share_object_cost_base: Option<u64>,
1580    // Cost params for the Move native function
1581    // `receive_object<T: key>(p: &mut UID, recv: Receiving<T>T)`
1582    transfer_receive_object_cost_base: Option<u64>,
1583    transfer_receive_object_cost_per_byte: Option<u64>,
1584    transfer_receive_object_type_cost_per_byte: Option<u64>,
1585
1586    // TxContext
1587    // Cost params for the Move native function `transfer_impl<T: key>(obj: T, recipient: address)`
1588    tx_context_derive_id_cost_base: Option<u64>,
1589    tx_context_fresh_id_cost_base: Option<u64>,
1590    tx_context_sender_cost_base: Option<u64>,
1591    tx_context_epoch_cost_base: Option<u64>,
1592    tx_context_epoch_timestamp_ms_cost_base: Option<u64>,
1593    tx_context_sponsor_cost_base: Option<u64>,
1594    tx_context_rgp_cost_base: Option<u64>,
1595    tx_context_gas_price_cost_base: Option<u64>,
1596    tx_context_gas_budget_cost_base: Option<u64>,
1597    tx_context_ids_created_cost_base: Option<u64>,
1598    tx_context_replace_cost_base: Option<u64>,
1599
1600    // Types
1601    // Cost params for the Move native function `is_one_time_witness<T: drop>(_: &T): bool`
1602    types_is_one_time_witness_cost_base: Option<u64>,
1603    types_is_one_time_witness_type_tag_cost_per_byte: Option<u64>,
1604    types_is_one_time_witness_type_cost_per_byte: Option<u64>,
1605
1606    // Validator
1607    // Cost params for the Move native function `validate_metadata_bcs(metadata: vector<u8>)`
1608    validator_validate_metadata_cost_base: Option<u64>,
1609    validator_validate_metadata_data_cost_per_byte: Option<u64>,
1610
1611    // Crypto natives
1612    crypto_invalid_arguments_cost: Option<u64>,
1613    // bls12381::bls12381_min_sig_verify
1614    bls12381_bls12381_min_sig_verify_cost_base: Option<u64>,
1615    bls12381_bls12381_min_sig_verify_msg_cost_per_byte: Option<u64>,
1616    bls12381_bls12381_min_sig_verify_msg_cost_per_block: Option<u64>,
1617
1618    // bls12381::bls12381_min_pk_verify
1619    bls12381_bls12381_min_pk_verify_cost_base: Option<u64>,
1620    bls12381_bls12381_min_pk_verify_msg_cost_per_byte: Option<u64>,
1621    bls12381_bls12381_min_pk_verify_msg_cost_per_block: Option<u64>,
1622
1623    // ecdsa_k1::ecrecover
1624    ecdsa_k1_ecrecover_keccak256_cost_base: Option<u64>,
1625    ecdsa_k1_ecrecover_keccak256_msg_cost_per_byte: Option<u64>,
1626    ecdsa_k1_ecrecover_keccak256_msg_cost_per_block: Option<u64>,
1627    ecdsa_k1_ecrecover_sha256_cost_base: Option<u64>,
1628    ecdsa_k1_ecrecover_sha256_msg_cost_per_byte: Option<u64>,
1629    ecdsa_k1_ecrecover_sha256_msg_cost_per_block: Option<u64>,
1630
1631    // ecdsa_k1::decompress_pubkey
1632    ecdsa_k1_decompress_pubkey_cost_base: Option<u64>,
1633
1634    // ecdsa_k1::secp256k1_verify
1635    ecdsa_k1_secp256k1_verify_keccak256_cost_base: Option<u64>,
1636    ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_byte: Option<u64>,
1637    ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_block: Option<u64>,
1638    ecdsa_k1_secp256k1_verify_sha256_cost_base: Option<u64>,
1639    ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_byte: Option<u64>,
1640    ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_block: Option<u64>,
1641
1642    // ecdsa_r1::ecrecover
1643    ecdsa_r1_ecrecover_keccak256_cost_base: Option<u64>,
1644    ecdsa_r1_ecrecover_keccak256_msg_cost_per_byte: Option<u64>,
1645    ecdsa_r1_ecrecover_keccak256_msg_cost_per_block: Option<u64>,
1646    ecdsa_r1_ecrecover_sha256_cost_base: Option<u64>,
1647    ecdsa_r1_ecrecover_sha256_msg_cost_per_byte: Option<u64>,
1648    ecdsa_r1_ecrecover_sha256_msg_cost_per_block: Option<u64>,
1649
1650    // ecdsa_r1::secp256k1_verify
1651    ecdsa_r1_secp256r1_verify_keccak256_cost_base: Option<u64>,
1652    ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_byte: Option<u64>,
1653    ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_block: Option<u64>,
1654    ecdsa_r1_secp256r1_verify_sha256_cost_base: Option<u64>,
1655    ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_byte: Option<u64>,
1656    ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_block: Option<u64>,
1657
1658    // ecvrf::verify
1659    ecvrf_ecvrf_verify_cost_base: Option<u64>,
1660    ecvrf_ecvrf_verify_alpha_string_cost_per_byte: Option<u64>,
1661    ecvrf_ecvrf_verify_alpha_string_cost_per_block: Option<u64>,
1662
1663    // ed25519
1664    ed25519_ed25519_verify_cost_base: Option<u64>,
1665    ed25519_ed25519_verify_msg_cost_per_byte: Option<u64>,
1666    ed25519_ed25519_verify_msg_cost_per_block: Option<u64>,
1667
1668    // groth16::prepare_verifying_key
1669    groth16_prepare_verifying_key_bls12381_cost_base: Option<u64>,
1670    groth16_prepare_verifying_key_bn254_cost_base: Option<u64>,
1671
1672    // groth16::verify_groth16_proof_internal
1673    groth16_verify_groth16_proof_internal_bls12381_cost_base: Option<u64>,
1674    groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input: Option<u64>,
1675    groth16_verify_groth16_proof_internal_bn254_cost_base: Option<u64>,
1676    groth16_verify_groth16_proof_internal_bn254_cost_per_public_input: Option<u64>,
1677    groth16_verify_groth16_proof_internal_public_input_cost_per_byte: Option<u64>,
1678
1679    // hash::blake2b256
1680    hash_blake2b256_cost_base: Option<u64>,
1681    hash_blake2b256_data_cost_per_byte: Option<u64>,
1682    hash_blake2b256_data_cost_per_block: Option<u64>,
1683
1684    // hash::keccak256
1685    hash_keccak256_cost_base: Option<u64>,
1686    hash_keccak256_data_cost_per_byte: Option<u64>,
1687    hash_keccak256_data_cost_per_block: Option<u64>,
1688
1689    // poseidon::poseidon_bn254
1690    poseidon_bn254_cost_base: Option<u64>,
1691    poseidon_bn254_cost_per_block: Option<u64>,
1692
1693    // group_ops
1694    group_ops_bls12381_decode_scalar_cost: Option<u64>,
1695    group_ops_bls12381_decode_g1_cost: Option<u64>,
1696    group_ops_bls12381_decode_g2_cost: Option<u64>,
1697    group_ops_bls12381_decode_gt_cost: Option<u64>,
1698    group_ops_bls12381_scalar_add_cost: Option<u64>,
1699    group_ops_bls12381_g1_add_cost: Option<u64>,
1700    group_ops_bls12381_g2_add_cost: Option<u64>,
1701    group_ops_bls12381_gt_add_cost: Option<u64>,
1702    group_ops_bls12381_scalar_sub_cost: Option<u64>,
1703    group_ops_bls12381_g1_sub_cost: Option<u64>,
1704    group_ops_bls12381_g2_sub_cost: Option<u64>,
1705    group_ops_bls12381_gt_sub_cost: Option<u64>,
1706    group_ops_bls12381_scalar_mul_cost: Option<u64>,
1707    group_ops_bls12381_g1_mul_cost: Option<u64>,
1708    group_ops_bls12381_g2_mul_cost: Option<u64>,
1709    group_ops_bls12381_gt_mul_cost: Option<u64>,
1710    group_ops_bls12381_scalar_div_cost: Option<u64>,
1711    group_ops_bls12381_g1_div_cost: Option<u64>,
1712    group_ops_bls12381_g2_div_cost: Option<u64>,
1713    group_ops_bls12381_gt_div_cost: Option<u64>,
1714    group_ops_bls12381_g1_hash_to_base_cost: Option<u64>,
1715    group_ops_bls12381_g2_hash_to_base_cost: Option<u64>,
1716    group_ops_bls12381_g1_hash_to_cost_per_byte: Option<u64>,
1717    group_ops_bls12381_g2_hash_to_cost_per_byte: Option<u64>,
1718    group_ops_bls12381_g1_msm_base_cost: Option<u64>,
1719    group_ops_bls12381_g2_msm_base_cost: Option<u64>,
1720    group_ops_bls12381_g1_msm_base_cost_per_input: Option<u64>,
1721    group_ops_bls12381_g2_msm_base_cost_per_input: Option<u64>,
1722    group_ops_bls12381_msm_max_len: Option<u32>,
1723    group_ops_bls12381_pairing_cost: Option<u64>,
1724    group_ops_bls12381_g1_to_uncompressed_g1_cost: Option<u64>,
1725    group_ops_bls12381_uncompressed_g1_to_g1_cost: Option<u64>,
1726    group_ops_bls12381_uncompressed_g1_sum_base_cost: Option<u64>,
1727    group_ops_bls12381_uncompressed_g1_sum_cost_per_term: Option<u64>,
1728    group_ops_bls12381_uncompressed_g1_sum_max_terms: Option<u64>,
1729
1730    group_ops_ristretto_decode_scalar_cost: Option<u64>,
1731    group_ops_ristretto_decode_point_cost: Option<u64>,
1732    group_ops_ristretto_scalar_add_cost: Option<u64>,
1733    group_ops_ristretto_point_add_cost: Option<u64>,
1734    group_ops_ristretto_scalar_sub_cost: Option<u64>,
1735    group_ops_ristretto_point_sub_cost: Option<u64>,
1736    group_ops_ristretto_scalar_mul_cost: Option<u64>,
1737    group_ops_ristretto_point_mul_cost: Option<u64>,
1738    group_ops_ristretto_scalar_div_cost: Option<u64>,
1739    group_ops_ristretto_point_div_cost: Option<u64>,
1740
1741    verify_bulletproofs_ristretto255_base_cost: Option<u64>,
1742    verify_bulletproofs_ristretto255_cost_per_bit_and_commitment: Option<u64>,
1743
1744    // hmac::hmac_sha3_256
1745    hmac_hmac_sha3_256_cost_base: Option<u64>,
1746    hmac_hmac_sha3_256_input_cost_per_byte: Option<u64>,
1747    hmac_hmac_sha3_256_input_cost_per_block: Option<u64>,
1748
1749    // zklogin::check_zklogin_id
1750    check_zklogin_id_cost_base: Option<u64>,
1751    // zklogin::check_zklogin_issuer
1752    check_zklogin_issuer_cost_base: Option<u64>,
1753
1754    vdf_verify_vdf_cost: Option<u64>,
1755    vdf_hash_to_input_cost: Option<u64>,
1756
1757    // nitro_attestation::load_nitro_attestation
1758    nitro_attestation_parse_base_cost: Option<u64>,
1759    nitro_attestation_parse_cost_per_byte: Option<u64>,
1760    nitro_attestation_verify_base_cost: Option<u64>,
1761    nitro_attestation_verify_cost_per_cert: Option<u64>,
1762
1763    // Stdlib costs
1764    bcs_per_byte_serialized_cost: Option<u64>,
1765    bcs_legacy_min_output_size_cost: Option<u64>,
1766    bcs_failure_cost: Option<u64>,
1767
1768    hash_sha2_256_base_cost: Option<u64>,
1769    hash_sha2_256_per_byte_cost: Option<u64>,
1770    hash_sha2_256_legacy_min_input_len_cost: Option<u64>,
1771    hash_sha3_256_base_cost: Option<u64>,
1772    hash_sha3_256_per_byte_cost: Option<u64>,
1773    hash_sha3_256_legacy_min_input_len_cost: Option<u64>,
1774    type_name_get_base_cost: Option<u64>,
1775    type_name_get_per_byte_cost: Option<u64>,
1776    type_name_id_base_cost: Option<u64>,
1777
1778    string_check_utf8_base_cost: Option<u64>,
1779    string_check_utf8_per_byte_cost: Option<u64>,
1780    string_is_char_boundary_base_cost: Option<u64>,
1781    string_sub_string_base_cost: Option<u64>,
1782    string_sub_string_per_byte_cost: Option<u64>,
1783    string_index_of_base_cost: Option<u64>,
1784    string_index_of_per_byte_pattern_cost: Option<u64>,
1785    string_index_of_per_byte_searched_cost: Option<u64>,
1786
1787    vector_empty_base_cost: Option<u64>,
1788    vector_length_base_cost: Option<u64>,
1789    vector_push_back_base_cost: Option<u64>,
1790    vector_push_back_legacy_per_abstract_memory_unit_cost: Option<u64>,
1791    vector_borrow_base_cost: Option<u64>,
1792    vector_pop_back_base_cost: Option<u64>,
1793    vector_destroy_empty_base_cost: Option<u64>,
1794    vector_swap_base_cost: Option<u64>,
1795    debug_print_base_cost: Option<u64>,
1796    debug_print_stack_trace_base_cost: Option<u64>,
1797
1798    // ==== Ephemeral (consensus only) params deleted ====
1799    //
1800    // Const params for consensus scoring decision
1801    // The scaling factor property for the MED outlier detection
1802    // scoring_decision_mad_divisor: Option<f64>,
1803    // The cutoff value for the MED outlier detection
1804    // scoring_decision_cutoff_value: Option<f64>,
1805    /// === Execution Version ===
1806    execution_version: Option<u64>,
1807
1808    // Dictates the threshold (percentage of stake) that is used to calculate the "bad" nodes to be
1809    // swapped when creating the consensus schedule. The values should be of the range [0 - 33]. Anything
1810    // above 33 (f) will not be allowed.
1811    consensus_bad_nodes_stake_threshold: Option<u64>,
1812
1813    max_jwk_votes_per_validator_per_epoch: Option<u64>,
1814    // The maximum age of a JWK in epochs before it is removed from the AuthenticatorState object.
1815    // Applied at the end of an epoch as a delta from the new epoch value, so setting this to 1
1816    // will cause the new epoch to start with JWKs from the previous epoch still valid.
1817    max_age_of_jwk_in_epochs: Option<u64>,
1818
1819    // === random beacon ===
1820    /// Maximum allowed precision loss when reducing voting weights for the random beacon
1821    /// protocol.
1822    random_beacon_reduction_allowed_delta: Option<u16>,
1823
1824    /// Minimum number of shares below which voting weights will not be reduced for the
1825    /// random beacon protocol.
1826    random_beacon_reduction_lower_bound: Option<u32>,
1827
1828    /// Consensus Round after which DKG should be aborted and randomness disabled for
1829    /// the epoch, if it hasn't already completed.
1830    random_beacon_dkg_timeout_round: Option<u32>,
1831
1832    /// Minimum interval between consecutive rounds of generated randomness.
1833    random_beacon_min_round_interval_ms: Option<u64>,
1834
1835    /// Version of the random beacon DKG protocol.
1836    /// 0 was deprecated (and currently not supported), 1 is the default version.
1837    random_beacon_dkg_version: Option<u64>,
1838
1839    /// The maximum serialised transaction size (in bytes) accepted by consensus. That should be bigger than the
1840    /// `max_tx_size_bytes` with some additional headroom.
1841    consensus_max_transaction_size_bytes: Option<u64>,
1842    /// The maximum size of transactions included in a consensus block.
1843    consensus_max_transactions_in_block_bytes: Option<u64>,
1844    /// The maximum number of transactions included in a consensus block.
1845    consensus_max_num_transactions_in_block: Option<u64>,
1846
1847    /// The maximum number of rounds where transaction voting is allowed.
1848    consensus_voting_rounds: Option<u32>,
1849
1850    /// DEPRECATED. Do not use.
1851    max_accumulated_txn_cost_per_object_in_narwhal_commit: Option<u64>,
1852
1853    /// The max number of consensus rounds a transaction can be deferred due to shared object congestion.
1854    /// Transactions will be cancelled after this many rounds.
1855    max_deferral_rounds_for_congestion_control: Option<u64>,
1856
1857    /// DEPRECATED. Do not use.
1858    max_txn_cost_overage_per_object_in_commit: Option<u64>,
1859
1860    /// DEPRECATED. Do not use.
1861    allowed_txn_cost_overage_burst_per_object_in_commit: Option<u64>,
1862
1863    /// Minimum interval of commit timestamps between consecutive checkpoints.
1864    min_checkpoint_interval_ms: Option<u64>,
1865
1866    /// Version number to use for version_specific_data in `CheckpointSummary`.
1867    checkpoint_summary_version_specific_data: Option<u64>,
1868
1869    /// The max number of transactions that can be included in a single Soft Bundle.
1870    max_soft_bundle_size: Option<u64>,
1871
1872    /// Whether to try to form bridge committee
1873    // Note: this is not a feature flag because we want to distinguish between
1874    // `None` and `Some(false)`, as committee was already finalized on Testnet.
1875    bridge_should_try_to_finalize_committee: Option<bool>,
1876
1877    /// The max accumulated txn execution cost per object in a mysticeti. Transactions
1878    /// in a commit will be deferred once their touch shared objects hit this limit,
1879    /// unless the selected congestion control mode allows overage.
1880    /// This config plays the same role as `max_accumulated_txn_cost_per_object_in_narwhal_commit`
1881    /// but for mysticeti commits due to that mysticeti has higher commit rate.
1882    max_accumulated_txn_cost_per_object_in_mysticeti_commit: Option<u64>,
1883
1884    /// As above, but separate per-commit budget for transactions that use randomness.
1885    /// If not configured, uses the setting for `max_accumulated_txn_cost_per_object_in_mysticeti_commit`.
1886    max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit: Option<u64>,
1887
1888    /// Configures the garbage collection depth for consensus. When is unset or `0` then the garbage collection
1889    /// is disabled.
1890    consensus_gc_depth: Option<u32>,
1891
1892    /// DEPRECATED. Do not use.
1893    gas_budget_based_txn_cost_cap_factor: Option<u64>,
1894
1895    /// DEPRECATED. Do not use.
1896    gas_budget_based_txn_cost_absolute_cap_commit_count: Option<u64>,
1897
1898    /// SIP-45: K in the formula `amplification_factor = max(0, gas_price / reference_gas_price - K)`.
1899    /// This is the threshold for activating consensus amplification.
1900    sip_45_consensus_amplification_threshold: Option<u64>,
1901
1902    /// DEPRECATED: this was an ephemeral feature flag only used in per-epoch tables, which has now
1903    /// been deployed everywhere.
1904    use_object_per_epoch_marker_table_v2: Option<bool>,
1905
1906    /// The number of commits to consider when computing a deterministic commit rate.
1907    consensus_commit_rate_estimation_window_size: Option<u32>,
1908
1909    /// A list of effective AliasedAddress.
1910    /// For each pair, `aliased` is allowed to act as `original` for any of the transaction digests
1911    /// listed in `tx_digests`
1912    #[serde(skip_serializing_if = "Vec::is_empty")]
1913    aliased_addresses: Vec<AliasedAddress>,
1914
1915    /// The base charge for each command in a programmable transaction. This is a fixed cost to
1916    /// account for the overhead of processing each command.
1917    translation_per_command_base_charge: Option<u64>,
1918
1919    /// The base charge for each input in a programmable transaction regardless of if it is used or
1920    /// not, or a pure/object/funds withdrawal input.
1921    translation_per_input_base_charge: Option<u64>,
1922
1923    /// The base charge for each byte of pure input in a programmable transaction.
1924    translation_pure_input_per_byte_charge: Option<u64>,
1925
1926    /// The multiplier for the number of type nodes when charging for type loading.
1927    /// This is multiplied by the number of type nodes to get the total cost.
1928    /// This should be a small number to avoid excessive gas costs for loading types.
1929    translation_per_type_node_charge: Option<u64>,
1930
1931    /// The multiplier for the number of type references when charging for type checking and reference
1932    /// checking.
1933    translation_per_reference_node_charge: Option<u64>,
1934
1935    /// The multiplier for each linkage entry when charging for linkage tables that we have
1936    /// created.
1937    translation_per_linkage_entry_charge: Option<u64>,
1938
1939    /// The maximum number of updates per settlement transaction.
1940    max_updates_per_settlement_txn: Option<u32>,
1941
1942    /// Maximum computation units allowed for a gasless transaction.
1943    gasless_max_computation_units: Option<u64>,
1944
1945    /// Allowed token types for gasless transactions, with minimum transfer sizes per token.
1946    #[skip_accessor]
1947    gasless_allowed_token_types: Option<Vec<(String, u64)>>,
1948
1949    /// Maximum number of unused Pure inputs allowed in a gasless transaction.
1950    /// Object and FundsWithdrawal inputs must always be used.
1951    /// When None, there is no limit (effectively unlimited).
1952    gasless_max_unused_inputs: Option<u64>,
1953
1954    /// Maximum size in bytes of each Pure input in a gasless transaction.
1955    /// When None, there is no limit (effectively unlimited).
1956    gasless_max_pure_input_bytes: Option<u64>,
1957
1958    /// Max tps for gasless transactions. Unlimited when unset, zero when set to zero.
1959    gasless_max_tps: Option<u64>,
1960
1961    #[serde(skip_serializing_if = "Option::is_none")]
1962    #[skip_accessor]
1963    include_special_package_amendments: Option<Arc<Amendments>>,
1964
1965    /// Maximum serialized size in bytes of a gasless transaction (SenderSignedData).
1966    /// Bounds the persistent storage impact of each admitted gasless transaction.
1967    gasless_max_tx_size_bytes: Option<u64>,
1968}
1969
1970/// An aliased address.
1971#[derive(Clone, Serialize, Deserialize, Debug)]
1972pub struct AliasedAddress {
1973    /// The original address.
1974    pub original: [u8; 32],
1975    /// An aliased address which is allowed to act as the original address.
1976    pub aliased: [u8; 32],
1977    /// A list of transaction digests for which the aliasing is allowed to be in effect.
1978    pub allowed_tx_digests: Vec<[u8; 32]>,
1979}
1980
1981// feature flags
1982impl ProtocolConfig {
1983    // Add checks for feature flag support here, e.g.:
1984    // pub fn check_new_protocol_feature_supported(&self) -> Result<(), Error> {
1985    //     if self.feature_flags.new_protocol_feature_supported {
1986    //         Ok(())
1987    //     } else {
1988    //         Err(Error(format!(
1989    //             "new_protocol_feature is not supported at {:?}",
1990    //             self.version
1991    //         )))
1992    //     }
1993    // }
1994
1995    pub fn check_package_upgrades_supported(&self) -> Result<(), Error> {
1996        if self.feature_flags.package_upgrades {
1997            Ok(())
1998        } else {
1999            Err(Error(format!(
2000                "package upgrades are not supported at {:?}",
2001                self.version
2002            )))
2003        }
2004    }
2005
2006    pub fn allow_receiving_object_id(&self) -> bool {
2007        self.feature_flags.allow_receiving_object_id
2008    }
2009
2010    pub fn receiving_objects_supported(&self) -> bool {
2011        self.feature_flags.receive_objects
2012    }
2013
2014    pub fn package_upgrades_supported(&self) -> bool {
2015        self.feature_flags.package_upgrades
2016    }
2017
2018    pub fn check_commit_root_state_digest_supported(&self) -> bool {
2019        self.feature_flags.commit_root_state_digest
2020    }
2021
2022    pub fn get_advance_epoch_start_time_in_safe_mode(&self) -> bool {
2023        self.feature_flags.advance_epoch_start_time_in_safe_mode
2024    }
2025
2026    pub fn loaded_child_objects_fixed(&self) -> bool {
2027        self.feature_flags.loaded_child_objects_fixed
2028    }
2029
2030    pub fn missing_type_is_compatibility_error(&self) -> bool {
2031        self.feature_flags.missing_type_is_compatibility_error
2032    }
2033
2034    pub fn scoring_decision_with_validity_cutoff(&self) -> bool {
2035        self.feature_flags.scoring_decision_with_validity_cutoff
2036    }
2037
2038    pub fn narwhal_versioned_metadata(&self) -> bool {
2039        self.feature_flags.narwhal_versioned_metadata
2040    }
2041
2042    pub fn consensus_order_end_of_epoch_last(&self) -> bool {
2043        self.feature_flags.consensus_order_end_of_epoch_last
2044    }
2045
2046    pub fn disallow_adding_abilities_on_upgrade(&self) -> bool {
2047        self.feature_flags.disallow_adding_abilities_on_upgrade
2048    }
2049
2050    pub fn disable_invariant_violation_check_in_swap_loc(&self) -> bool {
2051        self.feature_flags
2052            .disable_invariant_violation_check_in_swap_loc
2053    }
2054
2055    pub fn advance_to_highest_supported_protocol_version(&self) -> bool {
2056        self.feature_flags
2057            .advance_to_highest_supported_protocol_version
2058    }
2059
2060    pub fn ban_entry_init(&self) -> bool {
2061        self.feature_flags.ban_entry_init
2062    }
2063
2064    pub fn package_digest_hash_module(&self) -> bool {
2065        self.feature_flags.package_digest_hash_module
2066    }
2067
2068    pub fn disallow_change_struct_type_params_on_upgrade(&self) -> bool {
2069        self.feature_flags
2070            .disallow_change_struct_type_params_on_upgrade
2071    }
2072
2073    pub fn no_extraneous_module_bytes(&self) -> bool {
2074        self.feature_flags.no_extraneous_module_bytes
2075    }
2076
2077    pub fn zklogin_auth(&self) -> bool {
2078        self.feature_flags.zklogin_auth
2079    }
2080
2081    pub fn zklogin_supported_providers(&self) -> &BTreeSet<String> {
2082        &self.feature_flags.zklogin_supported_providers
2083    }
2084
2085    pub fn consensus_transaction_ordering(&self) -> ConsensusTransactionOrdering {
2086        self.feature_flags.consensus_transaction_ordering
2087    }
2088
2089    pub fn simplified_unwrap_then_delete(&self) -> bool {
2090        self.feature_flags.simplified_unwrap_then_delete
2091    }
2092
2093    pub fn supports_upgraded_multisig(&self) -> bool {
2094        self.feature_flags.upgraded_multisig_supported
2095    }
2096
2097    pub fn txn_base_cost_as_multiplier(&self) -> bool {
2098        self.feature_flags.txn_base_cost_as_multiplier
2099    }
2100
2101    pub fn shared_object_deletion(&self) -> bool {
2102        self.feature_flags.shared_object_deletion
2103    }
2104
2105    pub fn narwhal_new_leader_election_schedule(&self) -> bool {
2106        self.feature_flags.narwhal_new_leader_election_schedule
2107    }
2108
2109    pub fn loaded_child_object_format(&self) -> bool {
2110        self.feature_flags.loaded_child_object_format
2111    }
2112
2113    pub fn enable_jwk_consensus_updates(&self) -> bool {
2114        let ret = self.feature_flags.enable_jwk_consensus_updates;
2115        if ret {
2116            // jwk updates required end-of-epoch transactions
2117            assert!(self.feature_flags.end_of_epoch_transaction_supported);
2118        }
2119        ret
2120    }
2121
2122    pub fn simple_conservation_checks(&self) -> bool {
2123        self.feature_flags.simple_conservation_checks
2124    }
2125
2126    pub fn loaded_child_object_format_type(&self) -> bool {
2127        self.feature_flags.loaded_child_object_format_type
2128    }
2129
2130    pub fn end_of_epoch_transaction_supported(&self) -> bool {
2131        let ret = self.feature_flags.end_of_epoch_transaction_supported;
2132        if !ret {
2133            // jwk updates required end-of-epoch transactions
2134            assert!(!self.feature_flags.enable_jwk_consensus_updates);
2135        }
2136        ret
2137    }
2138
2139    pub fn recompute_has_public_transfer_in_execution(&self) -> bool {
2140        self.feature_flags
2141            .recompute_has_public_transfer_in_execution
2142    }
2143
2144    // this function only exists for readability in the genesis code.
2145    pub fn create_authenticator_state_in_genesis(&self) -> bool {
2146        self.enable_jwk_consensus_updates()
2147    }
2148
2149    pub fn random_beacon(&self) -> bool {
2150        self.feature_flags.random_beacon
2151    }
2152
2153    pub fn dkg_version(&self) -> u64 {
2154        // Version 0 was deprecated and removed, the default is 1 if not set.
2155        self.random_beacon_dkg_version.unwrap_or(1)
2156    }
2157
2158    pub fn enable_bridge(&self) -> bool {
2159        let ret = self.feature_flags.bridge;
2160        if ret {
2161            // bridge required end-of-epoch transactions
2162            assert!(self.feature_flags.end_of_epoch_transaction_supported);
2163        }
2164        ret
2165    }
2166
2167    pub fn should_try_to_finalize_bridge_committee(&self) -> bool {
2168        if !self.enable_bridge() {
2169            return false;
2170        }
2171        // In the older protocol version, always try to finalize the committee.
2172        self.bridge_should_try_to_finalize_committee.unwrap_or(true)
2173    }
2174
2175    pub fn enable_effects_v2(&self) -> bool {
2176        self.feature_flags.enable_effects_v2
2177    }
2178
2179    pub fn narwhal_certificate_v2(&self) -> bool {
2180        self.feature_flags.narwhal_certificate_v2
2181    }
2182
2183    pub fn verify_legacy_zklogin_address(&self) -> bool {
2184        self.feature_flags.verify_legacy_zklogin_address
2185    }
2186
2187    pub fn accept_zklogin_in_multisig(&self) -> bool {
2188        self.feature_flags.accept_zklogin_in_multisig
2189    }
2190
2191    pub fn accept_passkey_in_multisig(&self) -> bool {
2192        self.feature_flags.accept_passkey_in_multisig
2193    }
2194
2195    pub fn validate_zklogin_public_identifier(&self) -> bool {
2196        self.feature_flags.validate_zklogin_public_identifier
2197    }
2198
2199    pub fn zklogin_max_epoch_upper_bound_delta(&self) -> Option<u64> {
2200        self.feature_flags.zklogin_max_epoch_upper_bound_delta
2201    }
2202
2203    pub fn throughput_aware_consensus_submission(&self) -> bool {
2204        self.feature_flags.throughput_aware_consensus_submission
2205    }
2206
2207    pub fn include_consensus_digest_in_prologue(&self) -> bool {
2208        self.feature_flags.include_consensus_digest_in_prologue
2209    }
2210
2211    pub fn record_consensus_determined_version_assignments_in_prologue(&self) -> bool {
2212        self.feature_flags
2213            .record_consensus_determined_version_assignments_in_prologue
2214    }
2215
2216    pub fn record_additional_state_digest_in_prologue(&self) -> bool {
2217        self.feature_flags
2218            .record_additional_state_digest_in_prologue
2219    }
2220
2221    pub fn record_consensus_determined_version_assignments_in_prologue_v2(&self) -> bool {
2222        self.feature_flags
2223            .record_consensus_determined_version_assignments_in_prologue_v2
2224    }
2225
2226    pub fn prepend_prologue_tx_in_consensus_commit_in_checkpoints(&self) -> bool {
2227        self.feature_flags
2228            .prepend_prologue_tx_in_consensus_commit_in_checkpoints
2229    }
2230
2231    pub fn hardened_otw_check(&self) -> bool {
2232        self.feature_flags.hardened_otw_check
2233    }
2234
2235    pub fn enable_poseidon(&self) -> bool {
2236        self.feature_flags.enable_poseidon
2237    }
2238
2239    pub fn enable_coin_deny_list_v1(&self) -> bool {
2240        self.feature_flags.enable_coin_deny_list
2241    }
2242
2243    pub fn enable_accumulators(&self) -> bool {
2244        self.feature_flags.enable_accumulators
2245    }
2246
2247    pub fn enable_coin_reservation_obj_refs(&self) -> bool {
2248        self.new_vm_enabled() && self.feature_flags.enable_coin_reservation_obj_refs
2249    }
2250
2251    pub fn create_root_accumulator_object(&self) -> bool {
2252        self.feature_flags.create_root_accumulator_object
2253    }
2254
2255    pub fn enable_address_balance_gas_payments(&self) -> bool {
2256        self.feature_flags.enable_address_balance_gas_payments
2257    }
2258
2259    pub fn address_balance_gas_check_rgp_at_signing(&self) -> bool {
2260        self.feature_flags.address_balance_gas_check_rgp_at_signing
2261    }
2262
2263    pub fn address_balance_gas_reject_gas_coin_arg(&self) -> bool {
2264        self.feature_flags.address_balance_gas_reject_gas_coin_arg
2265    }
2266
2267    pub fn enable_multi_epoch_transaction_expiration(&self) -> bool {
2268        self.feature_flags.enable_multi_epoch_transaction_expiration
2269    }
2270
2271    pub fn relax_valid_during_for_owned_inputs(&self) -> bool {
2272        self.feature_flags.relax_valid_during_for_owned_inputs
2273    }
2274
2275    pub fn enable_authenticated_event_streams(&self) -> bool {
2276        self.feature_flags.enable_authenticated_event_streams && self.enable_accumulators()
2277    }
2278
2279    pub fn enable_non_exclusive_writes(&self) -> bool {
2280        self.feature_flags.enable_non_exclusive_writes
2281    }
2282
2283    pub fn enable_coin_registry(&self) -> bool {
2284        self.feature_flags.enable_coin_registry
2285    }
2286
2287    pub fn enable_display_registry(&self) -> bool {
2288        self.feature_flags.enable_display_registry
2289    }
2290
2291    pub fn enable_coin_deny_list_v2(&self) -> bool {
2292        self.feature_flags.enable_coin_deny_list_v2
2293    }
2294
2295    pub fn enable_group_ops_native_functions(&self) -> bool {
2296        self.feature_flags.enable_group_ops_native_functions
2297    }
2298
2299    pub fn enable_group_ops_native_function_msm(&self) -> bool {
2300        self.feature_flags.enable_group_ops_native_function_msm
2301    }
2302
2303    pub fn enable_ristretto255_group_ops(&self) -> bool {
2304        self.feature_flags.enable_ristretto255_group_ops
2305    }
2306
2307    pub fn enable_verify_bulletproofs_ristretto255(&self) -> bool {
2308        self.feature_flags.enable_verify_bulletproofs_ristretto255
2309    }
2310
2311    pub fn reject_mutable_random_on_entry_functions(&self) -> bool {
2312        self.feature_flags.reject_mutable_random_on_entry_functions
2313    }
2314
2315    pub fn per_object_congestion_control_mode(&self) -> PerObjectCongestionControlMode {
2316        self.feature_flags.per_object_congestion_control_mode
2317    }
2318
2319    pub fn consensus_choice(&self) -> ConsensusChoice {
2320        self.feature_flags.consensus_choice
2321    }
2322
2323    pub fn consensus_network(&self) -> ConsensusNetwork {
2324        self.feature_flags.consensus_network
2325    }
2326
2327    pub fn correct_gas_payment_limit_check(&self) -> bool {
2328        self.feature_flags.correct_gas_payment_limit_check
2329    }
2330
2331    pub fn reshare_at_same_initial_version(&self) -> bool {
2332        self.feature_flags.reshare_at_same_initial_version
2333    }
2334
2335    pub fn resolve_abort_locations_to_package_id(&self) -> bool {
2336        self.feature_flags.resolve_abort_locations_to_package_id
2337    }
2338
2339    pub fn mysticeti_use_committed_subdag_digest(&self) -> bool {
2340        self.feature_flags.mysticeti_use_committed_subdag_digest
2341    }
2342
2343    pub fn enable_vdf(&self) -> bool {
2344        self.feature_flags.enable_vdf
2345    }
2346
2347    pub fn fresh_vm_on_framework_upgrade(&self) -> bool {
2348        self.feature_flags.fresh_vm_on_framework_upgrade
2349    }
2350
2351    pub fn mysticeti_num_leaders_per_round(&self) -> Option<usize> {
2352        self.feature_flags.mysticeti_num_leaders_per_round
2353    }
2354
2355    pub fn soft_bundle(&self) -> bool {
2356        self.feature_flags.soft_bundle
2357    }
2358
2359    pub fn passkey_auth(&self) -> bool {
2360        self.feature_flags.passkey_auth
2361    }
2362
2363    pub fn authority_capabilities_v2(&self) -> bool {
2364        self.feature_flags.authority_capabilities_v2
2365    }
2366
2367    pub fn max_transaction_size_bytes(&self) -> u64 {
2368        // Provide a default value if protocol config version is too low.
2369        self.consensus_max_transaction_size_bytes
2370            .unwrap_or(256 * 1024)
2371    }
2372
2373    pub fn max_transactions_in_block_bytes(&self) -> u64 {
2374        if cfg!(msim) {
2375            256 * 1024
2376        } else {
2377            self.consensus_max_transactions_in_block_bytes
2378                .unwrap_or(512 * 1024)
2379        }
2380    }
2381
2382    pub fn max_num_transactions_in_block(&self) -> u64 {
2383        if cfg!(msim) {
2384            8
2385        } else {
2386            self.consensus_max_num_transactions_in_block.unwrap_or(512)
2387        }
2388    }
2389
2390    pub fn rethrow_serialization_type_layout_errors(&self) -> bool {
2391        self.feature_flags.rethrow_serialization_type_layout_errors
2392    }
2393
2394    pub fn consensus_distributed_vote_scoring_strategy(&self) -> bool {
2395        self.feature_flags
2396            .consensus_distributed_vote_scoring_strategy
2397    }
2398
2399    pub fn consensus_round_prober(&self) -> bool {
2400        self.feature_flags.consensus_round_prober
2401    }
2402
2403    pub fn validate_identifier_inputs(&self) -> bool {
2404        self.feature_flags.validate_identifier_inputs
2405    }
2406
2407    pub fn gc_depth(&self) -> u32 {
2408        self.consensus_gc_depth.unwrap_or(0)
2409    }
2410
2411    pub fn mysticeti_fastpath(&self) -> bool {
2412        self.feature_flags.mysticeti_fastpath
2413    }
2414
2415    pub fn relocate_event_module(&self) -> bool {
2416        self.feature_flags.relocate_event_module
2417    }
2418
2419    pub fn uncompressed_g1_group_elements(&self) -> bool {
2420        self.feature_flags.uncompressed_g1_group_elements
2421    }
2422
2423    pub fn disallow_new_modules_in_deps_only_packages(&self) -> bool {
2424        self.feature_flags
2425            .disallow_new_modules_in_deps_only_packages
2426    }
2427
2428    pub fn consensus_smart_ancestor_selection(&self) -> bool {
2429        self.feature_flags.consensus_smart_ancestor_selection
2430    }
2431
2432    pub fn disable_preconsensus_locking(&self) -> bool {
2433        self.feature_flags.disable_preconsensus_locking
2434    }
2435
2436    pub fn consensus_round_prober_probe_accepted_rounds(&self) -> bool {
2437        self.feature_flags
2438            .consensus_round_prober_probe_accepted_rounds
2439    }
2440
2441    pub fn native_charging_v2(&self) -> bool {
2442        self.feature_flags.native_charging_v2
2443    }
2444
2445    pub fn consensus_linearize_subdag_v2(&self) -> bool {
2446        let res = self.feature_flags.consensus_linearize_subdag_v2;
2447        assert!(
2448            !res || self.gc_depth() > 0,
2449            "The consensus linearize sub dag V2 requires GC to be enabled"
2450        );
2451        res
2452    }
2453
2454    pub fn consensus_median_based_commit_timestamp(&self) -> bool {
2455        let res = self.feature_flags.consensus_median_based_commit_timestamp;
2456        assert!(
2457            !res || self.gc_depth() > 0,
2458            "The consensus median based commit timestamp requires GC to be enabled"
2459        );
2460        res
2461    }
2462
2463    pub fn consensus_batched_block_sync(&self) -> bool {
2464        self.feature_flags.consensus_batched_block_sync
2465    }
2466
2467    pub fn convert_type_argument_error(&self) -> bool {
2468        self.feature_flags.convert_type_argument_error
2469    }
2470
2471    pub fn variant_nodes(&self) -> bool {
2472        self.feature_flags.variant_nodes
2473    }
2474
2475    pub fn consensus_zstd_compression(&self) -> bool {
2476        self.feature_flags.consensus_zstd_compression
2477    }
2478
2479    pub fn enable_nitro_attestation(&self) -> bool {
2480        self.feature_flags.enable_nitro_attestation
2481    }
2482
2483    pub fn enable_nitro_attestation_upgraded_parsing(&self) -> bool {
2484        self.feature_flags.enable_nitro_attestation_upgraded_parsing
2485    }
2486
2487    pub fn enable_nitro_attestation_all_nonzero_pcrs_parsing(&self) -> bool {
2488        self.feature_flags
2489            .enable_nitro_attestation_all_nonzero_pcrs_parsing
2490    }
2491
2492    pub fn enable_nitro_attestation_always_include_required_pcrs_parsing(&self) -> bool {
2493        self.feature_flags
2494            .enable_nitro_attestation_always_include_required_pcrs_parsing
2495    }
2496
2497    pub fn get_consensus_commit_rate_estimation_window_size(&self) -> u32 {
2498        self.consensus_commit_rate_estimation_window_size
2499            .unwrap_or(0)
2500    }
2501
2502    pub fn consensus_num_requested_prior_commits_at_startup(&self) -> u32 {
2503        // Currently there is only one parameter driving this value. If there are multiple
2504        // things computed from prior consensus commits, this function must return the max
2505        // of all of them.
2506        let window_size = self.get_consensus_commit_rate_estimation_window_size();
2507        // Ensure we are not using past commits without recording a state digest in the prologue.
2508        assert!(window_size == 0 || self.record_additional_state_digest_in_prologue());
2509        window_size
2510    }
2511
2512    pub fn minimize_child_object_mutations(&self) -> bool {
2513        self.feature_flags.minimize_child_object_mutations
2514    }
2515
2516    pub fn move_native_context(&self) -> bool {
2517        self.feature_flags.move_native_context
2518    }
2519
2520    pub fn normalize_ptb_arguments(&self) -> bool {
2521        self.feature_flags.normalize_ptb_arguments
2522    }
2523
2524    pub fn enforce_checkpoint_timestamp_monotonicity(&self) -> bool {
2525        self.feature_flags.enforce_checkpoint_timestamp_monotonicity
2526    }
2527
2528    pub fn max_ptb_value_size_v2(&self) -> bool {
2529        self.feature_flags.max_ptb_value_size_v2
2530    }
2531
2532    pub fn resolve_type_input_ids_to_defining_id(&self) -> bool {
2533        self.feature_flags.resolve_type_input_ids_to_defining_id
2534    }
2535
2536    pub fn enable_party_transfer(&self) -> bool {
2537        self.feature_flags.enable_party_transfer
2538    }
2539
2540    pub fn allow_unbounded_system_objects(&self) -> bool {
2541        self.feature_flags.allow_unbounded_system_objects
2542    }
2543
2544    pub fn type_tags_in_object_runtime(&self) -> bool {
2545        self.feature_flags.type_tags_in_object_runtime
2546    }
2547
2548    pub fn enable_ptb_execution_v2(&self) -> bool {
2549        self.feature_flags.enable_ptb_execution_v2
2550    }
2551
2552    pub fn better_adapter_type_resolution_errors(&self) -> bool {
2553        self.feature_flags.better_adapter_type_resolution_errors
2554    }
2555
2556    pub fn record_time_estimate_processed(&self) -> bool {
2557        self.feature_flags.record_time_estimate_processed
2558    }
2559
2560    pub fn ignore_execution_time_observations_after_certs_closed(&self) -> bool {
2561        self.feature_flags
2562            .ignore_execution_time_observations_after_certs_closed
2563    }
2564
2565    pub fn dependency_linkage_error(&self) -> bool {
2566        self.feature_flags.dependency_linkage_error
2567    }
2568
2569    pub fn additional_multisig_checks(&self) -> bool {
2570        self.feature_flags.additional_multisig_checks
2571    }
2572
2573    pub fn debug_fatal_on_move_invariant_violation(&self) -> bool {
2574        self.feature_flags.debug_fatal_on_move_invariant_violation
2575    }
2576
2577    pub fn allow_private_accumulator_entrypoints(&self) -> bool {
2578        self.feature_flags.allow_private_accumulator_entrypoints
2579    }
2580
2581    pub fn additional_consensus_digest_indirect_state(&self) -> bool {
2582        self.feature_flags
2583            .additional_consensus_digest_indirect_state
2584    }
2585
2586    pub fn check_for_init_during_upgrade(&self) -> bool {
2587        self.feature_flags.check_for_init_during_upgrade
2588    }
2589
2590    pub fn per_command_shared_object_transfer_rules(&self) -> bool {
2591        self.feature_flags.per_command_shared_object_transfer_rules
2592    }
2593
2594    pub fn consensus_checkpoint_signature_key_includes_digest(&self) -> bool {
2595        self.feature_flags
2596            .consensus_checkpoint_signature_key_includes_digest
2597    }
2598
2599    pub fn include_checkpoint_artifacts_digest_in_summary(&self) -> bool {
2600        self.feature_flags
2601            .include_checkpoint_artifacts_digest_in_summary
2602    }
2603
2604    pub fn use_mfp_txns_in_load_initial_object_debts(&self) -> bool {
2605        self.feature_flags.use_mfp_txns_in_load_initial_object_debts
2606    }
2607
2608    pub fn cancel_for_failed_dkg_early(&self) -> bool {
2609        self.feature_flags.cancel_for_failed_dkg_early
2610    }
2611
2612    pub fn abstract_size_in_object_runtime(&self) -> bool {
2613        self.feature_flags.abstract_size_in_object_runtime
2614    }
2615
2616    pub fn object_runtime_charge_cache_load_gas(&self) -> bool {
2617        self.feature_flags.object_runtime_charge_cache_load_gas
2618    }
2619
2620    pub fn additional_borrow_checks(&self) -> bool {
2621        self.feature_flags.additional_borrow_checks
2622    }
2623
2624    pub fn use_new_commit_handler(&self) -> bool {
2625        self.feature_flags.use_new_commit_handler
2626    }
2627
2628    pub fn better_loader_errors(&self) -> bool {
2629        self.feature_flags.better_loader_errors
2630    }
2631
2632    pub fn generate_df_type_layouts(&self) -> bool {
2633        self.feature_flags.generate_df_type_layouts
2634    }
2635
2636    pub fn allow_references_in_ptbs(&self) -> bool {
2637        self.feature_flags.allow_references_in_ptbs
2638    }
2639
2640    pub fn private_generics_verifier_v2(&self) -> bool {
2641        self.feature_flags.private_generics_verifier_v2
2642    }
2643
2644    pub fn deprecate_global_storage_ops_during_deserialization(&self) -> bool {
2645        self.feature_flags
2646            .deprecate_global_storage_ops_during_deserialization
2647    }
2648
2649    pub fn enable_observation_chunking(&self) -> bool {
2650        matches!(self.feature_flags.per_object_congestion_control_mode,
2651            PerObjectCongestionControlMode::ExecutionTimeEstimate(ref params)
2652                if params.observations_chunk_size.is_some()
2653        )
2654    }
2655
2656    pub fn deprecate_global_storage_ops(&self) -> bool {
2657        self.feature_flags.deprecate_global_storage_ops
2658    }
2659
2660    pub fn normalize_depth_formula(&self) -> bool {
2661        self.feature_flags.normalize_depth_formula
2662    }
2663
2664    pub fn consensus_skip_gced_accept_votes(&self) -> bool {
2665        self.feature_flags.consensus_skip_gced_accept_votes
2666    }
2667
2668    pub fn include_cancelled_randomness_txns_in_prologue(&self) -> bool {
2669        self.feature_flags
2670            .include_cancelled_randomness_txns_in_prologue
2671    }
2672
2673    pub fn address_aliases(&self) -> bool {
2674        let address_aliases = self.feature_flags.address_aliases;
2675        assert!(
2676            !address_aliases || self.mysticeti_fastpath(),
2677            "Address aliases requires Mysticeti fastpath to be enabled"
2678        );
2679        if address_aliases {
2680            assert!(
2681                self.feature_flags.disable_preconsensus_locking,
2682                "Address aliases requires CertifiedTransaction to be disabled"
2683            );
2684        }
2685        address_aliases
2686    }
2687
2688    pub fn fix_checkpoint_signature_mapping(&self) -> bool {
2689        self.feature_flags.fix_checkpoint_signature_mapping
2690    }
2691
2692    pub fn enable_object_funds_withdraw(&self) -> bool {
2693        self.feature_flags.enable_object_funds_withdraw
2694    }
2695
2696    pub fn gas_rounding_halve_digits(&self) -> bool {
2697        self.feature_flags.gas_rounding_halve_digits
2698    }
2699
2700    pub fn flexible_tx_context_positions(&self) -> bool {
2701        self.feature_flags.flexible_tx_context_positions
2702    }
2703
2704    pub fn disable_entry_point_signature_check(&self) -> bool {
2705        self.feature_flags.disable_entry_point_signature_check
2706    }
2707
2708    pub fn consensus_skip_gced_blocks_in_direct_finalization(&self) -> bool {
2709        self.feature_flags
2710            .consensus_skip_gced_blocks_in_direct_finalization
2711    }
2712
2713    pub fn convert_withdrawal_compatibility_ptb_arguments(&self) -> bool {
2714        self.feature_flags
2715            .convert_withdrawal_compatibility_ptb_arguments
2716    }
2717
2718    pub fn restrict_hot_or_not_entry_functions(&self) -> bool {
2719        self.feature_flags.restrict_hot_or_not_entry_functions
2720    }
2721
2722    pub fn split_checkpoints_in_consensus_handler(&self) -> bool {
2723        self.feature_flags.split_checkpoints_in_consensus_handler
2724    }
2725
2726    pub fn consensus_always_accept_system_transactions(&self) -> bool {
2727        self.feature_flags
2728            .consensus_always_accept_system_transactions
2729    }
2730
2731    pub fn validator_metadata_verify_v2(&self) -> bool {
2732        self.feature_flags.validator_metadata_verify_v2
2733    }
2734
2735    pub fn defer_unpaid_amplification(&self) -> bool {
2736        self.feature_flags.defer_unpaid_amplification
2737    }
2738
2739    pub fn gasless_transaction_drop_safety(&self) -> bool {
2740        self.feature_flags.gasless_transaction_drop_safety
2741    }
2742
2743    pub fn new_vm_enabled(&self) -> bool {
2744        self.execution_version.is_some_and(|v| v >= 4)
2745    }
2746
2747    pub fn merge_randomness_into_checkpoint(&self) -> bool {
2748        self.feature_flags.merge_randomness_into_checkpoint
2749    }
2750
2751    pub fn use_coin_party_owner(&self) -> bool {
2752        self.feature_flags.use_coin_party_owner
2753    }
2754
2755    pub fn enable_gasless(&self) -> bool {
2756        self.feature_flags.enable_gasless
2757    }
2758
2759    pub fn gasless_verify_remaining_balance(&self) -> bool {
2760        self.feature_flags.gasless_verify_remaining_balance
2761    }
2762
2763    pub fn gasless_allowed_token_types(&self) -> &[(String, u64)] {
2764        debug_assert!(self.gasless_allowed_token_types.is_some());
2765        self.gasless_allowed_token_types.as_deref().unwrap_or(&[])
2766    }
2767
2768    pub fn get_gasless_max_unused_inputs(&self) -> u64 {
2769        self.gasless_max_unused_inputs.unwrap_or(u64::MAX)
2770    }
2771
2772    pub fn get_gasless_max_pure_input_bytes(&self) -> u64 {
2773        self.gasless_max_pure_input_bytes.unwrap_or(u64::MAX)
2774    }
2775
2776    pub fn get_gasless_max_tx_size_bytes(&self) -> u64 {
2777        self.gasless_max_tx_size_bytes.unwrap_or(u64::MAX)
2778    }
2779
2780    pub fn disallow_jump_orphans(&self) -> bool {
2781        self.feature_flags.disallow_jump_orphans
2782    }
2783
2784    pub fn early_return_receive_object_mismatched_type(&self) -> bool {
2785        self.feature_flags
2786            .early_return_receive_object_mismatched_type
2787    }
2788
2789    pub fn include_special_package_amendments_as_option(&self) -> &Option<Arc<Amendments>> {
2790        &self.include_special_package_amendments
2791    }
2792}
2793
2794#[cfg(not(msim))]
2795static POISON_VERSION_METHODS: AtomicBool = AtomicBool::new(false);
2796
2797// Use a thread local in sim tests for test isolation.
2798#[cfg(msim)]
2799thread_local! {
2800    static POISON_VERSION_METHODS: AtomicBool = AtomicBool::new(false);
2801}
2802
2803// Instantiations for each protocol version.
2804impl ProtocolConfig {
2805    /// Get the value ProtocolConfig that are in effect during the given protocol version.
2806    pub fn get_for_version(version: ProtocolVersion, chain: Chain) -> Self {
2807        // ProtocolVersion can be deserialized so we need to check it here as well.
2808        assert!(
2809            version >= ProtocolVersion::MIN,
2810            "Network protocol version is {:?}, but the minimum supported version by the binary is {:?}. Please upgrade the binary.",
2811            version,
2812            ProtocolVersion::MIN.0,
2813        );
2814        assert!(
2815            version <= ProtocolVersion::MAX_ALLOWED,
2816            "Network protocol version is {:?}, but the maximum supported version by the binary is {:?}. Please upgrade the binary.",
2817            version,
2818            ProtocolVersion::MAX_ALLOWED.0,
2819        );
2820
2821        let mut ret = Self::get_for_version_impl(version, chain);
2822        ret.version = version;
2823
2824        ret = Self::apply_config_override(version, ret);
2825
2826        if std::env::var("SUI_PROTOCOL_CONFIG_OVERRIDE_ENABLE").is_ok() {
2827            warn!(
2828                "overriding ProtocolConfig settings with custom settings; this may break non-local networks"
2829            );
2830            let overrides: ProtocolConfigOptional =
2831                serde_env::from_env_with_prefix("SUI_PROTOCOL_CONFIG_OVERRIDE")
2832                    .expect("failed to parse ProtocolConfig override env variables");
2833            overrides.apply_to(&mut ret);
2834        }
2835
2836        ret
2837    }
2838
2839    /// Get the value ProtocolConfig that are in effect during the given protocol version.
2840    /// Or none if the version is not supported.
2841    pub fn get_for_version_if_supported(version: ProtocolVersion, chain: Chain) -> Option<Self> {
2842        if version.0 >= ProtocolVersion::MIN.0 && version.0 <= ProtocolVersion::MAX_ALLOWED.0 {
2843            let mut ret = Self::get_for_version_impl(version, chain);
2844            ret.version = version;
2845            ret = Self::apply_config_override(version, ret);
2846            Some(ret)
2847        } else {
2848            None
2849        }
2850    }
2851
2852    #[cfg(not(msim))]
2853    pub fn poison_get_for_min_version() {
2854        POISON_VERSION_METHODS.store(true, Ordering::Relaxed);
2855    }
2856
2857    #[cfg(not(msim))]
2858    fn load_poison_get_for_min_version() -> bool {
2859        POISON_VERSION_METHODS.load(Ordering::Relaxed)
2860    }
2861
2862    #[cfg(msim)]
2863    pub fn poison_get_for_min_version() {
2864        POISON_VERSION_METHODS.with(|p| p.store(true, Ordering::Relaxed));
2865    }
2866
2867    #[cfg(msim)]
2868    fn load_poison_get_for_min_version() -> bool {
2869        POISON_VERSION_METHODS.with(|p| p.load(Ordering::Relaxed))
2870    }
2871
2872    /// Convenience to get the constants at the current minimum supported version.
2873    /// Mainly used by client code that may not yet be protocol-version aware.
2874    pub fn get_for_min_version() -> Self {
2875        if Self::load_poison_get_for_min_version() {
2876            panic!("get_for_min_version called on validator");
2877        }
2878        ProtocolConfig::get_for_version(ProtocolVersion::MIN, Chain::Unknown)
2879    }
2880
2881    /// CAREFUL! - You probably want to use `get_for_version` instead.
2882    ///
2883    /// Convenience to get the constants at the current maximum supported version.
2884    /// Mainly used by genesis. Note well that this function uses the max version
2885    /// supported locally by the node, which is not necessarily the current version
2886    /// of the network. ALSO, this function disregards chain specific config (by
2887    /// using Chain::Unknown), thereby potentially returning a protocol config that
2888    /// is incorrect for some feature flags. Definitely safe for testing and for
2889    /// protocol version 11 and prior.
2890    #[allow(non_snake_case)]
2891    pub fn get_for_max_version_UNSAFE() -> Self {
2892        if Self::load_poison_get_for_min_version() {
2893            panic!("get_for_max_version_UNSAFE called on validator");
2894        }
2895        ProtocolConfig::get_for_version(ProtocolVersion::MAX, Chain::Unknown)
2896    }
2897
2898    fn get_for_version_impl(version: ProtocolVersion, chain: Chain) -> Self {
2899        #[cfg(msim)]
2900        {
2901            // populate the fake simulator version # with a different base tx cost.
2902            if version == ProtocolVersion::MAX_ALLOWED {
2903                let mut config = Self::get_for_version_impl(version - 1, Chain::Unknown);
2904                config.base_tx_cost_fixed = Some(config.base_tx_cost_fixed() + 1000);
2905                return config;
2906            }
2907        }
2908
2909        // IMPORTANT: Never modify the value of any constant for a pre-existing protocol version.
2910        // To change the values here you must create a new protocol version with the new values!
2911        let mut cfg = Self {
2912            // will be overwritten before being returned
2913            version,
2914
2915            // All flags are disabled in V1
2916            feature_flags: Default::default(),
2917
2918            max_tx_size_bytes: Some(128 * 1024),
2919            // We need this number to be at least 100x less than `max_serialized_tx_effects_size_bytes`otherwise effects can be huge
2920            max_input_objects: Some(2048),
2921            max_serialized_tx_effects_size_bytes: Some(512 * 1024),
2922            max_serialized_tx_effects_size_bytes_system_tx: Some(512 * 1024 * 16),
2923            max_gas_payment_objects: Some(256),
2924            max_modules_in_publish: Some(128),
2925            max_package_dependencies: None,
2926            max_arguments: Some(512),
2927            max_type_arguments: Some(16),
2928            max_type_argument_depth: Some(16),
2929            max_pure_argument_size: Some(16 * 1024),
2930            max_programmable_tx_commands: Some(1024),
2931            move_binary_format_version: Some(6),
2932            min_move_binary_format_version: None,
2933            binary_module_handles: None,
2934            binary_struct_handles: None,
2935            binary_function_handles: None,
2936            binary_function_instantiations: None,
2937            binary_signatures: None,
2938            binary_constant_pool: None,
2939            binary_identifiers: None,
2940            binary_address_identifiers: None,
2941            binary_struct_defs: None,
2942            binary_struct_def_instantiations: None,
2943            binary_function_defs: None,
2944            binary_field_handles: None,
2945            binary_field_instantiations: None,
2946            binary_friend_decls: None,
2947            binary_enum_defs: None,
2948            binary_enum_def_instantiations: None,
2949            binary_variant_handles: None,
2950            binary_variant_instantiation_handles: None,
2951            max_move_object_size: Some(250 * 1024),
2952            max_move_package_size: Some(100 * 1024),
2953            max_publish_or_upgrade_per_ptb: None,
2954            max_tx_gas: Some(10_000_000_000),
2955            max_gas_price: Some(100_000),
2956            max_gas_price_rgp_factor_for_aborted_transactions: None,
2957            max_gas_computation_bucket: Some(5_000_000),
2958            max_loop_depth: Some(5),
2959            max_generic_instantiation_length: Some(32),
2960            max_function_parameters: Some(128),
2961            max_basic_blocks: Some(1024),
2962            max_value_stack_size: Some(1024),
2963            max_type_nodes: Some(256),
2964            max_push_size: Some(10000),
2965            max_struct_definitions: Some(200),
2966            max_function_definitions: Some(1000),
2967            max_fields_in_struct: Some(32),
2968            max_dependency_depth: Some(100),
2969            max_num_event_emit: Some(256),
2970            max_num_new_move_object_ids: Some(2048),
2971            max_num_new_move_object_ids_system_tx: Some(2048 * 16),
2972            max_num_deleted_move_object_ids: Some(2048),
2973            max_num_deleted_move_object_ids_system_tx: Some(2048 * 16),
2974            max_num_transferred_move_object_ids: Some(2048),
2975            max_num_transferred_move_object_ids_system_tx: Some(2048 * 16),
2976            max_event_emit_size: Some(250 * 1024),
2977            max_move_vector_len: Some(256 * 1024),
2978            max_type_to_layout_nodes: None,
2979            max_ptb_value_size: None,
2980
2981            max_back_edges_per_function: Some(10_000),
2982            max_back_edges_per_module: Some(10_000),
2983            max_verifier_meter_ticks_per_function: Some(6_000_000),
2984            max_meter_ticks_per_module: Some(6_000_000),
2985            max_meter_ticks_per_package: None,
2986
2987            object_runtime_max_num_cached_objects: Some(1000),
2988            object_runtime_max_num_cached_objects_system_tx: Some(1000 * 16),
2989            object_runtime_max_num_store_entries: Some(1000),
2990            object_runtime_max_num_store_entries_system_tx: Some(1000 * 16),
2991            base_tx_cost_fixed: Some(110_000),
2992            package_publish_cost_fixed: Some(1_000),
2993            base_tx_cost_per_byte: Some(0),
2994            package_publish_cost_per_byte: Some(80),
2995            obj_access_cost_read_per_byte: Some(15),
2996            obj_access_cost_mutate_per_byte: Some(40),
2997            obj_access_cost_delete_per_byte: Some(40),
2998            obj_access_cost_verify_per_byte: Some(200),
2999            obj_data_cost_refundable: Some(100),
3000            obj_metadata_cost_non_refundable: Some(50),
3001            gas_model_version: Some(1),
3002            storage_rebate_rate: Some(9900),
3003            storage_fund_reinvest_rate: Some(500),
3004            reward_slashing_rate: Some(5000),
3005            storage_gas_price: Some(1),
3006            accumulator_object_storage_cost: None,
3007            max_transactions_per_checkpoint: Some(10_000),
3008            max_checkpoint_size_bytes: Some(30 * 1024 * 1024),
3009
3010            // For now, perform upgrades with a bare quorum of validators.
3011            // MUSTFIX: This number should be increased to at least 2000 (20%) for mainnet.
3012            buffer_stake_for_protocol_upgrade_bps: Some(0),
3013
3014            // === Native Function Costs ===
3015            // `address` module
3016            // Cost params for the Move native function `address::from_bytes(bytes: vector<u8>)`
3017            address_from_bytes_cost_base: Some(52),
3018            // Cost params for the Move native function `address::to_u256(address): u256`
3019            address_to_u256_cost_base: Some(52),
3020            // Cost params for the Move native function `address::from_u256(u256): address`
3021            address_from_u256_cost_base: Some(52),
3022
3023            // `config` module
3024            // Cost params for the Move native function `read_setting_impl``
3025            config_read_setting_impl_cost_base: None,
3026            config_read_setting_impl_cost_per_byte: None,
3027
3028            // `dynamic_field` module
3029            // Cost params for the Move native function `hash_type_and_key<K: copy + drop + store>(parent: address, k: K): address`
3030            dynamic_field_hash_type_and_key_cost_base: Some(100),
3031            dynamic_field_hash_type_and_key_type_cost_per_byte: Some(2),
3032            dynamic_field_hash_type_and_key_value_cost_per_byte: Some(2),
3033            dynamic_field_hash_type_and_key_type_tag_cost_per_byte: Some(2),
3034            // Cost params for the Move native function `add_child_object<Child: key>(parent: address, child: Child)`
3035            dynamic_field_add_child_object_cost_base: Some(100),
3036            dynamic_field_add_child_object_type_cost_per_byte: Some(10),
3037            dynamic_field_add_child_object_value_cost_per_byte: Some(10),
3038            dynamic_field_add_child_object_struct_tag_cost_per_byte: Some(10),
3039            // Cost params for the Move native function `borrow_child_object_mut<Child: key>(parent: &mut UID, id: address): &mut Child`
3040            dynamic_field_borrow_child_object_cost_base: Some(100),
3041            dynamic_field_borrow_child_object_child_ref_cost_per_byte: Some(10),
3042            dynamic_field_borrow_child_object_type_cost_per_byte: Some(10),
3043            // Cost params for the Move native function `remove_child_object<Child: key>(parent: address, id: address): Child`
3044            dynamic_field_remove_child_object_cost_base: Some(100),
3045            dynamic_field_remove_child_object_child_cost_per_byte: Some(2),
3046            dynamic_field_remove_child_object_type_cost_per_byte: Some(2),
3047            // Cost params for the Move native function `has_child_object(parent: address, id: address): bool`
3048            dynamic_field_has_child_object_cost_base: Some(100),
3049            // Cost params for the Move native function `has_child_object_with_ty<Child: key>(parent: address, id: address): bool`
3050            dynamic_field_has_child_object_with_ty_cost_base: Some(100),
3051            dynamic_field_has_child_object_with_ty_type_cost_per_byte: Some(2),
3052            dynamic_field_has_child_object_with_ty_type_tag_cost_per_byte: Some(2),
3053
3054            // `event` module
3055            // Cost params for the Move native function `event::emit<T: copy + drop>(event: T)`
3056            event_emit_cost_base: Some(52),
3057            event_emit_value_size_derivation_cost_per_byte: Some(2),
3058            event_emit_tag_size_derivation_cost_per_byte: Some(5),
3059            event_emit_output_cost_per_byte: Some(10),
3060            event_emit_auth_stream_cost: None,
3061
3062            //  `object` module
3063            // Cost params for the Move native function `borrow_uid<T: key>(obj: &T): &UID`
3064            object_borrow_uid_cost_base: Some(52),
3065            // Cost params for the Move native function `delete_impl(id: address)`
3066            object_delete_impl_cost_base: Some(52),
3067            // Cost params for the Move native function `record_new_uid(id: address)`
3068            object_record_new_uid_cost_base: Some(52),
3069
3070            // `transfer` module
3071            // Cost params for the Move native function `transfer_impl<T: key>(obj: T, recipient: address)`
3072            transfer_transfer_internal_cost_base: Some(52),
3073            // Cost params for the Move native function `party_transfer_impl<T: key>(obj: T, party_members: vector<address>)`
3074            transfer_party_transfer_internal_cost_base: None,
3075            // Cost params for the Move native function `freeze_object<T: key>(obj: T)`
3076            transfer_freeze_object_cost_base: Some(52),
3077            // Cost params for the Move native function `share_object<T: key>(obj: T)`
3078            transfer_share_object_cost_base: Some(52),
3079            transfer_receive_object_cost_base: None,
3080            transfer_receive_object_type_cost_per_byte: None,
3081            transfer_receive_object_cost_per_byte: None,
3082
3083            // `tx_context` module
3084            // Cost params for the Move native function `transfer_impl<T: key>(obj: T, recipient: address)`
3085            tx_context_derive_id_cost_base: Some(52),
3086            tx_context_fresh_id_cost_base: None,
3087            tx_context_sender_cost_base: None,
3088            tx_context_epoch_cost_base: None,
3089            tx_context_epoch_timestamp_ms_cost_base: None,
3090            tx_context_sponsor_cost_base: None,
3091            tx_context_rgp_cost_base: None,
3092            tx_context_gas_price_cost_base: None,
3093            tx_context_gas_budget_cost_base: None,
3094            tx_context_ids_created_cost_base: None,
3095            tx_context_replace_cost_base: None,
3096
3097            // `types` module
3098            // Cost params for the Move native function `is_one_time_witness<T: drop>(_: &T): bool`
3099            types_is_one_time_witness_cost_base: Some(52),
3100            types_is_one_time_witness_type_tag_cost_per_byte: Some(2),
3101            types_is_one_time_witness_type_cost_per_byte: Some(2),
3102
3103            // `validator` module
3104            // Cost params for the Move native function `validate_metadata_bcs(metadata: vector<u8>)`
3105            validator_validate_metadata_cost_base: Some(52),
3106            validator_validate_metadata_data_cost_per_byte: Some(2),
3107
3108            // Crypto
3109            crypto_invalid_arguments_cost: Some(100),
3110            // bls12381::bls12381_min_pk_verify
3111            bls12381_bls12381_min_sig_verify_cost_base: Some(52),
3112            bls12381_bls12381_min_sig_verify_msg_cost_per_byte: Some(2),
3113            bls12381_bls12381_min_sig_verify_msg_cost_per_block: Some(2),
3114
3115            // bls12381::bls12381_min_pk_verify
3116            bls12381_bls12381_min_pk_verify_cost_base: Some(52),
3117            bls12381_bls12381_min_pk_verify_msg_cost_per_byte: Some(2),
3118            bls12381_bls12381_min_pk_verify_msg_cost_per_block: Some(2),
3119
3120            // ecdsa_k1::ecrecover
3121            ecdsa_k1_ecrecover_keccak256_cost_base: Some(52),
3122            ecdsa_k1_ecrecover_keccak256_msg_cost_per_byte: Some(2),
3123            ecdsa_k1_ecrecover_keccak256_msg_cost_per_block: Some(2),
3124            ecdsa_k1_ecrecover_sha256_cost_base: Some(52),
3125            ecdsa_k1_ecrecover_sha256_msg_cost_per_byte: Some(2),
3126            ecdsa_k1_ecrecover_sha256_msg_cost_per_block: Some(2),
3127
3128            // ecdsa_k1::decompress_pubkey
3129            ecdsa_k1_decompress_pubkey_cost_base: Some(52),
3130
3131            // ecdsa_k1::secp256k1_verify
3132            ecdsa_k1_secp256k1_verify_keccak256_cost_base: Some(52),
3133            ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_byte: Some(2),
3134            ecdsa_k1_secp256k1_verify_keccak256_msg_cost_per_block: Some(2),
3135            ecdsa_k1_secp256k1_verify_sha256_cost_base: Some(52),
3136            ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_byte: Some(2),
3137            ecdsa_k1_secp256k1_verify_sha256_msg_cost_per_block: Some(2),
3138
3139            // ecdsa_r1::ecrecover
3140            ecdsa_r1_ecrecover_keccak256_cost_base: Some(52),
3141            ecdsa_r1_ecrecover_keccak256_msg_cost_per_byte: Some(2),
3142            ecdsa_r1_ecrecover_keccak256_msg_cost_per_block: Some(2),
3143            ecdsa_r1_ecrecover_sha256_cost_base: Some(52),
3144            ecdsa_r1_ecrecover_sha256_msg_cost_per_byte: Some(2),
3145            ecdsa_r1_ecrecover_sha256_msg_cost_per_block: Some(2),
3146
3147            // ecdsa_r1::secp256k1_verify
3148            ecdsa_r1_secp256r1_verify_keccak256_cost_base: Some(52),
3149            ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_byte: Some(2),
3150            ecdsa_r1_secp256r1_verify_keccak256_msg_cost_per_block: Some(2),
3151            ecdsa_r1_secp256r1_verify_sha256_cost_base: Some(52),
3152            ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_byte: Some(2),
3153            ecdsa_r1_secp256r1_verify_sha256_msg_cost_per_block: Some(2),
3154
3155            // ecvrf::verify
3156            ecvrf_ecvrf_verify_cost_base: Some(52),
3157            ecvrf_ecvrf_verify_alpha_string_cost_per_byte: Some(2),
3158            ecvrf_ecvrf_verify_alpha_string_cost_per_block: Some(2),
3159
3160            // ed25519
3161            ed25519_ed25519_verify_cost_base: Some(52),
3162            ed25519_ed25519_verify_msg_cost_per_byte: Some(2),
3163            ed25519_ed25519_verify_msg_cost_per_block: Some(2),
3164
3165            // groth16::prepare_verifying_key
3166            groth16_prepare_verifying_key_bls12381_cost_base: Some(52),
3167            groth16_prepare_verifying_key_bn254_cost_base: Some(52),
3168
3169            // groth16::verify_groth16_proof_internal
3170            groth16_verify_groth16_proof_internal_bls12381_cost_base: Some(52),
3171            groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input: Some(2),
3172            groth16_verify_groth16_proof_internal_bn254_cost_base: Some(52),
3173            groth16_verify_groth16_proof_internal_bn254_cost_per_public_input: Some(2),
3174            groth16_verify_groth16_proof_internal_public_input_cost_per_byte: Some(2),
3175
3176            // hash::blake2b256
3177            hash_blake2b256_cost_base: Some(52),
3178            hash_blake2b256_data_cost_per_byte: Some(2),
3179            hash_blake2b256_data_cost_per_block: Some(2),
3180
3181            // hash::keccak256
3182            hash_keccak256_cost_base: Some(52),
3183            hash_keccak256_data_cost_per_byte: Some(2),
3184            hash_keccak256_data_cost_per_block: Some(2),
3185
3186            poseidon_bn254_cost_base: None,
3187            poseidon_bn254_cost_per_block: None,
3188
3189            // hmac::hmac_sha3_256
3190            hmac_hmac_sha3_256_cost_base: Some(52),
3191            hmac_hmac_sha3_256_input_cost_per_byte: Some(2),
3192            hmac_hmac_sha3_256_input_cost_per_block: Some(2),
3193
3194            // group ops
3195            group_ops_bls12381_decode_scalar_cost: None,
3196            group_ops_bls12381_decode_g1_cost: None,
3197            group_ops_bls12381_decode_g2_cost: None,
3198            group_ops_bls12381_decode_gt_cost: None,
3199            group_ops_bls12381_scalar_add_cost: None,
3200            group_ops_bls12381_g1_add_cost: None,
3201            group_ops_bls12381_g2_add_cost: None,
3202            group_ops_bls12381_gt_add_cost: None,
3203            group_ops_bls12381_scalar_sub_cost: None,
3204            group_ops_bls12381_g1_sub_cost: None,
3205            group_ops_bls12381_g2_sub_cost: None,
3206            group_ops_bls12381_gt_sub_cost: None,
3207            group_ops_bls12381_scalar_mul_cost: None,
3208            group_ops_bls12381_g1_mul_cost: None,
3209            group_ops_bls12381_g2_mul_cost: None,
3210            group_ops_bls12381_gt_mul_cost: None,
3211            group_ops_bls12381_scalar_div_cost: None,
3212            group_ops_bls12381_g1_div_cost: None,
3213            group_ops_bls12381_g2_div_cost: None,
3214            group_ops_bls12381_gt_div_cost: None,
3215            group_ops_bls12381_g1_hash_to_base_cost: None,
3216            group_ops_bls12381_g2_hash_to_base_cost: None,
3217            group_ops_bls12381_g1_hash_to_cost_per_byte: None,
3218            group_ops_bls12381_g2_hash_to_cost_per_byte: None,
3219            group_ops_bls12381_g1_msm_base_cost: None,
3220            group_ops_bls12381_g2_msm_base_cost: None,
3221            group_ops_bls12381_g1_msm_base_cost_per_input: None,
3222            group_ops_bls12381_g2_msm_base_cost_per_input: None,
3223            group_ops_bls12381_msm_max_len: None,
3224            group_ops_bls12381_pairing_cost: None,
3225            group_ops_bls12381_g1_to_uncompressed_g1_cost: None,
3226            group_ops_bls12381_uncompressed_g1_to_g1_cost: None,
3227            group_ops_bls12381_uncompressed_g1_sum_base_cost: None,
3228            group_ops_bls12381_uncompressed_g1_sum_cost_per_term: None,
3229            group_ops_bls12381_uncompressed_g1_sum_max_terms: None,
3230
3231            group_ops_ristretto_decode_scalar_cost: None,
3232            group_ops_ristretto_decode_point_cost: None,
3233            group_ops_ristretto_scalar_add_cost: None,
3234            group_ops_ristretto_point_add_cost: None,
3235            group_ops_ristretto_scalar_sub_cost: None,
3236            group_ops_ristretto_point_sub_cost: None,
3237            group_ops_ristretto_scalar_mul_cost: None,
3238            group_ops_ristretto_point_mul_cost: None,
3239            group_ops_ristretto_scalar_div_cost: None,
3240            group_ops_ristretto_point_div_cost: None,
3241
3242            verify_bulletproofs_ristretto255_base_cost: None,
3243            verify_bulletproofs_ristretto255_cost_per_bit_and_commitment: None,
3244
3245            // zklogin::check_zklogin_id
3246            check_zklogin_id_cost_base: None,
3247            // zklogin::check_zklogin_issuer
3248            check_zklogin_issuer_cost_base: None,
3249
3250            vdf_verify_vdf_cost: None,
3251            vdf_hash_to_input_cost: None,
3252
3253            // nitro_attestation::verify_nitro_attestation
3254            nitro_attestation_parse_base_cost: None,
3255            nitro_attestation_parse_cost_per_byte: None,
3256            nitro_attestation_verify_base_cost: None,
3257            nitro_attestation_verify_cost_per_cert: None,
3258
3259            bcs_per_byte_serialized_cost: None,
3260            bcs_legacy_min_output_size_cost: None,
3261            bcs_failure_cost: None,
3262            hash_sha2_256_base_cost: None,
3263            hash_sha2_256_per_byte_cost: None,
3264            hash_sha2_256_legacy_min_input_len_cost: None,
3265            hash_sha3_256_base_cost: None,
3266            hash_sha3_256_per_byte_cost: None,
3267            hash_sha3_256_legacy_min_input_len_cost: None,
3268            type_name_get_base_cost: None,
3269            type_name_get_per_byte_cost: None,
3270            type_name_id_base_cost: None,
3271            string_check_utf8_base_cost: None,
3272            string_check_utf8_per_byte_cost: None,
3273            string_is_char_boundary_base_cost: None,
3274            string_sub_string_base_cost: None,
3275            string_sub_string_per_byte_cost: None,
3276            string_index_of_base_cost: None,
3277            string_index_of_per_byte_pattern_cost: None,
3278            string_index_of_per_byte_searched_cost: None,
3279            vector_empty_base_cost: None,
3280            vector_length_base_cost: None,
3281            vector_push_back_base_cost: None,
3282            vector_push_back_legacy_per_abstract_memory_unit_cost: None,
3283            vector_borrow_base_cost: None,
3284            vector_pop_back_base_cost: None,
3285            vector_destroy_empty_base_cost: None,
3286            vector_swap_base_cost: None,
3287            debug_print_base_cost: None,
3288            debug_print_stack_trace_base_cost: None,
3289
3290            max_size_written_objects: None,
3291            max_size_written_objects_system_tx: None,
3292
3293            // ==== Ephemeral (consensus only) params deleted ====
3294            // Const params for consensus scoring decision
3295            // scoring_decision_mad_divisor: None,
3296            // scoring_decision_cutoff_value: None,
3297
3298            // Limits the length of a Move identifier
3299            max_move_identifier_len: None,
3300            max_move_value_depth: None,
3301            max_move_enum_variants: None,
3302
3303            gas_rounding_step: None,
3304
3305            execution_version: None,
3306
3307            max_event_emit_size_total: None,
3308
3309            consensus_bad_nodes_stake_threshold: None,
3310
3311            max_jwk_votes_per_validator_per_epoch: None,
3312
3313            max_age_of_jwk_in_epochs: None,
3314
3315            random_beacon_reduction_allowed_delta: None,
3316
3317            random_beacon_reduction_lower_bound: None,
3318
3319            random_beacon_dkg_timeout_round: None,
3320
3321            random_beacon_min_round_interval_ms: None,
3322
3323            random_beacon_dkg_version: None,
3324
3325            consensus_max_transaction_size_bytes: None,
3326
3327            consensus_max_transactions_in_block_bytes: None,
3328
3329            consensus_max_num_transactions_in_block: None,
3330
3331            consensus_voting_rounds: None,
3332
3333            max_accumulated_txn_cost_per_object_in_narwhal_commit: None,
3334
3335            max_deferral_rounds_for_congestion_control: None,
3336
3337            max_txn_cost_overage_per_object_in_commit: None,
3338
3339            allowed_txn_cost_overage_burst_per_object_in_commit: None,
3340
3341            min_checkpoint_interval_ms: None,
3342
3343            checkpoint_summary_version_specific_data: None,
3344
3345            max_soft_bundle_size: None,
3346
3347            bridge_should_try_to_finalize_committee: None,
3348
3349            max_accumulated_txn_cost_per_object_in_mysticeti_commit: None,
3350
3351            max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit: None,
3352
3353            consensus_gc_depth: None,
3354
3355            gas_budget_based_txn_cost_cap_factor: None,
3356
3357            gas_budget_based_txn_cost_absolute_cap_commit_count: None,
3358
3359            sip_45_consensus_amplification_threshold: None,
3360
3361            use_object_per_epoch_marker_table_v2: None,
3362
3363            consensus_commit_rate_estimation_window_size: None,
3364
3365            aliased_addresses: vec![],
3366
3367            translation_per_command_base_charge: None,
3368            translation_per_input_base_charge: None,
3369            translation_pure_input_per_byte_charge: None,
3370            translation_per_type_node_charge: None,
3371            translation_per_reference_node_charge: None,
3372            translation_per_linkage_entry_charge: None,
3373
3374            max_updates_per_settlement_txn: None,
3375
3376            gasless_max_computation_units: None,
3377            gasless_allowed_token_types: None,
3378            gasless_max_unused_inputs: None,
3379            gasless_max_pure_input_bytes: None,
3380            gasless_max_tps: None,
3381            include_special_package_amendments: None,
3382            gasless_max_tx_size_bytes: None,
3383            // When adding a new constant, set it to None in the earliest version, like this:
3384            // new_constant: None,
3385        };
3386        for cur in 2..=version.0 {
3387            match cur {
3388                1 => unreachable!(),
3389                2 => {
3390                    cfg.feature_flags.advance_epoch_start_time_in_safe_mode = true;
3391                }
3392                3 => {
3393                    // changes for gas model
3394                    cfg.gas_model_version = Some(2);
3395                    // max gas budget is in MIST and an absolute value 50SUI
3396                    cfg.max_tx_gas = Some(50_000_000_000);
3397                    // min gas budget is in MIST and an absolute value 2000MIST or 0.000002SUI
3398                    cfg.base_tx_cost_fixed = Some(2_000);
3399                    // storage gas price multiplier
3400                    cfg.storage_gas_price = Some(76);
3401                    cfg.feature_flags.loaded_child_objects_fixed = true;
3402                    // max size of written objects during a TXn
3403                    // this is a sum of all objects written during a TXn
3404                    cfg.max_size_written_objects = Some(5 * 1000 * 1000);
3405                    // max size of written objects during a system TXn to allow for larger writes
3406                    // akin to `max_size_written_objects` but for system TXns
3407                    cfg.max_size_written_objects_system_tx = Some(50 * 1000 * 1000);
3408                    cfg.feature_flags.package_upgrades = true;
3409                }
3410                // This is the first protocol version currently possible.
3411                // Mainnet starts with version 4. Previous versions are pre mainnet and have
3412                // all been wiped out.
3413                // Every other chain is after version 4.
3414                4 => {
3415                    // Change reward slashing rate to 100%.
3416                    cfg.reward_slashing_rate = Some(10000);
3417                    // protect old and new lookup for object version
3418                    cfg.gas_model_version = Some(3);
3419                }
3420                5 => {
3421                    cfg.feature_flags.missing_type_is_compatibility_error = true;
3422                    cfg.gas_model_version = Some(4);
3423                    cfg.feature_flags.scoring_decision_with_validity_cutoff = true;
3424                    // ==== Ephemeral (consensus only) params deleted ====
3425                    // cfg.scoring_decision_mad_divisor = Some(2.3);
3426                    // cfg.scoring_decision_cutoff_value = Some(2.5);
3427                }
3428                6 => {
3429                    cfg.gas_model_version = Some(5);
3430                    cfg.buffer_stake_for_protocol_upgrade_bps = Some(5000);
3431                    cfg.feature_flags.consensus_order_end_of_epoch_last = true;
3432                }
3433                7 => {
3434                    cfg.feature_flags.disallow_adding_abilities_on_upgrade = true;
3435                    cfg.feature_flags
3436                        .disable_invariant_violation_check_in_swap_loc = true;
3437                    cfg.feature_flags.ban_entry_init = true;
3438                    cfg.feature_flags.package_digest_hash_module = true;
3439                }
3440                8 => {
3441                    cfg.feature_flags
3442                        .disallow_change_struct_type_params_on_upgrade = true;
3443                }
3444                9 => {
3445                    // Limits the length of a Move identifier
3446                    cfg.max_move_identifier_len = Some(128);
3447                    cfg.feature_flags.no_extraneous_module_bytes = true;
3448                    cfg.feature_flags
3449                        .advance_to_highest_supported_protocol_version = true;
3450                }
3451                10 => {
3452                    cfg.max_verifier_meter_ticks_per_function = Some(16_000_000);
3453                    cfg.max_meter_ticks_per_module = Some(16_000_000);
3454                }
3455                11 => {
3456                    cfg.max_move_value_depth = Some(128);
3457                }
3458                12 => {
3459                    cfg.feature_flags.narwhal_versioned_metadata = true;
3460                    if chain != Chain::Mainnet {
3461                        cfg.feature_flags.commit_root_state_digest = true;
3462                    }
3463
3464                    if chain != Chain::Mainnet && chain != Chain::Testnet {
3465                        cfg.feature_flags.zklogin_auth = true;
3466                    }
3467                }
3468                13 => {}
3469                14 => {
3470                    cfg.gas_rounding_step = Some(1_000);
3471                    cfg.gas_model_version = Some(6);
3472                }
3473                15 => {
3474                    cfg.feature_flags.consensus_transaction_ordering =
3475                        ConsensusTransactionOrdering::ByGasPrice;
3476                }
3477                16 => {
3478                    cfg.feature_flags.simplified_unwrap_then_delete = true;
3479                }
3480                17 => {
3481                    cfg.feature_flags.upgraded_multisig_supported = true;
3482                }
3483                18 => {
3484                    cfg.execution_version = Some(1);
3485                    // Following flags are implied by this execution version.  Once support for earlier
3486                    // protocol versions is dropped, these flags can be removed:
3487                    // cfg.feature_flags.package_upgrades = true;
3488                    // cfg.feature_flags.disallow_adding_abilities_on_upgrade = true;
3489                    // cfg.feature_flags.disallow_change_struct_type_params_on_upgrade = true;
3490                    // cfg.feature_flags.loaded_child_objects_fixed = true;
3491                    // cfg.feature_flags.ban_entry_init = true;
3492                    // cfg.feature_flags.pack_digest_hash_modules = true;
3493                    cfg.feature_flags.txn_base_cost_as_multiplier = true;
3494                    // this is a multiplier of the gas price
3495                    cfg.base_tx_cost_fixed = Some(1_000);
3496                }
3497                19 => {
3498                    cfg.max_num_event_emit = Some(1024);
3499                    // We maintain the same total size limit for events, but increase the number of
3500                    // events that can be emitted.
3501                    cfg.max_event_emit_size_total = Some(
3502                        256 /* former event count limit */ * 250 * 1024, /* size limit per event */
3503                    );
3504                }
3505                20 => {
3506                    cfg.feature_flags.commit_root_state_digest = true;
3507
3508                    if chain != Chain::Mainnet {
3509                        cfg.feature_flags.narwhal_new_leader_election_schedule = true;
3510                        cfg.consensus_bad_nodes_stake_threshold = Some(20);
3511                    }
3512                }
3513
3514                21 => {
3515                    if chain != Chain::Mainnet {
3516                        cfg.feature_flags.zklogin_supported_providers = BTreeSet::from([
3517                            "Google".to_string(),
3518                            "Facebook".to_string(),
3519                            "Twitch".to_string(),
3520                        ]);
3521                    }
3522                }
3523                22 => {
3524                    cfg.feature_flags.loaded_child_object_format = true;
3525                }
3526                23 => {
3527                    cfg.feature_flags.loaded_child_object_format_type = true;
3528                    cfg.feature_flags.narwhal_new_leader_election_schedule = true;
3529                    // Taking a baby step approach, we consider only 20% by stake as bad nodes so we
3530                    // have a 80% by stake of nodes participating in the leader committee. That allow
3531                    // us for more redundancy in case we have validators under performing - since the
3532                    // responsibility is shared amongst more nodes. We can increase that once we do have
3533                    // higher confidence.
3534                    cfg.consensus_bad_nodes_stake_threshold = Some(20);
3535                }
3536                24 => {
3537                    cfg.feature_flags.simple_conservation_checks = true;
3538                    cfg.max_publish_or_upgrade_per_ptb = Some(5);
3539
3540                    cfg.feature_flags.end_of_epoch_transaction_supported = true;
3541
3542                    if chain != Chain::Mainnet {
3543                        cfg.feature_flags.enable_jwk_consensus_updates = true;
3544                        // Max of 10 votes per hour
3545                        cfg.max_jwk_votes_per_validator_per_epoch = Some(240);
3546                        cfg.max_age_of_jwk_in_epochs = Some(1);
3547                    }
3548                }
3549                25 => {
3550                    // Enable zkLogin for all providers in all networks.
3551                    cfg.feature_flags.zklogin_supported_providers = BTreeSet::from([
3552                        "Google".to_string(),
3553                        "Facebook".to_string(),
3554                        "Twitch".to_string(),
3555                    ]);
3556                    cfg.feature_flags.zklogin_auth = true;
3557
3558                    // Enable jwk consensus updates
3559                    cfg.feature_flags.enable_jwk_consensus_updates = true;
3560                    cfg.max_jwk_votes_per_validator_per_epoch = Some(240);
3561                    cfg.max_age_of_jwk_in_epochs = Some(1);
3562                }
3563                26 => {
3564                    cfg.gas_model_version = Some(7);
3565                    // Only enable receiving objects in devnet
3566                    if chain != Chain::Mainnet && chain != Chain::Testnet {
3567                        cfg.transfer_receive_object_cost_base = Some(52);
3568                        cfg.feature_flags.receive_objects = true;
3569                    }
3570                }
3571                27 => {
3572                    cfg.gas_model_version = Some(8);
3573                }
3574                28 => {
3575                    // zklogin::check_zklogin_id
3576                    cfg.check_zklogin_id_cost_base = Some(200);
3577                    // zklogin::check_zklogin_issuer
3578                    cfg.check_zklogin_issuer_cost_base = Some(200);
3579
3580                    // Only enable effects v2 on devnet.
3581                    if chain != Chain::Mainnet && chain != Chain::Testnet {
3582                        cfg.feature_flags.enable_effects_v2 = true;
3583                    }
3584                }
3585                29 => {
3586                    cfg.feature_flags.verify_legacy_zklogin_address = true;
3587                }
3588                30 => {
3589                    // Only enable nw certificate v2 on testnet.
3590                    if chain != Chain::Mainnet {
3591                        cfg.feature_flags.narwhal_certificate_v2 = true;
3592                    }
3593
3594                    cfg.random_beacon_reduction_allowed_delta = Some(800);
3595                    // Only enable effects v2 on devnet and testnet.
3596                    if chain != Chain::Mainnet {
3597                        cfg.feature_flags.enable_effects_v2 = true;
3598                    }
3599
3600                    // zklogin_supported_providers config is deprecated, zklogin
3601                    // signature verifier will use the fetched jwk map to determine
3602                    // whether the provider is supported based on node config.
3603                    cfg.feature_flags.zklogin_supported_providers = BTreeSet::default();
3604
3605                    cfg.feature_flags.recompute_has_public_transfer_in_execution = true;
3606                }
3607                31 => {
3608                    cfg.execution_version = Some(2);
3609                    // Only enable shared object deletion on devnet
3610                    if chain != Chain::Mainnet && chain != Chain::Testnet {
3611                        cfg.feature_flags.shared_object_deletion = true;
3612                    }
3613                }
3614                32 => {
3615                    // enable zklogin in multisig in devnet and testnet
3616                    if chain != Chain::Mainnet {
3617                        cfg.feature_flags.accept_zklogin_in_multisig = true;
3618                    }
3619                    // enable receiving objects in devnet and testnet
3620                    if chain != Chain::Mainnet {
3621                        cfg.transfer_receive_object_cost_base = Some(52);
3622                        cfg.feature_flags.receive_objects = true;
3623                    }
3624                    // Only enable random beacon on devnet
3625                    if chain != Chain::Mainnet && chain != Chain::Testnet {
3626                        cfg.feature_flags.random_beacon = true;
3627                        cfg.random_beacon_reduction_lower_bound = Some(1600);
3628                        cfg.random_beacon_dkg_timeout_round = Some(3000);
3629                        cfg.random_beacon_min_round_interval_ms = Some(150);
3630                    }
3631                    // Only enable consensus digest in consensus commit prologue in devnet.
3632                    if chain != Chain::Testnet && chain != Chain::Mainnet {
3633                        cfg.feature_flags.include_consensus_digest_in_prologue = true;
3634                    }
3635
3636                    // enable nw cert v2 on mainnet
3637                    cfg.feature_flags.narwhal_certificate_v2 = true;
3638                }
3639                33 => {
3640                    cfg.feature_flags.hardened_otw_check = true;
3641                    cfg.feature_flags.allow_receiving_object_id = true;
3642
3643                    // Enable transfer-to-object in mainnet
3644                    cfg.transfer_receive_object_cost_base = Some(52);
3645                    cfg.feature_flags.receive_objects = true;
3646
3647                    // Enable shared object deletion in testnet and devnet
3648                    if chain != Chain::Mainnet {
3649                        cfg.feature_flags.shared_object_deletion = true;
3650                    }
3651
3652                    cfg.feature_flags.enable_effects_v2 = true;
3653                }
3654                34 => {}
3655                35 => {
3656                    // Add costs for poseidon::poseidon_bn254
3657                    if chain != Chain::Mainnet && chain != Chain::Testnet {
3658                        cfg.feature_flags.enable_poseidon = true;
3659                        cfg.poseidon_bn254_cost_base = Some(260);
3660                        cfg.poseidon_bn254_cost_per_block = Some(10);
3661                    }
3662
3663                    cfg.feature_flags.enable_coin_deny_list = true;
3664                }
3665                36 => {
3666                    // Only enable group ops on devnet
3667                    if chain != Chain::Mainnet && chain != Chain::Testnet {
3668                        cfg.feature_flags.enable_group_ops_native_functions = true;
3669                        cfg.feature_flags.enable_group_ops_native_function_msm = true;
3670                        // Next values are arbitrary in a similar way as the other crypto native functions.
3671                        cfg.group_ops_bls12381_decode_scalar_cost = Some(52);
3672                        cfg.group_ops_bls12381_decode_g1_cost = Some(52);
3673                        cfg.group_ops_bls12381_decode_g2_cost = Some(52);
3674                        cfg.group_ops_bls12381_decode_gt_cost = Some(52);
3675                        cfg.group_ops_bls12381_scalar_add_cost = Some(52);
3676                        cfg.group_ops_bls12381_g1_add_cost = Some(52);
3677                        cfg.group_ops_bls12381_g2_add_cost = Some(52);
3678                        cfg.group_ops_bls12381_gt_add_cost = Some(52);
3679                        cfg.group_ops_bls12381_scalar_sub_cost = Some(52);
3680                        cfg.group_ops_bls12381_g1_sub_cost = Some(52);
3681                        cfg.group_ops_bls12381_g2_sub_cost = Some(52);
3682                        cfg.group_ops_bls12381_gt_sub_cost = Some(52);
3683                        cfg.group_ops_bls12381_scalar_mul_cost = Some(52);
3684                        cfg.group_ops_bls12381_g1_mul_cost = Some(52);
3685                        cfg.group_ops_bls12381_g2_mul_cost = Some(52);
3686                        cfg.group_ops_bls12381_gt_mul_cost = Some(52);
3687                        cfg.group_ops_bls12381_scalar_div_cost = Some(52);
3688                        cfg.group_ops_bls12381_g1_div_cost = Some(52);
3689                        cfg.group_ops_bls12381_g2_div_cost = Some(52);
3690                        cfg.group_ops_bls12381_gt_div_cost = Some(52);
3691                        cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(52);
3692                        cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(52);
3693                        cfg.group_ops_bls12381_g1_hash_to_cost_per_byte = Some(2);
3694                        cfg.group_ops_bls12381_g2_hash_to_cost_per_byte = Some(2);
3695                        cfg.group_ops_bls12381_g1_msm_base_cost = Some(52);
3696                        cfg.group_ops_bls12381_g2_msm_base_cost = Some(52);
3697                        cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(52);
3698                        cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(52);
3699                        cfg.group_ops_bls12381_msm_max_len = Some(32);
3700                        cfg.group_ops_bls12381_pairing_cost = Some(52);
3701                    }
3702                    // Enable shared object deletion on all networks.
3703                    cfg.feature_flags.shared_object_deletion = true;
3704
3705                    cfg.consensus_max_transaction_size_bytes = Some(256 * 1024); // 256KB
3706                    cfg.consensus_max_transactions_in_block_bytes = Some(6 * 1_024 * 1024);
3707                    // 6 MB
3708                }
3709                37 => {
3710                    cfg.feature_flags.reject_mutable_random_on_entry_functions = true;
3711
3712                    // Enable consensus digest in consensus commit prologue in testnet and devnet.
3713                    if chain != Chain::Mainnet {
3714                        cfg.feature_flags.include_consensus_digest_in_prologue = true;
3715                    }
3716                }
3717                38 => {
3718                    cfg.binary_module_handles = Some(100);
3719                    cfg.binary_struct_handles = Some(300);
3720                    cfg.binary_function_handles = Some(1500);
3721                    cfg.binary_function_instantiations = Some(750);
3722                    cfg.binary_signatures = Some(1000);
3723                    // constants and identifiers are proportional to the binary size,
3724                    // and they vastly depend on the code, so we are leaving them
3725                    // reasonably high
3726                    cfg.binary_constant_pool = Some(4000);
3727                    cfg.binary_identifiers = Some(10000);
3728                    cfg.binary_address_identifiers = Some(100);
3729                    cfg.binary_struct_defs = Some(200);
3730                    cfg.binary_struct_def_instantiations = Some(100);
3731                    cfg.binary_function_defs = Some(1000);
3732                    cfg.binary_field_handles = Some(500);
3733                    cfg.binary_field_instantiations = Some(250);
3734                    cfg.binary_friend_decls = Some(100);
3735                    // reduce dependencies maximum
3736                    cfg.max_package_dependencies = Some(32);
3737                    cfg.max_modules_in_publish = Some(64);
3738                    // bump execution version
3739                    cfg.execution_version = Some(3);
3740                }
3741                39 => {
3742                    // It is important that we keep this protocol version blank due to an issue with random.move.
3743                }
3744                40 => {}
3745                41 => {
3746                    // Enable group ops and all networks (but not msm)
3747                    cfg.feature_flags.enable_group_ops_native_functions = true;
3748                    // Next values are arbitrary in a similar way as the other crypto native functions.
3749                    cfg.group_ops_bls12381_decode_scalar_cost = Some(52);
3750                    cfg.group_ops_bls12381_decode_g1_cost = Some(52);
3751                    cfg.group_ops_bls12381_decode_g2_cost = Some(52);
3752                    cfg.group_ops_bls12381_decode_gt_cost = Some(52);
3753                    cfg.group_ops_bls12381_scalar_add_cost = Some(52);
3754                    cfg.group_ops_bls12381_g1_add_cost = Some(52);
3755                    cfg.group_ops_bls12381_g2_add_cost = Some(52);
3756                    cfg.group_ops_bls12381_gt_add_cost = Some(52);
3757                    cfg.group_ops_bls12381_scalar_sub_cost = Some(52);
3758                    cfg.group_ops_bls12381_g1_sub_cost = Some(52);
3759                    cfg.group_ops_bls12381_g2_sub_cost = Some(52);
3760                    cfg.group_ops_bls12381_gt_sub_cost = Some(52);
3761                    cfg.group_ops_bls12381_scalar_mul_cost = Some(52);
3762                    cfg.group_ops_bls12381_g1_mul_cost = Some(52);
3763                    cfg.group_ops_bls12381_g2_mul_cost = Some(52);
3764                    cfg.group_ops_bls12381_gt_mul_cost = Some(52);
3765                    cfg.group_ops_bls12381_scalar_div_cost = Some(52);
3766                    cfg.group_ops_bls12381_g1_div_cost = Some(52);
3767                    cfg.group_ops_bls12381_g2_div_cost = Some(52);
3768                    cfg.group_ops_bls12381_gt_div_cost = Some(52);
3769                    cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(52);
3770                    cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(52);
3771                    cfg.group_ops_bls12381_g1_hash_to_cost_per_byte = Some(2);
3772                    cfg.group_ops_bls12381_g2_hash_to_cost_per_byte = Some(2);
3773                    cfg.group_ops_bls12381_g1_msm_base_cost = Some(52);
3774                    cfg.group_ops_bls12381_g2_msm_base_cost = Some(52);
3775                    cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(52);
3776                    cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(52);
3777                    cfg.group_ops_bls12381_msm_max_len = Some(32);
3778                    cfg.group_ops_bls12381_pairing_cost = Some(52);
3779                }
3780                42 => {}
3781                43 => {
3782                    cfg.feature_flags.zklogin_max_epoch_upper_bound_delta = Some(30);
3783                    cfg.max_meter_ticks_per_package = Some(16_000_000);
3784                }
3785                44 => {
3786                    // Enable consensus digest in consensus commit prologue on all networks..
3787                    cfg.feature_flags.include_consensus_digest_in_prologue = true;
3788                    // Switch between Narwhal and Mysticeti per epoch in tests, devnet and testnet.
3789                    if chain != Chain::Mainnet {
3790                        cfg.feature_flags.consensus_choice = ConsensusChoice::SwapEachEpoch;
3791                    }
3792                }
3793                45 => {
3794                    // Use tonic networking for consensus, in tests and devnet.
3795                    if chain != Chain::Testnet && chain != Chain::Mainnet {
3796                        cfg.feature_flags.consensus_network = ConsensusNetwork::Tonic;
3797                    }
3798
3799                    if chain != Chain::Mainnet {
3800                        // Enable leader scoring & schedule change on testnet for mysticeti.
3801                        cfg.feature_flags.mysticeti_leader_scoring_and_schedule = true;
3802                    }
3803                    cfg.min_move_binary_format_version = Some(6);
3804                    cfg.feature_flags.accept_zklogin_in_multisig = true;
3805
3806                    // Also bumps framework snapshot to fix binop issue.
3807
3808                    // enable bridge in devnet
3809                    if chain != Chain::Mainnet && chain != Chain::Testnet {
3810                        cfg.feature_flags.bridge = true;
3811                    }
3812                }
3813                46 => {
3814                    // enable bridge in devnet and testnet
3815                    if chain != Chain::Mainnet {
3816                        cfg.feature_flags.bridge = true;
3817                    }
3818
3819                    // Enable resharing at same initial version
3820                    cfg.feature_flags.reshare_at_same_initial_version = true;
3821                }
3822                47 => {}
3823                48 => {
3824                    // Use tonic networking for Mysticeti.
3825                    cfg.feature_flags.consensus_network = ConsensusNetwork::Tonic;
3826
3827                    // Enable resolving abort code IDs to package ID instead of runtime module ID
3828                    cfg.feature_flags.resolve_abort_locations_to_package_id = true;
3829
3830                    // Enable random beacon on testnet.
3831                    if chain != Chain::Mainnet {
3832                        cfg.feature_flags.random_beacon = true;
3833                        cfg.random_beacon_reduction_lower_bound = Some(1600);
3834                        cfg.random_beacon_dkg_timeout_round = Some(3000);
3835                        cfg.random_beacon_min_round_interval_ms = Some(200);
3836                    }
3837
3838                    // Enable the committed sub dag digest inclusion on the commit output
3839                    cfg.feature_flags.mysticeti_use_committed_subdag_digest = true;
3840                }
3841                49 => {
3842                    if chain != Chain::Testnet && chain != Chain::Mainnet {
3843                        cfg.move_binary_format_version = Some(7);
3844                    }
3845
3846                    // enable vdf in devnet
3847                    if chain != Chain::Mainnet && chain != Chain::Testnet {
3848                        cfg.feature_flags.enable_vdf = true;
3849                        // Set to 30x and 2x the cost of a signature verification for now. This
3850                        // should be updated along with other native crypto functions.
3851                        cfg.vdf_verify_vdf_cost = Some(1500);
3852                        cfg.vdf_hash_to_input_cost = Some(100);
3853                    }
3854
3855                    // Only enable consensus commit prologue V3 in devnet.
3856                    if chain != Chain::Testnet && chain != Chain::Mainnet {
3857                        cfg.feature_flags
3858                            .record_consensus_determined_version_assignments_in_prologue = true;
3859                    }
3860
3861                    // Run Mysticeti consensus in testnet.
3862                    if chain != Chain::Mainnet {
3863                        cfg.feature_flags.consensus_choice = ConsensusChoice::Mysticeti;
3864                    }
3865
3866                    // Run Move verification on framework upgrades in its own VM
3867                    cfg.feature_flags.fresh_vm_on_framework_upgrade = true;
3868                }
3869                50 => {
3870                    // Enable checkpoint batching in testnet.
3871                    if chain != Chain::Mainnet {
3872                        cfg.checkpoint_summary_version_specific_data = Some(1);
3873                        cfg.min_checkpoint_interval_ms = Some(200);
3874                    }
3875
3876                    // Only enable prepose consensus commit prologue in checkpoints in devnet.
3877                    if chain != Chain::Testnet && chain != Chain::Mainnet {
3878                        cfg.feature_flags
3879                            .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3880                    }
3881
3882                    cfg.feature_flags.mysticeti_num_leaders_per_round = Some(1);
3883
3884                    // Set max transaction deferral to 10 consensus rounds.
3885                    cfg.max_deferral_rounds_for_congestion_control = Some(10);
3886                }
3887                51 => {
3888                    cfg.random_beacon_dkg_version = Some(1);
3889
3890                    if chain != Chain::Testnet && chain != Chain::Mainnet {
3891                        cfg.feature_flags.enable_coin_deny_list_v2 = true;
3892                    }
3893                }
3894                52 => {
3895                    if chain != Chain::Mainnet {
3896                        cfg.feature_flags.soft_bundle = true;
3897                        cfg.max_soft_bundle_size = Some(5);
3898                    }
3899
3900                    cfg.config_read_setting_impl_cost_base = Some(100);
3901                    cfg.config_read_setting_impl_cost_per_byte = Some(40);
3902
3903                    // Turn on shared object congestion control in devnet.
3904                    if chain != Chain::Testnet && chain != Chain::Mainnet {
3905                        cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3906                        cfg.feature_flags.per_object_congestion_control_mode =
3907                            PerObjectCongestionControlMode::TotalTxCount;
3908                    }
3909
3910                    // Enable Mysticeti on mainnet.
3911                    cfg.feature_flags.consensus_choice = ConsensusChoice::Mysticeti;
3912
3913                    // Enable leader scoring & schedule change on mainnet for mysticeti.
3914                    cfg.feature_flags.mysticeti_leader_scoring_and_schedule = true;
3915
3916                    // Enable checkpoint batching on mainnet.
3917                    cfg.checkpoint_summary_version_specific_data = Some(1);
3918                    cfg.min_checkpoint_interval_ms = Some(200);
3919
3920                    // Enable consensus commit prologue V3 in testnet.
3921                    if chain != Chain::Mainnet {
3922                        cfg.feature_flags
3923                            .record_consensus_determined_version_assignments_in_prologue = true;
3924                        cfg.feature_flags
3925                            .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3926                    }
3927                    // Turn on enums in testnet and devnet
3928                    if chain != Chain::Mainnet {
3929                        cfg.move_binary_format_version = Some(7);
3930                    }
3931
3932                    if chain != Chain::Testnet && chain != Chain::Mainnet {
3933                        cfg.feature_flags.passkey_auth = true;
3934                    }
3935                    cfg.feature_flags.enable_coin_deny_list_v2 = true;
3936                }
3937                53 => {
3938                    // Do not allow bridge committee to finalize on mainnet.
3939                    cfg.bridge_should_try_to_finalize_committee = Some(chain != Chain::Mainnet);
3940
3941                    // Enable consensus commit prologue V3 on mainnet.
3942                    cfg.feature_flags
3943                        .record_consensus_determined_version_assignments_in_prologue = true;
3944                    cfg.feature_flags
3945                        .prepend_prologue_tx_in_consensus_commit_in_checkpoints = true;
3946
3947                    if chain == Chain::Unknown {
3948                        cfg.feature_flags.authority_capabilities_v2 = true;
3949                    }
3950
3951                    // Turns on shared object congestion control on testnet.
3952                    if chain != Chain::Mainnet {
3953                        cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3954                        cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(10);
3955                        cfg.feature_flags.per_object_congestion_control_mode =
3956                            PerObjectCongestionControlMode::TotalTxCount;
3957                    }
3958
3959                    // Adjust stdlib gas costs
3960                    cfg.bcs_per_byte_serialized_cost = Some(2);
3961                    cfg.bcs_legacy_min_output_size_cost = Some(1);
3962                    cfg.bcs_failure_cost = Some(52);
3963                    cfg.debug_print_base_cost = Some(52);
3964                    cfg.debug_print_stack_trace_base_cost = Some(52);
3965                    cfg.hash_sha2_256_base_cost = Some(52);
3966                    cfg.hash_sha2_256_per_byte_cost = Some(2);
3967                    cfg.hash_sha2_256_legacy_min_input_len_cost = Some(1);
3968                    cfg.hash_sha3_256_base_cost = Some(52);
3969                    cfg.hash_sha3_256_per_byte_cost = Some(2);
3970                    cfg.hash_sha3_256_legacy_min_input_len_cost = Some(1);
3971                    cfg.type_name_get_base_cost = Some(52);
3972                    cfg.type_name_get_per_byte_cost = Some(2);
3973                    cfg.string_check_utf8_base_cost = Some(52);
3974                    cfg.string_check_utf8_per_byte_cost = Some(2);
3975                    cfg.string_is_char_boundary_base_cost = Some(52);
3976                    cfg.string_sub_string_base_cost = Some(52);
3977                    cfg.string_sub_string_per_byte_cost = Some(2);
3978                    cfg.string_index_of_base_cost = Some(52);
3979                    cfg.string_index_of_per_byte_pattern_cost = Some(2);
3980                    cfg.string_index_of_per_byte_searched_cost = Some(2);
3981                    cfg.vector_empty_base_cost = Some(52);
3982                    cfg.vector_length_base_cost = Some(52);
3983                    cfg.vector_push_back_base_cost = Some(52);
3984                    cfg.vector_push_back_legacy_per_abstract_memory_unit_cost = Some(2);
3985                    cfg.vector_borrow_base_cost = Some(52);
3986                    cfg.vector_pop_back_base_cost = Some(52);
3987                    cfg.vector_destroy_empty_base_cost = Some(52);
3988                    cfg.vector_swap_base_cost = Some(52);
3989                }
3990                54 => {
3991                    // Enable random beacon on mainnet.
3992                    cfg.feature_flags.random_beacon = true;
3993                    cfg.random_beacon_reduction_lower_bound = Some(1000);
3994                    cfg.random_beacon_dkg_timeout_round = Some(3000);
3995                    cfg.random_beacon_min_round_interval_ms = Some(500);
3996
3997                    // Turns on shared object congestion control on mainnet.
3998                    cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(100);
3999                    cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(10);
4000                    cfg.feature_flags.per_object_congestion_control_mode =
4001                        PerObjectCongestionControlMode::TotalTxCount;
4002
4003                    // Enable soft bundle on mainnet.
4004                    cfg.feature_flags.soft_bundle = true;
4005                    cfg.max_soft_bundle_size = Some(5);
4006                }
4007                55 => {
4008                    // Turn on enums mainnet
4009                    cfg.move_binary_format_version = Some(7);
4010
4011                    // Assume 1KB per transaction and 500 transactions per block.
4012                    cfg.consensus_max_transactions_in_block_bytes = Some(512 * 1024);
4013                    // Assume 20_000 TPS * 5% max stake per validator / (minimum) 4 blocks per round = 250 transactions per block maximum
4014                    // Using a higher limit that is 512, to account for bursty traffic and system transactions.
4015                    cfg.consensus_max_num_transactions_in_block = Some(512);
4016
4017                    cfg.feature_flags.rethrow_serialization_type_layout_errors = true;
4018                }
4019                56 => {
4020                    if chain == Chain::Mainnet {
4021                        cfg.feature_flags.bridge = true;
4022                    }
4023                }
4024                57 => {
4025                    // Reduce minimum number of random beacon shares.
4026                    cfg.random_beacon_reduction_lower_bound = Some(800);
4027                }
4028                58 => {
4029                    if chain == Chain::Mainnet {
4030                        cfg.bridge_should_try_to_finalize_committee = Some(true);
4031                    }
4032
4033                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4034                        // Enable distributed vote scoring for devnet
4035                        cfg.feature_flags
4036                            .consensus_distributed_vote_scoring_strategy = true;
4037                    }
4038                }
4039                59 => {
4040                    // Enable round prober in consensus.
4041                    cfg.feature_flags.consensus_round_prober = true;
4042                }
4043                60 => {
4044                    cfg.max_type_to_layout_nodes = Some(512);
4045                    cfg.feature_flags.validate_identifier_inputs = true;
4046                }
4047                61 => {
4048                    if chain != Chain::Mainnet {
4049                        // Enable distributed vote scoring for testnet
4050                        cfg.feature_flags
4051                            .consensus_distributed_vote_scoring_strategy = true;
4052                    }
4053                    // Further reduce minimum number of random beacon shares.
4054                    cfg.random_beacon_reduction_lower_bound = Some(700);
4055
4056                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4057                        // Enable Mysticeti fastpath for devnet
4058                        cfg.feature_flags.mysticeti_fastpath = true;
4059                    }
4060                }
4061                62 => {
4062                    cfg.feature_flags.relocate_event_module = true;
4063                }
4064                63 => {
4065                    cfg.feature_flags.per_object_congestion_control_mode =
4066                        PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4067                    cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4068                    cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(18_500_000);
4069                    cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(240_000_000);
4070                }
4071                64 => {
4072                    cfg.feature_flags.per_object_congestion_control_mode =
4073                        PerObjectCongestionControlMode::TotalTxCount;
4074                    cfg.max_accumulated_txn_cost_per_object_in_narwhal_commit = Some(40);
4075                    cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(3);
4076                }
4077                65 => {
4078                    // Enable distributed vote scoring for mainnet
4079                    cfg.feature_flags
4080                        .consensus_distributed_vote_scoring_strategy = true;
4081                }
4082                66 => {
4083                    if chain == Chain::Mainnet {
4084                        // Revert the distributed vote scoring for mainnet (for one protocol upgrade)
4085                        cfg.feature_flags
4086                            .consensus_distributed_vote_scoring_strategy = false;
4087                    }
4088                }
4089                67 => {
4090                    // Enable it once again.
4091                    cfg.feature_flags
4092                        .consensus_distributed_vote_scoring_strategy = true;
4093                }
4094                68 => {
4095                    cfg.group_ops_bls12381_g1_to_uncompressed_g1_cost = Some(26);
4096                    cfg.group_ops_bls12381_uncompressed_g1_to_g1_cost = Some(52);
4097                    cfg.group_ops_bls12381_uncompressed_g1_sum_base_cost = Some(26);
4098                    cfg.group_ops_bls12381_uncompressed_g1_sum_cost_per_term = Some(13);
4099                    cfg.group_ops_bls12381_uncompressed_g1_sum_max_terms = Some(2000);
4100
4101                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4102                        cfg.feature_flags.uncompressed_g1_group_elements = true;
4103                    }
4104
4105                    cfg.feature_flags.per_object_congestion_control_mode =
4106                        PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4107                    cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4108                    cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(18_500_000);
4109                    cfg.max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit =
4110                        Some(3_700_000); // 20% of above
4111                    cfg.max_txn_cost_overage_per_object_in_commit = Some(u64::MAX);
4112                    cfg.gas_budget_based_txn_cost_absolute_cap_commit_count = Some(50);
4113
4114                    // Further reduce minimum number of random beacon shares.
4115                    cfg.random_beacon_reduction_lower_bound = Some(500);
4116
4117                    cfg.feature_flags.disallow_new_modules_in_deps_only_packages = true;
4118                }
4119                69 => {
4120                    // Sets number of rounds allowed for fastpath voting in consensus.
4121                    cfg.consensus_voting_rounds = Some(40);
4122
4123                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4124                        // Enable smart ancestor selection for devnet
4125                        cfg.feature_flags.consensus_smart_ancestor_selection = true;
4126                    }
4127
4128                    if chain != Chain::Mainnet {
4129                        cfg.feature_flags.uncompressed_g1_group_elements = true;
4130                    }
4131                }
4132                70 => {
4133                    if chain != Chain::Mainnet {
4134                        // Enable smart ancestor selection for testnet
4135                        cfg.feature_flags.consensus_smart_ancestor_selection = true;
4136                        // Enable probing for accepted rounds in round prober for testnet
4137                        cfg.feature_flags
4138                            .consensus_round_prober_probe_accepted_rounds = true;
4139                    }
4140
4141                    cfg.poseidon_bn254_cost_per_block = Some(388);
4142
4143                    cfg.gas_model_version = Some(9);
4144                    cfg.feature_flags.native_charging_v2 = true;
4145                    cfg.bls12381_bls12381_min_sig_verify_cost_base = Some(44064);
4146                    cfg.bls12381_bls12381_min_pk_verify_cost_base = Some(49282);
4147                    cfg.ecdsa_k1_secp256k1_verify_keccak256_cost_base = Some(1470);
4148                    cfg.ecdsa_k1_secp256k1_verify_sha256_cost_base = Some(1470);
4149                    cfg.ecdsa_r1_secp256r1_verify_sha256_cost_base = Some(4225);
4150                    cfg.ecdsa_r1_secp256r1_verify_keccak256_cost_base = Some(4225);
4151                    cfg.ecvrf_ecvrf_verify_cost_base = Some(4848);
4152                    cfg.ed25519_ed25519_verify_cost_base = Some(1802);
4153
4154                    // Manually changed to be "under cost"
4155                    cfg.ecdsa_r1_ecrecover_keccak256_cost_base = Some(1173);
4156                    cfg.ecdsa_r1_ecrecover_sha256_cost_base = Some(1173);
4157                    cfg.ecdsa_k1_ecrecover_keccak256_cost_base = Some(500);
4158                    cfg.ecdsa_k1_ecrecover_sha256_cost_base = Some(500);
4159
4160                    cfg.groth16_prepare_verifying_key_bls12381_cost_base = Some(53838);
4161                    cfg.groth16_prepare_verifying_key_bn254_cost_base = Some(82010);
4162                    cfg.groth16_verify_groth16_proof_internal_bls12381_cost_base = Some(72090);
4163                    cfg.groth16_verify_groth16_proof_internal_bls12381_cost_per_public_input =
4164                        Some(8213);
4165                    cfg.groth16_verify_groth16_proof_internal_bn254_cost_base = Some(115502);
4166                    cfg.groth16_verify_groth16_proof_internal_bn254_cost_per_public_input =
4167                        Some(9484);
4168
4169                    cfg.hash_keccak256_cost_base = Some(10);
4170                    cfg.hash_blake2b256_cost_base = Some(10);
4171
4172                    // group ops
4173                    cfg.group_ops_bls12381_decode_scalar_cost = Some(7);
4174                    cfg.group_ops_bls12381_decode_g1_cost = Some(2848);
4175                    cfg.group_ops_bls12381_decode_g2_cost = Some(3770);
4176                    cfg.group_ops_bls12381_decode_gt_cost = Some(3068);
4177
4178                    cfg.group_ops_bls12381_scalar_add_cost = Some(10);
4179                    cfg.group_ops_bls12381_g1_add_cost = Some(1556);
4180                    cfg.group_ops_bls12381_g2_add_cost = Some(3048);
4181                    cfg.group_ops_bls12381_gt_add_cost = Some(188);
4182
4183                    cfg.group_ops_bls12381_scalar_sub_cost = Some(10);
4184                    cfg.group_ops_bls12381_g1_sub_cost = Some(1550);
4185                    cfg.group_ops_bls12381_g2_sub_cost = Some(3019);
4186                    cfg.group_ops_bls12381_gt_sub_cost = Some(497);
4187
4188                    cfg.group_ops_bls12381_scalar_mul_cost = Some(11);
4189                    cfg.group_ops_bls12381_g1_mul_cost = Some(4842);
4190                    cfg.group_ops_bls12381_g2_mul_cost = Some(9108);
4191                    cfg.group_ops_bls12381_gt_mul_cost = Some(27490);
4192
4193                    cfg.group_ops_bls12381_scalar_div_cost = Some(91);
4194                    cfg.group_ops_bls12381_g1_div_cost = Some(5091);
4195                    cfg.group_ops_bls12381_g2_div_cost = Some(9206);
4196                    cfg.group_ops_bls12381_gt_div_cost = Some(27804);
4197
4198                    cfg.group_ops_bls12381_g1_hash_to_base_cost = Some(2962);
4199                    cfg.group_ops_bls12381_g2_hash_to_base_cost = Some(8688);
4200
4201                    cfg.group_ops_bls12381_g1_msm_base_cost = Some(62648);
4202                    cfg.group_ops_bls12381_g2_msm_base_cost = Some(131192);
4203                    cfg.group_ops_bls12381_g1_msm_base_cost_per_input = Some(1333);
4204                    cfg.group_ops_bls12381_g2_msm_base_cost_per_input = Some(3216);
4205
4206                    cfg.group_ops_bls12381_uncompressed_g1_to_g1_cost = Some(677);
4207                    cfg.group_ops_bls12381_g1_to_uncompressed_g1_cost = Some(2099);
4208                    cfg.group_ops_bls12381_uncompressed_g1_sum_base_cost = Some(77);
4209                    cfg.group_ops_bls12381_uncompressed_g1_sum_cost_per_term = Some(26);
4210
4211                    cfg.group_ops_bls12381_pairing_cost = Some(26897);
4212                    cfg.group_ops_bls12381_uncompressed_g1_sum_max_terms = Some(1200);
4213
4214                    cfg.validator_validate_metadata_cost_base = Some(20000);
4215                }
4216                71 => {
4217                    cfg.sip_45_consensus_amplification_threshold = Some(5);
4218
4219                    // Enable bursts for congestion control. (10x the per-commit budget)
4220                    cfg.allowed_txn_cost_overage_burst_per_object_in_commit = Some(185_000_000);
4221                }
4222                72 => {
4223                    cfg.feature_flags.convert_type_argument_error = true;
4224
4225                    // Invariant: max_gas_price * base_tx_cost_fixed <= max_tx_gas
4226                    // max gas budget is in MIST and an absolute value 50_000 SUI
4227                    cfg.max_tx_gas = Some(50_000_000_000_000);
4228                    // max gas price is in MIST and an absolute value 50 SUI
4229                    cfg.max_gas_price = Some(50_000_000_000);
4230
4231                    cfg.feature_flags.variant_nodes = true;
4232                }
4233                73 => {
4234                    // Enable new marker table version.
4235                    cfg.use_object_per_epoch_marker_table_v2 = Some(true);
4236
4237                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4238                        // Assuming a round rate of max 15/sec, then using a gc depth of 60 allow blocks within a window of ~4 seconds
4239                        // to be included before be considered garbage collected.
4240                        cfg.consensus_gc_depth = Some(60);
4241                    }
4242
4243                    if chain != Chain::Mainnet {
4244                        // Enable zstd compression for consensus in testnet
4245                        cfg.feature_flags.consensus_zstd_compression = true;
4246                    }
4247
4248                    // Enable smart ancestor selection for mainnet
4249                    cfg.feature_flags.consensus_smart_ancestor_selection = true;
4250                    // Enable probing for accepted rounds in round prober for mainnet
4251                    cfg.feature_flags
4252                        .consensus_round_prober_probe_accepted_rounds = true;
4253
4254                    // Increase congestion control budget.
4255                    cfg.feature_flags.per_object_congestion_control_mode =
4256                        PerObjectCongestionControlMode::TotalGasBudgetWithCap;
4257                    cfg.gas_budget_based_txn_cost_cap_factor = Some(400_000);
4258                    cfg.max_accumulated_txn_cost_per_object_in_mysticeti_commit = Some(37_000_000);
4259                    cfg.max_accumulated_randomness_txn_cost_per_object_in_mysticeti_commit =
4260                        Some(7_400_000); // 20% of above
4261                    cfg.max_txn_cost_overage_per_object_in_commit = Some(u64::MAX);
4262                    cfg.gas_budget_based_txn_cost_absolute_cap_commit_count = Some(50);
4263                    cfg.allowed_txn_cost_overage_burst_per_object_in_commit = Some(370_000_000);
4264                }
4265                74 => {
4266                    // Enable nitro attestation verify native move function for devnet
4267                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4268                        cfg.feature_flags.enable_nitro_attestation = true;
4269                    }
4270                    cfg.nitro_attestation_parse_base_cost = Some(53 * 50);
4271                    cfg.nitro_attestation_parse_cost_per_byte = Some(50);
4272                    cfg.nitro_attestation_verify_base_cost = Some(49632 * 50);
4273                    cfg.nitro_attestation_verify_cost_per_cert = Some(52369 * 50);
4274
4275                    // Enable zstd compression for consensus in mainnet
4276                    cfg.feature_flags.consensus_zstd_compression = true;
4277
4278                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4279                        cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4280                    }
4281                }
4282                75 => {
4283                    if chain != Chain::Mainnet {
4284                        cfg.feature_flags.passkey_auth = true;
4285                    }
4286                }
4287                76 => {
4288                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4289                        cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4290                        cfg.consensus_commit_rate_estimation_window_size = Some(10);
4291                    }
4292                    cfg.feature_flags.minimize_child_object_mutations = true;
4293
4294                    if chain != Chain::Mainnet {
4295                        cfg.feature_flags.accept_passkey_in_multisig = true;
4296                    }
4297                }
4298                77 => {
4299                    cfg.feature_flags.uncompressed_g1_group_elements = true;
4300
4301                    if chain != Chain::Mainnet {
4302                        cfg.consensus_gc_depth = Some(60);
4303                        cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4304                    }
4305                }
4306                78 => {
4307                    cfg.feature_flags.move_native_context = true;
4308                    cfg.tx_context_fresh_id_cost_base = Some(52);
4309                    cfg.tx_context_sender_cost_base = Some(30);
4310                    cfg.tx_context_epoch_cost_base = Some(30);
4311                    cfg.tx_context_epoch_timestamp_ms_cost_base = Some(30);
4312                    cfg.tx_context_sponsor_cost_base = Some(30);
4313                    cfg.tx_context_gas_price_cost_base = Some(30);
4314                    cfg.tx_context_gas_budget_cost_base = Some(30);
4315                    cfg.tx_context_ids_created_cost_base = Some(30);
4316                    cfg.tx_context_replace_cost_base = Some(30);
4317                    cfg.gas_model_version = Some(10);
4318
4319                    if chain != Chain::Mainnet {
4320                        cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4321                        cfg.consensus_commit_rate_estimation_window_size = Some(10);
4322
4323                        // Enable execution time estimate mode for congestion control on testnet.
4324                        cfg.feature_flags.per_object_congestion_control_mode =
4325                            PerObjectCongestionControlMode::ExecutionTimeEstimate(
4326                                ExecutionTimeEstimateParams {
4327                                    target_utilization: 30,
4328                                    allowed_txn_cost_overage_burst_limit_us: 100_000, // 100 ms
4329                                    randomness_scalar: 20,
4330                                    max_estimate_us: 1_500_000, // 1.5s
4331                                    stored_observations_num_included_checkpoints: 10,
4332                                    stored_observations_limit: u64::MAX,
4333                                    stake_weighted_median_threshold: 0,
4334                                    default_none_duration_for_new_keys: false,
4335                                    observations_chunk_size: None,
4336                                },
4337                            );
4338                    }
4339                }
4340                79 => {
4341                    if chain != Chain::Mainnet {
4342                        cfg.feature_flags.consensus_median_based_commit_timestamp = true;
4343
4344                        // Increase threshold for bad nodes that won't be considered
4345                        // leaders in consensus in testnet
4346                        cfg.consensus_bad_nodes_stake_threshold = Some(30);
4347
4348                        cfg.feature_flags.consensus_batched_block_sync = true;
4349
4350                        // Enable verify nitro attestation in testnet.
4351                        cfg.feature_flags.enable_nitro_attestation = true
4352                    }
4353                    cfg.feature_flags.normalize_ptb_arguments = true;
4354
4355                    cfg.consensus_gc_depth = Some(60);
4356                    cfg.feature_flags.consensus_linearize_subdag_v2 = true;
4357                }
4358                80 => {
4359                    cfg.max_ptb_value_size = Some(1024 * 1024);
4360                }
4361                81 => {
4362                    cfg.feature_flags.consensus_median_based_commit_timestamp = true;
4363                    cfg.feature_flags.enforce_checkpoint_timestamp_monotonicity = true;
4364                    cfg.consensus_bad_nodes_stake_threshold = Some(30)
4365                }
4366                82 => {
4367                    cfg.feature_flags.max_ptb_value_size_v2 = true;
4368                }
4369                83 => {
4370                    if chain == Chain::Mainnet {
4371                        // The address that will sign the recovery transaction.
4372                        let aliased: [u8; 32] = Hex::decode(
4373                            "0x0b2da327ba6a4cacbe75dddd50e6e8bbf81d6496e92d66af9154c61c77f7332f",
4374                        )
4375                        .unwrap()
4376                        .try_into()
4377                        .unwrap();
4378
4379                        // Allow aliasing for the two addresses that contain stolen funds.
4380                        cfg.aliased_addresses.push(AliasedAddress {
4381                            original: Hex::decode("0xcd8962dad278d8b50fa0f9eb0186bfa4cbdecc6d59377214c88d0286a0ac9562").unwrap().try_into().unwrap(),
4382                            aliased,
4383                            allowed_tx_digests: vec![
4384                                Base58::decode("B2eGLFoMHgj93Ni8dAJBfqGzo8EWSTLBesZzhEpTPA4").unwrap().try_into().unwrap(),
4385                            ],
4386                        });
4387
4388                        cfg.aliased_addresses.push(AliasedAddress {
4389                            original: Hex::decode("0xe28b50cef1d633ea43d3296a3f6b67ff0312a5f1a99f0af753c85b8b5de8ff06").unwrap().try_into().unwrap(),
4390                            aliased,
4391                            allowed_tx_digests: vec![
4392                                Base58::decode("J4QqSAgp7VrQtQpMy5wDX4QGsCSEZu3U5KuDAkbESAge").unwrap().try_into().unwrap(),
4393                            ],
4394                        });
4395                    }
4396
4397                    // These features had to be deferred to v84 for mainnet in order to ship the recovery protocol
4398                    // upgrade as a patch to 1.48
4399                    if chain != Chain::Mainnet {
4400                        cfg.feature_flags.resolve_type_input_ids_to_defining_id = true;
4401                        cfg.transfer_party_transfer_internal_cost_base = Some(52);
4402
4403                        // Enable execution time estimate mode for congestion control on mainnet.
4404                        cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4405                        cfg.consensus_commit_rate_estimation_window_size = Some(10);
4406                        cfg.feature_flags.per_object_congestion_control_mode =
4407                            PerObjectCongestionControlMode::ExecutionTimeEstimate(
4408                                ExecutionTimeEstimateParams {
4409                                    target_utilization: 30,
4410                                    allowed_txn_cost_overage_burst_limit_us: 100_000, // 100 ms
4411                                    randomness_scalar: 20,
4412                                    max_estimate_us: 1_500_000, // 1.5s
4413                                    stored_observations_num_included_checkpoints: 10,
4414                                    stored_observations_limit: u64::MAX,
4415                                    stake_weighted_median_threshold: 0,
4416                                    default_none_duration_for_new_keys: false,
4417                                    observations_chunk_size: None,
4418                                },
4419                            );
4420
4421                        // Enable the new depth-first block sync logic.
4422                        cfg.feature_flags.consensus_batched_block_sync = true;
4423
4424                        // Enable nitro attestation upgraded parsing logic and enable the
4425                        // native function on mainnet.
4426                        cfg.feature_flags.enable_nitro_attestation_upgraded_parsing = true;
4427                        cfg.feature_flags.enable_nitro_attestation = true;
4428                    }
4429                }
4430                84 => {
4431                    if chain == Chain::Mainnet {
4432                        cfg.feature_flags.resolve_type_input_ids_to_defining_id = true;
4433                        cfg.transfer_party_transfer_internal_cost_base = Some(52);
4434
4435                        // Enable execution time estimate mode for congestion control on mainnet.
4436                        cfg.feature_flags.record_additional_state_digest_in_prologue = true;
4437                        cfg.consensus_commit_rate_estimation_window_size = Some(10);
4438                        cfg.feature_flags.per_object_congestion_control_mode =
4439                            PerObjectCongestionControlMode::ExecutionTimeEstimate(
4440                                ExecutionTimeEstimateParams {
4441                                    target_utilization: 30,
4442                                    allowed_txn_cost_overage_burst_limit_us: 100_000, // 100 ms
4443                                    randomness_scalar: 20,
4444                                    max_estimate_us: 1_500_000, // 1.5s
4445                                    stored_observations_num_included_checkpoints: 10,
4446                                    stored_observations_limit: u64::MAX,
4447                                    stake_weighted_median_threshold: 0,
4448                                    default_none_duration_for_new_keys: false,
4449                                    observations_chunk_size: None,
4450                                },
4451                            );
4452
4453                        // Enable the new depth-first block sync logic.
4454                        cfg.feature_flags.consensus_batched_block_sync = true;
4455
4456                        // Enable nitro attestation upgraded parsing logic and enable the
4457                        // native function on mainnet.
4458                        cfg.feature_flags.enable_nitro_attestation_upgraded_parsing = true;
4459                        cfg.feature_flags.enable_nitro_attestation = true;
4460                    }
4461
4462                    // Limit the number of stored execution time observations at end of epoch.
4463                    cfg.feature_flags.per_object_congestion_control_mode =
4464                        PerObjectCongestionControlMode::ExecutionTimeEstimate(
4465                            ExecutionTimeEstimateParams {
4466                                target_utilization: 30,
4467                                allowed_txn_cost_overage_burst_limit_us: 100_000, // 100 ms
4468                                randomness_scalar: 20,
4469                                max_estimate_us: 1_500_000, // 1.5s
4470                                stored_observations_num_included_checkpoints: 10,
4471                                stored_observations_limit: 20,
4472                                stake_weighted_median_threshold: 0,
4473                                default_none_duration_for_new_keys: false,
4474                                observations_chunk_size: None,
4475                            },
4476                        );
4477                    cfg.feature_flags.allow_unbounded_system_objects = true;
4478                }
4479                85 => {
4480                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4481                        cfg.feature_flags.enable_party_transfer = true;
4482                    }
4483
4484                    cfg.feature_flags
4485                        .record_consensus_determined_version_assignments_in_prologue_v2 = true;
4486                    cfg.feature_flags.disallow_self_identifier = true;
4487                    cfg.feature_flags.per_object_congestion_control_mode =
4488                        PerObjectCongestionControlMode::ExecutionTimeEstimate(
4489                            ExecutionTimeEstimateParams {
4490                                target_utilization: 50,
4491                                allowed_txn_cost_overage_burst_limit_us: 500_000, // 500 ms
4492                                randomness_scalar: 20,
4493                                max_estimate_us: 1_500_000, // 1.5s
4494                                stored_observations_num_included_checkpoints: 10,
4495                                stored_observations_limit: 20,
4496                                stake_weighted_median_threshold: 0,
4497                                default_none_duration_for_new_keys: false,
4498                                observations_chunk_size: None,
4499                            },
4500                        );
4501                }
4502                86 => {
4503                    cfg.feature_flags.type_tags_in_object_runtime = true;
4504                    cfg.max_move_enum_variants = Some(move_core_types::VARIANT_COUNT_MAX);
4505
4506                    // Set a stake_weighted_median_threshold for congestion control.
4507                    cfg.feature_flags.per_object_congestion_control_mode =
4508                        PerObjectCongestionControlMode::ExecutionTimeEstimate(
4509                            ExecutionTimeEstimateParams {
4510                                target_utilization: 50,
4511                                allowed_txn_cost_overage_burst_limit_us: 500_000, // 500 ms
4512                                randomness_scalar: 20,
4513                                max_estimate_us: 1_500_000, // 1.5s
4514                                stored_observations_num_included_checkpoints: 10,
4515                                stored_observations_limit: 20,
4516                                stake_weighted_median_threshold: 3334,
4517                                default_none_duration_for_new_keys: false,
4518                                observations_chunk_size: None,
4519                            },
4520                        );
4521                    // Enable party transfer for testnet.
4522                    if chain != Chain::Mainnet {
4523                        cfg.feature_flags.enable_party_transfer = true;
4524                    }
4525                }
4526                87 => {
4527                    if chain == Chain::Mainnet {
4528                        cfg.feature_flags.record_time_estimate_processed = true;
4529                    }
4530                    cfg.feature_flags.better_adapter_type_resolution_errors = true;
4531                }
4532                88 => {
4533                    cfg.feature_flags.record_time_estimate_processed = true;
4534                    cfg.tx_context_rgp_cost_base = Some(30);
4535                    cfg.feature_flags
4536                        .ignore_execution_time_observations_after_certs_closed = true;
4537
4538                    // Disable backwards compatible behavior in execution time estimator for
4539                    // new protocol version.
4540                    cfg.feature_flags.per_object_congestion_control_mode =
4541                        PerObjectCongestionControlMode::ExecutionTimeEstimate(
4542                            ExecutionTimeEstimateParams {
4543                                target_utilization: 50,
4544                                allowed_txn_cost_overage_burst_limit_us: 500_000, // 500 ms
4545                                randomness_scalar: 20,
4546                                max_estimate_us: 1_500_000, // 1.5s
4547                                stored_observations_num_included_checkpoints: 10,
4548                                stored_observations_limit: 20,
4549                                stake_weighted_median_threshold: 3334,
4550                                default_none_duration_for_new_keys: true,
4551                                observations_chunk_size: None,
4552                            },
4553                        );
4554                }
4555                89 => {
4556                    cfg.feature_flags.dependency_linkage_error = true;
4557                    cfg.feature_flags.additional_multisig_checks = true;
4558                }
4559                90 => {
4560                    // 100x RGP
4561                    cfg.max_gas_price_rgp_factor_for_aborted_transactions = Some(100);
4562                    cfg.feature_flags.debug_fatal_on_move_invariant_violation = true;
4563                    cfg.feature_flags.additional_consensus_digest_indirect_state = true;
4564                    cfg.feature_flags.accept_passkey_in_multisig = true;
4565                    cfg.feature_flags.passkey_auth = true;
4566                    cfg.feature_flags.check_for_init_during_upgrade = true;
4567
4568                    // Enable Mysticeti fastpath handlers on testnet.
4569                    if chain != Chain::Mainnet {
4570                        cfg.feature_flags.mysticeti_fastpath = true;
4571                    }
4572                }
4573                91 => {
4574                    cfg.feature_flags.per_command_shared_object_transfer_rules = true;
4575                }
4576                92 => {
4577                    cfg.feature_flags.per_command_shared_object_transfer_rules = false;
4578                }
4579                93 => {
4580                    cfg.feature_flags
4581                        .consensus_checkpoint_signature_key_includes_digest = true;
4582                }
4583                94 => {
4584                    // Decrease stored observations limit 20->18 to stay within system object size limit.
4585                    cfg.feature_flags.per_object_congestion_control_mode =
4586                        PerObjectCongestionControlMode::ExecutionTimeEstimate(
4587                            ExecutionTimeEstimateParams {
4588                                target_utilization: 50,
4589                                allowed_txn_cost_overage_burst_limit_us: 500_000, // 500 ms
4590                                randomness_scalar: 20,
4591                                max_estimate_us: 1_500_000, // 1.5s
4592                                stored_observations_num_included_checkpoints: 10,
4593                                stored_observations_limit: 18,
4594                                stake_weighted_median_threshold: 3334,
4595                                default_none_duration_for_new_keys: true,
4596                                observations_chunk_size: None,
4597                            },
4598                        );
4599
4600                    // Enable party transfer on mainnet.
4601                    cfg.feature_flags.enable_party_transfer = true;
4602                }
4603                95 => {
4604                    cfg.type_name_id_base_cost = Some(52);
4605
4606                    // Reduce the frequency of checkpoint splitting under high TPS.
4607                    cfg.max_transactions_per_checkpoint = Some(20_000);
4608                }
4609                96 => {
4610                    // Enable artifacts digest in devnet.
4611                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4612                        cfg.feature_flags
4613                            .include_checkpoint_artifacts_digest_in_summary = true;
4614                    }
4615                    cfg.feature_flags.correct_gas_payment_limit_check = true;
4616                    cfg.feature_flags.authority_capabilities_v2 = true;
4617                    cfg.feature_flags.use_mfp_txns_in_load_initial_object_debts = true;
4618                    cfg.feature_flags.cancel_for_failed_dkg_early = true;
4619                    cfg.feature_flags.enable_coin_registry = true;
4620
4621                    // Enable Mysticeti fastpath handlers on mainnet.
4622                    cfg.feature_flags.mysticeti_fastpath = true;
4623                }
4624                97 => {
4625                    cfg.feature_flags.additional_borrow_checks = true;
4626                }
4627                98 => {
4628                    cfg.event_emit_auth_stream_cost = Some(52);
4629                    cfg.feature_flags.better_loader_errors = true;
4630                    cfg.feature_flags.generate_df_type_layouts = true;
4631                }
4632                99 => {
4633                    cfg.feature_flags.use_new_commit_handler = true;
4634                }
4635                100 => {
4636                    cfg.feature_flags.private_generics_verifier_v2 = true;
4637                }
4638                101 => {
4639                    cfg.feature_flags.create_root_accumulator_object = true;
4640                    cfg.max_updates_per_settlement_txn = Some(100);
4641                    if chain != Chain::Mainnet {
4642                        cfg.feature_flags.enable_poseidon = true;
4643                    }
4644                }
4645                102 => {
4646                    // Enable execution time observation chunking and increase limit to 180.
4647                    // max_move_object_size is 250 KB, we've experientially determined that fits ~ 18 estimates
4648                    // so if we have 10 chunks, that's 2.5MB, < 8MB max_serialized_tx_effects_size_bytes_system_tx
4649                    cfg.feature_flags.per_object_congestion_control_mode =
4650                        PerObjectCongestionControlMode::ExecutionTimeEstimate(
4651                            ExecutionTimeEstimateParams {
4652                                target_utilization: 50,
4653                                allowed_txn_cost_overage_burst_limit_us: 500_000, // 500 ms
4654                                randomness_scalar: 20,
4655                                max_estimate_us: 1_500_000, // 1.5s
4656                                stored_observations_num_included_checkpoints: 10,
4657                                stored_observations_limit: 180,
4658                                stake_weighted_median_threshold: 3334,
4659                                default_none_duration_for_new_keys: true,
4660                                observations_chunk_size: Some(18),
4661                            },
4662                        );
4663                    cfg.feature_flags.deprecate_global_storage_ops = true;
4664                }
4665                103 => {}
4666                104 => {
4667                    cfg.translation_per_command_base_charge = Some(1);
4668                    cfg.translation_per_input_base_charge = Some(1);
4669                    cfg.translation_pure_input_per_byte_charge = Some(1);
4670                    cfg.translation_per_type_node_charge = Some(1);
4671                    cfg.translation_per_reference_node_charge = Some(1);
4672                    cfg.translation_per_linkage_entry_charge = Some(10);
4673                    cfg.gas_model_version = Some(11);
4674                    cfg.feature_flags.abstract_size_in_object_runtime = true;
4675                    cfg.feature_flags.object_runtime_charge_cache_load_gas = true;
4676                    cfg.dynamic_field_hash_type_and_key_cost_base = Some(52);
4677                    cfg.dynamic_field_add_child_object_cost_base = Some(52);
4678                    cfg.dynamic_field_add_child_object_value_cost_per_byte = Some(1);
4679                    cfg.dynamic_field_borrow_child_object_cost_base = Some(52);
4680                    cfg.dynamic_field_borrow_child_object_child_ref_cost_per_byte = Some(1);
4681                    cfg.dynamic_field_remove_child_object_cost_base = Some(52);
4682                    cfg.dynamic_field_remove_child_object_child_cost_per_byte = Some(1);
4683                    cfg.dynamic_field_has_child_object_cost_base = Some(52);
4684                    cfg.dynamic_field_has_child_object_with_ty_cost_base = Some(52);
4685                    cfg.feature_flags.enable_ptb_execution_v2 = true;
4686
4687                    cfg.poseidon_bn254_cost_base = Some(260);
4688
4689                    cfg.feature_flags.consensus_skip_gced_accept_votes = true;
4690
4691                    if chain != Chain::Mainnet {
4692                        cfg.feature_flags
4693                            .enable_nitro_attestation_all_nonzero_pcrs_parsing = true;
4694                    }
4695
4696                    cfg.feature_flags
4697                        .include_cancelled_randomness_txns_in_prologue = true;
4698                }
4699                105 => {
4700                    cfg.feature_flags.enable_multi_epoch_transaction_expiration = true;
4701                    cfg.feature_flags.disable_preconsensus_locking = true;
4702
4703                    if chain != Chain::Mainnet {
4704                        cfg.feature_flags
4705                            .enable_nitro_attestation_always_include_required_pcrs_parsing = true;
4706                    }
4707                }
4708                106 => {
4709                    // est. 100 bytes per object * 76 (storage_gas_price)
4710                    cfg.accumulator_object_storage_cost = Some(7600);
4711
4712                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4713                        cfg.feature_flags.enable_accumulators = true;
4714                        cfg.feature_flags.enable_address_balance_gas_payments = true;
4715                        cfg.feature_flags.enable_authenticated_event_streams = true;
4716                        cfg.feature_flags.enable_object_funds_withdraw = true;
4717                    }
4718                }
4719                107 => {
4720                    cfg.feature_flags
4721                        .consensus_skip_gced_blocks_in_direct_finalization = true;
4722
4723                    // Trigger edge cases more often in integration tests.
4724                    if in_integration_test() {
4725                        cfg.consensus_gc_depth = Some(6);
4726                        cfg.consensus_max_num_transactions_in_block = Some(8);
4727                    }
4728                }
4729                108 => {
4730                    cfg.feature_flags.gas_rounding_halve_digits = true;
4731                    cfg.feature_flags.flexible_tx_context_positions = true;
4732                    cfg.feature_flags.disable_entry_point_signature_check = true;
4733
4734                    if chain != Chain::Mainnet {
4735                        cfg.feature_flags.address_aliases = true;
4736
4737                        cfg.feature_flags.enable_accumulators = true;
4738                        cfg.feature_flags.enable_address_balance_gas_payments = true;
4739                    }
4740
4741                    cfg.feature_flags.enable_poseidon = true;
4742                }
4743                109 => {
4744                    cfg.binary_variant_handles = Some(1024);
4745                    cfg.binary_variant_instantiation_handles = Some(1024);
4746                    cfg.feature_flags.restrict_hot_or_not_entry_functions = true;
4747                }
4748                110 => {
4749                    cfg.feature_flags
4750                        .enable_nitro_attestation_all_nonzero_pcrs_parsing = true;
4751                    cfg.feature_flags
4752                        .enable_nitro_attestation_always_include_required_pcrs_parsing = true;
4753                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4754                        cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4755                    }
4756                    cfg.feature_flags.validate_zklogin_public_identifier = true;
4757                    cfg.feature_flags.fix_checkpoint_signature_mapping = true;
4758                    cfg.feature_flags
4759                        .consensus_always_accept_system_transactions = true;
4760                    if chain != Chain::Mainnet {
4761                        cfg.feature_flags.enable_object_funds_withdraw = true;
4762                    }
4763                }
4764                111 => {
4765                    cfg.feature_flags.validator_metadata_verify_v2 = true;
4766                }
4767                112 => {
4768                    cfg.group_ops_ristretto_decode_scalar_cost = Some(7);
4769                    cfg.group_ops_ristretto_decode_point_cost = Some(200);
4770                    cfg.group_ops_ristretto_scalar_add_cost = Some(10);
4771                    cfg.group_ops_ristretto_point_add_cost = Some(500);
4772                    cfg.group_ops_ristretto_scalar_sub_cost = Some(10);
4773                    cfg.group_ops_ristretto_point_sub_cost = Some(500);
4774                    cfg.group_ops_ristretto_scalar_mul_cost = Some(11);
4775                    cfg.group_ops_ristretto_point_mul_cost = Some(1200);
4776                    cfg.group_ops_ristretto_scalar_div_cost = Some(151);
4777                    cfg.group_ops_ristretto_point_div_cost = Some(2500);
4778
4779                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4780                        cfg.feature_flags.enable_ristretto255_group_ops = true;
4781                    }
4782                }
4783                113 => {
4784                    cfg.feature_flags.address_balance_gas_check_rgp_at_signing = true;
4785                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4786                        cfg.feature_flags.defer_unpaid_amplification = true;
4787                    }
4788                }
4789                114 => {
4790                    cfg.feature_flags.randomize_checkpoint_tx_limit_in_tests = true;
4791                    cfg.feature_flags.address_balance_gas_reject_gas_coin_arg = true;
4792                    if chain != Chain::Mainnet {
4793                        cfg.feature_flags.split_checkpoints_in_consensus_handler = true;
4794                        cfg.feature_flags.enable_authenticated_event_streams = true;
4795                        cfg.feature_flags
4796                            .include_checkpoint_artifacts_digest_in_summary = true;
4797                    }
4798                }
4799                115 => {
4800                    cfg.feature_flags.normalize_depth_formula = true;
4801                }
4802                116 => {
4803                    cfg.feature_flags.gasless_transaction_drop_safety = true;
4804                    cfg.feature_flags.address_aliases = true;
4805                    cfg.feature_flags.relax_valid_during_for_owned_inputs = true;
4806                    // Disabled while debugging
4807                    cfg.feature_flags.defer_unpaid_amplification = false;
4808                    cfg.feature_flags.enable_display_registry = true;
4809                }
4810                117 => {}
4811                118 => {
4812                    cfg.feature_flags.use_coin_party_owner = true;
4813                }
4814                119 => {
4815                    // Enable new VM.
4816                    cfg.execution_version = Some(4);
4817                    cfg.feature_flags.address_balance_gas_reject_gas_coin_arg = false;
4818                    cfg.feature_flags.merge_randomness_into_checkpoint = true;
4819                    if chain != Chain::Mainnet {
4820                        cfg.feature_flags.enable_gasless = true;
4821                        cfg.gasless_max_computation_units = Some(50_000);
4822                        cfg.gasless_allowed_token_types = Some(vec![]);
4823                        cfg.feature_flags.enable_coin_reservation_obj_refs = true;
4824                        cfg.feature_flags
4825                            .convert_withdrawal_compatibility_ptb_arguments = true;
4826                    }
4827                    cfg.gasless_max_unused_inputs = Some(1);
4828                    cfg.gasless_max_pure_input_bytes = Some(32);
4829                    if chain == Chain::Testnet {
4830                        cfg.gasless_allowed_token_types = Some(vec![(TESTNET_USDC.to_string(), 0)]);
4831                    }
4832                    cfg.transfer_receive_object_cost_per_byte = Some(1);
4833                    cfg.transfer_receive_object_type_cost_per_byte = Some(2);
4834                }
4835                120 => {
4836                    cfg.feature_flags.disallow_jump_orphans = true;
4837                }
4838                121 => {
4839                    // Re-enable unpaid amplification deferral protection (testnet + devnet)
4840                    if chain != Chain::Mainnet {
4841                        cfg.feature_flags.defer_unpaid_amplification = true;
4842                        cfg.gasless_max_tps = Some(50);
4843                    }
4844                    cfg.feature_flags
4845                        .early_return_receive_object_mismatched_type = true;
4846                }
4847                122 => {
4848                    // Enable bulletproofs range proofs on devnet
4849                    cfg.verify_bulletproofs_ristretto255_base_cost = Some(30000);
4850                    cfg.verify_bulletproofs_ristretto255_cost_per_bit_and_commitment = Some(6500);
4851                    if chain != Chain::Mainnet && chain != Chain::Testnet {
4852                        cfg.feature_flags.enable_verify_bulletproofs_ristretto255 = true;
4853                    }
4854                    cfg.feature_flags.gasless_verify_remaining_balance = true;
4855                    cfg.include_special_package_amendments = match chain {
4856                        Chain::Mainnet => Some(MAINNET_LINKAGE_AMENDMENTS.clone()),
4857                        Chain::Testnet => Some(TESTNET_LINKAGE_AMENDMENTS.clone()),
4858                        Chain::Unknown => None,
4859                    };
4860                    cfg.gasless_max_tx_size_bytes = Some(16 * 1024);
4861                    cfg.gasless_max_tps = Some(300);
4862                    cfg.gasless_max_computation_units = Some(5_000);
4863                }
4864                // Use this template when making changes:
4865                //
4866                //     // modify an existing constant.
4867                //     move_binary_format_version: Some(7),
4868                //
4869                //     // Add a new constant (which is set to None in prior versions).
4870                //     new_constant: Some(new_value),
4871                //
4872                //     // Remove a constant (ensure that it is never accessed during this version).
4873                //     max_move_object_size: None,
4874                _ => panic!("unsupported version {:?}", version),
4875            }
4876        }
4877
4878        cfg
4879    }
4880
4881    pub fn apply_seeded_test_overrides(&mut self, seed: &[u8; 32]) {
4882        if !self.feature_flags.randomize_checkpoint_tx_limit_in_tests
4883            || !self.feature_flags.split_checkpoints_in_consensus_handler
4884        {
4885            return;
4886        }
4887
4888        if !mysten_common::in_test_configuration() {
4889            return;
4890        }
4891
4892        use rand::{Rng, SeedableRng, rngs::StdRng};
4893        let mut rng = StdRng::from_seed(*seed);
4894        let max_txns = rng.gen_range(10..=100u64);
4895        info!("seeded test override: max_transactions_per_checkpoint = {max_txns}");
4896        self.max_transactions_per_checkpoint = Some(max_txns);
4897    }
4898
4899    // Extract the bytecode verifier config from this protocol config.
4900    // If used during signing, `signing_limits` should be set.
4901    // The third limit configures`sanity_check_with_regex_reference_safety`,
4902    // which runs the new regex-based reference safety check to check that it is strictly more
4903    // permissive than the current implementation.
4904    pub fn verifier_config(&self, signing_limits: Option<(usize, usize, usize)>) -> VerifierConfig {
4905        let (
4906            max_back_edges_per_function,
4907            max_back_edges_per_module,
4908            sanity_check_with_regex_reference_safety,
4909        ) = if let Some((
4910            max_back_edges_per_function,
4911            max_back_edges_per_module,
4912            sanity_check_with_regex_reference_safety,
4913        )) = signing_limits
4914        {
4915            (
4916                Some(max_back_edges_per_function),
4917                Some(max_back_edges_per_module),
4918                Some(sanity_check_with_regex_reference_safety),
4919            )
4920        } else {
4921            (None, None, None)
4922        };
4923
4924        let additional_borrow_checks = if signing_limits.is_some() {
4925            // always turn on additional borrow checks during signing
4926            true
4927        } else {
4928            self.additional_borrow_checks()
4929        };
4930        let deprecate_global_storage_ops = if signing_limits.is_some() {
4931            // always turn on additional vector borrow checks during signing
4932            true
4933        } else {
4934            self.deprecate_global_storage_ops()
4935        };
4936
4937        VerifierConfig {
4938            max_loop_depth: Some(self.max_loop_depth() as usize),
4939            max_generic_instantiation_length: Some(self.max_generic_instantiation_length() as usize),
4940            max_function_parameters: Some(self.max_function_parameters() as usize),
4941            max_basic_blocks: Some(self.max_basic_blocks() as usize),
4942            max_value_stack_size: self.max_value_stack_size() as usize,
4943            max_type_nodes: Some(self.max_type_nodes() as usize),
4944            max_push_size: Some(self.max_push_size() as usize),
4945            max_dependency_depth: Some(self.max_dependency_depth() as usize),
4946            max_fields_in_struct: Some(self.max_fields_in_struct() as usize),
4947            max_function_definitions: Some(self.max_function_definitions() as usize),
4948            max_data_definitions: Some(self.max_struct_definitions() as usize),
4949            max_constant_vector_len: Some(self.max_move_vector_len()),
4950            max_back_edges_per_function,
4951            max_back_edges_per_module,
4952            max_basic_blocks_in_script: None,
4953            max_identifier_len: self.max_move_identifier_len_as_option(), // Before protocol version 9, there was no limit
4954            disallow_self_identifier: self.feature_flags.disallow_self_identifier,
4955            allow_receiving_object_id: self.allow_receiving_object_id(),
4956            reject_mutable_random_on_entry_functions: self
4957                .reject_mutable_random_on_entry_functions(),
4958            bytecode_version: self.move_binary_format_version(),
4959            max_variants_in_enum: self.max_move_enum_variants_as_option(),
4960            additional_borrow_checks,
4961            better_loader_errors: self.better_loader_errors(),
4962            private_generics_verifier_v2: self.private_generics_verifier_v2(),
4963            sanity_check_with_regex_reference_safety: sanity_check_with_regex_reference_safety
4964                .map(|limit| limit as u128),
4965            deprecate_global_storage_ops,
4966            disable_entry_point_signature_check: self.disable_entry_point_signature_check(),
4967            switch_to_regex_reference_safety: false,
4968            disallow_jump_orphans: self.disallow_jump_orphans(),
4969        }
4970    }
4971
4972    pub fn binary_config(
4973        &self,
4974        override_deprecate_global_storage_ops_during_deserialization: Option<bool>,
4975    ) -> BinaryConfig {
4976        let deprecate_global_storage_ops =
4977            override_deprecate_global_storage_ops_during_deserialization
4978                .unwrap_or_else(|| self.deprecate_global_storage_ops());
4979        BinaryConfig::new(
4980            self.move_binary_format_version(),
4981            self.min_move_binary_format_version_as_option()
4982                .unwrap_or(VERSION_1),
4983            self.no_extraneous_module_bytes(),
4984            deprecate_global_storage_ops,
4985            TableConfig {
4986                module_handles: self.binary_module_handles_as_option().unwrap_or(u16::MAX),
4987                datatype_handles: self.binary_struct_handles_as_option().unwrap_or(u16::MAX),
4988                function_handles: self.binary_function_handles_as_option().unwrap_or(u16::MAX),
4989                function_instantiations: self
4990                    .binary_function_instantiations_as_option()
4991                    .unwrap_or(u16::MAX),
4992                signatures: self.binary_signatures_as_option().unwrap_or(u16::MAX),
4993                constant_pool: self.binary_constant_pool_as_option().unwrap_or(u16::MAX),
4994                identifiers: self.binary_identifiers_as_option().unwrap_or(u16::MAX),
4995                address_identifiers: self
4996                    .binary_address_identifiers_as_option()
4997                    .unwrap_or(u16::MAX),
4998                struct_defs: self.binary_struct_defs_as_option().unwrap_or(u16::MAX),
4999                struct_def_instantiations: self
5000                    .binary_struct_def_instantiations_as_option()
5001                    .unwrap_or(u16::MAX),
5002                function_defs: self.binary_function_defs_as_option().unwrap_or(u16::MAX),
5003                field_handles: self.binary_field_handles_as_option().unwrap_or(u16::MAX),
5004                field_instantiations: self
5005                    .binary_field_instantiations_as_option()
5006                    .unwrap_or(u16::MAX),
5007                friend_decls: self.binary_friend_decls_as_option().unwrap_or(u16::MAX),
5008                enum_defs: self.binary_enum_defs_as_option().unwrap_or(u16::MAX),
5009                enum_def_instantiations: self
5010                    .binary_enum_def_instantiations_as_option()
5011                    .unwrap_or(u16::MAX),
5012                variant_handles: self.binary_variant_handles_as_option().unwrap_or(u16::MAX),
5013                variant_instantiation_handles: self
5014                    .binary_variant_instantiation_handles_as_option()
5015                    .unwrap_or(u16::MAX),
5016            },
5017        )
5018    }
5019
5020    /// Override one or more settings in the config, for testing.
5021    /// This must be called at the beginning of the test, before get_for_(min|max)_version is
5022    /// called, since those functions cache their return value.
5023    #[cfg(not(msim))]
5024    pub fn apply_overrides_for_testing(
5025        override_fn: impl Fn(ProtocolVersion, Self) -> Self + Send + Sync + 'static,
5026    ) -> OverrideGuard {
5027        let mut cur = CONFIG_OVERRIDE.lock().unwrap();
5028        assert!(cur.is_none(), "config override already present");
5029        *cur = Some(Box::new(override_fn));
5030        OverrideGuard
5031    }
5032
5033    /// Override one or more settings in the config, for testing.
5034    /// This must be called at the beginning of the test, before get_for_(min|max)_version is
5035    /// called, since those functions cache their return value.
5036    #[cfg(msim)]
5037    pub fn apply_overrides_for_testing(
5038        override_fn: impl Fn(ProtocolVersion, Self) -> Self + Send + 'static,
5039    ) -> OverrideGuard {
5040        CONFIG_OVERRIDE.with(|ovr| {
5041            let mut cur = ovr.borrow_mut();
5042            assert!(cur.is_none(), "config override already present");
5043            *cur = Some(Box::new(override_fn));
5044            OverrideGuard
5045        })
5046    }
5047
5048    #[cfg(not(msim))]
5049    fn apply_config_override(version: ProtocolVersion, mut ret: Self) -> Self {
5050        if let Some(override_fn) = CONFIG_OVERRIDE.lock().unwrap().as_ref() {
5051            warn!(
5052                "overriding ProtocolConfig settings with custom settings (you should not see this log outside of tests)"
5053            );
5054            ret = override_fn(version, ret);
5055        }
5056        ret
5057    }
5058
5059    #[cfg(msim)]
5060    fn apply_config_override(version: ProtocolVersion, ret: Self) -> Self {
5061        CONFIG_OVERRIDE.with(|ovr| {
5062            if let Some(override_fn) = &*ovr.borrow() {
5063                warn!(
5064                    "overriding ProtocolConfig settings with custom settings (you should not see this log outside of tests)"
5065                );
5066                override_fn(version, ret)
5067            } else {
5068                ret
5069            }
5070        })
5071    }
5072}
5073
5074// Setters for tests.
5075// This is only needed for feature_flags. Please suffix each setter with `_for_testing`.
5076// Non-feature_flags should already have test setters defined through macros.
5077impl ProtocolConfig {
5078    pub fn set_advance_to_highest_supported_protocol_version_for_testing(&mut self, val: bool) {
5079        self.feature_flags
5080            .advance_to_highest_supported_protocol_version = val
5081    }
5082    pub fn set_commit_root_state_digest_supported_for_testing(&mut self, val: bool) {
5083        self.feature_flags.commit_root_state_digest = val
5084    }
5085    pub fn set_zklogin_auth_for_testing(&mut self, val: bool) {
5086        self.feature_flags.zklogin_auth = val
5087    }
5088    pub fn set_enable_jwk_consensus_updates_for_testing(&mut self, val: bool) {
5089        self.feature_flags.enable_jwk_consensus_updates = val
5090    }
5091    pub fn set_random_beacon_for_testing(&mut self, val: bool) {
5092        self.feature_flags.random_beacon = val
5093    }
5094
5095    pub fn set_upgraded_multisig_for_testing(&mut self, val: bool) {
5096        self.feature_flags.upgraded_multisig_supported = val
5097    }
5098    pub fn set_accept_zklogin_in_multisig_for_testing(&mut self, val: bool) {
5099        self.feature_flags.accept_zklogin_in_multisig = val
5100    }
5101
5102    pub fn set_shared_object_deletion_for_testing(&mut self, val: bool) {
5103        self.feature_flags.shared_object_deletion = val;
5104    }
5105
5106    pub fn set_narwhal_new_leader_election_schedule_for_testing(&mut self, val: bool) {
5107        self.feature_flags.narwhal_new_leader_election_schedule = val;
5108    }
5109
5110    pub fn set_receive_object_for_testing(&mut self, val: bool) {
5111        self.feature_flags.receive_objects = val
5112    }
5113    pub fn set_narwhal_certificate_v2_for_testing(&mut self, val: bool) {
5114        self.feature_flags.narwhal_certificate_v2 = val
5115    }
5116    pub fn set_verify_legacy_zklogin_address_for_testing(&mut self, val: bool) {
5117        self.feature_flags.verify_legacy_zklogin_address = val
5118    }
5119
5120    pub fn set_per_object_congestion_control_mode_for_testing(
5121        &mut self,
5122        val: PerObjectCongestionControlMode,
5123    ) {
5124        self.feature_flags.per_object_congestion_control_mode = val;
5125    }
5126
5127    pub fn set_consensus_choice_for_testing(&mut self, val: ConsensusChoice) {
5128        self.feature_flags.consensus_choice = val;
5129    }
5130
5131    pub fn set_consensus_network_for_testing(&mut self, val: ConsensusNetwork) {
5132        self.feature_flags.consensus_network = val;
5133    }
5134
5135    pub fn set_zklogin_max_epoch_upper_bound_delta_for_testing(&mut self, val: Option<u64>) {
5136        self.feature_flags.zklogin_max_epoch_upper_bound_delta = val
5137    }
5138
5139    pub fn set_disable_bridge_for_testing(&mut self) {
5140        self.feature_flags.bridge = false
5141    }
5142
5143    pub fn set_mysticeti_num_leaders_per_round_for_testing(&mut self, val: Option<usize>) {
5144        self.feature_flags.mysticeti_num_leaders_per_round = val;
5145    }
5146
5147    pub fn set_enable_soft_bundle_for_testing(&mut self, val: bool) {
5148        self.feature_flags.soft_bundle = val;
5149    }
5150
5151    pub fn set_passkey_auth_for_testing(&mut self, val: bool) {
5152        self.feature_flags.passkey_auth = val
5153    }
5154
5155    pub fn set_enable_party_transfer_for_testing(&mut self, val: bool) {
5156        self.feature_flags.enable_party_transfer = val
5157    }
5158
5159    pub fn set_consensus_distributed_vote_scoring_strategy_for_testing(&mut self, val: bool) {
5160        self.feature_flags
5161            .consensus_distributed_vote_scoring_strategy = val;
5162    }
5163
5164    pub fn set_consensus_round_prober_for_testing(&mut self, val: bool) {
5165        self.feature_flags.consensus_round_prober = val;
5166    }
5167
5168    pub fn set_disallow_new_modules_in_deps_only_packages_for_testing(&mut self, val: bool) {
5169        self.feature_flags
5170            .disallow_new_modules_in_deps_only_packages = val;
5171    }
5172
5173    pub fn set_correct_gas_payment_limit_check_for_testing(&mut self, val: bool) {
5174        self.feature_flags.correct_gas_payment_limit_check = val;
5175    }
5176
5177    pub fn set_address_aliases_for_testing(&mut self, val: bool) {
5178        self.feature_flags.address_aliases = val;
5179    }
5180
5181    pub fn set_consensus_round_prober_probe_accepted_rounds(&mut self, val: bool) {
5182        self.feature_flags
5183            .consensus_round_prober_probe_accepted_rounds = val;
5184    }
5185
5186    pub fn set_mysticeti_fastpath_for_testing(&mut self, val: bool) {
5187        self.feature_flags.mysticeti_fastpath = val;
5188    }
5189
5190    pub fn set_accept_passkey_in_multisig_for_testing(&mut self, val: bool) {
5191        self.feature_flags.accept_passkey_in_multisig = val;
5192    }
5193
5194    pub fn set_consensus_batched_block_sync_for_testing(&mut self, val: bool) {
5195        self.feature_flags.consensus_batched_block_sync = val;
5196    }
5197
5198    pub fn set_record_time_estimate_processed_for_testing(&mut self, val: bool) {
5199        self.feature_flags.record_time_estimate_processed = val;
5200    }
5201
5202    pub fn set_prepend_prologue_tx_in_consensus_commit_in_checkpoints_for_testing(
5203        &mut self,
5204        val: bool,
5205    ) {
5206        self.feature_flags
5207            .prepend_prologue_tx_in_consensus_commit_in_checkpoints = val;
5208    }
5209
5210    pub fn enable_accumulators_for_testing(&mut self) {
5211        self.feature_flags.enable_accumulators = true;
5212    }
5213
5214    pub fn disable_accumulators_for_testing(&mut self) {
5215        self.feature_flags.enable_accumulators = false;
5216        self.feature_flags.enable_address_balance_gas_payments = false;
5217    }
5218
5219    pub fn enable_coin_reservation_for_testing(&mut self) {
5220        self.feature_flags.enable_coin_reservation_obj_refs = true;
5221        self.feature_flags
5222            .convert_withdrawal_compatibility_ptb_arguments = true;
5223        // Ensure execution_version >= 4 so new_vm_enabled() returns true,
5224        // which is required for enable_coin_reservation_obj_refs() to return true.
5225        self.execution_version = Some(self.execution_version.map_or(4, |v| v.max(4)));
5226    }
5227
5228    pub fn disable_coin_reservation_for_testing(&mut self) {
5229        self.feature_flags.enable_coin_reservation_obj_refs = false;
5230        self.feature_flags
5231            .convert_withdrawal_compatibility_ptb_arguments = false;
5232    }
5233
5234    pub fn create_root_accumulator_object_for_testing(&mut self) {
5235        self.feature_flags.create_root_accumulator_object = true;
5236    }
5237
5238    pub fn disable_create_root_accumulator_object_for_testing(&mut self) {
5239        self.feature_flags.create_root_accumulator_object = false;
5240    }
5241
5242    pub fn enable_address_balance_gas_payments_for_testing(&mut self) {
5243        self.feature_flags.enable_accumulators = true;
5244        self.feature_flags.allow_private_accumulator_entrypoints = true;
5245        self.feature_flags.enable_address_balance_gas_payments = true;
5246        self.feature_flags.address_balance_gas_check_rgp_at_signing = true;
5247        self.feature_flags.address_balance_gas_reject_gas_coin_arg = false;
5248        self.execution_version = Some(self.execution_version.map_or(4, |v| v.max(4)))
5249    }
5250
5251    pub fn disable_address_balance_gas_payments_for_testing(&mut self) {
5252        self.feature_flags.enable_address_balance_gas_payments = false;
5253    }
5254
5255    pub fn enable_gasless_for_testing(&mut self) {
5256        self.enable_address_balance_gas_payments_for_testing();
5257        self.feature_flags.enable_gasless = true;
5258        self.feature_flags.gasless_verify_remaining_balance = true;
5259        self.gasless_max_computation_units = Some(5_000);
5260        self.gasless_allowed_token_types = Some(vec![]);
5261        self.gasless_max_tps = Some(1000);
5262        self.gasless_max_tx_size_bytes = Some(16 * 1024);
5263    }
5264
5265    pub fn disable_gasless_for_testing(&mut self) {
5266        self.feature_flags.enable_gasless = false;
5267        self.gasless_max_computation_units = None;
5268        self.gasless_allowed_token_types = None;
5269    }
5270
5271    pub fn set_gasless_allowed_token_types_for_testing(&mut self, types: Vec<(String, u64)>) {
5272        self.gasless_allowed_token_types = Some(types);
5273    }
5274
5275    pub fn enable_multi_epoch_transaction_expiration_for_testing(&mut self) {
5276        self.feature_flags.enable_multi_epoch_transaction_expiration = true;
5277    }
5278
5279    pub fn enable_authenticated_event_streams_for_testing(&mut self) {
5280        self.enable_accumulators_for_testing();
5281        self.feature_flags.enable_authenticated_event_streams = true;
5282        self.feature_flags
5283            .include_checkpoint_artifacts_digest_in_summary = true;
5284        self.feature_flags.split_checkpoints_in_consensus_handler = true;
5285    }
5286
5287    pub fn disable_authenticated_event_streams_for_testing(&mut self) {
5288        self.feature_flags.enable_authenticated_event_streams = false;
5289    }
5290
5291    pub fn disable_randomize_checkpoint_tx_limit_for_testing(&mut self) {
5292        self.feature_flags.randomize_checkpoint_tx_limit_in_tests = false;
5293    }
5294
5295    pub fn enable_non_exclusive_writes_for_testing(&mut self) {
5296        self.feature_flags.enable_non_exclusive_writes = true;
5297    }
5298
5299    pub fn set_relax_valid_during_for_owned_inputs_for_testing(&mut self, val: bool) {
5300        self.feature_flags.relax_valid_during_for_owned_inputs = val;
5301    }
5302
5303    pub fn set_ignore_execution_time_observations_after_certs_closed_for_testing(
5304        &mut self,
5305        val: bool,
5306    ) {
5307        self.feature_flags
5308            .ignore_execution_time_observations_after_certs_closed = val;
5309    }
5310
5311    pub fn set_consensus_checkpoint_signature_key_includes_digest_for_testing(
5312        &mut self,
5313        val: bool,
5314    ) {
5315        self.feature_flags
5316            .consensus_checkpoint_signature_key_includes_digest = val;
5317    }
5318
5319    pub fn set_cancel_for_failed_dkg_early_for_testing(&mut self, val: bool) {
5320        self.feature_flags.cancel_for_failed_dkg_early = val;
5321    }
5322
5323    pub fn set_use_mfp_txns_in_load_initial_object_debts_for_testing(&mut self, val: bool) {
5324        self.feature_flags.use_mfp_txns_in_load_initial_object_debts = val;
5325    }
5326
5327    pub fn set_authority_capabilities_v2_for_testing(&mut self, val: bool) {
5328        self.feature_flags.authority_capabilities_v2 = val;
5329    }
5330
5331    pub fn allow_references_in_ptbs_for_testing(&mut self) {
5332        self.feature_flags.allow_references_in_ptbs = true;
5333    }
5334
5335    pub fn set_consensus_skip_gced_accept_votes_for_testing(&mut self, val: bool) {
5336        self.feature_flags.consensus_skip_gced_accept_votes = val;
5337    }
5338
5339    pub fn set_enable_object_funds_withdraw_for_testing(&mut self, val: bool) {
5340        self.feature_flags.enable_object_funds_withdraw = val;
5341    }
5342
5343    pub fn set_split_checkpoints_in_consensus_handler_for_testing(&mut self, val: bool) {
5344        self.feature_flags.split_checkpoints_in_consensus_handler = val;
5345    }
5346
5347    pub fn set_merge_randomness_into_checkpoint_for_testing(&mut self, val: bool) {
5348        self.feature_flags.merge_randomness_into_checkpoint = val;
5349    }
5350}
5351
5352#[cfg(not(msim))]
5353type OverrideFn = dyn Fn(ProtocolVersion, ProtocolConfig) -> ProtocolConfig + Send + Sync;
5354
5355#[cfg(not(msim))]
5356static CONFIG_OVERRIDE: Mutex<Option<Box<OverrideFn>>> = Mutex::new(None);
5357
5358#[cfg(msim)]
5359type OverrideFn = dyn Fn(ProtocolVersion, ProtocolConfig) -> ProtocolConfig + Send;
5360
5361#[cfg(msim)]
5362thread_local! {
5363    static CONFIG_OVERRIDE: RefCell<Option<Box<OverrideFn>>> = RefCell::new(None);
5364}
5365
5366#[must_use]
5367pub struct OverrideGuard;
5368
5369#[cfg(not(msim))]
5370impl Drop for OverrideGuard {
5371    fn drop(&mut self) {
5372        info!("restoring override fn");
5373        *CONFIG_OVERRIDE.lock().unwrap() = None;
5374    }
5375}
5376
5377#[cfg(msim)]
5378impl Drop for OverrideGuard {
5379    fn drop(&mut self) {
5380        info!("restoring override fn");
5381        CONFIG_OVERRIDE.with(|ovr| {
5382            *ovr.borrow_mut() = None;
5383        });
5384    }
5385}
5386
5387/// Defines which limit got crossed.
5388/// The value which crossed the limit and value of the limit crossed are embedded
5389#[derive(PartialEq, Eq)]
5390pub enum LimitThresholdCrossed {
5391    None,
5392    Soft(u128, u128),
5393    Hard(u128, u128),
5394}
5395
5396/// Convenience function for comparing limit ranges
5397/// V::MAX must be at >= U::MAX and T::MAX
5398pub fn check_limit_in_range<T: Into<V>, U: Into<V>, V: PartialOrd + Into<u128>>(
5399    x: T,
5400    soft_limit: U,
5401    hard_limit: V,
5402) -> LimitThresholdCrossed {
5403    let x: V = x.into();
5404    let soft_limit: V = soft_limit.into();
5405
5406    debug_assert!(soft_limit <= hard_limit);
5407
5408    // It is important to preserve this comparison order because if soft_limit == hard_limit
5409    // we want LimitThresholdCrossed::Hard
5410    if x >= hard_limit {
5411        LimitThresholdCrossed::Hard(x.into(), hard_limit.into())
5412    } else if x < soft_limit {
5413        LimitThresholdCrossed::None
5414    } else {
5415        LimitThresholdCrossed::Soft(x.into(), soft_limit.into())
5416    }
5417}
5418
5419#[macro_export]
5420macro_rules! check_limit {
5421    ($x:expr, $hard:expr) => {
5422        check_limit!($x, $hard, $hard)
5423    };
5424    ($x:expr, $soft:expr, $hard:expr) => {
5425        check_limit_in_range($x as u64, $soft, $hard)
5426    };
5427}
5428
5429/// Used to check which limits were crossed if the TX is metered (not system tx)
5430/// Args are: is_metered, value_to_check, metered_limit, unmetered_limit
5431/// metered_limit is always less than or equal to unmetered_hard_limit
5432#[macro_export]
5433macro_rules! check_limit_by_meter {
5434    ($is_metered:expr, $x:expr, $metered_limit:expr, $unmetered_hard_limit:expr, $metric:expr) => {{
5435        // If this is metered, we use the metered_limit limit as the upper bound
5436        let (h, metered_str) = if $is_metered {
5437            ($metered_limit, "metered")
5438        } else {
5439            // Unmetered gets more headroom
5440            ($unmetered_hard_limit, "unmetered")
5441        };
5442        use sui_protocol_config::check_limit_in_range;
5443        let result = check_limit_in_range($x as u64, $metered_limit, h);
5444        match result {
5445            LimitThresholdCrossed::None => {}
5446            LimitThresholdCrossed::Soft(_, _) => {
5447                $metric.with_label_values(&[metered_str, "soft"]).inc();
5448            }
5449            LimitThresholdCrossed::Hard(_, _) => {
5450                $metric.with_label_values(&[metered_str, "hard"]).inc();
5451            }
5452        };
5453        result
5454    }};
5455}
5456
5457// Amendments tables
5458
5459pub type Amendments = BTreeMap<AccountAddress, BTreeMap<AccountAddress, AccountAddress>>;
5460
5461static MAINNET_LINKAGE_AMENDMENTS: LazyLock<Arc<Amendments>> =
5462    LazyLock::new(|| parse_amendments(include_str!("mainnet_amendments.json")));
5463
5464static TESTNET_LINKAGE_AMENDMENTS: LazyLock<Arc<Amendments>> =
5465    LazyLock::new(|| parse_amendments(include_str!("testnet_amendments.json")));
5466
5467fn parse_amendments(json: &str) -> Arc<Amendments> {
5468    #[derive(serde::Deserialize)]
5469    struct AmendmentEntry {
5470        root: String,
5471        deps: Vec<DepEntry>,
5472    }
5473
5474    #[derive(serde::Deserialize)]
5475    struct DepEntry {
5476        original_id: String,
5477        version_id: String,
5478    }
5479
5480    let entries: Vec<AmendmentEntry> =
5481        serde_json::from_str(json).expect("Failed to parse amendments JSON");
5482    let mut amendments = BTreeMap::new();
5483    for entry in entries {
5484        let root_id = AccountAddress::from_hex_literal(&entry.root).unwrap();
5485        let mut dep_ids = BTreeMap::new();
5486        for dep in entry.deps {
5487            let orig_id = AccountAddress::from_hex_literal(&dep.original_id).unwrap();
5488            let upgraded_id = AccountAddress::from_hex_literal(&dep.version_id).unwrap();
5489            assert!(
5490                dep_ids.insert(orig_id, upgraded_id).is_none(),
5491                "Duplicate original ID in amendments table"
5492            );
5493        }
5494        assert!(
5495            amendments.insert(root_id, dep_ids).is_none(),
5496            "Duplicate root ID in amendments table"
5497        );
5498    }
5499    Arc::new(amendments)
5500}
5501
5502#[cfg(all(test, not(msim)))]
5503mod test {
5504    use insta::assert_yaml_snapshot;
5505
5506    use super::*;
5507
5508    #[test]
5509    fn snapshot_tests() {
5510        println!("\n============================================================================");
5511        println!("!                                                                          !");
5512        println!("! IMPORTANT: never update snapshots from this test. only add new versions! !");
5513        println!("!                                                                          !");
5514        println!("============================================================================\n");
5515        for chain_id in &[Chain::Unknown, Chain::Mainnet, Chain::Testnet] {
5516            // make Chain::Unknown snapshots compatible with pre-chain-id snapshots so that we
5517            // don't break the release-time compatibility tests. Once Chain Id configs have been
5518            // released everywhere, we can remove this and only test Mainnet and Testnet
5519            let chain_str = match chain_id {
5520                Chain::Unknown => "".to_string(),
5521                _ => format!("{:?}_", chain_id),
5522            };
5523            for i in MIN_PROTOCOL_VERSION..=MAX_PROTOCOL_VERSION {
5524                let cur = ProtocolVersion::new(i);
5525                assert_yaml_snapshot!(
5526                    format!("{}version_{}", chain_str, cur.as_u64()),
5527                    ProtocolConfig::get_for_version(cur, *chain_id)
5528                );
5529            }
5530        }
5531    }
5532
5533    #[test]
5534    fn test_getters() {
5535        let prot: ProtocolConfig =
5536            ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5537        assert_eq!(
5538            prot.max_arguments(),
5539            prot.max_arguments_as_option().unwrap()
5540        );
5541    }
5542
5543    #[test]
5544    fn test_setters() {
5545        let mut prot: ProtocolConfig =
5546            ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5547        prot.set_max_arguments_for_testing(123);
5548        assert_eq!(prot.max_arguments(), 123);
5549
5550        prot.set_max_arguments_from_str_for_testing("321".to_string());
5551        assert_eq!(prot.max_arguments(), 321);
5552
5553        prot.disable_max_arguments_for_testing();
5554        assert_eq!(prot.max_arguments_as_option(), None);
5555
5556        prot.set_attr_for_testing("max_arguments".to_string(), "456".to_string());
5557        assert_eq!(prot.max_arguments(), 456);
5558    }
5559
5560    #[test]
5561    fn test_get_for_version_if_supported_applies_test_overrides() {
5562        let before =
5563            ProtocolConfig::get_for_version_if_supported(ProtocolVersion::new(1), Chain::Unknown)
5564                .unwrap();
5565
5566        assert!(!before.enable_coin_reservation_obj_refs());
5567
5568        let _guard = ProtocolConfig::apply_overrides_for_testing(|_, mut cfg| {
5569            cfg.enable_coin_reservation_for_testing();
5570            cfg
5571        });
5572
5573        let after =
5574            ProtocolConfig::get_for_version_if_supported(ProtocolVersion::new(1), Chain::Unknown)
5575                .unwrap();
5576
5577        assert!(after.enable_coin_reservation_obj_refs());
5578    }
5579
5580    #[test]
5581    #[should_panic(expected = "unsupported version")]
5582    fn max_version_test() {
5583        // When this does not panic, version higher than MAX_PROTOCOL_VERSION exists.
5584        // To fix, bump MAX_PROTOCOL_VERSION or disable this check for the version.
5585        let _ = ProtocolConfig::get_for_version_impl(
5586            ProtocolVersion::new(MAX_PROTOCOL_VERSION + 1),
5587            Chain::Unknown,
5588        );
5589    }
5590
5591    #[test]
5592    fn lookup_by_string_test() {
5593        let prot: ProtocolConfig =
5594            ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5595        // Does not exist
5596        assert!(prot.lookup_attr("some random string".to_string()).is_none());
5597
5598        assert!(
5599            prot.lookup_attr("max_arguments".to_string())
5600                == Some(ProtocolConfigValue::u32(prot.max_arguments())),
5601        );
5602
5603        // We didnt have this in version 1
5604        assert!(
5605            prot.lookup_attr("max_move_identifier_len".to_string())
5606                .is_none()
5607        );
5608
5609        // But we did in version 9
5610        let prot: ProtocolConfig =
5611            ProtocolConfig::get_for_version(ProtocolVersion::new(9), Chain::Unknown);
5612        assert!(
5613            prot.lookup_attr("max_move_identifier_len".to_string())
5614                == Some(ProtocolConfigValue::u64(prot.max_move_identifier_len()))
5615        );
5616
5617        let prot: ProtocolConfig =
5618            ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5619        // We didnt have this in version 1
5620        assert!(
5621            prot.attr_map()
5622                .get("max_move_identifier_len")
5623                .unwrap()
5624                .is_none()
5625        );
5626        // We had this in version 1
5627        assert!(
5628            prot.attr_map().get("max_arguments").unwrap()
5629                == &Some(ProtocolConfigValue::u32(prot.max_arguments()))
5630        );
5631
5632        // Check feature flags
5633        let prot: ProtocolConfig =
5634            ProtocolConfig::get_for_version(ProtocolVersion::new(1), Chain::Unknown);
5635        // Does not exist
5636        assert!(
5637            prot.feature_flags
5638                .lookup_attr("some random string".to_owned())
5639                .is_none()
5640        );
5641        assert!(
5642            !prot
5643                .feature_flags
5644                .attr_map()
5645                .contains_key("some random string")
5646        );
5647
5648        // Was false in v1
5649        assert!(
5650            prot.feature_flags
5651                .lookup_attr("package_upgrades".to_owned())
5652                == Some(false)
5653        );
5654        assert!(
5655            prot.feature_flags
5656                .attr_map()
5657                .get("package_upgrades")
5658                .unwrap()
5659                == &false
5660        );
5661        let prot: ProtocolConfig =
5662            ProtocolConfig::get_for_version(ProtocolVersion::new(4), Chain::Unknown);
5663        // Was true from v3 and up
5664        assert!(
5665            prot.feature_flags
5666                .lookup_attr("package_upgrades".to_owned())
5667                == Some(true)
5668        );
5669        assert!(
5670            prot.feature_flags
5671                .attr_map()
5672                .get("package_upgrades")
5673                .unwrap()
5674                == &true
5675        );
5676    }
5677
5678    #[test]
5679    fn limit_range_fn_test() {
5680        let low = 100u32;
5681        let high = 10000u64;
5682
5683        assert!(check_limit!(1u8, low, high) == LimitThresholdCrossed::None);
5684        assert!(matches!(
5685            check_limit!(255u16, low, high),
5686            LimitThresholdCrossed::Soft(255u128, 100)
5687        ));
5688        // This wont compile because lossy
5689        //assert!(check_limit!(100000000u128, low, high) == LimitThresholdCrossed::None);
5690        // This wont compile because lossy
5691        //assert!(check_limit!(100000000usize, low, high) == LimitThresholdCrossed::None);
5692
5693        assert!(matches!(
5694            check_limit!(2550000u64, low, high),
5695            LimitThresholdCrossed::Hard(2550000, 10000)
5696        ));
5697
5698        assert!(matches!(
5699            check_limit!(2550000u64, high, high),
5700            LimitThresholdCrossed::Hard(2550000, 10000)
5701        ));
5702
5703        assert!(matches!(
5704            check_limit!(1u8, high),
5705            LimitThresholdCrossed::None
5706        ));
5707
5708        assert!(check_limit!(255u16, high) == LimitThresholdCrossed::None);
5709
5710        assert!(matches!(
5711            check_limit!(2550000u64, high),
5712            LimitThresholdCrossed::Hard(2550000, 10000)
5713        ));
5714    }
5715
5716    #[test]
5717    fn linkage_amendments_load() {
5718        let mainnet = LazyLock::force(&MAINNET_LINKAGE_AMENDMENTS);
5719        let testnet = LazyLock::force(&TESTNET_LINKAGE_AMENDMENTS);
5720        assert!(!mainnet.is_empty(), "mainnet amendments must not be empty");
5721        assert!(!testnet.is_empty(), "testnet amendments must not be empty");
5722    }
5723}