godprotocol 1.1.0 → 1.1.1

package/Objects/Filesystem.js

@@ -1,4 +1,12 @@
 import { hash } from "../utils/hash";
+import Num from '../Datatypes/num'
+import Str from '../Datatypes/str'
+import Arr from '../Datatypes/arr'
+import Bool from '../Datatypes/bool'
+import Voi from '../Datatypes/voi'
+import Twa from '../Datatypes/twa'
+import Instance from '../Datatypes/instance'
+import Func from '../Datatypes/func'
 
 class Filesystem {
   constructor() {
@@ -6,39 +14,157 @@ class Filesystem {
     this.base_address = process.env.BASE_ADDRESS || "Accounts";
   }
 
-  parse_path = (path) => {
+  parse_path = (path, options) => {
     if (!path || (typeof path === 'string' && (!path.includes("/") || path.includes(' ')))) return path;
 
-    return this.read(path);
+    return this.read(path, options);
   };
 
-  read = (datapath) => {
-    if (!datapath) return null;
-    
-    let type_folder = this.account.manager.oracle.get(datapath);
-
-    if (!type_folder){
-      return datapath;
-    }
-
+  cascade = (type_folder, options)=>{
+    options = options || {}
     let content;
     if (type_folder.type === "twain") {
       content = {};
       for (let prop in type_folder.obj) {
         let val = type_folder.obj[prop];
 
-        content[this.parse_path(prop)] = this.parse_path(val);
+        content[this.parse_path(prop, options)] = this.parse_path(val, options);
       }
+     
     } else if (type_folder.type === "array") {
       content = [];
       type_folder.obj.map((t) => {
-        content.push(this.parse_path(t));
+        content.push(this.parse_path(t, options));
       });
     } else content = type_folder.obj;
 
+    if(!options.callable)
+      content = this.cloth_content(content, {type:type_folder.type})
+
+    return content
+  }
+
+  read = (datapath, options) => {
+    if (!datapath) return null;
+    let {raw}=options ||{}
+
+    let type_folder = this.account.manager.oracle.get(datapath), content;
+
+    if (!type_folder){
+      return datapath;
+    }
+
+    if (raw) content = type_folder.obj
+    else content = this.cascade(type_folder, options)
+
     return content;
   };
 
+  cloth_object = object=>{
+    let raw, obj = object;
+
+    if (!object)object = {type:'void'}
+
+    switch(object.type){
+      case "string":
+        raw = this.read(object.static_address, {raw:true})
+        obj = new Str(raw, this.vm)
+        break
+      ;
+      case "number":
+        raw = this.read(object.static_address, {raw:true})
+        obj = new Num(raw, this.vm)
+        break
+      ;
+      case "array":
+        raw = this.read(object.static_address, {raw: true})
+        obj = new Arr(raw, this.vm)
+        break
+      ;
+      case 'boolean':
+        raw = this.read(object.static_address, {raw: true})
+        obj = new Bool(raw, this.vm)
+        break
+      ;
+      case 'void':
+        obj = new Voi(null, this.vm)
+        break
+      ;
+      case 'twain':
+        raw = this.read(object.static_address, {raw: true})
+        obj = new Twa(raw, this.vm)
+        break
+      ;
+      case 'function':
+        obj = new Func(object, this.vm)
+        break
+      ;
+      case 'class':
+        obj = new Func(object, this.vm)
+        break
+      ;
+      case 'instance':
+        obj = new Instance(object, this.vm)
+        break
+      ;
+      default:
+        obj = this.cloth_content(obj)
+      ;
+    }
+
+    return obj;
+  }
+
+  cloth_content = (content, options)=>{
+    let {type, datapath, location, skip, cascade, metadata} = options || {}
+    if (!type) type = this.object_type(content)
+
+    if (skip)return content;
+
+    let obj = content
+
+    if (!obj) type = 'void'
+    if(!obj || (obj && !obj.store))
+    switch(type){
+      case 'number':
+        obj = new Num(content, this.vm)
+        break
+      ;
+      case 'string':
+        obj = new Str(content, this.vm)
+        break
+      ;
+      case 'array':
+        obj = new Arr(content, this.vm)
+        if (cascade) obj.cascade({location})
+
+        break
+      ;
+      case 'boolean':
+        obj = new Bool(content, this.vm)
+        break
+      ;
+      case 'void':
+        obj = new Voi(content, this.vm)
+        break
+      ;
+      case 'twain':
+        obj = new Twa(content, this.vm)
+        if (cascade) obj.cascade({location})
+
+        break
+      ;
+    }
+    if (obj){
+      if (!datapath && !metadata) datapath = this.save(obj.value)
+      obj.static_address = datapath
+      if (metadata) obj.assume_metadata(metadata)
+    }
+    
+
+    return obj
+  }
+
   object_type = (obj, chain)=>{
     let type = typeof obj
     if (type === 'object'){
@@ -61,50 +187,19 @@ class Filesystem {
   }
 
   save = (content, chain, options) => {
-    let just_obj, pure;
+    let just_obj;
     if (typeof options !== 'object'){
       just_obj = options
-    }else if(options) {
+    } else if(options) {
       just_obj = options.just_obj
-      pure = options.pure
     }
-    let addr, obj;
+    let addr, obj = content;
 
-    if (!chain){
+    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;
 
@@ -112,6 +207,11 @@ class Filesystem {
     this;
     if (obj != null || type === 'void') this.manager.oracle.write(addr, obj);
 
+
+    if (obj && obj.startsWith &&obj.startsWith('config ')){
+      console.log(obj, 'hmm', chain.physical_address)
+      process.exit()
+    }
     this.manager.oracle.set(addr, { obj, type });
 
     return addr;

package/Objects/Frame.js

@@ -23,18 +23,13 @@ class Frame {
   to_instruction = () => {
     for (let prop in this.object) {
       let val = this.object[prop];
-      this.instructions.push(`chain ${prop}`);
+      this.instructions.push(`./${prop}`);
 
       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}`)
+        this.instructions.push(`>${prop} ${JSON.stringify(val)}`)
       }else val && this.frame(val).to_instruction();
 
-      this.instructions.push(`pop ${prop}`);
+      this.instructions.push(`;`);
     }
   };
 

package/Objects/Manager.js

@@ -4,22 +4,18 @@ 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";
+import Clock from "./Clock";
+import Protocol from "../Protocol/Protocol";
 
-
-class Manager extends Protocol{
+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.logger = new Logger()
     this.root = meta.root || __dirname;
     this.accounts_et_programs = new Object();
     this.web = new Blockweb(this);
@@ -29,6 +25,8 @@ class Manager extends Protocol{
     });
     this.servers = new Array();
     this.init_name = meta.initiator|| process.env.INITIATOR || "initiator"
+
+    this.clock = new Clock({frequency: meta.frequency, mgr:this})
   }
 
   stringify = (str) => {
@@ -70,94 +68,6 @@ class Manager extends Protocol{
     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(this.frequency)|| Number(process.env.HERTS) || 10;
-    this.clock = setInterval(() => {
-      
-      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.pointer++;
-        program.account.vm.execute(instruction, program);
-        program = program.account.vm.track;
-        
-        if (program.pointer >= program.sequence.length) {
-          program.account.flush_buffer(program.pid);
-
-          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 (!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.logger.log(this.state_logger)
-      if (!this.running){
-        clearInterval(this.clock)
-       this. finish_state(this.finish_state)
-      }
-    }, frequency);
-  };
-
   get_account = (name) => this.accounts[name];
 
   add_account = (name, meta) => {
@@ -183,7 +93,7 @@ class Manager extends Protocol{
       }
     }
 
-    return meta.string ? JSON.stringify(account) : account;
+    return meta.string ? account.stringify(true) : account;
   };
 
   push = (program) => {
@@ -198,11 +108,13 @@ class Manager extends Protocol{
           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 });
+        tracks.push({ ...program, pointer: 0, clocks:0 });  
+      }else{
+          tracks=  account.tracks
+          let prev_track = tracks.slice(-1)[0]
+
+         tracks.push({ ...program, pointer: 0, clocks:0, prev_track: prev_track && prev_track.pid });  
+      }
     } else {
       tracks = [{ ...program, pointer: 0, clocks:0 }];
       account = {
@@ -217,8 +129,8 @@ class Manager extends Protocol{
 
       this.accounts_et_programs[program.account.name] = account;
 
-      this.running++;
-      this.running === 1 && this.start_clock();
+      this.clock.inc()
+      this.clock.running === 1 && this.clock.start_clock();
     }
   };
 
@@ -292,24 +204,31 @@ class Manager extends Protocol{
     let query = split[1]
 
     let payload = data || this.prepare_query(query);
-    url = split[0].split('/').filter(a=>!!a)
 
-    if (url.length> 2){}
+    if (url.startsWith('/retrieve_large_payload')){
+      this.rt.resolve_buff(res, data)
+    }else {
+      url = split[0].split('/').filter(a=>!!a)
 
-    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 (url.length> 2){
+        console.log("MEEE")
+      }
 
-    if (['display', 'read_chain'].includes(payload.executable )){
-      if (!payload.metadata)payload.metadata = {}
-      payload.metadata.raw = true;
-    }
+      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)
+      let response = account.vm.exec(payload)
 
-    res.writeHead(200, { "Content-Type": "application/json" });
-    res.end(JSON.stringify(response))
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(response))
+    }
   }
 }
 

package/Objects/Opcodes.js

@@ -12,7 +12,6 @@ class Opcodes extends Vm_utils {
     this.opcodes[opcode] = circuit;
     obj.Opcodes[opcode] = null;
 
-    this.account.assembler.opcodes.push(opcode);
   };
 
   prepare_operation = (opcode, context) => {
@@ -20,20 +19,29 @@ class Opcodes extends Vm_utils {
 
     if (typeof circ !== "function") return;
 
-    let buf = context.get_buffer();
+    let instruction = this.track.sequence[this.track.pointer-1]
 
-    let args =
-      context.account.read(buf && buf.inputs) ||
-      this.account.stdin.splice(-1)[0];
+    let args = instruction.slice(opcode.length + 1), object;
 
-      try{
-        let res = circ(args, this);
+    try{
+      object = [JSON.parse(args)]
+    }catch(e){
+      let tokens = this.account.loader.tokenise(args)
+      object = this.account.loader.objectify(tokens)
+    }
 
-        this.stdin(this.static_cast(res));
-      } catch(e){
-        console.log(e)
-        this.stderr(`${JSON.stringify({circuit:opcode,args, error_message:e.message})}`)
-      }
+    let args_obj = {}
+    object.map((o,i)=>{
+      args_obj[`op${i}`] = o
+    })
+    try{
+      let res = circ(args_obj, this);
+
+      // this.air_object(res, {location: context.physical_address})
+    } catch(e){
+      console.log(e)
+      this.stderr(`${JSON.stringify({circuit:opcode,args, error_message:e.message})}`)
+    }
   };
 
   stdin = (object, cb, options) => {
@@ -41,6 +49,14 @@ class Opcodes extends Vm_utils {
     let full_obj = object
     object = object.static_value
 
+    if(full_obj.type){
+      let type_chain = this.account.get_datatype_chain(full_obj.type)
+      let blk = type_chain.forge_block({datapath: this.account.save(object)})
+
+      this.connect_block(blk, -1)
+      return
+    }
+
     if (object == null) {
       this.flags.void = true;
       object = null
@@ -71,7 +87,7 @@ class Opcodes extends Vm_utils {
       }else code_string = JSON.stringify(full_obj)
     }else code_string=  typeof object !== "string" ?object ==null?'Void': JSON.stringify(object) : `"${object}"`;
 
-    if (options.address){
+    if (code_string && options.address){
       let addr = options.address;
       if(!addr.startsWith('@')){
         addr = `@/${addr.split('/').slice(2).join('/')}`
@@ -80,7 +96,7 @@ class Opcodes extends Vm_utils {
       code_string = `>${addr} ${code_string}`
     }
     
-    this.account.assembler.run(code_string, { cb, pure: true });
+    code_string && this.account.assembler.run(code_string, { cb, pure: true });
   };
 }
 

package/Objects/Time_stack.js

@@ -0,0 +1,5 @@
+class Time_stack {
+  constructor(){}
+}
+
+export default Time_stack

package/Objects/Virtual_machine.js

@@ -30,13 +30,12 @@ class Virtual_machine extends Opcodes {
 
   quit = (payload)=>{
     let instruction = this.track.sequence[this.track.pointer-1]
-    if(instruction==='ret'){
+
+    let { opcode } = this.split_instruction(instruction);
+    if(opcode==='ret'){
       this.account.buff({ret:payload.op0}, this.track.pid)
     }
-
-    this.account.flush_buffer(this.track.pid, payload);
     this.track.pointer = this.track.sequence.length;
-    this.pop_context()
   }
 
   stderr = (err_object)=>{
@@ -133,11 +132,12 @@ class Virtual_machine extends Opcodes {
 
     let context = this.get_context(-1);
 
-    if (!context) return;
+    if (!context || opcode === 'pass') return;
 
     context.add_tx(instruction);
 
-    // console.log(`(${track.pointer}/${track.sequence.length})>> ${instruction}`)
+    // console.log(`(${track.pointer}/${track.sequence.length})`)
+    // console.log(`(${track.pointer}/${track.sequence.length-1})>> ${instruction}`)
     // this.account.log_output(`>> ${instruction}`);
 
     let chain;
@@ -146,6 +146,7 @@ class Virtual_machine extends Opcodes {
 
     switch (opcode) {
       case "chain":
+        
         chain = this.handle_chain(args, context)
 
         if(!chain)return this.stderr(`Chain error - ${args}`)
@@ -161,6 +162,7 @@ class Virtual_machine extends Opcodes {
 
         chain.append_buffer();
 
+        process.exit()
         break;
       case "link":
         chain = this.handle_chain(args, context)
@@ -211,6 +213,8 @@ class Virtual_machine extends Opcodes {
       case "write":
         context.account.write(args, context);
         break;
+      case "pass":
+        break;
       default:
         this.prepare_operation(opcode, context);
         break;

package/Protocol/Protocol.js

@@ -0,0 +1,10 @@
+import Realtime from "./Realtime"
+
+
+class Protocol{
+  socket_server = (port)=>{
+    this.rt = new Realtime({port, manager: this})
+  }
+}
+
+export default Protocol

package/Protocol/Realtime.js

@@ -0,0 +1,64 @@
+import { generate_random_string } from 'generalised-datastore/utils/functions';
+import Socket from './Socket'
+const net = require('net');
+
+class Realtime{
+  constructor({port, manager}){
+    this.manager = manager
+    this.server = this.create(port)
+
+    this.buffs = new Object()
+    this.sockets = new Object()
+    this.clients = new Object()
+  }
+
+  append_buff = (payload, socket)=>{
+    let hash = this.manager.oracle.hash(payload)
+    let rand = generate_random_string(12, 'alnum')
+
+    this.buffs[`${hash}-${rand}`] = {payload, client: socket.client_id}
+
+    socket.write('retrieve_large_payload', {hash, rand})
+  }
+
+  resolve_buff = (res, data)=>{
+    let _id = `${data.hash}-${data.rand}`
+    let buff = this.buffs[_id]
+
+    res.writeHead(200, { "Content-Type": "application/json" });
+    if (!buff){
+      res.end(JSON.stringify({route: 'error', data: {name: '404', message: "missing large payload", metadata: data}}))
+    }else { 
+      res.end(buff.payload)
+    }
+    
+    delete this.buffs[_id]
+  }
+
+  create = (port)=>{
+    let server = net.createServer((socket) => {
+      console.log('Client connected');
+
+      let obj = new Socket(socket, this)
+
+      this.sockets[obj._id] = obj
+    });
+
+    server.listen(port, () => {
+      console.log(`Socket server listening on :${port}`);
+    });
+
+    return server
+  }
+
+  send = (socket_meta, payload)=>{
+    let {socket: client_id, client_route} = socket_meta;
+    
+    let client = this.clients[client_id]
+    if (!client)return console.log(`Err, client is not set. Realtime.send`)
+
+    client.write(client_route, payload)
+  }
+}
+
+export default Realtime