godprotocol 1.0.842 → 1.1.0

package/Loader_sequence/repository.js

@@ -8,7 +8,7 @@ class Repository {
   }
 
   add_program = (config) => {
-    let codes = config.codes.filter((line) => !!line.trim());
+    let codes = config.codes.filter(line=>!!line.trim())
     let code_hash = this.oracle.hash(codes);
     let code_exist = this.codes.readone({ hash: code_hash });
 

package/Objects/Account.js

@@ -1,3 +1,4 @@
+
 import Loader_sequence from "../Loader_sequence/main";
 import validate_signature from "../utils/privacy";
 import { post_request } from "../utils/services";
@@ -17,6 +18,8 @@ class Account extends Filesystem {
     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();
@@ -33,7 +36,7 @@ class Account extends Filesystem {
 
     this.events = new Object();
 
-    console.log(`Account Instance: ${this.name}`);
+    this.log_output(`Account Instance: ${this.name}`);
   }
 
   on = (event, handler) => {
@@ -102,40 +105,87 @@ class Account extends Filesystem {
     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, payload) => {
     let buff = this.mine_buffer[pid];
     if (!buff) return;
 
-    buff.callback && this.run_callback(buff.callback, payload || 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]
   };
 
+  execute =( opcode, args)=>{
+    let circ = this.vm.opcodes[opcode]
+    if (typeof circ !== 'function') {return}
+
+    circ(args)
+  }
+
+  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 } = payload;
-    let { instructions, assemble } = program;
+    let { program, callback, location } = payload;
+    let { instructions, assemble, forge, spawn, unshift } = program;
 
     this.propagate(payload, "load");
-
-    if (assemble) {
-      this.assembler.spawn().run(instructions, { cb: callback });
+    
+    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(callback);
+      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 });
+    }
 
-      this.manager.push({ sequence: instructions, account: this, pid });
+    if(location && callback){
+      callback({estimated_time:'-ms', callback:location})
     }
   };
 
@@ -150,7 +200,7 @@ class Account extends Filesystem {
   };
 
   run = (request) => {
-    let { payload, callback } = request;
+    let { payload, callback, location} = request;
 
     let { physical_address, query, history } = payload;
 
@@ -158,7 +208,9 @@ class Account extends Filesystem {
 
     this.propagate(request, "run");
 
-    let pid = this.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)
@@ -166,50 +218,65 @@ class Account extends Filesystem {
 
     if (!context) {
       if (physical_address)
-        context = this.manager.web.split_set(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 -= 2;
-
-      if (blk && blk.metadata.program) {
-        if (history) {
-          history--;
-          blk = null;
-        }
-      }
-
-      while (!blk && index >= 0) {
-        index--;
-        blk = context.get_block(index);
+      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);
 
-      this.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: this,
+          payload,
+          error_stack: JSON.stringify(this.vm.error_manager),
           pid,
         });
-    } else this.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) => {
@@ -220,7 +287,7 @@ class Account extends Filesystem {
 
       callback.payload &&
         callback.payload.physical_address &&
-        this.vm.stdin(payload, () => this.run(callback));
+        this.vm.stdin(payload, callback);
     }, 0);
   };
 

package/Objects/Block.js

@@ -7,18 +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.blocks_folder = this.chain.account.manager.oracle.gds.folder(
-      process.env.BLOCKS_FOLDER || "blocks"
-    );
+    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));
   };
 
@@ -27,21 +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) => {
@@ -55,7 +60,7 @@ class Block {
     obj.previous_hash = this.previous_hash;
     obj.data = this.data;
     obj._id = this._id;
-    obj.children = this.children.map((ch) => ch._id);
+    obj.children = this.children.map((ch) => ch && ch._id);
     obj.chain = {
       hash: this.chain.hash,
       physical_address: this.chain.physical_address,
@@ -71,6 +76,7 @@ class Block {
     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 || [];

package/Objects/Blockweb.js

@@ -19,7 +19,7 @@ class Blockweb {
     let spli = physical_address.split("/");
 
     let chain = this.get(physical_address);
-    if (!chain) {
+    if (!chain && spli.length >1) {
       chain = this.set(spli.slice(0, -1).join("/"), spli.slice(-1)[0]);
     }
     return chain;

package/Objects/Chain.js

@@ -1,3 +1,4 @@
+import { _id } from "generalised-datastore/utils/functions";
 import { hash } from "../utils/hash";
 import Block from "./Block";
 import Explorer from "./Explorer";
@@ -9,6 +10,7 @@ class Chain extends Explorer {
     this.parent = parent;
     this.account = this.parent.account;
     this.name = name || this.parent.name;
+    
     this.physical_address =
       this.parent.manager || !name
         ? this.parent.physical_address
@@ -16,8 +18,7 @@ class Chain extends Explorer {
 
     this.pending_children = new Array();
     this.connections = new Array();
-
-    this.blocks = new Array();
+    
     this.txs = new Array();
 
     this.height = 0;
@@ -28,24 +29,53 @@ class Chain extends Explorer {
     this.generate_hash();
 
     this.folder = this.account.manager.oracle.gds.folder(this.hash);
-    this.height = this.folder.config.stats.total_files;
-    this.prev_hash = this.folder.config.stats.recent_file;
+    this.height = this.folder.config.stats.files;
+    this.blocks = new Array(this.height);
+
+    if (this.folder.config.stats.chain)
+    this.datapath = this.folder.config.stats.chain.datapath
+
+    // console.log(this.folder.config)
 
     this.account.set_paths(this);
 
     this.manage_config(true);
+
+    if (this.folder.config.stats.recent_file){
+      this.recent_block = this.build_block(this.folder.config.stats.recent_file);
+      this.blocks[this.recent_block.index] = this.recent_block
+    }
   }
 
   manage_config = (init) => {
     if (init) {
-      let dir = this.account.manager.oracle.fs.readdirSync(this.folder.path);
-      this.blocks = dir.filter((d) => d !== ".config");
-      this.height = this.blocks.length;
     }
 
-    this.folder.config.add_entry("object", this.stringify());
+    this.folder.config.add_entry("chain", this.stringify());
   };
 
+  set_fee = ({purpose, fee, validator})=>{
+    this.fees.set({purpose, fee, validator})
+  }
+
+  get_fee = purpose =>{
+    return this.fees.get(purpose)
+  }
+
+  pay = (purpose, payer, cb) =>{
+    let account = this.account.manager.get_account(payer)
+    let token = this.get_fee(purpose)
+
+    account.process_fee(token, cb)
+  }
+
+  set_obj_config = config=>{
+    let addr = typeof config === 'string'? config: this.account.save(config)
+    
+    this.datapath = addr;
+    this.manage_config()
+  }
+
   append_buffer = () => {
     this.buffs.push({});
     this.cursors.push(this.cursor);
@@ -66,18 +96,45 @@ class Chain extends Explorer {
     this.hash = hash(this.physical_address);
   };
 
-  build_block = (blk) => {
+  build_block = (blk, forge) => {
     if (typeof blk === "string") {
       let blk_data = this.folder.readone(blk, { depth: 1 });
 
-      blk = Block.build(blk_data, this);
+      if (blk_data){
+        blk = Block.build(blk_data, this);
+      }
+    }else if (forge){
+      if(!blk.hash) blk.hash = hash(JSON.stringify(blk))
+      blk = Block.build(blk, this)
+    }
+    return blk;
+  };
+
+  traverse_blocks = (stop) => {
+    let blk =  this.blocks.slice(stop).find(b=>b && b._id);
+    
+    while (blk&& blk.index !== stop) {
+      blk = this.build_block(blk.previous_hash);
+      
     }
     return blk;
   };
 
   get_block = (index) => {
+    index = index == null ? this.height -1 : index
     let blk = this.blocks[index];
-    return this.build_block(blk);
+
+    if(blk) blk = this.build_block(blk);
+
+    if (!blk||(blk&& blk.index !== index)) {
+      console.log("Twisted chain", index,blk&& blk.index, this.physical_address);
+      if (index < this.height) {
+        blk = this.traverse_blocks(index);
+      }
+    }
+    if(blk&& !isNaN(Number(blk.index)))this.blocks[blk.index] = blk
+
+    return blk;
   };
 
   add_tx = (instruction) => {
@@ -86,29 +143,55 @@ class Chain extends Explorer {
     this.txs.push(instruction);
   };
 
+  fabricate_datapath_block=()=>{
+    if(!this.datapath)return this.stderr({"name":"Chain_error",'message':'Cannot fabricate datapath block of no-call chain'})
+
+    return this.build_block({metadata:{output:this.datapath}, index:0, _id: _id(this.hash)}, true)
+  }
+
+  forge_block = (obj)=>{
+    obj.index = this.height
+    obj._id = _id(this.hash)
+    obj.previous_hash = this.recent_block && this.recent_block._id
+
+    let blk = this.build_block(obj, true)
+
+    this.add_block(blk)
+
+    return blk
+  }
+
   mine = (vm, no_curs) => {
+
+    if (this.physical_address === `${this.account.physical_address}/Datatypes/Void` && this.height){
+      let blk = this.get_latest_block()
+      vm.connect_block(blk)
+
+      return blk
+    }
+
     let block = new Block(this);
 
     block.generate_hash();
-    this.add_block(block);
-
     block.store(no_curs);
 
     block.children = this.pending_children;
     this.pending_children = new Array();
 
-    let prev_context = vm.get_context(-2);
-    if (prev_context) {
-      prev_context.pending_children.push(block);
-      prev_context.connections.push(block);
-    }
+    block.timelapse = Date.now() - this.start_time;
 
-    this.txs = new Array();
+    this.add_block(block);
 
-    block.timelapse = Date.now() - this.start_time;
+    vm.connect_block(block)
+
+    this.txs = new Array();
 
     this.manage_config();
 
+    return block;
+  };
+
+  persist = block=>{
     let data = block.stringify();
 
     data = this.account.manager.oracle.handle_compression({
@@ -117,22 +200,36 @@ class Chain extends Explorer {
       no_string: true,
     });
 
+    if(!data.previous_hash &&data.index!==0){
+      console.log(data)
+      return this.account.vm.stderr({name:"Chain_error", message:"chain corruption, as a non index 0 block is without a previous_hash"})
+    }
+
     this.folder.write(data);
-    return block;
-  };
+  }
 
   add_block = (block) => {
-    let recent_blk = this.get_latest_block();
-    block.previous_hash = recent_blk && recent_blk._id;
     this.blocks.push(block);
-    this.height = this.blocks.length;
+    this.height++;
+
+    if (!this.physical_address.startsWith(`${this.account.physical_address}/Opcodes`) &&  Array.from(Object.keys(block.metadata)).length){
+      this.persist(block)
+    }
+
+    this.recent_block = block;
+
+    if (this.account.initiated){
+      let parent_addr = this.parent.physical_address
+      if (this.account.vm.stack.has_stack(parent_addr)){
+        this.account.vm.stack.push(parent_addr, block);
+      }
+    }
   };
 
   get_latest_block = () => {
-    let blk = this.blocks.slice(-1)[0];
-    blk = this.build_block(blk);
+    let blk = this.recent_block;
 
-    return blk;
+    return this.build_block(blk);
   };
 
   stringify = (str) => {
@@ -143,6 +240,7 @@ class Chain extends Explorer {
     obj.parent = this.parent.path;
     obj.account = this.parent.account.name;
     obj.name = this.name;
+    obj.datapath = this.datapath
     obj.connections = this.connections.map((b) =>
       b.stringify
         ? new Object({
@@ -152,7 +250,7 @@ class Chain extends Explorer {
         : b
     );
     obj.hash = this.hash;
-    obj.blocks = this.blocks.map((blk) => blk.hash || blk);
+    // obj.blocks = this.blocks.map((blk) => blk.hash || blk);
 
     return str ? JSON.stringify(obj) : obj;
   };

package/Objects/Explorer.js

@@ -18,25 +18,11 @@ class Explorer {
 
     let obj;
     if (isNaN(q2)) {
-      let arr = this[prop || "connections"];
-      for (let b = 0; b < arr.length; b++) {
-        let blk = this.build_block(arr[b]);
-        if (blk.hash === query[1]) {
-          obj = blk;
-          break;
-        }
-      }
+      obj = this[prop || "connections"].find((c) => c.hash === query[1]);
     } else if (q2 >= 0) {
-      let arr = this[prop || "connections"];
-      for (let b = 0; b < arr.length; b++) {
-        let blk = this.build_block(arr[b]);
-        if (blk.index === q2) {
-          obj = blk;
-          break;
-        }
-      }
+      obj = this[prop || "connections"].find((q) => q.index === q2);
     } else {
-      obj = this.build_block(this[prop || "connections"].slice(q2)[0]);
+      obj = this[prop || "connections"].slice(q2)[0];
     }
 
     if (!prop)

package/Objects/Fee.js

@@ -0,0 +1,33 @@
+class Fee {
+  constructor(chain){
+    this.chain = chain;
+
+    this.fees = new Object()
+  }
+
+  set = ({purpose, fee, validator})=>{
+    let fees= this.fees[purpose]
+    if (!fees){
+      fees = new Array();
+      this.fees[purpose] = fees;
+    }
+    fees.push({fee, validator})
+  }
+
+  get = (purpose)=>{
+    let fees = this.fees[purpose]
+    if (!fees)return
+
+    return fees.slice(-1)[0]
+  }
+}
+
+// Fee is a physical_address
+// Validator is also a physical_address
+// If fee address is a callable/executable
+// validator runs itself using the result from the address using the payload as argument 0
+// Else if fee is a datastructure,
+// validator runs itself using data as argument.
+// Validator must return a true, to pass.
+
+// A chain can have multiple price purposes.