trac-peer 0.1.56 → 0.1.57

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-peer",
   "main": "src/index.js",
-  "version": "0.1.56",
+  "version": "0.1.57",
   "type": "module",
   "dependencies": {
     "assert": "npm:bare-node-assert",

package/src/api.js

@@ -105,41 +105,38 @@ export class ProtocolApi{
      * @param signature
      * @param nonce
      * @param sim
-     * @returns {Promise<boolean>}
+     * @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(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(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 too large.');
-        if(b4a.byteLength(jsonStringify(signature)) > 128) throw new Error('Signature too large.');
-        if(b4a.byteLength(jsonStringify(nonce)) > 256) throw new Error('Nonce too large.');
-        if(b4a.toString(b4a.from(signature, 'hex'), 'hex') !== signature) throw new Error('Invalid signature.');
-        if(b4a.toString(b4a.from(address, 'hex'), 'hex') !== address) throw new Error('Invalid address.');
+        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.');
         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));
         let _tx = await this.generateTx(address, content_hash, nonce);
         if(tx !== _tx) throw new Error('Invalid TX.');
-        while(null !== this.peer.protocol_instance.surrogate_tx) await this.peer.sleep(3);
-        this.peer.protocol_instance.surrogate_tx = { tx : ''+tx, nonce : ''+nonce, signature : ''+signature, address : ''+address };
+        const surrogate = { tx : _tx, nonce : ''+nonce, signature : ''+signature, address : ''+address };
         let res = false;
         try{
-            if(true === sim){
-                while(true === this.peer.protocol_instance.sim) await this.peer.sleep(3);
-                this.peer.protocol_instance.sim = true;
-            }
-            const subject = { command : prepared_command.value, validator : ''+this.getPeerValidatorAddress() };
-            res = await this.peer.protocol_instance.tx(subject);
+            const subject = { command : prepared_command.value, validator : this.getPeerValidatorAddress() };
+            res = await this.peer.protocol_instance.tx(subject, sim === true, surrogate);
         } catch(e){ console.log(e) }
-        const err = this.peer.protocol_instance.getError(res);
-        if(null !== err){
-            console.log(err.message);
+        if(res !== false) {
+            const err = this.peer.protocol_instance.getError(res);
+            if (null !== err) {
+                console.log(err.message);
+            }
         }
-        this.peer.protocol_instance.sim = false;
-        this.peer.protocol_instance.surrogate_tx = null;
         return res;
     }
 

package/src/feature.js

@@ -20,18 +20,22 @@ class Feature {
     }
 
     async append(key, value){
-        const nonce = this.peer.protocol_instance.generateNonce();
-        const hash = this.peer.wallet.sign(JSON.stringify(value) + nonce);
-        await this.peer.base.append({ type: 'feature', key: this.key + '_' + key, value : {
-                dispatch : {
-                    type : this.key + '_feature',
-                    key : key,
-                    hash : hash,
-                    value : value,
-                    nonce : nonce,
-                    address : this.peer.wallet.publicKey
-                }
-            }});
+        if(this.peer.base.writable){
+            const nonce = this.peer.protocol_instance.generateNonce();
+            const hash = this.peer.wallet.sign(JSON.stringify(value) + nonce);
+            await this.peer.base.append({ type: 'feature', key: this.key + '_' + key, value : {
+                    dispatch : {
+                        type : this.key + '_feature',
+                        key : key,
+                        hash : hash,
+                        value : value,
+                        nonce : nonce,
+                        address : this.peer.wallet.publicKey
+                    }
+                }});
+        } else {
+            console.log('Peer running features not writable.');
+        }
     }
 
     async start(options = {}) {

package/src/functions.js

@@ -334,30 +334,69 @@ export async function removeWriter(input, peer){
     }
 }
 
+export async function joinValidator(input, peer){
+    const splitted = peer.protocol_instance.parseArgs(input)
+    const address = ''+splitted.address;
+    const validator = await peer.msb.base.view.get(address);
+    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;
+            });
+        }
+    }
+}
+
 export async function tx(input, peer){
     const splitted = peer.protocol_instance.parseArgs(input);
+    let res = false;
     if(splitted.command === undefined){
-        throw new Error('Missing option. Please use the --command flag.');
-    } else if(splitted.sim === undefined && splitted.validator === undefined){
-        if(peer.validator === null){
-            throw new Error('No validator available: Please wait for your peer to find an available one before transacting or pass the public key of a known one that is online.');
-        }
-        splitted['validator'] = peer.validator;
-    } else if(splitted.sim !== undefined && splitted.validator !== undefined){
-        throw new Error('Validator flag not allowed when simulating a transaction.');
+        res = new Error('Missing option. Please use the --command flag.');
+    } else if(splitted.sim === undefined && peer.validator === null){
+        res = new Error('No validator available: Please wait for your peer to find an available one or use joinValidator to connect to a specific one.');
     }
-    let res = false;
+    let sim = false;
     try{
         if(splitted.sim !== undefined && parseInt(splitted.sim) === 1){
-            while(true === peer.protocol_instance.sim) await peer.sleep(3);
-            peer.protocol_instance.sim = true;
+            sim = true;
         }
-        res = await peer.protocol_instance.tx(splitted);
+        res = await peer.protocol_instance.tx(splitted, sim);
     } catch(e){ console.log(e) }
-    const err = peer.protocol_instance.getError(res);
-    if(null !== err){
-        console.log(err.message);
+    if(res !== false){
+        const err = peer.protocol_instance.getError(res);
+        if(null !== err){
+            console.log(err.message);
+        }
     }
-    peer.protocol_instance.sim = false;
     return res;
 }

package/src/index.js

@@ -15,7 +15,7 @@ import {
     addWriter, addAdmin, setAutoAddWriters, setChatStatus, setMod, deleteMessage,
     enableWhitelist, postMessage, jsonStringify, visibleLength, setNick,
     muteStatus, setWhitelistStatus, updateAdmin, tx, safeClone, jsonParse,
-    pinMessage
+    pinMessage, joinValidator, removeWriter
 } from "./functions.js";
 import Check from "./check.js";
 export {default as Protocol} from "./protocol.js";
@@ -124,7 +124,8 @@ export class Peer extends ReadyResource {
                             let _err = null;
                             if(null !== err) {
                                 if(err.constructor.name === 'UnknownContractOperationType') continue;
-                                _err = ''+err.message;
+                                const _err_msg = parseInt(err.message);
+                                _err = isNaN(_err_msg) ? ''+err.message : _err_msg;
                             }
                             let len = await batch.get('txl');
                             if(null === len) {
@@ -132,12 +133,13 @@ export class Peer extends ReadyResource {
                             } else {
                                 len = len.value;
                             }
-                            const cloned = safeClone(op.value.dispatch);
-                            cloned['err'] = _err;
-                            cloned['tx'] = post_tx.value.tx;
-                            cloned['ipk'] = post_tx.value.ipk;
-                            cloned['wp'] = post_tx.value.wp;
-                            await batch.put('txi/'+len, cloned);
+                            const dta = {};
+                            dta['val'] = safeClone(op.value.dispatch);
+                            dta['err'] = _err;
+                            dta['tx'] = post_tx.value.tx;
+                            dta['ipk'] = post_tx.value.ipk;
+                            dta['wp'] = post_tx.value.wp;
+                            await batch.put('txi/'+len, dta);
                             await batch.put('txl', len + 1);
                             await batch.put('tx/'+post_tx.value.tx, len);
                             let ulen = await batch.get('utxl/'+post_tx.value.ipk);
@@ -229,7 +231,7 @@ export class Peer extends ReadyResource {
                             const verified = _this.wallet.verify(op.hash, str_msg + op.nonce, admin.value);
                             if(true === verified){
                                 const writerKey = b4a.from(op.key, 'hex');
-                                base.addWriter(writerKey, { isIndexer : true });
+                                await base.addWriter(writerKey, { isIndexer : true });
                                 await batch.put('sh/'+op.hash, '');
                                 console.log(`Indexer added: ${op.key}`);
                             }
@@ -245,9 +247,9 @@ export class Peer extends ReadyResource {
                             const verified = _this.wallet.verify(op.hash, str_msg + op.nonce, admin.value);
                             if(true === verified){
                                 const writerKey = b4a.from(op.key, 'hex');
-                                base.addWriter(writerKey, { isIndexer : false });
+                                await base.addWriter(writerKey, { isIndexer : false });
                                 await batch.put('sh/'+op.hash, '');
-                                console.log(`Writer added: ${op.key}`);
+                                console.log(`Writer added: ${writerKey}`);
                             }
                         }
                     } else if (op.type === 'removeWriter') {
@@ -261,7 +263,7 @@ export class Peer extends ReadyResource {
                             const verified = _this.wallet.verify(op.hash, str_msg + op.nonce, admin.value);
                             if(true === verified){
                                 const writerKey = b4a.from(op.key, 'hex');
-                                base.removeWriter(writerKey);
+                                await base.removeWriter(writerKey);
                                 await batch.put('sh/'+op.hash, '');
                                 console.log(`Writer removed: ${op.key}`);
                             }
@@ -302,7 +304,7 @@ export class Peer extends ReadyResource {
                         const banned = await batch.get('bnd/'+op.key);
                         if(null === banned && null !== auto_add_writers && auto_add_writers.value === 'on'){
                             const writerKey = b4a.from(op.key, 'hex');
-                            base.addWriter(writerKey, { isIndexer : false });
+                            await base.addWriter(writerKey, { isIndexer : false });
                         }
                         console.log(`Writer auto added: ${op.key}`);
                     } else if (op.type === 'addAdmin') {
@@ -585,6 +587,25 @@ 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(){
@@ -694,10 +715,10 @@ export class Peer extends ReadyResource {
                 const msb_tx = await view_session.get(tx);
                 await view_session.close();
                 if(null !== msb_tx){
-                    msb_tx['dispatch'] = this.protocol_instance.prepared_transactions_content[tx].dispatch;
                     msb_tx['msbsl'] = msbsl;
+                    msb_tx['dispatch'] = this.protocol_instance.prepared_transactions_content[tx].dispatch;
                     msb_tx['ipk'] = this.protocol_instance.prepared_transactions_content[tx].ipk;
-                    msb_tx['wp'] = this.validator;
+                    msb_tx['wp'] = this.protocol_instance.prepared_transactions_content[tx].validator;
                     delete this.tx_pool[tx];
                     delete this.protocol_instance.prepared_transactions_content[tx];
                     await this.base.append({ type: 'tx', key: tx, value: msb_tx });
@@ -754,11 +775,12 @@ export class Peer extends ReadyResource {
                 poll: 5000
             });
             console.log('');
-            console.log('############################################################################');
-            console.log('# Hypermall Address:    ', this.wallet.publicKey, '#');
+            console.log('######################################################################################');
+            console.log('# Peer Address:    ', this.wallet.publicKey, '#');
             this.writerLocalKey = b4a.toString(this.base.local.key, 'hex');
-            console.log('# Hypermall Writer:     ', this.writerLocalKey, '#');
-            console.log('############################################################################');
+            console.log('# Peer Writer:     ', this.writerLocalKey, '#');
+            console.log('######################################################################################');
+            console.log('');
             console.log(`isIndexer: ${this.base.isIndexer}`);
             console.log(`isWriter: ${this.base.writable}`);
             console.log('');
@@ -855,6 +877,10 @@ export class Peer extends ReadyResource {
             const lengthdagSystem = this.base.system.core.length;
             console.log('wallet.address:', this.wallet !== null ? this.wallet.publicKey : 'unset');
             console.log('hypermall.writerKey:', this.writerLocalKey);
+            const admin = await this.base.view.get('admin')
+            console.log(`admin: ${admin !== null ? admin.value : 'unset'}`);
+            console.log(`isIndexer: ${this.base.isIndexer}`);
+            console.log(`isWriter: ${this.base.writable}`);
             console.log('swarm.connections.size:', this.swarm.connections.size);
             console.log('base.view.core.signedLength:', this.base.view.core.signedLength);
             console.log("base.signedLength", this.base.signedLength);
@@ -871,16 +897,12 @@ export class Peer extends ReadyResource {
         }
     }
 
-    async interactiveMode() {
-        if(this.readline_instance === null || (global.Pear !== undefined && global.Pear.config.options.type === 'desktop')) return;
-
-        const rl = this.readline_instance;
-
+    printHelp(){
         console.log('Node started. Available commands:');
         console.log(' ');
         console.log('- Setup Commands:');
         console.log('- /add_admin | Works only once and only on bootstrap node! Enter a wallet address to assign admin rights: \'/add_admin --address "<address>"\'.');
-        console.log('- /update_admin | Existing admins may transfer admin ownership. Enter "null" as address to waive admin rights for this peer entirely: \'/add_admin --address "<address>"\'.');
+        console.log('- /update_admin | Existing admins may transfer admin ownership. Enter "null" as address to waive admin rights for this peer entirely: \'/update_admin --address "<address>"\'.');
         console.log('- /add_indexer | Only admin. Enter a peer writer key to get included as indexer for this network: \'/add_indexer --key "<key>"\'.');
         console.log('- /add_writer | Only admin. Enter a peer writer key to get included as writer for this network: \'/add_writer --key "<key>"\'.');
         console.log('- /remove_writer | Only admin. Enter a peer writer key to get removed as writer or indexer for this network: \'/remove_writer --key "<key>"\'.');
@@ -898,18 +920,31 @@ export class Peer extends ReadyResource {
         console.log('- /set_whitelist_status | Only admin. Add/remove users to/from the chat whitelist: \'/set_whitelist_status --user "<address>" --status 1\'.');
         console.log(' ');
         console.log('- System Commands:');
-        console.log('- /tx | Perform a contract transaction. The command flag contains contract commands in json format: \'/tx --command "<string, content depends on the protocol>"\'. To try broadcasting to a specific validator, use the validator flag and pass the validator public key: --validator "<validator public key>". To simulate a tx, you must leave out the \'--validator\' flag and use \'--sim 1\' instead.');
+        console.log('- /tx | Perform a contract transaction. The command flag contains contract commands (format is protocol dependent): \'/tx --command "<string>"\'. To simulate a tx, additionally use \'--sim 1\'.');
+        console.log('- /join_validator | Try to connect to a specific validator with its MSB address: \'/join_validator --address "<address>"\'.');
         console.log('- /stats | check system properties such as writer key, DAG, etc.');
         console.log('- /get_keys | prints your public and private keys. Be careful and never share your private key!');
         console.log('- /exit | Exit the program');
+        console.log('- /help | This help text');
 
         this.protocol_instance.printOptions();
+    }
+
+    async interactiveMode() {
+        if(this.readline_instance === null || (global.Pear !== undefined && global.Pear.config.options.type === 'desktop')) return;
+
+        const rl = this.readline_instance;
+
+        this.printHelp();
 
         rl.on('line', async (input) => {
             switch (input) {
                 case '/stats':
                     await this.verifyDag();
                     break;
+                case '/help':
+                    await this.printHelp();
+                    break;
                 case '/exit':
                     console.log('Exiting...');
                     rl.close();
@@ -925,6 +960,8 @@ export class Peer extends ReadyResource {
                             await tx(input, this);
                         } else if (input.startsWith('/add_indexer') || input.startsWith('/add_writer')) {
                             await addWriter(input, this);
+                        } else if (input.startsWith('/remove_writer')) {
+                            await removeWriter(input, this);
                         } else if (input.startsWith('/add_admin')) {
                             await addAdmin(input, this);
                         } else if (input.startsWith('/update_admin')) {
@@ -949,6 +986,8 @@ export class Peer extends ReadyResource {
                             await enableWhitelist(input, this);
                         } else if (input.startsWith('/set_whitelist_status')) {
                             await setWhitelistStatus(input, this);
+                        } else if (input.startsWith('/join_validator')) {
+                            await joinValidator(input, this);
                         } else {
                             await this.protocol_instance.customCommand(input);
                         }

package/src/protocol.js

@@ -17,8 +17,6 @@ class Protocol{
         this.safeClone = safeClone;
         this.prepared_transactions_content = {};
         this.features = {};
-        this.sim = false;
-        this.surrogate_tx = null;
     }
 
     featMaxBytes(){
@@ -102,31 +100,27 @@ class Protocol{
         return await this.peer.createHash('sha256', await this.peer.createHash('sha256', tx));
     }
 
-    async simulateTransaction(obj){
+    async simulateTransaction(validator_pub_key, obj, surrogate = null){
         const storage = new SimStorage(this.peer);
-        const null_hex = '0000000000000000000000000000000000000000000000000000000000000000';
         let nonce = this.generateNonce();
         const content_hash = await this.peer.createHash('sha256', this.safeJsonStringify(obj));
-        let tx = await this.generateTx(this.peer.bootstrap, this.peer.msb.bootstrap, null_hex,
-            this.peer.writerLocalKey, this.surrogate_tx !== null ? this.surrogate_tx.address : this.peer.wallet.publicKey, content_hash, nonce);
+        let tx = await this.generateTx(this.peer.bootstrap, this.peer.msb.bootstrap, validator_pub_key,
+            this.peer.writerLocalKey, surrogate !== null ? surrogate.address : this.peer.wallet.publicKey, content_hash, nonce);
         const op = {
             type : 'tx',
             key : tx,
             value : {
                 dispatch : obj,
                 value : {
-                    ipk : this.surrogate_tx !== null ? this.surrogate_tx.address : this.peer.wallet.publicKey,
-                    wp : null_hex
+                    ipk : surrogate !== null ? surrogate.address : this.peer.wallet.publicKey,
+                    wp : validator_pub_key
                 }
             }
         }
         return await this.peer.contract_instance.execute(op, storage);
     }
 
-    async broadcastTransaction(validator_pub_key, obj){
-        if(true === this.sim) {
-            return await this.simulateTransaction(obj);
-        }
+    async broadcastTransaction(validator_pub_key, obj, sim = false, surrogate = null){
         if(this.peer.validator_stream !== null &&
             this.peer.wallet.publicKey !== null &&
             this.peer.wallet.secretKey !== null &&
@@ -134,15 +128,18 @@ class Protocol{
             obj.type !== undefined &&
             obj.value !== undefined)
         {
+            if(true === sim) {
+                return await this.simulateTransaction(validator_pub_key, obj, surrogate);
+            }
 
             let tx, signature, nonce, publicKey;
             const content_hash = await this.peer.createHash('sha256', this.safeJsonStringify(obj));
 
-            if(this.surrogate_tx !== null) {
-                nonce = this.surrogate_tx.nonce;
-                tx = this.surrogate_tx.tx;
-                signature = this.surrogate_tx.signature;
-                publicKey = this.surrogate_tx.address;
+            if(surrogate !== null) {
+                nonce = surrogate.nonce;
+                tx = surrogate.tx;
+                signature = surrogate.signature;
+                publicKey = surrogate.address;
             } else {
                 nonce = this.generateNonce();
                 tx = await this.generateTx(this.peer.bootstrap, this.peer.msb.bootstrap, validator_pub_key,
@@ -151,7 +148,7 @@ class Protocol{
                 publicKey = this.peer.wallet.publicKey;
             }
 
-            this.peer.emit('tx', {
+            const _tx = {
                 op: 'pre-tx',
                 tx: tx,
                 is: signature,
@@ -162,12 +159,14 @@ class Protocol{
                 in : nonce,
                 bs : this.peer.bootstrap,
                 mbs : this.peer.msb.bootstrap
-            });
-            this.prepared_transactions_content[tx] = { dispatch : obj, ipk : publicKey };
+            };
+
+            this.peer.emit('tx', _tx);
+            this.prepared_transactions_content[tx] = { dispatch : obj, ipk : publicKey, validator : validator_pub_key };
+            return _tx;
         } else {
             throw Error('broadcastTransaction(writer, obj): Cannot prepare transaction. Please make sure inputs and local writer are set.');
         }
-        return true;
     }
 
     async tokenizeInput(input){
@@ -190,15 +189,16 @@ class Protocol{
         return null;
     }
 
-    async tx(subject){
+    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) {
-            return await this.broadcastTransaction(subject.validator,{
+            return await this.broadcastTransaction(this.peer.validator,{
                 type : obj.type,
                 value : obj.value
-            });
+            }, sim, surrogate);
         }
-        return new Error('HyperMallProtocol::tx(): command not found.');
+        throw new Error('HyperMallProtocol::tx(): command not found.');
     }
 
     async customCommand(input){ }