godprotocol 1.0.6 → 1.0.71

package/Aircode/native_classes/fn.js

@@ -0,0 +1,49 @@
+import fn from "../keywords/fn";
+import Native from "./native";
+
+class Fn extends Native {
+  constructor(token) {
+    super();
+
+    this.token = { ...token, type: "function" };
+    this.name = this.token.value;
+  }
+
+  handle_definition = (tokens) => {
+    let pos = 0;
+    let token = tokens[pos];
+
+    if (token.value !== "fn") throw new Error();
+
+    pos++;
+    let name_token = tokens[pos];
+
+    if (name_token.type !== "variable") {
+      throw new Error();
+    }
+    pos++;
+
+    let { pos: pos_ } = fn(tokens.slice(pos), this);
+    pos += pos_ + 1;
+
+    return { pos };
+  };
+
+  greedy = (tokens) => {
+    let pos = 0;
+    let { pos: pos_ } = this.handle_definition(tokens.slice(pos));
+    pos += pos_;
+
+    return { obj: this, pos };
+  };
+
+  generate_assembly = (sequence) => {
+    sequence.push(`chain ${this.name}`);
+
+    this.children.map((ch) => ch.generate_assembly(sequence));
+
+    sequence.push(`pop ${this.name}`);
+  };
+}
+
+export default Fn;

package/Aircode/native_classes/global.js

@@ -1,12 +1,13 @@
 import Native from "./native";
 
 class Global extends Native {
-  constructor(name) {
+  constructor(compiler) {
     super();
 
     this.is_global = true;
-    this.name = name;
-    this.path = `./${this.name}`;
+    this.compiler = compiler;
+    this.name = this.compiler.name;
+    this.path = this.compiler.account.physical_address;
   }
 
   generate_assembly = (sequence) => {

package/Aircode/native_classes/keywords/return_.js

@@ -0,0 +1,23 @@
+import Native from "../native";
+
+class Return extends Native {
+  constructor(token) {
+    super();
+
+    this.token = token;
+    this.name = this.token.value;
+  }
+
+  generate_assembly = (sequence) => {
+    this.children.map((c) => c.generate_assembly(sequence));
+
+    sequence.push(`cursor {output}`);
+    sequence.push(
+      !this.token.compiler.datatypes.includes(this.children[0].token.type)
+        ? `write {metadata.output:-1}`
+        : `write {datapath:-1}`
+    );
+  };
+}
+
+export default Return;

package/Aircode/native_classes/native.js

@@ -1,12 +1,48 @@
+import { parse_expression } from "../functions/parse_expression";
+
 class Native {
   constructor() {
+    this._id = Math.random();
     this.children = new Array();
   }
 
-  generate_assembly = (sequence) => {};
+  find = (obj) => {
+    for (let c = 0; c < this.children.length; c++) {
+      let child = this.children[c];
+
+      if (
+        child.token.value === obj.token.value &&
+        child.token.type === "variable"
+      ) {
+        return child;
+      }
+    }
+
+    return this.parent ? this.parent.find(obj) : null;
+  };
+
+  greedy = (tokens) => {
+    let pos = 0,
+      obj;
+
+    if (this.token.compiler.expr_types.includes(this.token.type)) {
+      let { obj: obj_, pos: pos_ } = parse_expression(
+        tokens.slice(pos + 1),
+        this,
+        true
+      );
 
-  reference_path = () => {
-    return this.path;
+      obj = obj_;
+      pos += pos_;
+    } else if (this.token.type === "keyword") {
+      if (["parse", "return"].includes(this.token.value)) {
+        let { obj, pos: pos_ } = parse_expression(tokens.slice(pos + 1), this);
+
+        this.push(obj);
+        pos += pos_ + 1;
+      }
+    }
+    return { obj: obj || this, pos };
   };
 
   set_parent = (parent) => {
@@ -15,6 +51,8 @@ class Native {
   };
 
   push = (obj) => {
+    if (!obj) return;
+
     this.children.push(obj);
     if (obj.set_parent) obj.set_parent(this);
   };

package/Aircode/native_classes/operators.js

@@ -5,6 +5,7 @@ let op_to_name = {
   "-": "subtract",
   "/": "divide",
   "*": "multiply",
+  "=": "assign",
 };
 
 class Operator extends Native {
@@ -20,24 +21,36 @@ class Operator extends Native {
       `link ${this.token.compiler.account.physical_address}/Opcodes/${this.name}`
     );
 
-    sequence.push(`link Datatypes/Twain`);
+    sequence.push(
+      `link ${this.token.compiler.account.physical_address}/Datatypes/Twain`
+    );
     for (let c = 0; c < this.children.length; c++) {
       let child = this.children[c];
       child.generate_assembly(sequence);
       sequence.push(`cursor op${c}`);
-      sequence.push(`write {${"datapath"}:-1}`);
+      sequence.push(
+        `write {${
+          this.token.compiler.datatypes.includes(child.token.type)
+            ? "datapath"
+            : "metadata.output"
+        }:-1}`
+      );
     }
     sequence.push("pop");
 
-    sequence.push(`link Datatypes/Twain`);
+    sequence.push(
+      `link ${this.token.compiler.account.physical_address}/Datatypes/Twain`
+    );
     sequence.push("cursor inputs");
-    sequence.push(`write ../{metadata:-1}`);
+    sequence.push(`write ../{datapath:-1}`);
 
     sequence.push(this.name);
-    sequence.push(`pop Datatypes/Twain`);
+    sequence.push(
+      `pop ${this.token.compiler.account.physical_address}/Datatypes/Twain`
+    );
 
-    sequence.push(`cursor {metadata}`);
-    sequence.push(`write {metadata:-1}`);
+    sequence.push(`cursor {output}`);
+    sequence.push(`write ^{datapath:-1}`);
 
     sequence.push(`pop Opcodes/${this.name}`);
   };

package/Aircode/native_classes/parse.js

@@ -1,11 +1,12 @@
+import Variable from "./Variable";
 import Native from "./native";
+import Operator from "./operators";
 
 class Parse extends Native {
-  constructor(token, obj) {
+  constructor(token) {
     super();
 
     this.token = token;
-    this.obj = obj;
     this.name = "stdout";
   }
 
@@ -17,9 +18,20 @@ class Parse extends Native {
     sequence.push(
       `link ${this.token.compiler.account.physical_address}/Datatypes/Twain`
     );
-    this.obj.generate_assembly(sequence);
-    sequence.push(`cursor op${0}`);
-    sequence.push(`write {${"datapath"}:-1}`);
+
+    for (let c = 0; c < this.children.length; c++) {
+      let child = this.children[c];
+      child.generate_assembly(sequence);
+
+      sequence.push(`cursor op${c}`);
+      sequence.push(
+        `write {${
+          this.token.compiler.datatypes.includes(child.token.type)
+            ? "datapath"
+            : "metadata.output"
+        }:-1}`
+      );
+    }
 
     sequence.push("pop");
 
@@ -32,9 +44,6 @@ class Parse extends Native {
     sequence.push(this.name);
     sequence.push(`pop Datatypes/Twain`);
 
-    sequence.push(`cursor {datapath}`);
-    sequence.push(`write {datapath:-1}`);
-
     sequence.push(`pop Opcodes/stdout`);
   };
 }

package/Index.js

@@ -21,11 +21,11 @@ const start = (name, server) => {
   return initiator;
 };
 
-let immanuel = start("immanuel");
-
+let initiator = start(process.env.INITIATOR || "initiator");
+start("innii");
 setTimeout(() => {
-  immanuel.compiler.run("parse 'Hello'");
-}, 2000);
+  initiator.compiler.run("parse 'Hello, world!'");
+}, 1500);
 
 export default start;
-export { manager };
+export { manager, initiator };

package/Objects/Account.js

@@ -31,6 +31,10 @@ class Account extends Filesystem {
     this.chain.generate_hash();
 
     this.data_tracks = new Object();
+
+    console.log(`Account Instance: ${this.name}`);
+
+    this.mine_buffer = {};
   }
 
   init_folder = (name) => {
@@ -43,10 +47,64 @@ class Account extends Filesystem {
     return account || this;
   };
 
-  load = ({ instructions, account }) => {
+  manage_buffer = () => {
+    let call_session = `${Date.now()}-${Math.random()}`;
+    this.mine_buffer[call_session] = [];
+
+    return call_session;
+  };
+
+  buff = (block, pid) => {
+    let blks = this.mine_buffer[pid];
+    if (!blks) return;
+
+    blks.push(block.stringify());
+  };
+
+  flush_buffer = (cb, pid) => {
+    let blocks = this.mine_buffer[pid];
+
+    cb && cb(blocks);
+    delete this.mine_buffer[pid];
+  };
+
+  load = ({ instructions, account }, cb) => {
+    account = this.get_account(account);
+
+    let pid = account.manage_buffer();
+
+    this.manager.push({ sequence: instructions, account, pid });
+
+    account.flush_buffer(cb, pid);
+  };
+
+  parse = ({ physical_address, account, query }, cb) => {
+    account = this.get_account(account);
+
+    let chain = account.manager.web.get({ physical_address }, true);
+    if (!chain) return cb({ error: true, error_message: "Address not found" });
+
+    let data = query ? chain.explore(query) : chain;
+
+    cb(data && data.stringify());
+  };
+
+  run = ({ account, query, physical_address }, cb) => {
     account = this.get_account(account);
 
-    this.manager.push({ sequence: instructions, account });
+    let pid = account.manage_buffer();
+
+    let context = physical_address
+      ? this.manager.web.get({ physical_address }, true)
+      : account.vm.get_context();
+
+    if (!context) return account.flush_buffer(cb, pid);
+
+    let blk = query ? context.explore(query) : context.get_block(0);
+
+    blk && this.manager.push({ sequence: blk.data, account, pid });
+
+    account.flush_buffer(cb, pid);
   };
 
   add_server = (server) => {
@@ -68,59 +126,45 @@ class Account extends Filesystem {
     obj.data_tracks = this.data_tracks;
   };
 
-  send = (data, cb, one) => {
+  distribute = (data) => {
     if (!data) return;
 
-    let servers =
-      typeof one === "string" ? this.data_tracks[one] : this.servers;
+    let servers;
 
-    data = data.stringify ? data.stringify() : data;
+    let ky = data.blocks ? data.hash : `${data.chain.hash}-${data.hash}`;
 
-    let should_break = false;
-    if (servers)
-      for (let s = 0; s < servers.length; s++) {
-        if (should_break) break;
-
-        let server = servers[s];
+    if (data.blocks) {
+      servers = this.data_tracks[ky];
+    } else if (data.chain) {
+      servers = this.data_tracks[ky];
+    }
+    if (!servers) servers = this.servers;
 
-        if (typeof one === "object")
-          if (one.hostname !== server.hostname || one.port !== server.port)
-            continue;
+    for (let s = 0; s < servers.length; s++) {
+      let server = servers[s];
 
-        post_request(
-          {
-            options: {
-              ...server,
-              path: "/distribute",
-            },
-            data: JSON.stringify(data),
+      post_request(
+        {
+          options: {
+            hostname: server.domain,
+            port: server.port,
+            path: "/distribute",
           },
-          (res) => {
-            let track = this.data_tracks[data.hash];
-            if (!track) {
-              track = new Array();
-              this.data_tracks[data.hash] = track;
-            }
-            track.push(server);
-
-            this.vm.stdin(res);
-
-            if (typeof one === "boolean") {
-              should_break = true;
-            }
-          }
-        );
-
-        if (one) break;
-      }
+          data: data.stringify(true),
+        },
+        this.vm.stdin
+      );
+    }
+    this.data_tracks[ky] = servers;
   };
 
   account = (name, server) => {
-    let account = this.accounts[name];
+    let account = this.accounts[name] || this.manager.accounts[name];
 
     if (!account) {
       account = new Account(name, this);
       this.accounts[account.name] = account;
+      this.manager.accounts[account.name] = account;
     }
     account.add_server(server);
 

package/Objects/Block.js

@@ -1,13 +1,51 @@
+import { hash } from "../utils/hash";
+
 class Block {
   constructor(chain) {
     this.chain = chain;
     this.data = this.chain.txs;
     this.metadata = {};
     this.children = new Array();
+    this.index = this.chain.blocks.length;
   }
 
-  store = () => {
+  generate_hash = () => {
+    this.previous_hash = this.chain.get_latest_block();
+    if (this.previous_hash) this.previous_hash = this.previous_hash.hash;
+
+    this.hash = hash(JSON.stringify(this.data));
+  };
+
+  load_obj = (data) => {
+    let web = this.chain.parent.account.manager.web;
+
+    let children = data.children
+      .map((chi) => {
+        let chain = web.chains[chi];
+        if (!chain) return;
+
+        chain.connections.push(this);
+
+        for (let b = chain.blocks.length - 1; b >= 0; b++) {
+          let blk = chain.blocks[b];
+          if (blk.hash === chi.hash) return blk;
+        }
+      })
+      .filter((b) => !!b);
+    this.children = children;
+    this.data = data.data;
+    this.timelapse = data.timelapse;
+    this.datapath = data.datapath;
+    this.metadata = data.metadata;
+    this.hash = data.hash;
+    this.index = data.index;
+
+    return this;
+  };
+
+  store = (no_curs) => {
     let content = this.chain.buffs.splice(-1)[0];
+    if (!no_curs) this.cursor = this.chain.cursors.splice(-1)[0];
     if (!content) return;
 
     let cursors = Object.keys(content).filter(
@@ -24,7 +62,7 @@ class Block {
     this.datapath = datapath;
   };
 
-  stringify = () => {
+  stringify = (str) => {
     let obj = {};
 
     obj.metadata = this.metadata;
@@ -38,7 +76,7 @@ class Block {
     );
     obj.chain = this.chain.hash;
 
-    return obj;
+    return str ? JSON.stringify(obj) : obj;
   };
 }
 

package/Objects/Blockweb.js

@@ -10,34 +10,41 @@ class Blockweb {
     this.physical_addresses = new Object();
   }
 
-  sync_chain = (chain) => {
-    let chain_obj = this.chains[chain.hash];
-    if (!chain_obj) {
-      this.store_chain(chain.stringify());
+  get = (parent, no_new) => {
+    let hash = this.physical_addresses[parent.physical_address];
 
-      return chain;
-    }
-
-    return chain_obj;
-  };
-
-  store_chain = (chain_obj) => {
-    let addr = this.mgr.oracle.get(chain_obj.physical_address);
+    let chain = this.chains[hash];
 
-    if (!addr) return;
+    if (!chain && !no_new) {
+      chain = new Chain(parent);
+      chain.generate_hash();
 
-    let chain = new Chain(addr);
-    chain.hash = chain_obj.hash;
+      this.chains[chain.hash] = chain;
+      this.physical_addresses[chain.physical_address] = chain.hash;
+    }
+    if (!no_new) this.chains[chain.hash] = chain;
 
-    this.chains[chain_obj.hash] = chain;
+    return chain;
   };
 
-  store_block = (block_obj) => {
-    let chain = this.chains[block_obj.chain];
-    if (!chain) return;
-
-    let block = new Block(chain);
-    chain.add_block(block);
+  sync = (data) => {
+    if (data.chain) {
+      let chain = this.chains[data.chain];
+      if (!chain) {
+      } else {
+        let block = new Block(chain);
+        return block.load_obj(data);
+      }
+    } else {
+      let fold = this.mgr.oracle.get(data.name, {
+        physical_address: data.physical_address,
+        account: this.mgr.accounts[data.account],
+      });
+      if (!fold) {
+      } else {
+        return this.get(fold);
+      }
+    }
   };
 }
 

package/Objects/Chain.js

@@ -18,18 +18,19 @@ class Chain extends Explorer {
     this.txs = new Array();
 
     this.cursor = -1;
-    this.buffs = [];
-    this.listeners = [];
+    this.cursors = new Array();
+    this.buffs = new Array();
+    this.listeners = new Array();
   }
 
-  add_listener = (event_twain) => {};
-
-  on = (name) => {};
-
-  after = (name) => {};
+  get_block = (index) => {
+    return this.blocks[index];
+  };
 
   append_buffer = () => {
     this.buffs.push({});
+    this.cursors.push(this.cursor);
+    this.cursor = -1;
   };
 
   get_buffer = () => {
@@ -47,14 +48,11 @@ class Chain extends Explorer {
     this.txs.push(instruction);
   };
 
-  set_servers = (servers) => {
-    this.servers = servers;
-  };
-
-  mine = (vm) => {
+  mine = (vm, no_curs) => {
     let block = new Block(this);
 
-    block.store();
+    block.generate_hash();
+    block.store(no_curs);
 
     this.add_block(block);
 
@@ -76,21 +74,25 @@ class Chain extends Explorer {
     return block;
   };
 
-  stringify = () => {
+  stringify = (str) => {
     let obj = {};
 
     obj.physical_address = this.physical_address;
     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.hash = this.hash;
     obj.blocks = this.blocks.map((blk) => blk.hash);
 
-    return obj;
+    return str ? JSON.stringify(obj) : obj;
   };
 
   add_block = (block) => this.blocks.push(block);
+
+  get_latest_block = () => this.blocks.slice(-1)[0];
 }
 
 export default Chain;

package/Objects/Explorer.js

@@ -1,28 +1,34 @@
 class Explorer {
   constructor() {}
 
+  chain_props = ["blocks"];
+
   explore = (query) => {
     query = query.split(":");
 
     query[0] = query[0].split(".");
 
-    let q2 = Number(query[1]);
+    let q2 = Number(query[1]),
+      prop;
+
+    if (this.chain_props.includes(query[0][0])) prop = query[0][0];
 
     let obj;
     if (isNaN(q2)) {
-      obj = this.connections.find((c) => c.hash === query[1]);
+      obj = this[prop || "connections"].find((c) => c.hash === query[1]);
     } else if (q2 >= 0) {
-      obj = this.connections.find((q) => q.index === q2);
+      obj = this[prop || "connections"].find((q) => q.index === q2);
     } else {
-      obj = this.connections.slice(q2)[0];
+      obj = this[prop || "connections"].slice(q2)[0];
     }
 
-    for (let q = 0; q < query[0].length; q++) {
-      let que = query[0][q];
+    if (!prop)
+      for (let q = 0; q < query[0].length; q++) {
+        let que = query[0][q];
 
-      if (!obj) break;
-      obj = obj[que];
-    }
+        if (!obj) break;
+        obj = obj[que];
+      }
 
     return obj;
   };