socket-function 0.8.30 → 0.8.32

package/SocketFunction.ts

@@ -1,12 +1,10 @@
-import { SocketExposedInterface, CallContextType, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, NetworkLocation, CallerContext, SocketExposedInterfaceClass, CallType, FullCallType } from "./SocketFunctionTypes";
+import { SocketExposedInterface, CallContextType, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType } from "./SocketFunctionTypes";
 import { exposeClass, registerClass, registerGlobalClientHook, registerGlobalHook, runClientHooks } from "./src/callManager";
 import { SocketServerConfig, startSocketServer } from "./src/webSocketServer";
-import { getCallFactoryFromNodeId, getCreateCallFactoryLocation, getLocationFromNodeId, getNetworkLocationHash } from "./src/nodeCache";
+import { getCreateCallFactoryLocation, getNodeId, getNodeIdLocation } from "./src/nodeCache";
 import { getCallProxy } from "./src/nodeProxy";
 import { Args } from "./src/types";
 import { setDefaultHTTPCall } from "./src/callHTTPHandler";
-import { isNode } from "./src/misc";
-import { getOwnNodeId } from "./src/nodeAuthentication";
 
 module.allowclient = true;
 
@@ -31,7 +29,6 @@ export class SocketFunction {
     };
     public static httpETagCache = false;
     public static rejectUnauthorized = true;
-    public static additionalTrustedRootCAs: string[] = [];
 
     public static register<
         ClassInstance extends object,
@@ -40,12 +37,19 @@ export class SocketFunction {
     >(
         classGuid: string,
         instance: ClassInstance,
-        shape: Shape
+        shape: Shape,
+        defaultHooks?: SocketExposedShape[""]
     ):
         (
             SocketRegistered<ExtractShape<ClassInstance, Shape>, CallContext>
         ) {
 
+        for (let value of Object.values(shape)) {
+            if (!value) continue;
+            value.clientHooks = [...(defaultHooks?.clientHooks || []), ...(value.clientHooks || [])];
+            value.hooks = [...(defaultHooks?.hooks || []), ...(value.hooks || [])];
+            value.dataImmutable = defaultHooks?.dataImmutable ?? value.dataImmutable;
+        }
         registerClass(classGuid, instance as SocketExposedInterface, shape as any as SocketExposedShape);
 
         let nodeProxy = getCallProxy(classGuid, async (call) => {
@@ -56,10 +60,7 @@ export class SocketFunction {
                 console.log(`START\t\t\t${classGuid}.${functionName}`);
             }
             try {
-                let callFactory = await getCallFactoryFromNodeId(nodeId);
-                if (!callFactory) {
-                    throw new Error(`Cannot reach node ${nodeId}. It might have been incorrect provided to us via another node, which should have provided us a NetworkLocation instead.`);
-                }
+                let callFactory = await getCreateCallFactoryLocation(nodeId, SocketFunction.mountedNodeId);
 
                 let shapeObj = shape[functionName];
                 if (!shapeObj) {
@@ -72,6 +73,20 @@ export class SocketFunction {
                     return hookResult.overrideResult;
                 }
 
+                if (hookResult.callTimeout !== undefined) {
+                    let timeout = hookResult.callTimeout;
+                    let time = Date.now();
+                    let timeoutPromise = new Promise((resolve, reject) => {
+                        setTimeout(() => {
+                            reject(new Error(`Call timed out after ${Date.now() - time}ms`));
+                        }, timeout);
+                    });
+                    return await Promise.race([
+                        callFactory.performCall(call),
+                        timeoutPromise,
+                    ]);
+                }
+
                 return await callFactory.performCall(call);
             } finally {
                 time = Date.now() - time;
@@ -90,14 +105,15 @@ export class SocketFunction {
         return output as any;
     }
 
-    /** NOTE: Only works if the call has been loaded from a url (we can't convert arbitrary nodeIds into urls,
-     *      as we have no way of knowing how to contain a nodeId). */
+    /** NOTE: Only works if the nodeIs used is from SocketFunction.connect (we can't convert arbitrary nodeIds into urls,
+     *      as we have no way of knowing how to contain a nodeId).
+     *  */
     public static getHTTPCallLink(call: FullCallType): string {
-        let location = getLocationFromNodeId(call.nodeId);
+        let location = getNodeIdLocation(call.nodeId);
         if (!location) {
             throw new Error(`Cannot find call location for nodeId, and so do not know where call location is. NodeId ${call.nodeId}`);
         }
-        let url = new URL(`https://${location.address}:${location.listeningPorts[0]}`);
+        let url = new URL(`https://${location.address}:${location.port}`);
         url.searchParams.set("classGuid", call.classGuid);
         url.searchParams.set("functionName", call.functionName);
         url.searchParams.set("args", JSON.stringify(call.args));
@@ -112,12 +128,13 @@ export class SocketFunction {
         exposeClass(socketRegistered);
     }
 
+    public static mountedNodeId: string = "NOTMOUNTED";
     public static async mount(config: SocketServerConfig) {
-        await startSocketServer(config);
-    }
-
-    public static async getOwnNodeId() {
-        return await getOwnNodeId();
+        if (this.mountedNodeId !== "NOTMOUNTED") {
+            throw new Error("SocketFunction already mounted, mounting twice in one thread is not allowed.");
+        }
+        this.mountedNodeId = await startSocketServer(config);
+        return this.mountedNodeId;
     }
 
     /** Sets the default call when an http request is made, but no classGuid is set. */
@@ -136,28 +153,8 @@ export class SocketFunction {
         });
     }
 
-    public static async connect(location: NetworkLocation | { address: string; port: number }): Promise<string> {
-        if (!("listeningPorts" in location)) {
-            location = {
-                address: location.address,
-                listeningPorts: [location.port]
-            };
-        }
-        return await getCreateCallFactoryLocation(location);
-    }
-
-    public static connectSync(location: NetworkLocation | { address: string; port: number }): string {
-        if (!("listeningPorts" in location)) {
-            location = {
-                address: location.address,
-                listeningPorts: [location.port]
-            };
-        }
-        let tempNodeId = "syncTempNodeId_" + getNetworkLocationHash(location);
-
-        void getCreateCallFactoryLocation(location, tempNodeId);
-
-        return tempNodeId;
+    public static connect(location: { address: string, port: number }): string {
+        return getNodeId(location.address, location.port);
     }
 
     public static addGlobalHook<CallContext extends CallContextType>(hook: SocketFunctionHook<SocketExposedInterface, CallContext>) {
@@ -172,6 +169,11 @@ export class SocketFunction {
 const curSocketContext: SocketRegistered["context"] = {
     curContext: undefined,
     caller: undefined,
+    getCaller() {
+        const caller = curSocketContext.caller;
+        if (!caller) throw new Error(`Tried to access caller when not in the synchronous phase of a function call`);
+        return caller;
+    }
 };
 let socketContextSeqNum = 1;
 

package/SocketFunctionTypes.ts

@@ -2,6 +2,10 @@ module.allowclient = true;
 
 import debugbreak from "debugbreak";
 import * as tls from "tls";
+import { SenderInterface } from "./src/CallFactory";
+import { isNode } from "./src/misc";
+import { CertInfo, getNodeIdFromCert } from "./src/nodeAuthentication";
+import { getClientNodeId } from "./src/nodeCache";
 import { getCallObj } from "./src/nodeProxy";
 import { Args, MaybePromise } from "./src/types";
 
@@ -49,14 +53,18 @@ export interface SocketFunctionHook<ExposedType extends SocketExposedInterface =
 }
 export type HookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> = {
     call: CallType;
-    context: SocketRegistered["context"];
-    // If the result is overriden, we continue evaluating hooks BUT NOT perform the final call
+    context: SocketRegistered<ExposedType, CallContext>["context"];
+    // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
     overrideResult?: unknown;
 };
 
 export type ClientHookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> = {
     call: CallType;
-    // If the result is overriden, we continue evaluating hooks BUT NOT perform the final call
+    /** If the calls takes longer than this (for ANY reason), we return with an error.
+     *      - Different from reconnectTimeout, which only errors if we lose the connection.
+    */
+    callTimeout?: number;
+    // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
     overrideResult?: unknown;
 };
 export interface SocketFunctionClientHook<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> {
@@ -81,44 +89,29 @@ export interface SocketRegistered<ExposedType = any, DynamicCallContext extends
         // If undefined we are not synchronously in a call
         curContext: DynamicCallContext | undefined;
         caller: CallerContext | undefined;
+        getCaller(): CallerContext;
     };
     _classGuid: string;
 }
-export type CallerContext = {
+export type CallerContext = Readonly<CallerContextBase>;
+export type CallerContextBase = {
     // IMPORTANT! Do not pass nodeId to other nodes with the intention of having
     //  them call functions directly using nodeId. Instead pass location, and have them use connect.
-    //  - nodeId SHOULD be used to identify users though, as it cannot be impersonated
+    //  - nodeId will be unique per thread, so is only useful for temporary communcation. If you want
+    //      a more permanent identity, you must derive it from certInfo yourself.
     nodeId: string;
-    fromPort: number;
-    location: NetworkLocation;
-    // The location of the server. It helps if it is told, due to the fact that one server
-    //  can serve multiple domains.
-    serverLocation: NetworkLocation;
 
-    // NOTE: Only set in NodeJS, as clientside we are not given access to the certificate information.
-    //  TODO: Limit this type to only have the information we need, possible in a slightly different format.
-    certInfo: tls.DetailedPeerCertificate | undefined;
+    /** Gives further info on the node. When we set this, we always make sure it has a verified
+     *      issuer. It may be set by app code, which should make sure the issuer is verified (not
+     *      necessarily by the machine, but just in some sense, 'verified', to secure the common name
+     *      of the cert and prevent anyone from using the same common name as someone else).
+     *  IF set, is directly used to derive nodeId (by nodeAuthentication.ts)
+     */
+    certInfo: CertInfo | undefined;
+    updateCertInfo?: (certInfo: CertInfo, callbackPort: number | undefined) => void;
 
-    // TODO: Add callerBrowserAuthIP, which will allow "Proxy-IP" (or whatever cloudflare uses? It has to be a
-    //  header which the browser is restricted from sending), to override this, allowing the browser to use
-    //  proxies.
-    //  - We have to also ONLY accept this from certain trusted servers, as otherwise it is too easy to spoof.
-    //callerBrowserAuthIP: string;
-};
-
-export function setCertInfo(socket: tls.TLSSocket | undefined, context: CallerContext) {
-    if (!socket) return;
-    let cert = socket.getPeerCertificate(true);
-    /** Check for a property, because "If the peer does not provide a certificate, an empty object will be
-        returned. If the socket has been destroyed, `null` will be returned." */
-    if (cert?.issuer) {
-        context.certInfo = cert;
-    }
-}
-
-// IMPORTANT! Nodes at the same network location may vary, so you cannot store NetworkLocation
-//  in a list of allowed users, otherwise they can be impersonated!
-export interface NetworkLocation {
-    address: string;
-    listeningPorts: number[];
-}
+    // The nodeId they contacted. This is useful to determine their intention (otherwise
+    //  requests can be redirected to us and would accept them, even though they are being
+    //  blatantly MITMed).
+    localNodeId: string;
+};

package/package.json

@@ -1,21 +1,27 @@
 {
 	"name": "socket-function",
-	"version": "0.8.30",
+	"version": "0.8.32",
 	"main": "index.js",
 	"license": "MIT",
+	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
 	"dependencies": {
 		"@types/cookie": "^0.5.1",
 		"@types/node": "^18.0.0",
+		"@types/node-forge": "^1.3.1",
 		"@types/ws": "^8.5.3",
 		"cookie": "^0.5.0",
 		"debugbreak": "^0.6.5",
 		"mobx": "^6.6.2",
+		"node-forge": "https://github.com/sliftist/forge#name",
 		"preact": "^10.10.6",
-		"typenode": "^4.8.5",
+		"typenode": "^4.8.7",
 		"ws": "^8.8.0"
 	},
 	"scripts": {
 		"test": "yarn typenode ./test/server.ts",
 		"type": "yarn tsc --noEmit"
+	},
+	"devDependencies": {
+		"typedev": "^0.1.0"
 	}
 }

package/src/CallFactory.ts

@@ -1,14 +1,12 @@
-import { CallerContext, CallType, NetworkLocation, setCertInfo } from "../SocketFunctionTypes";
+import { CallerContext, CallerContextBase, CallType } from "../SocketFunctionTypes";
 import * as ws from "ws";
-import type * as net from "net";
 import { performLocalCall } from "./callManager";
 import { convertErrorStackToError, formatNumberSuffixed, isNode } from "./misc";
-import { createWebsocketFactory, getNodeId, getTLSSocket } from "./nodeAuthentication";
-import debugbreak from "debugbreak";
-import http from "http";
+import { createWebsocketFactory, getNodeIdFromCert, getTLSSocket } from "./nodeAuthentication";
 import { SocketFunction } from "../SocketFunction";
 import { gzip } from "zlib";
 import * as tls from "tls";
+import { getClientNodeId, getNodeIdLocation, registerNodeClient } from "./nodeCache";
 
 const retryInterval = 2000;
 
@@ -30,53 +28,10 @@ type InternalReturnType = {
 
 export interface CallFactory {
     nodeId: string;
-    location: NetworkLocation;
     // NOTE: May or may not have reconnection or retry logic inside of performCall.
     //  Trigger performLocalCall on the other side of the connection
     performCall(call: CallType): Promise<unknown>;
-}
-
-
-export async function callFactoryFromLocation(
-    location: NetworkLocation
-): Promise<CallFactory> {
-    let listeningPort = location.listeningPorts[0];
-    if (typeof listeningPort !== "number") {
-        throw new Error(`Expected listeningPorts to be provided, but it was empty`);
-    }
-
-    // Because we are the client, we don't get to know our NetworkLocation (but we shouldn't
-    //  need to anyway).
-    let serverLocation: NetworkLocation = {
-        address: "localhost",
-        listeningPorts: [],
-    };
-
-    return await createCallFactory(undefined, location, serverLocation);
-}
-
-export async function callFactoryFromWS(
-    webSocket: ws.WebSocket & { nodeId?: string },
-    serverLocation: NetworkLocation,
-): Promise<CallFactory> {
-    let socket = getTLSSocket(webSocket);
-    let remoteAddress = socket.remoteAddress;
-    let remotePort = socket.remotePort;
-    if (!remoteAddress) {
-        throw new Error("No remote address?");
-    }
-    if (!remotePort) {
-        throw new Error("No remote port?");
-    }
-
-    // NOTE: We COULD reconnect to clients, but... chances are... when they go down,
-    //  their process is dead, and is going to stay dead.
-    let location: NetworkLocation = {
-        address: remoteAddress,
-        listeningPorts: [],
-    };
-
-    return await createCallFactory(webSocket, location, serverLocation);
+    closedForever: boolean;
 }
 
 export interface SenderInterface {
@@ -92,27 +47,16 @@ export interface SenderInterface {
     addEventListener(event: "message", listener: (data: ws.RawData | ws.MessageEvent | string) => void): void;
 }
 
-async function createCallFactory(
+export async function createCallFactory(
     webSocketBase: SenderInterface | undefined,
-    location: NetworkLocation,
-    serverLocation: NetworkLocation,
+    nodeId: string,
+    localNodeId: string,
 ): Promise<CallFactory> {
-
-    let closedForever = false;
-
-    let fromPort = 0;
-    if (webSocketBase && webSocketBase instanceof ws.WebSocket) {
-        let socket = getTLSSocket(webSocketBase);
-        fromPort = socket.remotePort ?? fromPort;
-    }
-    let niceConnectionName = `${location.address}:${location.listeningPorts.join("|")}`;
-    if (fromPort && location.listeningPorts.length === 0) {
-        niceConnectionName += `(${fromPort})`;
-    }
+    let niceConnectionName = nodeId;
 
     const createWebsocket = createWebsocketFactory();
 
-    let retriesEnabled = location.listeningPorts.length > 0;
+    let retriesEnabled = !!getNodeIdLocation(nodeId);
 
     let lastReceivedSeqNum = 0;
 
@@ -131,8 +75,59 @@ async function createCallFactory(
     //  in return calls.
     let nextSeqNum = Math.random();
 
-    const pendingNodeId = "PENDING";
-    let callerContext: CallerContext = { location, nodeId: pendingNodeId, serverLocation, fromPort, certInfo: undefined };
+    let callerContext: CallerContextBase = {
+        nodeId,
+        localNodeId,
+        certInfo: webSocketBase?.socket?.getPeerCertificate(true),
+        updateCertInfo: (certRaw, port) => {
+            let nodeId = getNodeIdFromCert(certRaw, port);
+            if (!nodeId) {
+                return;
+            }
+            callerContext.nodeId = nodeId;
+            callerContext.certInfo = certRaw;
+        }
+    };
+
+    let callFactory: CallFactory = {
+        nodeId,
+        closedForever: false,
+        async performCall(call: CallType) {
+            if (callFactory.closedForever) {
+                throw new Error(`Connection lost to ${niceConnectionName}`);
+            }
+
+            let seqNum = nextSeqNum++;
+            let fullCall: InternalCallType = {
+                isReturn: false,
+                args: call.args,
+                classGuid: call.classGuid,
+                functionName: call.functionName,
+                seqNum,
+                compress: !!SocketFunction.compression,
+            };
+            let data = Buffer.from(JSON.stringify(fullCall));
+            let resultPromise = new Promise((resolve, reject) => {
+                let callback = (result: InternalReturnType) => {
+                    if (SocketFunction.logMessages) {
+                        console.log(`SIZE\t${(formatNumberSuffixed(result.resultSize) + "B").padEnd(4, " ")}\t${call.classGuid}.${call.functionName}`);
+                    }
+                    pendingCalls.delete(seqNum);
+                    if (result.error) {
+                        reject(convertErrorStackToError(result.error));
+                    } else {
+                        resolve(result.result);
+                    }
+                };
+                pendingCalls.set(seqNum, { callback, data, call: fullCall, reconnectTimeout: call.reconnectTimeout });
+            });
+
+            await sendWithRetry(call.reconnectTimeout, data);
+
+            return await resultPromise;
+        }
+    };
+
     let webSocket!: SenderInterface;
     if (!webSocketBase) {
         await tryToReconnect();
@@ -140,11 +135,6 @@ async function createCallFactory(
         webSocket = webSocketBase;
         setupWebsocket(webSocketBase);
     }
-    if (isNode()) {
-        callerContext.nodeId = getNodeId(webSocket);
-    } else {
-        callerContext.nodeId = location.address + ":" + location.listeningPorts[0];
-    }
 
     niceConnectionName = `${niceConnectionName} (${callerContext.nodeId})`;
 
@@ -189,11 +179,9 @@ async function createCallFactory(
         if (reconnectingPromise) return reconnectingPromise;
         return reconnectingPromise = (async () => {
             while (true) {
-                let ports = location.listeningPorts;
-
-                if (ports.length === 0) {
-                    closedForever = true;
-                    console.log(`No ports to reconnect for ${niceConnectionName}, pendingCall count: ${pendingCalls.size}`);
+                if (!retriesEnabled) {
+                    callFactory.closedForever = true;
+                    console.log(`Cannot reconnect to ${niceConnectionName}, aborting pendingCalls: ${pendingCalls.size}`);
                     for (let call of pendingCalls.values()) {
                         call.callback({
                             isReturn: true,
@@ -207,8 +195,7 @@ async function createCallFactory(
                     return;
                 }
 
-                let port = ports[reconnectAttempts % ports.length];
-                let newWebSocket = createWebsocket(location.address, port);
+                let newWebSocket = createWebsocket(nodeId);
 
                 let connectError = await new Promise<string | undefined>(resolve => {
                     newWebSocket.addEventListener("open", () => {
@@ -225,24 +212,9 @@ async function createCallFactory(
                 setupWebsocket(newWebSocket);
 
                 if (!connectError) {
-                    console.log(`Reconnected to ${location.address}:${port}`);
-
-                    // NOTE: Clientside doesn't have access to peer certificates, so it can't know the nodeId of the server
-                    //  that way. However, it can 
-                    if (isNode()) {
-                        let newNodeId = getNodeId(newWebSocket);
-                        let prevNodeId = callerContext.nodeId;
-                        if (prevNodeId === pendingNodeId) {
-                            callerContext.nodeId = newNodeId;
-                        } else {
-                            if (newNodeId !== prevNodeId) {
-                                throw new Error(`Connection lost to at ${niceConnectionName} ("${prevNodeId}"), but then re-established, however it is now "${newNodeId}"!`);
-                            }
-                        }
-                    }
+                    console.log(`Reconnected to ${niceConnectionName}`);
 
-                    // I'm not sure if we should clear reconnectAttempts? All the ports should be the same, and actually...
-                    //  why would there even be a bad port?
+                    // I'm not sure if we should clear reconnectAttempts? Maybe if we eventually have a max reconnectAttempts?
                     //reconnectAttempts = 0;
                     reconnectingPromise = undefined;
 
@@ -264,13 +236,15 @@ async function createCallFactory(
                 }
 
                 reconnectAttempts++;
-                console.error(`Connection retry to ${location.address}:${port} failed (attempt ${reconnectAttempts}), retrying in ${retryInterval}ms, error: ${JSON.stringify(connectError)}`);
+                console.error(`Connection retry to ${niceConnectionName} failed (attempt ${reconnectAttempts}), retrying in ${retryInterval}ms, error: ${JSON.stringify(connectError)}`);
                 await new Promise(resolve => setTimeout(resolve, retryInterval));
             }
         })();
     }
 
     function setupWebsocket(webSocket: SenderInterface) {
+        registerNodeClient(callFactory);
+
         webSocket.addEventListener("error", e => {
             console.log(`Websocket error for ${niceConnectionName}`, e);
         });
@@ -283,8 +257,6 @@ async function createCallFactory(
         });
 
         webSocket.addEventListener("message", onMessage);
-
-        setCertInfo(webSocket.socket || (webSocket as any)._socket, callerContext);
     }
 
 
@@ -374,42 +346,5 @@ async function createCallFactory(
         }
     }
 
-    return {
-        nodeId: callerContext.nodeId,
-        location,
-        async performCall(call: CallType) {
-            if (closedForever) {
-                throw new Error(`Connection lost to ${niceConnectionName}`);
-            }
-
-            let seqNum = nextSeqNum++;
-            let fullCall: InternalCallType = {
-                isReturn: false,
-                args: call.args,
-                classGuid: call.classGuid,
-                functionName: call.functionName,
-                seqNum,
-                compress: !!SocketFunction.compression,
-            };
-            let data = Buffer.from(JSON.stringify(fullCall));
-            let resultPromise = new Promise((resolve, reject) => {
-                let callback = (result: InternalReturnType) => {
-                    if (SocketFunction.logMessages) {
-                        console.log(`SIZE\t${(formatNumberSuffixed(result.resultSize) + "B").padEnd(4, " ")}\t${call.classGuid}.${call.functionName}`);
-                    }
-                    pendingCalls.delete(seqNum);
-                    if (result.error) {
-                        reject(convertErrorStackToError(result.error));
-                    } else {
-                        resolve(result.result);
-                    }
-                };
-                pendingCalls.set(seqNum, { callback, data, call: fullCall, reconnectTimeout: call.reconnectTimeout });
-            });
-
-            await sendWithRetry(call.reconnectTimeout, data);
-
-            return await resultPromise;
-        }
-    };
+    return callFactory;
 }

package/src/callHTTPHandler.ts

@@ -1,17 +1,11 @@
-import https from "https";
 import http from "http";
-import net from "net";
 import tls from "tls";
-import { CallerContext, CallType, NetworkLocation, setCertInfo } from "../SocketFunctionTypes";
+import { CallerContext, CallType } from "../SocketFunctionTypes";
 import { isDataImmutable, performLocalCall } from "./callManager";
-import { getNodeIdRaw } from "./nodeAuthentication";
-import debugbreak from "debugbreak";
-import * as cookie from "cookie";
 import { SocketFunction } from "../SocketFunction";
 import { gzip } from "zlib";
 import { formatNumberSuffixed, sha256Hash } from "./misc";
-
-const nodeIdCookie = "node-id4";
+import { getClientNodeId, getNodeId } from "./nodeCache";
 
 let defaultHTTPCall: CallType | undefined;
 
@@ -19,15 +13,7 @@ export function setDefaultHTTPCall(call: CallType) {
     defaultHTTPCall = call;
 }
 
-const cookieNodeIdPrefix = "COOKIE_nodeId_";
-export function getNodeIdFromRequest(request: http.IncomingMessage): string | undefined {
-    let cookies = cookie.parse(request.headers.cookie ?? "");
-    let value = cookies[nodeIdCookie];
-    if (!value) return value;
-    if (!value.startsWith(cookieNodeIdPrefix)) return undefined;
-    return value;
-}
-export function getServerLocationFromRequest(request: http.IncomingMessage): NetworkLocation {
+export function getServerLocationFromRequest(request: http.IncomingMessage) {
     let host = request.headers.host;
     if (!host) {
         throw new Error(`Missing host in request headers`);
@@ -41,10 +27,27 @@ export function getServerLocationFromRequest(request: http.IncomingMessage): Net
         address: host,
         // This is OUR location, so whatever they connected to us... we must be listening on!
         //  (and the localPort doesn't matter in this case)
-        listeningPorts: [port],
+        port,
     };
 }
 
+export function getNodeIdsFromRequest(request: http.IncomingMessage) {
+    // TODO: Support passing signed proof of userCertificate via headers in the HTTP request.
+    //  THAT WAY HTTP can have consistent nodeIds, instead of making them randomly every time!
+    //  (This isn't needed or possible for websockets, but they stay open, so calling functions
+    //      after they open to set the nodeId is possible, and preferred).
+    let remoteAddress = request.socket.remoteAddress;
+    if (!remoteAddress) {
+        throw new Error(`Missing remoteAddress`);
+    }
+    const nodeId = getClientNodeId(remoteAddress);
+
+    const serverLocation = getServerLocationFromRequest(request);
+    // IMPORTANT! Not the actual local id, but is the id the client called
+    const localNodeId = getNodeId(serverLocation.address, serverLocation.port);
+    return { nodeId, localNodeId };
+}
+
 export async function httpCallHandler(request: http.IncomingMessage, response: http.ServerResponse) {
     try {
 
@@ -72,48 +75,13 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
                 ;
         });
 
-        let socket = request.connection as tls.TLSSocket;
-
-        let address = socket.remoteAddress;
-        let port = socket.remotePort;
-        if (!address) {
-            throw new Error("Missing remote address");
-        }
-        if (!port) {
-            throw new Error("Missing remote port");
-        }
-
-        let nodeId = getNodeIdRaw(socket);
-        if (!nodeId) {
-            let cookieNodeId = getNodeIdFromRequest(request);
-            if (typeof cookieNodeId === "string") {
-                nodeId = cookieNodeId;
-            }
-        }
-        if (!nodeId) {
-            nodeId = cookieNodeIdPrefix + Date.now() + "_" + Math.random();
-            response.setHeader("Set-Cookie", cookie.serialize(nodeIdCookie, nodeId, {
-                httpOnly: true,
-                path: "/",
-                secure: true,
-                domain: urlObj.hostname,
-                sameSite: "none"
-            }));
-
-            response.setHeader(nodeIdCookie, nodeId);
-        }
+        const { nodeId, localNodeId } = getNodeIdsFromRequest(request);
 
         let caller: CallerContext = {
             nodeId,
-            fromPort: port,
-            location: {
-                address,
-                listeningPorts: [],
-            },
-            serverLocation: getServerLocationFromRequest(request),
             certInfo: undefined,
+            localNodeId,
         };
-        setCertInfo(socket, caller);
 
         let classGuid = urlObj.searchParams.get("classGuid");
         let functionName = urlObj.searchParams.get("functionName");

package/src/callManager.ts

@@ -1,4 +1,4 @@
-import { CallContextType, CallerContext, CallType, ClientHookContext, HookContext, NetworkLocation, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
+import { CallContextType, CallerContext, CallType, ClientHookContext, HookContext, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
 import { _setSocketContext } from "../SocketFunction";
 
 let classes: {
@@ -40,7 +40,7 @@ export async function performLocalCall(
     }
 
     let curContext: CallContextType = {};
-    let serverContext = await runServerHooks(call, { caller, curContext }, functionShape);
+    let serverContext = await runServerHooks(call, { caller, curContext, getCaller: () => caller }, functionShape);
     if ("overrideResult" in serverContext) {
         return serverContext.overrideResult;
     }
@@ -75,9 +75,21 @@ export function exposeClass(exposedClass: SocketRegistered) {
 export function registerGlobalHook(hook: SocketFunctionHook) {
     globalHooks.push(hook);
 }
+export function unregisterGlobalHook(hook: SocketFunctionHook) {
+    let index = globalHooks.indexOf(hook);
+    if (index >= 0) {
+        globalHooks.splice(index, 1);
+    }
+}
 export function registerGlobalClientHook(hook: SocketFunctionClientHook) {
     globalClientHooks.push(hook);
 }
+export function unregisterGlobalClientHook(hook: SocketFunctionClientHook) {
+    let index = globalClientHooks.indexOf(hook);
+    if (index >= 0) {
+        globalClientHooks.splice(index, 1);
+    }
+}
 
 export async function runClientHooks(
     callType: CallType,

package/src/certStore.ts

@@ -0,0 +1,50 @@
+import * as os from "os";
+import * as fs from "fs/promises";
+import * as fsSync from "fs";
+import * as child_process from "child_process";
+import * as tls from "tls";
+import { SocketFunction } from "../SocketFunction";
+import { isNode, isNodeTrue, sha256Hash } from "./misc";
+import { lazy } from "./caching";
+
+let trustedCerts = new Set<string>();
+let loadedTrustedCerts = false;
+let watchCallbacks = new Set<(certs: string[]) => void>();
+
+let storePath = isNodeTrue() && process.argv[1].replaceAll("\\", "/").split("/").slice(0, -1).join("/") + "/certstore/";
+if (isNode()) {
+    if (!fsSync.existsSync(storePath)) {
+        fsSync.mkdirSync(storePath);
+    }
+}
+
+/** Must be populated before the server starts */
+export async function trustUserCertificate(cert: string) {
+    if (trustedCerts.has(cert)) return;
+    trustedCerts.add(cert);
+    await fs.writeFile(storePath + sha256Hash(Buffer.from(cert)) + ".cer", cert);
+    let certs = getTrustedUserCertificates();
+    for (let callback of watchCallbacks) {
+        callback(certs);
+    }
+}
+export const loadTrustedUserCertificates = lazy(async () => {
+    let files = await fs.readdir(storePath);
+    for (let file of files) {
+        let cert = await fs.readFile(storePath + file, "utf8");
+        trustedCerts.add(cert);
+    }
+    loadedTrustedCerts = true;
+});
+export function getTrustedUserCertificates(): string[] {
+    if (!loadedTrustedCerts) {
+        throw new Error("Must call loadTrustedUserCertificates (and await it) before calling getTrustedUserCertificates");
+    }
+    return Array.from(trustedCerts);
+}
+
+export function watchUserCertificates(callback: (certs: string[]) => void) {
+    watchCallbacks.add(callback);
+    callback(getTrustedUserCertificates());
+    return () => watchCallbacks.delete(callback);
+}

package/src/misc.ts

@@ -7,7 +7,7 @@ export function convertErrorStackToError(error: string): Error {
     return errorObj;
 }
 
-export function sha256Hash(buffer: Buffer) {
+export function sha256Hash(buffer: Buffer | string) {
     return crypto.createHash("sha256").update(buffer).digest("hex");
 }
 /** Async, but works both clientside and serverside. */

package/src/nodeAuthentication.ts

@@ -12,6 +12,10 @@ import { isNode, sha256Hash } from "./misc";
 import { getArgs } from "./args";
 import { SenderInterface } from "./CallFactory";
 import { SocketFunction } from "../SocketFunction";
+import { getTrustedUserCertificates } from "./certStore";
+import { getClientNodeId, getNodeId, getNodeIdLocation } from "./nodeCache";
+
+export type CertInfo = { raw: Buffer | string; issuerCertificate: { raw: Buffer | string } };
 
 let certKeyPairOverride: { key: Buffer; cert: Buffer } | undefined;
 export function getCertKeyPair(): { key: Buffer; cert: Buffer } {
@@ -19,13 +23,6 @@ export function getCertKeyPair(): { key: Buffer; cert: Buffer } {
     return getCertKeyPairBase();
 }
 const getCertKeyPairBase = lazy((): { key: Buffer; cert: Buffer } => {
-    // TODO: Also get this working clientside...
-    //  - Use https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey
-    //      - We might need node-forge for the Certificate Signing Request and x509 stuff
-    //  - Use ECDSA keys
-    //  - ALSO, get our nodeId set in our cookies, so HTTP requests can work as well
-    //      - We will need callHTTPHandler to support this
-
     // https://nodejs.org/en/knowledge/HTTP/servers/how-to-create-a-HTTPS-server/
 
     let folder = getAppFolder();
@@ -45,6 +42,9 @@ const getCertKeyPairBase = lazy((): { key: Buffer; cert: Buffer } => {
 });
 
 export function overrideCertKeyPair<T>(certKey: { key: Buffer; cert: Buffer; }, code: () => T): T {
+    if (!isNode()) {
+        throw new Error(`Cannot override cert/key pair in browser`);
+    }
     let prevOverride = certKeyPairOverride;
     certKeyPairOverride = certKey;
     try {
@@ -70,66 +70,47 @@ export async function getOwnNodeId() {
     throw new Error(`TODO: Implement getOwnNodeId`);
 }
 
-export const getNodeId = cacheWeak(function (webSocket: SenderInterface | ws.WebSocket & { nodeId?: string }): string {
-    if (!(webSocket instanceof ws.WebSocket)) {
-        if (!webSocket.nodeId) {
-            throw new Error("Sender isn't a WebSocket, and doesn't have a nodeId");
-        }
-        return webSocket.nodeId;
-    }
-    let socket = getTLSSocket(webSocket);
-    let nodeId = getNodeIdRaw(socket);
-    if (!nodeId) {
-        if (webSocket.nodeId) {
-            return webSocket.nodeId;
-        }
-        throw new Error(`Missing nodeId. If it is from the browser, this likely means your websocket and HTTP request are using different domains (so the cookies are lost). If it is from NodeJs peer certificate must use an RSA key or EC key (which should have a .modulus property)`);
-    }
-    return nodeId;
-});
-
-export function getNodeIdFromCert(cert: { modulus: Buffer }) {
-    // Apparently some implementations strip preceding zeros, which makes sense, as it is a modulus so
-    //  preceding zeros aren't needed.
-    let startIndex = 0;
-    while (startIndex < cert.modulus.length && cert.modulus[startIndex] === 0) {
-        startIndex++;
+export function getNodeIdFromCert(certRaw: { raw: Buffer | string } | undefined, callbackPort: number | undefined) {
+    if (!certRaw?.raw) return undefined;
+    let cert = new crypto.X509Certificate(certRaw.raw);
+    if (!callbackPort) {
+        return getClientNodeId(cert.subject);
     }
-    return sha256Hash(cert.modulus.slice(startIndex));
-}
-export function getNodeIdRaw(socket: tls.TLSSocket) {
-    let peerCert = socket.getPeerCertificate();
-    if (!peerCert) {
-        throw new Error("WebSocket connections must provided a peer certificate");
+    let subject = cert.subject;
+    if (subject.startsWith("CN=")) {
+        subject = subject.slice("CN=".length);
     }
-
-    if (!peerCert.modulus) return undefined;
-    return getNodeIdFromCert({ modulus: Buffer.from(peerCert.modulus, "hex") });
+    return getNodeId(subject, callbackPort);
 }
 
 /** NOTE: We create a factory, which embeds the key/cert information. Otherwise retries might use
  *      a different key/cert context.
  */
-export function createWebsocketFactory(): (address: string, port: number) => SenderInterface {
+export function createWebsocketFactory(): (nodeId: string) => SenderInterface {
 
     if (!isNode()) {
-        // NOTE: We assume an HTTP request has already been made, which will setup a nodeId cookie
-        //  (And as this point we can't even use peer certificates if we wanted to, as this must be done
-        //      directly in the browser)
-        return (address: string, port: number) => {
+        return (nodeId: string) => {
+            let location = getNodeIdLocation(nodeId);
+            if (!location) throw new Error(`Cannot connect to ${nodeId}, no address known`);
+            let { address, port } = location;
+
             console.log(`Connecting to ${address}:${port}`);
             return new WebSocket(`wss://${address}:${port}`);
         };
     } else {
         let { key, cert } = getCertKeyPair();
         let rejectUnauthorized = SocketFunction.rejectUnauthorized;
-        return (address: string, port: number) => {
+        return (nodeId: string) => {
+            let location = getNodeIdLocation(nodeId);
+            if (!location) throw new Error(`Cannot connect to ${nodeId}, no address known`);
+            let { address, port } = location;
+
             console.log(`Connecting to ${address}:${port}`);
             let webSocket = new ws.WebSocket(`wss://${address}:${port}`, {
                 cert,
                 key,
                 rejectUnauthorized,
-                ca: tls.rootCertificates.concat(SocketFunction.additionalTrustedRootCAs),
+                ca: tls.rootCertificates.concat(getTrustedUserCertificates()),
             });
             let result = Object.assign(webSocket, { socket: undefined as tls.TLSSocket | undefined });
             webSocket.once("upgrade", e => {
@@ -138,4 +119,5 @@ export function createWebsocketFactory(): (address: string, port: number) => Sen
             return result;
         };
     }
-}
+}
+

package/src/nodeCache.ts

@@ -1,6 +1,7 @@
-import { callFactoryFromLocation, CallFactory } from "./CallFactory";
-import { NetworkLocation } from "../SocketFunctionTypes";
+import { CallFactory, createCallFactory } from "./CallFactory";
 import { MaybePromise } from "./types";
+import { lazy } from "./caching";
+import { SocketFunction } from "../SocketFunction";
 
 // TODO: Add CallInstanceFactory.isClosed, so nodeCache can clean up old entries.
 //  This is only needed for memory management, and not for correctness. Entries never
@@ -11,91 +12,66 @@ import { MaybePromise } from "./types";
 //  a value to a new value... then they should be obtained using connect() anyway,
 //  and so whatever way the user got the NetworkLocation to begin with, they should use again.
 
-
-// nodeId => 
-const nodeCache = new Map<string, {
-    callFactory: MaybePromise<CallFactory>;
-    // Just used for getCallFactoryFromNodeId
-    location: NetworkLocation | undefined;
-}>();
-const locationLookup = new Map<string, MaybePromise<string>>();
-
-export function getNetworkLocationHash(location: NetworkLocation): string {
-    return location.address + ":" + location.listeningPorts.join("|");
+export function getNodeId(domain: string, port: number): string {
+    // NOTE: As domains are never reused, this doesn't need any randomness
+    return `${domain}:${port}`;
 }
 
-// NOTE: For client connections, at which point we have the nodeId, location and callFactory.
-export function registerNodeClient(callFactory: CallFactory) {
-    let { nodeId } = callFactory;
-    // NOTE: We can always clobber the entry, AS, during client connection we give NetworkLocation information,
-    //  so even if we already have this node with NetworkLocation.listeningPorts, this new values should
-    //  be even newer, or the same.
-    //  - AND, clobbering shouldn't happen often, if the other end connected to us they should have given us their
-    //      nodeId. So they'll use the existing websocket when using that nodeId, instead of establishing a new connection,
-    //      except for race conditions cases, in which case we just have an extra connection, which isn't so bad...
-    //      - And of course, we have to use the newer connection, as it might be the case that the NetworkLocation has actually
-    //          updated, and the old connection is now forever closed.
+/** A nodeId not available for reconnecting. */
+export function getClientNodeId(address: string): string {
+    return `client_${address}:${Date.now()}:${Math.random()}`;
+}
 
-    // Never go from listening ports to no listening ports. Worst case the listening ports are old
-    //  and won't work, in which case... we won't be able to reconnect, which basically what
-    //  we would do if there were no listening ports.
-    let prevFactory = nodeCache.get(nodeId)?.callFactory;
-    if (prevFactory && !(prevFactory instanceof Promise)) {
-        let prevListeningPorts = prevFactory.location.listeningPorts;
-        if (prevListeningPorts && !callFactory.location.listeningPorts.length) {
-            callFactory.location.listeningPorts = prevListeningPorts;
-        }
+export function getNodeIdLocation(nodeId: string): { address: string, port: number; } | undefined {
+    if (nodeId.startsWith("client_")) {
+        return undefined;
     }
-    // TODO: Maybe even preserve the address in some cases, such as if it was a domain, and is now an ip?
-    nodeCache.set(nodeId, {
-        callFactory,
-        location: undefined,
-    });
+    let [address, port] = nodeId.split(":");
+    return { address, port: parseInt(port) };
 }
 
-export function getCreateCallFactoryLocation(location: NetworkLocation, tempNodeId?: string): MaybePromise<string> {
-    let locationHash = getNetworkLocationHash(location);
-    let nodeId = locationLookup.get(locationHash);
-    if (nodeId !== undefined) {
-        return nodeId;
+export function getNodeIdDomain(nodeId: string): string {
+    let location = getNodeIdLocation(nodeId);
+    if (!location) {
+        throw new Error(`Cannot get domain from nodeId, which is only usable as a client. NodeId: ${JSON.stringify(nodeId)}`);
     }
+    return new URL(location.address).hostname.split(".").slice(-2).join(".");
+}
 
-    let callFactoryPromise = callFactoryFromLocation(location);
-    let nodeIdPromise = callFactoryPromise.then(x => x.nodeId);
-    locationLookup.set(locationHash, nodeIdPromise);
+// NOTE: CallFactory turns into an actual CallFactory when registerNodeClient is called
+// nodeId => 
+const nodeCache = new Map<string, MaybePromise<CallFactory>>();
 
-    if (tempNodeId !== undefined) {
-        nodeCache.set(tempNodeId, {
-            callFactory: callFactoryPromise,
-            location,
-        });
+// NOTE: Should be called directly inside call factory constructor whenever
+//      their nodeId changes (and on construction).
+export function registerNodeClient(callFactory: CallFactory) {
+    nodeCache.set(callFactory.nodeId, callFactory);
+    startCleanupLoop();
+}
+
+export function getCreateCallFactoryLocation(nodeId: string, mountedNodeId: string): MaybePromise<CallFactory> {
+    let callFactory = nodeCache.get(nodeId);
+    if (callFactory === undefined) {
+        callFactory = createCallFactory(undefined, nodeId, mountedNodeId);
+        nodeCache.set(nodeId, callFactory);
     }
+    return callFactory;
+}
 
-    return callFactoryPromise.then(callFactory => {
-        let nodeId = callFactory.nodeId;
-        // TODO: Maybe warn if we just clobbered a nodeId?
-        let prevEntry = nodeCache.get(nodeId);
-        if (prevEntry) {
-            if (prevEntry.callFactory instanceof Promise) {
-                console.warn(`Clobbering nodeId ${nodeId}, with a new location ${locationHash}, which was still resolving. (This might indiciate multiple locations with the same nodeId, which could cause an issue. If this happens repeatedly it will cause stability issues).`);
-            } else {
-                console.warn(`Clobbering nodeId ${nodeId}, with a new location ${locationHash}, was ${getNetworkLocationHash(prevEntry.callFactory.location)}. (This might indiciate multiple locations with the same nodeId, which could cause an issue. If this happens repeatedly it will cause stability issues).`);
+const startCleanupLoop = lazy(() => {
+    (async () => {
+        while (true) {
+            for (let [key, value] of Array.from(nodeCache.entries())) {
+                let factory = value;
+                if (!(factory instanceof Promise)) {
+                    if (factory.closedForever) {
+                        nodeCache.delete(key);
+                    }
+                }
             }
+            await new Promise(resolve => setTimeout(resolve, 1000 * 60 * 5));
         }
-        nodeCache.set(nodeId, {
-            callFactory,
-            location,
-        });
-        return nodeId;
+    })().catch(e => {
+        console.error(`nodeCache cleanup loop failed, ${e.stack}`);
     });
-}
-
-
-// TODO: Give a special error if the nodeId has been seen, but is only one-way (from HTTP requests).
-export async function getCallFactoryFromNodeId(nodeId: string): Promise<CallFactory | undefined> {
-    return await nodeCache.get(nodeId)?.callFactory;
-}
-// NOTE: Only works if the nodeId has been loaded with getCreateCallFactoryLocation
-export function getLocationFromNodeId(nodeId: string): NetworkLocation | undefined {
-    return nodeCache.get(nodeId)?.location;
-}
+});

package/src/webSocketServer.ts

@@ -3,18 +3,11 @@ import http from "http";
 import net from "net";
 import tls from "tls";
 import * as ws from "ws";
-import { performLocalCall } from "./callManager";
-import { CallerContext, CallType, NetworkLocation } from "../SocketFunctionTypes";
-import { CallFactory, callFactoryFromWS } from "./CallFactory";
-import { registerNodeClient } from "./nodeCache";
-import { getCertKeyPair, getNodeId, getNodeIdRaw } from "./nodeAuthentication";
-import debugbreak from "debugbreak";
-import { cache } from "./caching";
-import { getNodeIdFromRequest, getServerLocationFromRequest, httpCallHandler } from "./callHTTPHandler";
+import { getCertKeyPair, getNodeIdFromCert } from "./nodeAuthentication";
+import { getNodeIdsFromRequest, httpCallHandler } from "./callHTTPHandler";
 import { SocketFunction } from "../SocketFunction";
-
-// TODO: Support conditional peer certificate requests, as it the certificate prompt
-//  seems suspicious in the browser (the user can just click cancel though).
+import { getTrustedUserCertificates, loadTrustedUserCertificates, watchUserCertificates } from "./certStore";
+import { createCallFactory } from "./CallFactory";
 
 export type SocketServerConfig = (
     {
@@ -30,7 +23,7 @@ export type SocketServerConfig = (
 
 export async function startSocketServer(
     config: SocketServerConfig
-) {
+): Promise<string> {
     let isSecure = "cert" in config || "key" in config || "pfx" in config;
     if (!isSecure) {
         let { key, cert } = getCertKeyPair();
@@ -38,19 +31,30 @@ export async function startSocketServer(
         config.cert = cert;
     }
 
+    await loadTrustedUserCertificates();
+
     // TODO: Only allow unauthorized for ip certificates, and then for domains use the domain as the nodeId,
     //  so it is easy to read, and consistent.
-    let httpsServer = https.createServer({
+    let options: https.ServerOptions = {
         ...config,
         rejectUnauthorized: SocketFunction.rejectUnauthorized,
         requestCert: true,
-        ca: tls.rootCertificates.concat(SocketFunction.additionalTrustedRootCAs),
+    };
+
+    let httpsServer = https.createServer(options);
+    watchUserCertificates(() => {
+        options.ca = tls.rootCertificates.concat(getTrustedUserCertificates());
+        httpsServer.setSecureContext(options);
     });
+
     httpsServer.on("connection", socket => {
         console.log("Client connection established");
         socket.on("error", e => {
             console.log(`Client socket error ${e.message}`);
         });
+        socket.on("close", () => {
+            console.log("Client socket closed");
+        });
     });
     httpsServer.on("error", e => {
         console.error(`Connection attempt error ${e.message}`);
@@ -83,15 +87,11 @@ export async function startSocketServer(
                 return;
             }
         }
-        webSocketServer.handleUpgrade(request, socket, upgradeHead, async (ws) => {
-            // NOTE: For the browser, the request will likely have a nodeId, from making an HTTP request.
-            //  We would prefer peer certificates, so this isn't the default (in getNodeId), but it will
-            //  likely be used most of the time.
-            let requestNodeId = getNodeIdFromRequest(request);
-            Object.assign(ws, { nodeId: requestNodeId });
-
-            let clientCallFactory = await callFactoryFromWS(ws, getServerLocationFromRequest(request));
-            registerNodeClient(clientCallFactory);
+        webSocketServer.handleUpgrade(request, socket, upgradeHead, (ws) => {
+            const { nodeId, localNodeId } = getNodeIdsFromRequest(request);
+            createCallFactory(ws, nodeId, localNodeId).catch(e => {
+                console.error(`Error in creating call factory, ${e.stack}`);
+            });
         });
     });
 
@@ -146,5 +146,13 @@ export async function startSocketServer(
 
     await listenPromise;
 
-    console.log(`Started Listening on ${host}:${config.port}`);
+    let port = (realServer.address() as net.AddressInfo).port;
+
+    console.log(`Started Listening on ${host}:${port}`);
+
+    let serverNodeId = getNodeIdFromCert({ raw: config.cert as Buffer | string }, port);
+    if (!serverNodeId) {
+        throw new Error(`Something is wrong with our cert, we don't have a nodeId?`);
+    }
+    return serverNodeId;
 }