godprotocol 1.1.0 → 1.1.2

package/Datatypes/arr.js

@@ -0,0 +1,11 @@
+import Storage from "./functions/storage";
+
+class Arr extends Storage {
+  constructor(value) {
+    super();
+
+    this.value = value;
+  }
+}
+
+export default Arr;

package/Datatypes/bool.js

@@ -0,0 +1,11 @@
+import Storage from "./functions/storage";
+
+class Bool extends Storage {
+  constructor(value) {
+    super();
+
+    this.value = value;
+  }
+}
+
+export default Bool;

package/Datatypes/callable.js

@@ -0,0 +1,11 @@
+import Storage from "./functions/storage";
+
+class Callable extends Storage {
+  constructor(value) {
+    super();
+
+    this.value = value;
+  }
+}
+
+export default Callable;

package/Datatypes/functions/storage.js

@@ -0,0 +1,5 @@
+class Storage {
+  constructor() {}
+}
+
+export default Storage;

package/Datatypes/num.js

@@ -0,0 +1,11 @@
+import Storage from "./functions/storage";
+
+class Num extends Storage {
+  constructor(value) {
+    super();
+
+    this.value = value;
+  }
+}
+
+export default Num;

package/Datatypes/str.js

@@ -0,0 +1,11 @@
+import Storage from "./functions/storage";
+
+class Str extends Storage {
+  constructor(value) {
+    super();
+
+    this.value = value;
+  }
+}
+
+export default Str;

package/Datatypes/twa.js

@@ -0,0 +1,11 @@
+import Storage from "./functions/storage";
+
+class Twa extends Storage {
+  constructor(value) {
+    super();
+
+    this.value = value;
+  }
+}
+
+export default Twa;

package/Datatypes/voi.js

@@ -0,0 +1,11 @@
+import Storage from "./functions/storage";
+
+class Voi extends Storage {
+  constructor(value) {
+    super();
+
+    this.value = value;
+  }
+}
+
+export default Voi;

package/Index.js

@@ -1,4 +1,38 @@
-import Trinity from "./Trinity";
+import Trinity from "./Objects/Trinity";
 
+let trinity = new Trinity();
 
-export default new Trinity();
+const starter = async () => {
+  let manager = await trinity.add_manager("Arena_classic", {
+    server: {
+      port: 1408,
+      hostname: "127.0.0.1",
+      repo: true,
+    },
+    repositories: [
+      // {server}
+    ],
+  });
+
+  // let manager2 = await trinity.add_manager("Arena_classic", {
+  //   server: {
+  //     port: 1409,
+  //     hostname: "127.0.0.1",
+  //     repo: true,
+  //   },
+  //   sync_server: {
+  //     port: 1408,
+  //     hostname: "127.0.0.1",
+  //   },
+  //   repositories: [
+  //     // {server}
+  //   ],
+  // });
+
+  let account = await manager.add_account("lola");
+  // let account2 = await manager2.add_account("lola");
+};
+
+starter();
+
+export default trinity;

package/Objects/Account.js

@@ -1,348 +1,61 @@
-
-import Loader_sequence from "../Loader_sequence/main";
-import validate_signature from "../utils/privacy";
-import { post_request } from "../utils/services";
-import Filesystem from "./Filesystem";
+import register from "../callables/register";
+import Chain from "./Chain";
 import Virtual_machine from "./Virtual_machine";
 
-class Account extends Filesystem {
-  constructor(name, meta = {}) {
-    super();
-
-    meta = meta || {};
-
+class Account {
+  constructor(name, options) {
     this.name = name;
-    this.private = meta.private;
-    this.manager = meta.manager;
-    this.account = this;
-    this.stdin = new Array();
-    this.stdout = new Array();
-
-    this.log_output = this.manager.logger.store_log
-
-    if (!this.manager) throw new Error("Manager instance missing.");
-
-    this.name_hash();
-    this.physical_address = `${this.base_address}/${this.name}`;
-    this.set_paths(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();
-
-    this.events = new Object();
-
-    this.log_output(`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);
-
-    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;
-  };
-
-  manage_buffer = (callback, real_cb) => {
-    let call_session = `${Date.now()}-${Math.random()}`;
-    this.mine_buffer[call_session] = { blocks: [], callback, real_cb };
-
-    return call_session;
-  };
-
-  results = new Object()
-
-  buff = (block, pid) => {
-    if(block.ret){
-      this.results[pid] = block.ret
-      return;
-    }
-
-    let buffer = this.mine_buffer[pid];
-    if (!buffer) return;
-
-    block && block.stringify &&  buffer.blocks.push(block.stringify());
-  };
-
-  flush_buffer = (pid, payload) => {
-    let buff = this.mine_buffer[pid];
-    if (!buff) return;
-
-    if (buff.callback){
-      this.run_callback(buff.callback,{ payload, ret: this.results[pid] , blocks: buff.blocks});
-    } else if(buff.real_cb){
-      buff.real_cb(payload)
-    }
-    
-    delete this.mine_buffer[pid];
-    delete this.results[pid]
-  };
-
-  execute =( opcode, args)=>{
-    let circ = this.vm.opcodes[opcode]
-    if (typeof circ !== 'function') {return}
 
-    circ(args)
-  }
+    this.manager = options.manager;
+    this.repository = this.manager.repository;
 
-  process_fee = ({fee, validator}, cb)=>{
-    let content = this.vm.read_chain(fee, {tell_callable})
+    this.physical_address = `Accounts/${name}`;
 
-    if (content.callable){
-      this.vm.exec({executable: content.__address__, location:result=>{
-        this.vm.exec({executable: validator, location: result=>{
-          cb && cb(result)
-        }, arguments: {argc:1, argv: [{position: 0, static_value: result}]}})
-      } })
-    }else {
-      this.vm.exec({executable: validator, location: (result)=>{
-        cb && cb(result)
-      }, arguments: {argc:1, argv: [{position:0, address: fee}]}})
-    }
+    this.chain = new Chain(this.physical_address, this);
   }
-  
-  load = (payload) => {
-    let { program, callback, location } = payload;
-    let { instructions, assemble, forge, spawn, unshift } = program;
-
-    this.propagate(payload, "load");
-    
-    if(forge){
-      let chain = this.vm.handle_chain(forge)
-      chain.forge_block({metadata:{output:this.save(instructions)}})
-    } else if (assemble) {
-      this.assembler
-        .spawn()
-        .run(instructions, { cb: callback, location, options: assemble , unshift});
-    } else {
-      let pid = this.manage_buffer(location?res=>{
-        this.vm.air_object(res, {location})
-      } : callback,location&& callback);
-
-      this.manager.push({ sequence: instructions, spawn, account: this, pid, unshift });
-    }
-
-    if(location && callback){
-      callback({estimated_time:'-ms', callback:location})
-    }
-  };
 
-  parse = (program) => {
-    let { payload, callback, signature } = program;
+  run = async (payload) => {
+    let { physical_address, query } = payload;
 
-    this.propagate(program, "parse");
+    let chain = await this.vm.handle_chain(physical_address);
+    let codes = await chain.read(query);
 
-    this.manager.oracle.fetch({ ...payload, signature }, (result) =>
-      this.run_callback(callback, result)
-    );
+    await this.vm.execute(codes);
   };
 
-  run = (request) => {
-    let { payload, callback, location} = request;
-
-    let { physical_address, query, history } = payload;
-
-    history = Math.abs(Number(history)) || 0;
-
-    this.propagate(request, "run");
-
-    let pid = this.manage_buffer(location?res=>{
-      this.vm.air_object(res, {location})
-    } : callback,location&& callback);
-
-    let context = physical_address
-      ? this.manager.web.get(physical_address)
-      : this.vm.get_context();
-
-    if (!context) {
-      if (physical_address)
-        context = this.vm.handle_chain(physical_address);
-      else return this.flush_buffer(pid);
-    }
-    if(!context)throw new Error()
-
-    let blk = query ? context.explore(query) : context.get_latest_block();
-
-    // console.log(context.stringify())
-    // console.log(blk)
-
-    if (!query) {
-      let index = context.height;
-      index -= 1;
-
-      const historic = (blk) => {
-        if (blk && blk.metadata.program) {
-          if (history) {
-            history--;
-            blk = null;
-          }
-        } else blk = null;
-        
-        return blk;
-      };
-      blk = historic(blk);
+  load = async (payload) => {
+    let { sequence: codes, physical_address } = payload;
 
-      while (!blk && index >= 0) {
-        index--;
-        blk = context.get_block(index);
+    for (let c = 0; c < codes.length; c++) {
+      let instruction = codes[c];
 
-        blk = historic(blk);
-        // console.log(blk)
-      }
-    }
-
-    // console.log(blk)
-
-    if (blk && blk.metadata && blk.metadata.program) {
-      let program = this.read(blk.metadata.program);
-
-      if (Array.isArray(program) && program.length) {
-        this.vm.push_context(context);
-        program = [...program, 'pop']
-
-        // console.log(program)
-
-        this.manager.push({
-          sequence: program,
-          account: this,
-          payload,
-          error_stack: JSON.stringify(this.vm.error_manager),
-          pid,
+      if (["function", "class"].includes(instruction.type)) {
+        let addresses = await this.load({
+          ...instruction,
+          sequence: instruction.sequence,
+          physical_address: instruction.physical_address,
         });
+        instruction.sequence = addresses;
       }
-    } else this.flush_buffer(pid,{error:true, error_message: "Program is not set!"});
-
-    if(location && callback){
-      callback({estimated_time:'-ms', callback:location})
-    }
-  };
-
-  run_callback = (callback, payload) => {
-    setTimeout(() => {
-      if (!callback) return;
 
-      if (typeof callback === "function") return callback(payload);
-
-      callback.payload &&
-        callback.payload.physical_address &&
-        this.vm.stdin(payload, callback);
-    }, 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;
-      }
+      let chain = await this.vm.handle_chain(instruction.physical_address);
+      let block = await chain.write(instruction);
+      codes[c] = block.address;
     }
-    this.stdout = this.stdout.filter((out) => !!out);
-  };
+    let chain = await this.vm.handle_chain(physical_address);
+    await chain.write({ ...payload, sequence: codes });
 
-  validate = (payload, signature, callback) => {
-    if (!this.private) return true;
-
-    let valid = validate_signature(
-      this.name,
-      JSON.stringify(payload),
-      signature
-    );
-    if (!valid && callback)
-      this.run_callback(callback, {
-        private: this.private,
-        error: true,
-        error_message: "Invalid signature",
-      });
-
-    return valid;
+    return codes;
   };
 
-  stringify = (str) => {
-    let obj = {};
-
-    obj.name = this.name;
-    obj.hash = this.hash;
-    obj.path = this.path;
-    obj.private = this.private;
-    obj.chain = this.chain.stringify();
-    obj.physical_address = this.physical_address;
-
-    return str ? JSON.stringify(obj) : obj;
-  };
+  sync = async () => {
+    this.servers = new Array();
+    this.vm = new Virtual_machine(this);
 
-  create_account = (payload) => {
-    this.propagate(payload, "create_account");
-    let { name, meta } = payload;
+    await this.chain.sync();
+    await this.vm.sync();
 
-    return this.manager.add_account(name, meta);
+    await register(this);
   };
 }
 

package/Objects/Block.js

@@ -1,90 +1,17 @@
-import { hash } from "../utils/hash";
-import { _id } from "generalised-datastore/utils/functions";
-
 class Block {
-  constructor(chain) {
+  constructor(meta, chain) {
+    this.content = meta.content;
     this.chain = chain;
-    this.data = this.chain.txs;
-    this.metadata = {};
-    this.children = new Array();
-    this.index = this.chain.height;
-    this._id = _id(this.chain.hash);
-    this.previous_hash = this.chain.recent_block && this.chain.recent_block._id
+    this.index = chain.blocks.length;
   }
 
-  generate_hash = () => {
-    this.hash = hash(JSON.stringify(this.data));
-  };
-
-  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;
-
-    if (this.data.length<=1 && this.chain.account.is_datatype(this.chain)){
-      content = this.chain.account.stringify_type(this.chain)
-    }else {
-      let cursors = Object.keys(content).filter(
-        (c) => c.startsWith("{") && c.endsWith("}")
-      );
-
-      for (let c = 0; c < cursors.length; c++) {
-        let curs = cursors[c];
-
-        this.metadata[curs.slice(1, -1)] = content[curs];
-        delete content[curs];
-      }
-    }
-    
-
-    this.metadata.stdout = new Array();
-    this.chain.account.flush_stdout(this);
+  sync = async () => {
+    this.address = `${this.chain.physical_address}:${this.index}`;
 
-    if(!this.chain.datapath){
-      let datapath = this.chain.account.save(content, this.chain);
-      this.datapath = datapath
-    }else {
-      this.chain.account.save(content)
-      this.datapath = this.chain.datapath
-    }
+    await this.generate_hash();
   };
 
-  stringify = (str) => {
-    let obj = {};
-
-    obj.metadata = this.metadata;
-    obj.datapath = this.datapath;
-    obj.timelapse = this.timelapse;
-    obj.index = this.index;
-    obj.hash = this.hash;
-    obj.previous_hash = this.previous_hash;
-    obj.data = this.data;
-    obj._id = this._id;
-    obj.children = this.children.map((ch) => ch && ch._id);
-    obj.chain = {
-      hash: this.chain.hash,
-      physical_address: this.chain.physical_address,
-    };
-
-    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.previous_hash = data.previous_hash;
-    blck.hash = data.hash;
-    blck.data = data.data;
-    blck.children = data.children || [];
-
-    blck._id = data._id;
-
-    return blck;
-  };
+  generate_hash = async () => {};
 }
 
 export default Block;

package/Objects/Blockweb.js

@@ -1,40 +1,33 @@
 import Chain from "./Chain";
 
 class Blockweb {
-  constructor(mgr) {
-    this.mgr = mgr;
-    this.physical_addresses = new Object();
+  constructor(manager) {
+    this.manager = manager;
+
     this.chains = new Object();
+    this.listeners = new Object();
   }
 
-  get = (addr) => {
-    let hash = this.physical_addresses[addr];
-
-    let chain = this.chains[hash];
-
-    return chain;
-  };
-
-  split_set = (physical_address) => {
-    let spli = physical_address.split("/");
-
-    let chain = this.get(physical_address);
-    if (!chain && spli.length >1) {
-      chain = this.set(spli.slice(0, -1).join("/"), spli.slice(-1)[0]);
+  listen = async (physical_address, config) => {
+    let ls = this.listeners[physical_address];
+    if (!ls) {
+      ls = new Array();
+      this.listeners[physical_address] = ls;
     }
-    return chain;
+    ls.push(config.server);
   };
 
-  set = (parent, name) => {
-    if (typeof parent === "string") {
-      parent = this.get(parent) || this.split_set(parent);
-    }
+  spli_get = async (address, account) => {
+    return this.get(address) || (await this.set(address, account));
+  };
 
-    let chain = new Chain(parent, name);
-    this.chains[chain.hash] = chain;
+  get = (address) => {
+    return this.chains[address];
+  };
 
-    this.physical_addresses[chain.physical_address] = chain.hash;
-    this.chains[chain.hash] = chain;
+  set = async (address, account) => {
+    let chain = new Chain(address, account);
+    await chain.sync();
 
     return chain;
   };