godprotocol 1.0.799 → 1.0.833

package/Objects/Chain.js

@@ -27,9 +27,27 @@ 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.account.set_paths(this);
   }
 
+  manage_config = (init) => {
+    if (init) {
+      let dir = this.account.manager.oracle.fs.readdirSync(
+        this.folder.folder_path
+      );
+      this.blocks = dir.filter((d) => d !== ".config");
+      this.height = this.blocks.length;
+    }
+
+    this.folder.config.object = { ...this.stringify() };
+  };
+
   append_buffer = () => {
     this.buffs.push({});
     this.cursors.push(this.cursor);
@@ -50,8 +68,18 @@ class Chain extends Explorer {
     this.hash = hash(this.physical_address);
   };
 
+  build_block = (blk) => {
+    if (typeof blk === "string") {
+      let blk_data = this.folder.readone(blk);
+
+      blk = Block.build(blk_data, this);
+    }
+    return blk;
+  };
+
   get_block = (index) => {
-    return this.blocks[index];
+    let blk = this.blocks[index];
+    return this.build_block(blk);
   };
 
   add_tx = (instruction) => {
@@ -81,6 +109,17 @@ class Chain extends Explorer {
 
     block.timelapse = Date.now() - this.start_time;
 
+    this.manage_config();
+
+    let data = block.stringify();
+
+    data = this.account.manager.oracle.handle_compression({
+      addr: this.folder.folder_path,
+      data,
+      no_string: true,
+    });
+
+    this.folder.write(data);
     return block;
   };
 
@@ -89,7 +128,12 @@ class Chain extends Explorer {
     this.height = this.blocks.length;
   };
 
-  get_latest_block = () => this.blocks.slice(-1)[0];
+  get_latest_block = () => {
+    let blk = this.blocks.slice(-1)[0];
+    blk = this.build_block(blk);
+
+    return blk;
+  };
 
   stringify = (str) => {
     let obj = {};
@@ -99,11 +143,16 @@ class Chain extends Explorer {
     obj.parent = this.parent.path;
     obj.account = this.parent.account.name;
     obj.name = this.name;
-    obj.connections = this.connections.map(
-      (b) => new Object({ chain: b.chain.hash, block: b.hash })
+    obj.connections = this.connections.map((b) =>
+      b.stringify
+        ? new Object({
+            chain: b.chain.hash,
+            block: { hash: b.hash, _id: b._id },
+          })
+        : b
     );
     obj.hash = this.hash;
-    obj.blocks = this.blocks.map((blk) => blk.hash);
+    obj.blocks = this.blocks.map((blk) => blk.hash || blk);
 
     return str ? JSON.stringify(obj) : obj;
   };

package/Objects/Filesystem.js

@@ -39,14 +39,14 @@ class Filesystem {
   save = (content, chain, just_obj) => {
     let addr, obj;
 
-    let type = this.get_type(chain);
+    let type = typeof chain === "string" ? chain : this.get_type(chain);
 
     if (type === "array" || type === "string") {
       obj = [];
 
-      for (let curs in content) {
+      for (let curs in content)
         obj.splice(Number(curs) || -1, 0, content[curs]);
-      }
+
       if (type === "string") obj = obj.join(" ");
     } else if (type === "twain") {
       obj = {};

package/Objects/Manager.js

@@ -18,22 +18,24 @@ class Manager {
     this.clock = setInterval(() => {
       for (let account in this.tracks) {
         let track = this.tracks[account];
+        let program = track.slice(-1)[0];
 
-        let instruction = track.sequence[track.pointer];
+        if (program.hold) continue;
 
-        track.account.vm.execute(instruction, track);
-        track.pointer++;
+        let instruction = program.sequence[program.pointer];
 
-        if (track.pointer === track.sequence.length) {
-          this.running--;
-          track.account.chain.mine(track.account.vm);
-          track.account.flush_buffer(track.pids.splice(-1)[0]);
+        program.account.vm.execute(instruction, program);
+        program.pointer++;
 
-          delete this.tracks[account];
-        }
+        if (program.pointer === program.sequence.length) {
+          program.account.flush_buffer(program.pid);
 
-        if (track.breakpoint.slice(-1)[0] === track.pointer) {
-          track.account.flush_buffer(track.pids.splice(-1)[0]);
+          track.pop();
+        }
+        if (!track.length) {
+          this.running -= 1;
+          delete this.tracks[account];
+          program.account.chain.mine(program.account.vm);
         }
       }
 
@@ -48,8 +50,8 @@ class Manager {
 
     if (!account) {
       account = new Account(name, { ...meta, manager: this });
-      framer(account);
       opcodes(account);
+      framer(account);
 
       this.accounts[account.name] = account;
     } else if (meta && meta.private && !account.private) {
@@ -63,23 +65,10 @@ class Manager {
     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);
-
-      if (!this.running) {
-        this.running++;
-        this.tracks[program.account.name] = track;
-        this.start_clock();
-      }
+      track.push({ ...program, pointer: 0 });
     } else {
-      track = {
-        ...program,
-        pointer: 0,
-        pids: [program.pid],
-        breakpoint: new Array(),
-      };
-      this.tracks[track.account.name] = track;
+      track = [{ ...program, pointer: 0 }];
+      this.tracks[program.account.name] = track;
 
       this.running++;
       this.running === 1 && this.start_clock();

package/Objects/Opcodes.js

@@ -1,4 +1,4 @@
-import { transpile_object } from "../utils/functions";
+import { obj } from "../framer";
 
 class Opcodes {
   constructor() {
@@ -7,6 +7,8 @@ class Opcodes {
 
   set = (opcode, circuit) => {
     this.opcodes[opcode] = circuit;
+    obj.Opcodes[opcode] = null;
+
     this.account.assembler.opcodes.push(opcode);
   };
 
@@ -17,19 +19,29 @@ 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);
+    let res = circ(args, this);
 
     this.stdin(res);
   };
 
   stdin = (object, cb) => {
-    if (object == null) return;
+    if (object == null) {
+      this.flags.void = true;
+      return;
+    }
+    this.flags.void = false;
+
+    this.flags.zero = !object;
+    if (typeof object === "number") this.flags.neg = object < 0;
 
-    let code_string = transpile_object(object);
+    let code_string =
+      typeof object !== "string" ? JSON.stringify(object) : object;
 
-    this.account.compiler.run(code_string, { cb, pure: true });
+    this.account.assembler.run(code_string, { cb, pure: true });
     // console.log(`Writing in: ${code_string}`);
   };
 }

package/Objects/Oracle.js

@@ -1,12 +1,27 @@
 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(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 +29,106 @@ class Oracle {
     };
   };
 
-  get = (path) => this.datapaths[path];
+  get = (path) => {
+    let obj = this.datapaths[path];
+
+    if (!obj) {
+      try {
+        obj = this.fs.readFileSync(path);
+        obj = JSON.parse(obj).data;
+        let type = obj && obj.data && typeof obj.data;
+        type =
+          type === "object" ? (Array.isArray(obj) ? "array" : "twain") : type;
+
+        obj = { type, obj };
+        this.set(path, obj);
+      } catch (e) {}
+    }
+
+    return obj;
+  };
+
+  hash = (data) => {
+    data = typeof data !== "string" ? JSON.stringify(data) : data;
+    return hash(data);
+  };
+
+  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(address, data, { encoding: "utf-8" });
+  };
+
+  fetch = (payload, callback, val_err_cb) => {
+    let { physical_address, config, query, account, signature } = 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) {
+        result = folder.config;
+      } 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];
 
-  write = (addr, data, meta = { encoding: "utf-8" }) => {
-    if (typeof data !== "string") data = JSON.stringify(data);
+          result =
+            operation && operation(query.query, { ...query.options, payload });
 
-    this.fs.writeFileSync(addr, data, meta);
+          if (result) {
+            if (account) {
+              // let content = account.read(result.data);
+              // if (content != null) result.content = content;
+            }
+          }
+        }
+      }
+    } catch (e) {
+      result = { error: true, message: e.message, payload };
+    }
+    typeof callback === "function" && callback(result);
   };
 }
 

package/Objects/Virtual_machine.js

@@ -7,6 +7,12 @@ class Virtual_machine extends Opcodes {
     this.account = context.account;
     this.contexts = [context];
     this.stack = new Array();
+    this.flags = {
+      neg: false,
+      equal: false,
+      zero: false,
+      void: false,
+    };
   }
 
   get_context = (index) => {
@@ -68,6 +74,8 @@ class Virtual_machine extends Opcodes {
 
     context.add_tx(instruction);
 
+    // console.log(instruction);
+
     let chain;
 
     args = this.parse_arg(args, opcode === "cursor");
@@ -77,6 +85,13 @@ class Virtual_machine extends Opcodes {
         chain = context.account.add_chain(args, context);
         this.contexts.push(chain);
 
+        let dim = context.folder.config.dimensions;
+        if (!dim) {
+          dim = [];
+          context.folder.config.dimensions = dim;
+        }
+        !dim.find((d) => d === args) && dim.push(args);
+
         chain.append_buffer();
 
         break;
@@ -84,6 +99,12 @@ class Virtual_machine extends Opcodes {
         chain = context.account.manager.web.get(args);
 
         if (!chain) {
+          this.account.flush_buffer(this.track.pid, {
+            error: true,
+            error_message: `LINKing Failed. - ${args}`,
+          });
+          this.track.pointer = this.track.sequence.length;
+
           console.log(`LINKing Failed. - ${args}`);
           return;
         }
@@ -96,7 +117,7 @@ class Virtual_machine extends Opcodes {
       case "mine":
         let bloc = context.mine(this, true);
 
-        this.account.buff(bloc, this.track.pids.slice(-1)[0]);
+        this.account.buff(bloc, this.track.pid);
 
         break;
       case "pop":
@@ -109,7 +130,7 @@ class Virtual_machine extends Opcodes {
 
           context.txs = [];
         }
-        blk && this.account.buff(blk, this.track.pids.slice(-1)[0]);
+        blk && this.account.buff(blk, this.track.pid);
 
         this.contexts.pop();
         break;

package/framer.js

@@ -1,61 +1,56 @@
 import Frame from "./Objects/Frame";
 
-const framer = (initiator) => {
-  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,
+let obj = {
+  Opcodes: {
+    add: null,
+    equal: null,
+    multiply: null,
+    subtract: null,
+    divide: null,
+    exp: null,
+    equal: null,
 
-      send: null,
-      readonly: null,
-      socket_send: null,
+    send: null,
+    readonly: null,
+    socket_send: null,
 
-      jmp: null,
-      jmp_if: null,
-      hold: null,
+    jmp: null,
 
-      stdout: null,
-      stdin: null,
+    stdout: null,
+    stdin: null,
 
-      run: null,
-      load: null,
-      parse: null,
-      create_account: null,
+    run: null,
+    load: null,
+    parse: null,
+    create_account: null,
+  },
+  Datatypes: {
+    Number: null,
+    String: null,
+    Twain: null,
+    Array: null,
+  },
+  Objects: {
+    Blockchain: {
+      Chain: null,
+      Block: null,
     },
-    Datatypes: {
-      Number: null,
-      String: null,
-      Twain: null,
-      Array: null,
+    Folder: {
+      active_file: null,
+      folder: null,
+      file: null,
     },
-    Objects: {
-      Blockchain: {
-        Chain: null,
-        Block: null,
-      },
-      Folder: {
-        active_file: null,
-        folder: null,
-        file: null,
-      },
-      File: {
-        row: null,
-        parse: null,
-        column: null,
-        write: null,
-      },
+    File: {
+      row: null,
+      parse: null,
+      column: null,
+      write: null,
     },
-  });
+  },
+};
+
+const framer = (initiator) => {
+  let frame = new Frame(obj);
   frame.to_instruction();
   let instructions = frame.flatten_instructions();
 
@@ -63,3 +58,4 @@ const framer = (initiator) => {
 };
 
 export default framer;
+export { obj };

package/opcodes/add.js

@@ -5,11 +5,6 @@ let ops = [
   { name: "divide", sign: "/" },
   { name: "exp", sign: "**" },
   { name: "equal", sign: "==" },
-  { name: "not_equal", sign: "!=" },
-  { name: "greater_than", sign: ">" },
-  { name: "less_than", sign: "<" },
-  { name: "gte", sign: ">=" },
-  { name: "lte", sign: "<=" },
 ];
 
 export { ops };

package/opcodes/indices.js

@@ -0,0 +1,28 @@
+const getter = (args) => {
+  let base = args.op0;
+  if (typeof base === "number") return base;
+
+  if (typeof base === "string") return base[args.op1];
+
+  if (Array.isArray(base)) return base.slice(args.op1)[0];
+
+  return base[args.op1];
+};
+
+const setter = (args) => {
+  let base = args.op0;
+  if (typeof base === "number") return base;
+
+  if (typeof base === "string") {
+    base = `${base.slice(0, args.op2)}${args.op1}${base.slice(args.op2 + 1)}`;
+  } else {
+    if (Array.isArray(base)) {
+      if (args.op2 == null || args.op2 >= base.length) base.push(args.op1);
+      else base[args.op2] = args.op1;
+    } else base[args.op2] = args.op1;
+  }
+
+  return base;
+};
+
+export { setter, getter };

package/opcodes/jmp.js

@@ -1,15 +1,14 @@
-const jmp = (args, vm) => {
-  vm.account.manager.tracker[vm.mgr_index].pointer += args.index;
-};
+const jmp = (args, vm, meta) => {
+  meta = meta || {};
+  let { flag, inverse } = meta;
 
-const jmp_if = (args, vm) => {
-  if (args.passed)
-    vm.account.manager.tracker[vm.mgr_index].pointer += args.index;
-};
+  let condition;
+  if (flag) condition = vm.flags[flag];
+  if (inverse) condition = !!!condition;
 
-const hold = (args, vm) => {
-  let track = vm.account.manager.tracker[vm.mgr_index];
-  track.hold = args.hold;
+  if ((condition || !flag) && typeof args.op0 === "number") {
+    vm.track.pointer = args.op0;
+  }
 };
 
-export { jmp, jmp_if, hold };
+export { jmp };

package/opcodes/std.js

@@ -1,6 +1,8 @@
-const stdout = (args) => {
+const stdout = (args, vm) => {
   if (!args) return;
 
+  vm.account.stdout.push({ data: args, pid: vm.track.pid });
+
   for (let v in args) console.log(args[v]);
 };
 

package/opcodes.js

@@ -1,6 +1,7 @@
 // import { socket_send } from "./Socket";
 import { ops } from "./opcodes/add";
-import { hold, jmp, jmp_if } from "./opcodes/jmp";
+import { getter, setter } from "./opcodes/indices";
+import { jmp } from "./opcodes/jmp";
 import { stdout } from "./opcodes/std";
 import { post_request } from "./utils/services";
 
@@ -13,6 +14,10 @@ const opcodes = (account) => {
 
       try {
         let result = eval(`${args.op0} ${op.sign} ${args.op1}`);
+        if (op.sign === "==") {
+          account.vm.flags.equal = !!result;
+          return;
+        }
 
         return result;
       } catch (e) {
@@ -21,16 +26,27 @@ const opcodes = (account) => {
     });
   });
 
-  set("hold", hold);
+  Object.keys(account.vm.flags).map((flag) => {
+    set(`jmp_${flag}`, (args, vm) => jmp(args, vm, { flag }));
+    set(`jmp_not_${flag}`, (args, vm) =>
+      jmp(args, vm, { flag, inverse: true })
+    );
+  });
   set("jmp", jmp);
-  set("jmp_if", jmp_if);
+
+  set("setter", setter);
+  set("getter", getter);
 
   set("send", (data) => post_request(data, account.vm.stdin));
   // set("socket_send", socket_send);
 
   set("stdout", stdout);
 
-  ["run", "load", "parse", "create_account"].map((op) =>
+  set("hold", (arg) => (vm.track.hold = !!arg.op0));
+
+  set("add_server", (args, vm) => account.add_server(args && args.op0));
+
+  [("run", "load", "parse", "create_account")].map((op) =>
     set(op, (arg) => arg && arg.op0 && account[op](arg && arg.op0))
   );
 };