trac-msb 0.0.80 → 0.0.82

package/Whitelist/pubkeys.csv

@@ -1,2 +1,5 @@
 e247a9ceefb8a83e28d3c5845055910bc61e0b418c7578d297354708f276af04
-580c44d7827fbeeb7778e4d2dce660b30f3ca3baa4de254ecd556dfb5b60fc35
+580c44d7827fbeeb7778e4d2dce660b30f3ca3baa4de254ecd556dfb5b60fc35
+a3590854889d059927fed4dfdf329b75447bc9f5885b6a843b317d1c2d38258a
+dd2f83c9cb1d146c8be6c1d98822cbbb3f631a0659b765c9e4564960acf6e228
+726b2885e551a98c20b37675b113476390f57321768a303e1b6c029ffca509a9

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-msb",
   "main": "msb.mjs",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"

package/src/index.js

@@ -67,7 +67,7 @@ export class MainSettlementBus extends ReadyResource {
         this.#bee = null;
         this.#swarm = null;
         this.#dht_node = new DHT();
-        this.#dht_server = this.#dht_node.createServer();
+        this.#dht_server = null;
         this.#base = null;
         this.#writingKey = null;
         this.#enable_txchannel = options.enable_txchannel !== false;
@@ -121,7 +121,6 @@ export class MainSettlementBus extends ReadyResource {
         for (const node of nodes) {
             const op = node.value;
             const handler = this.#getApplyOperationHandler(op.type);
-
             if (handler) {
                 await handler(op, view, base, node, batch);
             } else {
@@ -165,7 +164,7 @@ export class MainSettlementBus extends ReadyResource {
         if (!this.check.sanitizeAdminAndWritersOperations(op)) return;
         const adminEntry = await batch.get(EntryType.ADMIN);
         if (null === adminEntry) {
-            await this.#addAdminIfNotSet(op, view, node);
+            await this.#addAdminIfNotSet(op, view, node, batch);
         }
         else if (adminEntry.value.tracPublicKey === op.key) {
             await this.#addAdminIfSet(adminEntry.value, op, view, base, batch);
@@ -188,7 +187,7 @@ export class MainSettlementBus extends ReadyResource {
         }
     }
 
-    async #addAdminIfNotSet(op, view, node) {
+    async #addAdminIfNotSet(op, view, node, batch) {
         const isMessageVerifed = await this.#verifyMessage(op.value.sig, op.key, MsgUtils.createMessage(op.key, op.value.wk, op.value.nonce, op.type));
 
         if (node.from.key.toString('hex') === this.#bootstrap &&
@@ -233,8 +232,8 @@ export class MainSettlementBus extends ReadyResource {
     }
 
     async #addWriter(op, batch, base) {
-        const nodeEntry = await this.getSigned(op.key);
-        if (nodeEntry === null || !nodeEntry.isWriter) {
+        const nodeEntry = await batch.get(op.key);
+        if (nodeEntry === null || !nodeEntry.value.isWriter) {
             await base.addWriter(b4a.from(op.value.wk, 'hex'), { isIndexer: false })
             await batch.put(op.key, {
                 wk: op.value.wk,
@@ -246,8 +245,8 @@ export class MainSettlementBus extends ReadyResource {
     }
 
     async #handleApplyRemoveWriterOperation(op, view, base, node, batch) {
-        const adminEntry = await this.getSigned(EntryType.ADMIN);
-        if (!this.check.sanitizeAdminAndWritersOperations(op) || !this.#isAdmin(adminEntry, node)) return;
+        const adminEntry = await batch.get(EntryType.ADMIN);
+        if (null === adminEntry || !this.check.sanitizeAdminAndWritersOperations(op) || !this.#isAdmin(adminEntry.value, node)) return;
         const isMessageVerifed = await this.#verifyMessage(op.value.sig, op.key, MsgUtils.createMessage(op.key, op.value.wk, op.value.nonce, op.type));
         if (isMessageVerifed) {
             await this.#removeWriter(op, batch, base);
@@ -255,18 +254,19 @@ export class MainSettlementBus extends ReadyResource {
     }
 
     async #removeWriter(op, batch, base) {
-        const nodeEntry = await this.getSigned(op.key)
+        let nodeEntry = await batch.get(op.key)
         if (nodeEntry !== null) {
+            nodeEntry = nodeEntry.value;
             await base.removeWriter(b4a.from(nodeEntry.wk, 'hex'));
             nodeEntry.isWriter = false;
             if (nodeEntry.isIndexer) {
                 nodeEntry.isIndexer = false;
-                const indexersEntry = await this.getSigned(EntryType.INDEXERS);
-                if (indexersEntry && indexersEntry.includes(op.key)) {
-                    const idx = indexersEntry.indexOf(op.key);
+                const indexersEntry = await batch.get(EntryType.INDEXERS);
+                if (null !== indexersEntry && indexersEntry.value.includes(op.key)) {
+                    const idx = indexersEntry.value.indexOf(op.key);
                     if (idx !== -1) {
-                        indexersEntry.splice(idx, 1);
-                        await batch.put(EntryType.INDEXERS, indexersEntry);
+                        indexersEntry.value.splice(idx, 1);
+                        await batch.put(EntryType.INDEXERS, indexersEntry.value);
                     }
                 }
             }
@@ -281,27 +281,27 @@ export class MainSettlementBus extends ReadyResource {
             return;
         }
 
-        const adminEntry = await this.getSigned(EntryType.ADMIN);
-        if (!this.#isAdmin(adminEntry, node)) return;
+        const adminEntry = await batch.get(EntryType.ADMIN);
+        if (null === adminEntry || !this.#isAdmin(adminEntry.value, node)) return;
 
         if (!this.#isWhitelisted(op.key)) return;
 
-        const indexersEntry = await this.getSigned(EntryType.INDEXERS);
-        if (!indexersEntry || Array.from(indexersEntry).includes(op.key) ||
-            Array.from(indexersEntry).length >= MAX_INDEXERS) {
+        const indexersEntry = await batch.get(EntryType.INDEXERS);
+        if (null === indexersEntry || Array.from(indexersEntry.value).includes(op.key) ||
+            Array.from(indexersEntry.value).length >= MAX_INDEXERS) {
             return;
         }
-        const isMessageVerifed = await this.#verifyMessage(op.value.sig, adminEntry.tracPublicKey, MsgUtils.createMessage(op.key, op.value.nonce, op.type))
+        const isMessageVerifed = await this.#verifyMessage(op.value.sig, adminEntry.value.tracPublicKey, MsgUtils.createMessage(op.key, op.value.nonce, op.type))
         if (isMessageVerifed) {
-            await this.#addIndexer(indexersEntry, op, batch, base);
+            await this.#addIndexer(indexersEntry.value, op, batch, base);
         }
     }
 
     async #addIndexer(indexersEntry, op, batch, base) {
-        const nodeEntry = await this.getSigned(op.key);
-
-        if (nodeEntry !== null && nodeEntry.isWriter && !nodeEntry.isIndexer) {
+        let nodeEntry = await batch.get(op.key);
 
+        if (nodeEntry !== null && nodeEntry.value.isWriter && !nodeEntry.value.isIndexer) {
+            nodeEntry = nodeEntry.value;
             await base.removeWriter(b4a.from(nodeEntry.wk, 'hex'));
             await base.addWriter(b4a.from(nodeEntry.wk, 'hex'), { isIndexer: true })
             nodeEntry.isIndexer = true;
@@ -314,13 +314,15 @@ export class MainSettlementBus extends ReadyResource {
 
     async #handleApplyRemoveIndexerOperation(op, view, base, node, batch) {
         if (!this.check.sanitizeIndexerOrWhitelistOperations(op)) return;
-        const adminEntry = await this.getSigned(EntryType.ADMIN);
-        const indexersEntry = await this.getSigned(EntryType.INDEXERS);
-        if (!this.#isAdmin(adminEntry, node) || !indexersEntry || !Array.from(indexersEntry).includes(op.key) || Array.from(indexersEntry).length <= 1) return;
-        const isMessageVerifed = await this.#verifyMessage(op.value.sig, adminEntry.tracPublicKey, MsgUtils.createMessage(op.key, op.value.nonce, op.type))
+        const adminEntry = await batch.get(EntryType.ADMIN);
+        let indexersEntry = await batch.get(EntryType.INDEXERS);
+        if (null === adminEntry || !this.#isAdmin(adminEntry.value, node) || null === indexersEntry || !Array.from(indexersEntry.value).includes(op.key) || Array.from(indexersEntry.value).length <= 1) return;
+        const isMessageVerifed = await this.#verifyMessage(op.value.sig, adminEntry.value.tracPublicKey, MsgUtils.createMessage(op.key, op.value.nonce, op.type))
         if (isMessageVerifed) {
-            const nodeEntry = await this.getSigned(op.key);
-            if (nodeEntry !== null && nodeEntry.isWriter && nodeEntry.isIndexer) {
+            let nodeEntry = await batch.get(op.key);
+            if (nodeEntry !== null && nodeEntry.value.isWriter && nodeEntry.value.isIndexer) {
+                indexersEntry = indexersEntry.value;
+                nodeEntry = nodeEntry.value;
                 await base.removeWriter(b4a.from(nodeEntry.wk, 'hex'));
 
                 nodeEntry.isWriter = false;
@@ -355,7 +357,8 @@ export class MainSettlementBus extends ReadyResource {
         }
 
         if (this.#enable_txchannel) {
-            await Network.dhtServer(this.#dht_server, this.#base, this.#wallet, this.#writingKey, this.#network);
+            this.#dht_server = this.#dht_node.createServer();
+            await Network.dhtServer(this, this.#dht_server, this.#base, this.#wallet, this.#writingKey, this.#network);
         }
 
         const adminEntry = await this.getSigned(EntryType.ADMIN);
@@ -412,11 +415,13 @@ export class MainSettlementBus extends ReadyResource {
         if (!adminEntry || !message) {
             return;
         }
-        this.#swarm.connections.forEach((conn) => {
-            if (b4a.from(conn.remotePublicKey).toString('hex') === adminEntry.tracPublicKey && conn.connected) {
-                conn.write(JSON.stringify(message));
-            }
+        const stream = this.#dht_node.connect(b4a.from(adminEntry.tracPublicKey, 'hex'))
+        stream.on('connect', async function () {
+            await stream.send(b4a.from(JSON.stringify({ op : 'add_writer', message : message })));
         });
+        stream.on('open', function () { });
+        stream.on('close', () => { });
+        stream.on('error', (error) => { });
     }
 
     async #verifyMessage(signature, publicKey, bufferMessage) {
@@ -432,7 +437,7 @@ export class MainSettlementBus extends ReadyResource {
         return !!(this.#wallet.publicKey === adminEntry.tracPublicKey && adminEntry.wk === this.#writingKey);
     }
 
-    async #isAllowedToRequestRole(key, adminEntry) {
+    async isAllowedToRequestRole(key, adminEntry) {
         const isWhitelisted = await this.#isWhitelisted(key);
         return !!(isWhitelisted && !this.#isAdmin(adminEntry));
     }
@@ -639,7 +644,7 @@ export class MainSettlementBus extends ReadyResource {
         const isAlreadyWriter = !!(nodeEntry && nodeEntry.isWriter)
         let assembledMessage = null;
         if (toAdd) {
-            const isAllowedToRequestRole = await this.#isAllowedToRequestRole(this.#wallet.publicKey, adminEntry);
+            const isAllowedToRequestRole = await this.isAllowedToRequestRole(this.#wallet.publicKey, adminEntry);
             const canAddWriter = !!(!this.#base.writable && !isAlreadyWriter && isAllowedToRequestRole);
             if (canAddWriter) {
                 assembledMessage = await MsgUtils.assembleAddWriterMessage(this.#wallet, this.#writingKey);
@@ -651,6 +656,8 @@ export class MainSettlementBus extends ReadyResource {
             }
         }
 
+        console.log(assembledMessage);
+
         if (assembledMessage) {
             this.#sendMessageToAdmin(adminEntry, assembledMessage);
         }

package/src/network.js

@@ -1,7 +1,15 @@
 import w from 'protomux-wakeup';
 import b4a from 'b4a';
 import Hyperswarm from 'hyperswarm';
-import { EventType, TRAC_NAMESPACE, MAX_PEERS, MAX_PARALLEL, MAX_SERVER_CONNECTIONS, OperationType } from './utils/constants.js';
+import {
+    EventType,
+    TRAC_NAMESPACE,
+    MAX_PEERS,
+    MAX_PARALLEL,
+    MAX_SERVER_CONNECTIONS,
+    OperationType,
+    EntryType
+} from './utils/constants.js';
 import {sleep } from './utils/functions.js';
 import MsgUtils from './utils/msgUtils.js';
 import Check from './utils/check.js';
@@ -52,15 +60,25 @@ class Network {
         return swarm;
     }
 
-    static async dhtServer(dhtServer, base, wallet, writingKey, networkInstance){
+    static async dhtServer(msb, dhtServer, base, wallet, writingKey, networkInstance){
         try{
             dhtServer.on('connection', function (connection) {
                 connection.on('message', async (msg) =>  {
                     msg = b4a.toString(msg, 'utf-8');
+                    msg = JSON.parse(msg);
                     if(msg === 'get_writer_key'){
                         await connection.send(b4a.from(JSON.stringify({op:'writer_key', key : writingKey})));
+                    } else if(msg.op !== undefined && msg.message !== undefined && msg.op === 'add_writer'){
+                        const adminEntry = await msb.getSigned(EntryType.ADMIN);
+                        const nodeEntry = await msb.getSigned(msg.message.pk);
+                        const isAlreadyWriter = !!(nodeEntry && nodeEntry.isWriter);
+                        const isAllowedToRequestRole = await msb.isAllowedToRequestRole(msg.message.pk, adminEntry);
+                        const canAddWriter = !!(!base.writable && !isAlreadyWriter && isAllowedToRequestRole);
+                        if(null !== adminEntry && adminEntry.tracPublicKey === wallet.publicKey
+                            && msg.message.pk !== wallet.publicKey && canAddWriter){
+                            await base.append(msg.message);
+                        }
                     } else {
-
                         if (base.isIndexer || !base.writable) return;
 
                         // TODO: decide if a tx rejection should be responded with
@@ -72,7 +90,7 @@ class Network {
                         if (b4a.byteLength(msg) > 3072) return;
 
                         try {
-                            const parsedPreTx = JSON.parse(msg);
+                            const parsedPreTx = msg;
 
                             if (networkInstance.check.sanitizePreTx(parsedPreTx) &&
                                 wallet.verify(b4a.from(parsedPreTx.is, 'hex'), b4a.from(parsedPreTx.tx + parsedPreTx.in), b4a.from(parsedPreTx.ipk, 'hex')) &&
@@ -113,7 +131,7 @@ class Network {
             };
             await dhtServer.listen(keyPair)
             console.log('DHT node is listening on public key', wallet.publicKey);
-        } catch(e) { }
+        } catch(e) { console.log(e) }
     }
 
     async pool(base) {

package/src/utils/check.js

@@ -69,6 +69,7 @@ class Check {
             value: {
                 $$strict: true,
                 $$type: "object",
+                pk: { type: 'is_hex_string', length: 64, required: true },
                 wk: { type: 'is_hex_string', length: 64, required: true },
                 nonce: { type: 'string', min: 1, max: 256, required: true },
                 sig: { type: 'is_hex_string', length: 128, required: true },

package/src/utils/msgUtils.js

@@ -39,6 +39,7 @@ class MsgUtils {
                 msg = this.createMessage(wallet.publicKey, keyParam, nonce, operationType);
                 hash = await createHash('sha256', msg);
                 value = {
+                    pk : wallet.publicKey,
                     wk: keyParam,
                     nonce: nonce,
                     sig: wallet.sign(hash)