feat: Add in place update support to versioned macro

radix-blueprint-schema-init/src/lib.rs

@@ -43,11 +43,12 @@ impl Default for BlueprintSchemaInit {
     fn default() -> Self {
         Self {
             generics: Vec::new(),
-            schema: VersionedScryptoSchema::V1(SchemaV1 {
+            schema: Schema {
                 type_kinds: Vec::new(),
                 type_metadata: Vec::new(),
                 type_validations: Vec::new(),
-            }),
+            }
+            .into_versioned(),
             state: BlueprintStateSchemaInit::default(),
             events: BlueprintEventSchemaInit::default(),
             types: BlueprintTypeSchemaInit::default(),

radix-clis/src/replay/cmd_sync.rs

@@ -185,7 +185,7 @@ impl CommittedTxnReader {
                         let next_identifiers: VersionedCommittedTransactionIdentifiers =
                             scrypto_decode(next_identifiers_bytes.1.as_ref()).unwrap();
                         let expected_state_root_hash = next_identifiers
-                            .into_latest()
+                            .fully_update_and_into_latest_version()
                             .resultant_ledger_hashes
                             .state_root
                             .0;
@@ -208,7 +208,7 @@ impl CommittedTxnReader {
 
 define_single_versioned! {
     #[derive(Debug, Clone, Sbor)]
-    pub enum VersionedCommittedTransactionIdentifiers => CommittedTransactionIdentifiers = CommittedTransactionIdentifiersV1
+    pub VersionedCommittedTransactionIdentifiers(CommittedTransactionIdentifiersVersions) => CommittedTransactionIdentifiers = CommittedTransactionIdentifiersV1
 }
 
 #[derive(Debug, Clone, Sbor)]

radix-clis/src/resim/dumper.rs

@@ -55,7 +55,12 @@ pub fn dump_package<T: SubstateDatabase, O: std::io::Write>(
         output,
         "{}: {} bytes",
         "Code size".green().bold(),
-        substate.into_value().unwrap().into_latest().code.len()
+        substate
+            .into_value()
+            .unwrap()
+            .fully_update_and_into_latest_version()
+            .code
+            .len()
     );
 
     let metadata = get_entity_metadata(package_address.as_node_id(), substate_db);
@@ -232,7 +237,7 @@ pub fn dump_resource_manager<T: SubstateDatabase, O: std::io::Write>(
                     NonFungibleResourceManagerField::TotalSupply.into(),
                 )
                 .map_err(|_| EntityDumpError::InvalidStore("Missing Total Supply".to_string()))?
-                .into_latest();
+                .fully_update_and_into_latest_version();
 
             writeln!(
                 output,
@@ -249,7 +254,7 @@ pub fn dump_resource_manager<T: SubstateDatabase, O: std::io::Write>(
                 FungibleResourceManagerField::Divisibility.into(),
             )
             .map_err(|_| EntityDumpError::InvalidStore("Missing Divisibility".to_string()))?
-            .into_latest();
+            .fully_update_and_into_latest_version();
 
         writeln!(output, "{}: {}", "Resource Type".green().bold(), "Fungible");
         writeln!(
@@ -270,7 +275,7 @@ pub fn dump_resource_manager<T: SubstateDatabase, O: std::io::Write>(
                     FungibleResourceManagerField::TotalSupply.into(),
                 )
                 .map_err(|_| EntityDumpError::InvalidStore("Missing Total Supply".to_string()))?
-                .into_latest();
+                .fully_update_and_into_latest_version();
 
             writeln!(
                 output,
@@ -306,7 +311,7 @@ fn get_entity_metadata<T: SubstateDatabase>(
             let map_key = key.into_map();
             let key = scrypto_decode::<String>(&map_key).unwrap();
             let value = scrypto_decode::<MetadataEntryEntryPayload>(&value).unwrap();
-            (key, value.into_latest())
+            (key, value.fully_update_and_into_latest_version())
         })
         .collect()
 }

radix-clis/src/resim/mod.rs

@@ -409,9 +409,9 @@ pub fn get_event_schema<S: SubstateDatabase>(
         )
         .unwrap()?;
 
-    let bp_interface = match bp_definition {
-        VersionedPackageBlueprintVersionDefinition::V1(blueprint) => blueprint.interface,
-    };
+    let bp_interface = bp_definition
+        .fully_update_and_into_latest_version()
+        .interface;
 
     let event_def = bp_interface.events.get(event_name)?;
     match event_def {
@@ -489,7 +489,7 @@ pub fn db_upsert_epoch(epoch: Epoch) -> Result<(), Error> {
                 started: true,
             })
         })
-        .into_latest();
+        .fully_update_and_into_latest_version();
 
     consensus_mgr_state.epoch = epoch;
 

radix-clis/src/scrypto_bindgen/mod.rs

@@ -110,7 +110,7 @@ where
     ) -> Result<SchemaTypeKind<ScryptoCustomSchema>, schema::SchemaError> {
         self.lookup_schema(&type_identifier.0)
             .ok_or(schema::SchemaError::FailedToGetSchemaFromSchemaHash)?
-            .as_latest_ref()
+            .as_latest_version()
             .ok_or(schema::SchemaError::FailedToGetSchemaFromSchemaHash)?
             .resolve_type_kind(type_identifier.1)
             .ok_or(schema::SchemaError::NonExistentLocalTypeIndex(
@@ -125,7 +125,7 @@ where
     ) -> Result<TypeMetadata, schema::SchemaError> {
         self.lookup_schema(&type_identifier.0)
             .ok_or(schema::SchemaError::FailedToGetSchemaFromSchemaHash)?
-            .as_latest_ref()
+            .as_latest_version()
             .ok_or(schema::SchemaError::FailedToGetSchemaFromSchemaHash)?
             .resolve_type_metadata(type_identifier.1)
             .ok_or(schema::SchemaError::NonExistentLocalTypeIndex(
@@ -140,7 +140,7 @@ where
     ) -> Result<TypeValidation<ScryptoCustomTypeValidation>, schema::SchemaError> {
         self.lookup_schema(&type_identifier.0)
             .ok_or(schema::SchemaError::FailedToGetSchemaFromSchemaHash)?
-            .as_latest_ref()
+            .as_latest_version()
             .ok_or(schema::SchemaError::FailedToGetSchemaFromSchemaHash)?
             .resolve_type_validation(type_identifier.1)
             .ok_or(schema::SchemaError::NonExistentLocalTypeIndex(

radix-common/src/data/scrypto/custom_schema.rs

@@ -2,6 +2,7 @@ use crate::internal_prelude::*;
 
 pub type ScryptoTypeKind<L> = TypeKind<ScryptoCustomTypeKind, L>;
 pub type VersionedScryptoSchema = VersionedSchema<ScryptoCustomSchema>;
+pub type ScryptoSchema = Schema<ScryptoCustomSchema>;
 pub type ScryptoTypeData<L> = TypeData<ScryptoCustomTypeKind, L>;
 
 /// A schema for the values that a codec can decode / views as valid

radix-engine-interface/src/blueprints/resource/non_fungible/non_fungible_resource_manager.rs

@@ -432,7 +432,7 @@ mod test {
             mutable_fields,
         } = ds
         {
-            let VersionedSchema::V1(s) = schema;
+            let s = schema.fully_update_and_into_latest_version();
             assert_eq!(s.type_kinds.len(), 1);
             assert_eq!(s.type_metadata.len(), 1);
             assert_eq!(s.type_validations.len(), 1);

radix-engine-interface/src/object_modules/metadata/models/mod.rs

@@ -22,6 +22,7 @@ use sbor::SborEnum;
 
 #[cfg_attr(feature = "fuzzing", derive(Arbitrary))]
 #[derive(Debug, Clone, Eq, PartialEq, ScryptoSbor, ManifestSbor)]
+#[sbor(categorize_types = "U, O")]
 pub enum GenericMetadataValue<U, O> {
     #[sbor(discriminator(METADATA_VALUE_STRING_DISCRIMINATOR))]
     String(String),

radix-engine-interface/src/types/kv_store_init.rs

@@ -6,7 +6,7 @@ use sbor::rust::prelude::*;
 
 #[cfg_attr(feature = "fuzzing", derive(Arbitrary))]
 #[derive(Debug, Clone, Eq, PartialEq, ScryptoSbor, ManifestSbor)]
-#[sbor(transparent)]
+#[sbor(transparent, categorize_types = "K")]
 pub struct KeyValueStoreInit<K: Hash + Eq + PartialEq, V> {
     pub data: IndexMap<K, KeyValueStoreInitEntry<V>>,
 }

radix-engine-tests/assets/blueprints/package_invalid/src/lib.rs

@@ -1,4 +1,3 @@
-use sbor::*;
 use scrypto::prelude::*;
 use scrypto::radix_blueprint_schema_init::*;
 
@@ -21,11 +20,7 @@ pub extern "C" fn BadFunctionSchema_schema() -> Slice {
     );
 
     // Empty Schema
-    let empty_schema = VersionedScryptoSchema::V1(SchemaV1 {
-        type_kinds: Vec::new(),
-        type_metadata: Vec::new(),
-        type_validations: Vec::new(),
-    });
+    let empty_schema = Schema::empty().into_versioned();
 
     let return_data = scrypto::blueprints::package::BlueprintDefinitionInit {
         blueprint_type: scrypto::blueprints::package::BlueprintType::default(),

radix-engine-tests/assets/blueprints/scrypto_env/src/lib.rs

@@ -62,13 +62,8 @@ mod max_sbor_depth {
     impl MaxSborDepthTest {
         pub fn write_kv_store_entry_with_depth(buffer: Vec<u8>) {
             // Create KeyValueStore<Any, Any>
-            let schema = VersionedScryptoSchema::V1(SchemaV1 {
-                type_kinds: vec![],
-                type_metadata: vec![],
-                type_validations: vec![],
-            });
             let kv_store = ScryptoVmV1Api::kv_store_new(KeyValueStoreDataSchema::Local {
-                additional_schema: schema,
+                additional_schema: Schema::empty().into(),
                 key_type: LocalTypeId::from(ANY_TYPE),
                 value_type: LocalTypeId::from(ANY_TYPE),
                 allow_ownership: false,

radix-engine-tests/tests/kernel/test_environment.rs

@@ -232,12 +232,7 @@ fn references_read_from_state_are_visible_in_tests1() {
         .with_component_state::<VersionedTwoResourcePoolState, _, _, _>(
             radiswap_pool_component,
             |state, env| {
-                let VersionedTwoResourcePoolState::V1(
-                    radix_engine::blueprints::pool::v1::substates::two_resource_pool::Substate {
-                        vaults: [(_, vault1), (_, _)],
-                        ..
-                    },
-                ) = state;
+                let [(_, vault1), (_, _)] = &mut state.as_unique_version_mut().vaults;
                 vault1.amount(env)
             },
         )

radix-engine-tests/tests/system/bootstrap.rs

@@ -274,7 +274,7 @@ fn test_genesis_resource_with_initial_allocation(owned_resource: bool) {
         )
         .unwrap()
         .into_payload()
-        .into_latest();
+        .fully_update_and_into_latest_version();
     assert_eq!(total_supply, allocation_amount);
 
     let reader = SystemDatabaseReader::new(&substate_db);
@@ -288,7 +288,7 @@ fn test_genesis_resource_with_initial_allocation(owned_resource: bool) {
             ),
         )
         .unwrap()
-        .map(|v| v.into_latest());
+        .map(|v| v.fully_update_and_into_latest_version());
 
     if let Some(MetadataValue::String(symbol)) = entry {
         assert_eq!(symbol, "TST");
@@ -317,10 +317,10 @@ fn test_genesis_resource_with_initial_allocation(owned_resource: bool) {
             .unwrap();
         assert!(substate.is_locked());
         assert_eq!(
-            substate.into_value(),
-            Some(VersionedMetadataEntry::V1(MetadataValue::StringArray(
+            substate.into_value().map(|v| v.into_unique_version()),
+            Some(MetadataValue::StringArray(
                 vec!["badge".to_owned()]
-            )))
+            ))
         );
 
         assert_eq!(
@@ -491,7 +491,7 @@ fn test_genesis_stake_allocation() {
                     ),
                 )
                 .unwrap()
-                .map(|v| v.into_latest());
+                .map(|v| v.fully_update_and_into_latest_version());
             if let Some(MetadataValue::Url(url)) = validator_url_entry {
                 assert_eq!(
                     url,
@@ -532,7 +532,7 @@ fn test_genesis_time() {
             ConsensusManagerField::ProposerMinuteTimestamp.field_index(),
         )
         .unwrap()
-        .into_latest();
+        .fully_update_and_into_latest_version();
 
     assert_eq!(timestamp.epoch_minute, 123);
 }
@@ -758,7 +758,7 @@ fn test_bootstrap_should_create_consensus_manager_with_sorted_validator_index()
             ObjectCollectionKey::SortedIndex(0, u16::from_be_bytes(sort_prefix), &address),
         )
         .expect("validator cannot be read")
-        .map(|versioned| versioned.into_latest())
+        .map(|versioned| versioned.fully_update_and_into_latest_version())
         .expect("validator not found");
 
     assert_eq!(

radix-engine-tests/tests/system/package.rs

@@ -153,7 +153,7 @@ fn test_basic_package_missing_export() {
 
             schema: BlueprintSchemaInit {
                 generics: vec![],
-                schema: VersionedScryptoSchema::V1(SchemaV1 {
+                schema: VersionedScryptoSchema::from_latest_version(SchemaV1 {
                     type_kinds: vec![],
                     type_metadata: vec![],
                     type_validations: vec![],

radix-engine-tests/tests/system/schema_sanity_check.rs

@@ -459,7 +459,7 @@ fn native_blueprints_with_typed_addresses_have_expected_schema() {
         panic!("Generic output!")
     };
 
-    let schema = blueprint_definition.schema.schema.into_latest();
+    let schema = blueprint_definition.schema.schema.fully_update_and_into_latest_version();
     let type_kind = schema.resolve_type_kind(local_type_index).unwrap();
     let type_validation = schema.resolve_type_validation(local_type_index).unwrap();
 

radix-engine/src/blueprints/access_controller/blueprint.rs

@@ -1111,7 +1111,7 @@ impl AccessControllerBlueprint {
             let access_controller = {
                 let access_controller: AccessControllerStateFieldPayload =
                     api.field_read_typed(handle)?;
-                access_controller.into_latest()
+                access_controller.fully_update_and_into_latest_version()
             };
             access_controller.recovery_badge
         };
@@ -1175,7 +1175,7 @@ where
 
     let access_controller = {
         let access_controller: AccessControllerStateFieldPayload = api.field_read_typed(handle)?;
-        access_controller.into_latest()
+        access_controller.fully_update_and_into_latest_version()
     };
 
     let rtn = access_controller.transition(api, input)?;
@@ -1201,7 +1201,7 @@ where
 
     let mut access_controller = {
         let access_controller: AccessControllerStateFieldPayload = api.field_read_typed(handle)?;
-        access_controller.into_latest()
+        access_controller.fully_update_and_into_latest_version()
     };
 
     let rtn = access_controller.transition_mut(api, input)?;

radix-engine/src/blueprints/account/blueprint.rs

@@ -1180,7 +1180,7 @@ impl AccountBlueprint {
         )?;
         api.key_value_entry_set_typed(
             kv_store_entry_lock_handle,
-            &VersionedAccountResourcePreference::V1(resource_preference),
+            &AccountResourcePreferenceVersions::V1(resource_preference).into_versioned(),
         )?;
         api.key_value_entry_close(kv_store_entry_lock_handle)?;
 
@@ -1281,7 +1281,7 @@ impl AccountBlueprint {
         )?;
         let deposit_rule = api
             .field_read_typed::<AccountDepositRuleFieldPayload>(handle)?
-            .into_latest();
+            .fully_update_and_into_latest_version();
         let default = deposit_rule.default_deposit_rule;
         api.field_close(handle)?;
 
@@ -1314,7 +1314,7 @@ impl AccountBlueprint {
                 .key_value_entry_get_typed::<AccountResourceVaultEntryPayload>(
                     kv_store_entry_lock_handle,
                 )?
-                .map(|v| v.into_latest());
+                .map(|v| v.fully_update_and_into_latest_version());
 
             match entry {
                 Some(vault) => Ok(vault),
@@ -1427,7 +1427,7 @@ impl AccountBlueprint {
             .key_value_entry_get_typed::<AccountResourcePreferenceEntryPayload>(
                 kv_store_entry_lock_handle,
             )?
-            .map(|v| v.into_latest());
+            .map(|v| v.fully_update_and_into_latest_version());
         api.key_value_entry_close(kv_store_entry_lock_handle)?;
         Ok(entry)
     }