godprotocol 1.0.842 → 1.1.0

package/opcodes.js

@@ -1,29 +1,55 @@
 // import { socket_send } from "./Socket";
+import callables from "./callables";
 import { ops } from "./opcodes/add";
-import { getter, setter } from "./opcodes/indices";
+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;
-
-      try {
-        let result = eval(`${args.op0} ${op.sign} ${args.op1}`);
-        if (op.sign === "==") {
-          account.vm.flags.equal = !!result;
-          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;
 
-        return result;
-      } catch (e) {
-        console.log(e.message);
-      }
-    });
+          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("opcodes: ", e.message);
+          console.log(e)
+        }
+      });
   });
 
   Object.keys(account.vm.flags).map((flag) => {
@@ -34,24 +60,36 @@ const opcodes = (account) => {
   });
   set("jmp", jmp);
 
+  // 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("hold", (arg) => (vm.track.hold = !!arg.op0));
+  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 && manager.endpoint(op, arg && arg.op0))
+    set(op, (arg) => arg && arg.op0 && account.manager.endpoint(op, arg && arg.op0))
   );
 
   set("add_account", (arg) =>
-    manager.add_account({ ...arg.op0, string: true })
+   account. manager.add_account({ ...arg.op0, string: true })
   );
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.0.842",
+  "version": "1.1.0",
   "description": "A data mediator.",
   "main": "Index.js",
   "types": "types/index.d.ts",
@@ -46,7 +46,7 @@
     "crypto": "^1.0.1",
     "elliptic": "^6.5.5",
     "fs": "^0.0.1-security",
-    "generalised-datastore": "^2.0.13"
+    "generalised-datastore": "^2.0.112"
   },
   "publishConfig": {
     "ignore": [

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,7 +1,7 @@
 import http from "http";
 import { is_port_available } from "./functions";
 
-let PORT = Number(process.env.PORT) || 1409;
+let PORT = Number(process.env.PORT) || 1408;
 
 const cb = (res, data) => {
   if (typeof data !== "string") data = JSON.stringify(data);
@@ -31,6 +31,18 @@ const handle_routes = (req, res, app, manager) => {
     });
 
     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) {
@@ -41,6 +53,7 @@ const handle_routes = (req, res, app, manager) => {
         });
       }
 
+      
       if (req.url === "/create_account") {
         let account = manager.add_account(null, { ...data, string: true });
 
@@ -50,12 +63,7 @@ const handle_routes = (req, res, app, manager) => {
           cb(res, datagram)
         );
       } else {
-        let extension = extensions[req.url.slice(1)];
-
-        if (typeof extension !== "function") {
-          res.writeHead(404, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: true, error_message: "Not Found" }));
-        } else extension(data, { req, res });
+        manager.handle_route({req,res, data})
       }
     });
 

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)=>{
+  
+}

package/utils/vm_utils.js

@@ -0,0 +1,292 @@
+import { generate_random_string } from "generalised-datastore/utils/functions";
+import Executables from "../Executables/executables";
+
+class Vm_utils extends Executables{
+  constructor(){
+    super()
+
+    setTimeout(() => {
+      this.  air_object_paths = new Array(
+      `${this.account.physical_address}/language/natives/datatypes/string/String`,
+      `${this.account.physical_address}/language/natives/datatypes/number/Number`,
+      `${this.account.physical_address}/language/natives/datatypes/twain/Twain`,
+      `${this.account.physical_address}/language/natives/datatypes/array/Array`,
+      `${this.account.physical_address}/language/natives/datatypes/boolean/Boolean`,
+      `${this.account.physical_address}/language/natives/datatypes/void/Void`,
+      `${this.account.physical_address}/language/natives/server/chain/Chain`,
+      `${this.account.physical_address}/language/natives/server/block/Block`,
+      `${this.account.physical_address}/language/natives/server/chain/Chain`,
+    )
+    }, 0);
+
+    this.error_instance_address = "Accounts/initiator/language/natives/errors"
+  
+   this.air_types = new Array('boolean', 'string', 'twain', 'array', 'number', 'void')
+  }
+
+  set_config = (config)=>{
+    config = config.op0;
+    let chain = this.handle_chain(config.__address__);
+    chain.set_obj_config(config)
+  }
+
+  get_context = (index) => {
+    return this.contexts.slice(index == null ? -1 : index)[0];
+  };
+
+  parse_arg = (arg, opcode) => {
+    let context = this.get_context();
+
+    let args = arg.split("/"),
+      i = 0;
+
+    while (args[0] === "..") {
+      i++;
+
+      args.splice(0, 1);
+    }
+
+    i = (i + 1) * -1;
+    context = i ? this.get_context(i) : context;
+
+    arg = args.join("/");
+
+    while (arg.includes("^")) {
+      let blk = context.connections.slice(-1)[0];
+      if (!blk) break;
+      context = blk.chain;
+      let i = arg.indexOf("^");
+      arg = `${arg.slice(0, i)}${arg.slice(i + 1)}`;
+    }
+
+    let is_cursor = opcode === 'cursor'
+    if (arg.startsWith("{*") && is_cursor) {
+      arg = context.explore(arg.slice(2, -1));
+    } else if (arg.startsWith("{") && !is_cursor) {
+      arg = context.explore(arg.slice(1, -1));
+      if (['chain', 'link'].includes(opcode) && arg.includes('/')){
+        arg = this.account.read(arg)
+      }
+    }
+
+    return arg;
+  };
+
+  split_instruction = (instruction) => {
+    let split = instruction.split(" ");
+    let opcode = split[0],
+      args = split.slice(1).join(" ");
+
+    return { opcode, args };
+  };
+
+  handle_chain = (args, context)=>{
+    if (!args) return
+    if(!context) context = this.account.chain
+
+    let web = context.account.manager.web, chain;
+    
+    if (args.includes('/')){
+      chain = web.get(args)||web.split_set(args);
+    } else chain = context.account.add_chain(args, context);
+
+    return chain
+  }
+
+  read_chain = (addr, options)=>{
+    options = options || {}
+    let {no_callable, tell_callable, index} = options, callable;
+
+    if(!addr) return this.stderr(`Physical address cannot be undefined`)
+    let chn = addr.physical_address? addr: this.handle_chain(addr)
+
+    if (!chn)return this.stderr(`Address chain:${addr.physical_address ||addr} not found`)
+
+    let output;
+    if (chn.datapath && !no_callable){
+      output = chn.datapath
+      callable = true;
+    }else {
+      callable = false
+      if (!chn.height) return no_callable?null: this.stderr(`Chain has no height - ${addr.physical_address || addr}`)
+
+      let recent = chn.get_block(index)
+    
+      output = recent.metadata.output;
+      
+      if (!output)return;
+    }
+    output = this.account.read(output)
+
+    return  tell_callable? {output, callable} :output;
+  }
+
+  connect_block = block=>{
+    if(!block){
+      console.log(`Checkengine`)
+      return;
+    }
+    let prev_context = this.get_context(-2);
+    if (prev_context) {
+      if(block.chain.datapath){
+        block.metadata.output = block.datapath
+      }
+      prev_context.pending_children.push(block);
+      prev_context.connections.push(block);
+    }
+  }
+
+  get_type_address =type=>{
+    return this.air_object_paths.find(p=>p.includes(type))
+  }
+
+  parse_composite_content = (content, options)=>{
+    let {item_type, location} = options;
+
+    if (item_type === 'static_object'){
+      for (let c = 0; c< content.length; c++){
+        let cont = content[c]
+        let cont_addr = `${location}_${c}`
+        this.write_chain(cont, cont_addr)
+        content[c] = cont_addr;
+      }
+    }
+
+    return content;
+  }
+
+  air_object = (content, options)=>{
+    let {location, callback, local_address, metadata} = options;
+
+    if (Array.isArray(content)){
+      content=  this.parse_composite_content(content, options)
+    }
+
+    let static_location = `${local_address || location}_${generate_random_string(8, 'alnum')}`
+
+    let statc = this.static_cast(content, static_location)
+    let type = typeof statc === 'string' ? 'void' : statc.type
+
+    this.stdin(statc,()=>  this.exec({
+      executable: this.get_type_address(type), 
+      location,
+      metadata:{callback, ...metadata},
+      arguments: {
+        argc:1,
+        argv:[{position: 0, address: static_location, name:'value'}]
+      }}),
+      {address: static_location}
+    )
+  }
+  
+  id_hash = (data)=>{
+    let res = this.account.manager.oracle.hash(data, 'sha-1')
+    if (!isNaN(Number(res[0]))){
+      res = `_${res}`
+    }
+
+    return res;
+  }
+
+  get_voided_block = ()=>{
+    if(!this.account.initiated)return
+
+    let Void = this.account.get_datatype_chain(`Void`)
+    this.flags.void = true;
+    return Void && Void.get_latest_block()
+  }
+
+  modify_twain = (twa, chain, config)=>{
+
+    if (twa.__index__){
+      if (typeof twa.__index__ === 'number') twa.__index__ = chain.height
+      else twa.__index__[config.name] = chain.height
+    }
+    return twa
+  }
+
+  slice_trace = (s)=>{
+    let s_length = this.stacktrace.length;
+      for(let i=0; i < s_length - s; i++ ) this.pop_context()
+  }
+
+  push_context = context => {
+    this.contexts.push(context)
+    this.stacktrace.push(context.physical_address)
+    // console.log(`>> Current Stack - ${context.physical_address}`)
+  }
+
+  pop_context = () => {
+    let context = this.contexts.pop()
+    let addr = this.stacktrace.pop()
+
+    // console.log(`> Current Stack - ${this.contexts.slice(-1)[0].physical_address}`)
+
+    if(context && context.physical_address !== addr)
+      this.stderr(`Stack missalignment - ${context.physical_address} : ${addr}`)
+  }
+
+
+  run_opcode = (arg_arr, opcode)=>{
+    let circ = this.opcodes[opcode]
+
+    if (!circ)return this.stderr(`Opcode:${opcode} not set`)
+
+    let arg = {}
+    arg_arr.map((a,i)=>{
+      arg[`op${i.toString()}`] = a
+    })
+
+    return circ(arg, this)
+  }
+
+  static_cast = (content, addr)=>{
+    let res_obj = {}
+    let type = typeof content;
+    if(type === 'object' || type === 'undefined'){
+      if(content == null){
+        res_obj = "{'type':'void','static_value':Void,'__address__':'Accounts/initiator/Datatypes/Void'}"
+      }else if (Array.isArray(content)){
+        res_obj = {type:'array', static_value: content}
+      }else res_obj = {type:'twain', static_value: content}
+    }else {
+      res_obj = {type, static_value: content}
+    }
+
+    if (addr && typeof res_obj !== 'string') {
+      res_obj.__address__ = addr
+    }
+    
+    return res_obj
+  }
+
+  is_readonly = (args)=>{
+    if (args.op1.startsWith('__') && args.op1.endsWith('__') && args.op1 !== '__'){
+      let val = args.op0[args.op1]
+      let chn = this.handle_chain(`${val}/.config`)
+      let recent = chn.get_latest_block()
+      let value;
+      if(recent){
+        value = recent.metadata.output;
+        value = this.account.read(value)
+        if (value && !['function', 'class'].includes(value.type)){
+          return this.stderr('Cannot delete `readonly` property')
+        }
+      }
+    }
+  }
+  
+  static_value = (value, blow)=>{
+    if (value && value.__print__){
+      if(this.air_object_paths.includes(value.__classifier__)){
+        value = this.read_chain(value.value)
+      }else if (blow){
+        return
+      }
+    }
+    
+    return value
+  }
+}
+
+export default Vm_utils