godprotocol 1.0.799 → 1.0.831

package/Loader_sequence/main.js

@@ -11,6 +11,7 @@ class Loader {
     this.instruction_indexes = new Array();
     this.instruction_stacks = [[]];
     this.stacks = new Array(account.physical_address);
+    this.markers = new Array();
   }
 
   instruction_index = () => {
@@ -252,6 +253,8 @@ class Loader {
     } else this.push_instruction(`pop ${identifier.value}`);
   };
 
+  marker_pattern = /@[a-zA-Z_][a-zA-Z0-9_]*/;
+
   parse_opcode = (line) => {
     let tokens = Array.isArray(line) ? line : this.parse_tokens(line);
 
@@ -265,11 +268,19 @@ class Loader {
     ]);
 
     tokens.slice(1).map((tok, i) => {
-      this.parse(tok);
+      if (tok.type === "address" && tok.value.match(this.marker_pattern)) {
+        this.push_instruction([
+          `link ${this.account.physical_address}/Datatypes/Number`,
+          `write ${tok.value}`,
+          `pop Number`,
+        ]);
+      } else this.parse(tok);
+
       this.push_instruction([
         `cursor op${i}`,
         `write ${
-          this.is_not_literal(tok.type)
+          this.is_not_literal(tok.type) &&
+          !(tok.type === "address" && tok.value.match(this.marker_pattern))
             ? "{metadata.output:-1}"
             : "{datapath:-1}"
         }`,
@@ -351,6 +362,58 @@ class Loader {
     this.instruction_indexes.pop();
   };
 
+  revamp_marks = () => {
+    let instruction_stack = this.instruction_stacks.slice(-1)[0];
+
+    instruction_stack = instruction_stack.map((ins) =>
+      this.resolve_offset(ins, true)
+    );
+
+    this.instruction_stacks[this.instruction_stacks.length - 1] =
+      instruction_stack;
+  };
+
+  handle_marker = (line) => {
+    let splits = line.slice(1).split(" ");
+    let name = splits[0];
+
+    let curr_stack = this.stacks.slice(-1)[0];
+    let markers = this.markers[curr_stack];
+    if (!markers) {
+      markers = new Object();
+      this.markers[curr_stack] = markers;
+    }
+    markers[name] = this.instruction_index();
+
+    this.revamp_marks();
+
+    return splits.slice(1).join(" ");
+  };
+
+  resolve_offset = (line, revamping) => {
+    let matches = line.match(this.marker_pattern),
+      value;
+    if (matches) {
+      let match = matches[0].slice(1);
+
+      let curr_stack = this.stacks.slice(-1)[0];
+      let markers = this.markers[curr_stack];
+      if (!markers) {
+        markers = new Object();
+        this.markers[curr_stack] = markers;
+      }
+      value = markers[match];
+    }
+
+    if (typeof value === "number")
+      line = line.replace(
+        this.marker_pattern,
+        (revamping && value > 0 ? value - 1 : value).toString()
+      );
+
+    return line;
+  };
+
   compile = (codes) => {
     let code_array = codes.split("\n");
 
@@ -358,8 +421,15 @@ class Loader {
       let line = code_array[c].trim();
       if (!line) continue;
 
+      if (line.startsWith(":")) {
+        line = this.handle_marker(line);
+
+        if (!line) continue;
+      }
+
+      line = this.resolve_offset(line);
+
       if (line === ";") this.pop();
-      else if (line.startsWith("link ")) this.parse_routine(line);
       else if (line.startsWith(".") || line.startsWith("@"))
         this.parse_routine(line);
       else if (line.startsWith("//")) continue;
@@ -369,9 +439,11 @@ class Loader {
     }
   };
 
-  run = (codes, meta = { cb, pure }) => {
+  run = (codes, meta) => {
     if (!meta) meta = {};
-    this.pure = pure;
+    this.pure = meta && meta.pure;
+
+    let cb = meta && meta.cb;
 
     this.compile(codes);
 

package/Objects/Account.js

@@ -1,5 +1,6 @@
 import Loader_sequence from "../Loader_sequence/main";
 import validate_signature from "../utils/privacy";
+import { post_request } from "../utils/services";
 import Filesystem from "./Filesystem";
 import Virtual_machine from "./Virtual_machine";
 
@@ -13,6 +14,8 @@ class Account extends Filesystem {
     this.private = meta.private;
     this.manager = meta.manager;
     this.account = this;
+    this.stdin = new Array();
+    this.stdout = new Array();
 
     if (!this.manager) throw new Error("Manager instance missing.");
 
@@ -20,16 +23,53 @@ class Account extends Filesystem {
     this.physical_address = `${this.base_address}/${this.name}`;
     this.set_paths(this);
 
-    this.compiler = new Loader_sequence(this);
+    this.assembler = new Loader_sequence(this);
 
     this.chain = this.account_chain(this);
     this.vm = new Virtual_machine(this.chain);
 
     this.mine_buffer = {};
+    this.privileges = new Object();
 
     console.log(`Account Instance: ${this.name}`);
   }
 
+  propagate = (data, endpoint) => {
+    if (data.is_propagated) return;
+
+    let servers = this.privileges[endpoint];
+
+    data.is_propagated = true;
+    data = JSON.stringify(data);
+
+    if (servers && servers.length) {
+      servers.map((serv) => {
+        post_request({
+          options: {
+            ...serv,
+            path: `/${endpoint}`,
+          },
+          data,
+        });
+      });
+    }
+  };
+
+  add_server = ({ server, privileges }) => {
+    if (!Array.isArray(privileges) && privileges)
+      privileges = ["load", "parse", "run", "create_account"];
+
+    privileges.map((privilege) => {
+      let priv = this.privileges[privilege];
+      if (!priv) {
+        priv = [];
+        this.privileges[privilege] = priv;
+      }
+      if (!priv.find((serv) => serv.domain === server.domain))
+        priv.push(server);
+    });
+  };
+
   get_account = (name) => {
     return this.manager.get_account(name) || this;
   };
@@ -56,20 +96,24 @@ class Account extends Filesystem {
     delete this.mine_buffer[pid];
   };
 
-  load = ({ program, signature, callback }) => {
+  load = (payload) => {
+    let { program, signature, callback } = payload;
     let { instructions, account } = program;
     account = this.get_account(account);
+    account.propagate(payload, "load");
 
-    if (!account.validate(payload, signature, callback)) return;
+    if (!account.validate(program, signature, callback)) return;
 
     let pid = account.manage_buffer(callback);
 
     this.manager.push({ sequence: instructions, account, pid });
   };
 
-  parse = ({ payload, signature, callback }) => {
+  parse = (program) => {
+    let { payload, signature, callback } = program;
     let { physical_address, account, query } = payload;
     account = this.get_account(account);
+    this.propagate(program, "parse");
 
     if (!account.validate(payload, signature))
       return this.run_callback(callback, {
@@ -96,6 +140,7 @@ class Account extends Filesystem {
 
     let { physical_address, account, query } = payload;
     account = this.get_account(account);
+    account.propagate(request, "run");
 
     if (!account.validate(payload, signature, callback)) return;
 
@@ -137,6 +182,17 @@ class Account extends Filesystem {
     }, 0);
   };
 
+  flush_stdout = (block) => {
+    for (let s = 0; s < this.stdout.length; s++) {
+      let out = this.stdout[s];
+      if (out.pid === this.vm.track.pid) {
+        block.metadata.stdout.push(out.data);
+        this.stdout[s] = null;
+      }
+    }
+    this.stdout = this.stdout.filter((out) => !!out);
+  };
+
   validate = (payload, signature, callback) => {
     if (!this.private) return true;
 
@@ -145,7 +201,7 @@ class Account extends Filesystem {
       JSON.stringify(payload),
       signature
     );
-    if (!valid)
+    if (!valid && callback)
       this.run_callback(callback, {
         private: this.private,
         error: true,
@@ -169,6 +225,7 @@ class Account extends Filesystem {
   };
 
   create_account = (payload) => {
+    this.propagate(payload, "create_account");
     let { name, meta } = payload;
 
     return this.manager.add_account(name, meta);

package/Objects/Block.js

@@ -7,6 +7,10 @@ class Block {
     this.metadata = {};
     this.children = new Array();
     this.index = this.chain.blocks.length;
+
+    this.blocks_folder = this.chain.account.manager.oracle.gds.folder(
+      process.env.BLOCKS_FOLDER || "blocks"
+    );
   }
 
   generate_hash = () => {
@@ -31,6 +35,8 @@ class Block {
       this.metadata[curs.slice(1, -1)] = content[curs];
       delete content[curs];
     }
+    this.metadata.stdout = new Array();
+    this.chain.account.flush_stdout(this);
 
     let datapath = this.chain.account.save(content, this.chain);
     this.datapath = datapath;
@@ -46,7 +52,12 @@ class Block {
     obj.hash = this.hash;
     obj.data = this.data;
     obj.children = this.children.map(
-      (ch) => new Object({ hash: ch.hash, chain: ch.chain.hash })
+      (ch) =>
+        new Object({
+          hash: ch.hash,
+          chain: ch.chain.hash,
+          physical_address: ch.chain.physical_address,
+        })
     );
     obj.chain = {
       hash: this.chain.hash,

package/Objects/Chain.js

@@ -27,9 +27,15 @@ class Chain extends Explorer {
 
     this.generate_hash();
 
+    this.folder = this.account.manager.oracle.gds.folder(this.hash);
+
+    this.manage_config();
+
     this.account.set_paths(this);
   }
 
+  manage_config = () => {};
+
   append_buffer = () => {
     this.buffs.push({});
     this.cursors.push(this.cursor);
@@ -81,6 +87,7 @@ class Chain extends Explorer {
 
     block.timelapse = Date.now() - this.start_time;
 
+    this.folder.write(block.stringify());
     return block;
   };
 

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 = {};
@@ -64,7 +64,7 @@ class Filesystem {
 
     addr = `${chain.path}/${hash(JSON.stringify(obj))}`;
     this;
-    if (obj != null) this.manager.oracle.write(addr, obj);
+    if (obj != null) this.manager.oracle.write(addr, obj, this.account);
 
     this.manager.oracle.set(addr, { obj, type });
 

package/Objects/Manager.js

@@ -18,22 +18,22 @@ 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];
+        let instruction = program.sequence[program.pointer];
 
-        track.account.vm.execute(instruction, track);
-        track.pointer++;
+        program.account.vm.execute(instruction, program);
+        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]);
+        if (program.pointer === program.sequence.length) {
+          program.account.flush_buffer(program.pid);
 
-          delete this.tracks[account];
+          track.pop();
         }
-
-        if (track.breakpoint.slice(-1)[0] === track.pointer) {
-          track.account.flush_buffer(track.pids.splice(-1)[0]);
+        if (!track.length) {
+          this.running -= 1;
+          delete this.tracks[account];
+          program.account.chain.mine(program.account.vm);
         }
       }
 
@@ -48,8 +48,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 +63,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,3 +1,4 @@
+import { obj } from "../framer";
 import { transpile_object } from "../utils/functions";
 
 class Opcodes {
@@ -7,6 +8,8 @@ class Opcodes {
 
   set = (opcode, circuit) => {
     this.opcodes[opcode] = circuit;
+    obj.Opcodes[opcode] = null;
+
     this.account.assembler.opcodes.push(opcode);
   };
 
@@ -17,9 +20,11 @@ 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);
   };
@@ -27,9 +32,13 @@ class Opcodes {
   stdin = (object, cb) => {
     if (object == null) return;
 
-    let code_string = transpile_object(object);
+    this.flags.zero = !object;
+    if (typeof object === "number") this.flags.neg = object < 0;
+
+    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,19 @@
 import fs from "fs";
+import GDS from "generalised-datastore";
+import { hash } from "../utils/hash";
 
 class Oracle {
   constructor(mgr) {
     this.fs = fs;
     this.mgr = mgr;
     this.datapaths = new Object();
+    this.gds = new GDS(process.env.DATASTORE || "godprotocol").sync();
   }
 
+  get_folder = (physical_address) => {
+    return this.gds.folder(this.hash(physical_address));
+  };
+
   set = (path, { type, obj }) => {
     this.datapaths[path] = {
       obj,
@@ -14,12 +21,62 @@ 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 = 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);
+  };
+
+  write = (addr, data) => {
+    data = JSON.stringify({ data });
+
+    this.fs.writeFileSync(addr, data, { encoding: "utf-8" });
+  };
+
+  fetch = (payload, callback) => {
+    let { physical_address, query, account, signature } = payload,
+      result;
+
+    account = this.mgr.get_account(account);
+    if (account && account.private)
+      if (!account.validate({ physical_address, query }, signature, callback))
+        return;
+
+    try {
+      let operation = this.gds.folder(this.hash(physical_address))[
+        query.operation
+      ];
 
-  write = (addr, data, meta = { encoding: "utf-8" }) => {
-    if (typeof data !== "string") data = JSON.stringify(data);
+      result = operation && operation(query.query, query.options);
 
-    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,11 @@ class Virtual_machine extends Opcodes {
     this.account = context.account;
     this.contexts = [context];
     this.stack = new Array();
+    this.flags = {
+      neg: false,
+      equal: false,
+      zero: false,
+    };
   }
 
   get_context = (index) => {
@@ -68,6 +73,8 @@ class Virtual_machine extends Opcodes {
 
     context.add_tx(instruction);
 
+    // console.log(instruction);
+
     let chain;
 
     args = this.parse_arg(args, opcode === "cursor");
@@ -84,6 +91,9 @@ class Virtual_machine extends Opcodes {
         chain = context.account.manager.web.get(args);
 
         if (!chain) {
+          this.account.flush_buffer(this.track.pid);
+          this.track.pointer = this.track.sequence.length;
+
           console.log(`LINKing Failed. - ${args}`);
           return;
         }
@@ -96,7 +106,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 +119,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;