cargo fix

src/actor_store/block_map.rs

···
 
 /// Ref: https://github.com/blacksky-algorithms/rsky/blob/main/rsky-repo/src/types.rs#L341C1-L350C2
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct CommitData {
+pub(super) struct CommitData {
     pub cid: Cid,
     pub rev: String,
     pub since: Option<String>,
···
 
 /// Ref: https://github.com/blacksky-algorithms/rsky/blob/main/rsky-repo/src/cid_set.rs
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct CidSet {
+pub(super) struct CidSet {
     pub set: HashSet<String>,
 }
 impl CidSet {
-    pub fn new(arr: Option<Vec<Cid>>) -> Self {
+    pub(super) fn new(arr: Option<Vec<Cid>>) -> Self {
         let str_arr: Vec<String> = arr
             .unwrap_or(Vec::new())
             .into_iter()
···
         }
     }
 
-    pub fn add(&mut self, cid: Cid) -> () {
+    pub(super) fn add(&mut self, cid: Cid) -> () {
         let _ = &self.set.insert(cid.to_string());
         ()
     }
 
-    pub fn add_set(&mut self, to_merge: CidSet) -> () {
+    pub(super) fn add_set(&mut self, to_merge: CidSet) -> () {
         for cid in to_merge.to_list() {
             let _ = &self.add(cid);
         }
         ()
     }
 
-    pub fn subtract_set(&mut self, to_subtract: CidSet) -> () {
+    pub(super) fn subtract_set(&mut self, to_subtract: CidSet) -> () {
         for cid in to_subtract.to_list() {
             self.delete(cid);
         }
         ()
     }
 
-    pub fn delete(&mut self, cid: Cid) -> () {
+    pub(super) fn delete(&mut self, cid: Cid) -> () {
         self.set.remove(&cid.to_string());
         ()
     }
 
-    pub fn has(&self, cid: Cid) -> bool {
+    pub(super) fn has(&self, cid: Cid) -> bool {
         self.set.contains(&cid.to_string())
     }
 
-    pub fn size(&self) -> usize {
+    pub(super) fn size(&self) -> usize {
         self.set.len()
     }
 
-    pub fn clear(mut self) -> () {
+    pub(super) fn clear(mut self) -> () {
         self.set.clear();
         ()
     }
 
-    pub fn to_list(&self) -> Vec<Cid> {
+    pub(super) fn to_list(&self) -> Vec<Cid> {
         self.set
             .clone()
             .into_iter()
···
 }
 
 /// Ref: https://github.com/blacksky-algorithms/rsky/blob/main/rsky-common/src/lib.rs#L57
-pub fn struct_to_cbor<T: Serialize>(obj: &T) -> Result<Vec<u8>> {
+pub(super) fn struct_to_cbor<T: Serialize>(obj: &T) -> Result<Vec<u8>> {
     Ok(serde_ipld_dagcbor::to_vec(obj)?)
 }
 
 /// Ref: https://github.com/blacksky-algorithms/rsky/blob/37954845d06aaafea2b914d9096a1657abfc8d75/rsky-common/src/ipld.rs
 /// Create a CID for CBOR-encoded data
-pub fn cid_for_cbor<T: Serialize>(data: &T) -> Result<Cid> {
+pub(super) fn cid_for_cbor<T: Serialize>(data: &T) -> Result<Cid> {
     let bytes = struct_to_cbor(data)?;
     let multihash = atrium_repo::Multihash::wrap(
         atrium_repo::blockstore::SHA2_256,
···
 }
 
 /// Create a CID from a SHA-256 hash with the specified codec
-pub fn sha256_to_cid(hash: Vec<u8>, codec: u64) -> Cid {
+pub(super) fn sha256_to_cid(hash: Vec<u8>, codec: u64) -> Cid {
     let multihash = atrium_repo::Multihash::wrap(atrium_repo::blockstore::SHA2_256, &hash)
         .expect("valid multihash");
 
···
 }
 
 /// Create a CID from a raw SHA-256 hash (using raw codec 0x55)
-pub fn sha256_raw_to_cid(hash: Vec<u8>) -> Cid {
+pub(super) fn sha256_raw_to_cid(hash: Vec<u8>) -> Cid {
     sha256_to_cid(hash, 0x55) // 0x55 is the codec for raw
 }
 
 /// Ref: https://github.com/blacksky-algorithms/rsky/blob/main/rsky-repo/src/types.rs#L436
-pub type CarBlock = CidAndBytes;
-pub struct CidAndBytes {
+pub(super) type CarBlock = CidAndBytes;
+pub(super) struct CidAndBytes {
     pub cid: Cid,
     pub bytes: Vec<u8>,
 }
···
 // this newtype is treated the same as the underlying Vec<u8>.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(transparent)]
-pub struct Bytes(#[serde(with = "serde_bytes")] pub Vec<u8>);
+pub(super) struct Bytes(#[serde(with = "serde_bytes")] pub Vec<u8>);
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
-pub struct BlockMap {
+pub(super) struct BlockMap {
     pub map: BTreeMap<String, Bytes>,
 }
 
 impl BlockMap {
-    pub fn new() -> Self {
+    pub(super) fn new() -> Self {
         BlockMap {
             map: BTreeMap::new(),
         }
     }
 
-    pub fn add<T: Serialize>(&mut self, value: T) -> Result<Cid> {
+    pub(super) fn add<T: Serialize>(&mut self, value: T) -> Result<Cid> {
         let cid = cid_for_cbor(&value)?;
         self.set(
             cid,
···
         Ok(cid)
     }
 
-    pub fn set(&mut self, cid: Cid, bytes: Vec<u8>) -> () {
+    pub(super) fn set(&mut self, cid: Cid, bytes: Vec<u8>) -> () {
         self.map.insert(cid.to_string(), Bytes(bytes));
         ()
     }
 
-    pub fn get(&self, cid: Cid) -> Option<&Vec<u8>> {
+    pub(super) fn get(&self, cid: Cid) -> Option<&Vec<u8>> {
         self.map.get(&cid.to_string()).map(|bytes| &bytes.0)
     }
-    pub fn delete(&mut self, cid: Cid) -> Result<()> {
+    pub(super) fn delete(&mut self, cid: Cid) -> Result<()> {
         self.map.remove(&cid.to_string());
         Ok(())
     }
 
-    pub fn get_many(&mut self, cids: Vec<Cid>) -> Result<BlocksAndMissing> {
+    pub(super) fn get_many(&mut self, cids: Vec<Cid>) -> Result<BlocksAndMissing> {
         let mut missing: Vec<Cid> = Vec::new();
         let mut blocks = BlockMap::new();
         for cid in cids {
···
         Ok(BlocksAndMissing { blocks, missing })
     }
 
-    pub fn has(&self, cid: Cid) -> bool {
+    pub(super) fn has(&self, cid: Cid) -> bool {
         self.map.contains_key(&cid.to_string())
     }
 
-    pub fn clear(&mut self) -> () {
+    pub(super) fn clear(&mut self) -> () {
         self.map.clear()
     }
 
     // Not really using. Issues with closures
-    pub fn for_each(&self, cb: impl Fn(&Vec<u8>, Cid) -> ()) -> Result<()> {
+    pub(super) fn for_each(&self, cb: impl Fn(&Vec<u8>, Cid) -> ()) -> Result<()> {
         for (key, val) in self.map.iter() {
             cb(&val.0, Cid::from_str(&key)?);
         }
         Ok(())
     }
 
-    pub fn entries(&self) -> Result<Vec<CidAndBytes>> {
+    pub(super) fn entries(&self) -> Result<Vec<CidAndBytes>> {
         let mut entries: Vec<CidAndBytes> = Vec::new();
         for (cid, bytes) in self.map.iter() {
             entries.push(CidAndBytes {
···
         Ok(entries)
     }
 
-    pub fn cids(&self) -> Result<Vec<Cid>> {
+    pub(super) fn cids(&self) -> Result<Vec<Cid>> {
         Ok(self.entries()?.into_iter().map(|e| e.cid).collect())
     }
 
-    pub fn add_map(&mut self, to_add: BlockMap) -> Result<()> {
+    pub(super) fn add_map(&mut self, to_add: BlockMap) -> Result<()> {
         let results = for (cid, bytes) in to_add.map.iter() {
             self.set(Cid::from_str(cid)?, bytes.0.clone());
         };
         Ok(results)
     }
 
-    pub fn size(&self) -> usize {
+    pub(super) fn size(&self) -> usize {
         self.map.len()
     }
 
-    pub fn byte_size(&self) -> Result<usize> {
+    pub(super) fn byte_size(&self) -> Result<usize> {
         let mut size = 0;
         for (_, bytes) in self.map.iter() {
             size += bytes.0.len();
···
         Ok(size)
     }
 
-    pub fn equals(&self, other: BlockMap) -> Result<bool> {
+    pub(super) fn equals(&self, other: BlockMap) -> Result<bool> {
         if self.size() != other.size() {
             return Ok(false);
         }
···
 }
 
 #[derive(Debug)]
-pub struct BlocksAndMissing {
+pub(super) struct BlocksAndMissing {
     pub blocks: BlockMap,
     pub missing: Vec<Cid>,
 }

src/actor_store/preference/transactor.rs

···
 use super::reader::{AccountPreference, PreferenceReader, pref_in_scope, pref_match_namespace};
 
 /// Transactor for preference operations.
-pub struct PreferenceTransactor {
+pub(super) struct PreferenceTransactor {
     /// Preference reader.
     pub reader: PreferenceReader,
 }
 
 impl PreferenceTransactor {
     /// Create a new preference transactor.
-    pub fn new(db: SqlitePool, did: String) -> Self {
+    pub(super) fn new(db: SqlitePool, did: String) -> Self {
         Self {
             reader: PreferenceReader::new(db, did),
         }
     }
 
     /// Put preferences for a namespace.
-    pub async fn put_preferences(
+    pub(super) async fn put_preferences(
         &self,
         values: Vec<AccountPreference>,
         namespace: &str,

src/storage/mod.rs

···
 use anyhow::{Context as _, Result};
 use atrium_repo::{
     Cid, Repository,
-    blockstore::{AsyncBlockStoreRead, AsyncBlockStoreWrite, CarStore, Error as BlockstoreError},
+    blockstore::{AsyncBlockStoreRead, AsyncBlockStoreWrite},
 };
 use std::str::FromStr as _;