fix: update UTxOIdentifier initialization to use TxHash

Author: lowhung

modules/address_state/src/state.rs

@@ -233,7 +233,7 @@ impl State {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use acropolis_common::{Address, AddressDelta, UTxOIdentifier, Value};
+    use acropolis_common::{Address, AddressDelta, TxHash, UTxOIdentifier, Value};
     use tempfile::tempdir;
 
     fn dummy_address() -> Address {
@@ -284,7 +284,7 @@ mod tests {
         let mut state = setup_state_and_store().await?;
 
         let addr = dummy_address();
-        let utxo = UTxOIdentifier::new(0, 0, 0);
+        let utxo = UTxOIdentifier::new(TxHash::default(), 0);
         let tx_id = TxIdentifier::new(0, 0);
         let deltas = vec![delta(&addr, tx_id, vec![], vec![utxo], 0, 1)];
 
@@ -295,7 +295,7 @@ mod tests {
         let utxos = state.get_address_utxos(&addr).await?;
         assert!(utxos.is_some());
         assert_eq!(utxos.as_ref().unwrap().len(), 1);
-        assert_eq!(utxos.as_ref().unwrap()[0], UTxOIdentifier::new(0, 0, 0));
+        assert_eq!(utxos.as_ref().unwrap()[0], UTxOIdentifier::new(TxHash::default(), 0));
 
         // Drain volatile to immutable
         state.volatile.epoch_start_block = 1;
@@ -305,7 +305,7 @@ mod tests {
         let utxos = state.get_address_utxos(&addr).await?;
         assert!(utxos.is_some());
         assert_eq!(utxos.as_ref().unwrap().len(), 1);
-        assert_eq!(utxos.as_ref().unwrap()[0], UTxOIdentifier::new(0, 0, 0));
+        assert_eq!(utxos.as_ref().unwrap()[0], UTxOIdentifier::new(TxHash::default(), 0));
 
         // Perisist immutable to disk
         state.immutable.persist_epoch(0, &state.config).await?;
@@ -314,7 +314,7 @@ mod tests {
         let utxos = state.get_address_utxos(&addr).await?;
         assert!(utxos.is_some());
         assert_eq!(utxos.as_ref().unwrap().len(), 1);
-        assert_eq!(utxos.as_ref().unwrap()[0], UTxOIdentifier::new(0, 0, 0));
+        assert_eq!(utxos.as_ref().unwrap()[0], UTxOIdentifier::new(TxHash::default(), 0));
 
         Ok(())
     }
@@ -326,7 +326,7 @@ mod tests {
         let mut state = setup_state_and_store().await?;
 
         let addr = dummy_address();
-        let utxo = UTxOIdentifier::new(0, 0, 0);
+        let utxo = UTxOIdentifier::new(TxHash::default(), 0);
         let tx_id_create = TxIdentifier::new(0, 0);
         let tx_id_spend = TxIdentifier::new(1, 0);
 
@@ -377,8 +377,8 @@ mod tests {
         let mut state = setup_state_and_store().await?;
 
         let addr = dummy_address();
-        let utxo_old = UTxOIdentifier::new(0, 0, 0);
-        let utxo_new = UTxOIdentifier::new(0, 1, 0);
+        let utxo_old = UTxOIdentifier::new(TxHash::default(), 0);
+        let utxo_new = UTxOIdentifier::new(TxHash::default(), 1);
         let tx_id_create_old = TxIdentifier::new(0, 0);
         let tx_id_spend_old_create_new = TxIdentifier::new(1, 0);
 

modules/assets_state/src/state.rs

@@ -688,11 +688,7 @@ mod tests {
         asset_registry::{AssetId, AssetRegistry},
         state::{AssetsStorageConfig, State, StoreTransactions, CIP67_LABEL_222, CIP68_LABEL_100},
     };
-    use acropolis_common::{
-        Address, AddressDelta, AssetInfoRecord, AssetMetadata, AssetMetadataStandard, AssetName,
-        Datum, NativeAsset, NativeAssetDelta, PolicyId, ShelleyAddress, TxIdentifier, TxOutput,
-        TxUTxODeltas, UTxOIdentifier, Value,
-    };
+    use acropolis_common::{Address, AddressDelta, AssetInfoRecord, AssetMetadata, AssetMetadataStandard, AssetName, Datum, NativeAsset, NativeAssetDelta, PolicyId, ShelleyAddress, TxHash, TxIdentifier, TxOutput, TxUTxODeltas, UTxOIdentifier, Value};
     use serde_cbor::Value as CborValue;
 
     fn dummy_policy(byte: u8) -> PolicyId {
@@ -845,7 +841,7 @@ mod tests {
 
     fn make_output(policy_id: PolicyId, asset_name: AssetName, datum: Option<Vec<u8>>) -> TxOutput {
         TxOutput {
-            utxo_identifier: UTxOIdentifier::new(0, 0, 0),
+            utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
             address: dummy_address(),
             value: Value {
                 lovelace: 0,
@@ -1263,7 +1259,7 @@ mod tests {
             StoreTransactions::None,
         );
 
-        let input = UTxOIdentifier::new(0, 0, 0);
+        let input = UTxOIdentifier::new(TxHash::default(), 0);
         let output = make_output(policy_id, name, None);
 
         let tx_deltas = TxUTxODeltas {
@@ -1428,15 +1424,15 @@ mod tests {
             tx_identifier,
             inputs: Vec::new(),
             outputs: vec![TxOutput {
-                utxo_identifier: UTxOIdentifier::new(0, 0, 0),
+                utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
                 ..output.clone()
             }],
         };
         let tx2 = TxUTxODeltas {
             tx_identifier,
             inputs: Vec::new(),
             outputs: vec![TxOutput {
-                utxo_identifier: UTxOIdentifier::new(0, 0, 1),
+                utxo_identifier: UTxOIdentifier::new(TxHash::default(), 1),
                 ..output
             }],
         };
@@ -1470,15 +1466,15 @@ mod tests {
             tx_identifier: TxIdentifier::new(9, 0),
             inputs: Vec::new(),
             outputs: vec![TxOutput {
-                utxo_identifier: UTxOIdentifier::new(9, 0, 0),
+                utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
                 ..out1
             }],
         };
         let tx2 = TxUTxODeltas {
             tx_identifier: TxIdentifier::new(10, 0),
             inputs: Vec::new(),
             outputs: vec![TxOutput {
-                utxo_identifier: UTxOIdentifier::new(10, 0, 0),
+                utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
                 ..out2
             }],
         };
@@ -1513,23 +1509,23 @@ mod tests {
             tx_identifier: TxIdentifier::new(9, 0),
             inputs: Vec::new(),
             outputs: vec![TxOutput {
-                utxo_identifier: UTxOIdentifier::new(9, 0, 0),
+                utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
                 ..base_output.clone()
             }],
         };
         let tx2 = TxUTxODeltas {
             tx_identifier: TxIdentifier::new(8, 0),
             inputs: Vec::new(),
             outputs: vec![TxOutput {
-                utxo_identifier: UTxOIdentifier::new(8, 0, 0),
+                utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
                 ..base_output.clone()
             }],
         };
         let tx3 = TxUTxODeltas {
             tx_identifier: TxIdentifier::new(7, 0),
             inputs: Vec::new(),
             outputs: vec![TxOutput {
-                utxo_identifier: UTxOIdentifier::new(7, 0, 0),
+                utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
                 ..base_output
             }],
         };

modules/utxo_state/src/state.rs

@@ -399,10 +399,7 @@ struct AddressTxMap {
 mod tests {
     use super::*;
     use crate::InMemoryImmutableUTXOStore;
-    use acropolis_common::{
-        Address, AssetName, BlockHash, ByronAddress, Datum, Era, NativeAsset, ReferenceScript,
-        TxUTxODeltas, Value,
-    };
+    use acropolis_common::{Address, AssetName, BlockHash, ByronAddress, Datum, Era, NativeAsset, ReferenceScript, TxHash, TxUTxODeltas, Value};
     use config::Config;
     use tokio::sync::Mutex;
 
@@ -449,7 +446,7 @@ mod tests {
         let reference_script_bytes = vec![0xde, 0xad, 0xbe, 0xef];
 
         let output = TxOutput {
-            utxo_identifier: UTxOIdentifier::new(0, 0, 0),
+            utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
             address: create_address(99),
             value: Value::new(
                 42,
@@ -523,7 +520,7 @@ mod tests {
     async fn observe_input_spends_utxo() {
         let mut state = new_state();
         let output = TxOutput {
-            utxo_identifier: UTxOIdentifier::new(0, 0, 0),
+            utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
             address: create_address(99),
             value: Value::new(
                 42,
@@ -562,7 +559,7 @@ mod tests {
     async fn rollback_removes_future_created_utxos() {
         let mut state = new_state();
         let output = TxOutput {
-            utxo_identifier: UTxOIdentifier::new(0, 0, 0),
+            utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
             address: create_address(99),
             value: Value::new(
                 42,
@@ -603,7 +600,7 @@ mod tests {
 
         // Create the UTXO in block 10
         let output = TxOutput {
-            utxo_identifier: UTxOIdentifier::new(0, 0, 0),
+            utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
             address: create_address(99),
             value: Value::new(
                 42,
@@ -653,7 +650,7 @@ mod tests {
     async fn prune_shifts_new_utxos_into_immutable() {
         let mut state = new_state();
         let output = TxOutput {
-            utxo_identifier: UTxOIdentifier::new(0, 0, 0),
+            utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
             address: create_address(99),
             value: Value::new(
                 42,
@@ -701,7 +698,7 @@ mod tests {
     async fn prune_deletes_old_spent_utxos() {
         let mut state = new_state();
         let output = TxOutput {
-            utxo_identifier: UTxOIdentifier::new(0, 0, 0),
+            utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
             address: create_address(99),
             value: Value::new(
                 42,
@@ -820,7 +817,7 @@ mod tests {
         state.register_address_delta_observer(observer.clone());
 
         let output = TxOutput {
-            utxo_identifier: UTxOIdentifier::new(0, 0, 0),
+            utxo_identifier: UTxOIdentifier::new(TxHash::default(), 0),
             address: create_address(99),
             value: Value::new(
                 42,

modules/utxo_state/src/volatile_index.rs

@@ -97,6 +97,7 @@ impl VolatileIndex {
 // -- Tests --
 #[cfg(test)]
 mod tests {
+    use acropolis_common::TxHash;
     use super::*;
 
     #[test]
@@ -140,47 +141,47 @@ mod tests {
         assert_eq!(Some(1), index.first_block);
         assert_eq!(2, index.blocks.len());
 
-        let utxo = UTxOIdentifier::new(42, 42, 42);
+        let utxo = UTxOIdentifier::new(TxHash::default(), 422);
         index.add_utxo(&utxo);
 
         assert!(index.blocks[0].is_empty());
         assert!(!index.blocks[1].is_empty());
-        assert_eq!(42, index.blocks[1][0].output_index());
+        assert_eq!(422, index.blocks[1][0].output_index);
     }
 
     #[test]
     fn prune_before_deletes_and_calls_back_with_utxos() {
         let mut index = VolatileIndex::new();
         index.add_block(1);
-        index.add_utxo(&UTxOIdentifier::new(1, 1, 1));
-        index.add_utxo(&UTxOIdentifier::new(2, 2, 2));
+        index.add_utxo(&UTxOIdentifier::new(TxHash::default(), 1));
+        index.add_utxo(&UTxOIdentifier::new(TxHash::default(), 2));
         index.add_block(2);
-        index.add_utxo(&UTxOIdentifier::new(3, 3, 3));
+        index.add_utxo(&UTxOIdentifier::new(TxHash::default(), 3));
 
         let pruned = index.prune_before(2);
         assert_eq!(Some(2), index.first_block);
         assert_eq!(1, index.blocks.len());
         assert_eq!(2, pruned.len());
-        assert_eq!(1, pruned[0].output_index());
-        assert_eq!(2, pruned[1].output_index());
+        assert_eq!(1, pruned[0].output_index);
+        assert_eq!(2, pruned[1].output_index);
     }
 
     #[test]
     fn prune_on_or_after_deletes_and_calls_back_with_utxos() {
         let mut index = VolatileIndex::new();
         index.add_block(1);
-        index.add_utxo(&UTxOIdentifier::new(1, 1, 1));
-        index.add_utxo(&UTxOIdentifier::new(2, 2, 2));
+        index.add_utxo(&UTxOIdentifier::new(TxHash::default(), 1));
+        index.add_utxo(&UTxOIdentifier::new(TxHash::default(), 2));
         index.add_block(2);
-        index.add_utxo(&UTxOIdentifier::new(3, 3, 3));
+        index.add_utxo(&UTxOIdentifier::new(TxHash::default(), 3));
         let pruned = index.prune_on_or_after(1);
         assert_eq!(Some(1), index.first_block);
         assert_eq!(0, index.blocks.len());
         assert_eq!(3, pruned.len());
 
         // Note reverse order of blocks
-        assert_eq!(3, pruned[0].output_index());
-        assert_eq!(1, pruned[1].output_index());
-        assert_eq!(2, pruned[2].output_index());
+        assert_eq!(3, pruned[0].output_index);
+        assert_eq!(1, pruned[1].output_index);
+        assert_eq!(2, pruned[2].output_index);
     }
 }