feat!: implement per-worker aliasing [NET-352]

Cargo.toml

@@ -124,13 +124,13 @@ opt-level = 1
 
 # Enable high optimizations for dependencies, but not for our code:
 [profile.dev.package."*"]
-inherits = "release"
+opt-level = 3
 codegen-units = 256
 
 [profile.dev.package.clap]
 debug-assertions = false
 
 [profile.release]
 strip = true
-lto = true
+lto = false
 codegen-units = 1 # Reduce number of codegen units to increase optimizations

aquamarine/src/plumber.rs

@@ -94,7 +94,7 @@ impl<RT: AquaRuntime, F: ParticleFunctionStatic> Plumber<RT, F> {
             .actors
             .entry((particle.id.clone(), scope_peer_id))
             .or_insert_with(|| {
-                let params = ParticleParams::clone_from(&particle);
+                let params = ParticleParams::clone_from(&particle, scope_peer_id);
                 let functions = Functions::new(params, builtins.clone());
                 Actor::new(&particle, functions, scope_peer_id)
             });
@@ -139,11 +139,11 @@ impl<RT: AquaRuntime, F: ParticleFunctionStatic> Plumber<RT, F> {
         for actor in self.actors.values_mut() {
             if let Poll::Ready(result) = actor.poll_completed(cx) {
                 interpretation_stats.push(result.stats);
-                let (local_peers, remote_peers): (Vec<_>, Vec<_>) = result
-                    .effects
-                    .next_peers
-                    .into_iter()
-                    .partition(|p| key_manager.is_scope_peer_id(*p));
+                let (local_peers, remote_peers): (Vec<_>, Vec<_>) =
+                    result.effects.next_peers.into_iter().partition(|p| {
+                        key_manager.is_scope_peer_id(*p)
+                            || p.eq(&self.key_manager.get_host_peer_id())
+                    });
 
                 if !remote_peers.is_empty() {
                     remote_effects.push(RoutingEffects {

crates/libp2p/src/serde.rs

@@ -39,6 +39,34 @@ pub mod peerid_serializer {
     }
 }
 
+pub mod peerid_serializer_opt {
+    use libp2p::PeerId;
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+    use std::str::FromStr;
+
+    pub fn serialize<S>(value: &Option<PeerId>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        value.map(|p| p.to_base58()).serialize(serializer)
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<PeerId>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let opt: Option<String> = Option::deserialize(deserializer)?;
+        match opt {
+            None => Ok(None),
+            Some(str) => PeerId::from_str(&str)
+                .map_err(|e| {
+                    serde::de::Error::custom(format!("peer id deserialization failed for {e:?}"))
+                })
+                .map(Some),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::RandomPeerId;