godprotocol 1.1.0 → 1.1.2

package/utils/vm_utils.js

@@ -1,292 +1,70 @@
-import { generate_random_string } from "generalised-datastore/utils/functions";
-import Executables from "../Executables/executables";
+import Arr from "../Datatypes/arr";
+import Callable from "../Datatypes/callable";
+import Num from "../Datatypes/num";
+import Str from "../Datatypes/str";
+import Twa from "../Datatypes/twa";
+import Voi from "../Datatypes/voi";
 
-class Vm_utils extends Executables{
-  constructor(){
-    super()
+class Vm_utils {
+  constructor() {}
 
-    setTimeout(() => {
-      this.  air_object_paths = new Array(
-      `${this.account.physical_address}/language/natives/datatypes/string/String`,
-      `${this.account.physical_address}/language/natives/datatypes/number/Number`,
-      `${this.account.physical_address}/language/natives/datatypes/twain/Twain`,
-      `${this.account.physical_address}/language/natives/datatypes/array/Array`,
-      `${this.account.physical_address}/language/natives/datatypes/boolean/Boolean`,
-      `${this.account.physical_address}/language/natives/datatypes/void/Void`,
-      `${this.account.physical_address}/language/natives/server/chain/Chain`,
-      `${this.account.physical_address}/language/natives/server/block/Block`,
-      `${this.account.physical_address}/language/natives/server/chain/Chain`,
-    )
-    }, 0);
+  handle_chain = async (address) => {
+    let chain = await this.account.manager.web.spli_get(address);
 
-    this.error_instance_address = "Accounts/initiator/language/natives/errors"
-  
-   this.air_types = new Array('boolean', 'string', 'twain', 'array', 'number', 'void')
-  }
-
-  set_config = (config)=>{
-    config = config.op0;
-    let chain = this.handle_chain(config.__address__);
-    chain.set_obj_config(config)
-  }
-
-  get_context = (index) => {
-    return this.contexts.slice(index == null ? -1 : index)[0];
+    return chain;
   };
 
-  parse_arg = (arg, opcode) => {
-    let context = this.get_context();
-
-    let args = arg.split("/"),
-      i = 0;
-
-    while (args[0] === "..") {
-      i++;
-
-      args.splice(0, 1);
-    }
-
-    i = (i + 1) * -1;
-    context = i ? this.get_context(i) : context;
-
-    arg = args.join("/");
+  get_type = (object) => {
+    let type = typeof object;
 
-    while (arg.includes("^")) {
-      let blk = context.connections.slice(-1)[0];
-      if (!blk) break;
-      context = blk.chain;
-      let i = arg.indexOf("^");
-      arg = `${arg.slice(0, i)}${arg.slice(i + 1)}`;
+    if (type == "object") {
+      if (Array.isArray(object)) type = "array";
+      else if (!type) type = "void";
+      else type = "twain";
     }
-
-    let is_cursor = opcode === 'cursor'
-    if (arg.startsWith("{*") && is_cursor) {
-      arg = context.explore(arg.slice(2, -1));
-    } else if (arg.startsWith("{") && !is_cursor) {
-      arg = context.explore(arg.slice(1, -1));
-      if (['chain', 'link'].includes(opcode) && arg.includes('/')){
-        arg = this.account.read(arg)
-      }
-    }
-
-    return arg;
+    return type;
   };
 
-  split_instruction = (instruction) => {
-    let split = instruction.split(" ");
-    let opcode = split[0],
-      args = split.slice(1).join(" ");
-
-    return { opcode, args };
-  };
-
-  handle_chain = (args, context)=>{
-    if (!args) return
-    if(!context) context = this.account.chain
-
-    let web = context.account.manager.web, chain;
-    
-    if (args.includes('/')){
-      chain = web.get(args)||web.split_set(args);
-    } else chain = context.account.add_chain(args, context);
-
-    return chain
-  }
-
-  read_chain = (addr, options)=>{
-    options = options || {}
-    let {no_callable, tell_callable, index} = options, callable;
-
-    if(!addr) return this.stderr(`Physical address cannot be undefined`)
-    let chn = addr.physical_address? addr: this.handle_chain(addr)
-
-    if (!chn)return this.stderr(`Address chain:${addr.physical_address ||addr} not found`)
-
-    let output;
-    if (chn.datapath && !no_callable){
-      output = chn.datapath
-      callable = true;
-    }else {
-      callable = false
-      if (!chn.height) return no_callable?null: this.stderr(`Chain has no height - ${addr.physical_address || addr}`)
-
-      let recent = chn.get_block(index)
-    
-      output = recent.metadata.output;
-      
-      if (!output)return;
-    }
-    output = this.account.read(output)
-
-    return  tell_callable? {output, callable} :output;
-  }
-
-  connect_block = block=>{
-    if(!block){
-      console.log(`Checkengine`)
-      return;
+  parse_content = async (object, options) => {
+    let { type } = options || {};
+    if (!type) type = this.get_type(object);
+
+    let instance;
+    switch (type) {
+      case "number":
+        instance = new Num(object);
+        break;
+      case "string":
+        instance = new Str(object);
+        break;
+      case "array":
+        instance = new Arr(object);
+        break;
+      case "twain":
+        instance = new Twa(object);
+        break;
+      case "function":
+        instance = new Callable(object);
+        break;
+      case "class":
+        instance = new Callable(object);
+        break;
+      default:
+        instance = new Voi();
     }
-    let prev_context = this.get_context(-2);
-    if (prev_context) {
-      if(block.chain.datapath){
-        block.metadata.output = block.datapath
-      }
-      prev_context.pending_children.push(block);
-      prev_context.connections.push(block);
-    }
-  }
 
-  get_type_address =type=>{
-    return this.air_object_paths.find(p=>p.includes(type))
-  }
+    return instance;
+  };
 
-  parse_composite_content = (content, options)=>{
-    let {item_type, location} = options;
+  read_chain = async (address) => {
+    let chain = await this.handle_chain(address);
 
-    if (item_type === 'static_object'){
-      for (let c = 0; c< content.length; c++){
-        let cont = content[c]
-        let cont_addr = `${location}_${c}`
-        this.write_chain(cont, cont_addr)
-        content[c] = cont_addr;
-      }
-    }
+    let content = await chain.read();
+    content =
+      (content && (await content.parse())) || (await this.parse_content(null));
 
     return content;
-  }
-
-  air_object = (content, options)=>{
-    let {location, callback, local_address, metadata} = options;
-
-    if (Array.isArray(content)){
-      content=  this.parse_composite_content(content, options)
-    }
-
-    let static_location = `${local_address || location}_${generate_random_string(8, 'alnum')}`
-
-    let statc = this.static_cast(content, static_location)
-    let type = typeof statc === 'string' ? 'void' : statc.type
-
-    this.stdin(statc,()=>  this.exec({
-      executable: this.get_type_address(type), 
-      location,
-      metadata:{callback, ...metadata},
-      arguments: {
-        argc:1,
-        argv:[{position: 0, address: static_location, name:'value'}]
-      }}),
-      {address: static_location}
-    )
-  }
-  
-  id_hash = (data)=>{
-    let res = this.account.manager.oracle.hash(data, 'sha-1')
-    if (!isNaN(Number(res[0]))){
-      res = `_${res}`
-    }
-
-    return res;
-  }
-
-  get_voided_block = ()=>{
-    if(!this.account.initiated)return
-
-    let Void = this.account.get_datatype_chain(`Void`)
-    this.flags.void = true;
-    return Void && Void.get_latest_block()
-  }
-
-  modify_twain = (twa, chain, config)=>{
-
-    if (twa.__index__){
-      if (typeof twa.__index__ === 'number') twa.__index__ = chain.height
-      else twa.__index__[config.name] = chain.height
-    }
-    return twa
-  }
-
-  slice_trace = (s)=>{
-    let s_length = this.stacktrace.length;
-      for(let i=0; i < s_length - s; i++ ) this.pop_context()
-  }
-
-  push_context = context => {
-    this.contexts.push(context)
-    this.stacktrace.push(context.physical_address)
-    // console.log(`>> Current Stack - ${context.physical_address}`)
-  }
-
-  pop_context = () => {
-    let context = this.contexts.pop()
-    let addr = this.stacktrace.pop()
-
-    // console.log(`> Current Stack - ${this.contexts.slice(-1)[0].physical_address}`)
-
-    if(context && context.physical_address !== addr)
-      this.stderr(`Stack missalignment - ${context.physical_address} : ${addr}`)
-  }
-
-
-  run_opcode = (arg_arr, opcode)=>{
-    let circ = this.opcodes[opcode]
-
-    if (!circ)return this.stderr(`Opcode:${opcode} not set`)
-
-    let arg = {}
-    arg_arr.map((a,i)=>{
-      arg[`op${i.toString()}`] = a
-    })
-
-    return circ(arg, this)
-  }
-
-  static_cast = (content, addr)=>{
-    let res_obj = {}
-    let type = typeof content;
-    if(type === 'object' || type === 'undefined'){
-      if(content == null){
-        res_obj = "{'type':'void','static_value':Void,'__address__':'Accounts/initiator/Datatypes/Void'}"
-      }else if (Array.isArray(content)){
-        res_obj = {type:'array', static_value: content}
-      }else res_obj = {type:'twain', static_value: content}
-    }else {
-      res_obj = {type, static_value: content}
-    }
-
-    if (addr && typeof res_obj !== 'string') {
-      res_obj.__address__ = addr
-    }
-    
-    return res_obj
-  }
-
-  is_readonly = (args)=>{
-    if (args.op1.startsWith('__') && args.op1.endsWith('__') && args.op1 !== '__'){
-      let val = args.op0[args.op1]
-      let chn = this.handle_chain(`${val}/.config`)
-      let recent = chn.get_latest_block()
-      let value;
-      if(recent){
-        value = recent.metadata.output;
-        value = this.account.read(value)
-        if (value && !['function', 'class'].includes(value.type)){
-          return this.stderr('Cannot delete `readonly` property')
-        }
-      }
-    }
-  }
-  
-  static_value = (value, blow)=>{
-    if (value && value.__print__){
-      if(this.air_object_paths.includes(value.__classifier__)){
-        value = this.read_chain(value.value)
-      }else if (blow){
-        return
-      }
-    }
-    
-    return value
-  }
+  };
 }
 
-export default Vm_utils
+export default Vm_utils;

package/Executables/callables.js

@@ -1,131 +0,0 @@
-class Callables{
-  constructor(){
-    this.callables = new Object()
-  }
-
-  prepare_callable_args = (config, payload)=>{
-
-    let {arguments:args} = payload;
-    let {argv} = args;
-
-    let arg_obj = {}, spreading;
-
-    for (let a=0;a< argv.length;a++){
-      let arg = argv[a]
-
-      let param, content = arg.static_value || this.read_chain(arg.address)
-      if(spreading){
-        arg_obj[spreading].push(content)
-      } else {
-        if (arg.name){
-          arg_obj[arg.name] = content;
-          param = config.parameters.find(p=>p.name === arg.name)
-        }else {
-          param = config.parameters[arg.position]
-          if(!param)continue
-          arg_obj[param.name] = content
-        }
-
-        if (param.spread){
-          spreading = param.name;
-          arg_obj[spreading] = [arg_obj[spreading]]
-        }
-      }
-    }
-
-    return arg_obj
-  }
-
-  callable = (payload)=>{
-    let {executable, metadata, location} = payload;
-    if (!metadata)metadata = {}
-
-    let call = this.callables[executable];
-    if(!call)return this.stderr(`Callable:${executable} is not set`)
-
-    let callable = call.callable;
-    let config = call.config
-
-    if (typeof callable !== 'function') return this.stderr(`Callable:${executable} must be a callable type.`)
-
-
-    let args;
-    if (config) {
-      args = this.prepare_callable_args(config, payload)
-    }
-
-    let result = callable(args, this, {...payload, location})
-    if (!metadata.raw )
-    result && this.write_chain(result.result,result.address|| location, {is_callable: result.is_callable})
-
-    return metadata.raw ? result : {
-      estimated_time: '-ms',
-      callback: location
-    }
-  }
-
-  write_chain = (result, location, options)=>{
-    if (result==null)return
-    let {is_callable}=options || {};
-
-    let loc_chain = this.handle_chain(location)
-  
-    if(is_callable){
-      loc_chain.set_obj_config(result)
-    }else {
-      loc_chain.forge_block({metadata: {output: this.account.save(result)}})
-    }
-  }
-
-  add_callable = (name, callable_config)=>{
-    this.callables[name] = callable_config
-  }
-
-  composite_depth = 3
-
-  display = (values, options )=>{
-    let {buff, depth, include_address} = options || {}, value;
-    if (!buff) buff =  new Object()
-   
-    if (!values)return values
-    
-    if (values.__print__ ){
-       let stat = this.static_value(values, true)
-      if(!stat)return values;
-      value = stat
-    }else value = values
-
-    let hash = this.account.manager.oracle.hash(value);
-    if (buff[hash]) return buff[hash]
-
-    if(value.type === 'array'){
-      let arr = []
-      for (let a=0; a< value.static_value.length; a++){
-        arr.push(this.display(this.read_chain(value.static_value[a]), {buff}))
-      }
-      value = arr;
-    }else if (value.type === 'twain'){
-      let keys = Object.keys(value.static_value)
-      let obj = {}
-      for (let s=0; s< keys.length; s++){
-        let key = keys[s]
-        let pair = value.static_value[key]
-        
-        let prop = this.display(this.read_chain(pair[0]), {buff})
-
-        obj[prop] = this.display(this.read_chain(pair[1]), {buff})
-      }
-      value = obj
-    }else if (['string', 'number', 'boolean'].includes(value.type)){
-      value = value.static_value
-    }else value = (value && value.__address__) || value
-
-    buff[hash] = value;
-    
-    if (depth == null){
-      return value;
-    }
-  }
-}
-
-export default Callables

package/Executables/executables.js

@@ -1,230 +0,0 @@
-import { generate_random_string } from "generalised-datastore/utils/functions";
-import Callables from "./callables";
-import Stack from "./stack";
-import { post_request } from "godprotocol/utils/services";
-
-
-class Executables extends Callables{
-  constructor(){
-    super()
-
-    this.stack = new Stack(this)
-  }
-
-  exec = (request)=>{
-    let payload = request.op0 || request;
-
-    let {executable, url_callback, location} = payload;
-    console.log(request)
-    
-    if (!executable && request.op1) executable = request.op1.static_value
-
-    if(typeof executable !== 'string' && executable){
-      executable = executable.static_value || executable.__address__
-    }
-    if(!executable)return this.stderr({name: 'Call_error', message:"Executable cannot be undefined"})
-
-    if (!executable.includes('/')){
-      let result = this.callable(payload)
-      if (url_callback) post_request({options:url_callback, data: result})
-      return result
-    }
-
-    if(executable.includes('undefined')){
-      console.log(executable)
-      let err_obj = {name:'Type_error', message: `executable cannot have an undefined config`}
-      return this.stderr(err_obj)
-    }
-
-    // console.log(payload)
-    let config = this.get_config(executable)
-    if (!config){
-      return this.stderr({name:'Name_error', message:'Callable config not existing'})
-    }
-
-    switch(config.type){
-      case "class":
-        this.execute_class(config, payload)
-        break;  
-      case "function":
-        this.execute_function(config, payload)
-        break;
-      case "module":
-        this.execute_module(config, payload)
-        break;
-      default:
-        this.stderr(`Unknown call type`)  
-      ;
-    }
-
-    return {
-      estimated_time: `-ms`,
-      callback: location,
-    }
-  }
-
-  execute_class = (config, payload)=>{
-    let {methods, base_classes} = config;
-    let {location, local_address, url_callback, executable} = payload;
-
-    let object = {__classifier__:executable, __type__: `${this.account.physical_address}/CONSTANTS/types/instance`}
-    let object_id = generate_random_string(12, 'alnum')
-    object.__id__ = object_id
-
-    let real_path = `${local_address || location}_${object_id}`
-    let object_chain = this.handle_chain(real_path)
-
-    let location_height = object_chain.height;
-
-    for (let b=0; b< base_classes.length; b++){
-      let cls = base_classes[b]
-      let cls_config = this.get_config(cls);
-
-      if(!cls_config || (cls_config && cls_config.type !== 'class')){
-        return this.stderr(`Base must be a 'class' type`)
-      }
-
-      let {methods: b_methods} = cls_config;
-      for(let name in b_methods){
-        let method_addr = b_methods[name]
-
-       this.handle_method_config({name, method_addr, object, location: real_path, location_height}) 
-      }
-    }
-    for(let name in methods){
-      let method_addr = methods[name]
-
-      this.handle_method_config({name, method_addr, object, location: real_path, location_height})
-    }
-    
-    object.__address__ = real_path;
-
-    object_chain.forge_block({metadata:{output: this.account.save(object)}})
-
-    if (object.__init__){
-      this.execute_function(this.get_config(object.__init__), {...payload, executable: object.__init__})
-    }else {
-      if (url_callback) post_request({options:url_callback, data: object})
-    }
-  }
-
-  execute_function = (config, payload)=>{
-    let {arguments: args, location, url_callback, executable, metadata}=payload;
-    let {argv, argc} = args ||{};
-    argv = argv || []
-    let {parameters, object, __address__, method_address} = config;
-
-    let exec_address = method_address || __address__
-
-    this.stack.initiate(exec_address)
-
-    let arg_object = {}
-    parameters.map((p, i)=>{
-      arg_object[p.name] = {address: p.address, name: p.name, position: p.position || i}
-    })
-
-    for (let a =0; a< (argc || argv.length); a++){
-      let arg = argv[a]
-      let param;
-      if (arg.name) {
-        param = parameters.find(p=>p.name === arg.name)
-      } else {
-        param = parameters[arg.position]
-        arg.name = param.name
-      }
-
-      arg_object[arg.name].address = arg.address
-    }
-
-    if(object){
-      arg_object.this = {
-        position:-1, 
-        address: object,
-        name:'this'
-      }
-    }
-
-    for (let a in arg_object) {
-      let arg = arg_object[a]
-      let param_addr = `${exec_address}/${a}`
-      let param_chain = this.handle_chain(param_addr);
-
-      let arg_chain = this.handle_chain(arg.address)
-
-      if(arg_chain.datapath){
-        param_chain.set_obj_config(arg_chain.datapath)
-      }else {
-        let val = this.read_chain(arg_chain)
-        param_chain.forge_block({metadata: {output: this.account.save(val)}})
-      }
-    }
-
-    this.account.run({payload: {physical_address: method_address || __address__}, callback: ({ret})=>{
-      this.stack.pop(exec_address)
-      this.pop_context()
-
-      let res;
-      
-      if (typeof location === 'function'){
-        res = this.read_chain(ret)
-        if(metadata && metadata.loop){
-          
-          if (!metadata.loop.conditioner(res, metadata) && (metadata.loop.index+1) < metadata.loop.array.length){
-            metadata.loop.index ++
-
-            this.exec({executable, location, metadata, arguments: {argv: [{
-              address: metadata.loop.array[metadata.loop.index],
-              position: 0
-            }], argc: 1}})
-
-            return metadata.callback && metadata.callback(res)
-          }
-        }
-        location(res, metadata)
-        
-      }else if(ret){
-        let chain = this.handle_chain(ret)
-        let loc_chain = this.handle_chain(location)
-
-        if(chain.datapath){
-          res = chain.datapath;
-          loc_chain.set_obj_config(res)
-        }else {
-          res = this.read_chain(chain)
-          if (url_callback) post_request({options:url_callback, data: res})
-
-          loc_chain.forge_block({metadata: {output: this.account.save(res)}})
-          loc_chain.set_obj_config('')
-        }
-      }
-
-      if(metadata && metadata.callback){
-        metadata.callback(res)
-      }
-    }})
-  }
-
-  handle_method_config = ({name, method_addr, location, object})=>{
-    let conf = this.get_config(method_addr);
-    
-    let obj_method_addr = `${location}/${name}`
-    let chain = this.handle_chain(obj_method_addr)
-
-    conf.method_address = conf.__address__
-    conf.__address__ = obj_method_addr
-    conf.object = location;
-    chain.set_obj_config(conf)
-
-    object[name] = obj_method_addr;
-  }
-
-  get_config = exe =>{
-    let chn = this.handle_chain(exe);
-
-    if (!chn || (chn&& !chn.datapath))return this.stderr(`Executable:${exe} is not callable`)
-
-    return this.account.read(chn.datapath)
-  }
-}
-
-export default Executables