godprotocol 1.0.6 → 1.0.71

package/Objects/Filesystem.js

@@ -1,9 +1,6 @@
 import fs from "fs";
-import Chain from "./Chain";
 import { hash } from "../utils/hash";
 
-let type_buff = new Object();
-
 class Filesystem {
   constructor() {
     this.base_address = "Accounts";
@@ -14,7 +11,7 @@ class Filesystem {
   }
 
   parse_path = (path) => {
-    if (!path.includes("/")) return path;
+    if (!path || (path && !path.includes("/"))) return path;
 
     return this.load(path);
   };
@@ -45,7 +42,7 @@ class Filesystem {
     return content;
   };
 
-  save = (content) => {
+  save = (content, just_obj) => {
     let addr, obj;
 
     if (!this.type) this.type = "Void";
@@ -53,24 +50,25 @@ class Filesystem {
     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(" ");
-      }
+      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;
+      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" });
@@ -83,44 +81,35 @@ class Filesystem {
     return addr;
   };
 
+  data_addr = (type) => {
+    return `${this.account.physical_address}/Datatypes/${type}`;
+  };
+
   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";
+    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) return;
+    if (!content || !arg) return;
+
     content[context.cursor] = arg;
+
+    // console.log(`Writing: ${arg}`);
   };
 
   set_paths = () => {
@@ -130,40 +119,19 @@ class Filesystem {
     }
   };
 
-  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;
-    }
+  add_chain = (name) => {
+    let folds = this.account.manager.oracle.get(name, this, this.account);
 
     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;
+    let chain = folds.account.manager.web.get(folds);
 
     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;
-    }
+  get_chain = () => {
     return this.set_chain(this);
   };
 }

package/Objects/Manager.js

@@ -4,52 +4,47 @@ 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.tracks = 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];
+  start_clock = () =>
+    (this.clock = setInterval(() => {
+      for (let account in this.tracks) {
+        let track = this.tracks[account];
 
-        let instruction = sequence[track.pointer];
-        account.vm.execute(instruction, index);
+        let instruction = track.sequence[track.pointer];
+        track.account.vm.execute(instruction, track);
         track.pointer++;
 
-        if (track.pointer === sequence.length) {
-          delete this.tracker[index];
+        if (track.pointer === track.sequence.length) {
+          this.total--;
+          delete this.tracks[account];
         }
       }
 
-      if (!Array.from(Object.keys(this.tracker)).length)
-        clearInterval(this.clock);
-    }, 10);
-  };
+      !this.total && clearInterval(this.clock);
+    }, Number(process.env.HERTS) || 10));
 
   set_intiator = (initiator) => {
-    this.initiator = initiator;
-    this.accounts[this.initiator.name] = this.initiator;
+    this.accounts[initiator.name] = 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();
+    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);
+    }
   };
 }
 

package/Objects/Opcodes.js

@@ -1,3 +1,5 @@
+import { transpile_object } from "../utils/functions";
+
 class Opcodes {
   constructor() {
     this.opcodes = new Object();
@@ -10,16 +12,23 @@ class Opcodes {
   prepare_operation = (opcode, context) => {
     let circ = this.opcodes[opcode];
 
-    if (typeof circ !== "function") {
-      return;
-    }
+    if (typeof circ !== "function") return;
+
     let buf = context.get_buffer();
 
     let res = circ(context.parent.load(buf.inputs));
+
     this.stdin(res);
   };
 
-  stdin = (object) => {};
+  stdin = (object) => {
+    if (!object) return;
+
+    let code_string = transpile_object(object);
+
+    this.account.compiler.run(code_string);
+    console.log(`Writing in: ${code_string}`);
+  };
 }
 
 export default Opcodes;

package/Objects/Oracle.js

@@ -7,28 +7,17 @@ class Oracle {
     this.tree = new Object();
   }
 
-  get = (path, parent, should_break) => {
-    if (parent) path = parent.physical_address + `/${path}`;
+  get = (name, parent) => {
+    let path = parent ? `${parent.physical_address}/${name}` : name;
 
-    path = path.split("/");
-    path.splice(0, 2, `${path[0]}/${path[1]}`);
+    let obj = this.tree[path];
 
-    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;
-      }
+    if (!obj && parent) {
+      obj = new Folder(name, parent);
+      this.tree[obj.physical_address] = obj;
     }
-    return ini;
+
+    return obj;
   };
 }
 

package/Objects/Virtual_machine.js

@@ -9,12 +9,14 @@ class Virtual_machine extends Opcodes {
   }
 
   get_context = (index) => {
-    return this.contexts.slice(index != null ? index : -1)[0];
+    return this.contexts.slice(index == null ? -1 : index)[0];
   };
 
   /* VM moment */
   snap_id = () => {
-    return `${this.get_context().hash}-${this.mgr_index || -1}`;
+    return `${this.get_context().hash}-${
+      JSON.stringify({ ...this.track, account: "" }) || -1
+    }`;
   };
 
   parse_arg = (arg, cursor) => {
@@ -22,6 +24,7 @@ class Virtual_machine extends Opcodes {
 
     let args = arg.split("/"),
       i = 0;
+
     while (args[0] === "..") {
       i++;
 
@@ -33,8 +36,16 @@ class Virtual_machine extends Opcodes {
 
     arg = args.join("/");
 
+    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)}`;
+    }
+
     if (arg.startsWith("{*") && cursor) {
-      arg = context.explore(arg.splice(2, -1));
+      arg = context.explore(arg.slice(2, -1));
     } else if (arg.startsWith("{") && !cursor) {
       arg = context.explore(arg.slice(1, -1));
     }
@@ -42,13 +53,17 @@ class Virtual_machine extends Opcodes {
     return arg;
   };
 
-  execute = (instruction, mgr_index) => {
-    this.mgr_index = mgr_index;
+  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);
@@ -57,15 +72,13 @@ class Virtual_machine extends Opcodes {
 
     args = this.parse_arg(args, opcode === "cursor");
 
-    context.on(opcode, args);
-
     switch (opcode) {
       case "chain":
-        chain = context.parent.add_chain(args, mgr_index);
+        chain = context.parent.add_chain(args);
         this.contexts.push(chain);
 
         chain.append_buffer();
-        context.parent.account.send(chain);
+
         break;
       case "link":
         let folder = context.parent.account.manager.oracle.get(args);
@@ -81,21 +94,32 @@ class Virtual_machine extends Opcodes {
 
         this.contexts.push(chain);
 
-        context.parent.account.send(chain);
         break;
       case "listen":
         context.add_listener(args);
         break;
       case "mine":
-        let bloc = context.mine(this);
-        context.parent.account.send(bloc, null, bloc.chain.hash);
+        let bloc = context.mine(this, true);
+
+        this.account.buff(bloc, this.track.pid);
+
+        break;
+      case "run":
+        this.account.run({ query: original_arg }, this.stdin);
         break;
       case "pop":
         let blk;
         if (context.txs.length > 1) {
           blk = context.mine(this);
-          context.parent.account.send(blk, null, blk.chain.hash);
+        } 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 "cursor":
@@ -106,9 +130,8 @@ class Virtual_machine extends Opcodes {
         break;
       default:
         this.prepare_operation(opcode, context);
+        break;
     }
-
-    context.after(opcode, args);
   };
 }
 

package/framer.js

@@ -54,10 +54,9 @@ const framer = (initiator) => {
     },
   });
   frame.to_instruction();
+  let instructions = frame.flatten_instructions();
 
-  initiator.load({
-    instructions: frame.flatten_instructions(),
-  });
+  initiator.load({ instructions });
 };
 
 export default framer;

package/opcodes/std.js

@@ -1,5 +1,5 @@
 const stdout = (args) => {
-  console.log(args.op0);
+  console.log(args && args.op0);
 };
 
 export { stdout };

package/opcodes.js

@@ -9,9 +9,9 @@ const opcodes = (initiator) => {
 
   ops.map((op) => {
     set(op.name, (args) => {
-      console.log(args, "EMpty?");
       try {
         let result = eval(`${args.op0} ${op.sign} ${args.op1}`);
+
         return result;
       } catch (e) {
         console.log(e.message);
@@ -23,7 +23,7 @@ const opcodes = (initiator) => {
   set("jmp", jmp);
   set("jmp_if", jmp_if);
 
-  set("send", post_request);
+  set("send", (data) => post_request(data, initiator.vm.stdin));
   // set("socket_send", socket_send);
 
   set("stdout", stdout);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.0.6",
+  "version": "1.0.71",
   "description": "A data mediator.",
   "main": "Index.js",
   "types": "index.d.ts",

package/utils/create_server.js

@@ -1,11 +1,24 @@
 import http from "http";
-import { manager } from "../Index";
+import { is_port_available } from "./functions";
 
 let PORT = 1901,
   domain;
 
-const create_server = (initiator, serve) => {
-  PORT = (serve && serve.port) || PORT;
+const cb = (res, data) => {
+  if (typeof data !== "string") data = JSON.stringify(data);
+
+  res.end(data);
+};
+
+const create_server = async (initiator, serve) => {
+  if (!(serve && serve.port)) {
+    let av = await is_port_available(PORT);
+
+    while (!av) {
+      PORT++;
+      av = await is_port_available(PORT);
+    }
+  }
 
   let server = http.createServer((req, res) => {
     let data = "";
@@ -15,21 +28,29 @@ const create_server = (initiator, serve) => {
     });
 
     req.on("end", () => {
-      data = JSON.parse(data);
+      try {
+        data = JSON.parse(data);
+      } catch (e) {
+        return res.end(
+          JSON.stringify({ error_message: "Invalid data", error: true })
+        );
+      }
 
       if (req.url === "/distribute") {
-        if (data.blocks) {
-          manager.web.store_chain(data);
-        } else if (data.chain) {
-          manager.web.store_block(data);
-        }
-        res.end();
+        let obj = initiator.manager.web.sync(data);
+        res.end(obj ? obj.stringify(true) : "404");
       } else if (req.url === "/create_account") {
         let account = initiator.account(data.name, data.server);
-        res.end(JSON.stringify(account.stringify()));
+        res.end(account.stringify(true));
       } else if (req.url === "/load") {
-        initiator.load(data);
+        initiator.load(data, (datagram) => cb(res, datagram));
+      } else if (req.url === "/parse") {
+        initiator.parse(data, (datagram) => cb(res, datagram));
+      } else if (req.url === "/run") {
+        initiator.run(data, (datagram) => cb(res, datagram));
       }
+      if (serve && req.headers.host !== `${serve.domain}:${serve.port}`)
+        console.log(`services:${req.url}`);
     });
 
     req.on("error", (e) => {
@@ -39,14 +60,14 @@ const create_server = (initiator, serve) => {
   });
 
   server.listen(PORT, () => {
-    initiator.add_server({
+    let serv = {
       hostname: (serve && serve.domain) || domain || "127.0.0.1",
       port: PORT,
-    });
+    };
+    initiator.add_server(serv);
+    initiator.server = serv;
 
-    console.log(
-      `\n...GOD PROTOCOL RUNNING :${PORT}\nYour Public_key: ${process.env.PUBLIC_KEY}`
-    );
+    console.log(`\n...GOD PROTOCOL RUNNING :${PORT}`);
   });
 };
 

package/utils/functions.js

@@ -5,4 +5,66 @@ const array_to_nested_objects = (arr) => {
   return { [first]: array_to_nested_objects(rest) };
 };
 
-export { array_to_nested_objects };
+const transpile_object = (object) => {
+  let code_string = "",
+    type = typeof object;
+  if (type === "object") {
+    if (Array.isArray(object)) {
+      code_string += "arr(";
+      object.map((o) => {
+        code_string += `${transpile_object(o)},`;
+      });
+      code_string = code_string.slice(0, -1);
+      code_string += ")";
+    } else {
+      if (!object) code_string = "Void";
+      else {
+        code_string = "twain(";
+        for (let prop in object) {
+          let val = object[prop];
+          code_string += `${transpile_object(prop)}:${transpile_object(val)},`;
+        }
+        code_string = code_string.slice(0, -1);
+        code_string += ")";
+      }
+    }
+  } else if (type === "string") {
+    code_string = `"${object}"`;
+  } else if (type === "number") {
+    code_string = `${object}`;
+  } else if (type === "boolean") {
+    code_string = `${object}`;
+  }
+
+  return code_string;
+};
+
+const net = require("net");
+
+/**
+ * Check if a port is available
+ * @param {number} port - The port to check
+ * @returns {Promise<boolean>} - Resolves to true if the port is available, false otherwise
+ */
+function is_port_available(port) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve(false); // Port is in use
+      } else {
+        reject(err); // Some other error
+      }
+    });
+
+    server.once("listening", () => {
+      server.close();
+      resolve(true); // Port is available
+    });
+
+    server.listen(port);
+  });
+}
+
+export { array_to_nested_objects, transpile_object, is_port_available };

package/Aircode/utils/traverse.js

@@ -1,13 +0,0 @@
-const traverse = (parent, obj) => {
-  while (true) {
-    for (let c = 0; c < parent.children.length; c++) {
-      let child = parent.children[c];
-
-      if (!child.declaration && child.name === obj.name) return child;
-    }
-    parent = parent.parent;
-    if (!parent) break;
-  }
-};
-
-export { traverse };