Merge pull request #147 from cowlicks/use-hypercore-schema

Use `hypercore_schema` crate

Author: cowlicks

.clippy.toml

@@ -0,0 +1 @@
+avoid-breaking-exported-api = false

CHANGELOG.md

@@ -11,6 +11,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+* Added some new clippy lints to enforce.
+
+### Changed
+
+* `get_random_access` was renamed to `get_random_access_mut`.
+* Bumped to 2024 edition.
+* Structs that were shared with `hypercore-protocol` have been moved into a separate crate: `hypercore_schema`.
+* Dependencies update
+* Some function signatures were changed that were pass-by-value or pass-by-ref that didn't need to be.
+
+### Removed
+
+
+
+## [0.15.0] - 2025-12-25
+
+### Added
+
 * More impl's of `CompactEncoding`.
 
 ### Changed
@@ -480,5 +498,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ```
 
 <!-- next-url -->
-[Unreleased]: https://github.com/datrs/hypercore/compare/v0.14.0...HEAD
+[Unreleased]: https://github.com/datrs/hypercore/compare/v0.15.0...HEAD
+[0.15.0]: https://github.com/datrs/hypercore/compare/v0.14.0...v0.15.0
 [0.14.0]: https://github.com/datrs/hypercore/compare/v0.14.0...v0.13.0

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hypercore"
-version = "0.14.0"
+version = "0.15.0"
 license = "MIT OR Apache-2.0"
 description = "Secure, distributed, append-only log"
 documentation = "https://docs.rs/hypercore"
@@ -18,7 +18,7 @@ categories = [
   "data-structures",
   "encoding",
 ]
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 blake2 = "0.10"
@@ -42,6 +42,9 @@ moka = { version = "0.12", optional = true, features = ["sync"] }
 async-broadcast = { version = "0.7.1", optional = true }
 async-lock = {version = "3.4.0", optional = true }
 
+[dependencies.hypercore_schema]
+version = "0.2.0"
+
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 random-access-disk = { version = "3", default-features = false }
 
@@ -61,7 +64,7 @@ test-log = { version = "0.2.11", default-features = false, features = ["trace"]
 tracing-subscriber = { version = "0.3.16", features = ["env-filter", "fmt"] }
 
 [features]
-default = ["tokio", "sparse", "replication"]
+default = ["tokio", "sparse", "replication", "cache"]
 replication = ["dep:async-broadcast"]
 shared-core = ["replication", "dep:async-lock"]
 sparse = ["random-access-disk/sparse"]

benches/disk.rs

@@ -2,7 +2,7 @@ use std::time::{Duration, Instant};
 
 #[cfg(feature = "async-std")]
 use criterion::async_executor::AsyncStdExecutor;
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, black_box, criterion_group, criterion_main};
 use hypercore::{Hypercore, HypercoreBuilder, HypercoreError, Storage};
 use tempfile::Builder as TempfileBuilder;
 

benches/memory.rs

@@ -2,7 +2,7 @@ use std::time::{Duration, Instant};
 
 #[cfg(feature = "async-std")]
 use criterion::async_executor::AsyncStdExecutor;
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, black_box, criterion_group, criterion_main};
 use hypercore::{Hypercore, HypercoreBuilder, HypercoreError, Storage};
 use random_access_memory::RandomAccessMemory;
 

examples/replication.rs

@@ -1,9 +1,7 @@
 #[cfg(feature = "async-std")]
 use async_std::main as async_main;
-use hypercore::{
-    Hypercore, HypercoreBuilder, HypercoreError, PartialKeypair, RequestBlock, RequestUpgrade,
-    Storage,
-};
+use hypercore::{Hypercore, HypercoreBuilder, HypercoreError, PartialKeypair, Storage};
+use hypercore_schema::{RequestBlock, RequestUpgrade};
 use tempfile::Builder;
 #[cfg(feature = "tokio")]
 use tokio::main as async_main;
@@ -99,10 +97,12 @@ async fn replicate_index(
         .expect("Creating proof error")
         .expect("Could not get proof");
     // Then the proof is verified and applied to the replicated party.
-    assert!(replicated_hypercore
-        .verify_and_apply_proof(&proof)
-        .await
-        .expect("Verifying and applying proof failed"));
+    assert!(
+        replicated_hypercore
+            .verify_and_apply_proof(&proof)
+            .await
+            .expect("Verifying and applying proof failed")
+    );
 }
 
 fn format_res(res: Result<Option<Vec<u8>>, HypercoreError>) -> String {

src/bitfield/dynamic.rs

@@ -1,7 +1,7 @@
-use super::fixed::{FixedBitfield, FIXED_BITFIELD_BITS_LENGTH, FIXED_BITFIELD_LENGTH};
+use super::fixed::{FIXED_BITFIELD_BITS_LENGTH, FIXED_BITFIELD_LENGTH, FixedBitfield};
 use crate::{
-    common::{BitfieldUpdate, StoreInfo, StoreInfoInstruction, StoreInfoType},
     Store,
+    common::{BitfieldUpdate, StoreInfo, StoreInfoInstruction, StoreInfoType},
 };
 use futures::future::Either;
 use std::{cell::RefCell, convert::TryInto};
@@ -176,22 +176,22 @@ impl DynamicBitfield {
             // not pages that don't exist, as they can't possibly contain the value.
 
             // To keep the common case fast, first try the same page as the position
-            if let Some(p) = self.pages.get(first_page) {
-                if let Some(index) = p.borrow().index_of(value, first_index as u32) {
-                    return Some(first_page * DYNAMIC_BITFIELD_PAGE_SIZE as u64 + index as u64);
-                };
-            }
+            if let Some(p) = self.pages.get(first_page)
+                && let Some(index) = p.borrow().index_of(value, first_index as u32)
+            {
+                return Some(first_page * DYNAMIC_BITFIELD_PAGE_SIZE as u64 + index as u64);
+            };
 
             // It wasn't found on the first page, now get the keys that are bigger
             // than the given index and sort them.
             let mut keys: Vec<&u64> = self.pages.keys().filter(|key| **key > first_page).collect();
             keys.sort();
             for key in keys {
-                if let Some(p) = self.pages.get(*key) {
-                    if let Some(index) = p.borrow().index_of(value, 0) {
-                        return Some(key * DYNAMIC_BITFIELD_PAGE_SIZE as u64 + index as u64);
-                    };
-                }
+                if let Some(p) = self.pages.get(*key)
+                    && let Some(index) = p.borrow().index_of(value, 0)
+                {
+                    return Some(key * DYNAMIC_BITFIELD_PAGE_SIZE as u64 + index as u64);
+                };
             }
         } else {
             // Searching for the false value is easier as it is automatically hit on
@@ -223,11 +223,11 @@ impl DynamicBitfield {
             // not pages that don't exist, as they can't possibly contain the value.
 
             // To keep the common case fast, first try the same page as the position
-            if let Some(p) = self.pages.get(last_page) {
-                if let Some(index) = p.borrow().last_index_of(value, last_index as u32) {
-                    return Some(last_page * DYNAMIC_BITFIELD_PAGE_SIZE as u64 + index as u64);
-                };
-            }
+            if let Some(p) = self.pages.get(last_page)
+                && let Some(index) = p.borrow().last_index_of(value, last_index as u32)
+            {
+                return Some(last_page * DYNAMIC_BITFIELD_PAGE_SIZE as u64 + index as u64);
+            };
 
             // It wasn't found on the last page, now get the keys that are smaller
             // than the given index and sort them.
@@ -236,14 +236,13 @@ impl DynamicBitfield {
             keys.reverse();
 
             for key in keys {
-                if let Some(p) = self.pages.get(*key) {
-                    if let Some(index) = p
+                if let Some(p) = self.pages.get(*key)
+                    && let Some(index) = p
                         .borrow()
                         .last_index_of(value, FIXED_BITFIELD_BITS_LENGTH as u32 - 1)
-                    {
-                        return Some(key * DYNAMIC_BITFIELD_PAGE_SIZE as u64 + index as u64);
-                    };
-                }
+                {
+                    return Some(key * DYNAMIC_BITFIELD_PAGE_SIZE as u64 + index as u64);
+                };
             }
         } else {
             // Searching for the false value is easier as it is automatically hit on

src/builder.rs

@@ -5,7 +5,7 @@ use tracing::instrument;
 
 #[cfg(feature = "cache")]
 use crate::common::cache::CacheOptions;
-use crate::{core::HypercoreOptions, Hypercore, HypercoreError, PartialKeypair, Storage};
+use crate::{Hypercore, HypercoreError, PartialKeypair, Storage, core::HypercoreOptions};
 
 /// Build CacheOptions.
 #[cfg(feature = "cache")]

src/common/cache.rs

@@ -1,7 +1,7 @@
 use moka::sync::Cache;
 use std::time::Duration;
 
-use crate::Node;
+use hypercore_schema::Node;
 
 // Default to 1 year of cache
 const DEFAULT_CACHE_TTL_SEC: u64 = 31556952;

src/common/mod.rs

@@ -6,12 +6,8 @@ mod peer;
 mod store;
 
 pub use self::error::HypercoreError;
-pub use self::node::Node;
 pub(crate) use self::node::NodeByteRange;
 pub(crate) use self::peer::ValuelessProof;
-pub use self::peer::{
-    DataBlock, DataHash, DataSeek, DataUpgrade, Proof, RequestBlock, RequestSeek, RequestUpgrade,
-};
 pub use self::store::Store;
 pub(crate) use self::store::{StoreInfo, StoreInfoInstruction, StoreInfoType};