added local computation of random beacon

Author: sbazerque

examples/randomness-beacon/index.ts

@@ -0,0 +1,18 @@
+import { Beacon } from './model/Beacon';
+import { RNGImpl } from 'crypto/random';
+
+const STEPS = 66;
+
+async function main() {
+
+    console.log('creating random beacon...');
+
+    let beacon = new Beacon(new RNGImpl().randomHexString(128), STEPS);
+
+    //let res = await Beacon.computeVdfAsync(STEPS, new RNGImpl().randomHexString(128));
+
+    beacon.startCompute();
+
+}
+
+main();

examples/randomness-beacon/model/Beacon.ts

@@ -1,9 +1,20 @@
+import '@hyper-hyper-space/node-env';
+
 import { Hashing, HashedObject, MutableObject, MutationOp } from 'data/model';
 
 import { BeaconValueOp } from './BeaconValueOp';
 
+import { Worker, parentPort } from 'worker_threads';
+import { Logger, LogLevel } from 'util/logging';
+
+const createVdf = require('@subspace/vdf').default;
+(global as any).document = { }; // yikes!
+
 class Beacon extends MutableObject {
 
+    static log = new Logger(Beacon.name, LogLevel.DEBUG)
+    
+
     static className = 'hhs/v0/examples/Beacon';
     static opClasses = [BeaconValueOp.className];
 
@@ -12,6 +23,28 @@ class Beacon extends MutableObject {
     _lastOp?: BeaconValueOp;
     _values: string[];
 
+    _computation?: Worker;
+    _autoCompute: boolean;
+
+    static computeVdf(): void {
+
+        parentPort?.on('message', async (q: {challenge: string, steps: number}) => {
+
+            const vdfInstance = await createVdf();
+            const result = vdfInstance.generate(q.steps, Buffer.from(q.challenge, 'hex'), 2048, true);
+
+            parentPort?.postMessage(
+                { 
+                    challenge: q.challenge,
+                    steps: q.steps,
+                    result: Buffer.from(result).toString('hex')
+                }
+            );
+        });
+        
+
+    }
+
     constructor(seed?: string, steps?: number) {
         super(Beacon.opClasses);
 
@@ -21,22 +54,89 @@ class Beacon extends MutableObject {
         }
 
         this._values = [];
+        this._autoCompute = false;
+    }
+
+    startCompute() {
+        this._autoCompute = true;
+        this.race();
+    }
+
+    stopCompute() {
+        this._autoCompute = false;
+        this.stopCompute();
+    }
+
+    race() {
+        if (this._computation === undefined) {
+
+            Beacon.log.debug(() => 'Racing for challenge (' + this.steps + ' steps): "' + this.currentChallenge() + '".');
+
+            this._computation = new Worker('./dist-examples/examples/randomness-beacon/model/worker.js');
+
+            this._computation.postMessage({steps: this.steps, challenge: this.currentChallenge()});
+
+            this._computation.on('message', async (msg: {challenge: string, result: string}) => {
+                
+                Beacon.log.debug(() => 'Solved challenge "' + msg.challenge + '" with: "' + msg.result + '".');
+
+                this.stopRace();
+
+                if (msg.challenge === this.currentChallenge()) {
+                    let op = new BeaconValueOp(this, this.currentSeq(), msg.result);
+
+                    if (this._lastOp !== undefined) {
+                        op.setPrevOps(new Set([this._lastOp.createReference()]).values());
+                    }
+
+                    await this.applyNewOp(op);
+                    if (this._autoCompute) {
+                        this.race();
+                    }
+                }
+            });
+        }
+    }
+
+    stopRace() {
+        if (this._computation !== undefined) {
+            this._computation.terminate();
+            this._computation = undefined;
+        }
+    }
+
+    private currentChallenge(): string {
+        if (this._lastOp === undefined) {
+            return this.getId() as string;
+        } else {
+            return Hashing.toHex(this._lastOp.hash());
+        }
+    }
+
+    private currentSeq() {
+        if (this._lastOp === undefined) {
+            return 0;
+        } else {
+            return (this._lastOp.seq as number) + 1;
+        }
     }
 
 
     async mutate(op: MutationOp, isNew: boolean): Promise<void> {
 
+        isNew;
+
         if (op instanceof BeaconValueOp) {
 
-            if (!isNew && this._lastOp !== undefined &&
+            if (this._lastOp === undefined ||
                 !this._lastOp.equals(op)) {
 
                 if (op.prevOps?.size() === 0) {
+
                     if (this._lastOp !== undefined) {
                         throw new Error('Initial BeaconValueOp received, but there are already other ops in this beacon.');
                     }
 
-                    
                 } else {
                     if (this._lastOp === undefined) {
                         throw new Error('Non-initial BeaconValueOp received, but there are no values in this beacon.');
@@ -48,7 +148,14 @@ class Beacon extends MutableObject {
                 }
 
                 this._lastOp = op;
+
                 this._values.push(Hashing.toHex(op.hash()));
+
+                this.stopRace();
+
+                if (this._autoCompute) {
+                    this.race();
+                }
 
             }
 
@@ -58,7 +165,7 @@ class Beacon extends MutableObject {
     }
 
     getClassName(): string {
-        throw new Error('Method not implemented.');
+        return Beacon.className;
     }
 
     init(): void {

examples/randomness-beacon/model/BeaconValueOp.ts

@@ -94,6 +94,9 @@ class BeaconValueOp extends MutationOp {
 
         const steps = (this.getTarget() as Beacon).steps as number;
 
+
+        //TODO: make sure there is no upper/lowercase ambiguity in the vdfResult!
+
         if (!BeaconValueOp.vdfVerifier.verify(steps, challenge, this.vdfResult, 2048, true)) {
             return false;
         }

examples/randomness-beacon/model/worker.ts

@@ -0,0 +1,3 @@
+import { Beacon } from './Beacon';
+
+Beacon.computeVdf();

package.json

@@ -14,11 +14,13 @@
   "scripts": {
     "build": "npx microbundle-crl --tsconfig tsconfig.build.json &&  npx tsc --project tsconfig.build.json --declaration --outDir ./decl",
     "build-test": "npx microbundle-crl --tsconfig tsconfig.json --output dist-test",
-    "build-chat": "npx tsc --module CommonJs --project tsconfig.json --outDir ./dist-chat",
-    "chat": "NODE_PATH=\"dist-chat/src:dist-chat/examples/chat\" node ./dist-chat/examples/chat/index.js",
-    "winchat": "./scripts/chat.bat",
-    "clean": "rm -rf ./decl/* ./dist/* ./dist-test/* ./dist-chat/*",
-    "winclean": "if exist decl (rmdir decl /s /q) && mkdir decl && if exist dist (rmdir dist /s /q) && mkdir dist && if exist dist-test (rmdir dist-test /s /q) && mkdir dist-test && if exist dist-chat (rmdir dist-chat /s /q) && mkdir dist-chat",
+    "build-examples": "npx tsc --module CommonJs --project tsconfig.json --outDir ./dist-examples",
+    "example-chat": "NODE_PATH=\"dist-examples/src:dist-examples/examples/chat\" node ./dist-examples/examples/chat/index.js",
+    "example-chat-win": "./scripts/chat.bat",
+    "example-beacon": "NODE_PATH=\"dist-examples/src:dist-examples/examples/chat\" node ./dist-examples/examples/randomness-beacon/index.js",
+    "example-beacon-win": "./scripts/beacon.bat",
+    "clean": "rm -rf ./decl/* ./dist/* ./dist-test/* ./dist-examples/*",
+    "winclean": "if exist decl (rmdir decl /s /q) && mkdir decl && if exist dist (rmdir dist /s /q) && mkdir dist && if exist dist-test (rmdir dist-test /s /q) && mkdir dist-test && if exist dist-examples (rmdir dist-examples /s /q) && mkdir dist-examples",
     "test": "npx jest"
   },
   "devDependencies": {

scripts/beacon.bat

@@ -0,0 +1,4 @@
+@ECHO OFF
+setx NODE_PATH "dist-examples/src;dist-examples/examples/randomness-beacon" > $null
+@ECHO ON
+node ./dist-examples/examples/randomness-beacon/index.js

scripts/chat.bat

@@ -1,4 +1,7 @@
 @ECHO OFF
-setx NODE_PATH "dist-chat/src;dist-chat/examples/chat" > $null
+setx NODE_PATH "dist-examples/src;dist-examples/examples/chat" > $null
 @ECHO ON
-node ./dist-chat/examples/chat/index.js
+
+echo ${NODE_PATH}
+
+node ./dist-examples/examples/chat/index.js

src/crypto/ciphers/JSEncryptRSA.ts

@@ -4,17 +4,33 @@ import { SHA, SHAImpl } from '../hashing';
 
 // dummy objects for JSEncrypt
 
+let fixNavigator = false;
+
 if ((global as any).navigator === undefined) {
     (global as any).navigator = {appName: 'nodejs'};
+    fixNavigator = true;
 }
 
+let fixWindow = false;
+
 if ((global as any).window === undefined) {
     (global as any).window = {};
+    fixWindow = true;
 }
 
 
 const JSEncrypt = require('jsencrypt').JSEncrypt;
 
+
+if (fixNavigator) {
+    (global as any).navigator = undefined;
+}
+
+if (fixWindow) {
+    (global as any).window = undefined;
+}
+
+
 class JSEncryptRSA implements RSA {
 
     static PKCS8 = 'pkcs8';