godprotocol 1.0.835 → 1.0.837

package/Index.js

@@ -1,5 +1,30 @@
 import Manager from "./Objects/Manager";
 import create_server from "./utils/create_server";
 
+let manager = new Manager();
+
+let initiator = manager.initiate({
+  on_framed: () =>
+    initiator.assembler.run(
+      `@/datastore/main
+
+@/datastore/main/grey
+>matter 'lola'
+;
+
+
+    >storage {}
+    
+    ;`,
+      {
+        cb: (blks) => {
+          console.log(!!blks, "did");
+        },
+      }
+    ),
+});
+
+create_server(null, { manager });
+
 export default Manager;
 export { create_server };

package/Loader_sequence/main.js

@@ -1,4 +1,5 @@
 import { _id } from "generalised-datastore/utils/functions";
+import Repository from "./repository";
 
 let num_pattern = /^[+-]?\d+(\.\d+)?$/;
 // let str_pattern = /^["'][^"']*["']$/;
@@ -18,20 +19,7 @@ class Loader {
     this.programs_index = -1;
 
     // Code Repository
-    this.oracle = this.account.manager.oracle;
-    this.programs_folder = this.oracle.get_folder("programs", {
-      joins: ["codes"],
-    });
-    this.codes_folder = this.oracle.get_folder("codes");
-
-    this.globals = this.oracle.get_folder("globals", {
-      subfolder: ["global"],
-    });
-
-    if (!this.globals.readone({ global: "programs" }))
-      this.globals.write({ global: "programs", programs: [] });
-    if (!this.globals.readone({ global: "codes" }))
-      this.globals.write({ global: "codes", codes: [] });
+    this.repository = new Repository(this);
   }
 
   instruction_index = () => {
@@ -537,6 +525,8 @@ class Loader {
 
     this.compile(codes);
 
+    if (meta.instructions) return [...this.instructions];
+
     // console.log(JSON.stringify(this.instructions, null, 2), "hiya");
 
     this.account.load({
@@ -544,48 +534,8 @@ class Loader {
       callback: cb,
     });
 
-    let programs = this.globals.readone({ global: "programs" });
-    let codes_global = this.globals.readone({ global: "codes" });
-    this.program_configs.map((config) => {
-      let program = programs.programs.find(
-        (prog) => prog.physical_address === config.physical_address
-      );
-
-      let code_str = config.codes.join("\n");
-      let code_hash = this.oracle.hash(code_str);
-      let code = codes_global.codes.find((cod) => cod.hash === code_hash);
-      let code_id = code && code.code_id;
-      if (!code_id) {
-        code_id = _id("codes");
-
-        this.globals.update(
-          { global: "codes" },
-          { codes: { $unshift: { code_id, hash: code_hash } } }
-        );
-      }
+    this.program_configs.map((config) => this.repository.add_program(config));
 
-      if (program) {
-        config._id = program.program_id;
-        this.programs_folder.update(config._id, {
-          ...config,
-          codes: { $unshift: code_id },
-        });
-      } else {
-        this.programs_folder.write({ ...config, codes: [code_id] });
-        this.globals.update(
-          { global: "programs" },
-          {
-            programs: {
-              $unshift: {
-                physical_address: config.physical_address,
-                program_id: config._id,
-              },
-            },
-          }
-        );
-      }
-      !code && this.codes_folder.write({ codes: code_str, _id: code_id });
-    });
     this.program_configs = [];
     this.instructions = [];
     this.pure = false;

package/Loader_sequence/repository.js

@@ -0,0 +1,32 @@
+class Repository {
+  constructor(main) {
+    this.main = main;
+    this.oracle = this.main.account.manager.oracle;
+    this.gds = this.oracle.gds;
+    this.programs = this.gds.folder("programs");
+    this.codes = this.gds.folder("codes");
+  }
+
+  add_program = (config) => {
+    let code_hash = this.oracle.hash(config.codes);
+    let code_exist = this.codes.readone({ hash: code_hash });
+
+    let code = this.codes.write({
+      body: config.codes,
+      hash: code_hash,
+      _id: code_exist && code_exist._id,
+    });
+    config.codes = code._id;
+
+    let program_hash = this.oracle.hash(JSON.stringify(config));
+    let program_exist = this.programs.readone({ hash: program_hash });
+
+    this.programs.write({
+      ...config,
+      hash: program_hash,
+      _id: program_exist && program_exist._id,
+    });
+  };
+}
+
+export default Repository;

package/Objects/Account.js

@@ -31,14 +31,42 @@ class Account extends Filesystem {
     this.mine_buffer = {};
     this.privileges = new Object();
 
+    this.events = new Object();
+
     console.log(`Account Instance: ${this.name}`);
   }
 
+  on = (event, handler) => {
+    let handlers = this.events[event];
+    if (!handlers) {
+      handlers = new Array();
+      this.events[event] = handlers;
+    }
+    handlers.push(handler);
+  };
+
+  emit = (event, data) => {
+    let handlers = this.events[event];
+    Array.isArray(handlers) &&
+      handlers.map((handle) => this.run_callback(handle, data));
+  };
+
   propagate = (data, endpoint) => {
     if (data.is_propagated) return;
 
     let servers = this.privileges[endpoint];
 
+    if (data.exclusive) {
+      if (typeof data.exclusive === "boolean") return;
+      else if (Array.isArray(data.exclusive)) {
+        servers =
+          servers &&
+          servers.filter((serv) => {
+            return data.exclusive.includes(serv.domain);
+          });
+      }
+    }
+
     data.is_propagated = true;
     data = JSON.stringify(data);
 
@@ -97,57 +125,49 @@ class Account extends Filesystem {
   };
 
   load = (payload) => {
-    let { program, signature, callback } = payload;
-    let { instructions, account } = program;
-    account = this.get_account(account);
-    account.propagate(payload, "load");
+    let { program, callback } = payload;
+    let { instructions, assemble } = program;
 
-    if (!account.validate(program, signature, callback)) return;
+    this.propagate(payload, "load");
 
-    let pid = account.manage_buffer(callback);
+    if (assemble) {
+      this.assembler.run(instructions, { cb: callback });
+    } else {
+      let pid = this.manage_buffer(callback);
 
-    this.manager.push({ sequence: instructions, account, pid });
+      this.manager.push({ sequence: instructions, account: this, pid });
+    }
   };
 
   parse = (program) => {
-    let { payload, callback } = program;
-    let { account } = payload;
-    account = this.get_account(account);
-    account.propagate(program, "parse");
-
-    account.manager.oracle.fetch(
-      payload,
-      (result) => account.run_callback(callback, result),
-      () =>
-        account.run_callback(callback, {
-          private: account.private,
-          error: true,
-          error_message: "Invalid signature",
-        })
+    let { payload, callback, signature } = program;
+
+    this.propagate(program, "parse");
+
+    this.manager.oracle.fetch({ ...payload, signature }, (result) =>
+      this.run_callback(callback, result)
     );
   };
 
   run = (request) => {
-    let { payload, signature, callback } = request;
+    let { payload, callback } = request;
 
-    let { physical_address, account, query, history } = payload;
+    let { physical_address, query, history } = payload;
 
     history = Math.abs(Number(history)) || 0;
-    account = this.get_account(account);
-    account.propagate(request, "run");
 
-    if (!account.validate(payload, signature, callback)) return;
+    this.propagate(request, "run");
 
-    let pid = account.manage_buffer(callback);
+    let pid = this.manage_buffer(callback);
 
     let context = physical_address
       ? this.manager.web.get(physical_address)
-      : account.vm.get_context();
+      : this.vm.get_context();
 
     if (!context) {
       if (physical_address)
         context = this.manager.web.split_set(physical_address);
-      else return account.flush_buffer(pid);
+      else return this.flush_buffer(pid);
     }
 
     let blk = query ? context.explore(query) : context.get_latest_block();
@@ -179,17 +199,17 @@ class Account extends Filesystem {
     if (blk && blk.metadata && blk.metadata.program) {
       let program = this.read(blk.metadata.program);
 
-      account.vm.contexts.push(context);
+      this.vm.contexts.push(context);
       program.push("pop");
 
       Array.isArray(program) &&
         program.length &&
         this.manager.push({
           sequence: program,
-          account,
+          account: this,
           pid,
         });
-    } else account.flush_buffer(pid);
+    } else this.flush_buffer(pid);
   };
 
   run_callback = (callback, payload) => {
@@ -257,11 +277,6 @@ class Account extends Filesystem {
 
     return this.manager.add_account(name, meta);
   };
-
-  endpoint = (endpoint, payload) => {
-    let method = this[endpoint];
-    typeof method === "function" && method(payload);
-  };
 }
 
 export default Account;

package/Objects/Block.js

@@ -54,16 +54,7 @@ class Block {
     obj.hash = this.hash;
     obj.data = this.data;
     obj._id = this._id;
-    obj.children = this.children.map((ch) =>
-      ch.stringify
-        ? new Object({
-            hash: ch.hash,
-            chain: ch.chain.hash,
-            _id: ch._id,
-            physical_address: ch.chain.physical_address,
-          })
-        : ch
-    );
+    obj.children = this.children.map((ch) => ch._id);
     obj.chain = {
       hash: this.chain.hash,
       physical_address: this.chain.physical_address,

package/Objects/Chain.js

@@ -28,24 +28,22 @@ class Chain extends Explorer {
     this.generate_hash();
 
     this.folder = this.account.manager.oracle.gds.folder(this.hash);
-    this.height = this.folder.config.total_files;
-    this.prev_hash = this.folder.config.recent_file;
-
-    this.manage_config(true);
+    this.height = this.folder.config.stats.total_files;
+    this.prev_hash = this.folder.config.stats.recent_file;
 
     this.account.set_paths(this);
+
+    this.manage_config(true);
   }
 
   manage_config = (init) => {
     if (init) {
-      let dir = this.account.manager.oracle.fs.readdirSync(
-        this.folder.folder_path
-      );
+      let dir = this.account.manager.oracle.fs.readdirSync(this.folder.path);
       this.blocks = dir.filter((d) => d !== ".config");
       this.height = this.blocks.length;
     }
 
-    this.folder.config.object = { ...this.stringify() };
+    this.folder.config.add_entry("object", this.stringify());
   };
 
   append_buffer = () => {
@@ -70,7 +68,7 @@ class Chain extends Explorer {
 
   build_block = (blk) => {
     if (typeof blk === "string") {
-      let blk_data = this.folder.readone(blk);
+      let blk_data = this.folder.readone(blk, { depth: 1 });
 
       blk = Block.build(blk_data, this);
     }

package/Objects/Manager.js

@@ -1,3 +1,4 @@
+import { _id } from "generalised-datastore/utils/functions";
 import framer from "../framer";
 import opcodes from "../opcodes";
 import Account from "./Account";
@@ -9,21 +10,31 @@ class Manager {
     meta = meta || {};
 
     this.compression = meta.compression;
-
+    this.manager_id = _id("manager");
     this.accounts = new Object();
     this.running = 0;
     this.tracks = new Object();
     this.web = new Blockweb(this);
     this.oracle = new Oracle(this, { compression: this.compression });
+    this.servers = new Array();
   }
 
+  stringify = (str) => {
+    let obj = {
+      _id: this.manager_id,
+      servers: this.servers,
+    };
+
+    return str ? JSON.stringify(obj) : obj;
+  };
+
   initiate = (meta) => {
-    let initiator = this.add_account(
+    this.initiator = this.add_account(
       process.env.INITIATOR || "initiator",
       meta
     );
 
-    return initiator;
+    return this.initiator;
   };
 
   start_clock = () => {
@@ -59,19 +70,29 @@ class Manager {
   get_account = (name) => this.accounts[name];
 
   add_account = (name, meta) => {
-    let account = this.get_account(name);
+    meta = meta || {};
+    if (!name) name = meta.name;
 
-    if (!account) {
-      account = new Account(name, { ...meta, manager: this });
-      opcodes(account);
-      framer(account);
+    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 });
+
+        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) => {
@@ -87,6 +108,36 @@ class Manager {
       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) {
+      return this.get_initiator().run_callback(callback, {
+        error: true,
+        error_message: "Account is not found",
+        payload,
+        endpoint,
+      });
+    }
+
+    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);
+  };
 }
 
 export default Manager;

package/Objects/Oracle.js

@@ -74,57 +74,30 @@ class Oracle {
     this.fs.writeFileSync(address, data, { encoding: "utf-8" });
   };
 
-  fetch = (payload, callback, val_err_cb) => {
-    let { physical_address, config, query, account, signature } = payload,
+  fetch = async (payload, callback) => {
+    let { physical_address, config, remote, query } = payload,
       result;
 
-    account = this.mgr.get_account(account);
-    if (account && account.private)
-      if (
-        !account.validate(
-          { physical_address, account, query },
-          signature,
-          callback
-        )
-      )
-        return typeof val_err_cb === "function" && val_err_cb();
-
-    try {
-      let folder = this.gds.folder(this.hash(physical_address));
-
-      if (config) {
-        folder.add_remote(config);
-
-        result = folder.config;
+    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 {
-        if (!folder.check_remote(query.operation)) {
-          result = {
-            error: true,
-            error_message: "Forbidden remote operations",
-            payload,
-          };
-        } else {
-          if (query.operation === "call") {
-            let compressed_result = this.compression({ payload, val_err_cb });
-            if (compressed_result && compressed_result.halt)
-              return (
-                typeof callback === "function" &&
-                callback({ compressed: true, data: compressed_result })
-              );
-            query = (compressed_result && compressed_result.query) || query;
-          }
-
-          let operation = folder[query.operation];
-
-          result =
-            operation &&
-            operation(query.query, { ...query.options, account, payload });
-        }
+        let op = folder[query.operation];
+
+        result = await op(query.query, query.options);
+        folder.remote_stuff(remote, result);
       }
-    } catch (e) {
-      result = { error: true, message: e.message, payload };
     }
-    typeof callback === "function" && callback(result);
+
+    callback(result);
   };
 }
 

package/framer.js

@@ -49,12 +49,22 @@ let obj = {
   },
 };
 
-const framer = (initiator) => {
+const framer = (initiator, cb) => {
   let frame = new Frame(obj);
   frame.to_instruction();
   let instructions = frame.flatten_instructions();
 
-  initiator.load({ program: { instructions } });
+  let start = Date.now();
+  initiator.load({
+    program: { instructions },
+    callback: (blks) => {
+      console.log(
+        `Account:${initiator.name} is ready in ${Date.now() - start}ms.`
+      );
+
+      cb && cb(blks);
+    },
+  });
 };
 
 export default framer;

package/opcodes.js

@@ -44,10 +44,14 @@ const opcodes = (account) => {
 
   set("hold", (arg) => (vm.track.hold = !!arg.op0));
 
-  set("add_server", (args, vm) => account.add_server(args && args.op0));
+  set("add_server", (args) => account.add_server(args && args.op0));
 
-  [("run", "load", "parse", "create_account")].map((op) =>
-    set(op, (arg) => arg && arg.op0 && account[op](arg && arg.op0))
+  ["run", "load", "parse"].map((op) =>
+    set(op, (arg) => arg && arg.op0 && manager.endpoint(op, arg && arg.op0))
+  );
+
+  set("add_account", (arg) =>
+    manager.add_account({ ...arg.op0, string: true })
   );
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.0.835",
+  "version": "1.0.837",
   "description": "A data mediator.",
   "main": "Index.js",
   "types": "types/index.d.ts",
@@ -46,7 +46,7 @@
     "crypto": "^1.0.1",
     "elliptic": "^6.5.5",
     "fs": "^0.0.1-security",
-    "generalised-datastore": "^1.7.85"
+    "generalised-datastore": "^2.0.112"
   },
   "publishConfig": {
     "ignore": [

package/utils/create_server.js

@@ -1,7 +1,7 @@
 import http from "http";
 import { is_port_available } from "./functions";
 
-let PORT = Number(process.env.PORT) || 1408;
+let PORT = Number(process.env.PORT) || 1409;
 
 const cb = (res, data) => {
   if (typeof data !== "string") data = JSON.stringify(data);
@@ -12,16 +12,10 @@ const cb = (res, data) => {
 let extensions = new Object();
 
 const extension = (route, handler) => {
-  let handlers = extensions[route];
-  if (!handlers) {
-    handlers = new Array();
-    extensions[route] = handlers;
-  }
-
-  handlers.push(handler);
+  extensions[route] = handler;
 };
 
-const handle_routes = (req, res, app, initiator) => {
+const handle_routes = (req, res, app, manager) => {
   let data = "";
 
   let is_in_default_routes = [
@@ -48,27 +42,26 @@ const handle_routes = (req, res, app, initiator) => {
       }
 
       if (req.url === "/create_account") {
-        let account = initiator.create_account(data);
-        res.end(account.stringify(true));
+        let account = manager.add_account(null, { ...data, string: true });
+
+        res.end(account);
       } else if (["run", "load", "parse"].includes(req.url.slice(1))) {
-        let payload = {
-          ...data,
-          callback: (datagram) => cb(res, datagram),
-        };
-        initiator.endpoint(req.url.slice(1), payload);
+        manager.endpoint(req.url.slice(1), payload, (datagram) =>
+          cb(res, datagram)
+        );
       } else {
         let extension = extensions[req.url.slice(1)];
 
-        extension &&
-          extension.map((ex) => {
-            typeof ex === "function" && ex(data, { req, res });
-          });
+        if (typeof extension !== "function") {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: true, error_message: "Not Found" }));
+        } else extension(data, { req, res });
       }
     });
 
     req.on("error", (e) => {
       // res.writeHead(500, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ status: "error", message: e.message }));
+      res.end(JSON.stringify({ status: "error", error_message: e.message }));
     });
   } else {
     app && app(req, res);
@@ -92,11 +85,12 @@ const create_server = async (app, settings) => {
   PORT = port;
 
   let server = http.createServer((req, res) =>
-    handle_routes(req, res, app, settings.initiator)
+    handle_routes(req, res, app, settings.manager)
   );
 
   server.listen(port, () => {
     console.log(`\n...GOD PROTOCOL RUNNING :${port}`);
+    manager.add_server({ ...settings.server_details, port: PORT });
   });
 };