trac-peer 0.1.43 → 0.1.44

package/package.json

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

package/src/api.js

@@ -1,6 +1,146 @@
+import b4a from "b4a";
+import {jsonStringify} from "./functions.js";
+
 export class ProtocolApi{
-    constructor(options = {}) {
-        this.peer = options.peer || null;
+    constructor(peer, options = {}) {
+        this.peer = peer;
+        this.api_tx_exposed = options.api_tx_exposed === true;
+        this.api_msg_exposed = options.api_msg_exposed === true;
+        this.options = options;
+    }
+
+    getPeerValidatorAddress(){
+        return this.peer.validator;
+    }
+
+    getPeerBootstrap(){
+        return this.peer.bootstrap;
+    }
+
+    getPeerMsbBootstrap(){
+        return this.peer.msb.bootstrap;
+    }
+
+    getPeerWriterKey(){
+        return this.peer.writerLocalKey;
+    }
+
+    generateNonce(){
+        return this.peer.protocol_instance.generateNonce();
+    }
+
+    async 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(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');
+        for(let i = 0; i < attachments.length; i++){
+            if(typeof attachments[i] !== 'string') throw new Error('Attachment at index ' + i + ' is not a string.');
+        }
+        const prepared = {
+            dispatch : {
+                type : 'msg',
+                msg: msg,
+                address : address,
+                attachments : attachments,
+                deleted_by : null,
+                reply_to : reply_to !== null ? parseInt(reply_to) : null,
+                pinned : false,
+                pin_id : null
+            }};
+        if(b4a.byteLength(jsonStringify(prepared)) > this.peer.protocol_instance.msgMaxBytes()) throw new Error('Message too large.');
+        return prepared;
+    }
+
+    async post(prepared_message, signature, nonce){
+        if(false === this.api_msg_exposed) throw new Error('Posting messages not exposed in API.');
+        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 ||
+            prepared_message.dispatch.msg === undefined || prepared_message.dispatch.address === undefined ||
+            prepared_message.dispatch.attachments === undefined || prepared_message.dispatch.deleted_by === undefined ||
+            prepared_message.dispatch.reply_to === undefined || prepared_message.dispatch.pinned === undefined ||
+            prepared_message.dispatch.pin_id === undefined) throw new Error('Invalid prepared message.');
+        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(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++){
+            if(typeof prepared_message.dispatch.attachments[i] !== 'string') throw new Error('Attachment at index ' + i + ' is not a string.');
+        }
+        if(prepared_message.dispatch.deleted_by !== null) throw new Error('deleted_by must be null');
+        if(prepared_message.dispatch.reply_to !== null && isNaN(parseInt(prepared_message.dispatch.reply_to))) throw new Error('Reply to not a number.');
+        if(prepared_message.dispatch.pinned !== false) throw new Error('pinned must be false');
+        if(prepared_message.dispatch.pin_id !== null) throw new Error('pin_id must be null');
+        const verified = this.peer.wallet.verify(signature, JSON.stringify(prepared_message) + nonce, prepared_message.dispatch.address);
+        if(false === verified) throw new Error('Invalid signature. Please sign your prepared message.');
+        await this.peer.base.append({type: 'msg', value: prepared_message, hash : signature, nonce: nonce });
+    }
+
+    async generateTx(address, command_hash, nonce) {
+        return await this.peer.protocol_instance.generateTx(this.getPeerBootstrap(),
+            this.getPeerMsbBootstrap(), this.getPeerValidatorAddress(), this.getPeerWriterKey(),
+            address, command_hash, nonce);
+    }
+
+    async prepareTxCommand(command){
+        return await this.peer.protocol_instance.mapTxCommand(command);
+    }
+
+    /**
+     * To pass a TX, an ed25519 signature has to be provided over the given tx + nonce.
+     *
+     * Signing steps:
+     * let nonce = api.generateNonce()
+     * let tx = api.generateTx(address, sha256(JSON.stringify(api.prepareTxCommand(command))), nonce)
+     * let sig = your_sign_lib.sign(tx + nonce, address)
+     * api.tx(tx, api.prepareTxCommand(command), address, sig, nonce)
+     *
+     * @param tx
+     * @param prepared_command
+     * @param address
+     * @param signature
+     * @param nonce
+     * @param sim
+     * @returns {Promise<boolean>}
+     */
+    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(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 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.');
+        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 };
+        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);
+        } catch(e){ console.log(e) }
+        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;
     }
 
     async getAdmin(signed = true){

package/src/functions.js

@@ -332,6 +332,7 @@ export async function tx(input, peer){
     let res = 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;
         }
         res = await peer.protocol_instance.tx(splitted);

package/src/index.js

@@ -114,7 +114,6 @@ export class Peer extends ReadyResource {
                             post_tx.value.ch === content_hash &&
                             _this.wallet.verify(post_tx.value.ws, post_tx.value.tx + post_tx.value.wn, op.value.wp) &&
                             _this.wallet.verify(post_tx.value.is, post_tx.value.tx + post_tx.value.in, op.value.ipk) &&
-                            _this.wallet.verify(op.value.hash, post_tx.value.tx + post_tx.value.ch + op.value.nonce, post_tx.value.ipk) &&
                             post_tx.value.tx === await _this.protocol_instance.generateTx(
                                 _this.bootstrap, _this.msb.bootstrap,
                                 post_tx.value.wp, post_tx.value.i, post_tx.value.ipk,
@@ -493,7 +492,7 @@ export class Peer extends ReadyResource {
         if(this.validator_stream === null) return;
         let _msg = safeClone(msg);
         if(_msg['ts'] !== undefined) delete _msg['ts'];
-        await this.validator_stream.send(b4a.from(jsonStringify(_msg)));
+        try{ await this.validator_stream.send(b4a.from(jsonStringify(_msg))); } catch(e){ }
     }
 
     async getValidatorWriterKey(address){
@@ -554,10 +553,7 @@ export class Peer extends ReadyResource {
 
     async initContract(){
         this.init_contract_starting = true;
-        this.protocol_instance = new this.protocol({
-            peer : this,
-            base : this.base
-        });
+        this.protocol_instance = new this.protocol(this, this.base, this.options);
         await this.protocol_instance.extendApi();
         this.contract_instance = new this.contract(this.protocol_instance);
     }
@@ -651,12 +647,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];
+                    msb_tx['dispatch'] = this.protocol_instance.prepared_transactions_content[tx].dispatch;
                     msb_tx['msbsl'] = msbsl;
-                    msb_tx['ipk'] = this.wallet.publicKey;
+                    msb_tx['ipk'] = this.protocol_instance.prepared_transactions_content[tx].ipk;
                     msb_tx['wp'] = this.validator;
-                    msb_tx['nonce'] = this.protocol_instance.generateNonce();
-                    msb_tx['hash'] = this.wallet.sign(tx + await this.createHash('sha256', jsonStringify(msb_tx['dispatch'])) + msb_tx['nonce']);
                     delete this.tx_pool[tx];
                     delete this.protocol_instance.prepared_transactions_content[tx];
                     await this.base.append({ type: 'tx', key: tx, value: msb_tx });
@@ -706,7 +700,7 @@ export class Peer extends ReadyResource {
                 secretKey: b4a.from(this.wallet.secretKey, 'hex')
             };
 
-            this.swarm = new Hyperswarm({ keyPair, bootstrap: this.dhtBootstrap });
+            this.swarm = new Hyperswarm({ keyPair, randomPunchInterval: 500, bootstrap: this.dhtBootstrap });
             this.dhtNode = this.swarm.dht;
 
             console.log(`Writer key: ${this.writerLocalKey}`)

package/src/protocol.js

@@ -3,10 +3,10 @@ import {ProtocolApi} from './api.js';
 import Wallet from 'trac-wallet';
 
 class Protocol{
-    constructor(options = {}) {
-        this.api = new ProtocolApi({ peer : options.peer });
-        this.base = options.base || null;
-        this.peer = options.peer || null;
+    constructor(peer, base, options = {}) {
+        this.api = new ProtocolApi(peer, options);
+        this.base = base;
+        this.peer = peer;
         this.options = options;
         this.input = null;
         this.tokenized_input = null;
@@ -15,10 +15,10 @@ class Protocol{
         this.safeJsonStringify = jsonStringify;
         this.safeJsonParse = jsonParse;
         this.safeClone = safeClone;
-        this.nonce = 0;
         this.prepared_transactions_content = {};
         this.features = {};
         this.sim = false;
+        this.surrogate_tx = false;
     }
 
     featMaxBytes(){
@@ -91,10 +91,10 @@ class Protocol{
         this.features[key] = feature;
     }
 
-    async generateTx(bootstrap, msb_bootstrap, validator_writer_key, local_writer_key, local_public_key, content_hash, nonce){
+    async generateTx(bootstrap, msb_bootstrap, validator_public_key, local_writer_key, local_public_key, content_hash, nonce){
         let tx = bootstrap + '-' +
             msb_bootstrap + '-' +
-            validator_writer_key + '-' +
+            validator_public_key + '-' +
             local_writer_key + '-' +
             local_public_key + '-' +
             content_hash + '-' +
@@ -106,16 +106,16 @@ class Protocol{
         const storage = new SimStorage(this.peer);
         const null_hex = '0000000000000000000000000000000000000000000000000000000000000000';
         let nonce = this.generateNonce();
-        const content_hash = await this.peer.createHash('sha256', JSON.stringify(obj));
+        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.peer.wallet.publicKey, content_hash, nonce);
+            this.peer.writerLocalKey, this.surrogate_tx !== null ? this.surrogate_tx.address : this.peer.wallet.publicKey, content_hash, nonce);
         const op = {
             type : 'tx',
             key : tx,
             value : {
                 dispatch : obj,
                 value : {
-                    ipk : this.peer.wallet.publicKey,
+                    ipk : this.surrogate_tx !== null ? this.surrogate_tx.address : this.peer.wallet.publicKey,
                     wp : null_hex
                 }
             }
@@ -134,24 +134,36 @@ class Protocol{
             obj.type !== undefined &&
             obj.value !== undefined)
         {
-            this.nonce = this.generateNonce();
-            const content_hash = await this.peer.createHash('sha256', JSON.stringify(obj));
-            let tx = await this.generateTx(this.peer.bootstrap, this.peer.msb.bootstrap, validator_pub_key,
-                this.peer.writerLocalKey, this.peer.wallet.publicKey, content_hash, this.nonce);
-            const signature = this.peer.wallet.sign(tx + this.nonce);
+
+            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;
+            } else {
+                nonce = this.generateNonce();
+                tx = await this.generateTx(this.peer.bootstrap, this.peer.msb.bootstrap, validator_pub_key,
+                    this.peer.writerLocalKey, this.peer.wallet.publicKey, content_hash, nonce);
+                signature = this.peer.wallet.sign(tx + nonce);
+                publicKey = this.peer.wallet.publicKey;
+            }
+
             this.peer.emit('tx', {
                 op: 'pre-tx',
                 tx: tx,
                 is: signature,
                 wp : validator_pub_key,
                 i: this.peer.writerLocalKey,
-                ipk: this.peer.wallet.publicKey,
+                ipk: publicKey,
                 ch : content_hash,
-                in : this.nonce,
+                in : nonce,
                 bs : this.peer.bootstrap,
                 mbs : this.peer.msb.bootstrap
             });
-            this.prepared_transactions_content[tx] = obj;
+            this.prepared_transactions_content[tx] = { dispatch : obj, ipk : publicKey };
         } else {
             throw Error('broadcastTransaction(writer, obj): Cannot prepare transaction. Please make sure inputs and local writer are set.');
         }
@@ -174,7 +186,20 @@ class Protocol{
         return null;
     }
 
-    async tx(subject){ }
+    async mapTxCommand(command){
+        return null;
+    }
+
+    async tx(subject){
+        const obj = this.mapTxCommand(subject.command);
+        if(null !== obj) {
+            return await this.broadcastTransaction(subject.validator,{
+                type : obj.type,
+                value : obj.value
+            });
+        }
+        return new Error('HyperMallProtocol::tx(): command not found.');
+    }
 
     async customCommand(input){ }