fix: use Value instead of ValueDelta for AddressDelta and TxTotals

Signed-off-by: William Hankins <[email protected]>

Author: whankinsiv

common/src/types.rs

@@ -212,7 +212,7 @@ pub struct AddressDelta {
     pub created_utxos: Vec<UTxOIdentifier>,
 
     // Sums of spent and created UTxOs
-    pub sent: ValueDelta,
+    pub sent: Value,
     pub received: Value,
 }
 
@@ -2156,7 +2156,7 @@ pub struct AssetAddressEntry {
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct TxTotals {
-    pub sent: ValueDelta,
+    pub sent: Value,
     pub received: Value,
 }
 
@@ -2183,7 +2183,7 @@ impl AddAssign for AddressTotals {
 impl AddressTotals {
     pub fn apply_delta(&mut self, delta: &TxTotals) {
         self.received.lovelace += delta.received.lovelace;
-        self.sent.lovelace += delta.sent.lovelace as u64;
+        self.sent.lovelace += delta.sent.lovelace;
 
         for (policy, assets) in &delta.received.assets {
             for asset in assets {
@@ -2193,12 +2193,7 @@ impl AddressTotals {
 
         for (policy, assets) in &delta.sent.assets {
             for asset in assets {
-                Self::apply_asset(
-                    &mut self.sent.assets,
-                    *policy,
-                    asset.name,
-                    asset.amount.unsigned_abs(),
-                );
+                Self::apply_asset(&mut self.sent.assets, *policy, asset.name, asset.amount);
             }
         }
 

modules/address_state/src/state.rs

@@ -231,7 +231,7 @@ impl State {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use acropolis_common::{Address, AddressDelta, UTxOIdentifier, Value, ValueDelta};
+    use acropolis_common::{Address, AddressDelta, UTxOIdentifier, Value};
     use tempfile::tempdir;
 
     fn dummy_address() -> Address {
@@ -261,18 +261,15 @@ mod tests {
         tx_id: TxIdentifier,
         spent_utxos: Vec<UTxOIdentifier>,
         created_utxos: Vec<UTxOIdentifier>,
-        lovelace_sent: i64,
+        lovelace_sent: u64,
         lovelace_received: u64,
     ) -> AddressDelta {
         AddressDelta {
             address: addr.clone(),
             tx_identifier: tx_id,
             spent_utxos,
             created_utxos,
-            sent: ValueDelta {
-                lovelace: lovelace_sent,
-                assets: Vec::new(),
-            },
+            sent: Value::new(lovelace_sent, Vec::new()),
             received: Value::new(lovelace_received, Vec::new()),
         }
     }
@@ -331,7 +328,7 @@ mod tests {
         let tx_id_spend = TxIdentifier::new(1, 0);
 
         let created = vec![delta(&addr, tx_id_create, vec![], vec![utxo], 0, 1)];
-        let spent = vec![delta(&addr, tx_id_spend, vec![utxo], vec![], -1, 0)];
+        let spent = vec![delta(&addr, tx_id_spend, vec![utxo], vec![], 1, 0)];
         // Apply delta to volatile
         state.apply_address_deltas(&created);
 
@@ -391,7 +388,7 @@ mod tests {
             tx_id_spend_old_create_new,
             vec![utxo_old],
             vec![utxo_new],
-            -1,
+            1,
             1,
         )]);
 

modules/assets_state/src/state.rs

@@ -4,7 +4,6 @@ use std::collections::HashSet;
 
 use crate::asset_registry::{AssetId, AssetRegistry};
 use acropolis_common::{
-    math::update_value_with_delta,
     queries::assets::{AssetHistory, PolicyAssets},
     Address, AddressDelta, AssetAddressEntry, AssetInfoRecord, AssetMetadataStandard,
     AssetMintRecord, AssetName, Datum, Lovelace, NativeAssetsDelta, PolicyAsset, PolicyId,
@@ -426,12 +425,7 @@ impl State {
                         if let Some(asset_id) = registry.lookup_id(policy_id, &asset.name) {
                             if let Some(holders) = addr_map.get_mut(&asset_id) {
                                 let current = holders.entry(shelley_addr.clone()).or_insert(0);
-                                if let Err(e) = update_value_with_delta(current, asset.amount) {
-                                    error!(
-                                        "Address balance update error for {:?}: {e}",
-                                        address_delta.address
-                                    );
-                                }
+                                *current = current.saturating_sub(asset.amount);
 
                                 if *current == 0 {
                                     holders.remove(shelley_addr);
@@ -642,7 +636,7 @@ mod tests {
     use acropolis_common::{
         Address, AddressDelta, AssetInfoRecord, AssetMetadataStandard, AssetName, Datum,
         NativeAsset, NativeAssetDelta, PolicyId, ShelleyAddress, TxIdentifier, TxOutput,
-        TxUTxODeltas, UTxOIdentifier, Value, ValueDelta,
+        TxUTxODeltas, UTxOIdentifier, Value,
     };
 
     fn dummy_policy(byte: u8) -> PolicyId {
@@ -740,19 +734,47 @@ mod tests {
         serde_cbor::to_vec(&serde_cbor::Value::Map(policy_map)).unwrap()
     }
 
-    fn make_address_delta(policy_id: PolicyId, name: AssetName, amount: i64) -> AddressDelta {
+    fn make_address_delta(
+        policy_id: PolicyId,
+        name: AssetName,
+        sent_amount: u64,
+        received_amount: u64,
+    ) -> AddressDelta {
         AddressDelta {
             address: dummy_address(),
             tx_identifier: TxIdentifier::new(0, 0),
             spent_utxos: Vec::new(),
             created_utxos: Vec::new(),
-            sent: ValueDelta {
-                lovelace: 0,
-                assets: vec![(policy_id, vec![NativeAssetDelta { name, amount }])]
-                    .into_iter()
-                    .collect(),
-            },
-            received: Value::default(),
+
+            sent: Value::new(
+                0,
+                if sent_amount > 0 {
+                    vec![(
+                        policy_id,
+                        vec![NativeAsset {
+                            name,
+                            amount: sent_amount,
+                        }],
+                    )]
+                } else {
+                    vec![]
+                },
+            ),
+
+            received: Value::new(
+                0,
+                if received_amount > 0 {
+                    vec![(
+                        policy_id,
+                        vec![NativeAsset {
+                            name,
+                            amount: received_amount,
+                        }],
+                    )]
+                } else {
+                    vec![]
+                },
+            ),
         }
     }
 
@@ -1442,8 +1464,8 @@ mod tests {
             StoreTransactions::None,
         );
 
-        let delta1 = make_address_delta(policy_id, asset_name, 10);
-        let delta2 = make_address_delta(policy_id, asset_name, 15);
+        let delta1 = make_address_delta(policy_id, asset_name, 0, 10);
+        let delta2 = make_address_delta(policy_id, asset_name, 0, 15);
 
         let new_state = state.handle_address_deltas(&[delta1, delta2], &registry).unwrap();
         let addr_map = new_state.addresses.unwrap();
@@ -1475,7 +1497,7 @@ mod tests {
             StoreTransactions::None,
         );
 
-        let add_delta = make_address_delta(policy_id, asset_name, 10);
+        let add_delta = make_address_delta(policy_id, asset_name, 0, 10);
         let state_after_add = state.handle_address_deltas(&[add_delta], &registry).unwrap();
         let addr_map = state_after_add.addresses.as_ref().unwrap();
         let holders = addr_map.get(&asset_id).unwrap();
@@ -1491,7 +1513,7 @@ mod tests {
             10
         );
 
-        let remove_delta = make_address_delta(policy_id, asset_name, -10);
+        let remove_delta = make_address_delta(policy_id, asset_name, 10, 0);
         let state_after_remove =
             state_after_add.handle_address_deltas(&[remove_delta], &registry).unwrap();
         let addr_map = state_after_remove.addresses.as_ref().unwrap();

modules/stake_delta_filter/src/utils.rs

@@ -275,8 +275,8 @@ impl Tracker {
                     .map(|a| a.to_string())
                     .unwrap_or(Ok("(none)".to_owned()))
                     .unwrap_or("(???)".to_owned());
-                let lovelace_delta = event.address_delta.received.lovelace as i64
-                    - event.address_delta.sent.lovelace;
+                let lovelace_delta = (event.address_delta.received.lovelace as i64)
+                    - (event.address_delta.sent.lovelace as i64);
                 delta += lovelace_delta;
 
                 chunk.push(format!(
@@ -405,7 +405,7 @@ pub fn process_message(
             addresses_seen: HashSet::new(),
             txs_seen: HashSet::new(),
         });
-        entry.delta += d.received.lovelace as i64 - d.sent.lovelace;
+        entry.delta += (d.received.lovelace as i64) - (d.sent.lovelace as i64);
 
         if let Some(shelley) = shelley_opt {
             if entry.addresses_seen.insert(shelley.clone()) {
@@ -435,7 +435,7 @@ mod test {
     use acropolis_common::{
         messages::AddressDeltasMessage, Address, AddressDelta, BlockHash, BlockInfo, BlockStatus,
         ByronAddress, Era, ShelleyAddress, ShelleyAddressDelegationPart, ShelleyAddressPaymentPart,
-        ShelleyAddressPointer, StakeAddress, StakeCredential, ValueDelta,
+        ShelleyAddressPointer, StakeAddress, StakeCredential,
     };
     use acropolis_common::{TxIdentifier, Value};
     use bech32::{Bech32, Hrp};
@@ -448,7 +448,7 @@ mod test {
             tx_identifier: TxIdentifier::default(),
             spent_utxos: Vec::new(),
             created_utxos: Vec::new(),
-            sent: ValueDelta::default(),
+            sent: Value::default(),
             received: Value::default(),
         })
     }

modules/utxo_state/src/state.rs

@@ -3,9 +3,7 @@ use crate::volatile_index::VolatileIndex;
 use acropolis_common::{
     messages::UTXODeltasMessage, params::SECURITY_PARAMETER_K, BlockInfo, BlockStatus, TxOutput,
 };
-use acropolis_common::{
-    Address, AddressDelta, UTXOValue, UTxOIdentifier, Value, ValueDelta, ValueMap,
-};
+use acropolis_common::{Address, AddressDelta, UTXOValue, UTxOIdentifier, Value, ValueMap};
 use anyhow::Result;
 use async_trait::async_trait;
 use std::collections::HashMap;
@@ -365,7 +363,7 @@ impl State {
                     tx_identifier: tx.tx_identifier,
                     spent_utxos: entry.spent_utxos,
                     created_utxos: entry.created_utxos,
-                    sent: ValueDelta::from(entry.sent),
+                    sent: Value::from(entry.sent),
                     received: Value::from(entry.received),
                 };
                 if let Some(observer) = self.address_delta_observer.as_ref() {
@@ -771,7 +769,7 @@ mod tests {
                 &delta.address,
                 Address::Byron(ByronAddress { payload }) if payload[0] == 99
             ));
-            let lovelace_net = delta.received.lovelace as i64 - delta.sent.lovelace;
+            let lovelace_net = (delta.received.lovelace as i64) - (delta.sent.lovelace as i64);
             assert!(lovelace_net == 42 || lovelace_net == -42);
 
             let mut balance = self.balance.lock().await;
@@ -801,7 +799,7 @@ mod tests {
                                 && asset.amount == 200)
                     );
                     let key = (*policy, asset.name);
-                    *asset_balances.entry(key).or_insert(0) -= asset.amount;
+                    *asset_balances.entry(key).or_insert(0) -= asset.amount as i64;
                 }
             }
         }