trac-msb 0.0.79 → 0.0.81

package/package.json

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

package/src/index.js

@@ -147,7 +147,6 @@ export class MainSettlementBus extends ReadyResource {
 
     async #handleApplyTxOperation(op, view, base, node, batch) {
         const postTx = op.value;
-
         if (postTx.op === OperationType.POST_TX &&
             null === await batch.get(op.key) &&
             this.check.sanitizePostTx(op) &&
@@ -164,24 +163,23 @@ export class MainSettlementBus extends ReadyResource {
 
     async #handleApplyAddAdminOperation(op, view, base, node, batch) {
         if (!this.check.sanitizeAdminAndWritersOperations(op)) return;
-
-        const adminEntry = await this.getSigned(EntryType.ADMIN);
-        if (!adminEntry) {
-            await this.#addAdminIfNotSet(op, view, node);
+        const adminEntry = await batch.get(EntryType.ADMIN);
+        if (null === adminEntry || !this.#isAdmin(adminEntry.value, node)) {
+            await this.#addAdminIfNotSet(op, view, node, batch);
         }
-        else if (adminEntry.tracPublicKey === op.key) {
-            await this.#addAdminIfSet(adminEntry, op, view, base);
+        else if (adminEntry.value.tracPublicKey === op.key) {
+            await this.#addAdminIfSet(adminEntry.value, op, view, base, batch);
         }
     }
 
-    async #addAdminIfSet(adminEntry, op, view, base) {
+    async #addAdminIfSet(adminEntry, op, view, base, batch) {
         const isMessageVerifed = await this.#verifyMessage(op.value.sig, adminEntry.tracPublicKey, MsgUtils.createMessage(adminEntry.tracPublicKey, op.value.wk, op.value.nonce, op.type));
         if (isMessageVerifed) {
-            const indexersEntry = await this.getSigned(EntryType.INDEXERS);
-            if (indexersEntry && indexersEntry.includes(adminEntry.tracPublicKey)) {
+            const indexersEntry = await batch.get(EntryType.INDEXERS);
+            if (null !== indexersEntry && indexersEntry.value.includes(adminEntry.tracPublicKey)) {
                 await base.removeWriter(b4a.from(adminEntry.wk, 'hex'));
                 await base.addWriter(b4a.from(op.value.wk, 'hex'), { isIndexer: true })
-                await view.put(EntryType.ADMIN, {
+                await batch.put(EntryType.ADMIN, {
                     tracPublicKey: adminEntry.tracPublicKey,
                     wk: op.value.wk
                 })
@@ -190,56 +188,55 @@ 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 &&
             op.value.wk === this.#bootstrap &&
             isMessageVerifed
         ) {
-            await view.put(EntryType.ADMIN, {
+            await batch.put(EntryType.ADMIN, {
                 tracPublicKey: op.key,
                 wk: this.#bootstrap
             })
             const initIndexers = [op.key];
-            await view.put(EntryType.INDEXERS, initIndexers);
+            await batch.put(EntryType.INDEXERS, initIndexers);
             console.log(`Admin added: ${op.key}:${this.#bootstrap}`);
         }
     }
 
     async #handleApplyAppendWhitelistOperation(op, view, base, node, batch) {
-
-        const adminEntry = await this.getSigned(EntryType.ADMIN);
-        if (!this.check.sanitizeIndexerOrWhitelistOperations(op) || !this.#isAdmin(adminEntry, node)) 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);
+        if (null === adminEntry || !this.check.sanitizeIndexerOrWhitelistOperations(op) || !this.#isAdmin(adminEntry.value, node)) return;
+        const isMessageVerifed = await this.#verifyMessage(op.value.sig, adminEntry.value.tracPublicKey, MsgUtils.createMessage(op.key, op.value.nonce, op.type));
         if (!isMessageVerifed) return;
         const isWhitelisted = await this.#isWhitelisted(op.key);
         if (isWhitelisted) return;
-        await this.#createWhitelistEntry(view, op.key);
+        await this.#createWhitelistEntry(batch, op.key);
     }
 
-    async #createWhitelistEntry(view, pubKey) {
+    async #createWhitelistEntry(batch, pubKey) {
         const whitelistKey = WHITELIST_PREFIX + pubKey;
-        await view.put(whitelistKey, true);
+        await batch.put(whitelistKey, true);
     }
 
     async #handleApplyAddWriterOperation(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 isWhitelisted = await this.#isWhitelisted(op.key);
         if (!isWhitelisted) 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.#addWriter(op, view, base);
+            await this.#addWriter(op, batch, base);
         }
     }
 
-    async #addWriter(op, view, base) {
-        const nodeEntry = await this.getSigned(op.key);
-        if (nodeEntry === null || !nodeEntry.isWriter) {
+    async #addWriter(op, batch, base) {
+        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 view.put(op.key, {
+            await batch.put(op.key, {
                 wk: op.value.wk,
                 isWriter: true,
                 isIndexer: false
@@ -249,32 +246,33 @@ 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, view, base);
+            await this.#removeWriter(op, batch, base);
         }
     }
 
-    async #removeWriter(op, view, base) {
-        const nodeEntry = await this.getSigned(op.key)
+    async #removeWriter(op, batch, base) {
+        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 view.put(EntryType.INDEXERS, indexersEntry);
+                        indexersEntry.value.splice(idx, 1);
+                        await batch.put(EntryType.INDEXERS, indexersEntry.value);
                     }
                 }
             }
 
-            await view.put(op.key, nodeEntry);
+            await batch.put(op.key, nodeEntry);
             console.log(`Writer removed: ${op.key}:${op.value.wk}`);
         }
     }
@@ -284,56 +282,58 @@ 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, view, base);
+            await this.#addIndexer(indexersEntry.value, op, batch, base);
         }
     }
 
-    async #addIndexer(indexersEntry, op, view, base) {
-        const nodeEntry = await this.getSigned(op.key);
-
-        if (nodeEntry !== null && nodeEntry.isWriter && !nodeEntry.isIndexer) {
+    async #addIndexer(indexersEntry, op, batch, base) {
+        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;
-            await view.put(op.key, nodeEntry);
+            await batch.put(op.key, nodeEntry);
             indexersEntry.push(op.key);
-            await view.put(EntryType.INDEXERS, indexersEntry);
+            await batch.put(EntryType.INDEXERS, indexersEntry);
             console.log(`Indexer added: ${op.key}:${nodeEntry.wk}`);
         }
     }
 
     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;
                 nodeEntry.isIndexer = false;
-                await view.put(op.key, nodeEntry);
+                await batch.put(op.key, nodeEntry);
 
                 const idx = indexersEntry.indexOf(op.key);
                 if (idx !== -1) {
                     indexersEntry.splice(idx, 1);
-                    await view.put(EntryType.INDEXERS, indexersEntry);
+                    await batch.put(EntryType.INDEXERS, indexersEntry);
                 }
 
                 console.log(`Indexer removed: ${op.key}:${nodeEntry.wk}`);

package/src/writerManager.js

@@ -16,7 +16,6 @@ export class WriterManager extends ReadyResource {
         const adminEntry = await this.msbInstance.getSigned('admin');
         if (!adminEntry && this.msbInstance.writingKey && this.msbInstance.writingKey === this.msbInstance.bootstrap) {
 
-            
             const nonce = Math.random() + '-' + Date.now();
             const msg = Buffer.concat(
                 [
@@ -68,8 +67,6 @@ export class WriterManager extends ReadyResource {
                 }
             });
             }
-
-            
         }catch(e) {
             console.log('Error reading file', e);
         }