godprotocol 1.0.5 → 1.0.6

package/Objects/Blockweb.js

@@ -1,25 +1,43 @@
+import Block from "./Block";
+import Chain from "./Chain";
+
 class Blockweb {
-  constructor(vm) {
-    this.vm = vm;
+  constructor(mgr) {
+    this.mgr = mgr;
     this.chains = new Object();
     this.blocks = new Object();
+
+    this.physical_addresses = new Object();
   }
 
-  new_block = (block) => {
-    this.blocks[block.hash] = block;
-    this.chains[block.chain.hash] = block.chain;
-  };
+  sync_chain = (chain) => {
+    let chain_obj = this.chains[chain.hash];
+    if (!chain_obj) {
+      this.store_chain(chain.stringify());
+
+      return chain;
+    }
 
-  explore = (query) => {
-    this.vm.get_context().chain.explore(query);
+    return chain_obj;
   };
 
-  add_tx = (tx) => {
-    this.vm.get_context().chain.add_tx(tx);
+  store_chain = (chain_obj) => {
+    let addr = this.mgr.oracle.get(chain_obj.physical_address);
+
+    if (!addr) return;
+
+    let chain = new Chain(addr);
+    chain.hash = chain_obj.hash;
+
+    this.chains[chain_obj.hash] = chain;
   };
 
-  mine = () => {
-    this.vm.get_context().chain.mine();
+  store_block = (block_obj) => {
+    let chain = this.chains[block_obj.chain];
+    if (!chain) return;
+
+    let block = new Block(chain);
+    chain.add_block(block);
   };
 }
 

package/Objects/Chain.js

@@ -0,0 +1,96 @@
+import { hash } from "../utils/hash";
+import Block from "./Block";
+import Explorer from "./Explorer";
+
+class Chain extends Explorer {
+  constructor(parent) {
+    super();
+
+    this.parent = parent;
+    this.physical_address = this.parent.physical_address;
+    this.name = this.parent.name;
+    this.servers = new Array();
+
+    this.pending_children = new Array();
+    this.connections = new Array();
+
+    this.blocks = new Array();
+    this.txs = new Array();
+
+    this.cursor = -1;
+    this.buffs = [];
+    this.listeners = [];
+  }
+
+  add_listener = (event_twain) => {};
+
+  on = (name) => {};
+
+  after = (name) => {};
+
+  append_buffer = () => {
+    this.buffs.push({});
+  };
+
+  get_buffer = () => {
+    return this.buffs.slice(-1)[0];
+  };
+
+  generate_hash = () => {
+    let hsh = this.parent.path + this.parent.account.vm.snap_id();
+    this.hash = hash(hsh);
+  };
+
+  add_tx = (instruction) => {
+    if (!this.txs.length) this.start_time = Date.now();
+
+    this.txs.push(instruction);
+  };
+
+  set_servers = (servers) => {
+    this.servers = servers;
+  };
+
+  mine = (vm) => {
+    let block = new Block(this);
+
+    block.store();
+
+    this.add_block(block);
+
+    vm.account.manager.web.chains[this.hash] = this;
+
+    block.children = this.pending_children;
+    this.pending_children = new Array();
+
+    let prev_context = vm.get_context(-2);
+    if (prev_context) {
+      prev_context.pending_children.push(block);
+      prev_context.connections.push(block);
+    }
+
+    this.txs = new Array();
+
+    block.timelapse = Date.now() - this.start_time;
+
+    return block;
+  };
+
+  stringify = () => {
+    let obj = {};
+
+    obj.physical_address = this.physical_address;
+    obj.parent = this.parent.path;
+    obj.connections = this.connections.map(
+      (b) => new Object({ chain: b.chain.hash, block: b.hash })
+    );
+    obj.hash = this.hash;
+    obj.blocks = this.blocks.map((blk) => blk.hash);
+
+    return obj;
+  };
+
+  add_block = (block) => this.blocks.push(block);
+}
+
+export default Chain;

package/Objects/Explorer.js

@@ -1,74 +1,30 @@
-import Queries from "./Queries";
+class Explorer {
+  constructor() {}
 
-class Explorer extends Queries {
-  constructor() {
-    super();
-  }
+  explore = (query) => {
+    query = query.split(":");
 
-  super_query = (v1, fn, meta) => {
-    return fn(v1, fn, meta);
-  };
+    query[0] = query[0].split(".");
 
-  get_query_circuit = (address) => {
-    let circ;
-    if (address.startsWith("$")) {
-      circ = this[address.slice(1)];
+    let q2 = Number(query[1]);
+
+    let obj;
+    if (isNaN(q2)) {
+      obj = this.connections.find((c) => c.hash === query[1]);
+    } else if (q2 >= 0) {
+      obj = this.connections.find((q) => q.index === q2);
     } else {
+      obj = this.connections.slice(q2)[0];
     }
-    return circ;
-  };
 
-  solve_query = (query, value, block) => {
-    let props = Object.keys(query);
+    for (let q = 0; q < query[0].length; q++) {
+      let que = query[0][q];
 
-    let res = new Array();
-
-    for (let p = 0; p < props.length; p++) {
-      let pp = props[p];
-
-      let q = this.get_query_circuit(pp);
-      if (!q) throw new Error(`Query ${pp} is not designed!`);
-
-      res.push(q(value, query[pp], { chain: this, query, value, block }));
+      if (!obj) break;
+      obj = obj[que];
     }
 
-    return !res.includes(false);
-  };
-
-  pass = (query, block) => {
-    let pass = new Array();
-
-    if (Array.isArray(query)) {
-      for (let q = 0; q < query.length; q++) {
-        let qu = query[q];
-        let res = this.pass(qu, block);
-        if (res) {
-          pass.push(res);
-          break;
-        }
-      }
-    } else
-      for (let prop in query) {
-        let value = query[prop];
-
-        if (["number", "string", "boolean"].includes(typeof value)) {
-          value = { $equals: value };
-        }
-        pass.push(
-          this.solve_query(value, !prop.startsWith("$") && block[prop], block)
-        );
-      }
-
-    return Array.isArray(query) ? pass.includes(true) : !pass.includes(false);
-  };
-
-  explore = (query) => {
-    let match = new Array();
-    for (let b = 0; b < this.blocks.length; b++) {
-      let block = this.blocks[b];
-      if (this.pass(query, block)) match.push(block);
-    }
-    return match;
+    return obj;
   };
 }
 

package/Objects/Filesystem.js

@@ -1,20 +1,171 @@
-class File_system {
+import fs from "fs";
+import Chain from "./Chain";
+import { hash } from "../utils/hash";
+
+let type_buff = new Object();
+
+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.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) => {
+    let addr, obj;
+
+    if (!this.type) this.type = "Void";
+
+    if (this.type === "array" || this.type === "string") {
+      obj = [];
+      for (let curs in content) {
+        if (curs === "type") continue;
+        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) {
+        if (curs === "type") continue;
+        obj[curs] = content[curs];
+      }
+    } else if (this.type === "number") {
+      obj = Number(content["-1"]) || -1;
+    } else {
+      obj = null;
+    }
+
+    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;
+  };
+
+  get_type = () => {
+    if (
+      this.physical_address ===
+      `${this.account.physical_address}/Datatypes/Number`
+    )
+      return "number";
+    else if (
+      this.physical_address ===
+      `${this.account.physical_address}/Datatypes/String`
+    )
+      return "string";
+    else if (
+      this.physical_address ===
+      `${this.account.physical_address}/Datatypes/Array`
+    )
+      return "array";
+    else if (
+      this.physical_address ===
+      `${this.account.physical_address}/Datatypes/Twain`
+    )
+      return "twain";
+    else if (
+      this.physical_address ===
+      `${this.account.physical_address}/Datatypes/Void`
+    )
+      return "void";
+    else if (
+      this.physical_address ===
+      `${this.account.physical_address}/Datatypes/Boolean`
+    )
+      return "boolean";
+  };
+
+  write = (arg, context) => {
+    let content = context.get_buffer();
+
+    if (!content) return;
+    content[context.cursor] = 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, mgr_index) => {
+    let folds = this.account.manager.oracle.get(
+      `${this.physical_address}/${name}`
+    );
+
+    if (!folds) {
+      folds = this.account.manager.oracle.get(name, this);
+
+      this.managers[mgr_index].folders[name] = folds;
+    }
+
+    return this.set_chain(folds);
+  };
+
+  set_chain = (folds) => {
+    let chain = new Chain(folds);
+    chain.generate_hash();
+
+    this.account.manager.oracle.tree[folds.physical_address] = folds;
+
+    this.account.manager;
+
+    chain = this.account.manager.web.sync_chain(chain);
+
+    folds.chains[chain.hash] = chain;
+
+    return chain;
+  };
+
+  get_chain = (context) => {
+    for (let c in this.chains) {
+      let chain = this.chains[c];
+      if (chain.physical_address === context.physical_address) return 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,56 @@
+import Blockweb from "./Blockweb";
+import Oracle from "./Oracle";
+
+class Manager {
+  constructor() {
+    this.accounts = new Object();
+    this.stack = new Object();
+    this.total = 0;
+    this.counter = 0;
+    this.tracker = new Object();
+    this.web = new Blockweb(this);
+    this.oracle = new Oracle(this);
+
+    this.start_clock();
+  }
+
+  start_clock = () => {
+    this.clock = setInterval(() => {
+      for (let index in this.tracker) {
+        let { sequence, account } = this.stack[index];
+        let track = this.tracker[index];
+
+        let instruction = sequence[track.pointer];
+        account.vm.execute(instruction, index);
+        track.pointer++;
+
+        if (track.pointer === sequence.length) {
+          delete this.tracker[index];
+        }
+      }
+
+      if (!Array.from(Object.keys(this.tracker)).length)
+        clearInterval(this.clock);
+    }, 10);
+  };
+
+  set_intiator = (initiator) => {
+    this.initiator = initiator;
+    this.accounts[this.initiator.name] = this.initiator;
+  };
+
+  push = (program) => {
+    this.stack[this.total] = program;
+    this.tracker[this.total] = {
+      pointer: 0,
+      hold: false,
+      message: (message) => this.message(message, this.total),
+    };
+
+    this.total++;
+
+    if (Array.from(Object.keys(this.tracker)).length === 1) this.start_clock();
+  };
+}
+
+export default Manager;

package/Objects/Opcodes.js

@@ -1,29 +1,25 @@
-import Arr from "../Datatypes/Array";
-import Num from "../Datatypes/Number";
-import Str from "../Datatypes/String";
-import Twain from "../Datatypes/Twain";
-
 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);
-  };
 
-  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();
+    if (typeof circ !== "function") {
+      return;
+    }
+    let buf = context.get_buffer();
 
-    return obj;
+    let res = circ(context.parent.load(buf.inputs));
+    this.stdin(res);
   };
+
+  stdin = (object) => {};
 }
 
 export default Opcodes;

package/Objects/Oracle.js

@@ -0,0 +1,35 @@
+import Folder from "./folder";
+
+class Oracle {
+  constructor(mgr) {
+    this.mgr = mgr;
+
+    this.tree = new Object();
+  }
+
+  get = (path, parent, should_break) => {
+    if (parent) path = parent.physical_address + `/${path}`;
+
+    path = path.split("/");
+    path.splice(0, 2, `${path[0]}/${path[1]}`);
+
+    let ini = this.tree[path[0]],
+      prior;
+
+    for (let p = 1; p < path.length; p++) {
+      let pth = path[p];
+
+      prior = ini;
+      ini = this.tree[`${prior.physical_address}/${pth}`];
+      if (!ini) {
+        if (should_break) break;
+
+        ini = new Folder(pth, prior);
+        this.tree[ini.physical_address] = ini;
+      }
+    }
+    return ini;
+  };
+}
+
+export default Oracle;