godprotocol 1.0.799 → 1.0.833

package/Index.js

@@ -5,5 +5,39 @@ let manager = new Manager();
 
 let initiator = manager.add_account(process.env.INITIATOR || "initiator");
 
+setTimeout(() => {
+  initiator.assembler.run(
+    `
+    @/adder
+// coder: Savvy
+
+  >num 5
+  // dimensions.0.type: number
+
+  ./subtr
+
+>sub_result  sub 7 8
+  ;
+
+  >result add num 6
+  stdout result
+
+  ;
+    `,
+    {
+      cb: (blocks) => {
+        initiator.run({
+          payload: { physical_address: `${initiator.physical_address}/adder` },
+          callback: (blks) => {
+            // console.log(blks, "blocks");
+          },
+        });
+      },
+    }
+  );
+}, 1500);
+
+create_server(null, { port_search: true });
+
 export default manager;
 export { initiator, create_server };

package/Loader_sequence/main.js

@@ -1,3 +1,5 @@
+import { _id } from "generalised-datastore/utils/functions";
+
 let num_pattern = /^[+-]?\d+(\.\d+)?$/;
 // let str_pattern = /^["'][^"']*["']$/;
 let var_pattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
@@ -11,6 +13,25 @@ class Loader {
     this.instruction_indexes = new Array();
     this.instruction_stacks = [[]];
     this.stacks = new Array(account.physical_address);
+    this.markers = new Array();
+    this.program_configs = new Array();
+    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: [] });
   }
 
   instruction_index = () => {
@@ -219,6 +240,7 @@ class Loader {
       if (line.type === "address")
         return this.push_instruction(`pop ${path[path.length - 1]}`);
     } else {
+      this.current_program().dimensions.push({ name: identifier.value });
       this.push_instruction(`chain ${identifier.value}`);
       this.stack_instruction([
         `link ${this.stacks.slice(-1)[0]}`,
@@ -252,6 +274,12 @@ class Loader {
     } else this.push_instruction(`pop ${identifier.value}`);
   };
 
+  current_program = () => {
+    return this.program_configs[this.programs_index];
+  };
+
+  marker_pattern = /@[a-zA-Z_][a-zA-Z0-9_]*/;
+
   parse_opcode = (line) => {
     let tokens = Array.isArray(line) ? line : this.parse_tokens(line);
 
@@ -265,11 +293,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}"
         }`,
@@ -311,11 +347,23 @@ class Loader {
     let curr_stack = this.stacks.slice(-1)[0].split("/");
     new_stack = new_stack.split("/");
 
+    let physical_address = new_stack.join("/");
+    let program = {
+      program_name: new_stack[new_stack.length - 1],
+      physical_address,
+      codes: [],
+      dimensions: [],
+      sub_programs: [],
+      _id: _id("programs"),
+    };
+    let curr_program = this.current_program();
+    if (curr_program) curr_program.sub_programs.push(program._id);
+
+    this.programs_index++;
+    this.program_configs.push(program);
+
     if (curr_stack[1] !== new_stack[1]) {
     } else {
-      let i = 0;
-      while (curr_stack[i] === new_stack[i]) i++;
-
       for (let j = 2; j < new_stack.length; j++)
         this.stack_instruction(`chain ${new_stack[j]}`);
 
@@ -347,31 +395,145 @@ class Loader {
       this.stack_instruction(`pop ${addr[j]}`);
 
     this.instructions.push(...this.instruction_stacks.splice(-1)[0]);
+    this.programs_index--;
 
     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;
+  };
+
+  parse_comment = (line) => {
+    line = line.split(":");
+    if (line.length <= 1) return;
+
+    let curr_program = this.current_program();
+    let line1 = line[0].split(".");
+    let obj = curr_program;
+
+    for (let l = 0; l < line1.length - 1; l++) {
+      let term = line1[l];
+
+      if (term.trim() === "_id") break;
+
+      let n_term = Number(term);
+
+      if (n_term) {
+        obj = obj[n_term];
+      } else obj = obj[term];
+    }
+    if (!obj) return;
+
+    let index = line1[line1.length - 1];
+    let n_indx = Number(index);
+    if (!isNaN(n_indx)) index = n_indx;
+
+    if (index === "_id") return;
+
+    obj[index] = line.slice(1).join(":").trim();
+  };
+
   compile = (codes) => {
     let code_array = codes.split("\n");
 
     for (let c = 0; c < code_array.length; c++) {
       let line = code_array[c].trim();
+
+      let curr_program = this.current_program();
+      this.is_routine = line.startsWith(".") || line.startsWith("@");
+
+      this.handle_codes(line, curr_program);
+
       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;
+      else if (this.is_routine) this.parse_routine(line);
+      else if (line.startsWith("//")) this.parse_comment(line.slice(2).trim());
       else if (line.startsWith(">@")) this.parse_assignment(line, true);
       else if (line.startsWith(">")) this.parse_assignment(line);
       else this.parse_opcode(line);
+
+      (!curr_program || this.is_routine) &&
+        this.handle_codes(line, this.current_program());
+    }
+  };
+
+  handle_codes = (line, curr_program) => {
+    if (this.is_routine) {
+      let tilline = `~${line}`;
+      let prev_program = this.program_configs[this.programs_index - 1];
+      prev_program && prev_program.codes.push(tilline);
+
+      curr_program &&
+        !curr_program.codes.find((line) => !!line.trim()) &&
+        curr_program.codes.push(line);
     }
+
+    !this.is_routine && curr_program && curr_program.codes.push(line);
   };
 
-  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);
 
@@ -381,6 +543,50 @@ class Loader {
       program: { instructions: [...this.instructions] },
       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 } } }
+        );
+      }
+
+      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/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;
   };
@@ -48,54 +88,53 @@ class Account extends Filesystem {
     buffer.blocks.push(block.stringify());
   };
 
-  flush_buffer = (pid) => {
+  flush_buffer = (pid, payload) => {
     let buff = this.mine_buffer[pid];
     if (!buff) return;
 
-    buff.callback && this.run_callback(buff.callback, buff.blocks);
+    buff.callback && this.run_callback(buff.callback, payload || buff.blocks);
     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 }) => {
-    let { physical_address, account, query } = payload;
+  parse = (program) => {
+    let { payload, callback } = program;
+    let { account } = payload;
     account = this.get_account(account);
-
-    if (!account.validate(payload, signature))
-      return this.run_callback(callback, {
-        private: account.private,
-        error: true,
-        error_message: "Invalid signature",
-      });
-
-    let chain = account.manager.web.get(physical_address);
-
-    if (!chain)
-      return this.run_callback(callback, {
-        error: true,
-        error_message: "Address not found",
-      });
-
-    let data = query ? chain.explore(query) : chain;
-
-    this.run_callback(callback, data && data.stringify());
+    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",
+        })
+    );
   };
 
   run = (request) => {
     let { payload, signature, callback } = request;
 
-    let { physical_address, account, query } = payload;
+    let { physical_address, account, 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;
 
@@ -105,10 +144,38 @@ class Account extends Filesystem {
       ? this.manager.web.get(physical_address)
       : account.vm.get_context();
 
-    if (!context) return account.flush_buffer(pid);
+    if (!context) {
+      if (physical_address)
+        context = this.manager.web.split_set(physical_address);
+      else return account.flush_buffer(pid);
+    }
 
     let blk = query ? context.explore(query) : context.get_latest_block();
 
+    if (!query) {
+      let index = context.height;
+      index -= 2;
+
+      if (blk && blk.metadata.program) {
+        if (history) {
+          history--;
+          blk = null;
+        }
+      }
+
+      while (!blk && index >= 0) {
+        index--;
+        blk = context.get_block(index);
+
+        if (blk && blk.metadata.program) {
+          if (history) {
+            history--;
+            blk = null;
+          }
+        }
+      }
+    }
+
     if (blk && blk.metadata && blk.metadata.program) {
       let program = this.read(blk.metadata.program);
 
@@ -137,6 +204,22 @@ class Account extends Filesystem {
     }, 0);
   };
 
+  flush_stdout = (block) => {
+    if (
+      block.chain.physical_address === `${this.physical_address}/Opcodes/stdout`
+    )
+      return;
+
+    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 +228,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 +252,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

@@ -1,4 +1,5 @@
 import { hash } from "../utils/hash";
+import { _id } from "generalised-datastore/utils/functions";
 
 class Block {
   constructor(chain) {
@@ -7,6 +8,11 @@ class Block {
     this.metadata = {};
     this.children = new Array();
     this.index = this.chain.blocks.length;
+    this._id = _id(this.chain.hash);
+
+    this.blocks_folder = this.chain.account.manager.oracle.gds.folder(
+      process.env.BLOCKS_FOLDER || "blocks"
+    );
   }
 
   generate_hash = () => {
@@ -31,6 +37,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;
@@ -45,8 +53,16 @@ class Block {
     obj.index = this.index;
     obj.hash = this.hash;
     obj.data = this.data;
-    obj.children = this.children.map(
-      (ch) => new Object({ hash: ch.hash, chain: ch.chain.hash })
+    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.chain = {
       hash: this.chain.hash,
@@ -55,6 +71,22 @@ class Block {
 
     return str ? JSON.stringify(obj) : obj;
   };
+
+  static build = (data, chain) => {
+    let blck = new Block(chain);
+    blck.chain = chain;
+    blck.metadata = data.metadata;
+    blck.datapath = data.datapath;
+    blck.timelapse = data.timelapse;
+    blck.index = data.index;
+    blck.hash = data.hash;
+    blck.data = data.data;
+    blck.children = data.children || [];
+
+    blck._id = data._id;
+
+    return blck;
+  };
 }
 
 export default Block;

package/Objects/Blockweb.js

@@ -15,7 +15,21 @@ class Blockweb {
     return chain;
   };
 
+  split_set = (physical_address) => {
+    let spli = physical_address.split("/");
+
+    let chain = this.get(physical_address);
+    if (!chain) {
+      chain = this.set(spli.slice(0, -1).join("/"), spli.slice(-1)[0]);
+    }
+    return chain;
+  };
+
   set = (parent, name) => {
+    if (typeof parent === "string") {
+      parent = this.get(parent) || this.split_set(parent);
+    }
+
     let chain = new Chain(parent, name);
     this.chains[chain.hash] = chain;