godprotocol 1.0.7991 → 1.1.0

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;
@@ -27,7 +28,52 @@ class Chain extends Explorer {
 
     this.generate_hash();
 
+    this.folder = this.account.manager.oracle.gds.folder(this.hash);
+    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) {
+    }
+
+    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 = () => {
@@ -50,8 +96,45 @@ class Chain extends Explorer {
     this.hash = hash(this.physical_address);
   };
 
+  build_block = (blk, forge) => {
+    if (typeof blk === "string") {
+      let blk_data = this.folder.readone(blk, { depth: 1 });
+
+      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) => {
-    return this.blocks[index];
+    index = index == null ? this.height -1 : index
+    let blk = this.blocks[index];
+
+    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) => {
@@ -60,36 +143,94 @@ 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.add_block(block);
+
+    vm.connect_block(block)
 
     this.txs = new Array();
 
-    block.timelapse = Date.now() - this.start_time;
+    this.manage_config();
 
     return block;
   };
 
+  persist = block=>{
+    let data = block.stringify();
+
+    data = this.account.manager.oracle.handle_compression({
+      addr: this.folder.folder_path,
+      data,
+      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);
+  }
+
   add_block = (block) => {
     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 = () => this.blocks.slice(-1)[0];
+  get_latest_block = () => {
+    let blk = this.recent_block;
+
+    return this.build_block(blk);
+  };
 
   stringify = (str) => {
     let obj = {};
@@ -99,11 +240,17 @@ class Chain extends Explorer {
     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.datapath = this.datapath
+    obj.connections = this.connections.map((b) =>
+      b.stringify
+        ? new Object({
+            chain: b.chain.hash,
+            block: { hash: b.hash, _id: b._id },
+          })
+        : b
     );
     obj.hash = this.hash;
-    obj.blocks = this.blocks.map((blk) => blk.hash);
+    // obj.blocks = this.blocks.map((blk) => blk.hash || blk);
 
     return str ? JSON.stringify(obj) : obj;
   };

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.

package/Objects/Filesystem.js

@@ -2,21 +2,24 @@ import { hash } from "../utils/hash";
 
 class Filesystem {
   constructor() {
+    this.root = process.env.ROOT || __dirname;
     this.base_address = process.env.BASE_ADDRESS || "Accounts";
   }
 
   parse_path = (path) => {
-    if (!path || (path && !path.includes("/"))) return path;
+    if (!path || (typeof path === 'string' && (!path.includes("/") || path.includes(' ')))) return path;
 
     return this.read(path);
   };
 
   read = (datapath) => {
     if (!datapath) return null;
-
+    
     let type_folder = this.account.manager.oracle.get(datapath);
 
-    if (!type_folder) return datapath;
+    if (!type_folder){
+      return datapath;
+    }
 
     let content;
     if (type_folder.type === "twain") {
@@ -36,35 +39,78 @@ class Filesystem {
     return content;
   };
 
-  save = (content, chain, just_obj) => {
-    let addr, obj;
+  object_type = (obj, chain)=>{
+    let type = typeof obj
+    if (type === 'object'){
+      if (Array.isArray(obj)) type = 'array'
+      else if (!obj) type = 'void'
+      else type = 'twain'
+    }
 
-    let type = this.get_type(chain);
+    if (!chain)return type;
 
-    if (type === "array" || type === "string") {
-      obj = [];
+    type = `${type[0].toUpperCase()}${type.slice(1)}`
+    
+    return this.get_datatype_chain(type)
+  }
 
-      for (let curs in content) {
-        obj.splice(Number(curs) || -1, 0, content[curs]);
-      }
-      if (type === "string") obj = obj.join(" ");
-    } else if (type === "twain") {
-      obj = {};
-      for (let curs in content) {
-        obj[curs] = content[curs];
-      }
-    } else if (type === "number") {
-      obj = Number(content["-1"]);
-      if (isNaN(obj)) obj = -1;
-    } else {
-      obj = null;
+  get_datatype_chain = (type)=>{
+    let chain = this.vm.handle_chain(`${this.account.physical_address}/Datatypes/${type}`)
+
+    return chain
+  }
+
+  save = (content, chain, options) => {
+    let just_obj, pure;
+    if (typeof options !== 'object'){
+      just_obj = options
+    }else if(options) {
+      just_obj = options.just_obj
+      pure = options.pure
+    }
+    let addr, obj;
+
+    if (!chain){
+      chain = this.object_type(content, true)
     }
 
+    let type = typeof chain === "string" ? chain : this.get_type(chain);
+
+
+    if(!pure){
+      if(typeof content==='string'){
+        if(type!=="string")obj= JSON.parse(content)
+        else obj = content
+      } else{
+        if (type === "array" || type === "string") {
+          obj = [];
+
+          for (let curs in content)
+            obj.splice(Number(curs) || -1, 0, content[curs]);
+
+          if (type === "string") obj = obj.join(" ");
+        } else if (type === "twain") {
+          obj = {};
+          for (let curs in content) {
+            obj[curs] = content[curs];
+          }
+        } else if (type === "number") {
+          obj = Number(content["-1"]);
+          if (isNaN(obj)) obj = 0;
+        }else if (type === 'boolean'){
+          obj = content['-1']
+          obj = obj === 'True' ? true:false
+        } else {
+          obj = null;
+        }
+      }
+    }else obj = content
+    
     if (just_obj) return obj;
 
     addr = `${chain.path}/${hash(JSON.stringify(obj))}`;
     this;
-    if (obj != null) this.manager.oracle.write(addr, obj);
+    if (obj != null || type === 'void') this.manager.oracle.write(addr, obj);
 
     this.manager.oracle.set(addr, { obj, type });
 
@@ -92,13 +138,41 @@ class Filesystem {
     }
   };
 
+  is_datatype=chain=>{
+
+    let type = this.get_type(chain);
+    return !!type
+  }
+
+  stringify_type = (type)=>{
+    let val;
+    switch(type){
+      case 'string':
+        val = ""
+      break;
+      case 'number':
+        val = "0"
+      break;
+      case 'array':
+        val = "[]"
+      break;
+      case 'twain':
+        val = "{}"
+      break;
+      case 'void':
+        val = 'null'
+        break
+      ;
+    }
+    return val
+  }
+
   write = (arg, context) => {
     let content = context.get_buffer();
 
     if (!content || !arg) return;
 
     content[context.cursor] = arg;
-    //  console.log(`Writing: ${arg}`);
   };
 
   name_hash = () => {
@@ -116,8 +190,8 @@ class Filesystem {
 
     let fs = this.manager.oracle.fs;
 
-    if (!fs.existsSync(chain.path)) {
-      fs.mkdirSync(chain.path, { recursive: true });
+    if (!fs.existsSync(`${this.manager.root}/${chain.path}`)) {
+      fs.mkdirSync(`${this.manager.root}/${chain.path}`, { recursive: true });
     }
   };
 

package/Objects/Frame.js

@@ -8,15 +8,14 @@ class Frame {
       ? array_to_nested_objects(object)
       : object;
 
-    this.children = new Array();
     this.instructions = new Array();
   }
 
   frame = (object) => {
     let frame = new Frame(object, this);
+    frame.account = this.account;
 
     this.instructions.push(frame);
-    this.children.push(frame);
 
     return frame;
   };
@@ -26,7 +25,14 @@ class Frame {
       let val = this.object[prop];
       this.instructions.push(`chain ${prop}`);
 
-      val && this.frame(val).to_instruction();
+      if(val && val.__type){
+        let instructions = this.account.assembler.run(JSON.stringify(val.value), {instructions: true, pure: true})
+
+        this.instructions.push(...instructions)
+
+        this.instructions.push(`cursor {output}`)
+        this.instructions.push(`write {datapath:-1}`)
+      }else val && this.frame(val).to_instruction();
 
       this.instructions.push(`pop ${prop}`);
     }
@@ -40,6 +46,7 @@ class Frame {
       if (ins instanceof Frame) inss.push(...ins.flatten_instructions());
       else inss.push(ins);
     }
+
     return inss;
   };
 }