Fix P2P: wait for TCP connection before sending version handshake

The version message was being sent immediately after calling
socketProvider.connect(), but on react-native-tcp-socket the TCP
connection is asynchronous. The version message was silently dropped
because the socket wasn't connected yet.

Added onConnect callback to SocketConnection interface. Peer now waits
for onConnect before transitioning to 'connected' state and starting
the version/verack handshake. This matches how Bitcoin Core handles
the connection lifecycle.

Author: NateIsern

src/p2p/peer.ts

@@ -26,6 +26,7 @@ import {
 // ---------------------------------------------------------------------------
 
 export interface SocketConnection {
+  onConnect(callback: () => void): void;
   onData(callback: (data: Uint8Array) => void): void;
   onClose(callback: () => void): void;
   onError(callback: (err: Error) => void): void;
@@ -148,6 +149,11 @@ export class Peer {
       return;
     }
 
+    this.socket.onConnect(() => {
+      this._state = "connected";
+      this.startHandshake();
+    });
+
     this.socket.onData((data: Uint8Array) => {
       this.onSocketData(data);
     });
@@ -160,9 +166,6 @@ export class Peer {
       this.events.onError(this, err);
       this.handleDisconnect(`error: ${err.message}`);
     });
-
-    this._state = "connected";
-    this.startHandshake();
   }
 
   disconnect(): void {

src/p2p/socket-provider.ts

@@ -67,14 +67,20 @@ function getElectronAPI(): ElectronAPI | undefined {
 
 class NativeSocketProvider implements SocketProvider {
   connect(host: string, port: number): SocketConnection {
-    // Dynamic require to avoid web bundling issues (same pattern as kv-store.ts)
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
     const TcpSocket = require("react-native-tcp-socket") as { default: NativeTcpModule };
+
+    let connectCallback: (() => void) | undefined;
+
     const socket = TcpSocket.default.createConnection({ host, port }, () => {
-      // Connection callback - no-op, events handle the lifecycle
+      if (connectCallback) {
+        connectCallback();
+      }
     });
 
     return {
+      onConnect: (cb: () => void) => {
+        connectCallback = cb;
+      },
       onData: (cb: (data: Uint8Array) => void) => {
         socket.on("data", (data: Uint8Array) => {
           cb(new Uint8Array(data));
@@ -111,7 +117,17 @@ class ElectronSocketProvider implements SocketProvider {
 
     const socket = electronAPI.p2p.connect(host, port);
 
+    // Electron's IPC p2p:connect resolves when the TCP connection is established,
+    // so we fire onConnect immediately after setup.
+    let connectCallback: (() => void) | undefined;
+    setTimeout(() => {
+      if (connectCallback) connectCallback();
+    }, 0);
+
     return {
+      onConnect: (cb: () => void) => {
+        connectCallback = cb;
+      },
       onData: (cb: (data: Uint8Array) => void) => {
         socket.onData(cb);
       },