trac-msb 0.0.9 → 0.0.11

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-msb",
   "main": "src/index.js",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"
@@ -12,11 +12,11 @@
     "test": "brittle test/*.test.js"
   },
   "dependencies": {
-    "autobase": "7.1.0",
+    "autobase": "7.0.45",
     "b4a": "1.6.7",
     "bare-fs": "4.0.1",
     "brittle": "3.0.0",
-    "corestore": "7.0.23",
+    "corestore": "7.0.22",
     "debounceify": "1.1.0",
     "trac-wallet": "^0.0.3",
     "hyperbee": "2.23.0",
@@ -30,5 +30,9 @@
     "ready-resource": "^1.0.0",
     "safety-catch": "1.0.2",
     "xache": "1.2.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
   }
 }

package/src/functions.js

@@ -1,5 +1,4 @@
-import BlindPairing from "blind-pairing";
-
+import { createHash } from "node:crypto";
 //TODO: if something is missing, add additonal sanitization
 // parsed.op === 'pre-tx' -> moved out of the scope this check because we can re-use this function in the apply
 // TODO: Split sanitization on pre and post TX
@@ -16,11 +15,68 @@ export function sanitizeTransaction(parsedTx) {
     );
 }
 
-export async function addWriter(input, peer){
-    const splitted = input.split(' ');
-    if(splitted[0] === '/add_writer'){
-        await peer.base.append({ type: 'addWriter', key: splitted[splitted.length - 1] });
-    } else if(splitted[0] === '/add_writer2') {
-        await peer.base.append({ type: 'addWriter2', key: splitted[splitted.length - 1] });
+export function restoreManifest(parsedManifest) {
+
+    if (Array.isArray(parsedManifest.signers)) {
+        parsedManifest.signers = parsedManifest.signers.map(signer => {
+            if(signer.namespace && signer.namespace.data &&signer.publicKey && signer.publicKey.data){ 
+                return {
+                    ...signer,
+                    namespace: Buffer.from(signer.namespace.data),
+                    publicKey: Buffer.from(signer.publicKey.data),
+                }
+            } else {
+                return signer;
+            }
+        });
+    }
+
+    return parsedManifest;
+}
+
+// To improve - could be done in better approach (simplify)
+export function restoreHash(parsedPreTx) {
+    const reconstructedContentHash = createHash('sha256')
+        .update(JSON.stringify(parsedPreTx.ch))
+        .digest('hex');
+
+    const reconstructedTxHash = createHash('sha256')
+        .update(
+            parsedPreTx.w + '-' +
+            parsedPreTx.i + '-' +
+            parsedPreTx.ipk + '-' +
+            reconstructedContentHash + '-' +
+            parsedPreTx.in
+        )
+        .digest('hex');
+
+    const finalReconstructedTxHash = createHash('sha256')
+        .update(reconstructedTxHash)
+        .digest('hex');
+    return finalReconstructedTxHash;
+}
+
+export async function verifyDag(autoBaseInsance) {
+    try {
+        console.log('--- DAG Monitoring ---');
+        const dagView = await autoBaseInsance.view.core.treeHash();
+        const lengthdagView = autoBaseInsance.view.core.length;
+        const dagSystem = await autoBaseInsance.system.core.treeHash();
+        const lengthdagSystem = autoBaseInsance.system.core.length;
+        console.log('this.base.view.core.signedLength:', autoBaseInsance.view.core.signedLength);
+        console.log("this.base.signedLength", autoBaseInsance.signedLength);
+        console.log("this.base.linearizer.indexers.length", autoBaseInsance.linearizer.indexers.length);
+        console.log("this.base.indexedLength", autoBaseInsance.indexedLength);
+        console.log(`base.key/writingKey: ${autoBaseInsance.key.toString('hex')}`);
+
+        console.log(`VIEW Dag: ${dagView.toString('hex')} (length: ${lengthdagView})`);
+        console.log(`SYSTEM Dag: ${dagSystem.toString('hex')} (length: ${lengthdagSystem})`);
+
+    } catch (error) {
+        console.error('Error during DAG monitoring:', error.message);
     }
+}
+
+export async function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
 }

package/src/index.js

@@ -5,14 +5,20 @@ import ReadyResource from 'ready-resource';
 import b4a from 'b4a';
 import Hyperbee from 'hyperbee';
 import readline from 'readline';
-import crypto from 'hypercore-crypto';
-import { sanitizeTransaction, addWriter } from './functions.js';
+import { sanitizeTransaction, restoreManifest, sleep, restoreHash ,verifyDag } from './functions.js';
 import w from 'protomux-wakeup';
-import * as edKeyGen from "trac-wallet"
-import fs from 'node:fs';
 import Corestore from 'corestore';
+import verifier from 'hypercore/lib/verifier.js';
+import WriterManager from './writerManager.js';
+import PeerWallet from "trac-wallet"; // TODO: Decide if this should be used here directly or inputed as an option
+
+
+const { manifestHash, createManifest } = verifier;
 
 const wakeup = new w();
+//TODO: change isValid to isIndexer
+//TODO: How about nonce if edDSA is deterministic?
+//TODO: CHECK IF TX HASH IS ALREDY IN BASE BEFORE VALIDATING IT TO DON'T OVERWRITE tx/writerPubKey. Also we need to validate this case where the 2 nodes send the same hash. 
 
 export class MainSettlementBus extends ReadyResource {
 
@@ -20,31 +26,35 @@ export class MainSettlementBus extends ReadyResource {
         super();
         this.STORES_DIRECTORY = options.stores_directory;
         this.KEY_PAIR_PATH = `${this.STORES_DIRECTORY}${options.store_name}/db/keypair.json`
-        this.signingKeyPair = null;
         this.store = new Corestore(this.STORES_DIRECTORY + options.store_name);
         this.swarm = null;
         this.tx = options.tx || null;
         this.tx_pool = [];
         this.enable_txchannel = typeof options.enable_txchannel !== "undefined" && options.enable_txchannel === false ? false : true;
         this.enable_wallet = typeof options.enable_wallet !== "undefined" && options.enable_wallet === false ? false : true;
+        this.isVerifyOnly = typeof options.isVerifyOnly !== "undefined" && options.isVerifyOnly === true ? true : false;
         this.base = null;
-        this.key = null;
         this.channel = options.channel || null;
         this.connectedNodes = 1;
         this.replicate = options.replicate !== false;
-        this.writerLocalKey = null;
+        this.writingKey = null;
         this.isStreaming = false;
         this.bootstrap = options.bootstrap || null;
         this.opts = options;
-        this.connectedPeers = new Set();
         this.bee = null;
 
+        // TODO: Decide if this is better placed in the _open method instead of here
+        if (this.enable_wallet) {
+            this.wallet = new PeerWallet({ isVerifyOnly: this.isVerifyOnly });
+        }
+
         this.pool();
         this.msbListener();
         this._boot();
         this.ready().catch(noop);
-    }
 
+    }
+    //TODO: Move apply to the separate file
     _boot() {
         const _this = this;
         this.base = new Autobase(this.store, this.bootstrap, {
@@ -56,6 +66,8 @@ export class MainSettlementBus extends ReadyResource {
                     keyEncoding: 'utf-8',
                     valueEncoding: 'json'
                 })
+                _this.keysView = _this.bee.sub('pubKeys');
+
                 return _this.bee;
             },
 
@@ -64,25 +76,140 @@ export class MainSettlementBus extends ReadyResource {
                 for (const node of nodes) {
                     const op = node.value;
                     const postTx = op.value;
-                    if (op.type === 'tx') {
+
+                    if (!op || !op.type || !op.key || !op.value) {
+                        continue;
+                    }
+                    // WRITING & INDEXING
+                    if (op.type === 'addWriter') {
+                        //TODO: it can be optimalized by adding variables to don't call Buffer.from multiple times.
+                        //TODO: SANITIZE INCOMPING PROPOSAL
+                        if (node.from.key.toString('hex') === this.bootstrap) {
+                            const message = Buffer.concat([
+                                Buffer.from(JSON.stringify(op.value.hpm)),
+                                Buffer.from(op.value.wk, 'hex'),
+                                Buffer.from(op.key, 'hex')
+                                //TODO: ADD THE NONCE?
+                            ]);
+
+                            const pop1Valid = this.wallet.verify(op.value.pop1, message, Buffer.from(op.value.hpm.signers[0].publicKey));
+                            const pop2Valid = this.wallet.verify(op.value.pop2, message, op.key);
+
+
+                            const restoredManifest = restoreManifest(op.value.hpm); //temporary workaround
+                            if (pop1Valid && pop2Valid && manifestHash(createManifest(restoredManifest)).toString('hex') === op.value.wk) {
+
+                                const writerEntry = this.base.view.get(op.key);
+                                if (writerEntry === null || !writerEntry.isValid) {
+                                    await base.addWriter(b4a.from(op.value.wk, 'hex'), { isIndexer: false })
+
+                                    await view.put(op.key, {
+                                        wk: op.value.wk,
+                                        hpm: op.value.hpm,
+                                        pop1: op.value.pop1, // TODO: observation this is really necessary to store pops? IF NOT DELETE IT!
+                                        pop2: op.value.pop2,
+                                        isValid: true,
+                                        isIndexer: false
+                                        //TODO: ADD NONCE?
+                                    });
+                                    console.log(`Writer added: ${op.value.wk}`);
+
+                                }
+                            }
+                        }
+                    } else if (op.type === 'removeWriter') {
+                        //TODO: it can be optimalized by adding variables to don't call Buffer.from multiple times. And other operations
+                        //TODO: SANITIZE INCOMPING PROPOSAL
+                        if (node.from.key.toString('hex') === this.bootstrap) {
+                            const publicKey = Buffer.from(op.key, 'hex');
+                            const message = Buffer.concat([
+                                publicKey
+                                //TODO: ADD NONCE ?
+                            ]);
+
+                            const popIsValid = this.wallet.verify(op.value.pop, message, publicKey);
+                            if (popIsValid) {
+                                const writerEntry = await _this.base.view.get(op.key)
+                                if (writerEntry !== null && writerEntry.value.isValid ) {
+                                    await base.removeWriter(Buffer.from(writerEntry.value.wk, 'hex'));
+                                    writerEntry.value.isValid = false;
+                                    if (writerEntry.value.isIndexer === true) {
+                                        writerEntry.value.isIndexer = false;
+                                    }
+                                    await view.put(op.key, writerEntry.value);
+                                    console.log(`Writer removed: ${writerEntry.value.wk}`);
+                                }
+
+                            }
+                        }
+                    } else if (op.type === 'initBootstrap') {
+                        // this operation initializes the bootstrap skp to grant this public key the owner status.
+                        //TODO: ADD MORE SANITIZATION. THIS IS STILL JS.
+                        //TODO: HANDLE ERRORS?
+                        //TODO: it can be optimalized by adding variables to don't call Buffer.from multiple times.
+                        if (node.from.key.toString('hex') === this.bootstrap) {
+                            const message = Buffer.concat([
+                                Buffer.from(JSON.stringify(op.value.hpm)),
+                                Buffer.from(op.value.wk, 'hex'),
+                                Buffer.from(op.value.skp, 'hex')
+                                //here should be nonce anyway in the future - generated randomly from the huge space. 
+                            ]);
+
+                            const pop1Valid = this.wallet.verify(op.value.pop1, message, Buffer.from(op.value.hpm.signers[0].publicKey));
+                            const pop2Valid = this.wallet.verify(op.value.pop2, message, Buffer.from(op.value.skp, 'hex'));
+                            const restoredManifest = restoreManifest(op.value.hpm); //temporary workaround
+
+                            if (pop1Valid && pop2Valid && manifestHash(createManifest(restoredManifest)).toString('hex') === this.bootstrap) {
+                                await view.put(op.key, op.value);
+                            }
+                        }
+                    } else if (op.type === 'addIndexer') {
+                        if (node.from.key.toString('hex') === _this.bootstrap) {
+                            //Simplify signature
+                            const message = Buffer.concat([
+                                Buffer.from(op.value.ptpk, 'hex'),
+                                Buffer.from(op.value.pwk, 'hex')]
+                            )
+                            const popValid = _this.wallet.verify(op.value.pop, message, op.key);
+                            const writerEntry = await _this.base.view.get(op.value.ptpk);
+                            if (popValid && writerEntry !== null && writerEntry.value.isValid === true && writerEntry.value.wk === op.value.pwk && writerEntry.value.isIndexer === false) {
+                                await base.removeWriter(Buffer.from(writerEntry.value.wk, 'hex'));
+                                await base.addWriter(b4a.from(writerEntry.value.wk, 'hex'), { indexer: true })
+                                writerEntry.value.isIndexer = true;
+                                await view.put(op.value.ptpk, writerEntry.value);
+                                console.log(`${op.value.ptpk}:${op.value.pwk} writer became indexer`);
+                            }
+                        }
+                    } else if (op.type === 'removeIndexer') {
+                        if (node.from.key.toString('hex') === _this.bootstrap) {
+                            //Simplify signature
+                            const message = Buffer.concat([
+                                Buffer.from(op.value.ptpk, 'hex'),
+                                Buffer.from(op.value.pwk, 'hex')]
+                            )
+                            const popValid = _this.wallet.verify(op.value.pop, message, op.key);
+                            const writerEntry = await _this.base.view.get(op.value.ptpk);
+
+                            if (popValid && writerEntry !== null && writerEntry.value.isValid === true && writerEntry.value.wk === op.value.pwk && writerEntry.value.isIndexer === true) {
+                                await base.removeWriter(Buffer.from(writerEntry.value.wk, 'hex'));
+                                await base.addWriter(b4a.from(writerEntry.value.wk, 'hex'), { indexer: false })
+                                writerEntry.value.isIndexer = false;
+                                await view.put(op.value.ptpk, writerEntry.value);
+                                console.log(`Writer ${op.value.ptpk}:${op.value.pwk} is not longer indexer`);
+                            }
+                        }
+                    } else if (op.type === 'tx') {                        
                         if (null === await view.get(op.key) &&
+                            restoreHash(postTx) !== postTx.tx &&
                             sanitizeTransaction(postTx) &&
                             postTx.op === 'post-tx' &&
-                            crypto.verify(Buffer.from(postTx.tx, 'utf-8'), Buffer.from(postTx.is, 'hex'), Buffer.from(postTx.ipk, 'hex')) &&// sender verification
-                            crypto.verify(Buffer.from(postTx.tx, 'utf-8'), Buffer.from(postTx.ws, 'hex'), Buffer.from(postTx.wp, 'hex')) &&// writer verification
+                            this.wallet.verify(Buffer.from(postTx.is, 'hex'), Buffer.from(postTx.tx, 'utf-8'), Buffer.from(postTx.ipk, 'hex')) &&// sender verification
+                            this.wallet.verify(Buffer.from(postTx.ws, 'hex'), Buffer.from(postTx.tx, 'utf-8'), Buffer.from(postTx.wp, 'hex')) &&// writer verification
                             Buffer.byteLength(JSON.stringify(postTx)) <= 4096
                         ) {
                             await view.put(op.key, op.value);
-                            console.log(`TX: ${op.key} appended. Signed length: `,  _this.base.view.core.signedLength);
+                            console.log(`TX: ${op.key} appended. Signed length: `, _this.base.view.core.signedLength);
                         }
-                    } else if (op.type === 'addWriter') {
-                        const writerKey = b4a.from(op.key, 'hex');
-                        await base.addWriter(writerKey);
-                        console.log(`Writer added: ${op.key}`);
-                    } else if (op.type === 'addWriter2') {
-                        const writerKey = b4a.from(op.key, 'hex');
-                        await base.addWriter(writerKey, { isIndexer : false });
-                        console.log(`Writer added: ${op.key} non-indexer`);
                     }
                 }
             }
@@ -92,17 +219,23 @@ export class MainSettlementBus extends ReadyResource {
 
     async _open() {
         await this.base.ready();
-        if(this.enable_wallet){
-            await this.#initKeyPair();
+        if (this.enable_wallet && !this.isVerifyOnly) {
+            await this.wallet.initKeyPair(this.KEY_PAIR_PATH);
         }
-        console.log('View Length:', this.base.view.core.length);
-        console.log('View Signed Length:', this.base.view.core.signedLength);
-        console.log('MSB Key:', Buffer(this.base.view.core.key).toString('hex'));
-        this.writerLocalKey = b4a.toString(this.base.local.key, 'hex');
+
+        this.writingKey = b4a.toString(this.base.local.key, 'hex');
+
         if (this.replicate) await this._replicate();
         if (this.enable_txchannel) {
             await this.txChannel();
         }
+        this.writerManager = new WriterManager(this);
+
+        console.log('View Length:', this.base.view.core.length);
+        console.log('View Signed Length:', this.base.view.core.signedLength);
+        console.log('MSB Key:', Buffer(this.base.view.core.key).toString('hex'));
+        console.log(`isWritable? ${this.base.writable}`);
+        console.log(`isIndexer: ${this.base.isIndexer}`);
     }
 
     async close() {
@@ -116,23 +249,18 @@ export class MainSettlementBus extends ReadyResource {
         this.tx_swarm = new Hyperswarm({ maxPeers: 1024, maxParallel: 512, maxServerConnections: 256 });
         this.tx_swarm.on('connection', async (connection, peerInfo) => {
             const _this = this;
-            const peerName = b4a.toString(connection.remotePublicKey, 'hex');
-            this.connectedPeers.add(peerName);
-            this.connectedNodes++;
 
             connection.on('close', () => {
-                this.connectedNodes--;
-                this.connectedPeers.delete(peerName);
             });
 
             connection.on('error', (error) => { });
 
             connection.on('data', async (msg) => {
 
-                if(_this.base.isIndexer) return;
+                if (!_this.base.isIndexer) return;
 
                 // TODO: decide if a tx rejection should be responded with
-                if(_this.tx_pool.length >= 1000) {
+                if (_this.tx_pool.length >= 1000) {
                     console.log('pool full');
                     return
                 }
@@ -140,16 +268,17 @@ export class MainSettlementBus extends ReadyResource {
                 if(Buffer.byteLength(msg) > 3072) return;
 
                 try {
-
                     const parsedPreTx = JSON.parse(msg);
 
                     if (sanitizeTransaction(parsedPreTx) &&
                         parsedPreTx.op === 'pre-tx' &&
-                        crypto.verify(Buffer.from(parsedPreTx.tx, 'utf-8'), Buffer.from(parsedPreTx.is, 'hex'), Buffer.from(parsedPreTx.ipk, 'hex')) &&
-                        parsedPreTx.w === _this.writerLocalKey &&
+                        restoreHash(parsedPreTx) !== parsedPreTx.tx &&
+                        this.wallet.verify(Buffer.from(parsedPreTx.is, 'hex'), Buffer.from(parsedPreTx.tx, 'utf-8'), Buffer.from(parsedPreTx.ipk, 'hex')) &&
+                        parsedPreTx.w === _this.writingKey &&
                         null === await _this.base.view.get(parsedPreTx.tx)
                     ) {
-                        const signature = crypto.sign(Buffer.from(parsedPreTx.tx, 'utf-8'), this.signingKeyPair.secretKey);
+                        const signature = this.wallet.sign(Buffer.from(parsedPreTx.tx, 'utf-8'));
+                       
                         const append_tx = {
                             op: 'post-tx',
                             tx: parsedPreTx.tx,
@@ -159,10 +288,10 @@ export class MainSettlementBus extends ReadyResource {
                             ipk: parsedPreTx.ipk,
                             ch: parsedPreTx.ch,
                             in: parsedPreTx.in,
-                            ws: signature.toString('hex'),
-                            wp: this.signingKeyPair.publicKey.toString('hex'),
+                            ws: JSON.parse(JSON.stringify(signature)),
+                            wp: JSON.parse(JSON.stringify(this.wallet.publicKey)),
                         };
-                        _this.tx_pool.push({ tx: parsedPreTx.tx, append_tx : append_tx });
+                        _this.tx_pool.push({ tx: parsedPreTx.tx, append_tx: append_tx });
                     }
                 } catch (e) {
                     console.log(e)
@@ -176,44 +305,40 @@ export class MainSettlementBus extends ReadyResource {
         console.log('Joined MSB TX channel');
     }
 
-    async pool(){
-        while(true){
-            if(this.tx_pool.length > 0){
+    async pool() {
+        while (true) {
+            if (this.tx_pool.length > 0) {
                 const length = this.tx_pool.length;
-                for(let i = 0; i < length; i++){
+                for (let i = 0; i < length; i++) {
                     await this.base.append({ type: 'tx', key: this.tx_pool[i].tx, value: this.tx_pool[i].append_tx });
-                    await this.sleep(5);
+                    await sleep(5);
                 }
                 this.tx_pool.splice(0, length);
             }
-            await this.sleep(10);
+            await sleep(10);
         }
     }
 
-    async sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-
     async _replicate() {
         if (!this.swarm) {
-            const keyPair = await this.store.createKeyPair('hyperswarm');
+            const keyPair = this.base.local.keyPair //await this.store.createKeyPair('hyperswarm');
             this.swarm = new Hyperswarm({ keyPair, maxPeers: 1024, maxParallel: 512, maxServerConnections: 256 });
 
             console.log(`Channel: ${this.channel}`);
-            console.log(`Writer key: ${this.writerLocalKey}`)
-            console.log(`isIndexer: ${this.base.isIndexer}`);
+            console.log(`Writer key: ${this.writingKey}`)
+
             this.swarm.on('connection', async (connection, peerInfo) => {
-                const peerName = b4a.toString(connection.remotePublicKey, 'hex');
-                this.connectedPeers.add(peerName);
                 wakeup.addStream(connection);
                 this.store.replicate(connection);
-                this.connectedNodes++;
+
 
                 connection.on('close', () => {
-                    this.connectedNodes--;
-                    this.connectedPeers.delete(peerName);
                 });
 
+                connection.on('data', async data => {
+                    await WriterManager.handleIncomingWriterEvent(this, data);
+                })
+
                 connection.on('error', (error) => { });
 
                 if (!this.isStreaming) {
@@ -236,30 +361,6 @@ export class MainSettlementBus extends ReadyResource {
         });
     }
 
-    async verifyDag() {
-        try {
-            console.log('--- DAG Monitoring ---');
-            const dagView = await this.base.view.core.treeHash();
-            const lengthdagView = this.base.view.core.length;
-            const dagSystem = await this.base.system.core.treeHash();
-            const lengthdagSystem = this.base.system.core.length;
-            console.log('this.base.view.core.signedLength:', this.base.view.core.signedLength);
-            console.log("this.base.signedLength", this.base.signedLength);
-            console.log("this.base.linearizer.indexers.length", this.base.linearizer.indexers.length);
-            console.log("this.base.indexedLength", this.base.indexedLength);
-            //console.log("this.base.system.core", this.base.system.core);
-            console.log(`writerLocalKey: ${this.writerLocalKey}`);
-            console.log(`base.key: ${this.base.key.toString('hex')}`);
-            console.log('discoveryKey:', b4a.toString(this.base.discoveryKey, 'hex'));
-
-            console.log(`VIEW Dag: ${dagView.toString('hex')} (length: ${lengthdagView})`);
-            console.log(`SYSTEM Dag: ${dagSystem.toString('hex')} (length: ${lengthdagSystem})`);
-
-        } catch (error) {
-            console.error('Error during DAG monitoring:', error.message);
-        }
-    }
-
     async interactiveMode() {
         const rl = readline.createInterface({
             input: process.stdin,
@@ -267,102 +368,43 @@ export class MainSettlementBus extends ReadyResource {
         });
 
         console.log('MSB started. Available commands:');
-        console.log('- /add_writer: enter a peer writer key as argument to get included as writer.');
-        console.log('- /add_writer2: enter a peer writer key as argument to get included as non-indexing writer.');
+        console.log('- /addMe: send request to admin to become a writer node in the TRAC Network');
+        console.log('- /removeMe: send request to admin to remove writer node from the TRAC Network');
+        console.log('- /addIndexer <TracPublicKey> <WritingKey> (Admin only): enter a public key and writing key to make node as Indexer. Node have to be a writer already. ');
+        console.log('- /removeIndexer <TracPublicKey> <WritingKey> (Admin only): enter a public key and writing key to take off Indexer role. Node have to be a writer already');
         console.log('- /dag: check system properties such as writer key, DAG, etc.');
         console.log('- /exit: Exit the program');
 
         rl.on('line', async (input) => {
             switch (input) {
                 case '/dag':
-                    await this.verifyDag();
+                    await verifyDag(this.base);
                     break;
                 case '/exit':
                     console.log('Exiting...');
                     rl.close();
                     await this.close();
                     process.exit(0);
+                case '/addMe':
+                    await this.writerManager.addMe();
+                    break;
+                case '/removeMe':
+                    await this.writerManager.removeMe();
                     break;
                 default:
-                    if (input.startsWith('/add_writer')) {
-                        await addWriter(input, this);
+                    if (input.startsWith('/addIndexer')) {
+                        const splitted = input.split(' ');
+                        this.writerManager.addIndexer(splitted[1], splitted[2]);
+
+                    } else if (input.startsWith('/removeIndexer')) {
+                        const splitted = input.split(' ');
+                        this.writerManager.removeIndexer(splitted[1], splitted[2]);
                     }
             }
             rl.prompt();
         });
-
         rl.prompt();
     }
-
-    async #getMnemonicInteractiveMode() {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-
-        const question = (query) => {
-            return new Promise(resolve => {
-                rl.question(query, resolve);
-            });
-        }
-
-        let mnemonic;
-        let choice = '';
-        while (!choice.trim()) {
-            choice = await question("[1]. Generate new mnemonic phrase\n[2]. Restore keypair from backed up mnemonic phrase\nYour choice (1/2): ");
-            switch (choice) {
-                case '1':
-                    mnemonic = undefined
-                    break;
-                case '2':
-                    const mnemonicInput = await question("Enter your mnemonic phrase: ");
-                    mnemonic = edKeyGen.sanitizeMnemonic(mnemonicInput);
-                    break;
-                default:
-                    console.log("Invalid choice. Please select again");
-                    choice = '';
-                    break;
-            }
-        }
-        rl.close();
-        return mnemonic;
-    }
-
-    async #initKeyPair() {
-        // TODO: User shouldn't be allowed to store it in unencrypted form. ASK for a password to encrypt it. ENCRYPT(HASH(PASSWORD,SALT),FILE)/DECRYPT(HASH(PASSWORD,SALT),ENCRYPTED_FILE)?
-        try {
-            // Check if the key file exists
-            if (fs.existsSync(this.KEY_PAIR_PATH)) {
-                const keyPair = JSON.parse(fs.readFileSync(this.KEY_PAIR_PATH));
-                this.signingKeyPair = {
-                    publicKey: Buffer.from(keyPair.publicKey, 'hex'),
-                    secretKey: Buffer.from(keyPair.secretKey, 'hex')
-                }
-            } else {
-                console.log("Key file was not found. How do you wish to proceed?");
-                const mnemonic = await this.#getMnemonicInteractiveMode();
-
-                const generatedSecrets = edKeyGen.generateKeyPair(mnemonic);
-                const keyPair = {
-                    publicKey: Buffer.from(generatedSecrets.publicKey).toString('hex'),
-                    secretKey: Buffer.from(generatedSecrets.secretKey).toString('hex')
-                }
-
-                //TODO: ASK USER TO WRITE FIRST SECOND AND LAST WORD OR SOMETHING SIMILAR TO CONFIRM THEY HAVE WRITTEN IT DOWN
-                if (!mnemonic) console.log("This is your mnemonic:\n", generatedSecrets.mnemonic, "\nPlease back it up in a safe location")
-
-                fs.writeFileSync(this.KEY_PAIR_PATH, JSON.stringify(keyPair));
-                this.signingKeyPair = {
-                    publicKey: generatedSecrets.publicKey,
-                    secretKey: generatedSecrets.secretKey,
-                }
-
-                console.log("DEBUG: Key pair generated and stored in", this.KEY_PAIR_PATH);
-            }
-        } catch (err) {
-            console.error(err);
-        }
-    }
 }
 
 function noop() { }

package/src/writerManager.js

@@ -0,0 +1,316 @@
+import ReadyResource from 'ready-resource';
+
+//TODO ADD THROWS
+//TODO FOR NOW IT'S FINE. IT MUST BE INTEGRATED WITH TRAC WALLET
+//TODO: How about nonce if edDSA is deterministic?
+//TODO: if enable_wallet is false then user shouldn't be allowd to add or remove writer
+/**
+ * WriterManager manages writer nodes in the TRAC NETWORK, handling events, adding/removing writers, and managing the bootstrap process.
+ * It interacts with the MainSettlementBus instance to perform key operations.
+ */
+
+const MS_TO_WAIT = 5000;
+
+export class WriterManager extends ReadyResource {
+    /**
+     * Initializes the WriterManager with the given MainSettlementBus instance.
+     * @param {MainSettlementBus} msbInstance - An instance of the MainSettlementBus class.
+     */
+    constructor(msbInstance) {
+        super();
+        this.base = msbInstance.base;
+        this.wallet = msbInstance.wallet;
+        this.swarm = msbInstance.swarm;
+        this.bootstrap = msbInstance.bootstrap;
+        this.writingKey = msbInstance.writingKey;
+
+        this.#initBootstrap(msbInstance);
+
+    }
+
+    /**
+    * Initializes the bootstrap initialization process if the node is a bootstrap node and can be only executed by the bootstrap node.
+    * @returns {Promise<void>} Resolves once the bootstrap initialization is complete.
+    */
+    async #initBootstrap(msbInstance) {
+        try {
+
+            if (this.writingKey && this.writingKey === this.bootstrap) {
+
+                const bootStrapEntry = await this.getBootstrapEntry();
+                if (bootStrapEntry === null) {
+
+                    const message = Buffer.concat([
+                        Buffer.from(JSON.stringify(this.base.localWriter.core.manifest)),
+                        Buffer.from(this.writingKey, 'hex'),
+                        Buffer.from(this.wallet.publicKey, 'hex')
+                    ]);
+
+                    //SEND BOOTSTRAP TRAC MANIFEST
+                    await this.base.append({
+                        type: 'initBootstrap',
+                        key: 'bootstrap',
+                        value: {
+                            wk: this.writingKey,
+                            hpm: this.base.localWriter.core.manifest,
+                            skp: this.wallet.publicKey,
+                            pop1: this.wallet.sign(message, this.base.localWriter.core.keyPair.secretKey),
+                            pop2: this.wallet.sign(message)
+                        }
+                    });
+                }
+                console.log(`Bootstrap node ${this.writingKey} is ready to accept writers`);
+                await this.#WriterEventListener(msbInstance);
+            }
+        } catch (error) {
+            console.error(`err in `, error);
+        }
+    }
+
+    /**
+     * Listens for writer events and processes them by appending the parsed request to the base.
+     * At this moment only Bootstrap is listening for writer events.
+     * @private
+     */
+    async #WriterEventListener(msbInstance) {
+        msbInstance.on('writerEvent', async (parsedRequest) => {
+            await this.base.append(parsedRequest);
+        });
+    }
+
+    /**
+     * Adds the current node as a writer if it is not already a writer.
+     * The node must connect to the bootstrap node to complete the operation.
+     * @returns {Promise<void>} Resolves once the writer has been added or if the operation fails.
+     */
+    async addMe() {
+        try {
+
+            if (this.writingKey === this.bootstrap) {
+                console.log('Bootstrap node cannot add itself');
+                return;
+            }
+
+            const writerEntry = await this.base.view.get(this.wallet.publicKey);
+            if (writerEntry !== null && writerEntry.value.isValid) {
+                console.log(`Cannot perform operation because node is already writer`);
+                return;
+            }
+
+            const bootstrapEntry = await this.getBootstrapEntry();
+            if (!bootstrapEntry?.value?.hpm?.signers?.[0]?.publicKey?.data) {
+                console.log(`Bootstrap key not found`);
+                return;
+            }
+
+            const bootstrapPubKey = Buffer.from((bootstrapEntry.value.hpm.signers[0].publicKey.data)).toString('hex');
+
+            this.swarm.connections.forEach(async conn => {
+                if (conn.connected && conn.remotePublicKey.toString('hex') === bootstrapPubKey) {
+
+                    const message = Buffer.concat([
+                        Buffer.from(JSON.stringify(this.base.local.core.manifest)),
+                        Buffer.from(this.writingKey, 'hex'),
+                        Buffer.from(this.wallet.publicKey, 'hex')
+                        //TODO: ADD NONCE?
+                    ]);
+
+                    //SEND TRAC MANIFEST
+                    conn.write(JSON.stringify({
+                        type: 'addWriter',
+                        key: this.wallet.publicKey,
+                        value: {
+                            wk: this.writingKey,
+                            hpm: this.base.local.core.manifest,
+                            pop1: this.wallet.sign(message, this.base.local.core.header.keyPair.secretKey),
+                            pop2: this.wallet.sign(message),
+                            //TODO: ADD NONCE?
+                        }
+
+                    }));
+
+                    setTimeout(async () => {
+                        const updatedWriterEntry = await this.base.view.get(this.wallet.publicKey);
+                        if (updatedWriterEntry !== null && updatedWriterEntry.value.isValid) {
+                            console.log(`Writer ${this.writingKey} was successfully added.`);
+                        } else {
+                            console.warn(`Writer ${this.writingKey} was NOT added.`);
+                        }
+                    }, MS_TO_WAIT);
+                }
+            })
+        } catch (error) {
+            console.error(`err in `, error);
+        }
+    }
+    /**
+     * Removes the current node as a writer.
+     * The node must connect to the bootstrap node to complete the removal operation.
+     * @returns {Promise<void>} Resolves once the writer has been removed or if the operation fails.
+     */
+    async removeMe() {
+        try {
+
+            if (this.writingKey === this.bootstrap) {
+                console.log('Bootstrap node cannot remove itself');
+                return;
+            }
+
+            const writerEntry = await this.base.view.get(this.wallet.publicKey);
+            if (writerEntry === null || !writerEntry.value.isValid) {
+                console.log(`Your key does not exist in the database  or you can't remove it`);
+                return;
+            }
+
+            const bootstrapEntry = await this.getBootstrapEntry();
+
+            if (bootstrapEntry === null || !bootstrapEntry.value?.hpm?.signers?.[0]?.publicKey?.data) {
+                console.log(`Bootstrap key not found`);
+                return;
+            }
+
+            const bootstrapPubKey = Buffer.from(bootstrapEntry.value.hpm.signers[0].publicKey.data).toString('hex');
+
+            this.swarm.connections.forEach(async conn => {
+                if (conn.connected && conn.remotePublicKey.toString('hex') === bootstrapPubKey) {
+
+                    const message = Buffer.concat([
+                        Buffer.from(this.wallet.publicKey, 'hex') // TODO: TO REDUCE THE SIZE OF THE MESSAGE WE CAN SEND SIMPLE STRING SUCHAS  "REMOVE". You can just HASH the message and sign the hash.
+                        //TODO: ADD NONCE?
+                    ]);
+
+                    //SEND TRAC MANIFEST
+                    conn.write(JSON.stringify({
+                        type: 'removeWriter',
+                        key: this.wallet.publicKey,
+                        value: {
+                            pop: this.wallet.sign(message),
+                            //TODO: ADD NONCE?
+                        }
+                    }));
+                }
+            })
+
+            setTimeout(async () => {
+                const updatedWriterEntry = await this.base.view.get(this.wallet.publicKey);
+                if (updatedWriterEntry !== null && !updatedWriterEntry.value.isValid) {
+                    console.log(`Key successfully removed`);
+                } else {
+                    console.log(`Failed to remove key`);
+                }
+            }, MS_TO_WAIT);
+
+        } catch (error) {
+            console.error(`err in `, error);
+        }
+    }
+
+
+    /**
+     * Adds a writer node as an indexer.
+     * The node must already be a valid writer to become an indexer.
+     * This operation can only be performed by the bootstrap/admin node.
+     * 
+     * @param {string} peerTracPublicKey - The TRAC public key of the writer node to be promoted to indexer.
+     * @param {string} peerWritingKey - The writing key of the writer node to be promoted to indexer.
+     * @returns {Promise<void>} Resolves once the writer has been promoted to indexer or if the operation fails.
+     */
+    async addIndexer(peerTracPublicKey, peerWritingKey) {
+        //TODO: ADD TIMEOUT WITH MESSAGE OF SUCCESS OR FAILURE. 
+        //TODO IMPROVE CHECKS
+        if (this.writingKey !== this.bootstrap) {
+            console.log('Only bootstrap node can add indexer');
+            return;
+        }
+
+        const writerEntry = await this.base.view.get(peerTracPublicKey);
+        if (writerEntry === null || writerEntry.value.isValid === false || writerEntry.value.wk !== peerWritingKey || (writerEntry.value.isValid === true && writerEntry.value.isIndexer === true)) {
+            console.log(`Writer ${peerTracPublicKey}:${this.writingKey} cannot become an indexer`);
+            return;
+        } 
+
+        const message = Buffer.concat([
+            Buffer.from(peerTracPublicKey, 'hex'),
+            Buffer.from(peerWritingKey, 'hex')
+        ]);
+
+        const indexerRequest = {
+            type: 'addIndexer',
+            key: this.wallet.publicKey,
+            value: {
+                ptpk: peerTracPublicKey,
+                pwk: peerWritingKey,
+                pop: this.wallet.sign(message)
+            }
+        }
+        await this.base.append(indexerRequest);
+    }
+    /**
+     * Removes the indexer status from a writer node.
+     * The node must already be a valid writer and an indexer to lose its indexer status.
+     * This operation can only be performed by the bootstrap node.
+     * 
+     * @param {string} peerTracPublicKey - The TRAC public key of the writer node to lose indexer status.
+     * @param {string} peerWritingKey - The writing key of the writer node to lose indexer status.
+     * @returns {Promise<void>} Resolves once the writer has lost indexer status or if the operation fails.
+     */
+    async removeIndexer(peerTracPublicKey, peerWritingKey) {
+        //TODO: ADD TIMEOUT WITH MESSAGE OF SUCCESS OR FAILURE. 
+        //TODO IMPROVE CHECKS
+        if (this.writingKey !== this.bootstrap) {
+            console.log('Only bootstrap node can remove indexer');
+            return;
+        }
+        const writerEntry = await this.base.view.get(peerTracPublicKey);
+
+        if (writerEntry === null || writerEntry.value.isValid === false || writerEntry.value.wk !== peerWritingKey || (writerEntry.value.isValid === true && writerEntry.value.isIndexer === false)) {
+            console.log(`Writer ${peerTracPublicKey}:${this.writingKey} cannot lose indexer status`);
+            return;
+        } 
+
+        const message = Buffer.concat([
+            Buffer.from(peerTracPublicKey, 'hex'),
+            Buffer.from(peerWritingKey, 'hex')
+        ]);
+
+        const indexerRequest = {
+            type: 'removeIndexer',
+            key: this.wallet.publicKey,
+            value: {
+                ptpk: peerTracPublicKey,
+                pwk: peerWritingKey,
+                pop: this.wallet.sign(message)
+            }
+        }
+        await this.base.append(indexerRequest);
+    }
+
+    /**
+     * Retrieves the bootstrap entry from the base view.
+     * 
+     * @returns {Promise<Object|null>} The bootstrap entry if it exists, otherwise null.
+     */
+    async getBootstrapEntry() {
+        return await this.base.view.get('bootstrap');
+    }
+
+    /**
+     * Handles incoming writer events by parsing the data and emitting a writerEvent.
+     * 
+     * @param {MainSettlementBus} msbInstance - An instance of the MainSettlementBus class.
+     * @param {Buffer} data - The data received from the connection.
+     */
+    static async handleIncomingWriterEvent(msbInstance, data) {
+        try {
+            const bufferData = data.toString();
+            const parsedRequest = JSON.parse(bufferData);
+            if (parsedRequest.type === 'addWriter' || parsedRequest.type === 'removeWriter') {
+                msbInstance.emit('writerEvent', parsedRequest);
+            }
+        } catch (error) {
+            // for now ignore the error
+        }
+    }
+}
+
+export default WriterManager;