trac-msb 0.1.19 → 0.1.20

package/Whitelist/pubkeys.csv

@@ -1,2 +1 @@
-e914ba0570858924b6cf7bfc1852882cf1fc520f410ea84dc0c0248ba2ca725f
-01a6fc0108514ef6c8ff7b23e1eb25235724934e7e31bea391903baf15b742b9
+2ca71cadf349f877d2239633108afe7b5a8d98ac4796b093bb813323b1d18af9

package/package.json

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

package/src/index.js

@@ -29,7 +29,6 @@ export class MainSettlementBus extends ReadyResource {
     // Internal flags
     #shouldListenToAdminEvents = false;
     #shouldListenToWriterEvents = false;
-    #shouldValidatorObserverWorks = true;
     #isStreaming = false;
 
     // internal attributes
@@ -78,7 +77,7 @@ export class MainSettlementBus extends ReadyResource {
         this.#dht_bootstrap = ['116.202.214.143:10001', '116.202.214.149:10001', 'node1.hyperdht.org:49737', 'node2.hyperdht.org:49737', 'node3.hyperdht.org:49737'];
         this.#dht_node = null;
         this.#validator_stream = null
-        this.validator = null;
+        this.#validator = null;
         this.#base = null;
         this.#writingKey = null;
         this.#enable_txchannel = options.enable_txchannel !== false;
@@ -402,7 +401,7 @@ export class MainSettlementBus extends ReadyResource {
         await this.#removeWriter(op, batch, base);
 
     }
-    
+
     async _open() {
         await this.#base.ready();
         if (this.#enable_wallet) {
@@ -467,19 +466,51 @@ export class MainSettlementBus extends ReadyResource {
     }
 
     #sendMessageToAdmin(adminEntry, message) {
+        try{
+            if (!adminEntry || !message) {
+                return;
+            }
+            let stream;
+
+            if(this.#validator_stream !== null){
+                stream = this.#validator_stream;
+            } else {
+                stream = this.#dht_node.connect(b4a.from(adminEntry.tracPublicKey, 'hex'))
+            }
+
+            stream.on('connect', async function () {
+                console.log('Trying to send message to admin.');
+                await stream.send(b4a.from(JSON.stringify(message)));
+                await stream.end();
+            });
+            stream.on('open', function () { console.log('Message channel opened') });
+            stream.on('close', () => { console.log('Message channel closed') });
+            stream.on('error', (error) => { console.log('Message send error', error) });
+        }catch(e){
+            console.log(e)
+        }
+    }
+
+    async #sendMessageToAdmin2(adminEntry, message) {
         if (!adminEntry || !message) {
             return;
         }
 
-        const stream = this.#dht_node.connect(b4a.from(adminEntry.tracPublicKey, 'hex'))
+        this.#swarm.joinPeer(b4a.from(adminEntry.tracPublicKey, 'hex'))
 
-        stream.on('connect', async function () {
-            console.log('Trying to send message to admin.');
-            await stream.send(b4a.from(JSON.stringify(message)));
-        });
-        stream.on('open', function () { console.log('Message channel opened') });
-        stream.on('close', () => { console.log('Message channel closed') });
-        stream.on('error', (error) => { console.log('Message send error', error) });
+        let stream = undefined;
+
+        stream = this.#dht_node.connect(b4a.from(adminEntry.tracPublicKey, 'hex'))
+
+        if(stream !== undefined && stream.op !== undefined){
+            stream.on('connect', async function () {
+                console.log('Trying to send message to admin.');
+                await stream.send(b4a.from(JSON.stringify(message)));
+            });
+            stream.on('open', function () { console.log('Message channel opened') });
+            stream.on('close', () => { console.log('Message channel closed') });
+            stream.on('error', (error) => { console.log('Message send error', error) });
+        }
     }
 
     async #verifyMessage(signature, publicKey, bufferMessage) {
@@ -646,7 +677,6 @@ export class MainSettlementBus extends ReadyResource {
             if (!adminEntry && this.#wallet && this.#writingKey && this.#writingKey === this.#bootstrap) {
                 await this.#base.append(addAdminMessage);
             } else if (adminEntry && this.#wallet && adminEntry.tracPublicKey === this.#wallet.publicKey && this.#writingKey && this.#writingKey !== adminEntry.wk) {
-                
                 if (null === this.#validator_stream) return;
                 await this.#validator_stream.send(b4a.from(JSON.stringify(addAdminMessage)));
             }
@@ -716,7 +746,7 @@ export class MainSettlementBus extends ReadyResource {
         }
 
         if (assembledMessage) {
-            this.#sendMessageToAdmin(adminEntry, assembledMessage);
+            await this.#sendMessageToAdmin(adminEntry, assembledMessage);
         }
     }
 
@@ -749,11 +779,70 @@ export class MainSettlementBus extends ReadyResource {
         }
     }
 
+    async isValidatorAvailable(address){
+        if(null === this.#swarm) return null;
+        let writer_key = null;
+
+        this.#swarm.joinPeer(b4a.from(address, 'hex'))
+
+        let existing_stream = undefined;
+
+        if(this.#swarm.peers.has(address)){
+            const peerInfo = this.#swarm.peers.get(address)
+            existing_stream = this.#swarm._allConnections.get(peerInfo.publicKey)
+        }
+
+        if(existing_stream !== undefined){
+            existing_stream.on('message', (msg) => {
+                try{
+                    const response = JSON.parse(b4a.toString(msg, 'utf-8'));
+                    if(response.op === 'writer_key' && response.key !== undefined){
+                        writer_key = response.key;
+                    }
+                }catch(e){}
+            });
+            existing_stream.on('open', function () { });
+            existing_stream.on('close', () => { });
+            existing_stream.on('error', (error) => { });
+            await existing_stream.send(b4a.from(JSON.stringify('get_writer_key')));
+            let i = 0;
+            while(null === writer_key){
+                if(i >= 1_000) break;
+                await sleep(10);
+                i += 10;
+            }
+            return writer_key;
+        } else {
+            const stream = this.#swarm.dht.connect(b4a.from(address, 'hex'))
+            stream.on('connect', async function () {
+                await stream.send(b4a.from(JSON.stringify('get_writer_key')));
+            });
+            stream.on('message', (msg) => {
+                try{
+                    const response = jsonParse(b4a.toString(msg, 'utf-8'));
+                    if(response.op === 'writer_key' && response.key !== undefined){
+                        writer_key = response.key;
+                    }
+                }catch(e){}
+            });
+            stream.on('open', function () { });
+            stream.on('close', () => { });
+            stream.on('error', (error) => { });
+            let i = 0;
+            while(null === writer_key){
+                if(i >= 5_000) break;
+                await sleep(10);
+                i += 10;
+            }
+            return writer_key;
+        }
+    }
+
     async validatorObserver() {
         // Finding writers for admin recovery case
-        while (this.#shouldValidatorObserverWorks) {
+        while (this.#enable_wallet) {
 
-            if (this.#dht_node === null || this.#validator_stream !== null || this.#base.writable) {
+            if (this.#dht_node === null || this.#validator_stream !== null || this.#validator !== null) {
                 await sleep(1000);
                 continue;
             }
@@ -767,41 +856,59 @@ export class MainSettlementBus extends ReadyResource {
                 const wriEntry = await _this.#base.view.get('wri/' + rndIndex);
                 if (_this.#validator_stream !== null || wriEntry === null) return;
 
-
                 const validatorEntry = await _this.#base.view.get(wriEntry.value);
                 if (
                     _this.#validator_stream !== null ||
+                    _this.#validator !== null ||
                     validatorEntry === null ||
                     !validatorEntry.value.isWriter ||
                     validatorEntry.value.isIndexer
                 ) return;
 
                 const pubKey = validatorEntry.value.pub;
-                if (pubKey === _this.#wallet.publicKey) return; // avoid establishing connection to itself
-                _this.#validator = pubKey;
-                if (_this.#validator_stream !== null) return;
+                if (pubKey === _this.#wallet.publicKey) return;
 
-                const stream = _this.#dht_node.connect(b4a.from(pubKey, 'hex'));
-                _this.#validator_stream = stream;
+                const available = await _this.isValidatorAvailable(pubKey);
+                if (_this.#validator_stream !== null) return;
+                if(available === null) return;
 
-                _this.#validator_stream.on('open', () => {
-                    _this.#validator = pubKey;
-                    console.log('Validator stream established', pubKey);
-                });
+                let existing_stream = undefined;
 
-                _this.#validator_stream.on('close', () => {
-                    try { stream.destroy(); } catch { }
-                    _this.#validator_stream = null;
-                    _this.#validator = null;
-                    console.log('Stream closed', pubKey);
-                });
+                if(_this.#swarm.peers.has(pubKey)){
+                    const peerInfo = _this.#swarm.peers.get(pubKey)
+                    existing_stream = _this.#swarm._allConnections.get(peerInfo.publicKey)
+                }
+                if (_this.#validator_stream !== null) return;
 
-                _this.#validator_stream.on('error', (err) => {
-                    try { stream.destroy(); } catch { }
-                    _this.#validator_stream = null;
-                    _this.#validator = null;
-                    console.log(err);
-                });
+                if(existing_stream !== undefined){
+                    _this.#validator_stream = existing_stream;
+                    _this.#validator = pubKey;
+                    _this.#validator_stream.on('close', () => {
+                        if(_this.#validator_stream !== null && b4a.toString(_this.#validator_stream.publicKey, 'hex') === pubKey){
+                            _this.#validator_stream = null;
+                            _this.#validator = null;
+                            console.log('Exissting Stream closed', pubKey);
+                        }
+                    });
+                    console.log('Existing Stream established', pubKey);
+                } else {
+                    _this.#validator_stream = _this.#dht_node.connect(b4a.from(pubKey, 'hex'));
+                    _this.#validator = pubKey;
+                    _this.#validator_stream.on('close', () => {
+                        if(_this.#validator_stream !== null && b4a.toString(_this.#validator_stream.publicKey, 'hex') === pubKey){
+                            _this.#validator_stream = null;
+                            _this.#validator = null;
+                            console.log('Stream closed', pubKey);
+                        }
+                    });
+
+                    _this.#validator_stream.on('error', (err) => {
+                        if(_this.#validator_stream !== null && b4a.toString(_this.#validator_stream.publicKey, 'hex') === pubKey) {
+                            _this.#validator_stream = null;
+                            _this.#validator = null;
+                        }
+                    });
+                }
             }
 
             const promises = [];

package/src/network.js

@@ -44,7 +44,7 @@ class Network {
             swarm.on('connection', async (connection) => {
                 wakeup.addStream(connection);
                 store.replicate(connection);
-                connection.on('close', () => { });
+                connection.on('close', () => {});
                 connection.on('error', (error) => { });
 
                 if(enable_txchannel){
@@ -84,7 +84,6 @@ class Network {
 
                             }
                             else {
-                                //await connection.destroy();
                                 if (base.isIndexer || !base.writable) return;
 
                                 if (network.tx_pool.length >= 1000) {