trac-peer 0.1.57 → 0.1.58

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-peer",
   "main": "src/index.js",
-  "version": "0.1.57",
+  "version": "0.1.58",
   "type": "module",
   "dependencies": {
     "assert": "npm:bare-node-assert",
@@ -37,6 +37,7 @@
     "brittle": "3.0.0",
     "buffer": "npm:bare-node-buffer",
     "child_process": "npm:bare-node-child-process",
+    "compact-encoding": "^2.16.1",
     "console": "npm:bare-node-console",
     "corestore": "7.4.1",
     "crypto": "npm:bare-node-crypto",
@@ -60,6 +61,7 @@
     "path": "npm:bare-node-path",
     "pear-interface": "1.0.0",
     "process": "npm:bare-node-process",
+    "protomux": "^3.10.1",
     "protomux-wakeup": "^2.2.1",
     "readline": "npm:bare-node-readline",
     "ready-resource": "^1.0.0",

package/src/api.js

@@ -2,6 +2,14 @@ import b4a from "b4a";
 import {jsonStringify} from "./functions.js";
 
 export class ProtocolApi{
+
+    /**
+     * Exposes read and write functions.
+     * May be extended by contract protocol instances.
+     *
+     * @param peer
+     * @param options
+     */
     constructor(peer, options = {}) {
         this.peer = peer;
         this.api_tx_exposed = options.api_tx_exposed === true;
@@ -9,30 +17,57 @@ export class ProtocolApi{
         this.options = options;
     }
 
+    /**
+     *
+     * @returns {null|string}
+     */
     getPeerValidatorAddress(){
         return this.peer.validator;
     }
 
+    /**
+     *
+     * @returns {null|string}
+     */
     getPeerBootstrap(){
         return this.peer.bootstrap;
     }
 
+    /**
+     *
+     * @returns {null|string}
+     */
     getPeerMsbBootstrap(){
         return this.peer.msb.bootstrap;
     }
 
+    /**
+     *
+     * @returns {null|string}
+     */
     getPeerWriterKey(){
         return this.peer.writerLocalKey;
     }
 
+    /**
+     *
+     * @returns {string}
+     */
     generateNonce(){
         return this.peer.protocol_instance.generateNonce();
     }
 
-    async prepareMessage(msg, address, reply_to = null, attachments = []){
+    /**
+     * @throws Error
+     * @param msg
+     * @param address
+     * @param reply_to
+     * @param attachments
+     * @returns {{dispatch: {type: string, msg: string, address, attachments: *[], deleted_by: null, reply_to: (number|null), pinned: boolean, pin_id: null}}}
+     */
+    prepareMessage(msg, address, reply_to = null, attachments = []){
         if(typeof msg !== 'string') throw new Error('Msg must be a string');
-        if(b4a.byteLength(jsonStringify(address)) > 64) throw new Error('Address too large.');
-        if(b4a.byteLength(jsonStringify(reply_to)) > 256) throw new Error('Reply to too large.');
+        if(b4a.byteLength(jsonStringify(address)) !== 66) throw new Error('Address too large.');
         if(reply_to !== null && isNaN(parseInt(reply_to))) throw new Error('Reply to not a number.');
         if(false === Array.isArray(attachments)) throw new Error('attachments must be an array.');
         if(attachments.length > 20) throw new Error('Too many attachments');
@@ -54,8 +89,36 @@ export class ProtocolApi{
         return prepared;
     }
 
+    /**
+     *
+     * @returns {boolean}
+     */
+    msgExposed(){
+        return true === this.api_msg_exposed;
+    }
+
+    /**
+     * To post a message, an ed25519 signature has to be provided over the given message + nonce.
+     *
+     * Signing steps:
+     *
+     * let address = your_ed25519_wallet.getAccountAddress()
+     * let nonce = api.generateNonce()
+     * let prepared_message = api.prepareMessage("my message", address)
+     * let signature = your_ed25519_wallet.sign(JSON.stringify(prepared_message) + nonce)
+     * let result = api.post(prepared_message, signature, nonce)
+     *
+     * Note: new messages can be read from this api's msg functions.
+     *
+     * @throws Error
+     * @param prepared_message
+     * @param signature
+     * @param nonce
+     * @returns {Promise<void>}
+     */
     async post(prepared_message, signature, nonce){
-        if(false === this.api_msg_exposed) throw new Error('Posting messages not exposed in API.');
+        if(true !== this.api_msg_exposed) throw new Error('Posting messages not exposed in API.');
+        if(this.peer.base.writable === false) throw new Error('Peer is not writable.');
         if(b4a.byteLength(jsonStringify(prepared_message)) > this.peer.protocol_instance.msgMaxBytes()) throw new Error('Prepared message too large.');
         if(typeof prepared_message !== 'object') throw new Error('Prepared message must be an object generated with api.prepareMessage().');
         if(prepared_message.dispatch === undefined || prepared_message.dispatch.type === undefined ||
@@ -66,6 +129,8 @@ export class ProtocolApi{
         if(prepared_message.dispatch.type !== 'msg') throw new Error('Invalid type.');
         if(typeof prepared_message.dispatch.msg !== 'string') throw new Error('Msg must be a string');
         if(b4a.toString(b4a.from(prepared_message.dispatch.address, 'hex'), 'hex') !== prepared_message.dispatch.address) throw new Error('Invalid address.');
+        if(b4a.toString(b4a.from(signature, 'hex'), 'hex') !== signature) throw new Error('Invalid signature.');
+        if(b4a.toString(b4a.from(nonce, 'hex'), 'hex') !== nonce) throw new Error('Invalid nonce.');
         if(false === Array.isArray(prepared_message.dispatch.attachments)) throw new Error('attachments must be an array.');
         if(prepared_message.dispatch.attachments.length > 20) throw new Error('Too many attachments');
         for(let i = 0; i < prepared_message.dispatch.attachments.length; i++){
@@ -80,25 +145,52 @@ export class ProtocolApi{
         await this.peer.base.append({type: 'msg', value: prepared_message, hash : signature, nonce: nonce });
     }
 
+    /**
+     * @throws Error
+     * @param address
+     * @param command_hash
+     * @param nonce
+     * @returns {Promise<*>}
+     */
     async generateTx(address, command_hash, nonce) {
+        if(this.getPeerValidatorAddress() === null) throw new Error('Peer not connected to a validator.');
         return await this.peer.protocol_instance.generateTx(this.getPeerBootstrap(),
             this.getPeerMsbBootstrap(), this.getPeerValidatorAddress(), this.getPeerWriterKey(),
             address, command_hash, nonce);
     }
 
+    /**
+     *
+     * @param command
+     * @returns {*}
+     */
     prepareTxCommand(command){
         return this.peer.protocol_instance.mapTxCommand(command);
     }
 
     /**
-     * To pass a TX, an ed25519 signature has to be provided over the given tx + nonce.
+     *
+     * @returns {boolean}
+     */
+    txExposed(){
+        return true === this.api_tx_exposed;
+    }
+
+    /**
+     * To broadcast a TX, an ed25519 signature has to be provided over the given tx + nonce.
      *
      * Signing steps:
+     *
+     * let address = your_ed25519_wallet.getAccountAddress()
      * let nonce = api.generateNonce()
      * let tx_hash = api.generateTx(address, a_sha256_function(JSON.stringify(api.prepareTxCommand(command))), nonce)
-     * let signature = your_ed25519_sign_lib.sign(tx + nonce, address)
-     * api.tx(tx_hash, api.prepareTxCommand(command), address, signature, nonce)
+     * let signature = your_ed25519_wallet.sign(tx + nonce)
+     * // simulating
+     * let sim_result = api.tx(tx_hash, api.prepareTxCommand(command), address, signature, nonce, true)
+     * // broadcasting
+     * let result = api.tx(tx_hash, api.prepareTxCommand(command), address, signature, nonce)
      *
+     * @throws Error
      * @param tx
      * @param prepared_command
      * @param address
@@ -108,18 +200,19 @@ export class ProtocolApi{
      * @returns {Promise<boolean|object>}
      */
     async tx(tx, prepared_command, address, signature, nonce, sim = false ){
-        if(false === this.api_tx_exposed) throw new Error('Transactions not exposed in API.');
+        if(true !== this.api_tx_exposed) throw new Error('Transactions not exposed in API.');
+        if(this.peer.base.writable === false) throw new Error('Peer is not writable.');
         if(this.getPeerValidatorAddress() === null) throw new Error('Peer not connected to a validator.');
         if(typeof prepared_command !== 'object') throw new Error('prepared_command must be an object.');
         if(typeof prepared_command.type !== 'string') throw new Error('prepared_command.type must exist and be a string.');
         if(prepared_command.value === undefined) throw new Error('prepared_command.value is missing.');
         if(b4a.byteLength(jsonStringify(prepared_command)) > this.peer.protocol_instance.txMaxBytes()) throw new Error('prepared_command too large.');
-        if(b4a.byteLength(jsonStringify(address)) !== 64) throw new Error('Address length invalid.');
-        if(b4a.byteLength(jsonStringify(signature)) !== 128) throw new Error('Signature length invalid.');
-        if(b4a.byteLength(jsonStringify(nonce)) !== 64) throw new Error('Nonce length invalid.');
-        if(b4a.toString(b4a.from(signature, 'utf8'), 'hex') !== signature) throw new Error('Invalid signature.');
-        if(b4a.toString(b4a.from(address, 'utf8'), 'hex') !== address) throw new Error('Invalid address.');
-        if(b4a.toString(b4a.from(nonce, 'utf8'), 'hex') !== nonce) throw new Error('Invalid nonce.');
+        if(b4a.byteLength(jsonStringify(address)) !== 66) throw new Error('Address length invalid.');
+        if(b4a.byteLength(jsonStringify(signature)) !== 130) throw new Error('Signature length invalid.');
+        if(b4a.byteLength(jsonStringify(nonce)) !== 66) throw new Error('Nonce length invalid.');
+        if(b4a.toString(b4a.from(address, 'hex'), 'hex') !== address) throw new Error('Invalid address.');
+        if(b4a.toString(b4a.from(signature, 'hex'), 'hex') !== signature) throw new Error('Invalid signature.');
+        if(b4a.toString(b4a.from(nonce, 'hex'), 'hex') !== nonce) throw new Error('Invalid nonce.');
         const verified = this.peer.wallet.verify(signature, tx + nonce, address);
         if(false === verified) throw new Error('Invalid signature.');
         const content_hash = await this.peer.createHash('sha256', this.peer.protocol_instance.safeJsonStringify(prepared_command));
@@ -140,6 +233,11 @@ export class ProtocolApi{
         return res;
     }
 
+    /**
+     *
+     * @param signed
+     * @returns {Promise<null>}
+     */
     async getAdmin(signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('admin');
@@ -148,6 +246,11 @@ export class ProtocolApi{
         return null;
     }
 
+    /**
+     *
+     * @param signed
+     * @returns {Promise<boolean|null>}
+     */
     async getWhitelistEnabled(signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('wlst');
@@ -156,6 +259,12 @@ export class ProtocolApi{
         return false;
     }
 
+    /**
+     *
+     * @param address
+     * @param signed
+     * @returns {Promise<boolean|null>}
+     */
     async getWhitelistStatus(address, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('wl/'+address);
@@ -164,6 +273,12 @@ export class ProtocolApi{
         return false;
     }
 
+    /**
+     *
+     * @param address
+     * @param signed
+     * @returns {Promise<boolean|null>}
+     */
     async getModStatus(address, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('mod/'+address);
@@ -172,6 +287,12 @@ export class ProtocolApi{
         return false;
     }
 
+    /**
+     *
+     * @param address
+     * @param signed
+     * @returns {Promise<boolean|null>}
+     */
     async getMuteStatus(address, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('mtd/'+address);
@@ -180,6 +301,11 @@ export class ProtocolApi{
         return false;
     }
 
+    /**
+     *
+     * @param signed
+     * @returns {Promise<boolean>}
+     */
     async getAutoAddWritersStatus(signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('auto_add_writers');
@@ -190,6 +316,11 @@ export class ProtocolApi{
         return false;
     }
 
+    /**
+     *
+     * @param signed
+     * @returns {Promise<boolean>}
+     */
     async getChatStatus(signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('chat_status');
@@ -200,6 +331,12 @@ export class ProtocolApi{
         return false;
     }
 
+    /**
+     *
+     * @param nick
+     * @param signed
+     * @returns {Promise<null>}
+     */
     async getAddressFromNick(nick, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('kcin/'+nick);
@@ -207,6 +344,12 @@ export class ProtocolApi{
         return res;
     }
 
+    /**
+     *
+     * @param address
+     * @param signed
+     * @returns {Promise<null>}
+     */
     async getNick(address, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('nick/'+address);
@@ -214,6 +357,11 @@ export class ProtocolApi{
         return res;
     }
 
+    /**
+     *
+     * @param signed
+     * @returns {Promise<number>}
+     */
     async getPinnedMessageLength(signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('pnl');
@@ -222,6 +370,12 @@ export class ProtocolApi{
         return res;
     }
 
+    /**
+     *
+     * @param index
+     * @param signed
+     * @returns {Promise<null>}
+     */
     async getPinnedMessage(index, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('pni/'+parseInt(index));
@@ -232,6 +386,11 @@ export class ProtocolApi{
         return await this.getMessage(res.msg, signed);
     }
 
+    /**
+     *
+     * @param signed
+     * @returns {Promise<number>}
+     */
     async getDeletedMessageLength(signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('delml');
@@ -240,6 +399,12 @@ export class ProtocolApi{
         return res;
     }
 
+    /**
+     *
+     * @param index
+     * @param signed
+     * @returns {Promise<null>}
+     */
     async getDeletedMessage(index, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('delm/'+parseInt(index));
@@ -250,6 +415,11 @@ export class ProtocolApi{
         return await this.getMessage(res, signed);
     }
 
+    /**
+     *
+     * @param signed
+     * @returns {Promise<number>}
+     */
     async getMessageLength(signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('msgl');
@@ -258,6 +428,12 @@ export class ProtocolApi{
         return res;
     }
 
+    /**
+     *
+     * @param index
+     * @param signed
+     * @returns {Promise<null>}
+     */
     async getMessage(index, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('msg/'+parseInt(index));
@@ -265,6 +441,12 @@ export class ProtocolApi{
         return res;
     }
 
+    /**
+     *
+     * @param address
+     * @param signed
+     * @returns {Promise<number>}
+     */
     async getUserMessageLength(address, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('umsgl/'+address);
@@ -273,6 +455,13 @@ export class ProtocolApi{
         return res;
     }
 
+    /**
+     *
+     * @param address
+     * @param index
+     * @param signed
+     * @returns {Promise<null>}
+     */
     async getUserMessage(address, index, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('umsg/'+address+'/'+parseInt(index));
@@ -283,6 +472,11 @@ export class ProtocolApi{
         return await this.getMessage(res, signed);
     }
 
+    /**
+     *
+     * @param signed
+     * @returns {Promise<number>}
+     */
     async getTxLength(signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('txl');
@@ -291,6 +485,12 @@ export class ProtocolApi{
         return res;
     }
 
+    /**
+     *
+     * @param index
+     * @param signed
+     * @returns {Promise<null>}
+     */
     async getTx(index, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('txi/'+parseInt(index));
@@ -298,6 +498,12 @@ export class ProtocolApi{
         return res;
     }
 
+    /**
+     *
+     * @param tx
+     * @param signed
+     * @returns {Promise<null>}
+     */
     async getTxData(tx, signed = true){
         let index = null;
         if(true === signed) index = await this.peer.protocol_instance.getSigned('tx/'+tx);
@@ -308,6 +514,12 @@ export class ProtocolApi{
         return null;
     }
 
+    /**
+     *
+     * @param address
+     * @param signed
+     * @returns {Promise<number>}
+     */
     async getUserTxLength(address, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('utxl/'+address);
@@ -316,6 +528,13 @@ export class ProtocolApi{
         return res;
     }
 
+    /**
+     *
+     * @param address
+     * @param index
+     * @param signed
+     * @returns {Promise<null>}
+     */
     async getUserTx(address, index, signed = true){
         let res = null;
         if(true === signed) res = await this.peer.protocol_instance.getSigned('utxi/'+address+'/'+parseInt(index));

package/src/functions.js

@@ -341,40 +341,7 @@ export async function joinValidator(input, peer){
     if(validator === null || false === validator.value.isWriter || true === validator.value.isIndexer){
         throw new Error('Invalid validator address.');
     }
-    const result = await peer.isValidatorAvailable(address);
-    if(result === null) {
-        console.log('Validator not available');
-    } else {
-        let existing_stream = undefined;
-        if(peer.msb.getSwarm().peers.has(address)){
-            const peerInfo = peer.msb.getSwarm().peers.get(address)
-            existing_stream = peer.msb.getSwarm()._allConnections.get(peerInfo.publicKey)
-        }
-        if(existing_stream !== undefined){
-            peer.validator_stream = existing_stream;
-            peer.validator = address;
-            peer.validator_stream.on('close', () => {
-                peer.validator_stream = null;
-                peer.validator = null;
-                console.log('Validator stream closed', address);
-            });
-            console.log('Validator stream established', address);
-        } else {
-            peer.validator_stream = peer.msb.getSwarm().dht.connect(b4a.from(address, 'hex'));
-            peer.validator = address;
-            peer.validator_stream.on('open', () => {
-                console.log('Validator stream established', address);
-            });
-            peer.validator_stream.on('close', () => {
-                peer.validator_stream = null;
-                peer.validator = null;
-            });
-            peer.validator_stream.on('error', (error) => {
-                peer.validator_stream = null;
-                peer.validator = null;
-            });
-        }
-    }
+    await peer.tryConnection(address);
 }
 
 export async function tx(input, peer){

package/src/index.js

@@ -11,6 +11,8 @@ import Corestore from 'corestore';
 import w from 'protomux-wakeup';
 import BlindPairing from 'blind-pairing'
 const wakeup = new w();
+import Protomux from 'protomux'
+import c from 'compact-encoding'
 import {
     addWriter, addAdmin, setAutoAddWriters, setChatStatus, setMod, deleteMessage,
     enableWhitelist, postMessage, jsonStringify, visibleLength, setNick,
@@ -44,6 +46,7 @@ export class Peer extends ReadyResource {
         this.contract = options.contract || null;
         this.wallet = options.wallet || null;
         this.features = options.features || [];
+        this.custom_validators = options.custom_validators || [];
         this.protocol_instance = null;
         this.contract_instance = null;
         this.channel = b4a.alloc(32).fill(options.channel) || null;
@@ -512,6 +515,36 @@ export class Peer extends ReadyResource {
         try{ await this.validator_stream.send(b4a.from(jsonStringify(_msg))); } catch(e){ }
     }
 
+    async tryConnection(address){
+        if(null === this.swarm) return null;
+
+        // trying to join a peer from the global swarm
+        if(false === this.swarm.peers.has(address)){
+            this.swarm.joinPeer(b4a.from(address, 'hex'));
+            let cnt = 0;
+            while(false === this.swarm.peers.has(address)){
+                if(cnt >= 15) break;
+                await sleep(1_000);
+                cnt += 1;
+            }
+        }
+
+        if(this.swarm.peers.has(address)){
+            let stream;
+            const peerInfo = this.swarm.peers.get(address)
+            stream = this.swarm._allConnections.get(peerInfo.publicKey)
+            if(stream !== undefined && stream.messenger !== undefined){
+                stream.messenger.send('get_validator');
+                let cnt = 0;
+                while(this.validator_stream === null){
+                    if(cnt >= 1500) break;
+                    await this.sleep(10);
+                    cnt += 1;
+                }
+            }
+        }
+    }
+
     async isValidatorAvailable(address){
         if(null === this.msb.getSwarm()) return null;
         let writer_key = null;
@@ -529,7 +562,9 @@ export class Peer extends ReadyResource {
             existing_stream.on('message', (msg) => {
                 try{
                     const response = jsonParse(b4a.toString(msg, 'utf-8'));
-                    if(response.op === 'writer_key' && response.key !== undefined){
+                    if(response.op === 'writer_key' && response.key !== undefined &&
+                        response.channel !== undefined &&
+                        response.channel === b4a.toString(this.msb.getChannel(), 'utf8')){
                         writer_key = response.key;
                     }
                 }catch(e){}
@@ -553,7 +588,9 @@ export class Peer extends ReadyResource {
             stream.on('message', (msg) => {
                 try{
                     const response = jsonParse(b4a.toString(msg, 'utf-8'));
-                    if(response.op === 'writer_key' && response.key !== undefined){
+                    if(response.op === 'writer_key' && response.key !== undefined &&
+                        response.channel !== undefined &&
+                        response.channel === b4a.toString(this.msb.getChannel(), 'utf8')){
                         writer_key = response.key;
                     }
                 }catch(e){}
@@ -587,25 +624,6 @@ export class Peer extends ReadyResource {
             }
         });
         this.updater();
-
-        // test
-        const pins = this.protocol_instance;
-        const command = '';
-
-        const prepared_command = pins.api.prepareTxCommand(command);
-        let nonce = pins.api.generateNonce();
-
-        let tx_hash = pins.api.generateTx(
-            this.wallet.publicKey, await this.createHash('sha256', JSON.stringify(prepared_command)), nonce
-        )
-
-        console.log('TX Hash', tx_hash)
-
-        const signature = this.wallet.sign(tx_hash + nonce)
-
-        const res = await pins.api.tx(tx_hash, prepared_command, this.wallet.publicKey, signature, nonce)
-
-        console.log('TX Res', res)
     }
 
     async initContract(){
@@ -642,50 +660,23 @@ export class Peer extends ReadyResource {
                 } else {
                     length = length.value;
                 }
+                if(this.custom_validators.length !== 0){
+                    length = this.custom_validators.length;
+                }
                 async function findSome(){
                     if(_this.validator_stream !== null) return;
                     const rnd_index = Math.floor(Math.random() * length);
                     let validator = await _this.msb.base.view.get('wri/' + rnd_index);
+                    if(_this.custom_validators.length !== 0){
+                        validator = { value : _this.custom_validators[rnd_index] };
+                        console.log('Trying custom validator', validator.value);
+                    }
                     if(_this.validator_stream !== null) return;
                     if (null !== validator) {
                         validator = await _this.msb.base.view.get(validator.value);
                         if(_this.validator_stream !== null) return;
                         if(null !== validator && false !== validator.value.isWriter && false === validator.value.isIndexer) {
-                            const result = await _this.isValidatorAvailable(validator.value.pub);
-                            if(_this.validator_stream !== null) return;
-                            if (null !== result) {
-                                await _this.sleep(100);
-                                if(_this.validator_stream !== null) return;
-                                let existing_stream = undefined;
-                                if(_this.msb.getSwarm().peers.has(validator.value.pub)){
-                                    const peerInfo = _this.msb.getSwarm().peers.get(validator.value.pub)
-                                    existing_stream = _this.msb.getSwarm()._allConnections.get(peerInfo.publicKey)
-                                }
-                                if(existing_stream !== undefined){
-                                    _this.validator_stream = existing_stream;
-                                    _this.validator = validator.value.pub;
-                                    _this.validator_stream.on('close', () => {
-                                        _this.validator_stream = null;
-                                        _this.validator = null;
-                                        console.log('Validator stream closed', validator.value.pub);
-                                    });
-                                    console.log('Validator stream established', validator.value.pub);
-                                } else {
-                                    _this.validator_stream = _this.msb.getSwarm().dht.connect(b4a.from(validator.value.pub, 'hex'));
-                                    _this.validator = validator.value.pub;
-                                    _this.validator_stream.on('open', () => {
-                                        console.log('Validator stream established', validator.value.pub);
-                                    });
-                                    _this.validator_stream.on('close', () => {
-                                        _this.validator_stream = null;
-                                        _this.validator = null;
-                                    });
-                                    _this.validator_stream.on('error', (error) => {
-                                        _this.validator_stream = null;
-                                        _this.validator = null;
-                                    });
-                                }
-                            }
+                            await _this.tryConnection(validator.value.pub);
                         }
                     }
                 }
@@ -786,6 +777,40 @@ export class Peer extends ReadyResource {
             console.log('');
 
             this.swarm.on('connection', async (connection, peerInfo) => {
+
+                const mux = Protomux.from(connection)
+                connection.userData = mux
+
+                const message_channel = mux.createChannel({
+                    protocol: b4a.toString(channel, 'utf8'),
+                    onopen() { },
+                    onclose() { }
+                })
+
+                message_channel.open()
+
+                const message = message_channel.addMessage({
+                    encoding: c.json,
+                    async onmessage(msg) {
+                        try{
+                            if(msg.response !== undefined && msg.response.op !== undefined && msg.response.op === 'validator'){
+                                const res = await _this.msb.get(msg.response.address);
+                                if(res === null) return;
+                                const verified = _this.wallet.verify(msg.sig, JSON.stringify(msg.response) + msg.nonce, msg.response.address)
+                                if(verified && msg.response.channel === b4a.toString(channel, 'utf8')){
+                                    console.log('Validator stream established', msg.response.address)
+                                    _this.validator_stream = connection;
+                                    _this.validator = msg.response.address;
+                                }
+                            }
+                        } catch (e) {
+                            console.log(e);
+                        }
+                    }
+                })
+
+                connection.messenger = message;
+
                 const remotePublicKey = b4a.toString(connection.remotePublicKey, 'hex');
 
                 this.connectedPeers.add(remotePublicKey);
@@ -794,6 +819,11 @@ export class Peer extends ReadyResource {
                 this.connectedNodes++;
 
                 connection.on('close', () => {
+                    if(this.validator_stream === connection){
+                        this.validator_stream = null;
+                        this.validator = null;
+                    }
+                    message_channel.close()
                     this.connectedNodes--;
                     this.connectedPeers.delete(remotePublicKey);
                 });

package/src/protocol.js

@@ -192,7 +192,7 @@ class Protocol{
     async tx(subject, sim = false, surrogate = null){
         if(this.peer.validator_stream === null) throw new Error('HyperMallProtocol::tx(): No validator available.');
         const obj = this.mapTxCommand(subject.command);
-        if(null !== obj) {
+        if(null !== obj && typeof obj.type === 'string' && obj.value !== undefined) {
             return await this.broadcastTransaction(this.peer.validator,{
                 type : obj.type,
                 value : obj.value