trac-peer 0.0.63 → 0.0.65

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-peer",
   "main": "src/index.js",
-  "version": "0.0.63",
+  "version": "0.0.65",
   "type": "module",
   "dependencies": {
     "autobase": "7.0.45",

package/src/check.js

@@ -3,23 +3,23 @@ import Validator from 'fastest-validator';
 class Check {
 
     constructor() {
-        this._node = null;
-        this._tx = null;
-        this._post_tx = null;
-        this._msg = null;
-        this._feature = null;
-        this._add_writer = null;
-        this._key = null;
-        this._nick = null;
-        this._mute = null;
-        this._delete_message = null;
-        this._mod = null;
-        this._whitelist_status = null;
-        this._enable_whitelist = null;
         this.validator = new Validator();
+        this._node = this.compileNode();
+        this._tx = this.compileTx();
+        this._post_tx = this.compilePostTx();
+        this._msg = this.compileMsg();
+        this._feature = this.compileFeature();
+        this._add_writer = this.compileAddWriter();
+        this._key = this.compileKey();
+        this._nick = this.compileNick();
+        this._mute = this.compileMute();
+        this._delete_message = this.compileDeleteMessage();
+        this._mod = this.compileMod();
+        this._whitelist_status = this.compileWhitelistStatus();
+        this._enable_whitelist = this.compileEnableWhitelist();
     }
 
-    async compileEnableWhitelist (){
+    compileEnableWhitelist (){
         const schema = {
             nonce: { type : "string", min : 1 },
             hash: { type : "string", hex : null },
@@ -36,14 +36,12 @@ class Check {
         return this.validator.compile(schema);
     }
 
-    async enableWhitelist(op){
-        if(this._enable_whitelist === null) {
-            this._enable_whitelist = await this.compileEnableWhitelist();
-        }
-        return this._enable_whitelist(op);
+    enableWhitelist(op){
+        const res = this._enable_whitelist(op);
+        return res === true ? true : false;
     }
 
-    async compileWhitelistStatus (){
+    compileWhitelistStatus (){
         const schema = {
             nonce: { type : "string", min : 1 },
             hash: { type : "string", hex : null },
@@ -61,14 +59,12 @@ class Check {
         return this.validator.compile(schema);
     }
 
-    async whitelistStatus(op){
-        if(this._whitelist_status === null) {
-            this._whitelist_status = await this.compileWhitelistStatus();
-        }
-        return this._whitelist_status(op);
+    whitelistStatus(op){
+        const res = this._whitelist_status(op);
+        return res === true ? true : false;
     }
 
-    async compileMod (){
+    compileMod (){
         const schema = {
             nonce: { type : "string", min : 1 },
             hash: { type : "string", hex : null },
@@ -86,14 +82,12 @@ class Check {
         return this.validator.compile(schema);
     }
 
-    async mod(op){
-        if(this._mod === null) {
-            this._mod = await this.compileMod();
-        }
-        return this._mod(op);
+    mod(op){
+        const res = this._mod(op);
+        return res === true ? true : false;
     }
 
-    async compileDeleteMessage (){
+    compileDeleteMessage (){
         const schema = {
             nonce: { type : "string", min : 1 },
             hash: { type : "string", hex : null },
@@ -111,14 +105,12 @@ class Check {
         return this.validator.compile(schema);
     }
 
-    async deleteMessage(op){
-        if(this._delete_message === null) {
-            this._delete_message = await this.compileDeleteMessage();
-        }
-        return this._delete_message(op);
+    deleteMessage(op){
+        const res = this._delete_message(op);
+        return res === true ? true : false;
     }
 
-    async compileMute (){
+    compileMute (){
         const schema = {
             nonce: { type : "string", min : 1 },
             hash: { type : "string", hex : null },
@@ -136,14 +128,12 @@ class Check {
         return this.validator.compile(schema);
     }
 
-    async mute(op){
-        if(this._mute === null) {
-            this._mute = await this.compileMute();
-        }
-        return this._mute(op);
+    mute(op){
+        const res = this._mute(op);
+        return res === true ? true : false;
     }
 
-    async compileNick (){
+    compileNick (){
         const schema = {
             nonce: { type : "string", min : 1 },
             hash: { type : "string", hex : null },
@@ -161,33 +151,29 @@ class Check {
         return this.validator.compile(schema);
     }
 
-    async nick(op){
-        if(this._nick === null) {
-            this._nick = await this.compileNick();
-        }
-        return this._nick(op);
+    nick(op){
+        const res = this._nick(op);
+        return res === true ? true : false;
     }
 
-    async compileKey() {
+    compileKey() {
         const schema = {
             key: { type : 'string', hex: null }
         };
         return this.validator.compile(schema);
     }
 
-    async key(op){
-        if(this._key === null) {
-            this._key = await this.compileKey();
-        }
-        return this._key(op);
+    key(op){
+        const res = this._key(op);
+        return res === true ? true : false;
     }
 
-    async setStatus(op){
+    setStatus(op){
         // currently same as addWriter
-        return await this.addWriter(op);
+        return this.addWriter(op);
     }
 
-    async compileAddWriter (){
+    compileAddWriter (){
         const schema = {
             key: { type : "string", hex : null },
             hash : { type : "string", hex : null },
@@ -204,19 +190,17 @@ class Check {
         return this.validator.compile(schema);
     }
 
-    async addIndexer(op){
+    addIndexer(op){
         // currently same as addWriter
-        return await this.addWriter(op);
+        return this.addWriter(op);
     }
 
-    async addWriter(op){
-        if(this._add_writer === null) {
-            this._add_writer = await this.compileAddWriter();
-        }
-        return this._add_writer(op);
+    addWriter(op){
+        const res = this._add_writer(op);
+        return res === true ? true : false;
     }
 
-    async compileFeature (){
+    compileFeature (){
         const schema = {
             key: { type : "string", min : 1 },
             value : {
@@ -232,14 +216,12 @@ class Check {
         return this.validator.compile(schema);
     }
 
-    async feature(op){
-        if(this._feature === null) {
-            this._feature = await this.compileFeature();
-        }
-        return this._feature(op);
+    feature(op){
+        const res = this._feature(op);
+        return res === true ? true : false;
     }
 
-    async compileMsg (){
+    compileMsg (){
         const schema = {
             nonce: { type : "string", min : 1 },
             hash: { type : "string", hex : null },
@@ -258,14 +240,12 @@ class Check {
         return this.validator.compile(schema);
     }
 
-    async msg(op){
-        if(this._msg === null) {
-            this._msg = await this.compileMsg();
-        }
-        return this._msg(op);
+    msg(op){
+        const res = this._msg(op);
+        return res === true ? true : false;
     }
 
-    async compilePostTx() {
+    compilePostTx() {
         const schema = {
             value : {
                 $$type: "object",
@@ -276,14 +256,12 @@ class Check {
         return this.validator.compile(schema);
     }
 
-    async postTx(post_tx){
-        if(this._post_tx === null) {
-            this._post_tx = await this.compilePostTx();
-        }
-        return this._post_tx(post_tx);
+    postTx(post_tx){
+        const res = this._post_tx(post_tx);
+        return res === true ? true : false;
     }
 
-    async compileNode() {
+    compileNode() {
         const schema = {
             from : {
                 $$type: "object",
@@ -297,14 +275,12 @@ class Check {
         return this.validator.compile(schema);
     }
 
-    async node(node){
-        if(this._node === null) {
-            this._node = await this.compileNode();
-        }
-        return this._node(node);
+    node(node){
+        const res = this._node(node);
+        return res === true ? true : false;
     }
 
-    async compileTx() {
+    compileTx() {
         const schema = {
             key: { type : "string", hex : null },
             value : {
@@ -316,11 +292,9 @@ class Check {
         return this.validator.compile(schema);
     }
 
-    async tx(op){
-        if(this._tx === null) {
-            this._tx = await this.compileTx();
-        }
-        return this._tx(op);
+    tx(op){
+        const res = this._tx(op);
+        return res === true ? true : false;
     }
 }
 

package/src/contract.js

@@ -51,15 +51,15 @@ class Contract {
     }
 
     async execute(op, node, storage){
-        if(false === this.enter_execute_schema(op)) return;
+        if(true !== this.enter_execute_schema(op)) return;
 
         this.address = null;
         if(op.type !== 'feature' && op.type !== 'msg'){
             if(false === this.tx_schema(op)) return;
             this.address = op.value.value.ipk;
         } else {
-            if(false === this.address_schema(op)) return;
-            if(op.type === 'feature' && false === this.textkey_schema(op)) return;
+            if(true !== this.address_schema(op)) return;
+            if(op.type === 'feature' && true !== this.textkey_schema(op)) return;
             if(op.type === 'feature') this.is_feature = true;
             if(op.type === 'msg') this.is_message = true;
             this.address = op.value.dispatch.address;

package/src/index.js

@@ -79,7 +79,7 @@ export class Peer extends ReadyResource {
                     if(false === await this.check.node(node)) continue;
                     const op = node.value;
                     if (op.type === 'tx') {
-                        if(false === await this.check.tx(op)) continue;
+                        if(false === this.check.tx(op)) continue;
                         const str_dispatch = jsonStringify(op.value.dispatch);
                         const msb_view_session = _this.msb.base.view.checkout(op.value.msbsl);
                         const post_tx = await msb_view_session.get(op.key);
@@ -87,7 +87,7 @@ export class Peer extends ReadyResource {
                         if(false === await this.check.postTx(post_tx)) continue;
                         if (null !== str_dispatch &&
                             null === await batch.get('tx/'+op.key) &&
-                            op.key === post_tx.value.tx &&
+                            post_tx.value.tx === op.key &&
                             post_tx.value.ch === createHash('sha256').update(str_dispatch).digest('hex')) {
                             await batch.put('tx/'+op.key, op.value);
                             await _this.contract_instance.execute(op, node, batch);
@@ -450,12 +450,13 @@ export class Peer extends ReadyResource {
                     delete this.protocol_instance.prepared_transactions_content[tx];
                     continue;
                 }
-                const view_session = this.msb.base.view.checkout(this.msb.base.view.core.signedLength);
+                const msbsl = this.msb.base.view.core.signedLength;
+                const view_session = this.msb.base.view.checkout(msbsl);
                 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['msbsl'] = this.msb.base.view.core.signedLength;
+                    msb_tx['msbsl'] = msbsl;
                     delete this.tx_pool[tx];
                     delete this.protocol_instance.prepared_transactions_content[tx];
                     await this.base.append({ type: 'tx', key: tx, value: msb_tx });