@peerbit/native-backbone 0.1.2 → 0.1.4

package/src/shared_log_plan.rs

@@ -7,9 +7,10 @@ use wasm_bindgen::prelude::*;
 use crate::coordinates::{
     coordinate_core_value_to_row, decode_coordinate_value, CoordinateCoreValue,
 };
+use crate::error::BackboneError;
 use crate::js_interop::{
-    array_from_value, ensure_same_len, number_strings_to_array, parse_u64_string,
-    string_batches_from_array, strings_from_array, strings_to_array, usize_values_from_array,
+    array_from_value, ensure_same_len, parse_u64_string, string_batches_from_array,
+    strings_from_array, strings_to_array, usize_values_from_array,
 };
 use crate::NativePeerbitBackbone;
 
@@ -46,7 +47,7 @@ pub(crate) fn coordinate_commits_from_string_columns(
     next_hash_batches: Array,
     assigned_to_range_boundaries: Uint8Array,
     requested_replicas: Array,
-) -> Result<Vec<EntryCoordinateCommit>, JsValue> {
+) -> Result<Vec<EntryCoordinateCommit>, BackboneError> {
     let hashes = strings_from_array(hashes)?;
     let gids = strings_from_array(gids)?;
     let hash_numbers = strings_from_array(hash_numbers)?;
@@ -78,7 +79,7 @@ pub(crate) fn coordinate_commits_from_u64_columns(
     next_hash_batches: Array,
     assigned_to_range_boundaries: Uint8Array,
     requested_replicas: Uint32Array,
-) -> Result<Vec<EntryCoordinateCommit>, JsValue> {
+) -> Result<Vec<EntryCoordinateCommit>, BackboneError> {
     let hashes = strings_from_array(hashes)?;
     let gids = strings_from_array(gids)?;
     let hash_numbers = hash_numbers.to_vec();
@@ -99,7 +100,7 @@ pub(crate) fn coordinate_commits_from_u64_columns(
     let coordinate_total = coordinate_counts
         .iter()
         .try_fold(0usize, |sum, count| sum.checked_add(*count as usize))
-        .ok_or_else(|| JsValue::from_str("Coordinate count overflow"))?;
+        .ok_or(BackboneError::CoordinateCountOverflow)?;
     ensure_same_len(
         coordinate_total,
         coordinates.len(),
@@ -132,7 +133,7 @@ fn coordinate_commits_from_parts(
     next_hash_batches: Vec<Vec<String>>,
     assigned_to_range_boundaries: Uint8Array,
     requested_replicas: Vec<usize>,
-) -> Result<Vec<EntryCoordinateCommit>, JsValue> {
+) -> Result<Vec<EntryCoordinateCommit>, BackboneError> {
     ensure_same_len(hashes.len(), gids.len(), "coordinate commit gid")?;
     ensure_same_len(
         hashes.len(),
@@ -182,28 +183,31 @@ fn coordinate_commits_from_parts(
     Ok(commits)
 }
 
-fn coordinate_batches_from_array(values: Array) -> Result<Vec<Vec<u64>>, JsValue> {
+fn coordinate_batches_from_array(values: Array) -> Result<Vec<Vec<u64>>, BackboneError> {
     let mut out = Vec::with_capacity(values.length() as usize);
     for index in 0..values.length() {
         let value = values.get(index);
         if !Array::is_array(&value) {
-            return Err(JsValue::from_str("Expected coordinate batch array"));
+            return Err(BackboneError::ExpectedArray("coordinate batch"));
         }
         out.push(coordinate_numbers_from_array(Array::from(&value))?);
     }
     Ok(out)
 }
 
-pub(crate) fn coordinate_numbers_from_array(values: Array) -> Result<Vec<u64>, JsValue> {
+pub(crate) fn coordinate_numbers_from_array(values: Array) -> Result<Vec<u64>, BackboneError> {
     let mut out = Vec::with_capacity(values.length() as usize);
     for index in 0..values.length() {
         let value = values.get(index);
         if let Some(value) = value.as_string() {
             out.push(parse_u64_string(&value, "coordinate")?);
         } else if let Some(value) = value.as_f64() {
-            out.push(value as u64);
+            out.push(
+                crate::js_interop::checked_u64_from_f64(value)
+                    .ok_or(BackboneError::Expected("coordinate string array"))?,
+            );
         } else {
-            return Err(JsValue::from_str("Expected coordinate string array"));
+            return Err(BackboneError::Expected("coordinate string array"));
         }
     }
     Ok(out)
@@ -409,7 +413,8 @@ impl NativePeerbitBackbone {
             requested_replicas,
             0,
             Vec::new(),
-        )
+        )?;
+        Ok(())
     }
 
     pub fn delete_entry_coordinates(&mut self, hash: &str) -> bool {
@@ -421,7 +426,8 @@ impl NativePeerbitBackbone {
     pub fn delete_entry_coordinates_batch(&mut self, hashes: Array) -> Result<(), JsValue> {
         let hashes_for_core = hashes.clone();
         self.shared_log.delete_entry_coordinates_batch(hashes)?;
-        self.delete_coordinate_core_batch(hashes_for_core)
+        self.delete_coordinate_core_batch(hashes_for_core)?;
+        Ok(())
     }
 
     pub fn commit_entry_coordinates(
@@ -458,7 +464,8 @@ impl NativePeerbitBackbone {
             0,
             Vec::new(),
         )?;
-        self.delete_coordinate_core_batch(next_hashes_for_core)
+        self.delete_coordinate_core_batch(next_hashes_for_core)?;
+        Ok(())
     }
 
     pub fn commit_entry_coordinates_batch(
@@ -1330,7 +1337,7 @@ impl NativePeerbitBackbone {
         include_self: bool,
         full_replica_fallback: bool,
         include_strict_full_replica: bool,
-    ) -> Result<Option<bool>, JsValue> {
+    ) -> Result<Option<bool>, BackboneError> {
         if hashes.is_empty() {
             return Ok(Some(false));
         }
@@ -1360,7 +1367,7 @@ impl NativePeerbitBackbone {
         let Some(common_replicas) = common_replicas else {
             return Ok(Some(false));
         };
-        self.shared_log.full_replica_self_leader_for_replicas(
+        Ok(self.shared_log.full_replica_self_leader_for_replicas(
             common_replicas,
             role_age_ms,
             now,
@@ -1370,7 +1377,7 @@ impl NativePeerbitBackbone {
             include_self,
             full_replica_fallback,
             include_strict_full_replica,
-        )
+        )?)
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -1386,7 +1393,7 @@ impl NativePeerbitBackbone {
         include_self: bool,
         full_replica_fallback: bool,
         include_strict_full_replica: bool,
-    ) -> Result<Option<Vec<String>>, JsValue> {
+    ) -> Result<Option<Vec<String>>, BackboneError> {
         let empty = || Ok(None);
         if hashes.is_empty() {
             return empty();
@@ -1439,15 +1446,15 @@ impl NativePeerbitBackbone {
         &mut self,
         coordinate: CoordinateCoreValue,
         record_journal: bool,
-    ) -> Result<(), JsValue> {
-        self.shared_log.put_entry_coordinates(
+    ) -> Result<(), BackboneError> {
+        self.shared_log.put_entry_coordinates_core(
             coordinate.hash.clone(),
             coordinate.gid.clone(),
-            coordinate.hash_number.to_string(),
-            number_strings_to_array(&coordinate.coordinates),
+            coordinate.hash_number,
+            coordinate.coordinates.clone(),
             coordinate.assigned_to_range_boundary,
             coordinate.requested_replicas,
-        )?;
+        );
         self.put_coordinate_core(
             coordinate.hash,
             &coordinate.gid,
@@ -1462,3 +1469,38 @@ impl NativePeerbitBackbone {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::error::BackboneError;
+
+    #[test]
+    fn coordinate_array_error_message_matches_historical_string() {
+        // `coordinate_numbers_from_array` needs a live JS engine, but its
+        // error variant must keep rendering the exact string previously
+        // built with `JsValue::from_str`.
+        assert_eq!(
+            BackboneError::Expected("coordinate string array").to_string(),
+            "Expected coordinate string array"
+        );
+    }
+
+    #[test]
+    fn plan_error_messages_match_historical_strings() {
+        assert_eq!(
+            BackboneError::CoordinateCountOverflow.to_string(),
+            "Coordinate count overflow"
+        );
+        assert_eq!(
+            BackboneError::ExpectedArray("coordinate batch").to_string(),
+            "Expected coordinate batch array"
+        );
+    }
+
+    #[test]
+    fn shared_log_errors_render_through_the_bridge_unchanged() {
+        let inner = peerbit_shared_log_rust::SharedLogError::MissingCompactAppendFacts;
+        let expected = inner.to_string();
+        assert_eq!(BackboneError::SharedLog(inner).to_string(), expected);
+    }
+}

package/src/sync_send.rs

@@ -16,6 +16,7 @@ use peerbit_log_rust::NativeLogBlockStore;
 use peerbit_wire::sync_payload::{encode_raw_exchange_sync_payload_refs, SyncPayloadHeadRef};
 use wasm_bindgen::prelude::*;
 
+use crate::error::BackboneError;
 use crate::js_interop::{ensure_same_len, string_batches_from_array, strings_from_array};
 use crate::NativePeerbitBackbone;
 
@@ -55,6 +56,12 @@ pub(crate) fn encode_sync_payload_from_store(
     ))
 }
 
+pub(crate) fn reserved_bytes(reserved: &[u8]) -> Result<[u8; 4], BackboneError> {
+    reserved
+        .try_into()
+        .map_err(|_| BackboneError::ExpectedReservedBytes)
+}
+
 pub(crate) fn block_byte_lengths_core(blocks: &NativeLogBlockStore, hashes: &[String]) -> Vec<u32> {
     hashes
         .iter()
@@ -94,9 +101,7 @@ impl NativePeerbitBackbone {
         let hashes = strings_from_array(hashes)?;
         let gid_refrences = string_batches_from_array(gid_refrences, "sync send gid references")?;
         ensure_same_len(hashes.len(), gid_refrences.len(), "sync send heads")?;
-        let reserved: [u8; 4] = reserved
-            .try_into()
-            .map_err(|_| JsValue::from_str("expected 4 reserved bytes"))?;
+        let reserved = reserved_bytes(reserved)?;
         match encode_sync_payload_from_store(
             &self.blocks,
             topic,
@@ -164,6 +169,17 @@ mod tests {
         assert_eq!(parsed.heads.len(), 2);
     }
 
+    #[test]
+    fn reserved_bytes_require_exactly_four() {
+        assert_eq!(reserved_bytes(&[1, 2, 3, 4]).unwrap(), [1, 2, 3, 4]);
+
+        for bytes in [&[][..], &[1, 2, 3][..], &[1, 2, 3, 4, 5][..]] {
+            let error = reserved_bytes(bytes).unwrap_err();
+            assert_eq!(error, BackboneError::ExpectedReservedBytes);
+            assert_eq!(error.to_string(), "expected 4 reserved bytes");
+        }
+    }
+
     #[test]
     fn missing_blocks_fall_back() {
         let store = store_with(&[("zb2AA", vec![0xde])]);

package/src/time.rs

@@ -0,0 +1,14 @@
+#[cfg(target_arch = "wasm32")]
+#[inline]
+pub(crate) fn now_ms() -> f64 {
+    js_sys::Date::now()
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[inline]
+pub(crate) fn now_ms() -> f64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|duration| duration.as_secs_f64() * 1000.0)
+        .unwrap_or(0.0)
+}

package/src/wire_sync.rs

@@ -29,6 +29,7 @@ use peerbit_wire::{record_to_words, RECORD_FLAG_SYNC_STASHED, RECORD_WORDS};
 use std::collections::{HashMap, VecDeque};
 use wasm_bindgen::prelude::*;
 
+use crate::error::BackboneError;
 use crate::js_interop::strings_slice_to_array;
 use crate::NativePeerbitBackbone;
 
@@ -116,46 +117,48 @@ impl WireSyncCore {
         }
     }
 
-    /// Try to stash a decoded-and-verified DataMessage frame. Returns `true`
-    /// when the frame carried a raw exchange sync payload for a registered
-    /// topic addressed to this node.
+    /// Try to stash a decoded-and-verified DataMessage frame. Returns
+    /// `Ok(true)` when the frame carried a raw exchange sync payload for a
+    /// registered topic addressed to this node. The only error is the
+    /// (unreachable-by-construction) invariant breach of the frame buffer
+    /// disappearing between the checks and the take — previously a panic.
     pub(crate) fn try_stash(
         &mut self,
         frame: &mut Option<Vec<u8>>,
         data_offset: usize,
         data_length: usize,
-    ) -> bool {
+    ) -> Result<bool, BackboneError> {
         if self.topic_refs.is_empty() {
-            return false;
+            return Ok(false);
         }
         let Some(frame_bytes) = frame.as_deref() else {
-            return false;
+            return Ok(false);
         };
         let Some(payload) = frame_bytes.get(data_offset..data_offset + data_length) else {
-            return false;
+            return Ok(false);
         };
         let Ok(pubsub) = parse_pubsub_data(payload) else {
-            return false;
+            return Ok(false);
         };
         if !pubsub
             .topics
             .iter()
             .any(|topic| self.topic_refs.contains_key(topic))
         {
-            return false;
+            return Ok(false);
         }
         let Some(data) = payload.get(pubsub.data_offset..pubsub.data_offset + pubsub.data_length)
         else {
-            return false;
+            return Ok(false);
         };
         let Ok(parsed) = parse_raw_exchange_rpc_request(data) else {
-            return false;
+            return Ok(false);
         };
         let Ok(meta) = decode_frame_delivery_meta(frame_bytes) else {
-            return false;
+            return Ok(false);
         };
         if meta.variant != VARIANT_DATA || !self.delivered_locally(meta.mode.as_ref()) {
-            return false;
+            return Ok(false);
         }
 
         if self
@@ -168,7 +171,7 @@ impl WireSyncCore {
             // byte-identical. Keep the pinned entry (replacing it would reset
             // the pin) and report the frame as stashed.
             self.counters.stashed += 1;
-            return true;
+            return Ok(true);
         }
 
         let heads = parsed
@@ -180,7 +183,9 @@ impl WireSyncCore {
                 ..head
             })
             .collect();
-        let frame = frame.take().expect("frame checked above");
+        let Some(frame) = frame.take() else {
+            return Err(BackboneError::WireSyncStashFrameTaken);
+        };
         let frame_length = frame.len();
         if let Some(previous) = self.stash.insert(
             meta.id,
@@ -209,7 +214,7 @@ impl WireSyncCore {
                 self.counters.evicted += 1;
             }
         }
-        true
+        Ok(true)
     }
 
     pub(crate) fn get(&self, id: &[u8]) -> Option<&StashedSyncMessage> {
@@ -237,6 +242,24 @@ impl WireSyncCore {
         }
     }
 
+    /// Pin a stashed entry and return it for meta extraction. `Ok(None)`
+    /// means the id is not stashed; the error is the
+    /// (unreachable-by-construction) invariant breach of a just-pinned entry
+    /// missing from the stash — previously a panic.
+    pub(crate) fn pin_and_get(
+        &mut self,
+        id: &[u8],
+    ) -> Result<Option<&StashedSyncMessage>, BackboneError> {
+        if !self.pin(id) {
+            return Ok(None);
+        }
+        self.counters.meta_reads += 1;
+        match self.get(id) {
+            Some(stashed) => Ok(Some(stashed)),
+            None => Err(BackboneError::WireSyncPinnedEntryMissing),
+        }
+    }
+
     pub(crate) fn release(&mut self, id: &[u8]) -> bool {
         let Ok(id) = <&[u8; ID_LENGTH]>::try_from(id) else {
             return false;
@@ -341,11 +364,25 @@ impl NativeWireSyncSession {
         let mut words = Vec::with_capacity(records.len() * RECORD_WORDS);
         for (record, buffer) in records.iter().zip(buffers.iter_mut()) {
             let stashed = record_is_stash_candidate(record)
-                && self.core.try_stash(
+                && match self.core.try_stash(
                     buffer,
                     record.data_offset as usize,
                     record.data_length as usize,
-                );
+                ) {
+                    Ok(stashed) => stashed,
+                    // The wasm ABI of this hot-path function is frozen (it
+                    // must stay a plain Uint32Array return), so the typed
+                    // error is thrown instead of returned as a Result. NOTE:
+                    // throw_val unwinds without dropping the exported-method
+                    // borrow guard, so the session object would be unusable
+                    // afterwards ("recursive use of an object" on every
+                    // later call). Acceptable only because this path is
+                    // unreachable by construction (the frame is checked Some
+                    // above and nothing takes it in between) — the
+                    // pre-refactor expect() trapped the whole wasm instance
+                    // here instead.
+                    Err(error) => wasm_bindgen::throw_val(error.into()),
+                };
             record_to_words(record, &mut words);
             if stashed {
                 let flag_word = words.len() - RECORD_WORDS;
@@ -361,11 +398,18 @@ impl NativeWireSyncSession {
     /// fallback anymore, so the entry must survive FIFO eviction until
     /// `release` is called when processing finishes.
     pub fn stashed_meta(&mut self, id: &[u8]) -> JsValue {
-        if !self.core.pin(id) {
-            return JsValue::UNDEFINED;
-        }
-        self.core.counters.meta_reads += 1;
-        let stashed = self.core.get(id).expect("pinned above");
+        let stashed = match self.core.pin_and_get(id) {
+            Ok(Some(stashed)) => stashed,
+            Ok(None) => return JsValue::UNDEFINED,
+            // The wasm ABI is frozen (`undefined` is a valid success value,
+            // so errors cannot travel as a Result); throw the typed error.
+            // NOTE: throw_val leaks the exported-method borrow guard,
+            // leaving the session object permanently unusable — acceptable
+            // only because pin_and_get's Err path is unreachable by
+            // construction (pin() returning true implies the same-id get()
+            // succeeds).
+            Err(error) => wasm_bindgen::throw_val(error.into()),
+        };
         let hashes = Array::new();
         let gid_refrences = Array::new();
         let mut byte_lengths: Vec<u32> = Vec::with_capacity(stashed.heads.len());
@@ -566,7 +610,9 @@ mod tests {
         core.register_topic("topic".to_string());
         let (frame, data_offset, data_length) = sync_frame(7, "topic", silent_to_self(), &heads());
         let mut buffer = Some(frame.clone());
-        assert!(core.try_stash(&mut buffer, data_offset, data_length));
+        assert!(core
+            .try_stash(&mut buffer, data_offset, data_length)
+            .unwrap());
         assert!(buffer.is_none(), "stash takes frame ownership");
         assert_eq!(core.stash_len(), 1);
 
@@ -592,7 +638,9 @@ mod tests {
         let (frame, data_offset, data_length) =
             sync_frame(1, "other-topic", silent_to_self(), &heads());
         let mut buffer = Some(frame);
-        assert!(!core.try_stash(&mut buffer, data_offset, data_length));
+        assert!(!core
+            .try_stash(&mut buffer, data_offset, data_length)
+            .unwrap());
         assert!(buffer.is_some(), "rejected frames keep their buffer");
 
         let relay_mode = Some(DeliveryMode::Silent {
@@ -601,17 +649,23 @@ mod tests {
         });
         let (frame, data_offset, data_length) = sync_frame(2, "topic", relay_mode, &heads());
         let mut buffer = Some(frame);
-        assert!(!core.try_stash(&mut buffer, data_offset, data_length));
+        assert!(!core
+            .try_stash(&mut buffer, data_offset, data_length)
+            .unwrap());
 
         let (frame, data_offset, data_length) =
             sync_frame(3, "topic", Some(DeliveryMode::AnyWhere), &heads());
         let mut buffer = Some(frame);
-        assert!(core.try_stash(&mut buffer, data_offset, data_length));
+        assert!(core
+            .try_stash(&mut buffer, data_offset, data_length)
+            .unwrap());
 
         core.unregister_topic("topic");
         let (frame, data_offset, data_length) = sync_frame(4, "topic", silent_to_self(), &heads());
         let mut buffer = Some(frame);
-        assert!(!core.try_stash(&mut buffer, data_offset, data_length));
+        assert!(!core
+            .try_stash(&mut buffer, data_offset, data_length)
+            .unwrap());
     }
 
     #[test]
@@ -637,7 +691,9 @@ mod tests {
             let mut frame = frame;
             frame[2] = (index >> 8) as u8; // second byte of the 32-byte id
             let mut buffer = Some(frame);
-            assert!(core.try_stash(&mut buffer, data_offset, data_length));
+            assert!(core
+                .try_stash(&mut buffer, data_offset, data_length)
+                .unwrap());
         }
         assert_eq!(core.stash_len(), WIRE_SYNC_MAX_STASHED_MESSAGES);
         assert_eq!(core.counters.evicted, 3);
@@ -654,7 +710,9 @@ mod tests {
         core.register_topic("topic".to_string());
         let (frame, data_offset, data_length) = sync_frame(0, "topic", silent_to_self(), &heads());
         let mut buffer = Some(frame);
-        assert!(core.try_stash(&mut buffer, data_offset, data_length));
+        assert!(core
+            .try_stash(&mut buffer, data_offset, data_length)
+            .unwrap());
         assert!(core.pin(&[0u8; ID_LENGTH]));
         assert!(!core.pin(&[9u8; ID_LENGTH]), "missing ids cannot be pinned");
 
@@ -665,7 +723,9 @@ mod tests {
             let mut frame = frame;
             frame[2] = (index >> 8) as u8; // second byte of the 32-byte id
             let mut buffer = Some(frame);
-            assert!(core.try_stash(&mut buffer, data_offset, data_length));
+            assert!(core
+                .try_stash(&mut buffer, data_offset, data_length)
+                .unwrap());
         }
         assert!(core.counters.evicted > 0);
         // Pinned entry survives (the cap counts it, so the stash holds the
@@ -687,11 +747,15 @@ mod tests {
         core.register_topic("topic".to_string());
         let (frame, data_offset, data_length) = sync_frame(5, "topic", silent_to_self(), &heads());
         let mut buffer = Some(frame.clone());
-        assert!(core.try_stash(&mut buffer, data_offset, data_length));
+        assert!(core
+            .try_stash(&mut buffer, data_offset, data_length)
+            .unwrap());
         assert!(core.pin(&[5u8; ID_LENGTH]));
 
         let mut buffer = Some(frame);
-        assert!(core.try_stash(&mut buffer, data_offset, data_length));
+        assert!(core
+            .try_stash(&mut buffer, data_offset, data_length)
+            .unwrap());
         assert!(
             buffer.is_some(),
             "duplicates of pinned entries keep their buffer"
@@ -706,21 +770,68 @@ mod tests {
             frame[2] = 0xff; // distinct id space from the pinned entry
             frame[3] = (index >> 8) as u8;
             let mut buffer = Some(frame);
-            assert!(core.try_stash(&mut buffer, data_offset, data_length));
+            assert!(core
+                .try_stash(&mut buffer, data_offset, data_length)
+                .unwrap());
         }
         assert!(core.blocks(&[5u8; ID_LENGTH], None).is_some());
         assert!(core.release(&[5u8; ID_LENGTH]));
     }
 
+    #[test]
+    fn pin_and_get_resolves_stashed_entries_and_counts_meta_reads() {
+        let mut core = WireSyncCore::new("self-hash".to_string());
+        core.register_topic("topic".to_string());
+        let (frame, data_offset, data_length) = sync_frame(4, "topic", silent_to_self(), &heads());
+        let mut buffer = Some(frame);
+        assert!(core
+            .try_stash(&mut buffer, data_offset, data_length)
+            .unwrap());
+
+        assert!(
+            core.pin_and_get(&[3u8; ID_LENGTH]).unwrap().is_none(),
+            "unstashed ids resolve to None"
+        );
+        assert_eq!(
+            core.pin_and_get(&[4u8; ID_LENGTH])
+                .unwrap()
+                .unwrap()
+                .head_count(),
+            2
+        );
+        assert_eq!(core.counters.meta_reads, 1);
+        assert!(core.release(&[4u8; ID_LENGTH]));
+    }
+
+    #[test]
+    fn wire_sync_invariant_errors_render_their_messages() {
+        // Both invariant breaches replace former `expect` panics and cannot
+        // be reached through the public API (a `None` frame short-circuits
+        // `try_stash` early, and `pin` only succeeds for present entries);
+        // pin down the strings a breach would surface to JS.
+        assert_eq!(
+            BackboneError::WireSyncStashFrameTaken.to_string(),
+            "wire sync stash frame already taken"
+        );
+        assert_eq!(
+            BackboneError::WireSyncPinnedEntryMissing.to_string(),
+            "wire sync pinned stash entry missing"
+        );
+    }
+
     #[test]
     fn restashing_same_id_replaces_entry() {
         let mut core = WireSyncCore::new("self-hash".to_string());
         core.register_topic("topic".to_string());
         let (frame, data_offset, data_length) = sync_frame(9, "topic", silent_to_self(), &heads());
         let mut buffer = Some(frame.clone());
-        assert!(core.try_stash(&mut buffer, data_offset, data_length));
+        assert!(core
+            .try_stash(&mut buffer, data_offset, data_length)
+            .unwrap());
         let mut buffer = Some(frame);
-        assert!(core.try_stash(&mut buffer, data_offset, data_length));
+        assert!(core
+            .try_stash(&mut buffer, data_offset, data_length)
+            .unwrap());
         assert_eq!(core.stash_len(), 1);
         assert_eq!(core.counters.stashed, 2);
     }