Perform the multi-stream connections handshake inside smoldot

bin/light-base/src/network_service/tasks.rs

@@ -122,13 +122,10 @@ pub(super) async fn connection_task<TPlat: Platform>(
                 .pending_outcome_ok_single_stream(start_connect.id);
             (id, either::Left((socket, task)))
         }
-        PlatformConnection::MultiStream(socket, peer_id) => {
-            let (id, task) = guarded.network.pending_outcome_ok_multi_stream(
-                start_connect.id,
-                TPlat::now(),
-                &peer_id,
-            );
-
+        PlatformConnection::MultiStream(socket) => {
+            let (id, task) = guarded
+                .network
+                .pending_outcome_ok_multi_stream(start_connect.id);
             (id, either::Right((socket, task)))
         }
     };

bin/light-base/src/platform.rs

@@ -18,7 +18,6 @@
 use alloc::string::String;
 use core::{ops, str, time::Duration};
 use futures::prelude::*;
-use smoldot::libp2p::peer_id::PeerId;
 
 pub mod async_std;
 
@@ -136,7 +135,7 @@ pub enum PlatformConnection<TStream, TConnection> {
     SingleStream(TStream),
     /// The connection is made of multiple substreams. The encryption and multiplexing are handled
     /// externally.
-    MultiStream(TConnection, PeerId),
+    MultiStream(TConnection),
 }
 
 /// Direction in which a substream has been opened. See [`Platform::next_substream`].

bin/wasm-node/javascript/src/instance/bindings-smoldot-light.ts

@@ -131,7 +131,7 @@ export interface ConnectionConfig {
      *
      * Must only be called once per connection.
      */
-    onOpen: (info: { type: 'single-stream' } | { type: 'multi-stream', peerId: Uint8Array }) => void;
+    onOpen: (info: { type: 'single-stream' } | { type: 'multi-stream' }) => void;
 
     /**
      * Callback called when the connection transitions to the `Closed` state.
@@ -328,9 +328,7 @@ export default function (config: Config): { imports: WebAssembly.ModuleImports,
                                     break
                                 }
                                 case 'multi-stream': {
-                                    const ptr = instance.exports.alloc(info.peerId.length) >>> 0;
-                                    new Uint8Array(instance.exports.memory.buffer).set(info.peerId, ptr);
-                                    instance.exports.connection_open_multi_stream(connectionId, ptr, info.peerId.length);
+                                    instance.exports.connection_open_multi_stream(connectionId);
                                     break
                                 }
                             }

bin/wasm-node/javascript/src/instance/bindings.ts

@@ -35,7 +35,7 @@ export interface SmoldotWasmExports extends WebAssembly.Exports {
     database_content: (chainId: number, maxSize: number) => void,
     timer_finished: (timerId: number) => void,
     connection_open_single_stream: (connectionId: number) => void,
-    connection_open_multi_stream: (connectionId: number, peerIdPtr: number, peerIdLen: number) => void,
+    connection_open_multi_stream: (connectionId: number) => void,
     stream_message: (connectionId: number, streamId: number, ptr: number, len: number) => void,
     connection_stream_opened: (connectionId: number, streamId: number, outbound: number) => void,
     connection_closed: (connectionId: number, ptr: number, len: number) => void,

bin/wasm-node/rust/src/bindings.rs

@@ -465,24 +465,14 @@ pub extern "C" fn connection_open_single_stream(connection_id: u32) {
 ///
 /// See also [`connection_new`].
 ///
-/// The API user is responsible for determining the identity of the remote as part of the opening
-/// process of the connection. This identity must then be provided in the form of the binary
-/// representation of a peer ID, through `peer_id_ptr` and `peer_id_len`.
-/// See <https://github.com/libp2p/specs/blob/master/peer-ids/peer-ids.md#peer-ids> for a
-/// definition of the binary representation of a peer ID.
-/// The buffer **must** have been allocated with [`alloc`]. It is freed when this function is
-/// called.
-///
 /// When in the `Open` state, the connection can receive messages. When a message is received,
 /// [`alloc`] must be called in order to allocate memory for this message, then
 /// [`stream_message`] must be called with the pointer returned by [`alloc`].
 #[no_mangle]
 pub extern "C" fn connection_open_multi_stream(
     connection_id: u32,
-    peer_id_ptr: u32,
-    peer_id_len: u32,
 ) {
-    crate::platform::connection_open_multi_stream(connection_id, peer_id_ptr, peer_id_len)
+    crate::platform::connection_open_multi_stream(connection_id)
 }
 
 /// Notify of a message being received on the stream. The connection associated with that stream

bin/wasm-node/rust/src/platform.rs

@@ -154,14 +154,12 @@ impl smoldot_light::platform::Platform for Platform {
                     ))
                 }
                 ConnectionInner::MultiStream {
-                    peer_id,
                     connection_handles_alive,
                     ..
                 } => {
                     *connection_handles_alive += 1;
                     Ok(smoldot_light::platform::PlatformConnection::MultiStream(
                         ConnectionWrapper(connection_id),
-                        peer_id.clone(),
                     ))
                 }
                 ConnectionInner::Closed {
@@ -460,8 +458,6 @@ enum ConnectionInner {
     NotOpen,
     SingleStream,
     MultiStream {
-        /// Peer id we're connected to.
-        peer_id: smoldot_light::PeerId,
         /// List of substreams that the host (i.e. JavaScript side) has reported have been opened,
         /// but that haven't been reported through
         /// [`smoldot_light::platform::Platform::next_substream`] yet.
@@ -522,24 +518,11 @@ pub(crate) fn connection_open_single_stream(connection_id: u32) {
     connection.something_happened.notify(usize::max_value());
 }
 
-pub(crate) fn connection_open_multi_stream(connection_id: u32, peer_id_ptr: u32, peer_id_len: u32) {
-    let peer_id = {
-        let peer_id_ptr = usize::try_from(peer_id_ptr).unwrap();
-        let peer_id_len = usize::try_from(peer_id_len).unwrap();
-        let bytes: Box<[u8]> = unsafe {
-            Box::from_raw(slice::from_raw_parts_mut(
-                peer_id_ptr as *mut u8,
-                peer_id_len,
-            ))
-        };
-        smoldot_light::PeerId::from_bytes(bytes.into()).unwrap()
-    };
-
+pub(crate) fn connection_open_multi_stream(connection_id: u32) {
     let mut lock = STATE.try_lock().unwrap();
     let connection = lock.connections.get_mut(&connection_id).unwrap();
     debug_assert!(matches!(connection.inner, ConnectionInner::NotOpen));
     connection.inner = ConnectionInner::MultiStream {
-        peer_id,
         opened_substreams_to_pick_up: VecDeque::with_capacity(8),
         connection_handles_alive: 0,
     };

src/libp2p/collection.rs

@@ -377,8 +377,9 @@ where
 
     /// Adds a new multi-stream connection to the collection.
     ///
-    /// Note that no [`Event::HandshakeFinished`] event will be generated. The connection is
-    /// immediately considered as fully established.
+    /// Must be passed the moment (as a `TNow`) when the connection as been established, in order
+    /// to determine when the handshake timeout expires.
+    // TODO: add an is_initiator parameter? right now we're always implicitly the initiator
     pub fn insert_multi_stream<TSubId>(
         &mut self,
         now: TNow,
@@ -394,6 +395,7 @@ where
             self.randomness_seeds.gen(),
             now,
             self.max_inbound_substreams,
+            self.noise_key.clone(),
             self.notification_protocols.clone(),
             self.request_response_protocols.clone(),
             self.ping_protocol.clone(),