godprotocol 1.0.7991 → 1.1.1

package/framer.js

@@ -1,65 +1,137 @@
 import Frame from "./Objects/Frame";
 
-const framer = (initiator) => {
-  let frame = new Frame({
-    Opcodes: {
-      add: null,
-      equal: null,
-      multiply: null,
-      subtract: null,
-      divide: null,
-      exp: null,
-      equal: null,
-      not_equal: null,
-      greater_than: null,
-      less_than: null,
-      gte: null,
-      lte: null,
+/* 
+./Opcodes
+./add
+;
+./equal
+;
+;
 
-      send: null,
-      readonly: null,
-      socket_send: null,
+./CONSTANTS
+./overload
+>__add__ {type:'string'}
+;
+;
 
-      jmp: null,
-      jmp_if: null,
-      hold: null,
+*/
+let obj = {
+  Opcodes: {
+    add: null,
+    equal: null,
+    multiply: null,
+    subtract: null,
+    divide: null,
+    exp: null,
+    equal: null,
 
-      stdout: null,
-      stdin: null,
+    send: null,
+    readonly: null,
+    socket_send: null,
 
-      run: null,
-      load: null,
-      parse: null,
-      create_account: null,
+    jmp: null,
+
+    stdout: null,
+    stdin: null,
+
+    run: null,
+    load: null,
+    parse: null,
+    create_account: null,
+  },
+  Datatypes: {
+    Number: null,
+    String: null,
+    Twain: null,
+    Array: null,
+    Void: null,
+    Boolean: null,
+  },
+  Objects: {
+    Blockchain: {
+      Chain: null,
+      Block: null,
     },
-    Datatypes: {
-      Number: null,
-      String: null,
-      Twain: null,
-      Array: null,
+    Folder: {
+      active_file: null,
+      folder: null,
+      file: null,
     },
-    Objects: {
-      Blockchain: {
-        Chain: null,
-        Block: null,
-      },
-      Folder: {
-        active_file: null,
-        folder: null,
-        file: null,
-      },
-      File: {
-        row: null,
-        parse: null,
-        column: null,
-        write: null,
-      },
+    File: {
+      row: null,
+      parse: null,
+      column: null,
+      write: null,
+    },
+  },
+  CONSTANTS:{
+    overload: {
+      __add__: {__type:'twain', value: {type:'string', static_value:'__add__'}},
+      __multiply__: {__type:'twain', value: {type:'string', static_value:'__multiply__'}},
+      __subtract__: {__type:'twain', value: {type:'string', static_value:'__subtract__'}},
+      __divide__: {__type:'twain', value: {type:'string', static_value:'__divide__'}},
+      __exp__: {__type:'twain', value: {type:'string', static_value:'__exp__'}},
+      __equal__: {__type:'twain', value: {type:'string', static_value:'__equal__'}},
+      // __not_equal__: {__type:'twain', value: {type:'string', static_value:'__not_equal__'}},
+      __lt__: {__type:'twain', value: {type:'string', static_value:'__lt__'}},
+      __lte__: {__type:'twain', value: {type:'string', static_value:'__lte__'}},
+      __gt__: {__type:'twain', value: {type:'string', static_value:'__gt__'}},
+      __gte__: {__type:'twain', value: {type:'string', static_value:'__gte__'}},
     },
-  });
-  frame.to_instruction();
-  let instructions = frame.flatten_instructions();
+    types: {
+      instance: {__type: 'twain', value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/instance`, static_value: 'instance'}},
+      function: {__type:'string', value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/function`, static_value: 'function'}},
+      boolean: {__type:'string',value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/boolean`, static_value: 'boolean'}},
+      array: {__type:'string',value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/array`, static_value: 'array'}},
+      twain: {__type:'string',value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/twain`, static_value: 'twain'}},
+      number: { __type:'string', value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/number`, static_value: 'number'}},
+      string: {__type:'string', value: {type:'string', __address__:`Accounts/initiator/CONSTANTS/types/string`, static_value: 'string'}},
+    }
+  },
+};
+
+const framer = (initiator, cb) => {
+  let frame = new Frame(obj);
+  frame.account = initiator;
+  let start = Date.now();
+
+  let callback =  (blks) => {
+    console.log(
+      `Account:${initiator.name} is ready in ${Date.now() - start}ms.`
+    );
+
+    initiator.initiated = true
+
+    cb && cb(blks)
+  }
+
+  /* Quick due diligence */
+  let oracle = initiator.manager.oracle,
+   obj_hash = oracle.hash(obj), 
+   globals = oracle.gds.folder('globals'),
+   quick_hashes = globals.readone({title:'quick_hashes'});
 
-  initiator.load({ program: { instructions } });
+  if(!quick_hashes){
+    quick_hashes = {title:"quick_hashes"}
+    let res = globals.write(quick_hashes)
+    quick_hashes._id = res._id
+    quick_hashes.created = res.created
+  }
+  if(quick_hashes.frame === obj_hash){
+    setTimeout(() => {
+      callback([])  
+    }, 0);
+  }else {
+    frame.to_instruction();
+    let instructions = frame.flatten_instructions();
+  
+    initiator.run({
+      payload: { instructions, physical_address: initiator.physical_address },
+      callback,
+    });
+    globals.update({_id:quick_hashes._id}, {frame: obj_hash})
+  }
 };
 
 export default framer;
+export { obj };

package/opcodes/add.js

@@ -4,12 +4,13 @@ let ops = [
   { name: "subtract", sign: "-" },
   { name: "divide", sign: "/" },
   { name: "exp", sign: "**" },
-  { name: "equal", sign: "==" },
-  { name: "not_equal", sign: "!=" },
-  { name: "greater_than", sign: ">" },
-  { name: "less_than", sign: "<" },
-  { name: "gte", sign: ">=" },
-  { name: "lte", sign: "<=" },
+  { name: "mod", sign: "%" },
+  { name: "equal", sign: "==", jmp:true},
+  { name: "not_equal", sign: "!=", jmp:true},
+  { name: "gt", sign: ">",jmp:true },
+  { name: "lt", sign: "<", jmp:true },
+  { name: "lte", sign: "<=" , jmp:true},
+  { name: "gte", sign: ">=", jmp:true },
 ];
 
 export { ops };

package/opcodes/datatypes.js

@@ -0,0 +1,3 @@
+const str = (args, vm, meta)=>{
+  
+}

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]);
+
+  console.log(...logs)
 };
 
 export { stdout };

package/opcodes.js

@@ -1,37 +1,94 @@
 // 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) => {
+    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 result = eval(`${args.op0} ${op.sign} ${args.op1}`);
+        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'})
+        }
+
+        let result = eval(`val0 ${op.sign} val1`);
+
+        if (op.jmp) {
+          result = !!result;
+          account.vm.flags[op.name] = result;
+        }
+        
         return result;
       } catch (e) {
-        console.log(e.message);
+        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.1",
   "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);