godprotocol 1.0.842 → 1.1.0

package/Objects/Filesystem.js

@@ -7,17 +7,19 @@ class Filesystem {
   }
 
   parse_path = (path) => {
-    if (!path || (path && !path.includes("/"))) return path;
+    if (!path || (typeof path === 'string' && (!path.includes("/") || path.includes(' ')))) return path;
 
     return this.read(path);
   };
 
   read = (datapath) => {
     if (!datapath) return null;
-
+    
     let type_folder = this.account.manager.oracle.get(datapath);
 
-    if (!type_folder) return datapath;
+    if (!type_folder){
+      return datapath;
+    }
 
     let content;
     if (type_folder.type === "twain") {
@@ -37,35 +39,78 @@ class Filesystem {
     return content;
   };
 
-  save = (content, chain, just_obj) => {
-    let addr, obj;
+  object_type = (obj, chain)=>{
+    let type = typeof obj
+    if (type === 'object'){
+      if (Array.isArray(obj)) type = 'array'
+      else if (!obj) type = 'void'
+      else type = 'twain'
+    }
 
-    let type = typeof chain === "string" ? chain : this.get_type(chain);
+    if (!chain)return type;
 
-    if (type === "array" || type === "string") {
-      obj = [];
+    type = `${type[0].toUpperCase()}${type.slice(1)}`
+    
+    return this.get_datatype_chain(type)
+  }
 
-      for (let curs in content)
-        obj.splice(Number(curs) || -1, 0, content[curs]);
+  get_datatype_chain = (type)=>{
+    let chain = this.vm.handle_chain(`${this.account.physical_address}/Datatypes/${type}`)
 
-      if (type === "string") obj = obj.join(" ");
-    } else if (type === "twain") {
-      obj = {};
-      for (let curs in content) {
-        obj[curs] = content[curs];
-      }
-    } else if (type === "number") {
-      obj = Number(content["-1"]);
-      if (isNaN(obj)) obj = -1;
-    } else {
-      obj = null;
+    return chain
+  }
+
+  save = (content, chain, options) => {
+    let just_obj, pure;
+    if (typeof options !== 'object'){
+      just_obj = options
+    }else if(options) {
+      just_obj = options.just_obj
+      pure = options.pure
+    }
+    let addr, obj;
+
+    if (!chain){
+      chain = this.object_type(content, true)
     }
 
+    let type = typeof chain === "string" ? chain : this.get_type(chain);
+
+
+    if(!pure){
+      if(typeof content==='string'){
+        if(type!=="string")obj= JSON.parse(content)
+        else obj = content
+      } else{
+        if (type === "array" || type === "string") {
+          obj = [];
+
+          for (let curs in content)
+            obj.splice(Number(curs) || -1, 0, content[curs]);
+
+          if (type === "string") obj = obj.join(" ");
+        } else if (type === "twain") {
+          obj = {};
+          for (let curs in content) {
+            obj[curs] = content[curs];
+          }
+        } else if (type === "number") {
+          obj = Number(content["-1"]);
+          if (isNaN(obj)) obj = 0;
+        }else if (type === 'boolean'){
+          obj = content['-1']
+          obj = obj === 'True' ? true:false
+        } else {
+          obj = null;
+        }
+      }
+    }else obj = content
+    
     if (just_obj) return obj;
 
     addr = `${chain.path}/${hash(JSON.stringify(obj))}`;
     this;
-    if (obj != null) this.manager.oracle.write(addr, obj);
+    if (obj != null || type === 'void') this.manager.oracle.write(addr, obj);
 
     this.manager.oracle.set(addr, { obj, type });
 
@@ -93,13 +138,41 @@ class Filesystem {
     }
   };
 
+  is_datatype=chain=>{
+
+    let type = this.get_type(chain);
+    return !!type
+  }
+
+  stringify_type = (type)=>{
+    let val;
+    switch(type){
+      case 'string':
+        val = ""
+      break;
+      case 'number':
+        val = "0"
+      break;
+      case 'array':
+        val = "[]"
+      break;
+      case 'twain':
+        val = "{}"
+      break;
+      case 'void':
+        val = 'null'
+        break
+      ;
+    }
+    return val
+  }
+
   write = (arg, context) => {
     let content = context.get_buffer();
 
     if (!content || !arg) return;
 
     content[context.cursor] = arg;
-    //  console.log(`Writing: ${arg}`);
   };
 
   name_hash = () => {
@@ -117,8 +190,8 @@ class Filesystem {
 
     let fs = this.manager.oracle.fs;
 
-    if (!fs.existsSync(`${this.root}/${chain.path}`)) {
-      fs.mkdirSync(`${this.root}/${chain.path}`, { recursive: true });
+    if (!fs.existsSync(`${this.manager.root}/${chain.path}`)) {
+      fs.mkdirSync(`${this.manager.root}/${chain.path}`, { recursive: true });
     }
   };
 

package/Objects/Frame.js

@@ -8,15 +8,14 @@ class Frame {
       ? array_to_nested_objects(object)
       : object;
 
-    this.children = new Array();
     this.instructions = new Array();
   }
 
   frame = (object) => {
     let frame = new Frame(object, this);
+    frame.account = this.account;
 
     this.instructions.push(frame);
-    this.children.push(frame);
 
     return frame;
   };
@@ -26,7 +25,14 @@ class Frame {
       let val = this.object[prop];
       this.instructions.push(`chain ${prop}`);
 
-      val && this.frame(val).to_instruction();
+      if(val && val.__type){
+        let instructions = this.account.assembler.run(JSON.stringify(val.value), {instructions: true, pure: true})
+
+        this.instructions.push(...instructions)
+
+        this.instructions.push(`cursor {output}`)
+        this.instructions.push(`write {datapath:-1}`)
+      }else val && this.frame(val).to_instruction();
 
       this.instructions.push(`pop ${prop}`);
     }
@@ -40,6 +46,7 @@ class Frame {
       if (ins instanceof Frame) inss.push(...ins.flatten_instructions());
       else inss.push(ins);
     }
+
     return inss;
   };
 }

package/Objects/Manager.js

@@ -4,22 +4,31 @@ import opcodes from "../opcodes";
 import Account from "./Account";
 import Blockweb from "./Blockweb";
 import Oracle from "./Oracle";
+import Logger from "../utils/logger";
+import Protocol from "godprotocol/Objects/Protocol";
 
-class Manager {
+
+class Manager extends Protocol{
   constructor(meta) {
+    super()
+    
     meta = meta || {};
 
     this.compression = meta.compression;
+    this.frequency = meta.frequency
     this.manager_id = _id("manager");
     this.accounts = new Object();
     this.running = 0;
-    this.tracks = new Object();
+    this.logger = new Logger()
+    this.root = meta.root || __dirname;
+    this.accounts_et_programs = new Object();
     this.web = new Blockweb(this);
     this.oracle = new Oracle(this, {
       compression: this.compression,
       datastore: meta.datastore,
     });
     this.servers = new Array();
+    this.init_name = meta.initiator|| process.env.INITIATOR || "initiator"
   }
 
   stringify = (str) => {
@@ -33,40 +42,119 @@ class Manager {
 
   initiate = (meta) => {
     this.initiator = this.add_account(
-      process.env.INITIATOR || "initiator",
+     this.init_name,
       meta
     );
 
     return this.initiator;
   };
 
+  set_track = ({account, physical_address, pointer}, slice)=>{
+    let payload = this.accounts_et_programs[account], t, track;
+    
+    for(t= payload.tracks.length-1; t>=0; t--){
+      let trck = payload.tracks[t]
+      if (trck.payload.physical_address === physical_address){
+        track = trck
+        break
+      }
+    }
+
+    if(slice && track){
+      payload.tracks.splice(t+1)
+    }
+    if(pointer != null){
+      track.pointer = pointer;
+    }
+
+    return track
+  }
+
+  state_logger = ()=>{
+    let lines=0
+    for (let account in this.accounts_et_programs){
+      let payload = this.accounts_et_programs[account];
+      let tracks = payload.tracks
+
+      console.log(`(${payload.clocks}) Account: ${account} [tracks(${tracks.length})]`)
+
+      let curr_track = tracks.slice(-1)[0]
+      let pointer = curr_track.pointer
+      let instruction = curr_track.sequence[pointer]
+
+      console.log(`>(${curr_track.clocks}) Track [${pointer} / ${curr_track.sequence.length}] - executing '${instruction}'`)
+      lines+=2
+    }
+    return lines
+  }
+
+  finish_state = ()=>{
+    console.log(`All programs finished execution`)
+  }
+
   start_clock = () => {
-    let frequency = Number(process.env.HERTS) || 10;
+    let frequency = Number(this.frequency)|| Number(process.env.HERTS) || 10;
     this.clock = setInterval(() => {
-      for (let account in this.tracks) {
-        let track = this.tracks[account];
-        let program = track.slice(-1)[0];
+      
+      for (let account in this.accounts_et_programs) {
+        let payload = this.accounts_et_programs[account], spawn, tracks;
 
+        if(payload.spawn_list.length){
+          if(payload.spawn_cursor == undefined){
+            payload.spawn_cursor = 0
+            tracks = payload.tracks;
+          }else {
+            spawn = payload.spawn_list[payload.spawn_cursor]
+            tracks = payload.spawns[spawn];
+            payload.spawn_cursor ++
+          }
+        }else {
+          tracks = payload.tracks;
+        }
+
+        let program = tracks.slice(-1)[0];
+
+        payload.clocks ++
         if (program.hold) continue;
 
         let instruction = program.sequence[program.pointer];
+        program.clocks++
 
-        program.account.vm.execute(instruction, program);
         program.pointer++;
-
-        if (program.pointer === program.sequence.length) {
+        program.account.vm.execute(instruction, program);
+        program = program.account.vm.track;
+        
+        if (program.pointer >= program.sequence.length) {
           program.account.flush_buffer(program.pid);
 
-          track.pop();
+          if (program.error_stack)
+            program.account.vm.error_manager = JSON.parse(program.error_stack)
+          tracks.pop();
+
+          if(spawn){
+            if (payload.spawn_cursor >= payload.spawn_list.length){
+              payload.spawn_cursor = undefined
+            }
+          }
         }
-        if (!track.length) {
-          this.running -= 1;
-          delete this.tracks[account];
-          program.account.chain.mine(program.account.vm);
+        if (!tracks.length) {
+          if (spawn){
+            delete payload.spawns[spawn]
+            payload.spawn_list = payload.spawn_list.filter(s=>s!==spawn)
+          }else {
+            this.running -= 1;
+            delete this.accounts_et_programs[account];
+            program.account.chain.mine(program.account.vm);
+          }
+          
         }
       }
 
-      !this.running && clearInterval(this.clock);
+      this.logger.log(this.state_logger)
+      if (!this.running){
+        clearInterval(this.clock)
+       this. finish_state(this.finish_state)
+      }
     }, frequency);
   };
 
@@ -99,13 +187,35 @@ class Manager {
   };
 
   push = (program) => {
-    let track = this.tracks[program.account.name];
+    let account = this.accounts_et_programs[program.account.name];
+    let tracks ;
 
-    if (track) {
-      track.push({ ...program, pointer: 0 });
+    if (account) {
+      if (program.spawn) {
+        tracks = account.spawns[program.spawn]
+        if (!tracks) {
+          tracks = []
+          account.spawns[program.spawn] = tracks;
+        }
+        account.spawn_list.push(program.spawn)
+      }else tracks=  account.tracks
+      if(program.unshift){
+        delete program.unshift
+        tracks.unshift({ ...program, pointer: 0, clocks:0 });
+      } else tracks.push({ ...program, pointer: 0, clocks:0 });
     } else {
-      track = [{ ...program, pointer: 0 }];
-      this.tracks[program.account.name] = track;
+      tracks = [{ ...program, pointer: 0, clocks:0 }];
+      account = {
+        clocks:0,
+        spawns: {},
+        spawn_list: []
+      }
+      if (program.spawn){
+        account.spawns[program.spawn] = tracks
+        account.spawn_list.push(program.spawn)
+      }else account.tracks = tracks;
+
+      this.accounts_et_programs[program.account.name] = account;
 
       this.running++;
       this.running === 1 && this.start_clock();
@@ -116,14 +226,14 @@ class Manager {
 
   endpoint = (endpoint, payload, callback) => {
     let account = this.get_account(payload.account);
-    if (!account) {
+    if (!account && payload.account) {
       return this.get_initiator().run_callback(callback, {
         error: true,
         error_message: "Account is not found",
         payload,
         endpoint,
       });
-    }
+    }else account = this.get_initiator()
 
     if (
       !account.validate(
@@ -141,6 +251,66 @@ class Manager {
   add_server = (server) => {
     this.servers.push(server);
   };
+
+  prepare_query  = query=>{
+    query = query.split('&');
+    let obj = {}
+    for (let q=0; q< query.length; q++){
+      let [prop, value] = query[q].split('=')
+
+      if (prop === 'executable'){
+        obj.executable = value;
+      }else if (prop.startsWith('arguments')){
+        if (!obj.arguments) obj.arguments = {argv: []}
+        if (prop.includes('.')){
+          prop = prop.split('.')
+          if (prop[2] ==='$'){
+            try{
+              value = JSON.parse(value)
+            }catch(e){}
+          }
+          obj.arguments.argv.push({name: prop[1], [prop[2]==='$'?'static_value':'address']: value})
+        } else {
+          obj.arguments.argv.push({address:value, position: obj.arguments.argv.length})
+        }
+        obj.arguments.argc = obj.arguments.argv.length
+      }else if (prop === 'location'){
+        obj.location = value;
+      }else if (prop === 'metadata'){
+        try {
+          obj.metadata  = JSON.parse(value);  
+        } catch (e) {}
+      }
+    }
+    
+    return obj;
+  }
+
+  handle_route = ({req,res, data})=>{
+    let url = req.url;
+    let split = url.split('?')
+    let query = split[1]
+
+    let payload = data || this.prepare_query(query);
+    url = split[0].split('/').filter(a=>!!a)
+
+    if (url.length> 2){}
+
+    let account = this.get_account(data && data.account || url[1]);
+    if(!account){
+      return res.end(JSON.stringify({error:true, error_message:"Account is not found!"}))
+    }
+
+    if (['display', 'read_chain'].includes(payload.executable )){
+      if (!payload.metadata)payload.metadata = {}
+      payload.metadata.raw = true;
+    }
+
+    let response = account.vm.exec(payload)
+
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(response))
+  }
 }
 
 export default Manager;

package/Objects/Opcodes.js

@@ -1,7 +1,10 @@
+import Vm_utils from "../utils/vm_utils";
 import { obj } from "../framer";
 
-class Opcodes {
+class Opcodes extends Vm_utils {
   constructor() {
+    super()
+
     this.opcodes = new Object();
   }
 
@@ -23,26 +26,61 @@ class Opcodes {
       context.account.read(buf && buf.inputs) ||
       this.account.stdin.splice(-1)[0];
 
-    let res = circ(args, this);
+      try{
+        let res = circ(args, this);
 
-    this.stdin(res);
+        this.stdin(this.static_cast(res));
+      } catch(e){
+        console.log(e)
+        this.stderr(`${JSON.stringify({circuit:opcode,args, error_message:e.message})}`)
+      }
   };
 
-  stdin = (object, cb) => {
+  stdin = (object, cb, options) => {
+    options = options || {}
+    let full_obj = object
+    object = object.static_value
+
     if (object == null) {
       this.flags.void = true;
-      return;
-    }
-    this.flags.void = false;
+      object = null
+    } else this.flags.void = false;
 
     this.flags.zero = !object;
     if (typeof object === "number") this.flags.neg = object < 0;
 
-    let code_string =
-      typeof object !== "string" ? JSON.stringify(object) : object;
+    let code_string;
+
+    if (cb && cb.payload && cb.payload.stdin)
+      options.address = cb.payload.stdin;
 
+    if (!options.address){
+      let contx_2 = this.get_context(-2)
+      if (full_obj&& typeof full_obj === 'object'){
+        if(contx_2){
+        full_obj.__address__ = contx_2.physical_address
+        }else full_obj .__address__ = this.get_context().physical_address
+      }
+    }
+    
+    if (typeof full_obj === 'string'){
+      code_string = full_obj
+    } else if (full_obj.type){
+      if (full_obj.type === 'boolean'){
+        code_string =  `{"type":"boolean", "static_value":${full_obj.static_value?'True':'False'},"__address__":"${full_obj.__address__}"}`
+      }else code_string = JSON.stringify(full_obj)
+    }else code_string=  typeof object !== "string" ?object ==null?'Void': JSON.stringify(object) : `"${object}"`;
+
+    if (options.address){
+      let addr = options.address;
+      if(!addr.startsWith('@')){
+        addr = `@/${addr.split('/').slice(2).join('/')}`
+      }
+
+      code_string = `>${addr} ${code_string}`
+    }
+    
     this.account.assembler.run(code_string, { cb, pure: true });
-    // console.log(`Writing in: ${code_string}`);
   };
 }
 

package/Objects/Oracle.js

@@ -36,23 +36,26 @@ class Oracle {
 
     if (!obj) {
       try {
-        obj = this.fs.readFileSync(`${this.mgr.initiator.root}/${path}`);
-        obj = JSON.parse(obj).payload;
+        obj = this.fs.readFileSync(`${this.mgr.root}/${path}`, {encoding:'utf-8'});
+        obj = JSON.parse(obj);
         let type = obj && obj.payload && typeof obj.payload;
+        obj = obj && obj.payload;
         type =
           type === "object" ? (Array.isArray(obj) ? "array" : "twain") : type;
 
         obj = { type, obj };
         this.set(path, obj);
-      } catch (e) {}
+      } catch (e) {
+        // console.log(e.message, 'Error thrown?')
+      }
     }
 
     return obj;
   };
 
-  hash = (data) => {
+  hash = (data, alg) => {
     data = typeof data !== "string" ? JSON.stringify(data) : data;
-    return hash(data);
+    return hash(data, alg);
   };
 
   handle_compression = ({ addr, data, no_string }) => {
@@ -66,14 +69,14 @@ class Oracle {
     return data;
   };
 
-  write = (address, payload) => {
+  write = (address, payload) => { 
     payload = JSON.stringify({ payload });
     let data = this.handle_compression({
       addr: address,
       data: payload,
     });
-
-    this.fs.writeFileSync(`${this.mgr.initiator.root}/${address}`, data, {
+    
+    this.fs.writeFileSync(`${this.mgr.root}/${address}`, data, {
       encoding: "utf-8",
     });
   };

package/Objects/Protocol.js

@@ -0,0 +1,5 @@
+class Protocol{
+
+}
+
+export default Protocol