feat(peer): recover accepted relay anchors

native/runtime-host-peer/src/bindings.rs

@@ -43,6 +43,7 @@ const MAX_WEBRTC_STUN_URL_BYTES: usize = 512;
 #[napi(object)]
 pub struct StartPeerEndpointOptions {
     pub key_path: String,
+    pub relay_anchor_path: Option<String>,
     pub expected_peer_id: Option<String>,
     pub listen_addresses: Option<Vec<String>>,
     pub coordination_relays: Option<Vec<String>>,
@@ -92,11 +93,18 @@ pub struct PeerIdentitySignature {
     pub signature: Buffer,
 }
 
+#[napi(object)]
+#[derive(Clone)]
+pub struct PeerReachabilitySnapshot {
+    pub generation: u32,
+    pub listen_addresses: Vec<String>,
+    pub active_coordination_relays: Vec<String>,
+}
+
 #[napi]
 pub struct PeerEndpoint {
     peer_id: String,
-    listen_addresses: Vec<String>,
-    active_coordination_relays: Arc<RwLock<Vec<Multiaddr>>>,
+    reachability: watch::Receiver<engine::ReachabilitySnapshot>,
     transit_snapshot: Arc<RwLock<engine::TransitSnapshot>>,
     commands: mpsc::Sender<EngineCommand>,
     incoming: Arc<AsyncMutex<mpsc::Receiver<engine::PeerStream>>>,
@@ -113,16 +121,35 @@ impl PeerEndpoint {
     }
 
     #[napi(getter)]
-    pub fn listen_addresses(&self) -> Vec<String> {
-        self.listen_addresses.clone()
+    pub fn reachability_snapshot(&self) -> PeerReachabilitySnapshot {
+        reachability_snapshot(&self.reachability.borrow())
     }
 
-    #[napi(getter)]
-    pub fn active_coordination_relays(&self) -> Vec<String> {
-        self.active_coordination_relays
-            .read()
-            .map(|addresses| addresses.iter().map(ToString::to_string).collect())
-            .unwrap_or_default()
+    #[napi]
+    pub async fn watch_reachability(
+        &self,
+        after_generation: u32,
+        timeout_ms: u32,
+    ) -> Result<PeerReachabilitySnapshot> {
+        if !(1..=300_000).contains(&timeout_ms) {
+            return Err(Error::new(
+                Status::InvalidArg,
+                "reachability watch timeout must be between 1 and 300000 milliseconds",
+            ));
+        }
+        let mut receiver = self.reachability.clone();
+        if receiver.borrow().generation == after_generation {
+            match tokio::time::timeout(
+                Duration::from_millis(u64::from(timeout_ms)),
+                receiver.changed(),
+            )
+            .await
+            {
+                Ok(Ok(())) | Err(_) => {}
+                Ok(Err(_)) => return Err(native_closed_error()),
+            }
+        }
+        Ok(reachability_snapshot(&receiver.borrow()))
     }
 
     #[napi(getter)]
@@ -390,6 +417,7 @@ impl PeerStream {
 pub fn start_peer_endpoint(options: StartPeerEndpointOptions) -> Result<PeerEndpoint> {
     let started = engine::start(engine::StartOptions {
         key_path: PathBuf::from(options.key_path),
+        relay_anchor_path: options.relay_anchor_path.map(PathBuf::from),
         expected_peer_id: options
             .expected_peer_id
             .map(|value| parse_peer_id(&value))
@@ -408,12 +436,7 @@ pub fn start_peer_endpoint(options: StartPeerEndpointOptions) -> Result<PeerEndp
     .map_err(peer_error)?;
     Ok(PeerEndpoint {
         peer_id: started.peer_id.to_string(),
-        listen_addresses: started
-            .listen_addresses
-            .into_iter()
-            .map(|address| address.to_string())
-            .collect(),
-        active_coordination_relays: started.active_coordination_relays,
+        reachability: started.reachability,
         transit_snapshot: started.transit_snapshot,
         commands: started.commands,
         incoming: Arc::new(AsyncMutex::new(started.incoming)),
@@ -423,6 +446,22 @@ pub fn start_peer_endpoint(options: StartPeerEndpointOptions) -> Result<PeerEndp
     })
 }
 
+fn reachability_snapshot(snapshot: &engine::ReachabilitySnapshot) -> PeerReachabilitySnapshot {
+    PeerReachabilitySnapshot {
+        generation: snapshot.generation,
+        listen_addresses: snapshot
+            .listen_addresses
+            .iter()
+            .map(ToString::to_string)
+            .collect(),
+        active_coordination_relays: snapshot
+            .active_coordination_relays
+            .iter()
+            .map(ToString::to_string)
+            .collect(),
+    }
+}
+
 #[napi]
 pub async fn ensure_peer_identity(key_path: String) -> Result<String> {
     engine::ensure_identity(PathBuf::from(key_path))