godprotocol 1.0.5 → 1.0.7

package/Objects/Filesystem.js

@@ -1,20 +1,139 @@
-class File_system {
+import fs from "fs";
+import { hash } from "../utils/hash";
+
+class Filesystem {
   constructor() {
-    this.files = {};
-    this.folders = new Object();
+    this.base_address = "Accounts";
+    this.chains = new Object();
+    setTimeout(() => {
+      this.type = this.get_type();
+    }, 0);
   }
 
-  file = (name, folder) => {
-    console.log(name, folder, "HERE");
+  parse_path = (path) => {
+    if (!path || (path && !path.includes("/"))) return path;
+
+    return this.load(path);
   };
 
-  writeFile(filename, content) {
-    this.files[filename] = content;
-  }
+  load = (datapath) => {
+    if (!datapath) return null;
 
-  readFile(filename) {
-    return this.files[filename];
-  }
+    let type_folder = this.account.manager.oracle.tree[datapath];
+
+    if (!type_folder) return datapath;
+
+    let content;
+    if (type_folder.fold.type === "twain") {
+      content = {};
+      for (let prop in type_folder.obj) {
+        let val = type_folder.obj[prop];
+
+        content[type_folder.fold.parse_path(prop)] =
+          type_folder.fold.parse_path(val);
+      }
+    } else if (type_folder.fold.type === "array") {
+      content = [];
+      type_folder.obj.map((t) => {
+        content.push(type_folder.fold.parse_path(t));
+      });
+    } else content = type_folder.obj;
+
+    return content;
+  };
+
+  save = (content, just_obj) => {
+    let addr, obj;
+
+    if (!this.type) this.type = "Void";
+
+    if (this.type === "array" || this.type === "string") {
+      obj = [];
+      for (let curs in content) {
+        obj.splice(Number(curs) || -1, 0, content[curs]);
+      }
+      if (this.type === "string") obj = obj.join(" ");
+    } else if (this.type === "twain") {
+      obj = {};
+      for (let curs in content) {
+        obj[curs] = content[curs];
+      }
+    } else if (this.type === "number") {
+      obj = Number(content["-1"]) || -1;
+    } else {
+      content = content["-1"];
+      if (content === "True") obj = true;
+      else if (content === "False") obj = false;
+      else obj = null;
+    }
+
+    if (just_obj) return obj;
+
+    obj = JSON.stringify(obj);
+    addr = `${this.path}/${hash(obj)}`;
+    fs.writeFileSync(addr, obj, { encoding: "utf-8" });
+
+    this.account.manager.oracle.tree[addr] = {
+      fold: this,
+      obj: JSON.parse(obj),
+    };
+
+    return addr;
+  };
+
+  data_addr = (type) => {
+    return `${this.account.physical_address}/Datatypes/${type}`;
+  };
+
+  get_type = () => {
+    switch (this.physical_address) {
+      case this.data_addr(`Number`):
+        return "number";
+      case this.data_addr(`String`):
+        return "string";
+      case this.data_addr(`Twain`):
+        return "twain";
+      case this.data_addr(`Array`):
+        return "array";
+      case this.data_addr(`Boolean`):
+        return "boolean";
+      case this.data_addr(`Void`):
+        return "void";
+    }
+  };
+
+  write = (arg, context) => {
+    let content = context.get_buffer();
+
+    if (!content || !arg) return;
+
+    content[context.cursor] = arg;
+
+    // console.log(`Writing: ${arg}`);
+  };
+
+  set_paths = () => {
+    this.path = `${this.parent ? this.parent.path : "Accounts"}/${this.hash}`;
+    if (!fs.existsSync(this.path)) {
+      fs.mkdirSync(this.path, { recursive: true });
+    }
+  };
+
+  add_chain = (name) => {
+    let folds = this.account.manager.oracle.get(name, this, this.account);
+
+    return this.set_chain(folds);
+  };
+
+  set_chain = (folds) => {
+    let chain = folds.account.manager.web.get(folds);
+
+    return chain;
+  };
+
+  get_chain = () => {
+    return this.set_chain(this);
+  };
 }
 
-export default File_system;
+export default Filesystem;

package/Objects/Frame.js

@@ -1,5 +1,4 @@
 import { array_to_nested_objects } from "../utils/functions";
-import { Buffs, fs_buffer } from "../utils/hash";
 
 class Frame {
   constructor(object, parent) {
@@ -32,6 +31,17 @@ class Frame {
       this.instructions.push(`pop ${prop}`);
     }
   };
+
+  flatten_instructions = () => {
+    let inss = new Array();
+
+    for (let i = 0; i < this.instructions.length; i++) {
+      let ins = this.instructions[i];
+      if (ins instanceof Frame) inss.push(...ins.flatten_instructions());
+      else inss.push(ins);
+    }
+    return inss;
+  };
 }
 
 export default Frame;

package/Objects/Manager.js

@@ -0,0 +1,51 @@
+import Blockweb from "./Blockweb";
+import Oracle from "./Oracle";
+
+class Manager {
+  constructor() {
+    this.accounts = new Object();
+    this.total = 0;
+    this.tracks = new Object();
+    this.web = new Blockweb(this);
+    this.oracle = new Oracle(this);
+
+    this.start_clock();
+  }
+
+  start_clock = () =>
+    (this.clock = setInterval(() => {
+      for (let account in this.tracks) {
+        let track = this.tracks[account];
+
+        let instruction = track.sequence[track.pointer];
+        track.account.vm.execute(instruction, track);
+        track.pointer++;
+
+        if (track.pointer === track.sequence.length) {
+          this.total--;
+          delete this.tracks[account];
+        }
+      }
+
+      !this.total && clearInterval(this.clock);
+    }, Number(process.env.HERTS) || 10));
+
+  set_intiator = (initiator) => {
+    this.accounts[initiator.name] = initiator;
+  };
+
+  push = (program) => {
+    let track = this.tracks[program.account.name];
+
+    if (!track) {
+      track = { ...program, sequence: [...program.sequence], pointer: 0 };
+      this.tracks[track.account.name] = track;
+      this.total++;
+      this.total === 1 && this.start_clock();
+    } else {
+      track.sequence.splice(track.pointer + 1, 0, ...program.sequence);
+    }
+  };
+}
+
+export default Manager;

package/Objects/Opcodes.js

@@ -1,28 +1,33 @@
-import Arr from "../Datatypes/Array";
-import Num from "../Datatypes/Number";
-import Str from "../Datatypes/String";
-import Twain from "../Datatypes/Twain";
+import { transpile_object } from "../utils/functions";
 
 class Opcodes {
-  opcodes = new Object();
+  constructor() {
+    this.opcodes = new Object();
+  }
 
-  set = (name, callable) => {
-    this.opcodes[name] = callable;
+  set = (opcode, circuit) => {
+    this.opcodes[opcode] = circuit;
   };
 
   prepare_operation = (opcode, context) => {
     let circ = this.opcodes[opcode];
-    circ(context.parent.content_buffer, context);
+
+    if (typeof circ !== "function") return;
+
+    let buf = context.get_buffer();
+
+    let res = circ(context.parent.load(buf.inputs));
+
+    this.stdin(res);
   };
 
-  parse_content = (buffer) => {
-    let obj;
-    if (buffer.type === "twain") obj = new Twain(buffer.value).load();
-    else if (buffer.type === "array") obj = new Arr(buffer.value).load();
-    else if (buffer.type === "string") obj = new Str(buffer.value).load();
-    else if (buffer.type === "number") obj = new Num(buffer.value).load();
+  stdin = (object) => {
+    if (!object) return;
+
+    let code_string = transpile_object(object);
 
-    return obj;
+    this.account.compiler.run(code_string);
+    console.log(`Writing in: ${code_string}`);
   };
 }
 

package/Objects/Oracle.js

@@ -0,0 +1,24 @@
+import Folder from "./folder";
+
+class Oracle {
+  constructor(mgr) {
+    this.mgr = mgr;
+
+    this.tree = new Object();
+  }
+
+  get = (name, parent) => {
+    let path = parent ? `${parent.physical_address}/${name}` : name;
+
+    let obj = this.tree[path];
+
+    if (!obj && parent) {
+      obj = new Folder(name, parent);
+      this.tree[obj.physical_address] = obj;
+    }
+
+    return obj;
+  };
+}
+
+export default Oracle;

package/Objects/Virtual_machine.js

@@ -1,112 +1,137 @@
-import { Block } from "./Blockchain";
-import Blockweb from "./Blockweb";
-import File_system from "./Filesystem";
-import Frame from "./Frame";
 import Opcodes from "./Opcodes";
 
 class Virtual_machine extends Opcodes {
-  constructor(chain) {
+  constructor(context) {
     super();
 
-    this.state = [chain];
-    this.web = new Blockweb(this);
-    this.fm = new File_system(this);
-
-    this.pointers = new Array();
+    this.account = context.parent.account;
+    this.contexts = [context];
   }
 
   get_context = (index) => {
-    return index != null ? this.state[index] : this.state.slice(-1)[0];
+    return this.contexts.slice(index == null ? -1 : index)[0];
   };
 
-  push = (instructions) => {
-    this.pointers.push(0);
+  /* VM moment */
+  snap_id = () => {
+    return `${this.get_context().hash}-${
+      JSON.stringify({ ...this.track, account: "" }) || -1
+    }`;
+  };
 
-    while (this.pointers.slice(-1)[0] < instructions.length && !this.err_) {
-      let ins = instructions[this.pointers.slice(-1)[0]];
-      if (ins) {
-        let res = this.check_instruction(ins);
-        if (res) {
-        } else this.execute(ins);
-      }
+  parse_arg = (arg, cursor) => {
+    let context = this.get_context();
 
-      this.pointers[this.pointers.length - 1] = this.pointers.slice(-1)[0] + 1;
-    }
-    this.pointers.pop();
-    this.get_context().mine(this);
-  };
+    let args = arg.split("/"),
+      i = 0;
+
+    while (args[0] === "..") {
+      i++;
 
-  check_instruction = (instruction) => {
-    if (instruction instanceof Block) {
-      this.state.push(instruction);
-      instruction = instruction.data;
-    } else if (instruction instanceof Frame) {
-      instruction = instruction.instructions;
-    } else {
-      return;
+      args.splice(0, 1);
     }
 
-    this.push(instruction);
-    return true;
-  };
+    i = (i + 1) * -1;
+    context = i ? this.get_context(i) : context;
 
-  readonly = (tag) => {
-    let tags = tag.split(":");
-    tags[0] = tags[0].slice(1);
-    tags[1] = tags[1].slice(0, -1);
+    arg = args.join("/");
 
-    console.log(tags);
-  };
+    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)}`;
+    }
 
-  parse_arg = (arg) => {
-    let data;
-    if (!arg) return;
-    if (arg.startsWith("{")) {
-      data = this.readonly();
+    if (arg.startsWith("{*") && cursor) {
+      arg = context.explore(arg.slice(2, -1));
+    } else if (arg.startsWith("{") && !cursor) {
+      arg = context.explore(arg.slice(1, -1));
     }
 
-    return data;
+    return arg;
   };
 
-  execute(instruction) {
-    let [opcode, args] = instruction.split(" ");
+  execute = (instruction, track) => {
+    this.track = track;
+
+    if (!instruction) return;
+
+    let split = instruction.split(" ");
+    let opcode = split[0],
+      args = split.slice(1).join(" ");
+
+    let original_arg = args;
 
     let context = this.get_context();
 
     context.add_tx(instruction);
-    args = this.parse_arg(args);
+
+    let chain;
+
+    args = this.parse_arg(args, opcode === "cursor");
 
     switch (opcode) {
       case "chain":
-        let folder = context.parent.folder(args, context);
-        this.state.push(folder.chain);
+        chain = context.parent.add_chain(args);
+        this.contexts.push(chain);
+
+        chain.append_buffer();
+
         break;
       case "link":
-        this.state.push(args);
+        let folder = context.parent.account.manager.oracle.get(args);
+
+        if (!folder) {
+          console.log(`LINKing Failed. - ${args}`);
+          return;
+        }
+
+        chain = folder.get_chain(context);
+
+        chain.append_buffer();
+
+        this.contexts.push(chain);
+
+        break;
+      case "listen":
+        context.add_listener(args);
         break;
       case "mine":
-        context.mine(this);
-        this.state.slice(-2)[0].handle_children(context.get_latest_block());
+        let bloc = context.mine(this, true);
+
+        this.account.buff(bloc, this.track.pid);
+
         break;
-      case "pop_link":
-        this.state.pop();
+      case "run":
+        this.account.run({ query: original_arg }, this.stdin);
         break;
       case "pop":
-        context.mine(this);
-        this.state.pop();
+        let blk;
+        if (context.txs.length > 1) {
+          blk = context.mine(this);
+        } else {
+          blk = context.get_latest_block();
+          if (blk) {
+            this.contexts.slice(-2)[0].connections.push(blk);
+          }
+          context.txs = [];
+        }
+        blk && this.account.buff(blk, this.track.pid);
+
+        this.contexts.pop();
         break;
-      case "run":
-        this.push(args.data);
+      case "cursor":
+        context.cursor = args;
+        break;
+      case "write":
+        context.parent.write(args, context);
         break;
       default:
-        if (["cursor", "write"].includes(opcode)) context[opcode](args);
-        else this.prepare_operation(opcode, context);
+        this.prepare_operation(opcode, context);
+        break;
     }
-  }
-
-  err = (msg) => {
-    console.log(msg);
-    this.err_ = true;
   };
 }
 

package/Objects/folder.js

@@ -1,94 +1,19 @@
-import fs from "fs";
-import { emitter } from "./Account";
-import File from "./file";
-import { Block, Chain } from "./Blockchain";
 import { hash } from "../utils/hash";
+import Filesystem from "./Filesystem";
 
-class Folder {
-  object_name = "folder";
+class Folder extends Filesystem {
+  constructor(name, parent) {
+    super();
 
-  constructor(name, parent, hash) {
     this.name = name;
     this.parent = parent;
-    this.hash = hash;
-    this.path = `${parent.path}/${this.hash}`;
+    this.hash = hash(this.name);
+    this.physical_address = `${this.parent.physical_address}/${this.name}`;
 
-    emitter.listen(this.path, (cb) => cb && cb(this));
+    this.account = this.parent.account;
 
-    this.active_file = null;
-    this.files = new Array();
-    this.folders = new Array();
-    this.chain = new Chain(this);
-
-    this.curs = -1;
-    this.content_buffer = new Object();
-
-    this.set_path();
+    this.set_paths();
   }
-
-  cursor = (curs) => (this.curs = curs);
-
-  write = (data) => {
-    let v = this.content_buffer[this.curs];
-
-    if (!v) {
-      v = new Array();
-      this.content_buffer[this.curs] = v;
-    }
-
-    v.push(data instanceof Block ? data.hash : data);
-  };
-
-  file = (name) => {
-    let file = this.files.find((f) => f.name === name);
-
-    if (!file) {
-      file = new File(name, this);
-      this.files.push(file);
-    }
-
-    return file;
-  };
-
-  get = (opcode) => {
-    let circ = this[opcode];
-
-    return circ;
-  };
-
-  get_column = () => {
-    this.get_active_file().block.get_column();
-  };
-
-  fetch_arg = (path) => {
-    let block = this.chain.explore({ parents: `./God/${path}` });
-    return block.file.parse(true);
-  };
-
-  folder = (name, context) => {
-    let name_hash = hash(name + context.hash);
-    let folder = this.folders.find((f) => f.hash === name_hash);
-    if (!folder) {
-      folder = new Folder(name, this, name_hash);
-      folder.account = this.account;
-
-      this.folders.push(folder);
-    }
-    folder.context = context.hash;
-
-    return folder;
-  };
-
-  parse = () => {
-    return this;
-  };
-
-  set_path = () => {
-    if (fs.existsSync(this.path)) {
-    } else {
-      fs.mkdirSync(this.path);
-    }
-  };
 }
 
 export default Folder;

package/framer.js

@@ -1,19 +1,39 @@
+import Frame from "./Objects/Frame";
+
 const framer = (initiator) => {
-  let frame = initiator.frame({
+  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,
+
       send: null,
-      jmp: null,
-      jmp_if: null,
       readonly: null,
       socket_send: null,
+
+      jmp: null,
+      jmp_if: null,
+      hold: null,
+
+      stdout: null,
+      stdin: null,
     },
     Datatypes: {
       Number: null,
       String: null,
       Twain: null,
       Array: null,
+      Void: null,
+      Boolean: null,
     },
     Objects: {
       Blockchain: {
@@ -33,8 +53,10 @@ const framer = (initiator) => {
       },
     },
   });
+  frame.to_instruction();
+  let instructions = frame.flatten_instructions();
 
-  initiator.load({ instructions: frame.instructions });
+  initiator.load({ instructions });
 };
 
 export default framer;