godprotocol 1.0.7991 → 1.1.0

package/opcodes/indices.js

@@ -0,0 +1,82 @@
+const getter = (args) => {
+  let base = args.op0;
+
+  // console.log(args, 'getter.args')
+  if(!base)return base === ''?null: base
+  
+  if (typeof base === "number") return base;
+
+  if (typeof base === "string") return base[args.op1];
+
+  if (Array.isArray(base)) return base.slice(args.op1)[0];
+
+  return base[args.op1];
+};
+
+const setter = (args, vm) => {
+  let base = args.op0;
+  
+  if (typeof base === "number") return base;
+
+  if(vm.is_readonly(args))return;
+
+  if (typeof base === "string") {
+    if (args.op1 ===0 && base.length <= 1){
+      base = `${args.op2}${base}`
+    } else if (args.op1 ===-1){
+      base = `${base}${args.op2}`
+    } else base = `${base.slice(0, args.op1)}${args.op2}${base.slice(args.op1)}`;
+  } else {
+    if (Array.isArray(base)) {
+      if (args.op1<0|| args.op1 == null || args.op1 >= base.length) base.push(args.op2);
+      else base[args.op1] = args.op2;
+    } else base[args.op1] = args.op2;
+  }
+
+  return base;
+};
+
+const del = (args, vm)=>{
+  let base = args.op0
+
+  if (typeof base === 'number')return;
+
+  if(vm.is_readonly(args))return;
+
+  if (typeof base === 'string'){
+    if (args.op1 === 0){
+      base = base.slice(1)
+    }else if (args === -1){
+      base = base.slice(0, -1)
+    }else {
+      base = `${base.slice(0, args.op1)}${base.slice(args.op1+1)}`
+    }
+  }
+  else {
+    if (Array.isArray(base)){
+      base.splice(args.op1, 1)
+    }else delete base[args.op1]
+  }
+  return base;
+}
+
+const slice = (args, vm)=>{
+  let obj = args.op0
+  let indexes = args.op1
+  if (!Array.isArray(indexes))return vm.stderr(`Indexes must be an array`)
+
+  let res;
+
+  if (typeof obj === 'number' ||!obj)return null;
+
+  if (typeof obj === 'object' && !Array.isArray(obj)){
+    res = {}
+    indexes.map(i=>{
+      res[i] = obj[i]
+    })
+  }else res = obj.slice(indexes[0], indexes[1])
+
+  return res;
+}
+
+export { setter, getter , del, slice};

package/opcodes/jmp.js

@@ -1,15 +1,16 @@
-const jmp = (args, vm) => {
-  vm.account.manager.tracker[vm.mgr_index].pointer += args.index;
-};
+const jmp = (args, vm, meta) => {
+  meta = meta || {};
+  let { flag, inverse } = meta;
 
-const jmp_if = (args, vm) => {
-  if (args.passed)
-    vm.account.manager.tracker[vm.mgr_index].pointer += args.index;
-};
+  let condition;
+  if (flag) condition = vm.flags[flag];
+  if (inverse) condition = !!!condition;
+
+  if ((condition || !flag) && typeof args.op0 === "number") {
+    vm.track.pointer = args.op0;
 
-const hold = (args, vm) => {
-  let track = vm.account.manager.tracker[vm.mgr_index];
-  track.hold = args.hold;
+    vm.pop_context()
+  }
 };
 
-export { jmp, jmp_if, hold };
+export { jmp };

package/opcodes/std.js

@@ -1,7 +1,12 @@
-const stdout = (args) => {
+const stdout = (args, vm) => {
   if (!args) return;
 
-  for (let v in args) console.log(args[v]);
+ args&& args.op0&& vm.account.stdout.push({ data: args, pid: vm.track.pid });
+
+  let logs = []
+  for (let v in args) logs.push(args[v].static_value == null ? null :args[v].static_value);
+
+  console.log(...logs)
 };
 
 export { stdout };

package/opcodes.js

@@ -1,37 +1,95 @@
 // import { socket_send } from "./Socket";
+import callables from "./callables";
 import { ops } from "./opcodes/add";
-import { hold, jmp, jmp_if } from "./opcodes/jmp";
+import { del, getter, setter, slice } from "./opcodes/indices";
+import { jmp } from "./opcodes/jmp";
 import { stdout } from "./opcodes/std";
 import { post_request } from "./utils/services";
 
 const opcodes = (account) => {
+  callables(account)
+
   let set = account.vm.set;
 
   ops.map((op) => {
-    set(op.name, (args) => {
-      if (!args) return;
+    if(op.jmp){
+      let flag = op.name
+      account.vm.flags[flag] = false
+      
+      set(`jmp_${flag}`, (args, vm) => jmp(args, vm, { flag }));
+      set(`jmp_not_${flag}`, (args, vm) =>
+        jmp(args, vm, { flag, inverse: true })
+    );
+    }
+    
+      set(op.name, (args) => {
+        if (!args) return;
+        try {
+          let {op0, op1}=args;
+          
+          let type0 = op0.type
+          let type1 = op1.type
+
+          let val0 = op0.static_value;
+          let val1 = op1.static_value;
+
+          if(op.name ==='divide' && val1 === 0){
+            return account.vm.stderr({name:'Zero_division_error', message: 'Do not divide by zero'})
+          }
 
-      try {
-        let result = eval(`${args.op0} ${op.sign} ${args.op1}`);
+          let result = eval(`val0 ${op.sign} val1`);
 
-        return result;
-      } catch (e) {
-        console.log(e.message);
-      }
-    });
+          if (op.jmp) {
+            result = !!result;
+            account.vm.flags[op.name] = result;
+          }
+          
+          return result;
+        } catch (e) {
+          console.log("opcodes: ", e.message);
+          console.log(e)
+        }
+      });
   });
 
-  set("hold", hold);
+  Object.keys(account.vm.flags).map((flag) => {
+    set(`jmp_${flag}`, (args, vm) => jmp(args, vm, { flag }));
+    set(`jmp_not_${flag}`, (args, vm) =>
+      jmp(args, vm, { flag, inverse: true })
+    );
+  });
   set("jmp", jmp);
-  set("jmp_if", jmp_if);
+
+  // Indices
+  set("setter", setter);
+  set("getter", getter);
+  set("del", del);
+  set("slice", slice);
 
   set("send", (data) => post_request(data, account.vm.stdin));
   // set("socket_send", socket_send);
 
   set("stdout", stdout);
+  set("stdin",args=>account. vm.stdin(args&&args.op0));
+
+  /* Aliases */
+  set('quit', account.vm.quit)
+  set('exit', account.vm.quit)
+  
+  set('ret', arg=>account.vm.quit(arg, 'ret'))
+  
+  set('exec', account.vm.exec)
+
+  set('config', account.vm.set_config)
+
+  set("add_server", (args) => account.add_server(args && args.op0));
+
+  ["run", "load", "parse"].map((op) =>
+    set(op, (arg) => arg && arg.op0 && account.manager.endpoint(op, arg && arg.op0))
+  );
 
-  ["run", "load", "parse", "create_account"].map((op) =>
-    set(op, (arg) => arg && arg.op0 && account[op](arg && arg.op0))
+  set("add_account", (arg) =>
+   account. manager.add_account({ ...arg.op0, string: true })
   );
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.0.7991",
+  "version": "1.1.0",
   "description": "A data mediator.",
   "main": "Index.js",
   "types": "types/index.d.ts",
@@ -22,12 +22,12 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/immanuel-savvy/godprotocol.git"
+    "url": "git+https://github.com/godprotocol4/godprotocol.git"
   },
   "bugs": {
-    "url": "https://github.com/immanuel-savvy/godprotocol/issues"
+    "url": "https://github.com/godprotocol4/godprotocol/issues"
   },
-  "homepage": "https://github.com/immanuel-savvy/godprotocol#readme",
+  "homepage": "https://github.com/godprotocol4/godprotocol#readme",
   "keywords": [
     "web 4.0",
     "framework",
@@ -45,7 +45,8 @@
   "dependencies": {
     "crypto": "^1.0.1",
     "elliptic": "^6.5.5",
-    "fs": "^0.0.1-security"
+    "fs": "^0.0.1-security",
+    "generalised-datastore": "^2.0.112"
   },
   "publishConfig": {
     "ignore": [

package/readme.md

@@ -116,7 +116,7 @@ Type `method`
 |              | string   | `account`          | Account instance to execute the instructions in.                                                                                                                                                          |
 | `cb`         | function |                    | A function that is called with the blocks mined during the execution.                                                                                                                                     |
 
-See the [package source](https://github.com/immanuel-savvy/godprotocol.git) for more details.
+See the [package source](https://github.com/godprotocol4/GodProtocol) for more details.
 
 [npm-url]: https://npmjs.org/package/godprotocol
 [downloads-url]: https://npmjs.org/package/godprotocol

package/starter_scripts/constants.seq

@@ -0,0 +1,11 @@
+@/CONSTANTS
+./types
+>instance 'instance'
+>function 'function'
+>boolean 'boolean'
+>number 'number'
+>string 'string'
+>array 'array'
+>twain 'twain'
+;
+;

package/utils/create_server.js

@@ -1,28 +1,21 @@
 import http from "http";
 import { is_port_available } from "./functions";
-import { initiator } from "../Index";
 
 let PORT = Number(process.env.PORT) || 1408;
 
 const cb = (res, data) => {
   if (typeof data !== "string") data = JSON.stringify(data);
 
-  res(data);
+  res.end(data);
 };
 
 let extensions = new Object();
 
 const extension = (route, handler) => {
-  let handlers = extensions[route];
-  if (!handlers) {
-    handlers = new Array();
-    extensions[route] = handlers;
-  }
-
-  handlers.push(handler);
+  extensions[route] = handler;
 };
 
-const handle_routes = (req, res, app) => {
+const handle_routes = (req, res, app, manager) => {
   let data = "";
 
   let is_in_default_routes = [
@@ -38,34 +31,45 @@ const handle_routes = (req, res, app) => {
     });
 
     req.on("end", () => {
+      if (req.method === 'GET'){
+        console.log(req.url)
+        if(req.url === '/' ){
+          res.writeHead(404, { "Content-Type": "text/html" });
+          res.end(`<h1>God Protocol</h1>`);
+        }
+          else if(req.url.startsWith('/Accounts') ){
+          manager.handle_route({req, res});
+        }
+
+        return;
+      }
       try {
         data = JSON.parse(data);
       } catch (e) {
-        return cb(res.end, { error_message: "Invalid data", error: true });
+        return cb(res, {
+          error_message: "Invalid data",
+          url: req.url,
+          error: true,
+        });
       }
 
+      
       if (req.url === "/create_account") {
-        let account = initiator.create_account(data);
-        res.end(account.stringify(true));
+        let account = manager.add_account(null, { ...data, string: true });
+
+        res.end(account);
       } else if (["run", "load", "parse"].includes(req.url.slice(1))) {
-        let payload = {
-          ...data,
-          callback: (datagram) => cb(res.end, datagram),
-        };
-        initiator.endpoint(req.url.slice(1), payload);
+        manager.endpoint(req.url.slice(1), payload, (datagram) =>
+          cb(res, datagram)
+        );
       } else {
-        let extension = extensions[req.url.slice(1)];
-
-        extension &&
-          extension.map((ex) => {
-            typeof ex === "function" && ex(data, { req, res });
-          });
+        manager.handle_route({req,res, data})
       }
     });
 
     req.on("error", (e) => {
-      res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ status: "error", message: e.message }));
+      // res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ status: "error", error_message: e.message }));
     });
   } else {
     app && app(req, res);
@@ -88,10 +92,13 @@ const create_server = async (app, settings) => {
   }
   PORT = port;
 
-  let server = http.createServer((req, res) => handle_routes(req, res, app));
+  let server = http.createServer((req, res) =>
+    handle_routes(req, res, app, settings.manager)
+  );
 
   server.listen(port, () => {
     console.log(`\n...GOD PROTOCOL RUNNING :${port}`);
+    settings.manager.add_server({ ...settings.server_details, port: PORT });
   });
 };
 

package/utils/hash.js

@@ -1,7 +1,7 @@
 const crypto = require("crypto");
 
-const hash = (data) => {
-  let hash = crypto.createHash("sha256");
+const hash = (data, alg) => {
+  let hash = crypto.createHash(alg|| "sha256");
 
   hash.update(data);
 

package/utils/logger.js

@@ -0,0 +1,79 @@
+const blessed = require('blessed');
+
+
+// const screen = blessed.screen({
+//   smartCSR: true,
+//   title:'God Protocol'
+// })
+
+class Logger {
+  constructor() {
+   this.log_boxes= new Array()
+
+//  this.  clock_box = blessed.box({
+//     left: 'left',
+//     width: '100%',
+//     height: 'shrink',
+//     content: '',
+//     tags: true,
+//     border: {
+//       type: 'line'
+//     },
+//     style: {
+//       border: {
+//         fg: 'cyan'
+//       }
+//     }
+//   })
+
+//   screen.append(this.clock_box)
+
+  }
+
+
+
+  log=(data_logger)=> {
+    // this.clock_box.setContent(data_logger())
+    // this.update_log_box_positions()
+  }
+
+
+  update_log_box_positions() {
+    // this.log_boxes.forEach((box, index) => {
+    //   box.top = index;
+    // });
+  
+    // this.clock_box.top = this.log_boxes.length;
+    // screen.render();
+  }
+
+  store_log=(message)=> {
+  //   const logBox = blessed.box({
+  //     top: this.log_boxes.length,
+  //     left: 'left',
+  //     width: '100%',
+  //     height: 3,
+  //     content: message,
+  //     tags: true,
+  //     border: {
+  //       type: 'line'
+  //     },
+  //     style: {
+  //       border: {
+  //         fg: 'green'
+  //       }
+  //     }
+  //   });
+  
+  //   screen.append(logBox);
+  //   this.log_boxes.push(logBox);
+  //  this. update_log_box_positions();
+  //   screen.render();
+  // console.log(message)
+  }
+  
+}
+
+
+
+export default Logger;

package/utils/services.js

@@ -12,13 +12,15 @@ const post_request = (payload, cb) => {
   //   },
   // };
 
+  let data = typeof payload.data !== 'string' ? JSON.stringify(payload.data) : payload.data
+  
   let req = http.request(
     {
       ...payload.options,
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "Content-Length": Buffer.byteLength(payload.data),
+        "Content-Length": Buffer.byteLength(data),
       },
     },
     (res) => {
@@ -37,11 +39,11 @@ const post_request = (payload, cb) => {
   );
 
   req.on("error", (e) => {
-    cb(e.message);
+    cb && cb(e.message);
     console.error(`Problem with request: ${e.message}`);
   });
 
-  req.write(payload.data);
+  req.write(data);
 
   req.end();
 };

package/utils/type_coersion.js

@@ -0,0 +1,3 @@
+const type_coersion = (operation, op0, op1)=>{
+  
+}