From 740b0fafde5ee80bfb45d0bbb879cf98bf53c227 Mon Sep 17 00:00:00 2001 From: mrnaveira <47919901+mrnaveira@users.noreply.github.com> Date: Thu, 18 Jan 2024 10:55:53 +0000 Subject: [PATCH] rename database fields --- .../src/base_layer_scanner.rs | 4 +- .../tari_validator_node/src/bootstrap.rs | 4 +- .../src/substate_resolver.rs | 2 +- .../indexer_lib/src/transaction_autofiller.rs | 8 ++-- .../2024-01-18-100401_rename_fields/down.sql | 1 + .../2024-01-18-100401_rename_fields/up.sql | 17 +++++++ dan_layer/state_store_sqlite/src/reader.rs | 24 +++++----- dan_layer/state_store_sqlite/src/schema.rs | 4 +- .../src/sql_models/substate.rs | 4 +- dan_layer/state_store_sqlite/src/writer.rs | 44 +++++++++---------- .../storage/src/consensus_models/substate.rs | 18 ++++---- dan_layer/transaction/src/transaction.rs | 2 +- .../validator_node_rpc/proto/consensus.proto | 2 +- dan_layer/validator_node_rpc/proto/rpc.proto | 2 +- .../proto/transaction.proto | 2 +- .../src/conversions/consensus.rs | 4 +- .../validator_node_rpc/src/conversions/rpc.rs | 4 +- .../src/conversions/transaction.rs | 8 ++-- 18 files changed, 86 insertions(+), 68 deletions(-) create mode 100644 dan_layer/state_store_sqlite/migrations/2024-01-18-100401_rename_fields/down.sql create mode 100644 dan_layer/state_store_sqlite/migrations/2024-01-18-100401_rename_fields/up.sql diff --git a/applications/tari_dan_app_utilities/src/base_layer_scanner.rs b/applications/tari_dan_app_utilities/src/base_layer_scanner.rs index fc8fba3eb..988fbd749 100644 --- a/applications/tari_dan_app_utilities/src/base_layer_scanner.rs +++ b/applications/tari_dan_app_utilities/src/base_layer_scanner.rs @@ -362,7 +362,7 @@ impl BaseLayerScanner { } 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 BaseLayerScanner { // TODO: This should be proposed in a block... SubstateRecord { - address, + substate_id, version: 0, substate_value: substate, state_hash: Default::default(), diff --git a/applications/tari_validator_node/src/bootstrap.rs b/applications/tari_validator_node/src/bootstrap.rs index e99be3c18..4dd920ee9 100644 --- a/applications/tari_validator_node/src/bootstrap.rs +++ b/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, diff --git a/applications/tari_validator_node/src/substate_resolver.rs b/applications/tari_validator_node/src/substate_resolver.rs index acdc5fca7..c63960ec6 100644 --- a/applications/tari_validator_node/src/substate_resolver.rs +++ b/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) diff --git a/dan_layer/indexer_lib/src/transaction_autofiller.rs b/dan_layer/indexer_lib/src/transaction_autofiller.rs index ba6f9fb4d..b3c4a47a2 100644 --- a/dan_layer/indexer_lib/src/transaction_autofiller.rs +++ b/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,7 +160,7 @@ 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); @@ -168,12 +168,12 @@ where // 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? }, }; diff --git a/dan_layer/state_store_sqlite/migrations/2024-01-18-100401_rename_fields/down.sql b/dan_layer/state_store_sqlite/migrations/2024-01-18-100401_rename_fields/down.sql new file mode 100644 index 000000000..d9a93fe9a --- /dev/null +++ b/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` diff --git a/dan_layer/state_store_sqlite/migrations/2024-01-18-100401_rename_fields/up.sql b/dan_layer/state_store_sqlite/migrations/2024-01-18-100401_rename_fields/up.sql new file mode 100644 index 000000000..dbf77d91f --- /dev/null +++ b/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); + \ No newline at end of file diff --git a/dan_layer/state_store_sqlite/src/reader.rs b/dan_layer/state_store_sqlite/src/reader.rs index f4115786a..e3dbf7543 100644 --- a/dan_layer/state_store_sqlite/src/reader.rs +++ b/dan_layer/state_store_sqlite/src/reader.rs @@ -1322,7 +1322,7 @@ impl 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::(self.connection()) .map_err(|e| SqliteStorageError::DieselError { operation: "substates_get", @@ -1336,7 +1336,7 @@ impl 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::(self.connection()) .map_err(|e| SqliteStorageError::DieselError { operation: "substates_get_any", @@ -1348,13 +1348,13 @@ impl StateStoreReadTransa fn substates_any_exist, S: Borrow>( &mut self, - shard_ids: I, + addresses: I, ) -> Result { 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::(self.connection()) .map_err(|e| SqliteStorageError::DieselError { @@ -1388,13 +1388,13 @@ impl StateStoreReadTransa &mut self, start: &SubstateAddress, end: &SubstateAddress, - exclude_shards: &[SubstateAddress], + exclude: &[SubstateAddress], ) -> Result, 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::(self.connection()) .map_err(|e| SqliteStorageError::DieselError { operation: "substates_get_many_within_range", @@ -1503,7 +1503,7 @@ impl 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)>(self.connection()) .map_err(|e| SqliteStorageError::DieselError { operation: "transactions_try_lock_many", @@ -1534,21 +1534,21 @@ impl StateStoreReadTransa } // -------------------------------- LockedOutputs -------------------------------- // - fn locked_outputs_check_all(&mut self, output_shards: I) -> Result + fn locked_outputs_check_all(&mut self, output_addresses: I) -> Result where I: IntoIterator, B: Borrow, { 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::>(); 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::(self.connection()) .map_err(|e| SqliteStorageError::DieselError { operation: "locked_outputs_check_all", diff --git a/dan_layer/state_store_sqlite/src/schema.rs b/dan_layer/state_store_sqlite/src/schema.rs index 85be33f52..573b79e08 100644 --- a/dan_layer/state_store_sqlite/src/schema.rs +++ b/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, diff --git a/dan_layer/state_store_sqlite/src/sql_models/substate.rs b/dan_layer/state_store_sqlite/src/sql_models/substate.rs index 28032a392..1a98b7baa 100644 --- a/dan_layer/state_store_sqlite/src/sql_models/substate.rs +++ b/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 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)?, diff --git a/dan_layer/state_store_sqlite/src/writer.rs b/dan_layer/state_store_sqlite/src/writer.rs index 9f982df2f..87ebd777a 100644 --- a/dan_layer/state_store_sqlite/src/writer.rs +++ b/dan_layer/state_store_sqlite/src/writer.rs @@ -1029,7 +1029,7 @@ impl 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)>(self.connection()) .map_err(|e| SqliteStorageError::DieselError { operation: "transactions_try_lock_many", @@ -1059,7 +1059,7 @@ impl 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 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 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 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 StateStoreWriteTransaction for SqliteStateStoreWrit fn substate_down_many>( &mut self, - shard_ids: I, + addresses: I, epoch: Epoch, destroyed_block_id: &BlockId, destroyed_transaction_id: &TransactionId, @@ -1192,23 +1192,23 @@ impl StateStoreWriteTransaction for SqliteStateStoreWrit ) -> Result<(), StorageError> { use crate::schema::substates; - let shard_ids = shard_ids.into_iter().map(serialize_hex).collect::>(); + let addresses = addresses.into_iter().map(serialize_hex).collect::>(); 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 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 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 StateStoreWriteTransaction for SqliteStateStoreWrit &mut self, block_id: &BlockId, transaction_id: &TransactionId, - output_shards: I, + output_addresses: I, ) -> Result where I: IntoIterator, @@ -1288,13 +1288,13 @@ impl 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::>(); @@ -1317,16 +1317,16 @@ impl StateStoreWriteTransaction for SqliteStateStoreWrit Ok(lock_state) } - fn locked_outputs_release_all(&mut self, output_shards: I) -> Result, StorageError> + fn locked_outputs_release_all(&mut self, output_addresses: I) -> Result, StorageError> where I: IntoIterator, B: Borrow, { 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::>(); // let locked = locked_outputs::table @@ -1350,7 +1350,7 @@ impl 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", diff --git a/dan_layer/storage/src/consensus_models/substate.rs b/dan_layer/storage/src/consensus_models/substate.rs index b100bfacd..971b3ade3 100644 --- a/dan_layer/storage/src/consensus_models/substate.rs +++ b/dan_layer/storage/src/consensus_models/substate.rs @@ -26,7 +26,7 @@ const LOG_TARGET: &str = "tari::dan::storage::consensus_models::substate"; #[derive(Debug, Clone, Serialize, Deserialize)] pub struct SubstateRecord { - pub address: SubstateId, + pub substate_id: SubstateId, pub version: u32, pub substate_value: SubstateValue, pub state_hash: FixedHash, @@ -48,7 +48,7 @@ pub struct SubstateDestroyed { impl SubstateRecord { pub fn new( - address: SubstateId, + substate_id: SubstateId, version: u32, substate_value: SubstateValue, created_at_epoch: Epoch, @@ -58,7 +58,7 @@ impl SubstateRecord { created_justify: QcId, ) -> Self { Self { - address, + substate_id, version, substate_value, state_hash: Default::default(), @@ -72,11 +72,11 @@ impl SubstateRecord { } pub fn to_substate_address(&self) -> SubstateAddress { - SubstateAddress::from_address(&self.address, self.version) + SubstateAddress::from_address(&self.substate_id, self.version) } pub fn substate_id(&self) -> &SubstateId { - &self.address + &self.substate_id } pub fn substate_value(&self) -> &SubstateValue { @@ -275,7 +275,7 @@ pub struct SubstateCreatedProof { #[derive(Debug, Clone)] pub struct SubstateData { - pub address: SubstateId, + pub substate_id: SubstateId, pub version: u32, pub substate_value: SubstateValue, pub created_by_transaction: TransactionId, @@ -284,7 +284,7 @@ pub struct SubstateData { impl From for SubstateData { fn from(value: SubstateRecord) -> Self { Self { - address: value.address, + substate_id: value.substate_id, version: value.version, substate_value: value.substate_value, created_by_transaction: value.created_by_transaction, @@ -323,11 +323,11 @@ impl SubstateUpdate { debug!( target: LOG_TARGET, "🌲 Applying substate CREATE for {} v{}", - proof.substate.address, proof.substate.version + proof.substate.substate_id, proof.substate.version ); proof.created_qc.save(tx)?; SubstateRecord { - address: proof.substate.address, + substate_id: proof.substate.substate_id, version: proof.substate.version, substate_value: proof.substate.substate_value, state_hash: Default::default(), diff --git a/dan_layer/transaction/src/transaction.rs b/dan_layer/transaction/src/transaction.rs index b142725e9..796c924f9 100644 --- a/dan_layer/transaction/src/transaction.rs +++ b/dan_layer/transaction/src/transaction.rs @@ -179,7 +179,7 @@ impl SubstateRequirement { } } - pub fn address(&self) -> &SubstateId { + pub fn substate_id(&self) -> &SubstateId { &self.substate_id } diff --git a/dan_layer/validator_node_rpc/proto/consensus.proto b/dan_layer/validator_node_rpc/proto/consensus.proto index 75518aeef..b134369f9 100644 --- a/dan_layer/validator_node_rpc/proto/consensus.proto +++ b/dan_layer/validator_node_rpc/proto/consensus.proto @@ -179,7 +179,7 @@ message RequestedTransactionMessage { } message Substate { - bytes address = 1; + bytes substate_id = 1; uint32 version = 2; bytes substate = 3; diff --git a/dan_layer/validator_node_rpc/proto/rpc.proto b/dan_layer/validator_node_rpc/proto/rpc.proto index c50019667..2d82cdb39 100644 --- a/dan_layer/validator_node_rpc/proto/rpc.proto +++ b/dan_layer/validator_node_rpc/proto/rpc.proto @@ -169,7 +169,7 @@ message SubstateCreatedProof { // Minimal substate data message SubstateData { - bytes address = 1; + bytes substate_id = 1; uint32 version = 2; bytes substate_value = 3; bytes created_transaction = 7; diff --git a/dan_layer/validator_node_rpc/proto/transaction.proto b/dan_layer/validator_node_rpc/proto/transaction.proto index 603216599..cd67020b8 100644 --- a/dan_layer/validator_node_rpc/proto/transaction.proto +++ b/dan_layer/validator_node_rpc/proto/transaction.proto @@ -83,7 +83,7 @@ message Arg { } message SubstateRequirement { - bytes address = 1; + bytes substate_id = 1; OptionalVersion version = 2; } diff --git a/dan_layer/validator_node_rpc/src/conversions/consensus.rs b/dan_layer/validator_node_rpc/src/conversions/consensus.rs index e934dbdfa..59c23112d 100644 --- a/dan_layer/validator_node_rpc/src/conversions/consensus.rs +++ b/dan_layer/validator_node_rpc/src/conversions/consensus.rs @@ -535,7 +535,7 @@ impl TryFrom for SubstateRecord { fn try_from(value: proto::consensus::Substate) -> Result { Ok(Self { - address: SubstateId::from_bytes(&value.address)?, + substate_id: SubstateId::from_bytes(&value.substate_id)?, version: value.version, substate_value: SubstateValue::from_bytes(&value.substate)?, state_hash: Default::default(), @@ -554,7 +554,7 @@ impl TryFrom for SubstateRecord { impl From for proto::consensus::Substate { fn from(value: SubstateRecord) -> Self { Self { - address: value.address.to_bytes(), + substate_id: value.substate_id.to_bytes(), version: value.version, substate: value.substate_value.to_bytes(), diff --git a/dan_layer/validator_node_rpc/src/conversions/rpc.rs b/dan_layer/validator_node_rpc/src/conversions/rpc.rs index 23c401337..14e8e44cb 100644 --- a/dan_layer/validator_node_rpc/src/conversions/rpc.rs +++ b/dan_layer/validator_node_rpc/src/conversions/rpc.rs @@ -81,7 +81,7 @@ impl TryFrom for SubstateData { fn try_from(value: proto::rpc::SubstateData) -> Result { Ok(Self { - address: SubstateId::from_bytes(&value.address)?, + substate_id: SubstateId::from_bytes(&value.substate_id)?, version: value.version, substate_value: SubstateValue::from_bytes(&value.substate_value)?, created_by_transaction: value.created_transaction.try_into()?, @@ -92,7 +92,7 @@ impl TryFrom for SubstateData { impl From for proto::rpc::SubstateData { fn from(value: SubstateData) -> Self { Self { - address: value.address.to_bytes(), + substate_id: value.substate_id.to_bytes(), version: value.version, substate_value: value.substate_value.to_bytes(), created_transaction: value.created_by_transaction.as_bytes().to_vec(), diff --git a/dan_layer/validator_node_rpc/src/conversions/transaction.rs b/dan_layer/validator_node_rpc/src/conversions/transaction.rs index 7255d770d..d702ad8cd 100644 --- a/dan_layer/validator_node_rpc/src/conversions/transaction.rs +++ b/dan_layer/validator_node_rpc/src/conversions/transaction.rs @@ -347,9 +347,9 @@ impl TryFrom for SubstateRequirement { type Error = anyhow::Error; fn try_from(val: proto::transaction::SubstateRequirement) -> Result { - let address = SubstateId::from_bytes(&val.address)?; + let substate_id = SubstateId::from_bytes(&val.substate_id)?; let version = val.version.map(|v| v.version); - let substate_specification = SubstateRequirement::new(address, version); + let substate_specification = SubstateRequirement::new(substate_id, version); Ok(substate_specification) } } @@ -357,7 +357,7 @@ impl TryFrom for SubstateRequirement { impl From for proto::transaction::SubstateRequirement { fn from(val: SubstateRequirement) -> Self { Self { - address: val.address().to_bytes(), + substate_id: val.substate_id().to_bytes(), version: val.version().map(|v| OptionalVersion { version: v }), } } @@ -366,7 +366,7 @@ impl From for proto::transaction::SubstateRequirement { impl From<&SubstateRequirement> for proto::transaction::SubstateRequirement { fn from(val: &SubstateRequirement) -> Self { Self { - address: val.address().to_bytes(), + substate_id: val.substate_id().to_bytes(), version: val.version().map(|v| OptionalVersion { version: v }), } }