godprotocol 1.0.7991 → 1.1.0

package/Loader_sequence/repository.js

@@ -0,0 +1,33 @@
+class Repository {
+  constructor(main) {
+    this.main = main;
+    this.oracle = this.main.account.manager.oracle;
+    this.gds = this.oracle.gds;
+    this.programs = this.gds.folder("programs");
+    this.codes = this.gds.folder("codes");
+  }
+
+  add_program = (config) => {
+    let codes = config.codes.filter(line=>!!line.trim())
+    let code_hash = this.oracle.hash(codes);
+    let code_exist = this.codes.readone({ hash: code_hash });
+
+    let code = this.codes.write({
+      body: codes,
+      hash: code_hash,
+      _id: code_exist && code_exist._id,
+    });
+    config.codes = code._id;
+
+    let program_hash = this.oracle.hash(JSON.stringify(config));
+    let program_exist = this.programs.readone({ hash: program_hash });
+
+    this.programs.write({
+      ...config,
+      hash: program_hash,
+      _id: program_exist && program_exist._id,
+    });
+  };
+}
+
+export default Repository;

package/Objects/Account.js

@@ -1,5 +1,7 @@
+
 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 +15,10 @@ class Account extends Filesystem {
     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.");
 
@@ -20,109 +26,257 @@ 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();
+
+    this.events = new Object();
 
-    console.log(`Account Instance: ${this.name}`);
+    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) => {
+  manage_buffer = (callback, real_cb) => {
     let call_session = `${Date.now()}-${Math.random()}`;
-    this.mine_buffer[call_session] = { blocks: [], callback };
+    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;
 
-    buffer.blocks.push(block.stringify());
+    block && block.stringify &&  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);
+    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]
   };
 
-  load = ({ program, signature, callback }) => {
-    let { instructions, account } = program;
-    account = this.get_account(account);
+  execute =( opcode, args)=>{
+    let circ = this.vm.opcodes[opcode]
+    if (typeof circ !== 'function') {return}
 
-    if (!account.validate(payload, signature, callback)) return;
-
-    let pid = account.manage_buffer(callback);
+    circ(args)
+  }
 
-    this.manager.push({ sequence: instructions, account, pid });
+  process_fee = ({fee, validator}, cb)=>{
+    let content = this.vm.read_chain(fee, {tell_callable})
+
+    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}]}})
+    }
+  }
+  
+  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 = ({ payload, signature, callback }) => {
-    let { physical_address, account, query } = 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",
-      });
+  parse = (program) => {
+    let { payload, callback, signature } = program;
 
-    let data = query ? chain.explore(query) : chain;
+    this.propagate(program, "parse");
 
-    this.run_callback(callback, data && data.stringify());
+    this.manager.oracle.fetch({ ...payload, signature }, (result) =>
+      this.run_callback(callback, result)
+    );
   };
 
   run = (request) => {
-    let { payload, signature, callback } = request;
+    let { payload, callback, location} = request;
+
+    let { physical_address, query, history } = payload;
 
-    let { physical_address, account, query } = payload;
-    account = this.get_account(account);
+    history = Math.abs(Number(history)) || 0;
 
-    if (!account.validate(payload, signature, callback)) return;
+    this.propagate(request, "run");
 
-    let pid = account.manage_buffer(callback);
+    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)
-      : account.vm.get_context();
+      : this.vm.get_context();
 
-    if (!context) return account.flush_buffer(pid);
+    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);
+
+      while (!blk && index >= 0) {
+        index--;
+        blk = context.get_block(index);
+
+        blk = historic(blk);
+        // console.log(blk)
+      }
+    }
+
+    // console.log(blk)
+
     if (blk && blk.metadata && blk.metadata.program) {
       let program = this.read(blk.metadata.program);
 
-      account.vm.contexts.push(context);
-      program.push("pop");
+      if (Array.isArray(program) && program.length) {
+        this.vm.push_context(context);
+        program = [...program, 'pop']
+
+        // console.log(program)
 
-      Array.isArray(program) &&
-        program.length &&
         this.manager.push({
           sequence: program,
-          account,
+          account: this,
+          payload,
+          error_stack: JSON.stringify(this.vm.error_manager),
           pid,
         });
-    } else account.flush_buffer(pid);
+      }
+    } 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) => {
@@ -133,10 +287,26 @@ class Account extends Filesystem {
 
       callback.payload &&
         callback.payload.physical_address &&
-        this.vm.stdin(payload, () => this.run(callback));
+        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;
+      }
+    }
+    this.stdout = this.stdout.filter((out) => !!out);
+  };
+
   validate = (payload, signature, callback) => {
     if (!this.private) return true;
 
@@ -145,7 +315,7 @@ class Account extends Filesystem {
       JSON.stringify(payload),
       signature
     );
-    if (!valid)
+    if (!valid && callback)
       this.run_callback(callback, {
         private: this.private,
         error: true,
@@ -169,15 +339,11 @@ class Account extends Filesystem {
   };
 
   create_account = (payload) => {
+    this.propagate(payload, "create_account");
     let { name, meta } = payload;
 
     return this.manager.add_account(name, meta);
   };
-
-  endpoint = (endpoint, payload) => {
-    let method = this[endpoint];
-    typeof method === "function" && method(payload);
-  };
 }
 
 export default Account;

package/Objects/Block.js

@@ -1,4 +1,5 @@
 import { hash } from "../utils/hash";
+import { _id } from "generalised-datastore/utils/functions";
 
 class Block {
   constructor(chain) {
@@ -6,13 +7,12 @@ class Block {
     this.data = this.chain.txs;
     this.metadata = {};
     this.children = new Array();
-    this.index = this.chain.blocks.length;
+    this.index = this.chain.height;
+    this._id = _id(this.chain.hash);
+    this.previous_hash = this.chain.recent_block && this.chain.recent_block._id
   }
 
   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));
   };
 
@@ -21,19 +21,32 @@ class Block {
     if (!no_curs) this.cursor = this.chain.cursors.splice(-1)[0];
     if (!content) return;
 
-    let cursors = Object.keys(content).filter(
-      (c) => c.startsWith("{") && c.endsWith("}")
-    );
+    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];
+      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[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;
+    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
+    }
   };
 
   stringify = (str) => {
@@ -44,10 +57,10 @@ class Block {
     obj.timelapse = this.timelapse;
     obj.index = this.index;
     obj.hash = this.hash;
+    obj.previous_hash = this.previous_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 && ch._id);
     obj.chain = {
       hash: this.chain.hash,
       physical_address: this.chain.physical_address,
@@ -55,6 +68,23 @@ 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.previous_hash = data.previous_hash;
+    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 && spli.length >1) {
+      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;