socket-function 0.18.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.18.0",
+	"version": "0.19.0",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/require/require.js

@@ -240,7 +240,7 @@
             return requestsResolvedPaths.map(x => getModule(x));
         } finally {
             time = Date.now() - time;
-            console.log(`%cimport(${requests.join(", ")}) finished evaluate ${time}ms (${moduleCount} modules) at ${Date.now() - startTime}ms`, "color: blue");
+            console.log(`%cimport(${requests.join(", ")}) finished evaluate ${time}ms (${moduleCount} modules) at ${Date.now() - startTime}ms`, "color: lightblue");
         }
     }
 

package/src/batching.ts

@@ -226,7 +226,7 @@ export async function runInfinitePollCallAtStart(
                 try {
                     await fnc();
                 } catch (e: any) {
-                    console.error(`Error in infinite poll ${fnc.name} (continuing poll loop)\n${e.stack}`);
+                    console.error(`Error in infinite poll ${fnc.name || fnc.toString().slice(0, 100)} (continuing poll loop)\n${e.stack}`);
                 }
             }
         })();

package/src/misc.ts

@@ -1,4 +1,3 @@
-import * as crypto from "crypto";
 import { canHaveChildren, MaybePromise } from "./types";
 import { formatNumber } from "./formatting/format";
 
@@ -18,16 +17,17 @@ export function convertErrorStackToError(error: string): Error {
     return errorObj;
 }
 
+
 export function sha256Hash(buffer: Buffer | string): string {
-    return crypto.createHash("sha256").update(buffer).digest("hex");
+    return require("crypto").createHash("sha256").update(buffer).digest("hex");
 }
 export function sha256HashBuffer(buffer: Buffer | string): Buffer {
-    return crypto.createHash("sha256").update(buffer).digest();
+    return require("crypto").createHash("sha256").update(buffer).digest();
 }
 /** Async, but works both clientside and serverside. */
 export async function sha256HashPromise(buffer: Buffer) {
     if (isNode()) {
-        return crypto.createHash("sha256").update(buffer).digest("hex");
+        return require("crypto").createHash("sha256").update(buffer).digest("hex");
     } else {
         let buf = await window.crypto.subtle.digest("SHA-256", buffer);
         return Buffer.from(buf).toString("hex");
@@ -35,7 +35,7 @@ export async function sha256HashPromise(buffer: Buffer) {
 }
 export async function sha256BufferPromise(buffer: Buffer): Promise<Buffer> {
     if (isNode()) {
-        return crypto.createHash("sha256").update(buffer).digest();
+        return require("crypto").createHash("sha256").update(buffer).digest();
     } else {
         let buf = await window.crypto.subtle.digest("SHA-256", buffer);
         return Buffer.from(buf);

package/test.ts

@@ -8,23 +8,23 @@ import { forwardPort } from "./src/forwardPort";
 
 // Usage example:
 async function main() {
-    const externalPort = 8088;
+    const externalPort = 11300;
     const internalPort = externalPort;
 
     await forwardPort({ externalPort, internalPort });
 
     // Listen on the external port
-    const server = http.createServer((req, res) => {
-        console.log("Request received");
-        res.end("Hello, world!");
-    });
-    server.listen(externalPort, "0.0.0.0");
-
-    {
-        const externalIP = await getExternalIP();
-        let test = await fetch(`http://${externalIP}:${externalPort}`);
-        console.log(await test.text());
-    }
+    // const server = http.createServer((req, res) => {
+    //     console.log("Request received");
+    //     res.end("Hello, world!");
+    // });
+    // server.listen(externalPort, "0.0.0.0");
+
+    // {
+    //     const externalIP = await getExternalIP();
+    //     let test = await fetch(`http://${externalIP}:${externalPort}`);
+    //     console.log(await test.text());
+    // }
 
 
     //await createPortMapping({ externalPort, internalPort, gateWayIP, internalIP, });

package/time/trueTimeShim.ts

@@ -15,6 +15,10 @@ const UPDATE_SMEAR_TICK_DURATION = 100;
 const UPDATE_SMEAR_TICK_COUNT = 100;
 const UPDATE_VERIFY_COUNT = 3;
 
+// Time can never go backwards, but we can run at a slower rate until the output time allows
+//      the real time to catch up with it.
+const MINIMUM_TIME_RATE = 0.5;
+
 let trueTimeOffset = 0;
 let didFirstTimeSync = false;
 let onFirstTimeSync!: () => void;
@@ -23,8 +27,29 @@ let firstTimeSyncPromise = new Promise<void>((resolve) => {
 });
 
 const baseGetTime = Date.now;
+let lastTime = 0;
+let lastBaseTime = 0;
 export function getTrueTime() {
-    return baseGetTime() + trueTimeOffset;
+    let baseTime = baseGetTime();
+    let time = baseTime + trueTimeOffset;
+    // Only adjust time once we have a time offset. Otherwise systems with a really bad clock
+    //  might take days be correct. It is better for the time to jump once at startup, rather
+    //  than be off by days, for days at a time.
+    if (lastTime && trueTimeOffset) {
+        if (time < lastTime) {
+            let diff = baseTime - lastBaseTime;
+            if (diff >= 0) {
+                // Some time passed, so we have a baseline for how much to increase the time by.
+                //  This allows the real time to catch up with our time naturally.
+                time = lastTime + diff * MINIMUM_TIME_RATE;
+            } else {
+                // The issue is the system time going backwards. In this case, allow the time to change
+            }
+        }
+    }
+    lastTime = time;
+    lastBaseTime = baseTime;
+    return time;
 }
 export function getTrueTimeOffset() {
     return trueTimeOffset;