Handler & SubductionBuilder (#77)

Author: expede

nix/home-manager-module.nix

@@ -9,7 +9,7 @@ in {
   options.services.subduction = {
     package = lib.mkOption {
       type = lib.types.package;
-      default = self.packages.${pkgs.system}.subduction_cli;
+      default = self.packages.${pkgs.stdenv.hostPlatform.system}.subduction_cli;
       defaultText = lib.literalExpression "pkgs.subduction_cli";
       description = "The Subduction CLI package to use.";
     };

nix/nixos-module.nix

@@ -9,7 +9,7 @@ in {
   options.services.subduction = {
     package = lib.mkOption {
       type = lib.types.package;
-      default = self.packages.${pkgs.system}.subduction_cli;
+      default = self.packages.${pkgs.stdenv.hostPlatform.system}.subduction_cli;
       defaultText = lib.literalExpression "pkgs.subduction_cli";
       description = "The Subduction CLI package to use.";
     };

sedimentree_core/src/codec/decode.rs

@@ -5,15 +5,40 @@ use super::{
     schema::Schema,
 };
 
-/// Decode a type from its canonical binary representation.
+/// Decode a type from its complete wire representation.
 ///
-/// Types implementing this trait can be parsed from received bytes.
-pub trait Decode: Schema + Sized {
+/// This is the generic decoding trait for any type that can be
+/// deserialized from bytes, including both message envelopes
+/// and signed payloads.
+pub trait Decode: Sized {
     /// Minimum valid encoded size (for early rejection).
-    ///
-    /// This is the size of the full signed message (schema + issuer + fields + signature).
     const MIN_SIZE: usize;
 
+    /// Decode from complete wire bytes.
+    ///
+    /// The buffer should contain the full encoded representation
+    /// of the type, including any framing or headers.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`DecodeError`] if the buffer is malformed, too short,
+    /// contains invalid values, or fails validation.
+    fn try_decode(buf: &[u8]) -> Result<Self, DecodeError>;
+}
+
+/// Decode the fields portion of a signed payload.
+///
+/// This trait is for types that live inside [`Signed<T>`] envelopes.
+/// The `buf` passed to [`try_decode_fields`](DecodeFields::try_decode_fields)
+/// contains only the type-specific fields (after schema + issuer,
+/// before signature), not the full wire message.
+///
+/// [`Signed<T>`]: https://docs.rs/subduction_crypto/latest/subduction_crypto/signed/struct.Signed.html
+pub trait DecodeFields: Schema + Sized {
+    /// Minimum valid size of the full signed message
+    /// (schema + issuer + fields + signature), for early rejection.
+    const MIN_SIGNED_SIZE: usize;
+
     /// Decode type-specific fields from the buffer.
     ///
     /// `buf` contains only the fields portion (after schema + issuer,

sedimentree_core/src/fragment.rs

@@ -11,7 +11,7 @@ use id::FragmentId;
 use crate::{
     blob::{Blob, BlobMeta, has_meta::HasBlobMeta},
     codec::{
-        decode::{self, Decode},
+        decode::{self, DecodeFields},
         encode::{self, EncodeFields},
         error::{Bijou64Error, BufferTooShort, DecodeError, ReadingType},
         schema::{self, Schema},
@@ -335,8 +335,8 @@ impl EncodeFields for Fragment {
     }
 }
 
-impl Decode for Fragment {
-    const MIN_SIZE: usize = CODEC_MIN_SIZE;
+impl DecodeFields for Fragment {
+    const MIN_SIGNED_SIZE: usize = CODEC_MIN_SIZE;
 
     fn try_decode_fields(buf: &[u8]) -> Result<Self, DecodeError> {
         if buf.len() < CODEC_MIN_FIELDS_SIZE {
@@ -472,7 +472,7 @@ mod tests {
         #[test]
         fn min_size_is_correct() {
             // Schema(4) + IssuerVK(32) + SedimentreeId(32) + Head(32) + BlobDigest(32) + BndryCnt(1) + CkptCnt(2) + BlobSize(bijou64 min=1) + Signature(64)
-            assert_eq!(Fragment::MIN_SIZE, 200);
+            assert_eq!(Fragment::MIN_SIGNED_SIZE, 200);
         }
     }
     use alloc::collections::BTreeSet;
@@ -691,7 +691,7 @@ mod tests {
     mod proptests {
         use crate::{
             codec::{
-                decode::Decode,
+                decode::DecodeFields,
                 encode::{Encode, EncodeFields},
             },
             commit::CountLeadingZeroBytes,

sedimentree_core/src/loose_commit.rs

@@ -9,7 +9,7 @@ use id::CommitId;
 use crate::{
     blob::{Blob, BlobMeta, has_meta::HasBlobMeta},
     codec::{
-        decode::{self, Decode},
+        decode::{self, DecodeFields},
         encode::{self, EncodeFields},
         error::{Bijou64Error, BufferTooShort, DecodeError, ReadingType},
         schema::{self, Schema},
@@ -132,8 +132,8 @@ impl EncodeFields for LooseCommit {
     }
 }
 
-impl Decode for LooseCommit {
-    const MIN_SIZE: usize = CODEC_MIN_SIZE;
+impl DecodeFields for LooseCommit {
+    const MIN_SIGNED_SIZE: usize = CODEC_MIN_SIZE;
 
     fn try_decode_fields(buf: &[u8]) -> Result<Self, DecodeError> {
         if buf.len() < CODEC_MIN_FIELDS_SIZE {
@@ -233,7 +233,7 @@ mod tests {
     #[test]
     fn codec_min_size_is_correct() {
         // Schema(4) + IssuerVK(32) + SedimentreeId(32) + BlobDigest(32) + ParentCnt(1) + BlobSize(bijou64 min=1) + Signature(64)
-        assert_eq!(LooseCommit::MIN_SIZE, 166);
+        assert_eq!(LooseCommit::MIN_SIGNED_SIZE, 166);
     }
 }
 

sedimentree_wasm/src/storage.rs

@@ -11,7 +11,7 @@ use futures::future::LocalBoxFuture;
 use js_sys::{Promise, Uint8Array};
 use sedimentree_core::{
     blob::Blob,
-    codec::{decode::Decode, encode::Encode, error::DecodeError},
+    codec::{decode::DecodeFields, encode::Encode, error::DecodeError},
     crypto::digest::Digest,
     fragment::Fragment,
     id::{BadSedimentreeId, SedimentreeId},
@@ -154,7 +154,7 @@ impl core::fmt::Debug for JsStorage {
 /// Parse a JS array of digests.
 ///
 /// Returns an error if any element cannot be cast to a `Digest`.
-fn parse_digest_array<T: Encode + Decode>(
+fn parse_digest_array<T: Encode + DecodeFields>(
     js_value: &JsValue,
 ) -> Result<Set<Digest<T>>, JsStorageError> {
     let array = js_sys::Array::from(js_value);

subduction_cli/src/server.rs

@@ -7,9 +7,7 @@ use std::{net::SocketAddr, path::PathBuf, time::Duration};
 
 use eyre::Result;
 use iroh::EndpointAddr;
-use sedimentree_core::{
-    commit::CountLeadingZeroBytes, id::SedimentreeId, sedimentree::Sedimentree,
-};
+use sedimentree_core::commit::CountLeadingZeroBytes;
 use sedimentree_fs_storage::FsStorage;
 use subduction_core::{
     connection::{
@@ -18,9 +16,8 @@ use subduction_core::{
     },
     peer::id::PeerId,
     policy::open::OpenPolicy,
-    sharded_map::ShardedMap,
     storage::metrics::{MetricsStorage, RefreshMetrics},
-    subduction::{Subduction, pending_blob_requests::DEFAULT_MAX_PENDING_BLOB_REQUESTS},
+    subduction::{Subduction, builder::SubductionBuilder},
     timestamp::TimestampSeconds,
 };
 use subduction_crypto::{nonce::Nonce, signer::memory::MemorySigner};
@@ -203,20 +200,18 @@ pub(crate) async fn run(args: ServerArgs, token: CancellationToken) -> Result<()
     let discovery_id = Some(DiscoveryId::new(service_name.as_bytes()));
     let discovery_audience: Option<Audience> = discovery_id.map(Audience::discover_id);
 
-    let sedimentrees: ShardedMap<SedimentreeId, Sedimentree> = ShardedMap::new();
+    // Build the Subduction instance with all defaults
+    let mut builder = SubductionBuilder::new()
+        .signer(signer.clone())
+        .storage(storage, Arc::new(OpenPolicy))
+        .spawner(TokioSpawn);
 
-    // Create the unified Subduction instance (parameterized over UnifiedTransport)
-    let (subduction, listener_fut, manager_fut): (CliSubduction, _, _) = Subduction::new(
-        discovery_id,
-        signer.clone(),
-        storage,
-        OpenPolicy,
-        NonceCache::default(),
-        CountLeadingZeroBytes,
-        sedimentrees,
-        TokioSpawn,
-        DEFAULT_MAX_PENDING_BLOB_REQUESTS,
-    );
+    if let Some(id) = discovery_id {
+        builder = builder.discovery_id(id);
+    }
+
+    let (subduction, _handler, listener_fut, manager_fut): (CliSubduction, _, _, _) =
+        builder.build();
 
     let server_peer_id = subduction.peer_id();
 

subduction_cli/tests/iroh_e2e.rs

@@ -31,11 +31,10 @@ use std::{
 use future_form::Sendable;
 use sedimentree_core::{blob::Blob, commit::CountLeadingZeroBytes, id::SedimentreeId};
 use subduction_core::{
-    connection::{nonce_cache::NonceCache, test_utils::TokioSpawn},
+    connection::test_utils::TokioSpawn,
     policy::open::OpenPolicy,
-    sharded_map::ShardedMap,
     storage::memory::MemoryStorage,
-    subduction::{Subduction, pending_blob_requests::DEFAULT_MAX_PENDING_BLOB_REQUESTS},
+    subduction::{Subduction, builder::SubductionBuilder},
     timestamp::TimestampSeconds,
 };
 use subduction_crypto::signer::memory::MemorySigner;
@@ -188,17 +187,12 @@ async fn wait_for_http(base_url: &str) {
 async fn connect_to_server(base_url: &str, client_seed: u8, service_name: &str) -> TestSubduction {
     let client_signer = signer(client_seed);
 
-    let (subduction, listener_fut, manager_fut): (TestSubduction, _, _) = Subduction::new(
-        None,
-        client_signer.clone(),
-        MemoryStorage::default(),
-        OpenPolicy,
-        NonceCache::default(),
-        CountLeadingZeroBytes,
-        ShardedMap::new(),
-        TokioSpawn,
-        DEFAULT_MAX_PENDING_BLOB_REQUESTS,
-    );
+    let (subduction, _handler, listener_fut, manager_fut): (TestSubduction, _, _, _) =
+        SubductionBuilder::new()
+            .signer(client_signer.clone())
+            .storage(MemoryStorage::default(), Arc::new(OpenPolicy))
+            .spawner(TokioSpawn)
+            .build::<Sendable, HttpLongPollConnection<FuturesTimerTimeout>>();
 
     tokio::spawn(listener_fut);
     tokio::spawn(manager_fut);

subduction_core/src/connection/handshake.rs

@@ -69,7 +69,7 @@ use crate::{connection::nonce_cache::NonceCache, peer::id::PeerId, timestamp::Ti
 use sedimentree_core::{
     codec::{
         decode,
-        decode::Decode,
+        decode::DecodeFields,
         encode,
         encode::EncodeFields,
         error::{DecodeError, InvalidEnumTag},
@@ -309,8 +309,8 @@ impl EncodeFields for Challenge {
     }
 }
 
-impl Decode for Challenge {
-    const MIN_SIZE: usize = CHALLENGE_MIN_SIZE;
+impl DecodeFields for Challenge {
+    const MIN_SIGNED_SIZE: usize = CHALLENGE_MIN_SIZE;
 
     fn try_decode_fields(buf: &[u8]) -> Result<Self, DecodeError> {
         if buf.len() < CHALLENGE_FIELDS_SIZE {
@@ -381,8 +381,8 @@ impl EncodeFields for Response {
     }
 }
 
-impl Decode for Response {
-    const MIN_SIZE: usize = RESPONSE_MIN_SIZE;
+impl DecodeFields for Response {
+    const MIN_SIGNED_SIZE: usize = RESPONSE_MIN_SIZE;
 
     fn try_decode_fields(buf: &[u8]) -> Result<Self, DecodeError> {
         if buf.len() < RESPONSE_FIELDS_SIZE {