Merge branch 'development' into wallet-ensure-network-is-set

applications/tari_indexer/src/substate_manager.rs

@@ -136,14 +136,7 @@ impl SubstateManager {
         version: Option<u32>,
     ) -> Result<Option<SubstateResponse>, anyhow::Error> {
         let mut tx = self.substate_store.create_read_tx()?;
-        if let Some(row) = tx.get_substate(substate_address)? {
-            // if a version is requested, we must check that it matches the one in db
-            if let Some(version) = version {
-                if i64::from(version) != row.version {
-                    return Ok(None);
-                }
-            }
-
+        if let Some(row) = tx.get_substate(substate_address, version)? {
             // the substate is present in db and the version matches the requested version
             let substate_resp = row.try_into()?;
             return Ok(Some(substate_resp));

applications/tari_indexer/src/substate_storage_sqlite/sqlite_substate_store_factory.rs

@@ -187,7 +187,7 @@ pub trait SubstateStoreReadTransaction {
         limit: Option<u64>,
         offset: Option<u64>,
     ) -> Result<Vec<ListSubstateItem>, StorageError>;
-    fn get_substate(&mut self, address: &SubstateId) -> Result<Option<Substate>, StorageError>;
+    fn get_substate(&mut self, address: &SubstateId, version: Option<u32>) -> Result<Option<Substate>, StorageError>;
     #[allow(dead_code)]
     fn get_latest_version_for_substate(&mut self, address: &SubstateId) -> Result<Option<i64>, StorageError>;
     #[allow(dead_code)]
@@ -298,18 +298,25 @@ impl SubstateStoreReadTransaction for SqliteSubstateStoreReadTransaction<'_> {
         Ok(items)
     }
 
-    fn get_substate(&mut self, address: &SubstateId) -> Result<Option<Substate>, StorageError> {
+    fn get_substate(&mut self, address: &SubstateId, version: Option<u32>) -> Result<Option<Substate>, StorageError> {
         use crate::substate_storage_sqlite::schema::substates;
 
-        let substate = substates::table
-            .filter(substates::address.eq(address.to_string()))
+        let mut substate_query = substates::table
+            .into_boxed()
+            .filter(substates::address.eq(address.to_string()));
+        if let Some(version) = version {
+            substate_query = substate_query.filter(substates::version.eq(i64::from(version)));
+        } else {
+            substate_query = substate_query.order_by(substates::version.desc())
+        }
+
+        substate_query
+            .limit(1)
             .first(self.connection())
             .optional()
             .map_err(|e| StorageError::QueryError {
                 reason: format!("get_substate: {}", e),
-            })?;
-
-        Ok(substate)
+            })
     }
 
     fn get_latest_version_for_substate(&mut self, address: &SubstateId) -> Result<Option<i64>, StorageError> {

dan_layer/engine/src/runtime/working_state.rs

@@ -201,6 +201,16 @@ impl WorkingState {
 
         self.validate_component_state(Some(&before), &after)?;
 
+        // add event to indicate that there is a change in component
+        let (template_address, module_name) = self.current_template().map(|(addr, name)| (*addr, name.to_string()))?;
+        self.push_event(Event::new(
+            Some(locked.address().clone()),
+            template_address,
+            self.transaction_hash(),
+            "std.component.updated".to_string(),
+            tari_template_lib::models::Metadata::from([("module_name".to_string(), module_name)]),
+        ));
+
         Ok(())
     }