godprotocol 1.0.7991 → 1.1.0

package/Objects/Manager.js

@@ -1,90 +1,316 @@
+import { _id } from "generalised-datastore/utils/functions";
 import framer from "../framer";
 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 {
-  constructor() {
+
+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);
+    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) => {
+    let obj = {
+      _id: this.manager_id,
+      servers: this.servers,
+    };
+
+    return str ? JSON.stringify(obj) : obj;
+  };
+
+  initiate = (meta) => {
+    this.initiator = this.add_account(
+     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];
+      
+      for (let account in this.accounts_et_programs) {
+        let payload = this.accounts_et_programs[account], spawn, tracks;
 
-        let instruction = track.sequence[track.pointer];
+        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;
+        }
 
-        track.account.vm.execute(instruction, track);
-        track.pointer++;
+        let program = tracks.slice(-1)[0];
 
-        if (track.pointer === track.sequence.length) {
-          this.running--;
-          track.account.chain.mine(track.account.vm);
-          track.account.flush_buffer(track.pids.splice(-1)[0]);
+        payload.clocks ++
+        if (program.hold) continue;
 
-          delete this.tracks[account];
-        }
+        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 (track.breakpoint.slice(-1)[0] === track.pointer) {
-          track.account.flush_buffer(track.pids.splice(-1)[0]);
+          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.running && clearInterval(this.clock);
+      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) => {
-    let account = this.get_account(name);
+    meta = meta || {};
+    if (!name) name = meta.name;
+
+    let account;
+    if (!name) {
+      account = { error: true, error_message: "Name cannot be blank" };
+    } else {
+      account = this.get_account(name);
+
+      if (!account) {
+        account = new Account(name, { ...meta, manager: this });
 
-    if (!account) {
-      account = new Account(name, { ...meta, manager: this });
-      framer(account);
-      opcodes(account);
+        opcodes(account);
+        framer(account, meta.on_framed);
 
-      this.accounts[account.name] = account;
-    } else if (meta && meta.private && !account.private) {
-      account.private = true;
+        this.accounts[account.name] = account;
+        if (meta.string) account = account.stringify();
+      } else if (meta && meta.private && !account.private) {
+        account.private = true;
+      }
     }
 
-    return account;
+    return meta.string ? JSON.stringify(account) : account;
   };
 
   push = (program) => {
-    let track = this.tracks[program.account.name];
-
-    if (track) {
-      track.breakpoint.push(track.pointer + program.sequence.length + 1);
-      track.sequence.splice(track.pointer + 1, 0, ...program.sequence);
-      track.pids.push(program.pid);
+    let account = this.accounts_et_programs[program.account.name];
+    let tracks ;
 
-      if (!this.running) {
-        this.running++;
-        this.tracks[program.account.name] = track;
-        this.start_clock();
-      }
+    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,
-        pids: [program.pid],
-        breakpoint: new Array(),
-      };
-      this.tracks[track.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();
     }
   };
+
+  get_initiator = () => this.initiator || this.initiate();
+
+  endpoint = (endpoint, payload, callback) => {
+    let account = this.get_account(payload.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(
+        payload.program || payload.payload,
+        payload.signature,
+        callback || payload.callback
+      )
+    )
+      return;
+
+    let method = account[endpoint];
+    typeof method === "function" && method({ ...payload, callback });
+  };
+
+  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,12 +1,17 @@
-import { transpile_object } from "../utils/functions";
+import Vm_utils from "../utils/vm_utils";
+import { obj } from "../framer";
 
-class Opcodes {
+class Opcodes extends Vm_utils {
   constructor() {
+    super()
+
     this.opcodes = new Object();
   }
 
   set = (opcode, circuit) => {
     this.opcodes[opcode] = circuit;
+    obj.Opcodes[opcode] = null;
+
     this.account.assembler.opcodes.push(opcode);
   };
 
@@ -17,20 +22,65 @@ class Opcodes {
 
     let buf = context.get_buffer();
 
-    let args = buf && context.account.read(buf.inputs);
+    let args =
+      context.account.read(buf && buf.inputs) ||
+      this.account.stdin.splice(-1)[0];
 
-    let res = circ(args);
+      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) => {
-    if (object == null) return;
+  stdin = (object, cb, options) => {
+    options = options || {}
+    let full_obj = object
+    object = object.static_value
+
+    if (object == null) {
+      this.flags.void = true;
+      object = null
+    } else this.flags.void = false;
+
+    this.flags.zero = !object;
+    if (typeof object === "number") this.flags.neg = object < 0;
+
+    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}"`;
 
-    let code_string = transpile_object(object);
+    if (options.address){
+      let addr = options.address;
+      if(!addr.startsWith('@')){
+        addr = `@/${addr.split('/').slice(2).join('/')}`
+      }
 
-    this.account.compiler.run(code_string, { cb, pure: true });
-    // console.log(`Writing in: ${code_string}`);
+      code_string = `>${addr} ${code_string}`
+    }
+    
+    this.account.assembler.run(code_string, { cb, pure: true });
   };
 }
 

package/Objects/Oracle.js

@@ -1,12 +1,29 @@
 import fs from "fs";
+import GDS from "generalised-datastore";
+import { hash } from "../utils/hash";
 
 class Oracle {
-  constructor(mgr) {
+  constructor(mgr, meta) {
+    meta = meta || {};
+
+    this.compression = meta.compression;
     this.fs = fs;
     this.mgr = mgr;
     this.datapaths = new Object();
+    this.gds = new GDS(
+      meta.datastore || process.env.DATASTORE || "godprotocol"
+    ).sync({
+      manager: this.mgr,
+    });
   }
 
+  get_folder = (physical_address, options) => {
+    if (typeof options !== "object") {
+      options = { no_new: options ? false : true };
+    }
+    return this.gds.folder(this.hash(physical_address));
+  };
+
   set = (path, { type, obj }) => {
     this.datapaths[path] = {
       obj,
@@ -14,12 +31,80 @@ class Oracle {
     };
   };
 
-  get = (path) => this.datapaths[path];
+  get = (path) => {
+    let obj = this.datapaths[path];
+
+    if (!obj) {
+      try {
+        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) {
+        // console.log(e.message, 'Error thrown?')
+      }
+    }
+
+    return obj;
+  };
+
+  hash = (data, alg) => {
+    data = typeof data !== "string" ? JSON.stringify(data) : data;
+    return hash(data, alg);
+  };
+
+  handle_compression = ({ addr, data, no_string }) => {
+    if (this.compression) {
+      let res = this.compression({ addr, data, no_string });
+      if (res) data = res.data;
+    }
+    if (!no_string && (typeof addr !== "string" || typeof data !== "string"))
+      return;
+
+    return data;
+  };
+
+  write = (address, payload) => { 
+    payload = JSON.stringify({ payload });
+    let data = this.handle_compression({
+      addr: address,
+      data: payload,
+    });
+    
+    this.fs.writeFileSync(`${this.mgr.root}/${address}`, data, {
+      encoding: "utf-8",
+    });
+  };
+
+  fetch = async (payload, callback) => {
+    let { physical_address, config, remote, query } = payload,
+      result;
+
+    let folder = this.get_folder(physical_address);
+
+    if (config) {
+      result = folder.config.stringify();
+      folder.add_remote(remote);
+    } else {
+      if (!folder.check_remote(query.operation)) {
+        result = {
+          error: true,
+          error_message: "Query operation cannot be performed remotely.",
+        };
+      } else {
+        let op = folder[query.operation];
 
-  write = (addr, data, meta = { encoding: "utf-8" }) => {
-    if (typeof data !== "string") data = JSON.stringify(data);
+        result = await op(query.query, query.options);
+        folder.remote_stuff(remote, result);
+      }
+    }
 
-    this.fs.writeFileSync(addr, data, meta);
+    callback(result);
   };
 }
 

package/Objects/Protocol.js

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