Skip to main content

rostra_client_db/
tx_ops.rs

1use std::borrow::Cow;
2use std::collections::{HashMap, HashSet};
3
4use ids::{IdsFollowersRecord, IdsUnfollowedRecord};
5use itertools::Itertools as _;
6use rand::{Rng as _, RngCore as _};
7use redb::StorageError;
8use redb_bincode::{ReadableTable, Table};
9use rostra_core::event::{
10    EventContentRaw, EventExt as _, VerifiedEvent, VerifiedEventContent, content_kind,
11};
12use rostra_core::id::{RostraId, ToShort as _};
13use rostra_core::{ContentHash, ExternalEventId, ShortEventId, Timestamp};
14use tables::EventRecord;
15use tables::event::{
16    ContentStoreRecord, EventContentResult, EventContentState, EventsMissingRecord,
17};
18use tables::ids::IdsFolloweesRecord;
19use tracing::{debug, error};
20
21use super::event_order::EventOrder;
22use super::id_self::IdSelfAccountRecord;
23use super::{
24    Database, DbError, DbResult, EventsHeadsTableRecord, InsertEventOutcome, content_rc,
25    content_store, events, events_by_time, events_content_state, events_heads, events_missing,
26    events_self, get_first_in_range, get_last_in_range, ids, ids_follow_events, ids_followees,
27    ids_followers, ids_self, tables,
28};
29use crate::{
30    IdSocialProfileRecord, IdsDataUsageRecord, LOG_TARGET, Latest, LatestEventValue,
31    SocialPostRecord, WotData, events_content_missing, ids_data_usage, ids_full, social_posts,
32    social_profiles,
33};
34
35pub(crate) trait RandomTableKey: Copy + Ord {
36    fn min_key() -> Self;
37    fn random_key() -> Self;
38    fn max_key() -> Self;
39}
40
41impl RandomTableKey for ShortEventId {
42    fn min_key() -> Self {
43        Self::ZERO
44    }
45
46    fn random_key() -> Self {
47        Self::random()
48    }
49
50    fn max_key() -> Self {
51        Self::MAX
52    }
53}
54
55impl RandomTableKey for ExternalEventId {
56    fn min_key() -> Self {
57        Self::new(RostraId::ZERO, ShortEventId::ZERO)
58    }
59
60    fn random_key() -> Self {
61        let mut rng = rand::rng();
62        let mut rostra_id = [0u8; 32];
63        let mut event_id = [0u8; 16];
64        rng.fill_bytes(&mut rostra_id);
65        rng.fill_bytes(&mut event_id);
66        Self::new(
67            RostraId::from_bytes(rostra_id),
68            ShortEventId::from_bytes(event_id),
69        )
70    }
71
72    fn max_key() -> Self {
73        Self::new(RostraId::MAX, ShortEventId::MAX)
74    }
75}
76
77impl Database {
78    /// Merge a direct content-deletion candidate into stored attribution.
79    ///
80    /// Deletion presence is monotone. Multiple direct deleters select the
81    /// greatest `(event.timestamp, ShortEventId)` so delivery order cannot
82    /// affect attribution.
83    fn merge_deleted_by_tx(
84        current: Option<ShortEventId>,
85        candidate: Option<EventOrder>,
86        events_table: &impl events::ReadableTable,
87    ) -> DbResult<Option<ShortEventId>> {
88        let Some(candidate) = candidate else {
89            return Ok(current);
90        };
91        let Some(current_id) = current else {
92            return Ok(Some(candidate.event_id()));
93        };
94
95        let current_timestamp = events_table
96            .get(&current_id)?
97            .map(|event| event.value().timestamp())
98            .ok_or(DbError::MissingDeletionAttribution {
99                event_id: current_id,
100                location: snafu::Location::new(file!(), line!(), column!()),
101            })?;
102
103        Ok(Some(
104            EventOrder::new(current_timestamp, current_id)
105                .max(candidate)
106                .event_id(),
107        ))
108    }
109
110    pub(crate) fn read_followees_tx(
111        id: RostraId,
112        ids_followees_table: &impl ids_followees::ReadableTable,
113    ) -> DbResult<HashMap<RostraId, IdsFolloweesRecord>> {
114        Ok(ids_followees_table
115            .range((id, RostraId::ZERO)..=(id, RostraId::MAX))?
116            .map(|res| res.map(|(k, v)| (k.value().1, v.value())))
117            .collect::<Result<HashMap<_, _>, _>>()?)
118    }
119    pub(crate) fn read_followees_tx_iter(
120        id: RostraId,
121        ids_followees_table: &impl ids_followees::ReadableTable,
122    ) -> DbResult<impl Iterator<Item = Result<(RostraId, IdsFolloweesRecord), StorageError>>> {
123        Ok(ids_followees_table
124            .range((id, RostraId::ZERO)..=(id, RostraId::MAX))?
125            .map_ok(|(k, v)| (k.value().1, v.value())))
126    }
127
128    pub(crate) fn read_followers_tx(
129        id: RostraId,
130        ids_followers_table: &impl ids_followers::ReadableTable,
131    ) -> DbResult<HashMap<RostraId, IdsFollowersRecord>> {
132        Ok(ids_followers_table
133            .range((id, RostraId::ZERO)..=(id, RostraId::MAX))?
134            .map(|res| res.map(|(k, v)| (k.value().1, v.value())))
135            .collect::<Result<HashMap<_, _>, _>>()?)
136    }
137
138    /// Compute the web of trust data from the given direct followees.
139    ///
140    /// The WoT includes:
141    /// - Direct followees (passed in)
142    /// - Extended followees: followees of direct followees, excluding those
143    ///   already in direct followees
144    pub(crate) fn compute_wot_tx(
145        self_id: RostraId,
146        direct_followees: &HashMap<RostraId, IdsFolloweesRecord>,
147        ids_followees_table: &impl ids_followees::ReadableTable,
148    ) -> DbResult<WotData> {
149        let mut extended = HashSet::new();
150
151        for followee_id in direct_followees.keys() {
152            // Get the followees of this followee
153            for result in Self::read_followees_tx_iter(*followee_id, ids_followees_table)? {
154                let (ext_id, _record) = result?;
155                // Don't include self or direct followees in extended
156                if ext_id != self_id && !direct_followees.contains_key(&ext_id) {
157                    extended.insert(ext_id);
158                }
159            }
160        }
161
162        Ok(WotData {
163            followees: direct_followees.clone(),
164            extended,
165        })
166    }
167
168    pub(crate) fn insert_self_event_id_tx(
169        event_id: impl Into<rostra_core::ShortEventId>,
170        events_self_table: &mut events_self::Table,
171    ) -> DbResult<()> {
172        events_self_table.insert(&event_id.into(), &())?;
173        Ok(())
174    }
175
176    /// Insert an event and perform all DAG accounting.
177    ///
178    /// This function handles event insertion and related bookkeeping:
179    ///
180    /// 1. **Identity tracking**: Records the author's full RostraId
181    /// 2. **DAG structure**: Resolves author-scoped parents, updates heads, and
182    ///    handles missing parent references
183    /// 3. **Content tracking**:
184    ///    - Non-deleted content increments RC in `content_rc`
185    ///    - Nonempty content is marked `Missing` in `events_content_state`
186    ///    - If missing content is not in `content_store`, adds it to
187    ///      `events_content_missing`
188    ///    - Content that starts Deleted skips RC and Missing and is accounted
189    ///      directly as total and deleted usage
190    /// 4. **Deletion handling**: If event is a delete, marks its target Deleted
191    ///
192    /// **Important**: This function does NOT process content side effects (like
193    /// incrementing reply counts). That happens in `process_event_content_tx`.
194    /// The `Missing` marker ensures content processing is idempotent - it
195    /// can be called multiple times for the same event without duplicate
196    /// effects.
197    ///
198    /// Returns [`InsertEventOutcome`] indicating if the event was newly
199    /// inserted or already present, along with metadata about the
200    /// insertion.
201    #[allow(clippy::too_many_arguments)]
202    pub(crate) fn insert_event_tx(
203        event: VerifiedEvent,
204        ids_full_t: &mut ids_full::Table,
205        events_table: &mut events::Table,
206        events_missing_table: &mut events_missing::Table,
207        events_heads_table: &mut events_heads::Table,
208        events_by_time_table: &mut events_by_time::Table,
209        events_content_state_table: &mut events_content_state::Table,
210        content_store_table: &mut content_store::Table,
211        content_rc_table: &mut content_rc::Table,
212        events_content_missing_table: &mut events_content_missing::Table,
213        mut ids_data_usage_table: Option<&mut ids_data_usage::Table>,
214    ) -> DbResult<InsertEventOutcome> {
215        let author = event.author();
216        let event_id = event.event_id.to_short();
217
218        ids_full_t.register(author)?;
219
220        if events_table.get(&event_id)?.is_some() {
221            return Ok(InsertEventOutcome::AlreadyPresent);
222        }
223
224        let (was_missing, is_deleted) = match events_missing_table
225            .remove(&(author, event_id))?
226            .map(|g| g.value())
227        {
228            Some(prev_missing) => {
229                // If the missing was marked as deleted, we'll record it.
230                (
231                    true,
232                    if let Some(deleted_by) = prev_missing.deleted_by {
233                        events_content_state_table
234                            .insert(&event_id, &EventContentState::Deleted { deleted_by })?;
235                        true
236                    } else {
237                        false
238                    },
239                )
240            }
241            _ => {
242                // Since nothing was expecting this event yet, it must be a "head".
243                events_heads_table.insert(&(author, event_id), &EventsHeadsTableRecord)?;
244                (false, false)
245            }
246        };
247
248        // When both parents point at same thing, process only one: one that can
249        // be responsible for deletion.
250        let parent_ids = if event.parent_aux() == event.parent_prev() {
251            vec![(event.parent_aux(), true)]
252        } else {
253            vec![(event.parent_aux(), true), (event.parent_prev(), false)]
254        };
255
256        let mut deleted_parent = None;
257
258        let mut reverted_parent_content: Option<EventContentRaw> = None;
259        let mut missing_parents = vec![];
260
261        for (parent_id, parent_is_aux) in parent_ids {
262            let Some(parent_id) = parent_id else {
263                continue;
264            };
265
266            let parent_event = events_table
267                .get(&parent_id)?
268                .map(|r| r.value())
269                .filter(|parent| parent.author() == author);
270            if let Some(parent_event_record) = parent_event {
271                if event.is_delete_parent_aux_content_set() && parent_is_aux {
272                    deleted_parent = Some(parent_id);
273
274                    let parent_content_hash = parent_event_record.content_hash();
275                    let old_state = events_content_state_table
276                        .get(&parent_id)?
277                        .map(|state| state.value());
278                    let deleted_by = Self::merge_deleted_by_tx(
279                        match old_state {
280                            Some(EventContentState::Deleted { deleted_by }) => Some(deleted_by),
281                            _ => None,
282                        },
283                        Some(EventOrder::new(event.timestamp(), event_id)),
284                        events_table,
285                    )?
286                    .expect("a direct deletion candidate always produces attribution");
287                    events_content_state_table
288                        .insert(&parent_id, &EventContentState::Deleted { deleted_by })?;
289
290                    if let Some(EventContentState::Missing {
291                        next_fetch_attempt, ..
292                    }) = old_state
293                    {
294                        events_content_missing_table.remove(&(next_fetch_attempt, parent_id))?;
295                    }
296
297                    // Decrement RC unless already decremented
298                    // (Deleted/Pruned/Invalid all decrement RC on transition).
299                    let rc_already_decremented = matches!(
300                        old_state,
301                        Some(
302                            EventContentState::Deleted { .. }
303                                | EventContentState::Pruned
304                                | EventContentState::Invalid
305                        )
306                    );
307
308                    if old_state.is_none() {
309                        // Only processed content applied projections. Bytes in
310                        // the shared store can also belong to an unprocessed
311                        // Missing event.
312                        if let Some(ContentStoreRecord(cow)) = content_store_table
313                            .get(&parent_content_hash)?
314                            .map(|g| g.value())
315                        {
316                            reverted_parent_content = Some(cow.into_owned());
317                        }
318                    }
319                    if !rc_already_decremented {
320                        // Decrement RC for the deleted content
321                        Database::decrement_content_rc_tx(parent_content_hash, content_rc_table)?;
322                    }
323
324                    // Track payload deletion for the parent's author.
325                    // Already-Deleted is skipped (no bucket change), but
326                    // Pruned/Invalid → Deleted and Missing/Processed →
327                    // Deleted all need tracking.
328                    if !matches!(old_state, Some(EventContentState::Deleted { .. })) {
329                        if let Some(ref mut usage_table) = ids_data_usage_table {
330                            let parent_author = parent_event_record.author();
331                            Database::track_payload_deletion_tx(
332                                parent_author,
333                                parent_event_record.content_len(),
334                                old_state.as_ref(),
335                                usage_table,
336                            )?;
337                        }
338                    }
339                }
340            } else {
341                // We do not have this parent yet, so we mark it as missing
342                let old_deleted_by = events_missing_table
343                    .get(&(author, parent_id))?
344                    .and_then(|record| record.value().deleted_by);
345                let deleted_by = Self::merge_deleted_by_tx(
346                    old_deleted_by,
347                    (event.is_delete_parent_aux_content_set() && parent_is_aux)
348                        .then_some(EventOrder::new(event.timestamp(), event_id)),
349                    events_table,
350                )?;
351                events_missing_table
352                    .insert(&(author, parent_id), &EventsMissingRecord { deleted_by })?;
353                missing_parents.push(parent_id);
354            }
355            // If the event was considered a "head", it shouldn't as it has a child.
356            events_heads_table.remove(&(author, parent_id))?;
357        }
358
359        events_table.insert(
360            &event_id,
361            &EventRecord {
362                signed: event.into(),
363            },
364        )?;
365        events_by_time_table.insert(&(event.timestamp(), event_id), &())?;
366
367        // Track metadata for this event
368        if let Some(ref mut usage_table) = ids_data_usage_table {
369            Database::track_new_event_tx(author, usage_table)?;
370        }
371
372        // Handle content RC and state for this event.
373        let content_hash = event.content_hash();
374        if is_deleted {
375            if let Some(ref mut usage_table) = ids_data_usage_table {
376                Database::track_new_deleted_payload_tx(author, event.content_len(), usage_table)?;
377            }
378        } else {
379            // Increment RC for the content hash (including empty content)
380            Database::increment_content_rc_tx(content_hash, content_rc_table)?;
381
382            // Track new payload (starts as missing)
383            if let Some(ref mut usage_table) = ids_data_usage_table {
384                Database::track_new_payload_tx(author, event.content_len(), usage_table)?;
385            }
386
387            if 0 < event.content_len() {
388                // Regular content: mark as Missing, check content_missing
389                events_content_state_table.insert(
390                    &event_id,
391                    &EventContentState::Missing {
392                        last_fetch_attempt: None,
393                        fetch_attempt_count: 0,
394                        next_fetch_attempt: Timestamp::ZERO,
395                    },
396                )?;
397
398                if content_store_table.get(&content_hash)?.is_none() {
399                    events_content_missing_table.insert(&(Timestamp::ZERO, event_id), &())?;
400                }
401            } else {
402                // Empty content: store it immediately, go straight to "processed"
403                if content_store_table.get(&content_hash)?.is_none() {
404                    content_store_table.insert(
405                        &content_hash,
406                        &ContentStoreRecord(Cow::Owned(EventContentRaw::new(vec![]))),
407                    )?;
408                }
409                // Move from missing to current (was tracked as missing above)
410                if let Some(ref mut usage_table) = ids_data_usage_table {
411                    Database::track_payload_processed_tx(author, event.content_len(), usage_table)?;
412                }
413            }
414        }
415
416        Ok(InsertEventOutcome::Inserted {
417            was_missing,
418            is_deleted,
419            deleted_parent,
420            reverted_parent_content,
421            missing_parents,
422        }
423        .validate())
424    }
425
426    /// Check if we should process content for this event.
427    ///
428    /// This function ensures idempotent content processing by checking the
429    /// event's state in `events_content_state`:
430    ///
431    /// - **`Missing`** → `true`: Event was inserted but content hasn't been
432    ///   processed yet. Side effects should be applied.
433    /// - **No entry** → `false`: Content was already processed. Returning false
434    ///   prevents duplicate side effects (e.g., incrementing reply_count
435    ///   twice).
436    /// - **`Deleted`/`Pruned`** → `false`: Ordinary processing is unwanted. The
437    ///   caller may separately derive immutable replacement metadata from an
438    ///   eligible Deleted social-post edit.
439    ///
440    /// After processing content, callers should remove the `Missing` marker
441    /// from `events_content_state` to indicate processing is complete.
442    pub(crate) fn can_insert_event_content_tx(
443        VerifiedEventContent { event, .. }: &VerifiedEventContent,
444        events_content_state_table: &impl events_content_state::ReadableTable,
445    ) -> DbResult<bool> {
446        let event_id = event.event_id.to_short();
447
448        // Check content state
449        if let Some(state) = events_content_state_table
450            .get(&event_id)?
451            .map(|g| g.value())
452        {
453            match state {
454                EventContentState::Missing { .. } => {
455                    // Content not yet processed, can insert
456                    return Ok(true);
457                }
458                EventContentState::Deleted { .. }
459                | EventContentState::Pruned
460                | EventContentState::Invalid => {
461                    // Content deleted, pruned, or invalid — cannot insert
462                    return Ok(false);
463                }
464            }
465        }
466
467        // No state means content was already processed (came with event or processed
468        // earlier) Return false to skip reprocessing
469        Ok(false)
470    }
471
472    /// Mark an event's content as pruned.
473    ///
474    /// In the new model, RC was incremented when the event was inserted,
475    /// so we decrement it here (unless already deleted/pruned).
476    pub(crate) fn prune_event_content_tx(
477        event_id: impl Into<ShortEventId>,
478        content_hash: ContentHash,
479        events_content_state_table: &mut events_content_state::Table,
480        content_rc_table: &mut content_rc::Table,
481        events_content_missing_table: &mut events_content_missing::Table,
482        data_usage_info: Option<(RostraId, u32, &mut ids_data_usage::Table)>,
483    ) -> DbResult<bool> {
484        let event_id = event_id.into();
485
486        // Check current state - if already deleted or pruned, handle appropriately
487        let old_state = events_content_state_table
488            .get(&event_id)?
489            .map(|g| g.value());
490
491        match old_state {
492            Some(EventContentState::Deleted { .. }) => {
493                // Already deleted, can't prune
494                return Ok(false);
495            }
496            Some(EventContentState::Invalid) => {
497                // Already invalid (RC already decremented), can't prune
498                return Ok(false);
499            }
500            Some(EventContentState::Pruned) => {
501                // Already pruned, nothing to do
502                return Ok(true);
503            }
504            Some(EventContentState::Missing { .. }) | None => {
505                // Can proceed to prune
506            }
507        }
508
509        // Not yet deleted/pruned - decrement RC and mark as pruned
510        Database::decrement_content_rc_tx(content_hash, content_rc_table)?;
511
512        // Track payload pruning
513        if let Some((author, content_len, usage_table)) = data_usage_info {
514            Database::track_payload_pruning_tx(
515                author,
516                content_len,
517                old_state.as_ref(),
518                usage_table,
519            )?;
520        }
521
522        events_content_state_table.insert(&event_id, &EventContentState::Pruned)?;
523        if let Some(EventContentState::Missing {
524            next_fetch_attempt, ..
525        }) = old_state
526        {
527            events_content_missing_table.remove(&(next_fetch_attempt, event_id))?;
528        }
529
530        Ok(true)
531    }
532
533    pub(crate) fn get_missing_events_for_id_tx(
534        author: RostraId,
535        events_missing_table: &impl events_missing::ReadableTable,
536    ) -> DbResult<Vec<ShortEventId>> {
537        Ok(events_missing_table
538            .range((author, ShortEventId::ZERO)..=(author, ShortEventId::MAX))?
539            .map(|r| r.map(|(k, _v)| k.value().1))
540            .collect::<Result<Vec<_>, _>>()?)
541    }
542
543    pub(crate) fn get_ids_with_missing_events_tx(
544        after: Option<RostraId>,
545        limit: usize,
546        events_missing_table: &impl events_missing::ReadableTable,
547    ) -> DbResult<Vec<RostraId>> {
548        if limit == 0 {
549            return Ok(Vec::new());
550        }
551        let start = after.map_or(std::ops::Bound::Unbounded, |author| {
552            std::ops::Bound::Excluded((author, ShortEventId::MAX))
553        });
554        let mut authors = Vec::with_capacity(limit);
555
556        for row in events_missing_table.range((start, std::ops::Bound::Unbounded))? {
557            let author = row?.0.value().0;
558            if authors.last() != Some(&author) {
559                authors.push(author);
560                if limit <= authors.len() {
561                    break;
562                }
563            }
564        }
565
566        Ok(authors)
567    }
568
569    pub(crate) fn get_last_id_with_missing_events_tx(
570        events_missing_table: &impl events_missing::ReadableTable,
571    ) -> DbResult<Option<RostraId>> {
572        Ok(events_missing_table
573            .range((
574                std::ops::Bound::<(RostraId, ShortEventId)>::Unbounded,
575                std::ops::Bound::<(RostraId, ShortEventId)>::Unbounded,
576            ))?
577            .next_back()
578            .transpose()?
579            .map(|(key, _)| key.value().0))
580    }
581
582    pub(crate) fn get_heads_events_tx(
583        author: RostraId,
584        events_heads_table: &impl events_heads::ReadableTable,
585    ) -> DbResult<Vec<ShortEventId>> {
586        Ok(events_heads_table
587            .range((author, ShortEventId::ZERO)..=(author, ShortEventId::MAX))?
588            .map(|r| r.map(|(k, _v)| k.value().1))
589            .collect::<Result<Vec<_>, _>>()?)
590    }
591
592    pub(crate) fn get_ids_with_heads_tx(
593        after: Option<RostraId>,
594        limit: usize,
595        events_heads_table: &impl events_heads::ReadableTable,
596    ) -> DbResult<Vec<RostraId>> {
597        if limit == 0 {
598            return Ok(Vec::new());
599        }
600        let start = after.map_or(std::ops::Bound::Unbounded, |author| {
601            std::ops::Bound::Excluded((author, ShortEventId::MAX))
602        });
603        let mut authors = Vec::with_capacity(limit);
604
605        for row in events_heads_table.range((start, std::ops::Bound::Unbounded))? {
606            let author = row?.0.value().0;
607            if authors.last() != Some(&author) {
608                authors.push(author);
609                if limit <= authors.len() {
610                    break;
611                }
612            }
613        }
614
615        Ok(authors)
616    }
617
618    pub(crate) fn count_missing_events_for_id_tx(
619        author: RostraId,
620        events_missing_table: &impl events_missing::ReadableTable,
621    ) -> DbResult<usize> {
622        Ok(events_missing_table
623            .range((author, ShortEventId::ZERO)..=(author, ShortEventId::MAX))?
624            .count())
625    }
626
627    pub(crate) fn count_heads_events_tx(
628        author: RostraId,
629        events_heads_table: &impl events_heads::ReadableTable,
630    ) -> DbResult<usize> {
631        Ok(events_heads_table
632            .range((author, ShortEventId::ZERO)..=(author, ShortEventId::MAX))?
633            .count())
634    }
635
636    pub(crate) fn get_event_tx(
637        event: impl Into<ShortEventId>,
638        events_table: &impl events::ReadableTable,
639    ) -> DbResult<Option<EventRecord>> {
640        Ok(events_table.get(&event.into())?.map(|r| r.value()))
641    }
642
643    pub(crate) fn get_social_post_tx(
644        event: impl Into<ShortEventId>,
645        social_posts_table: &impl social_posts::ReadableTable,
646    ) -> DbResult<Option<SocialPostRecord>> {
647        Ok(social_posts_table.get(&event.into())?.map(|r| r.value()))
648    }
649    pub(crate) fn has_event_tx(
650        event: impl Into<ShortEventId>,
651        events_table: &impl events::ReadableTable,
652    ) -> DbResult<bool> {
653        Ok(events_table.get(&event.into())?.is_some())
654    }
655
656    /// Get the per-event content state (not the content itself).
657    ///
658    /// To get the actual content, use `get_event_content_full_tx` which also
659    /// looks up the content from the content_store.
660    pub(crate) fn get_event_content_state_tx(
661        event: impl Into<ShortEventId>,
662        events_content_state_table: &impl events_content_state::ReadableTable,
663    ) -> DbResult<Option<EventContentState>> {
664        Ok(events_content_state_table
665            .get(&event.into())?
666            .map(|r| r.value()))
667    }
668
669    /// Get the full content for an event, including looking it up from
670    /// content_store.
671    ///
672    /// Returns:
673    /// - `None` if no state recorded for this event
674    /// - `Some(Present(content))` if content is available
675    /// - `Some(Invalid(content))` if content was invalid
676    /// - `Some(Deleted { deleted_by })` if content was deleted
677    /// - `Some(Pruned)` if content was pruned
678    /// - `Some(Missing)` if content is not in store
679    pub(crate) fn get_event_content_full_tx(
680        event_id: impl Into<ShortEventId>,
681        content_hash: ContentHash,
682        events_content_state_table: &impl events_content_state::ReadableTable,
683        content_store_table: &impl content_store::ReadableTable,
684    ) -> DbResult<Option<EventContentResult>> {
685        let event_id = event_id.into();
686
687        // Check if content is deleted or pruned
688        // Check if deleted or pruned - return corresponding result
689        if let Some(state) = events_content_state_table
690            .get(&event_id)?
691            .map(|r| r.value())
692        {
693            match state {
694                EventContentState::Missing { .. } => {
695                    // Content not yet processed - fall through to check
696                    // content_store
697                }
698                EventContentState::Deleted { deleted_by } => {
699                    return Ok(Some(EventContentResult::Deleted { deleted_by }));
700                }
701                EventContentState::Pruned => {
702                    return Ok(Some(EventContentResult::Pruned));
703                }
704                EventContentState::Invalid => {
705                    return Ok(Some(EventContentResult::Invalid));
706                }
707            }
708        }
709
710        // Not deleted/pruned/invalid - look up content from content_store
711        Ok(Some(
712            match content_store_table.get(&content_hash)?.map(|r| r.value()) {
713                Some(ContentStoreRecord(content)) => {
714                    EventContentResult::Present(content.into_owned())
715                }
716                None => EventContentResult::Missing,
717            },
718        ))
719    }
720
721    /// Check if content is available for an event.
722    ///
723    /// In the new model, content is available if:
724    /// - Event is NOT in deleted/pruned state, AND
725    /// - Content hash is in content_store
726    pub(crate) fn has_event_content_tx(
727        event_id: impl Into<ShortEventId>,
728        content_hash: ContentHash,
729        events_content_state_table: &impl events_content_state::ReadableTable,
730        content_store_table: &impl content_store::ReadableTable,
731    ) -> DbResult<bool> {
732        let event_id = event_id.into();
733
734        // If event has a content state, it means content is deleted or pruned
735        if events_content_state_table.get(&event_id)?.is_some() {
736            return Ok(false);
737        }
738
739        // Check if content is in store
740        Ok(content_store_table.get(&content_hash)?.is_some())
741    }
742
743    /// Check if content is available for an event that was marked as missing.
744    ///
745    /// This is for cases where:
746    /// - Event A was inserted but its content wasn't available yet
747    /// - Later, content arrived via event B (which has the same content hash)
748    /// - Now we want to check if event A can use that content
749    ///
750    /// In the new model, RC is managed at event insertion time, so this
751    /// function doesn't touch RC. It just checks if content is available.
752    ///
753    /// Returns `true` if content is in store and event is not deleted/pruned.
754    #[cfg(test)]
755    pub(crate) fn is_content_available_for_event_tx(
756        event_id: impl Into<ShortEventId>,
757        content_hash: ContentHash,
758        events_content_state_table: &impl events_content_state::ReadableTable,
759        content_store_table: &impl content_store::ReadableTable,
760    ) -> DbResult<bool> {
761        let event_id = event_id.into();
762
763        // Check event content state
764        if let Some(state) = events_content_state_table
765            .get(&event_id)?
766            .map(|g| g.value())
767        {
768            match state {
769                // Missing means content wasn't in store at event insertion,
770                // but it might be now - check the store
771                EventContentState::Missing { .. } => {}
772                // Deleted, pruned, or invalid means content is not available
773                EventContentState::Deleted { .. }
774                | EventContentState::Pruned
775                | EventContentState::Invalid => {
776                    return Ok(false);
777                }
778            }
779        }
780
781        // Check if content is in store
782        Ok(content_store_table.get(&content_hash)?.is_some())
783    }
784
785    pub(crate) fn insert_follow_tx(
786        author: RostraId,
787        event_order: EventOrder,
788        content: content_kind::Follow,
789        followees_table: &mut Table<(RostraId, RostraId), IdsFolloweesRecord>,
790        followers_table: &mut Table<(RostraId, RostraId), IdsFollowersRecord>,
791        follow_events_table: &mut Table<(RostraId, RostraId, Timestamp, ShortEventId), ()>,
792        unfollowed_table: &mut Table<(RostraId, RostraId), IdsUnfollowedRecord>,
793    ) -> DbResult<bool> {
794        let followee = content.followee;
795        let db_key = (author, followee);
796        let epoch_boundary = unfollowed_table
797            .get(&db_key)?
798            .map(|record| record.value())
799            .map(|record| EventOrder::new(record.ts, record.event_id));
800        if epoch_boundary.is_some_and(|boundary| event_order <= boundary) {
801            return Ok(false);
802        }
803        follow_events_table.insert(
804            &(
805                author,
806                followee,
807                event_order.timestamp(),
808                event_order.event_id(),
809            ),
810            &(),
811        )?;
812
813        let existing = followees_table.get(&db_key)?.map(|v| v.value());
814        if let Some(ref followees) = existing {
815            if event_order <= EventOrder::new(followees.latest_ts, followees.latest_event_id) {
816                let first_ts = Self::first_follow_ts_after_tx(
817                    author,
818                    followee,
819                    epoch_boundary,
820                    follow_events_table,
821                )?
822                .unwrap_or(followees.latest_ts);
823                if first_ts == followees.first_ts {
824                    return Ok(false);
825                }
826                followees_table.insert(&db_key, &followees.clone().with_first_ts(first_ts))?;
827                return Ok(true);
828            }
829        }
830
831        let timestamp = event_order.timestamp();
832        let first_ts =
833            Self::first_follow_ts_after_tx(author, followee, epoch_boundary, follow_events_table)?
834                .unwrap_or(timestamp);
835
836        let tags_selector = content.persona_tags_selector.clone();
837        let selector = content.selector();
838        followees_table.insert(
839            &db_key,
840            &IdsFolloweesRecord::new(
841                timestamp,
842                event_order.event_id(),
843                first_ts,
844                selector,
845                tags_selector,
846            ),
847        )?;
848        followers_table.insert(&(followee, author), &IdsFollowersRecord {})?;
849
850        debug!(target: LOG_TARGET, follower = %author.to_short(), followee=%followee.to_short(), "Follow update");
851
852        Ok(true)
853    }
854
855    #[allow(deprecated)]
856    pub(crate) fn insert_unfollow_tx(
857        author: RostraId,
858        event_order: EventOrder,
859        followee: RostraId,
860        followees_table: &mut Table<(RostraId, RostraId), IdsFolloweesRecord>,
861        followers_table: &mut Table<(RostraId, RostraId), IdsFollowersRecord>,
862        follow_events_table: &mut Table<(RostraId, RostraId, Timestamp, ShortEventId), ()>,
863        unfollowed_table: &mut Table<(RostraId, RostraId), IdsUnfollowedRecord>,
864    ) -> DbResult<bool> {
865        let db_key = (author, followee);
866        if let Some(unfollowed) = unfollowed_table.get(&db_key)?.map(|v| v.value()) {
867            if event_order <= EventOrder::new(unfollowed.ts, unfollowed.event_id) {
868                return Ok(false);
869            }
870        }
871
872        unfollowed_table.insert(
873            &db_key,
874            &IdsUnfollowedRecord {
875                ts: event_order.timestamp(),
876                event_id: event_order.event_id(),
877            },
878        )?;
879        Self::prune_follow_events_through_tx(author, followee, event_order, follow_events_table)?;
880
881        let existing = followees_table.get(&db_key)?.map(|v| v.value());
882        if let Some(followees) = existing {
883            if event_order < EventOrder::new(followees.latest_ts, followees.latest_event_id) {
884                let first_ts = Self::first_follow_ts_after_tx(
885                    author,
886                    followee,
887                    Some(event_order),
888                    follow_events_table,
889                )?
890                .unwrap_or(followees.latest_ts);
891                followees_table.insert(&db_key, &followees.with_first_ts(first_ts))?;
892                debug!(target: LOG_TARGET, follower = %author.to_short(), followee=%followee.to_short(), "Follow epoch boundary update");
893                return Ok(true);
894            }
895        }
896
897        followees_table.remove(&db_key)?;
898        followers_table.remove(&(followee, author))?;
899        debug!(target: LOG_TARGET, follower = %author.to_short(), followee=%followee.to_short(), "Unfollow update");
900
901        Ok(true)
902    }
903
904    /// Find the earliest follow timestamp strictly after an unfollow boundary.
905    fn first_follow_ts_after_tx(
906        author: RostraId,
907        followee: RostraId,
908        boundary: Option<EventOrder>,
909        follow_events_table: &impl ids_follow_events::ReadableTable,
910    ) -> DbResult<Option<Timestamp>> {
911        let lower = boundary
912            .map(|order| (author, followee, order.timestamp(), order.event_id()))
913            .unwrap_or((author, followee, Timestamp::ZERO, ShortEventId::ZERO));
914        let upper = (author, followee, Timestamp::MAX, ShortEventId::MAX);
915
916        for entry in follow_events_table.range(lower..=upper)? {
917            let (key, _) = entry?;
918            let (_, _, timestamp, event_id) = key.value();
919            let order = EventOrder::new(timestamp, event_id);
920            if boundary.is_none_or(|boundary| boundary < order) {
921                return Ok(Some(timestamp));
922            }
923        }
924        Ok(None)
925    }
926
927    /// Discard follow history that cannot belong to this or any later epoch.
928    fn prune_follow_events_through_tx(
929        author: RostraId,
930        followee: RostraId,
931        boundary: EventOrder,
932        follow_events_table: &mut Table<(RostraId, RostraId, Timestamp, ShortEventId), ()>,
933    ) -> DbResult<()> {
934        const BATCH_SIZE: usize = 256;
935        let range = (author, followee, Timestamp::ZERO, ShortEventId::ZERO)
936            ..=(author, followee, boundary.timestamp(), boundary.event_id());
937        loop {
938            // redb does not allow mutation while a range iterator borrows the
939            // table. Bound the temporary key set and resume from the beginning
940            // after deleting each batch.
941            let keys = follow_events_table
942                .range(range.clone())?
943                .take(BATCH_SIZE)
944                .map(|entry| entry.map(|(key, _)| key.value()))
945                .collect::<Result<Vec<_>, _>>()?;
946            let len = keys.len();
947            for key in keys {
948                follow_events_table.remove(&key)?;
949            }
950            if len < BATCH_SIZE {
951                break;
952            }
953        }
954        Ok(())
955    }
956
957    pub(crate) fn insert_latest_value_tx<K, V>(
958        timestamp: Timestamp,
959        key: &K,
960        value: V,
961        table: &mut redb_bincode::Table<'_, K, Latest<V>>,
962    ) -> DbResult<bool>
963    where
964        K: bincode::Encode + bincode::Decode<()>,
965        V: bincode::Encode + bincode::Decode<()>,
966        V: LatestEventValue,
967    {
968        let event_order = EventOrder::new(timestamp, value.event_id());
969        if let Some(existing_value) = table.get(key)?.map(|v| v.value()) {
970            if event_order <= EventOrder::new(existing_value.ts, existing_value.inner.event_id()) {
971                return Ok(false);
972            }
973        }
974
975        table.insert(
976            key,
977            &Latest {
978                ts: timestamp,
979                inner: value,
980            },
981        )?;
982
983        Ok(true)
984    }
985
986    pub(crate) fn read_self_id_tx(
987        id_self_table: &impl ids_self::ReadableTable,
988    ) -> Result<Option<IdSelfAccountRecord>, DbError> {
989        Ok(id_self_table.get(&())?.map(|v| v.value()))
990    }
991
992    pub(crate) fn write_self_id_tx(
993        self_id: RostraId,
994        id_self_table: &mut Table<(), IdSelfAccountRecord>,
995    ) -> DbResult<IdSelfAccountRecord> {
996        let id_self_record = IdSelfAccountRecord {
997            rostra_id: self_id,
998            iroh_secret: rand::rng().random(),
999        };
1000        let _ = id_self_table.insert(&(), &id_self_record)?;
1001        Ok(id_self_record)
1002    }
1003
1004    pub(crate) fn read_head_tx(
1005        self_id: RostraId,
1006        events_heads_table: &impl ReadableTable<(RostraId, ShortEventId), EventsHeadsTableRecord>,
1007    ) -> DbResult<Option<ShortEventId>> {
1008        Ok(events_heads_table
1009            .range((self_id, ShortEventId::ZERO)..=(self_id, ShortEventId::MAX))?
1010            .next()
1011            .transpose()?
1012            .map(|(k, _)| k.value().1))
1013    }
1014
1015    pub(crate) fn get_heads_tx(
1016        self_id: RostraId,
1017        events_heads_table: &impl events_heads::ReadableTable,
1018    ) -> DbResult<HashSet<ShortEventId>> {
1019        Ok(events_heads_table
1020            .range((self_id, ShortEventId::ZERO)..=(self_id, ShortEventId::MAX))?
1021            .map(|r| r.map(|(k, _)| k.value().1))
1022            .collect::<Result<HashSet<_>, _>>()?)
1023    }
1024
1025    pub(crate) fn get_social_profile_tx(
1026        id: RostraId,
1027        table: &impl social_profiles::ReadableTable,
1028    ) -> DbResult<Option<IdSocialProfileRecord>> {
1029        Ok(table.get(&id)?.map(|v| v.value().inner))
1030    }
1031
1032    pub(crate) fn get_random_table_key<K, V>(
1033        table: &impl ReadableTable<K, V>,
1034    ) -> Result<Option<K>, DbError>
1035    where
1036        K: RandomTableKey + bincode::Decode<()> + bincode::Encode,
1037        V: bincode::Decode<()> + bincode::Encode,
1038    {
1039        let pivot = K::random_key();
1040
1041        let before_pivot = K::min_key()..pivot;
1042        let after_pivot = pivot..=K::max_key();
1043
1044        if rand::rng().random() {
1045            if let Some(key) = get_first_in_range(table, after_pivot)? {
1046                return Ok(Some(key));
1047            }
1048            return get_last_in_range(table, before_pivot);
1049        }
1050
1051        if let Some(key) = get_last_in_range(table, before_pivot)? {
1052            return Ok(Some(key));
1053        }
1054        get_first_in_range(table, after_pivot)
1055    }
1056
1057    pub(crate) fn get_random_self_event(
1058        events_self_table: &impl ReadableTable<ShortEventId, ()>,
1059    ) -> Result<Option<ShortEventId>, DbError> {
1060        Self::get_random_table_key(events_self_table)
1061    }
1062
1063    pub(crate) fn read_iroh_secret_tx(
1064        ids_self_t: &impl ids_self::ReadableTable,
1065    ) -> DbResult<iroh::SecretKey> {
1066        let self_id = Self::read_self_id_tx(ids_self_t)?
1067            .expect("Must have iroh secret generated after opening");
1068        Ok(iroh::SecretKey::from_bytes(&self_id.iroh_secret))
1069    }
1070
1071    /// Increment reference count for content by its hash.
1072    ///
1073    /// Called when a new event referencing this content is inserted.
1074    pub(crate) fn increment_content_rc_tx(
1075        content_hash: ContentHash,
1076        content_rc_table: &mut content_rc::Table,
1077    ) -> DbResult<u64> {
1078        let current_count = content_rc_table
1079            .get(&content_hash)?
1080            .map(|g| g.value())
1081            .unwrap_or(0); // Default to 0 if missing (first reference)
1082
1083        let new_count = current_count + 1;
1084        content_rc_table.insert(&content_hash, &new_count)?;
1085        Ok(new_count)
1086    }
1087
1088    /// Decrement reference count for content by its hash.
1089    ///
1090    /// Called when an event's content is deleted or pruned.
1091    /// Note: This does NOT remove the content from content_store - that should
1092    /// be done separately via garbage collection when RC reaches 0.
1093    pub(crate) fn decrement_content_rc_tx(
1094        content_hash: ContentHash,
1095        content_rc_table: &mut content_rc::Table,
1096    ) -> DbResult<u64> {
1097        let current_count = match content_rc_table.get(&content_hash)?.map(|g| g.value()) {
1098            Some(count) => count,
1099            None => {
1100                // RC entry missing - this shouldn't happen in normal operation.
1101                // It means decrement was called without a corresponding increment.
1102                debug_assert!(
1103                    false,
1104                    "Decrementing RC for content with no RC entry: {content_hash}"
1105                );
1106                error!(
1107                    target: LOG_TARGET,
1108                    %content_hash,
1109                    "Decrementing RC for content with no RC entry - possible bug"
1110                );
1111                // Default to 1 to avoid underflow, will result in RC=0
1112                1
1113            }
1114        };
1115
1116        if current_count <= 1 {
1117            // Count reached 0, remove the RC entry
1118            // (content_store cleanup is separate)
1119            content_rc_table.remove(&content_hash)?;
1120            Ok(0)
1121        } else {
1122            let new_count = current_count
1123                .checked_sub(1)
1124                .expect("Reference count should never underflow");
1125            content_rc_table.insert(&content_hash, &new_count)?;
1126            Ok(new_count)
1127        }
1128    }
1129
1130    /// Get the reference count for content by its hash.
1131    #[cfg(test)]
1132    pub(crate) fn get_content_rc_tx(
1133        content_hash: ContentHash,
1134        content_rc_table: &impl content_rc::ReadableTable,
1135    ) -> DbResult<u64> {
1136        Ok(content_rc_table
1137            .get(&content_hash)?
1138            .map(|g| g.value())
1139            .unwrap_or(0)) // Default to 0 if missing
1140    }
1141
1142    // ========================================================================
1143    // Data Usage Tracking
1144    // ========================================================================
1145
1146    /// Size of event metadata in bytes (Event struct + signature).
1147    /// See rostra_core::event::Event documentation.
1148    pub const EVENT_METADATA_SIZE: u64 = 192;
1149
1150    fn get_usage_mut(
1151        author: RostraId,
1152        ids_data_usage_table: &mut ids_data_usage::Table,
1153    ) -> DbResult<IdsDataUsageRecord> {
1154        Ok(ids_data_usage_table
1155            .get(&author)?
1156            .map(|g| g.value())
1157            .unwrap_or_default())
1158    }
1159
1160    /// Track a newly inserted event (metadata only).
1161    ///
1162    /// Called once per event in `insert_event_tx`.
1163    pub(crate) fn track_new_event_tx(
1164        author: RostraId,
1165        ids_data_usage_table: &mut ids_data_usage::Table,
1166    ) -> DbResult<()> {
1167        let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1168
1169        usage.current_metadata_size += Self::EVENT_METADATA_SIZE;
1170        usage.total_metadata_size += Self::EVENT_METADATA_SIZE;
1171        usage.current_metadata_num += 1;
1172        usage.total_metadata_num += 1;
1173
1174        ids_data_usage_table.insert(&author, &usage)?;
1175        Ok(())
1176    }
1177
1178    /// Track a newly inserted payload (starts as missing).
1179    ///
1180    /// Called in `insert_event_tx` when an event with `content_len > 0` is
1181    /// inserted and not deleted. The payload is counted in total and missing
1182    /// until content is received and processed.
1183    pub(crate) fn track_new_payload_tx(
1184        author: RostraId,
1185        content_len: u32,
1186        ids_data_usage_table: &mut ids_data_usage::Table,
1187    ) -> DbResult<()> {
1188        let len = u64::from(content_len);
1189        let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1190
1191        usage.total_content_size += len;
1192        usage.total_payload_num += 1;
1193        usage.missing_payload_size += len;
1194        usage.missing_payload_num += 1;
1195
1196        ids_data_usage_table.insert(&author, &usage)?;
1197        Ok(())
1198    }
1199
1200    /// Track a newly inserted payload whose event starts in Deleted.
1201    ///
1202    /// The payload contributes directly to total and deleted usage without
1203    /// entering Missing or participating in reference counting.
1204    pub(crate) fn track_new_deleted_payload_tx(
1205        author: RostraId,
1206        content_len: u32,
1207        ids_data_usage_table: &mut ids_data_usage::Table,
1208    ) -> DbResult<()> {
1209        let len = u64::from(content_len);
1210        let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1211
1212        usage.total_content_size += len;
1213        usage.total_payload_num += 1;
1214        usage.deleted_payload_size += len;
1215        usage.deleted_payload_num += 1;
1216
1217        ids_data_usage_table.insert(&author, &usage)?;
1218        Ok(())
1219    }
1220
1221    /// Track a payload that has been processed (missing → current).
1222    ///
1223    /// Called in `process_event_content_tx` when content transitions from
1224    /// `Missing` to processed.
1225    pub(crate) fn track_payload_processed_tx(
1226        author: RostraId,
1227        content_len: u32,
1228        ids_data_usage_table: &mut ids_data_usage::Table,
1229    ) -> DbResult<()> {
1230        let len = u64::from(content_len);
1231        let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1232
1233        usage.missing_payload_size = usage.missing_payload_size.saturating_sub(len);
1234        usage.missing_payload_num = usage.missing_payload_num.saturating_sub(1);
1235        usage.current_content_size += len;
1236        usage.current_payload_num += 1;
1237
1238        ids_data_usage_table.insert(&author, &usage)?;
1239        Ok(())
1240    }
1241
1242    /// Track a payload that failed validation (missing → invalid).
1243    ///
1244    /// Called in `process_event_content_tx` when content fails deserialization.
1245    pub(crate) fn track_payload_invalid_tx(
1246        author: RostraId,
1247        content_len: u32,
1248        ids_data_usage_table: &mut ids_data_usage::Table,
1249    ) -> DbResult<()> {
1250        let len = u64::from(content_len);
1251        let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1252
1253        usage.missing_payload_size = usage.missing_payload_size.saturating_sub(len);
1254        usage.missing_payload_num = usage.missing_payload_num.saturating_sub(1);
1255        usage.invalid_payload_size += len;
1256        usage.invalid_payload_num += 1;
1257
1258        ids_data_usage_table.insert(&author, &usage)?;
1259        Ok(())
1260    }
1261
1262    /// Track a payload deletion (missing/current/invalid/pruned → deleted).
1263    ///
1264    /// `old_state` determines which bucket the payload moves from:
1265    /// - `Some(Missing)` → moves from missing to deleted
1266    /// - `Some(Invalid)` → moves from invalid to deleted
1267    /// - `Some(Pruned)` → moves from pruned to deleted
1268    /// - `None` (processed) → moves from current to deleted
1269    pub(crate) fn track_payload_deletion_tx(
1270        author: RostraId,
1271        content_len: u32,
1272        old_state: Option<&EventContentState>,
1273        ids_data_usage_table: &mut ids_data_usage::Table,
1274    ) -> DbResult<()> {
1275        let len = u64::from(content_len);
1276        let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1277
1278        match old_state {
1279            Some(EventContentState::Missing { .. }) => {
1280                usage.missing_payload_size = usage.missing_payload_size.saturating_sub(len);
1281                usage.missing_payload_num = usage.missing_payload_num.saturating_sub(1);
1282            }
1283            Some(EventContentState::Invalid) => {
1284                usage.invalid_payload_size = usage.invalid_payload_size.saturating_sub(len);
1285                usage.invalid_payload_num = usage.invalid_payload_num.saturating_sub(1);
1286            }
1287            Some(EventContentState::Pruned) => {
1288                usage.pruned_payload_size = usage.pruned_payload_size.saturating_sub(len);
1289                usage.pruned_payload_num = usage.pruned_payload_num.saturating_sub(1);
1290            }
1291            None => {
1292                usage.current_content_size = usage.current_content_size.saturating_sub(len);
1293                usage.current_payload_num = usage.current_payload_num.saturating_sub(1);
1294            }
1295            // Already deleted -- should not happen (caller guards against it)
1296            Some(EventContentState::Deleted { .. }) => {}
1297        }
1298
1299        usage.deleted_payload_size += len;
1300        usage.deleted_payload_num += 1;
1301
1302        ids_data_usage_table.insert(&author, &usage)?;
1303        Ok(())
1304    }
1305
1306    /// Track a payload pruning (missing or current → pruned).
1307    ///
1308    /// `old_state` determines which bucket the payload moves from:
1309    /// - `Some(Missing)` → moves from missing to pruned
1310    /// - `None` (processed) → moves from current to pruned
1311    pub(crate) fn track_payload_pruning_tx(
1312        author: RostraId,
1313        content_len: u32,
1314        old_state: Option<&EventContentState>,
1315        ids_data_usage_table: &mut ids_data_usage::Table,
1316    ) -> DbResult<()> {
1317        let len = u64::from(content_len);
1318        let mut usage = Self::get_usage_mut(author, ids_data_usage_table)?;
1319
1320        match old_state {
1321            Some(EventContentState::Missing { .. }) => {
1322                usage.missing_payload_size = usage.missing_payload_size.saturating_sub(len);
1323                usage.missing_payload_num = usage.missing_payload_num.saturating_sub(1);
1324            }
1325            None => {
1326                usage.current_content_size = usage.current_content_size.saturating_sub(len);
1327                usage.current_payload_num = usage.current_payload_num.saturating_sub(1);
1328            }
1329            _ => {}
1330        }
1331
1332        usage.pruned_payload_size += len;
1333        usage.pruned_payload_num += 1;
1334
1335        ids_data_usage_table.insert(&author, &usage)?;
1336        Ok(())
1337    }
1338
1339    /// Get the data usage for an identity.
1340    pub(crate) fn get_data_usage_tx(
1341        author: RostraId,
1342        ids_data_usage_table: &impl ids_data_usage::ReadableTable,
1343    ) -> DbResult<IdsDataUsageRecord> {
1344        Ok(ids_data_usage_table
1345            .get(&author)?
1346            .map(|g| g.value())
1347            .unwrap_or_default())
1348    }
1349}