rename database fields

applications/tari_dan_app_utilities/src/base_layer_scanner.rs

@@ -362,7 +362,7 @@ impl<TAddr: NodeAddressable + 'static> BaseLayerScanner<TAddr> {
     }
 
     async fn register_burnt_utxo(&mut self, output: &TransactionOutput) -> Result<(), BaseLayerScannerError> {
-        let address = SubstateId::UnclaimedConfidentialOutput(
+        let substate_id = SubstateId::UnclaimedConfidentialOutput(
             UnclaimedConfidentialOutputAddress::try_from_commitment(output.commitment.as_bytes()).map_err(|e|
                 // Technically impossible, but anyway
                 BaseLayerScannerError::InvalidSideChainUtxoResponse(format!("Invalid commitment: {}", e)))?,
@@ -378,7 +378,7 @@ impl<TAddr: NodeAddressable + 'static> BaseLayerScanner<TAddr> {
 
                 // TODO: This should be proposed in a block...
                 SubstateRecord {
-                    address,
+                    substate_id,
                     version: 0,
                     substate_value: substate,
                     state_hash: Default::default(),

applications/tari_validator_node/src/bootstrap.rs

@@ -442,7 +442,7 @@ where
     if !SubstateRecord::exists(tx.deref_mut(), &substate_address)? {
         // Create the resource for public identity
         SubstateRecord {
-            address: substate_id,
+            substate_id,
             version: 0,
             substate_value: Resource::new(
                 ResourceType::NonFungible,
@@ -469,7 +469,7 @@ where
     metadata.insert(TOKEN_SYMBOL, "tXTR2".to_string());
     if !SubstateRecord::exists(tx.deref_mut(), &substate_address)? {
         SubstateRecord {
-            address: substate_id,
+            substate_id,
             version: 0,
             substate_value: Resource::new(
                 ResourceType::Confidential,

applications/tari_validator_node/src/substate_resolver.rs

@@ -74,7 +74,7 @@ where
         out.set_all(
             local_substates
                 .into_iter()
-                .map(|s| (s.address.clone(), s.into_substate())),
+                .map(|s| (s.substate_id.clone(), s.into_substate())),
         );
 
         Ok(missing_shards)

dan_layer/indexer_lib/src/transaction_autofiller.rs

@@ -101,7 +101,7 @@ where
             let related_addresses = related_addresses
                 .into_iter()
                 .flatten()
-                .filter(|s| !substate_requirements.iter().any(|r| r.address() == s));
+                .filter(|s| !substate_requirements.iter().any(|r| r.substate_id() == s));
 
             // we need to fetch (in parallel) the latest version of all the related substates
             let mut handles = HashMap::new();
@@ -160,20 +160,20 @@ where
 {
     let scan_res = match req.version() {
         Some(version) => {
-            let shard = SubstateAddress::from_address(req.address(), version);
+            let shard = SubstateAddress::from_address(req.substate_id(), version);
             if transaction.all_inputs_iter().any(|s| *s == shard) {
                 // Shard is already an input
                 return Ok(None);
             }
 
             // if the client specified a version, we need to retrieve it
             substate_scanner
-                .get_specific_substate_from_committee(req.address(), version)
+                .get_specific_substate_from_committee(req.substate_id(), version)
                 .await?
         },
         None => {
             // if the client didn't specify a version, we fetch the latest one
-            substate_scanner.get_substate(req.address(), None).await?
+            substate_scanner.get_substate(req.substate_id(), None).await?
         },
     };
 

dan_layer/state_store_sqlite/migrations/2024-01-18-100401_rename_fields/down.sql

@@ -0,0 +1 @@
+-- This file should undo anything in `up.sql`

dan_layer/state_store_sqlite/migrations/2024-01-18-100401_rename_fields/up.sql

@@ -0,0 +1,17 @@
+
+alter table substates
+    rename column address to substate_id;
+
+alter table substates
+    rename column shard_id to address;
+
+alter table locked_outputs
+    rename column shard_id to substate_address;
+
+-- to rename an index we need to drop it and crete it again
+drop index substates_uniq_shard_id;
+create unique index substates_uniq_address on substates (address);
+
+drop index substates_uniq_shard_id;
+create unique index locked_outputs_uniq_idx_substate_address on locked_outputs (substate_address);
+

dan_layer/state_store_sqlite/src/reader.rs

@@ -1322,7 +1322,7 @@ impl<TAddr: NodeAddressable + Serialize + DeserializeOwned> StateStoreReadTransa
         use crate::schema::substates;
 
         let substate = substates::table
-            .filter(substates::shard_id.eq(serialize_hex(address)))
+            .filter(substates::address.eq(serialize_hex(address)))
             .first::<sql_models::SubstateRecord>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "substates_get",
@@ -1336,7 +1336,7 @@ impl<TAddr: NodeAddressable + Serialize + DeserializeOwned> StateStoreReadTransa
         use crate::schema::substates;
 
         let substates = substates::table
-            .filter(substates::shard_id.eq_any(addresses.iter().map(serialize_hex)))
+            .filter(substates::address.eq_any(addresses.iter().map(serialize_hex)))
             .get_results::<sql_models::SubstateRecord>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "substates_get_any",
@@ -1348,13 +1348,13 @@ impl<TAddr: NodeAddressable + Serialize + DeserializeOwned> StateStoreReadTransa
 
     fn substates_any_exist<I: IntoIterator<Item = S>, S: Borrow<SubstateAddress>>(
         &mut self,
-        shard_ids: I,
+        addresses: I,
     ) -> Result<bool, StorageError> {
         use crate::schema::substates;
 
         let count = substates::table
             .count()
-            .filter(substates::shard_id.eq_any(shard_ids.into_iter().map(|s| serialize_hex(s.borrow()))))
+            .filter(substates::address.eq_any(addresses.into_iter().map(|s| serialize_hex(s.borrow()))))
             .limit(1)
             .get_result::<i64>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
@@ -1388,13 +1388,13 @@ impl<TAddr: NodeAddressable + Serialize + DeserializeOwned> StateStoreReadTransa
         &mut self,
         start: &SubstateAddress,
         end: &SubstateAddress,
-        exclude_shards: &[SubstateAddress],
+        exclude: &[SubstateAddress],
     ) -> Result<Vec<SubstateRecord>, StorageError> {
         use crate::schema::substates;
 
         let substates = substates::table
-            .filter(substates::shard_id.between(serialize_hex(start), serialize_hex(end)))
-            .filter(substates::shard_id.ne_all(exclude_shards.iter().map(serialize_hex)))
+            .filter(substates::address.between(serialize_hex(start), serialize_hex(end)))
+            .filter(substates::address.ne_all(exclude.iter().map(serialize_hex)))
             .get_results::<sql_models::SubstateRecord>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "substates_get_many_within_range",
@@ -1503,7 +1503,7 @@ impl<TAddr: NodeAddressable + Serialize + DeserializeOwned> StateStoreReadTransa
 
         let locked_details = substates::table
             .select((substates::is_locked_w, substates::destroyed_by_transaction))
-            .filter(substates::shard_id.eq_any(&objects))
+            .filter(substates::address.eq_any(&objects))
             .get_results::<(bool, Option<String>)>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "transactions_try_lock_many",
@@ -1534,21 +1534,21 @@ impl<TAddr: NodeAddressable + Serialize + DeserializeOwned> StateStoreReadTransa
     }
 
     // -------------------------------- LockedOutputs -------------------------------- //
-    fn locked_outputs_check_all<I, B>(&mut self, output_shards: I) -> Result<SubstateLockState, StorageError>
+    fn locked_outputs_check_all<I, B>(&mut self, output_addresses: I) -> Result<SubstateLockState, StorageError>
     where
         I: IntoIterator<Item = B>,
         B: Borrow<SubstateAddress>,
     {
         use crate::schema::locked_outputs;
 
-        let outputs_hex = output_shards
+        let outputs_hex = output_addresses
             .into_iter()
-            .map(|shard_id| serialize_hex(shard_id.borrow()))
+            .map(|address| serialize_hex(address.borrow()))
             .collect::<Vec<_>>();
 
         let has_conflict = locked_outputs::table
             .count()
-            .filter(locked_outputs::shard_id.eq_any(outputs_hex))
+            .filter(locked_outputs::substate_address.eq_any(outputs_hex))
             .first::<i64>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "locked_outputs_check_all",

dan_layer/state_store_sqlite/src/schema.rs

@@ -121,7 +121,7 @@ diesel::table! {
         id -> Integer,
         block_id -> Text,
         transaction_id -> Text,
-        shard_id -> Text,
+        substate_address -> Text,
         created_at -> Timestamp,
     }
 }
@@ -168,8 +168,8 @@ diesel::table! {
 diesel::table! {
     substates (id) {
         id -> Integer,
-        shard_id -> Text,
         address -> Text,
+        substate_id -> Text,
         version -> Integer,
         data -> Text,
         state_hash -> Text,

dan_layer/state_store_sqlite/src/sql_models/substate.rs

@@ -11,8 +11,8 @@ use crate::serialization::{deserialize_hex_try_from, deserialize_json, parse_fro
 #[derive(Debug, Clone, Queryable)]
 pub struct SubstateRecord {
     pub id: i32,
-    pub shard_id: String,
     pub address: String,
+    pub substate_id: String,
     pub version: i32,
     pub data: String,
     pub state_hash: String,
@@ -61,7 +61,7 @@ impl TryFrom<SubstateRecord> for consensus_models::SubstateRecord {
             .transpose()?;
 
         Ok(Self {
-            address: parse_from_string(&value.address)?,
+            substate_id: parse_from_string(&value.substate_id)?,
             version: value.version as u32,
             substate_value: deserialize_json(&value.data)?,
             state_hash: deserialize_hex_try_from(&value.state_hash)?,

dan_layer/state_store_sqlite/src/writer.rs

@@ -1029,7 +1029,7 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
 
         let locked_details = substates::table
             .select((substates::is_locked_w, substates::destroyed_by_transaction))
-            .filter(substates::shard_id.eq_any(&objects))
+            .filter(substates::address.eq_any(&objects))
             .get_results::<(bool, Option<String>)>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "transactions_try_lock_many",
@@ -1059,7 +1059,7 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
         match lock_flag {
             SubstateLockFlag::Write => {
                 diesel::update(substates::table)
-                    .filter(substates::shard_id.eq_any(objects))
+                    .filter(substates::address.eq_any(objects))
                     .set((
                         substates::is_locked_w.eq(true),
                         substates::locked_by.eq(serialize_hex(locked_by_tx)),
@@ -1072,7 +1072,7 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
             },
             SubstateLockFlag::Read => {
                 diesel::update(substates::table)
-                    .filter(substates::shard_id.eq_any(objects))
+                    .filter(substates::address.eq_any(objects))
                     .set(substates::read_locks.eq(substates::read_locks + 1))
                     .execute(self.connection())
                     .map_err(|e| SqliteStorageError::DieselError {
@@ -1128,7 +1128,7 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
                 // }
 
                 diesel::update(substates::table)
-                    .filter(substates::shard_id.eq_any(objects))
+                    .filter(substates::address.eq_any(objects))
                     .filter(substates::locked_by.eq(serialize_hex(locked_by_tx)))
                     .set((
                         substates::is_locked_w.eq(false),
@@ -1168,7 +1168,7 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
                 //     .into());
                 // }
                 diesel::update(substates::table)
-                    .filter(substates::shard_id.eq_any(objects))
+                    .filter(substates::address.eq_any(objects))
                     .set(substates::read_locks.eq(substates::read_locks - 1))
                     .execute(self.connection())
                     .map_err(|e| SqliteStorageError::DieselError {
@@ -1183,7 +1183,7 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
 
     fn substate_down_many<I: IntoIterator<Item = SubstateAddress>>(
         &mut self,
-        shard_ids: I,
+        addresses: I,
         epoch: Epoch,
         destroyed_block_id: &BlockId,
         destroyed_transaction_id: &TransactionId,
@@ -1192,23 +1192,23 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
     ) -> Result<(), StorageError> {
         use crate::schema::substates;
 
-        let shard_ids = shard_ids.into_iter().map(serialize_hex).collect::<Vec<_>>();
+        let addresses = addresses.into_iter().map(serialize_hex).collect::<Vec<_>>();
 
         let is_writable = substates::table
-            .select((substates::address, substates::is_locked_w))
-            .filter(substates::shard_id.eq_any(&shard_ids))
+            .select((substates::substate_id, substates::is_locked_w))
+            .filter(substates::address.eq_any(&addresses))
             .get_results::<(String, bool)>(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "substate_down",
                 source: e,
             })?;
-        if is_writable.len() != shard_ids.len() {
+        if is_writable.len() != addresses.len() {
             return Err(SqliteStorageError::NotAllSubstatesFound {
                 operation: "substate_down",
                 details: format!(
                     "Found {} substates, but {} were requested",
                     is_writable.len(),
-                    shard_ids.len()
+                    addresses.len()
                 ),
             }
             .into());
@@ -1232,7 +1232,7 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
         );
 
         diesel::update(substates::table)
-            .filter(substates::shard_id.eq_any(shard_ids))
+            .filter(substates::address.eq_any(addresses))
             .set(changes)
             .execute(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
@@ -1247,8 +1247,8 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
         use crate::schema::substates;
 
         let values = (
-            substates::shard_id.eq(serialize_hex(substate.to_substate_address())),
-            substates::address.eq(substate.address.to_string()),
+            substates::address.eq(serialize_hex(substate.to_substate_address())),
+            substates::substate_id.eq(substate.substate_id.to_string()),
             substates::version.eq(substate.version as i32),
             substates::data.eq(serialize_json(&substate.substate_value)?),
             substates::state_hash.eq(serialize_hex(substate.state_hash)),
@@ -1278,7 +1278,7 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
         &mut self,
         block_id: &BlockId,
         transaction_id: &TransactionId,
-        output_shards: I,
+        output_addresses: I,
     ) -> Result<SubstateLockState, StorageError>
     where
         I: IntoIterator<Item = B>,
@@ -1288,13 +1288,13 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
         let block_id_hex = serialize_hex(block_id);
         let transaction_id_hex = serialize_hex(transaction_id);
 
-        let insert = output_shards
+        let insert = output_addresses
             .into_iter()
-            .map(|shard_id| {
+            .map(|address| {
                 (
                     locked_outputs::block_id.eq(&block_id_hex),
                     locked_outputs::transaction_id.eq(&transaction_id_hex),
-                    locked_outputs::shard_id.eq(serialize_hex(shard_id.borrow())),
+                    locked_outputs::substate_address.eq(serialize_hex(address.borrow())),
                 )
             })
             .collect::<Vec<_>>();
@@ -1317,16 +1317,16 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
         Ok(lock_state)
     }
 
-    fn locked_outputs_release_all<I, B>(&mut self, output_shards: I) -> Result<Vec<LockedOutput>, StorageError>
+    fn locked_outputs_release_all<I, B>(&mut self, output_addresses: I) -> Result<Vec<LockedOutput>, StorageError>
     where
         I: IntoIterator<Item = B>,
         B: Borrow<SubstateAddress>,
     {
         use crate::schema::locked_outputs;
 
-        let output_shards = output_shards
+        let output_addresses = output_addresses
             .into_iter()
-            .map(|shard_id| serialize_hex(shard_id.borrow()))
+            .map(|address| serialize_hex(address.borrow()))
             .collect::<Vec<_>>();
 
         // let locked = locked_outputs::table
@@ -1350,7 +1350,7 @@ impl<TAddr: NodeAddressable> StateStoreWriteTransaction for SqliteStateStoreWrit
         // }
 
         diesel::delete(locked_outputs::table)
-            .filter(locked_outputs::shard_id.eq_any(&output_shards))
+            .filter(locked_outputs::substate_address.eq_any(&output_addresses))
             .execute(self.connection())
             .map_err(|e| SqliteStorageError::DieselError {
                 operation: "locked_outputs_release",