Struct CatchupSnapshot 

pub struct CatchupSnapshot {
    pub v: u8,
    pub conversation_metas: Vec<CatchupConversationEntry>,
    pub last_app_events_per_conv: Vec<CatchupAppEventEntry>,
}

[CR-13] Catchup snapshot delivered to a newly-linked device.

Populates the catchup_snapshot field of LinkingTicket so the new device boots with a populated conversation list + last-known plaintext per conversation, instead of an empty UI until peers re-Welcome.

group_state_bytes is reserved for the [CR-7] DeviceGroup-snapshot machinery; until CR-7 lands it’s always empty (Vec::new()) on every meta. The encoding is forward- compatible: a snapshot produced today will decode cleanly on a future SDK build that understands CR-7, and a future-produced snapshot decodes on today’s SDK (we just ignore the populated group_state_bytes).

last_app_events_per_conv is host-supplied — the SDK doesn’t store decrypted plaintext on its own, so the host passes through whatever it wants the new device to see on launch (typically: the last N AppEvent bytes per conversation).

Fields

v: u8

Format version. 1 today; bumped on incompatible CBOR-shape changes.

conversation_metas: Vec<CatchupConversationEntry>

Conversation list + per-conversation MLS state. group_state_bytes is empty pre-CR-7; the field is reserved so the wire format doesn’t churn when CR-7 ships.

last_app_events_per_conv: Vec<CatchupAppEventEntry>

Last-known decrypted AppEvent bytes per conversation. Host-supplied; opaque to the SDK. Each entry is keyed by ConversationId.

Implementations

impl CatchupSnapshot

pub fn empty() -> Self

Build an empty snapshot (no metas, no events). Equivalent to “no catchup data.”

pub fn encode(&self) -> Result<Vec<u8>>

CBOR-encode for inclusion in a LinkingTicket::catchup_snapshot.

Returns Err(Error::Invalid) if the encoded size exceeds CATCHUP_SNAPSHOT_HARD_CAP (256 KB). Sizes between the soft cap (64 KB) and the hard cap log a warning but still succeed — they’re suboptimal but not refused.

pub fn encode_within_cap(self) -> Result<Vec<u8>>

CBOR-encode, guaranteeing the result fits under CATCHUP_SNAPSHOT_HARD_CAP by shedding payload until it does — instead of erroring like [encode].

[encode] is the strict encoder used by conformance vectors and callers that build their own bounded snapshots. build_linking_ticket, by contrast, snapshots every conversation the user is in, so a user with many (or large) groups can blow the 256 KB ticket cap through no fault of the host — and a hard error there breaks device linking entirely (the new device can’t even join the DeviceGroup). This method makes linking degrade gracefully instead of failing:

1. Fast path — if the full snapshot already fits, return it.
2. Drop group_state_bytes (CR-7 per-group MLS state), largest first, until it fits. An empty group_state_bytes is an explicitly-supported receiver case (§CR-7): that conversation is caught up via the normal re-Welcome path instead of local import. Ping’s hosts (web + iOS) already re-admit every chat after linking, so dropping this state costs nothing functionally — only the “boot already able to decrypt” optimisation for the shed conversations.
3. If still over (pathological host-supplied last_app_events), trim last_app_events_per_conv from the tail.
4. If still over (thousands of conversation_metas), drop metas from the tail. The new device then relies fully on normal sync — identical to the pre-CR-13 empty-snapshot behaviour.

Conversation metadata is preserved as long as it fits, so the common large-account case still boots with a populated conversation list. Whatever is shed is logged.

pub fn decode(bytes: &[u8]) -> Result<Self>

Decode a CBOR-encoded snapshot. Refuses sizes over CATCHUP_SNAPSHOT_HARD_CAP to bound attacker-controlled allocation; refuses unknown v to avoid silently dropping fields a future version added.

Trait Implementations

impl Clone for CatchupSnapshot

fn clone(&self) -> CatchupSnapshot

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CatchupSnapshot

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CatchupSnapshot

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CatchupSnapshot

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.