trac-msb 0.0.13 → 0.0.14

package/_stores/n7/db/keypair.json

@@ -0,0 +1 @@
+{"publicKey":"e76e8affcd49bd1ebb7f1c0048243efcc272fd9f9d144f41e84d59587d368578","secretKey":"e2e6823887157d3dfa60e344325bce082694ae8b6c91b910efa5839cfee49f5ce76e8affcd49bd1ebb7f1c0048243efcc272fd9f9d144f41e84d59587d368578"}

package/msb.mjs

@@ -2,7 +2,7 @@ import MainSettlementBus from './src/index.js';
 const opts = {
     stores_directory : 'stores/',
     store_name : process.argv[2],
-    bootstrap: '3ad0f48d685fdf10c551e596c48596a99ff373c65845d8827da8b7862a476979',
+    bootstrap: '8e192d111aee4a29497f2967a4126fdabc2071dc7885a62a82bdfc97b4e4a2e3',
     channel: Buffer.alloc(32).fill('00botracnetworkmainsettlementbus'),
     tx : Buffer.alloc(32).fill('botracnetworkmainsettlementbustx')
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-msb",
   "main": "src/index.js",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"

package/src/functions.js

@@ -1,4 +1,4 @@
-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
@@ -15,68 +15,11 @@ export function sanitizeTransaction(parsedTx) {
     );
 }
 
-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 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 async function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
 }

package/src/index.js

@@ -5,20 +5,14 @@ import ReadyResource from 'ready-resource';
 import b4a from 'b4a';
 import Hyperbee from 'hyperbee';
 import readline from 'readline';
-import { sanitizeTransaction, restoreManifest, sleep, restoreHash ,verifyDag } from './functions.js';
+import crypto from 'hypercore-crypto';
+import { sanitizeTransaction, addWriter } from './functions.js';
 import w from 'protomux-wakeup';
+import PeerWallet 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 {
 
@@ -26,33 +20,32 @@ 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.writingKey = null;
+        this.writerLocalKey = 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
-        this.wallet = new PeerWallet({ isVerifyOnly: this.isVerifyOnly });
+        this.wallet = new PeerWallet(options);
 
         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, {
@@ -64,8 +57,6 @@ export class MainSettlementBus extends ReadyResource {
                     keyEncoding: 'utf-8',
                     valueEncoding: 'json'
                 })
-                _this.keysView = _this.bee.sub('pubKeys');
-
                 return _this.bee;
             },
 
@@ -74,142 +65,25 @@ export class MainSettlementBus extends ReadyResource {
                 for (const node of nodes) {
                     const op = node.value;
                     const postTx = op.value;
-
-                    // UNDER NO CIRCUMSTANCE DO THINGS LIKE THIS IN APPLY!
-
-                    if (!op || !op.type || !op.key || !op.value) {
-                        continue;
-                    }
-
-                    // WRITING & INDEXING
                     if (op.type === 'tx') {
                         if (null === await view.get(op.key) &&
-                            restoreHash(postTx) !== postTx.tx &&
                             sanitizeTransaction(postTx) &&
                             postTx.op === 'post-tx' &&
-                            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
+                            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
                             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') {
-                        //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`);
-                            }
-                        }
+                        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`);
                     }
                 }
             }
@@ -219,23 +93,17 @@ export class MainSettlementBus extends ReadyResource {
 
     async _open() {
         await this.base.ready();
-        if (this.enable_wallet && !this.isVerifyOnly) {
+        if(this.enable_wallet){
             await this.wallet.initKeyPair(this.KEY_PAIR_PATH);
         }
-
-        this.writingKey = b4a.toString(this.base.local.key, 'hex');
-
+        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');
         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() {
@@ -249,19 +117,23 @@ 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) => {
 
-                // indexers are NOT supposed to validate transactions!
-                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
                 }
@@ -269,17 +141,16 @@ export class MainSettlementBus extends ReadyResource {
                 if(Buffer.byteLength(msg) > 3072) return;
 
                 try {
+
                     const parsedPreTx = JSON.parse(msg);
 
                     if (sanitizeTransaction(parsedPreTx) &&
                         parsedPreTx.op === 'pre-tx' &&
-                        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 &&
+                        crypto.verify(Buffer.from(parsedPreTx.tx, 'utf-8'), Buffer.from(parsedPreTx.is, 'hex'), Buffer.from(parsedPreTx.ipk, 'hex')) &&
+                        parsedPreTx.w === _this.writerLocalKey &&
                         null === await _this.base.view.get(parsedPreTx.tx)
                     ) {
-                        const signature = this.wallet.sign(Buffer.from(parsedPreTx.tx, 'utf-8'));
-                       
+                        const signature = crypto.sign(Buffer.from(parsedPreTx.tx, 'utf-8'), this.signingKeyPair.secretKey);
                         const append_tx = {
                             op: 'post-tx',
                             tx: parsedPreTx.tx,
@@ -289,10 +160,10 @@ export class MainSettlementBus extends ReadyResource {
                             ipk: parsedPreTx.ipk,
                             ch: parsedPreTx.ch,
                             in: parsedPreTx.in,
-                            ws: JSON.parse(JSON.stringify(signature)),
-                            wp: JSON.parse(JSON.stringify(this.wallet.publicKey)),
+                            ws: signature.toString('hex'),
+                            wp: this.signingKeyPair.publicKey.toString('hex'),
                         };
-                        _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)
@@ -306,40 +177,44 @@ 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 sleep(5);
+                    await this.sleep(5);
                 }
                 this.tx_pool.splice(0, length);
             }
-            await sleep(10);
+            await this.sleep(10);
         }
     }
 
+    async sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
     async _replicate() {
         if (!this.swarm) {
-            const keyPair = this.base.local.keyPair //await this.store.createKeyPair('hyperswarm');
+            const 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.writingKey}`)
-
+            console.log(`Writer key: ${this.writerLocalKey}`)
+            console.log(`isIndexer: ${this.base.isIndexer}`);
             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) {
@@ -362,6 +237,30 @@ 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,
@@ -369,43 +268,102 @@ export class MainSettlementBus extends ReadyResource {
         });
 
         console.log('MSB started. Available commands:');
-        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('- /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('- /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 verifyDag(this.base);
+                    await this.verifyDag();
                     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('/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]);
+                    if (input.startsWith('/add_writer')) {
+                        await addWriter(input, this);
                     }
             }
             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 = this.wallet.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 = this.wallet.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() { }